docs(changelog): update for v2.0.0

Interactive/streaming sessions are persistent claude.exe processes that
wait on stdin and never exit on their own. The only teardown was an
explicit StopInteractiveSession from the UI — there is no client-disconnect
or shutdown sweep — so an abandoned chat (UI closed, navigated away,
crashed) kept its claude.exe (+ conhost) alive for the worker's whole
lifetime. Under a long-running autostart worker these accumulate to dozens
of orphaned child processes.

LiveSessionRegistry now tracks per-session activity (Touch on every output
line and user action) and exposes ReapIdleAsync, which stops sessions idle
past a timeout while skipping any with a turn in flight. IdleSessionReaper
(BackgroundService) sweeps every 5 min; idle timeout defaults to 30 min,
configurable via interactive_idle_timeout_minutes (0 disables).

.gitea/workflows/release.yml

@@ -145,18 +145,19 @@ jobs:
           ZIP_NAME="ClaudeDo-${VERSION}-win-x64.zip"
           ( cd bundle && zip -r -q "../assets/${ZIP_NAME}" app worker )
 
-          # 2) Installer single-file exe (renamed)
+          # 2) Installer single-file exe — STABLE name (no version) so the download URL
+          #    (…/releases/latest/download/ClaudeDo.Installer.exe) stays permanent.
           INSTALLER_EXE=$(ls out/installer/*.exe | head -n 1)
           if [ -z "$INSTALLER_EXE" ]; then
             echo "::error::No .exe produced by installer publish" >&2
             exit 1
           fi
-          cp "$INSTALLER_EXE" "assets/ClaudeDo.Installer-${VERSION}.exe"
+          cp "$INSTALLER_EXE" "assets/ClaudeDo.Installer.exe"
 
           # 3) Checksums (sha256, relative filenames)
           ( cd assets && sha256sum \
               "ClaudeDo-${VERSION}-win-x64.zip" \
-              "ClaudeDo.Installer-${VERSION}.exe" \
+              "ClaudeDo.Installer.exe" \
               > checksums.txt )
 
           echo "--- assets ---"
@@ -200,7 +201,7 @@ jobs:
           cd "$WORK/src/assets"
           for f in \
             "ClaudeDo-${VERSION}-win-x64.zip" \
-            "ClaudeDo.Installer-${VERSION}.exe" \
+            "ClaudeDo.Installer.exe" \
             "checksums.txt"
           do
             echo "Uploading: $f"

.gitignore

@@ -1,5 +1,6 @@
 # Local dev worktrees (created by using-git-worktrees skill)
 .worktrees/
+.claude/worktrees/
 
 # Brainstorming visual companion artifacts
 .superpowers/

CHANGELOG.md

@@ -1,5 +1,138 @@
 # Changelog
 
+## v2.0.0 — 2026-06-26
+
+### Features
+
+- remove a queued interactive message with a ✕ (afe7218)
+- remove a queued interactive message (fd1e38f)
+- show queued interactive messages above the composer (7c9ff18)
+- broadcast interactive message queue + delivery (84034e8)
+- highlight user chat messages + opt-in interrupt (stop) button (786eb28)
+- queue interactive messages by default, interrupt opt-in (bdda98e)
+- interactive chat composer in the session terminal + work console (1fe72a1)
+- interactive chat composer state on the session monitor VM (140b8e1)
+- worker client surface for in-app interactive sessions (9effdde)
+- in-app interactive session service, replacing the wt terminal launch (30e87e6)
+- persistent streaming Claude session + live session registry (d8a043f)
+- answer a running task's question inline in Mission Control (917301d)
+- AskUser MCP tool so a running task can ask the user mid-run (c7f8280)
+- replace OLE task-row drag with custom ghost drag (bec26b2)
+- ghost-window drag infrastructure for task rows (05aec8e)
+- drag a task into Mission Control to queue it (3b629c2)
+- read-only queue side strip in Mission Control (9eb54a0)
+- batch MCP tools for the external endpoint (1c94fbd)
+- open Settings from the Mission Control header (7f4dc8b)
+- drag-reorder Mission Control panes by their header (f6ecfc9)
+- mission control pane header actions + status tinting (e2fad88)
+- mission control detach/redock toggle, clear review panes, reorder helper (fbcffce)
+- detach a monitor into its own window (5f6e748)
+- open Mission Control from the title bar (b1bd912)
+- add MissionControl window + grid (283310a)
+- add MonitorPaneView (15a3e65)
+- reveal a task by id from anywhere (5a21d67)
+- add MissionControlViewModel (42da840)
+- extract TaskMonitorViewModel streaming core; DetailsIsland delegates (aa7a49f)
+- collapse parent task rows by default with granular row sync (38defee)
+- shell-style review prompt line in WorkConsole (0a119f1)
+- Log Visualizer overlay reachable from a clickable footer log line (c4f74a7)
+- route Serilog Warn/Error to footer + buffer recent logs for overlay (08a4f97)
+- segmented Description/Steps/Files header (9301bbc)
+- drag-and-drop file attachments on the detail pane (d8ff8cc)
+- MCP tools to attach/list/remove task files (f7e946e)
+- inject reference files into the run + clean up files on delete (6a0c0f5)
+- data layer for task file attachments (3f9f047)
+
+### Fixes
+
+- reap idle interactive sessions so they don't pile up (711374e)
+- kill spawned claude trees when the worker dies (faf6104)
+- scroll revealed task into view + stronger selection highlight (f63be28)
+- persist Online Inbox tab on settings save (66907d2)
+- paint accent buttons with moss tokens instead of Fluent blue (178fd25)
+- make worktree state chips readable with on-theme tints (df84fc3)
+- keep interactive & planning prompts intact past Windows Terminal (ea16da2)
+- honor runtime disable in sync loop to stop OIDC discovery (f86b785)
+- surface interactive/planning launch errors in footer (134b9fb)
+- render X remove icon as filled geometry (637886f)
+- hide batch Merge All in the global overview (5231ad6)
+
+### Refactoring
+
+- split LogLineViewModel into its own file (7b6a8f0)
+- single DiffViewer replaces DiffModal + WorktreeModal + PlanningDiff (167d2fe)
+- single AgentConfigEditor for list + task scopes (eb0ddb5)
+- drop self-update, publish stable-named ClaudeDo.Installer.exe (3cb4802)
+- single IMergeCoordinator replaces the 5 conflict seams (5be4b5c)
+- single IDialogService replaces scattered Show* dialog seams (d598a53)
+- route UI quick-add through TaskRepository.AddAsync (1fb2e34)
+- drop dead hunks conflict API (b3e099c)
+
+### Documentation
+
+- queued messages can be removed via ✕ (3eea2b7)
+- queued messages show in a pending strip above the composer (e7fa373)
+- interactive send=queue, interrupt opt-in via stop button (8e1732a)
+- manual-verification items for in-app interactive sessions (9c292e5)
+- spec + plan for in-app interactive sessions (10342bc)
+- spec + plan for answering Claude's mid-run questions in Mission Control (946d26c)
+- add Mission Control multi-task monitoring spec + plan (d80a578)
+- document footer log routing + Log Visualizer overlay (4022bd7)
+- spec + plan for worker-log footer routing and log visualizer overlay (60eb671)
+- document task file attachments across project docs (8716dd8)
+- spec + phased plan for one-component-per-feature (0993eb0)
+- update for v1.9.0 (bae8921)
+
+## v1.9.0 — 2026-06-19
+
+### Features
+
+- diff Merge opens the 3-pane editor + conflict overview ruler (29a294b)
+- toggle add/remove per side, MAIN/INCOMING labels, files readout (ca4377e)
+- additive conflict accept — stack ours/theirs in click order (d5eec75)
+- add accept-both control to the 3-pane conflict gutter (18479c0)
+- Rider-style 3-pane conflict editor view (c4d1acc)
+- unify planning conflicts onto the resolver + 3-pane VM foundation (378a92c)
+- move review feedback to the Output tab + review/worktree polish (3e4e4a0)
+- in-app 3-way merge editor (chunk 2b) (92767c6)
+- real conflict-hunk parsing pipeline (chunk 2 backend) (e779e13)
+- My Day actions, orphan-aware grouping, menu restructure (4847c5c)
+- unify review actions into the Git-tab cockpit (43fb506)
+- carry ownerId on sync to prepare for multi-user (cee051b)
+- gate access on Zitadel "user" project role (23c3065)
+- Online Inbox settings tab + auth-code/PKCE login (80a2de6)
+- Online Inbox config + auth hub plumbing (Phase 2) (17c7ff5)
+- real ZitadelAuthProvider (refresh-token grant, auth-code+PKCE) (619bc0c)
+- Online Inbox sync engine (Phase 1) (1ac9ced)
+- let Claude set the cheapest model per generated task via MCP (c27a179)
+
+### Fixes
+
+- unresolved conflicts compose to empty, not Ours (+ review nits) (23a93ce)
+- harden 3-pane editor + document the new conflict resolver (869dd25)
+- invalidate cached access token when the signed-in user changes (cfe23cd)
+- preserve API base path in Online Inbox client (8b347de)
+- queue dispatches skip the StartRunning re-claim (74ca2e0)
+- document and test Queued→Failed guard in FailAsync (fe73f45)
+- stateless AbortPlanningMerge after worker restart mid-merge (fb1d799)
+- route FinalizeParentDoneAsync through TaskStateService (e9e4ad8)
+
+### Refactoring
+
+- bring IWorkerClient to parity with WorkerClient (b5417f6)
+
+### Documentation
+
+- spec + plan for Rider-style 3-pane merge editor (983c177)
+- KunsZitadel is server-side only; desktop uses an OIDC client flow (96da9fb)
+- API contract, desktop design spec, and implementation plan (8cbe1ad)
+- close out the review round in open.md, sync CLAUDE.md with merges (23ff391)
+- record correctness-review findings (4 confirmed as tasks) (ddeded9)
+- record review findings as refactoring backlog (1448794)
+- spec + plan for per-task model override via MCP (51ef488)
+- refresh CLAUDE.md files and open.md to current code state (4904631)
+- update for v1.8.0 (f8f20bf)
+
 ## v1.8.0 — 2026-06-09
 
 ### Features

docs/open.md

@@ -17,6 +17,14 @@ Kein Code-Aufwand, nur Durchspielen mit explizit notiertem Pass-Kriterium. Der G
 - **UI-Sichtprüfung (neu, 2026-06-10, nach Refactoring-Merges):** Detail-Insel komplett durchklicken (Output/Git/Session-Tabs, Merge-Sektion, Agent-Settings-Overrides, Prep-Panel) — `DetailsIslandViewModel` wurde in Sektions-VMs aufgeteilt, Bindings angepasst. Außerdem: DiffModal-Fehler-State „Diff nicht mehr verfügbar" (Commit-Range ohne aufgezeichnete Commits) und der In-App-Konflikt-Resolver (Hub-Methoden umbenannt).
 - **UI-Sichtprüfung (neu, 2026-06-19, Rider-Style 3-Pane Merge-Editor):** Echten Konflikt auslösen (Single-Task-Approve mit Konflikt **und** Planning-Unit-Merge) und prüfen: drei Panes (Ours read-only | Result editierbar | Theirs read-only), Konfliktblöcke rot / aufgelöst grün in allen Panes, Inline-Accept `›`/`‹` in den Zwischen-Guttern landen die jeweilige Seite im Result, nur Konfliktregionen im Result editierbar (Stable read-only), synchrones vertikales Scrollen, File-Switcher bei mehreren Dateien, `M conflicts · K resolved`-Readout, Continue erst bei allen Konflikten gelöst, Binär-Guard. **Bekannte Kanten:** (1) Konflikt mit leerer Ours-Seite → Result-Region ist null-lang (Gutter via 1-Zeichen-Probe positioniert, Accept funktioniert; nur Hand-Tippen in die leere Region ist fummelig). (2) Gutter-Y nutzt `TranslatePoint` vom Result-`TextView` — bei sehr hohen Fenstern / großen Scrollständen die Ausrichtung gegenprüfen. (3) Blöcke richten sich nur über Stable-Text aus; nach einem Konflikt mit unterschiedlicher Zeilenzahl je Seite driften nachfolgende Blöcke vertikal (aligned/virtual-space Scroll ist bewusst zurückgestellt).
 - **Worker-Autostart am Gerät:** Logoff/Logon-Autostart, Update-Pfad, Uninstall entfernt die Startup-`.lnk`.
+- **In-App Interactive Sessions (neu, 2026-06-26):** ersetzt den externen `wt`-„Run interactively"-Launch durch einen In-App-Streaming-Chat (`StreamingClaudeSession`, `claude --input-format stream-json`). Real-CLI-Smoke (kein xUnit, kein Claude in Tests):
+  - Task rechtsklick → „Run interactively" startet **keinen** Terminal mehr; der Stream erscheint im Detail-Output-Tab des (selektierten) Tasks und als Monitor in Mission Control.
+  - Composer: Nachricht tippen + Enter/Send → erscheint sofort als `log-user`-Zeile in **Akzentfarbe** (via `LogKindForegroundConverter`, lokale Bindung schlägt den dim Style), Claude antwortet im selben Prozess.
+  - **Senden während Claude arbeitet = Queue (Default):** die Nachricht wird gepuffert und beim `result` des laufenden Turns abgeschickt (kein Interrupt). Mehrere Queue-Nachrichten FIFO, eine pro Turn. Gequeute Nachrichten erscheinen in einem **Pending-Streifen über der Eingabezeile** (⧗-Liste, via `InteractiveQueueChanged`); eine Nachricht landet erst im Transkript (`log-user`-Zeile via `InteractiveMessageSent`), wenn sie tatsächlich an Claude zugestellt wird. Der seeded Erst-Prompt erscheint als erste User-Zeile. Jede gequeute Zeile hat ein **✕ zum Entfernen** (`RemoveQueuedInteractiveMessage`, by-text first-match; Worker re-broadcastet die Queue).
+  - **Interrupt opt-in:** der kleine ■-Stop-Button neben Send unterbricht den laufenden Turn (`control_request`/`interrupt`, verifiziert mit CLI 2.1.191; Abbruch-`result` = `error_during_execution`, als Turn-Ende behandelt) — danach flusht die ggf. gequeute Nachricht im selben Prozess mit erhaltenem Kontext. Stop-Button ist immer sichtbar solange live (Interrupt im Idle ist ein No-op; Turn-in-flight wird nicht in die UI gebroadcastet).
+  - Session-Ende: Prozess-Exit/Stop → `InteractiveSessionEnded`, Composer verschwindet, Monitor wird „done".
+  - **Sicht-Konsistenz:** Mission-Control-Composer (SessionTerminalView-Bottom-Row mit Send-Button) vs. Detail-Composer (WorkConsole-Shell-Prompt `❯ … [Send]`) sehen unterschiedlich aus — ggf. angleichen.
+- **Drag-and-drop file attachments on the detail pane:** verify the "Drop to attach" hover overlay, drop round-trip (file appears in the list), "Add file…" picker, remove button, and that files land under `~/.todo-app/attachments/<taskId>/`. Also verify the MCP `AddTaskAttachment`/`ListTaskAttachments`/`RemoveTaskAttachment` tools and that a Running task refuses add/remove. (Manual; can't be unit-tested.)
 
 ## Offene Code-Punkte
 

docs/superpowers/plans/2026-06-19-feature-unification-plan.md

@@ -0,0 +1,104 @@
+# Feature unification — phased plan
+
+Date: 2026-06-19
+Design: `docs/superpowers/specs/2026-06-19-feature-unification-design.md`
+
+Six slices, sequenced cheapest/lowest-risk first. Each ends green
+(`dotnet build -c Release` + the touched test project) and is independently
+committable. Phases 0–1 are detailed here; 2–5 are scoped, and each gets its own
+`docs/superpowers/plans/2026-06-19-unify-<slice>.md` when picked up (per the
+2026-06-05 layer-A/B/C convention). Build per-csproj (`-c Release`) — `.slnx` needs
+.NET 9 and a running Worker locks `Debug`.
+
+---
+
+## Phase 0 — Groundwork (Bucket C). No UX change.
+
+**0a. Delete the dead hunks conflict API (C1).**
+- Remove `TaskMergeService.GetConflictsAsync` + the `MergeConflicts`/`ConflictFileContent` records it returns (`src/ClaudeDo.Worker/Lifecycle/TaskMergeService.cs:250`) if unused elsewhere.
+- Remove `WorkerHub.GetMergeConflicts` (`src/ClaudeDo.Worker/Hub/WorkerHub.cs:378`) + `MergeConflictsDto`/`ConflictFileDto`/`ConflictHunkDto` if unused.
+- Remove `WorkerClient`'s `"GetMergeConflicts"` invoke (`src/ClaudeDo.Ui/Services/WorkerClient.cs:276`) + the `IWorkerClient` member + every fake override (`tests/ClaudeDo.Ui.Tests/StubWorkerClient.cs`, `TasksIslandViewModelPlanningTests.cs`, others — grep `GetMergeConflicts`).
+- Delete `TaskMergeServiceTests.cs:672` `GetConflictsAsync_AfterConflictMerge_ReturnsOursAndTheirs`.
+- Verify with grep first: `GetConflictsAsync` and `GetMergeConflicts` have **no** callers outside this chain + tests.
+- Acceptance: Worker + Ui build; Worker.Tests + Ui.Tests green; `GetMergeConflictDocuments` path untouched.
+
+**0b. Single task-creation path (C2).**
+- Identify the path MCP `ExternalMcpService.AddTask` uses; expose a thin creation method (repository or a small `TaskCreationService`) that applies the same defaults (ListId, SortOrder, CreatedAt).
+- Re-point `TasksIslandViewModel.AddAsync` at it instead of `db.Tasks.Add` direct EF.
+- Acceptance: quick-add still works; one creation path; Ui.Tests + Worker.Tests green.
+
+**0c. Prune stale worktrees (C3).**
+- `git worktree list`; remove the orphaned `.claude/worktrees/*` entries (confirm each is unwanted with Mika before `git worktree remove`).
+- Acceptance: only intended worktrees remain; no tracked files change.
+
+> C4 (naming alignment) intentionally NOT in this phase — see design.
+
+---
+
+## Phase 1 — DialogService (B3–B5). Low–medium.
+
+**Goal:** one `IDialogService` replaces the scattered `Show*` Func seams and the
+duplicate open-commands.
+
+- New `IDialogService` (Ui/Services) with typed methods: `OpenListSettings(ListNavItemViewModel)`, `OpenRepoImport()`, `OpenWorktreesOverview(string? listId)`, `OpenWeeklyReport()`, `OpenAbout()`, `OpenWorkerConnectionHelp()`. Implementation owns the factories + `ModalShell`/TCS wiring currently in `MainWindow.axaml.cs` + `IslandsShellViewModel.cs:59-71`.
+- Inject it into `ListsIslandViewModel`, `TasksIslandViewModel`, `IslandsShellViewModel`. Collapse the three List-Settings doors (Lists context menu, Tasks header, shell bridge `IslandsShellViewModel.cs:190-194`) to one `dialogs.OpenListSettings(row)` call; same for Repo Import (2→1) and Worktrees Overview (2→1, keep the `listId?` param for global-vs-per-list).
+- Keep `ModalShell`/TCS dialog pattern; this only centralizes *opening*.
+- Update fakes/ctors per the IWorkerClient-fakes hazard (ctor changes ripple to Ui.Tests).
+- Acceptance: every dialog opens via one method; no duplicate open-commands; Ui.Tests green; visual gap flagged (open each dialog from each former door).
+
+---
+
+## Phase 2 — MergeCoordinator (B1). Medium.
+
+**Goal:** delete the five `RequestConflictResolution` seams; one coordinator.
+
+- New `IMergeCoordinator` (Ui) `MergeAsync(taskId, targetBranch)` = the body of `IslandsShellViewModel.RequestConflictResolutionAsync` (`:49`) plus the "open MergeModal → on conflict open resolver" flow currently split across `MergeModalViewModel:108` and `DiffModalViewModel:103`.
+- Remove the `Func<string,string,Task>? RequestConflictResolution` from `WorktreesOverviewModalViewModel:83`, `DiffModalViewModel:75`, `MergeModalViewModel:33`, `MergeSectionViewModel:51`, and the `DetailsIslandViewModel:347` delegate; inject the coordinator instead.
+- Re-point doors: review Approve, Diff Merge button, WorktreesOverview single + batch (`:331`), Details merge section.
+- Update seam tests (`WorktreesOverviewBatchMergeTests.cs:145`, `DetailsIslandConflictSeamTests.cs:84`) to assert via the coordinator.
+- Acceptance: one merge entry API; resolver still opens for single-task AND planning conflict; Ui.Tests green; visual gap flagged (force a conflict from Approve and from the Diff Merge button).
+
+---
+
+## Phase 3 — WorktreeActions (A3). Medium.
+
+**Goal:** one per-task worktree-actions VM reused by overview rows + Details.
+
+- New `WorktreeActionsViewModel(taskId)` with Merge/Diff/Discard/Keep/ForceRemove over `IWorkerClient` (uses the Phase-2 coordinator for Merge, the Phase-5 viewer for Diff — until then, current calls).
+- `WorktreesOverviewModalViewModel` rows compose one each; `MergeSectionViewModel` hosts one for the active task. Remove the duplicated commands.
+- Acceptance: both surfaces drive the same VM; Ui.Tests green; visual gap flagged.
+
+---
+
+## Phase 4 — AgentConfigEditor (A2). Medium.
+
+**Goal:** one config editor for Global | List | Task scope.
+
+- New `AgentConfigEditorViewModel(scope)` over `InheritanceResolver` exposing Model/SystemPrompt/AgentPath/MaxTurns + reset commands + `InheritedBadge` state; persists via the scope's hub method (`UpdateListConfig` / `UpdateTaskAgentSettings` / app settings).
+- Embed in `SettingsModalViewModel`, `ListSettingsModalViewModel`, and the Details `AgentSettingsSectionViewModel` host; delete the duplicated field/reset logic.
+- Acceptance: identical editor in all three scopes; Localization parity; Ui.Tests green; visual gap flagged.
+
+---
+
+## Phase 5 — DiffViewer (A1 + B2). High; last.
+
+**Goal:** one diff component replaces DiffModal + WorktreeModal + PlanningDiff.
+
+- New `DiffViewerViewModel` with `DiffSource` enum/abstraction (`DirtyWorktree | BranchVsBase | CommitRange | PlanningAggregate | IntegrationBranch`) and an optional file-tree pane (port `WorktreeModal`'s tree + Avalonia-12 selection workaround); reuse `UnifiedDiffParser` + `DiffLinesView`; keep PlanningDiff's combined-mode toggle as a source switch.
+- Re-point all B2 doors to open it with the right source. Remove the three old VMs/views.
+- Update `DiffModalViewModelTests`, `PlanningDiffViewModelTests`.
+- Acceptance: every diff door opens the one viewer; whole-unified AND file-tree layouts work; Ui.Tests green; visual gap flagged (worktree-dirty, post-merge commit-range, planning per-subtask + integration).
+
+---
+
+## Sequencing rationale
+
+0 (delete/no-UX) → 1 (isolated, unblocks nothing but cheap) → 2 (coordinator; 3 & 5
+lean on it for Merge/Diff) → 3 → 4 (independent) → 5 (biggest, most UX-sensitive,
+benefits from 2's coordinator). Stop after any phase and the app is shippable.
+
+## Per-phase commits
+
+Conventional Commits, one per phase (or per sub-step in Phase 0): e.g.
+`refactor(merge): single MergeCoordinator replaces 5 conflict seams`. Stage by path
+(never `git add -A` — concurrent sessions). Commit the spec + this plan first.

docs/superpowers/plans/2026-06-19-unify-agent-config.md

@@ -0,0 +1,131 @@
+# Phase 4 — AgentConfigEditor (A2)
+
+Date: 2026-06-23 (picked up after reordering Phase 3 ↔ 4)
+Umbrella: `docs/superpowers/plans/2026-06-19-feature-unification-plan.md`
+Design: `docs/superpowers/specs/2026-06-19-feature-unification-design.md` (A2)
+
+## Reordering note
+
+Phase 3 (WorktreeActions) was deferred. Its premise — overview rows and the Details
+merge section each owning duplicate worktree commands — only half-holds: Details has
+no Discard/Keep/ForceRemove, and the two Diff doors open different VMs (`WorktreeModal`
+vs `DiffModal`) that only Phase 5 unifies. So Phase 3's clean form depends on Phase 5
+(Diff) and a fuller MergeCoordinator (Merge); doing it now would build throwaway
+per-surface delegates. **Phase 3 is folded into Phase 5.** Phase 4 (independent, clean
+dedup) runs now.
+
+## Scope decision: List + Task only (global left as-is)
+
+The design names three scopes (Global | List | Task). Verified against the tree on
+2026-06-23, only **List and Task genuinely duplicate**:
+
+- **List** (`ListSettingsModalViewModel`, "AGENT" section): Model / MaxTurns /
+  SystemPrompt / AgentFile, each with `InheritedBadge` + `↺` reset; 2-tier
+  (list→global) badges computed with inline logic (does **not** use the existing
+  `InheritanceResolver.ResolveList` — which is currently dead code); explicit Save.
+- **Task** (`AgentSettingsSectionViewModel`, TaskHeaderBar gear flyout): same four
+  fields; 3-tier (task→list→global) badges via `InheritanceResolver.Resolve`;
+  `EffectiveMaxTurns` + `EffectiveSystemPromptHint`; `IsRunning` gate; debounced
+  auto-save.
+
+**Global** (`GeneralSettingsTabViewModel`, Settings → General) is the root: no
+inheritance, no badges, no agent file, no reset — three plain controls (model combo,
+max-turns numeric, instructions textbox) plus a global-only PermissionMode, interleaved
+with unrelated settings (Language, parallelism, report paths, standup weekday) and
+saved batched into one `AppSettingsDto` via the modal Save. Embedding the shared editor
+there buys ~3 plain fields at the cost of a degenerate no-badges/no-agent/no-reset mode
+plus surgery on the settings save path and a relayout of the most settings-dense view.
+**Not worth it — global stays as-is.** (Confirmed with Mika 2026-06-23.)
+
+The real maintenance hazard is the **VM logic** (two copies of badge/reset/inheritance
+that already drifted), and the **view** (3 of 4 field blocks are pixel-identical). Both
+collapse cleanly for List+Task.
+
+## Target
+
+One `AgentConfigEditorViewModel` + one `AgentConfigEditor` UserControl, instantiated
+per surface with a scope. The two host VMs keep only their non-agent concerns and host
+the editor as a child.
+
+### `ViewModels/Agent/AgentConfigEditorViewModel.cs` (new)
+
+- `enum AgentConfigScope { List, Task }`
+- ctor `(IWorkerClient worker, AgentConfigScope scope)`
+- Unified bindable surface (single names both views bind to):
+  `Model` (string?), `MaxTurns` (decimal?), `SystemPrompt` (string),
+  `SelectedAgent` (AgentInfo?); `ModelOptions`, `Agents`;
+  `ModelBadge`/`TurnsBadge`/`AgentBadge`, `ModelInheritedHint`/`TurnsInheritedHint`,
+  `EffectiveSystemPromptHint`; `EffectiveMaxTurns` (int), `IsRunning`/`IsEnabled`.
+- Reset commands: `ResetModel`, `ResetTurns`, `ResetAgent`, `ResetAll`.
+- Badges via `InheritanceResolver`: scope==Task → `Resolve(own, list, global)`;
+  scope==List → `ResolveList(own, global)` (adopts the dead method). One `BadgeFor`
+  helper covers both (List scope never yields the `List` source).
+- Load: `LoadForListAsync(listId)` and `LoadForTaskAsync(TaskEntity entity)` — both
+  pull agents + app-settings (global defaults); Task also pulls the list tier +
+  `EffectiveSystemPromptHint`. Localizer-change re-badges (port the `Loc.LanguageChanged`
+  handler + `IDisposable`).
+- Save: `SaveAsync()` is scope-aware — List builds `UpdateListConfigDto` →
+  `UpdateListConfigAsync`; Task builds `UpdateTaskAgentSettingsDto` →
+  `UpdateTaskAgentSettingsAsync`. Task scope also auto-saves debounced (300ms) on field
+  changes; List does not (the modal Save button calls `SaveAsync`). `SaveAsync` is
+  directly callable (tests bypass the debounce).
+- Task-only `Clear()` + `TaskId`.
+
+### `Views/Controls/AgentConfigEditor.axaml` (+ .axaml.cs) (new)
+
+- `x:DataType` = `AgentConfigEditorViewModel`; host sets `DataContext="{Binding Agent}"`.
+- The four field blocks (model/turns/systemprompt/agent) with `InheritedBadge` + `↺`
+  reset, lifted verbatim from the existing two views (they already match). Agent combo
+  shows Name + Description (both scopes; harmless for task). `EffectiveSystemPromptHint`
+  line gated on non-empty (hides for List).
+- `StyledProperty<bool> ShowAgentBrowse` (default false). True → render the Browse
+  button + path line; the browse file-picker code-behind lives here (moved from
+  `ListSettingsModalView`).
+- Shared localization namespace `settings.agentEditor.*` (model/maxTurns/systemPrompt/
+  agentFile/promptPrepended). Reset tooltip reuses `settings.inherit.resetToInherited`.
+
+### Re-point hosts
+
+- `ListSettingsModalViewModel`: drop the agent fields/badges/resets/option-lists; add
+  `public AgentConfigEditorViewModel Agent { get; }` (scope=List). `LoadAsync` →
+  `Agent.LoadForListAsync(listId)`. `SaveAsync` keeps `UpdateListAsync` (name/dir) and
+  adds `await Agent.SaveAsync()`. Keep working-dir browse (`BrowseClicked`).
+- `ListSettingsModalView.axaml`: replace the AGENT section body with
+  `<ctl:AgentConfigEditor DataContext="{Binding Agent}" ShowAgentBrowse="True"/>`; the
+  section-header "Reset agent settings" button binds `Agent.ResetAllCommand`. Remove the
+  agent browse code-behind (moved into the control).
+- `DetailsIslandViewModel`: `AgentSettings` becomes `AgentConfigEditorViewModel`
+  (scope=Task). Preserve the call sites: ctor, `EffectiveMaxTurns`→`TurnsText`
+  PropertyChanged hook, `IsRunning` push, `Dispose`, `Clear`, `TaskId`,
+  `LoadForTaskAsync(entity, ct)`.
+- `TaskHeaderBar.axaml`: replace the flyout field blocks with
+  `<ctl:AgentConfigEditor DataContext="{Binding AgentSettings}"/>` (ShowAgentBrowse=false).
+  Keep the gear button + heading.
+- Delete `AgentSettingsSectionViewModel.cs`.
+
+## Tests
+
+- New `tests/ClaudeDo.Ui.Tests/ViewModels/AgentConfigEditorViewModelTests.cs`:
+  - List scope: badges resolve override-vs-global; resets clear; `SaveAsync` builds the
+    right `UpdateListConfigDto` (via `StubWorkerClient`).
+  - Task scope: badges resolve override/list/global; `EffectiveMaxTurns`/
+    `EffectiveSystemPromptHint` from list tier; resets clear; `SaveAsync` builds the right
+    `UpdateTaskAgentSettingsDto`.
+- `InheritanceResolverTests` unchanged (resolver untouched).
+- Existing DetailsIsland* tests must stay green (they construct the VM but don't name the
+  moved members).
+
+## Acceptance
+
+- `dotnet build -c Release` clean for Ui (+ App).
+- `Ui.Tests` + `Localization.Tests` green.
+- One editor VM + one control drive both List and Task; duplicated field/badge/reset
+  logic deleted; `ResolveList` now has a real caller.
+- Visual gap flagged: open List Settings → Agent, and a task's gear flyout — verify
+  badges, ↺ resets, reset-all, agent browse (list only), system-prompt hint (task), and
+  that list Save persists + task auto-saves.
+
+## Commit
+
+`refactor(agent-config): single AgentConfigEditor for list + task scopes`. Stage by
+path. Commit this plan with it.

docs/superpowers/plans/2026-06-19-unify-diff-viewer.md

@@ -0,0 +1,111 @@
+# Phase 5 — DiffViewer (A1 + B2)
+
+Date: 2026-06-23
+Umbrella: `docs/superpowers/plans/2026-06-19-feature-unification-plan.md`
+Design: `docs/superpowers/specs/2026-06-19-feature-unification-design.md` (A1, B2)
+
+## Goal
+
+One diff component replaces the three parallel read-only diff windows:
+`DiffModalViewModel`/View, `WorktreeModalViewModel`/View, `PlanningDiffViewModel`/View.
+**Merge editor (`ConflictResolverViewModel`) is untouched** — per the design's hard
+decision; the viewer only *opens* it on conflict via the existing Merge flow.
+
+All three are already master-detail: **left nav pane + right `DiffLinesView`**. They
+differ only in left-pane content, chrome, and data source — so they collapse into one
+shell with a source mode.
+
+## Decisions (Mika, 2026-06-23)
+
+- **File nav = file-tree** (folder-grouped), not a flat list. Port `WorktreeModal`'s tree
+  + the Avalonia-12 `TreeView.SelectionChanged` workaround. Carry per-file status + +adds/
+  −dels into the tree rows (from the parsed `DiffFileViewModel`).
+- Planning keeps its **subtask-list + combined-mode toggle**; the branch source keeps its
+  **Merge** button.
+
+## Target
+
+### Shared types → `ViewModels/Modals/DiffModels.cs` (new, same namespace)
+
+Move out of the to-be-deleted VMs so `UnifiedDiffParser`/`DiffLinesView` keep compiling:
+`DiffLineKind`, `DiffFileStatus`, `DiffLineViewModel`, `DiffFileViewModel` (from
+`DiffModalViewModel.cs`), `SubtaskDiffRow` (from `PlanningDiffViewModel.cs`). Add new
+`DiffTreeNodeViewModel` (dir/file node; file leaves hold their `DiffFileViewModel`).
+
+### `DiffViewerViewModel` (`ViewModels/Modals/DiffViewerViewModel.cs`, new)
+
+ctor `(GitService git, IWorkerClient worker)`. A `DiffViewerMode { Files, Planning }`.
+
+- **File sources** (replaces DiffModal + WorktreeModal): config props `WorktreePath`,
+  `BaseRef`, `HeadCommit`, `FromCommitRange`, `TaskId`, `TaskTitle` + `ShowMergeModal`/
+  `ResolveMergeVm` delegates. `LoadAsync` pulls the whole diff via GitService
+  (`GetCommitRangeDiffAsync` | `GetBranchDiffAsync` | `GetDiffAsync`), parses with
+  `UnifiedDiffParser.Parse`, builds `FileTree`. `SelectedNode` (leaf) → `SelectedFile`
+  (header + binary/empty placeholders + `Lines`). Commit-range null-guard → "no longer
+  available" (preserve DiffModal behavior). `MergeCommand` (CanMerge = TaskId +
+  delegates) opens the MergeModal, closes on merged/routed (verbatim from DiffModal).
+- **Planning source** (replaces PlanningDiff): config `PlanningTaskId`, `TargetBranch`.
+  `LoadAsync` pulls `GetPlanningAggregateAsync` → `Subtasks`; `SelectedSubtask` →
+  `DisplayedDiff`; `IsCombinedMode` toggle → `BuildPlanningIntegrationBranchAsync`
+  (success → combined diff; conflict → `CombinedWarning` with subtask + file count;
+  null → hub-error warning). `DisplayedDiff` → flattened `DiffLines` (right pane).
+- Shared: `StatusMessage`, `CloseAction`, `CloseCommand`.
+
+### `DiffViewerView` (`Views/Modals/DiffViewerView.axaml` + `.cs`, new)
+
+`ModalShell`-based window. Left pane: `TreeView` (Files mode) or subtask `ListBox`
+(Planning mode), toggled by mode. Right pane: the DiffModal file pane (header + binary/
+empty/no-changes placeholders + `DiffLinesView Lines="SelectedFile.Lines"`) in Files mode,
+or `DiffLinesView Lines="DiffLines"` in Planning mode. Toolbar: combined toggle + warning
++ loading (Planning). Footer: Merge button (Files mode, CanMerge). Code-behind: `CloseAction`,
+the `TreeView.SelectionChanged` → `SelectedNode` workaround, dir-row tap-to-expand.
+
+### Re-point the 3 doors → one viewer
+
+- **`MergeSectionViewModel`**: `OpenDiffAsync` builds a Files-mode `DiffViewerViewModel`
+  (+ ShowMergeModal/ResolveMergeVm) and calls a single `ShowDiffViewer` delegate;
+  `ReviewCombinedDiffAsync` builds a Planning-mode one and calls the *same* delegate.
+  Replaces `ShowDiffModal` + `ShowPlanningDiffModal` with one `Func<DiffViewerViewModel,Task>
+  ShowDiffViewer`; keeps `ShowMergeModal`. (Resolve the VM via `_services`.)
+- **`DetailsIslandView.axaml.cs`**: replace the two `ShowDiffModal`/`ShowPlanningDiffModal`
+  wirings (→ `DiffModalView`/`PlanningDiffView`) with one `ShowDiffViewer` (→ `DiffViewerView`).
+  Keep `ShowMergeModal`.
+- **`WorktreesOverviewModalViewModel`**: `ShowDiff` builds a Files-mode viewer (worktree path
+  + base). Change `_diffVmFactory` from `Func<WorktreeModalViewModel>` to
+  `Func<DiffViewerViewModel>`; `ShowDiffAction` stays `Action<DiffViewerViewModel>`.
+- **`WindowDialogService.cs`**: `ShowDiffAction` → `new DiffViewerView` + `LoadAsync` + show.
+- **`Program.cs`**: register `DiffViewerViewModel` (transient) + `Func<DiffViewerViewModel>`;
+  drop the `WorktreeModalViewModel` registration.
+
+### Delete
+
+`DiffModalViewModel.cs`, `WorktreeModalViewModel.cs`, `PlanningDiffViewModel.cs`,
+`DiffModalView.axaml(.cs)`, `WorktreeModalView.axaml(.cs)`, `PlanningDiffView.axaml(.cs)`.
+
+### Localization
+
+Reuse existing keys in the merged view (`modals.diff.*` for the file pane, `planning.diff.*`
+for the planning toolbar). Prune clearly-orphaned `modals.worktree.*` if trivial; keep en/de
+parity.
+
+## Tests
+
+Replace `DiffModalViewModelTests` + `PlanningDiffViewModelTests` with
+`DiffViewerViewModelTests` preserving the behaviors: commit-range null-guard → unavailable;
+planning init populates + selects first; subtask select → DisplayedDiff; combined toggle
+success/conflict/null. `WorktreesOverviewBatchMergeTests` compiles unchanged (`() => null!`
+satisfies the new Func type). `UnifiedDiffParserTests` unchanged.
+
+## Acceptance
+
+- `dotnet build -c Release` clean (App); `Ui.Tests` + `Localization.Tests` green.
+- One viewer reached from all 3 doors; old VMs/views deleted; merge editor untouched.
+- Visual gap flagged: Details "Open Diff" (dirty + post-merge commit-range), Worktrees-
+  Overview "Show Diff" (tree), Details "Review Combined Diff" (subtasks + combined toggle),
+  and the Merge button still opens the merge form / resolver on conflict.
+
+## Commit
+
+`refactor(diff): single DiffViewer replaces DiffModal + WorktreeModal + PlanningDiff`.
+Stage by path (exclude concurrent peers' files). Then Phase 3 (WorktreeActions) follows as
+its own slice, reusing this viewer.

docs/superpowers/plans/2026-06-23-worker-log-footer-overlay.md

@@ -0,0 +1,32 @@
+# Plan — Worker log → footer + Log Visualizer overlay
+
+Design: `docs/superpowers/specs/2026-06-23-worker-log-footer-overlay-design.md`. Build on `main`, TDD, commit per task (Conventional Commits, explicit paths — shared worktree). Build `-c Release`.
+
+## Task 1 — `LogRingBuffer` (Worker) + tests
+- `src/ClaudeDo.Worker/Logging/WorkerLogRecord.cs` — `record WorkerLogRecord(string Message, WorkerLogLevel Level, DateTime TimestampUtc)`.
+- `src/ClaudeDo.Worker/Logging/LogRingBuffer.cs` — thread-safe, `TimeSpan window` + int cap; `Append(record)`, `Snapshot()`. Uses an injected clock func (`Func<DateTime>`) for testability (default `() => DateTime.UtcNow`).
+- Tests: age eviction, cap eviction, snapshot order. **No `DateTime.UtcNow` in tests — drive the clock.**
+
+## Task 2 — `BroadcastLogSink` (Worker) + tests
+- `src/ClaudeDo.Worker/Logging/BroadcastLogSink.cs : ILogEventSink` — level map, render (+exception first line), append-all-levels, broadcast Warn/Err via deferred `HubBroadcaster` (`Attach`), dedupe window (const 120s), loop-guard (skip SignalR `SourceContext` for broadcast; swallow broadcast exceptions). Inject clock func.
+- Broadcaster is an abstraction the test can fake: depend on a tiny `Func<string,WorkerLogLevel,DateTime,Task>?` set by `Attach`, OR on `HubBroadcaster` directly (it's a sealed class — prefer a delegate to keep the test pure). Use a delegate.
+- Tests: all levels buffered; only Warn/Err invoke the broadcast delegate; dedupe suppresses 2nd identical within window but still buffers; exception rendering; SignalR-source event buffered but not broadcast.
+
+## Task 3 — wire into `Program.cs` + `WorkerHub.GetRecentLogs`
+- `Program.cs`: create `LogRingBuffer` + `BroadcastLogSink` locals before build; `.WriteTo.Sink(broadcastSink)`; `AddSingleton(logBuffer)`; after build `broadcastSink.Attach((m,l,t) => broadcaster.WorkerLog(m,l,t))` using resolved `HubBroadcaster`.
+- `WorkerHub`: inject `LogRingBuffer`; `public IReadOnlyList<WorkerLogRecordDto> GetRecentLogs()` → snapshot mapped to DTO. Add `WorkerLogRecordDto` (Hub or shared). Update `WorkerHub` ctor → check hub-construction call sites/tests.
+- Build Worker `-c Release`; run Worker.Tests (filtered to new + hub).
+
+## Task 4 — `IWorkerClient.GetRecentLogsAsync` + WorkerClient + fakes
+- `IWorkerClient` + `WorkerClient` impl (`_hub.InvokeAsync<List<WorkerLogEntry>>("GetRecentLogs", ct)`).
+- Update fakes: `tests/ClaudeDo.Ui.Tests/StubWorkerClient.cs`, Worker.Tests UiVm fake(s) → return `Array.Empty<WorkerLogEntry>()`.
+- Build Ui + Worker.Tests.
+
+## Task 5 — `LogVisualizerViewModel` + View + dialog wiring + tests
+- VM (Modals/), View (Modals/, ModalShell), `IDialogService.ShowLogVisualizerAsync` + `WindowDialogService` impl.
+- `IslandsShellViewModel.OpenLogVisualizerCommand` (resolves VM, loads, shows). Make footer worker-log line a clickable Button → command.
+- Localization `vm.logVisualizer` en+de.
+- Tests: VM load/populate/filter. Build App `-c Release`; Ui.Tests + Localization.Tests.
+
+## Task 6 — verify + docs
+- Full relevant test pass. Update `src/ClaudeDo.Ui/CLAUDE.md` (overlay VM/view, footer click) + `src/ClaudeDo.Worker/CLAUDE.md` (Logging/ folder, sink, GetRecentLogs, WorkerLog now carries Serilog Warn/Err). Note visual-verification gap (overlay render) for the user.

docs/superpowers/plans/2026-06-25-interactive-ask-user.md

@@ -0,0 +1,56 @@
+# Plan — Interactive "Answer Claude's Questions"
+
+Spec: `docs/superpowers/specs/2026-06-25-interactive-ask-user-design.md`
+
+Implement on the shared main tree. Commit explicit paths per task (never `git add -A`).
+Build with `-c Release` (running Worker locks Debug). No real-Claude tests.
+
+## Task 1 — PendingQuestionRegistry (worker, new file)
+- `src/ClaudeDo.Worker/Runner/PendingQuestionRegistry.cs`: singleton; `record PendingQuestion(TaskId, QuestionId, Question)`.
+  - `(string QuestionId, Task<string> Answer) Register(taskId, question)` — overwrites any stale entry, `RunContinuationsAsynchronously`.
+  - `bool TryAnswer(taskId, questionId, answer)`; `PendingQuestion? Get(taskId)`; `void Remove(taskId, questionId)`.
+- Test: `tests/ClaudeDo.Worker.Tests/Runner/PendingQuestionRegistryTests.cs` — register→answer resolves the task; wrong questionId no-ops; Get reflects state; second Register overwrites.
+
+## Task 2 — AskUser MCP tool (worker)
+- `TaskRunMcpService.cs`: inject `PendingQuestionRegistry`; add
+  `[McpServerTool] async Task<string> AskUser(string question, CancellationToken ct)`:
+  - caller id from `_ctx.Current.CallerTaskId`; register; broadcast `TaskQuestionAsked`.
+  - await answer via `Task<string>.WaitAsync` with a 3-min linked-CTS; on timeout return the fallback string; on request-cancel rethrow.
+  - `finally`: `Remove` + broadcast `TaskQuestionResolved`.
+  - `[Description]`: when to use (only when a wrong guess is costly/irreversible; otherwise proceed).
+- Test: `tests/ClaudeDo.Worker.Tests/Runner/AskUserToolTests.cs` — answer path returns the answer; timeout path returns fallback (inject a short timeout or a seam) with a fake broadcaster + stub context accessor.
+
+## Task 3 — Wire MCP for all runs + timeout env (worker)
+- `TaskRunner.RunAsync`: move MCP-identity setup out of the `standalone` gate so every run gets `claudedo_run`; `AllowedTools` = `mcp__claudedo_run__AskUser` always, append `,mcp__claudedo_run__SuggestImprovement` when standalone. Keep token cleanup in `finally`.
+- `ClaudeProcess.cs`: `psi.Environment["MCP_TOOL_TIMEOUT"] = "200000";`.
+- System prompt file (PromptKind.System default): add one guidance line about `AskUser`.
+
+## Task 4 — Hub + Broadcaster (worker)
+- `HubBroadcaster.cs`: `TaskQuestionAsked(taskId, questionId, question)`, `TaskQuestionResolved(taskId, questionId)`.
+- `WorkerHub.cs`: inject registry; `bool AnswerTaskQuestion(taskId, questionId, answer)`; `PendingQuestionDto? GetPendingQuestion(taskId)`; `record PendingQuestionDto(...)`.
+- `Program.cs`: register `PendingQuestionRegistry` as singleton.
+
+## Task 5 — UI client (IWorkerClient/WorkerClient + fakes)
+- `IWorkerClient`: `Task AnswerTaskQuestionAsync(taskId, questionId, answer)`, `Task<PendingQuestionDto?> GetPendingQuestionAsync(taskId)`, events `Action<string,string,string>? TaskQuestionAskedEvent`, `Action<string,string>? TaskQuestionResolvedEvent`; UI DTO record.
+- `WorkerClient`: implement invokes + `On<...>` handlers raising the events.
+- Update hand-rolled `IWorkerClient` fakes in Ui.Tests (and Worker.Tests if present).
+
+## Task 6 — TaskMonitorViewModel (hot file)
+- Subscribe both events (filter by `_subscribedTaskId`); dispose handlers.
+- Props: `PendingQuestionId`, `PendingQuestion`, `HasPendingQuestion`, `AnswerDraft`, `IsWaitingForInput`.
+- `SubmitAnswerCommand` (CanExecute: non-empty draft + HasPendingQuestion) → `AnswerTaskQuestionAsync`; clear draft.
+- Clear pending on `TaskFinished` for this task and in `Reset()`.
+- Test: `TaskMonitorViewModelTests` — asked event surfaces question; submit invokes client + clears; resolved/finished clears.
+
+## Task 7 — Hydrate on attach (MissionControlViewModel)
+- In `HydrateAsync`, after `ApplyState`, call `GetPendingQuestionAsync(taskId)`; if present, set the monitor's pending question (re-attach case).
+
+## Task 8 — View banner (hot file, additive)
+- `MonitorPaneView.axaml`: a `Border DockPanel.Dock="Top"` above `SessionTerminalView`, `IsVisible="{Binding HasPendingQuestion}"`, showing the question text, a `TextBox` bound to `AnswerDraft` (Enter submits), and a Send `Button` → `SubmitAnswerCommand`. Mirror the roadblock-banner styling.
+
+## Task 9 — Localization
+- `en.json` + `de.json`: `missionControl.question.title`, `.placeholder`, `.send`. Keep parity (Localization.Tests).
+
+## Task 10 — Build + test + verify
+- `dotnet build` App + Worker `-c Release`; run Worker.Tests, Ui.Tests, Localization.Tests.
+- Self-review diffs. Flag the two manual verification gaps to Mika. Do not push.

docs/superpowers/plans/2026-06-25-mission-control.md

@@ -0,0 +1,98 @@
+# Plan — Mission Control (multi-task live monitoring)
+
+Spec: `docs/superpowers/specs/2026-06-25-mission-control-design.md`
+
+Execution: subagent-driven, **sonnet** model, TDD where a test is meaningful, build + test before
+each commit, one Conventional Commit per task. Stage files explicitly by path (never `git add -A`).
+**No duplication** — every task reuses the assets named in the spec's reuse map.
+
+---
+
+## Phase 1 — Extract the reusable monitor core (no behavior change)
+
+### Task 1.1 — Move `LogLineViewModel` + `LogKind` to their own file
+- Cut `LogKind` enum and `LogLineViewModel` from `DetailsIslandViewModel.cs` into
+  `ViewModels/Islands/LogLineViewModel.cs` (same namespace). No logic change.
+- Build `ClaudeDo.App`; run Ui.Tests. Commit: `refactor(ui): split LogLineViewModel into own file`.
+
+### Task 1.2 — Create `TaskMonitorViewModel` owning the streaming/status/outcome core
+- New `ViewModels/Islands/TaskMonitorViewModel.cs`. Move from `DetailsIslandViewModel`:
+  `Log`, `_subscribedTaskId`, `_formatter`, `_claudeBuf`, `OnTaskMessage`, `AppendStdoutLine`,
+  `FlushClaudeBuffer`, `ReplayLogFileAsync`, `ExpandUserPath`; `AgentState` + all `Is*` flags +
+  `OnAgentStateChanged`; `StatusToStateKey` / `FinishedStatusToStateKey`; `SessionOutcome` /
+  `Roadblocks` + `ApplyOutcome` + `RoadblockMarker`; the worker `TaskMessage/Started/Finished/Updated`
+  subscriptions for the streaming concern; `Title`/`TaskIdBadge`/`Model`/`TurnsText`/`TokensFormatted`/
+  diff text/elapsed; `BlockingReason` (+visible flag) from `BlockedByTaskId`/review/children/roadblocks.
+- Ctor takes `IDbContextFactory<ClaudeDoDbContext>`, `IWorkerClient`. `Attach(taskId)` /
+  `AttachAsync(entity)` to (re)bind + replay; `IDisposable` unsubscribes (mirror existing Dispose).
+- Unit test (Ui.Tests): feed `[stdout]`/`[claude]`/`[tool]` lines via the worker fake → `Log`
+  accumulates correctly; `TaskFinished` flips `AgentState`; `ApplyOutcome` splits the roadblock marker.
+  Reuse the existing IWorkerClient fake (see `iworkerclient_fakes_sync`).
+- Build + test. Commit: `feat(ui): extract TaskMonitorViewModel streaming core`.
+
+### Task 1.3 — `DetailsIslandViewModel` delegates to `Monitor`
+- Add `public TaskMonitorViewModel Monitor { get; }`; construct it; route `Bind`/`BindAsync` to
+  `Monitor.Attach`. Remove the moved members; keep subtasks/attachments/editing/merge/review/child
+  outcomes/notes/prep intact. Dispose `Monitor`.
+- Repoint `WorkConsole.axaml` Output-tab bindings (`Log`, `IsRunning/IsDone/IsFailed`,
+  `SessionOutcome`, `TurnsText`, `DiffAddText`/`DiffDelText`, `Model`) to `Monitor.*`. Leave
+  review/merge/session bindings unchanged.
+- Build + test. **Manual visual pass: Details pane behaves exactly as before** (flag for Mika).
+  Commit: `refactor(ui): route DetailsIsland streaming through Monitor`.
+
+---
+
+## Phase 2 — Mission Control window
+
+### Task 2.1 — `MissionControlViewModel`
+- New `ViewModels/MissionControlViewModel.cs`: `ObservableCollection<TaskMonitorViewModel> Monitors`
+  keyed by id; seed from `GetActive()`; add on `TaskStarted`, flip-state-and-keep on `TaskFinished`;
+  `ClearFinished` command; `ColumnCount`/layout signal from `Monitors.Count`; least-active collapse.
+  `IDisposable` disposes all monitors. Inject `IDbContextFactory`, `IWorkerClient`, `IServiceProvider`.
+- Register `AddSingleton<MissionControlViewModel>` in `App/Program.cs`.
+- Unit test: simulate two `TaskStarted` → two monitors; `TaskFinished` keeps the pane; `ColumnCount`
+  matches count. Commit: `feat(ui): add MissionControlViewModel`.
+
+### Task 2.2 — `RevealTaskAsync` navigation on the shell
+- Add `IslandsShellViewModel.RevealTaskAsync(taskId)` (resolve list → select → await load → select row).
+- Wire `TaskMonitorViewModel.OpenInApp` to it (via an `Action<string>?` set by the shell, like the
+  existing `CloseDetail`/`DeleteFromList` hooks — no new DI cycle).
+- Unit test for the select-by-id path. Commit: `feat(ui): reveal a task by id from anywhere`.
+
+### Task 2.3 — `MonitorPaneView` (reuses `SessionTerminalView`)
+- New `Views/MissionControl/MonitorPaneView.axaml(.cs)`: header (title/chip/tok/turn/elapsed),
+  blocking banner (`live-chip`/`terminal`/error-tint classes from IslandStyles — reuse), body =
+  `<SessionTerminalView Entries="{Binding Log}" ... />`, footer (Open in app / Detach / Cancel).
+  `x:DataType=TaskMonitorViewModel`. No new console control. Add `missionControl.*` en+de keys.
+- Build + Localization.Tests. Commit: `feat(ui): add MonitorPaneView`.
+
+### Task 2.4 — `MissionControlView` grid + `MissionControlWindow`
+- `MissionControlView.axaml`: `ItemsControl`/`UniformGrid` of `MonitorPaneView` driven by `ColumnCount`,
+  horizontal scroll fallback, header with `ClearFinished` (+ optional QuickAdd, deferrable).
+- `MissionControlWindow.axaml(.cs)`: hosts the view; lazy-create + hide-on-close.
+- Build. Commit: `feat(ui): add MissionControl window + grid`.
+
+### Task 2.5 — Launch button + lifetime
+- Title-bar toggle button in `MainWindow.axaml` → shell command that shows/focuses the window
+  (created lazily, owns the singleton VM).
+- Set `desktop.ShutdownMode = OnMainWindowClose` in `App.OnFrameworkInitializationCompleted`.
+- Build. **Manual visual pass** (flag for Mika): open with 2+ running tasks; main window still adds
+  tasks; blocking banner; Open-in-app. Commit: `feat(ui): open Mission Control from the title bar`.
+
+---
+
+## Phase 3 — Per-pane detach (lowest priority)
+
+### Task 3.1 — `TaskMonitorWindow` + detach/re-dock
+- `Views/MissionControl/TaskMonitorWindow.axaml(.cs)` hosting `MonitorPaneView`; `Detach` removes the
+  monitor from the grid and shows it in the window (optional always-on-top); close re-docks.
+- Build. Manual visual pass. Commit: `feat(ui): detach a monitor into its own window`.
+
+---
+
+## Cross-cutting checklist (every task)
+- Stage by explicit path; sonnet subagents; reuse per the spec's map — no new console/streaming/insert path.
+- en.json + de.json parity for any new string (Localization.Tests).
+- If `IWorkerClient`/ctor signatures change, update the hand-rolled fakes in **both** test projects.
+- Build `ClaudeDo.App` (`-c Release` if Worker is running) before marking a task done.
+- Never push without asking.

docs/superpowers/plans/2026-06-26-in-app-interactive-sessions.md

@@ -0,0 +1,101 @@
+# Plan — In-App Interactive Sessions
+
+Spec: `docs/superpowers/specs/2026-06-26-in-app-interactive-sessions-design.md`
+
+Implement on the shared main tree. Commit explicit paths per task (never `git add -A`).
+Build with `-c Release` (running Worker locks Debug). No real-Claude tests — fake the
+process stream. Sonnet subagents. Autonomous `TaskRunner`/`ClaudeProcess` path stays untouched.
+
+## Task 1 — StreamingClaudeSession (worker, new file)
+- `Runner/StreamingClaudeSession.cs`: persistent `claude` process. Ctor takes resolved args,
+  working dir, seeded first prompt, a line callback, `WorkerConfig`. Reuse the
+  `ProcessStartInfo` shape + `MCP_TOOL_TIMEOUT="200000"` from `ClaudeProcess`.
+  - Keeps stdin open; sends the first prompt as a user-message JSON line (escape via
+    `JsonSerializer`).
+  - stdout/stderr read tasks → line callback; parse `result` events to track `IsTurnInFlight`.
+  - `SendUserMessageAsync(text, ct)` — enqueue/write a user-message JSON line; if
+    `IsTurnInFlight`, also `InterruptAsync`.
+  - `InterruptAsync(ct)` — write the control-protocol interrupt line; best-effort (swallow +
+    log on failure → queue fallback applies).
+  - `StopAsync` / `DisposeAsync` — close stdin, kill the tree, await exit.
+  - Injectable stream seam so a fake can drive it without a real `claude` binary.
+- Test: `StreamingClaudeSessionTests` (fake stream) — first message emitted; `result` flips
+  `IsTurnInFlight` off; a sent message produces a second turn; mid-turn send calls interrupt
+  then delivers; interrupt throw → delivered at natural turn end; stop kills.
+
+## Task 2 — LiveSessionRegistry (worker, new file)
+- `Runner/LiveSessionRegistry.cs`: singleton; `Register(taskId, StreamingClaudeSession)`,
+  `bool TryGet(taskId, out session)`, `Unregister(taskId)`, `Task StopAsync(taskId)`.
+- Test: register→get; unregister; second register stops+replaces; missing get returns false.
+
+## Task 3 — InteractiveSessionService (worker, new file)
+- `Planning/InteractiveSessionService.cs`: inject `IDbContextFactory`, `WorkerConfig`,
+  `ClaudeArgsBuilder` (or build args inline), `HubBroadcaster`, `LiveSessionRegistry`.
+  - `StartAsync(taskId, ct)`: resolve list working dir + seeded prompt (reuse the body of
+    `PlanningSessionManager.OpenInteractiveAsync` + `BuildInteractivePrompt`); build interactive
+    args (`--model PlanningAlias --permission-mode auto` + streaming flags); spawn the session
+    with a callback that does `HubBroadcaster.TaskMessage(taskId, "[stdout] " + line)`;
+    register; broadcast `InteractiveSessionStarted`. Reject if one is already live for the task.
+  - `SendAsync(taskId, text, ct)` → registry `TryGet` → `SendUserMessageAsync`.
+  - `StopAsync(taskId, ct)` → registry stop + `InteractiveSessionEnded`.
+- Move `OpenInteractiveAsync`/`BuildInteractivePrompt` out of `PlanningSessionManager` if it
+  reads cleaner (or call into it). Remove the `InteractiveLaunchContext` terminal coupling.
+- Test: `InteractiveSessionServiceTests` (fake session factory + fake broadcaster) — start
+  resolves dir, seeds prompt, registers, broadcasts started; missing working dir throws;
+  send routes; stop broadcasts ended.
+
+## Task 4 — Remove terminal interactive path (worker)
+- `Planning/Interfaces/ITerminalLauncher.cs` + `WindowsTerminalLauncher.cs`: delete
+  `LaunchInteractiveAsync`; remove `InteractiveLaunchContext` from `PlanningSessionContext.cs`.
+  Keep planning start/resume launches.
+- Fix any references; ensure the planning launcher tests still build.
+
+## Task 5 — Hub + Broadcaster + DI (worker)
+- `Hub/WorkerHub.cs`: re-point `OpenInteractiveTerminalAsync` to
+  `InteractiveSessionService.StartAsync` (drop `_launcher.LaunchInteractiveAsync`); add
+  `Task SendInteractiveMessage(taskId, text)`, `Task StopInteractiveSession(taskId)`
+  (+ optional `InterruptInteractiveSession`).
+- `Hub/HubBroadcaster.cs`: `InteractiveSessionStarted(taskId)`, `InteractiveSessionEnded(taskId)`.
+- `Program.cs`: register `LiveSessionRegistry` + `InteractiveSessionService` singletons.
+- Test: `WorkerHub` send routes to a fake service; start invokes the service.
+
+## Task 6 — UI client + fakes (ui)
+- `Services/Interfaces/IWorkerClient.cs` + `WorkerClient.cs`: `SendInteractiveMessageAsync(
+  taskId, text)`, `StopInteractiveSessionAsync(taskId)` (+ optional interrupt); events
+  `Action<string>? InteractiveSessionStartedEvent`, `InteractiveSessionEndedEvent` with
+  `On<...>` handlers. `OpenInteractiveTerminalAsync` keeps name/signature.
+- Update hand-rolled `IWorkerClient` fakes in **both** Ui.Tests and Worker.Tests.
+
+## Task 7 — StreamLineFormatter user bubble (ui)
+- Render `type:"user"` NDJSON events as `LogKind.User` (add the kind if missing).
+- Test: a `user` event yields a `LogKind.User` `LogLineViewModel` with the text.
+
+## Task 8 — Shared composer state on the session VMs (ui, hot files)
+- Add to `TaskMonitorViewModel` and `DetailsIslandViewModel` (factor a shared helper —
+  `InteractiveComposer` — to avoid duplication): `ComposerDraft`, `IsInteractiveLive`
+  (toggled by `InteractiveSessionStarted/Ended` for the subscribed task),
+  `SubmitComposerCommand` (CanExecute: non-empty draft && (`HasPendingQuestion` ||
+  `IsInteractiveLive`)). Route: pending question → existing `AnswerTaskQuestionAsync`; else →
+  `SendInteractiveMessageAsync`. Clear draft on submit; clear `IsInteractiveLive` on ended.
+- `MissionControlViewModel`: `EnsureMonitor(taskId)` on `InteractiveSessionStarted`.
+- Test: composer enabled while interactive-live; submit routes (chat vs answer) + clears;
+  ended clears live state.
+
+## Task 9 — SessionTerminalView composer (ui)
+- `Views/Islands/SessionTerminalView.axaml(.cs)`: optional composer docked bottom (styled
+  props `IsComposerVisible`, `ComposerText`, `SubmitCommand`, `ComposerPlaceholder`); TextBox
+  (Enter submits) + Send button. Reuse existing tokens (no inline values).
+- Bind it in `MonitorPaneView.axaml` and `DetailsIslandView.axaml` to each VM's composer
+  state. Fold the existing AskUser banner into the composer's "answering" state if it reads
+  cleaner; otherwise leave the banner and add the composer below.
+
+## Task 10 — Localization
+- `en.json` + `de.json`: `interactive.composer.placeholder`, `.send`, `.stop`, plus any
+  "session ended" notice. Keep parity (Localization.Tests).
+
+## Task 11 — Build + test + verify
+- Build App + Worker `-c Release`; run Worker.Tests, Ui.Tests, Localization.Tests.
+- Self-review diffs. **Manual smoke (real CLI) — flag to Mika:** (a) Run interactively opens
+  an in-app chat (no terminal) and streams; (b) sending a message mid-turn interrupts +
+  redirects; (c) stop kills the process; (d) session shows in both task detail and Mission
+  Control. Do not push.

docs/superpowers/specs/2026-06-19-feature-unification-design.md

@@ -0,0 +1,91 @@
+# Feature unification — one component per feature
+
+Date: 2026-06-19
+
+## Goal
+
+ClaudeDo grew organically; several features now exist as parallel implementations
+or are reachable through many hand-wired entry points. This design maps the
+duplication and defines a target where **each feature is one component**, reached
+through one path, with dead code removed.
+
+## Method
+
+Mapped via five parallel exploration agents (merge/conflict, review→merge,
+diff+worktree, task create/edit, UI entry-point inventory), then verified the
+load-bearing claims by grep/read before writing this. Every file:line below was
+confirmed against the working tree on 2026-06-19.
+
+## Key finding: it is NOT three merge engines
+
+There is **one** merge engine (`TaskMergeService`), wrapped **once** for multi-child
+units (`PlanningMergeOrchestrator`), with **one** conflict resolver (the Rider
+3-pane). `Worker/CLAUDE.md` already records "there is no separate 'Merge all' entry —
+approve is the single review+merge action." What *looks* like 2–3 merge features is
+**entry-point sprawl** in the UI plus **one dead hunks-API** left over from the
+Layer-C rework. So unification is mostly UI plumbing + deletion, not re-architecting
+the engine.
+
+## Findings — three buckets
+
+### Bucket A — genuine duplication (parallel implementations of one job)
+
+| # | Feature | Duplicated components | Shared already |
+|---|---|---|---|
+| A1 | Diff viewing | `DiffModalViewModel` (worktree + commit-range), `WorktreeModalViewModel` (file-tree + per-file), `PlanningDiffViewModel` (per-subtask + integration) | `UnifiedDiffParser`, `DiffLinesView` (good) |
+| A2 | Agent-config editing | `ListSettingsModalViewModel` (list scope), `AgentSettingsSectionViewModel` (task scope); global lives in `SettingsModalViewModel` | `InheritanceResolver`, `InheritedBadge` (good) |
+| A3 | Worktree actions | `WorktreesOverviewModalViewModel` per-row cmds (Merge/Discard/Keep/ForceRemove/ShowDiff/Jump) vs `MergeSectionViewModel` (Merge/OpenDiff) | same `IWorkerClient` calls |
+| A4 | Merge display | `AgentStripView` re-displays `MergeSectionViewModel` state | — |
+
+### Bucket B — entry-point sprawl (one backend, many hand-wired doors)
+
+| # | Feature | Doors | Evidence |
+|---|---|---|---|
+| B1 | Conflict-resolution seam | 5 copies of `Func<string,string,Task>? RequestConflictResolution` | `WorktreesOverviewModalViewModel.cs:83`, `DiffModalViewModel.cs:75`, `MergeModalViewModel.cs:33`, `MergeSectionViewModel.cs:51`, `DetailsIslandViewModel.cs:347` (delegates). Threaded through `MainWindow.axaml.cs:81`, `IslandsShellViewModel.cs:49/202`, `DiffModalViewModel.cs:103`, `MergeSectionViewModel.cs:159` |
+| B2 | Diff (open) | 3–4 | MergeSection "Open Diff", TaskHeaderBar "Review Merged Diff", WorktreesOverview "Show Diff", Planning "Review Combined" |
+| B3 | List Settings dialog | 3 | Lists context menu, Tasks header button, shell bridge `IslandsShellViewModel.cs:190-194` |
+| B4 | Worktrees Overview | 2–3 | Repos menu (global), Lists context menu (per-list) |
+| B5 | Repo Import | 2 | Repos menu, Lists footer button |
+
+The conflict-resolution *target* is already single-point (`IslandsShellViewModel.RequestConflictResolutionAsync`, line 49). What is duplicated is the **seam plumbing**: five VMs each own the Func and it is threaded by hand.
+
+### Bucket C — dead / leftover
+
+| # | Item | Evidence |
+|---|---|---|
+| C1 | Dead hunks conflict API | `TaskMergeService.GetConflictsAsync` (`Lifecycle/TaskMergeService.cs:250`) ← `WorkerHub.GetMergeConflicts` (`Hub/WorkerHub.cs:378`) ← `WorkerClient` `"GetMergeConflicts"` (`Services/WorkerClient.cs:276`) ← `IWorkerClient`. Live resolver uses `GetMergeConflictDocuments` (`WorkerHub.cs:389`). Only `TaskMergeServiceTests.cs:672` still references the old one. |
+| C2 | Two task-creation paths | UI quick-add `TasksIslandViewModel.AddAsync` writes EF directly (`db.Tasks.Add`); MCP `ExternalMcpService.AddTask` is the service path. They can drift. |
+| C3 | Stale worktrees | `.claude/worktrees/feat+planning-sessions-ui/…` carries old copies of `DiffModalViewModel`/`ListSettingsModalViewModel`/`WorktreeModalViewModel`; layer-c resolver leftovers. Worktree hygiene, not main code. |
+| C4 | Naming drift (deferred) | Hub `StartConflictMerge`/`ContinueConflictMerge`/`AbortConflictMerge` (`WorkerHub.cs:367/405/414`) vs service `MergeAsync`/`ContinueMergeAsync`/`AbortMergeAsync`. **Documented as intentional** at `Worker/CLAUDE.md:153`. |
+
+## Targets — one component per feature
+
+1. **MergeCoordinator (B1).** Replace the five `RequestConflictResolution` Func seams with one injected coordinator exposing `MergeAsync(taskId, targetBranch)` that owns the "merge → on-conflict open resolver" sequence. Every door (review Approve, Diff Merge button, WorktreesOverview single + batch, Details merge section) calls it. The single resolution point (`IslandsShellViewModel.RequestConflictResolutionAsync`) becomes the coordinator's body.
+2. **DiffViewer (A1 + B2).** One `DiffViewerViewModel` + view with a `DiffSource` abstraction (`DirtyWorktree | BranchVsBase | CommitRange | PlanningAggregate | IntegrationBranch`) and an optional file-tree pane. Replaces `DiffModal` + `WorktreeModal` + `PlanningDiff` shells; keeps `UnifiedDiffParser`/`DiffLinesView`. All B2 doors open it with a different source.
+3. **WorktreeActions (A3).** One `WorktreeActionsViewModel` for a single task's worktree (merge/diff/discard/keep/force-remove), reused by both the overview rows and the Details merge section instead of each owning copies.
+4. **AgentConfigEditor (A2).** One editor component parameterized by scope (`Global | List | Task`) over `InheritanceResolver`, embedded in Settings, List Settings, and the Details panel. Collapses the duplicated property set + reset commands + badges.
+5. **DialogService (B3–B5).** Consolidate the per-modal `Show*` Func seams (`IslandsShellViewModel.cs:59-71`) into one `IDialogService` with typed open methods (`OpenListSettings(list)`, `OpenRepoImport()`, `OpenWorktreesOverview(listId?)`…). Menu, context menu, and footer all call the same method; duplicate command definitions across `ListsIsland`/shell collapse to one.
+6. **Single task-creation path (C2).** Route UI quick-add through the same creation path MCP `AddTask` uses (repository/service), so both honor the same invariants.
+
+Plus **C1** (delete dead hunks API + its test) and **C3** (prune stale worktrees) as groundwork. **C4** naming alignment is **deferred** — it is documented-intentional and would churn the hub + `WorkerClient` + every `IWorkerClient` fake (see the "fakes to sync" hazard) for cosmetic gain.
+
+## Decisions
+
+- **Phased, each phase ships green.** Six independently buildable/committable slices; cheapest and lowest-risk first (see the plan). No big-bang.
+- **One plan file per slice.** Matching the 2026-06-05 layer-A/B/C convention, each slice gets its own `docs/superpowers/plans/2026-06-19-unify-<slice>.md` authored when it is picked up. This umbrella plan sequences them and details Phase 0–1.
+- **DiffViewer (A1) is last.** Highest effort and most UX-sensitive (file-tree vs whole-unified are different layouts); deferring it lets the cheaper wins land first and de-risks the big one.
+- **Keep the merge engine and the resolver seam contract.** `TaskMergeService`, `PlanningMergeOrchestrator`, `ConflictResolverViewModel` ctor/`OpenAsync`/`OpenForPlanningAsync`/`CloseRequested` are unchanged — unification is above them.
+- **Naming alignment deferred, not done** (rationale above).
+
+## Out of scope / deferred
+
+- Hub/service merge-method renaming (C4).
+- Subtask deletion in the UI (a missing feature surfaced during mapping, not a duplicate).
+- Any DB migration, worker engine change, or push.
+
+## Acceptance (per phase)
+
+Each phase: `dotnet build -c Release` clean for touched projects; the relevant test
+project green; locales in parity (Localization.Tests) where keys change; the feature
+reachable through its single new path with the old doors removed or delegating. UI
+phases (2–5) flag a visual-verification gap for Mika to confirm in the running app.

docs/superpowers/specs/2026-06-23-worker-log-footer-overlay-design.md

@@ -0,0 +1,49 @@
+# Worker log → footer auto-route + Log Visualizer overlay
+
+**Date:** 2026-06-23
+**Status:** approved (design forks resolved with user)
+
+## Goal
+
+1. Auto-route **all Worker WARN/ERROR** Serilog events to the footer status strip (today only ~10 hand-curated business events reach it).
+2. Make the footer log line **clickable** → opens a **Log Visualizer overlay** showing the **last 30 min** of logs at **all levels**, color-coded.
+3. **Dedupe/rate-limit** the footer so repeating warnings (e.g. the current 60s OIDC-discovery failure) don't strobe.
+
+## Decisions (locked)
+
+- **Overlay source:** Worker-side **in-memory ring buffer** (30-min window, all levels), fetched via a hub call. No log-file parsing.
+- **Levels:** overlay shows INF/WRN/ERR; footer flashes **WARN/ERROR only**.
+- **Footer noise:** per-message dedupe within a rate-limit window (suppress the footer broadcast for an identical message seen recently; the event is still buffered for the overlay).
+
+## Architecture
+
+### Worker
+
+- **`LogRingBuffer`** (singleton, `Logging/`): thread-safe, time-bounded (`TimeSpan` window, default 30 min) + hard cap (e.g. 5000) ring of `WorkerLogRecord(Message, Level, TimestampUtc)`. Evicts on append by age + cap. `Snapshot()` returns newest-last.
+- **`BroadcastLogSink : Serilog.Core.ILogEventSink`** (`Logging/`): for every `LogEvent` —
+  - map level: Verbose/Debug/Information→`Info`, Warning→`Warn`, Error/Fatal→`Error`;
+  - render `msg = evt.RenderMessage()` (+ `": {ex.GetType().Name}: {ex.Message}"` first-line if `evt.Exception != null`);
+  - append to `LogRingBuffer` (all levels);
+  - if `Warn|Error` **and** not rate-limited: fire-and-forget `HubBroadcaster.WorkerLog(msg, level, evt.Timestamp.UtcDateTime)`.
+  - **Loop guard:** wrap the broadcast in try/catch and swallow; skip broadcasting events whose `SourceContext` is SignalR/connections plumbing (still buffered). Broadcasting must never itself log.
+  - **Dedupe/rate-limit:** dict `message → lastBroadcastUtc`; suppress footer broadcast if `now - last < RateLimitWindow` (const, 120 s). Periodic prune of the dict.
+- **DI wiring (chicken-egg):** `LogRingBuffer` + `BroadcastLogSink` are created as locals in `Program.cs` *before* `builder.Build()`, captured into `UseSerilog(... .WriteTo.Sink(broadcastSink))`, and registered as singletons. `HubBroadcaster` doesn't exist until post-build, so the sink starts detached; after `builder.Build()` we call `broadcastSink.Attach(app.Services.GetRequiredService<HubBroadcaster>())`. Buffering works from process start; broadcasting begins once attached.
+- **Hub:** `WorkerHub.GetRecentLogs() -> IReadOnlyList<WorkerLogRecordDto>` reads `LogRingBuffer.Snapshot()`. (Read-only, no auth beyond existing hub.)
+
+### UI
+
+- **IWorkerClient / WorkerClient:** add `Task<IReadOnlyList<WorkerLogEntry>> GetRecentLogsAsync(CancellationToken ct = default)`. ⚠ Update hand-rolled fakes in **both** test projects (StubWorkerClient + Worker.Tests UiVm fake).
+- **Footer:** wrap the worker-log `TextBlock` so it's clickable (Button, transparent) → `IslandsShellViewModel.OpenLogVisualizerCommand`. Existing `OnWorkerLogReceived` already routes the (now more numerous) `WorkerLog` broadcasts to the strip — **no change needed** for footer routing itself.
+- **`LogVisualizerViewModel`** (Modals/): on open, `GetRecentLogsAsync()` → `ObservableCollection<LogLineViewModel>` (msg, level→brush, HH:mm:ss). A level filter (All / Warn+Err) and a Refresh command. MVP = snapshot on open + Refresh; live-tail is a later nicety.
+- **`LogVisualizerView`** (Modals/): `ModalShell`-based dialog (consistent with other modals), shown via `IDialogService.ShowLogVisualizerAsync(vm)`. Small, scrollable, monospaced, color-coded lines.
+- **Localization:** new `vm.logVisualizer` (+ any view keys) in **en.json + de.json** (parity test enforces).
+
+## Out of scope / follow-ups
+
+- Live-tail while the overlay is open (snapshot + Refresh for MVP).
+- The **OIDC-discovery-every-60s failure** is a *separate* bug (Online Inbox enabled, `auth.kuns.dev` SSL fails). Dedupe tames the footer symptom; the root cause is tracked separately.
+
+## Tests
+
+- Worker: `LogRingBufferTests` (age + cap eviction, snapshot order), `BroadcastLogSinkTests` (level mapping; all levels buffered; only Warn/Err broadcast; dedupe suppresses repeat broadcast within window but still buffers; exception rendering; loop-guard source filter).
+- UI: `LogVisualizerViewModelTests` (loads from worker, populates, filter). Footer-click wiring smoke.

docs/superpowers/specs/2026-06-25-interactive-ask-user-design.md

@@ -0,0 +1,102 @@
+# Interactive "Answer Claude's Questions" — Design
+
+**Date:** 2026-06-25
+**Status:** Approved (brainstormed with Mika)
+
+## Goal
+
+Let the user answer a question Claude raises *mid-run* from inside Mission Control,
+without leaving the autonomous-execution model. Not a chat panel, not a terminal, not
+proactive steering — only: *Claude surfaces a question → the user types an answer → the
+run continues with that answer in context.*
+
+User decisions (brainstorm):
+- Scope: "I mostly want to answer his questions if he surfaces any."
+- Trigger: **any running task** may ask, with a **3-minute** answer window.
+
+## Why not the alternatives
+
+- **Embedded terminal / PTY** — would destroy the NDJSON contract the whole worker
+  pipeline depends on (StreamAnalyzer, token accounting, auto-commit, status flow) and
+  needs a terminal-emulator control Avalonia doesn't have. Rejected.
+- **Streaming-stdin (`--input-format stream-json`)** — right tool for a free-form chat,
+  overkill here. Rejected for v1.
+- **`--resume` per-turn** — already exists; not live (cold process per turn).
+
+## Mechanism
+
+The in-task MCP already blocks the `claude -p` process while a tool call is in flight.
+That blocking *is* the pause. Add one in-task MCP tool, `AskUser(question)`:
+
+1. The tool resolves the caller task id, registers a pending question + a
+   `TaskCompletionSource<string>` in a singleton `PendingQuestionRegistry`, and
+   broadcasts `TaskQuestionAsked(taskId, questionId, question)`.
+2. Mission Control surfaces the question with an input box.
+3. The user answers → `WorkerHub.AnswerTaskQuestion` resolves the TCS → the tool
+   returns the answer as its result → Claude continues.
+4. No answer within **3 minutes** → the tool returns *"No response received within 3
+   minutes — proceed using your best judgment."* and the run carries on autonomously.
+
+### Key facts that make this work
+
+- **No persisted status change.** The task is still genuinely `Running` (process alive,
+  blocked mid-tool-call). "Waiting for input" is **ephemeral**: in-memory registry +
+  live SignalR events + a UI overlay. No `TaskStatus` enum value, no `TaskStateService`
+  transition, **no EF migration**. If the worker dies mid-wait, `StaleTaskRecovery`
+  flips the orphaned `Running` row to `Failed` like any interrupted run.
+- **`MCP_TOOL_TIMEOUT` must be raised.** Claude Code caps HTTP MCP tool calls at **60 s**
+  by default. The `claudedo_run` MCP is HTTP, so `ClaudeProcess` must set
+  `MCP_TOOL_TIMEOUT=200000` (≈3 min + margin) on the spawned process or the 3-min window
+  is silently truncated to 60 s.
+- **MCP wired for all runs.** Today `TaskRunner` only mints the run MCP for standalone
+  top-level tasks (for `SuggestImprovement`). To satisfy "any running task," move the
+  MCP-identity setup out of that gate so every `RunAsync` gets `claudedo_run`.
+  `AllowedTools` always includes `mcp__claudedo_run__AskUser`; `SuggestImprovement` stays
+  gated to improvement-eligible (standalone) runs.
+
+## Surface changes
+
+**Worker (mostly new files):**
+- `Runner/PendingQuestionRegistry.cs` (new, singleton) — `Register`, `TryAnswer`, `Get`,
+  `Remove`; one pending question per task.
+- `Runner/TaskRunMcpService.cs` (edit) — add `AskUser` `[McpServerTool]`; inject the
+  registry.
+- `Runner/TaskRunner.cs` (edit) — wire MCP identity for all runs; add `AskUser` to
+  allowed tools.
+- `Runner/ClaudeProcess.cs` (edit) — set `MCP_TOOL_TIMEOUT` env.
+- `Hub/HubBroadcaster.cs` (edit) — `TaskQuestionAsked`, `TaskQuestionResolved`.
+- `Hub/WorkerHub.cs` (edit) — `AnswerTaskQuestion`, `GetPendingQuestion` + DTO.
+- `Program.cs` (edit) — register `PendingQuestionRegistry` singleton.
+- System prompt (edit) — one line telling Claude the tool exists and to use it only when
+  a wrong guess would be costly/irreversible (otherwise proceed).
+
+**UI:**
+- `Services/IWorkerClient.cs` + `WorkerClient.cs` (edit) — `AnswerTaskQuestionAsync`,
+  `GetPendingQuestionAsync`, `TaskQuestionAskedEvent`, `TaskQuestionResolvedEvent`.
+- `ViewModels/Islands/TaskMonitorViewModel.cs` (edit, **hot file**) — pending-question
+  state, `AnswerDraft`, `SubmitAnswerCommand`, clear on finish/resolve.
+- `ViewModels/MissionControlViewModel.cs` (edit) — hydrate pending question on attach.
+- `Views/MissionControl/MonitorPaneView.axaml` (edit, **hot file**) — additive
+  question/answer banner above the terminal.
+- `Localization/locales/en.json` + `de.json` — `missionControl.question.*` keys.
+
+**Tests:** `PendingQuestionRegistry` (answer/timeout/unknown/overwrite), `AskUser` tool
+(answer + timeout fallback, fake broadcaster — no real Claude), `TaskMonitorViewModel`
+(surface/submit/clear). Update IWorkerClient fakes in both test projects.
+
+## Concurrency note
+
+Two files (`TaskMonitorViewModel.cs`, `MonitorPaneView.axaml`) are also being touched by
+a concurrent Mission Control drag-and-drop session on the shared main tree. Keep edits
+additive, commit explicit paths only (never `git add -A`).
+
+## Verification gaps (manual)
+
+1. **Real-Claude smoke test** — confirm a blocking `AskUser` call survives ≥3 min with
+   `MCP_TOOL_TIMEOUT=200000` and that the model actually calls the tool when uncertain.
+2. **Visual** — the question banner + input box in the pane (Mika does the visual pass).
+
+## Non-goals
+
+Free-form chat panel; proactive steering; tool-permission prompts (stays `auto`);
+`ContinueAsync`/resumed runs gaining `AskUser` (deferred follow-up).

docs/superpowers/specs/2026-06-25-mission-control-design.md

@@ -0,0 +1,144 @@
+# Mission Control — multi-task live monitoring
+
+Date: 2026-06-25
+Status: approved (design); implementation not started
+
+## Problem
+
+The UI can observe only **one** running task at a time. `DetailsIslandViewModel` is hard 1:1
+(single `Task`, single `_subscribedTaskId`); selecting another task in the middle pane *replaces*
+what Details shows. Yet the worker runs several tasks concurrently (`MaxParallelExecutions`) and
+already broadcasts every task's live output to all clients keyed by `taskId`. So the user cannot
+watch multiple in-flight sessions, and monitoring blocks normal work (adding tasks, reviewing).
+
+## Goal
+
+Watch several running tasks at once **without** giving up the normal app. Requirements drawn from
+the brainstorm:
+
+- A **live console grid** — multiple full Claude output streams side by side.
+- Each pane also shows **task details, blocking reasons**, and a **navigation helper** to open the
+  monitored task in the main app.
+- Lives in a **separate, always-available window** so the main window stays fully usable (adding
+  tasks must never be blocked). Combines "full window" + "detachable".
+
+## Non-goals
+
+- No worker/SignalR changes. The broadcast layer is already N-capable (`TaskMessage(taskId,line)`,
+  `TaskStarted/Finished/Updated`, `GetActive()`). This is a UI/VM-only feature.
+- No second SignalR connection. The new window shares the existing singleton `IWorkerClient`.
+- No new merge/review engine. Review/merge stays in the main window's Details pane; Mission Control
+  is read-mostly (monitor + cancel + navigate).
+
+## Hard constraint: no duplicated components or features
+
+This feature is an **extract-and-reuse** exercise, not a rebuild. The single biggest risk is
+forking a second live-streaming/parsing/status implementation. The reuse map below is binding.
+
+### Reuse map (what already exists — use it, do not copy it)
+
+| Concern | Existing asset | Location | How Mission Control uses it |
+|---|---|---|---|
+| Live console body (log list, LIVE/DONE/FAILED chip, auto-scroll) | `SessionTerminalView` (StyledProps `Entries`, `Label`, `IsRunning/IsDone/IsFailed`) | `Views/Islands/SessionTerminalView.axaml(.cs)` | Bind a pane's `Entries`→its `Log`, status flags + label. **No new console control.** |
+| Log line model | `LogLineViewModel` + `LogKind` | `ViewModels/Islands/DetailsIslandViewModel.cs` (top) | Shared model — move to its own file so both consumers reference one type. |
+| Live stream parse/replay | `OnTaskMessage` / `AppendStdoutLine` / `FlushClaudeBuffer` / `ReplayLogFileAsync` + `StreamLineFormatter` + `ExpandUserPath` | private in `DetailsIslandViewModel.cs` | **Extract to `TaskMonitorViewModel`** (Phase 1). One streaming engine, two consumers. |
+| Status state machine | `AgentState` + `Is*` flags + `StatusToStateKey` / `FinishedStatusToStateKey` | `DetailsIslandViewModel.cs` | Extract into `TaskMonitorViewModel`. |
+| Outcome / roadblock split | `ApplyOutcome` + `RoadblockMarker` constant | `DetailsIslandViewModel.cs` | Extract into `TaskMonitorViewModel`. |
+| Status chip / terminal styling | `live-chip`, `terminal`, `log-*` style classes | `Design/IslandStyles.axaml` | Reuse the classes as-is. |
+| Add a new task | `TasksIslandViewModel.AddAsync` (`NewTaskTitle`, user-list only, direct `TaskRepository`) | `TasksIslandViewModel.cs:406` | Optional quick-add reuses this path; **must not** introduce a second insert path. |
+| Live task list | `IWorkerClient.GetActive()` + `TaskStarted/Finished` events | worker hub / `WorkerClient` | Populate the grid; add/remove panes. |
+| DI / singletons | `IslandsShellViewModel`, `DetailsIslandViewModel`, `IWorkerClient` all singletons | `App/Program.cs` | Register `MissionControlViewModel` singleton; inject existing singletons. |
+
+## Design
+
+### TaskMonitorViewModel (the reusable core — new, but carved out of DetailsIslandViewModel)
+
+One instance == one monitored task. Owns:
+
+- `Log` (`ObservableCollection<LogLineViewModel>`), the filtered `TaskMessageEvent` subscription
+  (by `taskId`), stdout buffering, and NDJSON replay from disk on attach.
+- `AgentState` + `Is*` flags; `SessionOutcome` / `Roadblocks` (the outcome split).
+- Lightweight display: `Title`, `TaskIdBadge`, `Model`, `TurnsText`, `TokensFormatted`,
+  diff add/del, elapsed.
+- `BlockingReason` (string/visible flag) derived from existing data: `BlockedByTaskId`
+  (planning/child chain), `WaitingForReview` / `WaitingForChildren` status, and roadblock markers.
+- Commands: `OpenInApp`, `Detach`, `Cancel`.
+- `IDisposable` — unsubscribes all worker events (mirror DetailsIslandViewModel.Dispose).
+
+`DetailsIslandViewModel` is refactored to **own one `TaskMonitorViewModel` (`public Monitor`)** and
+delegate streaming/status/outcome to it. Its heavy concerns (subtasks, attachments, editing, merge
+cockpit, review verbs, child outcomes, notes/prep modes) stay put. **Phase 1 must be a no-behavior-
+change refactor** — all existing Ui.Tests stay green.
+
+> Binding-surface decision (Phase 1): repoint `WorkConsole.axaml`'s Output-tab bindings that
+> reference streaming/status (`Log`, `IsRunning/IsDone/IsFailed`, `SessionOutcome`, `TurnsText`,
+> diff text, `Model`) to `Monitor.*`. `x:DataType` stays `DetailsIslandViewModel`; compiled bindings
+> handle the nested path. Review/merge/session bindings are untouched. Prefer repointing over adding
+> ~15 forwarding properties (one source of truth, no boilerplate).
+
+### MissionControlViewModel (new)
+
+- `ObservableCollection<TaskMonitorViewModel> Monitors`, keyed by `taskId`.
+- On open: seed from `GetActive()`. On `TaskStarted`: add a monitor. On `TaskFinished`: keep the
+  pane (so the final output stays readable) but flip its state; a "clear finished" action prunes them.
+- Adaptive layout signal (column count) from `Monitors.Count`:
+  `1→1col, 2→2col, 3–4→2col(2 rows), 5+→fixed-width panes, horizontal scroll`. Least-active panes
+  beyond a threshold collapse to a compact card (title + last line + chip), click to expand — this is
+  the readability fallback so we never render N unreadable slivers.
+- Optional `QuickAdd` (deferred within Phase 2): title + target user-list → the **same** creation
+  path as `TasksIslandViewModel.AddAsync` (shared method, not a copy).
+- Disposes every monitor on window close.
+
+### Windowing (new plumbing — thin)
+
+- `MissionControlWindow` (Avalonia `Window`) hosting `MissionControlView`; DataContext =
+  the singleton `MissionControlViewModel`.
+- No non-modal secondary-window precedent exists (all current dialogs use `ShowDialog(owner)`), so
+  this is genuinely new but small:
+  - Set `desktop.ShutdownMode = OnMainWindowClose` in `App.OnFrameworkInitializationCompleted` so
+    closing Mission Control never quits the app, and closing the main window does.
+  - Open via a **title-bar button in MainWindow** (toggle: show / focus-if-open). The window is
+    created lazily and hidden (not destroyed) on close so its monitors persist cheaply.
+  - Persist size/position (reuse the ui.config.json mechanism if present; otherwise defer).
+
+### MonitorPaneView (new view, reuses SessionTerminalView)
+
+```
+┌─ #142  Refactor auth module ───────── ● running ─┐   header: title, live chip, tok/turn/elapsed
+│  ⏱ 4m12s   ◆ 18.3k tok   ↻ turn 6                 │
+├───────────────────────────────────────────────────┤
+│ ⚠ Blocked: waiting on #141 (planning parent)      │   blocking banner (visible only when blocked)
+├───────────────────────────────────────────────────┤
+│  <SessionTerminalView Entries={Log} .../>          │   the REUSED console
+├───────────────────────────────────────────────────┤
+│  [↗ Open in app]   [⧉ Detach]   [✕ Cancel]        │   footer
+└───────────────────────────────────────────────────┘
+```
+
+### Navigation helper "Open in app" (new shell method)
+
+No select-by-id exists today. Add `IslandsShellViewModel.RevealTaskAsync(taskId)`:
+1. resolve the task's list, set `Lists.SelectedList`; 2. await `Tasks.LoadForList`; 3. find the row in
+`Tasks.Items` by id, set `Tasks.SelectedTask` (→ `Details.Bind`); 4. bring MainWindow to front.
+`TaskMonitorViewModel.OpenInApp` calls this. Single navigation entry point — no duplicate selection logic.
+
+### Detach (Phase 3)
+
+`Detach` moves a `TaskMonitorViewModel` out of the grid into a small `TaskMonitorWindow`
+(reuses `MonitorPaneView`), optionally always-on-top; closing it re-docks. Lowest priority.
+
+## Risks / open items
+
+- **Phase 1 binding repoint** is the main risk: a missed `WorkConsole` binding shows as a blank
+  field, not a build error. Mitigation: Ui.Tests + a manual visual pass on the Details pane.
+- **Localization parity** (Localization.Tests): every new visible string needs en + de keys under a
+  `missionControl.*` namespace.
+- **Quick-add coupling** across windows is the weakest part; kept optional/deferrable.
+- Detached windows = most plumbing, least daily payoff → Phase 3, last.
+
+## Verification
+
+- Build `ClaudeDo.App` + run Ui.Tests / Localization.Tests after each phase.
+- Manual visual pass (cannot be auto-verified): Details pane unchanged after Phase 1; grid populates
+  with 2+ concurrent tasks, blocking banner shows, Open-in-app surfaces the task, adding a task in the
+  main window works while Mission Control is open.

docs/superpowers/specs/2026-06-26-in-app-interactive-sessions-design.md

@@ -0,0 +1,147 @@
+# In-App Interactive Sessions — Design
+
+**Date:** 2026-06-26
+**Status:** Proposed (awaiting approval)
+
+## Goal
+
+Replace the external Windows-Terminal "Run interactively" session with an **in-app
+streaming chat**, rendered in the existing `SessionTerminalView` in **both task detail and
+Mission Control**. Keep everything inside the app — no `wt.exe` pop-out. Autonomous task
+execution is **untouched** (stays one-shot, non-interactive).
+
+## Decisions (brainstorm)
+
+1. **Engine: persistent streaming session.** One `claude` process kept alive with
+   `--input-format stream-json`; user messages pushed over stdin.
+2. **Scope: interactive sessions only.** The autonomous `TaskRunner`/`ClaudeProcess` run
+   loop, review, queue, and worktree machinery are NOT changed.
+3. **Placement: shared `SessionTerminalView`** — the in-app session + composer appear in the
+   task-detail session surface and in the Mission Control monitor pane.
+4. **Full replace.** "Run interactively" now opens the in-app session; the
+   `WindowsTerminalLauncher.LaunchInteractiveAsync` path is removed. **Planning** sessions
+   keep using `wt` (untouched).
+5. **Send semantics: interrupt + redirect** mid-turn (control protocol), with automatic
+   *queue-for-next-turn* fallback if interrupt is unavailable.
+
+## What an interactive session is (unchanged semantics, new transport)
+
+Today (`PlanningSessionManager.OpenInteractiveAsync` + `WindowsTerminalLauncher`):
+`claude --model <PlanningAlias> --permission-mode auto "<task title+description>"` in the
+**list's working dir**, env `MAX_THINKING_TOKENS=20000`, full default toolset, relies on the
+globally-registered `claudedo` MCP. **Ephemeral** — no worktree, no `task_run` record, no
+status change, no review.
+
+We keep all of that. Only the transport changes: instead of a `wt` window, the same
+`claude` invocation runs as a persistent stream-json process owned by the worker, its output
+streamed into the app and its stdin fed from an in-app composer.
+
+> Honest tradeoff: the `wt` terminal gave the full Claude Code TUI (slash-command UX,
+> interactive prompts). An in-app stream-json chat is plainer — type messages, watch streamed
+> output. `--permission-mode auto` means no blocking permission prompts (so headless works),
+> but it is a simpler surface than the real TUI. Accepted per the "full replace" decision.
+
+## The streaming engine
+
+Flags: `--model <PlanningAlias> --permission-mode auto --input-format stream-json
+--output-format stream-json --verbose --replay-user-messages` in the list working dir, env
+`MAX_THINKING_TOKENS=20000`. No `--mcp-config`/`--allowedTools` (interactive uses the global
+MCP + default tools, exactly as today).
+
+- First stdin message = the seeded interactive prompt:
+  `{"type":"user","message":{"role":"user","content":[{"type":"text","text":"…"}]},"parent_tool_use_id":null}\n`
+  (stdin stays open).
+- A stdout read task forwards each NDJSON line to a callback (→ broadcast + the session's log)
+  and detects `result` events (turn boundary; the process then idles for the next message).
+- `SendUserMessageAsync(text)` writes a user-message JSON line; if a turn is in flight, also
+  `InterruptAsync()` (control-protocol interrupt) so Claude pivots immediately. If interrupt
+  is unavailable, the message lands when the current turn ends → automatic queue fallback.
+- **Interrupt is verified working** (spike, 2026-06-26, CLI 2.1.191). Exact shape:
+  `{"type":"control_request","request_id":"<id>","request":{"subtype":"interrupt"}}` — no
+  `initialize` handshake needed; `control_response {"subtype":"success"}` confirms
+  synchronously; the same process then accepts the redirect and runs a fresh turn with
+  context intact.
+- **Interrupt artifact:** the aborted turn emits a `result` with `is_error=true,
+  subtype="error_during_execution"`. The session must treat an interrupt-induced result as
+  *"turn aborted, continue"* (drain the queued redirect), **not** as a session failure.
+  Tolerate the incidental `system:init`/`system:status`/`rate_limit_event`/hook events that
+  also appear in the stream.
+- `--replay-user-messages` echoes each sent message back on stdout as a `user` event, so it
+  rides the existing stream pipeline into the timeline (ordered + confirmed) with no extra
+  broadcast surface.
+- The session ends only when the **user stops it** (kill the process tree) — an interactive
+  session has no auto-finalize and never enters review. No queue slot is involved (it is
+  launched directly, not via the autonomous picker).
+
+## Surface changes
+
+**Worker**
+- `Runner/StreamingClaudeSession.cs` (new) — persistent process + send/interrupt/stop; reuse
+  the `ProcessStartInfo` shape + `MCP_TOOL_TIMEOUT` from `ClaudeProcess`; streams via a line
+  callback; `IsTurnInFlight`. Cancellation kills the tree.
+- `Runner/LiveSessionRegistry.cs` (new, singleton) — `taskId → StreamingClaudeSession`
+  (`Register`/`TryGet`/`Unregister`/`Stop`), mirrors `PendingQuestionRegistry`.
+- `Planning/InteractiveSessionService.cs` (new) — owns interactive lifecycle: `StartAsync(
+  taskId)` resolves the list working dir + seeded prompt (reuse `OpenInteractiveAsync`'s
+  body), spawns the session, registers it, wires output to `HubBroadcaster.TaskMessage`,
+  broadcasts `InteractiveSessionStarted`; `SendAsync(taskId, text)`; `StopAsync(taskId)` →
+  `InteractiveSessionEnded`.
+- `Planning/WindowsTerminalLauncher.cs` + `Planning/Interfaces/ITerminalLauncher.cs` — remove
+  `LaunchInteractiveAsync` (+ `InteractiveLaunchContext`). Planning start/resume stay.
+- `Hub/WorkerHub.cs` — `OpenInteractiveTerminalAsync` re-pointed to
+  `InteractiveSessionService.StartAsync` (no terminal); add `SendInteractiveMessage(taskId,
+  text)`, `StopInteractiveSession(taskId)` (+ optional `InterruptInteractiveSession`).
+- `Hub/HubBroadcaster.cs` — `InteractiveSessionStarted(taskId)`,
+  `InteractiveSessionEnded(taskId)`. Log lines reuse the existing `TaskMessage(taskId, line)`.
+- `Program.cs` — register `LiveSessionRegistry` + `InteractiveSessionService`.
+
+**UI**
+- `Views/Islands/SessionTerminalView.axaml(.cs)` — add an optional composer (styled
+  properties: `IsComposerVisible`, `ComposerText`, `SubmitCommand`, `ComposerPlaceholder`).
+  Both hosts (task detail + Mission Control) get it by binding their VM's composer state.
+- `StreamLineFormatter` — render `type:"user"` NDJSON events as a `LogKind.User` bubble.
+- A small shared composer concept on `TaskMonitorViewModel` **and** `DetailsIslandViewModel`
+  (factor a helper to avoid duplication): `ComposerDraft`, `SubmitComposerCommand`,
+  `IsInteractiveLive` (set by `InteractiveSessionStarted/Ended`). Submit →
+  `SendInteractiveMessageAsync`; clear draft. (If a pending AskUser question exists, the same
+  composer answers it — keep the existing answer route.)
+- `MissionControlViewModel` — `EnsureMonitor(taskId)` on `InteractiveSessionStarted` so the
+  session appears as a monitor; mark it interactive.
+- `Services/Interfaces/IWorkerClient.cs` + `WorkerClient.cs` — `SendInteractiveMessageAsync`,
+  `StopInteractiveSessionAsync` (+ optional interrupt); events
+  `InteractiveSessionStartedEvent`/`InteractiveSessionEndedEvent`. `OpenInteractiveTerminalAsync`
+  keeps its name/signature (now starts the in-app session). Update hand-rolled fakes in **both**
+  test projects (`iworkerclient_fakes_sync`).
+- `TasksIslandViewModel.RunInteractivelyAsync` — unchanged call site; now opens/focuses the
+  in-app session surface instead of a terminal.
+- Localization `interactive.*` / `missionControl.chat.*` (en/de, parity enforced).
+
+**Tests**
+- `StreamingClaudeSessionTests` (fake process stream, no real Claude): first message streams;
+  `result` idles; a sent message starts another turn; mid-turn send calls `InterruptAsync`
+  then delivers; interrupt-failure degrades to queue; stop kills.
+- `LiveSessionRegistryTests` — register/get/unregister/stop.
+- `InteractiveSessionServiceTests` — start resolves working dir + seeds prompt + registers +
+  broadcasts started; send routes to the session; stop broadcasts ended (fake session +
+  broadcaster).
+- `TaskMonitorViewModelTests` / `DetailsIslandViewModelTests` — composer enabled while
+  interactive-live; submit invokes client + clears; `user` line renders; question route still
+  answers.
+
+## Risks / open questions
+
+- **Interrupt protocol shape — RESOLVED** (spike 2026-06-26, see "The streaming engine").
+  Mid-turn interrupt works on CLI 2.1.191 with the documented shape; the queue fallback is a
+  genuine fallback now, not the expected path. Re-verify if the CLI version changes.
+- **Plainer than the TUI** — slash-command/interactive-prompt UX differs (accepted).
+- **Auto-mode editing the list working dir directly** (no worktree) — this is the *existing*
+  interactive behavior, unchanged here.
+- **No real-Claude tests** (project rule) — the live loop is covered only by the fake stream;
+  real interrupt/redirect is a **manual verification gap** to flag.
+
+## Non-goals
+
+- Changing autonomous task execution / review / queue / worktrees.
+- Interactive sessions producing run records, worktrees, or review (stays ephemeral).
+- Worktree isolation for interactive edits; image/attachment messages in the composer.
+- Removing planning's `wt` terminal launch.

src/ClaudeDo.App/App.axaml

@@ -21,6 +21,7 @@
             <converters:DotBrushConverter          x:Key="DotBrush"/>
             <converters:BoolToItalicConverter      x:Key="BoolToItalic"/>
             <converters:BoolToDraftOpacityConverter x:Key="BoolToDraftOpacity"/>
+            <converters:LogKindForegroundConverter  x:Key="LogKindForeground"/>
 
         </ResourceDictionary>
     </Application.Resources>

src/ClaudeDo.App/App.axaml.cs

@@ -1,5 +1,6 @@
 using System;
 using Avalonia;
+using Avalonia.Controls;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Markup.Xaml;
 using ClaudeDo.Ui.Services;
@@ -32,6 +33,10 @@ public partial class App : Application
 
             FocusClearing.Install();
 
+            // The main window is authoritative — closing it shuts the app down even if the
+            // modeless Mission Control window is still open.
+            desktop.ShutdownMode = ShutdownMode.OnMainWindowClose;
+
             desktop.MainWindow = new MainWindow
             {
                 DataContext = services.GetRequiredService<IslandsShellViewModel>(),

src/ClaudeDo.App/CLAUDE.md

@@ -20,7 +20,7 @@ Desktop entry point for the ClaudeDo application. Configures DI, initializes the
 ## DI Registration Pattern
 
 - **Singletons**: `IDbContextFactory`, all Repositories, GitService, WorkerClient, `IReleaseClient`, `UpdateCheckService`, `IPrimeScheduleApi`/`WorkerPrimeScheduleApi`, `INotesApi`/`WorkerNotesApi`, `InstallerLocator` / `WorkerLocator`, the island VMs (`ListsIslandViewModel`, `TasksIslandViewModel`, `DetailsIslandViewModel`) and `IslandsShellViewModel` (the window's DataContext)
-- **Transients**: modal VMs (`SettingsModalViewModel`, `MergeModalViewModel`, `ListSettingsModalViewModel`, `RepoImportModalViewModel`, `WeeklyReportModalViewModel`, `WorktreeModalViewModel`, `WorktreesOverviewModalViewModel`, `PrimeClaudeTabViewModel`), several exposed as `Func<T>` factories for on-demand dialog creation; `ConflictResolverViewModel` via a `Func<string, ConflictResolverViewModel>` factory keyed by taskId (singleton factory, handed to `IslandsShellViewModel.ConflictResolverFactory`)
+- **Transients**: modal VMs (`SettingsModalViewModel`, `MergeModalViewModel`, `ListSettingsModalViewModel`, `RepoImportModalViewModel`, `WeeklyReportModalViewModel`, `DiffViewerViewModel`, `WorktreesOverviewModalViewModel`, `PrimeClaudeTabViewModel`), several exposed as `Func<T>` factories for on-demand dialog creation (`Func<DiffViewerViewModel>` for the diff viewer); `ConflictResolverViewModel` via a `Func<string, ConflictResolverViewModel>` factory keyed by taskId (singleton factory, handed to `IslandsShellViewModel.ConflictResolverFactory`)
 
 ## Notes
 

src/ClaudeDo.App/Program.cs

@@ -116,9 +116,13 @@ sealed class Program
             return new UpdateCheckService(releases, version);
         });
 
+        // Conflict-merge coordinator: single seam the shell wires to its resolver entry.
+        sc.AddSingleton<MergeCoordinator>();
+        sc.AddSingleton<IMergeCoordinator>(sp => sp.GetRequiredService<MergeCoordinator>());
+
         // ViewModels
-        sc.AddTransient<WorktreeModalViewModel>();
+        sc.AddTransient<DiffViewerViewModel>();
-        sc.AddTransient<Func<WorktreeModalViewModel>>(sp => () => sp.GetRequiredService<WorktreeModalViewModel>());
+        sc.AddTransient<Func<DiffViewerViewModel>>(sp => () => sp.GetRequiredService<DiffViewerViewModel>());
         sc.AddTransient<WorktreesOverviewModalViewModel>();
         sc.AddTransient<Func<WorktreesOverviewModalViewModel>>(sp => () => sp.GetRequiredService<WorktreesOverviewModalViewModel>());
         sc.AddSingleton<IPrimeScheduleApi, WorkerPrimeScheduleApi>();
@@ -152,12 +156,18 @@ sealed class Program
                 sp.GetRequiredService<IDbContextFactory<ClaudeDoDbContext>>(),
                 sp.GetRequiredService<IWorkerClient>(),
                 sp,
-                sp.GetRequiredService<INotesApi>()));
+                sp.GetRequiredService<INotesApi>(),
+                sp.GetRequiredService<IMergeCoordinator>()));
+        sc.AddSingleton<MissionControlViewModel>(sp =>
+            new MissionControlViewModel(
+                sp.GetRequiredService<IDbContextFactory<ClaudeDoDbContext>>(),
+                sp.GetRequiredService<IWorkerClient>()));
         sc.AddSingleton<IslandsShellViewModel>(sp =>
         {
             var shell = ActivatorUtilities.CreateInstance<IslandsShellViewModel>(sp);
             shell.ConflictResolverFactory =
                 sp.GetRequiredService<Func<string, ClaudeDo.Ui.ViewModels.Conflicts.ConflictResolverViewModel>>();
+            sp.GetRequiredService<MergeCoordinator>().Handler = shell.RequestConflictResolutionAsync;
             return shell;
         });
 

src/ClaudeDo.Data/AttachmentStore.cs

@@ -0,0 +1,85 @@
+namespace ClaudeDo.Data;
+
+public sealed class AttachmentStore
+{
+    private const long MaxBytes = 5 * 1024 * 1024; // 5 MB
+
+    private readonly string _root;
+
+    public AttachmentStore(string? root = null)
+        => _root = root ?? Paths.Expand("~/.todo-app/attachments");
+
+    public string Root => _root;
+
+    public IReadOnlyList<string> EnumerateTaskIds()
+    {
+        if (!Directory.Exists(_root)) return Array.Empty<string>();
+        return Directory.GetDirectories(_root)
+            .Select(Path.GetFileName)
+            .Where(n => n is not null)
+            .Select(n => n!)
+            .ToList();
+    }
+
+    public string TaskDir(string taskId)
+        => Path.Combine(_root, taskId);
+
+    public async Task<long> SaveAsync(string taskId, string fileName, Stream content, CancellationToken ct = default)
+    {
+        if (Path.GetFileName(fileName) != fileName)
+            throw new ArgumentException("fileName must not contain path separators or '..'.", nameof(fileName));
+
+        var dir = TaskDir(taskId);
+        var resolvedPath = Path.GetFullPath(Path.Combine(dir, fileName));
+
+        // Containment guard: resolved path must stay inside TaskDir
+        var resolvedDir = Path.GetFullPath(dir);
+        if (!resolvedPath.StartsWith(resolvedDir + Path.DirectorySeparatorChar, StringComparison.Ordinal)
+            && !resolvedPath.Equals(resolvedDir, StringComparison.Ordinal))
+            throw new ArgumentException("fileName resolves outside the task directory.", nameof(fileName));
+
+        Directory.CreateDirectory(dir);
+
+        // Buffer up to MaxBytes + 1 to detect oversize without reading fully
+        await using var fs = new FileStream(resolvedPath, FileMode.Create, FileAccess.Write, FileShare.None,
+            bufferSize: 81920, useAsync: true);
+
+        var buffer = new byte[81920];
+        long total = 0;
+        int read;
+        while ((read = await content.ReadAsync(buffer, ct)) > 0)
+        {
+            total += read;
+            if (total > MaxBytes)
+            {
+                fs.Close();
+                try { File.Delete(resolvedPath); } catch { }
+                throw new InvalidOperationException($"Attachment exceeds the 5 MB size limit.");
+            }
+            await fs.WriteAsync(buffer.AsMemory(0, read), ct);
+        }
+
+        return total;
+    }
+
+    public void DeleteFile(string taskId, string fileName)
+    {
+        if (Path.GetFileName(fileName) != fileName)
+            return; // traversal attempt — ignore silently
+
+        var dir = TaskDir(taskId);
+        var resolvedPath = Path.GetFullPath(Path.Combine(dir, fileName));
+        var resolvedDir = Path.GetFullPath(dir);
+        if (!resolvedPath.StartsWith(resolvedDir + Path.DirectorySeparatorChar, StringComparison.Ordinal)
+            && !resolvedPath.Equals(resolvedDir, StringComparison.Ordinal))
+            return; // containment violation — ignore silently
+
+        try { File.Delete(resolvedPath); } catch (DirectoryNotFoundException) { } catch (FileNotFoundException) { }
+    }
+
+    public void DeleteTaskDir(string taskId)
+    {
+        var dir = TaskDir(taskId);
+        try { Directory.Delete(dir, recursive: true); } catch (DirectoryNotFoundException) { } catch (IOException) { }
+    }
+}

src/ClaudeDo.Data/CLAUDE.md

@@ -12,6 +12,7 @@ Shared data layer: models, repositories, SQLite infrastructure, and git operatio
 - **PrimeScheduleEntity** — Id, Days (`[Flags] PrimeDays` weekday bitmask, stored as `days_of_week` int), TimeOfDay, Enabled, LastRunAt, PromptOverride, CreatedAt. Recurs on the selected weekdays; no date range.
 - **DailyNoteEntity** — Id, Date (DateOnly), Text, SortOrder, CreatedAt → table `daily_notes`
 - **WeekReportEntity** — Id, StartDate/EndDate (DateOnly), Markdown, GeneratedAt → table `week_reports`, unique index on (start_date, end_date)
+- **TaskAttachmentEntity** — Id, TaskId (FK to tasks, ON DELETE CASCADE), FileName, ByteSize, CreatedAt → table `task_attachments`
 - **AppSettingsEntity** also carries `ReportExcludedPaths` (string?, JSON array of excluded path prefixes, column `report_excluded_paths`), `StandupWeekday` (int DayOfWeek, default Wednesday, column `standup_weekday`), and `DailyPrepMaxTasks` (int, default 5, column `daily_prep_max_tasks` — hard cap on how many open tasks the daily-prep / "Prime Claude" feature may place in MyDay)
 - **SubtaskEntity**, **AppSettingsEntity**, **AgentInfo** — existing helpers / settings / record for scanned agent files
 
@@ -25,6 +26,7 @@ All repositories use EF Core LINQ queries via `ClaudeDoDbContext`. The atomic `Q
 - **TaskRunRepository**, **SubtaskRepository**, **AppSettingsRepository**
 - **DailyNoteRepository** — `ListByDayAsync`, `ListBetweenAsync`, `AddAsync`, `UpdateAsync`, `DeleteAsync`
 - **WeekReportRepository** — `GetByRangeAsync`, `UpsertAsync`
+- **TaskAttachmentRepository** — `AddAsync`, `UpdateAsync`, `GetAsync(taskId, fileName)`, `ListByTaskIdAsync`, `DeleteAsync(taskId, fileName)`, `DeleteAllForTaskAsync`
 
 ## Infrastructure
 
@@ -32,14 +34,15 @@ All repositories use EF Core LINQ queries via `ClaudeDoDbContext`. The atomic `Q
 - **IDbContextFactory<ClaudeDoDbContext>** — registered in DI; used by singleton consumers (e.g. Worker hosted service)
 - **Paths** — expands `~` and `%USERPROFILE%`, resolves relative paths. App root: `~/.todo-app`
 - **AppSettings** — loads `~/.todo-app/ui.config.json` (DbPath, SignalRUrl)
+- **AttachmentStore** — dependency-free file store; default root `~/.todo-app/attachments/<taskId>/`. `SaveAsync` enforces a 5 MB cap and path-traversal/containment guard. Also exposes `DeleteFile`, `DeleteTaskDir`, `TaskDir`, `Root`, and `EnumerateTaskIds` (used by the worker orphan sweep). Attachment files live outside git worktrees intentionally.
 
 ## Git
 
-- **GitService** — async wrapper around git CLI (ProcessStartInfo, no shell). Worktree ops (add — serialized to avoid a commondir race —, remove, prune, list paths for branch), branch ops (current, list local, checkout, delete), staging/commit (status porcelain, add-all, add-path, commit via stdin), diffs (working tree, branch vs base, commit range `base..head` — used to show a merged task's diff after the worktree is gone —, per-file, diff-stat, committed files, has-changes), merge (ff-only, no-ff, abort, mid-merge detection, conflicted files, show-stage for conflict hunks), `PreviewMergeAsync` (non-destructive mergeability check via `git merge-tree --write-tree`), `CountChangedFilesAsync`, rev-parse, is-git-repo
+- **GitService** — async wrapper around git CLI (ProcessStartInfo, no shell). Worktree ops (add — serialized to avoid a commondir race —, remove, prune, list paths for branch), branch ops (current, list local, checkout, delete), staging/commit (status porcelain, add-all, add-path, commit via stdin), diffs (working tree, branch vs base, commit range `base..head` — used to show a merged task's diff after the worktree is gone —, per-file, diff-stat, committed files, has-changes), merge (ff-only, no-ff, abort, mid-merge detection, conflicted files), `PreviewMergeAsync` (non-destructive mergeability check via `git merge-tree --write-tree`), `CountChangedFilesAsync`, rev-parse, is-git-repo
 
 ## Schema
 
-Tables: `lists`, `tasks`, `worktrees`, `list_config`, `task_runs`, `subtasks`, `app_settings`, `prime_schedules`, `daily_notes`, `week_reports`. Managed by EF Core migrations in the `Migrations/` folder. The `tasks` table holds `status`, `planning_phase` (default `none`), and `blocked_by_task_id` (FK to `tasks.id`, `ON DELETE SET NULL`). Migration `WeeklyReport` added `daily_notes`, `week_reports`, and the two new `app_settings` columns. Migration `DailyPrepMaxTasks` added the `daily_prep_max_tasks` column to `app_settings` (no new tables).
+Tables: `lists`, `tasks`, `worktrees`, `list_config`, `task_runs`, `subtasks`, `app_settings`, `prime_schedules`, `daily_notes`, `week_reports`, `task_attachments`. Managed by EF Core migrations in the `Migrations/` folder. The `tasks` table holds `status`, `planning_phase` (default `none`), and `blocked_by_task_id` (FK to `tasks.id`, `ON DELETE SET NULL`). Migration `WeeklyReport` added `daily_notes`, `week_reports`, and the two new `app_settings` columns. Migration `DailyPrepMaxTasks` added the `daily_prep_max_tasks` column to `app_settings` (no new tables). Migration `AddTaskAttachments` created the `task_attachments` table. `TaskRepository.DeleteAsync` and `ListRepository.DeleteAsync` also delete the on-disk attachment dir(s) via an optional `AttachmentStore` ctor param (defaults to the production store).
 
 ## Conventions
 

src/ClaudeDo.Data/ClaudeDoDbContext.cs

@@ -46,6 +46,7 @@ public class ClaudeDoDbContext : DbContext
     public DbSet<WorktreeEntity> Worktrees => Set<WorktreeEntity>();
     public DbSet<TaskRunEntity> TaskRuns => Set<TaskRunEntity>();
     public DbSet<SubtaskEntity> Subtasks => Set<SubtaskEntity>();
+    public DbSet<TaskAttachmentEntity> TaskAttachments => Set<TaskAttachmentEntity>();
     public DbSet<AppSettingsEntity> AppSettings => Set<AppSettingsEntity>();
     public DbSet<PrimeScheduleEntity> PrimeSchedules => Set<PrimeScheduleEntity>();
     public DbSet<DailyNoteEntity> DailyNotes => Set<DailyNoteEntity>();

src/ClaudeDo.Data/Configuration/TaskAttachmentEntityConfiguration.cs

@@ -0,0 +1,27 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ClaudeDo.Data.Configuration;
+
+public class TaskAttachmentEntityConfiguration : IEntityTypeConfiguration<TaskAttachmentEntity>
+{
+    public void Configure(EntityTypeBuilder<TaskAttachmentEntity> builder)
+    {
+        builder.ToTable("task_attachments");
+
+        builder.HasKey(a => a.Id);
+        builder.Property(a => a.Id).HasColumnName("id");
+        builder.Property(a => a.TaskId).HasColumnName("task_id").IsRequired();
+        builder.Property(a => a.FileName).HasColumnName("file_name").IsRequired();
+        builder.Property(a => a.ByteSize).HasColumnName("byte_size").IsRequired();
+        builder.Property(a => a.CreatedAt).HasColumnName("created_at").IsRequired();
+
+        builder.HasOne(a => a.Task)
+            .WithMany()
+            .HasForeignKey(a => a.TaskId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasIndex(a => a.TaskId).HasDatabaseName("idx_task_attachments_task_id");
+    }
+}

src/ClaudeDo.Data/Git/GitService.cs

@@ -280,17 +280,6 @@ public sealed class GitService
             .ToList();
     }
 
-    /// <summary>
-    /// Reads a conflicted file's blob at a merge stage: 1=base, 2=ours, 3=theirs.
-    /// Returns null when the stage doesn't exist (e.g. add/add conflict has no base).
-    /// Output is NOT trimmed so file content round-trips exactly.
-    /// </summary>
-    public async Task<string?> ShowStageAsync(string repoDir, int stage, string path, CancellationToken ct = default)
-    {
-        var (exitCode, stdout, _) = await RunGitAsync(repoDir, ["show", $":{stage}:{path}"], ct, trimOutput: false);
-        return exitCode == 0 ? stdout : null;
-    }
-
     public async Task AddPathAsync(string repoDir, string path, CancellationToken ct = default)
     {
         var (exitCode, _, stderr) = await RunGitAsync(repoDir, ["add", "--", path], ct);

src/ClaudeDo.Data/Migrations/20260622150934_AddTaskAttachments.Designer.cs

@@ -0,0 +1,739 @@
+// <auto-generated />
+using System;
+using ClaudeDo.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    [DbContext(typeof(ClaudeDoDbContext))]
+    [Migration("20260622150934_AddTaskAttachments")]
+    partial class AddTaskAttachments
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.11");
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.AppSettingsEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<string>("CentralWorktreeRoot")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("central_worktree_root");
+
+                    b.Property<int>("DailyPrepMaxTasks")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(5)
+                        .HasColumnName("daily_prep_max_tasks");
+
+                    b.Property<string>("DefaultClaudeInstructions")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("")
+                        .HasColumnName("default_claude_instructions");
+
+                    b.Property<int>("DefaultMaxTurns")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(30)
+                        .HasColumnName("default_max_turns");
+
+                    b.Property<string>("DefaultModel")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sonnet")
+                        .HasColumnName("default_model");
+
+                    b.Property<string>("DefaultPermissionMode")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("bypassPermissions")
+                        .HasColumnName("default_permission_mode");
+
+                    b.Property<int>("MaxParallelExecutions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1)
+                        .HasColumnName("max_parallel_executions");
+
+                    b.Property<string>("RepoImportFolders")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("repo_import_folders");
+
+                    b.Property<string>("ReportExcludedPaths")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("report_excluded_paths");
+
+                    b.Property<int>("StandupWeekday")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(3)
+                        .HasColumnName("standup_weekday");
+
+                    b.Property<int>("WorktreeAutoCleanupDays")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(7)
+                        .HasColumnName("worktree_auto_cleanup_days");
+
+                    b.Property<bool>("WorktreeAutoCleanupEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("worktree_auto_cleanup_enabled");
+
+                    b.Property<string>("WorktreeStrategy")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sibling")
+                        .HasColumnName("worktree_strategy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("app_settings", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            DailyPrepMaxTasks = 5,
+                            DefaultClaudeInstructions = "",
+                            DefaultMaxTurns = 100,
+                            DefaultModel = "sonnet",
+                            DefaultPermissionMode = "auto",
+                            MaxParallelExecutions = 1,
+                            StandupWeekday = 3,
+                            WorktreeAutoCleanupDays = 7,
+                            WorktreeAutoCleanupEnabled = false,
+                            WorktreeStrategy = "sibling"
+                        });
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.DailyNoteEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("note_date");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("sort_order");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.ToTable("daily_notes", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
+                {
+                    b.Property<string>("ListId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("list_id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<int?>("MaxTurns")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("max_turns");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.HasKey("ListId");
+
+                    b.ToTable("list_config", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DefaultCommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("default_commit_type");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<string>("WorkingDir")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("working_dir");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SortOrder")
+                        .HasDatabaseName("idx_lists_sort");
+
+                    b.ToTable("lists", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<int>("Days")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(31)
+                        .HasColumnName("days_of_week");
+
+                    b.Property<bool>("Enabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true)
+                        .HasColumnName("enabled");
+
+                    b.Property<DateTimeOffset?>("LastRunAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_run_at");
+
+                    b.Property<string>("PromptOverride")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt_override");
+
+                    b.Property<TimeSpan>("TimeOfDay")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time_of_day");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("prime_schedules", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("Completed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("completed");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<int>("OrderNum")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("order_num");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_subtasks_task_id");
+
+                    b.ToTable("subtasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<long>("ByteSize")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("byte_size");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("file_name");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_task_attachments_task_id");
+
+                    b.ToTable("task_attachments", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<string>("BlockedByTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("blocked_by_task_id");
+
+                    b.Property<string>("CommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("commit_type");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<bool>("IsMyDay")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_my_day");
+
+                    b.Property<bool>("IsStarred")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_starred");
+
+                    b.Property<string>("ListId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("list_id");
+
+                    b.Property<string>("LogPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("log_path");
+
+                    b.Property<int?>("MaxTurns")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("max_turns");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("notes");
+
+                    b.Property<string>("ParentTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("parent_task_id");
+
+                    b.Property<DateTime?>("PlanningFinalizedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_finalized_at");
+
+                    b.Property<string>("PlanningPhase")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("none")
+                        .HasColumnName("planning_phase");
+
+                    b.Property<string>("PlanningSessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_session_id");
+
+                    b.Property<string>("PlanningSessionToken")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_session_token");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result");
+
+                    b.Property<string>("ReviewFeedback")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("review_feedback");
+
+                    b.Property<int>("RoadblockCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("roadblock_count");
+
+                    b.Property<DateTime?>("ScheduledFor")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("scheduled_for");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("status");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockedByTaskId")
+                        .HasDatabaseName("idx_tasks_blocked_by");
+
+                    b.HasIndex("ListId")
+                        .HasDatabaseName("idx_tasks_list_id");
+
+                    b.HasIndex("ParentTaskId")
+                        .HasDatabaseName("idx_tasks_parent_task_id");
+
+                    b.HasIndex("Status")
+                        .HasDatabaseName("idx_tasks_status");
+
+                    b.HasIndex("ListId", "SortOrder")
+                        .HasDatabaseName("idx_tasks_list_sort");
+
+                    b.ToTable("tasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<string>("ErrorMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("error_markdown");
+
+                    b.Property<int?>("ExitCode")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("exit_code");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<bool>("IsRetry")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_retry");
+
+                    b.Property<string>("LogPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("log_path");
+
+                    b.Property<string>("Prompt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt");
+
+                    b.Property<string>("ResultMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result_markdown");
+
+                    b.Property<int>("RunNumber")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("run_number");
+
+                    b.Property<string>("SessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_id");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("StructuredOutputJson")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("structured_output");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<int?>("TokensIn")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("tokens_in");
+
+                    b.Property<int?>("TokensOut")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("tokens_out");
+
+                    b.Property<int?>("TurnCount")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("turn_count");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_task_runs_task_id");
+
+                    b.ToTable("task_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WeekReportEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("end_date");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("generated_at");
+
+                    b.Property<string>("Markdown")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("markdown");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("start_date");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StartDate", "EndDate")
+                        .IsUnique();
+
+                    b.ToTable("week_reports", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
+                {
+                    b.Property<string>("TaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("BaseCommit")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("base_commit");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("branch_name");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DiffStat")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("diff_stat");
+
+                    b.Property<string>("HeadCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("head_commit");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("path");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("active")
+                        .HasColumnName("state");
+
+                    b.HasKey("TaskId");
+
+                    b.ToTable("worktrees", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
+                        .WithOne("Config")
+                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("List");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany("Subtasks")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany()
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
+                        .WithMany()
+                        .HasForeignKey("BlockedByTaskId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
+                        .WithMany("Tasks")
+                        .HasForeignKey("ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentTaskId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("List");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany("Runs")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithOne("Worktree")
+                        .HasForeignKey("ClaudeDo.Data.Models.WorktreeEntity", "TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Navigation("Config");
+
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Navigation("Children");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Subtasks");
+
+                    b.Navigation("Worktree");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260622150934_AddTaskAttachments.cs

@@ -0,0 +1,48 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddTaskAttachments : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "task_attachments",
+                columns: table => new
+                {
+                    id = table.Column<string>(type: "TEXT", nullable: false),
+                    task_id = table.Column<string>(type: "TEXT", nullable: false),
+                    file_name = table.Column<string>(type: "TEXT", nullable: false),
+                    byte_size = table.Column<long>(type: "INTEGER", nullable: false),
+                    created_at = table.Column<DateTime>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_task_attachments", x => x.id);
+                    table.ForeignKey(
+                        name: "FK_task_attachments_tasks_task_id",
+                        column: x => x.task_id,
+                        principalTable: "tasks",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "idx_task_attachments_task_id",
+                table: "task_attachments",
+                column: "task_id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "task_attachments");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/ClaudeDoDbContextModelSnapshot.cs

@@ -294,6 +294,38 @@ namespace ClaudeDo.Data.Migrations
                     b.ToTable("subtasks", (string)null);
                 });
 
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<long>("ByteSize")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("byte_size");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("file_name");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_task_attachments_task_id");
+
+                    b.ToTable("task_attachments", (string)null);
+                });
+
             modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
                 {
                     b.Property<string>("Id")
@@ -625,6 +657,17 @@ namespace ClaudeDo.Data.Migrations
                     b.Navigation("Task");
                 });
 
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany()
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
             modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
                 {
                     b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)

src/ClaudeDo.Data/Models/TaskAttachmentEntity.cs

@@ -0,0 +1,13 @@
+namespace ClaudeDo.Data.Models;
+
+public sealed class TaskAttachmentEntity
+{
+    public required string Id { get; init; }
+    public required string TaskId { get; init; }
+    public required string FileName { get; set; }
+    public long ByteSize { get; set; }
+    public required DateTime CreatedAt { get; init; }
+
+    // Navigation property
+    public TaskEntity Task { get; set; } = null!;
+}

src/ClaudeDo.Data/PromptFiles.cs

@@ -105,9 +105,12 @@ public static class PromptFiles
         - Don't introduce injection/XSS/secret-leak issues. Never commit credentials.
 
         ## You are running unattended
-        You run autonomously with no human watching. There is no one to answer mid-task
+        You run autonomously, usually with no one watching. Default to making the most
-        questions, so never stop to ask — make the most reasonable decision, note the
+        reasonable decision yourself, noting the assumption, and continuing — do not stop
-        assumption, and continue.
+        for routine choices. The one exception: at a genuine fork where a wrong guess
+        would be costly or hard to undo (an irreversible action, contradictory
+        requirements), you may call AskUser(question) to ask the user and wait briefly for
+        an answer. If no one responds in time, proceed on your best judgment.
 
         ## When you are blocked
         If something genuinely prevents you from completing part of the task (missing

src/ClaudeDo.Data/Repositories/ListRepository.cs

@@ -6,8 +6,13 @@ namespace ClaudeDo.Data.Repositories;
 public sealed class ListRepository
 {
     private readonly ClaudeDoDbContext _context;
+    private readonly AttachmentStore _attachments;
 
-    public ListRepository(ClaudeDoDbContext context) => _context = context;
+    public ListRepository(ClaudeDoDbContext context, AttachmentStore? attachments = null)
+    {
+        _context = context;
+        _attachments = attachments ?? new AttachmentStore();
+    }
 
     public async Task AddAsync(ListEntity entity, CancellationToken ct = default)
     {
@@ -23,7 +28,13 @@ public sealed class ListRepository
 
     public async Task DeleteAsync(string listId, CancellationToken ct = default)
     {
+        var taskIds = await _context.Tasks
+            .Where(t => t.ListId == listId)
+            .Select(t => t.Id)
+            .ToListAsync(ct);
         await _context.Lists.Where(l => l.Id == listId).ExecuteDeleteAsync(ct);
+        foreach (var id in taskIds)
+            _attachments.DeleteTaskDir(id);
     }
 
     public async Task<ListEntity?> GetByIdAsync(string listId, CancellationToken ct = default)

src/ClaudeDo.Data/Repositories/TaskAttachmentRepository.cs

@@ -0,0 +1,51 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace ClaudeDo.Data.Repositories;
+
+public sealed class TaskAttachmentRepository
+{
+    private readonly ClaudeDoDbContext _context;
+
+    public TaskAttachmentRepository(ClaudeDoDbContext context) => _context = context;
+
+    public async Task AddAsync(TaskAttachmentEntity entity, CancellationToken ct = default)
+    {
+        _context.TaskAttachments.Add(entity);
+        await _context.SaveChangesAsync(ct);
+    }
+
+    public async Task<List<TaskAttachmentEntity>> ListByTaskIdAsync(string taskId, CancellationToken ct = default)
+    {
+        return await _context.TaskAttachments
+            .Where(a => a.TaskId == taskId)
+            .OrderBy(a => a.CreatedAt)
+            .ToListAsync(ct);
+    }
+
+    public async Task<TaskAttachmentEntity?> GetAsync(string taskId, string fileName, CancellationToken ct = default)
+    {
+        return await _context.TaskAttachments
+            .FirstOrDefaultAsync(a => a.TaskId == taskId && a.FileName == fileName, ct);
+    }
+
+    public async Task UpdateAsync(TaskAttachmentEntity entity, CancellationToken ct = default)
+    {
+        _context.TaskAttachments.Update(entity);
+        await _context.SaveChangesAsync(ct);
+    }
+
+    public async Task DeleteAsync(string taskId, string fileName, CancellationToken ct = default)
+    {
+        await _context.TaskAttachments
+            .Where(a => a.TaskId == taskId && a.FileName == fileName)
+            .ExecuteDeleteAsync(ct);
+    }
+
+    public async Task DeleteAllForTaskAsync(string taskId, CancellationToken ct = default)
+    {
+        await _context.TaskAttachments
+            .Where(a => a.TaskId == taskId)
+            .ExecuteDeleteAsync(ct);
+    }
+}

src/ClaudeDo.Data/Repositories/TaskRepository.cs

@@ -7,8 +7,13 @@ namespace ClaudeDo.Data.Repositories;
 public sealed class TaskRepository
 {
     private readonly ClaudeDoDbContext _context;
+    private readonly AttachmentStore _attachments;
 
-    public TaskRepository(ClaudeDoDbContext context) => _context = context;
+    public TaskRepository(ClaudeDoDbContext context, AttachmentStore? attachments = null)
+    {
+        _context = context;
+        _attachments = attachments ?? new AttachmentStore();
+    }
 
     #region CRUD
 
@@ -37,6 +42,7 @@ public sealed class TaskRepository
     public async Task DeleteAsync(string taskId, CancellationToken ct = default)
     {
         await _context.Tasks.Where(t => t.Id == taskId).ExecuteDeleteAsync(ct);
+        _attachments.DeleteTaskDir(taskId);
     }
 
     public async Task<TaskEntity?> GetByIdAsync(string taskId, CancellationToken ct = default)

src/ClaudeDo.Data/TaskPromptComposer.cs

@@ -9,7 +9,8 @@ namespace ClaudeDo.Data;
 /// </summary>
 public static class TaskPromptComposer
 {
-    public static string Compose(string title, string? description, IEnumerable<(string Title, bool Completed)> subtasks)
+    public static string Compose(string title, string? description, IEnumerable<(string Title, bool Completed)> subtasks,
+        IEnumerable<string>? attachmentPaths = null)
     {
         var sb = new StringBuilder((title ?? "").Trim());
 
@@ -24,6 +25,14 @@ public static class TaskPromptComposer
                 sb.Append("- [ ] ").Append(s.Title).Append('\n');
         }
 
+        var paths = attachmentPaths?.ToList();
+        if (paths is { Count: > 0 })
+        {
+            sb.Append("\n\n## Reference files\nThese files were attached to this task as read-only reference (they live outside the repo). Read them as needed:\n");
+            foreach (var p in paths)
+                sb.Append("- ").Append(p).Append('\n');
+        }
+
         return sb.ToString();
     }
 }

src/ClaudeDo.Installer/App.xaml.cs

@@ -38,104 +38,6 @@ public partial class App : Application
         var localizer = new Localizer(localeStore, initialLang);
         TrExtension.Localizer = localizer;
 
-        // --- Self-update pre-flight ---
-        // Resolve current exe path. Assembly.Location may point to a .dll for apphost-based
-        // .NET apps; swap to the .exe companion when that happens.
-        var currentExePath = Assembly.GetEntryAssembly()!.Location;
-        if (currentExePath.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
-        {
-            currentExePath = System.IO.Path.ChangeExtension(currentExePath, ".exe");
-        }
-
-        // Arg form: --replace-self "<old-path>"
-        var replaceSelfIndex = Array.FindIndex(e.Args, a => a.Equals("--replace-self", StringComparison.OrdinalIgnoreCase));
-        if (replaceSelfIndex >= 0 && replaceSelfIndex + 1 < e.Args.Length)
-        {
-            var oldPath = e.Args[replaceSelfIndex + 1];
-            var relaunched = await SelfUpdater.HandleReplaceSelfAsync(
-                oldPath: oldPath,
-                currentExePath: currentExePath,
-                launchProcess: path =>
-                {
-                    try
-                    {
-                        System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(path) { UseShellExecute = true });
-                        return true;
-                    }
-                    catch { return false; }
-                });
-            if (relaunched)
-            {
-                Shutdown(0);
-                return;
-            }
-            // Replacement failed — fall through to normal wizard from the temp location.
-        }
-        else
-        {
-            // Normal launch: check for a newer installer.
-            using var selfUpdateHttp = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
-            var selfUpdateReleases = new ReleaseClient(selfUpdateHttp);
-            var currentVersion = GetInstallerVersion();
-
-            var decision = await SelfUpdater.DecideUpdateAsync(selfUpdateReleases, currentVersion, CancellationToken.None);
-            if (decision.Kind == SelfUpdateDecisionKind.UpdateAvailable)
-            {
-                var prompt = new SelfUpdatePromptWindow(currentVersion, decision.LatestVersion!);
-                DarkTitleBar.Apply(prompt);
-                var ok = prompt.ShowDialog() == true;
-                if (!ok)
-                {
-                    Shutdown(0);
-                    return;
-                }
-                if (prompt.Choice == SelfUpdateChoice.Update)
-                {
-                    prompt.ShowProgress("Downloading...");
-                    var tempDir = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "ClaudeDo.Installer.Update");
-                    var verifiedPath = await SelfUpdater.DownloadAndVerifyAsync(
-                        selfUpdateReleases,
-                        decision.InstallerAsset!,
-                        decision.ChecksumsAsset!,
-                        tempDir,
-                        new Progress<long>(_ => { }),
-                        CancellationToken.None);
-
-                    if (verifiedPath is null)
-                    {
-                        MessageBox.Show(prompt,
-                            "Update download or verification failed. Continuing with current installer.",
-                            "ClaudeDo Installer", MessageBoxButton.OK, MessageBoxImage.Warning);
-                    }
-                    else
-                    {
-                        try
-                        {
-                            var psi = new System.Diagnostics.ProcessStartInfo(verifiedPath)
-                            {
-                                UseShellExecute = true,
-                            };
-                            psi.ArgumentList.Add("--replace-self");
-                            psi.ArgumentList.Add(currentExePath);
-                            System.Diagnostics.Process.Start(psi);
-                            Shutdown(0);
-                            return;
-                        }
-                        catch (Exception ex)
-                        {
-                            MessageBox.Show(prompt,
-                                "Failed to launch updated installer: " + ex.Message + "\nContinuing with current installer.",
-                                "ClaudeDo Installer", MessageBoxButton.OK, MessageBoxImage.Warning);
-                        }
-                    }
-                }
-                // SelfUpdateChoice.Continue — fall through to normal wizard.
-            }
-            // No-update or check failed — fall through to normal wizard.
-        }
-
-        // --- Existing wizard start-up unchanged below this line ---
-
         _services = BuildServices(localizer);
 
         var context = _services.GetRequiredService<InstallContext>();

src/ClaudeDo.Installer/CLAUDE.md

@@ -12,14 +12,22 @@ Note: this is the one project where `System.Windows` is correct (WPF, not Avalon
 - Entry point: `App.xaml` / `App.xaml.cs` (no `Program.cs`)
 - References: `ClaudeDo.Data`, `ClaudeDo.Releases`, `ClaudeDo.Localization`
 - Manifests: `app.manifest` (requireAdministrator, Release) / `app.debug.manifest` (asInvoker, Debug)
-- Only CLI arg: `--replace-self <old-path>` (self-update handoff)
+- No CLI args — mode is detected from `install.json` + the Gitea API
 
 ## Startup Sequence (`App.OnStartup`)
 
 1. Load locale
-2. Self-update preflight — `SelfUpdater.DecideUpdateAsync` checks Gitea API; if a newer installer exists, download + checksum verify + relaunch with `--replace-self <old-path>`
+2. Detect mode — `InstallModeDetector` reads `install.json` + Gitea API
-3. Detect mode — `InstallModeDetector` reads `install.json` + Gitea API
+3. Open `WizardWindow` (FreshInstall / Update) or `SettingsWindow` (Config)
-4. Open `WizardWindow` (FreshInstall / Update) or `SettingsWindow` (Config)
+
+The installer does **not** self-update. Each release ships a stable-named
+`ClaudeDo.Installer.exe` asset (permanent URL
+`…/releases/latest/download/ClaudeDo.Installer.exe`); the installer never checks for or
+replaces itself on launch. The in-app "Update" button relaunches the on-disk installer to
+run the app update — the installer binary itself only changes when the user downloads a
+fresh copy. App-update detection is unaffected: `WriteInstallManifestStep` records
+`ctx.InstalledVersion` (the release tag from `DownloadAndExtractStep`), which
+`InstallModeDetector` compares against the latest tag.
 
 ## Modes (`Core/InstallerMode.cs`)
 
@@ -56,8 +64,7 @@ Installer/
               Interfaces/ — IInstallStep + StepResult/StepStatus/StepProgress, IInstallerPage
   Pages/    — WelcomePage, PathsPage, ServicePage, UiSettingsPage, InstallPage
                (each: ViewModel + View.xaml)
-  Views/    — WizardWindow(+WizardViewModel), SettingsWindow(+SettingsViewModel),
+  Views/    — WizardWindow(+WizardViewModel), SettingsWindow(+SettingsViewModel)
-               SelfUpdatePromptWindow
 ```
 
 ## Key Step Behaviors

src/ClaudeDo.Installer/Steps/WriteUninstallRegistryStep.cs

@@ -26,9 +26,9 @@ public sealed class WriteUninstallRegistryStep : IInstallStep
         // the single-file temp extract is gone once this process exits.
         var sourceExe = Environment.ProcessPath
             ?? throw new InvalidOperationException("Cannot resolve running installer path.");
-        // In the self-update path the installer already runs from uninstaller/ (the
+        // When relaunched from the installed copy (e.g. the Apps & Features "Rerun
-        // --replace-self handoff put it there), so source == target and the copy would
+        // Installer" entry points at uninstaller/ClaudeDo.Installer.exe), source == target
-        // throw. Skip it; the binary is already in place.
+        // and the copy would throw. Skip it; the binary is already in place.
         var alreadyInPlace = string.Equals(
             Path.GetFullPath(sourceExe), Path.GetFullPath(targetExe), StringComparison.OrdinalIgnoreCase);
         if (!alreadyInPlace)

src/ClaudeDo.Installer/Views/SelfUpdatePromptWindow.xaml

@@ -1,26 +0,0 @@
-<Window x:Class="ClaudeDo.Installer.Views.SelfUpdatePromptWindow"
-        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        xmlns:loc="clr-namespace:ClaudeDo.Installer.Localization"
-        Title="ClaudeDo Installer Update"
-        Width="460" Height="200"
-        WindowStartupLocation="CenterScreen"
-        ResizeMode="NoResize"
-        Background="#1a1a1a" Foreground="#f0f0f0">
-    <Grid Margin="20">
-        <Grid.RowDefinitions>
-            <RowDefinition Height="Auto"/>
-            <RowDefinition Height="Auto"/>
-            <RowDefinition Height="*"/>
-            <RowDefinition Height="Auto"/>
-        </Grid.RowDefinitions>
-        <TextBlock Grid.Row="0" FontSize="16" FontWeight="SemiBold" Text="{loc:Tr installer.selfUpdate.heading}"/>
-        <TextBlock Grid.Row="1" Margin="0,8,0,0" TextWrapping="Wrap" x:Name="DetailText"/>
-        <TextBlock Grid.Row="2" Margin="0,12,0,0" TextWrapping="Wrap" Foreground="#a0a0a0" x:Name="ProgressText" Visibility="Collapsed"/>
-        <StackPanel Grid.Row="3" Orientation="Horizontal" HorizontalAlignment="Right">
-            <Button x:Name="UpdateBtn" Content="{loc:Tr installer.selfUpdate.update}" MinWidth="90" Margin="4,0" Padding="10,4" Click="UpdateBtn_Click" IsDefault="True"/>
-            <Button x:Name="ContinueBtn" Content="{loc:Tr installer.selfUpdate.continueAnyway}" MinWidth="140" Margin="4,0" Padding="10,4" Click="ContinueBtn_Click"/>
-            <Button x:Name="CancelBtn" Content="{loc:Tr installer.nav.cancel}" MinWidth="90" Margin="4,0" Padding="10,4" Click="CancelBtn_Click" IsCancel="True"/>
-        </StackPanel>
-    </Grid>
-</Window>

src/ClaudeDo.Installer/Views/SelfUpdatePromptWindow.xaml.cs

@@ -1,42 +0,0 @@
-using System.Windows;
-
-namespace ClaudeDo.Installer.Views;
-
-public enum SelfUpdateChoice { Update, Continue, Cancel }
-
-public partial class SelfUpdatePromptWindow : Window
-{
-    public SelfUpdateChoice Choice { get; private set; } = SelfUpdateChoice.Cancel;
-
-    public SelfUpdatePromptWindow(string currentVersion, string latestVersion)
-    {
-        InitializeComponent();
-        DetailText.Text = $"Installer v{latestVersion} is available (you are running v{currentVersion}). Update before continuing?";
-    }
-
-    public void ShowProgress(string text)
-    {
-        ProgressText.Text = text;
-        ProgressText.Visibility = Visibility.Visible;
-        UpdateBtn.IsEnabled = false;
-        ContinueBtn.IsEnabled = false;
-    }
-
-    private void UpdateBtn_Click(object sender, RoutedEventArgs e)
-    {
-        Choice = SelfUpdateChoice.Update;
-        DialogResult = true;
-    }
-
-    private void ContinueBtn_Click(object sender, RoutedEventArgs e)
-    {
-        Choice = SelfUpdateChoice.Continue;
-        DialogResult = true;
-    }
-
-    private void CancelBtn_Click(object sender, RoutedEventArgs e)
-    {
-        Choice = SelfUpdateChoice.Cancel;
-        DialogResult = false;
-    }
-}

src/ClaudeDo.Localization/locales/de.json

@@ -88,6 +88,14 @@
       "inheritedFromGlobal": "geerbt · Global",
       "overrideBadge": "überschrieben",
       "resetToInherited": "Auf geerbt zurücksetzen"
+    },
+    "agentEditor": {
+      "model": "Modell",
+      "maxTurns": "Max. Durchläufe",
+      "systemPrompt": "System-Prompt (angehängt)",
+      "promptPrepended": "Wird automatisch vorangestellt:",
+      "agentFile": "Agent-Datei",
+      "browse": "Durchsuchen..."
     }
   },
   "tasks": {
@@ -161,11 +169,6 @@
     "starTip": "Favorit",
     "agentSettingsTip": "Agent-Einstellungen",
     "agentSettingsHeading": "Agent-Einstellungen (Überschreibungen)",
-    "modelLabel": "Modell",
-    "maxTurnsLabel": "Max. Durchläufe",
-    "systemPromptLabel": "System-Prompt (angehängt)",
-    "systemPromptPrepended": "Wird automatisch vorangestellt:",
-    "agentFileLabel": "Agent-Datei",
     "mergeLabel": "MERGE",
     "mergeTargetLabel": "Merge-Ziel",
     "reviewCombinedDiff": "Kombiniertes Diff prüfen",
@@ -182,7 +185,22 @@
     "descriptionPlaceholder": "Aufgabendetails hinzufügen (Markdown unterstützt)...",
     "prepTitle": "Tagesvorbereitung",
     "planDay": "Tag planen",
-    "prepEmpty": "Heute noch keine Vorbereitung — klick Tag planen"
+    "prepEmpty": "Heute noch keine Vorbereitung — klick Tag planen",
+    "attachments": {
+      "sectionLabel": "ANHÄNGE",
+      "dropToAttach": "Zum Anhängen ablegen",
+      "addFile": "Datei hinzufügen…",
+      "removeTip": "Anhang entfernen",
+      "addedSummary": "✓ Hinzugefügt: {0} ({1} Datei(en))",
+      "overLimitError": "Konnte {0} nicht hinzufügen: {1}",
+      "invalidNameError": "Konnte {0} nicht hinzufügen: {1}",
+      "selectIdleTask": "Zuerst eine inaktive Aufgabe auswählen"
+    },
+    "sections": {
+      "description": "Beschreibung",
+      "steps": "Schritte",
+      "files": "Dateien"
+    }
   },
   "agent": {
     "stopTip": "Agent stoppen",
@@ -213,9 +231,43 @@
     "chipDone": "FERTIG",
     "chipFailed": "FEHLGESCHLAGEN",
     "reviewContinueTip": "Dieses Feedback senden und die Aufgabe erneut ausführen",
-    "reviewResetTip": "Alle Änderungen verwerfen und die Aufgabe auf Leerlauf zurücksetzen"
+    "reviewResetTip": "Alle Änderungen verwerfen und die Aufgabe auf Leerlauf zurücksetzen",
+    "composer": {
+      "placeholder": "Nachricht an die Sitzung…",
+      "send": "Senden",
+      "stop": "Sitzung beenden",
+      "interrupt": "Aktuellen Zug unterbrechen",
+      "queued": "Wartet — wird nach dem aktuellen Zug gesendet",
+      "unqueue": "Aus Warteschlange entfernen"
+    }
+  },
+  "missionControl": {
+    "openInApp": "In App öffnen",
+    "cancel": "Abbrechen",
+    "detach": "Abdocken",
+    "redock": "Andocken",
+    "windowTitle": "Mission Control",
+    "clearFinished": "Erledigte entfernen",
+    "empty": "Keine laufenden Aufgaben",
+    "settings": "Einstellungen",
+    "queue": "Warteschlange",
+    "blocked": "Blockiert",
+    "question": {
+      "title": "Claude fragt nach",
+      "placeholder": "Antwort eingeben…",
+      "send": "Senden"
+    }
   },
   "modals": {
+    "logVisualizer": {
+      "title": "WORKER-LOGS — LETZTE 30 MIN",
+      "warnErrorOnly": "Nur Warnungen & Fehler",
+      "refresh": "Aktualisieren",
+      "empty": "Keine Logs in den letzten 30 Minuten.",
+      "count": "{0} Einträge",
+      "footerHint": "logs",
+      "openTooltip": "Aktuelle Worker-Logs anzeigen"
+    },
     "about": {
       "title": "ÜBER",
       "version": "Version",
@@ -241,11 +293,7 @@
       "browse": "Durchsuchen...",
       "defaultCommitType": "Standard-Commit-Typ",
       "sectionAgent": "AGENT",
-      "resetAgentSettings": "Agent-Einstellungen zurücksetzen",
+      "resetAgentSettings": "Agent-Einstellungen zurücksetzen"
-      "model": "Modell",
-      "maxTurns": "Max. Durchläufe",
-      "systemPrompt": "System-Prompt (angehängt)",
-      "agentFile": "Agent-Datei"
     },
     "merge": {
       "title": "WORKTREE MERGEN",
@@ -265,9 +313,6 @@
       "binary": "Binärdatei — kein Text-Diff",
       "empty": "Kein Inhalt"
     },
-    "worktree": {
-      "title": "Worktree"
-    },
     "worktreesOverview": {
       "refresh": "Aktualisieren",
       "cleanupFinished": "Abgeschlossene aufräumen",
@@ -390,8 +435,6 @@
       "abort": "Diesen Merge abbrechen"
     },
     "diff": {
-      "windowTitle": "Planung — Kombiniertes Diff",
-      "modalTitle": "PLANUNG — KOMBINIERTES DIFF",
       "previewCombined": "Kombinierte Vorschau",
       "loading": "Wird geladen…"
     }
@@ -449,7 +492,7 @@
     "taskStatus": { "idle": "Leerlauf", "queued": "In Warteschlange", "running": "Läuft", "waitingForReview": "Wartet auf Prüfung", "waitingForChildren": "Wartet auf Verbesserungen", "done": "Fertig", "failed": "Fehlgeschlagen", "cancelled": "Abgebrochen", "parked": "Geparkt" },
     "planningBadge": { "active": "PLANUNG", "finalized": "GEPLANT" },
     "taskRow": { "createdPrefix": "Erstellt {0}", "stepsText": "{0}/{1} Schritte" },
-    "tasksIsland": { "completedHeader": "ABGESCHLOSSEN", "completedHeaderCount": "ABGESCHLOSSEN · {0}" },
+    "tasksIsland": { "completedHeader": "ABGESCHLOSSEN", "completedHeaderCount": "ABGESCHLOSSEN · {0}", "runInteractiveFailed": "Interaktiv ausführen fehlgeschlagen: {0}", "planningOpenFailed": "Planungssitzung konnte nicht geöffnet werden: {0}" },
     "diff": { "loadFailed": "Diff konnte nicht geladen werden: {0}", "noChanges": "Keine Änderungen anzuzeigen.", "unavailable": "Diff nicht mehr verfügbar — Commit-Bereich unvollständig." },
     "planningDiff": { "hubError": "Kombinierte Vorschau konnte nicht erstellt werden (Hub-Fehler).", "conflict": "Kombinierte Vorschau nicht möglich: Teilaufgabe {0} steht im Konflikt mit einer früheren Teilaufgabe ({1} Dateien)." },
     "merge": { "commitMessage": "Merge-Aufgabe: {0}", "workerOfflineBranches": "Worker offline — Branches können nicht aufgelistet werden.", "loadBranchesFailed": "Branches konnten nicht geladen werden: {0}", "merged": "Zusammengeführt.", "conflict": "Merge-Konflikt — Ziel-Branch wiederhergestellt. Manuell oder über Fortsetzen lösen, dann erneut versuchen.", "blocked": "Blockiert: {0}", "unknownStatus": "Unbekannter Status: {0}", "mergeFailed": "Merge fehlgeschlagen: {0}" },

src/ClaudeDo.Localization/locales/en.json

@@ -88,6 +88,14 @@
       "inheritedFromGlobal": "inherited · Global",
       "overrideBadge": "override",
       "resetToInherited": "Reset to inherited"
+    },
+    "agentEditor": {
+      "model": "Model",
+      "maxTurns": "Max turns",
+      "systemPrompt": "System prompt (appended)",
+      "promptPrepended": "Prepended automatically:",
+      "agentFile": "Agent file",
+      "browse": "Browse..."
     }
   },
   "tasks": {
@@ -161,11 +169,6 @@
     "starTip": "Star",
     "agentSettingsTip": "Agent settings",
     "agentSettingsHeading": "Agent settings (overrides)",
-    "modelLabel": "Model",
-    "maxTurnsLabel": "Max turns",
-    "systemPromptLabel": "System prompt (appended)",
-    "systemPromptPrepended": "Prepended automatically:",
-    "agentFileLabel": "Agent file",
     "mergeLabel": "MERGE",
     "mergeTargetLabel": "Merge target",
     "reviewCombinedDiff": "Review combined diff",
@@ -182,7 +185,22 @@
     "descriptionPlaceholder": "Add task details (markdown supported)...",
     "prepTitle": "Daily prep",
     "planDay": "Plan day",
-    "prepEmpty": "No prep run today yet — click Plan day"
+    "prepEmpty": "No prep run today yet — click Plan day",
+    "attachments": {
+      "sectionLabel": "ATTACHMENTS",
+      "dropToAttach": "Drop to attach",
+      "addFile": "Add file…",
+      "removeTip": "Remove attachment",
+      "addedSummary": "✓ Added {0} ({1} file(s))",
+      "overLimitError": "Could not add {0}: {1}",
+      "invalidNameError": "Could not add {0}: {1}",
+      "selectIdleTask": "Select an idle task first"
+    },
+    "sections": {
+      "description": "Description",
+      "steps": "Steps",
+      "files": "Files"
+    }
   },
   "agent": {
     "stopTip": "Stop agent",
@@ -213,9 +231,43 @@
     "chipDone": "DONE",
     "chipFailed": "FAILED",
     "reviewContinueTip": "Send this feedback and re-run the task",
-    "reviewResetTip": "Discard all changes and reset the task to Idle"
+    "reviewResetTip": "Discard all changes and reset the task to Idle",
+    "composer": {
+      "placeholder": "Message the session…",
+      "send": "Send",
+      "stop": "Stop session",
+      "interrupt": "Interrupt current turn",
+      "queued": "Queued — sends after the current turn",
+      "unqueue": "Remove from queue"
+    }
+  },
+  "missionControl": {
+    "openInApp": "Open in app",
+    "cancel": "Cancel",
+    "detach": "Detach",
+    "redock": "Re-dock",
+    "windowTitle": "Mission Control",
+    "clearFinished": "Clear finished",
+    "empty": "No running tasks",
+    "settings": "Settings",
+    "queue": "Queue",
+    "blocked": "Blocked",
+    "question": {
+      "title": "Claude is asking",
+      "placeholder": "Type your answer…",
+      "send": "Send"
+    }
   },
   "modals": {
+    "logVisualizer": {
+      "title": "WORKER LOGS — LAST 30 MIN",
+      "warnErrorOnly": "Warnings & errors only",
+      "refresh": "Refresh",
+      "empty": "No logs in the last 30 minutes.",
+      "count": "{0} entries",
+      "footerHint": "logs",
+      "openTooltip": "View recent worker logs"
+    },
     "about": {
       "title": "ABOUT",
       "version": "Version",
@@ -241,11 +293,7 @@
       "browse": "Browse...",
       "defaultCommitType": "Default commit type",
       "sectionAgent": "AGENT",
-      "resetAgentSettings": "Reset agent settings",
+      "resetAgentSettings": "Reset agent settings"
-      "model": "Model",
-      "maxTurns": "Max turns",
-      "systemPrompt": "System prompt (appended)",
-      "agentFile": "Agent file"
     },
     "merge": {
       "title": "MERGE WORKTREE",
@@ -265,9 +313,6 @@
       "binary": "Binary file — no text diff",
       "empty": "No content"
     },
-    "worktree": {
-      "title": "Worktree"
-    },
     "worktreesOverview": {
       "refresh": "Refresh",
       "cleanupFinished": "Cleanup finished",
@@ -390,8 +435,6 @@
       "abort": "Abort this merge"
     },
     "diff": {
-      "windowTitle": "Planning — Combined diff",
-      "modalTitle": "PLANNING — COMBINED DIFF",
       "previewCombined": "Preview combined",
       "loading": "Loading…"
     }
@@ -449,7 +492,7 @@
     "taskStatus": { "idle": "Idle", "queued": "Queued", "running": "Running", "waitingForReview": "Waiting for Review", "waitingForChildren": "Waiting for Improvements", "done": "Done", "failed": "Failed", "cancelled": "Cancelled", "parked": "Parked" },
     "planningBadge": { "active": "PLANNING", "finalized": "PLANNED" },
     "taskRow": { "createdPrefix": "Created {0}", "stepsText": "{0}/{1} steps" },
-    "tasksIsland": { "completedHeader": "COMPLETED", "completedHeaderCount": "COMPLETED · {0}" },
+    "tasksIsland": { "completedHeader": "COMPLETED", "completedHeaderCount": "COMPLETED · {0}", "runInteractiveFailed": "Run interactively failed: {0}", "planningOpenFailed": "Couldn't open planning session: {0}" },
     "diff": { "loadFailed": "Failed to load diff: {0}", "noChanges": "No changes to show.", "unavailable": "Diff no longer available — commit range incomplete." },
     "planningDiff": { "hubError": "Could not build combined preview (hub error).", "conflict": "Cannot build combined preview: subtask {0} conflicts with an earlier subtask ({1} files)." },
     "merge": { "commitMessage": "Merge task: {0}", "workerOfflineBranches": "Worker offline — cannot list branches.", "loadBranchesFailed": "Failed to load branches: {0}", "merged": "Merged.", "conflict": "Merge conflict — target branch restored. Resolve manually or via Continue, then retry.", "blocked": "Blocked: {0}", "unknownStatus": "Unknown status: {0}", "mergeFailed": "Merge failed: {0}" },

src/ClaudeDo.Releases/SelfUpdateResult.cs

@@ -1,15 +0,0 @@
-namespace ClaudeDo.Releases;
-
-public sealed record InstallerAssetMatch(ReleaseAsset Asset, string Version);
-
-public enum SelfUpdateDecisionKind
-{
-    NoUpdate,
-    UpdateAvailable,
-}
-
-public sealed record SelfUpdateDecision(
-    SelfUpdateDecisionKind Kind,
-    string? LatestVersion = null,
-    ReleaseAsset? InstallerAsset = null,
-    ReleaseAsset? ChecksumsAsset = null);

src/ClaudeDo.Releases/SelfUpdater.cs

@@ -1,126 +0,0 @@
-using System.IO;
-using System.Net.Http;
-using System.Text.RegularExpressions;
-
-namespace ClaudeDo.Releases;
-
-public static partial class SelfUpdater
-{
-    [GeneratedRegex(@"^ClaudeDo\.Installer-(?<version>[\d\.]+)\.exe$", RegexOptions.IgnoreCase)]
-    private static partial Regex InstallerAssetRegex();
-
-    public static InstallerAssetMatch? FindInstallerAsset(IEnumerable<ReleaseAsset> assets)
-    {
-        foreach (var asset in assets)
-        {
-            var m = InstallerAssetRegex().Match(asset.Name);
-            if (m.Success)
-            {
-                return new InstallerAssetMatch(asset, m.Groups["version"].Value);
-            }
-        }
-        return null;
-    }
-
-    public static async Task<SelfUpdateDecision> DecideUpdateAsync(
-        IReleaseClient releases,
-        string currentVersion,
-        CancellationToken ct)
-    {
-        GiteaRelease? release;
-        try
-        {
-            release = await releases.GetLatestReleaseAsync(ct);
-        }
-        catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException)
-        {
-            return new SelfUpdateDecision(SelfUpdateDecisionKind.NoUpdate);
-        }
-
-        if (release is null)
-            return new SelfUpdateDecision(SelfUpdateDecisionKind.NoUpdate);
-
-        var match = FindInstallerAsset(release.Assets);
-        if (match is null)
-            return new SelfUpdateDecision(SelfUpdateDecisionKind.NoUpdate);
-
-        var cmp = VersionComparer.Compare(match.Version, currentVersion);
-        if (!cmp.IsNewer)
-            return new SelfUpdateDecision(SelfUpdateDecisionKind.NoUpdate);
-
-        var checksums = release.Assets.FirstOrDefault(
-            a => string.Equals(a.Name, "checksums.txt", StringComparison.OrdinalIgnoreCase));
-
-        return new SelfUpdateDecision(
-            SelfUpdateDecisionKind.UpdateAvailable,
-            LatestVersion: match.Version,
-            InstallerAsset: match.Asset,
-            ChecksumsAsset: checksums);
-    }
-
-    public static async Task<bool> HandleReplaceSelfAsync(
-        string oldPath,
-        string currentExePath,
-        Func<string, bool> launchProcess,
-        int maxWaitMs = 5000)
-    {
-        var deadline = DateTime.UtcNow.AddMilliseconds(maxWaitMs);
-        while (DateTime.UtcNow < deadline)
-        {
-            try
-            {
-                if (File.Exists(oldPath))
-                {
-                    File.Delete(oldPath);
-                }
-                break;
-            }
-            catch (IOException)
-            {
-                await Task.Delay(100);
-            }
-            catch (UnauthorizedAccessException)
-            {
-                await Task.Delay(100);
-            }
-        }
-
-        if (File.Exists(oldPath))
-        {
-            return false;
-        }
-
-        File.Copy(currentExePath, oldPath, overwrite: false);
-        return launchProcess(oldPath);
-    }
-
-    public static async Task<string?> DownloadAndVerifyAsync(
-        IReleaseClient releases,
-        ReleaseAsset installerAsset,
-        ReleaseAsset checksumsAsset,
-        string tempDir,
-        IProgress<long> progress,
-        CancellationToken ct)
-    {
-        Directory.CreateDirectory(tempDir);
-        var installerPath = Path.Combine(tempDir, installerAsset.Name);
-        var checksumsPath = Path.Combine(tempDir, "checksums.txt");
-
-        try
-        {
-            await releases.DownloadAsync(installerAsset.BrowserDownloadUrl, installerPath, progress, ct);
-            await releases.DownloadAsync(checksumsAsset.BrowserDownloadUrl, checksumsPath, new Progress<long>(_ => { }), ct);
-        }
-        catch (Exception ex) when (ex is HttpRequestException or IOException or TaskCanceledException)
-        {
-            return null;
-        }
-
-        var checksumsText = await File.ReadAllTextAsync(checksumsPath, ct);
-        var map = ChecksumVerifier.ParseChecksumsFile(checksumsText);
-        if (!map.TryGetValue(installerAsset.Name, out var expected))
-            return null;
-
-        return ChecksumVerifier.Verify(installerPath, expected) ? installerPath : null;
-    }
-}

src/ClaudeDo.Ui/CLAUDE.md

@@ -19,33 +19,33 @@ ViewModels/
   IslandsShellViewModel.cs  — root coordinator
   Islands/    — ListsIsland, TasksIsland, DetailsIsland, TaskRow, ListNavItem,
                 NotesEditor, MergePreviewPresenter
-  Modals/     — About, Diff, ListSettings, Merge, RepoImport, Settings (+ Settings/ tab VMs),
+  Agent/      — AgentConfigEditorViewModel (scope-parameterized: List | Task)
-                UnfinishedPlanning, WeeklyReport, WorkerConnection, Worktree,
+  Modals/     — About, DiffViewer (+ DiffModels), ListSettings, Merge, RepoImport,
-                WorktreesOverview, UnifiedDiffParser
+                Settings (+ Settings/ tab VMs), UnfinishedPlanning, WeeklyReport,
-  Planning/   — PlanningDiffViewModel
+                WorkerConnection, WorktreesOverview, UnifiedDiffParser
   Conflicts/  — ConflictResolverViewModel + ConflictModels (MergeFile/MergeFileSegment/MergeConflictBlock)
 Views/        — mirrors the VM layout; Islands/Detail/ holds TaskHeaderBar,
                 DescriptionStepsCard, WorkConsole; plus AgentStripView, SessionTerminalView
-Views/Controls/ — MarkdownView, ModalShell, ThemedDatePicker, DiffLinesView, InheritedBadge
+Views/Controls/ — MarkdownView, ModalShell, ThemedDatePicker, DiffLinesView, InheritedBadge, AgentConfigEditor
 Design/     — Tokens.axaml (design tokens; merged before styles) + IslandStyles.axaml
               (component styles + the filled icon geometry library)
 ```
 
 ## ViewModels
 
-- **IslandsShellViewModel** — root coordinator; owns the three island VMs and the `WorkerClient`, wires cross-island events (selection, notes/prep mode, conflict resolution), owns connection state, the update banner, the inline worker-log strip, responsive-layout flags (`ShowLists`/`ShowDetails` by window width), `PrimeStatus` flash, and the modal openers (About, RepoImport, WeeklyReport, WorktreesOverview, WorkerConnection help) plus `RestartWorkerAsync`/`CheckForUpdatesAsync`. Hosts `UpdateCheckService`.
+- **IslandsShellViewModel** — root coordinator; owns the three island VMs and the `WorkerClient`, wires cross-island events (selection, notes/prep mode, conflict resolution), owns connection state, the update banner, the inline worker-log strip (clickable → Log Visualizer overlay via `OpenLogVisualizerCommand`; `FlashFooterError` surfaces UI-action failures + the worker's Serilog Warn/Error there), responsive-layout flags (`ShowLists`/`ShowDetails` by window width), `PrimeStatus` flash, and the modal openers (About, RepoImport, WeeklyReport, WorktreesOverview, WorkerConnection help, LogVisualizer) plus `RestartWorkerAsync`/`CheckForUpdatesAsync`. Hosts `UpdateCheckService`.
 - **ListsIslandViewModel** — smart lists (My Day, Important, Planned, virtual queued/running/review), user lists, selection, list CRUD, drag-reorder, badge counts, opens list settings / repo import / worktrees overview, `OpenInExplorer`/`OpenInTerminal`.
 - **TasksIslandViewModel** — open/overdue/completed groups for the selected list with hierarchy-aware regrouping; task CRUD, drag-reorder, toggle done/star, schedule, enqueue/dequeue, cancel; review actions (approve, reject-rerun, reject-park, cancel); planning session lifecycle (open/resume/discard/finalize, `QueuePlanningSubtasksAsync`); `RunInteractivelyAsync`, `RefineTask`; MyDay extras (`IsMyDayList`, `ClearDayCommand`, `ShowPrepLogCommand`) and the pinned Notes pseudo-row (`ShowNotesRow`, `OpenNotesCommand`). Raises `NotesRequested`/`PrepRequested` events consumed by the shell.
-- **DetailsIslandViewModel** — the detail pane for a bound `TaskRowViewModel`. Owns live-log streaming (`Log` via `StreamLineFormatter`), debounced title/description editing, subtasks, session-outcome/roadblock split (splits `Result` at the roadblock marker into two cards), the three-tab work console (`output`/`git`/`session`), child surfacing (`ChildOutcomes` rows plus `ChildrenNeedingAttention`/`HasChildrenNeedingAttention` — children that failed, were cancelled, await review, or reported roadblocks — drive an attention band on the Session tab, which is only visible when `HasChildOutcomes`), and the modes: `IsNotesMode` (hosts `NotesEditorViewModel`), `IsPrepMode`, computed `IsTaskDetailVisible = !IsNotesMode && !IsPrepMode`. Three concerns are extracted into section VMs exposed as properties: **AgentSettingsSectionViewModel** (per-task Model/MaxTurns/AgentPath overrides with `InheritedBadge` + `InheritanceResolver`, additive SystemPrompt, debounced save), **MergeSectionViewModel** (merge-target selection, mergeability indicator via `MergePreviewPresenter` over `PreviewMergeAsync`, `OpenDiffAsync` — live worktree or commit range after merge —, `ReviewCombinedDiffCommand` → `PlanningDiffViewModel`), **PrepPanelViewModel** (daily-prep panel: `PrepLog`, `PlanDayCommand` → `RunDailyPrepNowAsync`, persisted last run via `GetLastPrepLogAsync`). Helper rows (`ChildOutcomeRowViewModel`, `SubtaskRowViewModel`, `LogLineViewModel`) live in the same file.
+- **DetailsIslandViewModel** — the detail pane for a bound `TaskRowViewModel`. Owns live-log streaming (`Log` via `StreamLineFormatter`), debounced title/description editing, subtasks, session-outcome/roadblock split (splits `Result` at the roadblock marker into two cards), the three-tab work console (`output`/`git`/`session`), child surfacing (`ChildOutcomes` rows plus `ChildrenNeedingAttention`/`HasChildrenNeedingAttention` — children that failed, were cancelled, await review, or reported roadblocks — drive an attention band on the Session tab, which is only visible when `HasChildOutcomes`), and the modes: `IsNotesMode` (hosts `NotesEditorViewModel`), `IsPrepMode`, computed `IsTaskDetailVisible = !IsNotesMode && !IsPrepMode`. Three concerns are extracted into section VMs exposed as properties: **AgentConfigEditorViewModel** (scope=Task; per-task Model/MaxTurns/AgentPath overrides with `InheritedBadge` + `InheritanceResolver`, additive SystemPrompt, debounced auto-save; exposed as `AgentSettings`), **MergeSectionViewModel** (merge-target selection, mergeability indicator via `MergePreviewPresenter` over `PreviewMergeAsync`, `OpenDiffAsync` and `ReviewCombinedDiffCommand` — both build a `DiffViewerViewModel` and call `ShowDiffViewer`), **PrepPanelViewModel** (daily-prep panel: `PrepLog`, `PlanDayCommand` → `RunDailyPrepNowAsync`, persisted last run via `GetLastPrepLogAsync`). Attachments: `Attachments` (`ObservableCollection<AttachmentRowViewModel>`), `IsDragOver`, `DropStatus`, `CanAcceptDrop`, `AddFilesAsync`, `RemoveAttachmentCommand`; loads on task change; `ComposedPreview` includes attachment paths. Writes directly via `new AttachmentStore()` + `new TaskAttachmentRepository(ctx)`. Helper rows (`ChildOutcomeRowViewModel`, `SubtaskRowViewModel`, `LogLineViewModel`, `AttachmentRowViewModel`) live in the same file.
 - **TaskRowViewModel** / **ListNavItemViewModel** — lightweight display VMs (task row: status, planning phase, parent/blocked links, roadblock count, computed `IsDraft`/`IsPlanned`/`IsChild`/`IsPlanningParent`/`CanRefine`; list row: kind Smart/Virtual/User, count, icon/dot keys, drop hints).
 - **NotesEditorViewModel** — day navigator + bullet CRUD for daily notes via `INotesApi`.
-- **Modal VMs** — `SettingsModalViewModel` (four tabs: General, Worktrees, Files prompt-paths, Prime Claude incl. `DailyPrepMaxTasks` + prime-schedule rows), `ListSettingsModalViewModel` (name, working dir, commit type, per-list Model/SystemPrompt/AgentPath/MaxTurns with inherited-badge + reset, delete list), `RepoImportModalViewModel` (bulk-create lists from git repos found under chosen parents; already-wired repos disabled), `WeeklyReportModalViewModel` (range pickers default "since last standup weekday → today", cached per range, markdown via MarkdownView), `MergeModalViewModel` (single-task merge form, called from the diff modal), `WorktreesOverviewModalViewModel` (global/per-list worktree rows, batch merge + state ops), `UnfinishedPlanningModalViewModel` (Resume/FinalizeNow/Discard for a draft planning session), `WorkerConnectionModalViewModel` (offline help), `AboutModalViewModel`.
+- **Modal VMs** — `SettingsModalViewModel` (four tabs: General, Worktrees, Files prompt-paths, Prime Claude incl. `DailyPrepMaxTasks` + prime-schedule rows), `ListSettingsModalViewModel` (name, working dir, commit type, delete list; hosts shared `AgentConfigEditorViewModel` as `Agent` property (scope=List) — save delegates to `Agent.SaveAsync()`), `RepoImportModalViewModel` (bulk-create lists from git repos found under chosen parents; already-wired repos disabled), `WeeklyReportModalViewModel` (range pickers default "since last standup weekday → today", cached per range, markdown via MarkdownView), `MergeModalViewModel` (single-task merge form, called from the diff modal), `WorktreesOverviewModalViewModel` (global/per-list worktree rows, batch merge + state ops), `UnfinishedPlanningModalViewModel` (Resume/FinalizeNow/Discard for a draft planning session), `WorkerConnectionModalViewModel` (offline help), `AboutModalViewModel`, `LogVisualizerViewModel` (worker logs, last 30 min, all levels + a warn/error-only filter; loads via `GetRecentLogsAsync`).
-- **Diff stack** — `UnifiedDiffParser` (static; parses `git diff` output into `DiffFileViewModel`s, detecting added/deleted/renamed/binary files and per-line numbers; `Flatten` injects file-header rows for a combined single-pane view). `DiffModalViewModel` has two modes: live worktree (branch diff vs base, with a Merge action) and commit-range `base..head` (`FromCommitRange = true` — shows a merged task's diff after its worktree is gone; no merge action). The view renders a file list with binary/empty placeholders via `DiffLinesView`.
+- **Diff stack** — `UnifiedDiffParser` (static; parses `git diff` output into `DiffFileViewModel`s, detecting added/deleted/renamed/binary files and per-line numbers; `Flatten` injects file-header rows for a combined single-pane view). `DiffModels.cs` holds shared types: `DiffLineViewModel`, `DiffFileViewModel`, `DiffLineKind`, `DiffFileStatus`, `SubtaskDiffRow`, `DiffTreeNodeViewModel`, `DiffTree`. `DiffViewerViewModel` is a single unified read-only diff viewer with two modes: **Files** (dirty worktree / branch-vs-base / commit-range — loads via GitService, shows a folder file-tree on the left + per-file diff pane on the right, Merge button for live branch source) and **Planning** (per-subtask diffs via `GetPlanningAggregateAsync`, subtask list left + flat diff right, combined integration-branch toggle). The Merge button opens the merge form, which routes to `ConflictResolverViewModel` on conflict. `DiffLinesView` renders per-file diff content with binary/empty placeholders.
-- **Planning/Conflicts** — `PlanningDiffViewModel` (per-subtask diffs via `GetPlanningAggregateAsync`, toggle to combined integration-branch diff, conflict warnings), `ConflictResolverViewModel` (in-app **Rider-style 3-pane merge editor** for both single-task and planning unit-merge conflicts: single-task starts the conflict merge, parses each conflicted file into stable/conflict `MergeFileSegment`s via the worker's `GetMergeConflictDocuments`; exposes the active file's three reconstructed documents — `ActiveOursText` / `ActiveResultText` / `ActiveTheirsText` (from `MergeFile.OursText/ResultText/TheirsText`; Result seeds unresolved conflicts with Ours) — plus `ActiveFile`/`SelectFileCommand` (multi-file switcher), `Current`/`Next`/`Previous` (focused-conflict nav), a per-active-file `PositionText` readout, per-block `AcceptOurs/Theirs/Both/Base` + `MergeFile.Compose`, and `CanContinue` gated on every file resolved + no binary; writes each file via `WriteConflictResolution`, continue/abort; **planning mode** via `OpenForPlanningAsync(parentId, subtaskId)` loads the current subtask's mid-merge conflicts without re-starting the merge and routes continue/abort to `ContinuePlanningMerge`/`AbortPlanningMerge`, so a unit-merge conflict re-opens the editor per subtask via the `PlanningMergeConflict` broadcast). The view (`Views/Conflicts/ConflictResolverView`) shows the whole file in three **AvaloniaEdit** panes — MAIN/ours (read-only) | editable Result | INCOMING/theirs (read-only) — with TextMate highlighting by extension (theme `StyleInclude` in `App.axaml`); a code-behind `IBackgroundRenderer` tints each conflict block (unresolved/resolved) across panes, an `IReadOnlySectionProvider` + `TextAnchor` regions keep only conflict spans editable in Result (edits flow back to the block); each unresolved conflict starts EMPTY (a thin marker bar); the between-pane gutter controls **toggle** each side in/out of the result — `›`/`‹` add MAIN/INCOMING in click order (first pick on top), clicking again removes that side — so a conflict can take main, incoming, both, or neither; a `FilesSummary` readout shows how many files still have conflicts, and the three panes share a proportional synced vertical scroll. A conflict overview ruler right of the Result pane (`ConflictMap`) maps every conflict in the file proportionally (click a tick to jump) — handy for long files. Conflict block tints live in `Tokens.axaml` (`Merge*TintBrush`). The editor is reached from review **Approve** on conflict and from the **Merge** button in the Diff window (a conflicting `MergeTask` hands off to the resolver via `RequestConflictResolution`).
+- **Conflicts** — `ConflictResolverViewModel` (in-app **Rider-style 3-pane merge editor** for both single-task and planning unit-merge conflicts: single-task starts the conflict merge, parses each conflicted file into stable/conflict `MergeFileSegment`s via the worker's `GetMergeConflictDocuments`; exposes the active file's three reconstructed documents — `ActiveOursText` / `ActiveResultText` / `ActiveTheirsText` (from `MergeFile.OursText/ResultText/TheirsText`; Result seeds unresolved conflicts with Ours) — plus `ActiveFile`/`SelectFileCommand` (multi-file switcher), `Current`/`Next`/`Previous` (focused-conflict nav), a per-active-file `PositionText` readout, per-block `AcceptOurs/Theirs/Both/Base` + `MergeFile.Compose`, and `CanContinue` gated on every file resolved + no binary; writes each file via `WriteConflictResolution`, continue/abort; **planning mode** via `OpenForPlanningAsync(parentId, subtaskId)` loads the current subtask's mid-merge conflicts without re-starting the merge and routes continue/abort to `ContinuePlanningMerge`/`AbortPlanningMerge`, so a unit-merge conflict re-opens the editor per subtask via the `PlanningMergeConflict` broadcast). The view (`Views/Conflicts/ConflictResolverView`) shows the whole file in three **AvaloniaEdit** panes — MAIN/ours (read-only) | editable Result | INCOMING/theirs (read-only) — with TextMate highlighting by extension (theme `StyleInclude` in `App.axaml`); a code-behind `IBackgroundRenderer` tints each conflict block (unresolved/resolved) across panes, an `IReadOnlySectionProvider` + `TextAnchor` regions keep only conflict spans editable in Result (edits flow back to the block); each unresolved conflict starts EMPTY (a thin marker bar); the between-pane gutter controls **toggle** each side in/out of the result — `›`/`‹` add MAIN/INCOMING in click order (first pick on top), clicking again removes that side — so a conflict can take main, incoming, both, or neither; a `FilesSummary` readout shows how many files still have conflicts, and the three panes share a proportional synced vertical scroll. A conflict overview ruler right of the Result pane (`ConflictMap`) maps every conflict in the file proportionally (click a tick to jump) — handy for long files. Conflict block tints live in `Tokens.axaml` (`Merge*TintBrush`). The editor is reached from review **Approve** on conflict and from the **Merge** button in the Diff window (a conflicting `MergeTask` hands off to the resolver via `RequestConflictResolution`).
 
 ## Services
 
-- **WorkerClient** / **IWorkerClient** — SignalR client connecting to `http://127.0.0.1:47821/hub`, auto-reconnect with exponential backoff. The surface tracks `WorkerHub` (see `src/ClaudeDo.Worker/CLAUDE.md` for the canonical method/event list); groups: task execution (RunNow/Cancel/Continue/Reset/SetTaskStatus), review (`ApproveReviewAsync(taskId, targetBranch) -> MergeResultDto`, reject-to-queue/idle, cancel review, `PreviewMergeAsync -> MergePreviewDto`), planning sessions (start/resume/discard/finalize, queue subtasks, pending draft count, interactive terminal, refine), planning aggregate/integration-branch diffs, unit-merge continue/abort, single-task conflict resolving (start/get-conflicts/write-resolution/continue/abort), worktrees (overview, set state, force remove, cleanup, reset all), agents, app settings, lists/config, weekly report, daily notes, daily prep (`RunDailyPrepNowAsync`, `ClearMyDayAsync`, `GetLastPrepLogAsync`), prime schedules. Events mirror `HubBroadcaster` (task/worktree/list/run updates, prep events, planning-merge events, refine events, worker log). Lifecycle (`StartAsync`/`StopAsync`) and a few admin methods live only on the concrete `WorkerClient`.
+- **WorkerClient** / **IWorkerClient** — SignalR client connecting to `http://127.0.0.1:47821/hub`, auto-reconnect with exponential backoff. The surface tracks `WorkerHub` (see `src/ClaudeDo.Worker/CLAUDE.md` for the canonical method/event list); groups: task execution (RunNow/Cancel/Continue/Reset/SetTaskStatus), review (`ApproveReviewAsync(taskId, targetBranch) -> MergeResultDto`, reject-to-queue/idle, cancel review, `PreviewMergeAsync -> MergePreviewDto`), planning sessions (start/resume/discard/finalize, queue subtasks, pending draft count, interactive terminal, refine), planning aggregate/integration-branch diffs, unit-merge continue/abort, single-task conflict resolving (start/get-conflict-documents/write-resolution/continue/abort), worktrees (overview, set state, force remove, cleanup, reset all), agents, app settings, lists/config, weekly report, daily notes, daily prep (`RunDailyPrepNowAsync`, `ClearMyDayAsync`, `GetLastPrepLogAsync`), prime schedules, recent worker logs (`GetRecentLogsAsync`). Events mirror `HubBroadcaster` (task/worktree/list/run updates, prep events, planning-merge events, refine events, worker log). Lifecycle (`StartAsync`/`StopAsync`) and a few admin methods live only on the concrete `WorkerClient`.
 - **INotesApi** / **WorkerNotesApi** — daily-note CRUD (`ListAsync(day)`, `AddAsync`, `UpdateAsync`, `DeleteAsync`); UI DTO `DailyNoteDto(Id, Date, Text, SortOrder)`.
 - **IPrimeScheduleApi** — prime-schedule CRUD (`ListAsync`, `UpsertAsync`, `DeleteAsync`).
 - **UpdateCheckService** — polls releases, exposes `LastCheckStatus`/`LatestVersion`/`CheckNowAsync` (feeds the shell's update banner).
@@ -54,7 +54,7 @@ Design/     — Tokens.axaml (design tokens; merged before styles) + IslandStyle
 
 ## Converters
 
-`StatusColorConverter` (+ `ConnectionColorConverter` in the same file), `WorktreeStateColorConverter`, `WorkerLogLevelToBrushConverter`, `DotBrushConverter`, `EqStatusConverter`, `IconKeyConverter`, `CheckboxBorderConverter`, `StrikeIfTrueConverter`, `BoolToItalicConverter`, `BoolToDraftOpacityConverter`, `NotNullToBoolConverter`, `UpperCaseConverter`, `DateOnlyToDateTimeConverter`.
+`StatusColorConverter` (+ `ConnectionColorConverter` in the same file), `WorkerLogLevelToBrushConverter`, `DotBrushConverter`, `EqStatusConverter`, `IconKeyConverter`, `CheckboxBorderConverter`, `StrikeIfTrueConverter`, `BoolToItalicConverter`, `BoolToDraftOpacityConverter`, `NotNullToBoolConverter`, `UpperCaseConverter`, `DateOnlyToDateTimeConverter`.
 
 ## Dialog Pattern
 
@@ -66,3 +66,4 @@ Modals use `TaskCompletionSource` results behind the reusable `ModalShell` contr
 - "Run Now" CanExecute re-evaluates when worker connection state changes
 - Icon gotcha: `PathIcon` fills geometry. Line-art/stroke icons must be defined as filled geometry or rendered as a stroked `Path` (e.g. `Icon.PlanDay` via the `Path.plan-icon` style); a pure stroke path used with `PathIcon` is invisible.
 - `SessionTerminalView` is the reusable log terminal (StyledProperties `Entries`, `Label`, `IsRunning`, `IsDone`, `IsFailed`) used for both the task `Log` and the prep `PrepLog`.
+- `DetailsIslandView` is a pane-wide drag-and-drop file target (`DragDrop.AllowDrop`, Avalonia 12 `DataFormat.File`) with a "Drop to attach" hover overlay. `DescriptionStepsCard` shows an Attachments list (file name, size, remove button), an "Add file…" picker, and an explicit `DropStatus` confirmation line. Keys use the `details.attachments.*` localization namespace (en + de).

src/ClaudeDo.Ui/Converters/LogKindForegroundConverter.cs

@@ -0,0 +1,43 @@
+using System.Globalization;
+using Avalonia;
+using Avalonia.Data.Converters;
+using Avalonia.Media;
+using Avalonia.Styling;
+using ClaudeDo.Ui.ViewModels.Islands;
+
+namespace ClaudeDo.Ui.Converters;
+
+public sealed class LogKindForegroundConverter : IValueConverter
+{
+    private static IBrush? Resolve(string key)
+    {
+        if (Application.Current is { } app &&
+            app.Resources.TryGetResource(key, app.ActualThemeVariant, out var res) &&
+            res is IBrush brush)
+        {
+            return brush;
+        }
+        return null;
+    }
+
+    public object? Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        var key = value is LogKind kind ? kind switch
+        {
+            LogKind.Sys    => "TextMuteBrush",
+            LogKind.Tool   => "SageBrush",
+            LogKind.Claude => "TextBrush",
+            LogKind.Stdout => "TextDimBrush",
+            LogKind.Stderr => "BloodBrush",
+            LogKind.Done   => "MossBrightBrush",
+            LogKind.Msg    => "TextDimBrush",
+            LogKind.User   => "AccentBrush",
+            _              => "TextDimBrush",
+        } : "TextDimBrush";
+
+        return Resolve(key) ?? AvaloniaProperty.UnsetValue;
+    }
+
+    public object? ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) =>
+        throw new NotSupportedException();
+}

src/ClaudeDo.Ui/Converters/WorktreeStateColorConverter.cs

@@ -1,30 +0,0 @@
-using System.Globalization;
-using Avalonia.Data.Converters;
-using Avalonia.Media;
-using ClaudeDo.Data.Models;
-
-namespace ClaudeDo.Ui.Converters;
-
-public sealed class WorktreeStateColorConverter : IValueConverter
-{
-    private static readonly ISolidColorBrush Active = new SolidColorBrush(Color.Parse("#42A5F5"));
-    private static readonly ISolidColorBrush Merged = new SolidColorBrush(Color.Parse("#66BB6A"));
-    private static readonly ISolidColorBrush Discarded = new SolidColorBrush(Color.Parse("#9E9E9E"));
-    private static readonly ISolidColorBrush Kept = new SolidColorBrush(Color.Parse("#FFA726"));
-    private static readonly ISolidColorBrush Default = new SolidColorBrush(Colors.Gray);
-
-    public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) =>
-        value is WorktreeState state
-            ? state switch
-            {
-                WorktreeState.Active    => Active,
-                WorktreeState.Merged    => Merged,
-                WorktreeState.Discarded => Discarded,
-                WorktreeState.Kept      => Kept,
-                _                       => Default,
-            }
-            : Default;
-
-    public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
-        => throw new NotSupportedException();
-}

src/ClaudeDo.Ui/Design/IslandStyles.axaml

@@ -21,6 +21,8 @@
     <!-- Window control icons — filled geometries (PathIcon fills, not strokes) -->
     <StreamGeometry x:Key="Icon.WinMin">M4 9 H16 V11 H4 Z</StreamGeometry>
     <StreamGeometry x:Key="Icon.WinMax">M4 4 H16 V6 H4 Z M4 14 H16 V16 H4 Z M4 4 H6 V16 H4 Z M14 4 H16 V16 H14 Z</StreamGeometry>
+    <!-- Icon.Grid (four filled panes — Mission Control launcher) -->
+    <StreamGeometry x:Key="Icon.Grid">M3 3 H9 V9 H3 Z M11 3 H17 V9 H11 Z M3 11 H9 V17 H3 Z M11 11 H17 V17 H11 Z</StreamGeometry>
     <StreamGeometry x:Key="Icon.WinRestore">M4 7 H13 V9 H4 Z M4 14 H13 V16 H4 Z M4 7 H6 V16 H4 Z M11 7 H13 V16 H11 Z M7 4 H16 V6 H7 Z M14 4 H16 V13 H14 Z</StreamGeometry>
     <StreamGeometry x:Key="Icon.WinClose">M4 5 L5 4 L16 15 L15 16 Z M15 4 L16 5 L5 16 L4 15 Z</StreamGeometry>
     <!-- Brand check glyph — filled rounded square with inset tick -->
@@ -79,8 +81,11 @@
     <!-- Icon.Refine (stroke-rendered via Path.plan-icon — list lines + two sparkles) -->
     <StreamGeometry x:Key="Icon.Refine">M3,6 L13,6 M3,11 L11,11 M3,16 L9,16 M18.5,3 L19.28,5.22 L21.5,6 L19.28,6.78 L18.5,9 L17.72,6.78 L15.5,6 L17.72,5.22 Z M19.5,14.9 L19.85,16.15 L21.1,16.5 L19.85,16.85 L19.5,18.1 L19.15,16.85 L17.9,16.5 L19.15,16.15 Z</StreamGeometry>
 
-    <!-- Icon.X -->
+    <!-- Icon.X — filled X outline (PathIcon fills, so a stroke-only X renders invisible) -->
-    <StreamGeometry x:Key="Icon.X">M6 6l12 12M18 6L6 18</StreamGeometry>
+    <StreamGeometry x:Key="Icon.X">M6.4 4.6 L12 10.2 L17.6 4.6 L19.4 6.4 L13.8 12 L19.4 17.6 L17.6 19.4 L12 13.8 L6.4 19.4 L4.6 17.6 L10.2 12 L4.6 6.4 Z</StreamGeometry>
+
+    <!-- Icon.Stop — filled square (stop / interrupt) -->
+    <StreamGeometry x:Key="Icon.Stop">M4 4 H20 V20 H4 Z</StreamGeometry>
 
     <!-- Icon.Check -->
     <StreamGeometry x:Key="Icon.Check">M4 12l5 5 11-11</StreamGeometry>
@@ -88,6 +93,10 @@
     <!-- Icon.ArrowOut — filled arrow for "open external" button -->
     <StreamGeometry x:Key="Icon.ArrowOut">M13 4 H20 V11 H18 V7.4 L11.4 14 L10 12.6 L16.6 6 H13 Z M4 6 H10 V8 H6 V18 H16 V14 H18 V20 H4 Z</StreamGeometry>
 
+    <!-- Icon.ChevronRight / Icon.ChevronDown — filled expand/collapse chevrons (PathIcon fills) -->
+    <StreamGeometry x:Key="Icon.ChevronRight">M9 5 L16 12 L9 19 L6.8 16.8 L11.6 12 L6.8 7.2 Z</StreamGeometry>
+    <StreamGeometry x:Key="Icon.ChevronDown">M5 9 L12 16 L19 9 L16.8 6.8 L12 11.6 L7.2 6.8 Z</StreamGeometry>
+
     <!-- Icon.Text — three filled horizontal bars (paragraph / description icon) -->
     <StreamGeometry x:Key="Icon.Text">M4 6 H20 V8 H4 Z M4 11 H20 V13 H4 Z M4 16 H14 V18 H4 Z</StreamGeometry>
 
@@ -238,6 +247,43 @@
     <Setter Property="Foreground" Value="#8FB9D6" />
   </Style>
 
+  <!-- Worktree-state chips (worktrees overview) -->
+  <!-- active → slate-blue (same hue as parked: a live worktree) -->
+  <Style Selector="Border.chip.wt-active">
+    <Setter Property="Background"  Value="#22303A" />
+    <Setter Property="BorderBrush" Value="#3A5060" />
+  </Style>
+  <Style Selector="Border.chip.wt-active > TextBlock">
+    <Setter Property="Foreground" Value="#8FB9D6" />
+  </Style>
+
+  <!-- merged → green -->
+  <Style Selector="Border.chip.wt-merged">
+    <Setter Property="Background"  Value="{StaticResource DoneTintBrush}" />
+    <Setter Property="BorderBrush" Value="{StaticResource DoneTintBorderBrush}" />
+  </Style>
+  <Style Selector="Border.chip.wt-merged > TextBlock">
+    <Setter Property="Foreground" Value="{StaticResource StatusDoneBrush}" />
+  </Style>
+
+  <!-- kept → amber -->
+  <Style Selector="Border.chip.wt-kept">
+    <Setter Property="Background"  Value="{StaticResource ReviewTintBrush}" />
+    <Setter Property="BorderBrush" Value="{StaticResource ReviewTintBorderBrush}" />
+  </Style>
+  <Style Selector="Border.chip.wt-kept > TextBlock">
+    <Setter Property="Foreground" Value="{StaticResource StatusReviewBrush}" />
+  </Style>
+
+  <!-- discarded → muted gray (same as idle) -->
+  <Style Selector="Border.chip.wt-discarded">
+    <Setter Property="Background"  Value="{StaticResource Surface2Brush}" />
+    <Setter Property="BorderBrush" Value="{StaticResource LineBrush}" />
+  </Style>
+  <Style Selector="Border.chip.wt-discarded > TextBlock">
+    <Setter Property="Foreground" Value="{StaticResource TextMuteBrush}" />
+  </Style>
+
   <!-- ============================================================ -->
   <!-- BUTTONS                                                      -->
   <!-- ============================================================ -->
@@ -364,6 +410,8 @@
         <BrushTransition     Property="Background"  Duration="0:0:0.12" />
         <BrushTransition     Property="BorderBrush" Duration="0:0:0.12" />
         <ThicknessTransition Property="Margin"      Duration="0:0:0.15" />
+        <TransformOperationsTransition Property="RenderTransform" Duration="0:0:0.12" />
+        <DoubleTransition    Property="Opacity"     Duration="0:0:0.12" />
       </Transitions>
     </Setter>
   </Style>
@@ -371,9 +419,16 @@
     <Setter Property="BorderBrush" Value="{StaticResource LineBrightBrush}" />
   </Style>
   <Style Selector="Border.task-row.selected">
-    <Setter Property="BorderBrush"     Value="{StaticResource LineBrightBrush}" />
+    <Setter Property="BorderBrush"     Value="{StaticResource AccentBrush}" />
     <Setter Property="BorderThickness" Value="1" />
   </Style>
+  <!-- "Grabbed" row: lift + slight scale + lower opacity + shadow while the custom drag runs. -->
+  <Style Selector="Border.task-row.dragging">
+    <Setter Property="Opacity"         Value="0.55" />
+    <Setter Property="RenderTransform" Value="scale(1.03)" />
+    <Setter Property="BoxShadow"       Value="0 10 26 0 #66000000" />
+    <Setter Property="BorderBrush"     Value="{StaticResource AccentBrush}" />
+  </Style>
 
   <!-- Checkbox indicator (the 18px circle that replaces the native CheckBox template) -->
   <Style Selector="Ellipse.task-check">
@@ -476,6 +531,10 @@
   <Style Selector="Border.terminal TextBlock[Tag=log-msg]">
     <Setter Property="Foreground" Value="{StaticResource TextDimBrush}" />
   </Style>
+  <!-- log-user: user's own messages in interactive sessions — accent color to stand out -->
+  <Style Selector="Border.terminal TextBlock[Tag=log-user]">
+    <Setter Property="Foreground" Value="{DynamicResource AccentBrush}" />
+  </Style>
 
   <!-- ============================================================ -->
   <!-- TERMINAL HEADER                                              -->
@@ -1086,6 +1145,23 @@
     <Setter Property="Foreground"      Value="{StaticResource TextBrush}" />
     <Setter Property="FontWeight"      Value="SemiBold" />
   </Style>
+  <!-- Override Fluent's built-in accent button (SystemAccentColor = blue) at the
+       ContentPresenter level so our moss tokens win across rest/hover/pressed. -->
+  <Style Selector="Button.accent /template/ ContentPresenter">
+    <Setter Property="Background"  Value="{StaticResource AccentDimBrush}" />
+    <Setter Property="BorderBrush" Value="{StaticResource AccentBrush}" />
+    <Setter Property="TextElement.Foreground" Value="{StaticResource TextBrush}" />
+  </Style>
+  <Style Selector="Button.accent:pointerover /template/ ContentPresenter">
+    <Setter Property="Background"  Value="{StaticResource AccentBrush}" />
+    <Setter Property="BorderBrush" Value="{StaticResource AccentBrush}" />
+    <Setter Property="TextElement.Foreground" Value="{StaticResource TextBrush}" />
+  </Style>
+  <Style Selector="Button.accent:pressed /template/ ContentPresenter">
+    <Setter Property="Background"  Value="{StaticResource AccentSoftBrush}" />
+    <Setter Property="BorderBrush" Value="{StaticResource AccentBrush}" />
+    <Setter Property="TextElement.Foreground" Value="{StaticResource TextBrush}" />
+  </Style>
 
   <!-- ============================================================ -->
   <!-- DAY TOGGLE                                                    -->
@@ -1106,4 +1182,30 @@
     <Setter Property="Background" Value="{DynamicResource AccentBrush}"/>
   </Style>
 
+  <!-- ============================================================ -->
+  <!-- MISSION CONTROL PANE STATUS TINTING                          -->
+  <!-- Base neutral grey; tints layer on by status.                 -->
+  <!-- Running / idle / queued: no class → fall through to base.    -->
+  <!-- ============================================================ -->
+  <Style Selector="Border.monitor-pane">
+    <Setter Property="Background"  Value="{DynamicResource SurfaceBrush}" />
+    <Setter Property="BorderBrush" Value="{DynamicResource LineBrush}" />
+  </Style>
+  <Style Selector="Border.monitor-pane.mon-done">
+    <Setter Property="Background"  Value="{DynamicResource DoneTintBrush}" />
+    <Setter Property="BorderBrush" Value="{DynamicResource DoneTintBorderBrush}" />
+  </Style>
+  <Style Selector="Border.monitor-pane.mon-review">
+    <Setter Property="Background"  Value="{DynamicResource DoneTintBrush}" />
+    <Setter Property="BorderBrush" Value="{DynamicResource DoneTintBorderBrush}" />
+  </Style>
+  <Style Selector="Border.monitor-pane.mon-roadblock">
+    <Setter Property="Background"  Value="{DynamicResource RoadblockTintBrush}" />
+    <Setter Property="BorderBrush" Value="{DynamicResource RoadblockTintBorderBrush}" />
+  </Style>
+  <Style Selector="Border.monitor-pane.mon-failed">
+    <Setter Property="Background"  Value="{DynamicResource ErrorTintBrush}" />
+    <Setter Property="BorderBrush" Value="{DynamicResource ErrorTintBorderBrush}" />
+  </Style>
+
 </Styles>

src/ClaudeDo.Ui/Design/Tokens.axaml

@@ -99,6 +99,8 @@
   <SolidColorBrush x:Key="QueuedTintBorderBrush"  Color="#4C8B9D7A" />
   <SolidColorBrush x:Key="DoneTintBrush"          Color="#1F6FA86B" />
   <SolidColorBrush x:Key="DoneTintBorderBrush"    Color="#4C6FA86B" />
+  <SolidColorBrush x:Key="RoadblockTintBrush"       Color="#1FD4A574" />
+  <SolidColorBrush x:Key="RoadblockTintBorderBrush" Color="#4CD4A574" />
 
   <!-- Merge editor (3-pane conflict resolver) block tints -->
   <SolidColorBrush x:Key="MergeOursTintBrush"     Color="#1F7C9166" /> <!-- ours side (moss) -->

src/ClaudeDo.Ui/Services/IDialogService.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Threading.Tasks;
+using ClaudeDo.Ui.ViewModels;
+using ClaudeDo.Ui.ViewModels.Conflicts;
+using ClaudeDo.Ui.ViewModels.Islands;
+using ClaudeDo.Ui.ViewModels.Modals;
+
+namespace ClaudeDo.Ui.Services;
+
+/// <summary>
+/// Single seam for opening modal dialogs. Replaces the per-modal <c>Show*Modal</c>
+/// Func callbacks that were previously wired separately on the shell and the lists
+/// island (and the Confirm/Error dialogs duplicated in both code-behinds). The view
+/// layer supplies the implementation (<see cref="ClaudeDo.Ui.Views.WindowDialogService"/>);
+/// callers build + initialize the VM and hand it here to be shown.
+/// </summary>
+public interface IDialogService
+{
+    Task ShowAboutAsync(AboutModalViewModel vm);
+    Task ShowWeeklyReportAsync(WeeklyReportModalViewModel vm);
+    Task ShowSettingsAsync(SettingsModalViewModel vm);
+    Task ShowListSettingsAsync(ListSettingsModalViewModel vm);
+    Task ShowRepoImportAsync(RepoImportModalViewModel vm);
+    Task ShowWorktreesOverviewAsync(WorktreesOverviewModalViewModel vm);
+    Task ShowWorkerConnectionAsync(WorkerConnectionModalViewModel vm);
+    Task ShowConflictResolverAsync(ConflictResolverViewModel vm);
+    Task ShowLogVisualizerAsync(LogVisualizerViewModel vm);
+
+    /// <summary>Modal yes/no confirmation. Returns true only when confirmed.</summary>
+    Task<bool> ConfirmAsync(string message);
+
+    /// <summary>Modal error notice with a single dismiss button.</summary>
+    Task ShowErrorAsync(string message);
+
+    /// <summary>Show (or re-show + focus) the modeless Mission Control window. Lazily created; hides on close.</summary>
+    void ShowMissionControl(MissionControlViewModel vm);
+
+    /// <summary>Show a detached monitor in its own window; <paramref name="onClosed"/> re-docks it when that window closes.</summary>
+    void ShowDetachedMonitor(TaskMonitorViewModel monitor, Action onClosed);
+}

src/ClaudeDo.Ui/Services/IMergeCoordinator.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Threading.Tasks;
+
+namespace ClaudeDo.Ui.Services;
+
+/// <summary>
+/// Single entry point for handing a conflicting merge to the in-app 3-pane resolver.
+/// Replaces the per-VM <c>RequestConflictResolution</c> Func seams that used to be
+/// hand-threaded shell → details → merge-section → diff → merge-modal. The shell wires
+/// <see cref="MergeCoordinator.Handler"/> once at composition; invokers depend only on
+/// this interface (injected via DI).
+/// </summary>
+public interface IMergeCoordinator
+{
+    Task ResolveConflictAsync(string taskId, string targetBranch);
+}
+
+/// <summary>
+/// DI singleton holding the resolver entry. The holder breaks the shell↔island construction
+/// cycle: islands depend on the interface, the shell sets <see cref="Handler"/> after it is built.
+/// </summary>
+public sealed class MergeCoordinator : IMergeCoordinator
+{
+    /// Set once at composition to the shell's resolver entry. Null (headless/tests) ⇒ no-op.
+    public Func<string, string, Task>? Handler { get; set; }
+
+    public Task ResolveConflictAsync(string taskId, string targetBranch) =>
+        Handler?.Invoke(taskId, targetBranch) ?? Task.CompletedTask;
+}

src/ClaudeDo.Ui/Services/Interfaces/IWorkerClient.cs

@@ -20,6 +20,16 @@ public interface IWorkerClient : INotifyPropertyChanged
     event Action<string, string>? TaskMessageEvent;
     event Action<WorkerLogEntry>? WorkerLogReceivedEvent;
 
+    /// <summary>A running task raised a question via AskUser: (taskId, questionId, question).</summary>
+    event Action<string, string, string>? TaskQuestionAskedEvent;
+    /// <summary>A pending question was answered, timed out, or the run ended: (taskId, questionId).</summary>
+    event Action<string, string>? TaskQuestionResolvedEvent;
+
+    event Action<string>? InteractiveSessionStartedEvent;
+    event Action<string>? InteractiveSessionEndedEvent;
+    event Action<string, IReadOnlyList<string>>? InteractiveQueueChangedEvent;
+    event Action<string, string>? InteractiveMessageSentEvent;
+
     event Action? PrepStartedEvent;
     event Action<string>? PrepLineEvent;
     event Action<bool>? PrepFinishedEvent;
@@ -34,9 +44,19 @@ public interface IWorkerClient : INotifyPropertyChanged
 
     string? LastApproveTarget { get; }
 
+    IReadOnlyList<ActiveTask> GetActiveTasks();
+
     Task WakeQueueAsync();
     Task RunNowAsync(string taskId);
     Task ContinueTaskAsync(string taskId, string followUpPrompt);
+    /// <summary>Answer a question a running task raised via AskUser.</summary>
+    Task AnswerTaskQuestionAsync(string taskId, string questionId, string answer);
+    Task SendInteractiveMessageAsync(string taskId, string text);
+    Task RemoveQueuedInteractiveMessageAsync(string taskId, string text);
+    Task StopInteractiveSessionAsync(string taskId);
+    Task InterruptInteractiveSessionAsync(string taskId);
+    /// <summary>The question a running task is currently blocked on, if any (for re-attach).</summary>
+    Task<PendingQuestionDto?> GetPendingQuestionAsync(string taskId);
     Task ResetTaskAsync(string taskId);
     Task CancelTaskAsync(string taskId);
     Task<List<AgentInfo>> GetAgentsAsync();
@@ -54,7 +74,6 @@ public interface IWorkerClient : INotifyPropertyChanged
 
     // ── Conflict resolution (worker hub side implemented by Layer C) ──
     Task<MergeResultDto> StartConflictMergeAsync(string taskId, string targetBranch);
-    Task<MergeConflictsDto> GetMergeConflictsAsync(string taskId);
     Task<MergeConflictDocumentsDto> GetMergeConflictDocumentsAsync(string taskId);
     Task WriteConflictResolutionAsync(string taskId, string path, string resolvedContent);
     Task<MergeResultDto> ContinueConflictMergeAsync(string taskId);
@@ -86,6 +105,7 @@ public interface IWorkerClient : INotifyPropertyChanged
     Task UpdateDailyNoteAsync(string id, string text);
     Task DeleteDailyNoteAsync(string id);
     Task<string> GetLastPrepLogAsync();
+    Task<IReadOnlyList<WorkerLogEntry>> GetRecentLogsAsync();
 
     Task<List<PrimeScheduleDto>> GetPrimeSchedulesAsync();
     Task<PrimeScheduleDto?> UpsertPrimeScheduleAsync(PrimeScheduleDto dto);

src/ClaudeDo.Ui/Services/WorkerClient.cs

@@ -1,4 +1,5 @@
 using System.Collections.ObjectModel;
+using System.Linq;
 using Avalonia.Threading;
 using ClaudeDo.Data.Models;
 using ClaudeDo.Data.Repositories;
@@ -46,6 +47,12 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public event Action<string, string, string, DateTime>? TaskFinishedEvent;
     public event Action<string, string>? TaskMessageEvent;
     public event Action<string>? TaskUpdatedEvent;
+    public event Action<string, string, string>? TaskQuestionAskedEvent;
+    public event Action<string, string>? TaskQuestionResolvedEvent;
+    public event Action<string>? InteractiveSessionStartedEvent;
+    public event Action<string>? InteractiveSessionEndedEvent;
+    public event Action<string, IReadOnlyList<string>>? InteractiveQueueChangedEvent;
+    public event Action<string, string>? InteractiveMessageSentEvent;
     public event Action? ConnectionRestoredEvent;
     public event Action<string>? WorktreeUpdatedEvent;
     public event Action<string>? ListUpdatedEvent;
@@ -68,6 +75,8 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
 
     public string? LastApproveTarget { get; private set; }
 
+    public IReadOnlyList<ActiveTask> GetActiveTasks() => ActiveTasks.ToList();
+
     public WorkerClient(string signalRUrl)
     {
         _hub = new HubConnectionBuilder()
@@ -133,6 +142,36 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
             Dispatcher.UIThread.Post(() => TaskUpdatedEvent?.Invoke(taskId));
         });
 
+        _hub.On<string, string, string>("TaskQuestionAsked", (taskId, questionId, question) =>
+        {
+            Dispatcher.UIThread.Post(() => TaskQuestionAskedEvent?.Invoke(taskId, questionId, question));
+        });
+
+        _hub.On<string, string>("TaskQuestionResolved", (taskId, questionId) =>
+        {
+            Dispatcher.UIThread.Post(() => TaskQuestionResolvedEvent?.Invoke(taskId, questionId));
+        });
+
+        _hub.On<string>("InteractiveSessionStarted", taskId =>
+        {
+            Dispatcher.UIThread.Post(() => InteractiveSessionStartedEvent?.Invoke(taskId));
+        });
+
+        _hub.On<string>("InteractiveSessionEnded", taskId =>
+        {
+            Dispatcher.UIThread.Post(() => InteractiveSessionEndedEvent?.Invoke(taskId));
+        });
+
+        _hub.On<string, IReadOnlyList<string>>("InteractiveQueueChanged", (taskId, pending) =>
+        {
+            Dispatcher.UIThread.Post(() => InteractiveQueueChangedEvent?.Invoke(taskId, pending));
+        });
+
+        _hub.On<string, string>("InteractiveMessageSent", (taskId, text) =>
+        {
+            Dispatcher.UIThread.Post(() => InteractiveMessageSentEvent?.Invoke(taskId, text));
+        });
+
         _hub.On<string>("WorktreeUpdated", taskId =>
         {
             Dispatcher.UIThread.Post(() => WorktreeUpdatedEvent?.Invoke(taskId));
@@ -258,6 +297,39 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
         await _hub.InvokeAsync("ContinueTask", taskId, followUpPrompt);
     }
 
+    public async Task AnswerTaskQuestionAsync(string taskId, string questionId, string answer)
+    {
+        try { await _hub.InvokeAsync<bool>("AnswerTaskQuestion", taskId, questionId, answer); }
+        catch { /* offline or already resolved — the UI clears optimistically */ }
+    }
+
+    public async Task SendInteractiveMessageAsync(string taskId, string text)
+    {
+        try { await _hub.InvokeAsync("SendInteractiveMessage", taskId, text); }
+        catch { /* offline or session already ended */ }
+    }
+
+    public async Task RemoveQueuedInteractiveMessageAsync(string taskId, string text)
+    {
+        try { await _hub.InvokeAsync("RemoveQueuedInteractiveMessage", taskId, text); }
+        catch { /* offline or session already ended */ }
+    }
+
+    public async Task StopInteractiveSessionAsync(string taskId)
+    {
+        try { await _hub.InvokeAsync("StopInteractiveSession", taskId); }
+        catch { /* offline */ }
+    }
+
+    public async Task InterruptInteractiveSessionAsync(string taskId)
+    {
+        try { await _hub.InvokeAsync("InterruptInteractiveSession", taskId); }
+        catch { /* offline */ }
+    }
+
+    public Task<PendingQuestionDto?> GetPendingQuestionAsync(string taskId)
+        => TryInvokeAsync<PendingQuestionDto>("GetPendingQuestion", taskId);
+
     public async Task ResetTaskAsync(string taskId)
     {
         await _hub.InvokeAsync("ResetTask", taskId);
@@ -272,9 +344,6 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public Task<MergeResultDto> StartConflictMergeAsync(string taskId, string targetBranch)
         => _hub.InvokeAsync<MergeResultDto>("StartConflictMerge", taskId, targetBranch);
 
-    public Task<MergeConflictsDto> GetMergeConflictsAsync(string taskId)
-        => _hub.InvokeAsync<MergeConflictsDto>("GetMergeConflicts", taskId);
-
     public Task<MergeConflictDocumentsDto> GetMergeConflictDocumentsAsync(string taskId)
         => _hub.InvokeAsync<MergeConflictDocumentsDto>("GetMergeConflictDocuments", taskId);
 
@@ -391,6 +460,9 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public async Task<string> GetLastPrepLogAsync()
         => await TryInvokeAsync<string>("GetLastPrepLog") ?? string.Empty;
 
+    public async Task<IReadOnlyList<WorkerLogEntry>> GetRecentLogsAsync()
+        => await TryInvokeAsync<List<WorkerLogEntry>>("GetRecentLogs") ?? new List<WorkerLogEntry>();
+
     public async Task UpdateListAsync(UpdateListDto dto)
     {
         await _hub.InvokeAsync("UpdateList", dto);
@@ -559,9 +631,6 @@ public sealed record WorktreeResetDto(int Removed, int TasksAffected, bool Block
 public record MergeResultDto(string Status, IReadOnlyList<string> ConflictFiles, string? ErrorMessage);
 public record MergePreviewDto(string Status, IReadOnlyList<string> ConflictFiles, int ChangedFileCount);
 public record MergeTargetsDto(string DefaultBranch, IReadOnlyList<string> LocalBranches);
-public record MergeConflictsDto(string TaskId, IReadOnlyList<ConflictFileDto> Files);
-public record ConflictFileDto(string Path, IReadOnlyList<ConflictHunkDto> Hunks);
-public record ConflictHunkDto(string Ours, string Theirs, string? Base);
 public record MergeConflictDocumentsDto(string TaskId, IReadOnlyList<ConflictDocumentDto> Files);
 public record ConflictDocumentDto(string Path, bool IsBinary, IReadOnlyList<MergeSegmentDto> Segments);
 public record MergeSegmentDto(bool IsConflict, string Text, string Ours, string? Base, string Theirs);
@@ -586,6 +655,7 @@ public sealed record WorktreeOverviewDto(
     bool PathExistsOnDisk);
 
 public sealed record ForceRemoveResultDto(bool Removed, string? Reason);
+public sealed record PendingQuestionDto(string TaskId, string QuestionId, string Question);
 
 public sealed record OnlineInboxStateDto(
     bool Enabled,

src/ClaudeDo.Ui/ViewModels/Agent/AgentConfigEditorViewModel.cs

@@ -0,0 +1,259 @@
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Ui.Localization;
+using ClaudeDo.Ui.Services;
+
+namespace ClaudeDo.Ui.ViewModels.Agent;
+
+public enum AgentConfigScope { List, Task }
+
+/// <summary>
+/// One agent-config editor (Model / MaxTurns / SystemPrompt / AgentFile with inherited
+/// badges + reset) shared by the List Settings modal and the per-task gear flyout.
+/// Scope picks the inheritance depth (List: list→global; Task: task→list→global) and the
+/// persistence (List: explicit <see cref="SaveAsync"/>; Task: debounced auto-save).
+/// </summary>
+public sealed partial class AgentConfigEditorViewModel : ViewModelBase, IDisposable
+{
+    private readonly IWorkerClient _worker;
+    private readonly AgentConfigScope _scope;
+    private readonly EventHandler _langChangedHandler;
+
+    /// scope==List ⇒ the list id; scope==Task ⇒ the task id. Null ⇒ no save target.
+    internal string? TargetId { get; set; }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsEnabled))]
+    private bool _isRunning;
+
+    // Task scope gates the editor while the run is live; List scope is always enabled.
+    public bool IsEnabled => !IsRunning;
+
+    [ObservableProperty] private string? _model;
+    [ObservableProperty] private decimal? _maxTurns;
+    [ObservableProperty] private string _systemPrompt = "";
+    [ObservableProperty] private AgentInfo? _selectedAgent;
+
+    [ObservableProperty] private string _modelBadge = "";
+    [ObservableProperty] private string _modelInheritedHint = "";
+    [ObservableProperty] private string _turnsBadge = "";
+    [ObservableProperty] private string _turnsInheritedHint = "";
+    [ObservableProperty] private string _agentBadge = "";
+    [ObservableProperty] private string _effectiveSystemPromptHint = "";
+
+    private string _globalModel = ModelRegistry.DefaultAlias;
+    private int _globalMaxTurns = 100;
+    private string? _listModel;     // Task scope only
+    private int? _listMaxTurns;     // Task scope only
+    private string? _listAgentName; // Task scope only
+
+    private bool _suppressSave;
+    private CancellationTokenSource? _saveCts;
+
+    public int EffectiveMaxTurns =>
+        MaxTurns is decimal t ? (int)t : (_listMaxTurns ?? _globalMaxTurns);
+
+    public ObservableCollection<string> ModelOptions { get; } = new(ModelRegistry.Aliases);
+    public ObservableCollection<AgentInfo> Agents { get; } = new();
+
+    public AgentConfigEditorViewModel(IWorkerClient worker, AgentConfigScope scope)
+    {
+        _worker = worker;
+        _scope = scope;
+        _langChangedHandler = (_, _) => RecomputeBadges();
+        // Only the long-lived Task editor needs live re-badging; the List editor is a
+        // short-lived modal recreated with the current language on each open.
+        if (scope == AgentConfigScope.Task)
+            Loc.LanguageChanged += _langChangedHandler;
+    }
+
+    public void Dispose() => Loc.LanguageChanged -= _langChangedHandler;
+
+    partial void OnModelChanged(string? value) { RecomputeModelBadge(); QueueSave(); }
+
+    partial void OnMaxTurnsChanged(decimal? value)
+    {
+        RecomputeTurnsBadge();
+        OnPropertyChanged(nameof(EffectiveMaxTurns));
+        QueueSave();
+    }
+
+    partial void OnSystemPromptChanged(string value) => QueueSave();
+    partial void OnSelectedAgentChanged(AgentInfo? value) { RecomputeAgentBadge(); QueueSave(); }
+
+    private void RecomputeBadges()
+    {
+        RecomputeModelBadge();
+        RecomputeTurnsBadge();
+        RecomputeAgentBadge();
+    }
+
+    private void RecomputeModelBadge()
+    {
+        var own = string.IsNullOrWhiteSpace(Model) ? null : Model;
+        var (value, source) = _scope == AgentConfigScope.Task
+            ? InheritanceResolver.Resolve(own, _listModel, _globalModel)
+            : InheritanceResolver.ResolveList(own, _globalModel);
+        ModelInheritedHint = value;
+        ModelBadge = BadgeFor(source, own is not null);
+    }
+
+    private void RecomputeTurnsBadge()
+    {
+        var own = MaxTurns?.ToString();
+        var (value, source) = _scope == AgentConfigScope.Task
+            ? InheritanceResolver.Resolve(own, _listMaxTurns?.ToString(), _globalMaxTurns.ToString())
+            : InheritanceResolver.ResolveList(own, _globalMaxTurns.ToString());
+        TurnsInheritedHint = value;
+        TurnsBadge = BadgeFor(source, MaxTurns is not null);
+    }
+
+    private void RecomputeAgentBadge()
+    {
+        var agentSet = SelectedAgent is not null && !string.IsNullOrWhiteSpace(SelectedAgent.Path);
+        var own = agentSet ? SelectedAgent!.Path : null;
+        var (_, source) = _scope == AgentConfigScope.Task
+            ? InheritanceResolver.Resolve(own, _listAgentName, null)
+            : InheritanceResolver.ResolveList(own, null);
+        AgentBadge = BadgeFor(source, agentSet);
+    }
+
+    private static string BadgeFor(InheritSource source, bool isSet) => isSet
+        ? Loc.T("settings.inherit.overrideBadge")
+        : source == InheritSource.List
+            ? Loc.T("settings.inherit.inheritedFromList")
+            : Loc.T("settings.inherit.inheritedFromGlobal");
+
+    private void QueueSave()
+    {
+        // List scope persists on the modal Save button; only Task auto-saves.
+        if (_suppressSave || _scope != AgentConfigScope.Task || TargetId is null) return;
+        _saveCts?.Cancel();
+        _saveCts = new CancellationTokenSource();
+        _ = DebouncedSaveAsync(_saveCts.Token);
+    }
+
+    private async System.Threading.Tasks.Task DebouncedSaveAsync(CancellationToken ct)
+    {
+        try
+        {
+            await System.Threading.Tasks.Task.Delay(300, ct);
+            if (TargetId is null) return;
+            await SaveAsync();
+        }
+        catch (OperationCanceledException) { }
+        catch { }
+    }
+
+    public async System.Threading.Tasks.Task SaveAsync()
+    {
+        if (TargetId is null) return;
+        var model = string.IsNullOrWhiteSpace(Model) ? null : Model;
+        var sp = string.IsNullOrWhiteSpace(SystemPrompt) ? null : SystemPrompt;
+        var ap = SelectedAgent is null || string.IsNullOrWhiteSpace(SelectedAgent.Path) ? null : SelectedAgent.Path;
+        var turns = MaxTurns is decimal d ? (int?)d : null;
+
+        if (_scope == AgentConfigScope.Task)
+            await _worker.UpdateTaskAgentSettingsAsync(new UpdateTaskAgentSettingsDto(TargetId, model, sp, ap, turns));
+        else
+            await _worker.UpdateListConfigAsync(new UpdateListConfigDto(TargetId, model, sp, ap, turns));
+    }
+
+    public async System.Threading.Tasks.Task LoadForListAsync(string listId, CancellationToken ct = default)
+    {
+        _suppressSave = true;
+        try
+        {
+            TargetId = listId;
+            await ReloadAgentsAsync("(none)");
+            await LoadGlobalDefaultsAsync();
+
+            var cfg = await _worker.GetListConfigAsync(listId);
+            ApplyConfig(cfg?.Model, cfg?.MaxTurns, cfg?.SystemPrompt, cfg?.AgentPath);
+
+            _listModel = null; _listMaxTurns = null; _listAgentName = null;
+            EffectiveSystemPromptHint = "";
+            RecomputeBadges();
+            OnPropertyChanged(nameof(EffectiveMaxTurns));
+        }
+        finally { _suppressSave = false; }
+    }
+
+    public async System.Threading.Tasks.Task LoadForTaskAsync(TaskEntity entity, CancellationToken ct = default)
+    {
+        _suppressSave = true;
+        try
+        {
+            TargetId = entity.Id;
+            await ReloadAgentsAsync("(inherited)");
+            ApplyConfig(entity.Model, entity.MaxTurns, entity.SystemPrompt, entity.AgentPath);
+
+            var listCfg = await _worker.GetListConfigAsync(entity.ListId);
+            await LoadGlobalDefaultsAsync();
+            _listModel = listCfg?.Model;
+            _listMaxTurns = listCfg?.MaxTurns;
+            _listAgentName = string.IsNullOrWhiteSpace(listCfg?.AgentPath)
+                ? null : System.IO.Path.GetFileName(listCfg!.AgentPath!);
+            EffectiveSystemPromptHint = string.IsNullOrWhiteSpace(listCfg?.SystemPrompt)
+                ? "" : listCfg!.SystemPrompt!;
+
+            RecomputeBadges();
+            OnPropertyChanged(nameof(EffectiveMaxTurns));
+        }
+        finally { _suppressSave = false; }
+    }
+
+    public void Clear()
+    {
+        _suppressSave = true;
+        try
+        {
+            Model = null;
+            MaxTurns = null;
+            SystemPrompt = "";
+            SelectedAgent = null;
+        }
+        finally { _suppressSave = false; }
+        EffectiveSystemPromptHint = "";
+        TargetId = null;
+    }
+
+    private async System.Threading.Tasks.Task ReloadAgentsAsync(string placeholderName)
+    {
+        Agents.Clear();
+        Agents.Add(new AgentInfo(placeholderName, "", ""));
+        foreach (var a in await _worker.GetAgentsAsync()) Agents.Add(a);
+    }
+
+    private async System.Threading.Tasks.Task LoadGlobalDefaultsAsync()
+    {
+        var app = await _worker.GetAppSettingsAsync();
+        _globalModel = app?.DefaultModel ?? ModelRegistry.DefaultAlias;
+        _globalMaxTurns = app?.DefaultMaxTurns ?? 100;
+    }
+
+    private void ApplyConfig(string? model, int? maxTurns, string? systemPrompt, string? agentPath)
+    {
+        Model = string.IsNullOrWhiteSpace(model) ? null : model!;
+        MaxTurns = maxTurns is int mt ? mt : (decimal?)null;
+        SystemPrompt = systemPrompt ?? "";
+        SelectedAgent = string.IsNullOrWhiteSpace(agentPath)
+            ? Agents[0]
+            : (Agents.FirstOrDefault(a => a.Path == agentPath) ?? Agents[0]);
+    }
+
+    [RelayCommand] private void ResetModel() => Model = null;
+    [RelayCommand] private void ResetTurns() => MaxTurns = null;
+    [RelayCommand] private void ResetAgent() => SelectedAgent = Agents.Count > 0 ? Agents[0] : null;
+
+    [RelayCommand]
+    private void ResetAll()
+    {
+        Model = null;
+        MaxTurns = null;
+        SystemPrompt = "";
+        SelectedAgent = Agents.Count > 0 ? Agents[0] : null;
+    }
+}

src/ClaudeDo.Ui/ViewModels/Islands/AgentSettingsSectionViewModel.cs

@@ -1,196 +0,0 @@
-using System.Collections.ObjectModel;
-using CommunityToolkit.Mvvm.ComponentModel;
-using CommunityToolkit.Mvvm.Input;
-using ClaudeDo.Data.Models;
-using ClaudeDo.Ui.Helpers;
-using ClaudeDo.Ui.Localization;
-using ClaudeDo.Ui.Services;
-
-namespace ClaudeDo.Ui.ViewModels.Islands;
-
-public sealed partial class AgentSettingsSectionViewModel : ViewModelBase, IDisposable
-{
-    private readonly IWorkerClient _worker;
-    private readonly EventHandler _langChangedHandler;
-
-    internal string? TaskId { get; set; }
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(IsAgentSectionEnabled))]
-    private bool _isRunning;
-
-    public bool IsAgentSectionEnabled => !IsRunning;
-
-    [ObservableProperty] private string? _taskModelSelection;
-    [ObservableProperty] private string _taskSystemPrompt = "";
-    [ObservableProperty] private AgentInfo? _taskSelectedAgent;
-    [ObservableProperty] private decimal? _taskMaxTurns;
-    [ObservableProperty] private string _modelBadge = "";
-    [ObservableProperty] private string _modelInheritedHint = "";
-    [ObservableProperty] private string _turnsBadge = "";
-    [ObservableProperty] private string _turnsInheritedHint = "";
-    [ObservableProperty] private string _agentBadge = "";
-    [ObservableProperty] private string _effectiveSystemPromptHint = "";
-
-    private string _globalModel = ModelRegistry.DefaultAlias;
-    private int _globalMaxTurns = 100;
-    private string? _listModel;
-    private int? _listMaxTurns;
-    private string? _listAgentName;
-
-    private bool _suppressAgentSave;
-    private CancellationTokenSource? _agentSaveCts;
-
-    public int EffectiveMaxTurns =>
-        TaskMaxTurns is decimal t ? (int)t : (_listMaxTurns ?? _globalMaxTurns);
-
-    public ObservableCollection<string> TaskModelOptions { get; } = new(ModelRegistry.Aliases);
-    public ObservableCollection<AgentInfo> TaskAgentOptions { get; } = new();
-
-    public AgentSettingsSectionViewModel(IWorkerClient worker)
-    {
-        _worker = worker;
-        _langChangedHandler = (_, _) =>
-        {
-            RecomputeModelBadge();
-            RecomputeTurnsBadge();
-            RecomputeAgentBadge();
-        };
-        Loc.LanguageChanged += _langChangedHandler;
-    }
-
-    public void Dispose() => Loc.LanguageChanged -= _langChangedHandler;
-
-    partial void OnTaskModelSelectionChanged(string? value) { RecomputeModelBadge(); QueueAgentSave(); }
-
-    partial void OnTaskMaxTurnsChanged(decimal? value)
-    {
-        RecomputeTurnsBadge();
-        OnPropertyChanged(nameof(EffectiveMaxTurns));
-        QueueAgentSave();
-    }
-
-    partial void OnTaskSystemPromptChanged(string value) => QueueAgentSave();
-    partial void OnTaskSelectedAgentChanged(AgentInfo? value) { RecomputeAgentBadge(); QueueAgentSave(); }
-
-    private void RecomputeModelBadge()
-    {
-        var (value, source) = InheritanceResolver.Resolve(TaskModelSelection, _listModel, _globalModel);
-        ModelInheritedHint = value;
-        ModelBadge = BadgeFor(source, !string.IsNullOrWhiteSpace(TaskModelSelection));
-    }
-
-    private void RecomputeTurnsBadge()
-    {
-        var (value, source) = InheritanceResolver.Resolve(
-            TaskMaxTurns?.ToString(), _listMaxTurns?.ToString(), _globalMaxTurns.ToString());
-        TurnsInheritedHint = value;
-        TurnsBadge = BadgeFor(source, TaskMaxTurns is not null);
-    }
-
-    private void RecomputeAgentBadge()
-    {
-        var taskSet = TaskSelectedAgent is not null && !string.IsNullOrWhiteSpace(TaskSelectedAgent.Path);
-        var (_, source) = InheritanceResolver.Resolve(
-            taskSet ? TaskSelectedAgent!.Path : null, _listAgentName, null);
-        AgentBadge = BadgeFor(source, taskSet);
-    }
-
-    private static string BadgeFor(InheritSource source, bool taskSet) => taskSet
-        ? Loc.T("settings.inherit.overrideBadge")
-        : source == InheritSource.List
-            ? Loc.T("settings.inherit.inheritedFromList")
-            : Loc.T("settings.inherit.inheritedFromGlobal");
-
-    private void QueueAgentSave()
-    {
-        if (_suppressAgentSave || TaskId is null) return;
-        _agentSaveCts?.Cancel();
-        _agentSaveCts = new CancellationTokenSource();
-        _ = SaveAgentSettingsAsync(_agentSaveCts.Token);
-    }
-
-    private async System.Threading.Tasks.Task SaveAgentSettingsAsync(CancellationToken ct)
-    {
-        try
-        {
-            await System.Threading.Tasks.Task.Delay(300, ct);
-            if (TaskId is null) return;
-
-            var model = string.IsNullOrWhiteSpace(TaskModelSelection) ? null : TaskModelSelection;
-            var sp = string.IsNullOrWhiteSpace(TaskSystemPrompt) ? null : TaskSystemPrompt;
-            var ap = TaskSelectedAgent is null || string.IsNullOrWhiteSpace(TaskSelectedAgent.Path)
-                ? null : TaskSelectedAgent.Path;
-            var turns = TaskMaxTurns is decimal d ? (int?)d : null;
-
-            await _worker.UpdateTaskAgentSettingsAsync(
-                new UpdateTaskAgentSettingsDto(TaskId, model, sp, ap, turns));
-        }
-        catch (OperationCanceledException) { }
-        catch { }
-    }
-
-    internal async System.Threading.Tasks.Task LoadAsync(
-        ClaudeDo.Data.Models.TaskEntity entity, CancellationToken ct)
-    {
-        _suppressAgentSave = true;
-        try
-        {
-            TaskAgentOptions.Clear();
-            TaskAgentOptions.Add(new AgentInfo("(inherited)", "", ""));
-            var agents = await _worker.GetAgentsAsync();
-            foreach (var a in agents) TaskAgentOptions.Add(a);
-
-            TaskModelSelection = string.IsNullOrWhiteSpace(entity.Model) ? null : entity.Model!;
-            TaskMaxTurns = entity.MaxTurns is int tmt ? tmt : (decimal?)null;
-            TaskSystemPrompt = entity.SystemPrompt ?? "";
-            TaskSelectedAgent = string.IsNullOrWhiteSpace(entity.AgentPath)
-                ? TaskAgentOptions[0]
-                : (TaskAgentOptions.FirstOrDefault(a => a.Path == entity.AgentPath) ?? TaskAgentOptions[0]);
-
-            var listCfg = await _worker.GetListConfigAsync(entity.ListId);
-            var app = await _worker.GetAppSettingsAsync();
-            _globalModel = app?.DefaultModel ?? ModelRegistry.DefaultAlias;
-            _globalMaxTurns = app?.DefaultMaxTurns ?? 100;
-            _listModel = listCfg?.Model;
-            _listMaxTurns = listCfg?.MaxTurns;
-            _listAgentName = string.IsNullOrWhiteSpace(listCfg?.AgentPath)
-                ? null : System.IO.Path.GetFileName(listCfg!.AgentPath!);
-
-            EffectiveSystemPromptHint = string.IsNullOrWhiteSpace(listCfg?.SystemPrompt)
-                ? "" : listCfg!.SystemPrompt!;
-
-            RecomputeModelBadge();
-            RecomputeTurnsBadge();
-            RecomputeAgentBadge();
-            OnPropertyChanged(nameof(EffectiveMaxTurns));
-        }
-        finally
-        {
-            _suppressAgentSave = false;
-        }
-    }
-
-    internal void Clear()
-    {
-        _suppressAgentSave = true;
-        try
-        {
-            TaskModelSelection = null;
-            TaskMaxTurns = null;
-            TaskSystemPrompt = "";
-            TaskSelectedAgent = null;
-        }
-        finally
-        {
-            _suppressAgentSave = false;
-        }
-        EffectiveSystemPromptHint = "";
-        TaskId = null;
-    }
-
-    [RelayCommand] private void ResetTaskModel() => TaskModelSelection = null;
-    [RelayCommand] private void ResetTaskTurns() => TaskMaxTurns = null;
-    [RelayCommand] private void ResetTaskAgent() =>
-        TaskSelectedAgent = TaskAgentOptions.Count > 0 ? TaskAgentOptions[0] : null;
-}

src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs

@@ -1,60 +1,30 @@
 using System.Collections.ObjectModel;
-using System.Text;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using ClaudeDo.Data;
 using ClaudeDo.Data.Models;
 using ClaudeDo.Data.Repositories;
-using ClaudeDo.Ui.Helpers;
 using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
 using ClaudeDo.Ui.Services.Interfaces;
+using ClaudeDo.Ui.ViewModels.Agent;
 using ClaudeDo.Ui.ViewModels.Modals;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
+using System.IO;
 
 namespace ClaudeDo.Ui.ViewModels.Islands;
 
-public enum LogKind { Sys, Tool, Claude, Stdout, Stderr, Done, Msg }
-
-public sealed class LogLineViewModel
-{
-    public required LogKind Kind { get; init; }
-    public required string Text { get; init; }
-    public string TimestampFormatted { get; } = DateTime.Now.ToString("HH:mm:ss");
-    public string KindMarker => Kind switch
-    {
-        LogKind.Sys    => "sys",
-        LogKind.Tool   => "tool",
-        LogKind.Claude => "claude",
-        LogKind.Stdout => "out",
-        LogKind.Stderr => "err",
-        LogKind.Done   => "done",
-        LogKind.Msg    => "claude",
-        _              => "",
-    };
-    public string ClassName => Kind switch
-    {
-        LogKind.Sys    => "log-sys",
-        LogKind.Tool   => "log-tool",
-        LogKind.Claude => "log-claude",
-        LogKind.Stdout => "log-stdout",
-        LogKind.Stderr => "log-stderr",
-        LogKind.Done   => "log-done",
-        LogKind.Msg    => "log-msg",
-        _              => "",
-    };
-}
-
 public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
 {
     private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
     private readonly IWorkerClient _worker;
     private readonly IServiceProvider _services;
     private readonly INotesApi _notesApi;
+    private readonly IMergeCoordinator _merge;
 
     // ── Section view models ───────────────────────────────────────────────────
-    public AgentSettingsSectionViewModel AgentSettings { get; }
+    public AgentConfigEditorViewModel AgentSettings { get; }
     public MergeSectionViewModel Merge { get; }
     public PrepPanelViewModel Prep { get; }
 
@@ -115,29 +85,39 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     [RelayCommand]
     private void ToggleDescriptionExpanded() => IsDescriptionExpanded = !IsDescriptionExpanded;
 
-    [ObservableProperty] private bool _isStepsExpanded;
+    // Which section of the details card is shown (header acts as a segment switcher).
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsDescriptionSection))]
+    [NotifyPropertyChangedFor(nameof(IsStepsSection))]
+    [NotifyPropertyChangedFor(nameof(IsFilesSection))]
+    private string _detailSection = "description";
+
+    public bool IsDescriptionSection => DetailSection == "description";
+    public bool IsStepsSection       => DetailSection == "steps";
+    public bool IsFilesSection       => DetailSection == "files";
 
     [RelayCommand]
-    private void ToggleStepsExpanded() => IsStepsExpanded = !IsStepsExpanded;
+    private void SelectDetailSection(string? section) => DetailSection = section ?? "description";
 
     public int TotalStepCount => Subtasks.Count;
-    public int OpenStepCount => Subtasks.Count(s => !s.Done);
+    public int DoneStepCount => Subtasks.Count(s => s.Done);
-    public string StepsSummary =>
+    public string StepsBadge => TotalStepCount > 0 ? $"{DoneStepCount}/{TotalStepCount}" : "";
-        TotalStepCount == 0 ? "no steps yet"
+    public string FilesBadge => Attachments.Count > 0 ? Attachments.Count.ToString() : "";
-        : OpenStepCount == 0 ? $"all done · {TotalStepCount} total"
-        : $"{OpenStepCount} open · {TotalStepCount} total";
 
     private void NotifyStepsChanged()
     {
         OnPropertyChanged(nameof(TotalStepCount));
-        OnPropertyChanged(nameof(OpenStepCount));
+        OnPropertyChanged(nameof(DoneStepCount));
-        OnPropertyChanged(nameof(StepsSummary));
+        OnPropertyChanged(nameof(StepsBadge));
         OnPropertyChanged(nameof(ComposedPreview));
     }
 
     public string ComposedPreview =>
         ClaudeDo.Data.TaskPromptComposer.Compose(
-            EditableTitle, EditableDescription, Subtasks.Select(s => (s.Title, s.Done)));
+            EditableTitle, EditableDescription, Subtasks.Select(s => (s.Title, s.Done)),
+            Task is not null
+                ? Attachments.Select(a => Path.Combine(new AttachmentStore().TaskDir(Task.Id), a.FileName))
+                : null);
 
     [ObservableProperty]
     [NotifyPropertyChangedFor(nameof(IsOutputTab))]
@@ -166,98 +146,53 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     public string DiffAddText => $"+{DiffAdditions}";
     public string DiffDelText => $"-{DiffDeletions}";
 
-    public bool ShowRoadblock => IsFailed;
+    // ── Monitor forwarding ───────────────────────────────────────────────────
-    public string RoadblockMessage =>
+    public TaskMonitorViewModel Monitor { get; }
-        IsFailed ? "The session ended with an error." : "";
 
-    [ObservableProperty]
+    public ObservableCollection<LogLineViewModel> Log => Monitor.Log;
-    [NotifyPropertyChangedFor(nameof(ShowSessionOutcome))]
-    private string? _sessionOutcome;
 
-    public bool ShowSessionOutcome =>
+    public string AgentState
-        !string.IsNullOrWhiteSpace(SessionOutcome)
-        && (IsWaitingForReview || IsDone || IsFailed || IsCancelled);
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(ShowRoadblockCard))]
-    private string? _roadblocks;
-
-    public bool ShowRoadblockCard =>
-        !string.IsNullOrWhiteSpace(Roadblocks)
-        && (IsWaitingForReview || IsDone || IsFailed || IsCancelled);
-
-    private const string RoadblockMarker = "Roadblocks reported during the run:";
-
-    private void ApplyOutcome(string? result, string? errorFallback)
     {
-        if (string.IsNullOrWhiteSpace(result))
+        get => Monitor.AgentState;
-        {
+        set => Monitor.AgentState = value;
-            SessionOutcome = errorFallback;
+    }
-            Roadblocks = null;
-            return;
-        }
 
-        var idx = result.IndexOf(RoadblockMarker, StringComparison.Ordinal);
+    public string AgentStatusLabel        => Monitor.AgentStatusLabel;
-        if (idx < 0)
+    public bool IsIdle                    => Monitor.IsIdle;
-        {
+    public bool IsQueued                  => Monitor.IsQueued;
-            SessionOutcome = result;
+    public bool IsRunning                 => Monitor.IsRunning;
-            Roadblocks = null;
+    public bool IsWaitingForReview        => Monitor.IsWaitingForReview;
-            return;
+    public bool IsWaitingForChildren      => Monitor.IsWaitingForChildren;
-        }
+    public bool IsDone                    => Monitor.IsDone;
+    public bool IsFailed                  => Monitor.IsFailed;
+    public bool IsCancelled               => Monitor.IsCancelled;
+    public bool ShowContinue              => Monitor.ShowContinue;
+    public bool ShowResetAndRetry         => Monitor.ShowResetAndRetry;
+    public bool ShowRoadblock             => Monitor.ShowRoadblock;
+    public string RoadblockMessage        => Monitor.RoadblockMessage;
+    public bool ShowSessionOutcome        => Monitor.ShowSessionOutcome;
+    public bool ShowRoadblockCard         => Monitor.ShowRoadblockCard;
 
-        var summary = result[..idx].TrimEnd().TrimEnd('⚠').TrimEnd();
+    public string? SessionOutcome
-        SessionOutcome = string.IsNullOrWhiteSpace(summary) ? null : summary;
+    {
-        Roadblocks = result[(idx + RoadblockMarker.Length)..].Trim();
+        get => Monitor.SessionOutcome;
+        set => Monitor.SessionOutcome = value;
+    }
+
+    public string? Roadblocks
+    {
+        get => Monitor.Roadblocks;
+        set => Monitor.Roadblocks = value;
     }
 
     public string SessionLabel => "claude-session";
 
     public string TaskIdBadge => Task != null ? $"#T{Task.Id[..Math.Min(3, Task.Id.Length)].ToUpperInvariant()}" : "";
 
-    [ObservableProperty]
-    [NotifyCanExecuteChangedFor(nameof(EnqueueCommand))]
-    [NotifyCanExecuteChangedFor(nameof(DequeueCommand))]
-    [NotifyCanExecuteChangedFor(nameof(ResetAndRetryCommand))]
-    [NotifyCanExecuteChangedFor(nameof(ContinueCommand))]
-    private string _agentState = "idle";
-    public string AgentStatusLabel => Loc.T($"vm.agentStatus.{AgentState}");
-    public bool IsIdle               => AgentState == "idle";
-    public bool IsQueued             => AgentState == "queued";
-    public bool IsRunning            => AgentState == "running";
-    public bool IsWaitingForReview   => AgentState == "review";
-    public bool IsWaitingForChildren => AgentState == "children";
-    public bool IsDone               => AgentState == "done";
-    public bool IsFailed             => AgentState == "failed";
-    public bool IsCancelled          => AgentState == "cancelled";
-
-    public bool ShowContinue => IsFailed || IsCancelled;
-    public bool ShowResetAndRetry => IsFailed || IsCancelled || IsDone;
-
     [ObservableProperty]
     [NotifyCanExecuteChangedFor(nameof(ContinueCommand))]
     private string? _latestRunSessionId;
 
-    partial void OnAgentStateChanged(string value)
-    {
-        OnPropertyChanged(nameof(AgentStatusLabel));
-        OnPropertyChanged(nameof(IsIdle));
-        OnPropertyChanged(nameof(IsQueued));
-        OnPropertyChanged(nameof(IsRunning));
-        OnPropertyChanged(nameof(IsWaitingForReview));
-        OnPropertyChanged(nameof(IsWaitingForChildren));
-        OnPropertyChanged(nameof(IsDone));
-        OnPropertyChanged(nameof(IsFailed));
-        OnPropertyChanged(nameof(IsCancelled));
-        OnPropertyChanged(nameof(ShowContinue));
-        OnPropertyChanged(nameof(ShowResetAndRetry));
-        OnPropertyChanged(nameof(ShowRoadblock));
-        OnPropertyChanged(nameof(RoadblockMessage));
-        OnPropertyChanged(nameof(ShowSessionOutcome));
-        OnPropertyChanged(nameof(ShowRoadblockCard));
-        AgentSettings.IsRunning = IsRunning;
-        NotifySessionSections();
-    }
-
     [ObservableProperty] private string? _model;
 
     [ObservableProperty] private string? _worktreePath;
@@ -289,9 +224,14 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         }
     }
 
-    public ObservableCollection<LogLineViewModel> Log { get; } = new();
     public ObservableCollection<SubtaskRowViewModel> Subtasks { get; } = new();
     public ObservableCollection<ChildOutcomeRowViewModel> ChildOutcomes { get; } = new();
+    public ObservableCollection<AttachmentRowViewModel> Attachments { get; } = new();
+
+    [ObservableProperty] private bool _isDragOver;
+    [ObservableProperty] private string? _dropStatus;
+
+    public bool CanAcceptDrop => Task is not null && !Task.IsRunning;
     public bool HasChildOutcomes => ChildOutcomes.Count > 0;
 
     public int ChildrenNeedingAttention => ChildOutcomes.Count(c =>
@@ -313,11 +253,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
 
     [ObservableProperty] private string _newSubtaskTitle = "";
 
-    // Claude CLI stream-json parser + buffer for partial text deltas
-    private readonly StreamLineFormatter _formatter = new();
-    private readonly StringBuilder _claudeBuf = new();
-
-    private string? _subscribedTaskId;
     private CancellationTokenSource? _loadCts;
 
     private bool _suppressDescSave;
@@ -343,93 +278,40 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
 
     public bool HasReviewFeedback => !string.IsNullOrWhiteSpace(ReviewFeedback);
 
-    // Kept for backwards-compat surface — delegates to Merge.RequestConflictResolution
-    public Func<string, string, System.Threading.Tasks.Task>? RequestConflictResolution
-    {
-        get => Merge.RequestConflictResolution;
-        set => Merge.RequestConflictResolution = value;
-    }
-
-    private static string StatusToStateKey(ClaudeDo.Data.Models.TaskStatus status) => status switch
-    {
-        ClaudeDo.Data.Models.TaskStatus.Queued           => "queued",
-        ClaudeDo.Data.Models.TaskStatus.Running          => "running",
-        ClaudeDo.Data.Models.TaskStatus.WaitingForReview    => "review",
-        ClaudeDo.Data.Models.TaskStatus.WaitingForChildren => "children",
-        ClaudeDo.Data.Models.TaskStatus.Done             => "done",
-        ClaudeDo.Data.Models.TaskStatus.Failed           => "failed",
-        ClaudeDo.Data.Models.TaskStatus.Cancelled        => "cancelled",
-        _                                                => "idle",
-    };
-
-    private static string FinishedStatusToStateKey(string status) => status switch
-    {
-        "done"               => "done",
-        "failed"             => "failed",
-        "cancelled"          => "cancelled",
-        "waiting_for_review"    => "review",
-        "waiting_for_children" => "children",
-        _                    => status.ToLowerInvariant(),
-    };
-
-    private async System.Threading.Tasks.Task RefreshStatusAsync(string taskId)
-    {
-        try
-        {
-            await using var ctx = await _dbFactory.CreateDbContextAsync();
-            var entity = await ctx.Tasks
-                .AsNoTracking()
-                .FirstOrDefaultAsync(t => t.Id == taskId);
-            if (entity is null || Task?.Id != taskId) return;
-
-            AgentState = StatusToStateKey(entity.Status);
-        }
-        catch { }
-    }
-
-    private async System.Threading.Tasks.Task RefreshOutcomeAsync(string taskId)
-    {
-        try
-        {
-            await using var ctx = await _dbFactory.CreateDbContextAsync();
-            var entity = await ctx.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Id == taskId);
-            var latestRun = await new TaskRunRepository(ctx).GetLatestByTaskIdAsync(taskId);
-            if (Task?.Id != taskId) return;
-            ApplyOutcome(entity?.Result, latestRun?.ErrorMarkdown);
-        }
-        catch { }
-    }
-
     public DetailsIslandViewModel(
         IDbContextFactory<ClaudeDoDbContext> dbFactory,
         IWorkerClient worker,
         IServiceProvider services,
-        INotesApi notesApi)
+        INotesApi notesApi,
+        IMergeCoordinator merge)
     {
         _dbFactory = dbFactory;
         _worker = worker;
         _services = services;
         _notesApi = notesApi;
+        _merge = merge;
 
-        AgentSettings = new AgentSettingsSectionViewModel(worker);
+        Monitor = new TaskMonitorViewModel(dbFactory, worker);
+        Monitor.PropertyChanged += OnMonitorPropertyChanged;
+
+        AgentSettings = new AgentConfigEditorViewModel(worker, AgentConfigScope.Task);
         Merge = new MergeSectionViewModel(worker, services);
         Prep = new PrepPanelViewModel(worker);
 
         Notes = new NotesEditorViewModel(_notesApi);
         Subtasks.CollectionChanged += (_, _) => NotifyStepsChanged();
         Subtasks.CollectionChanged += (_, _) => Merge.SyncChildOutcomes(HasChildOutcomes, Subtasks.Count);
+        Attachments.CollectionChanged += (_, _) => OnPropertyChanged(nameof(FilesBadge));
 
         AgentSettings.PropertyChanged += (_, e) =>
         {
-            if (e.PropertyName == nameof(AgentSettingsSectionViewModel.EffectiveMaxTurns))
+            if (e.PropertyName == nameof(AgentConfigEditorViewModel.EffectiveMaxTurns))
                 OnPropertyChanged(nameof(TurnsText));
         };
 
         _langChangedHandler = (_, _) => OnPropertyChanged(nameof(AgentStatusLabel));
         Loc.LanguageChanged += _langChangedHandler;
 
-        _worker.TaskMessageEvent += OnTaskMessage;
-
         _workerPropertyChangedHandler = (_, e) =>
         {
             if (e.PropertyName == nameof(IWorkerClient.IsConnected))
@@ -444,7 +326,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
 
         _workerTaskStartedHandler = (slot, taskId, startedAt) =>
         {
-            if (Task?.Id == taskId) AgentState = "running";
             _ = RefreshChildOutcomeAsync(taskId);
         };
         _worker.TaskStartedEvent += _workerTaskStartedHandler;
@@ -452,16 +333,8 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         _workerTaskFinishedHandler = (slot, taskId, status, finishedAt) =>
         {
             if (Task?.Id != taskId) return;
-            FlushClaudeBuffer();
-            Log.Add(new LogLineViewModel
-            {
-                Kind = LogKind.Done,
-                Text = $"── {status.ToUpperInvariant()} · {finishedAt.ToLocalTime():HH:mm:ss} ──",
-            });
-            AgentState = FinishedStatusToStateKey(status);
             _ = RefreshWorktreeAsync(taskId);
             _ = RefreshChildOutcomeAsync(taskId);
-            _ = RefreshOutcomeAsync(taskId);
         };
         _worker.TaskFinishedEvent += _workerTaskFinishedHandler;
 
@@ -475,7 +348,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
 
         _workerTaskUpdatedHandler = taskId =>
         {
-            if (Task?.Id == taskId) _ = RefreshStatusAsync(taskId);
             if (Task?.IsPlanningParent == true) _ = RefreshPlanningChildAsync(taskId);
             _ = RefreshChildOutcomeAsync(taskId);
         };
@@ -490,64 +362,56 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
 
     public void Dispose()
     {
+        Monitor.PropertyChanged -= OnMonitorPropertyChanged;
+        Monitor.Dispose();
         Loc.LanguageChanged -= _langChangedHandler;
         _worker.PropertyChanged -= _workerPropertyChangedHandler;
         _worker.TaskStartedEvent -= _workerTaskStartedHandler;
         _worker.TaskFinishedEvent -= _workerTaskFinishedHandler;
         _worker.WorktreeUpdatedEvent -= _workerWorktreeUpdatedHandler;
         _worker.TaskUpdatedEvent -= _workerTaskUpdatedHandler;
-        _worker.TaskMessageEvent -= OnTaskMessage;
         AgentSettings.Dispose();
         Prep.Dispose();
     }
 
-    private void OnTaskMessage(string taskId, string line)
+    private void OnMonitorPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
     {
-        if (taskId != _subscribedTaskId) return;
+        switch (e.PropertyName)
-
-        if (line.StartsWith("[stdout]", StringComparison.OrdinalIgnoreCase))
         {
-            var body = line["[stdout]".Length..].TrimStart();
+            case nameof(TaskMonitorViewModel.AgentState):
-            AppendStdoutLine(body);
+                OnPropertyChanged(nameof(AgentState));
-            return;
+                OnPropertyChanged(nameof(AgentStatusLabel));
+                OnPropertyChanged(nameof(IsIdle));
+                OnPropertyChanged(nameof(IsQueued));
+                OnPropertyChanged(nameof(IsRunning));
+                OnPropertyChanged(nameof(IsWaitingForReview));
+                OnPropertyChanged(nameof(IsWaitingForChildren));
+                OnPropertyChanged(nameof(IsDone));
+                OnPropertyChanged(nameof(IsFailed));
+                OnPropertyChanged(nameof(IsCancelled));
+                OnPropertyChanged(nameof(ShowContinue));
+                OnPropertyChanged(nameof(ShowResetAndRetry));
+                OnPropertyChanged(nameof(ShowRoadblock));
+                OnPropertyChanged(nameof(RoadblockMessage));
+                OnPropertyChanged(nameof(ShowSessionOutcome));
+                OnPropertyChanged(nameof(ShowRoadblockCard));
+                EnqueueCommand.NotifyCanExecuteChanged();
+                DequeueCommand.NotifyCanExecuteChanged();
+                ResetAndRetryCommand.NotifyCanExecuteChanged();
+                ContinueCommand.NotifyCanExecuteChanged();
+                AgentSettings.IsRunning = IsRunning;
+                NotifySessionSections();
+                OnPropertyChanged(nameof(CanAcceptDrop));
+                break;
+            case nameof(TaskMonitorViewModel.SessionOutcome):
+                OnPropertyChanged(nameof(SessionOutcome));
+                OnPropertyChanged(nameof(ShowSessionOutcome));
+                break;
+            case nameof(TaskMonitorViewModel.Roadblocks):
+                OnPropertyChanged(nameof(Roadblocks));
+                OnPropertyChanged(nameof(ShowRoadblockCard));
+                break;
         }
-
-        FlushClaudeBuffer();
-
-        var kind = line.StartsWith("[sys]", StringComparison.OrdinalIgnoreCase)    ? LogKind.Sys
-                 : line.StartsWith("[tool]", StringComparison.OrdinalIgnoreCase)   ? LogKind.Tool
-                 : line.StartsWith("[claude]", StringComparison.OrdinalIgnoreCase) ? LogKind.Claude
-                 : line.StartsWith("[stderr]", StringComparison.OrdinalIgnoreCase) ? LogKind.Stderr
-                 : line.StartsWith("[done]", StringComparison.OrdinalIgnoreCase)   ? LogKind.Done
-                 : LogKind.Msg;
-        Log.Add(new LogLineViewModel { Kind = kind, Text = line });
-    }
-
-    private void AppendStdoutLine(string line)
-    {
-        var formatted = _formatter.FormatLine(line);
-        if (formatted is null) return;
-        _claudeBuf.Append(formatted);
-        while (true)
-        {
-            var text = _claudeBuf.ToString();
-            var nl = text.IndexOf('\n');
-            if (nl < 0) break;
-            var piece = text[..nl].TrimEnd('\r');
-            if (!string.IsNullOrWhiteSpace(piece))
-                Log.Add(new LogLineViewModel { Kind = LogKind.Claude, Text = piece });
-            _claudeBuf.Clear();
-            _claudeBuf.Append(text[(nl + 1)..]);
-        }
-    }
-
-    private void FlushClaudeBuffer()
-    {
-        if (_claudeBuf.Length == 0) return;
-        var piece = _claudeBuf.ToString().TrimEnd();
-        _claudeBuf.Clear();
-        if (!string.IsNullOrWhiteSpace(piece))
-            Log.Add(new LogLineViewModel { Kind = LogKind.Claude, Text = piece });
     }
 
     partial void OnEditableDescriptionChanged(string value)
@@ -602,18 +466,16 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
 
         Task = row;
         OnPropertyChanged(nameof(TaskIdBadge));
-        Log.Clear();
+        Monitor.Reset();
         Subtasks.Clear();
         ChildOutcomes.Clear();
+        Attachments.Clear();
+        DropStatus = null;
         OnPropertyChanged(nameof(HasChildOutcomes));
-        SessionOutcome = null;
-        Roadblocks = null;
-        _claudeBuf.Clear();
         Merge.Clear();
 
         if (row == null)
         {
-            _subscribedTaskId = null;
             EditableTitle = "";
             EditableDescription = "";
             Model = null;
@@ -624,7 +486,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
             BranchLine = null;
             DiffAdditions = 0;
             DiffDeletions = 0;
-            AgentState = "idle";
             LatestRunSessionId = null;
             AgentSettings.Clear();
             return;
@@ -662,31 +523,36 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
             var (add, del) = ParseDiffStat(entity.Worktree?.DiffStat);
             DiffAdditions = add;
             DiffDeletions = del;
-            AgentState = StatusToStateKey(entity.Status);
+            Monitor.ApplyState(entity.Status);
 
             Merge.SyncTaskContext(row.Id, row.Title, row.IsPlanningParent);
             Merge.SyncWorktree(WorktreePath, WorktreeBaseCommit, WorktreeHeadCommit,
                 WorktreeStateLabel, _listWorkingDir);
 
-            AgentSettings.TaskId = row.Id;
+            await AgentSettings.LoadForTaskAsync(entity, ct);
-            await AgentSettings.LoadAsync(entity, ct);
             ct.ThrowIfCancellationRequested();
 
             var runRepo = new TaskRunRepository(ctx);
             var latestRun = await runRepo.GetLatestByTaskIdAsync(row.Id, ct);
             ct.ThrowIfCancellationRequested();
             LatestRunSessionId = latestRun?.SessionId;
-            ApplyOutcome(entity.Result, latestRun?.ErrorMarkdown);
+            Monitor.ApplyOutcome(entity.Result, latestRun?.ErrorMarkdown);
 
-            _subscribedTaskId = row.Id;
+            Monitor.SetTaskId(row.Id);
 
-            await ReplayLogFileAsync(entity.LogPath, ct);
+            await Monitor.ReplayLogFileAsync(entity.LogPath, ct);
 
             var subs = await subtaskRepo.GetByTaskIdAsync(row.Id);
             ct.ThrowIfCancellationRequested();
             foreach (var s in subs)
                 Subtasks.Add(new SubtaskRowViewModel { Id = s.Id, Title = s.Title, Done = s.Completed });
 
+            var attachmentRepo = new TaskAttachmentRepository(ctx);
+            var attachments = await attachmentRepo.ListByTaskIdAsync(row.Id, ct);
+            ct.ThrowIfCancellationRequested();
+            foreach (var a in attachments)
+                Attachments.Add(new AttachmentRowViewModel { FileName = a.FileName, ByteSize = a.ByteSize });
+
             if (entity.PlanningPhase != ClaudeDo.Data.Models.PlanningPhase.None)
                 await LoadPlanningChildrenAsync(row.Id, ct);
             await LoadChildOutcomesAsync(row.Id, ct);
@@ -754,56 +620,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         catch { /* best-effort */ }
     }
 
-    private async System.Threading.Tasks.Task ReplayLogFileAsync(string? logPath, CancellationToken ct)
-    {
-        if (string.IsNullOrWhiteSpace(logPath)) return;
-        var expanded = ExpandUserPath(logPath);
-        if (!System.IO.File.Exists(expanded)) return;
-
-        try
-        {
-            const int maxLines = 2000;
-            string[] all;
-            await using (var fs = new System.IO.FileStream(
-                             expanded,
-                             System.IO.FileMode.Open,
-                             System.IO.FileAccess.Read,
-                             System.IO.FileShare.ReadWrite | System.IO.FileShare.Delete))
-            using (var reader = new System.IO.StreamReader(fs))
-            {
-                var list = new List<string>();
-                while (await reader.ReadLineAsync(ct) is { } line)
-                    list.Add(line);
-                all = list.ToArray();
-            }
-            ct.ThrowIfCancellationRequested();
-
-            var start = Math.Max(0, all.Length - maxLines);
-            for (int i = start; i < all.Length; i++)
-            {
-                ct.ThrowIfCancellationRequested();
-                if (_subscribedTaskId is null) return;
-                var line = all[i];
-                var normalized = line.StartsWith("[", StringComparison.Ordinal) ? line : "[stdout] " + line;
-                OnTaskMessage(_subscribedTaskId, normalized);
-            }
-            FlushClaudeBuffer();
-        }
-        catch (OperationCanceledException) { throw; }
-        catch { /* best-effort replay */ }
-    }
-
-    private static string ExpandUserPath(string path)
-    {
-        if (path.StartsWith("~/", StringComparison.Ordinal) || path.StartsWith("~\\", StringComparison.Ordinal))
-            return System.IO.Path.Combine(
-                Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
-                path[2..]);
-        if (path == "~")
-            return Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
-        return path;
-    }
-
     private async System.Threading.Tasks.Task LoadPlanningChildrenAsync(string parentTaskId, CancellationToken ct)
     {
         try
@@ -907,7 +723,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
             WorktreeHeadCommit = entity.Worktree?.HeadCommit;
             WorktreeStateLabel = entity.Worktree?.State.ToString();
             BranchLine = entity.Worktree is { } w ? $"{w.BranchName} ← main" : null;
-            AgentState = StatusToStateKey(entity.Status);
             if (Task is { } row && entity.Worktree?.DiffStat is { } stat)
                 row.DiffStat = stat;
             var (add, del) = ParseDiffStat(entity.Worktree?.DiffStat);
@@ -935,6 +750,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     {
         Merge.SyncTaskContext(Task?.Id, Task?.Title, Task?.IsPlanningParent == true);
         NotifySessionSections();
+        OnPropertyChanged(nameof(CanAcceptDrop));
     }
 
     [RelayCommand]
@@ -966,7 +782,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
             ? ClaudeDo.Data.Models.TaskStatus.Done
             : ClaudeDo.Data.Models.TaskStatus.Idle;
         Task.Status = entity.Status;
-        AgentState = StatusToStateKey(entity.Status);
+        Monitor.ApplyState(entity.Status);
         await repo.UpdateAsync(entity);
     }
 
@@ -1151,20 +967,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
             var hasChildren = Subtasks.Count > 0 || ChildOutcomes.Count > 0;
             var result = await _worker.ApproveReviewAsync(Task.Id, Merge.SelectedMergeTarget ?? "");
             if (!hasChildren && result?.Status == "conflict")
-            {
+                await _merge.ResolveConflictAsync(Task.Id, Merge.SelectedMergeTarget ?? "");
-                if (Merge.RequestConflictResolution is not null)
-                {
-                    await Merge.RequestConflictResolution(Task.Id, Merge.SelectedMergeTarget ?? "");
-                }
-                else
-                {
-                    var (text, _, _) = MergePreviewPresenter.Describe(
-                        new MergePreviewDto("conflict", result.ConflictFiles, 0));
-                    Merge.MergePreviewText = text;
-                    Merge.MergeIsClean = false;
-                    Merge.MergeIsConflict = true;
-                }
-            }
         }
         catch (Exception ex)
         {
@@ -1213,6 +1016,107 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         catch { /* stale review action; broadcast reconciles */ }
     }
 
+    private async System.Threading.Tasks.Task ReloadAttachmentsAsync()
+    {
+        if (Task is null) return;
+        try
+        {
+            await using var ctx = await _dbFactory.CreateDbContextAsync();
+            var attachments = await new TaskAttachmentRepository(ctx).ListByTaskIdAsync(Task.Id);
+            Attachments.Clear();
+            foreach (var a in attachments)
+                Attachments.Add(new AttachmentRowViewModel { FileName = a.FileName, ByteSize = a.ByteSize });
+            OnPropertyChanged(nameof(ComposedPreview));
+        }
+        catch { /* best-effort */ }
+    }
+
+    public async System.Threading.Tasks.Task AddFilesAsync(IReadOnlyList<(string FileName, Stream Content)> files)
+    {
+        DetailSection = "files";
+        if (Task is null || Task.IsRunning)
+        {
+            DropStatus = Loc.T("details.attachments.selectIdleTask");
+            return;
+        }
+
+        var store = new AttachmentStore();
+        var successes = new List<string>();
+        var failures = new List<string>();
+
+        foreach (var (fileName, content) in files)
+        {
+            try
+            {
+                var byteSize = await store.SaveAsync(Task.Id, fileName, content);
+                await using var ctx = await _dbFactory.CreateDbContextAsync();
+                var repo = new TaskAttachmentRepository(ctx);
+                var existing = await repo.GetAsync(Task.Id, fileName);
+                if (existing is not null)
+                {
+                    existing.ByteSize = byteSize;
+                    await repo.UpdateAsync(existing);
+                }
+                else
+                {
+                    await repo.AddAsync(new ClaudeDo.Data.Models.TaskAttachmentEntity
+                    {
+                        Id = Guid.NewGuid().ToString(),
+                        TaskId = Task.Id,
+                        FileName = fileName,
+                        ByteSize = byteSize,
+                        CreatedAt = DateTime.UtcNow,
+                    });
+                }
+                successes.Add(fileName);
+            }
+            catch (InvalidOperationException ex)
+            {
+                failures.Add(string.Format(Loc.T("details.attachments.overLimitError"), fileName, ex.Message));
+            }
+            catch (ArgumentException ex)
+            {
+                failures.Add(string.Format(Loc.T("details.attachments.invalidNameError"), fileName, ex.Message));
+            }
+            catch (Exception ex)
+            {
+                failures.Add($"{fileName}: {ex.Message}");
+            }
+        }
+
+        await ReloadAttachmentsAsync();
+
+        if (failures.Count == 0)
+        {
+            var names = string.Join(", ", successes);
+            DropStatus = string.Format(Loc.T("details.attachments.addedSummary"), names, successes.Count);
+        }
+        else if (successes.Count == 0)
+        {
+            DropStatus = string.Join(" · ", failures);
+        }
+        else
+        {
+            var names = string.Join(", ", successes);
+            var addedPart = string.Format(Loc.T("details.attachments.addedSummary"), names, successes.Count);
+            DropStatus = addedPart + " · " + string.Join(" · ", failures);
+        }
+    }
+
+    [RelayCommand]
+    private async System.Threading.Tasks.Task RemoveAttachment(AttachmentRowViewModel? row)
+    {
+        if (row is null || Task is null) return;
+        try
+        {
+            new AttachmentStore().DeleteFile(Task.Id, row.FileName);
+            await using var ctx = await _dbFactory.CreateDbContextAsync();
+            await new TaskAttachmentRepository(ctx).DeleteAsync(Task.Id, row.FileName);
+            await ReloadAttachmentsAsync();
+        }
+        catch { /* best-effort */ }
+    }
+
     internal static (int Additions, int Deletions) ParseDiffStat(string? stat)
     {
         if (string.IsNullOrEmpty(stat)) return (0, 0);
@@ -1225,6 +1129,18 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     }
 }
 
+public sealed class AttachmentRowViewModel
+{
+    public required string FileName { get; init; }
+    public required long ByteSize { get; init; }
+    public string SizeText => ByteSize switch
+    {
+        >= 1024 * 1024 => $"{ByteSize / (1024.0 * 1024.0):F1} MB",
+        >= 1024 => $"{ByteSize / 1024.0:F1} KB",
+        _ => $"{ByteSize} B",
+    };
+}
+
 public sealed partial class SubtaskRowViewModel : ViewModelBase
 {
     public required string Id { get; init; }

src/ClaudeDo.Ui/ViewModels/Islands/ListsIslandViewModel.cs

@@ -27,28 +27,25 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
     public event EventHandler? FocusSearchRequested;
     public void RequestFocusSearch() => FocusSearchRequested?.Invoke(this, EventArgs.Empty);
 
-    public Func<SettingsModalViewModel, Task>? ShowSettingsModal { get; set; }
+    public IDialogService? Dialogs { get; set; }
-    public Func<ListSettingsModalViewModel, System.Threading.Tasks.Task>? ShowListSettingsModal { get; set; }
-    public Func<WorktreesOverviewModalViewModel, Task>? ShowWorktreesOverviewModal { get; set; }
-    public Func<RepoImportModalViewModel, System.Threading.Tasks.Task>? ShowRepoImportModal { get; set; }
 
     [RelayCommand]
     private async Task OpenSettings()
     {
-        if (ShowSettingsModal is null || _services is null) return;
+        if (Dialogs is null || _services is null) return;
         var settingsVm = _services.GetRequiredService<SettingsModalViewModel>();
         await settingsVm.LoadAsync();
-        await ShowSettingsModal(settingsVm);
+        await Dialogs.ShowSettingsAsync(settingsVm);
     }
 
     [RelayCommand]
     private async System.Threading.Tasks.Task OpenListSettingsAsync(ListNavItemViewModel? row)
     {
-        if (row is null || ShowListSettingsModal is null || _services is null) return;
+        if (row is null || Dialogs is null || _services is null) return;
         var rawId = row.Id.StartsWith("user:", StringComparison.Ordinal) ? row.Id["user:".Length..] : row.Id;
         var vm = _services.GetRequiredService<ListSettingsModalViewModel>();
         await vm.LoadAsync(rawId, row.Name, row.WorkingDir, row.DefaultCommitType);
-        await ShowListSettingsModal(vm);
+        await Dialogs.ShowListSettingsAsync(vm);
         if (vm.Deleted) await LoadAsync();
         else await RefreshRowAsync(row.Id);
     }
@@ -56,10 +53,10 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
     [RelayCommand]
     private async System.Threading.Tasks.Task OpenRepoImportAsync()
     {
-        if (ShowRepoImportModal is null || _services is null) return;
+        if (Dialogs is null || _services is null) return;
         var vm = _services.GetRequiredService<RepoImportModalViewModel>();
         await vm.LoadAsync();
-        await ShowRepoImportModal(vm);
+        await Dialogs.ShowRepoImportAsync(vm);
         await LoadAsync();
     }
 
@@ -68,7 +65,7 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
     [RelayCommand]
     private async Task OpenWorktreesOverviewAsync(ListNavItemViewModel? row)
     {
-        if (row is null || ShowWorktreesOverviewModal is null || _services is null) return;
+        if (row is null || Dialogs is null || _services is null) return;
         if (row.Kind != ListKind.User) return;
         if (_worktreesOverviewOpen) return;
         _worktreesOverviewOpen = true;
@@ -78,7 +75,7 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
             var vm = _services.GetRequiredService<WorktreesOverviewModalViewModel>();
             vm.Configure(rawId, row.Name);
             await vm.LoadAsync();
-            await ShowWorktreesOverviewModal(vm);
+            await Dialogs.ShowWorktreesOverviewAsync(vm);
         }
         finally { _worktreesOverviewOpen = false; }
     }
@@ -297,11 +294,11 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
         UserLists.Add(item);
         SelectedList = item;
 
-        if (ShowListSettingsModal is not null && _services is not null)
+        if (Dialogs is not null && _services is not null)
         {
             var vm = _services.GetRequiredService<ListSettingsModalViewModel>();
             await vm.LoadAsync(entity.Id, entity.Name, entity.WorkingDir, entity.DefaultCommitType);
-            await ShowListSettingsModal(vm);
+            await Dialogs.ShowListSettingsAsync(vm);
             if (vm.Deleted) await LoadAsync();
             else await RefreshRowAsync(item.Id);
         }

src/ClaudeDo.Ui/ViewModels/Islands/LogLineViewModel.cs

@@ -0,0 +1,34 @@
+namespace ClaudeDo.Ui.ViewModels.Islands;
+
+public enum LogKind { Sys, Tool, Claude, Stdout, Stderr, Done, Msg, User }
+
+public sealed class LogLineViewModel
+{
+    public required LogKind Kind { get; init; }
+    public required string Text { get; init; }
+    public string TimestampFormatted { get; } = DateTime.Now.ToString("HH:mm:ss");
+    public string KindMarker => Kind switch
+    {
+        LogKind.Sys    => "sys",
+        LogKind.Tool   => "tool",
+        LogKind.Claude => "claude",
+        LogKind.Stdout => "out",
+        LogKind.Stderr => "err",
+        LogKind.Done   => "done",
+        LogKind.Msg    => "claude",
+        LogKind.User   => "you",
+        _              => "",
+    };
+    public string ClassName => Kind switch
+    {
+        LogKind.Sys    => "log-sys",
+        LogKind.Tool   => "log-tool",
+        LogKind.Claude => "log-claude",
+        LogKind.Stdout => "log-stdout",
+        LogKind.Stderr => "log-stderr",
+        LogKind.Done   => "log-done",
+        LogKind.Msg    => "log-msg",
+        LogKind.User   => "log-user",
+        _              => "",
+    };
+}

src/ClaudeDo.Ui/ViewModels/Islands/MergeSectionViewModel.cs

@@ -45,10 +45,8 @@ public sealed partial class MergeSectionViewModel : ViewModelBase
     public bool ShowMergeSection =>
         _worktreePath != null || _isPlanningParent || _hasChildOutcomes;
 
-    public Func<DiffModalViewModel, System.Threading.Tasks.Task>? ShowDiffModal { get; set; }
+    public Func<DiffViewerViewModel, System.Threading.Tasks.Task>? ShowDiffViewer { get; set; }
     public Func<MergeModalViewModel, System.Threading.Tasks.Task>? ShowMergeModal { get; set; }
-    public Func<ViewModels.Planning.PlanningDiffViewModel, System.Threading.Tasks.Task>? ShowPlanningDiffModal { get; set; }
-    public Func<string, string, System.Threading.Tasks.Task>? RequestConflictResolution { get; set; }
 
     public MergeSectionViewModel(IWorkerClient worker, IServiceProvider services)
     {
@@ -126,10 +124,11 @@ public sealed partial class MergeSectionViewModel : ViewModelBase
     [RelayCommand(CanExecute = nameof(CanReviewDiff))]
     private async System.Threading.Tasks.Task ReviewCombinedDiffAsync()
     {
-        if (TaskId is null || ShowPlanningDiffModal is null) return;
+        if (TaskId is null || ShowDiffViewer is null) return;
-        var vm = new ViewModels.Planning.PlanningDiffViewModel(_worker, TaskId, SelectedMergeTarget ?? "main");
+        var vm = _services.GetRequiredService<DiffViewerViewModel>();
-        await vm.InitializeAsync();
+        vm.ConfigurePlanning(TaskId, SelectedMergeTarget ?? "main");
-        await ShowPlanningDiffModal(vm);
+        await vm.LoadAsync();
+        await ShowDiffViewer(vm);
     }
 
     private bool CanReviewDiff() => (_isPlanningParent && _subtaskCount > 0) || _hasChildOutcomes;
@@ -137,44 +136,28 @@ public sealed partial class MergeSectionViewModel : ViewModelBase
     [RelayCommand(CanExecute = nameof(CanOpenDiff))]
     private async System.Threading.Tasks.Task OpenDiffAsync()
     {
-        if (ShowDiffModal is null) return;
+        if (ShowDiffViewer is null) return;
-        var git = _services.GetRequiredService<ClaudeDo.Data.Git.GitService>();
 
         var hasLiveWorktree =
             _worktreePath != null
             && _worktreeStateLabel == "Active"
             && System.IO.Directory.Exists(_worktreePath);
 
-        DiffModalViewModel diffVm;
+        var vm = _services.GetRequiredService<DiffViewerViewModel>();
         if (hasLiveWorktree)
         {
-            diffVm = new DiffModalViewModel(git)
+            vm.ConfigureWorktree(_worktreePath!, _worktreeBaseCommit, TaskId, TaskTitle ?? "");
-            {
+            vm.ShowMergeModal = ShowMergeModal;
-                WorktreePath = _worktreePath!,
+            vm.ResolveMergeVm = () => _services.GetRequiredService<MergeModalViewModel>();
-                BaseRef = _worktreeBaseCommit,
-                TaskId = TaskId,
-                TaskTitle = TaskTitle ?? "",
-                ShowMergeModal = ShowMergeModal,
-                ResolveMergeVm = () => _services.GetRequiredService<MergeModalViewModel>(),
-                RequestConflictResolution = RequestConflictResolution,
-            };
         }
         else if (CanDiffMergedRange)
         {
-            diffVm = new DiffModalViewModel(git)
+            vm.ConfigureCommitRange(_listWorkingDir!, _worktreeBaseCommit, _worktreeHeadCommit, TaskId, TaskTitle ?? "");
-            {
-                WorktreePath = _listWorkingDir!,
-                BaseRef = _worktreeBaseCommit,
-                HeadCommit = _worktreeHeadCommit,
-                FromCommitRange = true,
-                TaskId = TaskId,
-                TaskTitle = TaskTitle ?? "",
-            };
         }
         else return;
 
-        await diffVm.LoadAsync();
+        await vm.LoadAsync();
-        await ShowDiffModal(diffVm);
+        await ShowDiffViewer(vm);
     }
 
     private bool CanDiffMergedRange =>

src/ClaudeDo.Ui/ViewModels/Islands/TaskMonitorViewModel.cs

@@ -0,0 +1,537 @@
+using System.Collections.ObjectModel;
+using System.Text;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using ClaudeDo.Data;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Ui.Helpers;
+using ClaudeDo.Ui.Localization;
+using ClaudeDo.Ui.Services;
+using Microsoft.EntityFrameworkCore;
+
+namespace ClaudeDo.Ui.ViewModels.Islands;
+
+public sealed partial class TaskMonitorViewModel : ViewModelBase, IDisposable
+{
+    private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
+    private readonly IWorkerClient _worker;
+
+    private readonly StreamLineFormatter _formatter = new();
+    private readonly StringBuilder _claudeBuf = new();
+    private string? _subscribedTaskId;
+
+    public string? SubscribedTaskId => _subscribedTaskId;
+
+    public ObservableCollection<LogLineViewModel> Log { get; } = new();
+
+    [ObservableProperty] private string _agentState = "idle";
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(DisplayTitle))]
+    private string? _title;
+
+    public string DisplayTitle =>
+        string.IsNullOrWhiteSpace(Title) ? (SubscribedTaskId ?? "task") : Title!;
+
+    public string AgentStatusLabel => Loc.T($"vm.agentStatus.{AgentState}");
+    public bool IsIdle               => AgentState == "idle";
+    public bool IsQueued             => AgentState == "queued";
+    public bool IsRunning            => AgentState == "running";
+    public bool IsWaitingForReview   => AgentState == "review";
+    public bool IsWaitingForChildren => AgentState == "children";
+    public bool IsDone               => AgentState == "done";
+    public bool IsFailed             => AgentState == "failed";
+    public bool IsCancelled          => AgentState == "cancelled";
+
+    public bool ShowContinue       => IsFailed || IsCancelled;
+    public bool ShowResetAndRetry  => IsFailed || IsCancelled || IsDone;
+
+    public bool ShowRoadblock      => IsFailed;
+    public string RoadblockMessage => IsFailed ? "The session ended with an error." : "";
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowSessionOutcome))]
+    private string? _sessionOutcome;
+
+    public bool ShowSessionOutcome =>
+        !string.IsNullOrWhiteSpace(SessionOutcome)
+        && (IsWaitingForReview || IsDone || IsFailed || IsCancelled);
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowRoadblockCard))]
+    [NotifyPropertyChangedFor(nameof(HasRoadblock))]
+    private string? _roadblocks;
+
+    public bool HasRoadblock => !string.IsNullOrWhiteSpace(Roadblocks);
+
+    public bool ShowRoadblockCard =>
+        !string.IsNullOrWhiteSpace(Roadblocks)
+        && (IsWaitingForReview || IsDone || IsFailed || IsCancelled);
+
+    private const string RoadblockMarker = "Roadblocks reported during the run:";
+
+    public ObservableCollection<QueuedMessageViewModel> QueuedMessages { get; } = new();
+    public bool HasQueuedMessages => QueuedMessages.Count > 0;
+
+    // Captured handler delegates for disposal
+    private readonly Action<string, string> _onTaskMessage;
+    private readonly Action<string, string, DateTime> _onTaskStarted;
+    private readonly Action<string, string, string, DateTime> _onTaskFinished;
+    private readonly Action<string> _onTaskUpdated;
+    private readonly Action<string, string, string> _onTaskQuestionAsked;
+    private readonly Action<string, string> _onTaskQuestionResolved;
+    private readonly Action<string> _onInteractiveStarted;
+    private readonly Action<string> _onInteractiveEnded;
+    private readonly Action<string, IReadOnlyList<string>> _onInteractiveQueueChanged;
+    private readonly Action<string, string> _onInteractiveMessageSent;
+
+    // Interactive composer — active while the worker is in an interactive session.
+    [ObservableProperty]
+    [NotifyCanExecuteChangedFor(nameof(SubmitComposerCommand))]
+    private bool _isInteractiveLive;
+
+    [ObservableProperty]
+    [NotifyCanExecuteChangedFor(nameof(SubmitComposerCommand))]
+    private string _composerDraft = string.Empty;
+
+    // A question the running task raised via AskUser and is blocking on, plus the answer
+    // the user is typing. Ephemeral (in-memory + live events) — the task is still Running.
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasPendingQuestion))]
+    [NotifyCanExecuteChangedFor(nameof(SubmitAnswerCommand))]
+    private string? _pendingQuestionId;
+
+    [ObservableProperty] private string? _pendingQuestion;
+
+    [ObservableProperty]
+    [NotifyCanExecuteChangedFor(nameof(SubmitAnswerCommand))]
+    private string _answerDraft = string.Empty;
+
+    public bool HasPendingQuestion => PendingQuestionId is not null;
+
+    public TaskMonitorViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, IWorkerClient worker)
+    {
+        _dbFactory = dbFactory;
+        _worker = worker;
+
+        _onTaskMessage = OnTaskMessage;
+        _worker.TaskMessageEvent += _onTaskMessage;
+
+        _onTaskStarted = (slot, taskId, startedAt) =>
+        {
+            if (taskId == _subscribedTaskId)
+                AgentState = "running";
+        };
+        _worker.TaskStartedEvent += _onTaskStarted;
+
+        _onTaskFinished = (slot, taskId, status, finishedAt) =>
+        {
+            if (taskId != _subscribedTaskId) return;
+            FlushClaudeBuffer();
+            Log.Add(new LogLineViewModel
+            {
+                Kind = LogKind.Done,
+                Text = $"── {status.ToUpperInvariant()} · {finishedAt.ToLocalTime():HH:mm:ss} ──",
+            });
+            AgentState = FinishedStatusToStateKey(status);
+            ClearPendingQuestion();
+            _ = RefreshOutcomeAsync(taskId);
+        };
+        _worker.TaskFinishedEvent += _onTaskFinished;
+
+        _onTaskUpdated = taskId =>
+        {
+            if (taskId == _subscribedTaskId)
+                _ = RefreshStatusAsync(taskId);
+        };
+        _worker.TaskUpdatedEvent += _onTaskUpdated;
+
+        _onTaskQuestionAsked = (taskId, questionId, question) =>
+        {
+            if (taskId != _subscribedTaskId) return;
+            PendingQuestionId = questionId;
+            PendingQuestion = question;
+        };
+        _worker.TaskQuestionAskedEvent += _onTaskQuestionAsked;
+
+        _onTaskQuestionResolved = (taskId, questionId) =>
+        {
+            if (taskId == _subscribedTaskId && PendingQuestionId == questionId)
+                ClearPendingQuestion();
+        };
+        _worker.TaskQuestionResolvedEvent += _onTaskQuestionResolved;
+
+        _onInteractiveStarted = taskId =>
+        {
+            if (taskId == _subscribedTaskId) { IsInteractiveLive = true; AgentState = "running"; }
+        };
+        _worker.InteractiveSessionStartedEvent += _onInteractiveStarted;
+
+        _onInteractiveEnded = taskId =>
+        {
+            if (taskId != _subscribedTaskId) return;
+            IsInteractiveLive = false;
+            AgentState = "done";
+            QueuedMessages.Clear();
+            OnPropertyChanged(nameof(HasQueuedMessages));
+        };
+        _worker.InteractiveSessionEndedEvent += _onInteractiveEnded;
+
+        _onInteractiveQueueChanged = (taskId, pending) =>
+        {
+            if (taskId != _subscribedTaskId) return;
+            QueuedMessages.Clear();
+            foreach (var m in pending)
+            {
+                var text = m;
+                QueuedMessages.Add(new QueuedMessageViewModel
+                {
+                    Text = text,
+                    RemoveCommand = new CommunityToolkit.Mvvm.Input.RelayCommand(() => _ = RemoveQueuedAsync(text)),
+                });
+            }
+            OnPropertyChanged(nameof(HasQueuedMessages));
+        };
+        _worker.InteractiveQueueChangedEvent += _onInteractiveQueueChanged;
+
+        _onInteractiveMessageSent = (taskId, text) =>
+        {
+            if (taskId == _subscribedTaskId)
+                Log.Add(new LogLineViewModel { Kind = LogKind.User, Text = text });
+        };
+        _worker.InteractiveMessageSentEvent += _onInteractiveMessageSent;
+    }
+
+    // Surface a pending question (used by live event + re-attach hydration).
+    public void SetPendingQuestion(string questionId, string question)
+    {
+        PendingQuestionId = questionId;
+        PendingQuestion = question;
+    }
+
+    // Used by Mission Control when it creates the monitor after the started event already fired.
+    public void SetInteractiveLive(bool live)
+    {
+        IsInteractiveLive = live;
+        if (live) AgentState = "running";
+    }
+
+    [RelayCommand(CanExecute = nameof(CanSubmitComposer))]
+    private async System.Threading.Tasks.Task SubmitComposer()
+    {
+        if (string.IsNullOrEmpty(_subscribedTaskId)) return;
+        var text = ComposerDraft;
+        if (string.IsNullOrWhiteSpace(text)) return;
+        ComposerDraft = string.Empty;
+        await _worker.SendInteractiveMessageAsync(_subscribedTaskId, text);
+    }
+
+    private bool CanSubmitComposer() => IsInteractiveLive && !string.IsNullOrWhiteSpace(ComposerDraft);
+
+    [RelayCommand]
+    private async System.Threading.Tasks.Task StopInteractive()
+    {
+        if (!string.IsNullOrEmpty(_subscribedTaskId) && IsInteractiveLive)
+            await _worker.StopInteractiveSessionAsync(_subscribedTaskId);
+    }
+
+    [RelayCommand]
+    private async System.Threading.Tasks.Task InterruptInteractive()
+    {
+        if (!string.IsNullOrEmpty(_subscribedTaskId) && IsInteractiveLive)
+            await _worker.InterruptInteractiveSessionAsync(_subscribedTaskId);
+    }
+
+    private async System.Threading.Tasks.Task RemoveQueuedAsync(string text)
+    {
+        if (!string.IsNullOrEmpty(_subscribedTaskId))
+            await _worker.RemoveQueuedInteractiveMessageAsync(_subscribedTaskId, text);
+    }
+
+    private void ClearPendingQuestion()
+    {
+        PendingQuestionId = null;
+        PendingQuestion = null;
+        AnswerDraft = string.Empty;
+    }
+
+    [RelayCommand(CanExecute = nameof(CanSubmitAnswer))]
+    private async System.Threading.Tasks.Task SubmitAnswer()
+    {
+        var questionId = PendingQuestionId;
+        if (questionId is null || string.IsNullOrEmpty(_subscribedTaskId)) return;
+        var answer = AnswerDraft;
+        if (string.IsNullOrWhiteSpace(answer)) return;
+        ClearPendingQuestion();                 // optimistic; the resolved event also clears
+        await _worker.AnswerTaskQuestionAsync(_subscribedTaskId, questionId, answer);
+    }
+
+    private bool CanSubmitAnswer() => HasPendingQuestion && !string.IsNullOrWhiteSpace(AnswerDraft);
+
+    partial void OnAgentStateChanged(string value)
+    {
+        OnPropertyChanged(nameof(AgentStatusLabel));
+        OnPropertyChanged(nameof(IsIdle));
+        OnPropertyChanged(nameof(IsQueued));
+        OnPropertyChanged(nameof(IsRunning));
+        OnPropertyChanged(nameof(IsWaitingForReview));
+        OnPropertyChanged(nameof(IsWaitingForChildren));
+        OnPropertyChanged(nameof(IsDone));
+        OnPropertyChanged(nameof(IsFailed));
+        OnPropertyChanged(nameof(IsCancelled));
+        OnPropertyChanged(nameof(ShowContinue));
+        OnPropertyChanged(nameof(ShowResetAndRetry));
+        OnPropertyChanged(nameof(ShowRoadblock));
+        OnPropertyChanged(nameof(RoadblockMessage));
+        OnPropertyChanged(nameof(ShowSessionOutcome));
+        OnPropertyChanged(nameof(ShowRoadblockCard));
+    }
+
+    public void Reset()
+    {
+        Log.Clear();
+        _claudeBuf.Clear();
+        _subscribedTaskId = null;
+        AgentState = "idle";
+        SessionOutcome = null;
+        Roadblocks = null;
+        ClearPendingQuestion();
+        IsInteractiveLive = false;
+        ComposerDraft = string.Empty;
+        QueuedMessages.Clear();
+        OnPropertyChanged(nameof(HasQueuedMessages));
+    }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(DetachTooltip))]
+    private bool _isDetached;
+
+    // Localized tooltip for the detach/re-dock toggle button.
+    public string DetachTooltip => Loc.T(IsDetached ? "missionControl.redock" : "missionControl.detach");
+
+    // Set by the detached window so the re-dock action can close it.
+    public Action? CloseWindowRequested { get; set; }
+
+    // Set by the host (e.g. Mission Control) to navigate the main app to this task.
+    public Action<string>? OpenInAppRequested { get; set; }
+
+    // Set by the host (Mission Control) to pop this monitor out into its own window.
+    public Action<TaskMonitorViewModel>? DetachRequested { get; set; }
+
+    [RelayCommand]
+    private void Detach()
+    {
+        if (IsDetached) CloseWindowRequested?.Invoke();   // re-dock: close the detached window
+        else DetachRequested?.Invoke(this);               // detach: pop out to its own window
+    }
+
+    [RelayCommand]
+    private void OpenInApp()
+    {
+        if (!string.IsNullOrEmpty(_subscribedTaskId))
+            OpenInAppRequested?.Invoke(_subscribedTaskId);
+    }
+
+    [RelayCommand]
+    private async System.Threading.Tasks.Task CancelTask()
+    {
+        if (!string.IsNullOrEmpty(_subscribedTaskId) && (IsRunning || IsQueued))
+            await _worker.CancelTaskAsync(_subscribedTaskId);
+    }
+
+    public void SetTaskId(string id) => _subscribedTaskId = id;
+
+    public void ApplyState(ClaudeDo.Data.Models.TaskStatus status) =>
+        AgentState = StatusToStateKey(status);
+
+    public void ApplyOutcome(string? result, string? errorFallback)
+    {
+        if (string.IsNullOrWhiteSpace(result))
+        {
+            SessionOutcome = errorFallback;
+            Roadblocks = null;
+            return;
+        }
+
+        var idx = result.IndexOf(RoadblockMarker, StringComparison.Ordinal);
+        if (idx < 0)
+        {
+            SessionOutcome = result;
+            Roadblocks = null;
+            return;
+        }
+
+        var summary = result[..idx].TrimEnd().TrimEnd('⚠').TrimEnd();
+        SessionOutcome = string.IsNullOrWhiteSpace(summary) ? null : summary;
+        Roadblocks = result[(idx + RoadblockMarker.Length)..].Trim();
+    }
+
+    public async System.Threading.Tasks.Task ReplayLogFileAsync(string? logPath, CancellationToken ct)
+    {
+        if (string.IsNullOrWhiteSpace(logPath)) return;
+        var expanded = ExpandUserPath(logPath);
+        if (!System.IO.File.Exists(expanded)) return;
+
+        try
+        {
+            const int maxLines = 2000;
+            string[] all;
+            await using (var fs = new System.IO.FileStream(
+                             expanded,
+                             System.IO.FileMode.Open,
+                             System.IO.FileAccess.Read,
+                             System.IO.FileShare.ReadWrite | System.IO.FileShare.Delete))
+            using (var reader = new System.IO.StreamReader(fs))
+            {
+                var list = new List<string>();
+                while (await reader.ReadLineAsync(ct) is { } line)
+                    list.Add(line);
+                all = list.ToArray();
+            }
+            ct.ThrowIfCancellationRequested();
+
+            var start = Math.Max(0, all.Length - maxLines);
+            for (int i = start; i < all.Length; i++)
+            {
+                ct.ThrowIfCancellationRequested();
+                if (_subscribedTaskId is null) return;
+                var line = all[i];
+                var normalized = line.StartsWith("[", StringComparison.Ordinal) ? line : "[stdout] " + line;
+                OnTaskMessage(_subscribedTaskId, normalized);
+            }
+            FlushClaudeBuffer();
+        }
+        catch (OperationCanceledException) { throw; }
+        catch { /* best-effort replay */ }
+    }
+
+    private void OnTaskMessage(string taskId, string line)
+    {
+        if (taskId != _subscribedTaskId) return;
+
+        if (line.StartsWith("[stdout]", StringComparison.OrdinalIgnoreCase))
+        {
+            var body = line["[stdout]".Length..].TrimStart();
+            AppendStdoutLine(body);
+            return;
+        }
+
+        FlushClaudeBuffer();
+
+        var kind = line.StartsWith("[sys]", StringComparison.OrdinalIgnoreCase)    ? LogKind.Sys
+                 : line.StartsWith("[tool]", StringComparison.OrdinalIgnoreCase)   ? LogKind.Tool
+                 : line.StartsWith("[claude]", StringComparison.OrdinalIgnoreCase) ? LogKind.Claude
+                 : line.StartsWith("[stderr]", StringComparison.OrdinalIgnoreCase) ? LogKind.Stderr
+                 : line.StartsWith("[done]", StringComparison.OrdinalIgnoreCase)   ? LogKind.Done
+                 : LogKind.Msg;
+        Log.Add(new LogLineViewModel { Kind = kind, Text = line });
+    }
+
+    private void AppendStdoutLine(string line)
+    {
+        var formatted = _formatter.FormatLine(line);
+        if (formatted is null) return;
+        _claudeBuf.Append(formatted);
+        while (true)
+        {
+            var text = _claudeBuf.ToString();
+            var nl = text.IndexOf('\n');
+            if (nl < 0) break;
+            var piece = text[..nl].TrimEnd('\r');
+            if (!string.IsNullOrWhiteSpace(piece))
+                Log.Add(new LogLineViewModel { Kind = LogKind.Claude, Text = piece });
+            _claudeBuf.Clear();
+            _claudeBuf.Append(text[(nl + 1)..]);
+        }
+    }
+
+    private void FlushClaudeBuffer()
+    {
+        if (_claudeBuf.Length == 0) return;
+        var piece = _claudeBuf.ToString().TrimEnd();
+        _claudeBuf.Clear();
+        if (!string.IsNullOrWhiteSpace(piece))
+            Log.Add(new LogLineViewModel { Kind = LogKind.Claude, Text = piece });
+    }
+
+    private async System.Threading.Tasks.Task RefreshStatusAsync(string taskId)
+    {
+        try
+        {
+            await using var ctx = await _dbFactory.CreateDbContextAsync();
+            var entity = await ctx.Tasks
+                .AsNoTracking()
+                .FirstOrDefaultAsync(t => t.Id == taskId);
+            if (entity is null || _subscribedTaskId != taskId) return;
+
+            AgentState = StatusToStateKey(entity.Status);
+        }
+        catch { }
+    }
+
+    private async System.Threading.Tasks.Task RefreshOutcomeAsync(string taskId)
+    {
+        try
+        {
+            await using var ctx = await _dbFactory.CreateDbContextAsync();
+            var entity = await ctx.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Id == taskId);
+            var latestRun = await new TaskRunRepository(ctx).GetLatestByTaskIdAsync(taskId);
+            if (_subscribedTaskId != taskId) return;
+            ApplyOutcome(entity?.Result, latestRun?.ErrorMarkdown);
+        }
+        catch { }
+    }
+
+    internal static string StatusToStateKey(ClaudeDo.Data.Models.TaskStatus status) => status switch
+    {
+        ClaudeDo.Data.Models.TaskStatus.Queued              => "queued",
+        ClaudeDo.Data.Models.TaskStatus.Running             => "running",
+        ClaudeDo.Data.Models.TaskStatus.WaitingForReview    => "review",
+        ClaudeDo.Data.Models.TaskStatus.WaitingForChildren  => "children",
+        ClaudeDo.Data.Models.TaskStatus.Done                => "done",
+        ClaudeDo.Data.Models.TaskStatus.Failed              => "failed",
+        ClaudeDo.Data.Models.TaskStatus.Cancelled           => "cancelled",
+        _                                                   => "idle",
+    };
+
+    internal static string FinishedStatusToStateKey(string status) => status switch
+    {
+        "done"                  => "done",
+        "failed"                => "failed",
+        "cancelled"             => "cancelled",
+        "waiting_for_review"    => "review",
+        "waiting_for_children"  => "children",
+        _                       => status.ToLowerInvariant(),
+    };
+
+    private static string ExpandUserPath(string path)
+    {
+        if (path.StartsWith("~/", StringComparison.Ordinal) || path.StartsWith("~\\", StringComparison.Ordinal))
+            return System.IO.Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+                path[2..]);
+        if (path == "~")
+            return Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+        return path;
+    }
+
+    public void Dispose()
+    {
+        _worker.TaskMessageEvent  -= _onTaskMessage;
+        _worker.TaskStartedEvent  -= _onTaskStarted;
+        _worker.TaskFinishedEvent -= _onTaskFinished;
+        _worker.TaskUpdatedEvent  -= _onTaskUpdated;
+        _worker.TaskQuestionAskedEvent    -= _onTaskQuestionAsked;
+        _worker.TaskQuestionResolvedEvent -= _onTaskQuestionResolved;
+        _worker.InteractiveSessionStartedEvent -= _onInteractiveStarted;
+        _worker.InteractiveSessionEndedEvent   -= _onInteractiveEnded;
+        _worker.InteractiveQueueChangedEvent   -= _onInteractiveQueueChanged;
+        _worker.InteractiveMessageSentEvent    -= _onInteractiveMessageSent;
+    }
+}
+
+public sealed class QueuedMessageViewModel
+{
+    public required string Text { get; init; }
+    public required System.Windows.Input.ICommand RemoveCommand { get; init; }
+}

src/ClaudeDo.Ui/ViewModels/Islands/TaskRowViewModel.cs

@@ -35,6 +35,8 @@ public sealed partial class TaskRowViewModel : ViewModelBase
     [ObservableProperty] private bool _parentInView = true;
     [ObservableProperty] private int _roadblockCount;
     [ObservableProperty] private bool _isRefining;
+    // Set by the custom drag while this row is being dragged — drives the "grabbed" row style.
+    [ObservableProperty] private bool _isDragging;
 
     public bool CanRefine => Status == TaskStatus.Idle && PlanningPhase == PlanningPhase.None && !IsRefining;
 

src/ClaudeDo.Ui/ViewModels/Islands/TasksIslandViewModel.cs

@@ -28,6 +28,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
     public event EventHandler? TasksChanged;
     public event Action? NotesRequested;
     public event Action? PrepRequested;
+    public event Action<string>? ErrorReported;
     public void RequestFocusAddTask() => FocusAddTaskRequested?.Invoke(this, EventArgs.Empty);
 
     [RelayCommand]
@@ -69,6 +70,8 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
     [ObservableProperty] private bool _showNotesRow;
     [ObservableProperty] private bool _isMyDayList;
 
+    internal Task? LoadTask { get; private set; }
+
     public Func<UnfinishedPlanningModalViewModel, Task>? ShowUnfinishedPlanningModal { get; set; }
 
     private readonly EventHandler _langChangedHandler;
@@ -219,14 +222,14 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         HasCompleted  = false;
         ShowOpenLabel = false;
         ShowNotesRow  = false;
-        if (list is null) return;
+        if (list is null) { LoadTask = Task.CompletedTask; return; }
 
         HeaderTitle = list.Name;
         HeaderEyebrow = DateTime.Now.ToString("dddd · MMM dd", CultureInfo.InvariantCulture).ToUpperInvariant();
         ShowNotesRow = list.Id == "smart:my-day";
         IsMyDayList  = list.Id == "smart:my-day";
 
-        _ = LoadForListAsync(list, ct);
+        LoadTask = LoadForListAsync(list, ct);
     }
 
     private async Task LoadForListAsync(ListNavItemViewModel list, CancellationToken ct)
@@ -300,27 +303,17 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
 
     internal void Regroup()
     {
-        OverdueItems.Clear();
+        // Collapse parents that have children by default, so subtasks stay tucked away until
-        OpenItems.Clear();
+        // the user expands the row (an explicit toggle is saved and wins over this default).
-        CompletedItems.Clear();
-
-        // Auto-collapse planning parents whose every child is Done (unless the user
-        // has explicitly toggled the row — saved state wins).
         var childrenByParent = Items
             .Where(r => r.IsChild && !string.IsNullOrEmpty(r.ParentTaskId))
             .GroupBy(r => r.ParentTaskId!)
             .ToDictionary(g => g.Key, g => g.ToList());
-        foreach (var parent in Items.Where(r => r.IsPlanningParent && !r.IsChild
+        foreach (var parent in Items.Where(r => r.IsPlanningParent && !r.IsChild && !r.Done))
-                                                 && r.PlanningPhase == PlanningPhase.Finalized
-                                                 && !r.Done))
         {
             if (_expandedState.ContainsKey(parent.Id)) continue;
-            if (childrenByParent.TryGetValue(parent.Id, out var kids)
+            if (childrenByParent.TryGetValue(parent.Id, out var kids) && kids.Count > 0)
-                && kids.Count > 0
-                && kids.All(c => c.Status == TaskStatus.Done))
-            {
                 parent.IsExpanded = false;
-            }
         }
 
         // Restore IsExpanded from saved state
@@ -361,19 +354,29 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         }
 
         var today = DateTime.Today;
+        var overdue   = new List<TaskRowViewModel>();
+        var open      = new List<TaskRowViewModel>();
+        var completed = new List<TaskRowViewModel>();
         foreach (var r in flat)
         {
             var underOpenPlanningParent = r.IsChild &&
                 flat.Any(p => p.Id == r.ParentTaskId && p.IsPlanningParent && !p.Done);
 
             if (r.Done && !underOpenPlanningParent)
-                CompletedItems.Add(r);
+                completed.Add(r);
             else if (r.ScheduledFor is { } d && d.Date < today)
-                OverdueItems.Add(r);
+                overdue.Add(r);
             else
-                OpenItems.Add(r);
+                open.Add(r);
         }
 
+        // Reconcile the bound collections in place (granular Insert/Move/Remove) rather than
+        // Clear+Add, so toggling a parent only touches its own child rows — the ItemsControl
+        // keeps every unchanged container instead of tearing the whole list down on a Reset.
+        SyncCollection(OverdueItems, overdue);
+        SyncCollection(OpenItems, open);
+        SyncCollection(CompletedItems, completed);
+
         HasOverdue     = OverdueItems.Count > 0;
         HasOpen        = OpenItems.Count > 0;
         HasCompleted   = CompletedItems.Count > 0;
@@ -408,20 +411,15 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         if (string.IsNullOrWhiteSpace(NewTaskTitle) || _currentList?.Kind != ListKind.User) return;
         var listId = _currentList.Id["user:".Length..];
         await using var db = await _dbFactory.CreateDbContextAsync();
-        var maxSort = await db.Tasks
-            .Where(t => t.ListId == listId)
-            .Select(t => (int?)t.SortOrder)
-            .MaxAsync();
         var entity = new TaskEntity
         {
             Id        = Guid.NewGuid().ToString("N"),
             ListId    = listId,
             Title     = NewTaskTitle.Trim(),
+            Status    = TaskStatus.Idle,
             CreatedAt = DateTime.UtcNow,
-            SortOrder = (maxSort ?? -1) + 1,
         };
-        db.Tasks.Add(entity);
+        await new TaskRepository(db).AddAsync(entity);
-        await db.SaveChangesAsync();
         var row = TaskRowViewModel.FromEntity(entity);
         row.ShowListChip = _currentList?.Kind == ListKind.Virtual;
         Items.Add(row);
@@ -504,6 +502,28 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         coll.Move(srcIdx, finalIdx);
     }
 
+    // Reconcile a bound collection toward a target order using granular Remove/Move/Insert,
+    // so unchanged rows keep their containers (no Reset-driven full re-render).
+    private static void SyncCollection(
+        System.Collections.ObjectModel.ObservableCollection<TaskRowViewModel> dst,
+        List<TaskRowViewModel> target)
+    {
+        var keep = new HashSet<TaskRowViewModel>(target);
+        for (int i = dst.Count - 1; i >= 0; i--)
+            if (!keep.Contains(dst[i]))
+                dst.RemoveAt(i);
+
+        for (int i = 0; i < target.Count; i++)
+        {
+            var item = target[i];
+            if (i < dst.Count && ReferenceEquals(dst[i], item)) continue;
+
+            var cur = dst.IndexOf(item);
+            if (cur >= 0) dst.Move(cur, i);
+            else dst.Insert(i, item);
+        }
+    }
+
     private System.Collections.ObjectModel.ObservableCollection<TaskRowViewModel>? SectionFor(TaskRowViewModel row)
     {
         if (OverdueItems.Contains(row))   return OverdueItems;
@@ -760,6 +780,18 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
     [RelayCommand]
     private void Select(TaskRowViewModel row) => SelectedTask = row;
 
+    public async System.Threading.Tasks.Task<bool> SelectByIdAsync(string taskId)
+    {
+        if (LoadTask is { } lt)
+        {
+            try { await lt; } catch { /* load cancelled/failed — fall through */ }
+        }
+        var row = Items.FirstOrDefault(r => r.Id == taskId);
+        if (row is null) return false;
+        SelectedTask = row;
+        return true;
+    }
+
     [RelayCommand]
     private void ToggleShowCompleted() => IsShowingCompleted = !IsShowingCompleted;
 
@@ -775,7 +807,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         if (row.Status != TaskStatus.Idle || row.PlanningPhase != PlanningPhase.None) return;
         ForegroundHelper.AllowAny();
         try { await _worker!.StartPlanningSessionAsync(row.Id); }
-        catch { }
+        catch (Exception ex) { ErrorReported?.Invoke(Loc.T("vm.tasksIsland.planningOpenFailed", ex.Message)); }
     }
 
     [RelayCommand]
@@ -784,7 +816,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         if (row is null || _worker is null) return;
         ForegroundHelper.AllowAny();
         try { await _worker.OpenInteractiveTerminalAsync(row.Id); }
-        catch { }
+        catch (Exception ex) { ErrorReported?.Invoke(Loc.T("vm.tasksIsland.runInteractiveFailed", ex.Message)); }
     }
 
     [RelayCommand]

src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs

@@ -10,7 +10,6 @@ using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
 using ClaudeDo.Ui.ViewModels.Islands;
 using ClaudeDo.Ui.ViewModels.Modals;
-using ClaudeDo.Ui.ViewModels.Planning;
 using Microsoft.EntityFrameworkCore;
 
 namespace ClaudeDo.Ui.ViewModels;
@@ -21,6 +20,7 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
     public TasksIslandViewModel? Tasks { get; }
     public DetailsIslandViewModel? Details { get; }
     public IWorkerClient? Worker { get; }
+    public MissionControlViewModel? MissionControl { get; }
     public UpdateCheckService UpdateCheck => _updateCheck;
 
     public string ConnectionText =>
@@ -41,35 +41,60 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
 
     public Func<MergeModalViewModel> ResolveMergeVm => _mergeVmFactory;
 
-    // Layer C seam: composition root sets the factory; MainWindow sets the dialog opener.
+    // Layer C seam: composition root sets the factory; the dialog service shows the resolver.
-    // The integrator connects Layer A/B's RequestConflictResolution(taskId, target) to this method.
     public Func<string, ClaudeDo.Ui.ViewModels.Conflicts.ConflictResolverViewModel>? ConflictResolverFactory { get; set; }
-    public Func<ClaudeDo.Ui.ViewModels.Conflicts.ConflictResolverViewModel, Task>? ShowConflictResolver { get; set; }
+
+    // Set by MainWindow so a reveal can bring the main window to the foreground.
+    public Action? BringToFront { get; set; }
+
+    // Single dialog seam (set by MainWindow); propagated to the lists island.
+    private IDialogService? _dialogs;
+    public IDialogService? Dialogs
+    {
+        get => _dialogs;
+        set
+        {
+            _dialogs = value;
+            if (Lists is not null) Lists.Dialogs = value;
+        }
+    }
+
+    public async Task RevealTaskAsync(string taskId)
+    {
+        if (Tasks is null || Lists is null) { BringToFront?.Invoke(); return; }
+
+        string? listId = null;
+        if (_dbFactory is not null)
+        {
+            try
+            {
+                await using var ctx = await _dbFactory.CreateDbContextAsync();
+                var entity = await ctx.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Id == taskId);
+                listId = entity?.ListId;
+            }
+            catch { /* best-effort list resolution */ }
+        }
+
+        if (listId is not null)
+        {
+            var navItem = Lists.Items.FirstOrDefault(i => i.Id == $"user:{listId}");
+            if (navItem is not null && !ReferenceEquals(Lists.SelectedList, navItem))
+                Lists.SelectedList = navItem; // raises SelectionChanged → Tasks.LoadForList
+        }
+
+        await Tasks.SelectByIdAsync(taskId);
+        BringToFront?.Invoke();
+    }
 
     public async Task RequestConflictResolutionAsync(string taskId, string targetBranch)
     {
-        if (ConflictResolverFactory is null || ShowConflictResolver is null) return;
+        if (ConflictResolverFactory is null || Dialogs is null) return;
         var vm = ConflictResolverFactory(taskId);
         var hasConflicts = await vm.OpenAsync(targetBranch);
         if (hasConflicts)
-            await ShowConflictResolver(vm);
+            await Dialogs.ShowConflictResolverAsync(vm);
     }
 
-    // Set by MainWindow to open the About dialog.
-    public Func<AboutModalViewModel, Task>? ShowAboutModal { get; set; }
-
-    // Set by MainWindow to open the repo-import dialog.
-    public Func<RepoImportModalViewModel, Task>? ShowRepoImportModal { get; set; }
-
-    // Set by MainWindow to open the global worktrees overview dialog.
-    public Func<WorktreesOverviewModalViewModel, Task>? ShowWorktreesOverviewModal { get; set; }
-
-    // Set by MainWindow to open the weekly report dialog.
-    public Func<WeeklyReportModalViewModel, Task>? ShowWeeklyReportModal { get; set; }
-
-    // Set by MainWindow to open the worker-connection help dialog.
-    public Func<WorkerConnectionModalViewModel, Task>? ShowWorkerConnectionModal { get; set; }
-
     [ObservableProperty] private bool _isUpdateBannerVisible;
     [ObservableProperty] private string? _updateBannerLatestVersion;
     [ObservableProperty] private string? _inlineUpdateStatus;
@@ -130,6 +155,17 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         WorkerLogText = null;
     }
 
+    // Surfaces a UI-originated failure in the footer status strip (same line as the
+    // worker log), color-coded as an error and auto-cleared by _clearTimer.
+    public void FlashFooterError(string message)
+    {
+        WorkerLogText = $"{DateTime.Now:HH:mm} · {message}";
+        WorkerLogLevel = WorkerLogLevel.Error;
+        IsWorkerLogVisible = true;
+        _clearTimer.Stop();
+        _clearTimer.Start();
+    }
+
     private void OnPrimeFired(PrimeFiredEvent evt)
     {
         var when = evt.FiredAt.LocalDateTime.ToString("HH:mm");
@@ -149,11 +185,11 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
 
     private async Task OpenPlanningConflictAsync(string planningTaskId, string subtaskId)
     {
-        if (ConflictResolverFactory is null || ShowConflictResolver is null) return;
+        if (ConflictResolverFactory is null || Dialogs is null) return;
         var vm = ConflictResolverFactory(subtaskId);
         var hasConflicts = await vm.OpenForPlanningAsync(planningTaskId, subtaskId);
         if (hasConflicts)
-            await ShowConflictResolver(vm);
+            await Dialogs.ShowConflictResolverAsync(vm);
     }
 
     // For tests only — does NOT wire up events.
@@ -171,9 +207,14 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         Func<WorktreesOverviewModalViewModel> worktreesOverviewVmFactory,
         Func<WeeklyReportModalViewModel> weeklyReportVmFactory,
         Func<MergeModalViewModel> mergeVmFactory,
-        Func<RepoImportModalViewModel> repoImportVmFactory)
+        Func<RepoImportModalViewModel> repoImportVmFactory,
+        MissionControlViewModel missionControl)
     {
         Lists = lists; Tasks = tasks; Details = details; Worker = worker;
+        MissionControl = missionControl;
+        MissionControl.OpenInApp = id => _ = RevealTaskAsync(id);
+        MissionControl.ShowDetached = (monitor, reDock) => Dialogs?.ShowDetachedMonitor(monitor, reDock);
+        MissionControl.OpenSettingsRequested = () => Lists.OpenSettingsCommand.Execute(null);
         _updateCheck = updateCheck;
         _installerLocator = installerLocator;
         _workerLocator = workerLocator;
@@ -186,6 +227,7 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         Tasks.SelectionChanged += (_, _) => Details.Bind(Tasks.SelectedTask);
         Tasks.NotesRequested += () => Details.ShowNotes();
         Tasks.PrepRequested += () => Details.ShowPrep();
+        Tasks.ErrorReported += FlashFooterError;
         Tasks.TasksChanged     += (_, _) => _ = Lists.RefreshCountsAsync();
         Tasks.OpenListSettingsRequested += (_, _) =>
         {
@@ -199,7 +241,6 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
             _ = Lists.RefreshCountsAsync();
             return System.Threading.Tasks.Task.CompletedTask;
         };
-        Details.RequestConflictResolution = RequestConflictResolutionAsync;
         Worker.PropertyChanged += (_, e) =>
         {
             if (e.PropertyName is nameof(IWorkerClient.IsConnected) or nameof(IWorkerClient.IsReconnecting))
@@ -277,11 +318,27 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         if (InlineUpdateStatus == text) InlineUpdateStatus = null;
     }
 
+    [RelayCommand]
+    private void OpenMissionControl()
+    {
+        if (Dialogs is not null && MissionControl is not null)
+            Dialogs.ShowMissionControl(MissionControl);
+    }
+
     [RelayCommand]
     private async Task OpenAbout()
     {
         var vm = new AboutModalViewModel();
-        if (ShowAboutModal is not null) await ShowAboutModal(vm);
+        if (Dialogs is not null) await Dialogs.ShowAboutAsync(vm);
+    }
+
+    [RelayCommand]
+    private async Task OpenLogVisualizer()
+    {
+        if (Dialogs is null || Worker is null) return;
+        var vm = new LogVisualizerViewModel(Worker);
+        await vm.RefreshAsync();
+        await Dialogs.ShowLogVisualizerAsync(vm);
     }
 
     private bool _connectionPromptShown;
@@ -297,7 +354,7 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
     private async Task OpenWorkerConnectionHelpAsync()
     {
         var vm = new WorkerConnectionModalViewModel(_workerLocator, _installerLocator);
-        if (ShowWorkerConnectionModal is not null) await ShowWorkerConnectionModal(vm);
+        if (Dialogs is not null) await Dialogs.ShowWorkerConnectionAsync(vm);
     }
 
     [RelayCommand]
@@ -306,10 +363,10 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
     [RelayCommand]
     private async Task OpenRepoImport()
     {
-        if (ShowRepoImportModal is null || _repoImportVmFactory is null) return;
+        if (Dialogs is null || _repoImportVmFactory is null) return;
         var vm = _repoImportVmFactory();
         await vm.LoadAsync();
-        await ShowRepoImportModal(vm);
+        await Dialogs.ShowRepoImportAsync(vm);
         if (Lists is not null) await Lists.LoadAsync();
     }
 
@@ -318,14 +375,14 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
     [RelayCommand]
     private async Task OpenWorktreesOverviewGlobalAsync()
     {
-        if (ShowWorktreesOverviewModal is null || _worktreesOverviewOpen) return;
+        if (Dialogs is null || _worktreesOverviewOpen) return;
         _worktreesOverviewOpen = true;
         try
         {
             var vm = _worktreesOverviewVmFactory();
             vm.Configure(null, null);
             await vm.LoadAsync();
-            await ShowWorktreesOverviewModal(vm);
+            await Dialogs.ShowWorktreesOverviewAsync(vm);
         }
         finally { _worktreesOverviewOpen = false; }
     }
@@ -335,13 +392,13 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
     [RelayCommand]
     private async Task OpenWeeklyReport()
     {
-        if (ShowWeeklyReportModal is null || _weeklyReportOpen) return;
+        if (Dialogs is null || _weeklyReportOpen) return;
         _weeklyReportOpen = true;
         try
         {
             var vm = _weeklyReportVmFactory();
             await vm.InitializeAsync();
-            await ShowWeeklyReportModal(vm);
+            await Dialogs.ShowWeeklyReportAsync(vm);
         }
         finally { _weeklyReportOpen = false; }
     }

src/ClaudeDo.Ui/ViewModels/MissionControlViewModel.cs

@@ -0,0 +1,234 @@
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Linq;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using ClaudeDo.Data;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Ui.Services;
+using ClaudeDo.Ui.ViewModels.Islands;
+using Microsoft.EntityFrameworkCore;
+
+namespace ClaudeDo.Ui.ViewModels;
+
+public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
+{
+    private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
+    private readonly IWorkerClient _worker;
+    private readonly Action<string, string, DateTime> _onTaskStarted;
+    private readonly Action<string, string, string, DateTime> _onTaskFinished;
+    private readonly Action<string> _onTaskUpdated;
+    private readonly Action _onConnectionRestored;
+    private readonly Action<string> _onInteractiveStarted;
+
+    public ObservableCollection<TaskMonitorViewModel> Monitors { get; } = new();
+
+    [ObservableProperty] private int _columnCount = 1;
+
+    private Action<string>? _openInApp;
+    public Action<string>? OpenInApp
+    {
+        get => _openInApp;
+        set
+        {
+            _openInApp = value;
+            foreach (var m in Monitors) m.OpenInAppRequested = value;
+        }
+    }
+
+    // View-layer seam: show a detached monitor in its own window. Second arg is the re-dock callback
+    // invoked when that window closes.
+    public Action<TaskMonitorViewModel, Action>? ShowDetached { get; set; }
+
+    // View-layer seam: open the app Settings modal from the Mission Control window.
+    public Action? OpenSettingsRequested { get; set; }
+
+    public bool HasMonitors => Monitors.Count > 0;
+
+    // Read-only view of the worker queue (tasks waiting to run), shown as a side strip.
+    public ObservableCollection<QueuedTaskViewModel> Queued { get; } = new();
+    public bool HasQueued => Queued.Count > 0;
+
+    public MissionControlViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, IWorkerClient worker)
+    {
+        _dbFactory = dbFactory;
+        _worker = worker;
+
+        Monitors.CollectionChanged += OnMonitorsChanged;
+
+        _onTaskStarted = (slot, taskId, startedAt) => { EnsureMonitor(taskId); _ = RefreshQueueAsync(); };
+        _worker.TaskStartedEvent += _onTaskStarted;
+
+        _onTaskFinished = (slot, taskId, status, finishedAt) => _ = RefreshQueueAsync();
+        _worker.TaskFinishedEvent += _onTaskFinished;
+
+        _onTaskUpdated = taskId => _ = RefreshQueueAsync();
+        _worker.TaskUpdatedEvent += _onTaskUpdated;
+
+        _onConnectionRestored = () => { SeedActive(); _ = RefreshQueueAsync(); };
+        _worker.ConnectionRestoredEvent += _onConnectionRestored;
+
+        _onInteractiveStarted = taskId =>
+        {
+            EnsureMonitor(taskId);
+            var m = Monitors.FirstOrDefault(x => x.SubscribedTaskId == taskId);
+            m?.SetInteractiveLive(true);
+        };
+        _worker.InteractiveSessionStartedEvent += _onInteractiveStarted;
+
+        SeedActive();
+        _ = RefreshQueueAsync();
+    }
+
+    internal async System.Threading.Tasks.Task RefreshQueueAsync()
+    {
+        try
+        {
+            await using var ctx = await _dbFactory.CreateDbContextAsync();
+            var rows = await ctx.Tasks.AsNoTracking()
+                .Where(t => t.Status == ClaudeDo.Data.Models.TaskStatus.Queued)
+                .OrderBy(t => t.SortOrder).ThenBy(t => t.CreatedAt)
+                .Select(t => new { t.Id, t.Title, t.BlockedByTaskId })
+                .ToListAsync();
+
+            Queued.Clear();
+            foreach (var r in rows)
+                Queued.Add(new QueuedTaskViewModel
+                {
+                    Id = r.Id,
+                    Title = r.Title ?? string.Empty,
+                    IsBlocked = r.BlockedByTaskId != null,
+                });
+            OnPropertyChanged(nameof(HasQueued));
+        }
+        catch { /* best-effort queue refresh */ }
+    }
+
+    // Drop-to-queue: a task dragged from the main app onto Mission Control gets queued.
+    public async System.Threading.Tasks.Task EnqueueTaskAsync(string taskId)
+    {
+        if (string.IsNullOrEmpty(taskId)) return;
+        try
+        {
+            await using var db = await _dbFactory.CreateDbContextAsync();
+            var entity = await db.Tasks.FirstOrDefaultAsync(t => t.Id == taskId);
+            if (entity is null
+                || entity.Status == ClaudeDo.Data.Models.TaskStatus.Running
+                || entity.Status == ClaudeDo.Data.Models.TaskStatus.Queued)
+                return;
+            entity.Status = ClaudeDo.Data.Models.TaskStatus.Queued;
+            await db.SaveChangesAsync();
+            await _worker.WakeQueueAsync();
+        }
+        catch { /* best-effort enqueue */ }
+        await RefreshQueueAsync();
+    }
+
+    private void SeedActive()
+    {
+        foreach (var a in _worker.GetActiveTasks())
+            EnsureMonitor(a.TaskId);
+    }
+
+    private void EnsureMonitor(string taskId)
+    {
+        if (string.IsNullOrEmpty(taskId)) return;
+        if (Monitors.Any(m => m.SubscribedTaskId == taskId)) return;
+
+        var monitor = new TaskMonitorViewModel(_dbFactory, _worker);
+        monitor.SetTaskId(taskId);
+        monitor.OpenInAppRequested = _openInApp;
+        monitor.DetachRequested = Detach;
+        Monitors.Add(monitor);
+        _ = HydrateAsync(monitor, taskId);
+    }
+
+    private void Detach(TaskMonitorViewModel monitor)
+    {
+        if (!Monitors.Contains(monitor)) return;
+        monitor.IsDetached = true;
+        Monitors.Remove(monitor);            // drop from grid — do NOT dispose; it keeps streaming
+        ShowDetached?.Invoke(monitor, () => ReDock(monitor));
+    }
+
+    private void ReDock(TaskMonitorViewModel monitor)
+    {
+        monitor.IsDetached = false;
+        if (!Monitors.Contains(monitor) && monitor.SubscribedTaskId is not null)
+            Monitors.Add(monitor);           // back into the grid
+    }
+
+    private async System.Threading.Tasks.Task HydrateAsync(TaskMonitorViewModel monitor, string taskId)
+    {
+        try
+        {
+            await using var ctx = await _dbFactory.CreateDbContextAsync();
+            var entity = await ctx.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Id == taskId);
+            if (entity is null || monitor.SubscribedTaskId != taskId) return;
+            monitor.ApplyState(entity.Status);
+            monitor.Title = entity.Title;
+            var latestRun = await new TaskRunRepository(ctx).GetLatestByTaskIdAsync(taskId);
+            monitor.ApplyOutcome(entity.Result, latestRun?.ErrorMarkdown);
+            await monitor.ReplayLogFileAsync(entity.LogPath, CancellationToken.None);
+
+            // Re-attach: if the task is blocked on an AskUser question right now, surface it.
+            var pending = await _worker.GetPendingQuestionAsync(taskId);
+            if (pending is not null && monitor.SubscribedTaskId == taskId)
+                monitor.SetPendingQuestion(pending.QuestionId, pending.Question);
+        }
+        catch { /* best-effort hydrate */ }
+    }
+
+    [RelayCommand]
+    private void ClearFinished()
+    {
+        foreach (var m in Monitors.Where(m => m.IsDone || m.IsFailed || m.IsCancelled || m.IsWaitingForReview).ToList())
+        {
+            Monitors.Remove(m);
+            m.Dispose();
+        }
+    }
+
+    [RelayCommand]
+    private void OpenSettings() => OpenSettingsRequested?.Invoke();
+
+    public void MoveMonitor(TaskMonitorViewModel dragged, TaskMonitorViewModel target)
+    {
+        if (ReferenceEquals(dragged, target)) return;
+        var from = Monitors.IndexOf(dragged);
+        var to = Monitors.IndexOf(target);
+        if (from < 0 || to < 0) return;
+        Monitors.Move(from, to);
+    }
+
+    private void OnMonitorsChanged(object? sender, NotifyCollectionChangedEventArgs e)
+    {
+        ColumnCount = Monitors.Count switch
+        {
+            <= 1 => 1,
+            <= 4 => 2,
+            _    => 3,
+        };
+        OnPropertyChanged(nameof(HasMonitors));
+    }
+
+    public void Dispose()
+    {
+        _worker.TaskStartedEvent -= _onTaskStarted;
+        _worker.TaskFinishedEvent -= _onTaskFinished;
+        _worker.TaskUpdatedEvent -= _onTaskUpdated;
+        _worker.ConnectionRestoredEvent -= _onConnectionRestored;
+        _worker.InteractiveSessionStartedEvent -= _onInteractiveStarted;
+        Monitors.CollectionChanged -= OnMonitorsChanged;
+        foreach (var m in Monitors) m.Dispose();
+        Monitors.Clear();
+    }
+}
+
+/// <summary>Read-only display row for a queued task in the Mission Control side strip.</summary>
+public sealed class QueuedTaskViewModel
+{
+    public required string Id { get; init; }
+    public required string Title { get; init; }
+    public bool IsBlocked { get; init; }
+}

src/ClaudeDo.Ui/ViewModels/Modals/DiffModalViewModel.cs

@@ -1,148 +0,0 @@
-using System.Collections.ObjectModel;
-using CommunityToolkit.Mvvm.ComponentModel;
-using CommunityToolkit.Mvvm.Input;
-using ClaudeDo.Data.Git;
-using ClaudeDo.Ui.Localization;
-
-namespace ClaudeDo.Ui.ViewModels.Modals;
-
-public enum DiffLineKind { Add, Del, Ctx, File }
-
-public enum DiffFileStatus { Modified, Added, Deleted, Renamed }
-
-public sealed class DiffLineViewModel
-{
-    public required DiffLineKind Kind { get; init; }
-    public int? OldNo { get; init; }
-    public int? NewNo { get; init; }
-    public required string Text { get; init; }
-    public string ClassName => Kind switch
-    {
-        DiffLineKind.Add  => "add",
-        DiffLineKind.Del  => "del",
-        DiffLineKind.File => "file",
-        _                 => "ctx",
-    };
-
-    public string Sign => Kind switch
-    {
-        DiffLineKind.Add => "+",
-        DiffLineKind.Del => "-",
-        _                => " ",
-    };
-}
-
-public sealed class DiffFileViewModel
-{
-    public required string Path { get; set; }
-    public string? OldPath { get; set; }
-    public DiffFileStatus Status { get; set; } = DiffFileStatus.Modified;
-    public bool IsBinary { get; set; }
-    public int Additions { get; set; }
-    public int Deletions { get; set; }
-    public ObservableCollection<DiffLineViewModel> Lines { get; } = new();
-
-    /// Single-letter badge for the file's change kind (A/M/D/R).
-    public string StatusCode => Status switch
-    {
-        DiffFileStatus.Added    => "A",
-        DiffFileStatus.Deleted  => "D",
-        DiffFileStatus.Renamed  => "R",
-        _                       => "M",
-    };
-
-    public bool HasLines => Lines.Count > 0;
-
-    /// A text file that produced no diff hunks (e.g. a newly added empty file).
-    public bool IsEmptyContent => !IsBinary && Lines.Count == 0;
-}
-
-public sealed partial class DiffModalViewModel : ViewModelBase
-{
-    private readonly GitService _git;
-
-    public required string WorktreePath { get; init; }
-    public string? BaseRef { get; init; }
-    /// When set together with <see cref="FromCommitRange"/>, the diff is computed as
-    /// <c>BaseRef..HeadCommit</c> inside <see cref="WorktreePath"/> (used as the repo
-    /// dir) — lets a merged task's diff be viewed after its worktree is gone.
-    public string? HeadCommit { get; init; }
-    public bool FromCommitRange { get; init; }
-    public string? TaskId { get; init; }
-    public string TaskTitle { get; init; } = "";
-    public Func<MergeModalViewModel, Task>? ShowMergeModal { get; set; }
-    public Func<MergeModalViewModel>? ResolveMergeVm { get; set; }
-    public Func<string, string, Task>? RequestConflictResolution { get; set; }
-
-    public ObservableCollection<DiffFileViewModel> Files { get; } = new();
-
-    [ObservableProperty] private DiffFileViewModel? _selectedFile;
-    [ObservableProperty] private string? _statusMessage;
-
-    // Injected action to close the owning Window
-    public Action? CloseAction { get; set; }
-
-    public DiffModalViewModel(GitService git)
-    {
-        _git = git;
-    }
-
-    [RelayCommand]
-    private void Close() => CloseAction?.Invoke();
-
-    private bool CanMerge() =>
-        !string.IsNullOrEmpty(TaskId)
-        && ShowMergeModal is not null
-        && ResolveMergeVm is not null;
-
-    [RelayCommand(CanExecute = nameof(CanMerge))]
-    private async Task MergeAsync()
-    {
-        if (TaskId is null || ShowMergeModal is null || ResolveMergeVm is null) return;
-        var vm = ResolveMergeVm();
-        vm.RequestConflictResolution = RequestConflictResolution;
-        await vm.InitializeAsync(TaskId, TaskTitle);
-        await ShowMergeModal(vm);
-        // The diff is stale once the worktree merged away or a conflict opened the editor.
-        if (vm.Merged || vm.RoutedToResolver) CloseAction?.Invoke();
-    }
-
-    public async Task LoadAsync(CancellationToken ct = default)
-    {
-        Files.Clear();
-        StatusMessage = null;
-
-        if (FromCommitRange && (BaseRef is null || HeadCommit is null))
-        {
-            StatusMessage = Loc.T("vm.diff.unavailable");
-            return;
-        }
-
-        string raw;
-        try
-        {
-            raw = FromCommitRange && BaseRef is not null && HeadCommit is not null
-                ? await _git.GetCommitRangeDiffAsync(WorktreePath, BaseRef, HeadCommit, ct)
-                : BaseRef is not null
-                    ? await _git.GetBranchDiffAsync(WorktreePath, BaseRef, ct)
-                    : await _git.GetDiffAsync(WorktreePath, ct);
-        }
-        catch (Exception ex)
-        {
-            StatusMessage = Loc.T("vm.diff.loadFailed", ex.Message);
-            return;
-        }
-
-        if (string.IsNullOrWhiteSpace(raw))
-        {
-            StatusMessage = Loc.T("vm.diff.noChanges");
-            return;
-        }
-
-        foreach (var file in UnifiedDiffParser.Parse(raw))
-            Files.Add(file);
-
-        SelectedFile = Files.Count > 0 ? Files[0] : null;
-        if (Files.Count == 0) StatusMessage = Loc.T("vm.diff.noChanges");
-    }
-}

src/ClaudeDo.Ui/ViewModels/Modals/DiffModels.cs

@@ -0,0 +1,131 @@
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+
+namespace ClaudeDo.Ui.ViewModels.Modals;
+
+// Shared diff models used by UnifiedDiffParser, DiffLinesView and DiffViewerViewModel.
+
+public enum DiffLineKind { Add, Del, Ctx, File }
+
+public enum DiffFileStatus { Modified, Added, Deleted, Renamed }
+
+public sealed class DiffLineViewModel
+{
+    public required DiffLineKind Kind { get; init; }
+    public int? OldNo { get; init; }
+    public int? NewNo { get; init; }
+    public required string Text { get; init; }
+    public string ClassName => Kind switch
+    {
+        DiffLineKind.Add  => "add",
+        DiffLineKind.Del  => "del",
+        DiffLineKind.File => "file",
+        _                 => "ctx",
+    };
+
+    public string Sign => Kind switch
+    {
+        DiffLineKind.Add => "+",
+        DiffLineKind.Del => "-",
+        _                => " ",
+    };
+}
+
+public sealed class DiffFileViewModel
+{
+    public required string Path { get; set; }
+    public string? OldPath { get; set; }
+    public DiffFileStatus Status { get; set; } = DiffFileStatus.Modified;
+    public bool IsBinary { get; set; }
+    public int Additions { get; set; }
+    public int Deletions { get; set; }
+    public ObservableCollection<DiffLineViewModel> Lines { get; } = new();
+
+    /// Single-letter badge for the file's change kind (A/M/D/R).
+    public string StatusCode => Status switch
+    {
+        DiffFileStatus.Added    => "A",
+        DiffFileStatus.Deleted  => "D",
+        DiffFileStatus.Renamed  => "R",
+        _                       => "M",
+    };
+
+    public bool HasLines => Lines.Count > 0;
+
+    /// A text file that produced no diff hunks (e.g. a newly added empty file).
+    public bool IsEmptyContent => !IsBinary && Lines.Count == 0;
+}
+
+/// One row in the planning subtask list (left pane in Planning mode).
+public sealed record SubtaskDiffRow(string Id, string Title, string? DiffStat, string UnifiedDiff);
+
+/// Folder/file node for the file-tree nav (left pane in Files mode). File leaves carry
+/// their parsed <see cref="DiffFileViewModel"/> so selection swaps the right pane with no
+/// further git calls.
+public sealed partial class DiffTreeNodeViewModel : ViewModelBase
+{
+    public required string Name { get; init; }
+    public bool IsDirectory { get; init; }
+    public string RelativePath { get; init; } = "";
+    public DiffFileViewModel? File { get; init; }
+    public ObservableCollection<DiffTreeNodeViewModel> Children { get; } = new();
+    [ObservableProperty] private bool _isExpanded = true;
+
+    public string? StatusCode => File?.StatusCode;
+    public bool ShowStats => File is { IsBinary: false };
+    public int Additions => File?.Additions ?? 0;
+    public int Deletions => File?.Deletions ?? 0;
+}
+
+/// Builds a folder-grouped tree from a flat list of parsed diff files.
+public static class DiffTree
+{
+    public static List<DiffTreeNodeViewModel> Build(IEnumerable<DiffFileViewModel> files)
+    {
+        var roots = new List<DiffTreeNodeViewModel>();
+        var dirs = new Dictionary<string, DiffTreeNodeViewModel>(StringComparer.Ordinal);
+
+        foreach (var file in files)
+        {
+            var path = file.Path.Replace('\\', '/');
+            var segments = path.Split('/', StringSplitOptions.RemoveEmptyEntries);
+            if (segments.Length == 0) continue;
+
+            DiffTreeNodeViewModel? parent = null;
+            var accumulated = "";
+            for (var i = 0; i < segments.Length - 1; i++)
+            {
+                accumulated = accumulated.Length == 0 ? segments[i] : accumulated + "/" + segments[i];
+                if (!dirs.TryGetValue(accumulated, out var dir))
+                {
+                    dir = new DiffTreeNodeViewModel { Name = segments[i], IsDirectory = true, RelativePath = accumulated };
+                    dirs[accumulated] = dir;
+                    if (parent is null) roots.Add(dir); else parent.Children.Add(dir);
+                }
+                parent = dir;
+            }
+
+            var leaf = new DiffTreeNodeViewModel
+            {
+                Name = segments[^1],
+                IsDirectory = false,
+                RelativePath = path,
+                File = file,
+            };
+            if (parent is null) roots.Add(leaf); else parent.Children.Add(leaf);
+        }
+
+        return roots;
+    }
+
+    public static DiffTreeNodeViewModel? FirstLeaf(IEnumerable<DiffTreeNodeViewModel> nodes)
+    {
+        foreach (var n in nodes)
+        {
+            if (!n.IsDirectory) return n;
+            var nested = FirstLeaf(n.Children);
+            if (nested is not null) return nested;
+        }
+        return null;
+    }
+}

src/ClaudeDo.Ui/ViewModels/Modals/DiffViewerViewModel.cs

@@ -0,0 +1,243 @@
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using ClaudeDo.Data.Git;
+using ClaudeDo.Ui.Localization;
+using ClaudeDo.Ui.Services;
+
+namespace ClaudeDo.Ui.ViewModels.Modals;
+
+public enum DiffViewerMode { Files, Planning }
+
+/// <summary>
+/// One read-only diff viewer replacing DiffModal + WorktreeModal + PlanningDiff.
+/// <see cref="DiffViewerMode.Files"/> sources (dirty worktree / branch-vs-base / commit
+/// range) load the whole diff via <see cref="GitService"/> and present a folder tree;
+/// <see cref="DiffViewerMode.Planning"/> loads per-subtask diffs from the worker with a
+/// combined integration-branch toggle. The Merge button (branch source) opens the merge
+/// form, which routes to the 3-pane resolver on conflict — the resolver itself is untouched.
+/// </summary>
+public sealed partial class DiffViewerViewModel : ViewModelBase
+{
+    private readonly GitService _git;
+    private readonly IWorkerClient _worker;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsPlanning))]
+    [NotifyPropertyChangedFor(nameof(ShowMerge))]
+    [NotifyCanExecuteChangedFor(nameof(MergeCommand))]
+    private DiffViewerMode _mode = DiffViewerMode.Files;
+
+    public bool IsPlanning => Mode == DiffViewerMode.Planning;
+
+    // ── File-source config ──────────────────────────────────────────────────
+    public string? WorktreePath { get; set; }
+    public string? BaseRef { get; set; }
+    public string? HeadCommit { get; set; }
+    public bool FromCommitRange { get; set; }
+    public string? TaskId { get; set; }
+    public string TaskTitle { get; set; } = "";
+    public Func<MergeModalViewModel, Task>? ShowMergeModal { get; set; }
+    public Func<MergeModalViewModel>? ResolveMergeVm { get; set; }
+
+    // ── Planning-source config ──────────────────────────────────────────────
+    private string? _planningTaskId;
+    private string _targetBranch = "";
+
+    // ── Left pane ───────────────────────────────────────────────────────────
+    public ObservableCollection<DiffTreeNodeViewModel> FileTree { get; } = new();
+    public ObservableCollection<SubtaskDiffRow> Subtasks { get; } = new();
+    [ObservableProperty] private DiffTreeNodeViewModel? _selectedNode;
+    [ObservableProperty] private SubtaskDiffRow? _selectedSubtask;
+
+    // ── Right pane ──────────────────────────────────────────────────────────
+    [ObservableProperty] private DiffFileViewModel? _selectedFile;       // Files mode
+    public ObservableCollection<DiffLineViewModel> DiffLines { get; } = new(); // Planning mode
+    [ObservableProperty] private string _displayedDiff = "";
+    [ObservableProperty] private string? _statusMessage;
+
+    // ── Planning combined toggle ────────────────────────────────────────────
+    [ObservableProperty] private bool _isCombinedMode;
+    [ObservableProperty] private string? _combinedWarning;
+    [ObservableProperty] private bool _isLoadingCombined;
+
+    public Action? CloseAction { get; set; }
+
+    public DiffViewerViewModel(GitService git, IWorkerClient worker)
+    {
+        _git = git;
+        _worker = worker;
+    }
+
+    [RelayCommand]
+    private void Close() => CloseAction?.Invoke();
+
+    // ── Configuration (called by the doors) ─────────────────────────────────
+
+    public void ConfigureWorktree(string worktreePath, string? baseRef, string? taskId = null, string taskTitle = "")
+    {
+        Mode = DiffViewerMode.Files;
+        WorktreePath = worktreePath;
+        BaseRef = string.IsNullOrEmpty(baseRef) ? null : baseRef;
+        TaskId = taskId;
+        TaskTitle = taskTitle;
+    }
+
+    public void ConfigureCommitRange(string repoDir, string? baseRef, string? headCommit,
+                                     string? taskId = null, string taskTitle = "")
+    {
+        Mode = DiffViewerMode.Files;
+        WorktreePath = repoDir;
+        BaseRef = baseRef;
+        HeadCommit = headCommit;
+        FromCommitRange = true;
+        TaskId = taskId;
+        TaskTitle = taskTitle;
+    }
+
+    public void ConfigurePlanning(string planningTaskId, string targetBranch)
+    {
+        Mode = DiffViewerMode.Planning;
+        _planningTaskId = planningTaskId;
+        _targetBranch = targetBranch;
+    }
+
+    // ── Load ────────────────────────────────────────────────────────────────
+
+    public Task LoadAsync(CancellationToken ct = default) =>
+        Mode == DiffViewerMode.Planning ? LoadPlanningAsync() : LoadFilesAsync(ct);
+
+    private async Task LoadFilesAsync(CancellationToken ct)
+    {
+        FileTree.Clear();
+        SelectedNode = null;
+        SelectedFile = null;
+        StatusMessage = null;
+
+        if ((FromCommitRange && (BaseRef is null || HeadCommit is null)) || WorktreePath is null)
+        {
+            StatusMessage = Loc.T("vm.diff.unavailable");
+            return;
+        }
+
+        string raw;
+        try
+        {
+            raw = FromCommitRange && BaseRef is not null && HeadCommit is not null
+                ? await _git.GetCommitRangeDiffAsync(WorktreePath, BaseRef, HeadCommit, ct)
+                : BaseRef is not null
+                    ? await _git.GetBranchDiffAsync(WorktreePath, BaseRef, ct)
+                    : await _git.GetDiffAsync(WorktreePath, ct);
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = Loc.T("vm.diff.loadFailed", ex.Message);
+            return;
+        }
+
+        if (string.IsNullOrWhiteSpace(raw))
+        {
+            StatusMessage = Loc.T("vm.diff.noChanges");
+            return;
+        }
+
+        var files = UnifiedDiffParser.Parse(raw).ToList();
+        foreach (var node in DiffTree.Build(files))
+            FileTree.Add(node);
+
+        SelectedNode = DiffTree.FirstLeaf(FileTree);
+        if (files.Count == 0) StatusMessage = Loc.T("vm.diff.noChanges");
+    }
+
+    partial void OnSelectedNodeChanged(DiffTreeNodeViewModel? value)
+    {
+        if (value is { IsDirectory: false, File: { } f })
+            SelectedFile = f;
+    }
+
+    private async Task LoadPlanningAsync()
+    {
+        if (_planningTaskId is null) return;
+        var items = await _worker.GetPlanningAggregateAsync(_planningTaskId);
+        Subtasks.Clear();
+        foreach (var i in items)
+            Subtasks.Add(new SubtaskDiffRow(i.SubtaskId, i.Title, i.DiffStat, i.UnifiedDiff));
+        SelectedSubtask = Subtasks.FirstOrDefault();
+    }
+
+    partial void OnSelectedSubtaskChanged(SubtaskDiffRow? value)
+    {
+        if (!IsCombinedMode)
+            DisplayedDiff = value?.UnifiedDiff ?? "";
+    }
+
+    [RelayCommand]
+    private async Task ToggleCombinedAsync()
+    {
+        if (IsCombinedMode)
+        {
+            IsLoadingCombined = true;
+            try
+            {
+                var result = await _worker.BuildPlanningIntegrationBranchAsync(_planningTaskId!, _targetBranch);
+                if (result is null)
+                {
+                    DisplayedDiff = "";
+                    CombinedWarning = Loc.T("vm.planningDiff.hubError");
+                }
+                else if (result.Success)
+                {
+                    DisplayedDiff = result.UnifiedDiff ?? "";
+                    CombinedWarning = null;
+                }
+                else
+                {
+                    var files = result.ConflictedFiles?.Count ?? 0;
+                    CombinedWarning = Loc.T("vm.planningDiff.conflict", result.FirstConflictSubtaskId ?? "", files);
+                    DisplayedDiff = "";
+                }
+            }
+            finally
+            {
+                IsLoadingCombined = false;
+            }
+        }
+        else
+        {
+            DisplayedDiff = SelectedSubtask?.UnifiedDiff ?? "";
+            CombinedWarning = null;
+        }
+    }
+
+    partial void OnIsCombinedModeChanged(bool value) => ToggleCombinedCommand.Execute(null);
+
+    partial void OnDisplayedDiffChanged(string value)
+    {
+        DiffLines.Clear();
+        foreach (var line in UnifiedDiffParser.Flatten(UnifiedDiffParser.Parse(value)))
+            DiffLines.Add(line);
+    }
+
+    // ── Merge (Files mode, branch source) ───────────────────────────────────
+
+    /// Whether the Merge button is offered — only a live branch source with a task and the
+    /// merge delegates wired (set before the view binds, so a plain computed read suffices).
+    public bool ShowMerge =>
+        Mode == DiffViewerMode.Files
+        && !string.IsNullOrEmpty(TaskId)
+        && ShowMergeModal is not null
+        && ResolveMergeVm is not null;
+
+    private bool CanMerge() => ShowMerge;
+
+    [RelayCommand(CanExecute = nameof(CanMerge))]
+    private async Task MergeAsync()
+    {
+        if (TaskId is null || ShowMergeModal is null || ResolveMergeVm is null) return;
+        var vm = ResolveMergeVm();
+        await vm.InitializeAsync(TaskId, TaskTitle);
+        await ShowMergeModal(vm);
+        // The diff is stale once the worktree merged away or a conflict opened the editor.
+        if (vm.Merged || vm.RoutedToResolver) CloseAction?.Invoke();
+    }
+}

src/ClaudeDo.Ui/ViewModels/Modals/ListSettingsModalViewModel.cs

@@ -4,6 +4,7 @@ using ClaudeDo.Data.Models;
 using ClaudeDo.Data.Repositories;
 using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
+using ClaudeDo.Ui.ViewModels.Agent;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using Microsoft.EntityFrameworkCore;
@@ -28,25 +29,11 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
     [ObservableProperty] private string _workingDir = "";
     [ObservableProperty] private string _defaultCommitType = CommitTypeRegistry.DefaultType;
 
-    [ObservableProperty] private string? _selectedModel;          // null = inherit from global
-    [ObservableProperty] private decimal? _maxTurns;              // null = inherit from global
-    [ObservableProperty] private string _modelInheritedHint = ""; // resolved value placeholder, e.g. "sonnet"
-    [ObservableProperty] private string _modelBadge = "";
-    [ObservableProperty] private string _turnsInheritedHint = "";
-    [ObservableProperty] private string _turnsBadge = "";
-    [ObservableProperty] private string _agentBadge = "";
-
-    [ObservableProperty] private string _systemPrompt = "";
-    [ObservableProperty] private AgentInfo? _selectedAgent;
-
-    private string _globalModel = ModelRegistry.DefaultAlias;
-    private int _globalMaxTurns = 100;
-
-    public ObservableCollection<string> ModelOptions { get; } = new(ModelRegistry.Aliases);
-
     public ObservableCollection<string> CommitTypeOptions { get; } = new(CommitTypeRegistry.Types);
 
-    public ObservableCollection<AgentInfo> Agents { get; } = new();
+    // The shared agent-config editor (Model / MaxTurns / SystemPrompt / AgentFile),
+    // scoped to this list (list → global inheritance).
+    public AgentConfigEditorViewModel Agent { get; }
 
     public Action? CloseAction { get; set; }
 
@@ -54,34 +41,7 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
     {
         _worker = worker;
         _dbFactory = dbFactory;
-    }
+        Agent = new AgentConfigEditorViewModel(worker, AgentConfigScope.List);
-
-    partial void OnSelectedModelChanged(string? value) => RecomputeModelBadge();
-    partial void OnMaxTurnsChanged(decimal? value) => RecomputeTurnsBadge();
-    partial void OnSelectedAgentChanged(AgentInfo? value) => RecomputeAgentBadge();
-
-    private void RecomputeModelBadge()
-    {
-        ModelInheritedHint = _globalModel;
-        ModelBadge = !string.IsNullOrWhiteSpace(SelectedModel)
-            ? Loc.T("settings.inherit.overrideBadge")
-            : Loc.T("settings.inherit.inheritedFromGlobal");
-    }
-
-    private void RecomputeTurnsBadge()
-    {
-        TurnsInheritedHint = _globalMaxTurns.ToString();
-        TurnsBadge = MaxTurns is not null
-            ? Loc.T("settings.inherit.overrideBadge")
-            : Loc.T("settings.inherit.inheritedFromGlobal");
-    }
-
-    private void RecomputeAgentBadge()
-    {
-        var overridden = SelectedAgent is not null && !string.IsNullOrWhiteSpace(SelectedAgent.Path);
-        AgentBadge = overridden
-            ? Loc.T("settings.inherit.overrideBadge")
-            : Loc.T("settings.inherit.inheritedFromGlobal");
     }
 
     public async Task LoadAsync(
@@ -96,44 +56,19 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
         WorkingDir = workingDir ?? "";
         DefaultCommitType = string.IsNullOrWhiteSpace(defaultCommitType) ? CommitTypeRegistry.DefaultType : defaultCommitType;
 
-        Agents.Clear();
+        await Agent.LoadForListAsync(listId, ct);
-        Agents.Add(new AgentInfo("(none)", "", ""));
-        var agents = await _worker.GetAgentsAsync();
-        foreach (var a in agents) Agents.Add(a);
-
-        var config = await _worker.GetListConfigAsync(listId);
-
-        var app = await _worker.GetAppSettingsAsync();
-        _globalModel = app?.DefaultModel ?? ModelRegistry.DefaultAlias;
-        _globalMaxTurns = app?.DefaultMaxTurns ?? 100;
-
-        SelectedModel = string.IsNullOrWhiteSpace(config?.Model) ? null : config!.Model!;
-        MaxTurns = config?.MaxTurns is int mt ? mt : (decimal?)null;
-        SystemPrompt = config?.SystemPrompt ?? "";
-        SelectedAgent = string.IsNullOrWhiteSpace(config?.AgentPath)
-            ? Agents[0]
-            : (Agents.FirstOrDefault(a => a.Path == config!.AgentPath) ?? Agents[0]);
-
-        RecomputeModelBadge();
-        RecomputeTurnsBadge();
-        RecomputeAgentBadge();
     }
 
     [RelayCommand]
     private async Task SaveAsync()
     {
-        var model = string.IsNullOrWhiteSpace(SelectedModel) ? null : SelectedModel;
-        var sp = string.IsNullOrWhiteSpace(SystemPrompt) ? null : SystemPrompt;
-        var ap = SelectedAgent is null || string.IsNullOrWhiteSpace(SelectedAgent.Path) ? null : SelectedAgent.Path;
-        var turns = MaxTurns is decimal d ? (int?)d : null;
-
         await _worker.UpdateListAsync(new UpdateListDto(
             ListId,
             string.IsNullOrWhiteSpace(Name) ? Loc.T("vm.listSettings.untitled") : Name,
             string.IsNullOrWhiteSpace(WorkingDir) ? null : WorkingDir,
             DefaultCommitType));
 
-        await _worker.UpdateListConfigAsync(new UpdateListConfigDto(ListId, model, sp, ap, turns));
+        await Agent.SaveAsync();
 
         CloseAction?.Invoke();
     }
@@ -171,17 +106,4 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
 
     [RelayCommand]
     private void Cancel() => CloseAction?.Invoke();
-
-    [RelayCommand] private void ResetModel() => SelectedModel = null;
-    [RelayCommand] private void ResetTurns() => MaxTurns = null;
-    [RelayCommand] private void ResetAgent() => SelectedAgent = Agents.Count > 0 ? Agents[0] : null;
-
-    [RelayCommand]
-    private void ResetAgentSettings()
-    {
-        SelectedModel = null;
-        MaxTurns = null;
-        SystemPrompt = "";
-        SelectedAgent = Agents.Count > 0 ? Agents[0] : null;
-    }
 }

src/ClaudeDo.Ui/ViewModels/Modals/LogVisualizerViewModel.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Ui.Localization;
+using ClaudeDo.Ui.Services;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+
+namespace ClaudeDo.Ui.ViewModels.Modals;
+
+/// <summary>
+/// Log Visualizer overlay — shows the worker's last 30 min of log records (all levels),
+/// fetched once on open via <see cref="IWorkerClient.GetRecentLogsAsync"/> with a manual
+/// Refresh and a "warnings &amp; errors only" filter.
+/// </summary>
+public sealed partial class LogVisualizerViewModel : ViewModelBase
+{
+    private readonly IWorkerClient _worker;
+    private IReadOnlyList<WorkerLogEntry> _all = Array.Empty<WorkerLogEntry>();
+
+    public ObservableCollection<LogVisualizerRow> Rows { get; } = new();
+
+    [ObservableProperty] private bool _warnErrorOnly;
+    [ObservableProperty] private string _statusText = "";
+
+    public Action? CloseAction { get; set; }
+
+    public LogVisualizerViewModel(IWorkerClient worker) => _worker = worker;
+
+    [RelayCommand]
+    public async Task RefreshAsync()
+    {
+        _all = await _worker.GetRecentLogsAsync();
+        Apply();
+    }
+
+    partial void OnWarnErrorOnlyChanged(bool value) => Apply();
+
+    private void Apply()
+    {
+        Rows.Clear();
+        IEnumerable<WorkerLogEntry> items = WarnErrorOnly
+            ? _all.Where(e => e.Level is WorkerLogLevel.Warn or WorkerLogLevel.Error)
+            : _all;
+        foreach (var e in items)
+            Rows.Add(new LogVisualizerRow(e.TimestampUtc.ToLocalTime().ToString("HH:mm:ss"), e.Message, e.Level));
+        StatusText = Rows.Count == 0
+            ? Loc.T("modals.logVisualizer.empty")
+            : Loc.T("modals.logVisualizer.count", Rows.Count);
+    }
+
+    [RelayCommand] private void Close() => CloseAction?.Invoke();
+}
+
+public sealed record LogVisualizerRow(string Time, string Message, WorkerLogLevel Level);

src/ClaudeDo.Ui/ViewModels/Modals/MergeModalViewModel.cs

@@ -9,6 +9,7 @@ namespace ClaudeDo.Ui.ViewModels.Modals;
 public sealed partial class MergeModalViewModel : ViewModelBase
 {
     private readonly IWorkerClient _worker;
+    private readonly IMergeCoordinator _merge;
 
     public string TaskId { get; set; } = "";
     public string TaskTitle { get; set; } = "";
@@ -28,10 +29,6 @@ public sealed partial class MergeModalViewModel : ViewModelBase
 
     public Action? CloseAction { get; set; }
 
-    /// Set by the caller to hand a conflicting merge off to the in-app 3-pane editor
-    /// instead of dead-ending on the conflict message.
-    public Func<string, string, Task>? RequestConflictResolution { get; set; }
-
     /// True once a merge has succeeded — lets the caller (e.g. the diff window)
     /// close itself after this modal closes.
     public bool Merged { get; private set; }
@@ -39,9 +36,10 @@ public sealed partial class MergeModalViewModel : ViewModelBase
     /// True once a conflict has been handed off to the resolver — also a cue to close the diff window.
     public bool RoutedToResolver { get; private set; }
 
-    public MergeModalViewModel(IWorkerClient worker)
+    public MergeModalViewModel(IWorkerClient worker, IMergeCoordinator merge)
     {
         _worker = worker;
+        _merge = merge;
     }
 
     public async Task InitializeAsync(string taskId, string taskTitle)
@@ -103,21 +101,11 @@ public sealed partial class MergeModalViewModel : ViewModelBase
                     });
                     break;
                 case "conflict":
-                    // Hand off to the in-app 3-pane merge editor when wired (MergeTask aborted
+                    // MergeTask aborted cleanly; hand the conflict to the in-app 3-pane editor,
-                    // cleanly, so the resolver re-starts the merge leaving conflicts in the tree).
+                    // which re-starts the merge leaving conflicts in the tree.
-                    if (RequestConflictResolution is not null)
+                    RoutedToResolver = true;
-                    {
+                    CloseAction?.Invoke();
-                        var branch = SelectedBranch!;
+                    await _merge.ResolveConflictAsync(TaskId, SelectedBranch!);
-                        RoutedToResolver = true;
-                        CloseAction?.Invoke();
-                        await RequestConflictResolution(TaskId, branch);
-                    }
-                    else
-                    {
-                        HasConflict = true;
-                        ConflictFiles = result.ConflictFiles;
-                        ErrorMessage = Loc.T("vm.merge.conflict");
-                    }
                     break;
                 case "blocked":
                     ErrorMessage = Loc.T("vm.merge.blocked", result.ErrorMessage ?? "");

src/ClaudeDo.Ui/ViewModels/Modals/Settings/OnlineInboxSettingsViewModel.cs

@@ -52,8 +52,9 @@ public sealed partial class OnlineInboxSettingsViewModel : ViewModelBase
         finally { IsBusy = false; }
     }
 
-    [RelayCommand]
+    // Persists the Online Inbox config. Exceptions propagate so callers (the modal's Apply)
-    private async Task Save()
+    // can surface and halt; the per-tab Save button wraps this and shows its own message.
+    public async Task SaveAsync()
     {
         IsBusy = true;
         StatusMessage = "";
@@ -69,13 +70,16 @@ public sealed partial class OnlineInboxSettingsViewModel : ViewModelBase
                 RedirectUri));
             StatusMessage = Loc.T("vm.onlineInbox.saved");
         }
-        catch (Exception ex)
-        {
-            StatusMessage = Loc.T("vm.onlineInbox.saveFailed", ex.Message);
-        }
         finally { IsBusy = false; }
     }
 
+    [RelayCommand]
+    private async Task Save()
+    {
+        try { await SaveAsync(); }
+        catch (Exception ex) { StatusMessage = Loc.T("vm.onlineInbox.saveFailed", ex.Message); }
+    }
+
     [RelayCommand]
     private async Task SignIn()
     {

src/ClaudeDo.Ui/ViewModels/Modals/SettingsModalViewModel.cs

@@ -100,6 +100,7 @@ public sealed partial class SettingsModalViewModel : ViewModelBase
                 Prime.DailyPrepMaxTasks);
             await _worker.UpdateAppSettingsAsync(dto);
             await Prime.SaveAsync();
+            await OnlineInbox.SaveAsync();
             CloseAction?.Invoke();
         }
         catch (Exception ex) { StatusMessage = Loc.T("vm.settingsModal.saveFailed", ex.Message); }

src/ClaudeDo.Ui/ViewModels/Modals/WorktreeModalViewModel.cs

@@ -1,150 +0,0 @@
-using System.Collections.ObjectModel;
-using CommunityToolkit.Mvvm.ComponentModel;
-using CommunityToolkit.Mvvm.Input;
-using ClaudeDo.Data.Git;
-
-namespace ClaudeDo.Ui.ViewModels.Modals;
-
-public sealed partial class WorktreeNodeViewModel : ViewModelBase
-{
-    public required string Name { get; init; }
-    public string? Status { get; init; }
-    public bool IsDirectory { get; init; }
-    public string RelativePath { get; init; } = "";
-    public ObservableCollection<WorktreeNodeViewModel> Children { get; } = new();
-    [ObservableProperty] private bool _isExpanded = true;
-}
-
-public sealed partial class WorktreeModalViewModel : ViewModelBase
-{
-    private readonly GitService _git;
-
-    public ObservableCollection<WorktreeNodeViewModel> Root { get; } = new();
-    public ObservableCollection<DiffLineViewModel> SelectedFileDiffLines { get; } = new();
-
-    [ObservableProperty] private string _worktreePath = "";
-    [ObservableProperty] private string? _baseCommit;
-    [ObservableProperty] private WorktreeNodeViewModel? _selectedNode;
-
-    // Set by the view (same pattern as DiffModalViewModel.CloseAction)
-    public Action? CloseAction { get; set; }
-
-    public WorktreeModalViewModel(GitService git)
-    {
-        _git = git;
-    }
-
-    partial void OnSelectedNodeChanged(WorktreeNodeViewModel? value)
-    {
-        _ = LoadFileDiffAsync(value);
-    }
-
-    private async Task LoadFileDiffAsync(WorktreeNodeViewModel? node)
-    {
-        SelectedFileDiffLines.Clear();
-
-        if (node is null || node.IsDirectory || string.IsNullOrEmpty(node.RelativePath))
-            return;
-
-        string diff;
-        try
-        {
-            diff = await _git.GetFileDiffAsync(WorktreePath, BaseCommit, node.RelativePath);
-        }
-        catch
-        {
-            return;
-        }
-
-        foreach (var line in UnifiedDiffParser.Flatten(UnifiedDiffParser.Parse(diff)))
-            SelectedFileDiffLines.Add(line);
-    }
-
-    [RelayCommand]
-    private void Close() => CloseAction?.Invoke();
-
-    public async Task LoadAsync(CancellationToken ct = default)
-    {
-        Root.Clear();
-
-        string stdout;
-        bool committedMode = !string.IsNullOrEmpty(BaseCommit);
-        try
-        {
-            stdout = committedMode
-                ? await _git.GetCommittedFilesAsync(WorktreePath, BaseCommit!, ct)
-                : await _git.GetStatusPorcelainAsync(WorktreePath, ct);
-        }
-        catch { return; }
-
-        if (string.IsNullOrWhiteSpace(stdout)) return;
-
-        var dirs = new Dictionary<string, WorktreeNodeViewModel>(StringComparer.Ordinal);
-
-        foreach (var line in stdout.Split('\n', StringSplitOptions.RemoveEmptyEntries))
-        {
-            string? path;
-            string? status;
-
-            if (committedMode)
-            {
-                // diff --name-status format: <status>\t<path>
-                var tab = line.IndexOf('\t');
-                if (tab < 0) continue;
-                var statusChar = line[0];
-                status = statusChar != ' ' ? statusChar.ToString() : null;
-                path = line[(tab + 1)..].Trim().Replace('\\', '/');
-            }
-            else
-            {
-                // porcelain format: XY<space>path
-                if (line.Length < 4) continue;
-                var xy = line[..2];
-                var statusChar = xy[0] != ' ' ? xy[0] : xy[1];
-                status = statusChar != ' ' ? statusChar.ToString() : null;
-                path = line[3..].Trim().Replace('\\', '/');
-            }
-
-            var segments = path.Split('/', StringSplitOptions.RemoveEmptyEntries);
-            if (segments.Length == 0) continue;
-
-            WorktreeNodeViewModel? parent = null;
-            var accumulated = "";
-            for (var i = 0; i < segments.Length - 1; i++)
-            {
-                accumulated = accumulated.Length == 0 ? segments[i] : accumulated + "/" + segments[i];
-                if (!dirs.TryGetValue(accumulated, out var dir))
-                {
-                    dir = new WorktreeNodeViewModel { Name = segments[i], IsDirectory = true };
-                    dirs[accumulated] = dir;
-                    if (parent == null) Root.Add(dir);
-                    else parent.Children.Add(dir);
-                }
-                parent = dir;
-            }
-
-            var leaf = new WorktreeNodeViewModel
-            {
-                Name = segments[^1],
-                Status = status,
-                IsDirectory = false,
-                RelativePath = path
-            };
-            if (parent == null) Root.Add(leaf);
-            else parent.Children.Add(leaf);
-        }
-
-        SelectedNode = FindFirstLeaf(Root);
-    }
-
-    private static WorktreeNodeViewModel? FindFirstLeaf(IEnumerable<WorktreeNodeViewModel> nodes)
-    {
-        foreach (var n in nodes)
-        {
-            if (!n.IsDirectory) return n;
-            var nested = FindFirstLeaf(n.Children);
-            if (nested is not null) return nested;
-        }
-        return null;
-    }
-}

src/ClaudeDo.Ui/ViewModels/Modals/WorktreesOverviewModalViewModel.cs

@@ -24,7 +24,12 @@ public sealed partial class WorktreeOverviewRowViewModel : ViewModelBase
     [ObservableProperty] private string _path = "";
     [ObservableProperty] private string _branchName = "";
     [ObservableProperty] private string _baseCommit = "";
-    [ObservableProperty][NotifyPropertyChangedFor(nameof(IsActive))] private WorktreeState _state;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsActive))]
+    [NotifyPropertyChangedFor(nameof(IsMerged))]
+    [NotifyPropertyChangedFor(nameof(IsDiscarded))]
+    [NotifyPropertyChangedFor(nameof(IsKept))]
+    private WorktreeState _state;
     [ObservableProperty] private string? _diffStat;
     [ObservableProperty][NotifyPropertyChangedFor(nameof(AgeText))] private DateTime _createdAt;
     [ObservableProperty] private bool _pathExistsOnDisk;
@@ -40,6 +45,9 @@ public sealed partial class WorktreeOverviewRowViewModel : ViewModelBase
 
     public string AgeText => FormatAge(DateTime.UtcNow - CreatedAt);
     public bool IsActive => State == WorktreeState.Active;
+    public bool IsMerged => State == WorktreeState.Merged;
+    public bool IsDiscarded => State == WorktreeState.Discarded;
+    public bool IsKept => State == WorktreeState.Kept;
     public bool IsRunning => TaskStatus == TaskStatus.Running;
 
     private static string FormatAge(TimeSpan ts)
@@ -61,7 +69,8 @@ public sealed partial class WorktreesGroupViewModel : ViewModelBase
 public sealed partial class WorktreesOverviewModalViewModel : ViewModelBase
 {
     private readonly IWorkerClient _worker;
-    private readonly Func<WorktreeModalViewModel> _diffVmFactory;
+    private readonly Func<DiffViewerViewModel> _diffVmFactory;
+    private readonly IMergeCoordinator _merge;
 
     [ObservableProperty] private string? _listIdFilter;
     [ObservableProperty] private string _title = "Worktrees";
@@ -79,20 +88,18 @@ public sealed partial class WorktreesOverviewModalViewModel : ViewModelBase
     public ObservableCollection<string> MergeTargets { get; } = new();
     public ObservableCollection<WorktreeOverviewRowViewModel> ConflictRows { get; } = new();
 
-    /// Inert seam wired by the integrator to Layer C's resolver at merge time. (taskId, targetBranch)
-    public Func<string, string, Task>? RequestConflictResolution { get; set; }
-
     public Action? CloseAction { get; set; }
-    public Action<WorktreeModalViewModel>? ShowDiffAction { get; set; }
+    public Action<DiffViewerViewModel>? ShowDiffAction { get; set; }
     public Action<string, string>? JumpToTaskAction { get; set; }
     public Func<string, Task<bool>>? ConfirmAction { get; set; }
     public Func<MergeModalViewModel>? ResolveMergeVm { get; set; }
     public Func<MergeModalViewModel, Task>? ShowMergeAction { get; set; }
 
-    public WorktreesOverviewModalViewModel(IWorkerClient worker, Func<WorktreeModalViewModel> diffVmFactory)
+    public WorktreesOverviewModalViewModel(IWorkerClient worker, Func<DiffViewerViewModel> diffVmFactory, IMergeCoordinator merge)
     {
         _worker = worker;
         _diffVmFactory = diffVmFactory;
+        _merge = merge;
     }
 
     public void SelectRow(WorktreeOverviewRowViewModel row)
@@ -178,8 +185,7 @@ public sealed partial class WorktreesOverviewModalViewModel : ViewModelBase
     {
         if (row is null) return;
         var diffVm = _diffVmFactory();
-        diffVm.WorktreePath = row.Path;
+        diffVm.ConfigureWorktree(row.Path, row.BaseCommit);
-        diffVm.BaseCommit = string.IsNullOrEmpty(row.BaseCommit) ? null : row.BaseCommit;
         ShowDiffAction?.Invoke(diffVm);
     }
 
@@ -328,7 +334,7 @@ public sealed partial class WorktreesOverviewModalViewModel : ViewModelBase
     private void ResolveConflict(WorktreeOverviewRowViewModel? row)
     {
         if (row is null) return;
-        RequestConflictResolution?.Invoke(row.TaskId, SelectedTarget ?? "");
+        _ = _merge.ResolveConflictAsync(row.TaskId, SelectedTarget ?? "");
     }
 
     [RelayCommand]

src/ClaudeDo.Ui/ViewModels/Planning/PlanningDiffViewModel.cs

@@ -1,101 +0,0 @@
-using System.Collections.ObjectModel;
-using CommunityToolkit.Mvvm.ComponentModel;
-using CommunityToolkit.Mvvm.Input;
-using ClaudeDo.Ui.Localization;
-using ClaudeDo.Ui.Services;
-using ClaudeDo.Ui.ViewModels.Modals;
-
-namespace ClaudeDo.Ui.ViewModels.Planning;
-
-public sealed partial class PlanningDiffViewModel : ObservableObject
-{
-    private readonly IWorkerClient _worker;
-    private readonly string _planningTaskId;
-    private readonly string _targetBranch;
-
-    public ObservableCollection<SubtaskDiffRow> Subtasks { get; } = new();
-    public ObservableCollection<DiffLineViewModel> DiffLines { get; } = new();
-
-    [ObservableProperty] private SubtaskDiffRow? _selectedSubtask;
-    [ObservableProperty] private string _displayedDiff = "";
-    [ObservableProperty] private bool _isCombinedMode;
-    [ObservableProperty] private string? _combinedWarning;
-    [ObservableProperty] private bool _isLoadingCombined;
-
-    public Action? CloseAction { get; set; }
-
-    public PlanningDiffViewModel(IWorkerClient worker, string planningTaskId, string targetBranch)
-    {
-        _worker = worker;
-        _planningTaskId = planningTaskId;
-        _targetBranch = targetBranch;
-    }
-
-    [RelayCommand]
-    private void Close() => CloseAction?.Invoke();
-
-    public async Task InitializeAsync()
-    {
-        var items = await _worker.GetPlanningAggregateAsync(_planningTaskId);
-        Subtasks.Clear();
-        foreach (var i in items)
-            Subtasks.Add(new SubtaskDiffRow(i.SubtaskId, i.Title, i.DiffStat, i.UnifiedDiff));
-        SelectedSubtask = Subtasks.FirstOrDefault();
-    }
-
-    partial void OnSelectedSubtaskChanged(SubtaskDiffRow? value)
-    {
-        if (!IsCombinedMode)
-            DisplayedDiff = value?.UnifiedDiff ?? "";
-    }
-
-    [RelayCommand]
-    private async Task ToggleCombinedAsync()
-    {
-        if (IsCombinedMode)
-        {
-            IsLoadingCombined = true;
-            try
-            {
-                var result = await _worker.BuildPlanningIntegrationBranchAsync(_planningTaskId, _targetBranch);
-
-                if (result is null)
-                {
-                    DisplayedDiff = "";
-                    CombinedWarning = Loc.T("vm.planningDiff.hubError");
-                }
-                else if (result.Success)
-                {
-                    DisplayedDiff = result.UnifiedDiff ?? "";
-                    CombinedWarning = null;
-                }
-                else
-                {
-                    var files = result.ConflictedFiles?.Count ?? 0;
-                    CombinedWarning = Loc.T("vm.planningDiff.conflict", result.FirstConflictSubtaskId ?? "", files);
-                    DisplayedDiff = "";
-                }
-            }
-            finally
-            {
-                IsLoadingCombined = false;
-            }
-        }
-        else
-        {
-            DisplayedDiff = SelectedSubtask?.UnifiedDiff ?? "";
-            CombinedWarning = null;
-        }
-    }
-
-    partial void OnIsCombinedModeChanged(bool value) => ToggleCombinedCommand.Execute(null);
-
-    partial void OnDisplayedDiffChanged(string value)
-    {
-        DiffLines.Clear();
-        foreach (var line in UnifiedDiffParser.Flatten(UnifiedDiffParser.Parse(value)))
-            DiffLines.Add(line);
-    }
-}
-
-public sealed record SubtaskDiffRow(string Id, string Title, string? DiffStat, string UnifiedDiff);

src/ClaudeDo.Ui/Views/Controls/AgentConfigEditor.axaml

@@ -0,0 +1,85 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:vm="using:ClaudeDo.Ui.ViewModels.Agent"
+             xmlns:ctl="using:ClaudeDo.Ui.Views.Controls"
+             xmlns:loc="using:ClaudeDo.Ui.Localization"
+             x:Class="ClaudeDo.Ui.Views.Controls.AgentConfigEditor"
+             x:DataType="vm:AgentConfigEditorViewModel"
+             x:Name="Root">
+  <StackPanel Spacing="12">
+
+    <!-- Model -->
+    <StackPanel Spacing="4">
+      <Grid ColumnDefinitions="Auto,Auto,*,Auto" ColumnSpacing="6">
+        <TextBlock Grid.Column="0" Classes="field-label" Text="{loc:Tr settings.agentEditor.model}" VerticalAlignment="Center"/>
+        <ctl:InheritedBadge Grid.Column="1" BadgeText="{Binding ModelBadge}"/>
+        <Button Grid.Column="3" Classes="icon-btn" Content="↺" ToolTip.Tip="{loc:Tr settings.inherit.resetToInherited}"
+                Command="{Binding ResetModelCommand}"/>
+      </Grid>
+      <ComboBox ItemsSource="{Binding ModelOptions}"
+                SelectedItem="{Binding Model, Mode=TwoWay}"
+                PlaceholderText="{Binding ModelInheritedHint}"
+                HorizontalAlignment="Stretch"/>
+    </StackPanel>
+
+    <!-- Max turns -->
+    <StackPanel Spacing="4">
+      <Grid ColumnDefinitions="Auto,Auto,*,Auto" ColumnSpacing="6">
+        <TextBlock Grid.Column="0" Classes="field-label" Text="{loc:Tr settings.agentEditor.maxTurns}" VerticalAlignment="Center"/>
+        <ctl:InheritedBadge Grid.Column="1" BadgeText="{Binding TurnsBadge}"/>
+        <Button Grid.Column="3" Classes="icon-btn" Content="↺" ToolTip.Tip="{loc:Tr settings.inherit.resetToInherited}"
+                Command="{Binding ResetTurnsCommand}"/>
+      </Grid>
+      <NumericUpDown Value="{Binding MaxTurns, Mode=TwoWay}"
+                     PlaceholderText="{Binding TurnsInheritedHint}"
+                     Minimum="1" Maximum="200" Increment="1" FormatString="0"
+                     HorizontalAlignment="Stretch"/>
+    </StackPanel>
+
+    <!-- System prompt -->
+    <StackPanel Spacing="4">
+      <TextBlock Classes="field-label" Text="{loc:Tr settings.agentEditor.systemPrompt}"/>
+      <TextBox Text="{Binding SystemPrompt, Mode=TwoWay}"
+               AcceptsReturn="True" TextWrapping="Wrap" MinHeight="80"/>
+      <TextBlock Classes="meta" Opacity="0.6"
+                 Text="{loc:Tr settings.agentEditor.promptPrepended}"
+                 IsVisible="{Binding EffectiveSystemPromptHint, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
+      <TextBlock Classes="meta" Opacity="0.6" TextWrapping="Wrap"
+                 Text="{Binding EffectiveSystemPromptHint}"
+                 IsVisible="{Binding EffectiveSystemPromptHint, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
+    </StackPanel>
+
+    <!-- Agent file -->
+    <StackPanel Spacing="4">
+      <Grid ColumnDefinitions="Auto,Auto,*,Auto" ColumnSpacing="6">
+        <TextBlock Grid.Column="0" Classes="field-label" Text="{loc:Tr settings.agentEditor.agentFile}" VerticalAlignment="Center"/>
+        <ctl:InheritedBadge Grid.Column="1" BadgeText="{Binding AgentBadge}"/>
+        <Button Grid.Column="3" Classes="icon-btn" Content="↺" ToolTip.Tip="{loc:Tr settings.inherit.resetToInherited}"
+                Command="{Binding ResetAgentCommand}"/>
+      </Grid>
+      <Grid ColumnDefinitions="*,Auto">
+        <ComboBox Grid.Column="0"
+                  ItemsSource="{Binding Agents}"
+                  SelectedItem="{Binding SelectedAgent, Mode=TwoWay}"
+                  HorizontalAlignment="Stretch">
+          <ComboBox.ItemTemplate>
+            <DataTemplate>
+              <StackPanel>
+                <TextBlock Classes="title" Text="{Binding Name}"/>
+                <TextBlock Classes="meta" Text="{Binding Description}"
+                           IsVisible="{Binding Description, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
+              </StackPanel>
+            </DataTemplate>
+          </ComboBox.ItemTemplate>
+        </ComboBox>
+        <Button Classes="btn" Grid.Column="1" Content="{loc:Tr settings.agentEditor.browse}"
+                Margin="8,0,0,0" Click="BrowseAgentClicked"
+                IsVisible="{Binding #Root.ShowAgentBrowse}"/>
+      </Grid>
+      <TextBlock Classes="path-mono" Text="{Binding SelectedAgent.Path}"
+                 TextTrimming="PrefixCharacterEllipsis"
+                 IsVisible="{Binding SelectedAgent.Path, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
+    </StackPanel>
+
+  </StackPanel>
+</UserControl>

src/ClaudeDo.Ui/Views/Controls/AgentConfigEditor.axaml.cs

@@ -0,0 +1,75 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Platform.Storage;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Ui.ViewModels.Agent;
+
+namespace ClaudeDo.Ui.Views.Controls;
+
+public partial class AgentConfigEditor : UserControl
+{
+    // List scope shows a file picker for ad-hoc agent files; the task flyout only
+    // picks from discovered agents, so it leaves this off (default).
+    public static readonly StyledProperty<bool> ShowAgentBrowseProperty =
+        AvaloniaProperty.Register<AgentConfigEditor, bool>(nameof(ShowAgentBrowse));
+
+    public bool ShowAgentBrowse
+    {
+        get => GetValue(ShowAgentBrowseProperty);
+        set => SetValue(ShowAgentBrowseProperty, value);
+    }
+
+    public AgentConfigEditor() => InitializeComponent();
+
+    private async void BrowseAgentClicked(object? sender, RoutedEventArgs e)
+    {
+        if (DataContext is not AgentConfigEditorViewModel vm) return;
+        var top = TopLevel.GetTopLevel(this);
+        if (top is null) return;
+
+        var files = await top.StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
+        {
+            Title = "Choose agent file",
+            AllowMultiple = false,
+            FileTypeFilter = new[]
+            {
+                new FilePickerFileType("Agent files (*.md)") { Patterns = new[] { "*.md" } },
+                new FilePickerFileType("All files") { Patterns = new[] { "*" } },
+            },
+        });
+        if (files.Count == 0) return;
+
+        var path = files[0].Path.LocalPath;
+        var existing = vm.Agents.FirstOrDefault(a => string.Equals(a.Path, path, StringComparison.OrdinalIgnoreCase));
+        if (existing is not null)
+        {
+            vm.SelectedAgent = existing;
+            return;
+        }
+
+        var (name, description) = ReadFrontmatter(path);
+        var agent = new AgentInfo(name, description, path);
+        vm.Agents.Add(agent);
+        vm.SelectedAgent = agent;
+    }
+
+    private static (string name, string description) ReadFrontmatter(string filePath)
+    {
+        var fallback = System.IO.Path.GetFileNameWithoutExtension(filePath);
+        try
+        {
+            using var reader = new System.IO.StreamReader(filePath);
+            if (reader.ReadLine()?.Trim() != "---") return (fallback, "");
+            string name = fallback, description = "";
+            while (reader.ReadLine() is { } line)
+            {
+                if (line.Trim() == "---") break;
+                if (line.StartsWith("name:")) name = line["name:".Length..].Trim();
+                else if (line.StartsWith("description:")) description = line["description:".Length..].Trim();
+            }
+            return (name, description);
+        }
+        catch { return (fallback, ""); }
+    }
+}

src/ClaudeDo.Ui/Views/Controls/DragGhostWindow.axaml

@@ -0,0 +1,22 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        x:Class="ClaudeDo.Ui.Views.Controls.DragGhostWindow"
+        SystemDecorations="None"
+        Background="Transparent"
+        TransparencyLevelHint="Transparent"
+        ShowInTaskbar="False"
+        ShowActivated="False"
+        Topmost="True"
+        Focusable="False"
+        IsHitTestVisible="False"
+        CanResize="False">
+  <!-- Translucent, slightly tilted snapshot of the dragged row that follows the cursor
+       across the whole screen (incl. over the separate Mission Control window). -->
+  <Image x:Name="GhostImage" Opacity="0.7"
+         HorizontalAlignment="Center" VerticalAlignment="Center"
+         RenderTransformOrigin="0.5,0.5">
+    <Image.RenderTransform>
+      <RotateTransform Angle="-6"/>
+    </Image.RenderTransform>
+  </Image>
+</Window>

src/ClaudeDo.Ui/Views/Controls/DragGhostWindow.axaml.cs

@@ -0,0 +1,29 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Media;
+
+namespace ClaudeDo.Ui.Views.Controls;
+
+/// <summary>
+/// Borderless, transparent, topmost, click-through window that hosts the translucent drag
+/// "ghost" — a snapshot of the row being dragged. It never activates (so the source window
+/// keeps pointer capture) and is repositioned to the screen cursor on every captured move.
+/// </summary>
+public partial class DragGhostWindow : Window
+{
+    public DragGhostWindow() => InitializeComponent();
+
+    /// <summary>
+    /// Show <paramref name="image"/> at <paramref name="logicalWidth"/>×<paramref name="logicalHeight"/>
+    /// with <paramref name="pad"/> of slack around it so the tilt isn't clipped by the window bounds.
+    /// </summary>
+    public void SetImage(IImage image, double logicalWidth, double logicalHeight, double pad)
+    {
+        GhostImage.Source = image;
+        GhostImage.Width = logicalWidth;
+        GhostImage.Height = logicalHeight;
+        GhostImage.Margin = new Thickness(pad);
+        Width = logicalWidth + pad * 2;
+        Height = logicalHeight + pad * 2;
+    }
+}

src/ClaudeDo.Ui/Views/Controls/DragHitTest.cs

@@ -0,0 +1,24 @@
+using System;
+using Avalonia;
+
+namespace ClaudeDo.Ui.Views.Controls;
+
+/// <summary>
+/// Pure, DPI-aware screen-rectangle hit testing for the custom drag. Kept free of any view
+/// dependency so the "is the cursor over that window?" decision is unit-testable.
+/// </summary>
+public static class DragHitTest
+{
+    /// <summary>
+    /// True when <paramref name="cursor"/> (physical px) falls inside a window whose top-left is
+    /// <paramref name="position"/> (physical px) and whose <paramref name="clientSize"/> is in
+    /// logical units at the given <paramref name="scaling"/>.
+    /// </summary>
+    public static bool WindowContains(PixelPoint position, Size clientSize, double scaling, PixelPoint cursor)
+    {
+        var right = position.X + (int)Math.Round(clientSize.Width * scaling);
+        var bottom = position.Y + (int)Math.Round(clientSize.Height * scaling);
+        return cursor.X >= position.X && cursor.X < right
+            && cursor.Y >= position.Y && cursor.Y < bottom;
+    }
+}

src/ClaudeDo.Ui/Views/Controls/TaskDragController.cs

@@ -0,0 +1,69 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Media.Imaging;
+
+namespace ClaudeDo.Ui.Views.Controls;
+
+/// <summary>
+/// Owns the lifecycle of the translucent follower window used by the custom task-row drag.
+/// Snapshots the dragged control to a bitmap, shows a borderless topmost click-through window
+/// that tracks the screen cursor across every top-level window, and tears it down on release.
+/// </summary>
+internal sealed class TaskDragController
+{
+    // Slack around the snapshot so the tilted card isn't clipped by the window's own bounds.
+    private const double Pad = 36;
+
+    private DragGhostWindow? _ghost;
+    private PixelPoint _grabOffset; // physical px from the ghost window's top-left to the cursor
+
+    public bool IsActive => _ghost is not null;
+
+    /// <summary>
+    /// Begin the ghost. <paramref name="grabPointInSource"/> is the cursor position inside
+    /// <paramref name="source"/> (logical px) at grab time so the snapshot stays under the cursor.
+    /// </summary>
+    public void Begin(Control source, Point grabPointInSource, double scaling)
+    {
+        End();
+
+        var size = source.Bounds.Size;
+        if (size.Width < 1 || size.Height < 1) return;
+
+        var bitmap = Snapshot(source, scaling);
+        if (bitmap is null) return;
+
+        _ghost = new DragGhostWindow();
+        _ghost.SetImage(bitmap, size.Width, size.Height, Pad);
+
+        _grabOffset = new PixelPoint(
+            (int)Math.Round((grabPointInSource.X + Pad) * scaling),
+            (int)Math.Round((grabPointInSource.Y + Pad) * scaling));
+
+        _ghost.Show();
+    }
+
+    public void MoveTo(PixelPoint screenCursor)
+    {
+        if (_ghost is null) return;
+        _ghost.Position = new PixelPoint(screenCursor.X - _grabOffset.X, screenCursor.Y - _grabOffset.Y);
+    }
+
+    public void End()
+    {
+        _ghost?.Close();
+        _ghost = null;
+    }
+
+    private static RenderTargetBitmap? Snapshot(Control source, double scaling)
+    {
+        var size = source.Bounds.Size;
+        var pixelSize = new PixelSize(
+            Math.Max(1, (int)Math.Ceiling(size.Width * scaling)),
+            Math.Max(1, (int)Math.Ceiling(size.Height * scaling)));
+        var rtb = new RenderTargetBitmap(pixelSize, new Vector(96 * scaling, 96 * scaling));
+        rtb.Render(source);
+        return rtb;
+    }
+}

src/ClaudeDo.Ui/Views/Islands/Detail/DescriptionStepsCard.axaml

@@ -6,17 +6,70 @@
              x:Class="ClaudeDo.Ui.Views.Islands.Detail.DescriptionStepsCard"
              x:DataType="vm:DetailsIslandViewModel">
 
+  <UserControl.Styles>
+    <!-- Segment switcher in the card header (mirrors the WorkConsole tab look) -->
+    <Style Selector="Button.seg-btn">
+      <Setter Property="Background"      Value="Transparent" />
+      <Setter Property="BorderThickness" Value="0" />
+      <Setter Property="Padding"         Value="8,3" />
+      <Setter Property="CornerRadius"    Value="6" />
+      <Setter Property="FontFamily"      Value="{StaticResource MonoFont}" />
+      <Setter Property="FontSize"        Value="{StaticResource FontSizeMono}" />
+      <Setter Property="Foreground"      Value="{StaticResource TextMuteBrush}" />
+      <Setter Property="Cursor"          Value="Hand" />
+    </Style>
+    <Style Selector="Button.seg-btn:pointerover /template/ ContentPresenter">
+      <Setter Property="Background"             Value="{StaticResource Surface2Brush}" />
+      <Setter Property="TextElement.Foreground" Value="{StaticResource TextDimBrush}" />
+    </Style>
+    <Style Selector="Button.seg-btn.active /template/ ContentPresenter">
+      <Setter Property="Background"             Value="{StaticResource Surface3Brush}" />
+      <Setter Property="TextElement.Foreground" Value="{StaticResource AccentBrush}" />
+    </Style>
+    <Style Selector="TextBlock.seg-count">
+      <Setter Property="Foreground" Value="{StaticResource TextMuteBrush}" />
+      <Setter Property="FontSize"   Value="{StaticResource FontSizeMono}" />
+    </Style>
+  </UserControl.Styles>
+
   <Border Classes="island"
           Background="{DynamicResource Surface2Brush}"
           BorderBrush="{DynamicResource LineBrush}">
     <DockPanel>
 
-      <!-- Header: DETAILS · copy · preview/edit -->
+      <!-- Header: segment switcher (Description · Steps · Files) + copy + edit -->
       <Border DockPanel.Dock="Top" Classes="island-header">
         <Grid ColumnDefinitions="Auto,*,Auto,Auto" VerticalAlignment="Center">
 
-          <TextBlock Grid.Column="0" Classes="section-label" Text="DETAILS"
+          <StackPanel Grid.Column="0" Orientation="Horizontal" Spacing="2">
-                     VerticalAlignment="Center"/>
+            <Button Classes="seg-btn"
+                    Classes.active="{Binding IsDescriptionSection}"
+                    Command="{Binding SelectDetailSectionCommand}"
+                    CommandParameter="description"
+                    Content="{loc:Tr details.sections.description}"/>
+            <Button Classes="seg-btn"
+                    Classes.active="{Binding IsStepsSection}"
+                    Command="{Binding SelectDetailSectionCommand}"
+                    CommandParameter="steps">
+              <StackPanel Orientation="Horizontal" Spacing="5">
+                <TextBlock Text="{loc:Tr details.sections.steps}" VerticalAlignment="Center"/>
+                <TextBlock Classes="seg-count" Text="{Binding StepsBadge}"
+                           VerticalAlignment="Center"
+                           IsVisible="{Binding StepsBadge, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
+              </StackPanel>
+            </Button>
+            <Button Classes="seg-btn"
+                    Classes.active="{Binding IsFilesSection}"
+                    Command="{Binding SelectDetailSectionCommand}"
+                    CommandParameter="files">
+              <StackPanel Orientation="Horizontal" Spacing="5">
+                <TextBlock Text="{loc:Tr details.sections.files}" VerticalAlignment="Center"/>
+                <TextBlock Classes="seg-count" Text="{Binding FilesBadge}"
+                           VerticalAlignment="Center"
+                           IsVisible="{Binding FilesBadge, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
+              </StackPanel>
+            </Button>
+          </StackPanel>
 
           <!-- Copy formatted -->
           <Button Grid.Column="2"
@@ -27,10 +80,11 @@
             <PathIcon Data="{StaticResource Icon.Copy}" Width="11" Height="11"/>
           </Button>
 
-          <!-- Preview/Edit toggle -->
+          <!-- Preview/Edit toggle (Description section only) -->
           <Button Grid.Column="3"
                   Classes="btn"
                   Padding="8,3"
+                  IsVisible="{Binding IsDescriptionSection}"
                   ToolTip.Tip="{loc:Tr details.toggleEditPreviewTip}"
                   Command="{Binding ToggleEditDescriptionCommand}">
             <Panel>
@@ -42,126 +96,146 @@
         </Grid>
       </Border>
 
-      <!-- Body (scrolls inside the card so the card fills its row to the divider) -->
+      <!-- Body: only the active section is shown -->
       <ScrollViewer VerticalScrollBarVisibility="Auto">
-      <StackPanel Margin="14" Spacing="10">
+        <Panel Margin="14">
 
-        <!-- Description (always visible) -->
+          <!-- Description -->
-        <Panel>
+          <Panel IsVisible="{Binding IsDescriptionSection}">
-          <!-- Edit mode: raw TextBox -->
+            <!-- Edit mode: raw TextBox -->
-          <TextBox Text="{Binding EditableDescription, Mode=TwoWay}"
+            <TextBox Text="{Binding EditableDescription, Mode=TwoWay}"
-                   AcceptsReturn="True"
+                     AcceptsReturn="True"
-                   TextWrapping="Wrap"
+                     TextWrapping="Wrap"
-                   MinHeight="80"
+                     MinHeight="80"
-                   MaxHeight="320"
+                     MaxHeight="320"
-                   Padding="8"
+                     Padding="8"
-                   FontFamily="{DynamicResource MonoFont}"
+                     FontFamily="{DynamicResource MonoFont}"
-                   FontSize="{StaticResource FontSizeBody}"
+                     FontSize="{StaticResource FontSizeBody}"
-                   Background="{DynamicResource Surface3Brush}"
+                     Background="{DynamicResource Surface3Brush}"
-                   BorderBrush="{DynamicResource LineBrush}"
+                     BorderBrush="{DynamicResource LineBrush}"
-                   BorderThickness="1"
+                     BorderThickness="1"
-                   CornerRadius="8"
+                     CornerRadius="8"
-                   IsVisible="{Binding IsEditingDescription}"/>
+                     IsVisible="{Binding IsEditingDescription}"/>
-          <!-- Preview mode: rendered composed text (title + description + open steps) -->
+            <!-- Preview mode: rendered composed text (title + description + open steps) -->
-          <ctl:MarkdownView Markdown="{Binding ComposedPreview}"
+            <ctl:MarkdownView Markdown="{Binding ComposedPreview}"
-                            IsVisible="{Binding !IsEditingDescription}"/>
+                              IsVisible="{Binding !IsEditingDescription}"/>
-        </Panel>
+          </Panel>
 
-        <!-- Steps: always-visible summary strip; expand to manage -->
+          <!-- Steps -->
-        <Border BorderBrush="{DynamicResource LineBrush}"
+          <StackPanel IsVisible="{Binding IsStepsSection}" Spacing="6">
-                BorderThickness="0,1,0,0"
+            <TextBox Text="{Binding NewSubtaskTitle, Mode=TwoWay}"
-                Padding="0,8,0,0">
+                     PlaceholderText="Add step…"
-          <StackPanel Spacing="6">
+                     Padding="8"
+                     Background="{DynamicResource Surface3Brush}"
+                     BorderBrush="{DynamicResource LineBrush}"
+                     BorderThickness="1"
+                     CornerRadius="8">
+              <TextBox.KeyBindings>
+                <KeyBinding Gesture="Enter" Command="{Binding AddSubtaskCommand}"/>
+              </TextBox.KeyBindings>
+            </TextBox>
 
-            <!-- Summary header (click to expand/collapse) -->
+            <!-- Subtask rows -->
-            <Button Classes="flat" Cursor="Hand"
+            <ItemsControl ItemsSource="{Binding Subtasks}">
-                    HorizontalAlignment="Stretch"
+              <ItemsControl.ItemTemplate>
-                    HorizontalContentAlignment="Stretch"
+                <DataTemplate DataType="vm:SubtaskRowViewModel">
-                    Command="{Binding ToggleStepsExpandedCommand}">
+                  <Border Classes="subtask-row" Classes.done="{Binding Done}">
-              <Grid ColumnDefinitions="Auto,Auto,*,Auto">
+                    <Grid ColumnDefinitions="Auto,*">
-                <Panel Grid.Column="0" Width="12" Margin="0,0,6,0" VerticalAlignment="Center">
-                  <TextBlock Classes="meta" Text="▸" IsVisible="{Binding !IsStepsExpanded}"/>
-                  <TextBlock Classes="meta" Text="▾" IsVisible="{Binding IsStepsExpanded}"/>
-                </Panel>
-                <TextBlock Grid.Column="1" Classes="section-label" Text="STEPS"
-                           VerticalAlignment="Center"/>
-                <TextBlock Grid.Column="3" Classes="meta" Text="{Binding StepsSummary}"
-                           Foreground="{DynamicResource TextMuteBrush}"
-                           VerticalAlignment="Center"/>
-              </Grid>
-            </Button>
 
-            <!-- Expanded: add-step input + step rows -->
+                      <!-- Check circle -->
-            <StackPanel IsVisible="{Binding IsStepsExpanded}" Spacing="6">
+                      <Button Grid.Column="0"
-              <TextBox Text="{Binding NewSubtaskTitle, Mode=TwoWay}"
+                              Classes="flat"
-                       PlaceholderText="Add step…"
+                              Padding="0"
-                       Padding="8"
+                              Margin="0,0,8,0"
-                       Background="{DynamicResource Surface3Brush}"
+                              VerticalAlignment="Center"
-                       BorderBrush="{DynamicResource LineBrush}"
+                              Command="{Binding $parent[ItemsControl].((vm:DetailsIslandViewModel)DataContext).ToggleSubtaskDoneCommand}"
-                       BorderThickness="1"
+                              CommandParameter="{Binding}">
-                       CornerRadius="8">
+                        <Ellipse Classes="task-check"
-                <TextBox.KeyBindings>
+                                 Classes.done="{Binding Done}"
-                  <KeyBinding Gesture="Enter" Command="{Binding AddSubtaskCommand}"/>
+                                 Width="16" Height="16"
-                </TextBox.KeyBindings>
+                                 Cursor="Hand"/>
-              </TextBox>
+                      </Button>
 
-              <!-- Subtask rows -->
+                      <!-- Title / edit -->
-              <ItemsControl ItemsSource="{Binding Subtasks}">
+                      <Panel Grid.Column="1" VerticalAlignment="Center">
-            <ItemsControl.ItemTemplate>
+                        <TextBlock Classes="subtask-title"
-              <DataTemplate DataType="vm:SubtaskRowViewModel">
+                                   Text="{Binding Title}"
-                <Border Classes="subtask-row" Classes.done="{Binding Done}">
+                                   IsVisible="{Binding !IsEditing}"
-                  <Grid ColumnDefinitions="Auto,*">
+                                   FontSize="{StaticResource FontSizeBody}"
-
+                                   Foreground="{DynamicResource TextDimBrush}"
-                    <!-- Check circle -->
+                                   VerticalAlignment="Center"
-                    <Button Grid.Column="0"
+                                   TextWrapping="Wrap"
-                            Classes="flat"
+                                   Cursor="Ibeam"
-                            Padding="0"
+                                   Tapped="OnSubtaskTitleTapped"/>
-                            Margin="0,0,8,0"
+                        <TextBox Classes="subtask-edit"
-                            VerticalAlignment="Center"
+                                 Text="{Binding Title, Mode=TwoWay}"
-                            Command="{Binding $parent[ItemsControl].((vm:DetailsIslandViewModel)DataContext).ToggleSubtaskDoneCommand}"
+                                 IsVisible="{Binding IsEditing}"
-                            CommandParameter="{Binding}">
-                      <Ellipse Classes="task-check"
-                               Classes.done="{Binding Done}"
-                               Width="16" Height="16"
-                               Cursor="Hand"/>
-                    </Button>
-
-                    <!-- Title / edit -->
-                    <Panel Grid.Column="1" VerticalAlignment="Center">
-                      <TextBlock Classes="subtask-title"
-                                 Text="{Binding Title}"
-                                 IsVisible="{Binding !IsEditing}"
                                  FontSize="{StaticResource FontSizeBody}"
-                                 Foreground="{DynamicResource TextDimBrush}"
+                                 AcceptsReturn="False"
-                                 VerticalAlignment="Center"
                                  TextWrapping="Wrap"
-                                 Cursor="Ibeam"
+                                 LostFocus="OnSubtaskEditLostFocus">
-                                 Tapped="OnSubtaskTitleTapped"/>
+                          <TextBox.KeyBindings>
-                      <TextBox Classes="subtask-edit"
+                            <KeyBinding Gesture="Enter"
-                               Text="{Binding Title, Mode=TwoWay}"
+                                        Command="{Binding $parent[ItemsControl].((vm:DetailsIslandViewModel)DataContext).CommitSubtaskEditCommand}"
-                               IsVisible="{Binding IsEditing}"
+                                        CommandParameter="{Binding}"/>
-                               FontSize="{StaticResource FontSizeBody}"
+                          </TextBox.KeyBindings>
-                               AcceptsReturn="False"
+                        </TextBox>
-                               TextWrapping="Wrap"
+                      </Panel>
-                               LostFocus="OnSubtaskEditLostFocus">
-                        <TextBox.KeyBindings>
-                          <KeyBinding Gesture="Enter"
-                                      Command="{Binding $parent[ItemsControl].((vm:DetailsIslandViewModel)DataContext).CommitSubtaskEditCommand}"
-                                      CommandParameter="{Binding}"/>
-                        </TextBox.KeyBindings>
-                      </TextBox>
-                    </Panel>
 
-                  </Grid>
+                    </Grid>
-                </Border>
+                  </Border>
-              </DataTemplate>
+                </DataTemplate>
-            </ItemsControl.ItemTemplate>
+              </ItemsControl.ItemTemplate>
-              </ItemsControl>
+            </ItemsControl>
-            </StackPanel>
           </StackPanel>
-        </Border>
 
-      </StackPanel>
+          <!-- Files -->
+          <StackPanel IsVisible="{Binding IsFilesSection}" Spacing="6">
+            <!-- Attachment rows -->
+            <ItemsControl ItemsSource="{Binding Attachments}">
+              <ItemsControl.ItemTemplate>
+                <DataTemplate DataType="vm:AttachmentRowViewModel">
+                  <Grid ColumnDefinitions="*,Auto,Auto" Margin="0,2,0,2">
+                    <TextBlock Grid.Column="0"
+                               Text="{Binding FileName}"
+                               VerticalAlignment="Center"
+                               FontSize="{StaticResource FontSizeBody}"
+                               Foreground="{DynamicResource TextDimBrush}"
+                               TextTrimming="CharacterEllipsis"/>
+                    <TextBlock Grid.Column="1"
+                               Text="{Binding SizeText}"
+                               VerticalAlignment="Center"
+                               Margin="8,0"
+                               FontSize="{StaticResource FontSizeBody}"
+                               Foreground="{DynamicResource TextMuteBrush}"/>
+                    <Button Grid.Column="2"
+                            Classes="icon-btn"
+                            ToolTip.Tip="{loc:Tr details.attachments.removeTip}"
+                            Command="{Binding $parent[ItemsControl].((vm:DetailsIslandViewModel)DataContext).RemoveAttachmentCommand}"
+                            CommandParameter="{Binding}">
+                      <PathIcon Data="{StaticResource Icon.X}" Width="11" Height="11"/>
+                    </Button>
+                  </Grid>
+                </DataTemplate>
+              </ItemsControl.ItemTemplate>
+            </ItemsControl>
+
+            <!-- Add file button -->
+            <Button Classes="btn"
+                    Padding="8,3"
+                    HorizontalAlignment="Left"
+                    Click="OnAddFileClick"
+                    Content="{loc:Tr details.attachments.addFile}"/>
+
+            <!-- Drop status / confirmation -->
+            <TextBlock Text="{Binding DropStatus}"
+                       IsVisible="{Binding DropStatus, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"
+                       FontSize="{StaticResource FontSizeBody}"
+                       Foreground="{DynamicResource TextMuteBrush}"
+                       TextWrapping="Wrap"/>
+          </StackPanel>
+
+        </Panel>
       </ScrollViewer>
     </DockPanel>
   </Border>

src/ClaudeDo.Ui/Views/Islands/Detail/DescriptionStepsCard.axaml.cs

@@ -2,6 +2,7 @@ using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Interactivity;
+using Avalonia.Platform.Storage;
 using ClaudeDo.Ui.ViewModels.Islands;
 
 namespace ClaudeDo.Ui.Views.Islands.Detail;
@@ -34,4 +35,32 @@ public partial class DescriptionStepsCard : UserControl
             && vm.CommitSubtaskEditCommand.CanExecute(row))
             vm.CommitSubtaskEditCommand.Execute(row);
     }
+
+    private async void OnAddFileClick(object? sender, RoutedEventArgs e)
+    {
+        if (DataContext is not DetailsIslandViewModel vm) return;
+        var topLevel = TopLevel.GetTopLevel(this);
+        if (topLevel is null) return;
+
+        var picked = await topLevel.StorageProvider.OpenFilePickerAsync(
+            new FilePickerOpenOptions { AllowMultiple = true });
+
+        if (picked.Count == 0) return;
+
+        var files = new List<(string FileName, System.IO.Stream Content)>();
+        foreach (var item in picked)
+        {
+            var stream = await item.OpenReadAsync();
+            files.Add((item.Name, stream));
+        }
+
+        try
+        {
+            await vm.AddFilesAsync(files);
+        }
+        finally
+        {
+            foreach (var (_, s) in files) await s.DisposeAsync();
+        }
+    }
 }

src/ClaudeDo.Ui/Views/Islands/Detail/TaskHeaderBar.axaml

@@ -52,7 +52,7 @@
     <!-- Column 2: gear button with agent settings flyout -->
     <Button Grid.Column="2" Classes="icon-btn"
             ToolTip.Tip="{loc:Tr details.agentSettingsTip}"
-            IsEnabled="{Binding AgentSettings.IsAgentSectionEnabled}"
+            IsEnabled="{Binding AgentSettings.IsEnabled}"
             VerticalAlignment="Top"
             Margin="6,0,0,0">
       <TextBlock Text="⚙" FontSize="{StaticResource FontSizeTaskTitle}"/>
@@ -60,62 +60,7 @@
         <Flyout Placement="BottomEdgeAlignedRight" ShowMode="Standard">
           <StackPanel Width="340" Spacing="10" Margin="4">
             <TextBlock Text="{loc:Tr details.agentSettingsHeading}" FontWeight="SemiBold"/>
-
+            <ctl:AgentConfigEditor DataContext="{Binding AgentSettings}"/>
-            <StackPanel Spacing="2">
-              <Grid ColumnDefinitions="Auto,Auto,*,Auto" ColumnSpacing="6">
-                <TextBlock Grid.Column="0" Classes="field-label" Text="{loc:Tr details.modelLabel}" VerticalAlignment="Center"/>
-                <ctl:InheritedBadge Grid.Column="1" BadgeText="{Binding AgentSettings.ModelBadge}"/>
-                <Button Grid.Column="3" Classes="icon-btn" Content="↺" ToolTip.Tip="{loc:Tr settings.inherit.resetToInherited}"
-                        Command="{Binding AgentSettings.ResetTaskModelCommand}"/>
-              </Grid>
-              <ComboBox ItemsSource="{Binding AgentSettings.TaskModelOptions}"
-                        SelectedItem="{Binding AgentSettings.TaskModelSelection, Mode=TwoWay}"
-                        PlaceholderText="{Binding AgentSettings.ModelInheritedHint}"
-                        HorizontalAlignment="Stretch"/>
-            </StackPanel>
-
-            <StackPanel Spacing="2">
-              <Grid ColumnDefinitions="Auto,Auto,*,Auto" ColumnSpacing="6">
-                <TextBlock Grid.Column="0" Classes="field-label" Text="{loc:Tr details.maxTurnsLabel}" VerticalAlignment="Center"/>
-                <ctl:InheritedBadge Grid.Column="1" BadgeText="{Binding AgentSettings.TurnsBadge}"/>
-                <Button Grid.Column="3" Classes="icon-btn" Content="↺" ToolTip.Tip="{loc:Tr settings.inherit.resetToInherited}"
-                        Command="{Binding AgentSettings.ResetTaskTurnsCommand}"/>
-              </Grid>
-              <NumericUpDown Value="{Binding AgentSettings.TaskMaxTurns, Mode=TwoWay}"
-                             PlaceholderText="{Binding AgentSettings.TurnsInheritedHint}"
-                             Minimum="1" Maximum="200" Increment="1" FormatString="0"
-                             HorizontalAlignment="Stretch"/>
-            </StackPanel>
-
-            <StackPanel Spacing="2">
-              <TextBlock Classes="field-label" Text="{loc:Tr details.systemPromptLabel}"/>
-              <TextBox Text="{Binding AgentSettings.TaskSystemPrompt, Mode=TwoWay}"
-                       AcceptsReturn="True" TextWrapping="Wrap" MinHeight="70"/>
-              <TextBlock Classes="meta" Opacity="0.6"
-                         Text="{loc:Tr details.systemPromptPrepended}"
-                         IsVisible="{Binding AgentSettings.EffectiveSystemPromptHint, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
-              <TextBlock Classes="meta" Opacity="0.6" TextWrapping="Wrap"
-                         Text="{Binding AgentSettings.EffectiveSystemPromptHint}"
-                         IsVisible="{Binding AgentSettings.EffectiveSystemPromptHint, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
-            </StackPanel>
-
-            <StackPanel Spacing="2">
-              <Grid ColumnDefinitions="Auto,Auto,*,Auto" ColumnSpacing="6">
-                <TextBlock Grid.Column="0" Classes="field-label" Text="{loc:Tr details.agentFileLabel}" VerticalAlignment="Center"/>
-                <ctl:InheritedBadge Grid.Column="1" BadgeText="{Binding AgentSettings.AgentBadge}"/>
-                <Button Grid.Column="3" Classes="icon-btn" Content="↺" ToolTip.Tip="{loc:Tr settings.inherit.resetToInherited}"
-                        Command="{Binding AgentSettings.ResetTaskAgentCommand}"/>
-              </Grid>
-              <ComboBox ItemsSource="{Binding AgentSettings.TaskAgentOptions}"
-                        SelectedItem="{Binding AgentSettings.TaskSelectedAgent, Mode=TwoWay}"
-                        HorizontalAlignment="Stretch">
-                <ComboBox.ItemTemplate>
-                  <DataTemplate>
-                    <TextBlock Text="{Binding Name}"/>
-                  </DataTemplate>
-                </ComboBox.ItemTemplate>
-              </ComboBox>
-            </StackPanel>
           </StackPanel>
         </Flyout>
       </Button.Flyout>

src/ClaudeDo.Ui/Views/Islands/Detail/WorkConsole.axaml

@@ -61,6 +61,28 @@
     <Style Selector="Button.prompt-action.accent:pointerover /template/ ContentPresenter">
       <Setter Property="TextElement.Foreground" Value="{StaticResource MossBrightBrush}" />
     </Style>
+
+    <!-- Review prompt input: blends into the terminal — no border/fill highlight in any state -->
+    <Style Selector="TextBox.review-prompt">
+      <Setter Property="Background"      Value="Transparent" />
+      <Setter Property="BorderThickness" Value="0" />
+      <Setter Property="Padding"         Value="0" />
+    </Style>
+    <Style Selector="TextBox.review-prompt /template/ Border#PART_BorderElement">
+      <Setter Property="Background"      Value="Transparent" />
+      <Setter Property="BorderBrush"     Value="Transparent" />
+      <Setter Property="BorderThickness" Value="0" />
+      <Setter Property="BoxShadow"       Value="none" />
+    </Style>
+    <Style Selector="TextBox.review-prompt:pointerover /template/ Border#PART_BorderElement">
+      <Setter Property="Background"  Value="Transparent" />
+      <Setter Property="BorderBrush" Value="Transparent" />
+    </Style>
+    <Style Selector="TextBox.review-prompt:focus /template/ Border#PART_BorderElement">
+      <Setter Property="Background"  Value="Transparent" />
+      <Setter Property="BorderBrush" Value="Transparent" />
+      <Setter Property="BoxShadow"   Value="none" />
+    </Style>
   </UserControl.Styles>
 
   <!-- Outer terminal card — Padding="0" so header/strip span edge-to-edge;
@@ -212,27 +234,111 @@
             </StackPanel>
           </Border>
 
-          <!-- Review footer: feedback + Resume session, shown while awaiting review.
+          <!-- Review prompt — sits directly on the terminal, like a shell input line;
-               Lives here (with the live log) rather than the Git tab. -->
+               only while awaiting review. No border/fill so it reads as part of the log. -->
-          <Border DockPanel.Dock="Bottom"
+          <Grid DockPanel.Dock="Bottom"
-                  IsVisible="{Binding IsWaitingForReview}"
+                IsVisible="{Binding IsWaitingForReview}"
-                  Margin="12,6,12,2">
+                ColumnDefinitions="Auto,*,Auto"
-            <StackPanel Spacing="8">
+                Margin="12,2,12,8">
-              <TextBox Name="ReviewInput"
+            <TextBlock Grid.Column="0" Text="&#x276F;"
-                       KeyDown="OnReviewInputKeyDown"
-                       Text="{Binding ReviewFeedback, Mode=TwoWay}"
-                       AcceptsReturn="True"
-                       TextWrapping="Wrap"
-                       MaxHeight="120"
-                       PlaceholderText="Feedback for a re-run…"
                        FontFamily="{StaticResource MonoFont}"
-                       FontSize="{StaticResource FontSizeMono}" />
+                       FontSize="{StaticResource FontSizeMono}"
-              <Button Classes="btn" Content="Resume session"
+                       Foreground="{DynamicResource AccentBrush}"
-                      HorizontalAlignment="Left"
+                       VerticalAlignment="Center" Margin="0,0,8,0" />
-                      ToolTip.Tip="{loc:Tr session.reviewContinueTip}"
+            <TextBox Grid.Column="1"
-                      Command="{Binding RejectReviewCommand}" />
+                     Name="ReviewInput"
-            </StackPanel>
+                     Classes="review-prompt"
-          </Border>
+                     KeyDown="OnReviewInputKeyDown"
+                     Text="{Binding ReviewFeedback, Mode=TwoWay}"
+                     AcceptsReturn="True"
+                     TextWrapping="Wrap"
+                     MaxHeight="160"
+                     PlaceholderText="Feedback for the next run…"
+                     VerticalContentAlignment="Center"
+                     FontFamily="{StaticResource MonoFont}"
+                     FontSize="{StaticResource FontSizeMono}" />
+            <Button Grid.Column="2" Classes="prompt-action accent" Content="[Resume]"
+                    VerticalAlignment="Center" Margin="12,0,0,0"
+                    ToolTip.Tip="{loc:Tr session.reviewContinueTip}"
+                    Command="{Binding RejectReviewCommand}" />
+          </Grid>
+
+          <!-- Interactive composer + queued strip — chat with a live in-app session -->
+          <StackPanel DockPanel.Dock="Bottom" Orientation="Vertical">
+            <!-- Queued messages strip -->
+            <Border IsVisible="{Binding Monitor.HasQueuedMessages}"
+                    BorderBrush="{DynamicResource LineBrush}"
+                    BorderThickness="0,1,0,0"
+                    Padding="12,4">
+              <StackPanel Spacing="2">
+                <TextBlock Classes="meta"
+                           Text="{loc:Tr session.composer.queued}"
+                           Foreground="{DynamicResource TextMuteBrush}" />
+                <ItemsControl ItemsSource="{Binding Monitor.QueuedMessages}">
+                  <ItemsControl.ItemTemplate>
+                    <DataTemplate x:DataType="vm:QueuedMessageViewModel">
+                      <Grid ColumnDefinitions="Auto,*,Auto" Margin="0,1">
+                        <TextBlock Grid.Column="0"
+                                   Text="⧗"
+                                   Foreground="{DynamicResource TextMuteBrush}"
+                                   FontFamily="{StaticResource MonoFont}"
+                                   FontSize="{StaticResource FontSizeMono}"
+                                   VerticalAlignment="Center"
+                                   Margin="0,0,6,0" />
+                        <TextBlock Grid.Column="1"
+                                   Text="{Binding Text}"
+                                   Foreground="{DynamicResource TextDimBrush}"
+                                   FontFamily="{StaticResource MonoFont}"
+                                   FontSize="{StaticResource FontSizeMono}"
+                                   TextTrimming="CharacterEllipsis"
+                                   VerticalAlignment="Center" />
+                        <Button Grid.Column="2"
+                                Classes="title-ctrl"
+                                Command="{Binding RemoveCommand}"
+                                ToolTip.Tip="{loc:Tr session.composer.unqueue}"
+                                Margin="4,0,0,0">
+                          <PathIcon Data="{StaticResource Icon.WinClose}" Width="8" Height="8"/>
+                        </Button>
+                      </Grid>
+                    </DataTemplate>
+                  </ItemsControl.ItemTemplate>
+                </ItemsControl>
+              </StackPanel>
+            </Border>
+            <!-- Composer input row -->
+            <Grid IsVisible="{Binding Monitor.IsInteractiveLive}"
+                  ColumnDefinitions="Auto,*,Auto,Auto"
+                  Margin="12,2,12,8">
+              <TextBlock Grid.Column="0" Text="&#x276F;"
+                         FontFamily="{StaticResource MonoFont}"
+                         FontSize="{StaticResource FontSizeMono}"
+                         Foreground="{DynamicResource AccentBrush}"
+                         VerticalAlignment="Center" Margin="0,0,8,0" />
+              <TextBox Grid.Column="1"
+                       Classes="review-prompt"
+                       Text="{Binding Monitor.ComposerDraft, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                       AcceptsReturn="False"
+                       TextWrapping="Wrap"
+                       MaxHeight="160"
+                       PlaceholderText="{loc:Tr session.composer.placeholder}"
+                       VerticalContentAlignment="Center"
+                       FontFamily="{StaticResource MonoFont}"
+                       FontSize="{StaticResource FontSizeMono}">
+                <TextBox.KeyBindings>
+                  <KeyBinding Gesture="Enter" Command="{Binding Monitor.SubmitComposerCommand}" />
+                </TextBox.KeyBindings>
+              </TextBox>
+              <Button Grid.Column="2" Classes="prompt-action"
+                      VerticalAlignment="Center" Margin="12,0,0,0"
+                      Command="{Binding Monitor.InterruptInteractiveCommand}"
+                      ToolTip.Tip="{loc:Tr session.composer.interrupt}">
+                <PathIcon Data="{StaticResource Icon.Stop}" Width="10" Height="10"/>
+              </Button>
+              <Button Grid.Column="3" Classes="prompt-action accent" Content="[Send]"
+                      VerticalAlignment="Center" Margin="4,0,0,0"
+                      Command="{Binding Monitor.SubmitComposerCommand}" />
+            </Grid>
+          </StackPanel>
 
           <ScrollViewer Name="LogScroll"
                         VerticalScrollBarVisibility="Visible"
@@ -247,7 +353,7 @@
                                Text="{Binding TimestampFormatted}" />
                     <SelectableTextBlock Grid.Column="1"
                                          Text="{Binding Text}" Tag="{Binding ClassName}"
-                                         Foreground="{DynamicResource TextDimBrush}"
+                                         Foreground="{Binding Kind, Converter={StaticResource LogKindForeground}}"
                                          TextWrapping="Wrap" />
                   </Grid>
                 </DataTemplate>

src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml

@@ -5,7 +5,9 @@
              xmlns:detail="using:ClaudeDo.Ui.Views.Islands.Detail"
              xmlns:loc="using:ClaudeDo.Ui.Localization"
              x:Class="ClaudeDo.Ui.Views.Islands.DetailsIslandView"
-             x:DataType="vm:DetailsIslandViewModel">
+             x:DataType="vm:DetailsIslandViewModel"
+             DragDrop.AllowDrop="True">
+  <Panel>
   <DockPanel>
 
     <!-- ── Metadata footer (sticky bottom) — created-at + close — task detail only ── -->
@@ -124,4 +126,21 @@
     </Grid>
 
   </DockPanel>
+
+  <!-- Drop overlay — shown while dragging files over the pane -->
+  <Border IsVisible="{Binding IsDragOver}"
+          Background="{DynamicResource AccentSoftBrush}"
+          BorderBrush="{DynamicResource AccentBrush}"
+          BorderThickness="2"
+          CornerRadius="14"
+          IsHitTestVisible="False">
+    <TextBlock Text="{loc:Tr details.attachments.dropToAttach}"
+               HorizontalAlignment="Center"
+               VerticalAlignment="Center"
+               Foreground="{DynamicResource AccentBrush}"
+               FontSize="16"
+               FontWeight="Medium"/>
+  </Border>
+
+  </Panel>
 </UserControl>

src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml.cs

@@ -1,12 +1,13 @@
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Input;
+using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.Media;
+using Avalonia.Platform.Storage;
 using Avalonia.Reactive;
 using ClaudeDo.Ui.ViewModels.Islands;
 using ClaudeDo.Ui.Views.Modals;
-using ClaudeDo.Ui.Views.Planning;
 
 namespace ClaudeDo.Ui.Views.Islands;
 
@@ -27,6 +28,78 @@ public partial class DetailsIslandView : UserControl
         // row Min/Max during a drag, so the console stops shrinking at 1/3.
         DetailBodyGrid.GetObservable(BoundsProperty)
             .Subscribe(new AnonymousObserver<Rect>(_ => UpdateRowLimits()));
+
+        AddHandler(DragDrop.DragEnterEvent, OnDragEnter);
+        AddHandler(DragDrop.DragOverEvent, OnDragOver);
+        AddHandler(DragDrop.DragLeaveEvent, OnDragLeave);
+        AddHandler(DragDrop.DropEvent, OnDrop);
+    }
+
+    private static bool IsFilesDrop(DragEventArgs e)
+        => e.DataTransfer?.Contains(DataFormat.File) == true;
+
+    private void OnDragEnter(object? sender, DragEventArgs e)
+    {
+        if (_vm is { CanAcceptDrop: true } && IsFilesDrop(e))
+        {
+            e.DragEffects = DragDropEffects.Copy;
+            _vm.IsDragOver = true;
+        }
+        else
+        {
+            e.DragEffects = DragDropEffects.None;
+        }
+        e.Handled = true;
+    }
+
+    private void OnDragOver(object? sender, DragEventArgs e)
+    {
+        if (_vm is { CanAcceptDrop: true } && IsFilesDrop(e))
+        {
+            e.DragEffects = DragDropEffects.Copy;
+            _vm.IsDragOver = true;
+        }
+        else
+        {
+            e.DragEffects = DragDropEffects.None;
+        }
+        e.Handled = true;
+    }
+
+    private void OnDragLeave(object? sender, RoutedEventArgs e)
+    {
+        if (_vm != null) _vm.IsDragOver = false;
+    }
+
+    private async void OnDrop(object? sender, DragEventArgs e)
+    {
+        if (_vm != null) _vm.IsDragOver = false;
+        if (_vm is not { CanAcceptDrop: true } || !IsFilesDrop(e)) return;
+        e.Handled = true;
+
+        var items = e.DataTransfer.TryGetFiles();
+        if (items is null) return;
+
+        var files = new List<(string FileName, System.IO.Stream Content)>();
+        foreach (var item in items)
+        {
+            if (item is IStorageFile sf)
+            {
+                var stream = await sf.OpenReadAsync();
+                files.Add((sf.Name, stream));
+            }
+        }
+
+        if (files.Count == 0) return;
+
+        try
+        {
+            await _vm.AddFilesAsync(files);
+        }
+        finally
+        {
+            foreach (var (_, s) in files) await s.DisposeAsync();
+        }
     }
 
     private void UpdateRowLimits()
@@ -55,11 +128,11 @@ public partial class DetailsIslandView : UserControl
             vm.PropertyChanged += OnViewModelPropertyChanged;
             ApplyResizeStateForCurrentTask();
 
-            vm.Merge.ShowDiffModal = async (diffVm) =>
+            vm.Merge.ShowDiffViewer = async (diffVm) =>
             {
                 var owner = TopLevel.GetTopLevel(this) as Window;
                 if (owner == null) return;
-                var modal = new DiffModalView { DataContext = diffVm };
+                var modal = new DiffViewerView { DataContext = diffVm };
                 await modal.ShowDialog(owner);
             };
 
@@ -71,14 +144,6 @@ public partial class DetailsIslandView : UserControl
                 await modal.ShowDialog(owner);
             };
 
-            vm.Merge.ShowPlanningDiffModal = async (planningDiffVm) =>
-            {
-                var owner = TopLevel.GetTopLevel(this) as Window;
-                if (owner == null) return;
-                var modal = new PlanningDiffView { DataContext = planningDiffVm };
-                await modal.ShowDialog(owner);
-            };
-
             vm.ConfirmAsync = ShowConfirmAsync;
             vm.ShowErrorAsync = ShowErrorDialogAsync;
         }

src/ClaudeDo.Ui/Views/Islands/ListsIslandView.axaml

@@ -49,12 +49,12 @@
           <TextBlock Classes="title" Text="{Binding UserName}"/>
           <TextBlock Classes="meta" Text="{Binding MachineNameLocal}"/>
         </StackPanel>
-        <!-- More button -->
+        <!-- Settings button -->
         <Button Grid.Column="2" Classes="icon-btn" VerticalAlignment="Center"
                 Command="{Binding OpenSettingsCommand}"
                 ToolTip.Tip="{loc:Tr lists.settingsTip}">
-          <PathIcon Data="{StaticResource Icon.MoreHorizontal}"
+          <PathIcon Data="{StaticResource Icon.Settings}"
-                    Width="14" Height="14"
+                    Width="15" Height="15"
                     Foreground="{DynamicResource TextMuteBrush}"/>
         </Button>
       </Grid>

src/ClaudeDo.Ui/Views/Islands/ListsIslandView.axaml.cs

@@ -25,61 +25,7 @@ public partial class ListsIslandView : UserControl
         DataContextChanged += (_, _) =>
         {
             if (DataContext is ListsIslandViewModel vm)
-            {
                 vm.FocusSearchRequested += (_, _) => SearchBox.Focus();
-                vm.ShowSettingsModal = ShowSettingsAsync;
-                vm.ShowListSettingsModal = async modal =>
-                {
-                    var window = new ListSettingsModalView { DataContext = modal };
-                    modal.CloseAction = () => window.Close();
-                    modal.ConfirmAsync = ShowConfirmAsync;
-                    modal.ShowErrorAsync = ShowErrorDialogAsync;
-                    var top = TopLevel.GetTopLevel(this) as Window;
-                    if (top is null) window.Show();
-                    else await window.ShowDialog(top);
-                };
-                vm.ShowRepoImportModal = async modal =>
-                {
-                    var window = new RepoImportModalView { DataContext = modal };
-                    modal.CloseAction = () => window.Close();
-                    var top = TopLevel.GetTopLevel(this) as Window;
-                    if (top is null) window.Show();
-                    else await window.ShowDialog(top);
-                };
-                vm.ShowWorktreesOverviewModal = async modal =>
-                {
-                    var top = TopLevel.GetTopLevel(this) as Window;
-                    var shell = top?.DataContext as IslandsShellViewModel;
-                    var window = new WorktreesOverviewModalView { DataContext = modal };
-                    modal.CloseAction = () => window.Close();
-                    modal.JumpToTaskAction = (listId, taskId) =>
-                    {
-                        if (shell is not null)
-                            _ = JumpToTaskAsync(shell, listId, taskId);
-                    };
-                    modal.ShowDiffAction = diffVm =>
-                    {
-                        if (top is null) return;
-                        var dlg = new WorktreeModalView { DataContext = diffVm };
-                        diffVm.CloseAction = () => dlg.Close();
-                        _ = diffVm.LoadAsync();
-                        _ = dlg.ShowDialog(top);
-                    };
-                    modal.ConfirmAction = ShowConfirmAsync;
-                    if (shell is not null)
-                    {
-                        modal.ResolveMergeVm = shell.ResolveMergeVm;
-                        modal.ShowMergeAction = async mergeVm =>
-                        {
-                            if (top is null) return;
-                            var mergeDlg = new MergeModalView { DataContext = mergeVm };
-                            await mergeDlg.ShowDialog(top);
-                        };
-                    }
-                    if (top is null) window.Show();
-                    else await window.ShowDialog(top);
-                };
-            }
         };
     }
 
@@ -211,95 +157,4 @@ public partial class ListsIslandView : UserControl
         return idx + 1 < vm.UserLists.Count ? vm.UserLists[idx + 1] : null;
     }
 
-    private async System.Threading.Tasks.Task ShowSettingsAsync(SettingsModalViewModel settingsVm)
-    {
-        var owner = TopLevel.GetTopLevel(this) as Window;
-        if (owner == null) return;
-        var modal = new SettingsModalView { DataContext = settingsVm };
-        await modal.ShowDialog(owner);
-    }
-
-    private static System.Threading.Tasks.Task JumpToTaskAsync(IslandsShellViewModel s, string listId, string taskId)
-        => JumpToTaskHelper.SelectAsync(s, listId, taskId);
-
-    private async System.Threading.Tasks.Task ShowErrorDialogAsync(string message)
-    {
-        var owner = TopLevel.GetTopLevel(this) as Window;
-        if (owner is null) return;
-
-        var ok = new Button { Content = "OK", MinWidth = 90 };
-        var dialog = new Window
-        {
-            Title = "Error",
-            Width = 360,
-            SizeToContent = SizeToContent.Height,
-            CanResize = false,
-            WindowStartupLocation = WindowStartupLocation.CenterOwner,
-            ShowInTaskbar = false,
-            Background = this.FindResource("SurfaceBrush") as IBrush,
-            Content = new StackPanel
-            {
-                Spacing = 16,
-                Margin = new Thickness(20),
-                Children =
-                {
-                    new TextBlock { Text = message, TextWrapping = TextWrapping.Wrap },
-                    new StackPanel
-                    {
-                        Orientation = Orientation.Horizontal,
-                        Spacing = 8,
-                        HorizontalAlignment = HorizontalAlignment.Right,
-                        Children = { ok },
-                    },
-                },
-            },
-        };
-
-        ok.Click += (_, _) => dialog.Close();
-        await dialog.ShowDialog(owner);
-    }
-
-    private async System.Threading.Tasks.Task<bool> ShowConfirmAsync(string message)
-    {
-        var owner = TopLevel.GetTopLevel(this) as Window;
-        if (owner is null) return false;
-
-        var tcs = new TaskCompletionSource<bool>();
-        var cancel = new Button { Content = "Cancel", MinWidth = 90 };
-        var confirm = new Button { Content = "Confirm", MinWidth = 90, Classes = { "danger" } };
-
-        var dialog = new Window
-        {
-            Title = "Confirm",
-            Width = 380,
-            SizeToContent = SizeToContent.Height,
-            CanResize = false,
-            WindowStartupLocation = WindowStartupLocation.CenterOwner,
-            ShowInTaskbar = false,
-            Background = this.FindResource("SurfaceBrush") as IBrush,
-            Content = new StackPanel
-            {
-                Margin = new Thickness(20),
-                Spacing = 16,
-                Children =
-                {
-                    new TextBlock { Text = message, TextWrapping = TextWrapping.Wrap },
-                    new StackPanel
-                    {
-                        Orientation = Orientation.Horizontal,
-                        HorizontalAlignment = HorizontalAlignment.Right,
-                        Spacing = 8,
-                        Children = { cancel, confirm },
-                    },
-                },
-            },
-        };
-
-        cancel.Click += (_, _) => { tcs.TrySetResult(false); dialog.Close(); };
-        confirm.Click += (_, _) => { tcs.TrySetResult(true); dialog.Close(); };
-        dialog.Closed += (_, _) => tcs.TrySetResult(false);
-
-        _ = dialog.ShowDialog(owner);
-        return await tcs.Task;
-    }
 }

src/ClaudeDo.Ui/Views/Islands/SessionTerminalView.axaml

@@ -50,6 +50,79 @@
         </Border>
       </Grid>
 
+      <!-- ── Queued strip + Composer bar ── -->
+      <StackPanel DockPanel.Dock="Bottom" Orientation="Vertical">
+        <!-- Queued messages strip -->
+        <Border IsVisible="{Binding #Root.HasQueuedMessages}"
+                Background="{DynamicResource Surface2Brush}"
+                BorderBrush="{DynamicResource LineBrush}"
+                BorderThickness="0,0,0,1"
+                Padding="8,4">
+          <StackPanel Spacing="2">
+            <TextBlock Classes="meta"
+                       Text="{loc:Tr session.composer.queued}"
+                       Foreground="{DynamicResource TextMuteBrush}" />
+            <ItemsControl ItemsSource="{Binding #Root.QueuedMessages}">
+              <ItemsControl.ItemTemplate>
+                <DataTemplate x:DataType="vm:QueuedMessageViewModel">
+                  <Grid ColumnDefinitions="Auto,*,Auto" Margin="0,1">
+                    <TextBlock Grid.Column="0"
+                               Text="⧗"
+                               Foreground="{DynamicResource TextMuteBrush}"
+                               FontFamily="{StaticResource MonoFont}"
+                               FontSize="{StaticResource FontSizeMono}"
+                               VerticalAlignment="Center"
+                               Margin="0,0,6,0" />
+                    <TextBlock Grid.Column="1"
+                               Text="{Binding Text}"
+                               Foreground="{DynamicResource TextDimBrush}"
+                               FontFamily="{StaticResource MonoFont}"
+                               FontSize="{StaticResource FontSizeMono}"
+                               TextTrimming="CharacterEllipsis"
+                               VerticalAlignment="Center" />
+                    <Button Grid.Column="2"
+                            Classes="title-ctrl"
+                            Command="{Binding RemoveCommand}"
+                            ToolTip.Tip="{loc:Tr session.composer.unqueue}"
+                            Margin="4,0,0,0">
+                      <PathIcon Data="{StaticResource Icon.WinClose}" Width="8" Height="8"/>
+                    </Button>
+                  </Grid>
+                </DataTemplate>
+              </ItemsControl.ItemTemplate>
+            </ItemsControl>
+          </StackPanel>
+        </Border>
+        <!-- Composer input row -->
+        <Border IsVisible="{Binding #Root.IsComposerVisible}"
+                Background="{DynamicResource Surface2Brush}"
+                BorderBrush="{DynamicResource LineBrush}"
+                BorderThickness="0,1,0,0"
+                Padding="6,5">
+          <Grid ColumnDefinitions="*,Auto,Auto">
+            <TextBox Grid.Column="0"
+                     Text="{Binding #Root.ComposerText, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                     PlaceholderText="{Binding #Root.ComposerPlaceholder}"
+                     AcceptsReturn="False">
+              <TextBox.KeyBindings>
+                <KeyBinding Gesture="Enter" Command="{Binding #Root.SubmitCommand}"/>
+              </TextBox.KeyBindings>
+            </TextBox>
+            <Button Grid.Column="1"
+                    Margin="6,0,0,0"
+                    Classes="title-ctrl"
+                    Command="{Binding #Root.InterruptCommand}"
+                    ToolTip.Tip="{loc:Tr session.composer.interrupt}">
+              <PathIcon Data="{StaticResource Icon.Stop}" Width="10" Height="10"/>
+            </Button>
+            <Button Grid.Column="2"
+                    Margin="6,0,0,0"
+                    Content="{loc:Tr session.composer.send}"
+                    Command="{Binding #Root.SubmitCommand}"/>
+          </Grid>
+        </Border>
+      </StackPanel>
+
       <!-- ── Log output ── -->
       <ScrollViewer Name="LogScroll"
                     VerticalScrollBarVisibility="Visible"
@@ -66,7 +139,7 @@
                 <!-- Message text — selectable so the user can copy raw output -->
                 <SelectableTextBlock Grid.Column="1"
                                      Text="{Binding Text}" Tag="{Binding ClassName}"
-                                     Foreground="{DynamicResource TextDimBrush}"
+                                     Foreground="{Binding Kind, Converter={StaticResource LogKindForeground}}"
                                      TextWrapping="Wrap"/>
               </Grid>
             </DataTemplate>

src/ClaudeDo.Ui/Views/Islands/SessionTerminalView.axaml.cs

@@ -1,7 +1,9 @@
 using System.Collections;
 using System.Collections.Specialized;
+using System.Windows.Input;
 using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Data;
 
 namespace ClaudeDo.Ui.Views.Islands;
 
@@ -17,12 +19,33 @@ public partial class SessionTerminalView : UserControl
         AvaloniaProperty.Register<SessionTerminalView, bool>(nameof(IsDone));
     public static readonly StyledProperty<bool> IsFailedProperty =
         AvaloniaProperty.Register<SessionTerminalView, bool>(nameof(IsFailed));
+    public static readonly StyledProperty<bool> IsComposerVisibleProperty =
+        AvaloniaProperty.Register<SessionTerminalView, bool>(nameof(IsComposerVisible), defaultValue: false);
+    public static readonly StyledProperty<string?> ComposerTextProperty =
+        AvaloniaProperty.Register<SessionTerminalView, string?>(nameof(ComposerText), defaultBindingMode: BindingMode.TwoWay);
+    public static readonly StyledProperty<ICommand?> SubmitCommandProperty =
+        AvaloniaProperty.Register<SessionTerminalView, ICommand?>(nameof(SubmitCommand));
+    public static readonly StyledProperty<ICommand?> InterruptCommandProperty =
+        AvaloniaProperty.Register<SessionTerminalView, ICommand?>(nameof(InterruptCommand));
+    public static readonly StyledProperty<string?> ComposerPlaceholderProperty =
+        AvaloniaProperty.Register<SessionTerminalView, string?>(nameof(ComposerPlaceholder));
+    public static readonly StyledProperty<System.Collections.IEnumerable?> QueuedMessagesProperty =
+        AvaloniaProperty.Register<SessionTerminalView, System.Collections.IEnumerable?>(nameof(QueuedMessages));
+    public static readonly StyledProperty<bool> HasQueuedMessagesProperty =
+        AvaloniaProperty.Register<SessionTerminalView, bool>(nameof(HasQueuedMessages), defaultValue: false);
 
     public IEnumerable? Entries { get => GetValue(EntriesProperty); set => SetValue(EntriesProperty, value); }
     public string? Label { get => GetValue(LabelProperty); set => SetValue(LabelProperty, value); }
     public bool IsRunning { get => GetValue(IsRunningProperty); set => SetValue(IsRunningProperty, value); }
     public bool IsDone { get => GetValue(IsDoneProperty); set => SetValue(IsDoneProperty, value); }
     public bool IsFailed { get => GetValue(IsFailedProperty); set => SetValue(IsFailedProperty, value); }
+    public bool IsComposerVisible { get => GetValue(IsComposerVisibleProperty); set => SetValue(IsComposerVisibleProperty, value); }
+    public string? ComposerText { get => GetValue(ComposerTextProperty); set => SetValue(ComposerTextProperty, value); }
+    public ICommand? SubmitCommand { get => GetValue(SubmitCommandProperty); set => SetValue(SubmitCommandProperty, value); }
+    public ICommand? InterruptCommand { get => GetValue(InterruptCommandProperty); set => SetValue(InterruptCommandProperty, value); }
+    public string? ComposerPlaceholder { get => GetValue(ComposerPlaceholderProperty); set => SetValue(ComposerPlaceholderProperty, value); }
+    public System.Collections.IEnumerable? QueuedMessages { get => GetValue(QueuedMessagesProperty); set => SetValue(QueuedMessagesProperty, value); }
+    public bool HasQueuedMessages { get => GetValue(HasQueuedMessagesProperty); set => SetValue(HasQueuedMessagesProperty, value); }
 
     private INotifyCollectionChanged? _subscribedCollection;
 

src/ClaudeDo.Ui/Views/Islands/TaskRowView.axaml

@@ -30,6 +30,7 @@
       <Border Grid.Column="1" Classes="task-row"
               Margin="0"
               Classes.selected="{Binding IsSelected}"
+              Classes.dragging="{Binding IsDragging}"
               Classes.done="{Binding Done}">
         <Border.ContextMenu>
           <ContextMenu>
@@ -87,10 +88,10 @@
                 VerticalAlignment="Center"
                 ToolTip.Tip="{loc:Tr tasks.toggleSubtasksTip}">
           <Panel>
-            <TextBlock Classes="meta" Text="▾" IsVisible="{Binding IsExpanded}"
+            <PathIcon Width="12" Height="12" Data="{StaticResource Icon.ChevronDown}"
-                       VerticalAlignment="Center" HorizontalAlignment="Center"/>
+                      Foreground="{DynamicResource TextDimBrush}" IsVisible="{Binding IsExpanded}"/>
-            <TextBlock Classes="meta" Text="▸" IsVisible="{Binding !IsExpanded}"
+            <PathIcon Width="12" Height="12" Data="{StaticResource Icon.ChevronRight}"
-                       VerticalAlignment="Center" HorizontalAlignment="Center"/>
+                      Foreground="{DynamicResource TextDimBrush}" IsVisible="{Binding !IsExpanded}"/>
           </Panel>
         </Button>
 

src/ClaudeDo.Ui/Views/Islands/TaskRowView.axaml.cs

@@ -1,12 +1,7 @@
 using System.Linq;
-using Avalonia;
-using Avalonia.Animation;
-using Avalonia.Animation.Easings;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 using Avalonia.Interactivity;
-using Avalonia.Media;
-using Avalonia.Styling;
 using Avalonia.VisualTree;
 using ClaudeDo.Data.Models;
 using ClaudeDo.Ui.ViewModels.Islands;
@@ -123,24 +118,4 @@ public partial class TaskRowView : UserControl
         ScheduleAnchor.Flyout?.Hide();
         _pendingScheduleRow = null;
     }
-
-    protected override async void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
-    {
-        base.OnAttachedToVisualTree(e);
-        RenderTransform = new TranslateTransform(0, 8);
-        Opacity = 0;
-        var anim = new Avalonia.Animation.Animation
-        {
-            Duration = TimeSpan.FromMilliseconds(300),
-            Easing = new CubicEaseOut(),
-            Children =
-            {
-                new KeyFrame { Cue = new Cue(0), Setters = { new Setter(OpacityProperty, 0d) } },
-                new KeyFrame { Cue = new Cue(1), Setters = { new Setter(OpacityProperty, 1d) } },
-            }
-        };
-        await anim.RunAsync(this);
-        Opacity = 1;
-        RenderTransform = null;
-    }
 }

src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml

@@ -95,13 +95,7 @@
                 <Button Classes="flat" HorizontalAlignment="Stretch"
                         HorizontalContentAlignment="Stretch"
                         Command="{Binding $parent[ItemsControl].((vm:TasksIslandViewModel)DataContext).SelectCommand}"
-                        CommandParameter="{Binding}"
+                        CommandParameter="{Binding}">
-                        PointerPressed="OnRowPointerPressed"
-                        PointerMoved="OnRowPointerMoved"
-                        PointerReleased="OnRowPointerReleased"
-                        DragDrop.AllowDrop="True"
-                        DragDrop.DragOver="OnRowDragOver"
-                        DragDrop.Drop="OnRowDrop">
                   <islands:TaskRowView/>
                 </Button>
               </DataTemplate>
@@ -120,13 +114,7 @@
                 <Button Classes="flat" HorizontalAlignment="Stretch"
                         HorizontalContentAlignment="Stretch"
                         Command="{Binding $parent[ItemsControl].((vm:TasksIslandViewModel)DataContext).SelectCommand}"
-                        CommandParameter="{Binding}"
+                        CommandParameter="{Binding}">
-                        PointerPressed="OnRowPointerPressed"
-                        PointerMoved="OnRowPointerMoved"
-                        PointerReleased="OnRowPointerReleased"
-                        DragDrop.AllowDrop="True"
-                        DragDrop.DragOver="OnRowDragOver"
-                        DragDrop.Drop="OnRowDrop">
                   <islands:TaskRowView/>
                 </Button>
               </DataTemplate>
@@ -159,13 +147,7 @@
                 <Button Classes="flat" HorizontalAlignment="Stretch"
                         HorizontalContentAlignment="Stretch"
                         Command="{Binding $parent[ItemsControl].((vm:TasksIslandViewModel)DataContext).SelectCommand}"
-                        CommandParameter="{Binding}"
+                        CommandParameter="{Binding}">
-                        PointerPressed="OnRowPointerPressed"
-                        PointerMoved="OnRowPointerMoved"
-                        PointerReleased="OnRowPointerReleased"
-                        DragDrop.AllowDrop="True"
-                        DragDrop.DragOver="OnRowDragOver"
-                        DragDrop.Drop="OnRowDrop">
                   <islands:TaskRowView/>
                 </Button>
               </DataTemplate>

src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml.cs

@@ -1,25 +1,43 @@
+using System;
+using System.Linq;
 using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.Media;
+using Avalonia.Threading;
 using Avalonia.VisualTree;
+using ClaudeDo.Ui.ViewModels;
 using ClaudeDo.Ui.ViewModels.Islands;
 using ClaudeDo.Ui.ViewModels.Modals;
+using ClaudeDo.Ui.Views.Controls;
+using ClaudeDo.Ui.Views.MissionControl;
 using ClaudeDo.Ui.Views.Modals;
 
 namespace ClaudeDo.Ui.Views.Islands;
 
 public partial class TasksIslandView : UserControl
 {
-    private static readonly DataFormat<string> TaskRowFormat =
+    private readonly TaskDragController _drag = new();
-        DataFormat.CreateStringApplicationFormat("claudedo-task-row");
+
+    // Custom-drag gesture state. The drag is ARMED on press and BEGINS once the pointer moves
+    // past the threshold, so a plain click still selects the row.
+    private const double DragThreshold = 4;
+    private Point _pressPoint;
+    private TaskRowViewModel? _pressRow;
+    private Control? _pressControl;
+    private bool _dragArmed;
+    private bool _dragging;
 
     public TasksIslandView()
     {
         InitializeComponent();
         AddHandler(PointerPressedEvent, OnTunnelPointerPressed, RoutingStrategies.Tunnel);
+        AddHandler(PointerMovedEvent, OnPointerMovedDrag, RoutingStrategies.Tunnel);
+        AddHandler(PointerReleasedEvent, OnPointerReleasedDrag, RoutingStrategies.Tunnel);
+        AddHandler(PointerCaptureLostEvent, OnPointerCaptureLost);
         DataContextChanged += (_, _) =>
         {
             if (DataContext is TasksIslandViewModel vm)
@@ -36,10 +54,26 @@ public partial class TasksIslandView : UserControl
                     // ShowDialog completes once the window is closed (CloseAction or OS close).
                 };
                 vm.ConfirmAsync = ShowConfirmAsync;
+                vm.SelectionChanged += (_, _) => ScrollSelectedIntoView();
             }
         };
     }
 
+    // Bring the selected row into view — the task list is a plain ItemsControl with no
+    // built-in selection scrolling, so a programmatic select (e.g. Mission Control's
+    // "Open in app") would otherwise highlight a row that stays off-screen.
+    private void ScrollSelectedIntoView()
+    {
+        if (DataContext is not TasksIslandViewModel vm || vm.SelectedTask is not { } target) return;
+        Dispatcher.UIThread.Post(() =>
+        {
+            var match = this.GetVisualDescendants()
+                .OfType<Button>()
+                .FirstOrDefault(b => ReferenceEquals(b.DataContext, target));
+            match?.BringIntoView();
+        }, DispatcherPriority.Background);
+    }
+
     private async System.Threading.Tasks.Task<bool> ShowConfirmAsync(string message)
     {
         var owner = TopLevel.GetTopLevel(this) as Window;
@@ -84,9 +118,15 @@ public partial class TasksIslandView : UserControl
         return await tcs.Task;
     }
 
-    private async void OnTunnelPointerPressed(object? sender, PointerPressedEventArgs e)
+    // ── Custom ghost drag ────────────────────────────────────────────────────
+    // Replaces both the OLE DoDragDropAsync reorder and the OLE drop-to-queue path: a hand-built
+    // drag (pointer capture + a transparent topmost ghost window) is the only way to get a
+    // translucent follower that crosses from this window into the separate Mission Control window.
+
+    private void OnTunnelPointerPressed(object? sender, PointerPressedEventArgs e)
     {
-        if (DataContext is not TasksIslandViewModel vm) return;
+        ResetPressState();
+        if (DataContext is not TasksIslandViewModel) return;
         if (e.Source is not Visual src) return;
 
         var button = src as Button ?? src.FindAncestorOfType<Button>();
@@ -94,8 +134,7 @@ public partial class TasksIslandView : UserControl
         if (!e.GetCurrentPoint(button).Properties.IsLeftButtonPressed) return;
 
         // Select now so the details pane updates whether the gesture becomes a click or a drag.
-        // (Button.Click doesn't fire once DoDragDropAsync captures the pointer.)
+        if (DataContext is TasksIslandViewModel vm) vm.SelectedTask = row;
-        vm.SelectedTask = row;
 
         // If the click landed on a nested Button (e.g. the done-toggle checkbox or star),
         // don't start a drag — that would capture the pointer and swallow the inner Click.
@@ -103,79 +142,171 @@ public partial class TasksIslandView : UserControl
             && parentVisual.FindAncestorOfType<Button>() is not null;
         if (nestedInsideButton) return;
 
-        if (!vm.CanReorder || row.IsRunning) return;
+        // Running tasks can be neither reordered nor re-queued.
+        if (row.IsRunning) return;
 
-        var data = new DataTransfer();
+        // Arm the drag for ANY list kind so drag-to-queue works everywhere; reorder-on-drop is
-        data.Add(DataTransferItem.Create(TaskRowFormat, row.Id));
+        // still gated on CanReorder (user lists only).
-        try
+        _pressPoint = e.GetPosition(this);
+        _pressRow = row;
+        _pressControl = button;
+        _dragArmed = true;
+    }
+
+    private void OnPointerMovedDrag(object? sender, PointerEventArgs e)
+    {
+        if (!_dragArmed && !_dragging) return;
+        if (TopLevel.GetTopLevel(this) is not { } topLevel) return;
+
+        if (_dragArmed && !_dragging)
         {
-            await DragDrop.DoDragDropAsync(e, data, DragDropEffects.Move);
+            var p = e.GetPosition(this);
+            if (Math.Abs(p.X - _pressPoint.X) < DragThreshold && Math.Abs(p.Y - _pressPoint.Y) < DragThreshold)
+                return;
+            BeginDrag(e, topLevel);
         }
-        finally
+
+        if (_dragging)
         {
-            vm.ClearDropHints();
+            _drag.MoveTo(this.PointToScreen(e.GetPosition(this)));
+            UpdateReorderHint(e, topLevel);
         }
     }
 
-    private void OnRowPointerPressed(object? sender, PointerPressedEventArgs e) { }
+    private void BeginDrag(PointerEventArgs e, TopLevel topLevel)
-    private void OnRowPointerMoved(object? sender, PointerEventArgs e) { }
-    private void OnRowPointerReleased(object? sender, PointerReleasedEventArgs e) { }
-
-    private void OnRowDragOver(object? sender, DragEventArgs e)
     {
-        if (DataContext is not TasksIslandViewModel vm) { e.DragEffects = DragDropEffects.None; return; }
+        if (_pressControl is null || _pressRow is null) return;
-        if (!e.DataTransfer?.Contains(TaskRowFormat) ?? true)
+        // Snapshot the row BEFORE applying the "grabbed" style so the ghost stays crisp.
+        _drag.Begin(_pressControl, e.GetPosition(_pressControl), topLevel.RenderScaling);
+        _pressRow.IsDragging = true;
+        _dragging = true;
+        e.Pointer.Capture(this);
+    }
+
+    private async void OnPointerReleasedDrag(object? sender, PointerReleasedEventArgs e)
+    {
+        if (!_dragArmed && !_dragging) return;
+
+        var wasDragging = _dragging;
+        var row = _pressRow;
+        var topLevel = TopLevel.GetTopLevel(this);
+        var screen = wasDragging && topLevel is not null
+            ? this.PointToScreen(e.GetPosition(this))
+            : default;
+
+        EndDrag(e);
+
+        if (!wasDragging || row is null || topLevel is null) return;
+
+        // 1) Released over the Mission Control window → queue the task.
+        if (MissionControlUnder(screen) is { } mc)
         {
-            e.DragEffects = DragDropEffects.None;
+            await mc.EnqueueTaskAsync(row.Id);
-            vm.ClearDropHints();
             return;
         }
-        if (sender is not Button b || b.DataContext is not TaskRowViewModel target || target.IsRunning)
+
+        // 2) Released over another row in the same user list → reorder.
+        if (DataContext is TasksIslandViewModel vm && vm.CanReorder)
+        {
+            var targetButton = RowButtonAt(e, topLevel);
+            if (targetButton?.DataContext is TaskRowViewModel target
+                && !ReferenceEquals(target, row) && !target.IsRunning)
+            {
+                var placeBelow = e.GetPosition(targetButton).Y > targetButton.Bounds.Height / 2;
+                await vm.ReorderAsync(row, target, placeBelow);
+                return;
+            }
+        }
+
+        // 3) Anywhere else → cancel; EndDrag already restored the source row.
+    }
+
+    private void OnPointerCaptureLost(object? sender, PointerCaptureLostEventArgs e)
+    {
+        // We just took capture ourselves (stealing it from the row Button when the drag began) —
+        // that is not a real loss, so don't tear the drag down.
+        if (ReferenceEquals(e.Pointer.Captured, this)) return;
+        if (!_dragArmed && !_dragging) return;
+        if (_pressRow is not null) _pressRow.IsDragging = false;
+        if (DataContext is TasksIslandViewModel vm) vm.ClearDropHints();
+        _drag.End();
+        ResetPressState();
+    }
+
+    private void EndDrag(PointerEventArgs e)
+    {
+        if (_pressRow is not null) _pressRow.IsDragging = false;
+        if (DataContext is TasksIslandViewModel vm) vm.ClearDropHints();
+        _drag.End();
+        if (_dragging) e.Pointer.Capture(null);
+        ResetPressState();
+    }
+
+    private void ResetPressState()
+    {
+        _dragArmed = false;
+        _dragging = false;
+        _pressRow = null;
+        _pressControl = null;
+    }
+
+    // Live drop-hint while dragging over rows in the source (user) list.
+    private void UpdateReorderHint(PointerEventArgs e, TopLevel topLevel)
+    {
+        if (DataContext is not TasksIslandViewModel vm) return;
+        if (!vm.CanReorder) { vm.ClearDropHints(); return; }
+
+        var targetButton = RowButtonAt(e, topLevel);
+        if (targetButton?.DataContext is not TaskRowViewModel target
+            || target.IsRunning || ReferenceEquals(target, _pressRow))
         {
-            e.DragEffects = DragDropEffects.None;
             vm.ClearDropHints();
             return;
         }
 
-        var sourceId = e.DataTransfer?.TryGetValue(TaskRowFormat);
+        var placeBelow = e.GetPosition(targetButton).Y > targetButton.Bounds.Height / 2;
-        if (string.IsNullOrEmpty(sourceId) || sourceId == target.Id)
-        {
-            e.DragEffects = DragDropEffects.None;
-            vm.ClearDropHints();
-            return;
-        }
 
-        var placeBelow = e.GetPosition(b).Y > b.Bounds.Height / 2;
+        // Canonicalize: "drop below X" == "drop above X+1". Render the indicator above X+1 when
-
+        // there is one; only the last row in a section shows a below-line.
-        // Canonicalize: "drop below X" == "drop above X+1". Render the indicator
-        // above X+1 when there is one; only the last row in a section shows a below-line.
         TaskRowViewModel hintRow = target;
         bool hintBelow = false;
         if (placeBelow)
         {
             var next = FindNextInSameSection(vm, target);
-            if (next is not null && !next.IsRunning)
+            if (next is not null && !next.IsRunning) { hintRow = next; hintBelow = false; }
-            {
+            else { hintRow = target; hintBelow = true; }
-                hintRow = next;
-                hintBelow = false;
-            }
-            else
-            {
-                hintRow = target;
-                hintBelow = true;
-            }
         }
 
         // A hint that lands right where the dragged row already sits is a no-op.
-        if (hintRow.Id == sourceId)
+        if (_pressRow is not null && hintRow.Id == _pressRow.Id) { vm.ClearDropHints(); return; }
-        {
-            e.DragEffects = DragDropEffects.None;
-            vm.ClearDropHints();
-            return;
-        }
 
         vm.SetDropHint(hintRow, hintBelow);
-        e.DragEffects = DragDropEffects.Move;
+    }
+
+    // The row-level Button under the cursor, found by geometric hit-test on the source window
+    // (works while the pointer is captured to this control).
+    private static Button? RowButtonAt(PointerEventArgs e, TopLevel topLevel)
+    {
+        var pt = e.GetPosition((Visual)topLevel);
+        if (topLevel.InputHitTest(pt) is not Visual hit) return null;
+        var button = hit as Button ?? hit.FindAncestorOfType<Button>();
+        while (button is not null && button.DataContext is not TaskRowViewModel)
+            button = (button.Parent as Visual)?.FindAncestorOfType<Button>();
+        return button?.DataContext is TaskRowViewModel ? button : null;
+    }
+
+    // The Mission Control view model whose window contains the release point, if any.
+    private static MissionControlViewModel? MissionControlUnder(PixelPoint screen)
+    {
+        if (Application.Current?.ApplicationLifetime is not IClassicDesktopStyleApplicationLifetime desktop)
+            return null;
+        foreach (var w in desktop.Windows)
+        {
+            if (w is not MissionControlWindow mc || !mc.IsVisible) continue;
+            if (DragHitTest.WindowContains(mc.Position, mc.ClientSize, mc.RenderScaling, screen))
+                return mc.DataContext as MissionControlViewModel;
+        }
+        return null;
     }
 
     private static TaskRowViewModel? FindNextInSameSection(TasksIslandViewModel vm, TaskRowViewModel row)
@@ -187,41 +318,4 @@ public partial class TasksIslandView : UserControl
         }
         return null;
     }
-
-    private async void OnRowDrop(object? sender, DragEventArgs e)
-    {
-        if (DataContext is not TasksIslandViewModel vm) return;
-        try
-        {
-            if (sender is not Button b || b.DataContext is not TaskRowViewModel target) return;
-            if (target.IsRunning) return;
-
-            var sourceId = e.DataTransfer?.TryGetValue(TaskRowFormat);
-            if (string.IsNullOrEmpty(sourceId) || sourceId == target.Id) return;
-
-            var source = FindRowById(vm, sourceId);
-            if (source is null || source.IsRunning) return;
-
-            var placeBelow = e.GetPosition(b).Y > b.Bounds.Height / 2;
-
-            // Clear the 6px drop-hint spacer BEFORE the move so the reorder animates
-            // into its truly-final layout in one step (otherwise the row lands in the
-            // gap, then the gap collapses and everything shifts up a second time).
-            vm.ClearDropHints();
-
-            await vm.ReorderAsync(source, target, placeBelow);
-        }
-        catch
-        {
-            vm.ClearDropHints();
-            throw;
-        }
-    }
-
-    private static TaskRowViewModel? FindRowById(TasksIslandViewModel vm, string id)
-    {
-        foreach (var r in vm.Items)
-            if (r.Id == id) return r;
-        return null;
-    }
 }

src/ClaudeDo.Ui/Views/MainWindow.axaml

@@ -88,6 +88,11 @@
         <!-- Right: window controls -->
         <StackPanel Grid.Column="2" Orientation="Horizontal" Spacing="0"
                     VerticalAlignment="Center" Margin="0,0,4,0">
+          <Button Classes="title-ctrl"
+                  Command="{Binding OpenMissionControlCommand}"
+                  ToolTip.Tip="{loc:Tr missionControl.windowTitle}">
+            <PathIcon Data="{StaticResource Icon.Grid}" Width="12" Height="12"/>
+          </Button>
           <Button Classes="title-ctrl" Click="OnMinimize">
             <PathIcon Data="{StaticResource Icon.WinMin}" Width="10" Height="10"/>
           </Button>
@@ -215,15 +220,28 @@
           </StackPanel>
         </Button>
 
-        <!-- Right: worker log line -->
+        <!-- Right: worker log line — click to open the Log Visualizer overlay -->
-        <TextBlock DockPanel.Dock="Right"
+        <Button DockPanel.Dock="Right"
-                   Classes="meta"
+                Command="{Binding OpenLogVisualizerCommand}"
-                   Text="{Binding WorkerLogText}"
+                Background="Transparent" BorderThickness="0" Padding="6,0"
-                   IsVisible="{Binding IsWorkerLogVisible}"
+                Cursor="Hand" VerticalAlignment="Center"
-                   Foreground="{Binding WorkerLogLevel, Converter={StaticResource WorkerLogLevelToBrush}}"
+                ToolTip.Tip="{loc:Tr modals.logVisualizer.openTooltip}">
-                   LetterSpacing="1.4"
+          <Panel>
-                   TextTrimming="CharacterEllipsis"
+            <TextBlock Classes="meta"
-                   VerticalAlignment="Center"/>
+                       Text="{loc:Tr modals.logVisualizer.footerHint}"
+                       IsVisible="{Binding !IsWorkerLogVisible}"
+                       Foreground="{DynamicResource TextMuteBrush}"
+                       LetterSpacing="1.4"
+                       VerticalAlignment="Center"/>
+            <TextBlock Classes="meta"
+                       Text="{Binding WorkerLogText}"
+                       IsVisible="{Binding IsWorkerLogVisible}"
+                       Foreground="{Binding WorkerLogLevel, Converter={StaticResource WorkerLogLevelToBrush}}"
+                       LetterSpacing="1.4"
+                       TextTrimming="CharacterEllipsis"
+                       VerticalAlignment="Center"/>
+          </Panel>
+        </Button>
 
         <!-- Right: prime status notification -->
         <TextBlock DockPanel.Dock="Right"

src/ClaudeDo.Ui/Views/MainWindow.axaml.cs

@@ -8,7 +8,6 @@ using ClaudeDo.Ui.ViewModels;
 using ClaudeDo.Ui.ViewModels.Islands;
 using ClaudeDo.Ui.ViewModels.Modals;
 using ClaudeDo.Ui.Views.Modals;
-using ClaudeDo.Ui.Views.Planning;
 
 namespace ClaudeDo.Ui.Views;
 
@@ -42,64 +41,12 @@ public partial class MainWindow : Window
     {
         if (DataContext is IslandsShellViewModel vm)
         {
-            vm.ShowAboutModal = async (aboutVm) =>
+            vm.Dialogs = new WindowDialogService(this);
+            vm.BringToFront = () =>
             {
-                var dlg = new AboutModalView { DataContext = aboutVm };
+                if (WindowState == WindowState.Minimized)
-                var tcs = new TaskCompletionSource<bool>();
+                    WindowState = WindowState.Normal;
-                aboutVm.CloseAction = () => { dlg.Close(); tcs.TrySetResult(true); };
+                Activate();
-                await dlg.ShowDialog(this);
-            };
-            vm.ShowWeeklyReportModal = async (modal) =>
-            {
-                var dlg = new WeeklyReportModalView { DataContext = modal };
-                modal.CloseAction = () => dlg.Close();
-                await dlg.ShowDialog(this);
-            };
-            vm.ShowWorktreesOverviewModal = async (modal) =>
-            {
-                var dlg = new WorktreesOverviewModalView { DataContext = modal };
-                modal.CloseAction = () => dlg.Close();
-                modal.JumpToTaskAction = (listId, taskId) =>
-                {
-                    if (DataContext is IslandsShellViewModel s)
-                        _ = JumpToTaskAsync(s, listId, taskId);
-                };
-                modal.ShowDiffAction = diffVm =>
-                {
-                    var diffDlg = new WorktreeModalView { DataContext = diffVm };
-                    diffVm.CloseAction = () => diffDlg.Close();
-                    _ = diffVm.LoadAsync();
-                    _ = diffDlg.ShowDialog(this);
-                };
-                modal.ConfirmAction = ShowConfirmAsync;
-                modal.ResolveMergeVm = vm.ResolveMergeVm;
-                modal.ShowMergeAction = async mergeVm =>
-                {
-                    var mergeDlg = new MergeModalView { DataContext = mergeVm };
-                    await mergeDlg.ShowDialog(this);
-                };
-                modal.RequestConflictResolution = (taskId, target) =>
-                    DataContext is IslandsShellViewModel s
-                        ? s.RequestConflictResolutionAsync(taskId, target)
-                        : System.Threading.Tasks.Task.CompletedTask;
-                await dlg.ShowDialog(this);
-            };
-            vm.ShowRepoImportModal = async (modal) =>
-            {
-                var dlg = new RepoImportModalView { DataContext = modal };
-                modal.CloseAction = () => dlg.Close();
-                await dlg.ShowDialog(this);
-            };
-            vm.ShowWorkerConnectionModal = async (connVm) =>
-            {
-                var dlg = new WorkerConnectionModalView { DataContext = connVm };
-                connVm.CloseAction = () => dlg.Close();
-                await dlg.ShowDialog(this);
-            };
-            vm.ShowConflictResolver = async (resolverVm) =>
-            {
-                var dlg = new ClaudeDo.Ui.Views.Conflicts.ConflictResolverView { DataContext = resolverVm };
-                await dlg.ShowDialog(this);
             };
         }
     }
@@ -132,47 +79,4 @@ public partial class MainWindow : Window
         if (DataContext is IslandsShellViewModel vm) vm.WindowWidth = Bounds.Width;
     }
 
-    private static System.Threading.Tasks.Task JumpToTaskAsync(IslandsShellViewModel s, string listId, string taskId)
-        => JumpToTaskHelper.SelectAsync(s, listId, taskId);
-
-    private async System.Threading.Tasks.Task<bool> ShowConfirmAsync(string message)
-    {
-        var tcs = new TaskCompletionSource<bool>();
-        var cancel = new Button { Content = "Cancel", MinWidth = 90 };
-        var confirm = new Button { Content = "Confirm", MinWidth = 90, Classes = { "danger" } };
-
-        var dialog = new Window
-        {
-            Title = "Confirm",
-            Width = 380,
-            SizeToContent = SizeToContent.Height,
-            CanResize = false,
-            WindowStartupLocation = WindowStartupLocation.CenterOwner,
-            ShowInTaskbar = false,
-            Background = this.FindResource("SurfaceBrush") as IBrush,
-            Content = new StackPanel
-            {
-                Margin = new Thickness(20),
-                Spacing = 16,
-                Children =
-                {
-                    new TextBlock { Text = message, TextWrapping = TextWrapping.Wrap },
-                    new StackPanel
-                    {
-                        Orientation = Orientation.Horizontal,
-                        HorizontalAlignment = HorizontalAlignment.Right,
-                        Spacing = 8,
-                        Children = { cancel, confirm },
-                    },
-                },
-            },
-        };
-
-        cancel.Click += (_, _) => { tcs.TrySetResult(false); dialog.Close(); };
-        confirm.Click += (_, _) => { tcs.TrySetResult(true); dialog.Close(); };
-        dialog.Closed += (_, _) => tcs.TrySetResult(false);
-
-        _ = dialog.ShowDialog(this);
-        return await tcs.Task;
-    }
 }

src/ClaudeDo.Ui/Views/MissionControl/MissionControlView.axaml

@@ -0,0 +1,97 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:vm="using:ClaudeDo.Ui.ViewModels"
+             xmlns:vmi="using:ClaudeDo.Ui.ViewModels.Islands"
+             xmlns:mc="using:ClaudeDo.Ui.Views.MissionControl"
+             xmlns:loc="using:ClaudeDo.Ui.Localization"
+             x:DataType="vm:MissionControlViewModel"
+             x:Class="ClaudeDo.Ui.Views.MissionControl.MissionControlView">
+  <DockPanel LastChildFill="True" Background="{DynamicResource VoidBrush}"
+             DragDrop.AllowDrop="True">
+
+    <!-- Header -->
+    <Border DockPanel.Dock="Top"
+            Background="{DynamicResource DeepBrush}"
+            BorderBrush="{DynamicResource LineBrush}"
+            BorderThickness="0,0,0,1" Padding="14,8">
+      <Grid ColumnDefinitions="*,Auto">
+        <TextBlock Grid.Column="0" Classes="eyebrow"
+                   Text="{loc:Tr missionControl.windowTitle}"
+                   Foreground="{DynamicResource TextBrush}"
+                   LetterSpacing="1.4" VerticalAlignment="Center" />
+        <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="8"
+                    VerticalAlignment="Center">
+          <Button Classes="icon-btn"
+                  Command="{Binding OpenSettingsCommand}"
+                  ToolTip.Tip="{loc:Tr missionControl.settings}">
+            <PathIcon Data="{StaticResource Icon.Settings}" Width="15" Height="15"
+                      Foreground="{DynamicResource TextMuteBrush}"/>
+          </Button>
+          <Button Classes="btn"
+                  Content="{loc:Tr missionControl.clearFinished}"
+                  Command="{Binding ClearFinishedCommand}" />
+        </StackPanel>
+      </Grid>
+    </Border>
+
+    <!-- Read-only queue strip — collapses when nothing is queued -->
+    <Border DockPanel.Dock="Right"
+            IsVisible="{Binding HasQueued}"
+            Width="210"
+            Background="{DynamicResource DeepBrush}"
+            BorderBrush="{DynamicResource LineBrush}"
+            BorderThickness="1,0,0,0">
+      <DockPanel LastChildFill="True" Margin="10,10">
+        <TextBlock DockPanel.Dock="Top" Classes="eyebrow"
+                   Text="{loc:Tr missionControl.queue}"
+                   Foreground="{DynamicResource TextMuteBrush}"
+                   LetterSpacing="1.4" Margin="0,0,0,8" />
+        <ScrollViewer>
+          <ItemsControl ItemsSource="{Binding Queued}">
+            <ItemsControl.ItemTemplate>
+              <DataTemplate x:DataType="vm:QueuedTaskViewModel">
+                <Border Margin="0,0,0,4" Padding="8,6"
+                        Background="{DynamicResource SurfaceBrush}"
+                        BorderBrush="{DynamicResource LineBrush}"
+                        BorderThickness="1" CornerRadius="6">
+                  <StackPanel Spacing="2">
+                    <TextBlock Text="{Binding Title}"
+                               TextTrimming="CharacterEllipsis"
+                               ToolTip.Tip="{Binding Title}"
+                               Foreground="{DynamicResource TextDimBrush}" />
+                    <TextBlock Classes="meta"
+                               Text="{loc:Tr missionControl.blocked}"
+                               IsVisible="{Binding IsBlocked}"
+                               Foreground="{DynamicResource AmberBrush}" />
+                  </StackPanel>
+                </Border>
+              </DataTemplate>
+            </ItemsControl.ItemTemplate>
+          </ItemsControl>
+        </ScrollViewer>
+      </DockPanel>
+    </Border>
+
+    <!-- Grid / empty state -->
+    <Panel Margin="6">
+      <ItemsControl ItemsSource="{Binding Monitors}" IsVisible="{Binding HasMonitors}">
+        <ItemsControl.ItemsPanel>
+          <ItemsPanelTemplate>
+            <UniformGrid x:CompileBindings="False" Columns="{Binding ColumnCount}" />
+          </ItemsPanelTemplate>
+        </ItemsControl.ItemsPanel>
+        <ItemsControl.ItemTemplate>
+          <DataTemplate x:DataType="vmi:TaskMonitorViewModel">
+            <mc:MonitorPaneView Margin="6" />
+          </DataTemplate>
+        </ItemsControl.ItemTemplate>
+      </ItemsControl>
+
+      <TextBlock IsVisible="{Binding !HasMonitors}"
+                 Text="{loc:Tr missionControl.empty}"
+                 Foreground="{DynamicResource TextMuteBrush}"
+                 HorizontalAlignment="Center" VerticalAlignment="Center" />
+    </Panel>
+
+  </DockPanel>
+</UserControl>

src/ClaudeDo.Ui/Views/MissionControl/MissionControlView.axaml.cs

@@ -0,0 +1,50 @@
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.VisualTree;
+using ClaudeDo.Ui.ViewModels;
+using ClaudeDo.Ui.ViewModels.Islands;
+
+namespace ClaudeDo.Ui.Views.MissionControl;
+
+public partial class MissionControlView : UserControl
+{
+    // Shared with MonitorPaneView (the drag source).
+    public static readonly DataFormat<string> PaneFormat =
+        DataFormat.CreateStringApplicationFormat("claudedo-monitor-pane");
+
+    public MissionControlView()
+    {
+        InitializeComponent();
+        AddHandler(DragDrop.DragOverEvent, OnPaneDragOver);
+        AddHandler(DragDrop.DropEvent, OnPaneDrop);
+    }
+
+    private void OnPaneDragOver(object? sender, DragEventArgs e)
+    {
+        var dt = e.DataTransfer;
+        e.DragEffects = (dt?.Contains(PaneFormat) ?? false) ? DragDropEffects.Move : DragDropEffects.None;
+    }
+
+    private void OnPaneDrop(object? sender, DragEventArgs e)
+    {
+        if (DataContext is not MissionControlViewModel vm) return;
+        var dt = e.DataTransfer;
+        if (dt is null) return;
+
+        // A pane dragged within the grid → reorder. (Drag-to-queue from the main app now arrives
+        // via the custom ghost drag's screen hit-test, not an OLE drop.)
+        var draggedId = dt.TryGetValue(PaneFormat);
+        if (string.IsNullOrEmpty(draggedId)) return;
+        if (e.Source is not Avalonia.Visual src) return;
+
+        var targetPane = src.FindAncestorOfType<MonitorPaneView>();
+        if (targetPane?.DataContext is not TaskMonitorViewModel target) return;
+
+        var dragged = vm.Monitors.FirstOrDefault(m => m.SubscribedTaskId == draggedId);
+        if (dragged is null) return;
+
+        vm.MoveMonitor(dragged, target);
+    }
+}

src/ClaudeDo.Ui/Views/MissionControl/MissionControlWindow.axaml

@@ -0,0 +1,13 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:vm="using:ClaudeDo.Ui.ViewModels"
+        xmlns:mc="using:ClaudeDo.Ui.Views.MissionControl"
+        xmlns:loc="using:ClaudeDo.Ui.Localization"
+        x:Class="ClaudeDo.Ui.Views.MissionControl.MissionControlWindow"
+        x:DataType="vm:MissionControlViewModel"
+        Title="{loc:Tr missionControl.windowTitle}"
+        Width="1100" Height="760" MinWidth="640" MinHeight="420"
+        Background="{DynamicResource VoidBrush}"
+        Icon="avares://ClaudeDo.Ui/Assets/ClaudeTask.ico">
+  <mc:MissionControlView />
+</Window>

src/ClaudeDo.Ui/Views/MissionControl/MissionControlWindow.axaml.cs

@@ -0,0 +1,17 @@
+using Avalonia.Controls;
+
+namespace ClaudeDo.Ui.Views.MissionControl;
+
+public partial class MissionControlWindow : Window
+{
+    public MissionControlWindow() => InitializeComponent();
+
+    protected override void OnClosing(WindowClosingEventArgs e)
+    {
+        // Hide instead of destroying — Mission Control keeps tracking tasks in the
+        // background and re-shows on next open.
+        e.Cancel = true;
+        Hide();
+        base.OnClosing(e);
+    }
+}