docs(changelog): update for v2.16.0

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

CHANGELOG.md

@@ -1,5 +1,217 @@
 # Changelog
 
+## v2.16.0 — 2026-09-16
+
+### Features
+
+- Bilder aus der Zwischenablage ins interaktive Terminal einfuegen (81d835c0)
+- preview_merge_set flags removed symbols and locale-key overlaps (fb7dddb3)
+- poll the OAuth usage endpoint as fast as its measured rate limit allows (6b6d9895)
+- dirty Ziel-Verzeichnis beim Oeffnen des Merge-Dialogs melden statt nach dem Fehlschlag (0805540a)
+
+### Fixes
+
+- depends_on-Nachfolger schon beim gelandeten Merge freigeben (21591a5d)
+- preview_merge braucht einen runVerify-Parameter wie preview_merge_set (d725e3f1)
+- Shutdown beendet die App auch mit offenen Nebenfenstern (d7898240)
+- Worker-Neustart trifft nun den tatsaechlich laufenden Prozess (c486b85b)
+- Ordner-Toggle in der Sidebar schluckt schnelle Klicks (0cd31411)
+- Diff-Viewer scrollt jetzt auch horizontal synchron (f4af0b98)
+- Worktrees-Uebersicht zeigt Task-Nummern, DIFF-Spalte trimmt statt abzuschneiden (62349c4f)
+- duplizierter Confirm-Dialog mit "Delete"-Knopf zusammengefuehrt und lokalisiert (a0ad4d0f)
+
+## v2.15.0 — 2026-09-11
+
+### Features
+
+- Stash-Option fuer uncommittete Aenderungen im Ziel-Tree (251b70ce)
+
+### Documentation
+
+- update for v2.14.0 (8e2d37e6)
+
+## v2.14.0 — 2026-09-10
+
+### Features
+
+- Listen und Ordner in einer gemischten Sidebar-Reihenfolge (bfb1c652)
+- confirm before closing a running ConPTY session (eb623714)
+- worker-menu Shutdown ends worker + app after confirm (1bdf2027)
+- chain a normal parent's children on WaitingForChildren (d2648f96)
+- localize WorkConsole, DescriptionStepsCard and the ROADBLOCK label (8e6f0d16)
+- surface depends_on blocking in status chip, chain label, and detail pane (4cf601e4)
+- Worker-Menü "Update Claude CLI" führt claude update aus (dbee4a0d)
+- triage model picker (opus/fable) in the merge helper start modal (1177463a)
+- collapsible folders for the list sidebar (25c9a619)
+- list_folders table plus lists.folder_id (13e860f0)
+
+### Fixes
+
+- Import broadcastet TaskUpdated fuer neue Tasks (1770b677)
+- ConnectedClientTracker in den externen MCP-Container teilen (3d09323e)
+- de.json-Konsistenz-Pass und restliche harte EN-Strings (d6696c33)
+- force English git output for locale-fragile stderr matches (5ecf6f75)
+- make diff-stat parsing locale-safe and dedupe the two parsers (29ea18c4)
+- report failed paste/drop in the interactive terminal (0cec0a77)
+- surface worker connect/restart failures instead of no-opting (b4b62254)
+- validate PowerUse window, explain effort and Prime Claude in Settings (951c2fe9)
+- start_list_handler ehrlich machen, wenn keine App verbunden ist (451c0184)
+- warn and block save when a list's working dir isn't a git repo (3348736e)
+- show a banner when a ConPTY session dies after startup (256bea5f)
+- merge duplicate top-level "checks" block in en/de.json (741f66fe)
+- translate max_turns failure text to English (0fcfe7c5)
+- route WeekReportService permission-mode through PermissionModeResolver (1c768529)
+- report startup port conflicts instead of crashing silently (c9d4823f)
+
+### Documentation
+
+- record list folders in the Data and Ui CLAUDE.md (5477ae53)
+- update for v2.13.6 (ec1e60be)
+
+## v2.13.6 — 2026-09-07
+
+### Features
+
+- Home-Ordner als Sitzungsziel in Mission Control (f231f08a)
+- Einfuegen und Datei-Drop im interaktiven Terminal (23491d3b)
+- Cheat-Sheet-Fenster im Hilfe-Menue (0db9fade)
+- PowerUse-Einstellungen nach Settings -> Ausfuehrung verschieben (7c7c33d6)
+
+### Documentation
+
+- update for v2.13.5 (c7392e08)
+
+## v2.13.5 — 2026-09-03
+
+### Fixes
+
+- Version im About-Dialog aus der FileVersion lesen (cccfe2ec)
+
+### Refactoring
+
+- "Nach Updates suchen" ins Hilfe-Menue verschieben (c16c7b97)
+
+### Documentation
+
+- update for v2.13.4 (a8ec5507)
+
+## v2.13.4 — 2026-09-03
+
+### Fixes
+
+- interaktive Session ohne Arbeitsverzeichnis im User-Verzeichnis starten (f70503d0)
+
+### Documentation
+
+- update for v2.13.3 (9360cd2f)
+
+## v2.13.3 — 2026-09-03
+
+### Fixes
+
+- raise SignalR MaximumParallelInvocationsPerClient (e64d5705)
+
+### Documentation
+
+- update for v2.13.2 (fc25ee45)
+
+## v2.13.2 — 2026-09-03
+
+### Features
+
+- Handler-Run per Knopf abbrechen (bd5aa265)
+
+### Fixes
+
+- strip CLAUDE_CODE_CHILD_SESSION/CLAUDECODE before every ConPTY launch (51ee5050)
+- Dequeue-X auf blockierten Queue-Zeilen anzeigen und Kette konsistent halten (df3e7ba0)
+- report and gate ListSettingsModal load failures instead of swallowing them (a1b20d9f)
+- move ScrollViewer padding to inner content in modal bodies (e0c6b670)
+- Mission Control oeffnen, wenn ein Handler-Run per MCP startet oder ein Handoff eintrifft (b05b6fba)
+
+### Performance
+
+- show list settings modal before its seven-round-trip load finishes (f24654df)
+
+### Documentation
+
+- remove stale session-skills empty-state entry (2bd48ea1)
+- update for v2.13.1 (eb3aee41)
+- update for v2.13.0 (2b873322)
+
+## v2.13.1 — 2026-09-02
+
+### Fixes
+
+- Mission Control oeffnen, wenn ein Handler-Run per MCP startet oder ein Handoff eintrifft (9f64ba50)
+
+## v2.13.0 — 2026-09-02
+
+### Features
+
+- Handler-Session vor dem Usage-Limit warnen und Handoff bis zum Reset zurueckhalten (fe818651)
+- start_list_handler MCP-Tool startet einen List-Handler-Run wie der Button (c2166a0d)
+- Handler-Session nach Usage-Limit-Reset automatisch neu starten (016b9203)
+- PowerUse-Zeitfenster + Handoff-Schwellwert als Settings (69898be5)
+- PowerUse-Toggle im Usage-Monitor, Opt-in pro Liste (19375254)
+- PowerUse-Addendum an die Handler-Prompts, Cap aus den Settings (453d61ca)
+- PowerUse-Flags und konfigurierbares Handoff-Budget (3cf9628f)
+- depends_on als Menge statt Einzelfeld (c25732cf)
+- surface the handoff round budget in the merge-helper handoff brief (81a5fc5d)
+- add ExpectsNoDiff flag for verification/audit tasks (0b506f52)
+- add dependency audit and diff-review threshold to list-handler prompts (9e805646)
+- add "move to list" to the task row context menu (80fe188a)
+- notes get their own list, a day log and an Enter chain (0f04b796)
+- add_note MCP tool with a per-day agent cap (ae0c7d37)
+
+### Fixes
+
+- carry ExpectsNoDiff into the relocated merge MCP tools (4ee1d05f)
+- stop Ui.Tests order-dependent flakiness on shared Loc.Current (dc1e67d0)
+- add failureReason field to batch_get_tasks (91220177)
+- make locale-parity test able to detect a malformed locale file (4c78a5d6)
+- don't leave an orphaned list behind on cancel (56bc1651)
+- stop treating git worktrees and submodules as repos (b6e5876b)
+- fix Bandel ticket sync and reactivate the integration (30d0611b)
+- Shift+Enter in the capture box, not just in the note rows (f6405804)
+- let Shift+Enter break the line, and clear the leftovers around the editor (b90c5855)
+- auto-bootstrap commit-less repos before creating worktrees (e0748ba3)
+- bootstrap commit-less repos and survive missing git identity (de44196b)
+
+### Performance
+
+- switch to workstation GC to cut idle memory (c347e4fc)
+
+### Refactoring
+
+- share StubWorkerClient between Ui.Tests and Worker.Tests (9f90e75a)
+- remove the stale-worker banner (6be62f02)
+
+### Documentation
+
+- Handler-Prompt praezisieren (Wave-Plan, Task-Split, review_task-Aufruf) (20b3b4ce)
+- Test-Scoping fuer Implementer-Tasks, PowerUse in den Explore-Notes (416997d7)
+- plan for multi-dependency depends_on relation table (84d955df)
+- empty-repo hardening notes + verification item (cf093e31)
+- spec + plan for empty-repo (unborn HEAD) hardening (fea8236e)
+- update for v2.12.0 (1d6cd49b)
+
+## v2.12.0 — 2026-08-28
+
+### Features
+
+- wählbares Listen-Icon und aufgeräumter Task-Detail-Header (c31f79d3)
+- Mission Control als Session-Hub (22e70ffc)
+
+### Fixes
+
+- make re-approve after revert_merge do a real merge, not a silent no-op (8d597df4)
+- survive a worker restart when cancelling a mid-merge unit-merge parent (1affb397)
+
+### Documentation
+
+- update for v2.11.0 (bbdb0223)
+
 ## v2.11.0 — 2026-08-27
 
 ### Features

CLAUDE.md

@@ -66,14 +66,38 @@ Commit freely (per task + the spec/plan docs). Never push without asking.
 
 ## Building & Testing
 
-`dotnet build ClaudeDo.slnx` requires .NET 9; on .NET 8 build individual projects with `-c Release` (a running Worker locks the `Debug` output).
+**Build the whole solution, test only what you touched.** Always `-c Release` — a running Worker locks the `Debug` output.
 
 ```bash
-dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release      # pulls in Ui + Data
-dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
-dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release   # also: Data.Tests, Ui.Tests, Localization.Tests, Installer.Tests, Releases.Tests
+dotnet build ClaudeDo.slnx -c Release                                    # ~40s, catches cross-project breaks
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --no-build \
+  --filter "FullyQualifiedName~Handoff"                                  # seconds, not minutes
 ```
 
+`.slnx` needs SDK 9+ (this machine is on 10). On an older SDK build the projects individually:
+`src/ClaudeDo.App` (pulls in Ui + Data) and `src/ClaudeDo.Worker`.
+
+### Do NOT run the full test suite to finish a task
+
+Measured 2026-09-02, sequentially after one build: **Worker.Tests 507s**, Ui.Tests 33s, Data.Tests 8s,
+Localization/Installer/Releases 3s each, build 42s — ~10 min for all six. Run in parallel across
+projects it is *worse*, not better (Worker.Tests 801s, Ui.Tests 82s): these tests create real git
+worktrees and spawn processes, so they thrash rather than share.
+
+With up to 5 implementer tasks running at once, a full suite per task costs hours — and **cannot find
+what it costs that for.** Each task works in its own worktree containing only its own change, so a
+collision between two parallel tasks is invisible to both. Collisions surface after the merge, which
+is exactly where `verify_merges` runs the list's verify command **once per batch**. The full suite is
+the merge gate's job, not the task's.
+
+So, per task:
+- **Build:** the whole solution, always. It's cheap and it catches the compile break your change
+  caused three projects over.
+- **Tests:** `--no-build --filter` scoped to what you touched. Add a filter for the classes covering
+  your change; if you genuinely can't scope it, run the one relevant test project, never all six.
+- **Report** what you ran and what you did not, so the merge session knows what is still unverified.
+- Never report "all tests pass" when you ran a filtered subset. Say which filter you used.
+
 ### Gotchas
 - **Subagents:** use the `sonnet` model; stage files explicitly by path — never `git add -A` (parallel sessions often leave unrelated WIP in the tree).
 - **Icons:** `PathIcon` *fills* its geometry — line-art icons must be filled geometry or a `Path Classes="icon-stroke"`, else they render invisible. Colour comes from the `ICON PAINTING` block in `IslandStyles.axaml` (class + state); setting `Foreground`/`Stroke` inline kills the hover state.

docs/explore-notes/conpty-sessions.md

@@ -115,6 +115,22 @@ share the same prompt/model as their non-final counterpart and differ only in on
 rendered into the handoff kickoff file (`PromptKind.MergeHelperHandoff`) marking the final round
 and forbidding further reruns.
 
+The chain length is bounded server-side by `HandoffRoundTracker`, whose cap comes from
+`AppSettingsEntity.ListHandlerMaxHandoffs` (default 4 = two merge rounds; `HandoffMcpTools` reads it
+per call and `Register` clamps to min 1, so 0 can never mean "unbounded"). Past the cap a
+`wait`/`merge` request is silently coerced to its `_final` counterpart — check the result's
+`coerced` flag — and any handoff after a `merge_final` round throws.
+
+**PowerUse.** When `AppSettingsEntity.PowerUseEnabled` (Settings → Execution) **and** the
+list's own `ListConfigEntity.PowerUseAllowed` are both set, `InteractiveLaunchSpecService.
+ComposeHandlerPromptAsync` appends `PromptKind.PowerUseAddendum` to whichever handler prompt the
+phase resolved to. The addendum is written as an *override* of the base prompt's interactive rules
+(never ask, decide and record instead; resolve or abort conflicts rather than leaving them in the
+tree; harvest new tasks when a round would starve). Both keys are required on purpose: the global
+switch can stay on overnight without turning an unrelated list's handler run unattended. A run that
+is not in PowerUse gets a byte-identical prompt to the pre-PowerUse behaviour — there is deliberately
+no second set of handler prompts to keep in sync.
+
 Each handoff hands the SAME handler task id to a NEW tile, and `MissionControlViewModel.
 OpenMergeHelperHandoffConPtySessionAsync` closes the outgoing phase's pane (`CloseConPtySession`,
 which disposes its `PtyTerminalSession` and kills the underlying `claude` process) before opening
@@ -127,6 +143,43 @@ outgoing session is only ever told to end its turn, never to exit. This keeps th
 `MCP_TOOL_TIMEOUT` is 200 s here — `TaskWaitMcpTools` clamps its own timeout to 170 s to stay
 comfortably under it (see [external-mcp.md](external-mcp.md)).
 
+### Auto-restart after the usage limit
+
+A handler session that dies mid-phase used to be a silent dead tile: `InteractiveTerminalViewModel.
+OnSessionProcessExited` only raised a visible banner for a death **inside** its 5 s
+`StartupGraceWindow`. It now raises `ExitedAfterStartup` for a later non-zero exit; the pane
+forwards it as `SessionDiedAfterStartup(taskId, exitCode)` and `MissionControlViewModel` reports it
+via `WorkerHub.ReportInteractiveSessionExited`. Every task-based pane reports — the UI does no
+filtering, because the exit code is the *only* thing it knows.
+
+`HandlerRestartCoordinator` (Worker) decides the rest and **fails closed** — unlike the usage gate,
+every missing signal means "don't relaunch":
+
+- **Which round was running** comes from `HandlerRoundState`, a JSON file at
+  `~/.claudeDo/handler-rounds.json` (one `HandlerRound` per handler task id, deliberately not a DB
+  column). `BuildForMergeHelperAsync` writes the opening round as phase `"triage"`;
+  `BuildForMergeHelperHandoffAsync` writes each subsequent `MergeHelperPhase`. Without it the phase
+  and task set exist *only* in the transient `HandoffRequested` broadcast, so a dead tile could not
+  be reopened. A `"triage"` round is never reopened — there is no handoff spec for it.
+- **Was it really the usage limit?** A ConPTY session has no captured stdout, so `TaskRunner.
+  IsUsageLimitMessage` (which matches the CLI's own "session limit" text) has nothing to read. The
+  corroborating witness is `UsageState.Snapshot.FiveHour.Utilization ≥ 95`
+  (`HandlerRestartCoordinator.UsageLimitProofPct`) at the moment of death. A crash at 40 % is not
+  restarted; no snapshot at all is not restarted.
+- **PowerUse only** — both keys, exactly like the prompt addendum above.
+- **One restart per round**, claimed via `HandlerRoundState.TryClaimAutoRestart` before the wait, so
+  a restart that dies again stays dead. `HandlerRoundState.Save` carries `AutoRestartUsed` over when
+  the phase is unchanged, because the restart's own launch-spec build writes the round again — a
+  naive overwrite would hand out a fresh budget every time and loop all night.
+- The restart waits out `FiveHour.ResetsAt`, then re-broadcasts `HandoffRequested` with the
+  persisted phase + task set, which the UI already handles by reopening the tile. It goes **around**
+  `handoff_list_handler`, so `HandoffRoundTracker.Register` is never called and the run loses no
+  handoff budget.
+
+Sibling to `UsageLimitAutoContinueCoordinator`, not an extension of it: that one only ever sees
+headless runs (`FailureReason == "usage_limit"`, resumed through the override slot), and a ConPTY
+session has no `task_runs` row to classify.
+
 ### The host task and its commit range
 
 The handler run **owns a real ClaudeDo task**, created by `CreateMergeHelperTask` (hub) →

docs/explore-notes/external-mcp.md

@@ -98,6 +98,7 @@ Daily prep: `GetDailyPrepCandidates`, `SetMyDay`.
 | `TaskWaitMcpTools` | `WaitForTaskChange` |
 | `QueueStateMcpTools` | `GetQueueState` |
 | `AttachmentMcpTools` | `AddTaskAttachment`, `ListTaskAttachments`, `RemoveTaskAttachment` |
+| `ListHandlerMcpTools` | `StartListHandler` |
 
 ## Per-tool behaviour worth knowing
 
@@ -235,6 +236,13 @@ task already outside those two (unknown ids reported as status `"NotFound"`, als
 **`AttachmentMcpTools`** — re-attaching the same `fileName` overwrites. Add/remove refuse on a
 `Running` task.
 
+**`StartListHandler`** — the worker only broadcasts `ListHandlerStartRequested`; the connected
+ClaudeDo App does the actual work (creates the handler task, opens the triage ConPTY tile). Before
+broadcasting it checks `ConnectedClientTracker` (a `WorkerHub.OnConnectedAsync`/`OnDisconnectedAsync`-driven
+singleton count) — with zero connected clients the broadcast would reach nobody, so the tool
+returns `Requested: false` plus a `Reason` instead of claiming success. Does not queue or retry the
+request for a later connect.
+
 **`GetDailyPrepCandidates`** — Idle, non-blocked tasks in a git repo **not** excluded by
 `AppSettings.ReportExcludedPaths` and not already `IsMyDay`, plus the current Idle MyDay tasks
 and `maxTasks` (= `DailyPrepMaxTasks`). Repo-exclusion logic lives in the `DailyPrepFilter`

docs/explore-notes/review-merge.md

@@ -184,9 +184,9 @@ detached-HEAD scratch worktree under the OS temp dir (`GitService.WorktreeAddDet
 is always removed afterward (`finally`, non-cancellable cleanup). No verify command configured, or
 `runVerify=false`, reproduces the pre-existing preview exactly — no delay, no scratch worktree.
 
-Wired into `ExternalMcpService`: `preview_merge` (single task) always requests a verify run when the
-list has a command configured; `preview_merge_set` only does when its `runVerify` parameter is
-explicitly set (default `false`) — a set preview never starts N builds unasked. The Hub's
+Wired into `ExternalMcpService`: both `preview_merge` (single task) and `preview_merge_set` only
+request a verify run when their `runVerify` parameter is explicitly set (default `false`) — a
+preview never starts a build unasked. The Hub's
 `PreviewMerge` (the UI's live mergeability indicator) always passes `runVerify: false`, since
 running a build on every poll would be a bad regression; `MergePreviewDto` carries the
 verify fields anyway so a future UI entry point can opt in. Result fields: `VerifyExitCode` (null =

docs/explore-notes/usage-monitoring.md

@@ -21,6 +21,11 @@ authenticated with the Bearer access token Claude Code itself keeps fresh at
 Because the endpoint is undocumented and can change without notice, **every consumer
 fails open**. That is the single most important invariant here.
 
+**Measured 2026-09-16** (clean burst against the live endpoint, Worker otherwise idle): exactly
+5 requests succeed, the 6th 429s with `Retry-After: 300` — a flat 5-requests-per-5-minute quota,
+no `ratelimit-*`/`x-ratelimit-*` headers on either the 200s or the 429. The quota is per-account,
+not per-process, so a manual refresh or another consumer of the same OAuth token shares it.
+
 ## Components (`Usage/`)
 
 | Type | Role |
@@ -28,7 +33,7 @@ fails open**. That is the single most important invariant here.
 | `UsageModels` | `UsageBucket` / `UsageLimitRow` / `UsageSnapshot`. `UsageBucket.Utilization` is already a 0–100 percent — compare directly against thresholds, don't rescale. |
 | `ClaudeOAuthUsageClient` | Reads the token, calls the endpoint. Defensive parsing: missing/null buckets → null, missing `limits` → empty list. |
 | `UsageState` | Threadsafe singleton. A failed poll **never** overwrites the last good snapshot — it only sets `LastError`. |
-| `UsageMonitorService` | `BackgroundService`; polls on `usage_poll_interval_seconds` (default 60, clamped to min 15 on config load), one poll at startup. Logs a failure at most once per distinct error message. Broadcasts `HubBroadcaster.UsageUpdated` after **every** tick, success or failure. |
+| `UsageMonitorService` | `BackgroundService`; polls on `usage_poll_interval_active_seconds` / `usage_poll_interval_idle_seconds` (default 120 each, clamped to min 90 on config load), one poll at startup. Logs a failure at most once per distinct error message. Broadcasts `HubBroadcaster.UsageUpdated` after **every** tick, success or failure. |
 | `UsageSnapshotBuilder` | Builds the Hub-facing `UsageSnapshotDto` from `UsageState` + `IUsageGate` + `AppSettings`. The one shared place for stale/threshold/gate logic — `WorkerHub.GetUsageSnapshot` and `UsageMonitorService` must not diverge. |
 | `UsageGate` | Hard pause decision → `UsageGateDecision(IsBlocked, Reason)`. |
 | `UsageThrottle` | Pure static staging of parallelism ahead of the gate. |
@@ -254,6 +259,7 @@ degrades instead of throwing. Worker config: `usage_poll_interval_active_seconds
 `usage_poll_interval_idle_seconds`.
 
 The gate percentages are editable in **two** places that both write the same `app_settings` row:
-Settings → General (typed) and the usage-monitor gauges (dragged). The throttle stages are
+Settings → Execution (typed) and the usage-monitor gauges (dragged). The throttle stages are
 gauge-only — `SettingsModalViewModel` therefore carries them load→save verbatim so saving Settings
-can't reset a dragged value.
+can't reset a dragged value. PowerUse (switch, time window, handoff %) used to be usage-monitor-only
+and is now typed on the same Settings tab, so it needs no such round-trip.

docs/open.md

@@ -15,9 +15,7 @@ Checkliste lebt in `docs/verification-handoff.md`.
 
 - **Planning-aktiver Parent zeigt weiter „Idle":** Parent in `planning_phase=active` hat `Status=Idle` (korrekt im Modell), aber `TaskRowViewModel.StatusLabel` (Zeile 132) kennt nur `HasInteractiveSession`/`IsParked` als Overrides — der `PlanningBadge` ersetzt den Chip nicht sichtbar → liest sich wie ein normaler Idle-Task. Wunsch: klarer „Planning/Draft aktiv"-Zustand, der Idle überschreibt. (Kinder zeigen korrekt „Draft".)
 - **Blocked-by-Kette nicht sichtbar:** Nach Finalize ist die sequentielle Kette korrekt gesetzt (child[i] blocked-by child[i-1]), aber die UI stellt Reihenfolge/Abhängigkeit nicht dar — es gibt nur den „waiting"-Chip. Wunsch: Kette visualisieren (z.B. „wartet auf <Vorgänger>").
-- **Dequeue-„X" fehlt auf wartenden (blockierten) Kettengliedern:** `CanRemoveFromQueue = IsQueued || HasQueuedSubtasks` (TaskRowViewModel.cs:99), `IsQueued` verlangt leeres `blocked_by`. Ein gequeuetes, aber blockiertes Kind (`IsWaiting`) bekommt daher kein Remove-from-queue-X — nur Parent + erstes (entsperrtes) Kind.
-- **Session-Skills-Tab hat keinen Empty-State:** Bei 0 installierten Skills zeigt der Skills-Tab (Settings) nur eine nackte leere Fläche unter der Install-Zeile — kein erklärender Hinweis (z.B. „Noch keine Skills installiert — GitHub-URL oben einfügen"). Im `sessionSkillsTab`-Locale-Namespace (en.json:674) gibt es keinen `empty`-Key.
-- **Modal-Bodies sind unten abgeschnitten** (Sichtprüfung 2026-08-06, beobachtet in den Listen-Settings: der Hinweistext unter „Verify command" ist mitten in der Zeile vom Footer weggeschnitten und lässt sich nicht herunterscrollen; laut Mika „fast überall" in den Settings-Modals). Gemeinsames Muster: `<ScrollViewer Padding="20,16">` als Modal-Body — in `ListSettingsModalView:36`, `MergeModalView:33`, `WorktreesOverviewModalView:131`, `AboutModalView:20`, `MergeHelperSelectionModal:47`, `RepoImportModalView:45`, `LogVisualizerView:45` sowie `WorkConsole:295/395`. **Vermutete** Ursache (nicht verifiziert): das untere `Padding` des ScrollViewers zählt nicht zum scrollbaren Extent, die letzten Pixel sind also unerreichbar. Erst am echten Fall nachmessen, dann ggf. einheitlich das Padding vom ScrollViewer auf ein `Margin` des inneren Inhalts umziehen.
+- **Modal-Bodies unten abgeschnitten — gefixt, Sichtprüfung offen** (Ursache 2026-09-02 verifiziert: `ScrollViewer.Padding` zählt in Avalonia 12 nicht zum Extent; Fix ist das Padding auf ein `Margin` des inneren Inhalts umzuziehen). Betraf `AboutModalView`, `MergeHelperSelectionModal`, `MergeModalView`, `RepoImportModalView`, `WorktreesOverviewModalView` — alle fünf umgestellt. `ListSettingsModalView`, `LogVisualizerView` und `WorkConsole` hatten zu diesem Zeitpunkt bereits kein ScrollViewer-Padding mehr.
 - **Usage-Monitor-Modal: Analyse-Tabellen ausbaufähig** (Sichtprüfung 2026-08-06; Gauges, Info-Bänder, Presets/Custom-Range und Refresh-Button sind in Ordnung). Models-Tab: die Spaltenköpfe „OTHER CACHE" und „SHARE" kollidieren zu `OTHER CACHISHARE`; `claude-haiku-4-5-20251001` läuft in die IN-Spalte; alle Zahlen linksbündig und ohne Tausendertrenner (`506830708`). Tasks-Tab: Task-Titel wird ohne Ellipse hart an der LIST-Spalte abgeschnitten, der LIST-Text ebenfalls; MODEL ist bei Runs von vor der `task_runs.model`-Spalte leer (besser „—"). Wunsch: Zahlen rechtsbündig + `#,##0` (oder k/M), Spaltenbreiten/Truncation fixen.
 - **Conflict-Resolver: mehrere Konfliktdateien schlecht erkennbar:** Beim 2-Datei-Konflikt schwer zu sehen, dass zwei Dateien betroffen sind (File-Switcher/Anzahl zu unauffällig). Prominentere Datei-Liste / „x von y Dateien".
 - **Attachments: erster Drag&Drop der Session schlug einmalig fehl („An error occurred"):** Beim allerersten Drop-to-attach einer UI-Session zeigte die `DropStatus`-Zeile inline einen generischen Fehler und es wurde nichts persistiert (kein File, keine DB-Row); alle folgenden Drops derselben Session + der „Add file…"-Picker + Remove funktionierten fehlerfrei. Nicht reproduzierbar nach dem ersten Mal. Kandidaten: transiente SQLite-Contention (der UI-Prozess schreibt `todo.db` direkt via `new TaskAttachmentRepository`, während der Worker dieselbe DB hält) ODER ein Fehler im Drop-Stream-Pfad (`IStorageFile.OpenReadAsync` im Code-Behind, außerhalb des `try` in `AddFilesAsync`). Falls es erneut auftritt: `AddFilesAsync`/`OnDrop` mit robusterem Error-Logging versehen.
@@ -46,36 +44,45 @@ verifiziert und deshalb hier entfernt. Es bleiben die Entscheidungen, die daran
 
 ## Offene Verifikation (2026-08-27, Ticketsystem-Anbindung)
 
-> **PAUSIERT.** `TicketSettingsTabViewModel.FeatureEnabled = false` versteckt Settings-Tab,
-> Projekt-Dropdown und Kontextmenü-Eintrag; zum Reaktivieren die Konstante umlegen. Grund: die
-> API ist unter `http://bandelapis.fb-tuning.local` nicht erreichbar (*connection actively
-> refused* — nichts lauscht dort). Kein ClaudeDo-Bug und kein CORS; wahrscheinlich fehlt eine
-> IIS-Hostname-Bindung oder der Port stimmt nicht (`deploy/deploy-iis-winrm.ps1` der API notiert,
-> dass srv-04b diese Sites *by IP:port rather than by hostname* erreicht). Wird mit dem
-> API-Kollegen geklärt. Die Punkte unten bleiben stehen, bis die Erreichbarkeit steht.
+> **Reaktiviert am 2026-09-01.** `FeatureEnabled = true`. Die API läuft unter
+> `http://192.168.45.161` — der Hostname `bandelapis.fb-tuning.local` lehnt die Verbindung
+> weiterhin ab, die Base-URL muss also die **IP** sein.
 
-Tasks 1–9 sind implementiert und gemergt (Build + Tests grün, `_broadcaster.TaskUpdated` genau
-einmal in `TaskStateService.cs`), aber **kein Smoke-Test gegen die echte Bandel-API ist
-gelaufen**. Die fünf Punkte aus der „Manuellen Verifikation" des Specs
-(`docs/superpowers/specs/2026-08-27-ticketsystem-integration-design.md`):
+Alle vier Routen sind jetzt live gegen die echte API geprüft. Die aus dem `Bandel.APIs`-Quellcode
+abgeleiteten Shapes stimmten bis auf zwei Punkte, beide gefixt und mit Tests belegt:
 
-- [ ] PAT in den Settings hinterlegen, „Verbindung testen" → korrekter Benutzername + Scopes.
-- [ ] Liste mit Projekt `393 Bandel.LagerApp` verknüpfen, „Update from Ticketsystem" → nur
-      eigene, offene Tickets erscheinen als Tasks.
-- [ ] Einen Task laufen lassen → Ticket steht im Ticketsystem auf `InBearbeitung`.
+- `PATCH /api/Ticket/{id}/status` braucht **`statusId` UND `statusName`** — ohne den Namen 400
+  („The StatusName field is required."), also hätte *jede* Write-Back fehlgeschlagen. Der Name
+  wird nicht gegen die Id validiert, muss aber nicht-leer sein (`TicketStatusMap.NameOf`).
+- Das flache `assigneeName` im Board-Item ist auf **jedem** Ticket null (alle 63 in Abteilung
+  Entwicklung geprüft). Der Assignee-Filter des Imports hätte damit immer 0 Tasks erzeugt. Echte
+  Quelle: `ticketAssignees[].assigneeName`, das exakt das Format von `/pat/me`s `userName` hat.
+  `personInChargeName` ist die falsche Quelle (mal Login, mal Anzeigename).
+
+Import zieht jetzt `Offen` **und** `InBearbeitung`, weiterhin nur eigene Tickets.
+
+Bleibt manuell zu prüfen (UI-Pfad, nie sichtbar gelaufen):
+
+- [ ] PAT in Settings → Ticketsystem hinterlegen (Base-URL `http://192.168.45.161`),
+      „Verbindung testen" → `mika.kuns` + 9 Scopes.
+- [ ] Liste mit einem Projekt verknüpfen (Rechtsklick → Listeneinstellungen → Ticket-Projekt),
+      „Update from Ticketsystem" → nur eigene offene/laufende Tickets erscheinen als Tasks.
+      Achtung: aktuell ist **kein** offenes Ticket in Entwicklung dir zugewiesen — zum Testen
+      erst im Ticketsystem zuweisen, sonst ist 0 importiert das korrekte Ergebnis.
+- [ ] Einen Task laufen lassen → Ticket steht auf `InBearbeitung`.
 - [ ] Approve/Merge → Ticket steht auf `Fertig`.
 - [ ] Base-URL leeren → Menüeintrag verschwindet, keine Netzwerkaufrufe mehr.
-
-**Wichtig:** die Response-Shapes der Bandel-API (`BandelEnvelope<T>`, `TicketIdentity`,
-`TicketBoardItem`, `SidebarDepartment`/`SidebarProject`, `TicketDtos.cs`) wurden aus dem
-**Quellcode** von `Bandel.APIs` abgeleitet, **nie live gegen die echte API verifiziert** — es gab
-keinen einzigen echten Netzwerkaufruf während der Implementierung. Die Punkte 1–4 oben sind
-zugleich der erste Test dieser Annahme: schlägt einer davon mit einem Deserialisierungs- oder
-404/Formatfehler fehl, ist das erwartbar und kein Regressions-Bug — dann müssen die DTOs in
-`src/ClaudeDo.Worker/Tickets/TicketDtos.cs` an die tatsächliche Antwort angepasst werden.
+- [ ] Sichtprüfung des Settings-Tabs + des Ticket-Projekt-Dropdowns (nie gerendert gesehen).
 
 ## Offene Verifikation (2026-07-27)
 
+- **Empty-Repo-Hardening (2026-07-30)** — Worker/App neu starten (laufende Instanz hat den
+  Fix noch nicht), dann auf dem Task „HEy this is a Test" (Test List → `C:\Dev\TestRepo`,
+  aktuell 0 Commits) „Open ConPTY session" klicken: muss jetzt starten und in `C:\Dev\TestRepo`
+  genau einen leeren Commit „chore: initialize repository (ClaudeDo)" hinterlassen. Idealerweise
+  auch einmal auf dem Zweit-PC gegentesten (dort zusätzlich: Task-Run auf einem PC ohne
+  `git config user.name/email` — Auto-Commit darf nicht mehr scheitern).
+
 - **List handler (2026-07-27)** — visual pass: the Broom button is gone from the lists footer,
   the context-menu item appears only on lists with a working dir, and the selection dialog has no
   LIST column. (Der real-Claude-Smoke-Run der fünf Phasen ist am 2026-07-29 gelaufen — 6/6 sauber

docs/superpowers/plans/2026-07-30-empty-repo-hardening-plan.md

@@ -0,0 +1,58 @@
+# Empty-repo hardening — implementation plan
+
+Spec: `docs/superpowers/specs/2026-07-30-empty-repo-hardening-design.md`
+
+## Task 1 — GitService: HasHeadCommitAsync + EnsureHeadCommitAsync + friendly unborn error
+
+**Files:** `src/ClaudeDo.Data/Git/GitService.cs`,
+`tests/ClaudeDo.Worker.Tests/Runner/GitServiceBootstrapTests.cs` (new)
+
+1. Tests first (skip when git unavailable, mirroring `WorktreeManagerTests`):
+   - fresh `git init` repo (no commit): `HasHeadCommitAsync` false; after a commit true.
+   - `EnsureHeadCommitAsync` on empty repo → true; `RevParseHeadAsync` then succeeds;
+     `git ls-tree HEAD` empty; second call → false.
+   - staged file in empty repo survives bootstrap: still staged, not in the commit.
+   - corrupt HEAD (write a garbage SHA into `.git/HEAD` as a detached head):
+     `EnsureHeadCommitAsync` throws `InvalidOperationException` mentioning the dir.
+   - `RevParseHeadAsync` on empty repo: message says "has no commits yet" (no raw
+     "ambiguous argument").
+2. Implement: `HasHeadCommitAsync` (`rev-parse --verify --quiet HEAD`),
+   `EnsureHeadCommitAsync` (symbolic-ref guard → hash-object/commit-tree/update-ref
+   plumbing behind a static `SemaphoreSlim` with post-acquire re-check), unborn-HEAD
+   message in `RevParseHeadAsync`.
+3. Build Data + run new tests. Commit `fix(git): bootstrap empty repos with an initial commit`.
+
+## Task 2 — CommitAsync identity fallback
+
+**Files:** same two files.
+
+1. Test: repo with local `user.name`/`user.email` set to empty strings → `CommitAsync`
+   succeeds (retry path), commit exists.
+2. Implement: on identity-signature failure, retry once with
+   `-c user.name=ClaudeDo -c user.email=claudedo@local`.
+3. Commit `fix(git): fall back to a ClaudeDo identity when git has none`.
+
+## Task 3 — call sites
+
+**Files:** `src/ClaudeDo.Worker/Runner/WorktreeManager.cs`,
+`src/ClaudeDo.Worker/Planning/PlanningSessionManager.cs`,
+`tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs`
+
+1. Test: `CreateAsync` on a commit-less repo succeeds; worktree on disk; DB row Active.
+2. Wire `EnsureHeadCommitAsync` into `WorktreeManager.CreateAsync` (log info on
+   bootstrap) and `PlanningSessionManager.StartAsync`.
+3. Full Worker.Tests run. Commit `fix(worktree): auto-bootstrap commit-less repos before creating worktrees`.
+
+## Task 4 — docs
+
+- `src/ClaudeDo.Data/CLAUDE.md`: GitService bullet gains bootstrap/identity-fallback.
+- `docs/open.md`: verification item — open a ConPTY session on a fresh `git init` repo
+  on a second PC.
+- Commit `docs: empty-repo hardening notes`.
+
+## Verification
+
+- `dotnet test tests/ClaudeDo.Worker.Tests -c Release` green.
+- Manual: task 61609f79… in "Test List" (`C:\Dev\TestRepo`, currently commit-less) —
+  opening the ConPTY session must now succeed and leave `C:\Dev\TestRepo` with exactly
+  one empty commit by ClaudeDo.

docs/superpowers/plans/2026-09-02-multi-dependencies.md

@@ -0,0 +1,147 @@
+# Mehrfach-Abhängigkeiten (`depends_on` als Menge) — Implementation Plan
+
+**Goal:** A task can declare *n* predecessors instead of exactly one. The queue picker
+claims it only once **all** of them are `Done`.
+
+**Architecture:** Replace the single `tasks.depends_on_task_id` column with a
+`task_dependencies(task_id, depends_on_task_id)` relation table (composite PK, both FKs to
+`tasks.id`, `ON DELETE CASCADE`). Cascade reproduces today's `ON DELETE SET NULL` semantics
+on a join table: deleting a predecessor drops the edge, so the dependent becomes pickable
+instead of blocked forever. `BlockedByTaskId` (the internal planning chain) is untouched —
+the split stays deliberate.
+
+**Tech Stack:** .NET 8, EF Core (SQLite), SignalR, Avalonia 12, xUnit.
+
+**Not in scope:** `BlockedByTaskId`; rewriting the list-handler prompt to *use* multi-deps;
+a graph visualizer.
+
+---
+
+## File Structure
+
+**Create:**
+- `src/ClaudeDo.Data/Models/TaskDependencyEntity.cs`
+- `src/ClaudeDo.Data/Configuration/TaskDependencyEntityConfiguration.cs`
+- `src/ClaudeDo.Data/Migrations/<ts>_AddTaskDependencies.cs` — scaffolded
+- `src/ClaudeDo.Worker/External/TaskBlocking.cs` — the shared `blockedReason` builder
+  (two consumers: `ExternalMcpService`, `TaskWaitMcpTools`)
+- `tests/ClaudeDo.Data.Tests/TaskDependencyMigrationTests.cs` — real `Migrate()` on a DB
+  seeded with legacy `depends_on_task_id` rows
+
+**Modify:**
+- `src/ClaudeDo.Data/Models/TaskEntity.cs` — `DependsOnTaskId` → `Dependencies` nav +
+  `[NotMapped] DependsOnTaskIds`
+- `src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs` — drop column/FK/index
+- `src/ClaudeDo.Data/ClaudeDoDbContext.cs` — `DbSet<TaskDependencyEntity>`
+- `src/ClaudeDo.Data/Repositories/TaskRepository.cs` — `.Include(t => t.Dependencies)` on
+  the three read paths; `UpdateAsync` must not push the nav graph
+- `src/ClaudeDo.Worker/Queue/QueuePicker.cs` — `NOT EXISTS` over the relation table
+- `src/ClaudeDo.Worker/State/TaskStateService.cs` — `SetDependsOnAsync` takes a set,
+  graph-wide cycle check
+- `src/ClaudeDo.Worker/State/Interfaces/ITaskStateService.cs`
+- `src/ClaudeDo.Worker/External/ExternalMcpService.cs` — DTOs, `add_task`, `update_task`,
+  `ComputeBlockedInfoAsync`
+- `src/ClaudeDo.Worker/External/TaskWaitMcpTools.cs`
+- `src/ClaudeDo.Ui/ViewModels/Islands/TaskRowViewModel.cs`,
+  `TasksIslandViewModel.cs` — display of *n* predecessors
+- `src/ClaudeDo.Data/CLAUDE.md`, `src/ClaudeDo.Worker/CLAUDE.md`
+- test files listed per task below
+
+---
+
+## Task 1 — Schema + migration
+
+- [ ] `TaskDependencyEntity { string TaskId; string DependsOnTaskId; }`, table
+      `task_dependencies`, composite PK, both FKs cascade, index on `depends_on_task_id`.
+- [ ] `TaskEntity.Dependencies` (`ICollection<TaskDependencyEntity>`), `[NotMapped]
+      DependsOnTaskIds` projection. `DependsOnTaskId` and its FK/index are removed.
+- [ ] Scaffold the migration, then **hand-edit the Up body** so the data copy sits between
+      create and drop:
+      `CreateTable` → `INSERT INTO task_dependencies (task_id, depends_on_task_id) SELECT
+      id, depends_on_task_id FROM tasks WHERE depends_on_task_id IS NOT NULL` →
+      `DropColumn`. Down reverses it (add column, `UPDATE … FROM` the first edge, drop
+      table) — lossy for >1 edge, which is inherent and documented in the migration.
+- [ ] Verify: `dotnet ef database update` against a temp DB seeded with legacy rows;
+      `pragma_table_info` diff. **`DropColumn` forces a SQLite table rebuild** — the
+      `ef-migration-parallel-designer-collision` trap applies: if another migration lands
+      in parallel, hand-check both `.Designer.cs` snapshots.
+
+**Test:** `TaskDependencyMigrationTests` — migrate to the previous migration, seed a task
+with `depends_on_task_id` via raw SQL, migrate to head, assert the edge is in
+`task_dependencies` and nothing else changed. (Acceptance #2.)
+
+## Task 2 — Queue gating
+
+- [ ] `QueuePicker` replaces the `depends_on_task_id IS NULL OR EXISTS(...)` clause with
+      a doubly-negated `NOT EXISTS` over `task_dependencies`, so a dangling edge keeps
+      blocking exactly as today:
+      ```sql
+      AND NOT EXISTS (
+          SELECT 1 FROM task_dependencies td
+          WHERE td.task_id = t.id
+            AND NOT EXISTS (SELECT 1 FROM tasks d
+                            WHERE d.id = td.depends_on_task_id AND d.status = 'done')
+      )
+      ```
+
+**Tests** (`QueuePickerTests`, real SQLite): n=2 both `Done` → claimed; one `Done` one
+`Running` → skipped; zero deps → claimed (regression); one dep `Failed` → still skipped,
+no cascade (acceptance #6); one dep `Cancelled` → still skipped.
+
+## Task 3 — Write path + cycle detection
+
+- [ ] `ITaskStateService.SetDependsOnAsync(string taskId, IReadOnlyList<string>
+      dependsOnTaskIds, CancellationToken)` — empty list clears. Rejects self-reference,
+      unknown id, duplicate handling by de-dup.
+- [ ] Cycle check walks the **graph**: load the whole edge set once (it only ever holds
+      *declared* dependencies, so it stays small — `ponytail:` note, switch to a recursive
+      CTE if it ever isn't), BFS from every proposed predecessor; reaching `taskId` is a
+      cycle. Visited set guards pre-existing bad data.
+- [ ] Replace rows transactionally (`ExecuteDelete` for `taskId` + `AddRange`), wake the
+      queue when the set shrank.
+
+**Tests** (`TaskStateServiceTests`): sets n edges; empty list clears + wakes; self-ref
+rejected; unknown id rejected; **A→B→C→A rejected** (acceptance #3); adding a second edge
+leaves the first intact.
+
+## Task 4 — MCP surface
+
+- [ ] `add_task` / `update_task` keep `dependsOnTaskId` (string) **and** gain
+      `dependsOnTaskIds` (`string[]?`). Precedence: `dependsOnTaskIds` non-null wins;
+      otherwise the legacy scalar is treated as a one-element set, with `""` still the
+      clear sentinel. Both run through `TaskIdResolver` so `#123` keeps working.
+- [ ] `TaskDto`/`TaskRefDto`: `DependsOnTaskId` → `DependsOnTaskIds`
+      (`IReadOnlyList<string>`). Only the *input* form is contractually frozen.
+- [ ] `TaskBlocking.Describe` builds one reason naming **every** unmet predecessor
+      (acceptance #4); `ComputeBlockedInfoAsync` and `TaskWaitMcpTools.CheckOnceAsync`
+      both use it.
+
+**Tests** (`ExternalMcpServiceTests`, `TaskWaitMcpToolsTests`, `BatchMcpToolsTests`):
+legacy scalar still sets + clears the link (acceptance #5, explicit back-compat test);
+`dependsOnTaskIds` sets n; cycle via the list form throws; `blockedReason` names both
+open predecessors.
+
+## Task 5 — UI
+
+- [ ] `TaskRowViewModel.DependsOnTaskIds`; `DependsOnTaskId` becomes a computed
+      "single predecessor or null" so the existing linear-chain rail is unchanged for the
+      1-dependency case.
+- [ ] `BuildAfterLabel` joins all resolvable predecessors (`#3, #7`); a row with >1
+      predecessor gets the label, never a rail (a rail can only render a line).
+- [ ] `GroupingKey` folds the joined ids so the reconcile tick still detects a change.
+- [ ] `.Include(t => t.Dependencies)` on the `TasksIslandViewModel` query sites that
+      hydrate rows.
+
+**Tests** (`TasksIslandChainTests`, `TasksIslandClassifyItemsTests`,
+`TasksIslandReconcileTickTests`): existing chain tests keep passing via the 1-dep path;
+a 2-dep row shows a joined after-label and no rail.
+
+## Task 6 — Docs + verify
+
+- [ ] `src/ClaudeDo.Data/CLAUDE.md` (Models, Schema) and
+      `src/ClaudeDo.Worker/CLAUDE.md` (Status Model table, picker bullet,
+      `TaskStateService` bullet) describe the relation table (acceptance #7).
+- [ ] VERIFY (acceptance #8): `dotnet build src/ClaudeDo.App -c Release`,
+      `dotnet build src/ClaudeDo.Worker -c Release`, `dotnet test` for
+      `ClaudeDo.Data.Tests`, `ClaudeDo.Worker.Tests`, `ClaudeDo.Ui.Tests` (`-c Release`),
+      report counts.

docs/superpowers/specs/2026-07-30-empty-repo-hardening-design.md

@@ -0,0 +1,98 @@
+# Empty-repo hardening (unborn HEAD) — design
+
+**Date:** 2026-07-30
+**Status:** approved (option "Auto-Bootstrap" chosen by Mika)
+
+## Problem
+
+`GetInteractiveLaunchSpec` (embedded ConPTY session) fails with a raw git error when the
+task's list points at a git repository that has **no commits yet** (fresh `git init`,
+unborn HEAD):
+
+```
+HubException: git rev-parse HEAD failed (exit 128): fatal: ambiguous argument 'HEAD': unknown revision ...
+```
+
+Root cause chain: `InteractiveLaunchSpecService.BuildForTaskAsync` → `WorktreeManager.CreateAsync`
+→ `IsGitRepoAsync` (passes — `rev-parse --git-dir` works on an empty repo) →
+`ResolveBaseCommitAsync` → `RevParseHeadAsync` (fatals — HEAD is unborn). The same gap
+exists in `PlanningSessionManager.StartAsync` and hits autonomous runs (`TaskRunner` →
+`CreateAsync` → task `Failed` with the same cryptic message).
+
+This is a "works on my laptop" class of bug: on a fresh PC the first thing a user tries is
+a freshly init-ed test repo, which breaks instantly. A second member of the same class:
+a PC without `git config user.name/email` breaks every auto-commit
+("Please tell me who you are").
+
+## Decision
+
+**Auto-bootstrap:** when a worktree (task run / ConPTY / planning) needs a base commit and
+the repo has zero commits, ClaudeDo creates an empty initial commit automatically and
+proceeds. Nothing can be lost — the repo is empty. Genuinely broken states (HEAD not a
+symbolic ref and not resolvable) still produce a clear, actionable error instead of raw
+git stderr.
+
+## Design
+
+### 1. `GitService.HasHeadCommitAsync(dir)`
+
+`git rev-parse --verify --quiet HEAD` → exit 0 means HEAD resolves to a commit.
+
+### 2. `GitService.EnsureHeadCommitAsync(dir)` → `bool` (true = bootstrapped)
+
+- HEAD resolves → return `false` (no-op).
+- `git symbolic-ref -q HEAD` fails → repo is corrupt (detached HEAD onto a missing
+  commit, mangled `.git/HEAD`) → throw `InvalidOperationException` with a clear message
+  naming the directory. Auto-fixing a corrupt repo is out of scope by design.
+- Otherwise HEAD is an unborn branch → bootstrap **via plumbing only** (never touches the
+  user's index or working tree — staged/untracked files stay exactly as they were):
+  1. `git hash-object -w -t tree --stdin` with empty stdin → empty tree object.
+  2. `git -c user.name=ClaudeDo -c user.email=claudedo@local commit-tree <tree> -m
+     "chore: initialize repository (ClaudeDo)"` — inline identity so this works on a PC
+     with no git identity configured.
+  3. `git update-ref <unborn-branch-ref> <commit>`.
+- Serialized behind a process-wide gate with a re-check after acquiring, so two parallel
+  task starts on the same empty repo bootstrap exactly once.
+
+### 3. Defense-in-depth: friendly `RevParseHeadAsync` error
+
+When `rev-parse HEAD` fails with the unborn-HEAD signature ("ambiguous argument 'HEAD'"),
+throw "The repository at {dir} has no commits yet" instead of raw stderr — covers any
+future call site that forgets the preflight.
+
+### 4. Call sites
+
+- `WorktreeManager.CreateAsync` — after the `IsGitRepoAsync` guard, call
+  `EnsureHeadCommitAsync`; log when a bootstrap happened. Covers autonomous runs,
+  interactive ConPTY sessions, improvement/planning children.
+- `PlanningSessionManager.StartAsync` — same, before its own `RevParseHeadAsync`.
+
+### 5. Git identity fallback for auto-commits
+
+`GitService.CommitAsync`: if the commit fails with the missing/empty-identity signature,
+retry once with inline `-c user.name="ClaudeDo" -c user.email="claudedo@local"`.
+Happy path costs nothing (no preflight call); a fresh PC without git identity no longer
+fails every task auto-commit.
+
+## Out of scope
+
+- UI validation when configuring a list's WorkingDir (nice-to-have; the worktree paths now
+  either self-heal or produce clear errors).
+- Repairing corrupt repos.
+
+## Test plan (real git, Worker.Tests)
+
+- `HasHeadCommitAsync`: false on fresh `git init`, true after a commit.
+- `EnsureHeadCommitAsync` on an empty repo: returns true, `rev-parse HEAD` then works,
+  tree of the bootstrap commit is empty, second call returns false.
+- Staged-file preservation: file staged in empty repo → after bootstrap it is still
+  staged and NOT part of the bootstrap commit.
+- Corrupt HEAD (point `.git/HEAD` at a bogus ref? no — detach onto a garbage SHA by
+  writing `.git/HEAD` directly): clear error, no bootstrap.
+- `CommitAsync` identity fallback: local `user.name`/`user.email` set to empty strings
+  (forces the identity failure deterministically regardless of global config) → commit
+  succeeds via fallback, author is ClaudeDo.
+- `WorktreeManager.CreateAsync` on an empty repo: succeeds; worktree exists; base commit
+  = bootstrap commit.
+- `PlanningSessionManager.StartAsync` on an empty repo: succeeds (if existing test infra
+  makes this cheap; otherwise covered by the shared code path).

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
     "version": "8.0.418",
-    "rollForward": "latestFeature"
+    "rollForward": "latestMajor"
   }
 }

src/ClaudeDo.App/Program.cs

@@ -42,6 +42,8 @@ sealed class Program
             ClaudeDoDbContext.MigrateAndConfigure(db);
         }
 
+        ClipboardImageTempStore.DeleteOlderThan(TimeSpan.FromHours(24), DateTime.UtcNow);
+
         try
         {
             ConfigureAppBuilder(AppBuilder.Configure(() => new App(services)))
@@ -165,13 +167,13 @@ sealed class Program
         sc.AddSingleton<TasksIslandViewModel>(sp =>
             new TasksIslandViewModel(
                 sp.GetRequiredService<IDbContextFactory<ClaudeDoDbContext>>(),
-                sp.GetRequiredService<IWorkerClient>()));
+                sp.GetRequiredService<IWorkerClient>(),
+                sp.GetRequiredService<INotesApi>()));
         sc.AddSingleton<DetailsIslandViewModel>(sp =>
             new DetailsIslandViewModel(
                 sp.GetRequiredService<IDbContextFactory<ClaudeDoDbContext>>(),
                 sp.GetRequiredService<IWorkerClient>(),
                 sp,
-                sp.GetRequiredService<INotesApi>(),
                 sp.GetRequiredService<MergeCoordinator>()));
         sc.AddSingleton<UsagePillViewModel>(sp =>
             new UsagePillViewModel(sp.GetRequiredService<IWorkerClient>()));

src/ClaudeDo.Data/CLAUDE.md

@@ -4,14 +4,17 @@ Shared data layer: models, repositories, SQLite infrastructure, and git operatio
 
 ## Models
 
-- **TaskEntity** — Id, ListId, Title, Description, Status, PlanningPhase, BlockedByTaskId (FK to predecessor in a chain), DependsOnTaskId (FK to a user/MCP-declared predecessor, distinct from BlockedByTaskId), ScheduledFor, Result, ReviewFeedback, LogPath, timestamps, CommitType, Model / SystemPrompt / AgentPath / MaxTurns / PermissionMode (nullable overrides), IsStarred, IsMyDay, IsManual, Notes, ParentTaskId, PlanningSessionId / PlanningSessionToken / PlanningFinalizedAt, CreatedBy, HandlerBaseCommit / HandlerHeadCommit, InteractiveSessionId, TicketRef, Number (global immutable human-readable alias).
+- **TaskEntity** — Id, ListId, Title, Description, Status, PlanningPhase, BlockedByTaskId (FK to predecessor in a chain), Dependencies (n user/MCP-declared predecessors via `task_dependencies`, distinct from BlockedByTaskId), ScheduledFor, Result, ReviewFeedback, LogPath, timestamps, CommitType, Model / SystemPrompt / AgentPath / MaxTurns / PermissionMode (nullable overrides), IsStarred, IsMyDay, IsManual, Notes, ParentTaskId, PlanningSessionId / PlanningSessionToken / PlanningFinalizedAt, CreatedBy, HandlerBaseCommit / HandlerHeadCommit, InteractiveSessionId, TicketRef, Number (global immutable human-readable alias).
   - `TicketRef` (`ticket_ref`, nullable string) — link to an external ticket, format `<provider>:<id>` (currently always `bandel:<ticketId>`). Set by the ticket import, otherwise null. → `ClaudeDo.Worker/CLAUDE.md` Tickets section.
-  - Status / PlanningPhase / BlockedByTaskId / DependsOnTaskId semantics + allowed transitions: `ClaudeDo.Worker/CLAUDE.md` → Status Model.
+  - Status / PlanningPhase / BlockedByTaskId / dependency-set semantics + allowed transitions: `ClaudeDo.Worker/CLAUDE.md` → Status Model.
+  - `Dependencies` (`ICollection<TaskDependencyEntity>`) + the `[NotMapped] DependsOnTaskIds` id projection. **Only populated where the query `Include`s it** — `TaskRepository.GetByIdAsync`/`GetByNumberAsync`/`GetByListIdAsync` do, and so do the `TasksIslandViewModel` row-hydration queries. The queue gate itself is raw SQL in `QueuePicker` and never reads the nav, so a forgotten Include misreports the UI/MCP `blocked` flag but can never let a blocked task run. ⚠️ `TaskRepository.UpdateAsync` marks **only the root entity** Modified (`Entry().State`, not `Update()`) — `Update()` marks the loaded graph, and an all-key `task_dependencies` row has nothing to SET.
   - `HandlerBaseCommit`/`HandlerHeadCommit` = the review range for a **worktree-less "list handler" host task** ("Let Claude handle it"), which commits straight into the list's working dir instead of a per-task worktree. Everything that reads a task's diff falls back to this pair whenever `Worktree` is null → [conpty-sessions](../../docs/explore-notes/conpty-sessions.md).
   - `InteractiveSessionId` = the claude session id an embedded ConPTY interactive task session runs under, persisted by `InteractiveLaunchSpecService` before launch so a closed/aborted session can be resumed → [conpty-sessions](../../docs/explore-notes/conpty-sessions.md).
   - `Number` (INTEGER NOT NULL, unique index `idx_tasks_number`) — a global, monotonically increasing display alias for tasks. **Never reused**: deleting a task leaves a gap in numbering, ensuring that a task number that appears in a log or report always points to the same task (if it exists). Allocated by `TaskNumberAllocator.AddWithNumberAsync` on every insert via a persistent counter (`app_settings.next_task_number`). **Why not `MAX(number) + 1`:** deleting the highest-numbered task would free its number for reuse, breaking the immutability guarantee. The allocator uses an `UPDATE…RETURNING` statement to claim numbers atomically, retrying up to 5 times if a uniqueness collision occurs (the counter advances on each attempt, so retries always allocate fresh numbers). The one-time backfill for pre-existing rows lived in the `AddTaskNumbers` migration, squashed away 2026-08-26.
   - Legacy status values `Manual`/`Planning`/`Planned`/`Draft`/`Waiting` were retired. The backfill migration was squashed away (2026-08-26) — a database still holding those values can't be upgraded, see Schema below.
-- **ListEntity** — Id, Name, WorkingDir, DefaultCommitType, CreatedAt, IsManual (reminder list — tasks created here default to `IsManual`)
+- **ListEntity** — Id, Name, WorkingDir, DefaultCommitType, CreatedAt, IsManual (reminder list — tasks created here default to `IsManual`), Icon, FolderId
+  - `FolderId` (`folder_id`, nullable FK → `list_folders.id`, `ON DELETE SET NULL`) — the sidebar folder the list sits in; null = top level. Written only by the UI (`ListsIslandViewModel` drag/context menu), never by MCP.
+- **ListFolderEntity** — Id, Name, Icon, SortOrder, IsCollapsed, CreatedAt → `list_folders`. A pure sidebar grouping: no tasks, no config, no working dir, **one level** (folders never nest). Deliberately its own table rather than a flag on `lists`, so every caller that enumerates lists (MCP `list_task_lists`, "move to list", the queue picker, repo import) needs no folder filtering. Folder CRUD lives on `ListRepository`.
 - **ListConfigEntity** — ListId (PK, 1:1), Model, SystemPrompt, AgentPath, MaxTurns, SessionSkills, VerifyCommand, PermissionMode, TicketProjectId (all nullable). `VerifyCommand` is an optional post-merge gate; null/blank = no gate → [review-merge](../../docs/explore-notes/review-merge.md). `PermissionMode` is null = inherit the global default; resolution order task → list → global lives in `EffectiveRunConfigResolver`. `TicketProjectId` (`ticket_project_id`) links the list to a project in the external ticket system; null = not linked → `ClaudeDo.Worker/CLAUDE.md` Tickets section.
   - ⚠️ `ListRepository.SetConfigAsync` copies the entity **verbatim**, so every writer must carry the fields it doesn't own (`SessionSkills`, `PermissionMode`, `TicketProjectId`) or they silently reset. `UpdateListConfigDto.TicketProjectId` is tri-state (`null` = keep stored) for exactly that reason — only the list-settings modal sends an explicit value. This bit `PermissionMode` for real: its update-branch copy was missing from `SetConfigAsync` until `f0a3a186`, so a list's permission-mode override only ever stuck on the list's *first* save, never on a later one.
 - **WorktreeEntity** — TaskId (PK, 1:1), Path, BranchName, BaseCommit, HeadCommit, DiffStat, MergeCommit (nullable — SHA of the merge commit this branch produced; the only thing making `revert_merge` possible without searching `git log`), State (`Active|Merged|Discarded|Kept`)
@@ -20,6 +23,7 @@ Shared data layer: models, repositories, SQLite infrastructure, and git operatio
 - **DailyNoteEntity** — Id, Date (DateOnly), Text, SortOrder, CreatedAt → `daily_notes`
 - **WeekReportEntity** — Id, StartDate/EndDate (DateOnly), Markdown, GeneratedAt → `week_reports`, unique index on (start_date, end_date)
 - **TaskAttachmentEntity** — Id, TaskId (FK, ON DELETE CASCADE), FileName, ByteSize, CreatedAt → `task_attachments`
+- **TaskDependencyEntity** — one declared "run after" edge: TaskId + DependsOnTaskId, composite PK, table `task_dependencies`. Both FKs are `ON DELETE CASCADE`, which is what the old single `depends_on_task_id` column got from `ON DELETE SET NULL`: deleting a predecessor drops the edge so the dependent becomes pickable instead of blocked on a task that's gone. Written **only** by `TaskStateService.SetDependsOnAsync`.
 - **SubtaskEntity**, **AgentInfo** — subtasks / record for scanned agent files
 
 ### AppSettingsEntity
@@ -37,10 +41,20 @@ Beyond the basics it carries:
 | `ReportExcludedPaths` | `report_excluded_paths` | null | JSON array of excluded path prefixes. |
 | `StandupWeekday` | `standup_weekday` | Wednesday | int `DayOfWeek`. |
 | `NextTaskNumber` | `next_task_number` | 1 | Persistent counter for `TaskEntity.Number` allocation. Incremented atomically in `TaskNumberAllocator.AddWithNumberAsync` on every task insert. **Monotonic only:** the counter itself advances across all tasks (no per-list numbering), and it never resets. A deleted task leaves a gap. |
+| `PowerUseEnabled` | `power_use_enabled` | false | PowerUse master switch, toggled in **Settings → Execution**. ⚠️ Never sufficient alone — a handler run is in PowerUse only when `list_config.power_use_allowed` is also set. |
+| `ListHandlerMaxHandoffs` | `list_handler_max_handoffs` | 4 | Cap on a list-handler run's wait↔merge handoff chain (`HandoffRoundTracker`). 4 = two merge rounds. Independent of PowerUse — applies to interactive runs too. Clamped to min 1 in `WorkerHub.UpdateAppSettings` and again in `Register`, because 0 would remove the only bound on a runaway chain. |
+| `PowerUseWindowStart` / `PowerUseWindowEnd` | `power_use_window_*` | null | Optional local-time window (`HH:mm`) narrowing when PowerUse applies. Both null (or only one set) = round the clock, i.e. byte-identical to the pre-window behaviour; end before start wraps over midnight. Semantics live in the pure `PowerUseWindow`; checked in `InteractiveLaunchSpecService.ComposeHandlerPromptAsync` **per phase** at prompt-build time, so a chain handing off past the end time drops the addendum from there on. Unparseable input is stored as null, not rejected. |
+| `PowerUseHandoffPct` | `power_use_handoff_pct` | 95 | 5h-usage percentage at which a PowerUse handler session should hand off. Clamped 50..99. Typed in Settings → Execution; the consumer is the handoff prompt. |
 
 All four usage percentages are clamped 0..100 by `AppSettingsRepository.UpdateAsync`.
 Gate/throttle semantics → [usage-monitoring](../../docs/explore-notes/usage-monitoring.md).
 
+⚠️ **`AppSettingsRepository.UpdateAsync` copies the incoming entity field by field** onto the
+singleton row — a property missing from that block never persists, however correctly the caller
+filled the entity, and nothing fails. `ModelPresets`, `PowerUseEnabled` and
+`ListHandlerMaxHandoffs` were all silently unwritable that way until 2026-09-02. Add a new column
+to that block, not just to the entity + the hub.
+
 ### Model / effort registries
 
 - **ModelPresets / ModelPreset** — per-model run defaults (`Model`, `Effort`, `MaxTurns`), one row per `ModelRegistry.Aliases` entry, supplying the **global** effort and max-turns defaults. Ship defaults: haiku medium/20, sonnet high/30, opus high/40, fable high/25. `Parse`/`Serialize` normalize (unknown models dropped, missing aliases filled from `Defaults`, effort validated, turns clamped 1–200) and **never throw** — a malformed settings row must not stop a run. `For(presets, model, fallbackMaxTurns)` always returns a usable row; resolution order and the fallback trap → [worker-task-pipeline](../../docs/explore-notes/worker-task-pipeline.md).
@@ -53,7 +67,8 @@ All use EF Core LINQ via `ClaudeDoDbContext`. The atomic `Queued → Running` cl
 Worker's `QueuePicker` (`FromSqlRaw`), **not** here.
 
 - **TaskRepository** — CRUD, planning helpers (`CreateChildAsync`, `SetPlanningStartedAsync`, `DiscardPlanningAsync`, `UpdateChildAsync`), `UpdateAgentSettingsAsync`. ⚠️ Status-mutation primitives (`MarkRunningAsync`/`MarkDoneAsync`/`MarkFailedAsync`/`FlipAllRunningToFailedAsync`) are **`internal`** — only the Worker's `TaskStateService` may call them. `CreateChildAsync` produces children with `Status=Idle, PlanningPhase=None`. **Task-number allocation:** `AddAsync` (line 20) and `CreateChildAsync` (line 276) are the two sole task-creation paths; both call `TaskNumberAllocator.AddWithNumberAsync` to allocate a number atomically during the same transaction as the insert. Every other creation path (UI, MCP `add_task`, `batch_add_tasks`, Online Inbox sync, merge-helper handler tasks, planning children) routes through one of these two.
-- **ListRepository** — CRUD, `GetConfigAsync`/`SetConfigAsync` (upsert)/`DeleteConfigAsync` for `list_config`
+- **ListRepository** — CRUD, `GetConfigAsync`/`SetConfigAsync` (upsert)/`DeleteConfigAsync` for `list_config`, plus the `list_folders` set: `GetFoldersAsync`, `AddFolderAsync` (appends), `RenameFolderAsync`, `DeleteFolderAsync` (folder only — the FK releases its lists), `SetFolderCollapsedAsync`, `SetListFolderAsync`. The folder writers are `ExecuteUpdate` patches, not entity `Update()`s, so a rename can't reset `SortOrder`/`IsCollapsed` the way `SetConfigAsync`'s verbatim copy resets forgotten columns.
+  - ⚠️ **`lists.sort_order` and `list_folders.sort_order` share one number space** — the sidebar interleaves folders and top-level lists in a single order, so `ReorderSidebarAsync` numbers the whole visual sequence (each folder followed by its children) across both tables, and `AddAsync`/`AddFolderAsync` append via `MAX(sort_order)+1` over **both**. Never renumber one table on its own.
 - **WorktreeRepository** — CRUD, `UpdateHeadAsync`, `SetStateAsync`, `SetMergedAsync` (atomically sets State=Merged **and** stamps MergeCommit in one update — the only writer of MergeCommit)
 - **TaskAttachmentRepository** — `AddAsync`, `UpdateAsync`, `GetAsync(taskId, fileName)`, `ListByTaskIdAsync`, `DeleteAsync(taskId, fileName)`. Bulk delete-per-task is the `ON DELETE CASCADE` on `task_attachments`, not a repository method.
 - **DailyNoteRepository**, **WeekReportRepository**, **TaskRunRepository**, **SubtaskRepository**, **AppSettingsRepository**
@@ -80,10 +95,15 @@ dir(s) via an optional `AttachmentStore` ctor param (defaults to the production
 - Merge: ff-only, no-ff, abort, mid-merge detection (`MERGE_HEAD`), conflicted files
 - Revert: `RevertMergeCommitAsync` (`git revert --no-edit -m 1 <sha>`), `RevertAbortAsync`, `IsMidRevertAsync` (`REVERT_HEAD`, mirrors `IsMidMergeAsync`)
 - `PreviewMergeAsync` (non-destructive check via `git merge-tree --write-tree`), `CountChangedFilesAsync`, rev-parse, is-git-repo
+- Empty repos: `HasHeadCommitAsync` (HEAD resolves to a real commit) and `EnsureHeadCommitAsync` — a fresh `git init` repo (unborn HEAD) gets an empty bootstrap commit via plumbing only (mktree/commit-tree/update-ref), so the user's index and working tree stay untouched; identity is passed inline, so it also works with no git config, and a broken HEAD throws instead of guessing
+- Identity fallback: `CommitAsync` retries once as the ClaudeDo identity when the machine has none configured
 
 ⚠️ **Revert never resets or rewrites** — it always produces a new commit, because the working
 directory it operates on is shared with other concurrent sessions.
 
+⚠️ **Git stdin is BOM-less UTF-8** — `Encoding.UTF8` writes a BOM preamble, which git rejects
+as input (`mktree` fails with "input format error", and commit messages would carry it).
+
 ## Schema
 
 Tables (one per line so parallel migrations don't collide on the same line):
@@ -98,6 +118,8 @@ Tables (one per line so parallel migrations don't collide on the same line):
 - `daily_notes`
 - `week_reports`
 - `task_attachments`
+- `task_dependencies`
+- `list_folders`
 
 Managed by EF Core migrations in `Migrations/`. **The 40 incremental migrations were squashed into
 a single `20260826094154_InitialCreate` on 2026-08-26** — the schema history is git history now,
@@ -107,8 +129,9 @@ not a migration chain. Consequences:
   (pre-EF databases without a history, and databases whose history still lists the old chain ending
   at `20260825063230_AddPrimeActionKind`). A database that stopped *mid*-chain can no longer be
   upgraded and throws with a reinstall message instead of being stamped onto a schema it lacks.
-  Covered by `MigrationBaselineTests` — the only test that runs a real `Migrate()` (every other
-  Data.Tests fixture uses `EnsureCreated`, which skips migrations entirely). Its fixture builds the
+  Covered by `MigrationBaselineTests` — one of only two tests that run a real `Migrate()`
+  (`TaskDependencyMigrationTests` is the other; every other Data.Tests fixture uses
+  `EnsureCreated`, which skips migrations entirely). Its fixture builds the
   legacy database by migrating **to** `InitialCreate` and seeding rows with raw SQL: `EnsureCreated`
   would build *today's* schema, so every post-squash migration would then re-add an existing column
   ("duplicate column name"). Assert "nothing pending", never "InitialCreate is the only history row".
@@ -117,10 +140,12 @@ not a migration chain. Consequences:
   Release` — `Data` is its own startup project (it holds the `Design` package and a design-time
   factory), and `--configuration Release` is needed because a running Worker locks `Debug`.
 
-`tasks` holds `status`, `planning_phase` (default `none`),
-`blocked_by_task_id` (FK to `tasks.id`, `ON DELETE SET NULL`), and `depends_on_task_id` (same FK
-shape, but a separate column — see Worker/CLAUDE.md → Status Model for why it isn't unified with
-`blocked_by_task_id`).
+`tasks` holds `status`, `planning_phase` (default `none`) and `blocked_by_task_id` (FK to
+`tasks.id`, `ON DELETE SET NULL`). The user/MCP-declared predecessors live in `task_dependencies`
+instead — a **set**, so a task can wait on n of them; see Worker/CLAUDE.md → Status Model for why
+it isn't unified with `blocked_by_task_id`. `AddTaskDependencies` (2026-09-02) migrated the former
+single `tasks.depends_on_task_id` column into that table (each value became a one-element set) and
+dropped it; the `Down` direction is inherently lossy for more than one edge.
 
 ## Conventions
 

src/ClaudeDo.Data/ClaudeDoDbContext.cs

@@ -41,7 +41,9 @@ public class ClaudeDoDbContext : DbContext
         => optionsBuilder.AddInterceptors(SqliteForeignKeyInterceptor.Instance);
 
     public DbSet<TaskEntity> Tasks => Set<TaskEntity>();
+    public DbSet<TaskDependencyEntity> TaskDependencies => Set<TaskDependencyEntity>();
     public DbSet<ListEntity> Lists => Set<ListEntity>();
+    public DbSet<ListFolderEntity> ListFolders => Set<ListFolderEntity>();
     public DbSet<ListConfigEntity> ListConfigs => Set<ListConfigEntity>();
     public DbSet<WorktreeEntity> Worktrees => Set<WorktreeEntity>();
     public DbSet<TaskRunEntity> TaskRuns => Set<TaskRunEntity>();

src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs

@@ -70,6 +70,17 @@ public class AppSettingsEntityConfiguration : IEntityTypeConfiguration<AppSettin
         builder.Property(s => s.AutoContinueOnUsageLimit)
             .HasColumnName("auto_continue_on_usage_limit").IsRequired().HasDefaultValue(false);
 
+        builder.Property(s => s.PowerUseEnabled)
+            .HasColumnName("power_use_enabled").IsRequired().HasDefaultValue(false);
+        builder.Property(s => s.PowerUseWindowStart)
+            .HasColumnName("power_use_window_start");
+        builder.Property(s => s.PowerUseWindowEnd)
+            .HasColumnName("power_use_window_end");
+        builder.Property(s => s.PowerUseHandoffPct)
+            .HasColumnName("power_use_handoff_pct").IsRequired().HasDefaultValue(95);
+        builder.Property(s => s.ListHandlerMaxHandoffs)
+            .HasColumnName("list_handler_max_handoffs").IsRequired().HasDefaultValue(4);
+
         builder.HasData(new AppSettingsEntity { Id = AppSettingsEntity.SingletonId });
     }
 }

src/ClaudeDo.Data/Configuration/DailyNoteEntityConfiguration.cs

@@ -14,6 +14,7 @@ public class DailyNoteEntityConfiguration : IEntityTypeConfiguration<DailyNoteEn
         builder.Property(n => n.Date).HasColumnName("note_date").IsRequired();
         builder.Property(n => n.Text).HasColumnName("text").IsRequired();
         builder.Property(n => n.SortOrder).HasColumnName("sort_order").IsRequired();
+        builder.Property(n => n.FromAgent).HasColumnName("from_agent").IsRequired();
         builder.Property(n => n.CreatedAt).HasColumnName("created_at").IsRequired();
         builder.HasIndex(n => n.Date);
     }

src/ClaudeDo.Data/Configuration/ListConfigEntityConfiguration.cs

@@ -20,5 +20,6 @@ public class ListConfigEntityConfiguration : IEntityTypeConfiguration<ListConfig
         builder.Property(c => c.VerifyCommand).HasColumnName("verify_command");
         builder.Property(c => c.PermissionMode).HasColumnName("permission_mode");
         builder.Property(c => c.TicketProjectId).HasColumnName("ticket_project_id");
+        builder.Property(c => c.PowerUseAllowed).HasColumnName("power_use_allowed");
     }
 }

src/ClaudeDo.Data/Configuration/ListEntityConfiguration.cs

@@ -20,8 +20,17 @@ public class ListEntityConfiguration : IEntityTypeConfiguration<ListEntity>
         builder.Property(l => l.IsManual).HasColumnName("is_manual").IsRequired().HasDefaultValue(false);
         builder.Property(l => l.FindingsTracked).HasColumnName("findings_tracked").IsRequired().HasDefaultValue(false);
         builder.Property(l => l.Icon).HasColumnName("icon");
+        builder.Property(l => l.FolderId).HasColumnName("folder_id");
 
         builder.HasIndex(l => l.SortOrder).HasDatabaseName("idx_lists_sort");
+        builder.HasIndex(l => l.FolderId).HasDatabaseName("idx_lists_folder");
+
+        // No navigation property on either side: nothing needs the graph, and a nav would have to
+        // be Include'd (or silently come back empty) in every list query.
+        builder.HasOne<ListFolderEntity>()
+            .WithMany()
+            .HasForeignKey(l => l.FolderId)
+            .OnDelete(DeleteBehavior.SetNull);
 
         builder.HasOne(l => l.Config)
             .WithOne(c => c.List)

src/ClaudeDo.Data/Configuration/ListFolderEntityConfiguration.cs

@@ -0,0 +1,23 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ClaudeDo.Data.Configuration;
+
+public class ListFolderEntityConfiguration : IEntityTypeConfiguration<ListFolderEntity>
+{
+    public void Configure(EntityTypeBuilder<ListFolderEntity> builder)
+    {
+        builder.ToTable("list_folders");
+
+        builder.HasKey(f => f.Id);
+        builder.Property(f => f.Id).HasColumnName("id");
+        builder.Property(f => f.Name).HasColumnName("name").IsRequired();
+        builder.Property(f => f.CreatedAt).HasColumnName("created_at").IsRequired();
+        builder.Property(f => f.Icon).HasColumnName("icon");
+        builder.Property(f => f.SortOrder).HasColumnName("sort_order").IsRequired().HasDefaultValue(0);
+        builder.Property(f => f.IsCollapsed).HasColumnName("is_collapsed").IsRequired().HasDefaultValue(false);
+
+        builder.HasIndex(f => f.SortOrder).HasDatabaseName("idx_list_folders_sort");
+    }
+}

src/ClaudeDo.Data/Configuration/TaskDependencyEntityConfiguration.cs

@@ -0,0 +1,32 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ClaudeDo.Data.Configuration;
+
+public class TaskDependencyEntityConfiguration : IEntityTypeConfiguration<TaskDependencyEntity>
+{
+    public void Configure(EntityTypeBuilder<TaskDependencyEntity> builder)
+    {
+        builder.ToTable("task_dependencies");
+
+        builder.HasKey(d => new { d.TaskId, d.DependsOnTaskId });
+        builder.Property(d => d.TaskId).HasColumnName("task_id");
+        builder.Property(d => d.DependsOnTaskId).HasColumnName("depends_on_task_id");
+
+        // Cascade on both sides reproduces what the old single depends_on_task_id column got from
+        // ON DELETE SET NULL: deleting the predecessor drops the edge, so the dependent becomes
+        // pickable rather than blocked forever on a task that no longer exists.
+        builder.HasOne<TaskEntity>()
+            .WithMany(t => t.Dependencies)
+            .HasForeignKey(d => d.TaskId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasOne<TaskEntity>()
+            .WithMany()
+            .HasForeignKey(d => d.DependsOnTaskId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasIndex(d => d.DependsOnTaskId).HasDatabaseName("idx_task_dependencies_depends_on");
+    }
+}

src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs

@@ -75,7 +75,6 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         builder.Property(t => t.PlanningPhase).HasColumnName("planning_phase").IsRequired()
             .HasConversion(PhaseConverter).HasDefaultValue(PlanningPhase.None);
         builder.Property(t => t.BlockedByTaskId).HasColumnName("blocked_by_task_id");
-        builder.Property(t => t.DependsOnTaskId).HasColumnName("depends_on_task_id");
         builder.Property(t => t.ScheduledFor).HasColumnName("scheduled_for");
         builder.Property(t => t.Result).HasColumnName("result");
         builder.Property(t => t.ReviewFeedback).HasColumnName("review_feedback");
@@ -97,6 +96,7 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         builder.Property(t => t.IsStarred).HasColumnName("is_starred").HasDefaultValue(false);
         builder.Property(t => t.IsMyDay).HasColumnName("is_my_day").HasDefaultValue(false);
         builder.Property(t => t.IsManual).HasColumnName("is_manual").HasDefaultValue(false);
+        builder.Property(t => t.ExpectsNoDiff).HasColumnName("expects_no_diff").HasDefaultValue(false);
         builder.Property(t => t.Notes).HasColumnName("notes");
         builder.Property(t => t.SortOrder).HasColumnName("sort_order").IsRequired().HasDefaultValue(0);
         builder.Property(t => t.SessionSkills).HasColumnName("session_skills");
@@ -123,12 +123,8 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
             .HasForeignKey(t => t.BlockedByTaskId)
             .OnDelete(DeleteBehavior.SetNull);
 
-        // DependsOn: user/MCP-declared predecessor. SetNull on delete so the dependent becomes
-        // pickable rather than blocked forever on a task that no longer exists.
-        builder.HasOne<TaskEntity>()
-            .WithMany()
-            .HasForeignKey(t => t.DependsOnTaskId)
-            .OnDelete(DeleteBehavior.SetNull);
+        // DependsOn edges live in task_dependencies (a task can declare n predecessors) —
+        // configured in TaskDependencyEntityConfiguration, which also owns the Dependencies nav.
 
         builder.HasOne(t => t.List)
             .WithMany(l => l.Tasks)
@@ -145,6 +141,5 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         builder.HasIndex(t => new { t.ListId, t.SortOrder }).HasDatabaseName("idx_tasks_list_sort");
         builder.HasIndex(t => t.ParentTaskId).HasDatabaseName("idx_tasks_parent_task_id");
         builder.HasIndex(t => t.BlockedByTaskId).HasDatabaseName("idx_tasks_blocked_by");
-        builder.HasIndex(t => t.DependsOnTaskId).HasDatabaseName("idx_tasks_depends_on");
     }
 }

src/ClaudeDo.Data/Git/GitService.cs

@@ -25,7 +25,16 @@ public sealed class GitService
     {
         var (exitCode, stdout, stderr) = await RunGitAsync(dir, ["rev-parse", "HEAD"], ct);
         if (exitCode != 0)
+        {
+            // Unborn HEAD (fresh `git init`, no commits) — the raw git stderr ("ambiguous
+            // argument 'HEAD'") is useless to a user; call sites should have run
+            // EnsureHeadCommitAsync, this message is the safety net for any that didn't.
+            if (stderr.Contains("ambiguous argument 'HEAD'", StringComparison.Ordinal) ||
+                stderr.Contains("unknown revision", StringComparison.Ordinal))
+                throw new InvalidOperationException(
+                    $"The repository at {dir} has no commits yet (unborn or broken HEAD) — ClaudeDo needs at least one commit to work in it.");
             throw new InvalidOperationException($"git rev-parse HEAD failed (exit {exitCode}): {stderr}");
+        }
         return stdout.Trim();
     }
 
@@ -55,6 +64,67 @@ public sealed class GitService
         return exitCode == 0 ? stdout.Trim() : null;
     }
 
+    /// <summary>HEAD resolves to a commit (false for a fresh `git init` repo or a broken HEAD).</summary>
+    public async Task<bool> HasHeadCommitAsync(string dir, CancellationToken ct = default)
+    {
+        // ^{commit} forces the object to actually exist and be a commit — a bare
+        // `--verify HEAD` happily accepts a detached HEAD pointing at a missing object.
+        var (exitCode, _, _) = await RunGitAsync(dir, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], ct);
+        return exitCode == 0;
+    }
+
+    private const string FallbackUserName = "ClaudeDo";
+    private const string FallbackUserEmail = "claudedo@local";
+
+    // Two parallel task starts on the same empty repo must create exactly one initial commit.
+    private static readonly SemaphoreSlim BootstrapGate = new(1, 1);
+
+    /// <summary>
+    /// Guarantees HEAD resolves to a commit so worktrees can be created. A repo with an
+    /// unborn HEAD (fresh `git init`) gets an empty initial commit built from plumbing only
+    /// (hash-object/commit-tree/update-ref) — the user's index and working tree are never
+    /// touched, so staged and untracked files stay exactly as they were. Identity is passed
+    /// inline, so this also works on machines with no git identity configured. A repo whose
+    /// HEAD is broken (not a symbolic ref and not resolvable) throws instead of guessing.
+    /// </summary>
+    /// <returns>true if a bootstrap commit was created; false if HEAD already resolved.</returns>
+    public async Task<bool> EnsureHeadCommitAsync(string dir, CancellationToken ct = default)
+    {
+        if (await HasHeadCommitAsync(dir, ct)) return false;
+
+        var (symExit, symRef, _) = await RunGitAsync(dir, ["symbolic-ref", "--quiet", "HEAD"], ct);
+        if (symExit != 0)
+            throw new InvalidOperationException(
+                $"The repository at {dir} has a broken HEAD (detached onto a missing commit, or a corrupt .git/HEAD). Repair the repository manually.");
+
+        await BootstrapGate.WaitAsync(ct);
+        try
+        {
+            if (await HasHeadCommitAsync(dir, ct)) return false;
+
+            var (treeExit, treeSha, treeErr) = await RunGitAsync(dir, ["mktree"], ct, stdinData: "");
+            if (treeExit != 0)
+                throw new InvalidOperationException($"git mktree failed (exit {treeExit}): {treeErr}");
+
+            var (commitExit, commitSha, commitErr) = await RunGitAsync(dir,
+                ["-c", $"user.name={FallbackUserName}", "-c", $"user.email={FallbackUserEmail}",
+                 "commit-tree", treeSha.Trim(), "-m", "chore: initialize repository (ClaudeDo)"], ct);
+            if (commitExit != 0)
+                throw new InvalidOperationException($"git commit-tree failed (exit {commitExit}): {commitErr}");
+
+            var (refExit, _, refErr) = await RunGitAsync(dir,
+                ["update-ref", symRef.Trim(), commitSha.Trim()], ct);
+            if (refExit != 0)
+                throw new InvalidOperationException($"git update-ref failed (exit {refExit}): {refErr}");
+
+            return true;
+        }
+        finally
+        {
+            BootstrapGate.Release();
+        }
+    }
+
     public async Task WorktreeAddAsync(string repoDir, string branchName, string worktreePath, string baseCommit, CancellationToken ct = default)
     {
         await WorktreeAddGate.WaitAsync(ct);
@@ -135,10 +205,24 @@ public sealed class GitService
     {
         // Use -F - (read message from stdin) to handle multi-line messages safely.
         var (exitCode, _, stderr) = await RunGitAsync(worktreePath, ["commit", "-F", "-"], ct, stdinData: message);
+        if (exitCode != 0 && IsMissingIdentityError(stderr))
+        {
+            // A machine without git identity configured must not fail every auto-commit —
+            // retry once as ClaudeDo. The happy path pays no preflight cost.
+            (exitCode, _, stderr) = await RunGitAsync(worktreePath,
+                ["-c", $"user.name={FallbackUserName}", "-c", $"user.email={FallbackUserEmail}",
+                 "commit", "-F", "-"], ct, stdinData: message);
+        }
         if (exitCode != 0)
             throw new InvalidOperationException($"git commit failed (exit {exitCode}): {stderr}");
     }
 
+    private static bool IsMissingIdentityError(string stderr) =>
+        stderr.Contains("tell me who you are", StringComparison.OrdinalIgnoreCase) ||
+        stderr.Contains("empty ident", StringComparison.OrdinalIgnoreCase) ||
+        stderr.Contains("no email was given", StringComparison.OrdinalIgnoreCase) ||
+        stderr.Contains("unable to auto-detect email address", StringComparison.OrdinalIgnoreCase);
+
     public async Task<string> GetDiffAsync(
         string worktreePath, IReadOnlyList<string>? paths = null, CancellationToken ct = default)
     {
@@ -254,6 +338,38 @@ public sealed class GitService
         return paths;
     }
 
+    /// <summary>All git-registered worktrees for <paramref name="repoDir"/>, with their branch (short name, null if detached).</summary>
+    public async Task<List<(string Path, string? Branch)>> ListWorktreesAsync(string repoDir, CancellationToken ct = default)
+    {
+        var (exitCode, stdout, _) = await RunGitAsync(repoDir, ["worktree", "list", "--porcelain"], ct);
+        if (exitCode != 0) return new();
+
+        var result = new List<(string Path, string? Branch)>();
+        string? currentPath = null;
+        string? currentBranch = null;
+        foreach (var raw in stdout.Split('\n'))
+        {
+            var line = raw.TrimEnd('\r');
+            if (line.StartsWith("worktree ", StringComparison.Ordinal))
+            {
+                currentPath = line["worktree ".Length..].Trim();
+            }
+            else if (line.StartsWith("branch ", StringComparison.Ordinal))
+            {
+                var b = line["branch ".Length..].Trim();
+                currentBranch = b.StartsWith("refs/heads/", StringComparison.Ordinal) ? b["refs/heads/".Length..] : b;
+            }
+            else if (string.IsNullOrWhiteSpace(line))
+            {
+                if (currentPath is not null) result.Add((currentPath, currentBranch));
+                currentPath = null;
+                currentBranch = null;
+            }
+        }
+        if (currentPath is not null) result.Add((currentPath, currentBranch));
+        return result;
+    }
+
     public async Task WorktreePruneAsync(string repoDir, CancellationToken ct = default)
     {
         var (exitCode, _, stderr) = await RunGitAsync(repoDir, ["worktree", "prune"], ct);
@@ -308,14 +424,22 @@ public sealed class GitService
         return File.Exists(Path.Combine(gitDir, "MERGE_HEAD"));
     }
 
+    /// <param name="autostash">Stash the target working tree's uncommitted changes before the
+    /// merge and restore them after it. Git owns the bookkeeping: on a conflict the stash stays
+    /// pending and is re-applied by `merge --continue`/`--abort`, so a conflicted merge left in
+    /// the tree doesn't lose it. A restore that itself conflicts leaves the stash in
+    /// `git stash list` rather than dropping it.</param>
     public async Task<(int ExitCode, string Stderr)> MergeNoFfAsync(
-        string repoDir, string sourceBranch, string message, CancellationToken ct = default)
+        string repoDir, string sourceBranch, string message, CancellationToken ct = default,
+        bool autostash = false)
     {
         // diff3 conflict style writes the merge base (|||||||) into conflict markers so the
         // in-app resolver can show a true three-way view. It only enriches conflicted hunks;
         // clean merges are unaffected.
-        var (exitCode, _, stderr) = await RunGitAsync(repoDir,
-            ["-c", "merge.conflictStyle=diff3", "merge", "--no-ff", "-m", message, sourceBranch], ct);
+        string[] args = autostash
+            ? ["-c", "merge.conflictStyle=diff3", "merge", "--no-ff", "--autostash", "-m", message, sourceBranch]
+            : ["-c", "merge.conflictStyle=diff3", "merge", "--no-ff", "-m", message, sourceBranch];
+        var (exitCode, _, stderr) = await RunGitAsync(repoDir, args, ct);
         return (exitCode, stderr);
     }
 
@@ -434,6 +558,16 @@ public sealed class GitService
         return exitCode == 0 ? stdout : null;
     }
 
+    /// <summary>
+    /// Content of <paramref name="path"/> at <paramref name="revision"/> via `git show revision:path`.
+    /// Null when the path doesn't exist at that revision (new, deleted, or renamed file).
+    /// </summary>
+    public async Task<string?> ShowFileAsync(string repoDir, string revision, string path, CancellationToken ct = default)
+    {
+        var (exitCode, stdout, _) = await RunGitAsync(repoDir, ["show", $"{revision}:{path}"], ct, trimOutput: false);
+        return exitCode == 0 ? stdout : null;
+    }
+
     /// <summary>
     /// Non-destructive mergeability probe via `git merge-tree --write-tree`. Writes only
     /// loose objects — the working tree, index, and refs are left untouched.
@@ -584,8 +718,15 @@ public sealed class GitService
             CreateNoWindow = true,
             StandardOutputEncoding = Encoding.UTF8,
             StandardErrorEncoding = Encoding.UTF8,
-            StandardInputEncoding = stdinData is not null ? Encoding.UTF8 : null,
+            // BOM-less: Encoding.UTF8 writes a BOM preamble, which git rejects as input
+            // (mktree "input format error") and would prepend to stdin commit messages.
+            StandardInputEncoding = stdinData is not null ? new UTF8Encoding(false) : null,
         };
+        // Force English stderr/stdout so the English-only substring matches below
+        // (e.g. "ambiguous argument 'HEAD'", "tell me who you are") work regardless
+        // of the OS locale git for Windows picks up.
+        psi.Environment["LC_ALL"] = "C";
+        psi.Environment["LANGUAGE"] = "C";
         psi.ArgumentList.Add("-C");
         psi.ArgumentList.Add(workDir);
         foreach (var a in args) psi.ArgumentList.Add(a);

src/ClaudeDo.Data/Migrations/20260828185839_AddDailyNoteFromAgent.Designer.cs

@@ -0,0 +1,982 @@
+// <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("20260828185839_AddDailyNoteFromAgent")]
+    partial class AddDailyNoteFromAgent
+    {
+        /// <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<bool>("AutoContinueOnUsageLimit")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("auto_continue_on_usage_limit");
+
+                    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(40)
+                        .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<int>("MaxTurnsCeiling")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(80)
+                        .HasColumnName("max_turns_ceiling");
+
+                    b.Property<string>("ModelPresets")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model_presets");
+
+                    b.Property<int>("NextTaskNumber")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1)
+                        .HasColumnName("next_task_number");
+
+                    b.Property<string>("RepoImportFolders")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("repo_import_folders");
+
+                    b.Property<string>("ReportExcludedPaths")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("report_excluded_paths");
+
+                    b.Property<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    b.Property<int>("StandupWeekday")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(3)
+                        .HasColumnName("standup_weekday");
+
+                    b.Property<int>("UsageGateFiveHourPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(80)
+                        .HasColumnName("usage_gate_five_hour_pct");
+
+                    b.Property<int>("UsageGateSevenDayPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(90)
+                        .HasColumnName("usage_gate_seven_day_pct");
+
+                    b.Property<int>("UsageThrottleFiveHourHardPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(65)
+                        .HasColumnName("usage_throttle_five_hour_hard_pct");
+
+                    b.Property<int>("UsageThrottleFiveHourSoftPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(50)
+                        .HasColumnName("usage_throttle_five_hour_soft_pct");
+
+                    b.Property<int>("UsageThrottleSevenDayHardPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(65)
+                        .HasColumnName("usage_throttle_seven_day_hard_pct");
+
+                    b.Property<int>("UsageThrottleSevenDaySoftPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(50)
+                        .HasColumnName("usage_throttle_seven_day_soft_pct");
+
+                    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,
+                            AutoContinueOnUsageLimit = false,
+                            DailyPrepMaxTasks = 5,
+                            DefaultClaudeInstructions = "",
+                            DefaultMaxTurns = 40,
+                            DefaultModel = "sonnet",
+                            DefaultPermissionMode = "auto",
+                            MaxParallelExecutions = 1,
+                            MaxTurnsCeiling = 80,
+                            NextTaskNumber = 1,
+                            StandupWeekday = 3,
+                            UsageGateFiveHourPct = 80,
+                            UsageGateSevenDayPct = 90,
+                            UsageThrottleFiveHourHardPct = 65,
+                            UsageThrottleFiveHourSoftPct = 50,
+                            UsageThrottleSevenDayHardPct = 65,
+                            UsageThrottleSevenDaySoftPct = 50,
+                            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<bool>("FromAgent")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("from_agent");
+
+                    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>("PermissionMode")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("permission_mode");
+
+                    b.Property<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.Property<int?>("TicketProjectId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ticket_project_id");
+
+                    b.Property<string>("VerifyCommand")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("verify_command");
+
+                    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<bool>("FindingsTracked")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("findings_tracked");
+
+                    b.Property<string>("Icon")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("icon");
+
+                    b.Property<bool>("IsManual")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_manual");
+
+                    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<string>("Kind")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("ping")
+                        .HasColumnName("action_kind");
+
+                    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.SessionSkillEntity", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<DateTimeOffset>("AddedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("added_at");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<string>("PinnedRef")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("pinned_ref");
+
+                    b.Property<string>("SourceUrl")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("source_url");
+
+                    b.Property<string>("Subpath")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("subpath");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("session_skills", (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>("DependsOnTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("depends_on_task_id");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<int?>("FailureMaxTurns")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("failure_max_turns");
+
+                    b.Property<string>("FailureReason")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("failure_reason");
+
+                    b.Property<int?>("FailureTurnsUsed")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("failure_turns_used");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<string>("HandlerBaseCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("handler_base_commit");
+
+                    b.Property<string>("HandlerHeadCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("handler_head_commit");
+
+                    b.Property<string>("InteractiveSessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("interactive_session_id");
+
+                    b.Property<bool>("IsManual")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_manual");
+
+                    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<int>("Number")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("number");
+
+                    b.Property<string>("ParentTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("parent_task_id");
+
+                    b.Property<string>("PermissionMode")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("permission_mode");
+
+                    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<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    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>("TicketRef")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ticket_ref");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.Property<DateTime?>("UsageLimitAutoContinuedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("usage_limit_auto_continued_at");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockedByTaskId")
+                        .HasDatabaseName("idx_tasks_blocked_by");
+
+                    b.HasIndex("DependsOnTaskId")
+                        .HasDatabaseName("idx_tasks_depends_on");
+
+                    b.HasIndex("ListId")
+                        .HasDatabaseName("idx_tasks_list_id");
+
+                    b.HasIndex("Number")
+                        .IsUnique()
+                        .HasDatabaseName("idx_tasks_number");
+
+                    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<int?>("CacheReadTokens")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cache_read_tokens");
+
+                    b.Property<int?>("CacheWriteTokens")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cache_write_tokens");
+
+                    b.Property<string>("ErrorMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("error_markdown");
+
+                    b.Property<string>("Errors")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("errors");
+
+                    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>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("Prompt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt");
+
+                    b.Property<string>("ResultMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result_markdown");
+
+                    b.Property<string>("ResultSubtype")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result_subtype");
+
+                    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<string>("TerminalReason")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("terminal_reason");
+
+                    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>("MergeCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("merge_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.TaskEntity", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnTaskId")
+                        .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/20260828185839_AddDailyNoteFromAgent.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddDailyNoteFromAgent : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "from_agent",
+                table: "daily_notes",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "from_agent",
+                table: "daily_notes");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260902102003_AddExpectsNoDiff.Designer.cs

@@ -0,0 +1,988 @@
+// <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("20260902102003_AddExpectsNoDiff")]
+    partial class AddExpectsNoDiff
+    {
+        /// <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<bool>("AutoContinueOnUsageLimit")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("auto_continue_on_usage_limit");
+
+                    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(40)
+                        .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<int>("MaxTurnsCeiling")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(80)
+                        .HasColumnName("max_turns_ceiling");
+
+                    b.Property<string>("ModelPresets")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model_presets");
+
+                    b.Property<int>("NextTaskNumber")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1)
+                        .HasColumnName("next_task_number");
+
+                    b.Property<string>("RepoImportFolders")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("repo_import_folders");
+
+                    b.Property<string>("ReportExcludedPaths")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("report_excluded_paths");
+
+                    b.Property<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    b.Property<int>("StandupWeekday")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(3)
+                        .HasColumnName("standup_weekday");
+
+                    b.Property<int>("UsageGateFiveHourPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(80)
+                        .HasColumnName("usage_gate_five_hour_pct");
+
+                    b.Property<int>("UsageGateSevenDayPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(90)
+                        .HasColumnName("usage_gate_seven_day_pct");
+
+                    b.Property<int>("UsageThrottleFiveHourHardPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(65)
+                        .HasColumnName("usage_throttle_five_hour_hard_pct");
+
+                    b.Property<int>("UsageThrottleFiveHourSoftPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(50)
+                        .HasColumnName("usage_throttle_five_hour_soft_pct");
+
+                    b.Property<int>("UsageThrottleSevenDayHardPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(65)
+                        .HasColumnName("usage_throttle_seven_day_hard_pct");
+
+                    b.Property<int>("UsageThrottleSevenDaySoftPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(50)
+                        .HasColumnName("usage_throttle_seven_day_soft_pct");
+
+                    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,
+                            AutoContinueOnUsageLimit = false,
+                            DailyPrepMaxTasks = 5,
+                            DefaultClaudeInstructions = "",
+                            DefaultMaxTurns = 40,
+                            DefaultModel = "sonnet",
+                            DefaultPermissionMode = "auto",
+                            MaxParallelExecutions = 1,
+                            MaxTurnsCeiling = 80,
+                            NextTaskNumber = 1,
+                            StandupWeekday = 3,
+                            UsageGateFiveHourPct = 80,
+                            UsageGateSevenDayPct = 90,
+                            UsageThrottleFiveHourHardPct = 65,
+                            UsageThrottleFiveHourSoftPct = 50,
+                            UsageThrottleSevenDayHardPct = 65,
+                            UsageThrottleSevenDaySoftPct = 50,
+                            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<bool>("FromAgent")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("from_agent");
+
+                    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>("PermissionMode")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("permission_mode");
+
+                    b.Property<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.Property<int?>("TicketProjectId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ticket_project_id");
+
+                    b.Property<string>("VerifyCommand")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("verify_command");
+
+                    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<bool>("FindingsTracked")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("findings_tracked");
+
+                    b.Property<string>("Icon")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("icon");
+
+                    b.Property<bool>("IsManual")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_manual");
+
+                    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<string>("Kind")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("ping")
+                        .HasColumnName("action_kind");
+
+                    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.SessionSkillEntity", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<DateTimeOffset>("AddedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("added_at");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<string>("PinnedRef")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("pinned_ref");
+
+                    b.Property<string>("SourceUrl")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("source_url");
+
+                    b.Property<string>("Subpath")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("subpath");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("session_skills", (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>("DependsOnTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("depends_on_task_id");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<bool>("ExpectsNoDiff")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("expects_no_diff");
+
+                    b.Property<int?>("FailureMaxTurns")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("failure_max_turns");
+
+                    b.Property<string>("FailureReason")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("failure_reason");
+
+                    b.Property<int?>("FailureTurnsUsed")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("failure_turns_used");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<string>("HandlerBaseCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("handler_base_commit");
+
+                    b.Property<string>("HandlerHeadCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("handler_head_commit");
+
+                    b.Property<string>("InteractiveSessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("interactive_session_id");
+
+                    b.Property<bool>("IsManual")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_manual");
+
+                    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<int>("Number")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("number");
+
+                    b.Property<string>("ParentTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("parent_task_id");
+
+                    b.Property<string>("PermissionMode")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("permission_mode");
+
+                    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<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    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>("TicketRef")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ticket_ref");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.Property<DateTime?>("UsageLimitAutoContinuedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("usage_limit_auto_continued_at");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockedByTaskId")
+                        .HasDatabaseName("idx_tasks_blocked_by");
+
+                    b.HasIndex("DependsOnTaskId")
+                        .HasDatabaseName("idx_tasks_depends_on");
+
+                    b.HasIndex("ListId")
+                        .HasDatabaseName("idx_tasks_list_id");
+
+                    b.HasIndex("Number")
+                        .IsUnique()
+                        .HasDatabaseName("idx_tasks_number");
+
+                    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<int?>("CacheReadTokens")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cache_read_tokens");
+
+                    b.Property<int?>("CacheWriteTokens")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cache_write_tokens");
+
+                    b.Property<string>("ErrorMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("error_markdown");
+
+                    b.Property<string>("Errors")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("errors");
+
+                    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>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("Prompt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt");
+
+                    b.Property<string>("ResultMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result_markdown");
+
+                    b.Property<string>("ResultSubtype")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result_subtype");
+
+                    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<string>("TerminalReason")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("terminal_reason");
+
+                    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>("MergeCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("merge_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.TaskEntity", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnTaskId")
+                        .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/20260902102003_AddExpectsNoDiff.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddExpectsNoDiff : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "expects_no_diff",
+                table: "tasks",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "expects_no_diff",
+                table: "tasks");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260902121712_AddTaskDependencies.cs

@@ -0,0 +1,104 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <summary>
+    /// Turns the single <c>tasks.depends_on_task_id</c> column into a set: one row per declared
+    /// "run after" edge in <c>task_dependencies</c>. Hand-edited after scaffolding so the data copy
+    /// sits between CreateTable and DropColumn — the scaffolded order dropped the column first and
+    /// would have discarded every existing link.
+    /// </summary>
+    public partial class AddTaskDependencies : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "task_dependencies",
+                columns: table => new
+                {
+                    task_id = table.Column<string>(type: "TEXT", nullable: false),
+                    depends_on_task_id = table.Column<string>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_task_dependencies", x => new { x.task_id, x.depends_on_task_id });
+                    table.ForeignKey(
+                        name: "FK_task_dependencies_tasks_depends_on_task_id",
+                        column: x => x.depends_on_task_id,
+                        principalTable: "tasks",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_task_dependencies_tasks_task_id",
+                        column: x => x.task_id,
+                        principalTable: "tasks",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "idx_task_dependencies_depends_on",
+                table: "task_dependencies",
+                column: "depends_on_task_id");
+
+            // Every existing link becomes a one-element set. The old FK was ON DELETE SET NULL, so
+            // a surviving value always points at an existing task and can't violate the new FK.
+            migrationBuilder.Sql("""
+                INSERT INTO task_dependencies (task_id, depends_on_task_id)
+                SELECT id, depends_on_task_id FROM tasks WHERE depends_on_task_id IS NOT NULL
+                """);
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_tasks_tasks_depends_on_task_id",
+                table: "tasks");
+
+            migrationBuilder.DropIndex(
+                name: "idx_tasks_depends_on",
+                table: "tasks");
+
+            migrationBuilder.DropColumn(
+                name: "depends_on_task_id",
+                table: "tasks");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "depends_on_task_id",
+                table: "tasks",
+                type: "TEXT",
+                nullable: true);
+
+            // Inherently lossy: a task with several predecessors keeps only one. There is no
+            // single-column shape that could hold the rest.
+            migrationBuilder.Sql("""
+                UPDATE tasks SET depends_on_task_id = (
+                    SELECT td.depends_on_task_id FROM task_dependencies td
+                    WHERE td.task_id = tasks.id
+                    ORDER BY td.depends_on_task_id
+                    LIMIT 1
+                )
+                """);
+
+            migrationBuilder.DropTable(
+                name: "task_dependencies");
+
+            migrationBuilder.CreateIndex(
+                name: "idx_tasks_depends_on",
+                table: "tasks",
+                column: "depends_on_task_id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_tasks_tasks_depends_on_task_id",
+                table: "tasks",
+                column: "depends_on_task_id",
+                principalTable: "tasks",
+                principalColumn: "id",
+                onDelete: ReferentialAction.SetNull);
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260902121816_AddPowerUse.cs

@@ -0,0 +1,58 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPowerUse : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "power_use_allowed",
+                table: "list_config",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<int>(
+                name: "list_handler_max_handoffs",
+                table: "app_settings",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 4);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "power_use_enabled",
+                table: "app_settings",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.UpdateData(
+                table: "app_settings",
+                keyColumn: "id",
+                keyValue: 1,
+                column: "list_handler_max_handoffs",
+                value: 4);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "power_use_allowed",
+                table: "list_config");
+
+            migrationBuilder.DropColumn(
+                name: "list_handler_max_handoffs",
+                table: "app_settings");
+
+            migrationBuilder.DropColumn(
+                name: "power_use_enabled",
+                table: "app_settings");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260902170501_AddPowerUseWindow.cs

@@ -0,0 +1,56 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPowerUseWindow : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "power_use_handoff_pct",
+                table: "app_settings",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 95);
+
+            migrationBuilder.AddColumn<string>(
+                name: "power_use_window_end",
+                table: "app_settings",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "power_use_window_start",
+                table: "app_settings",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.UpdateData(
+                table: "app_settings",
+                keyColumn: "id",
+                keyValue: 1,
+                columns: new[] { "power_use_handoff_pct", "power_use_window_end", "power_use_window_start" },
+                values: new object[] { 95, null, null });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "power_use_handoff_pct",
+                table: "app_settings");
+
+            migrationBuilder.DropColumn(
+                name: "power_use_window_end",
+                table: "app_settings");
+
+            migrationBuilder.DropColumn(
+                name: "power_use_window_start",
+                table: "app_settings");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260910062251_AddListFolders.cs

@@ -0,0 +1,74 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddListFolders : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "folder_id",
+                table: "lists",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "list_folders",
+                columns: table => new
+                {
+                    id = table.Column<string>(type: "TEXT", nullable: false),
+                    name = table.Column<string>(type: "TEXT", nullable: false),
+                    created_at = table.Column<DateTime>(type: "TEXT", nullable: false),
+                    icon = table.Column<string>(type: "TEXT", nullable: true),
+                    sort_order = table.Column<int>(type: "INTEGER", nullable: false, defaultValue: 0),
+                    is_collapsed = table.Column<bool>(type: "INTEGER", nullable: false, defaultValue: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_list_folders", x => x.id);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "idx_lists_folder",
+                table: "lists",
+                column: "folder_id");
+
+            migrationBuilder.CreateIndex(
+                name: "idx_list_folders_sort",
+                table: "list_folders",
+                column: "sort_order");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_lists_list_folders_folder_id",
+                table: "lists",
+                column: "folder_id",
+                principalTable: "list_folders",
+                principalColumn: "id",
+                onDelete: ReferentialAction.SetNull);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_lists_list_folders_folder_id",
+                table: "lists");
+
+            migrationBuilder.DropTable(
+                name: "list_folders");
+
+            migrationBuilder.DropIndex(
+                name: "idx_lists_folder",
+                table: "lists");
+
+            migrationBuilder.DropColumn(
+                name: "folder_id",
+                table: "lists");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/ClaudeDoDbContextModelSnapshot.cs

@@ -66,6 +66,12 @@ namespace ClaudeDo.Data.Migrations
                         .HasDefaultValue("bypassPermissions")
                         .HasColumnName("default_permission_mode");
 
+                    b.Property<int>("ListHandlerMaxHandoffs")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(4)
+                        .HasColumnName("list_handler_max_handoffs");
+
                     b.Property<int>("MaxParallelExecutions")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("INTEGER")
@@ -88,6 +94,26 @@ namespace ClaudeDo.Data.Migrations
                         .HasDefaultValue(1)
                         .HasColumnName("next_task_number");
 
+                    b.Property<bool>("PowerUseEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("power_use_enabled");
+
+                    b.Property<int>("PowerUseHandoffPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(95)
+                        .HasColumnName("power_use_handoff_pct");
+
+                    b.Property<string>("PowerUseWindowEnd")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("power_use_window_end");
+
+                    b.Property<string>("PowerUseWindowStart")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("power_use_window_start");
+
                     b.Property<string>("RepoImportFolders")
                         .HasColumnType("TEXT")
                         .HasColumnName("repo_import_folders");
@@ -175,9 +201,12 @@ namespace ClaudeDo.Data.Migrations
                             DefaultMaxTurns = 40,
                             DefaultModel = "sonnet",
                             DefaultPermissionMode = "auto",
+                            ListHandlerMaxHandoffs = 4,
                             MaxParallelExecutions = 1,
                             MaxTurnsCeiling = 80,
                             NextTaskNumber = 1,
+                            PowerUseEnabled = false,
+                            PowerUseHandoffPct = 95,
                             StandupWeekday = 3,
                             UsageGateFiveHourPct = 80,
                             UsageGateSevenDayPct = 90,
@@ -205,6 +234,10 @@ namespace ClaudeDo.Data.Migrations
                         .HasColumnType("TEXT")
                         .HasColumnName("note_date");
 
+                    b.Property<bool>("FromAgent")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("from_agent");
+
                     b.Property<int>("SortOrder")
                         .HasColumnType("INTEGER")
                         .HasColumnName("sort_order");
@@ -243,6 +276,10 @@ namespace ClaudeDo.Data.Migrations
                         .HasColumnType("TEXT")
                         .HasColumnName("permission_mode");
 
+                    b.Property<bool>("PowerUseAllowed")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("power_use_allowed");
+
                     b.Property<string>("SessionSkills")
                         .HasColumnType("TEXT")
                         .HasColumnName("session_skills");
@@ -287,6 +324,10 @@ namespace ClaudeDo.Data.Migrations
                         .HasDefaultValue(false)
                         .HasColumnName("findings_tracked");
 
+                    b.Property<string>("FolderId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("folder_id");
+
                     b.Property<string>("Icon")
                         .HasColumnType("TEXT")
                         .HasColumnName("icon");
@@ -314,12 +355,54 @@ namespace ClaudeDo.Data.Migrations
 
                     b.HasKey("Id");
 
+                    b.HasIndex("FolderId")
+                        .HasDatabaseName("idx_lists_folder");
+
                     b.HasIndex("SortOrder")
                         .HasDatabaseName("idx_lists_sort");
 
                     b.ToTable("lists", (string)null);
                 });
 
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListFolderEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("Icon")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("icon");
+
+                    b.Property<bool>("IsCollapsed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_collapsed");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SortOrder")
+                        .HasDatabaseName("idx_list_folders_sort");
+
+                    b.ToTable("list_folders", (string)null);
+                });
+
             modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
                 {
                     b.Property<Guid>("Id")
@@ -471,6 +554,24 @@ namespace ClaudeDo.Data.Migrations
                     b.ToTable("task_attachments", (string)null);
                 });
 
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskDependencyEntity", b =>
+                {
+                    b.Property<string>("TaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("DependsOnTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("depends_on_task_id");
+
+                    b.HasKey("TaskId", "DependsOnTaskId");
+
+                    b.HasIndex("DependsOnTaskId")
+                        .HasDatabaseName("idx_task_dependencies_depends_on");
+
+                    b.ToTable("task_dependencies", (string)null);
+                });
+
             modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
                 {
                     b.Property<string>("Id")
@@ -500,14 +601,16 @@ namespace ClaudeDo.Data.Migrations
                         .HasColumnType("TEXT")
                         .HasColumnName("created_by");
 
-                    b.Property<string>("DependsOnTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("depends_on_task_id");
-
                     b.Property<string>("Description")
                         .HasColumnType("TEXT")
                         .HasColumnName("description");
 
+                    b.Property<bool>("ExpectsNoDiff")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("expects_no_diff");
+
                     b.Property<int?>("FailureMaxTurns")
                         .HasColumnType("INTEGER")
                         .HasColumnName("failure_max_turns");
@@ -665,9 +768,6 @@ namespace ClaudeDo.Data.Migrations
                     b.HasIndex("BlockedByTaskId")
                         .HasDatabaseName("idx_tasks_blocked_by");
 
-                    b.HasIndex("DependsOnTaskId")
-                        .HasDatabaseName("idx_tasks_depends_on");
-
                     b.HasIndex("ListId")
                         .HasDatabaseName("idx_tasks_list_id");
 
@@ -880,6 +980,14 @@ namespace ClaudeDo.Data.Migrations
                     b.Navigation("List");
                 });
 
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.ListFolderEntity", null)
+                        .WithMany()
+                        .HasForeignKey("FolderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+                });
+
             modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
                 {
                     b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
@@ -902,6 +1010,21 @@ namespace ClaudeDo.Data.Migrations
                     b.Navigation("Task");
                 });
 
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskDependencyEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnTaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
+                        .WithMany("Dependencies")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
                 {
                     b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
@@ -909,11 +1032,6 @@ namespace ClaudeDo.Data.Migrations
                         .HasForeignKey("BlockedByTaskId")
                         .OnDelete(DeleteBehavior.SetNull);
 
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("DependsOnTaskId")
-                        .OnDelete(DeleteBehavior.SetNull);
-
                     b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
                         .WithMany("Tasks")
                         .HasForeignKey("ListId")
@@ -963,6 +1081,8 @@ namespace ClaudeDo.Data.Migrations
                 {
                     b.Navigation("Children");
 
+                    b.Navigation("Dependencies");
+
                     b.Navigation("Runs");
 
                     b.Navigation("Subtasks");

src/ClaudeDo.Data/Models/AppSettingsEntity.cs

@@ -60,4 +60,27 @@ public sealed class AppSettingsEntity
     // automatic ContinueTask once the 5h window resets, and the gate-blocked queue wakes exactly
     // at that reset time instead of only on the 30s backstop.
     public bool AutoContinueOnUsageLimit { get; set; }
+
+    // Master switch for PowerUse: list-handler runs go unattended (never ask the user) and harvest
+    // new work when a round would otherwise starve. Toggled in Settings → Execution. Off by default,
+    // and on its own it changes nothing — a run is only in PowerUse when the LIST also opted in via
+    // ListConfigEntity.PowerUseAllowed, so leaving this on cannot make an unrelated list's handler
+    // run unattended. Composition lives in InteractiveLaunchSpecService.
+    public bool PowerUseEnabled { get; set; }
+
+    // Optional local-time window (both `HH:mm`) narrowing when PowerUse applies, checked per phase
+    // at prompt-build time. Both null (the default) = round the clock, byte-identical to the
+    // pre-window behaviour; only one set counts as unset too. End before start wraps over midnight.
+    // Semantics live in PowerUseWindow.
+    public string? PowerUseWindowStart { get; set; }
+    public string? PowerUseWindowEnd { get; set; }
+
+    // Percentage of the 5h usage window at which a PowerUse handler session is told to hand off
+    // rather than start more work. Stored and displayed here; the consumer is the handoff prompt.
+    public int PowerUseHandoffPct { get; set; } = 95;
+
+    // Server-side cap on a list-handler run's wait<->merge handoff chain (HandoffRoundTracker).
+    // 4 = two full wait/merge cycles, the long-standing default. Raise it for a run meant to keep
+    // going for hours. It exists to bound runaway handoff loops, so it must stay >= 1.
+    public int ListHandlerMaxHandoffs { get; set; } = 4;
 }

src/ClaudeDo.Data/Models/DailyNoteEntity.cs

@@ -6,5 +6,9 @@ public sealed class DailyNoteEntity
     public DateOnly Date { get; set; }
     public string Text { get; set; } = string.Empty;
     public int SortOrder { get; set; }
+
+    /// <summary>True when an agent wrote this note through the MCP tool rather than the user.
+    /// Drives the UI marker and the per-day cap in <c>NotesMcpTools</c>.</summary>
+    public bool FromAgent { get; set; }
     public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
 }

src/ClaudeDo.Data/Models/ListConfigEntity.cs

@@ -17,6 +17,12 @@ public sealed class ListConfigEntity
     // Feld mitführen, sonst setzt es sich still zurück.
     public int? TicketProjectId { get; set; }
 
+    // Per-Liste-Opt-in für PowerUse. Ein Handler-Run läuft nur unattended, wenn BEIDES gesetzt ist:
+    // dieses Flag und AppSettingsEntity.PowerUseEnabled. Der globale Toggle bleibt damit gefahrlos
+    // an — eine Liste, die hier nicht zugestimmt hat, behält das interaktive Verhalten. Default
+    // false, also opt-in. ⚠️ Gleiche Falle wie TicketProjectId: SetConfigAsync kopiert verbatim.
+    public bool PowerUseAllowed { get; set; }
+
     // Navigation property
     public ListEntity List { get; set; } = null!;
 }

src/ClaudeDo.Data/Models/ListEntity.cs

@@ -16,6 +16,9 @@ public sealed class ListEntity
     public bool FindingsTracked { get; set; }
     // Icon key into the UI's icon library (e.g. "Star"); null = the default folder icon.
     public string? Icon { get; set; }
+    // Sidebar folder this list sits in (ListFolderEntity.Id); null = top level. ON DELETE SET NULL,
+    // so deleting a folder moves its lists back to the top level instead of deleting them.
+    public string? FolderId { get; set; }
 
     // Navigation properties
     public ListConfigEntity? Config { get; set; }

src/ClaudeDo.Data/Models/ListFolderEntity.cs

@@ -0,0 +1,20 @@
+namespace ClaudeDo.Data.Models;
+
+/// <summary>
+/// A sidebar folder grouping user lists. Deliberately its own table rather than a flag on
+/// <see cref="ListEntity"/>: every place that enumerates lists (MCP list_task_lists, "move to
+/// list", the queue picker, repo import) would otherwise have to filter folders out.
+/// One level only — a folder holds lists, never other folders.
+/// </summary>
+public sealed class ListFolderEntity
+{
+    public required string Id { get; init; }
+    public required string Name { get; set; }
+    public required DateTime CreatedAt { get; init; }
+    // Icon key into the UI's icon library, same set as ListEntity.Icon; null = default folder icon.
+    public string? Icon { get; set; }
+    public int SortOrder { get; set; }
+    // Sidebar expand/collapse state. Lives here rather than in ui.config.json because the row is
+    // already being read for the folder itself.
+    public bool IsCollapsed { get; set; }
+}

src/ClaudeDo.Data/Models/PowerUseWindow.cs

@@ -0,0 +1,32 @@
+namespace ClaudeDo.Data.Models;
+
+/// <summary>
+/// The optional local-time window restricting when PowerUse applies
+/// (<see cref="AppSettingsEntity.PowerUseWindowStart"/> / <c>End</c>, both <c>HH:mm</c>).
+/// Pure on purpose — the caller supplies "now", so the window logic is testable without a clock.
+/// </summary>
+public static class PowerUseWindow
+{
+    /// <summary>Parses an <c>HH:mm</c> string; anything else (including null/blank) is null.</summary>
+    public static TimeOnly? Parse(string? value)
+        => TimeOnly.TryParseExact(value?.Trim(), "HH:mm", out var t) ? t : null;
+
+    /// <summary>Round-trips a stored/typed value through <see cref="Parse"/>, so an unparseable
+    /// string is stored as null instead of sitting in the column pretending to be a window.</summary>
+    public static string? Normalize(string? value) => Parse(value)?.ToString("HH:mm");
+
+    /// <summary>
+    /// True when <paramref name="now"/> falls inside the window. Half-open: start is included,
+    /// end is not. Either bound missing = no window at all = always true (the pre-window
+    /// behaviour). A window whose end is before its start wraps over midnight.
+    /// </summary>
+    public static bool Contains(TimeOnly now, TimeOnly? start, TimeOnly? end)
+    {
+        if (start is not { } from || end is not { } to) return true;
+        return from < to ? now >= from && now < to : now >= from || now < to;
+    }
+
+    /// <summary>Convenience overload for the two stored strings and a wall clock.</summary>
+    public static bool IsOpen(DateTime now, string? start, string? end)
+        => Contains(TimeOnly.FromDateTime(now), Parse(start), Parse(end));
+}

src/ClaudeDo.Data/Models/TaskDependencyEntity.cs

@@ -0,0 +1,13 @@
+namespace ClaudeDo.Data.Models;
+
+/// <summary>
+/// One declared "task must run after task" edge. A task can carry n of them; the queue picker
+/// claims it only once every predecessor reached <see cref="TaskStatus.Done"/>.
+/// Deliberately separate from <see cref="TaskEntity.BlockedByTaskId"/>, the planning chain's own
+/// internal single link — see ClaudeDo.Worker/CLAUDE.md → Status Model.
+/// </summary>
+public sealed class TaskDependencyEntity
+{
+    public required string TaskId { get; init; }
+    public required string DependsOnTaskId { get; init; }
+}

src/ClaudeDo.Data/Models/TaskEntity.cs

@@ -1,3 +1,5 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
 namespace ClaudeDo.Data.Models;
 
 public enum TaskStatus
@@ -33,12 +35,17 @@ public sealed class TaskEntity
     public PlanningPhase PlanningPhase { get; set; } = PlanningPhase.None;
     public string? BlockedByTaskId { get; set; }
 
-    // A user/MCP-declared predecessor, distinct from BlockedByTaskId (the planning chain's own
-    // internal link): the picker also skips a Queued task while this is set and the referenced
-    // task's Status isn't Done. Unlike the chain, a Failed/Cancelled dependency does NOT cascade
-    // or auto-resolve -- the dependent just stays blocked and reports why (see TaskStateService.
-    // SetDependsOnAsync and QueuePicker).
-    public string? DependsOnTaskId { get; set; }
+    // User/MCP-declared predecessors, distinct from BlockedByTaskId (the planning chain's own
+    // internal link): the picker skips a Queued task until EVERY predecessor reached Done.
+    // Unlike the chain, a Failed/Cancelled dependency does NOT cascade or auto-resolve -- the
+    // dependent just stays blocked and reports why (see TaskStateService.SetDependsOnAsync and
+    // QueuePicker). Only loaded where a read path Includes it; the picker gates in raw SQL and
+    // never relies on this collection.
+    public ICollection<TaskDependencyEntity> Dependencies { get; set; } = new List<TaskDependencyEntity>();
+
+    [NotMapped]
+    public IReadOnlyList<string> DependsOnTaskIds =>
+        Dependencies.Select(d => d.DependsOnTaskId).ToList();
     public DateTime? ScheduledFor { get; set; }
     public string? Result { get; set; }
     public string? ReviewFeedback { get; set; }
@@ -71,6 +78,10 @@ public sealed class TaskEntity
     // list handler) and the Claude affordances are hidden; a hand-driven ConPTY session is still
     // allowed. New tasks in a manual list default to true.
     public bool IsManual { get; set; }
+    // Set on verification/audit/research tasks whose correct outcome is an empty diff (e.g. "build
+    // and test, don't change code"). Lets the merge-helper session tell that apart from a task that
+    // silently failed to commit -- both look identical to preview_merge_set otherwise.
+    public bool ExpectsNoDiff { get; set; }
     public string? Notes { get; set; }
     public int SortOrder { get; set; }
     public string? SessionSkills { get; set; }

src/ClaudeDo.Data/PromptFiles.cs

@@ -5,7 +5,7 @@ using System.Text.RegularExpressions;
 
 namespace ClaudeDo.Data;
 
-public enum PromptKind { System, Planning, PlanningInitial, Retry, DailyPrep, WeeklyReport, ImprovementChild, Refine, MergeHelperTriage, MergeHelperWait, MergeHelperMerge, MergeHelperInitial, MergeHelperHandoff }
+public enum PromptKind { System, Planning, PlanningInitial, Retry, DailyPrep, WeeklyReport, ImprovementChild, Refine, MergeHelperTriage, MergeHelperWait, MergeHelperMerge, MergeHelperInitial, MergeHelperHandoff, PowerUseAddendum }
 
 /// <summary>
 /// How a prompt kind's on-disk override (if any) relates to the bundled default.
@@ -44,6 +44,7 @@ public static class PromptFiles
         PromptKind.MergeHelperMerge => "merge-helper-merge.md",
         PromptKind.MergeHelperInitial => "merge-helper-initial.md",
         PromptKind.MergeHelperHandoff => "merge-helper-handoff.md",
+        PromptKind.PowerUseAddendum => "power-use.md",
         _ => throw new ArgumentOutOfRangeException(nameof(kind))
     };
 
@@ -221,6 +222,7 @@ public static class PromptFiles
         PromptKind.MergeHelperMerge => MergeHelperMergeDefault,
         PromptKind.MergeHelperInitial => MergeHelperInitialDefault,
         PromptKind.MergeHelperHandoff => MergeHelperHandoffDefault,
+        PromptKind.PowerUseAddendum => PowerUseAddendumDefault,
         _ => ""
     };
 
@@ -448,6 +450,15 @@ public static class PromptFiles
 
         Cancel nothing without an explicit answer.
 
+        ## Phase 1.5 — Audit dependencies
+        For every surviving task that carries a dependsOnTaskId, decide whether the link is real or artificial before you hand off. Real: task B genuinely needs something task A produces — a symbol/type B's code references, a changed signature, a migration that must land before repository code assumes it. Artificial: the tasks just got numbered in sequence by the plan but touch disjoint files for unrelated reasons. Task descriptions usually name their target files explicitly — use that to check for real file/symbol overlap instead of trusting the order.
+
+        Resolve every artificial link with update_task(taskId, dependsOnTaskId="") — a chain numbered 1→2→3→... is the default shape to suspect, not the default shape to trust.
+
+        Group what's left into waves: batches that can run in parallel, where a later wave depends only on tasks in an earlier one. Report this as a wave plan (e.g. "[3] → [4,5,6] → [7]"), not a flat list — the Wait/Merge sessions after you need the batching, not just which ids survived.
+
+        Then check the wave count against the handoff cap. This list-handler chain allows a limited number of handoffs (wait, merge, wait_final, merge_final) — by default 4, i.e. exactly two merge rounds, but it is configurable and may be higher for this run. Assume two rounds unless the kickoff tells you otherwise. If your wave plan needs more rounds than that to clear, say so explicitly when you hand off — name which waves won't fit — so the Merge session ends by telling the user "the rest needs manual approval in the UI" instead of silently stranding mid-chain.
+
         ## Phase 2 — Enhance for execution
         Before touching any task, check the list's verify command ONCE for this whole run (not per task): call get_list_config. If verifyCommand is already set, leave it alone — never overwrite an existing one — and move straight to sharpening tasks below.
 
@@ -471,7 +482,7 @@ public static class PromptFiles
         Once every surviving task is enhanced, print your triage summary — one line per task from the brief:
         title — dedupe action (kept / merged into X / cancelled as duplicate of X) — enhanced (yes/no).
 
-        Then call handoff_list_handler(taskId, survivingTaskIds, nextPhase: "wait"). That opens a fresh session to carry out the wait/merge phases with just that list, without dragging along this session's dedupe/rewrite context. Say a short goodbye line, then stop — do not continue into phase 3 yourself.
+        Then print the wave plan from Phase 1.5, including any "won't fit in two rounds" note, and call handoff_list_handler(taskId, survivingTaskIds, nextPhase: "wait"). That opens a fresh session to carry out the wait/merge phases with just that list, without dragging along this session's dedupe/rewrite context. Say a short goodbye line, then stop — do not continue into phase 3 yourself.
         """;
 
     private const string MergeHelperWaitDefault = """
@@ -505,14 +516,14 @@ public static class PromptFiles
 
         One task at a time. Default to the order the brief lists them. If the overlap check shows two or more tasks touching the same file, tell the user which tasks collide and merge those in an order you can justify (e.g. the one making the smaller change first) — deviate from brief order only with that stated reason.
 
-        1. Never read a task's diff yourself. Instead start a sonnet subagent (Task tool) per task to inspect get_task_diff and sanity-check it against the task's title and description; only its short verdict (clean / risky + reason) comes back into your own context. If preview_merge_set flagged this task in an overlap, tell the subagent to also skim the diff of the other task(s) sharing that file.
-        2. Before approving, cross-check changedFileCount from preview_merge_set (or the length of get_task_diff's files list — the diff tool has no changedFileCount field). 0 changed files means an empty branch, not a clean success — do not approve it; treat it like a risky diff instead.
+        1. Check this task's changedFileCount from preview_merge_set first. Below 5 changed files, read get_task_diff yourself and sanity-check it against the task's title and description — a subagent hop is wasted context for a diff that small. At 5 or more, delegate instead: start a sonnet subagent (Task tool) to inspect get_task_diff and sanity-check it, so only its short verdict (clean / risky + reason) comes back into your own context — the whole point of never reading a large diff yourself. If preview_merge_set flagged this task in an overlap, also skim (or have the subagent skim) the diff of the other task(s) sharing that file.
+        2. Before approving, cross-check changedFileCount from preview_merge_set (or the length of get_task_diff's files list — the diff tool has no changedFileCount field). 0 changed files means an empty branch, not a clean success — do not approve it; treat it like a risky diff instead. Exception: if preview_merge_set's expectsNoDiff is true for this task (a verification/audit/research task deliberately expected to change nothing), 0 changed files is the correct outcome — read the task's Result to confirm it reports what was checked and that it passed, then approve normally.
         3. If the subagent's verdict is risky, or the change looks wrong or incomplete, STOP and ask the user before merging — offer reject_rerun (with feedback) or skip.
         4. Otherwise merge with review_task(taskId, decision="approve", leaveConflictsInTree=true, skipVerify=true). skipVerify defers the list's verify command to ONE verify_merges call after the last merge (below) instead of paying it per merge.
            - Clean merge → mergeStatus "merged_verify_pending" (expected: the task deliberately stays WaitingForReview until verify_merges passes) or "merged" (list has no verify command; the task is Done). Either way, move on.
            - Conflict (markers left in the working tree, repoPath returned) → resolve it below.
 
-        After each merge, main has moved — a clean preview_merge_set result from before this merge is now stale for the remaining tasks. If you are unsure whether an earlier overlap warning still matters, call preview_merge for the next task again before merging it.
+        After each merge, main has moved — a clean preview_merge_set result from before this merge is now stale for the remaining tasks. If you are unsure whether an earlier overlap warning still matters, call preview_merge for the next task again before merging it (default runVerify=false — this is just a conflict recheck, not a build; the verify command still runs once via verify_merges after the last merge).
 
         Every branch in this run forked from the same base, so conflicts between them are the NORMAL case, not a failure. Resolve them and keep going; do not abandon the run because a merge conflicted.
 
@@ -539,6 +550,30 @@ public static class PromptFiles
 
         Allow at most ONE rerun per task in this session.
 
+        ## Keep watching the queue
+
+        Do not assume the tasks you were handed are the only ones that matter. A prior Wait session
+        can already have finished before every one of its tasks actually reached a terminal status,
+        or new tasks can still be running when you start — merging only what happened to be ready the
+        moment you looked in and then stopping is how work silently falls through the cracks.
+
+        Before you go to Handoff / end, call get_queue_state and check whether any task id from your
+        brief still shows up in activeSlots or waitingTaskIds. If none do, your list is clear — go to
+        Handoff / end now.
+
+        If some do, call wait_for_task_change with exactly those still-busy task ids,
+        timeoutSeconds=900, treatWaitingForChildrenAsBusy=true. When it reports a change, go back to
+        Phase 4 and merge/review whatever it now says is WaitingForReview, then repeat this check.
+
+        This is NOT a `sleep`-and-poll loop — never write your own retry/sleep loop around get_task or
+        get_queue_state. wait_for_task_change already blocks server-side and reports progress so it
+        survives your own client's idle-silence abort; that is the only waiting mechanism allowed here.
+
+        Hard cap: stop after at most THREE consecutive wait_for_task_change calls made this way (three
+        900s timeouts ≈ 45 minutes total), even if tasks are still busy. When you stop — because the
+        queue cleared or because you hit the cap — report whatever is still Queued/Running in the
+        summary below and proceed to Handoff / end exactly as if this section didn't exist.
+
         ## Handoff / end
 
         - If you started any reruns: call handoff_list_handler(taskId, <the rerun task ids>, nextPhase: "wait_final"), then stop your turn immediately — do not merge anything yet that you just restarted. Do NOT submit this run for review yet — the chain isn't finished.
@@ -584,7 +619,81 @@ public static class PromptFiles
 
         Start with phase 3 (run), continuing through review/merge and the summary as your
         instructions describe.
-        {finalNote}
+        {roundInfo}
+        """;
+
+    // Appended to the triage/wait/merge system prompt when a run is in PowerUse (global switch AND
+    // the list's own opt-in). Deliberately an addendum rather than a second set of prompts: the
+    // shared 95% stays in one place, and a normal run's prompt is byte-identical to what it was.
+    // It therefore has to read as an OVERRIDE of the rules above it, not as standalone instructions.
+    private const string PowerUseAddendumDefault = """
+        # PowerUse mode — these rules supersede the ones above
+
+        PowerUse is ON for this run. Everything above was written for a session with a user watching it. That assumption no longer holds, and where the two conflict, this section wins.
+
+        ## No user exists
+
+        Nobody is watching and nobody can answer a question. Every instruction above that says to ask the user, confirm with the user, or stop and let the user decide is replaced by: decide it yourself, act, and record the decision in your summary. A question asked here is a hung session and a wasted run.
+
+        This does not lower the bar for what you may do — it removes escalation as an option, so the decisions you make must be ones you can defend in writing afterwards. Where a rule above offered "ask the user" as the safe path, the safe path is now the conservative action plus a written record, never the bold one.
+
+        Specifically:
+        - **Duplicate pairs (Triage Phase 1):** decide them. Clear duplicate — same goal, or one fully contained in the other — fold the loser's unique content into the survivor and cancel the loser. Genuinely different intent that merely touches the same area — keep both and chain them with dependsOnTaskId so they cannot run against the same files at once.
+        - **A task too vague to sharpen (Triage Phase 2):** cancel it with a recorded reason rather than guessing a specification for someone else's half-sentence. Guessing burns a whole slot on work nobody asked for.
+        - **Wave plan vs. handoff cap (Triage Phase 1.5):** do not assume two rounds, and never trim the wave plan to fit a cap or defer waves to "manual approval in the UI" — nobody will be there. Call get_handoff_status with your own handler task id to read this run's real cap, then plan the waves the work actually needs and hand off the first one.
+        - **A task that bundles several independent features (Triage Phase 2):** split it yourself — create the pieces, chain them with dependsOnTaskId where one builds on another, cancel or narrow the original, and record what you did.
+        - **Verify command not set (Triage Phase 2):** determine it, run it once via Bash to prove it works, then set it. Never write a command you have not actually run.
+        - **A risky or wrong-looking diff (Merge Phase 4):** if it contradicts the task's own acceptance criteria, call review_task(taskId, decision="reject_rerun", feedback=...) with concrete feedback naming what was missing. If it merely looks unusual but meets the criteria, merge it and say why. If it looks actively destructive — deletes code no task asked to delete, drops a migration, rewrites unrelated files — leave it unmerged and record it as HELD FOR REVIEW. Never merge something you would describe as destructive.
+        - **A conflict you cannot resolve with confidence (Merge Phase 4):** call abort_merge(taskId) and record it as HELD FOR REVIEW. Aborting is always correct over guessing: the task keeps its status, and a rerun against the new main usually removes the conflict entirely.
+
+        ## Conflicts are the normal case
+
+        Never end your turn with a conflicted merge left in the working tree. A half-merged tree makes the repo unbuildable for every session and every task after you, and any verify that runs against it reports a false red.
+
+        Prefer get_merge_conflicts + resolve_conflict_hunk over reading marker text by hand — for a large conflict that is the only tractable route; a 200k-character marker dump is not something to read linearly.
+
+        The common collision shape in a parallel run is one task MOVING code out of a file while another task ADDS to it. The resolution is almost always to keep the move and re-apply the addition in the file the code moved to — not to pick a side. Picking "ours" silently deletes the other task's work.
+
+        When ordering merges that overlap on a file, merge the task that moves or deletes code BEFORE the task that only adds to it. A move landing second turns every addition into a conflict.
+
+        ## Rerun budget
+
+        At most TWO reruns per task across the whole run, replacing the single-rerun limit above. A task that has already been rerun twice is recorded as HELD FOR REVIEW instead of getting a third attempt — three failures on the same task is a specification problem, not bad luck, and further attempts starve the rest of the run.
+
+        ## Harvest — so the run does not starve
+
+        This applies to the Merge phase only, after its merges and reruns are done.
+
+        If you have fewer than five tasks to hand to the next round, harvest new work for this list's repo before handing off. Only for the list named in the brief — never another list or repo.
+
+        Sources, in this order; prefer one you have not exhausted yet:
+        1. **Verify/build output** — real compiler warnings. One task per warning group.
+        2. **`ponytail:` comments** — deliberate shortcuts with a named ceiling and upgrade path. Take the ones whose upgrade is small.
+        3. **TODO / HACK / FIXME** — only the concretely formulated ones.
+        4. **Unfinished plan slices** — `docs/superpowers/plans/*.md` whose last slices never landed. Check against `git log` before believing a slice is open. One task per slice, naming the plan path and slice number.
+        5. **Test gaps at bug hotspots** — `git log --grep="^fix"` over recent commits; files with repeated fixes and no test.
+        6. **Over-engineering** — the ponytail-audit skill against individual subfolders, never the whole repo at once. Deletion candidates.
+        7. **Feature work** — improvements that follow clearly from what the code already does and from the plans and specs under `docs/`. Ground each one in something you actually read; a feature you cannot point at a file for is a guess, not a proposal.
+
+        Rules for every harvested task, without exception:
+        - Write it the way the Triage phase would: concrete acceptance criteria, real file paths found with Read/Grep/Glob, and what is out of scope. A vague harvested task wastes a whole slot.
+        - Keep it narrow — one concern, ideally under five changed files. Narrow tasks merge in parallel; broad ones collide with everything.
+        - Do not hand two new tasks to the same round if they touch the same file. Stagger them across rounds, or chain them with dependsOnTaskId.
+        - Tag every harvested task `createdBy: "power-use"` so a later review can tell your proposals from the ones a human asked for.
+        - A task that only verifies, audits or researches and is not meant to change code must be created with `expectsNoDiff: true`, or the next Merge session will read its empty diff as a failure.
+
+        ## Verify red is the one thing you must not paper over
+
+        If verify_merges returns verify_failed, the target branch is now RED. Do not try to fix it inside this session. Create ONE task with add_task(queueImmediately: true, model: "sonnet") titled `fix: verify red after this round`, put the failing output tail in its description, and hand that task to the next round as its ONLY entry. Merge nothing further until it has landed.
+
+        ## The summary is the only record
+
+        Nobody saw you work, so anything not written down did not happen. In addition to the per-task lines the Merge phase already asks for, your summary must carry these sections. An empty section is a valid answer; an omitted one is not:
+
+        - **HELD FOR REVIEW** — every task you did not merge, with the reason.
+        - **Conflicts resolved** — per conflict: the file, which two tasks collided, and which way you resolved it. Someone must be able to find your resolution without re-deriving it.
+        - **Harvested** — every task you created, grouped by source.
+        - **Round state** — which round this was and what you handed to the next one.
         """;
 
     private const string WeeklyReportDefault = """

src/ClaudeDo.Data/Repositories/AppSettingsRepository.cs

@@ -93,6 +93,16 @@ public sealed class AppSettingsRepository
         row.UsageThrottleSevenDaySoftPct = Math.Clamp(updated.UsageThrottleSevenDaySoftPct, 0, 100);
         row.UsageThrottleSevenDayHardPct = Math.Clamp(updated.UsageThrottleSevenDayHardPct, 0, 100);
         row.AutoContinueOnUsageLimit = updated.AutoContinueOnUsageLimit;
+        // ModelPresets / PowerUse* / ListHandlerMaxHandoffs were missing from this copy block, so
+        // every write of them was silently dropped (the row keeps whatever it already had). This
+        // block is the single write path for the singleton row — a field absent here does not
+        // persist, no matter how correctly the hub fills the entity.
+        row.ModelPresets = string.IsNullOrWhiteSpace(updated.ModelPresets) ? row.ModelPresets : updated.ModelPresets;
+        row.PowerUseEnabled = updated.PowerUseEnabled;
+        row.PowerUseWindowStart = PowerUseWindow.Normalize(updated.PowerUseWindowStart);
+        row.PowerUseWindowEnd = PowerUseWindow.Normalize(updated.PowerUseWindowEnd);
+        row.PowerUseHandoffPct = Math.Clamp(updated.PowerUseHandoffPct, 50, 99);
+        row.ListHandlerMaxHandoffs = Math.Max(1, updated.ListHandlerMaxHandoffs);
 
         await _context.SaveChangesAsync(ct);
     }

src/ClaudeDo.Data/Repositories/DailyNoteRepository.cs

@@ -22,7 +22,13 @@ public sealed class DailyNoteRepository
             .OrderBy(n => n.Date).ThenBy(n => n.SortOrder)
             .ToListAsync(ct);
 
-    public async Task<DailyNoteEntity> AddAsync(DateOnly day, string text, CancellationToken ct = default)
+    /// <summary>Notes an agent wrote on <paramref name="day"/> — the number the MCP cap counts against.</summary>
+    public async Task<int> CountAgentNotesAsync(DateOnly day, CancellationToken ct = default) =>
+        await _context.DailyNotes.AsNoTracking()
+            .CountAsync(n => n.Date == day && n.FromAgent, ct);
+
+    public async Task<DailyNoteEntity> AddAsync(
+        DateOnly day, string text, bool fromAgent = false, CancellationToken ct = default)
     {
         var nextOrder = await _context.DailyNotes
             .Where(n => n.Date == day)
@@ -34,6 +40,7 @@ public sealed class DailyNoteRepository
             Date = day,
             Text = text,
             SortOrder = nextOrder + 1,
+            FromAgent = fromAgent,
             CreatedAt = DateTime.UtcNow,
         };
         _context.DailyNotes.Add(note);

src/ClaudeDo.Data/Repositories/ListRepository.cs

@@ -17,10 +17,20 @@ public sealed class ListRepository
     public async Task AddAsync(ListEntity entity, CancellationToken ct = default)
     {
         NormalizeWorkingDir(entity);
+        if (entity.SortOrder == 0) entity.SortOrder = await NextSortOrderAsync(ct);
         _context.Lists.Add(entity);
         await _context.SaveChangesAsync(ct);
     }
 
+    /// <summary>One past the highest <c>sort_order</c> in use — across <b>both</b> tables, because
+    /// the sidebar interleaves folders and top-level lists in a single order sequence.</summary>
+    private async Task<int> NextSortOrderAsync(CancellationToken ct = default)
+    {
+        var maxList = await _context.Lists.MaxAsync(l => (int?)l.SortOrder, ct) ?? -1;
+        var maxFolder = await _context.ListFolders.MaxAsync(f => (int?)f.SortOrder, ct) ?? -1;
+        return Math.Max(maxList, maxFolder) + 1;
+    }
+
     public async Task UpdateAsync(ListEntity entity, CancellationToken ct = default)
     {
         NormalizeWorkingDir(entity);
@@ -56,18 +66,83 @@ public sealed class ListRepository
         return await _context.Lists.OrderBy(l => l.SortOrder).ThenBy(l => l.CreatedAt).ToListAsync(ct);
     }
 
-    public async Task ReorderAsync(IReadOnlyList<string> orderedListIds, CancellationToken ct = default)
+    /// <summary>
+    /// Writes the sidebar's visual order as one sequence spanning both tables: folders and lists
+    /// share the <c>sort_order</c> number space, which is what lets a top-level list sit between
+    /// two folders. A folder's own children follow it in the sequence, so ordering folders by
+    /// <c>sort_order</c> and lists by <c>sort_order</c> independently still reproduces the sidebar.
+    /// </summary>
+    public async Task ReorderSidebarAsync(IReadOnlyList<(string Id, bool IsFolder)> ordered, CancellationToken ct = default)
     {
-        var idSet = orderedListIds.ToHashSet();
-        var entities = await _context.Lists.Where(l => idSet.Contains(l.Id)).ToListAsync(ct);
-        for (int i = 0; i < orderedListIds.Count; i++)
+        var listIds = ordered.Where(o => !o.IsFolder).Select(o => o.Id).ToHashSet();
+        var folderIds = ordered.Where(o => o.IsFolder).Select(o => o.Id).ToHashSet();
+        var lists = await _context.Lists.Where(l => listIds.Contains(l.Id)).ToListAsync(ct);
+        var folders = await _context.ListFolders.Where(f => folderIds.Contains(f.Id)).ToListAsync(ct);
+
+        for (int i = 0; i < ordered.Count; i++)
         {
-            var e = entities.FirstOrDefault(x => x.Id == orderedListIds[i]);
-            if (e is not null) e.SortOrder = i;
+            var (id, isFolder) = ordered[i];
+            if (isFolder)
+            {
+                if (folders.FirstOrDefault(f => f.Id == id) is { } folder) folder.SortOrder = i;
+            }
+            else if (lists.FirstOrDefault(l => l.Id == id) is { } list) list.SortOrder = i;
         }
         await _context.SaveChangesAsync(ct);
     }
 
+    // ---- Sidebar folders (list_folders) ----
+    // Folders live here rather than in their own repository because they exist only as a grouping
+    // of these lists — every caller that touches one already holds a ListRepository.
+
+    public async Task<List<ListFolderEntity>> GetFoldersAsync(CancellationToken ct = default)
+    {
+        return await _context.ListFolders
+            .OrderBy(f => f.SortOrder).ThenBy(f => f.CreatedAt)
+            .ToListAsync(ct);
+    }
+
+    public async Task AddFolderAsync(ListFolderEntity folder, CancellationToken ct = default)
+    {
+        folder.SortOrder = await NextSortOrderAsync(ct);
+        _context.ListFolders.Add(folder);
+        await _context.SaveChangesAsync(ct);
+    }
+
+    /// <summary>Patches just the two editable fields — a whole-entity Update would need
+    /// <c>CreatedAt</c>/<c>SortOrder</c>/<c>IsCollapsed</c> carried along and silently reset
+    /// whichever the caller forgot (see the SetConfigAsync note in CLAUDE.md).</summary>
+    public async Task RenameFolderAsync(string folderId, string name, string? icon, CancellationToken ct = default)
+    {
+        await _context.ListFolders
+            .Where(f => f.Id == folderId)
+            .ExecuteUpdateAsync(s => s
+                .SetProperty(f => f.Name, name)
+                .SetProperty(f => f.Icon, icon), ct);
+    }
+
+    /// <summary>Deletes the folder only — its lists survive and fall back to the top level via
+    /// the ON DELETE SET NULL on <c>lists.folder_id</c>.</summary>
+    public async Task DeleteFolderAsync(string folderId, CancellationToken ct = default)
+    {
+        await _context.ListFolders.Where(f => f.Id == folderId).ExecuteDeleteAsync(ct);
+    }
+
+    public async Task SetFolderCollapsedAsync(string folderId, bool collapsed, CancellationToken ct = default)
+    {
+        await _context.ListFolders
+            .Where(f => f.Id == folderId)
+            .ExecuteUpdateAsync(s => s.SetProperty(f => f.IsCollapsed, collapsed), ct);
+    }
+
+    /// <summary>Moves a list into <paramref name="folderId"/>, or back to the top level when null.</summary>
+    public async Task SetListFolderAsync(string listId, string? folderId, CancellationToken ct = default)
+    {
+        await _context.Lists
+            .Where(l => l.Id == listId)
+            .ExecuteUpdateAsync(s => s.SetProperty(l => l.FolderId, folderId), ct);
+    }
+
     public async Task<ListConfigEntity?> GetConfigAsync(string listId, CancellationToken ct = default)
     {
         return await _context.ListConfigs.FirstOrDefaultAsync(c => c.ListId == listId, ct);
@@ -90,6 +165,7 @@ public sealed class ListRepository
             existing.VerifyCommand = config.VerifyCommand;
             existing.PermissionMode = config.PermissionMode;
             existing.TicketProjectId = config.TicketProjectId;
+            existing.PowerUseAllowed = config.PowerUseAllowed;
         }
         await _context.SaveChangesAsync(ct);
     }

src/ClaudeDo.Data/Repositories/TaskRepository.cs

@@ -34,7 +34,10 @@ public sealed class TaskRepository
         var tracked = _context.Tasks.Local.FirstOrDefault(t => t.Id == entity.Id);
         if (tracked is not null && !ReferenceEquals(tracked, entity))
             _context.Entry(tracked).State = Microsoft.EntityFrameworkCore.EntityState.Detached;
-        _context.Tasks.Update(entity);
+        // Entry().State instead of Update(): Update marks the whole loaded graph Modified, which
+        // for the all-key task_dependencies rows means an UPDATE with nothing to set. Dependency
+        // edges are written only by TaskStateService.SetDependsOnAsync.
+        _context.Entry(entity).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
         await _context.SaveChangesAsync(ct);
     }
 
@@ -46,17 +49,20 @@ public sealed class TaskRepository
 
     public async Task<TaskEntity?> GetByIdAsync(string taskId, CancellationToken ct = default)
     {
-        return await _context.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Id == taskId, ct);
+        return await _context.Tasks.AsNoTracking().Include(t => t.Dependencies)
+            .FirstOrDefaultAsync(t => t.Id == taskId, ct);
     }
 
     public async Task<TaskEntity?> GetByNumberAsync(int number, CancellationToken ct = default)
     {
-        return await _context.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Number == number, ct);
+        return await _context.Tasks.AsNoTracking().Include(t => t.Dependencies)
+            .FirstOrDefaultAsync(t => t.Number == number, ct);
     }
 
     public async Task<List<TaskEntity>> GetByListIdAsync(string listId, CancellationToken ct = default)
     {
         return await _context.Tasks
+            .Include(t => t.Dependencies)
             .Where(t => t.ListId == listId)
             .OrderBy(t => t.SortOrder).ThenBy(t => t.CreatedAt)
             .ToListAsync(ct);

src/ClaudeDo.Data/Wire.cs

@@ -13,8 +13,6 @@ namespace ClaudeDo.Data.Wire;
 
 public record ActiveTaskDto(string Slot, string TaskId, DateTime StartedAt);
 
-public record WorkerBuildInfoDto(string? BuildSha);
-
 public record AppSettingsDto(
     string DefaultClaudeInstructions,
     string DefaultModel,
@@ -38,7 +36,16 @@ public record AppSettingsDto(
     int UsageThrottleFiveHourHardPct = 65,
     int UsageThrottleSevenDaySoftPct = 50,
     int UsageThrottleSevenDayHardPct = 65,
-    bool AutoContinueOnUsageLimit = false);
+    bool AutoContinueOnUsageLimit = false,
+    // PowerUse master switch — Settings → Execution. Only takes effect for a list that also set
+    // PowerUseAllowed.
+    bool PowerUseEnabled = false,
+    int ListHandlerMaxHandoffs = 4,
+    // PowerUse time window (`HH:mm`, local, null = round the clock) + the 5h-usage percentage at
+    // which a PowerUse handler session should hand off. Same Settings tab.
+    string? PowerUseWindowStart = null,
+    string? PowerUseWindowEnd = null,
+    int PowerUseHandoffPct = 95);
 
 public record ModelPresetDto(string Model, string Effort, int MaxTurns);
 
@@ -65,7 +72,8 @@ public record WorktreeOverviewDto(
     WorktreeState State,
     string? DiffStat,
     DateTime CreatedAt,
-    bool PathExistsOnDisk);
+    bool PathExistsOnDisk,
+    int TaskNumber = 0);
 
 public record ForceRemoveResultDto(bool Removed, string? Reason);
 
@@ -84,7 +92,8 @@ public record MergePreviewDto(
     int? VerifyExitCode = null, long? VerifyDurationMs = null, string? VerifyOutputTail = null);
 
 public record MergeTargetsDto(
-    string DefaultBranch, IReadOnlyList<string> LocalBranches, string DefaultCommitMessage);
+    string DefaultBranch, IReadOnlyList<string> LocalBranches, string DefaultCommitMessage,
+    bool TargetDirty = false);
 
 public record MergeConflictDocumentsDto(string TaskId, IReadOnlyList<ConflictDocumentDto> Files);
 
@@ -97,11 +106,13 @@ public record UpdateListDto(string Id, string Name, string? WorkingDir, string D
 // TicketProjectId is tri-state on purpose: a caller that doesn't own the field (anything but the
 // list-settings modal) must not be able to clear it by omission — SetConfigAsync copies the entity
 // verbatim. Its scale: null = keep stored, <= 0 = clear the link, > 0 = set it.
-public record UpdateListConfigDto(string ListId, string? Model, string? SystemPrompt, string? AgentPath, int? MaxTurns = null, List<string>? SessionSkills = null, string? VerifyCommand = null, string? PermissionMode = null, int? TicketProjectId = null);
+// PowerUseAllowed is nullable for the same reason: null = keep stored, false = revoke the opt-in.
+// A non-nullable bool here would let any caller that omits it silently revoke PowerUse for the list.
+public record UpdateListConfigDto(string ListId, string? Model, string? SystemPrompt, string? AgentPath, int? MaxTurns = null, List<string>? SessionSkills = null, string? VerifyCommand = null, string? PermissionMode = null, int? TicketProjectId = null, bool? PowerUseAllowed = null);
 
 public record UpdateTaskAgentSettingsDto(string TaskId, string? Model, string? SystemPrompt, string? AgentPath, int? MaxTurns = null, List<string>? SessionSkills = null, string? PermissionMode = null);
 
-public record ListConfigDto(string? Model, string? SystemPrompt, string? AgentPath, int? MaxTurns = null, List<string>? SessionSkills = null, string? VerifyCommand = null, string? PermissionMode = null, int? TicketProjectId = null);
+public record ListConfigDto(string? Model, string? SystemPrompt, string? AgentPath, int? MaxTurns = null, List<string>? SessionSkills = null, string? VerifyCommand = null, string? PermissionMode = null, int? TicketProjectId = null, bool PowerUseAllowed = false);
 
 public record SeedResultDto(int Copied, int Skipped);
 
@@ -207,6 +218,10 @@ public sealed record LaunchSpec(
     IReadOnlyList<string> Args,
     IReadOnlyDictionary<string, string> Env);
 
+// A handler round's still-open (Queued/Running) task, for the Mission Control "abandon run"
+// action -- confirms with a count, then cancels each one before closing the pane.
+public record HandlerOpenTaskDto(string Id, string Title);
+
 public record TicketSettingsDto(string? ApiBaseUrl, bool TokenSet);
 public record TicketConnectionDto(bool Ok, string? UserName, IReadOnlyList<string> Scopes, string? Error);
 public record TicketProjectDto(int Id, string Title, string DepartmentName);

src/ClaudeDo.Installer/Checks/ClaudeAuthCheck.cs

@@ -1,5 +1,6 @@
 using System.Text.Json;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 
 namespace ClaudeDo.Installer.Checks;
 
@@ -23,11 +24,12 @@ public sealed class ClaudeAuthCheck : IEnvironmentCheck
 
     public async Task<CheckResult> RunAsync(InstallContext ctx, CancellationToken ct)
     {
+        var loc = TrExtension.Localizer;
         var lookup = await _lookup.ResolveAsync(ctx, ct);
         if (lookup.Resolved is null)
         {
             return CheckResult.Unknown(Id, Severity, "checks.claudeAuth.title",
-                "The claude CLI was not found — login could not be checked.");
+                loc?["checks.claudeAuth.notFound"] ?? "The claude CLI was not found — login could not be checked.");
         }
 
         var (fileName, arguments) = ProcessCommand.For(lookup.Resolved, "auth", "status", "--json");
@@ -36,19 +38,19 @@ public sealed class ClaudeAuthCheck : IEnvironmentCheck
         if (exitCode != 0)
         {
             return CheckResult.Unknown(Id, Severity, "checks.claudeAuth.title",
-                "Login status could not be determined.", output);
+                loc?["checks.claudeAuth.undetermined"] ?? "Login status could not be determined.", output);
         }
 
         var loggedIn = TryParseLoggedIn(output);
         if (loggedIn is null)
         {
             return CheckResult.Unknown(Id, Severity, "checks.claudeAuth.title",
-                "Login status could not be determined.", output);
+                loc?["checks.claudeAuth.undetermined"] ?? "Login status could not be determined.", output);
         }
 
         return loggedIn.Value
-            ? CheckResult.Ok(Id, Severity, "checks.claudeAuth.title", "Logged in.")
-            : CheckResult.Fail(Id, Severity, "checks.claudeAuth.title", "Not logged in.", "checks.claudeAuth.hint");
+            ? CheckResult.Ok(Id, Severity, "checks.claudeAuth.title", loc?["checks.claudeAuth.loggedIn"] ?? "Logged in.")
+            : CheckResult.Fail(Id, Severity, "checks.claudeAuth.title", loc?["checks.claudeAuth.notLoggedIn"] ?? "Not logged in.", "checks.claudeAuth.hint");
     }
 
     private static bool? TryParseLoggedIn(string output)

src/ClaudeDo.Installer/Checks/ClaudeCliCheck.cs

@@ -1,6 +1,7 @@
 using System.IO;
 using ClaudeDo.Data.Environment;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 
 namespace ClaudeDo.Installer.Checks;
 
@@ -21,20 +22,21 @@ public sealed class ClaudeCliCheck : IEnvironmentCheck
 
     public async Task<CheckResult> RunAsync(InstallContext ctx, CancellationToken ct)
     {
+        var loc = TrExtension.Localizer;
         var lookup = await _lookup.ResolveAsync(ctx, ct);
 
         if (lookup.Resolved is null)
         {
             var searched = string.Join(", ", SearchedLocations());
             return CheckResult.Fail(Id, Severity, "checks.claudeCli.title",
-                $"'{ctx.ClaudeBin}' was not found on PATH. Searched: {searched}.",
+                loc?.Get("checks.claudeCli.notFound", ctx.ClaudeBin, searched) ?? $"'{ctx.ClaudeBin}' was not found on PATH. Searched: {searched}.",
                 "checks.claudeCli.hint");
         }
 
         if (lookup.ExitCode != 0)
         {
             return CheckResult.Fail(Id, Severity, "checks.claudeCli.title",
-                $"'{lookup.Resolved.Path}' exited with code {lookup.ExitCode}.",
+                loc?.Get("checks.claudeCli.exitCode", lookup.Resolved.Path, lookup.ExitCode) ?? $"'{lookup.Resolved.Path}' exited with code {lookup.ExitCode}.",
                 "checks.claudeCli.hint", detail: lookup.Output);
         }
 
@@ -42,7 +44,8 @@ public sealed class ClaudeCliCheck : IEnvironmentCheck
         var detail = lookup.Resolved.IsShim
             ? "Resolved via a shim (.cmd/.bat/.ps1), not a native .exe."
             : null;
-        return CheckResult.Ok(Id, Severity, "checks.claudeCli.title", $"{lookup.Resolved.Path} — {version}", detail);
+        return CheckResult.Ok(Id, Severity, "checks.claudeCli.title",
+            loc?.Get("checks.claudeCli.resolvedFormat", lookup.Resolved.Path, version) ?? $"{lookup.Resolved.Path} — {version}", detail);
     }
 
     private IEnumerable<string> SearchedLocations()

src/ClaudeDo.Installer/Checks/ClaudeVersionCheck.cs

@@ -1,4 +1,5 @@
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 
 namespace ClaudeDo.Installer.Checks;
 
@@ -27,28 +28,29 @@ public sealed class ClaudeVersionCheck : IEnvironmentCheck
 
     public async Task<CheckResult> RunAsync(InstallContext ctx, CancellationToken ct)
     {
+        var loc = TrExtension.Localizer;
         var lookup = await _lookup.ResolveAsync(ctx, ct);
 
         if (lookup.Resolved is null)
         {
             return CheckResult.Unknown(Id, Severity, "checks.claudeVersion.title",
-                "The claude CLI was not found — version could not be checked.");
+                loc?["checks.claudeVersion.notFound"] ?? "The claude CLI was not found — version could not be checked.");
         }
 
         if (lookup.ExitCode != 0 || lookup.ParsedVersion is null)
         {
             return CheckResult.Unknown(Id, Severity, "checks.claudeVersion.title",
-                $"Could not parse a version from '{lookup.Output.Trim()}'.");
+                loc?.Get("checks.claudeVersion.parseFailed", lookup.Output.Trim()) ?? $"Could not parse a version from '{lookup.Output.Trim()}'.");
         }
 
         if (lookup.ParsedVersion < MinimumVersion)
         {
             return CheckResult.Fail(Id, Severity, "checks.claudeVersion.title",
-                $"claude {lookup.ParsedVersion} is older than the required {MinimumVersion}.",
+                loc?.Get("checks.claudeVersion.tooOld", lookup.ParsedVersion, MinimumVersion) ?? $"claude {lookup.ParsedVersion} is older than the required {MinimumVersion}.",
                 "checks.claudeVersion.hint");
         }
 
         return CheckResult.Ok(Id, Severity, "checks.claudeVersion.title",
-            $"claude {lookup.ParsedVersion} meets the minimum ({MinimumVersion}).");
+            loc?.Get("checks.claudeVersion.ok", lookup.ParsedVersion, MinimumVersion) ?? $"claude {lookup.ParsedVersion} meets the minimum ({MinimumVersion}).");
     }
 }

src/ClaudeDo.Installer/Checks/GitCheck.cs

@@ -2,6 +2,7 @@ using System.Text.RegularExpressions;
 using ClaudeDo.Data.Environment;
 using ClaudeDo.Installer.Core;
 using ClaudeDo.Installer.Core.Interfaces;
+using ClaudeDo.Installer.Localization;
 
 namespace ClaudeDo.Installer.Checks;
 
@@ -27,10 +28,12 @@ public sealed class GitCheck : IEnvironmentCheck
 
     public async Task<CheckResult> RunAsync(InstallContext ctx, CancellationToken ct)
     {
+        var loc = TrExtension.Localizer;
         var resolved = ExecutableResolver.Resolve("git", _pathOverride, _pathExtOverride);
         if (resolved is null)
         {
-            return CheckResult.Fail(Id, Severity, "checks.git.title", "git was not found on PATH.",
+            return CheckResult.Fail(Id, Severity, "checks.git.title",
+                loc?["checks.git.notFound"] ?? "git was not found on PATH.",
                 "checks.git.hint", "https://git-scm.com/downloads");
         }
 
@@ -39,11 +42,13 @@ public sealed class GitCheck : IEnvironmentCheck
 
         if (exitCode != 0)
         {
-            return CheckResult.Fail(Id, Severity, "checks.git.title", $"'{resolved.Path}' exited with code {exitCode}.",
+            return CheckResult.Fail(Id, Severity, "checks.git.title",
+                loc?.Get("checks.git.exitCode", resolved.Path, exitCode) ?? $"'{resolved.Path}' exited with code {exitCode}.",
                 "checks.git.hint", "https://git-scm.com/downloads", output);
         }
 
         var version = VersionPattern.Match(output) is { Success: true } match ? match.Value : output.Trim();
-        return CheckResult.Ok(Id, Severity, "checks.git.title", $"{resolved.Path} — {version}");
+        return CheckResult.Ok(Id, Severity, "checks.git.title",
+            loc?.Get("checks.git.resolvedFormat", resolved.Path, version) ?? $"{resolved.Path} — {version}");
     }
 }

src/ClaudeDo.Installer/Checks/GitIdentityCheck.cs

@@ -1,6 +1,7 @@
 using ClaudeDo.Data.Environment;
 using ClaudeDo.Installer.Core;
 using ClaudeDo.Installer.Core.Interfaces;
+using ClaudeDo.Installer.Localization;
 
 namespace ClaudeDo.Installer.Checks;
 
@@ -25,10 +26,12 @@ public sealed class GitIdentityCheck : IEnvironmentCheck
 
     public async Task<CheckResult> RunAsync(InstallContext ctx, CancellationToken ct)
     {
+        var loc = TrExtension.Localizer;
         var resolved = ExecutableResolver.Resolve("git", _pathOverride, _pathExtOverride);
         if (resolved is null)
         {
-            return CheckResult.Unknown(Id, Severity, "checks.gitIdentity.title", "git was not found — identity could not be checked.");
+            return CheckResult.Unknown(Id, Severity, "checks.gitIdentity.title",
+                loc?["checks.gitIdentity.notFound"] ?? "git was not found — identity could not be checked.");
         }
 
         var name = await ReadConfigAsync(resolved, "user.name", ct);
@@ -48,7 +51,8 @@ public sealed class GitIdentityCheck : IEnvironmentCheck
             _ => "user.email",
         };
 
-        return CheckResult.Fail(Id, Severity, "checks.gitIdentity.title", $"Missing git identity: {missing}.", "checks.gitIdentity.hint");
+        return CheckResult.Fail(Id, Severity, "checks.gitIdentity.title",
+            loc?.Get("checks.gitIdentity.missing", missing) ?? $"Missing git identity: {missing}.", "checks.gitIdentity.hint");
     }
 
     private async Task<string> ReadConfigAsync(ResolvedExecutable resolved, string key, CancellationToken ct)

src/ClaudeDo.Installer/Checks/PermissionModeAutoCheck.cs

@@ -1,5 +1,6 @@
 using System.Text.RegularExpressions;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 
 namespace ClaudeDo.Installer.Checks;
 
@@ -28,11 +29,12 @@ public sealed class PermissionModeAutoCheck : IEnvironmentCheck
 
     public async Task<CheckResult> RunAsync(InstallContext ctx, CancellationToken ct)
     {
+        var loc = TrExtension.Localizer;
         var lookup = await _lookup.ResolveAsync(ctx, ct);
         if (lookup.Resolved is null)
         {
             return CheckResult.Unknown(Id, Severity, "checks.permissionModeAuto.title",
-                "The claude CLI was not found — permission-mode support could not be checked.");
+                loc?["checks.permissionModeAuto.notFound"] ?? "The claude CLI was not found — permission-mode support could not be checked.");
         }
 
         var (fileName, arguments) = ProcessCommand.For(lookup.Resolved, "--help");
@@ -41,17 +43,17 @@ public sealed class PermissionModeAutoCheck : IEnvironmentCheck
         if (exitCode != 0 || string.IsNullOrWhiteSpace(output))
         {
             return CheckResult.Unknown(Id, Severity, "checks.permissionModeAuto.title",
-                "Could not determine whether --permission-mode auto is supported.");
+                loc?["checks.permissionModeAuto.undetermined"] ?? "Could not determine whether --permission-mode auto is supported.");
         }
 
         if (AutoIsListed(output))
         {
             return CheckResult.Ok(Id, Severity, "checks.permissionModeAuto.title",
-                "--permission-mode auto is recognized by this CLI.");
+                loc?["checks.permissionModeAuto.ok"] ?? "--permission-mode auto is recognized by this CLI.");
         }
 
         return CheckResult.Fail(Id, Severity, "checks.permissionModeAuto.title",
-            "This claude CLI version does not list 'auto' as a --permission-mode choice.",
+            loc?["checks.permissionModeAuto.notListed"] ?? "This claude CLI version does not list 'auto' as a --permission-mode choice.",
             "checks.permissionModeAuto.hint");
     }
 

src/ClaudeDo.Installer/Checks/PortCheck.cs

@@ -2,6 +2,7 @@ using System.Net;
 using System.Net.Sockets;
 using ClaudeDo.Installer.Checks.Interfaces;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 
 namespace ClaudeDo.Installer.Checks;
 
@@ -19,6 +20,7 @@ public sealed class PortCheck : IEnvironmentCheck
 
     public async Task<CheckResult> RunAsync(InstallContext ctx, CancellationToken ct)
     {
+        var loc = TrExtension.Localizer;
         var ports = new (string Label, int Port)[]
         {
             ("SignalR", ctx.SignalRPort),
@@ -39,7 +41,9 @@ public sealed class PortCheck : IEnvironmentCheck
                 continue;
             }
 
-            blocked.Add(owner is null ? $"{label} port {port} is in use." : $"{label} port {port} is in use by '{owner}'.");
+            blocked.Add(owner is null
+                ? loc?.Get("checks.ports.inUse", label, port) ?? $"{label} port {port} is in use."
+                : loc?.Get("checks.ports.inUseBy", label, port, owner) ?? $"{label} port {port} is in use by '{owner}'.");
         }
 
         if (blocked.Count > 0)
@@ -49,10 +53,12 @@ public sealed class PortCheck : IEnvironmentCheck
 
         if (ownWorker.Count > 0)
         {
-            return CheckResult.Ok(Id, Severity, "checks.ports.title", $"In use by the running ClaudeDo Worker: {string.Join(", ", ownWorker)}.");
+            var ownWorkerList = string.Join(", ", ownWorker);
+            return CheckResult.Ok(Id, Severity, "checks.ports.title",
+                loc?.Get("checks.ports.inUseByOwnWorker", ownWorkerList) ?? $"In use by the running ClaudeDo Worker: {ownWorkerList}.");
         }
 
-        return CheckResult.Ok(Id, Severity, "checks.ports.title", "Ports are available.");
+        return CheckResult.Ok(Id, Severity, "checks.ports.title", loc?["checks.ports.available"] ?? "Ports are available.");
     }
 
     private static bool IsFree(int port)

src/ClaudeDo.Installer/Checks/WriteAccessCheck.cs

@@ -1,6 +1,7 @@
 using System.IO;
 using ClaudeDo.Data;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 
 namespace ClaudeDo.Installer.Checks;
 
@@ -14,17 +15,19 @@ public sealed class WriteAccessCheck : IEnvironmentCheck
 
     public Task<CheckResult> RunAsync(InstallContext ctx, CancellationToken ct)
     {
+        var loc = TrExtension.Localizer;
         foreach (var target in new[] { ctx.InstallDirectory, Paths.AppDataRoot() })
         {
             var error = TryWrite(target);
             if (error is not null)
             {
                 return Task.FromResult(CheckResult.Fail(Id, Severity, "checks.writeAccess.title",
-                    $"Cannot write to '{target}': {error}", "checks.writeAccess.hint"));
+                    loc?.Get("checks.writeAccess.cannotWrite", target, error) ?? $"Cannot write to '{target}': {error}", "checks.writeAccess.hint"));
             }
         }
 
-        return Task.FromResult(CheckResult.Ok(Id, Severity, "checks.writeAccess.title", "Install directory and data directory are writable."));
+        return Task.FromResult(CheckResult.Ok(Id, Severity, "checks.writeAccess.title",
+            loc?["checks.writeAccess.writable"] ?? "Install directory and data directory are writable."));
     }
 
     private static string? TryWrite(string path)

src/ClaudeDo.Localization/locales/de.json

@@ -11,6 +11,7 @@
       "categoryGeneral": "Allgemein",
       "categoryExecution": "Ausführung",
       "categoryPrime": "Prime Claude",
+      "categoryPrimeHint": "Geplante Claude-Läufe: Ping, My Day füllen oder ein eigener Prompt, zu festen Zeiten.",
       "categoryWorktrees": "Worktrees",
       "categoryFiles": "Dateien & Prompts",
       "categorySkills": "Session Skills",
@@ -27,6 +28,7 @@
       "model": "Modell",
       "maxTurns": "Max. Durchläufe",
       "effort": "Effort",
+      "effortHint": "Denkaufwand, den das Modell anwendet. Höher kostet mehr und denkt tiefer.",
       "modelPresets": "Vorgaben pro Modell",
       "modelPresetsHint": "Effort und Durchlauf-Budget, mit denen eine Sitzung unter diesem Modell läuft. Overrides auf Listen- und Aufgabenebene gewinnen weiterhin.",
       "maxTurnsCeiling": "Max. Durchläufe – Obergrenze",
@@ -36,13 +38,23 @@
       "maxParallelExecutions": "Max. parallele Ausführungen",
       "maxParallelExecutionsHint": "Wie viele Aufgaben aus der Warteschlange der Worker gleichzeitig ausführt.",
       "usageGateHeading": "Usage-Limit-Stopp",
-      "usageGateHint": "Ab dieser Auslastung holt die Queue keine neuen Tasks mehr; laufende Tasks laufen zu Ende. 0 schaltet den Stopp ab.",
+      "usageGateHint": "Ab dieser Auslastung holt die Warteschlange keine neuen Aufgaben mehr; laufende Aufgaben laufen zu Ende. 0 schaltet den Stopp ab.",
       "usageGateFiveHourPct": "5-Stunden-Fenster (%)",
       "usageGateSevenDayPct": "7-Tage-Fenster (%)",
       "autoContinueOnUsageLimit": "Nach Limit-Reset fortsetzen",
-      "autoContinueOnUsageLimitHint": "Ist ein Run am Nutzungslimit abgebrochen, wird er nach Ablauf des 5-Stunden-Fensters automatisch fortgesetzt. Weckt außerdem die pausierte Queue genau zum Reset-Zeitpunkt statt erst beim nächsten Backstop-Check.",
+      "autoContinueOnUsageLimitHint": "Ist ein Run am Nutzungslimit abgebrochen, wird er nach Ablauf des 5-Stunden-Fensters automatisch fortgesetzt. Weckt außerdem die pausierte Warteschlange genau zum Reset-Zeitpunkt statt erst beim nächsten Backstop-Check.",
+      "listHandlerMaxHandoffs": "Handoff-Budget des List-Handlers",
+      "listHandlerMaxHandoffsHint": "Wie viele Wait/Merge-Handoffs ein „Let Claude handle it\"-Run verketten darf. 4 entspricht zwei Merge-Runden. Für Läufe, die stundenlang durchlaufen sollen, höher setzen; der Wert begrenzt eine entlaufene Kette und darf daher nicht 0 sein.",
+      "powerUseHeading": "PowerUse",
+      "powerUse": "PowerUse aktivieren",
+      "powerUseHint": "Das restliche Fenster ausnutzen: ein List-Handler-Run fragt nichts, löst Konflikte selbst, sammelt neue Arbeit und handoffet weiter, solange sein Budget reicht. Wirkt nur auf Listen, die PowerUse in ihren Listen-Einstellungen erlaubt haben.",
+      "powerUseWindow": "Nur zwischen",
+      "powerUseWindowPlaceholder": "HH:mm",
+      "powerUseHandoffPct": "Übergabe bei (% von 5h)",
+      "powerUseWindowHint": "Beide Zeiten leer = rund um die Uhr. Das Fenster wird bei jedem Start einer Handler-Phase geprüft — eine Kette, die über das Ende hinausläuft, macht ohne PowerUse weiter.",
+      "powerUseWindowInvalid": "PowerUse-Zeiten müssen im Format HH:mm sein oder leer bleiben.",
       "throttleStagesHeading": "Throttle-Stufen",
-      "throttleStagesHint": "Die Parallelität wird vor dem harten Gate begrenzt: soft auf 2 Slots, hard auf 1. Eingestellt wird das durch Ziehen der Marker an den Gauges im Usage-Monitor. Der Monitor schließt diese Einstellungen — vorher speichern, wenn du etwas geändert hast.",
+      "throttleStagesHint": "Die Parallelität wird vor dem harten Limit-Stopp begrenzt: soft auf 2 Slots, hard auf 1. Eingestellt wird das durch Ziehen der Marker an den Gauges im Usage-Monitor. Der Monitor schließt diese Einstellungen — vorher speichern, wenn du etwas geändert hast.",
       "throttleStagesValues": "5h: soft {0}% / hard {1}%  ·  7d: soft {2}% / hard {3}%",
       "openUsageMonitor": "Usage-Monitor öffnen...",
       "reportExcludedPaths": "Bericht: ausgeschlossene Pfade (einer pro Zeile)",
@@ -85,6 +97,7 @@
       "retryPrompt": "Wiederholung",
       "dailyPrepPrompt": "Tagesplanung",
       "weeklyReportPrompt": "Wochenbericht",
+      "powerUsePrompt": "PowerUse-Addendum",
       "viewPrompt": "Ansehen",
       "customizedSection": "ANGEPASST",
       "customizedHint": "Diese Prompts weichen vom mitgelieferten Standard ab und werden unverändert beibehalten. Zurücksetzen, um künftige Standard-Verbesserungen zu erhalten.",
@@ -177,7 +190,6 @@
     "listSettingsTip": "Listeneinstellungen",
     "addPlaceholder": "Aufgabe hinzufügen…",
     "enterKey": "ENTER",
-    "notesPinnedRow": "Notizen (Tagesnotizen)",
     "clearDayTip": "Tag leeren",
     "planMyDayTip": "Meinen Tag planen",
     "overdue": "ÜBERFÄLLIG",
@@ -209,6 +221,7 @@
     "ctxRefineTask": "Aufgabe verfeinern",
     "ctxPlanning": "Planung",
     "ctxSchedule": "Zeitplan",
+    "ctxMoveToList": "In Liste verschieben",
     "ctxDeleteTask": "Aufgabe löschen",
     "reasonAlreadyRunning": "Aufgabe läuft bereits",
     "reasonAlreadyQueued": "Bereits in der Warteschlange",
@@ -223,12 +236,13 @@
     "reasonIsPlanningParent": "Teil eines Plans",
     "reasonIsChildTask": "Teilaufgaben haben keine eigene Planungssitzung",
     "reasonPlanAlreadyFinalized": "Plan ist bereits finalisiert",
-    "reasonNoWorktree": "Kein Worktree für diesen Task",
+    "reasonNoWorktree": "Kein Worktree für diese Aufgabe",
     "cancel": "Abbrechen",
     "removeFromQueueTip": "Aus Warteschlange entfernen",
     "toggleSubtasksTip": "Unteraufgaben ein-/ausklappen",
     "agentSuggestedTip": "Vom Agenten vorgeschlagen",
     "interactiveChipTip": "Interaktive Sitzung offen — klicken, um im Mission Control dorthin zu springen",
+    "waitingOnTip": "Wartet auf {0}",
     "scheduleTitle": "Aufgabe planen",
     "scheduleWhen": "WANN",
     "scheduleConfirm": "Planen",
@@ -250,21 +264,24 @@
     "contextOpenFindings": "Findings-Ordner öffnen",
     "contextImportTickets": "Aus Ticketsystem aktualisieren",
     "contextSettings": "Einstellungen…",
+    "contextFolderSettings": "Ordner-Einstellungen…",
+    "contextRemoveFromFolder": "Aus Ordner herausnehmen",
     "newList": "Neue Liste",
     "addReposTip": "Repos als Listen hinzufügen",
-    "noRepoBannerText": "Noch kein Repo verknüpft. ClaudeDo führt Tasks in einem Git-Repo aus.",
+    "noRepoBannerText": "Noch kein Repo verknüpft. ClaudeDo führt Aufgaben in einem Git-Repo aus.",
     "noRepoBannerButton": "Repo importieren",
     "importTicketsResult": "{0} Tickets geprüft, {1} neue Tasks."
   },
   "details": {
     "deleteTaskTip": "Aufgabe löschen",
-    "killSessionTip": "Laufende Sitzung beenden",
+    "killSessionTip": "Laufende Sitzung hart beenden",
     "sendToQueue": "In Warteschlange einreihen",
     "sendToQueueTip": "Diese Aufgabe in die Warteschlange einreihen, damit Claude sie beim nächsten Lauf übernimmt",
     "copyTaskIdTip": "Aufgaben-ID kopieren",
     "starTip": "Favorit",
     "agentSettingsTip": "Agent-Einstellungen",
     "agentSettingsHeading": "Agent-Einstellungen (Überschreibungen)",
+    "waitingOnPrefix": "Wartet auf",
     "copyFormattedTip": "Titel, Beschreibung und offene Schritte kopieren",
     "toggleEditPreviewTip": "Bearbeiten/Vorschau umschalten",
     "planDay": "Tag planen",
@@ -290,7 +307,37 @@
       "steps": "Schritte",
       "files": "Dateien"
     },
-    "emptyState": "Wähle eine Aufgabe aus, um Details zu sehen"
+    "emptyState": "Wähle eine Aufgabe aus, um Details zu sehen",
+    "roadblockLabel": "ROADBLOCK",
+    "stepsCard": {
+      "preview": "Vorschau",
+      "edit": "Bearbeiten",
+      "addStepPlaceholder": "Schritt hinzufügen…"
+    },
+    "workConsole": {
+      "continue": "Fortsetzen",
+      "resetAndRetry": "Zurücksetzen & erneut versuchen",
+      "tabOutput": "Ausgabe",
+      "tabGit": "Git",
+      "tabSession": "Sitzung",
+      "outcomeLabel": "ERGEBNIS",
+      "reviewLabel": "REVIEW",
+      "mergeLabel": "MERGE",
+      "targetBranch": "Zielbranch",
+      "openDiff": "Diff öffnen",
+      "worktree": "Worktree",
+      "reviewCombinedDiff": "Kombinierten Diff prüfen",
+      "openDiffHint": "Diff öffnen, um Mergen freizuschalten",
+      "targetDirty": "Ziel-Arbeitsverzeichnis hat uncommittete Änderungen — beim Mergen werden sie gestasht und danach wiederhergestellt.",
+      "approveMerge": "Genehmigen & Mergen",
+      "park": "Parken",
+      "parkTip": "Zurückstellen — zurück auf Leerlauf, Worktree bleibt erhalten",
+      "cancel": "Abbrechen",
+      "resetDiscardBranch": "Zurücksetzen (Branch verwerfen)…",
+      "submitForReviewHint": "Von Hand daran gearbeitet? Den Worktree zum Review einreichen, um ihn zu mergen.",
+      "submitForReview": "Zum Review einreichen",
+      "outcomesLabel": "ERGEBNISSE"
+    }
   },
   "agent": {
     "openWorktreeTip": "Worktree im Datei-Explorer öffnen — benötigt einen aktiven Worktree",
@@ -299,8 +346,11 @@
   },
   "notes": {
     "today": "Heute",
-    "add": "Hinzufügen",
-    "newNotePlaceholder": "Neue Notiz…"
+    "yesterday": "Gestern",
+    "newNotePlaceholder": "Neue Notiz…",
+    "emptyHint": "Noch nichts notiert. Tippen, Enter, fertig.",
+    "deleteTip": "Notiz löschen",
+    "fromAgentTip": "Von Claude notiert"
   },
   "session": {
     "chipLive": "LIVE",
@@ -326,12 +376,17 @@
     "failed": "Fehlgeschlagen",
     "roadblock": "Blockade gemeldet",
     "openSession": "Sitzung öffnen",
+    "homeFolder": "Home (Schnellsitzung)",
     "browseForFolder": "Ordner wählen…",
     "focusMode": "Fokus",
     "overviewMode": "Übersicht",
-    "closeSession": "Sitzung beenden",
+    "closeSession": "Sitzung hart beenden",
+    "closeSessionConfirm": "Laufende Sitzung beenden? Der Claude-Prozess wird abgebrochen.",
     "conptyLaunchFailed": "Interaktive Sitzung konnte nicht geöffnet werden: {0}",
     "conptyStarting": "Sitzung wird gestartet…",
+    "conptyExited": "Sitzung beendet (Code {0}).",
+    "usageWarningNotDelivered": "Die Listen-Handler-Sitzung konnte nicht vor dem Usage-Limit gewarnt werden.",
+    "terminalSendFailed": "Konnte nicht an die Terminal-Sitzung gesendet werden.",
     "mergeHelperTitle": "Merge-Helfer",
     "mergeHelperHandoffTitleSuffix": " (Übergabe)",
     "mergeHelperTaskTitle": "Listen-Handler: {0}",
@@ -347,6 +402,10 @@
     "enqueueAlreadyOpen": "Kann nicht in die Warteschlange gestellt werden — dieser Task hat eine offene interaktive Sitzung.",
     "enqueueFailed": "In die Warteschlange stellen fehlgeschlagen: {0}",
     "queueRefreshFailed": "Warteschlange konnte nicht aktualisiert werden: {0}",
+    "abandonRun": "Lauf abbrechen",
+    "abandonRunTip": "Die noch offenen Tasks dieses Laufs abbrechen und die Sitzung schließen",
+    "abandonRunConfirm": "{0} offene Aufgabe(n) abbrechen und diese Sitzung schließen? Aufgaben im Review oder bereits erledigt bleiben unangetastet.",
+    "abandonRunFailed": "Offene Tasks konnten nicht abgebrochen werden: {0}",
     "question": {
       "title": "Claude fragt nach",
       "placeholder": "Antwort eingeben…",
@@ -380,11 +439,18 @@
       "body": "ClaudeDo kann den Hintergrund-Worker nicht erreichen. Normalerweise wird er bei der Anmeldung automatisch gestartet. Du kannst ihn jetzt starten oder neu installieren, falls das Problem bestehen bleibt.",
       "dismiss": "Ausblenden",
       "rerunInstaller": "Installer erneut ausführen",
-      "startWorker": "Worker starten"
+      "startWorker": "Worker starten",
+      "workerNotFound": "Worker-Programm nicht gefunden. Installation prüfen.",
+      "installerNotFound": "Installer nicht gefunden. Installation prüfen.",
+      "startFailed": "Start fehlgeschlagen: {0}"
     },
     "listSettings": {
       "title": "LISTENEINSTELLUNGEN",
+      "folderTitle": "ORDNER",
       "deleteList": "Liste löschen",
+      "deleteFolder": "Ordner löschen",
+      "createAsFolder": "Stattdessen einen Ordner anlegen",
+      "createAsFolderHint": "Ein Ordner gruppiert nur Listen in der Seitenleiste — er enthält keine Aufgaben und führt nichts aus. Listen per Drag-and-Drop hineinziehen.",
       "sectionGeneral": "ALLGEMEIN",
       "name": "Name",
       "workingDirectory": "Arbeitsverzeichnis",
@@ -395,6 +461,8 @@
       "manualListHint": "Neue Aufgaben in dieser Liste sind zunächst manuell: kein Einreihen, Ausführen oder Verfeinern, und die Automatik überspringt sie. Eine handgesteuerte Sitzung kannst du weiterhin öffnen.",
       "findingsTracked": "Findings-Ordner .claudedo einchecken",
       "findingsTrackedHint": "Aus: der Ordner bleibt über .git/info/exclude aus git heraus. An: Findings reisen mit dem Repo.",
+      "powerUseAllowed": "PowerUse für diese Liste erlauben",
+      "powerUseAllowedHint": "Erlaubt einem List-Handler-Run auf dieser Liste, unbeaufsichtigt zu laufen, sobald PowerUse in Einstellungen → Ausführung eingeschaltet ist: er fragt nichts, löst Konflikte selbst und sammelt neue Arbeit. Beide Schalter sind nötig — ein global aktives PowerUse ändert an einer Liste ohne Opt-in also nichts.",
       "sectionIcon": "ICON",
       "icon": "Listen-Icon",
       "iconHint": "Wird in der Seitenleiste neben dem Listennamen angezeigt.",
@@ -414,7 +482,8 @@
       "targetBranch": "Ziel-Branch",
       "removeWorktree": "Worktree nach dem Mergen entfernen",
       "commitMessage": "Commit-Nachricht",
-      "conflictedFiles": "Konfliktdateien:"
+      "conflictedFiles": "Konfliktdateien:",
+      "stashAndMerge": "Änderungen stashen und mergen"
     },
     "diff": {
       "title": "DIFF",
@@ -470,6 +539,8 @@
       "windowTitle": "Claude machen lassen",
       "scopeList": "Liste: {0}",
       "scopeReview": "Alle Listen — Tasks im Review",
+      "modelLabel": "Modell",
+      "modelTip": "Modell für die Triage-Session (Dedupe & Verfeinern). Spätere Merge-Phasen laufen immer auf Opus.",
       "confirm": "Claude machen lassen",
       "cancel": "Abbrechen",
       "selectAll": "Alle auswählen",
@@ -497,21 +568,27 @@
       "regenerate": "Neu erstellen",
       "emptyStateHint": "Noch kein Bericht für diesen Zeitraum. Klicke auf „Erstellen“."
     },
+    "cheatSheets": {
+      "title": "CHEAT SHEETS",
+      "windowTitle": "Cheat Sheets",
+      "pin": "Anpinnen",
+      "pinTooltip": "Fenster über den anderen halten",
+      "missing": "Cheat Sheet {0} nicht gefunden."
+    },
     "usageMonitor": {
       "title": "USAGE MONITOR",
       "windowTitle": "Usage Monitor",
       "noGauges": "Noch keine Nutzungslimits gemeldet.",
-      "refresh": "Jetzt aktualisieren",
-      "refreshHint": "Abruf alle 5 Min., während ein Task läuft, sonst alle 15 Min.",
+      "refreshHint": "Jetzt aktualisieren — Abruf alle 5 Min., während ein Task läuft, sonst alle 15 Min.",
       "staleFormat": "Werte veraltet (Stand {0})",
-      "staleGateHint": "Das Gate greift in diesem Zustand nicht.",
+      "staleGateHint": "Der Limit-Stopp greift in diesem Zustand nicht.",
       "gateBlockedFormat": "Warteschlange pausiert — {0}",
       "throttleFormat": "Warteschlange gedrosselt: {0}/{1} Slots ({2})",
       "resetIn": "Reset in {0} ({1})",
       "dragHint": "Marker ziehen oder Wert unten eintragen.",
       "legendSoft": "Soft · 2 Slots",
       "legendHard": "Hard · 1 Slot",
-      "legendGate": "Gate · Pause",
+      "legendGate": "Limit-Stopp · Pause",
       "gaugeSession": "Session (5 Std.)",
       "gaugeWeeklyAll": "Woche (alle Modelle)",
       "gaugeWeeklyScopedFormat": "Woche ({0})",
@@ -531,7 +608,7 @@
       "columnOtherOut": "ÜBRIGES OUT",
       "columnOtherCache": "ÜBRIGES CACHE",
       "columnShare": "ANTEIL",
-      "columnTask": "TASK",
+      "columnTask": "AUFGABE",
       "columnList": "LISTE",
       "columnModelShort": "MODELL",
       "columnRuns": "RUNS",
@@ -635,35 +712,61 @@
   "checks": {
     "git": {
       "title": "Git",
-      "hint": "Installiere Git und stelle sicher, dass es im PATH liegt."
+      "hint": "Installiere Git von https://git-scm.com/downloads und starte den Installer neu.",
+      "notFound": "git wurde nicht im PATH gefunden.",
+      "exitCode": "'{0}' wurde mit Exitcode {1} beendet.",
+      "resolvedFormat": "{0} — {1}"
     },
     "gitIdentity": {
       "title": "Git-Identität",
-      "hint": "Lege deine Git-Identität fest: git config --global user.name \"...\" und user.email \"...\"."
+      "hint": "Führe aus: git config --global user.name \"Dein Name\" und git config --global user.email \"du@example.com\"",
+      "notFound": "git wurde nicht gefunden — Identität konnte nicht geprüft werden.",
+      "missing": "Fehlende Git-Identität: {0}."
     },
     "ports": {
       "title": "Ports",
-      "hint": "Gib den Port frei oder ändere ihn nach der Installation auf der Worker-Seite."
+      "hint": "Ändere die SignalR-/MCP-Ports auf der Dienste-Seite, oder beende den blockierenden Prozess.",
+      "inUse": "{0}-Port {1} ist belegt.",
+      "inUseBy": "{0}-Port {1} ist belegt von '{2}'.",
+      "inUseByOwnWorker": "Belegt vom laufenden ClaudeDo Worker: {0}.",
+      "available": "Ports sind verfügbar."
     },
     "writeAccess": {
       "title": "Schreibzugriff",
-      "hint": "Wähle ein anderes Installationsverzeichnis oder starte den Installer als Administrator."
+      "hint": "Wähle ein anderes Installationsverzeichnis oder starte den Installer mit ausreichenden Rechten (z. B. als Administrator).",
+      "cannotWrite": "Kein Schreibzugriff auf '{0}': {1}",
+      "writable": "Installations- und Datenverzeichnis sind beschreibbar."
     },
     "claudeCli": {
       "title": "Claude CLI",
-      "hint": "Installiere die Claude CLI und stelle sicher, dass sie im PATH liegt."
+      "hint": "Installiere die Claude CLI (npm install -g @anthropic-ai/claude-code) und starte danach dein Terminal/deine Anmeldesitzung neu, damit der aktualisierte PATH greift.",
+      "notFound": "'{0}' wurde nicht im PATH gefunden. Durchsucht: {1}.",
+      "exitCode": "'{0}' wurde mit Exitcode {1} beendet.",
+      "resolvedFormat": "{0} — {1}"
     },
     "claudeVersion": {
       "title": "Claude-CLI-Version",
-      "hint": "Aktualisiere die Claude CLI auf eine neuere Version."
+      "hint": "Aktualisiere die CLI: npm update -g @anthropic-ai/claude-code",
+      "notFound": "Die claude-CLI wurde nicht gefunden — Version konnte nicht geprüft werden.",
+      "parseFailed": "Konnte keine Version aus '{0}' auslesen.",
+      "tooOld": "claude {0} ist älter als die erforderliche Version {1}.",
+      "ok": "claude {0} erfüllt die Mindestanforderung ({1})."
     },
     "claudeAuth": {
-      "title": "Claude-Anmeldung",
-      "hint": "Führe 'claude auth login' aus, um dich anzumelden."
+      "title": "Claude-CLI-Login",
+      "hint": "Starte 'claude' einmal und schließe den Login-Vorgang ab.",
+      "notFound": "Die claude-CLI wurde nicht gefunden — Login konnte nicht geprüft werden.",
+      "undetermined": "Login-Status konnte nicht ermittelt werden.",
+      "notLoggedIn": "Nicht angemeldet.",
+      "loggedIn": "Angemeldet."
     },
     "permissionModeAuto": {
       "title": "Berechtigungsmodus",
-      "hint": "Aktualisiere die Claude CLI auf eine Version, die --permission-mode auto unterstützt."
+      "hint": "Aktualisiere die CLI: npm update -g @anthropic-ai/claude-code. ClaudeDo funktioniert auch im Modus acceptEdits/default, dann mit mehr Rückfragen.",
+      "notFound": "Die claude-CLI wurde nicht gefunden — Unterstützung für permission-mode konnte nicht geprüft werden.",
+      "undetermined": "Konnte nicht ermitteln, ob --permission-mode auto unterstützt wird.",
+      "ok": "--permission-mode auto wird von dieser CLI erkannt.",
+      "notListed": "Diese claude-CLI-Version listet 'auto' nicht als --permission-mode-Option."
     }
   },
   "planning": {
@@ -691,6 +794,9 @@
     "abort": "Merge abbrechen"
   },
   "controls": {
+    "markdown": {
+      "copy": "Befehl kopieren"
+    },
     "datePicker": {
       "today": "Heute",
       "tomorrow": "Morgen",
@@ -700,6 +806,14 @@
       "done": "Fertig"
     }
   },
+  "dialog": {
+    "cancel": "Abbrechen",
+    "confirm": "Bestätigen",
+    "delete": "Löschen",
+    "ok": "OK",
+    "confirmTitle": "Bestätigen",
+    "errorTitle": "Fehler"
+  },
   "shell": {
     "menu": {
       "help": "Hilfe",
@@ -707,9 +821,18 @@
       "repositories": "Repositories",
       "checkForUpdates": "Nach Updates suchen",
       "restartWorker": "Worker neu starten",
+      "updateClaudeCli": "Claude CLI aktualisieren",
+      "shutdown": "Beenden",
       "worktrees": "Worktrees…",
       "weeklyReport": "Wochenbericht…",
       "usageMonitor": "Usage Monitor…",
+      "cheatSheets": "Cheat Sheets",
+      "cheatSheetGit": "Git…",
+      "cheatSheetCommits": "Conventional Commits…",
+      "cheatSheetClaude": "Claude CLI…",
+      "cheatSheetClaudeConfig": "Claude-Konfiguration…",
+      "cheatSheetDotnet": "dotnet CLI…",
+      "cheatSheetPowershell": "PowerShell…",
       "about": "Über…",
       "addRepos": "Repos als Listen hinzufügen…"
     },
@@ -718,9 +841,6 @@
       "updateNow": "Jetzt aktualisieren",
       "dismiss": "Ausblenden"
     },
-    "staleWorker": {
-      "message": "Der Worker läuft auf einem älteren Stand als der gemergte main-Branch dieses Repos — Neustart nötig, damit gemergte Änderungen wirken."
-    },
     "externalMerge": {
       "banner": "Eine Claude-Session löst gerade einen Merge-Konflikt auf — bitte keine Dateien im Repository bearbeiten.",
       "open": "Resolver öffnen"
@@ -728,19 +848,19 @@
   },
   "vm": {
     "connection": { "online": "Online", "connecting": "Verbinden…", "offline": "Offline" },
-    "shell": { "restartingWorker": "Worker wird neu gestartet…", "unexpectedError": "Unerwarteter Fehler: {0}" },
+    "shell": { "unexpectedError": "Unerwarteter Fehler: {0}", "shutdownConfirm": "Dadurch wird der ClaudeDo-Worker beendet (laufende Task-Runs und interaktive Sitzungen brechen ab) und die App geschlossen. Fortfahren?" },
     "mainWindow": { "closeConfirm": { "message": "{0} Mission-Control-Sitzung(en) laufen noch. Beim Beenden werden sie abgebrochen. Trotzdem schließen?" } },
     "agentStatus": { "idle": "Leerlauf", "queued": "In Warteschlange", "running": "Läuft", "review": "Prüfung", "children": "Wartet auf Teilaufgaben", "done": "Fertig", "failed": "Fehlgeschlagen", "cancelled": "Abgebrochen" },
-    "taskStatus": { "idle": "Leerlauf", "queued": "In Warteschlange", "running": "Läuft", "waitingForReview": "Wartet auf Prüfung", "waitingForChildren": "Wartet auf Teilaufgaben", "done": "Fertig", "failed": "Fehlgeschlagen", "cancelled": "Abgebrochen", "parked": "Geparkt", "interactive": "Interaktiv" },
+    "taskStatus": { "idle": "Leerlauf", "queued": "In Warteschlange", "running": "Läuft", "waitingForReview": "Wartet auf Prüfung", "waitingForChildren": "Wartet auf Teilaufgaben", "done": "Fertig", "failed": "Fehlgeschlagen", "cancelled": "Abgebrochen", "parked": "Geparkt", "interactive": "Interaktiv", "waiting": "Wartet" },
     "failureReason": { "maxTurns": "Turn-Limit erreicht", "timeout": "Zeitüberschreitung", "usageLimit": "Nutzungslimit erreicht", "error": "Fehler", "cancelled": "Abgebrochen", "unknown": "Grund unbekannt" },
     "failureReasonTooltip": { "maxTurns": "Turn-Limit erreicht ({0}/{1} Turns) — der Worktree ist meist brauchbar; Task fortsetzen statt zurücksetzen." },
     "planningBadge": { "active": "PLANUNG", "finalized": "GEPLANT" },
     "taskRow": { "createdPrefix": "Erstellt {0}", "stepsText": "{0}/{1} Schritte" },
     "queue": { "baseDirtyWarning": "Achtung: Das Repo dieser Liste hat uncommittete Änderungen ({0} geändert, {1} untracked) — ein neuer Worktree startet vom letzten Commit und enthält sie nicht." },
-    "tasksIsland": { "completedHeader": "ABGESCHLOSSEN", "completedHeaderCount": "ABGESCHLOSSEN · {0}", "planningResumeFailed": "Planungssitzung konnte nicht fortgesetzt werden: {0}", "approveFailed": "Genehmigen & Mergen fehlgeschlagen: {0}", "cancelReviewFailed": "Prüfung abbrechen fehlgeschlagen: {0}", "sendToQueueFailed": "In die Warteschlange stellen fehlgeschlagen: {0}", "queuePlanBlockedInteractive": "Plan kann nicht in die Warteschlange gestellt werden — {0} hat eine offene interaktive Sitzung und muss zuerst geschlossen werden.", "moveRunningRejected": "Ein laufender Task kann nicht in eine andere Liste verschoben werden.", "moveWorktreeRejected": "Verschieben nicht möglich — dieser Task hat einen aktiven Worktree, der auf sein aktuelles Repo zeigt.", "moveRepoConfirm": "Unterschiedliche Repos — {0} → {1}. Task trotzdem verschieben?", "moveConfirmUnavailable": "Verschieben nicht möglich — der Bestätigungsdialog ist nicht verfügbar.", "quickClaudeNoWorkingDir": "Für diese Liste ist kein Arbeitsverzeichnis konfiguriert.", "quickClaudeDirMissing": "Arbeitsverzeichnis existiert nicht mehr: {0}", "setStatusFailed": "Status konnte nicht aktualisiert werden: {0}", "cancelFailed": "Abbrechen fehlgeschlagen: {0}", "rejectToQueueFailed": "Zurückweisen in die Warteschlange fehlgeschlagen: {0}", "rejectToIdleFailed": "Zurückweisen fehlgeschlagen: {0}", "deleteTaskConfirm": "\"{0}\" löschen? Dies kann nicht rückgängig gemacht werden.", "deleteTaskFailed": "Löschen fehlgeschlagen: {0}", "toggleDoneFailed": "Erledigt-Status konnte nicht aktualisiert werden: {0}", "removeFromQueueFailed": "Aus der Warteschlange entfernen fehlgeschlagen: {0}", "openWorktreeFailed": "Worktree konnte nicht geöffnet werden: {0}" },
+    "tasksIsland": { "completedHeader": "ABGESCHLOSSEN", "completedHeaderCount": "ABGESCHLOSSEN · {0}", "statusPill": "{0} laufend · {1} Prüfung", "openTaskOne": "1 offene Aufgabe", "openTasks": "{0} offene Aufgaben", "planningResumeFailed": "Planungssitzung konnte nicht fortgesetzt werden: {0}", "approveFailed": "Genehmigen & Mergen fehlgeschlagen: {0}", "cancelReviewFailed": "Prüfung abbrechen fehlgeschlagen: {0}", "sendToQueueFailed": "In die Warteschlange stellen fehlgeschlagen: {0}", "queuePlanBlockedInteractive": "Plan kann nicht in die Warteschlange gestellt werden — {0} hat eine offene interaktive Sitzung und muss zuerst geschlossen werden.", "moveRunningRejected": "Ein laufender Task kann nicht in eine andere Liste verschoben werden.", "moveWorktreeRejected": "Verschieben nicht möglich — dieser Task hat einen aktiven Worktree, der auf sein aktuelles Repo zeigt.", "moveRepoConfirm": "Unterschiedliche Repos — {0} → {1}. Task trotzdem verschieben?", "moveConfirmUnavailable": "Verschieben nicht möglich — der Bestätigungsdialog ist nicht verfügbar.", "quickClaudeNoWorkingDir": "Für diese Liste ist kein Arbeitsverzeichnis konfiguriert.", "quickClaudeDirMissing": "Arbeitsverzeichnis existiert nicht mehr: {0}", "setStatusFailed": "Status konnte nicht aktualisiert werden: {0}", "cancelFailed": "Abbrechen fehlgeschlagen: {0}", "rejectToQueueFailed": "Zurückweisen in die Warteschlange fehlgeschlagen: {0}", "rejectToIdleFailed": "Zurückweisen fehlgeschlagen: {0}", "deleteTaskConfirm": "\"{0}\" löschen? Dies kann nicht rückgängig gemacht werden.", "deleteTaskFailed": "Löschen fehlgeschlagen: {0}", "toggleDoneFailed": "Erledigt-Status konnte nicht aktualisiert werden: {0}", "removeFromQueueFailed": "Aus der Warteschlange entfernen fehlgeschlagen: {0}", "openWorktreeFailed": "Worktree 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).", "buildFailed": "Kombinierte Vorschau konnte nicht erstellt werden: {0}" },
-    "merge": { "commitMessage": "chore: merge {0}", "progressMerging": "Wird zusammengeführt…", "progressVerifying": "Verify-Kommando der Liste läuft… ({0})", "workerOfflineBranches": "Worker offline — Branches können nicht aufgelistet werden.", "loadBranchesFailed": "Branches konnten nicht geladen werden: {0}", "merged": "Zusammengeführt.", "blocked": "Blockiert: {0}", "verifyFailed": "Merge ist gelandet, aber das Verify-Kommando der Liste ist fehlgeschlagen — die Aufgabe wurde nicht auf Erledigt gesetzt.", "untrackedCollision": "Merge abgelehnt — er würde eine unversionierte Datei im Ziel-Arbeitsverzeichnis überschreiben.", "unknownStatus": "Unbekannter Status: {0}", "mergeFailed": "Merge fehlgeschlagen: {0}" },
+    "merge": { "commitMessage": "chore: merge {0}", "progressMerging": "Wird zusammengeführt…", "progressVerifying": "Verify-Kommando der Liste läuft… ({0})", "workerOfflineBranches": "Worker offline — Branches können nicht aufgelistet werden.", "loadBranchesFailed": "Branches konnten nicht geladen werden: {0}", "merged": "Zusammengeführt.", "blocked": "Blockiert: {0}", "verifyFailed": "Merge ist gelandet, aber das Verify-Kommando der Liste ist fehlgeschlagen — die Aufgabe wurde nicht auf Erledigt gesetzt.", "untrackedCollision": "Merge abgelehnt — er würde eine unversionierte Datei im Ziel-Arbeitsverzeichnis überschreiben.", "dirtyTarget": "Merge abgelehnt — das Ziel-Arbeitsverzeichnis hat uncommittete Änderungen.", "targetDirty": "Das Ziel-Arbeitsverzeichnis hat bereits uncommittete Änderungen — stashen und mergen?", "unknownStatus": "Unbekannter Status: {0}", "mergeFailed": "Merge fehlgeschlagen: {0}" },
     "settingsModal": { "workerOffline": "Worker offline — Einstellungen schreibgeschützt.", "saveFailed": "Speichern fehlgeschlagen: {0}" },
     "onlineInbox": { "workerOffline": "Worker offline — Konfiguration kann nicht geladen werden.", "saved": "Konfiguration gespeichert.", "saveFailed": "Speichern fehlgeschlagen: {0}", "signedIn": "Erfolgreich angemeldet.", "signedInNoRole": "Angemeldet, aber diesem Konto fehlt die Rolle 'user' in Zitadel — die Online-Synchronisierung wird abgelehnt, bis die Rolle im ClaudeDo-Projekt zugewiesen wird.", "signInFailed": "Anmeldung fehlgeschlagen: {0}", "signedOut": "Abgemeldet.", "signOutFailed": "Abmeldung fehlgeschlagen: {0}" },
     "tickets": { "connectionOk": "Verbunden als {0}.", "connectionMissingScopes": "Verbunden als {0}, aber es fehlen Scopes: {1}", "tokenCleared": "Token entfernt.", "workerOffline": "Worker nicht erreichbar." },
@@ -759,12 +879,12 @@
     "sessionSkillsTab": { "installed": "Installiert: {0}", "installFailed": "Installation fehlgeschlagen: {0}", "updated": "Aktualisiert.", "updateFailed": "Aktualisierung fehlgeschlagen: {0}", "removed": "Entfernt.", "removeFailed": "Entfernen fehlgeschlagen: {0}" },
     "worktreesTab": { "workerOffline": "Worker offline.", "removed": "{0} Worktree(s) entfernt.", "blocked": "Zwangsentfernung nicht möglich: {0} Aufgabe(n) laufen noch. Brich sie zuerst ab.", "removedFrom": "{0} Worktree(s) von {1} Aufgabe(n) entfernt.", "cleanupFailed": "Aufräumen fehlgeschlagen: {0}", "resetFailed": "Zurücksetzen fehlgeschlagen: {0}" },
     "worktreesOverview": { "titleAll": "Worktrees", "titleList": "Worktrees — {0}", "listFallback": "Liste", "cleanupFailed": "Aufräumen fehlgeschlagen.", "cleanupFailedDetailed": "Aufräumen fehlgeschlagen: {0}", "removed": "{0} Worktree(s) entfernt.", "discardConfirm": "Worktree für \"{0}\" verwerfen? Nicht committete Arbeit geht verloren.", "discardFailed": "Worktree konnte nicht verworfen werden.", "keepFailed": "Worktree konnte nicht behalten werden.", "cannotForceRunning": "Eine laufende Aufgabe kann nicht zwangsweise entfernt werden.", "forceRemoveFailed": "Zwangsentfernung fehlgeschlagen.", "forceRemoveFailedDetailed": "Zwangsentfernung fehlgeschlagen: {0}", "batchDone": "{0} gemergt, {1} zu lösen.", "openInExplorerFailed": "Pfad konnte nicht geöffnet werden: {0}" },
-    "listSettings": { "untitled": "Unbenannt", "ticketProjectNone": "— keins —" },
-    "detailsIsland": { "verifyFailed": "Merge ist erfolgt, aber das Verifikationskommando der Liste ist fehlgeschlagen — die Aufgabe wurde nicht auf 'Erledigt' gesetzt.", "untrackedCollision": "Merge abgelehnt — er würde eine unversionierte Datei im Ziel-Arbeitsverzeichnis überschreiben.", "stopOffline": "Worker offline — Task kann nicht gestoppt werden.", "stopFailed": "Stoppen fehlgeschlagen: {0}", "enqueueFailed": "In die Warteschlange stellen fehlgeschlagen: {0}", "dequeueFailed": "Aus der Warteschlange entfernen fehlgeschlagen: {0}", "resetAndRetryFailed": "Zurücksetzen & erneut versuchen fehlgeschlagen: {0}", "toggleDoneFailed": "Erledigt-Status konnte nicht aktualisiert werden: {0}" },
+    "listSettings": { "untitled": "Unbenannt", "ticketProjectNone": "— keins —", "loadFailed": "Listeneinstellungen konnten nicht geladen werden: {0}", "ticketProjectsLoadFailed": "Ticket-Projekte konnten nicht geladen werden: {0}", "confirmDeleteFolder": "Ordner \"{0}\" löschen? Die Listen darin bleiben erhalten und wandern auf die oberste Ebene.", "confirmDeleteList": "Liste \"{0}\" und alle ihre Aufgaben löschen? Das kann nicht rückgängig gemacht werden.", "deleteBlockedPlanning": "Diese Liste hat Planungssitzungen mit Kind-Aufgaben. Erst diese verwerfen, dann die Liste löschen.", "workingDirMissing": "Dieser Ordner existiert nicht.", "workingDirNotRepo": "Dieser Ordner ist noch kein Git-Repository. Führe darin zuerst `git init` aus, oder leere das Arbeitsverzeichnis, um dies als manuelle Liste zu speichern." },
+    "detailsIsland": { "verifyFailed": "Merge ist erfolgt, aber das Verifikationskommando der Liste ist fehlgeschlagen — die Aufgabe wurde nicht auf 'Erledigt' gesetzt.", "untrackedCollision": "Merge abgelehnt — er würde eine unversionierte Datei im Ziel-Arbeitsverzeichnis überschreiben.", "dirtyTarget": "Merge abgelehnt — das Ziel-Arbeitsverzeichnis hat uncommittete Änderungen.", "stashAndMergeConfirm": "Das Ziel-Arbeitsverzeichnis hat uncommittete Änderungen.\nStashen, mergen und danach wiederherstellen?", "stopOffline": "Worker offline — Task kann nicht gestoppt werden.", "stopFailed": "Stoppen fehlgeschlagen: {0}", "enqueueFailed": "In die Warteschlange stellen fehlgeschlagen: {0}", "dequeueFailed": "Aus der Warteschlange entfernen fehlgeschlagen: {0}", "resetAndRetryFailed": "Zurücksetzen & erneut versuchen fehlgeschlagen: {0}", "toggleDoneFailed": "Erledigt-Status konnte nicht aktualisiert werden: {0}" },
     "mergeSection": { "openWorktreeFailed": "Worktree konnte nicht geöffnet werden: {0}" },
     "about": { "openPathFailed": "Pfad konnte nicht geöffnet werden: {0}" },
-    "lists": { "localSuffix": "{0} / lokal", "smartMyDay": "Mein Tag", "smartImportant": "Wichtig", "smartPlanned": "Geplant", "virtualQueue": "Warteschlange", "virtualRunning": "Läuft", "virtualReview": "Prüfung", "newList": "Neue Liste", "findingsNotFound": "Für diese Liste gibt es noch keine Findings.", "findingsOpenFailed": "Findings-Ordner konnte nicht geöffnet werden: {0}", "openInExplorerFailed": "Pfad konnte nicht geöffnet werden: {0}" },
-    "repoImport": { "loadFailed": "Gespeicherte Ordner konnten nicht geladen werden: {0}", "saveFailed": "Ordner konnten nicht gespeichert werden: {0}" }
+    "lists": { "localSuffix": "{0} / lokal", "smartMyDay": "Mein Tag", "smartImportant": "Wichtig", "smartPlanned": "Geplant", "smartNotes": "Notizen", "virtualQueue": "Warteschlange", "virtualRunning": "Läuft", "virtualReview": "Prüfung", "newList": "Neue Liste", "findingsNotFound": "Für diese Liste gibt es noch keine Findings.", "findingsOpenFailed": "Findings-Ordner konnte nicht geöffnet werden: {0}", "openInExplorerFailed": "Pfad konnte nicht geöffnet werden: {0}" },
+    "repoImport": { "loadFailed": "Gespeicherte Ordner konnten nicht geladen werden: {0}", "saveFailed": "Ordner konnten nicht gespeichert werden: {0}", "createButton": "{0} Liste(n) erstellen" }
   },
   "ops": {
     "stalledHint": "Läuft weiter — Worker antwortet noch",
@@ -832,39 +952,5 @@
       "lastError": "Letzter Fehler: {0}",
       "throttled": "Gedrosselt: {0}/{1} Slots ({2})"
     }
-  },
-  "checks": {
-    "git": {
-      "title": "Git",
-      "hint": "Installiere Git von https://git-scm.com/downloads und starte den Installer neu."
-    },
-    "gitIdentity": {
-      "title": "Git-Identität",
-      "hint": "Führe aus: git config --global user.name \"Dein Name\" und git config --global user.email \"du@example.com\""
-    },
-    "ports": {
-      "title": "Ports",
-      "hint": "Ändere die SignalR-/MCP-Ports auf der Dienste-Seite, oder beende den blockierenden Prozess."
-    },
-    "writeAccess": {
-      "title": "Schreibzugriff",
-      "hint": "Wähle ein anderes Installationsverzeichnis oder starte den Installer mit ausreichenden Rechten (z. B. als Administrator)."
-    },
-    "claudeCli": {
-      "title": "Claude CLI",
-      "hint": "Installiere die Claude CLI (npm install -g @anthropic-ai/claude-code) und starte danach dein Terminal/deine Anmeldesitzung neu, damit der aktualisierte PATH greift."
-    },
-    "claudeVersion": {
-      "title": "Claude-CLI-Version",
-      "hint": "Aktualisiere die CLI: npm update -g @anthropic-ai/claude-code"
-    },
-    "claudeAuth": {
-      "title": "Claude-CLI-Login",
-      "hint": "Starte 'claude' einmal und schließe den Login-Vorgang ab."
-    },
-    "permissionModeAuto": {
-      "title": "Unterstützung für --permission-mode auto",
-      "hint": "Aktualisiere die CLI: npm update -g @anthropic-ai/claude-code. ClaudeDo funktioniert auch im Modus acceptEdits/default, dann mit mehr Rückfragen."
-    }
   }
 }

src/ClaudeDo.Localization/locales/en.json

@@ -11,6 +11,7 @@
       "categoryGeneral": "General",
       "categoryExecution": "Execution",
       "categoryPrime": "Prime Claude",
+      "categoryPrimeHint": "Scheduled Claude runs: Ping, Fill My Day, or a custom prompt, at fixed times.",
       "categoryWorktrees": "Worktrees",
       "categoryFiles": "Files & Prompts",
       "categorySkills": "Session Skills",
@@ -27,6 +28,7 @@
       "model": "Model",
       "maxTurns": "Max turns",
       "effort": "Effort",
+      "effortHint": "Reasoning effort the model applies. Higher costs more and reasons deeper.",
       "modelPresets": "Per-model defaults",
       "modelPresetsHint": "Reasoning effort and turn budget used when a session runs under that model. List- and task-level max-turn overrides still win.",
       "maxTurnsCeiling": "Max turns ceiling",
@@ -41,6 +43,16 @@
       "usageGateSevenDayPct": "7-day window (%)",
       "autoContinueOnUsageLimit": "Continue on session limit reset",
       "autoContinueOnUsageLimitHint": "When a run stops because it hit the usage limit, automatically continue it once the 5-hour window resets. Also wakes the paused queue exactly at reset time instead of waiting for the next backstop check.",
+      "listHandlerMaxHandoffs": "List-handler handoff budget",
+      "listHandlerMaxHandoffsHint": "How many wait/merge handoffs one \"Let Claude handle it\" run may chain. 4 means two merge rounds. Raise it for runs meant to keep going for hours; it bounds a runaway chain, so it cannot be 0.",
+      "powerUseHeading": "PowerUse",
+      "powerUse": "Enable PowerUse",
+      "powerUseHint": "Spend the rest of the window: a list-handler run asks nothing, resolves conflicts itself, harvests new work, and keeps handing off for as long as its budget allows. Only affects lists that allowed PowerUse in their list settings.",
+      "powerUseWindow": "Only between",
+      "powerUseWindowPlaceholder": "HH:mm",
+      "powerUseHandoffPct": "Hand off at (% of 5h)",
+      "powerUseWindowHint": "Leave both times empty for round the clock. A window is checked whenever a handler phase starts, so a chain that runs past the end time continues without PowerUse.",
+      "powerUseWindowInvalid": "PowerUse window times must be HH:mm, or left blank.",
       "throttleStagesHeading": "Throttle stages",
       "throttleStagesHint": "Parallelism is capped before the hard gate: soft caps at 2 slots, hard at 1. Edited by dragging the markers on the usage-monitor gauges. Opening the monitor closes these settings — save first if you changed anything.",
       "throttleStagesValues": "5h: soft {0}% / hard {1}%  ·  7d: soft {2}% / hard {3}%",
@@ -85,6 +97,7 @@
       "retryPrompt": "Retry",
       "dailyPrepPrompt": "Daily prep",
       "weeklyReportPrompt": "Weekly report",
+      "powerUsePrompt": "PowerUse addendum",
       "viewPrompt": "View",
       "customizedSection": "CUSTOMIZED",
       "customizedHint": "These prompts differ from the bundled default and are kept as-is. Reset to pick up future default improvements.",
@@ -177,7 +190,6 @@
     "listSettingsTip": "List settings",
     "addPlaceholder": "Add a task…",
     "enterKey": "ENTER",
-    "notesPinnedRow": "Notes (daily notes)",
     "clearDayTip": "Clear day",
     "planMyDayTip": "Plan My Day",
     "overdue": "OVERDUE",
@@ -209,6 +221,7 @@
     "ctxRefineTask": "Refine task",
     "ctxPlanning": "Planning",
     "ctxSchedule": "Schedule",
+    "ctxMoveToList": "Move to list",
     "ctxDeleteTask": "Delete task",
     "reasonAlreadyRunning": "Task is already running",
     "reasonAlreadyQueued": "Already in the queue",
@@ -229,6 +242,7 @@
     "toggleSubtasksTip": "Expand / collapse subtasks",
     "agentSuggestedTip": "Suggested by the agent",
     "interactiveChipTip": "Interactive session open — click to jump to it in Mission Control",
+    "waitingOnTip": "Waiting on {0}",
     "scheduleTitle": "Schedule task",
     "scheduleWhen": "WHEN",
     "scheduleConfirm": "Schedule",
@@ -250,6 +264,8 @@
     "contextOpenFindings": "Open findings folder",
     "contextImportTickets": "Update from ticket system",
     "contextSettings": "Settings…",
+    "contextFolderSettings": "Folder settings…",
+    "contextRemoveFromFolder": "Move out of folder",
     "newList": "New list",
     "addReposTip": "Add repos as lists",
     "noRepoBannerText": "No repo linked yet. ClaudeDo runs tasks in a git repo.",
@@ -265,6 +281,7 @@
     "starTip": "Star",
     "agentSettingsTip": "Agent settings",
     "agentSettingsHeading": "Agent settings (overrides)",
+    "waitingOnPrefix": "Waiting on",
     "copyFormattedTip": "Copy title, description and open steps",
     "toggleEditPreviewTip": "Toggle edit/preview",
     "planDay": "Plan day",
@@ -290,7 +307,37 @@
       "steps": "Steps",
       "files": "Files"
     },
-    "emptyState": "Select a task to see its details"
+    "emptyState": "Select a task to see its details",
+    "roadblockLabel": "ROADBLOCK",
+    "stepsCard": {
+      "preview": "Preview",
+      "edit": "Edit",
+      "addStepPlaceholder": "Add step…"
+    },
+    "workConsole": {
+      "continue": "Continue",
+      "resetAndRetry": "Reset & Retry",
+      "tabOutput": "Output",
+      "tabGit": "Git",
+      "tabSession": "Session",
+      "outcomeLabel": "OUTCOME",
+      "reviewLabel": "REVIEW",
+      "mergeLabel": "MERGE",
+      "targetBranch": "Target branch",
+      "openDiff": "Open Diff",
+      "worktree": "Worktree",
+      "reviewCombinedDiff": "Review Combined Diff",
+      "openDiffHint": "Open the diff to enable merge",
+      "targetDirty": "Target working directory has uncommitted changes — merging will stash and restore them.",
+      "approveMerge": "Approve & Merge",
+      "park": "Park",
+      "parkTip": "Set aside — back to Idle, keeps the worktree",
+      "cancel": "Cancel",
+      "resetDiscardBranch": "Reset (discard branch)…",
+      "submitForReviewHint": "Worked on this by hand? Submit the worktree for review to merge it.",
+      "submitForReview": "Submit for review",
+      "outcomesLabel": "OUTCOMES"
+    }
   },
   "agent": {
     "openWorktreeTip": "Open worktree in file explorer — requires an active worktree",
@@ -299,8 +346,11 @@
   },
   "notes": {
     "today": "Today",
-    "add": "Add",
-    "newNotePlaceholder": "New note…"
+    "yesterday": "Yesterday",
+    "newNotePlaceholder": "New note…",
+    "emptyHint": "Nothing noted yet. Type, hit Enter, done.",
+    "deleteTip": "Delete note",
+    "fromAgentTip": "Written by Claude"
   },
   "session": {
     "chipLive": "LIVE",
@@ -326,12 +376,17 @@
     "failed": "Failed",
     "roadblock": "Roadblock reported",
     "openSession": "Open session",
+    "homeFolder": "Home (quick session)",
     "browseForFolder": "Choose folder…",
     "focusMode": "Focus",
     "overviewMode": "Overview",
     "closeSession": "Kill session",
+    "closeSessionConfirm": "End the running session? The Claude process will be aborted.",
     "conptyLaunchFailed": "Couldn't open interactive session: {0}",
     "conptyStarting": "Starting session…",
+    "conptyExited": "Session ended (code {0}).",
+    "usageWarningNotDelivered": "Couldn't warn the list-handler session about the usage limit.",
+    "terminalSendFailed": "Couldn't send that to the terminal session.",
     "mergeHelperTitle": "Merge Helper",
     "mergeHelperHandoffTitleSuffix": " (Handoff)",
     "mergeHelperTaskTitle": "List handler: {0}",
@@ -347,6 +402,10 @@
     "enqueueAlreadyOpen": "Can't queue — this task has an open interactive session.",
     "enqueueFailed": "Queue failed: {0}",
     "queueRefreshFailed": "Couldn't refresh the queue: {0}",
+    "abandonRun": "Abandon run",
+    "abandonRunTip": "Cancel this run's still-open tasks and close the session",
+    "abandonRunConfirm": "Cancel {0} open task(s) and close this session? Tasks already in review or done are not affected.",
+    "abandonRunFailed": "Couldn't cancel the open tasks: {0}",
     "question": {
       "title": "Claude is asking",
       "placeholder": "Type your answer…",
@@ -380,11 +439,18 @@
       "body": "ClaudeDo can't reach the background worker. It is normally started automatically at logon. You can start it now, or reinstall if the problem persists.",
       "dismiss": "Dismiss",
       "rerunInstaller": "Rerun Installer",
-      "startWorker": "Start Worker"
+      "startWorker": "Start Worker",
+      "workerNotFound": "Worker executable not found. Check the installation.",
+      "installerNotFound": "Installer not found. Check the installation.",
+      "startFailed": "Start failed: {0}"
     },
     "listSettings": {
       "title": "LIST SETTINGS",
+      "folderTitle": "FOLDER",
       "deleteList": "Delete list",
+      "deleteFolder": "Delete folder",
+      "createAsFolder": "Create a folder instead",
+      "createAsFolderHint": "A folder just groups lists in the sidebar — it holds no tasks and runs nothing. Drag lists onto it to fill it.",
       "sectionGeneral": "GENERAL",
       "name": "Name",
       "workingDirectory": "Working directory",
@@ -395,6 +461,8 @@
       "manualListHint": "New tasks in this list start out manual: no queueing, running or refining, and automation skips them. You can still open a hand-driven session.",
       "findingsTracked": "Commit the .claudedo findings folder",
       "findingsTrackedHint": "Off: the folder stays out of git via .git/info/exclude. On: findings travel with the repo.",
+      "powerUseAllowed": "Allow PowerUse for this list",
+      "powerUseAllowedHint": "Lets a list-handler run on this list go unattended when PowerUse is switched on in Settings → Execution: it asks nothing, resolves conflicts itself, and harvests new work. Both switches are needed, so leaving PowerUse on globally never changes a list that hasn't opted in.",
       "sectionIcon": "ICON",
       "icon": "List icon",
       "iconHint": "Shown next to the list name in the sidebar.",
@@ -414,7 +482,8 @@
       "targetBranch": "Target branch",
       "removeWorktree": "Remove worktree after merge",
       "commitMessage": "Commit message",
-      "conflictedFiles": "Conflicted files:"
+      "conflictedFiles": "Conflicted files:",
+      "stashAndMerge": "Stash changes and merge"
     },
     "diff": {
       "title": "DIFF",
@@ -470,6 +539,8 @@
       "windowTitle": "Let Claude handle it",
       "scopeList": "List: {0}",
       "scopeReview": "All lists — tasks waiting for review",
+      "modelLabel": "Model",
+      "modelTip": "Model for the triage session (dedupe & refine). Later merge phases always run on opus.",
       "confirm": "Let Claude handle it",
       "cancel": "Cancel",
       "selectAll": "Select all",
@@ -497,12 +568,18 @@
       "regenerate": "Regenerate",
       "emptyStateHint": "No report for this range yet. Click “Generate”."
     },
+    "cheatSheets": {
+      "title": "CHEAT SHEETS",
+      "windowTitle": "Cheat Sheets",
+      "pin": "Pin",
+      "pinTooltip": "Keep this window on top of the others",
+      "missing": "Cheat sheet {0} not found."
+    },
     "usageMonitor": {
       "title": "USAGE MONITOR",
       "windowTitle": "Usage Monitor",
       "noGauges": "No usage limits reported yet.",
-      "refresh": "Refresh now",
-      "refreshHint": "Polled every 5 min while a task runs, otherwise every 15 min.",
+      "refreshHint": "Refresh now — polled every 5 min while a task runs, otherwise every 15 min.",
       "staleFormat": "Values stale (as of {0})",
       "staleGateHint": "The gate does not apply while values are stale.",
       "gateBlockedFormat": "Queue paused — {0}",
@@ -635,35 +712,61 @@
   "checks": {
     "git": {
       "title": "Git",
-      "hint": "Install Git and make sure it is on PATH."
+      "hint": "Install Git from https://git-scm.com/downloads, then restart the installer.",
+      "notFound": "git was not found on PATH.",
+      "exitCode": "'{0}' exited with code {1}.",
+      "resolvedFormat": "{0} — {1}"
     },
     "gitIdentity": {
       "title": "Git Identity",
-      "hint": "Set your git identity: git config --global user.name \"...\" and user.email \"...\"."
+      "hint": "Run: git config --global user.name \"Your Name\" and git config --global user.email \"you@example.com\"",
+      "notFound": "git was not found — identity could not be checked.",
+      "missing": "Missing git identity: {0}."
     },
     "ports": {
       "title": "Ports",
-      "hint": "Free the port, or change it on the Worker page after install."
+      "hint": "Change the SignalR/MCP ports on the Service page, or stop the process using them.",
+      "inUse": "{0} port {1} is in use.",
+      "inUseBy": "{0} port {1} is in use by '{2}'.",
+      "inUseByOwnWorker": "In use by the running ClaudeDo Worker: {0}.",
+      "available": "Ports are available."
     },
     "writeAccess": {
       "title": "Write Access",
-      "hint": "Choose a different install directory, or run the installer as administrator."
+      "hint": "Choose a different install directory, or run the installer with sufficient permissions (e.g. as administrator).",
+      "cannotWrite": "Cannot write to '{0}': {1}",
+      "writable": "Install directory and data directory are writable."
     },
     "claudeCli": {
       "title": "Claude CLI",
-      "hint": "Install the Claude CLI and make sure it is on PATH."
+      "hint": "Install the Claude CLI (npm install -g @anthropic-ai/claude-code), then restart your terminal/login session so the updated PATH takes effect.",
+      "notFound": "'{0}' was not found on PATH. Searched: {1}.",
+      "exitCode": "'{0}' exited with code {1}.",
+      "resolvedFormat": "{0} — {1}"
     },
     "claudeVersion": {
       "title": "Claude CLI Version",
-      "hint": "Update the Claude CLI to a newer version."
+      "hint": "Update the CLI: npm update -g @anthropic-ai/claude-code",
+      "notFound": "The claude CLI was not found — version could not be checked.",
+      "parseFailed": "Could not parse a version from '{0}'.",
+      "tooOld": "claude {0} is older than the required {1}.",
+      "ok": "claude {0} meets the minimum ({1})."
     },
     "claudeAuth": {
-      "title": "Claude Login",
-      "hint": "Run 'claude auth login' to sign in."
+      "title": "Claude CLI Login",
+      "hint": "Run 'claude' once and complete the login flow.",
+      "notFound": "The claude CLI was not found — login could not be checked.",
+      "undetermined": "Login status could not be determined.",
+      "notLoggedIn": "Not logged in.",
+      "loggedIn": "Logged in."
     },
     "permissionModeAuto": {
       "title": "Permission Mode",
-      "hint": "Update the Claude CLI to a version that supports --permission-mode auto."
+      "hint": "Update the CLI: npm update -g @anthropic-ai/claude-code. ClaudeDo still works in acceptEdits/default mode, with more prompts.",
+      "notFound": "The claude CLI was not found — permission-mode support could not be checked.",
+      "undetermined": "Could not determine whether --permission-mode auto is supported.",
+      "ok": "--permission-mode auto is recognized by this CLI.",
+      "notListed": "This claude CLI version does not list 'auto' as a --permission-mode choice."
     }
   },
   "planning": {
@@ -691,6 +794,9 @@
     "abort": "Abort merge"
   },
   "controls": {
+    "markdown": {
+      "copy": "Copy command"
+    },
     "datePicker": {
       "today": "Today",
       "tomorrow": "Tomorrow",
@@ -700,6 +806,14 @@
       "done": "Done"
     }
   },
+  "dialog": {
+    "cancel": "Cancel",
+    "confirm": "Confirm",
+    "delete": "Delete",
+    "ok": "OK",
+    "confirmTitle": "Confirm",
+    "errorTitle": "Error"
+  },
   "shell": {
     "menu": {
       "help": "Help",
@@ -707,9 +821,18 @@
       "repositories": "Repositories",
       "checkForUpdates": "Check for updates",
       "restartWorker": "Restart worker",
+      "updateClaudeCli": "Update Claude CLI",
+      "shutdown": "Shutdown",
       "worktrees": "Worktrees…",
       "weeklyReport": "Weekly Report…",
       "usageMonitor": "Usage Monitor…",
+      "cheatSheets": "Cheat Sheets",
+      "cheatSheetGit": "Git…",
+      "cheatSheetCommits": "Conventional Commits…",
+      "cheatSheetClaude": "Claude CLI…",
+      "cheatSheetClaudeConfig": "Claude configuration…",
+      "cheatSheetDotnet": "dotnet CLI…",
+      "cheatSheetPowershell": "PowerShell…",
       "about": "About…",
       "addRepos": "Add repos as lists…"
     },
@@ -718,9 +841,6 @@
       "updateNow": "Update now",
       "dismiss": "Dismiss"
     },
-    "staleWorker": {
-      "message": "The worker is running an older build than this repo's merged main — restart it so your merged changes take effect."
-    },
     "externalMerge": {
       "banner": "A Claude session is resolving a merge conflict — don't edit files in the repository.",
       "open": "Open resolver"
@@ -728,19 +848,19 @@
   },
   "vm": {
     "connection": { "online": "Online", "connecting": "Connecting…", "offline": "Offline" },
-    "shell": { "restartingWorker": "Restarting worker…", "unexpectedError": "Unexpected error: {0}" },
+    "shell": { "unexpectedError": "Unexpected error: {0}", "shutdownConfirm": "This stops the ClaudeDo worker (any running task or interactive session is interrupted) and closes the app. Continue?" },
     "mainWindow": { "closeConfirm": { "message": "{0} Mission Control session(s) are still running. Closing the app will end them. Close anyway?" } },
     "agentStatus": { "idle": "Idle", "queued": "Queued", "running": "Running", "review": "Review", "children": "Waiting for Subtasks", "done": "Done", "failed": "Failed", "cancelled": "Cancelled" },
-    "taskStatus": { "idle": "Idle", "queued": "Queued", "running": "Running", "waitingForReview": "Waiting for Review", "waitingForChildren": "Waiting for Subtasks", "done": "Done", "failed": "Failed", "cancelled": "Cancelled", "parked": "Parked", "interactive": "Interactive" },
+    "taskStatus": { "idle": "Idle", "queued": "Queued", "running": "Running", "waitingForReview": "Waiting for Review", "waitingForChildren": "Waiting for Subtasks", "done": "Done", "failed": "Failed", "cancelled": "Cancelled", "parked": "Parked", "interactive": "Interactive", "waiting": "Waiting" },
     "failureReason": { "maxTurns": "Turn limit reached", "timeout": "Timed out", "usageLimit": "Usage limit reached", "error": "Error", "cancelled": "Cancelled", "unknown": "Unknown reason" },
     "failureReasonTooltip": { "maxTurns": "Turn limit reached ({0}/{1} turns) — the worktree is usually fine; continue the task instead of resetting it." },
     "planningBadge": { "active": "PLANNING", "finalized": "PLANNED" },
     "taskRow": { "createdPrefix": "Created {0}", "stepsText": "{0}/{1} steps" },
     "queue": { "baseDirtyWarning": "Heads up: this list's repo has uncommitted changes ({0} modified, {1} untracked) — a new worktree starts from the last commit and won't include them." },
-    "tasksIsland": { "completedHeader": "COMPLETED", "completedHeaderCount": "COMPLETED · {0}", "planningResumeFailed": "Couldn't resume planning session: {0}", "approveFailed": "Approve & merge failed: {0}", "cancelReviewFailed": "Cancel review failed: {0}", "sendToQueueFailed": "Send to queue failed: {0}", "queuePlanBlockedInteractive": "Can't queue the plan — {0} has an open interactive session and must be closed first.", "moveRunningRejected": "Can't move a running task to another list.", "moveWorktreeRejected": "Can't move — this task has an active worktree pointing at its current repo.", "moveRepoConfirm": "Different repos — {0} → {1}. Move the task anyway?", "moveConfirmUnavailable": "Can't move — the confirmation dialog isn't available.", "quickClaudeNoWorkingDir": "This list has no working directory configured.", "quickClaudeDirMissing": "Working directory no longer exists: {0}", "setStatusFailed": "Failed to update status: {0}", "cancelFailed": "Cancel failed: {0}", "rejectToQueueFailed": "Reject to queue failed: {0}", "rejectToIdleFailed": "Reject failed: {0}", "deleteTaskConfirm": "Delete \"{0}\"? This cannot be undone.", "deleteTaskFailed": "Delete failed: {0}", "toggleDoneFailed": "Couldn't update done state: {0}", "removeFromQueueFailed": "Remove from queue failed: {0}", "openWorktreeFailed": "Couldn't open worktree: {0}" },
+    "tasksIsland": { "completedHeader": "COMPLETED", "completedHeaderCount": "COMPLETED · {0}", "statusPill": "{0} running · {1} review", "openTaskOne": "1 open task", "openTasks": "{0} open tasks", "planningResumeFailed": "Couldn't resume planning session: {0}", "approveFailed": "Approve & merge failed: {0}", "cancelReviewFailed": "Cancel review failed: {0}", "sendToQueueFailed": "Send to queue failed: {0}", "queuePlanBlockedInteractive": "Can't queue the plan — {0} has an open interactive session and must be closed first.", "moveRunningRejected": "Can't move a running task to another list.", "moveWorktreeRejected": "Can't move — this task has an active worktree pointing at its current repo.", "moveRepoConfirm": "Different repos — {0} → {1}. Move the task anyway?", "moveConfirmUnavailable": "Can't move — the confirmation dialog isn't available.", "quickClaudeNoWorkingDir": "This list has no working directory configured.", "quickClaudeDirMissing": "Working directory no longer exists: {0}", "setStatusFailed": "Failed to update status: {0}", "cancelFailed": "Cancel failed: {0}", "rejectToQueueFailed": "Reject to queue failed: {0}", "rejectToIdleFailed": "Reject failed: {0}", "deleteTaskConfirm": "Delete \"{0}\"? This cannot be undone.", "deleteTaskFailed": "Delete failed: {0}", "toggleDoneFailed": "Couldn't update done state: {0}", "removeFromQueueFailed": "Remove from queue failed: {0}", "openWorktreeFailed": "Couldn't open worktree: {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).", "buildFailed": "Could not build combined preview: {0}" },
-    "merge": { "commitMessage": "chore: merge {0}", "progressMerging": "Merging…", "progressVerifying": "Running the list's verify command… ({0})", "workerOfflineBranches": "Worker offline — cannot list branches.", "loadBranchesFailed": "Failed to load branches: {0}", "merged": "Merged.", "blocked": "Blocked: {0}", "verifyFailed": "Merge landed, but the list's verify command failed — the task was kept out of Done.", "untrackedCollision": "Merge refused — it would overwrite an untracked file in the target working directory.", "unknownStatus": "Unknown status: {0}", "mergeFailed": "Merge failed: {0}" },
+    "merge": { "commitMessage": "chore: merge {0}", "progressMerging": "Merging…", "progressVerifying": "Running the list's verify command… ({0})", "workerOfflineBranches": "Worker offline — cannot list branches.", "loadBranchesFailed": "Failed to load branches: {0}", "merged": "Merged.", "blocked": "Blocked: {0}", "verifyFailed": "Merge landed, but the list's verify command failed — the task was kept out of Done.", "untrackedCollision": "Merge refused — it would overwrite an untracked file in the target working directory.", "dirtyTarget": "Merge refused — the target working directory has uncommitted changes.", "targetDirty": "The target working directory already has uncommitted changes — stash them and merge?", "unknownStatus": "Unknown status: {0}", "mergeFailed": "Merge failed: {0}" },
     "settingsModal": { "workerOffline": "Worker offline — settings read-only.", "saveFailed": "Save failed: {0}" },
     "onlineInbox": { "workerOffline": "Worker offline — cannot load config.", "saved": "Config saved.", "saveFailed": "Save failed: {0}", "signedIn": "Signed in successfully.", "signedInNoRole": "Signed in, but this account is missing the 'user' role in Zitadel — online sync will be rejected until the role is granted in the ClaudeDo project.", "signInFailed": "Sign-in failed: {0}", "signedOut": "Signed out.", "signOutFailed": "Sign-out failed: {0}" },
     "tickets": { "connectionOk": "Connected as {0}.", "connectionMissingScopes": "Connected as {0}, but missing scopes: {1}", "tokenCleared": "Token removed.", "workerOffline": "Worker not reachable." },
@@ -759,12 +879,12 @@
     "sessionSkillsTab": { "installed": "Installed: {0}", "installFailed": "Install failed: {0}", "updated": "Updated.", "updateFailed": "Update failed: {0}", "removed": "Removed.", "removeFailed": "Remove failed: {0}" },
     "worktreesTab": { "workerOffline": "Worker offline.", "removed": "Removed {0} worktree(s).", "blocked": "Cannot force-remove: {0} task(s) still running. Cancel them first.", "removedFrom": "Removed {0} worktree(s) from {1} task(s).", "cleanupFailed": "Cleanup failed: {0}", "resetFailed": "Reset failed: {0}" },
     "worktreesOverview": { "titleAll": "Worktrees", "titleList": "Worktrees — {0}", "listFallback": "list", "cleanupFailed": "Cleanup failed.", "cleanupFailedDetailed": "Cleanup failed: {0}", "removed": "Removed {0} worktree(s).", "discardConfirm": "Discard the worktree for \"{0}\"? Uncommitted work will be lost.", "discardFailed": "Failed to discard worktree.", "keepFailed": "Failed to keep worktree.", "cannotForceRunning": "Cannot force-remove a running task.", "forceRemoveFailed": "Force remove failed.", "forceRemoveFailedDetailed": "Force remove failed: {0}", "batchDone": "Merged {0}, {1} need resolution.", "openInExplorerFailed": "Couldn't open path: {0}" },
-    "listSettings": { "untitled": "Untitled", "ticketProjectNone": "— none —" },
-    "detailsIsland": { "verifyFailed": "Merge landed, but the list's verify command failed — the task was kept out of Done.", "untrackedCollision": "Merge refused — it would overwrite an untracked file in the target working directory.", "stopOffline": "Worker offline — can't stop the task.", "stopFailed": "Stop failed: {0}", "enqueueFailed": "Queue failed: {0}", "dequeueFailed": "Remove from queue failed: {0}", "resetAndRetryFailed": "Reset & retry failed: {0}", "toggleDoneFailed": "Couldn't update done state: {0}" },
+    "listSettings": { "untitled": "Untitled", "ticketProjectNone": "— none —", "loadFailed": "Couldn't load list settings: {0}", "ticketProjectsLoadFailed": "Couldn't load ticket projects: {0}", "confirmDeleteFolder": "Delete folder \"{0}\"? The lists inside it are kept and move back to the top level.", "confirmDeleteList": "Delete list \"{0}\" and all its tasks? This cannot be undone.", "deleteBlockedPlanning": "This list has planning sessions with child tasks. Discard those first, then delete the list.", "workingDirMissing": "This folder doesn't exist.", "workingDirNotRepo": "This folder isn't a git repository yet. Run `git init` in it first, or clear the working directory to save this as a manual list." },
+    "detailsIsland": { "verifyFailed": "Merge landed, but the list's verify command failed — the task was kept out of Done.", "untrackedCollision": "Merge refused — it would overwrite an untracked file in the target working directory.", "dirtyTarget": "Merge refused — the target working directory has uncommitted changes.", "stashAndMergeConfirm": "The target working directory has uncommitted changes.\nStash them, merge, and restore them afterwards?", "stopOffline": "Worker offline — can't stop the task.", "stopFailed": "Stop failed: {0}", "enqueueFailed": "Queue failed: {0}", "dequeueFailed": "Remove from queue failed: {0}", "resetAndRetryFailed": "Reset & retry failed: {0}", "toggleDoneFailed": "Couldn't update done state: {0}" },
     "mergeSection": { "openWorktreeFailed": "Couldn't open worktree: {0}" },
     "about": { "openPathFailed": "Couldn't open path: {0}" },
-    "lists": { "localSuffix": "{0} / local", "smartMyDay": "My Day", "smartImportant": "Important", "smartPlanned": "Planned", "virtualQueue": "Queue", "virtualRunning": "Running", "virtualReview": "Review", "newList": "New list", "findingsNotFound": "No findings yet for this list.", "findingsOpenFailed": "Couldn't open findings folder: {0}", "openInExplorerFailed": "Couldn't open path: {0}" },
-    "repoImport": { "loadFailed": "Couldn't load remembered folders: {0}", "saveFailed": "Couldn't save folders: {0}" }
+    "lists": { "localSuffix": "{0} / local", "smartMyDay": "My Day", "smartImportant": "Important", "smartPlanned": "Planned", "smartNotes": "Notes", "virtualQueue": "Queue", "virtualRunning": "Running", "virtualReview": "Review", "newList": "New list", "findingsNotFound": "No findings yet for this list.", "findingsOpenFailed": "Couldn't open findings folder: {0}", "openInExplorerFailed": "Couldn't open path: {0}" },
+    "repoImport": { "loadFailed": "Couldn't load remembered folders: {0}", "saveFailed": "Couldn't save folders: {0}", "createButton": "Create {0} list(s)" }
   },
   "ops": {
     "stalledHint": "Still running — worker hasn't responded in a while",
@@ -832,39 +952,5 @@
       "lastError": "Last error: {0}",
       "throttled": "Throttled: {0}/{1} slots ({2})"
     }
-  },
-  "checks": {
-    "git": {
-      "title": "Git",
-      "hint": "Install Git from https://git-scm.com/downloads, then restart the installer."
-    },
-    "gitIdentity": {
-      "title": "Git identity",
-      "hint": "Run: git config --global user.name \"Your Name\" and git config --global user.email \"you@example.com\""
-    },
-    "ports": {
-      "title": "Ports",
-      "hint": "Change the SignalR/MCP ports on the Service page, or stop the process using them."
-    },
-    "writeAccess": {
-      "title": "Write access",
-      "hint": "Choose a different install directory, or run the installer with sufficient permissions (e.g. as administrator)."
-    },
-    "claudeCli": {
-      "title": "Claude CLI",
-      "hint": "Install the Claude CLI (npm install -g @anthropic-ai/claude-code), then restart your terminal/login session so the updated PATH takes effect."
-    },
-    "claudeVersion": {
-      "title": "Claude CLI version",
-      "hint": "Update the CLI: npm update -g @anthropic-ai/claude-code"
-    },
-    "claudeAuth": {
-      "title": "Claude CLI login",
-      "hint": "Run 'claude' once and complete the login flow."
-    },
-    "permissionModeAuto": {
-      "title": "--permission-mode auto support",
-      "hint": "Update the CLI: npm update -g @anthropic-ai/claude-code. ClaudeDo still works in acceptEdits/default mode, with more prompts."
-    }
   }
 }

src/ClaudeDo.Ui/Assets/CheatSheets/claude-cli.md

@@ -0,0 +1,63 @@
+# Claude CLI
+
+## Session starten
+- `claude` — interaktive Session im aktuellen Verzeichnis
+- `claude "<prompt>"` — Session mit erstem Prompt starten
+- `claude -c` — letzte Session in diesem Verzeichnis fortsetzen
+- `claude -r` — Session aus einer Auswahlliste fortsetzen
+- `claude -r <session-id>` — bestimmte Session fortsetzen
+- `claude --fork-session -r <id>` — Session unter neuer ID fortsetzen
+- `claude -n "<name>"` — Anzeigename für die Session setzen
+
+## Modell und Aufwand
+- `claude --model sonnet` — Alias oder voller Name (`fable`, `opus`, `sonnet`, `claude-opus-5`)
+- `claude --effort high` — Denkaufwand: `low`, `medium`, `high`, `xhigh`, `max`
+- `claude --fallback-model sonnet` — Ausweichmodell bei Überlast (nur mit `-p`)
+
+## Nicht interaktiv
+- `claude -p "<prompt>"` — antworten und beenden
+- `claude -p --output-format json` — ein JSON-Ergebnis
+- `claude -p --output-format stream-json` — Streaming-JSON für Skripte
+- `claude -p --include-partial-messages` — Teil-Chunks mitstreamen
+- `claude -p --max-budget-usd 5` — Kostendeckel für den Lauf
+- `claude -p --json-schema '<schema>'` — strukturierte Ausgabe validieren
+
+## Berechtigungen und Tools
+- `claude --permission-mode <mode>` — `acceptEdits`, `auto`, `plan`, `manual`, `dontAsk`, `bypassPermissions`
+- `claude --allowed-tools "Bash(git *)" Edit` — nur diese Tools erlauben
+- `claude --disallowed-tools "Bash(rm *)"` — diese Tools sperren
+- `claude --tools "Bash,Edit,Read"` — Built-in-Toolset festlegen
+- `claude --add-dir <pfad>` — weiteres Arbeitsverzeichnis freigeben
+- `claude --restricted` — ohne befehlsausführende Tools und ohne lokale Settings
+
+## Kontext und Konfiguration
+- `claude --append-system-prompt "<text>"` — Systemprompt ergänzen
+- `claude --system-prompt "<text>"` — Systemprompt ersetzen
+- `claude --settings <datei|json>` — zusätzliche Settings laden
+- `claude --agents '<json>'` — eigene Subagents für diese Session
+- `claude --mcp-config <datei>` — MCP-Server aus JSON laden
+- `claude --strict-mcp-config` — nur diese MCP-Server, alle anderen ignorieren
+- `claude --safe-mode` — alle Anpassungen aus, zum Fehlersuchen
+- `claude --bare` — Minimalmodus ohne Hooks, Plugins, CLAUDE.md
+
+## Hintergrund-Sessions
+- `claude --bg "<prompt>"` — im Hintergrund starten, gibt die Kurz-ID aus
+- `claude agents` — laufende Hintergrund-Sessions auflisten
+- `claude attach <id>` — Hintergrund-Session in dieses Terminal holen
+- `claude logs <id>` — letzte Ausgabe einer Hintergrund-Session
+- `claude stop <id>` — Session stoppen, Verlauf bleibt
+- `claude rm <id>` — Session löschen
+
+## Worktree
+- `claude -w` — neuen Git-Worktree für diese Session anlegen
+- `claude -w <name>` — Worktree mit eigenem Namen
+
+## Verwaltung
+- `claude doctor` — Installation prüfen
+- `claude update` — auf neue Version aktualisieren
+- `claude mcp` — MCP-Server konfigurieren
+- `claude plugin` — Plugins verwalten
+- `claude auth` — Authentifizierung verwalten
+- `claude setup-token` — Langzeit-Token einrichten
+- `claude -d api,hooks` — Debugmodus mit Kategoriefilter
+- `claude -v` — Version ausgeben

src/ClaudeDo.Ui/Assets/CheatSheets/claude-config.md

@@ -0,0 +1,48 @@
+# Claude Konfiguration
+
+## Dateien und Orte
+- `~/.claude/settings.json` — globale Settings für alle Projekte
+- `.claude/settings.json` — Projekt-Settings, eingecheckt fürs Team
+- `.claude/settings.local.json` — persönliche Projekt-Settings, nicht eingecheckt
+- `Rangfolge: managed > local > projekt > global` — spezifischer gewinnt
+- `/config` — Settings interaktiv in der Session ansehen und ändern
+- `claude doctor` — Konfiguration auf Fehler prüfen
+
+## CLAUDE.md
+- `~/.claude/CLAUDE.md` — globale Anweisungen für alle Projekte
+- `CLAUDE.md` — im Projekt-Root, wird bei Start automatisch geladen
+- `<unterordner>/CLAUDE.md` — wird geladen, sobald dort gearbeitet wird
+- `@pfad/zur/datei.md` — Import einer weiteren Datei in eine CLAUDE.md
+- `# <notiz>` — in der Session: Notiz in die CLAUDE.md übernehmen
+- `/init` — CLAUDE.md für ein Projekt generieren lassen
+
+## Berechtigungen
+- `"permissions": { "allow": [...], "deny": [...], "ask": [...] }` — Struktur in settings.json
+- `Bash(git *)` — Bash-Befehle per Muster erlauben oder sperren
+- `Edit(src/**)` — Dateizugriff per Glob einschränken
+- `WebFetch(domain:example.com)` — Webzugriff auf eine Domain begrenzen
+- `mcp__<server>__<tool>` — Regel für ein einzelnes MCP-Tool
+- `/permissions` — Regeln in der Session ansehen und ergänzen
+
+## MCP-Server
+- `claude mcp add <name> -- <befehl>` — lokalen stdio-Server anlegen
+- `claude mcp add --transport http <name> <url>` — HTTP-Server anlegen
+- `claude mcp add --scope project <name> ...` — in `.mcp.json` fürs Team
+- `claude mcp list` — konfigurierte Server anzeigen
+- `claude mcp remove <name>` — Server entfernen
+- `/mcp` — Serverstatus in der Session, OAuth-Login
+
+## Hooks
+- `"hooks": { "PreToolUse": [...] }` — Shell-Befehle an Lifecycle-Events hängen
+- `PreToolUse / PostToolUse` — vor und nach jedem Tool-Aufruf
+- `UserPromptSubmit` — beim Absenden eines Prompts
+- `SessionStart / Stop` — bei Sessionbeginn und -ende
+- `Exit-Code 2` — blockiert die Aktion, stderr geht an Claude
+- `/hooks` — Hooks interaktiv verwalten
+
+## Erweiterungen
+- `.claude/commands/<name>.md` — eigener Slash-Command `/name`
+- `.claude/skills/<name>/SKILL.md` — Skill, wird bei passender Aufgabe geladen
+- `.claude/agents/<name>.md` — eigener Subagent-Typ
+- `~/.claude/...` — dieselben Ordner global statt pro Projekt
+- `claude plugin` — Plugins installieren und verwalten

src/ClaudeDo.Ui/Assets/CheatSheets/conventional-commits.md

@@ -0,0 +1,34 @@
+# Conventional Commits
+
+## Format
+- `<type>(<scope>): <beschreibung>` — Grundform, Scope optional
+- `feat(auth): add login endpoint` — Beispiel mit Scope
+- `fix: prevent crash on empty input` — Beispiel ohne Scope
+- `imperativ, klein, kein Punkt am Ende` — Stil der Beschreibung
+
+## Types
+- `feat` — neues Feature
+- `fix` — Bugfix
+- `refactor` — Umbau ohne Verhaltensänderung
+- `perf` — Performance-Verbesserung
+- `docs` — nur Dokumentation
+- `test` — Tests hinzufügen oder korrigieren
+- `style` — Formatierung, kein Code-Effekt
+- `build` — Build-System oder Dependencies
+- `ci` — CI-Konfiguration
+- `chore` — Sonstiges ohne src- oder Test-Änderung
+
+## Breaking Changes
+- `feat(api)!: remove legacy endpoint` — `!` markiert einen Breaking Change
+- `BREAKING CHANGE: <erklärung>` — alternativ als Footer im Commit-Body
+
+## Body und Footer
+- `Leerzeile nach der Betreffzeile` — dann optionaler Body mit dem Warum
+- `Refs: #123` — Footer für Ticket-Referenzen
+- `Reverts: <hash>` — Footer für Reverts
+
+## Warum das Ganze
+- `feat` — löst ein Minor-Release aus (SemVer)
+- `fix` — löst ein Patch-Release aus (SemVer)
+- `!` oder `BREAKING CHANGE` — löst ein Major-Release aus
+- `git log --oneline --grep "^feat"` — Verlauf wird filterbar

src/ClaudeDo.Ui/Assets/CheatSheets/dotnet-cli.md

@@ -0,0 +1,49 @@
+# dotnet CLI
+
+## Projekt anlegen
+- `dotnet new list` — verfügbare Vorlagen anzeigen
+- `dotnet new console -n <name>` — Projekt aus Vorlage anlegen
+- `dotnet new sln` — Solution anlegen
+- `dotnet sln add <projekt>` — Projekt in die Solution aufnehmen
+
+## Bauen
+- `dotnet restore` — NuGet-Pakete auflösen
+- `dotnet build <projekt> -c Release` — Release bauen
+- `dotnet build --no-restore` — ohne Restore, wenn Pakete aktuell sind
+- `dotnet build -v minimal` — knappere Ausgabe
+- `dotnet clean -c Release` — Build-Ausgabe löschen
+
+## Laufen lassen
+- `dotnet run --project <projekt> -c Release` — starten
+- `dotnet run --project <projekt> -- <args>` — Argumente an die App
+- `dotnet watch --project <projekt> run` — bei Dateiänderung neu starten
+
+## Testen
+- `dotnet test <projekt> -c Release --no-build` — Tests ohne Neubau
+- `dotnet test --filter "FullyQualifiedName~<name>"` — nur passende Tests
+- `dotnet test --filter "FullyQualifiedName!~<name>"` — Tests ausschließen
+- `dotnet test --logger "console;verbosity=detailed"` — Details pro Test
+- `dotnet test --blame-hang-timeout 60s` — hängende Tests aufspüren
+
+## Pakete
+- `dotnet add <projekt> package <name>` — Paket hinzufügen
+- `dotnet add <projekt> package <name> --version 1.2.3` — feste Version
+- `dotnet remove <projekt> package <name>` — Paket entfernen
+- `dotnet list <projekt> package --outdated` — veraltete Pakete
+- `dotnet nuget locals all --clear` — NuGet-Caches leeren
+
+## EF Core Migrationen
+- `dotnet ef migrations add <name> -p <daten-projekt>` — Migration anlegen
+- `dotnet ef migrations list -p <daten-projekt>` — Migrationen anzeigen
+- `dotnet ef migrations remove -p <daten-projekt>` — letzte Migration zurücknehmen
+- `dotnet ef database update -p <daten-projekt>` — Schema anwenden
+
+## Veröffentlichen
+- `dotnet publish <projekt> -c Release -r win-x64 --self-contained` — eigenständiges Build
+- `dotnet publish <projekt> -c Release -p:PublishSingleFile=true` — eine Exe
+
+## Diagnose
+- `dotnet --info` — SDKs, Runtimes, RID
+- `dotnet --list-sdks` — installierte SDKs
+- `dotnet format <projekt>` — Formatierung anwenden
+- `dotnet build -p:TreatWarningsAsErrors=true` — Warnungen als Fehler

src/ClaudeDo.Ui/Assets/CheatSheets/git.md

@@ -0,0 +1,80 @@
+# Git
+
+## Start
+- `git clone <url>` — Repository klonen
+- `git init` — neues Repository anlegen
+- `git remote add origin <url>` — Remote verbinden
+
+## Stand ansehen
+- `git status -sb` — Kurzstatus mit Branch-Zeile
+- `git diff` — nicht gestagete Änderungen
+- `git diff --staged` — gestagete Änderungen
+- `git diff main...HEAD` — alles, was dieser Branch gegenüber main bringt
+- `git diff --stat` — nur Datei- und Zeilenzähler
+- `git log --oneline --graph --decorate -20` — kompakter Verlauf
+- `git log -p -- <pfad>` — Verlauf einer Datei mit Diffs
+- `git show <commit>` — ein Commit im Detail
+
+## Branch
+- `git switch <branch>` — Branch wechseln
+- `git switch -c <name>` — Branch anlegen und wechseln
+- `git switch -` — zurück zum vorherigen Branch
+- `git branch -vv` — Branches mit Upstream und letztem Commit
+- `git branch -d <name>` — gemergten Branch löschen (`-D` erzwingt)
+
+## Committen
+- `git add <pfad>` — Änderungen stagen
+- `git add -p` — Änderungen hunk-weise stagen
+- `git commit -m "<text>"` — gestagete Änderungen committen
+- `git commit -- <pfad>` — nur diese Pfade committen
+- `git commit --amend --no-edit` — letzten Commit um die Staging-Area erweitern
+- `git commit --fixup <commit>` — Fixup für späteres Autosquash
+
+## Remote
+- `git fetch --all --prune` — alles holen, gelöschte Remote-Branches aufräumen
+- `git pull --rebase` — holen und eigene Commits obendrauf setzen
+- `git push -u origin <name>` — pushen und Upstream setzen
+- `git push --force-with-lease` — sicheres Force-Push, nie plain `--force`
+
+## Rebase und Merge
+- `git rebase main` — Branch auf aktuellen main setzen
+- `git rebase -i --autosquash main` — interaktiv aufräumen
+- `git rebase --continue` — nach gelöstem Konflikt weiter
+- `git rebase --abort` — Rebase abbrechen, Ausgangszustand zurück
+- `git merge --no-ff <branch>` — Merge-Commit erzwingen
+- `git merge --abort` — laufenden Merge abbrechen
+- `git cherry-pick <commit>` — einzelnen Commit übernehmen
+
+## Konflikte
+- `git diff --name-only --diff-filter=U` — konfliktbehaftete Dateien
+- `git checkout --ours <pfad>` — eigene Seite übernehmen
+- `git checkout --theirs <pfad>` — fremde Seite übernehmen
+- `git mergetool` — konfiguriertes Merge-Tool starten
+
+## Rückgängig
+- `git restore <pfad>` — Datei auf HEAD zurücksetzen, Änderungen weg
+- `git restore --staged <pfad>` — unstagen, Änderungen behalten
+- `git reset --soft HEAD~1` — letzten Commit auflösen, Änderungen gestaged behalten
+- `git reset --hard <commit>` — alles verwerfen, nicht rückholbar
+- `git revert <commit>` — Commit durch Gegen-Commit aufheben
+- `git reflog` — Referenzverlauf, um verlorene Commits wiederzufinden
+
+## Stash
+- `git stash push -m "<text>"` — Änderungen wegpacken
+- `git stash push -u` — inklusive unversionierter Dateien
+- `git stash list` — Stashes anzeigen
+- `git stash pop` — letzten Stash zurückholen und entfernen
+- `git stash apply <stash>` — anwenden, aber behalten
+
+## Worktrees
+- `git worktree list` — alle Worktrees
+- `git worktree add <pfad> <branch>` — Worktree für bestehenden Branch
+- `git worktree add -b <name> <pfad>` — Worktree mit neuem Branch
+- `git worktree remove <pfad>` — Worktree entfernen
+- `git worktree prune` — verwaiste Einträge aufräumen
+
+## Suchen
+- `git grep -n "<text>"` — im Arbeitsbaum suchen
+- `git log -S"<text>"` — Commits, die den Text einfügen oder entfernen
+- `git blame -L 40,60 <pfad>` — Zeilenbereich zuordnen
+- `git bisect start` — binäre Suche nach dem Fehler-Commit

src/ClaudeDo.Ui/Assets/CheatSheets/powershell.md

@@ -0,0 +1,52 @@
+# PowerShell
+
+## Navigieren und Dateien
+- `Get-ChildItem` — Verzeichnis auflisten (`ls`, `-Force` zeigt versteckte)
+- `Set-Location <pfad>` — Verzeichnis wechseln (`cd`)
+- `New-Item -ItemType Directory <pfad>` — Ordner anlegen (`mkdir`)
+- `Copy-Item <quelle> <ziel> -Recurse` — kopieren
+- `Move-Item <quelle> <ziel>` — verschieben oder umbenennen
+- `Remove-Item <pfad> -Recurse -Force` — löschen, endgültig
+- `Test-Path <pfad>` — existiert die Datei oder der Ordner?
+
+## Ansehen und Suchen
+- `Get-Content <datei> -Tail 50` — letzte Zeilen (`-Wait` folgt wie tail -f)
+- `Select-String "<text>" <dateien> -List` — in Dateien suchen (grep)
+- `Get-ChildItem -Recurse -Filter *.log` — Dateien rekursiv finden
+- `<befehl> | Select-Object -First 10` — Ausgabe begrenzen (head)
+- `<befehl> | Where-Object Name -like "*test*"` — Ausgabe filtern
+- `<befehl> | Measure-Object` — zählen (wc)
+- `<befehl> | Out-GridView` — Ausgabe in sortierbarem Fenster
+
+## Prozesse und Dienste
+- `Get-Process | Sort-Object CPU -Descending | Select-Object -First 10` — Top-Prozesse
+- `Stop-Process -Name <name>` — Prozess beenden (`-Id <pid>` per PID)
+- `Get-Service <name>` — Dienststatus
+- `Restart-Service <name>` — Dienst neu starten (Admin nötig)
+
+## Netzwerk
+- `Test-NetConnection <host> -Port 443` — Erreichbarkeit und Port testen
+- `Get-NetTCPConnection -LocalPort <port>` — wer belegt den Port (OwningProcess = PID)
+- `Invoke-RestMethod <url>` — HTTP-Aufruf, JSON kommt als Objekt zurück
+- `Resolve-DnsName <host>` — DNS-Auflösung prüfen
+
+## Umgebung
+- `$env:PATH -split ";"` — PATH lesbar ausgeben
+- `$env:NAME = "wert"` — Variable für diese Session setzen
+- `[Environment]::SetEnvironmentVariable("NAME", "wert", "User")` — dauerhaft setzen
+- `Get-Command <name>` — wo liegt ein Befehl (which)
+- `Get-History` — bisherige Befehle dieser Session
+
+## Windows-Spezifisches
+- `explorer .` — aktuellen Ordner im Explorer öffnen
+- `Start-Process <datei>` — mit Standardprogramm öffnen
+- `Start-Process pwsh -Verb RunAs` — Terminal als Administrator
+- `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned` — lokale Skripte erlauben
+- `winget search <name>` — Software im Paketmanager suchen
+- `winget install <id>` — installieren
+- `winget upgrade --all` — alles aktualisieren
+
+## Hilfe
+- `Get-Help <befehl> -Examples` — Beispiele zu einem Cmdlet
+- `Get-Member` — Eigenschaften eines Pipeline-Objekts anzeigen
+- `Get-Alias <kurzform>` — welches Cmdlet steckt hinter einem Alias

src/ClaudeDo.Ui/CLAUDE.md

@@ -41,6 +41,7 @@ Design/         — Tokens.axaml (design tokens; merged before styles)
 
 - **IslandsShellViewModel** — root coordinator. Owns the three island VMs and the `WorkerClient`, wires cross-island events (selection, notes/prep mode, conflict resolution), connection state, the update banner, the inline worker-log strip (clickable → Log Visualizer overlay; `FlashFooterError` surfaces UI-action failures + the worker's Warn/Error there), responsive-layout flags (`ShowLists`/`ShowDetails` by window width), `PrimeStatus` flash, the modal openers, and `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`.
+  - **Folders:** the sidebar's top level is **one mixed collection**, `TopLevel` (`ObservableCollection<object>`: `ListFolderNavItemViewModel` rows, each with its own `Lists`, interleaved with folder-less `ListNavItemViewModel` rows) — that's what lets a list sit *above* a folder. `Folders`/`RootLists` are `OfType` **projections** of it, not collections to keep in sync. `UserLists` stays the **flat superset** every count refresh, row refresh and the no-repo banner work over — a row lives in both. `ContainerOf(row)` resolves which collection renders it (non-generic `IList`, since the top level is mixed). The view is a single `ItemsControl` over `TopLevel` with **implicit, type-matched `DataTemplate`s in `UserControl.DataTemplates`** — no keyed row template, and the folder's child `ItemsControl` resolves the same list template by walking up to the UserControl. A folder is never selectable: tapping the header runs `ToggleFolderCommand` (persisted to `list_folders.is_collapsed`), and its badge is the sum of its children. `DropAsync(source, target, placeBelow)` handles all four source/target combinations and doubles as the move: a drop position implies a container, so dropping a list onto a row in another folder — or next to *anything* at the top level, folder headers included — reassigns `FolderId`. A folder dropped onto a row inside a folder is ignored; folders never nest. `MoveToFolderAsync` is the drop-into-the-header path (reaches collapsed/empty folders, bound to the middle half of the header — the outer quarters insert *next to* the folder instead); `RemoveFromFolderCommand` is its context-menu counterpart. Both end in `PersistOrderAsync` → `ListRepository.ReorderSidebarAsync`, one `sort_order` sequence spanning **both tables**. ⚠️ A **folder** drag starts from `PointerMoved` past a 4px threshold using the *stored* `PointerPressedEventArgs` (`DoDragDropAsync` only accepts those) — starting it on press would capture the pointer and swallow the `Tapped` that folds the folder.
 - **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; planning session lifecycle; `RefineTask`, `OpenConPtySessionRequested`, `ToggleManual`, `SyncInteractiveSessions`; MyDay extras (`IsMyDayList`, `ClearDayCommand`, `ShowPrepLogCommand`) and the pinned Notes pseudo-row. Raises `NotesRequested`/`PrepRequested` for the shell.
 - **DetailsIslandViewModel** — the detail pane for a bound `TaskRowViewModel`. Owns live-log streaming (`Log` via `StreamLineFormatter`), debounced title/description editing, subtasks, the session-outcome/roadblock split, the three-tab work console (`output`/`git`/`session`), child surfacing (`ChildOutcomes` + `ChildrenNeedingAttention` drive an attention band on the Session tab), attachments, and the modes `IsNotesMode`/`IsPrepMode`/computed `IsTaskDetailVisible`. Failures raise `ErrorReported`, wired by the shell into `FlashFooterError`.
   - Three concerns are extracted into section VMs exposed as properties: `AgentSettings` (`AgentConfigEditorViewModel`, scope=Task), `MergeSectionViewModel`, `PrepPanelViewModel`. Helper rows live in the same file.
@@ -55,16 +56,28 @@ Design/         — Tokens.axaml (design tokens; merged before styles)
 | VM | Notes |
 |---|---|
 | `SettingsModalViewModel` | Four tabs: General, Worktrees, Files (prompt paths), Prime Claude. General hosts the per-model preset table (`ModelPresetRowViewModel`: effort + max turns per alias) which **replaced** the single global "Max turns" field. The Prime Claude tab gives each schedule row a three-way action radio group (Ping / Fill My Day / Custom) — `RadioButton.GroupName` is bound to a **per-row** `RadioGroup` string, since a shared group name would make every schedule share one selection. `DailyPrepMaxTasks` is disabled unless some row is `FillMyDay`. |
-| `ListSettingsModalViewModel` | Name, working dir, commit type, "manual list" flag, `VerifyCommand`, delete. Hosts the shared `AgentConfigEditorViewModel` as `Agent` (scope=List) — ⚠️ save delegates to `Agent.SaveAsync(verifyCommand)` because both land in the same `list_config` row via one `UpdateListConfig` call and would otherwise clobber each other. |
+| `ListSettingsModalViewModel` | Name, working dir, commit type, "manual list" flag, `VerifyCommand`, delete. Hosts the shared `AgentConfigEditorViewModel` as `Agent` (scope=List) — ⚠️ save delegates to `Agent.SaveAsync(verifyCommand)` because both land in the same `list_config` row via one `UpdateListConfig` call and would otherwise clobber each other. **Doubles as the folder editor:** `IsFolder` collapses the body to name + icon, and it's reached either via the create-only "create a folder instead" toggle (`CanToggleFolder`, set by `BeginLoad`) or via `BeginLoadFolder` on an existing folder. There is no list↔folder conversion. Creating a folder writes a `list_folders` row and **deletes the list row the create flow pre-created**, reporting it as `Deleted` so the caller does a full reload. |
 | `WeeklyReportModalViewModel` | Range pickers default "since last standup weekday → today", cached per range. |
 | `MergeHelperSelectionModalViewModel` | "Let Claude handle it" picker → [conpty-sessions](../../docs/explore-notes/conpty-sessions.md). |
-| `UsageMonitorModalViewModel` | Opened from the usage pill (shown **before** the data loads via `BeginLoad`); gauges are **dynamic** per `UsageSnapshotDto.Limits` row, and the 5h/7d ones carry three draggable stage markers (soft/hard/gate) via `UsageGaugeBar` + the pure `UsageThresholdDrag`, plus a colour-matched legend with a `NumericUpDown` per stage → [usage-monitoring](../../docs/explore-notes/usage-monitoring.md). The **analytics** part (models/tasks/cost) comes from the external TokenTracker export, not from us: without the CLI the modal shows a hint card with an install button (gated on Node ≥ 20) instead of the totals header. Gauges, gate and throttle are unaffected by it. |
+| `UsageMonitorModalViewModel` | Opened from the usage pill (shown **before** the data loads via `BeginLoad`); gauges are **dynamic** per `UsageSnapshotDto.Limits` row, and the 5h/7d ones carry three draggable stage markers (soft/hard/gate) via `UsageGaugeBar` + the pure `UsageThresholdDrag`, plus a colour-matched legend with a `NumericUpDown` per stage → [usage-monitoring](../../docs/explore-notes/usage-monitoring.md). The **analytics** part (models/tasks/cost) comes from the external TokenTracker export, not from us: without the CLI the modal shows a hint card with an install button (gated on Node ≥ 20) instead of the totals header. Gauges, gate and throttle are unaffected by it. The modal is **display + threshold drag only** — the PowerUse switch/window/handoff % it used to host moved to Settings → Execution (`GeneralSettingsTabViewModel`), and "Refresh now" is an icon in the titlebar via `ModalShell.HeaderActions` rather than a body row. |
 
 Self-explanatory: `RepoImportModalViewModel` (bulk-create lists from git repos; already-wired
 repos disabled), `MergeModalViewModel`, `WorktreesOverviewModalViewModel`,
 `UnfinishedPlanningModalViewModel`, `LogVisualizerViewModel` (last 30 min, all levels + a
 warn/error filter), `WorkerConnectionModalViewModel`, `AboutModalViewModel`.
 
+`CheatSheetsViewModel` backs the modeless `CheatSheetsWindow` (Help → Cheat Sheets): content is
+markdown under `Assets/CheatSheets/*.md` as **EmbeddedResource** (not `AvaloniaResource` —
+`AssetLoader` throws without an initialized Avalonia app, which would make the VM unconstructible
+in tests), rendered through `MarkdownView`, with a `Topmost` pin so it can sit docked beside the
+shell. A new sheet = a new `.md` file + its key in `CheatSheetsViewModel.Keys` (+ a menu entry if
+it should be directly reachable). `MarkdownView` has no table/fenced-code support, so sheets are
+bullet lists with inline code — rendered via its opt-in `CommandRows` property, which turns a
+`` `command` — description `` bullet into a mono chip + copy button + description and wraps each
+`##` section in a collapsible `Expander` (blocks are added to the open section's panel, not to the
+host). The flag is opt-in because the other three `MarkdownView` call sites (prompt-file viewer,
+weekly report, task-description preview) render prose where copy buttons would be noise.
+
 ## Diff & Conflicts
 
 `UnifiedDiffParser` (static) + `DiffModels.cs` shared types + `DiffViewerViewModel` (one unified
@@ -79,7 +92,7 @@ single-task and planning unit-merge conflicts. Full detail →
 The two surfaces are **not** variants of one control (read-only 2-way renderer over aligned rows
 vs. 3-way editor over a writable document), but they share their AvaloniaEdit host plumbing via
 `Views/Controls/DiffEditorSetup.cs`: the process-wide TextMate `Registry`, `InstallHighlighting`,
-`ApplyGrammar`, the `Brush` resource fallback, the `Seg` segment, and `VerticalScrollSync`. Put
+`ApplyGrammar`, the `Brush` resource fallback, the `Seg` segment, and `ScrollSync`. Put
 new editor boilerplate there rather than copying it a third time.
 
 ## Services
@@ -106,6 +119,9 @@ There is no null→bool converter — bind
 Modals use `TaskCompletionSource` results behind the reusable `ModalShell` control — the dialog
 sets the result on save/cancel, the caller awaits the TCS.
 
+`ModalShell.HeaderActions` is the titlebar slot left of maximise/close — for a window-level action
+that should stay visible without costing a body row (currently only the usage monitor's refresh).
+
 `ModalShell` also owns the window chrome for every modal: the titlebar drag goes through
 `Window.BeginMoveDrag` (so Windows snap works — drag to the top edge to maximise; the OS only
 snaps `CanResize="True"` windows, which is the opt-in), and it insets itself by the window's

src/ClaudeDo.Ui/ClaudeDo.Ui.csproj

@@ -36,6 +36,9 @@
   </ItemGroup>
 
   <ItemGroup>
+    <!-- EmbeddedResource, not AvaloniaResource: reading these needs no initialized Avalonia
+         app, so the VM stays constructible in tests. -->
+    <EmbeddedResource Include="Assets/CheatSheets/*.md" />
     <AvaloniaResource Include="Assets/Fonts/*.ttf" />
     <AvaloniaResource Include="Assets/Fonts/OFL-InterTight.txt" />
     <AvaloniaResource Include="Assets/Fonts/OFL-JetBrainsMono.txt" />

src/ClaudeDo.Ui/Design/IslandStyles.axaml

@@ -297,6 +297,18 @@
     <Setter Property="Foreground" Value="{StaticResource StatusQueuedBrush}" />
   </Style>
 
+  <!-- waiting → muted amber: a Queued task blocked on an unmet predecessor (a task_dependencies
+       edge, or the planning chain's BlockedByTaskId) — distinct from queued (unblocked, next up
+       to run) and from children (a parent waiting on its own subtasks). Mutually exclusive with
+       .queued on the same chip (IsQueued/IsWaiting), so no declaration-order fight between them. -->
+  <Style Selector="Border.chip.waiting">
+    <Setter Property="Background"  Value="#332F1A" />
+    <Setter Property="BorderBrush" Value="#4D451A" />
+  </Style>
+  <Style Selector="Border.chip.waiting > TextBlock">
+    <Setter Property="Foreground" Value="#C9A227" />
+  </Style>
+
   <!-- done → green (#6FA86B) -->
   <Style Selector="Border.chip.done">
     <Setter Property="Background"  Value="{StaticResource DoneTintBrush}" />

src/ClaudeDo.Ui/Services/ClipboardImageTempStore.cs

@@ -0,0 +1,45 @@
+using System;
+using System.IO;
+using ClaudeDo.Data;
+
+namespace ClaudeDo.Ui.Services;
+
+/// <summary>
+/// Temp PNGs written for clipboard-image paste into the interactive terminal (see
+/// <see cref="ClaudeDo.Ui.Views.InteractiveTerminalView"/>) — dropped into the composer as a path,
+/// the same way a file drop is, then read by Claude like any other file.
+/// </summary>
+public static class ClipboardImageTempStore
+{
+    public static string Directory => Path.Combine(Paths.AppDataRoot(), "tmp");
+
+    /// <summary>A fresh, collision-free path for one pasted image.</summary>
+    public static string NewPngPath(DateTime utcNow) => NewPngPath(Directory, utcNow);
+
+    /// <summary>Deletes files older than <paramref name="maxAge"/> under the tmp dir — called once at
+    /// app startup, not a running cleanup service.</summary>
+    public static void DeleteOlderThan(TimeSpan maxAge, DateTime utcNow) => DeleteOlderThan(Directory, maxAge, utcNow);
+
+    /// <summary>Test seam for <see cref="NewPngPath(DateTime)"/> — takes the target dir explicitly
+    /// instead of the real app data root.</summary>
+    internal static string NewPngPath(string dir, DateTime utcNow) =>
+        Path.Combine(dir, $"paste-{utcNow:yyyyMMdd-HHmmssfff}-{Guid.NewGuid():N}.png");
+
+    /// <summary>Test seam for <see cref="DeleteOlderThan(TimeSpan,DateTime)"/> — takes the target dir
+    /// explicitly instead of the real app data root.</summary>
+    internal static void DeleteOlderThan(string dir, TimeSpan maxAge, DateTime utcNow)
+    {
+        if (!System.IO.Directory.Exists(dir)) return;
+
+        foreach (var file in System.IO.Directory.EnumerateFiles(dir))
+        {
+            try
+            {
+                if (utcNow - File.GetLastWriteTimeUtc(file) > maxAge)
+                    File.Delete(file);
+            }
+            catch (IOException) { /* best effort */ }
+            catch (UnauthorizedAccessException) { /* best effort */ }
+        }
+    }
+}

src/ClaudeDo.Ui/Services/IDialogService.cs

@@ -28,12 +28,16 @@ public interface IDialogService
     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 yes/no confirmation. Returns true only when confirmed. <paramref name="confirmLabel"/>
+    /// overrides the default localized "Confirm" button text (e.g. a localized "Delete" for destructive actions).</summary>
+    Task<bool> ConfirmAsync(string message, string? confirmLabel = null);
 
     /// <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 (or re-show + focus) the modeless cheat-sheet window for the shell's shared VM.</summary>
+    void ShowCheatSheets(CheatSheetsViewModel vm);
 }

src/ClaudeDo.Ui/Services/InstallArtifactLocator.cs

@@ -1,9 +1,10 @@
 namespace ClaudeDo.Ui.Services;
 
-// Two named types because DI resolves them by type, not by key.
-public sealed class InstallerLocator() : InstallArtifactLocator("uninstaller", "ClaudeDo.Installer.exe");
+// Two named types because DI resolves them by type, not by key. Not sealed: tests subclass
+// these to fake Find() without touching the real filesystem/registry.
+public class InstallerLocator() : InstallArtifactLocator("uninstaller", "ClaudeDo.Installer.exe");
 
-public sealed class WorkerLocator() : InstallArtifactLocator("worker", "ClaudeDo.Worker.exe");
+public class WorkerLocator() : InstallArtifactLocator("worker", "ClaudeDo.Worker.exe");
 
 /// <summary>
 /// Locates an executable inside a ClaudeDo install: walk up from the running
@@ -14,7 +15,7 @@ public abstract class InstallArtifactLocator(string subdir, string exeName)
 {
     private const string InstallJson = "install.json";
 
-    public string? Find()
+    public virtual string? Find()
         => FindByWalkingUp(AppContext.BaseDirectory)
            ?? (OperatingSystem.IsWindows() ? FindByRegistry() : null);
 

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

@@ -5,6 +5,8 @@ namespace ClaudeDo.Ui.Services.Interfaces;
 public interface INotesApi
 {
     Task<List<DailyNoteDto>> ListAsync(DateOnly day);
+    /// <summary>Both ends inclusive — today plus its history in one call.</summary>
+    Task<List<DailyNoteDto>> ListBetweenAsync(DateOnly start, DateOnly end);
     Task<DailyNoteDto?> AddAsync(DateOnly day, string text);
     Task UpdateAsync(string id, string text);
     Task DeleteAsync(string id);

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

@@ -30,6 +30,17 @@ public interface IWorkerClient : INotifyPropertyChanged
     /// task to carry out nextPhase ("wait" | "merge" | "wait_final" | "merge_final").</summary>
     event Action<string, IReadOnlyList<string>, string>? HandoffRequestedEvent;
 
+    /// <summary>start_list_handler was called through the external MCP: (listId, taskIds). The UI
+    /// starts a list-handler run for them exactly like the "Let Claude handle it" button.</summary>
+    event Action<string, IReadOnlyList<string>>? ListHandlerStartRequestedEvent;
+    /// <summary>The 5h usage window is running out under a running list-handler session:
+    /// (handlerTaskId, message). Mission Control types the message into that task's ConPTY pane so
+    /// the session can hand off cleanly; no pane for the task means nothing happens.</summary>
+    event Action<string, string>? HandlerUsageWarningEvent;
+
+    /// <summary>An agent added a note through the MCP tool — an open notes editor reloads.</summary>
+    event Action? NotesUpdatedEvent;
+
     event Action? PrepStartedEvent;
     event Action<string>? PrepLineEvent;
     event Action<bool>? PrepFinishedEvent;
@@ -41,13 +52,6 @@ public interface IWorkerClient : INotifyPropertyChanged
     /// total.</summary>
     event Action<string, string, int, int>? OperationProgressEvent;
 
-    /// <summary>(taskId, phase, elapsedSeconds) — phase of an in-flight single-task merge
-    /// ("merging" | "verifying"). Fires while the MergeTask call itself is still pending, so the
-    /// waiting UI can show what it's blocked on; the verify phase re-fires every 30 s. A thin
-    /// forwarder over <see cref="OperationProgressEvent"/> kept for existing consumers (elapsed
-    /// seconds riding in the generic "current" slot).</summary>
-    event Action<string, string, int>? MergeProgressEvent;
-
     event Action<string, string>? PlanningMergeStartedEvent;
     event Action<string, string>? PlanningSubtaskMergedEvent;
     /// <summary>(planningTaskId, subtaskId, conflictedFiles, externallyDriven). externallyDriven
@@ -106,9 +110,11 @@ public interface IWorkerClient : INotifyPropertyChanged
     /// and clears BlockedByTaskId in the same update) — call once per row (parent and each
     /// queued child) rather than cascading server-side.</summary>
     Task DequeueTaskAsync(string taskId);
-    Task<MergeResultDto?> ApproveReviewAsync(string taskId, string targetBranch);
+    /// <param name="autostash">Retry flag for status "dirty_target": stash the target working
+    /// tree's uncommitted changes before merging and restore them afterwards (git --autostash).</param>
+    Task<MergeResultDto?> ApproveReviewAsync(string taskId, string targetBranch, bool autostash = false);
     Task<MergePreviewDto?> PreviewMergeAsync(string taskId, string targetBranch);
-    Task<MergeResultDto> MergeTaskAsync(string taskId, string targetBranch, bool removeWorktree, string commitMessage);
+    Task<MergeResultDto> MergeTaskAsync(string taskId, string targetBranch, bool removeWorktree, string commitMessage, bool autostash = false);
     Task RejectReviewToQueueAsync(string taskId, string feedback);
     Task RejectReviewToIdleAsync(string taskId);
     Task CancelReviewAsync(string taskId);
@@ -132,8 +138,9 @@ public interface IWorkerClient : INotifyPropertyChanged
     /// <summary>Launch spec for an embedded ConPTY "merge helper" session that drives the given
     /// tasks to a merged/Done state. listId scopes the session (and cwd) to that list.
     /// handlerTaskId (from CreateMergeHelperTaskAsync) is rendered into the brief so the session
-    /// can call handoff_list_handler on its own handler task.</summary>
-    Task<LaunchSpec> GetMergeHelperLaunchSpecAsync(IReadOnlyList<string> taskIds, string listId, string handlerTaskId, CancellationToken ct = default);
+    /// can call handoff_list_handler on its own handler task. model overrides the triage
+    /// session's model (null = default).</summary>
+    Task<LaunchSpec> GetMergeHelperLaunchSpecAsync(IReadOnlyList<string> taskIds, string listId, string handlerTaskId, string? model = null, CancellationToken ct = default);
     /// <summary>Creates the ClaudeDo task that owns a list-handler run (one per run, Idle/IsManual,
     /// never queued) so the ConPTY tile can be task-based instead of ad-hoc. Returns the new task id.</summary>
     Task<string> CreateMergeHelperTaskAsync(
@@ -143,6 +150,14 @@ public interface IWorkerClient : INotifyPropertyChanged
     /// session's role: "wait" | "merge" | "wait_final" | "merge_final".</summary>
     Task<LaunchSpec> GetMergeHelperHandoffLaunchSpecAsync(
         string taskId, IReadOnlyList<string> survivingTaskIds, string nextPhase, CancellationToken ct = default);
+    /// <summary>Reports that a task-based ConPTY session's process exited non-zero after it had been
+    /// running. The exit code only exists in this process; the worker decides whether it was a
+    /// list-handler session killed by the usage limit and reopens the same phase after the 5h reset.</summary>
+    Task ReportInteractiveSessionExitedAsync(string taskId, int exitCode, CancellationToken ct = default);
+    /// <summary>The handler round's still-open (Queued/Running) tasks, for the Mission Control
+    /// "abandon run" action. Empty when the round has no entry or nothing open -- the caller then
+    /// closes the pane without a confirmation dialog.</summary>
+    Task<IReadOnlyList<HandlerOpenTaskDto>> GetHandlerOpenTasksAsync(string handlerTaskId, CancellationToken ct = default);
     /// <summary>Starts a planning session and returns the launch spec for an embedded ConPTY
     /// planning terminal (replaces StartPlanningSessionAsync's external wt window).</summary>
     Task<LaunchSpec> GetPlanningStartLaunchSpecAsync(string taskId, CancellationToken ct = default);
@@ -172,15 +187,14 @@ public interface IWorkerClient : INotifyPropertyChanged
     Task<AppSettingsDto?> GetAppSettingsAsync();
     Task UpdateAppSettingsAsync(AppSettingsDto dto);
     Task<List<DailyNoteDto>> GetDailyNotesAsync(DateOnly day);
+    /// <summary>Both ends inclusive.</summary>
+    Task<List<DailyNoteDto>> GetDailyNotesBetweenAsync(DateOnly start, DateOnly end);
     Task<DailyNoteDto?> AddDailyNoteAsync(DateOnly day, string text);
     Task UpdateDailyNoteAsync(string id, string text);
     Task DeleteDailyNoteAsync(string id);
     Task<string> GetLastPrepLogAsync();
     Task<IReadOnlyList<WorkerLogEntry>> GetRecentLogsAsync();
 
-    /// <summary>Git SHA the running worker was built from (null when offline or the build isn't stamped).</summary>
-    Task<WorkerBuildInfoDto?> GetWorkerBuildInfoAsync();
-
     Task<List<PrimeScheduleDto>> GetPrimeSchedulesAsync();
     Task<PrimeScheduleDto?> UpsertPrimeScheduleAsync(PrimeScheduleDto dto);
     Task DeletePrimeScheduleAsync(Guid id);

src/ClaudeDo.Ui/Services/PtyTerminalSession.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using Iciclecreek.Terminal;
@@ -67,6 +68,14 @@ public sealed class PtyTerminalSession : IDisposable
         await WaitForLaunchGateAsync(s_launchGate, s_launchGateTimeout, ct);
         try
         {
+            // If ClaudeDo.App itself was started from inside a claude session (e.g. a dev/test
+            // launch), it inherits these markers and every embedded PTY session would otherwise
+            // inherit them too — the child claude then thinks it's a spawned subagent and
+            // disables transcript saving / degrades its own startup banner. Every ConPTY tile
+            // must look like a fresh top-level session regardless of how ClaudeDo.App was launched.
+            Environment.SetEnvironmentVariable("CLAUDE_CODE_CHILD_SESSION", null);
+            Environment.SetEnvironmentVariable("CLAUDECODE", null);
+
             foreach (var (key, value) in descriptor.Env)
                 Environment.SetEnvironmentVariable(key, value);
 
@@ -93,6 +102,96 @@ public sealed class PtyTerminalSession : IDisposable
         ProcessExited?.Invoke(this, e.ExitCode);
     }
 
+    /// <summary>
+    /// Types <paramref name="text"/> into the running session and submits it, exactly as if the user
+    /// had typed it — used to warn a list-handler session before the usage limit
+    /// (<c>HandlerUsageWarning</c>). Verified against a real `claude` TUI, including while it was
+    /// mid-turn (the message is queued and acted on when the turn ends).
+    ///
+    /// Three non-obvious details, all established by that spike:
+    /// • <see cref="TerminalControl"/> exposes no public write path at all — its only public paste is
+    ///   <c>TerminalView.PasteAsync()</c>, which takes no argument and reads the clipboard. The
+    ///   private <c>SendToPtyAsync</c> on the inner view is the write seam, hence the reflection.
+    /// • The text and the Enter must be TWO writes. A single <c>text + "\r"</c> chunk lands in
+    ///   claude's composer but is never submitted — a chunk carrying an embedded CR reads as pasted
+    ///   text, not as a keypress.
+    /// • The Enter bytes come from the emulator (<c>GenerateKeyInput</c>) rather than a literal
+    ///   "\r", because claude turns Win32 input mode on and the emulator owns that encoding.
+    ///
+    /// Best-effort by design: a package upgrade that renames the private member costs a warning that
+    /// never arrives, never a crashed Mission Control.
+    /// </summary>
+    public async Task<bool> SendLineAsync(string text)
+    {
+        if (_control is not { } control || !IsRunning || string.IsNullOrEmpty(text)) return false;
+        try
+        {
+            await SendRawAsync(control, text);
+            await Task.Delay(SubmitDelay);
+            await SendRawAsync(control, control.Terminal.GenerateKeyInput(XTerm.Input.Key.Enter, XTerm.Input.KeyModifiers.None));
+            return true;
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Inserts <paramref name="text"/> at the cursor without submitting it — the drop-a-file-path
+    /// case. Same write seam as <see cref="SendLineAsync"/>, just without the Enter.
+    /// </summary>
+    public async Task<bool> SendTextAsync(string text)
+    {
+        if (_control is not { } control || !IsRunning || string.IsNullOrEmpty(text)) return false;
+        try
+        {
+            await SendRawAsync(control, text);
+            return true;
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Pastes the clipboard into the session. <see cref="TerminalControl"/> wires paste to the
+    /// right-click menu only, so Ctrl+V otherwise reaches the child as a raw control byte and does
+    /// nothing. Goes through the emulator's own <see cref="TerminalView.PasteAsync"/> rather than
+    /// writing the clipboard text raw, because that is what honours bracketed-paste mode — without
+    /// it a multi-line paste is read line by line and submits on the first newline.
+    /// </summary>
+    public async Task<bool> PasteAsync()
+    {
+        if (_control is not { } control || !IsRunning) return false;
+        try
+        {
+            if (s_terminalViewField?.GetValue(control) is not TerminalView view) return false;
+            await view.PasteAsync();
+            return true;
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+    }
+
+    // Long enough that the two writes can't be read as one chunk by the child's stdin reader.
+    private static readonly TimeSpan SubmitDelay = TimeSpan.FromMilliseconds(150);
+
+    private static readonly FieldInfo? s_terminalViewField =
+        typeof(TerminalControl).GetField("_terminalView", BindingFlags.Instance | BindingFlags.NonPublic);
+    private static readonly MethodInfo? s_sendToPty =
+        typeof(TerminalView).GetMethod("SendToPtyAsync", BindingFlags.Instance | BindingFlags.NonPublic);
+
+    private static Task SendRawAsync(TerminalControl control, string data)
+    {
+        if (s_terminalViewField?.GetValue(control) is not TerminalView view || s_sendToPty is null)
+            throw new InvalidOperationException("Iciclecreek.Avalonia.Terminal no longer exposes a PTY write seam.");
+        return (Task)s_sendToPty.Invoke(view, new object[] { data, CancellationToken.None })!;
+    }
+
     public void Kill()
     {
         try { _control?.Kill(); }

src/ClaudeDo.Ui/Services/RepoScanner.cs

@@ -67,9 +67,7 @@ public static class RepoScanner
         }
     }
 
-    private static bool IsRepo(string dir)
-    {
-        var gitPath = Path.Combine(dir, ".git");
-        return Directory.Exists(gitPath) || File.Exists(gitPath);
-    }
+    // A real clone has .git as a directory. Worktrees and submodules have it as a file
+    // ("gitdir: ...") — those are not standalone repos and would flood the list.
+    public static bool IsRepo(string dir) => Directory.Exists(Path.Combine(dir, ".git"));
 }

src/ClaudeDo.Ui/Services/ReportDtos.cs

@@ -1,3 +1,3 @@
 namespace ClaudeDo.Ui.Services;
 
-public sealed record DailyNoteDto(string Id, string Date, string Text, int SortOrder);
+public sealed record DailyNoteDto(string Id, string Date, string Text, int SortOrder, bool FromAgent);

src/ClaudeDo.Ui/Services/WorkerClient.cs

@@ -49,11 +49,14 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public event Action<string, string, string>? TaskQuestionAskedEvent;
     public event Action<string, string>? TaskQuestionResolvedEvent;
     public event Action<string, IReadOnlyList<string>, string>? HandoffRequestedEvent;
+    public event Action<string, IReadOnlyList<string>>? ListHandlerStartRequestedEvent;
+    public event Action<string, string>? HandlerUsageWarningEvent;
     public event Action? ConnectionRestoredEvent;
     public event Action<string>? WorktreeUpdatedEvent;
     public event Action<string>? ListUpdatedEvent;
     public event Action<WorkerLogEntry>? WorkerLogReceivedEvent;
 
+    public event Action? NotesUpdatedEvent;
     public event Action? PrepStartedEvent;
     public event Action<string>? PrepLineEvent;
     public event Action<bool>? PrepFinishedEvent;
@@ -64,7 +67,6 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public event Action<UsageSnapshotDto>? UsageUpdatedEvent;
 
     public event Action<string, string, int, int>? OperationProgressEvent;
-    public event Action<string, string, int>? MergeProgressEvent;
 
     public event Action<string, string>? PlanningMergeStartedEvent;
     public event Action<string, string>? PlanningSubtaskMergedEvent;
@@ -158,6 +160,16 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
             Dispatcher.UIThread.Post(() => HandoffRequestedEvent?.Invoke(taskId, survivingTaskIds, nextPhase));
         });
 
+        _hub.On<string, IReadOnlyList<string>>("ListHandlerStartRequested", (listId, taskIds) =>
+        {
+            Dispatcher.UIThread.Post(() => ListHandlerStartRequestedEvent?.Invoke(listId, taskIds));
+        });
+
+        _hub.On<string, string>("HandlerUsageWarning", (taskId, message) =>
+        {
+            Dispatcher.UIThread.Post(() => HandlerUsageWarningEvent?.Invoke(taskId, message));
+        });
+
         _hub.On<string>("WorktreeUpdated", taskId =>
         {
             Dispatcher.UIThread.Post(() => WorktreeUpdatedEvent?.Invoke(taskId));
@@ -176,11 +188,7 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
 
         _hub.On<string, string, int, int>("OperationProgress", (opKey, phase, current, total) =>
         {
-            Dispatcher.UIThread.Post(() =>
-            {
-                OperationProgressEvent?.Invoke(opKey, phase, current, total);
-                MergeProgressEvent?.Invoke(opKey, phase, current);
-            });
+            Dispatcher.UIThread.Post(() => OperationProgressEvent?.Invoke(opKey, phase, current, total));
         });
 
         _hub.On<string, string>("PlanningMergeStarted", (planningTaskId, targetBranch) =>
@@ -213,6 +221,7 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
             Dispatcher.UIThread.Post(() => PrimeFired?.Invoke(new PrimeFiredEvent(id, ok, msg, when)));
         });
 
+        _hub.On("NotesUpdated", () => Dispatcher.UIThread.Post(() => NotesUpdatedEvent?.Invoke()));
         _hub.On("PrepStarted", () => Dispatcher.UIThread.Post(() => PrepStartedEvent?.Invoke()));
         _hub.On<string>("PrepLine", line => Dispatcher.UIThread.Post(() => PrepLineEvent?.Invoke(line)));
         _hub.On<bool>("PrepFinished", ok => Dispatcher.UIThread.Post(() => PrepFinishedEvent?.Invoke(ok)));
@@ -344,10 +353,11 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
         await InvokeTimedAsync("ResetTask", () => _hub.InvokeAsync("ResetTask", taskId));
     }
 
-    public async Task<MergeResultDto> MergeTaskAsync(string taskId, string targetBranch, bool removeWorktree, string commitMessage)
+    public async Task<MergeResultDto> MergeTaskAsync(
+        string taskId, string targetBranch, bool removeWorktree, string commitMessage, bool autostash = false)
     {
         return await InvokeTimedAsync<MergeResultDto>("MergeTask", () => _hub.InvokeAsync<MergeResultDto>(
-            "MergeTask", taskId, targetBranch, removeWorktree, commitMessage));
+            "MergeTask", taskId, targetBranch, removeWorktree, commitMessage, autostash));
     }
 
     public Task<MergeResultDto> StartConflictMergeAsync(string taskId, string targetBranch)
@@ -475,6 +485,9 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public async Task<List<DailyNoteDto>> GetDailyNotesAsync(DateOnly day)
         => await TryInvokeAsync<List<DailyNoteDto>>("GetDailyNotes", IsoDay(day)) ?? new List<DailyNoteDto>();
 
+    public async Task<List<DailyNoteDto>> GetDailyNotesBetweenAsync(DateOnly start, DateOnly end)
+        => await TryInvokeAsync<List<DailyNoteDto>>("GetDailyNotesBetween", IsoDay(start), IsoDay(end)) ?? new List<DailyNoteDto>();
+
     public async Task<DailyNoteDto?> AddDailyNoteAsync(DateOnly day, string text)
         => await InvokeTimedAsync<DailyNoteDto>("AddDailyNote", () => _hub.InvokeAsync<DailyNoteDto>("AddDailyNote", IsoDay(day), text));
 
@@ -487,9 +500,6 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public async Task<string> GetLastPrepLogAsync()
         => await TryInvokeAsync<string>("GetLastPrepLog") ?? string.Empty;
 
-    public Task<WorkerBuildInfoDto?> GetWorkerBuildInfoAsync()
-        => TryInvokeAsync<WorkerBuildInfoDto>("GetWorkerBuildInfo");
-
     public async Task<IReadOnlyList<WorkerLogEntry>> GetRecentLogsAsync()
         => await TryInvokeAsync<List<WorkerLogEntry>>("GetRecentLogs") ?? new List<WorkerLogEntry>();
 
@@ -544,10 +554,10 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public Task DequeueTaskAsync(string taskId)
         => InvokeTimedAsync("DequeueTask", () => _hub.InvokeAsync("DequeueTask", taskId));
 
-    public async Task<MergeResultDto?> ApproveReviewAsync(string taskId, string targetBranch)
+    public async Task<MergeResultDto?> ApproveReviewAsync(string taskId, string targetBranch, bool autostash = false)
     {
         LastApproveTarget = targetBranch;
-        return await InvokeTimedAsync<MergeResultDto>("ApproveReview", () => _hub.InvokeAsync<MergeResultDto>("ApproveReview", taskId, targetBranch));
+        return await InvokeTimedAsync<MergeResultDto>("ApproveReview", () => _hub.InvokeAsync<MergeResultDto>("ApproveReview", taskId, targetBranch, autostash));
     }
 
     public Task<MergePreviewDto?> PreviewMergeAsync(string taskId, string targetBranch)
@@ -613,8 +623,8 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public async Task<LaunchSpec> GetAdHocLaunchSpecAsync(string directory, CancellationToken ct = default)
         => await InvokeTimedAsync<LaunchSpec>("GetAdHocLaunchSpec", () => _hub.InvokeAsync<LaunchSpec>("GetAdHocLaunchSpec", directory, ct));
 
-    public async Task<LaunchSpec> GetMergeHelperLaunchSpecAsync(IReadOnlyList<string> taskIds, string listId, string handlerTaskId, CancellationToken ct = default)
-        => await InvokeTimedAsync<LaunchSpec>("GetMergeHelperLaunchSpec", () => _hub.InvokeAsync<LaunchSpec>("GetMergeHelperLaunchSpec", taskIds, listId, handlerTaskId, ct));
+    public async Task<LaunchSpec> GetMergeHelperLaunchSpecAsync(IReadOnlyList<string> taskIds, string listId, string handlerTaskId, string? model = null, CancellationToken ct = default)
+        => await InvokeTimedAsync<LaunchSpec>("GetMergeHelperLaunchSpec", () => _hub.InvokeAsync<LaunchSpec>("GetMergeHelperLaunchSpec", taskIds, listId, handlerTaskId, model, ct));
 
     public async Task<string> CreateMergeHelperTaskAsync(
         IReadOnlyList<string> taskIds, string listId, string title, string descriptionHeader, CancellationToken ct = default)
@@ -624,6 +634,12 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
         string taskId, IReadOnlyList<string> survivingTaskIds, string nextPhase, CancellationToken ct = default)
         => await InvokeTimedAsync<LaunchSpec>("GetMergeHelperHandoffLaunchSpec", () => _hub.InvokeAsync<LaunchSpec>("GetMergeHelperHandoffLaunchSpec", taskId, survivingTaskIds, nextPhase, ct));
 
+    public Task ReportInteractiveSessionExitedAsync(string taskId, int exitCode, CancellationToken ct = default)
+        => InvokeTimedAsync("ReportInteractiveSessionExited", () => _hub.InvokeAsync("ReportInteractiveSessionExited", taskId, exitCode, ct));
+
+    public async Task<IReadOnlyList<HandlerOpenTaskDto>> GetHandlerOpenTasksAsync(string handlerTaskId, CancellationToken ct = default)
+        => await InvokeTimedAsync<List<HandlerOpenTaskDto>>("GetHandlerOpenTasks", () => _hub.InvokeAsync<List<HandlerOpenTaskDto>>("GetHandlerOpenTasks", handlerTaskId, ct));
+
     public async Task<LaunchSpec> GetPlanningStartLaunchSpecAsync(string taskId, CancellationToken ct = default)
         => await InvokeTimedAsync<LaunchSpec>("GetPlanningStartLaunchSpec", () => _hub.InvokeAsync<LaunchSpec>("GetPlanningStartLaunchSpec", taskId, ct));
 

src/ClaudeDo.Ui/Services/WorkerNotesApi.cs

@@ -7,6 +7,7 @@ public sealed class WorkerNotesApi : INotesApi
     private readonly IWorkerClient _client;
     public WorkerNotesApi(IWorkerClient client) => _client = client;
     public Task<List<DailyNoteDto>> ListAsync(DateOnly day) => _client.GetDailyNotesAsync(day);
+    public Task<List<DailyNoteDto>> ListBetweenAsync(DateOnly start, DateOnly end) => _client.GetDailyNotesBetweenAsync(start, end);
     public Task<DailyNoteDto?> AddAsync(DateOnly day, string text) => _client.AddDailyNoteAsync(day, text);
     public Task UpdateAsync(string id, string text) => _client.UpdateDailyNoteAsync(id, text);
     public Task DeleteAsync(string id) => _client.DeleteDailyNoteAsync(id);

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

@@ -208,11 +208,13 @@ public sealed partial class AgentConfigEditorViewModel : ViewModelBase, IDisposa
         catch { }
     }
 
-    // verifyCommand and ticketProjectId are List-only fields owned by ListSettingsModalViewModel
-    // (not this editor, which is also reused for Task scope); the caller passes them through so the
-    // single UpdateListConfig call carries the full desired row instead of clobbering it.
+    // verifyCommand, ticketProjectId and powerUseAllowed are List-only fields owned by
+    // ListSettingsModalViewModel (not this editor, which is also reused for Task scope); the caller
+    // passes them through so the single UpdateListConfig call carries the full desired row instead
+    // of clobbering it. powerUseAllowed stays null-by-default for the same reason ticketProjectId
+    // does: a caller that doesn't own it must not revoke the list's opt-in by omission.
     public async System.Threading.Tasks.Task SaveAsync(
-        string? verifyCommand = null, int? ticketProjectId = null)
+        string? verifyCommand = null, int? ticketProjectId = null, bool? powerUseAllowed = null)
     {
         if (TargetId is null) return;
         var model = string.IsNullOrWhiteSpace(Model) ? null : Model;
@@ -225,7 +227,7 @@ public sealed partial class AgentConfigEditorViewModel : ViewModelBase, IDisposa
         if (_scope == AgentConfigScope.Task)
             await _worker.UpdateTaskAgentSettingsAsync(new UpdateTaskAgentSettingsDto(TargetId, model, sp, ap, turns, skills, permission));
         else
-            await _worker.UpdateListConfigAsync(new UpdateListConfigDto(TargetId, model, sp, ap, turns, skills, verifyCommand, permission, ticketProjectId));
+            await _worker.UpdateListConfigAsync(new UpdateListConfigDto(TargetId, model, sp, ap, turns, skills, verifyCommand, permission, ticketProjectId, powerUseAllowed));
     }
 
     private List<string>? SelectedSessionSkillNames()
@@ -234,6 +236,10 @@ public sealed partial class AgentConfigEditorViewModel : ViewModelBase, IDisposa
         return names.Count == 0 ? null : names;
     }
 
+    // The list_config row fetched by the most recent LoadForListAsync — exposed so a caller that
+    // needs the same row (ListSettingsModalViewModel) can reuse it instead of fetching it again.
+    public ListConfigDto? LastLoadedListConfig { get; private set; }
+
     public async System.Threading.Tasks.Task LoadForListAsync(string listId, CancellationToken ct = default)
     {
         _suppressSave = true;
@@ -244,6 +250,7 @@ public sealed partial class AgentConfigEditorViewModel : ViewModelBase, IDisposa
             await LoadGlobalDefaultsAsync();
 
             var cfg = await _worker.GetListConfigAsync(listId);
+            LastLoadedListConfig = cfg;
             ApplyConfig(cfg?.Model, cfg?.MaxTurns, cfg?.SystemPrompt, cfg?.AgentPath, cfg?.PermissionMode);
             await ReloadSessionSkillsAsync(cfg?.SessionSkills);
 

src/ClaudeDo.Ui/ViewModels/Conflicts/ConflictResolverViewModel.cs

@@ -145,7 +145,7 @@ public sealed partial class ConflictResolverViewModel : ObservableObject
             {
                 // Any non-conflict outcome here means nothing was left mid-merge for this dialog
                 // to resolve -- surface why instead of quietly closing with no explanation.
-                if (start.Status is "blocked" or "untracked_collision")
+                if (start.Status is "blocked" or "untracked_collision" or "dirty_target")
                     Error = start.ErrorMessage;
                 return false;
             }

src/ClaudeDo.Ui/ViewModels/InteractiveTerminalViewModel.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Threading.Tasks;
 using CommunityToolkit.Mvvm.ComponentModel;
+using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
 using Iciclecreek.Terminal;
 
@@ -36,14 +37,29 @@ public sealed partial class InteractiveTerminalViewModel : ViewModelBase, IDispo
     /// can show a spinner instead of an empty black pane.</summary>
     public bool IsStarting => !IsRunning && !HasExited && StartError is null;
 
+    /// <summary>True once the process has died without a <see cref="StartError"/> already covering it —
+    /// i.e. every death that isn't a launch-time failure: a crash after running a while, a clean exit,
+    /// or a quiet exit inside the startup grace window. Drives the host's "session ended" banner so a
+    /// dead pane never looks like it's still running/thinking.</summary>
+    public bool HasExitedAfterStartup => HasExited && StartError is null;
+
     partial void OnIsRunningChanged(bool value)
     {
         OnPropertyChanged(nameof(IsStarting));
         if (value) _startedAtUtc = _utcNow();
     }
 
-    partial void OnHasExitedChanged(bool value)   => OnPropertyChanged(nameof(IsStarting));
-    partial void OnStartErrorChanged(string? value) => OnPropertyChanged(nameof(IsStarting));
+    partial void OnHasExitedChanged(bool value)
+    {
+        OnPropertyChanged(nameof(IsStarting));
+        OnPropertyChanged(nameof(HasExitedAfterStartup));
+    }
+
+    partial void OnStartErrorChanged(string? value)
+    {
+        OnPropertyChanged(nameof(IsStarting));
+        OnPropertyChanged(nameof(HasExitedAfterStartup));
+    }
 
     public InteractiveTerminalViewModel() : this(() => DateTime.UtcNow)
     {
@@ -96,6 +112,22 @@ public sealed partial class InteractiveTerminalViewModel : ViewModelBase, IDispo
         }
     }
 
+    /// <summary>Raised when a user-initiated paste or drop couldn't reach the session (write seam
+    /// gone, no running process) — mirrors the island ViewModels' ErrorReported, forwarded by
+    /// <see cref="ClaudeDo.Ui.ViewModels.MissionControl.ConPtyPaneViewModel"/> into the footer error strip.</summary>
+    public event Action<string>? ErrorReported;
+
+    /// <summary>Called by the view after a failed <see cref="PasteAsync"/>/<see cref="SendTextAsync"/>
+    /// so the failure surfaces through <see cref="ErrorReported"/> instead of vanishing silently.</summary>
+    public void ReportSendFailed() => ErrorReported?.Invoke(Loc.T("missionControl.terminalSendFailed"));
+
+    /// <summary>Raised when the process died non-zero *after* clearing <see cref="StartupGraceWindow"/> —
+    /// i.e. a session that ran, then broke. That used to be a silent dead tile with no signal at all;
+    /// the worker turns it into a usage-limit auto-restart for list-handler sessions
+    /// (<c>HandlerRestartCoordinator</c>). A startup death keeps using <see cref="StartError"/> instead:
+    /// it never reached a state worth resuming.</summary>
+    public event Action<int>? ExitedAfterStartup;
+
     /// <summary>Internal (not private) so tests can drive it directly without a real ConPTY spawn.</summary>
     internal void OnSessionProcessExited(object? sender, int exitCode)
     {
@@ -103,11 +135,16 @@ public sealed partial class InteractiveTerminalViewModel : ViewModelBase, IDispo
         HasExited = true;
         ExitCode = exitCode;
 
+        if (exitCode == 0) return;
+        if (_startedAtUtc is not { } startedAt) return; // never reached "running" — nothing ran to resume
+
         // Died at startup: route through the same banner as a launch-time failure instead of
         // leaving a dead terminal with no Retry affordance (ConPtyPaneViewModel.CanRetry
         // requires StartError).
-        if (exitCode != 0 && _startedAtUtc is { } startedAt && _utcNow() - startedAt < StartupGraceWindow)
+        if (_utcNow() - startedAt < StartupGraceWindow)
             StartError = $"Session exited immediately (code {exitCode}).";
+        else
+            ExitedAfterStartup?.Invoke(exitCode);
     }
 
     /// <summary>Reports a failure that happened before <see cref="Start"/> could be called (e.g. the
@@ -119,6 +156,20 @@ public sealed partial class InteractiveTerminalViewModel : ViewModelBase, IDispo
         StartError = message;
     }
 
+    /// <summary>Types a line into the live session and submits it — see
+    /// <see cref="PtyTerminalSession.SendLineAsync"/>. False when there is no running process to
+    /// type into (or the write seam is gone).</summary>
+    public Task<bool> SendLineAsync(string text) => _session.SendLineAsync(text);
+
+    /// <summary>Inserts text at the cursor without submitting — see
+    /// <see cref="PtyTerminalSession.SendTextAsync"/> (dropped file paths).</summary>
+    public Task<bool> SendTextAsync(string text) => _session.SendTextAsync(text);
+
+    /// <summary>Pastes the clipboard into the session (Ctrl+V) — see
+    /// <see cref="PtyTerminalSession.PasteAsync"/>. False when there is no running process to
+    /// paste into (or the write seam is gone).</summary>
+    public Task<bool> PasteAsync() => _session.PasteAsync();
+
     public void Kill() => _session.Kill();
 
     public void Dispose()

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

@@ -20,7 +20,6 @@ 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 MergeCoordinator _merge;
 
     // ── Section view models ───────────────────────────────────────────────────
@@ -39,29 +38,20 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     private readonly Action<string, string?> _workerPlanningMergeAbortedHandler;
     private readonly Action<string> _workerPlanningCompletedHandler;
 
-    [ObservableProperty] private bool _isNotesMode;
     [ObservableProperty] private bool _isPrepMode;
 
-    public bool IsTaskDetailVisible => !IsNotesMode && !IsPrepMode;
+    public bool IsTaskDetailVisible => !IsPrepMode;
 
-    /// <summary>Centered placeholder shown when no task is selected — hidden in Notes/Prep mode,
+    /// <summary>Centered placeholder shown when no task is selected — hidden in Prep mode,
     /// where <see cref="IsTaskDetailVisible"/> is already false.</summary>
     public bool IsEmptyStateVisible => Task is null && IsTaskDetailVisible;
 
-    partial void OnIsNotesModeChanged(bool value)
-    {
-        OnPropertyChanged(nameof(IsTaskDetailVisible));
-        OnPropertyChanged(nameof(IsEmptyStateVisible));
-    }
-
     partial void OnIsPrepModeChanged(bool value)
     {
         OnPropertyChanged(nameof(IsTaskDetailVisible));
         OnPropertyChanged(nameof(IsEmptyStateVisible));
     }
 
-    public NotesEditorViewModel Notes { get; private set; } = null!;
-
     // Current task row (set by IslandsShellViewModel via Bind)
     [ObservableProperty]
     [NotifyCanExecuteChangedFor(nameof(EnqueueCommand))]
@@ -301,11 +291,9 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     // Set by shell so DeleteTaskCommand can remove from list
     public Func<TaskRowViewModel, System.Threading.Tasks.Task>? DeleteFromList { get; set; }
 
-    // Set by the view so DeleteTaskCommand can prompt yes/no before deleting
-    public Func<string, System.Threading.Tasks.Task<bool>>? ConfirmAsync { get; set; }
-
-    // Set by the view so DeleteTaskCommand can show an error message
-    public Func<string, System.Threading.Tasks.Task>? ShowErrorAsync { get; set; }
+    // Set by the shell (mirrors ListsIslandViewModel.Dialogs) so confirm/error prompts go
+    // through the one shared dialog implementation instead of a view-local copy.
+    public IDialogService? Dialogs { get; set; }
 
     // ── Review ──────────────────────────────────────────────────────────────
     [ObservableProperty]
@@ -324,13 +312,11 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         IDbContextFactory<ClaudeDoDbContext> dbFactory,
         IWorkerClient worker,
         IServiceProvider services,
-        INotesApi notesApi,
         MergeCoordinator merge)
     {
         _dbFactory = dbFactory;
         _worker = worker;
         _services = services;
-        _notesApi = notesApi;
         _merge = merge;
 
         Monitor = new TaskMonitorViewModel(dbFactory, worker);
@@ -374,8 +360,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
             if (e.PropertyName == nameof(OperationStatus.IsRunning)) ParkReviewCommand.NotifyCanExecuteChanged();
         };
 
-        Notes = new NotesEditorViewModel(_notesApi);
-        Notes.ErrorReported += msg => { if (ShowErrorAsync is not null) _ = ShowErrorAsync(msg); };
         Subtasks.CollectionChanged += (_, _) => NotifyStepsChanged();
         Subtasks.CollectionChanged += (_, _) => Merge.SyncChildOutcomes(HasChildOutcomes, Subtasks.Count);
         Attachments.CollectionChanged += (_, _) => OnPropertyChanged(nameof(FilesBadge));
@@ -592,18 +576,9 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         catch { }
     }
 
-    public void ShowNotes()
-    {
-        Bind(null, "notes");
-        IsPrepMode = false;
-        IsNotesMode = true;
-        _ = Notes.LoadDayAsync(DateOnly.FromDateTime(DateTime.Today));
-    }
-
     public void ShowPrep()
     {
         Bind(null, "prep");
-        IsNotesMode = false;
         IsPrepMode = true;
         _ = Prep.LoadLastPrepLogIfEmptyAsync();
     }
@@ -612,7 +587,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     /// logged with the bind timing so rebind churn can be attributed to a trigger.</param>
     public void Bind(TaskRowViewModel? row, string source = "?")
     {
-        IsNotesMode = false;
         IsPrepMode = false;
         _loadCts?.Cancel();
         _loadCts?.Dispose();
@@ -752,6 +726,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
                     Merge.MergeTargetBranches.Clear();
                     foreach (var b in targets.LocalBranches) Merge.MergeTargetBranches.Add(b);
                     Merge.SelectedMergeTarget = targets.DefaultBranch;
+                    Merge.TargetDirty = targets.TargetDirty;
                 }
             }
             await Merge.RefreshMergePreviewAsync();
@@ -802,6 +777,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
                         foreach (var b in targets.LocalBranches)
                             Merge.MergeTargetBranches.Add(b);
                         Merge.SelectedMergeTarget = targets.DefaultBranch;
+                        Merge.TargetDirty = targets.TargetDirty;
                     }
                 }
             }
@@ -848,6 +824,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
                         foreach (var b in targets.LocalBranches)
                             Merge.MergeTargetBranches.Add(b);
                         Merge.SelectedMergeTarget = targets.DefaultBranch;
+                        Merge.TargetDirty = targets.TargetDirty;
                     }
                 }
             }
@@ -1066,9 +1043,9 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     {
         if (Task == null) return;
         var row = Task;
-        if (ConfirmAsync != null)
+        if (Dialogs != null)
         {
-            var ok = await ConfirmAsync($"Delete \"{row.Title}\"? This cannot be undone.");
+            var ok = await Dialogs.ConfirmAsync($"Delete \"{row.Title}\"? This cannot be undone.", Loc.T("dialog.delete"));
             if (!ok) return;
         }
         // Routed through the worker (mirrors the MCP delete_task tool) so a deleted child
@@ -1084,14 +1061,14 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         {
             // Belt and braces: the connection can drop between the CanExecute check and
             // this call, so a stray throw here must surface, not vanish silently.
-            if (ShowErrorAsync != null)
-                await ShowErrorAsync(ex.Message);
+            if (Dialogs != null)
+                await Dialogs.ShowErrorAsync(ex.Message);
             return;
         }
         if (!deleted)
         {
-            if (ShowErrorAsync != null)
-                await ShowErrorAsync(error ?? "Delete failed.");
+            if (Dialogs != null)
+                await Dialogs.ShowErrorAsync(error ?? "Delete failed.");
             return;
         }
         if (DeleteFromList != null)
@@ -1240,10 +1217,10 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     private async System.Threading.Tasks.Task ResetAndRetryAsync()
     {
         if (Task == null) return;
-        if (ConfirmAsync == null) return;
+        if (Dialogs == null) return;
 
         var branchName = $"claudedo/{Task.Id.Replace("-", "")}";
-        var ok = await ConfirmAsync(
+        var ok = await Dialogs.ConfirmAsync(
             $"Reset and retry?\nThis discards branch {branchName} (and uncommitted changes), then queues the task to run from the beginning.");
         if (!ok) return;
 
@@ -1286,43 +1263,51 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         using var op = ApproveOp.Begin(Loc.T("ops.merge.merging"));
         // Subscribed only for the duration of the call: the worker broadcasts to every
         // client, and a VM left on this event would keep reacting to merges for other tasks.
-        void OnMergeProgress(string progressTaskId, string phase, int elapsedSeconds)
-        {
-            if (progressTaskId != taskId || phase != MergePhaseVerifying) return;
-            ApproveOp.Report(Loc.T("ops.merge.verifying", FormatElapsed(elapsedSeconds)));
-        }
-        // Separate event: MergeProgressEvent forwards elapsed-seconds-only (verifying), but the
-        // rebase phase needs the branch count too, which only rides the untrimmed OperationProgress.
         void OnOperationProgress(string opKey, string phase, int current, int total)
         {
-            if (opKey != taskId || phase != MergePhaseRebasing) return;
-            ApproveOp.Report(FormatRebasing(current, total));
+            if (opKey != taskId) return;
+            if (phase == MergePhaseVerifying)
+                ApproveOp.Report(Loc.T("ops.merge.verifying", FormatElapsed(current)));
+            else if (phase == MergePhaseRebasing)
+                ApproveOp.Report(FormatRebasing(current, total));
         }
-        _worker.MergeProgressEvent += OnMergeProgress;
         _worker.OperationProgressEvent += OnOperationProgress;
         try
         {
             var hasChildren = Subtasks.Count > 0 || ChildOutcomes.Count > 0;
             var result = await _worker.ApproveReviewAsync(taskId, Merge.SelectedMergeTarget ?? "");
-            if (!hasChildren && result?.Status == "conflict")
+
+            // Nothing landed -- the target working dir has uncommitted changes (often another
+            // session's WIP in the shared main checkout). Offer the one-shot stash retry; git
+            // restores the changes itself once the merge is through.
+            if (result?.Status == "dirty_target" && Dialogs != null
+                && await Dialogs.ConfirmAsync(Loc.T("vm.detailsIsland.stashAndMergeConfirm")))
+            {
+                ApproveOp.Report(Loc.T("ops.merge.merging"));
+                result = await _worker.ApproveReviewAsync(
+                    taskId, Merge.SelectedMergeTarget ?? "", autostash: true);
+            }
+
+            if (result?.Status == "dirty_target" && Dialogs != null)
+                await Dialogs.ShowErrorAsync(result.ErrorMessage ?? Loc.T("vm.detailsIsland.dirtyTarget"));
+            else if (!hasChildren && result?.Status == "conflict")
                 await _merge.ResolveConflictAsync(taskId, Merge.SelectedMergeTarget ?? "");
             // The merge itself already landed; the verify command failed, so the task stayed
             // out of Done. Surface that instead of silently looking like nothing happened.
-            else if (!hasChildren && result?.Status == "verify_failed" && ShowErrorAsync != null)
-                await ShowErrorAsync(result.ErrorMessage ?? Loc.T("vm.detailsIsland.verifyFailed"));
+            else if (!hasChildren && result?.Status == "verify_failed" && Dialogs != null)
+                await Dialogs.ShowErrorAsync(result.ErrorMessage ?? Loc.T("vm.detailsIsland.verifyFailed"));
             // Nothing landed -- the merge was refused before touching the repo because the
             // branch would have overwritten an untracked file in the target working directory.
-            else if (!hasChildren && result?.Status == "untracked_collision" && ShowErrorAsync != null)
-                await ShowErrorAsync(result.ErrorMessage ?? Loc.T("vm.detailsIsland.untrackedCollision"));
+            else if (!hasChildren && result?.Status == "untracked_collision" && Dialogs != null)
+                await Dialogs.ShowErrorAsync(result.ErrorMessage ?? Loc.T("vm.detailsIsland.untrackedCollision"));
         }
         catch (Exception ex)
         {
-            if (ShowErrorAsync != null)
-                await ShowErrorAsync(ex.Message);
+            if (Dialogs != null)
+                await Dialogs.ShowErrorAsync(ex.Message);
         }
         finally
         {
-            _worker.MergeProgressEvent -= OnMergeProgress;
             _worker.OperationProgressEvent -= OnOperationProgress;
         }
     }
@@ -1364,7 +1349,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         try { await _worker.SubmitTaskForReviewAsync(Task.Id); }
         catch (Exception ex)
         {
-            if (ShowErrorAsync != null) await ShowErrorAsync(ex.Message);
+            if (Dialogs != null) await Dialogs.ShowErrorAsync(ex.Message);
         }
     }
 
@@ -1395,9 +1380,9 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     [RelayCommand]
     private async System.Threading.Tasks.Task ResetReviewAsync()
     {
-        if (Task is null || !_worker.IsConnected || ConfirmAsync is null) return;
+        if (Task is null || !_worker.IsConnected || Dialogs is null) return;
         var branchName = $"claudedo/{Task.Id.Replace("-", "")}";
-        var ok = await ConfirmAsync(
+        var ok = await Dialogs.ConfirmAsync(
             $"Reset working tree?\nThis discards branch {branchName} (and all changes) and returns the task to Idle.");
         if (!ok) return;
         try { await _worker.ResetTaskAsync(Task.Id); }
@@ -1533,12 +1518,17 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         catch { /* best-effort */ }
     }
 
+    // Shared by TaskRowViewModel.UpdateFromEntity — this is the one parser for
+    // `git diff --stat`'s summary line ("N insertions(+), M deletions(-)"). Anchored on the
+    // literal "(+)"/"(-)" markers rather than the English words: git for Windows localizes
+    // "insertion"/"deletion" to the OS language (e.g. German "Einfügung(en)"/"Löschung(en)"),
+    // but always keeps the untranslated (+)/(-) suffix, so this reads correctly in any locale.
     internal static (int Additions, int Deletions) ParseDiffStat(string? stat)
     {
         if (string.IsNullOrEmpty(stat)) return (0, 0);
         int add = 0, del = 0;
-        var m1 = System.Text.RegularExpressions.Regex.Match(stat, @"(\d+)\s+insertion");
-        var m2 = System.Text.RegularExpressions.Regex.Match(stat, @"(\d+)\s+deletion");
+        var m1 = System.Text.RegularExpressions.Regex.Match(stat, @"(\d+)[^,\n]*\(\+\)");
+        var m2 = System.Text.RegularExpressions.Regex.Match(stat, @"(\d+)[^,\n]*\(-\)");
         if (m1.Success) int.TryParse(m1.Groups[1].Value, out add);
         if (m2.Success) int.TryParse(m2.Groups[1].Value, out del);
         return (add, del);

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

@@ -0,0 +1,27 @@
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+
+namespace ClaudeDo.Ui.ViewModels.Islands;
+
+/// <summary>
+/// A sidebar folder row. Not a <see cref="ListNavItemViewModel"/> and not a
+/// <see cref="ListKind"/> — a folder holds no tasks and is never selectable, so tapping it
+/// toggles <see cref="IsCollapsed"/> instead of changing the selection.
+/// </summary>
+public sealed partial class ListFolderNavItemViewModel : ViewModelBase
+{
+    public required string Id { get; init; }
+    [ObservableProperty] private string _name = "";
+    [ObservableProperty] private string _iconKey = "Folder";
+    [ObservableProperty] private bool _isCollapsed;
+    // Sum of the child lists' counts — a collapsed folder still shows what's inside it.
+    [ObservableProperty] private int _count;
+    // Set while a dragged list row hovers over the middle of this folder header (move-into-folder).
+    [ObservableProperty] private bool _isDropTarget;
+    // Insert-position hints for a drop next to the folder instead of into it. Drawn around the
+    // whole folder block (header + children), not just the header.
+    [ObservableProperty] private bool _dropHintAbove;
+    [ObservableProperty] private bool _dropHintBelow;
+
+    public ObservableCollection<ListNavItemViewModel> Lists { get; } = new();
+}

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

@@ -26,4 +26,6 @@ public sealed partial class ListNavItemViewModel : ViewModelBase
     [ObservableProperty] private bool _isTaskDropTarget;
     // Settable (not init) so a list-settings icon change refreshes the row in place.
     [ObservableProperty] private string? _iconKey;
+    // The sidebar folder this row sits in (ListEntity.FolderId); null = top level.
+    [ObservableProperty] private string? _folderId;
 }

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

@@ -17,11 +17,19 @@ namespace ClaudeDo.Ui.ViewModels.Islands;
 
 public enum ListKind { Smart, Virtual, User }
 
-/// <summary>Confirmed handler run: the scope list and the ordered selected task ids.</summary>
-public sealed record MergeHelperRequest(string ListId, IReadOnlyList<string> TaskIds);
+/// <summary>Confirmed handler run: the scope list, the ordered selected task ids, and the model
+/// picked for the triage session (null = default; review-mode runs skip triage entirely).</summary>
+public sealed record MergeHelperRequest(string ListId, IReadOnlyList<string> TaskIds, string? TriageModel = null);
 
 public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
 {
+    /// <summary>The day-log list. A smart list with no tasks in it: selecting it makes the tasks
+    /// island show the notes editor instead of rows.</summary>
+    public const string NotesListId = "smart:notes";
+
+    /// <summary>Icon key a folder falls back to when it has none of its own.</summary>
+    public const string ListFolderIcon = "Folder";
+
     private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
     private readonly IServiceProvider? _services;
     private readonly IWorkerClient? _worker;
@@ -54,7 +62,8 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
         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, row.IsManual, row.FindingsTracked, row.IconKey);
+        vm.ErrorReported += msg => ErrorReported?.Invoke(msg);
+        vm.BeginLoad(rawId, row.Name, row.WorkingDir, row.DefaultCommitType, row.IsManual, row.FindingsTracked, row.IconKey);
         await Dialogs.ShowListSettingsAsync(vm);
         if (vm.Deleted) await LoadAsync();
         else await RefreshRowAsync(row.Id);
@@ -106,7 +115,7 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
         await vm.LoadAsync();
         var ids = await Dialogs.ShowMergeHelperSelectionAsync(vm);
         if (ids is { Count: > 0 })
-            LetClaudeHandleRequested?.Invoke(new MergeHelperRequest(rawId, ids));
+            LetClaudeHandleRequested?.Invoke(new MergeHelperRequest(rawId, ids, vm.SelectedModel));
     }
 
     /// <summary>Raised once per list after the review-scoped selection dialog is confirmed;
@@ -197,7 +206,22 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
 
     public ObservableCollection<ListNavItemViewModel> Items { get; } = new();
     public ObservableCollection<ListNavItemViewModel> SmartLists { get; } = new();
+    /// <summary>Every user list, flat, regardless of folder — the set the count refresh, the
+    /// row refresh and the no-repo banner work over.</summary>
     public ObservableCollection<ListNavItemViewModel> UserLists { get; } = new();
+    /// <summary>The sidebar's top level, in render order: folder rows
+    /// (<see cref="ListFolderNavItemViewModel"/>) and folder-less lists
+    /// (<see cref="ListNavItemViewModel"/>) interleaved, so a list can sit above a folder.
+    /// This is what the view binds to; <see cref="UserLists"/> stays the flat superset.</summary>
+    public ObservableCollection<object> TopLevel { get; } = new();
+
+    /// <summary>Sidebar folders in order — a projection of <see cref="TopLevel"/>, not a second
+    /// collection to keep in sync.</summary>
+    public IReadOnlyList<ListFolderNavItemViewModel> Folders =>
+        TopLevel.OfType<ListFolderNavItemViewModel>().ToList();
+    /// <summary>The user lists that sit outside any folder — likewise a projection.</summary>
+    public IReadOnlyList<ListNavItemViewModel> RootLists =>
+        TopLevel.OfType<ListNavItemViewModel>().ToList();
 
     [ObservableProperty] private string _searchText = "";
     [ObservableProperty] private ListNavItemViewModel? _selectedList;
@@ -255,6 +279,7 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
         "smart:my-day"    => "vm.lists.smartMyDay",
         "smart:important" => "vm.lists.smartImportant",
         "smart:planned"   => "vm.lists.smartPlanned",
+        NotesListId       => "vm.lists.smartNotes",
         "virtual:queued"  => "vm.lists.virtualQueue",
         "virtual:running" => "vm.lists.virtualRunning",
         "virtual:review"  => "vm.lists.virtualReview",
@@ -273,10 +298,12 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
         Items.Clear();
         SmartLists.Clear();
         UserLists.Clear();
+        TopLevel.Clear();
 
         var smart = new[]
         {
             new ListNavItemViewModel { Id = "smart:my-day",    Name = Loc.T("vm.lists.smartMyDay"),      Kind = ListKind.Smart,   IconKey = "Sun" },
+            new ListNavItemViewModel { Id = NotesListId,       Name = Loc.T("vm.lists.smartNotes"),      Kind = ListKind.Smart,   IconKey = "Text" },
             new ListNavItemViewModel { Id = "smart:important", Name = Loc.T("vm.lists.smartImportant"),  Kind = ListKind.Smart,   IconKey = "Star" },
             new ListNavItemViewModel { Id = "smart:planned",   Name = Loc.T("vm.lists.smartPlanned"),    Kind = ListKind.Smart,   IconKey = "Calendar" },
             new ListNavItemViewModel { Id = "virtual:queued",  Name = Loc.T("vm.lists.virtualQueue"),    Kind = ListKind.Virtual, IconKey = "Inbox" },
@@ -292,6 +319,24 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
             var ticketsConfigured = await IsTicketsConfiguredAsync();
             await using var ctx = await _dbFactory.CreateDbContextAsync(ct);
             var lists = new ListRepository(ctx);
+
+            // Folders and top-level lists share one sort_order space, so both go into a single
+            // ordered bucket and get merged by it — that's what interleaves them.
+            var topLevel = new List<(int Sort, object Item)>();
+            var foldersById = new Dictionary<string, ListFolderNavItemViewModel>();
+            foreach (var f in await lists.GetFoldersAsync(ct))
+            {
+                var folder = new ListFolderNavItemViewModel
+                {
+                    Id = f.Id,
+                    Name = f.Name,
+                    IconKey = f.Icon ?? ListFolderIcon,
+                    IsCollapsed = f.IsCollapsed,
+                };
+                foldersById[f.Id] = folder;
+                topLevel.Add((f.SortOrder, folder));
+            }
+
             var seedNames = new HashSet<string>(new[] { "My Day", "Important", "Planned" });
             foreach (var l in await lists.GetAllAsync(ct))
             {
@@ -308,10 +353,20 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
                     IsManual = l.IsManual,
                     FindingsTracked = l.FindingsTracked,
                     HasTicketProject = ticketsConfigured && cfg?.TicketProjectId > 0,
+                    FolderId = l.FolderId,
                 };
                 Items.Add(item);
                 UserLists.Add(item);
+                if (item.FolderId is { } fid && foldersById.TryGetValue(fid, out var owner))
+                    owner.Lists.Add(item);
+                else
+                    topLevel.Add((l.SortOrder, item));
             }
+
+            // OrderBy is stable, so legacy rows (folders and lists each numbered from 0
+            // independently) keep the old look — folders first — until the first drag.
+            foreach (var (_, item) in topLevel.OrderBy(t => t.Sort))
+                TopLevel.Add(item);
             ok = true;
         }
         finally { OperationTiming.Shared.Record("db", "ListsIsland.LoadAsync", sw.Elapsed, ok); }
@@ -358,6 +413,8 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
                 var filter = _filters.Resolve(item.Id);
                 item.Count = filter is null ? 0 : all.Count(filter.ShouldCount);
             }
+
+            RecomputeFolderCounts();
             ok = true;
         }
         catch (OperationCanceledException) { throw; }
@@ -396,15 +453,26 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
         };
         Items.Add(item);
         UserLists.Add(item);
+        TopLevel.Add(item);
         SelectedList = item;
         RecomputeHasNoLinkedRepo();
 
         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, entity.IsManual, entity.FindingsTracked, entity.Icon);
+            vm.ErrorReported += msg => ErrorReported?.Invoke(msg);
+            // canToggleFolder: only the create flow offers "make this a folder instead".
+            vm.BeginLoad(entity.Id, entity.Name, entity.WorkingDir, entity.DefaultCommitType, entity.IsManual, entity.FindingsTracked, entity.Icon, canToggleFolder: true);
             await Dialogs.ShowListSettingsAsync(vm);
-            if (vm.Deleted) await LoadAsync();
+            if (!vm.Saved && !vm.Deleted)
+            {
+                // Cancel/close right after "New list" means "never mind" — drop the row we
+                // pre-created, otherwise an untitled empty list is left behind.
+                await using var ctx = await _dbFactory.CreateDbContextAsync();
+                await new ListRepository(ctx).DeleteAsync(entity.Id);
+                await LoadAsync();
+            }
+            else if (vm.Deleted) await LoadAsync();
             else await RefreshRowAsync(item.Id);
         }
     }
@@ -416,42 +484,203 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
             r.DropHintAbove = false;
             r.DropHintBelow = false;
         }
-    }
-
-    public void SetDropHint(ListNavItemViewModel target, bool placeBelow)
-    {
-        foreach (var r in UserLists)
+        foreach (var f in Folders)
         {
-            var isTarget = ReferenceEquals(r, target);
-            r.DropHintAbove = isTarget && !placeBelow;
-            r.DropHintBelow = isTarget && placeBelow;
+            f.IsDropTarget = false;
+            f.DropHintAbove = false;
+            f.DropHintBelow = false;
         }
     }
 
-    public async Task ReorderAsync(ListNavItemViewModel source, ListNavItemViewModel target, bool placeBelow)
+    /// <summary>Marks the insert position for a drop next to <paramref name="target"/> — either a
+    /// list row or a folder header (folders take the same two hint lines, drawn around the whole
+    /// folder block).</summary>
+    public void SetDropHint(object target, bool placeBelow)
+    {
+        ClearDropHints();
+        switch (target)
+        {
+            case ListNavItemViewModel row:
+                row.DropHintAbove = !placeBelow;
+                row.DropHintBelow = placeBelow;
+                break;
+            case ListFolderNavItemViewModel folder:
+                folder.DropHintAbove = !placeBelow;
+                folder.DropHintBelow = placeBelow;
+                break;
+        }
+    }
+
+    public void SetFolderDropTarget(ListFolderNavItemViewModel? target)
+    {
+        ClearDropHints();
+        if (target is not null) target.IsDropTarget = true;
+    }
+
+    /// <summary>The collection a row is rendered in: its folder's <c>Lists</c>, or
+    /// <see cref="TopLevel"/> when it has no folder. Non-generic because the top level is mixed.</summary>
+    public System.Collections.IList ContainerOf(ListNavItemViewModel row) =>
+        Folders.FirstOrDefault(f => f.Id == row.FolderId)?.Lists ?? (System.Collections.IList)TopLevel;
+
+    /// <summary>Kept for the list→list case; <see cref="DropAsync"/> covers all four combinations.</summary>
+    public Task ReorderAsync(ListNavItemViewModel source, ListNavItemViewModel target, bool placeBelow) =>
+        DropAsync(source, target, placeBelow);
+
+    /// <summary>
+    /// Drops <paramref name="source"/> (a list row or a folder) at <paramref name="target"/>'s
+    /// position. Since a drop position implies a container, dropping a list onto a row in a
+    /// different folder (or next to anything at the top level) also *moves* it there — that's the
+    /// only way to drag a list out of a folder. Folders live at the top level only, so a folder
+    /// dropped onto a row inside a folder is ignored rather than nested.
+    /// </summary>
+    public async Task DropAsync(object source, object target, bool placeBelow)
     {
-        if (source.Kind != ListKind.User || target.Kind != ListKind.User) return;
         if (ReferenceEquals(source, target)) return;
+        if (target is ListNavItemViewModel { Kind: not ListKind.User }) return;
 
-        MoveWithinCollection(UserLists, source, target, placeBelow);
+        if (source is ListFolderNavItemViewModel folder)
+        {
+            if (target is ListNavItemViewModel { FolderId: not null }) return;
+            MoveWithinCollection(TopLevel, folder, target, placeBelow);
+            await PersistOrderAsync(null);
+            return;
+        }
+
+        if (source is not ListNavItemViewModel row || row.Kind != ListKind.User) return;
+
+        // Next to a folder *header* means top level, not inside it — MoveToFolderAsync is the
+        // drop-into-the-folder path.
+        var targetFolderId = target is ListNavItemViewModel t ? t.FolderId : null;
+        var folderChanged = row.FolderId != targetFolderId;
+        if (folderChanged)
+        {
+            ContainerOf(row).Remove(row);
+            row.FolderId = targetFolderId;
+            ContainerOf(row).Add(row);
+        }
+
+        MoveWithinCollection(ContainerOf(row), row, target, placeBelow);
+        await PersistOrderAsync(folderChanged ? row : null);
+    }
+
+    /// <summary>Appends a list to a folder (or to the top level when <paramref name="folder"/> is
+    /// null) — the drop-onto-the-folder-header path, which also reaches collapsed and empty folders.</summary>
+    public async Task MoveToFolderAsync(ListNavItemViewModel source, ListFolderNavItemViewModel? folder)
+    {
+        if (source.Kind != ListKind.User) return;
+        if (source.FolderId == folder?.Id) return;
+
+        ContainerOf(source).Remove(source);
+        source.FolderId = folder?.Id;
+        ContainerOf(source).Add(source);
+        await PersistOrderAsync(source);
+    }
+
+    /// <summary>
+    /// Writes the sidebar's visual order back as a single global <c>sort_order</c> sequence
+    /// (folders top to bottom, then the top-level lists) and, when a list changed folder, its new
+    /// <c>folder_id</c>.
+    /// </summary>
+    private async Task PersistOrderAsync(ListNavItemViewModel? movedRow)
+    {
+        var ordered = new List<(string Id, bool IsFolder)>();
+        foreach (var item in TopLevel)
+        {
+            switch (item)
+            {
+                case ListFolderNavItemViewModel f:
+                    ordered.Add((f.Id, true));
+                    ordered.AddRange(f.Lists.Select(l => (RawId(l.Id), false)));
+                    break;
+                case ListNavItemViewModel l:
+                    ordered.Add((RawId(l.Id), false));
+                    break;
+            }
+        }
 
-        var orderedIds = UserLists.Select(i => i.Id["user:".Length..]).ToList();
         var sw = System.Diagnostics.Stopwatch.StartNew();
         var ok = false;
         try
         {
             await using var ctx = await _dbFactory.CreateDbContextAsync();
             var lists = new ListRepository(ctx);
-            await lists.ReorderAsync(orderedIds);
+            if (movedRow is not null)
+                await lists.SetListFolderAsync(RawId(movedRow.Id), movedRow.FolderId);
+            await lists.ReorderSidebarAsync(ordered);
             ok = true;
         }
         finally { OperationTiming.Shared.Record("db", "ListsIsland.ReorderAsync", sw.Elapsed, ok); }
+
+        RecomputeFolderCounts();
     }
 
+    /// <summary>Context-menu counterpart to dragging a list out of a folder.</summary>
+    [RelayCommand]
+    private async Task RemoveFromFolderAsync(ListNavItemViewModel? row)
+    {
+        if (row is null) return;
+        await MoveToFolderAsync(row, null);
+    }
+
+    private readonly Dictionary<string, CancellationTokenSource> _folderCollapseCts = new();
+
+    // Synchronous on purpose: the fold is pure UI state and must never miss a click waiting on
+    // the AsyncRelayCommand's own CanExecute lock while the DB write below is in flight. The
+    // write is fire-and-forget with a per-folder cancellation token so a second toggle before the
+    // first one lands cancels it — the DB always ends up with the last-clicked state, never a
+    // stale one racing ahead of it.
+    [RelayCommand]
+    private void ToggleFolder(ListFolderNavItemViewModel? folder)
+    {
+        if (folder is null) return;
+        folder.IsCollapsed = !folder.IsCollapsed;
+        if (_folderCollapseCts.TryGetValue(folder.Id, out var previous)) previous.Cancel();
+        var cts = new CancellationTokenSource();
+        _folderCollapseCts[folder.Id] = cts;
+        _ = PersistFolderCollapsedAsync(folder.Id, folder.IsCollapsed, cts.Token);
+    }
+
+    private async Task PersistFolderCollapsedAsync(string folderId, bool isCollapsed, CancellationToken ct)
+    {
+        try
+        {
+            await using var ctx = await _dbFactory.CreateDbContextAsync();
+            ct.ThrowIfCancellationRequested();
+            await new ListRepository(ctx).SetFolderCollapsedAsync(folderId, isCollapsed);
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception ex)
+        {
+            // The fold itself already happened in the UI; only its persistence failed.
+            ErrorReported?.Invoke(ex.Message);
+        }
+    }
+
+    [RelayCommand]
+    private async Task OpenFolderSettingsAsync(ListFolderNavItemViewModel? folder)
+    {
+        if (folder is null || Dialogs is null || _services is null) return;
+        var vm = _services.GetRequiredService<ListSettingsModalViewModel>();
+        vm.ErrorReported += msg => ErrorReported?.Invoke(msg);
+        vm.BeginLoadFolder(folder.Id, folder.Name, folder.IconKey);
+        await Dialogs.ShowListSettingsAsync(vm);
+        // Rename, re-icon and delete all change the folder header (and delete releases its lists
+        // back to the top level) — one reload covers every outcome.
+        if (vm.Saved || vm.Deleted) await LoadAsync();
+    }
+
+    private void RecomputeFolderCounts()
+    {
+        foreach (var f in Folders) f.Count = f.Lists.Sum(l => l.Count);
+    }
+
+    private static string RawId(string rowId) =>
+        rowId.StartsWith("user:", StringComparison.Ordinal) ? rowId["user:".Length..] : rowId;
+
     private static void MoveWithinCollection(
-        ObservableCollection<ListNavItemViewModel> coll,
-        ListNavItemViewModel source,
-        ListNavItemViewModel target,
+        System.Collections.IList coll,
+        object source,
+        object target,
         bool placeBelow)
     {
         var srcIdx = coll.IndexOf(source);
@@ -464,7 +693,8 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
         if (finalIdx >= coll.Count) finalIdx = coll.Count - 1;
         if (finalIdx == srcIdx) return;
 
-        coll.Move(srcIdx, finalIdx);
+        coll.RemoveAt(srcIdx);
+        coll.Insert(finalIdx, source);
     }
 
     partial void OnSelectedListChanged(ListNavItemViewModel? value)
@@ -554,6 +784,7 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
             IsManual = entity.IsManual,
             FindingsTracked = entity.FindingsTracked,
             HasTicketProject = hasTicketProject,
+            FolderId = entity.FolderId,
         };
 
         var seedNames = new HashSet<string>(new[] { "My Day", "Important", "Planned" });
@@ -563,6 +794,22 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
 
         UserLists.Insert(insertAt, item);
         Items.Insert(SmartLists.Count + insertAt, item);
+
+        // Inside a folder, the same DB-order position; at the top level just appended — the mixed
+        // top level has no index that a per-folder DB order maps onto, and AddAsync numbers a new
+        // list past everything anyway.
+        if (Folders.FirstOrDefault(f => f.Id == item.FolderId) is { } folder)
+        {
+            var containerIdx = ordered
+                .Where(l => l.FolderId == item.FolderId)
+                .Select(l => l.Id)
+                .ToList()
+                .IndexOf(entity.Id);
+            folder.Lists.Insert(
+                containerIdx < 0 || containerIdx > folder.Lists.Count ? folder.Lists.Count : containerIdx,
+                item);
+        }
+        else TopLevel.Add(item);
         RecomputeHasNoLinkedRepo();
     }
 }

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

@@ -28,6 +28,10 @@ public sealed partial class MergeSectionViewModel : ViewModelBase
     [ObservableProperty] private ObservableCollection<string> _mergeTargetBranches = new();
     [ObservableProperty] private string? _selectedMergeTarget;
 
+    // Mirrors MergeTargetsDto.TargetDirty — surfaced next to Approve so a dirty target working
+    // dir is visible before anyone clicks, not just after the merge modal refuses it.
+    [ObservableProperty] private bool _targetDirty;
+
     // No CanExecute to gate here — RefreshMergePreviewAsync is triggered from the Bind path,
     // not a [RelayCommand], so PreviewOp only drives the indicator, never locks a button.
     public OperationStatus PreviewOp { get; } = new();
@@ -141,6 +145,7 @@ public sealed partial class MergeSectionViewModel : ViewModelBase
         MergePreviewText = "";
         MergeIsClean = false;
         MergeIsConflict = false;
+        TargetDirty = false;
         SyncWorktree(null, null, null, null, null);
         SyncTaskContext(null, null, false);
         SyncChildOutcomes(false, 0);

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

@@ -1,25 +1,57 @@
 using System.Collections.ObjectModel;
+using ClaudeDo.Ui.Localization;
+using ClaudeDo.Ui.Services;
 using ClaudeDo.Ui.Services.Interfaces;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 
 namespace ClaudeDo.Ui.ViewModels.Islands;
 
+/// <summary>Date separator between the note groups. Rows carry these inline (like the task list's
+/// HeaderRow) so one ItemsControl renders today and the history without a nested control per day.</summary>
+public sealed class NoteDayHeaderViewModel
+{
+    public DateOnly Day { get; }
+    public string Label { get; }
+    public bool IsToday { get; }
+
+    public NoteDayHeaderViewModel(DateOnly day, DateOnly today)
+    {
+        Day = day;
+        IsToday = day == today;
+        Label = day == today ? Loc.T("notes.today")
+              : day == today.AddDays(-1) ? Loc.T("notes.yesterday")
+              : day.ToString("dddd, dd.MM.");
+    }
+}
+
 public sealed partial class NoteBulletViewModel : ViewModelBase
 {
-    public string Id { get; }
+    /// <summary>Empty until the note is persisted — a row the user started but hasn't typed into
+    /// yet exists only in the list, so an abandoned Enter leaves nothing behind in the database.</summary>
+    public string Id { get; set; }
+
+    public DateOnly Day { get; }
+    public bool FromAgent { get; }
+    public bool IsNew => Id.Length == 0;
 
     [ObservableProperty] private string _text;
 
-    public NoteBulletViewModel(string id, string text)
+    public NoteBulletViewModel(string id, DateOnly day, string text, bool fromAgent = false)
     {
         Id = id;
+        Day = day;
         _text = text;
+        FromAgent = fromAgent;
     }
 }
 
 public sealed partial class NotesEditorViewModel : ViewModelBase
 {
+    /// <summary>How far the history scrolls back. Older notes stay in the database and in the week
+    /// report; they are simply not worth the round trip in a day log.</summary>
+    public const int HistoryDays = 14;
+
     private readonly INotesApi _api;
 
     public NotesEditorViewModel(INotesApi api) => _api = api;
@@ -27,32 +59,58 @@ public sealed partial class NotesEditorViewModel : ViewModelBase
     // Raised when a worker call fails so the host VM can surface it (e.g. via ShowErrorAsync).
     public event Action<string>? ErrorReported;
 
-    public ObservableCollection<NoteBulletViewModel> Bullets { get; } = new();
+    /// <summary>Raised after a row is inserted so the view can move the caret into it.</summary>
+    public event Action<NoteBulletViewModel>? FocusRequested;
+
+    /// <summary>NoteDayHeaderViewModel | NoteBulletViewModel, newest day first.</summary>
+    public ObservableCollection<object> Rows { get; } = new();
 
-    [ObservableProperty] private DateOnly _currentDay = DateOnly.FromDateTime(DateTime.Today);
     [ObservableProperty] private string _newBulletText = "";
+    [ObservableProperty] private bool _isEmpty = true;
 
-    public DateTime CurrentDate
+    public DateOnly Today { get; private set; } = DateOnly.FromDateTime(DateTime.Today);
+
+    /// <summary>Loads today plus <see cref="HistoryDays"/> days of history.</summary>
+    public async Task LoadAsync()
     {
-        get => CurrentDay.ToDateTime(TimeOnly.MinValue);
-        set { var d = DateOnly.FromDateTime(value); if (d != CurrentDay) _ = LoadDayAsync(d); }
+        Today = DateOnly.FromDateTime(DateTime.Today);
+        List<DailyNoteDto> notes;
+        try
+        {
+            notes = await _api.ListBetweenAsync(Today.AddDays(-HistoryDays), Today);
+        }
+        catch (Exception ex)
+        {
+            ErrorReported?.Invoke(ex.Message);
+            return;
+        }
+
+        Rows.Clear();
+        // Today always gets a header, even with nothing under it — it is where typing lands.
+        Rows.Add(new NoteDayHeaderViewModel(Today, Today));
+        foreach (var n in notes.Where(n => Day(n) == Today).OrderBy(n => n.SortOrder))
+            Rows.Add(Bullet(n));
+
+        foreach (var group in notes.Where(n => Day(n) != Today)
+                     .GroupBy(Day).OrderByDescending(g => g.Key))
+        {
+            Rows.Add(new NoteDayHeaderViewModel(group.Key, Today));
+            foreach (var n in group.OrderBy(n => n.SortOrder))
+                Rows.Add(Bullet(n));
+        }
+
+        RefreshEmpty();
     }
 
-    public string CurrentDayLabel => CurrentDay.ToString("dddd, dd.MM.yyyy");
+    private static DateOnly Day(DailyNoteDto n) => DateOnly.Parse(n.Date);
 
-    public async Task LoadDayAsync(DateOnly day)
-    {
-        CurrentDay = day;
-        OnPropertyChanged(nameof(CurrentDate));
-        OnPropertyChanged(nameof(CurrentDayLabel));
-        Bullets.Clear();
-        foreach (var dto in await _api.ListAsync(day))
-            Bullets.Add(MakeBullet(dto.Id, dto.Text));
-    }
+    private static NoteBulletViewModel Bullet(DailyNoteDto n) =>
+        new(n.Id, Day(n), n.Text, n.FromAgent);
 
-    private NoteBulletViewModel MakeBullet(string id, string text) =>
-        new(id, text);
+    private void RefreshEmpty() => IsEmpty = !Rows.OfType<NoteBulletViewModel>().Any();
 
+    /// <summary>The box above the list: Enter files the note under today and keeps the box focused,
+    /// so a burst of notes is one uninterrupted stream of typing.</summary>
     [RelayCommand]
     private async Task AddBullet()
     {
@@ -60,9 +118,10 @@ public sealed partial class NotesEditorViewModel : ViewModelBase
         if (text.Length == 0) return;
         try
         {
-            var dto = await _api.AddAsync(CurrentDay, text);
-            if (dto is not null) Bullets.Add(MakeBullet(dto.Id, dto.Text));
+            var dto = await _api.AddAsync(Today, text);
+            if (dto is not null) Rows.Insert(1, Bullet(dto));
             NewBulletText = "";
+            RefreshEmpty();
         }
         catch (Exception ex)
         {
@@ -70,21 +129,68 @@ public sealed partial class NotesEditorViewModel : ViewModelBase
         }
     }
 
-    [RelayCommand] private Task PrevDay() => LoadDayAsync(CurrentDay.AddDays(-1));
-    [RelayCommand] private Task NextDay() => LoadDayAsync(CurrentDay.AddDays(1));
-    [RelayCommand] private Task Today() => LoadDayAsync(DateOnly.FromDateTime(DateTime.Today));
+    /// <summary>Enter inside a note: save it, then open an empty row underneath and focus it.</summary>
+    [RelayCommand]
+    private async Task SplitBullet(NoteBulletViewModel? b)
+    {
+        if (b is null) return;
+        await CommitBullet(b);
+        if (!Rows.Contains(b)) return;   // committing an emptied note removed it
+
+        var fresh = new NoteBulletViewModel("", b.Day, "");
+        Rows.Insert(Rows.IndexOf(b) + 1, fresh);
+        FocusRequested?.Invoke(fresh);
+    }
+
+    /// <summary>Backspace in an already-empty note: drop it and put the caret in the one above.</summary>
+    [RelayCommand]
+    private async Task DeleteBullet(NoteBulletViewModel? b)
+    {
+        if (b is null) return;
+        var index = Rows.IndexOf(b);
+        await RemoveAsync(b);
+
+        for (var i = index - 1; i >= 0; i--)
+            if (Rows[i] is NoteBulletViewModel previous)
+            {
+                FocusRequested?.Invoke(previous);
+                return;
+            }
+    }
 
     [RelayCommand]
     private async Task CommitBullet(NoteBulletViewModel? b)
     {
         if (b is null) return;
         var text = b.Text?.Trim() ?? "";
-        if (text.Length == 0)
+        try
         {
-            await _api.DeleteAsync(b.Id);
-            Bullets.Remove(b);
-            return;
+            if (text.Length == 0)
+            {
+                await RemoveAsync(b);
+                return;
+            }
+
+            if (b.IsNew)
+            {
+                var dto = await _api.AddAsync(b.Day, text);
+                if (dto is not null) b.Id = dto.Id;
+            }
+            else
+            {
+                await _api.UpdateAsync(b.Id, text);
+            }
         }
-        await _api.UpdateAsync(b.Id, text);
+        catch (Exception ex)
+        {
+            ErrorReported?.Invoke(ex.Message);
+        }
+    }
+
+    private async Task RemoveAsync(NoteBulletViewModel b)
+    {
+        if (!b.IsNew) await _api.DeleteAsync(b.Id);
+        Rows.Remove(b);
+        RefreshEmpty();
     }
 }

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

@@ -8,67 +8,234 @@ namespace ClaudeDo.Ui.ViewModels.Islands;
 public sealed partial class TaskRowViewModel : ViewModelBase
 {
     public required string Id { get; init; }
-    [ObservableProperty] private int _number;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowNumberBadge))]
+    private int _number;
     [ObservableProperty] private string _title = "";
     [ObservableProperty] private string _listName = "";
-    [ObservableProperty] private bool _done;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsOverdue))]
+    [NotifyPropertyChangedFor(nameof(CanAddToMyDay))]
+    private bool _done;
     [ObservableProperty] private bool _isStarred;
-    [ObservableProperty] private bool _isMyDay;
-    [ObservableProperty] private bool _isSelected;
-    [ObservableProperty] private TaskStatus _status;
-    [ObservableProperty] private PlanningPhase _planningPhase;
-    [ObservableProperty] private string? _branch;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanAddToMyDay))]
+    private bool _isMyDay;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowRowActions))]
+    private bool _isSelected;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(StatusChipClass))]
+    [NotifyPropertyChangedFor(nameof(StatusLabel))]
+    [NotifyPropertyChangedFor(nameof(ShowStatusChip))]
+    [NotifyPropertyChangedFor(nameof(IsRunning))]
+    [NotifyPropertyChangedFor(nameof(IsWaitingForReview))]
+    [NotifyPropertyChangedFor(nameof(IsParked))]
+    [NotifyPropertyChangedFor(nameof(IsQueued))]
+    [NotifyPropertyChangedFor(nameof(IsWaiting))]
+    [NotifyPropertyChangedFor(nameof(HasFailureReason))]
+    [NotifyPropertyChangedFor(nameof(FailureReasonTooltip))]
+    [NotifyPropertyChangedFor(nameof(StatusChipTooltip))]
+    [NotifyPropertyChangedFor(nameof(IsDraft))]
+    [NotifyPropertyChangedFor(nameof(IsPlanned))]
+    [NotifyPropertyChangedFor(nameof(CanOpenPlanningSession))]
+    [NotifyPropertyChangedFor(nameof(CanRemoveFromQueue))]
+    [NotifyPropertyChangedFor(nameof(CanSendToQueue))]
+    [NotifyPropertyChangedFor(nameof(CanRefine))]
+    [NotifyPropertyChangedFor(nameof(SendToQueueDisabledReason))]
+    [NotifyPropertyChangedFor(nameof(CancelDisabledReason))]
+    [NotifyPropertyChangedFor(nameof(RefineDisabledReason))]
+    [NotifyPropertyChangedFor(nameof(PlanningDisabledReason))]
+    [NotifyPropertyChangedFor(nameof(MarkAsDisabledReason))]
+    private TaskStatus _status;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsPlanningParent))]
+    [NotifyPropertyChangedFor(nameof(PlanningBadge))]
+    [NotifyPropertyChangedFor(nameof(ShowStatusChip))]
+    [NotifyPropertyChangedFor(nameof(IsPlanActive))]
+    [NotifyPropertyChangedFor(nameof(IsPlanFinalized))]
+    [NotifyPropertyChangedFor(nameof(CanOpenPlanningSession))]
+    [NotifyPropertyChangedFor(nameof(CanResumeOrDiscardPlanning))]
+    [NotifyPropertyChangedFor(nameof(CanQueuePlan))]
+    [NotifyPropertyChangedFor(nameof(CanSendToQueue))]
+    [NotifyPropertyChangedFor(nameof(CanFinalizePlanning))]
+    [NotifyPropertyChangedFor(nameof(CanRefine))]
+    [NotifyPropertyChangedFor(nameof(SendToQueueDisabledReason))]
+    [NotifyPropertyChangedFor(nameof(RefineDisabledReason))]
+    [NotifyPropertyChangedFor(nameof(PlanningDisabledReason))]
+    private PlanningPhase _planningPhase;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasBranch))]
+    private string? _branch;
     [ObservableProperty] private string? _diffStat;
-    [ObservableProperty] private ClaudeDo.Data.Models.WorktreeState? _worktreeState;
-    [ObservableProperty] private string? _worktreePath;
-    [ObservableProperty] private DateTime? _scheduledFor;
-    [ObservableProperty] private int _diffAdditions;
-    [ObservableProperty] private int _diffDeletions;
-    [ObservableProperty] private bool _dropHintAbove;
-    [ObservableProperty] private bool _dropHintBelow;
-    [ObservableProperty] private string? _parentTaskId;
-    [ObservableProperty] private string? _createdBy;
-    [ObservableProperty] private string? _blockedByTaskId;
-    [ObservableProperty] private string? _dependsOnTaskId;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsParked))]
+    [NotifyPropertyChangedFor(nameof(StatusLabel))]
+    private ClaudeDo.Data.Models.WorktreeState? _worktreeState;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanOpenWorktree))]
+    [NotifyPropertyChangedFor(nameof(OpenWorktreeDisabledReason))]
+    private string? _worktreePath;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsOverdue))]
+    [NotifyPropertyChangedFor(nameof(HasSchedule))]
+    private DateTime? _scheduledFor;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasDiff))]
+    [NotifyPropertyChangedFor(nameof(DiffAdditionsText))]
+    private int _diffAdditions;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasDiff))]
+    [NotifyPropertyChangedFor(nameof(DiffDeletionsText))]
+    private int _diffDeletions;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsDropTarget))]
+    private bool _dropHintAbove;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsDropTarget))]
+    private bool _dropHintBelow;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsChild))]
+    [NotifyPropertyChangedFor(nameof(IsAgentSuggested))]
+    [NotifyPropertyChangedFor(nameof(ShowAsChild))]
+    [NotifyPropertyChangedFor(nameof(IsDraft))]
+    [NotifyPropertyChangedFor(nameof(IsPlanned))]
+    [NotifyPropertyChangedFor(nameof(CanSendToQueue))]
+    [NotifyPropertyChangedFor(nameof(CanOpenPlanningSession))]
+    [NotifyPropertyChangedFor(nameof(SendToQueueDisabledReason))]
+    [NotifyPropertyChangedFor(nameof(PlanningDisabledReason))]
+    private string? _parentTaskId;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsAgentSuggested))]
+    private string? _createdBy;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsQueued))]
+    [NotifyPropertyChangedFor(nameof(IsWaiting))]
+    [NotifyPropertyChangedFor(nameof(StatusChipClass))]
+    [NotifyPropertyChangedFor(nameof(StatusLabel))]
+    [NotifyPropertyChangedFor(nameof(StatusChipTooltip))]
+    [NotifyPropertyChangedFor(nameof(CanRemoveFromQueue))]
+    private string? _blockedByTaskId;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(DependsOnTaskId))]
+    private IReadOnlyList<string> _dependsOnTaskIds = [];
+    // Extrinsic — assigned by TasksIslandViewModel.ApplyDependencyWaitState, which alone has the
+    // cross-row graph (plus any cross-list predecessor lookup) needed to tell an unmet
+    // task_dependencies edge from a satisfied one. True only for the task_dependencies case;
+    // IsWaiting also ORs in the older BlockedByTaskId planning-chain link.
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsQueued))]
+    [NotifyPropertyChangedFor(nameof(IsWaiting))]
+    [NotifyPropertyChangedFor(nameof(StatusChipClass))]
+    [NotifyPropertyChangedFor(nameof(StatusLabel))]
+    [NotifyPropertyChangedFor(nameof(StatusChipTooltip))]
+    [NotifyPropertyChangedFor(nameof(CanRemoveFromQueue))]
+    private bool _isBlockedByDependency;
+    // The predecessor(s) this row is waiting on, rendered ("#42" or "#42, #57"), or null when not
+    // waiting. Prefers BlockedByTaskId's single predecessor (the planning chain "parent wins" the
+    // same way it does for the chain rail), else lists every unmet task_dependencies edge.
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(StatusChipTooltip))]
+    private string? _dependencyWaitLabel;
+
+    // The single predecessor, or null when the task has none or several. The chain rail can only
+    // draw a line, so a task waiting on n predecessors gets a ChainAfterLabel instead — see
+    // TasksIslandViewModel.ApplyChainGrouping.
+    public string? DependsOnTaskId => DependsOnTaskIds.Count == 1 ? DependsOnTaskIds[0] : null;
     [ObservableProperty] private bool _isExpanded = true;
-    [ObservableProperty] private bool _hasPlanningChildren;
-    [ObservableProperty] private bool _hasQueuedSubtasks;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsPlanningParent))]
+    [NotifyPropertyChangedFor(nameof(CanQueuePlan))]
+    private bool _hasPlanningChildren;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanRemoveFromQueue))]
+    [NotifyPropertyChangedFor(nameof(CanSendToQueue))]
+    [NotifyPropertyChangedFor(nameof(CanQueuePlan))]
+    [NotifyPropertyChangedFor(nameof(SendToQueueDisabledReason))]
+    private bool _hasQueuedSubtasks;
     [ObservableProperty] private bool _showListChip = true;
-    [ObservableProperty] private bool _parentFinalized;
-    [ObservableProperty] private bool _parentInView = true;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsDraft))]
+    [NotifyPropertyChangedFor(nameof(IsPlanned))]
+    [NotifyPropertyChangedFor(nameof(CanSendToQueue))]
+    [NotifyPropertyChangedFor(nameof(SendToQueueDisabledReason))]
+    private bool _parentFinalized;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowAsChild))]
+    [NotifyPropertyChangedFor(nameof(IsDraft))]
+    [NotifyPropertyChangedFor(nameof(IsPlanned))]
+    private bool _parentInView = true;
     // The three below are extrinsic — computed and assigned by TasksIslandViewModel.Regroup
     // (it alone has the cross-row graph needed to walk DependsOnTaskId chains), mirroring how
     // ParentInView is assigned by the same pass rather than derived locally.
     [ObservableProperty] private bool _showAsChainMember;
     [ObservableProperty] private int? _chainStep;
     [ObservableProperty] private string? _chainAfterLabel;
-    [ObservableProperty] private int _roadblockCount;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasRoadblock))]
+    [NotifyPropertyChangedFor(nameof(RoadblockTooltip))]
+    private int _roadblockCount;
     // Only meaningful when Status=Failed; stamped by TaskRunner.MarkFailed. "unknown" for a
     // Failed task that predates this field. Null on every other status.
-    [ObservableProperty] private string? _failureReason;
-    [ObservableProperty] private int? _failureTurnsUsed;
-    [ObservableProperty] private int? _failureMaxTurns;
-    [ObservableProperty] private bool _isRefining;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasFailureReason))]
+    [NotifyPropertyChangedFor(nameof(FailureReasonLabel))]
+    [NotifyPropertyChangedFor(nameof(FailureReasonTooltip))]
+    [NotifyPropertyChangedFor(nameof(StatusChipTooltip))]
+    private string? _failureReason;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(FailureReasonTooltip))]
+    private int? _failureTurnsUsed;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(FailureReasonTooltip))]
+    private int? _failureMaxTurns;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanRefine))]
+    [NotifyPropertyChangedFor(nameof(RefineDisabledReason))]
+    private bool _isRefining;
     // Manual = a reminder only the user can do. Every "hand this to Claude" affordance is hidden
     // and automation skips it; opening a hand-driven ConPTY session stays allowed.
-    [ObservableProperty] private bool _isManual;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ManualBadge))]
+    [NotifyPropertyChangedFor(nameof(CanRefine))]
+    [NotifyPropertyChangedFor(nameof(CanSendToQueue))]
+    [NotifyPropertyChangedFor(nameof(CanOpenPlanningSession))]
+    [NotifyPropertyChangedFor(nameof(SendToQueueDisabledReason))]
+    [NotifyPropertyChangedFor(nameof(RefineDisabledReason))]
+    [NotifyPropertyChangedFor(nameof(PlanningDisabledReason))]
+    private bool _isManual;
     // Set by the shell from Mission Control's open ConPTY panes: this task has a live hand-driven
     // session, which outranks the persisted status on the lifecycle chip (an interactive task is
     // typically Idle+Active-worktree, i.e. would otherwise read "Parked").
-    [ObservableProperty] private bool _hasInteractiveSession;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsParked))]
+    [NotifyPropertyChangedFor(nameof(StatusChipClass))]
+    [NotifyPropertyChangedFor(nameof(StatusLabel))]
+    [NotifyPropertyChangedFor(nameof(ShowStatusChip))]
+    [NotifyPropertyChangedFor(nameof(StatusChipTooltip))]
+    [NotifyPropertyChangedFor(nameof(CanSendToQueue))]
+    [NotifyPropertyChangedFor(nameof(SendToQueueDisabledReason))]
+    [NotifyPropertyChangedFor(nameof(CanDeleteTask))]
+    [NotifyPropertyChangedFor(nameof(DeleteDisabledReason))]
+    private bool _hasInteractiveSession;
     // Set by the custom drag while this row is being dragged — drives the "grabbed" row style.
     [ObservableProperty] private bool _isDragging;
 
     // Set from PointerEntered/PointerExited in TaskRowView.axaml.cs. Drives ShowRowActions
     // together with IsSelected, so hover-only affordances (refine button, unset star, dequeue-X)
     // stay reachable via keyboard/selection, not just mouse hover.
-    [ObservableProperty] private bool _isHovered;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowRowActions))]
+    private bool _isHovered;
 
     // Transient: set from HubBroadcaster's OperationProgress while the worker is still creating
     // this task's worktree (the silent gap between Queued and the first agent output). Cleared
     // by the next entity refresh — UpdateFromEntity always reflects a settled state, so there's
     // nothing left to show past that point.
-    [ObservableProperty] private string? _creationPhase;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasCreationPhase))]
+    [NotifyPropertyChangedFor(nameof(CreationPhaseLabel))]
+    private string? _creationPhase;
 
     // True while a drag is hovering this row (i.e. it would show a drop-hint gap). Used to
     // suppress the ordinary hover highlight/transitions so they don't fight the hint.
@@ -128,9 +295,9 @@ public sealed partial class TaskRowViewModel : ViewModelBase
     // task). A live ConPTY session is that same shape but not parked — it reads "Interactive".
     public bool IsParked    => Status == TaskStatus.Idle && WorktreeState == ClaudeDo.Data.Models.WorktreeState.Active
                                && !HasInteractiveSession;
-    public bool IsQueued    => Status == TaskStatus.Queued && string.IsNullOrEmpty(BlockedByTaskId);
-    public bool IsWaiting   => Status == TaskStatus.Queued && !string.IsNullOrEmpty(BlockedByTaskId);
-    public bool CanRemoveFromQueue => IsQueued || HasQueuedSubtasks;
+    public bool IsQueued    => Status == TaskStatus.Queued && string.IsNullOrEmpty(BlockedByTaskId) && !IsBlockedByDependency;
+    public bool IsWaiting   => Status == TaskStatus.Queued && (!string.IsNullOrEmpty(BlockedByTaskId) || IsBlockedByDependency);
+    public bool CanRemoveFromQueue => IsQueued || IsWaiting || HasQueuedSubtasks;
     // "Send to queue" is the single queue entry. On a finalized planning parent it queues the
     // plan (children) via CanQueuePlan; an Active (not-yet-finalized) planning parent is hidden —
     // it must be finalized first. The worker never sees a UI-hosted ConPTY session (it never
@@ -265,9 +432,12 @@ public sealed partial class TaskRowViewModel : ViewModelBase
             : FailureReasonLabel;
 
     // Drives the status chip tooltip: an open interactive session takes priority (it's tappable),
-    // otherwise a Failed task's reason, otherwise no tooltip.
+    // then the predecessor(s) a waiting task is blocked on, then a Failed task's reason,
+    // otherwise no tooltip.
     public string? StatusChipTooltip
-        => HasInteractiveSession ? Loc.T("tasks.interactiveChipTip") : FailureReasonTooltip;
+        => HasInteractiveSession ? Loc.T("tasks.interactiveChipTip")
+         : IsWaiting && DependencyWaitLabel is not null ? Loc.T("tasks.waitingOnTip", DependencyWaitLabel)
+         : FailureReasonTooltip;
 
     public string DiffAdditionsText => $"+{DiffAdditions}";
     public string DiffDeletionsText => $"−{DiffDeletions}";
@@ -275,7 +445,8 @@ public sealed partial class TaskRowViewModel : ViewModelBase
 
     public string StatusLabel
         => HasInteractiveSession ? Loc.T("vm.taskStatus.interactive")
-         : IsParked ? Loc.T("vm.taskStatus.parked") : Status switch
+         : IsParked ? Loc.T("vm.taskStatus.parked")
+         : IsWaiting ? Loc.T("vm.taskStatus.waiting") : Status switch
     {
         TaskStatus.Idle             => Loc.T("vm.taskStatus.idle"),
         TaskStatus.Queued           => Loc.T("vm.taskStatus.queued"),
@@ -297,7 +468,7 @@ public sealed partial class TaskRowViewModel : ViewModelBase
 
     public string StatusChipClass => HasInteractiveSession
         ? "interactive"
-        : (Status, IsBlocked: !string.IsNullOrEmpty(BlockedByTaskId)) switch
+        : (Status, IsBlocked: !string.IsNullOrEmpty(BlockedByTaskId) || IsBlockedByDependency) switch
     {
         (TaskStatus.Running,            _) => "running",
         (TaskStatus.WaitingForReview,   _) => "review",
@@ -309,179 +480,6 @@ public sealed partial class TaskRowViewModel : ViewModelBase
         _                                => "idle",
     };
 
-    partial void OnStatusChanged(TaskStatus value)
-    {
-        OnPropertyChanged(nameof(StatusChipClass));
-        OnPropertyChanged(nameof(StatusLabel));
-        OnPropertyChanged(nameof(ShowStatusChip));
-        OnPropertyChanged(nameof(IsRunning));
-        OnPropertyChanged(nameof(IsWaitingForReview));
-        OnPropertyChanged(nameof(IsParked));
-        OnPropertyChanged(nameof(IsQueued));
-        OnPropertyChanged(nameof(IsWaiting));
-        OnPropertyChanged(nameof(HasFailureReason));
-        OnPropertyChanged(nameof(FailureReasonTooltip));
-        OnPropertyChanged(nameof(StatusChipTooltip));
-        OnPropertyChanged(nameof(IsDraft));
-        OnPropertyChanged(nameof(IsPlanned));
-        OnPropertyChanged(nameof(CanOpenPlanningSession));
-        OnPropertyChanged(nameof(CanRemoveFromQueue));
-        OnPropertyChanged(nameof(CanSendToQueue));
-        OnPropertyChanged(nameof(CanRefine));
-        OnPropertyChanged(nameof(SendToQueueDisabledReason));
-        OnPropertyChanged(nameof(CancelDisabledReason));
-        OnPropertyChanged(nameof(RefineDisabledReason));
-        OnPropertyChanged(nameof(PlanningDisabledReason));
-        OnPropertyChanged(nameof(MarkAsDisabledReason));
-    }
-
-    partial void OnParentTaskIdChanged(string? value)
-    {
-        OnPropertyChanged(nameof(IsChild));
-        OnPropertyChanged(nameof(IsAgentSuggested));
-        OnPropertyChanged(nameof(ShowAsChild));
-        OnPropertyChanged(nameof(IsDraft));
-        OnPropertyChanged(nameof(IsPlanned));
-        OnPropertyChanged(nameof(CanSendToQueue));
-        OnPropertyChanged(nameof(CanOpenPlanningSession));
-        OnPropertyChanged(nameof(SendToQueueDisabledReason));
-        OnPropertyChanged(nameof(PlanningDisabledReason));
-    }
-
-    partial void OnParentInViewChanged(bool value)
-    {
-        OnPropertyChanged(nameof(ShowAsChild));
-        OnPropertyChanged(nameof(IsDraft));
-        OnPropertyChanged(nameof(IsPlanned));
-    }
-
-    partial void OnCreatedByChanged(string? value) => OnPropertyChanged(nameof(IsAgentSuggested));
-
-    partial void OnParentFinalizedChanged(bool value)
-    {
-        OnPropertyChanged(nameof(IsDraft));
-        OnPropertyChanged(nameof(IsPlanned));
-        OnPropertyChanged(nameof(CanSendToQueue));
-        OnPropertyChanged(nameof(SendToQueueDisabledReason));
-    }
-
-    partial void OnPlanningPhaseChanged(PlanningPhase value)
-    {
-        OnPropertyChanged(nameof(IsPlanningParent));
-        OnPropertyChanged(nameof(PlanningBadge));
-        OnPropertyChanged(nameof(ShowStatusChip));
-        OnPropertyChanged(nameof(IsPlanActive));
-        OnPropertyChanged(nameof(IsPlanFinalized));
-        OnPropertyChanged(nameof(CanOpenPlanningSession));
-        OnPropertyChanged(nameof(CanResumeOrDiscardPlanning));
-        OnPropertyChanged(nameof(CanQueuePlan));
-        OnPropertyChanged(nameof(CanSendToQueue));
-        OnPropertyChanged(nameof(CanFinalizePlanning));
-        OnPropertyChanged(nameof(CanRefine));
-        OnPropertyChanged(nameof(SendToQueueDisabledReason));
-        OnPropertyChanged(nameof(RefineDisabledReason));
-        OnPropertyChanged(nameof(PlanningDisabledReason));
-    }
-
-    partial void OnIsRefiningChanged(bool value)
-    {
-        OnPropertyChanged(nameof(CanRefine));
-        OnPropertyChanged(nameof(RefineDisabledReason));
-    }
-
-    partial void OnIsManualChanged(bool value)
-    {
-        OnPropertyChanged(nameof(ManualBadge));
-        OnPropertyChanged(nameof(CanRefine));
-        OnPropertyChanged(nameof(CanSendToQueue));
-        OnPropertyChanged(nameof(CanOpenPlanningSession));
-        OnPropertyChanged(nameof(SendToQueueDisabledReason));
-        OnPropertyChanged(nameof(RefineDisabledReason));
-        OnPropertyChanged(nameof(PlanningDisabledReason));
-    }
-
-    partial void OnHasInteractiveSessionChanged(bool value)
-    {
-        OnPropertyChanged(nameof(IsParked));
-        OnPropertyChanged(nameof(StatusChipClass));
-        OnPropertyChanged(nameof(StatusLabel));
-        OnPropertyChanged(nameof(ShowStatusChip));
-        OnPropertyChanged(nameof(StatusChipTooltip));
-        OnPropertyChanged(nameof(CanSendToQueue));
-        OnPropertyChanged(nameof(SendToQueueDisabledReason));
-        OnPropertyChanged(nameof(CanDeleteTask));
-        OnPropertyChanged(nameof(DeleteDisabledReason));
-    }
-
-    partial void OnFailureReasonChanged(string? value)
-    {
-        OnPropertyChanged(nameof(HasFailureReason));
-        OnPropertyChanged(nameof(FailureReasonLabel));
-        OnPropertyChanged(nameof(FailureReasonTooltip));
-        OnPropertyChanged(nameof(StatusChipTooltip));
-    }
-
-    partial void OnFailureTurnsUsedChanged(int? value) => OnPropertyChanged(nameof(FailureReasonTooltip));
-    partial void OnFailureMaxTurnsChanged(int? value) => OnPropertyChanged(nameof(FailureReasonTooltip));
-
-    partial void OnHasQueuedSubtasksChanged(bool value)
-    {
-        OnPropertyChanged(nameof(CanRemoveFromQueue));
-        OnPropertyChanged(nameof(CanSendToQueue));
-        OnPropertyChanged(nameof(CanQueuePlan));
-        OnPropertyChanged(nameof(SendToQueueDisabledReason));
-    }
-
-    partial void OnIsHoveredChanged(bool value) => OnPropertyChanged(nameof(ShowRowActions));
-    partial void OnIsSelectedChanged(bool value) => OnPropertyChanged(nameof(ShowRowActions));
-
-    partial void OnBlockedByTaskIdChanged(string? value)
-    {
-        OnPropertyChanged(nameof(IsQueued));
-        OnPropertyChanged(nameof(IsWaiting));
-        OnPropertyChanged(nameof(StatusChipClass));
-    }
-
-    partial void OnHasPlanningChildrenChanged(bool value)
-    {
-        OnPropertyChanged(nameof(IsPlanningParent));
-        OnPropertyChanged(nameof(CanQueuePlan));
-    }
-
-    partial void OnNumberChanged(int value)        => OnPropertyChanged(nameof(ShowNumberBadge));
-    partial void OnBranchChanged(string? value)    => OnPropertyChanged(nameof(HasBranch));
-    partial void OnWorktreePathChanged(string? value)
-    {
-        OnPropertyChanged(nameof(CanOpenWorktree));
-        OnPropertyChanged(nameof(OpenWorktreeDisabledReason));
-    }
-    partial void OnWorktreeStateChanged(ClaudeDo.Data.Models.WorktreeState? value)
-    {
-        OnPropertyChanged(nameof(IsParked));
-        OnPropertyChanged(nameof(StatusLabel));
-    }
-    partial void OnDoneChanged(bool value)
-    {
-        OnPropertyChanged(nameof(IsOverdue));
-        OnPropertyChanged(nameof(CanAddToMyDay));
-    }
-    partial void OnIsMyDayChanged(bool value)      => OnPropertyChanged(nameof(CanAddToMyDay));
-    partial void OnScheduledForChanged(DateTime? value)
-    {
-        OnPropertyChanged(nameof(IsOverdue));
-        OnPropertyChanged(nameof(HasSchedule));
-    }
-    partial void OnDiffAdditionsChanged(int value) { OnPropertyChanged(nameof(HasDiff)); OnPropertyChanged(nameof(DiffAdditionsText)); }
-    partial void OnDiffDeletionsChanged(int value) { OnPropertyChanged(nameof(HasDiff)); OnPropertyChanged(nameof(DiffDeletionsText)); }
-    partial void OnRoadblockCountChanged(int value) { OnPropertyChanged(nameof(HasRoadblock)); OnPropertyChanged(nameof(RoadblockTooltip)); }
-    partial void OnDropHintAboveChanged(bool value) => OnPropertyChanged(nameof(IsDropTarget));
-    partial void OnDropHintBelowChanged(bool value) => OnPropertyChanged(nameof(IsDropTarget));
-    partial void OnCreationPhaseChanged(string? value)
-    {
-        OnPropertyChanged(nameof(HasCreationPhase));
-        OnPropertyChanged(nameof(CreationPhaseLabel));
-    }
-
     public void RefreshLocalized()
     {
         OnPropertyChanged(nameof(StatusLabel));
@@ -502,7 +500,7 @@ public sealed partial class TaskRowViewModel : ViewModelBase
         // Any entity-backed refresh reflects a settled state, so the transient creation-phase
         // banner (set from the OperationProgress broadcast) has nothing left to announce.
         CreationPhase     = null;
-        var (add, del) = ParseDiffStat(t.Worktree?.DiffStat);
+        var (add, del) = DetailsIslandViewModel.ParseDiffStat(t.Worktree?.DiffStat);
         Number            = t.Number;
         Title             = t.Title;
         ListName          = t.List?.Name ?? "";
@@ -522,24 +520,13 @@ public sealed partial class TaskRowViewModel : ViewModelBase
         ParentTaskId      = t.ParentTaskId;
         CreatedBy         = t.CreatedBy;
         BlockedByTaskId   = t.BlockedByTaskId;
-        DependsOnTaskId   = t.DependsOnTaskId;
+        // Guarded: TaskEntity.DependsOnTaskIds projects a fresh List every read, so a plain
+        // assignment would fire PropertyChanged on every reconcile tick even when nothing moved.
+        var deps = t.DependsOnTaskIds;
+        if (!DependsOnTaskIds.SequenceEqual(deps)) DependsOnTaskIds = deps;
         RoadblockCount    = t.RoadblockCount;
         FailureReason     = t.FailureReason;
         FailureTurnsUsed  = t.FailureTurnsUsed;
         FailureMaxTurns   = t.FailureMaxTurns;
     }
-
-    // Best-effort parse of diff stat strings like "+12 -3" or "12 additions, 3 deletions".
-    private static (int add, int del) ParseDiffStat(string? s)
-    {
-        if (string.IsNullOrWhiteSpace(s)) return (0, 0);
-        int add = 0, del = 0;
-        var parts = s.Split(new[] { ' ', ',', '\t' }, StringSplitOptions.RemoveEmptyEntries);
-        foreach (var p in parts)
-        {
-            if (p.Length > 1 && p[0] == '+' && int.TryParse(p.AsSpan(1), out var a)) add = a;
-            else if (p.Length > 1 && (p[0] == '-' || p[0] == '\u2212') && int.TryParse(p.AsSpan(1), out var d)) del = d;
-        }
-        return (add, del);
-    }
 }

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

@@ -9,6 +9,7 @@ using ClaudeDo.Data.Models;
 using ClaudeDo.Data.Repositories;
 using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
+using ClaudeDo.Ui.Services.Interfaces;
 using ClaudeDo.Ui.ViewModels.Modals;
 using Microsoft.EntityFrameworkCore;
 using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
@@ -42,6 +43,12 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
     // Two events (TaskUpdated + WorktreeUpdated) drive the same delta refresh, so two reads for
     // one task can be in flight at once. Only the newest may write to the row.
     private readonly Dictionary<string, long> _deltaSeq = new();
+    // Number/Title/Status for a predecessor id that isn't loaded into Items (a different list, My
+    // Day, or the completed group) -- populated by RefreshExternalDependencyCacheAsync so
+    // ApplyChainGrouping/ApplyDependencyWaitState can still render "after #N" and the blocked
+    // chip for a cross-list predecessor instead of silently dropping it. Refreshed, never evicted:
+    // stale entries just get overwritten on the next load/delta that references the same id.
+    private readonly Dictionary<string, (int Number, string Title, TaskStatus Status)> _externalDependencyInfo = new();
     private long _deltaCounter;
     // Phase 3 reconcile tick — see the block at the end of this class.
     private readonly System.Timers.Timer _reconcileTimer = new(4_000);
@@ -62,18 +69,10 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
 
     public event EventHandler? FocusAddTaskRequested;
     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]
-    private void OpenNotes()
-    {
-        SelectFrom(null, "notes");
-        NotesRequested?.Invoke();
-    }
-
     [RelayCommand]
     private void ShowPrepLog() => PrepRequested?.Invoke();
 
@@ -118,8 +117,17 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
     private bool _hasCompleted;
     [ObservableProperty] private bool _showOpenLabel;
     [ObservableProperty] private string _completedHeader = "";
-    [ObservableProperty] private bool _showNotesRow;
     [ObservableProperty] private bool _isMyDayList;
+
+    /// <summary>The notes list is content, not a task list — the island swaps its rows for the
+    /// notes editor instead of showing an empty task list.</summary>
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsTasksEmptyHintVisible))]
+    [NotifyPropertyChangedFor(nameof(IsTasksEmptyRepoHintVisible))]
+    private bool _isNotesList;
+
+    /// <summary>Null only in tests that construct the island without a notes API.</summary>
+    public NotesEditorViewModel? Notes { get; }
     [ObservableProperty]
     [NotifyPropertyChangedFor(nameof(IsTasksEmptyRepoHintVisible))]
     private bool _isLetClaudeVisible;
@@ -128,7 +136,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
 
     /// <summary>No visible tasks below the add-task row — every item lands in one of
     /// Overdue/Open/Completed, so all-false here always means the list has zero items.</summary>
-    public bool IsTasksEmptyHintVisible => !HasOverdue && !HasOpen && !HasCompleted;
+    public bool IsTasksEmptyHintVisible => !HasOverdue && !HasOpen && !HasCompleted && !IsNotesList;
 
     /// <summary>Extra empty-state line for a User list with no linked working dir, where the
     /// execution features (queue, Let Claude handle it, Quick session) are unavailable. Derived
@@ -182,10 +190,20 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
 
     private readonly EventHandler _langChangedHandler;
 
-    public TasksIslandViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, IWorkerClient? worker = null)
+    public TasksIslandViewModel(
+        IDbContextFactory<ClaudeDoDbContext> dbFactory,
+        IWorkerClient? worker = null,
+        INotesApi? notesApi = null)
     {
         _dbFactory = dbFactory;
         _worker = worker;
+        if (notesApi is not null)
+        {
+            Notes = new NotesEditorViewModel(notesApi);
+            Notes.ErrorReported += msg => ErrorReported?.Invoke(msg);
+            if (worker is not null)
+                worker.NotesUpdatedEvent += () => { if (IsNotesList) _ = Notes.LoadAsync(); };
+        }
         _completedHeaderRow = new() { ActionCommand = ClearCompletedCommand };
         CompletedHeader = Loc.T("vm.tasksIsland.completedHeader");
         if (_worker is not null)
@@ -301,6 +319,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         var entity = await db.Tasks
             .Include(t => t.List)
             .Include(t => t.Worktree)
+            .Include(t => t.Dependencies)
             .FirstOrDefaultAsync(t => t.Id == taskId);
 
         // A newer refresh for this task started while we were reading — its result is fresher.
@@ -350,6 +369,12 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
                     r.ParentTaskId == parent.Id && (r.IsQueued || r.IsWaiting));
         }
 
+        // entity is not null here whenever `existing` is still reachable (see the branching
+        // above: an early return covers every entity-null-but-existing case except delete, which
+        // needs no lookup refresh).
+        if (entity is not null && existing is not null)
+            await RefreshExternalDependencyCacheAsync(db, DependencyLookupIds([existing]));
+
         Regroup();
         UpdateSubtitle();
     }
@@ -417,14 +442,14 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         HasOpen       = false;
         HasCompleted  = false;
         ShowOpenLabel = false;
-        ShowNotesRow  = false;
         if (listChanged) SelectFrom(null, "list-change");
         if (list is null) { IsLetClaudeVisible = false; IsQuickClaudeVisible = false; IsMergeReviewsVisible = false; 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";
+        IsNotesList  = list.Id == ListsIslandViewModel.NotesListId;
+        if (IsNotesList && Notes is not null) _ = Notes.LoadAsync();
         IsLetClaudeVisible = list.Kind == ListKind.User && !string.IsNullOrWhiteSpace(list.WorkingDir);
         IsQuickClaudeVisible = IsLetClaudeVisible;
         IsMergeReviewsVisible = list.Id == "virtual:review";
@@ -441,7 +466,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         {
             await using var db = await _dbFactory.CreateDbContextAsync(ct);
             var filter = _filters.Resolve(list.Id);
-            var baseQuery = db.Tasks.Include(t => t.List).Include(t => t.Worktree);
+            var baseQuery = db.Tasks.Include(t => t.List).Include(t => t.Worktree).Include(t => t.Dependencies);
 
             var filteredList = filter is null
                 ? new List<TaskEntity>()
@@ -535,6 +560,8 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
                 r.ParentFinalized = !string.IsNullOrEmpty(r.ParentTaskId)
                                     && finalizedParents.Contains(r.ParentTaskId!);
 
+            await RefreshExternalDependencyCacheAsync(db, DependencyLookupIds(Items), ct);
+
             Regroup();
             UpdateSubtitle();
             ok = true;
@@ -543,6 +570,32 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         finally { OperationTiming.Shared.Record("db", "TasksIsland.LoadForListAsync", sw.Elapsed, ok); }
     }
 
+    // Every predecessor id a row in `items` could need labelled/checked: its task_dependencies
+    // edges plus the planning chain's BlockedByTaskId (both resolved the same way in
+    // ApplyDependencyWaitState/BuildAfterLabel).
+    private static IEnumerable<string> DependencyLookupIds(IEnumerable<TaskRowViewModel> items) =>
+        items.SelectMany(r => string.IsNullOrEmpty(r.BlockedByTaskId)
+            ? r.DependsOnTaskIds
+            : r.DependsOnTaskIds.Append(r.BlockedByTaskId));
+
+    // Resolves predecessor ids that aren't loaded into Items (a different list, My Day, or the
+    // completed group) so cross-list dependency display doesn't silently drop them. Cheap: reuses
+    // the caller's already-open context, one query for however many ids are actually missing.
+    private async Task RefreshExternalDependencyCacheAsync(
+        ClaudeDoDbContext db, IEnumerable<string> ids, CancellationToken ct = default)
+    {
+        var known = Items.Select(r => r.Id).ToHashSet();
+        var missing = ids.Where(id => !string.IsNullOrEmpty(id) && !known.Contains(id)).Distinct().ToList();
+        if (missing.Count == 0) return;
+
+        var rows = await db.Tasks
+            .Where(t => missing.Contains(t.Id))
+            .Select(t => new { t.Id, t.Number, t.Title, t.Status })
+            .ToListAsync(ct);
+        foreach (var r in rows)
+            _externalDependencyInfo[r.Id] = (r.Number, r.Title, r.Status);
+    }
+
     internal void Regroup()
     {
         // Collapse parents that have children by default, so subtasks stay tucked away until
@@ -678,13 +731,70 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         // with a label rather than an orphaned rail. Whether the head is resolvable at all
         // still uses the whole-Items graph (rowsById), independent of section.
         var rowsById = Items.ToDictionary(r => r.Id);
-        overdue   = ApplyChainGrouping(overdue, rowsById);
-        open      = ApplyChainGrouping(open, rowsById);
-        completed = ApplyChainGrouping(completed, rowsById);
+
+        // Blocked-by-dependency is independent of section (a blocked row can be Overdue or Open
+        // alike) and independent of chain membership, so it's computed once over all of Items
+        // rather than per section.
+        foreach (var r in Items)
+            ApplyDependencyWaitState(r, rowsById, _externalDependencyInfo);
+
+        overdue   = ApplyChainGrouping(overdue, rowsById, _externalDependencyInfo);
+        open      = ApplyChainGrouping(open, rowsById, _externalDependencyInfo);
+        completed = ApplyChainGrouping(completed, rowsById, _externalDependencyInfo);
 
         return (overdue, open, completed);
     }
 
+    // Assigns IsBlockedByDependency/DependencyWaitLabel for one row. BlockedByTaskId (the planning
+    // chain's single link) wins the label the same way a planning child's parent indent wins over
+    // chain-rail membership -- "parent wins" is the existing precedent (ApplyChainGrouping below).
+    private static void ApplyDependencyWaitState(
+        TaskRowViewModel row, Dictionary<string, TaskRowViewModel> rowsById,
+        IReadOnlyDictionary<string, (int Number, string Title, TaskStatus Status)> external)
+    {
+        if (row.Status != TaskStatus.Queued)
+        {
+            row.IsBlockedByDependency = false;
+            row.DependencyWaitLabel = null;
+            return;
+        }
+
+        var unmet = row.DependsOnTaskIds.Where(id => IsUnmet(id, rowsById, external)).ToList();
+        row.IsBlockedByDependency = unmet.Count > 0;
+
+        var waitIds = !string.IsNullOrEmpty(row.BlockedByTaskId) ? [row.BlockedByTaskId] : unmet;
+        row.DependencyWaitLabel = waitIds.Count == 0 ? null
+            : string.Join(", ", waitIds.Select(id => ResolveLabel(id, rowsById, external)).Where(s => s is not null));
+    }
+
+    // A predecessor missing from both rowsById and the external cache counts as unmet -- mirrors
+    // QueuePicker/Worker's TaskBlocking.Unmet: an edge pointing at an unresolved/vanished task
+    // keeps blocking rather than being silently treated as satisfied. A landed merge satisfies
+    // the edge too (skipVerify parks a merged task in WaitingForReview until the batch verify);
+    // the external cache carries no worktree state, so a cross-list predecessor still shows as
+    // waiting until it reaches Done.
+    private static bool IsUnmet(
+        string id, Dictionary<string, TaskRowViewModel> rowsById,
+        IReadOnlyDictionary<string, (int Number, string Title, TaskStatus Status)> external)
+    {
+        if (rowsById.TryGetValue(id, out var p))
+            return p.Status != TaskStatus.Done && p.WorktreeState != WorktreeState.Merged;
+        if (external.TryGetValue(id, out var e)) return e.Status != TaskStatus.Done;
+        return true;
+    }
+
+    // Resolves a predecessor id to its display label, checking the in-view rows first and falling
+    // back to the cross-list cache (RefreshExternalDependencyCacheAsync) -- null only when the
+    // predecessor is genuinely unresolvable anywhere (e.g. a deleted task).
+    private static string? ResolveLabel(
+        string id, Dictionary<string, TaskRowViewModel> rowsById,
+        IReadOnlyDictionary<string, (int Number, string Title, TaskStatus Status)> external)
+    {
+        if (rowsById.TryGetValue(id, out var p)) return p.Number > 0 ? $"#{p.Number}" : p.Title;
+        if (external.TryGetValue(id, out var e)) return e.Number > 0 ? $"#{e.Number}" : e.Title;
+        return null;
+    }
+
     // Cycles are rejected by TaskStateService.SetDependsOnAsync, so this should always
     // terminate quickly — capped anyway against a corrupt/legacy row forming a loop.
     private const int MaxChainWalkDepth = 64;
@@ -710,12 +820,18 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
     }
 
     // Content only — "after " + localization is Slice 2's concern (the view), which is why this
-    // holds just the identifying fragment rather than an assembled sentence.
-    private static string? BuildAfterLabel(TaskRowViewModel row, Dictionary<string, TaskRowViewModel> rowsById)
+    // holds just the identifying fragment rather than an assembled sentence. Names every
+    // predecessor it can resolve (in-view first, then the cross-list external cache): a task can
+    // wait on n of them, and hiding all but the first would misreport what the row is waiting for.
+    private static string? BuildAfterLabel(
+        TaskRowViewModel row, Dictionary<string, TaskRowViewModel> rowsById,
+        IReadOnlyDictionary<string, (int Number, string Title, TaskStatus Status)> external)
     {
-        if (string.IsNullOrEmpty(row.DependsOnTaskId)) return null;
-        if (!rowsById.TryGetValue(row.DependsOnTaskId, out var predecessor)) return null;
-        return predecessor.Number > 0 ? $"#{predecessor.Number}" : predecessor.Title;
+        var parts = row.DependsOnTaskIds
+            .Select(id => ResolveLabel(id, rowsById, external))
+            .Where(p => p is not null)
+            .ToList();
+        return parts.Count == 0 ? null : string.Join(", ", parts);
     }
 
     // Assigns ShowAsChainMember/ChainStep/ChainAfterLabel for every row in `section`, then
@@ -723,7 +839,8 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
     // (ascending ChainStep), regardless of their SortOrder-derived position — mirroring how
     // planning children already sit right after their parent regardless of Items order.
     private static List<TaskRowViewModel> ApplyChainGrouping(
-        List<TaskRowViewModel> section, Dictionary<string, TaskRowViewModel> rowsById)
+        List<TaskRowViewModel> section, Dictionary<string, TaskRowViewModel> rowsById,
+        IReadOnlyDictionary<string, (int Number, string Title, TaskStatus Status)> external)
     {
         var sectionIds = section.Select(r => r.Id).ToHashSet();
         var headIdOf = new Dictionary<TaskRowViewModel, string>();
@@ -731,7 +848,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
 
         foreach (var r in section)
         {
-            if (string.IsNullOrEmpty(r.DependsOnTaskId))
+            if (r.DependsOnTaskIds.Count == 0)
             {
                 r.ShowAsChainMember = false;
                 r.ChainStep = null;
@@ -739,13 +856,23 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
                 continue;
             }
 
+            // Several predecessors aren't a chain — the rail draws one line, so a fan-in row
+            // only ever gets the label listing everything it waits on.
+            if (r.DependsOnTaskId is null)
+            {
+                r.ShowAsChainMember = false;
+                r.ChainStep = null;
+                r.ChainAfterLabel = BuildAfterLabel(r, rowsById, external);
+                continue;
+            }
+
             // A planning child keeps its parent indent — chain membership only ever shows as a
             // label for it, never as a second, nested rail (design: "parent wins").
             if (r.IsChild)
             {
                 r.ShowAsChainMember = false;
                 r.ChainStep = null;
-                r.ChainAfterLabel = BuildAfterLabel(r, rowsById);
+                r.ChainAfterLabel = BuildAfterLabel(r, rowsById, external);
                 continue;
             }
 
@@ -762,7 +889,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
             {
                 r.ShowAsChainMember = false;
                 r.ChainStep = null;
-                r.ChainAfterLabel = BuildAfterLabel(r, rowsById);
+                r.ChainAfterLabel = BuildAfterLabel(r, rowsById, external);
             }
         }
 
@@ -794,13 +921,16 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         var now     = DateTime.Now;
         var open    = Items.Count(i => !i.Done);
         var running = Items.Count(i => i.Status == TaskStatus.Running);
-        var review  = Items.Count(i => i.Status == TaskStatus.Done && i.Branch != null);
+        var review  = Items.Count(i => i.Status == TaskStatus.WaitingForReview);
 
-        Subtitle = open == 1 ? "1 open task" : $"{open} open tasks";
+        // The notes list holds no tasks — an "0 open tasks" line under its header is just noise.
+        Subtitle = IsNotesList ? ""
+                 : open == 1 ? Loc.T("vm.tasksIsland.openTaskOne")
+                 : Loc.T("vm.tasksIsland.openTasks", open);
 
         if (running > 0 || review > 0)
         {
-            StatusPill    = $"{running} running · {review} review";
+            StatusPill    = Loc.T("vm.tasksIsland.statusPill", running, review);
             HasStatusPill = true;
         }
         else
@@ -1079,9 +1209,9 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         // block removing a completed planning parent together with its done children.
         var toDelete = completed.OrderByDescending(r => r.IsChild).ToList();
 
-        if (ConfirmAsync is not null)
+        if (Dialogs is not null)
         {
-            var ok = await ConfirmAsync($"Clear {toDelete.Count} completed task(s)? This cannot be undone.");
+            var ok = await Dialogs.ConfirmAsync($"Clear {toDelete.Count} completed task(s)? This cannot be undone.", Loc.T("dialog.delete"));
             if (!ok) return;
         }
 
@@ -1209,9 +1339,9 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
     private async Task DeleteTaskAsync(TaskRowViewModel? row)
     {
         if (row is null || row.HasInteractiveSession || _worker is null) return;
-        if (ConfirmAsync is not null)
+        if (Dialogs is not null)
         {
-            var ok = await ConfirmAsync(Loc.T("vm.tasksIsland.deleteTaskConfirm", row.Title));
+            var ok = await Dialogs.ConfirmAsync(Loc.T("vm.tasksIsland.deleteTaskConfirm", row.Title), Loc.T("dialog.delete"));
             if (!ok) return;
         }
 
@@ -1523,8 +1653,8 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
 
         if (outcome.Result == DiscardPlanningResult.BlockedByQueuedChildren)
         {
-            if (ConfirmAsync is null) return;
-            var ok = await ConfirmAsync(
+            if (Dialogs is null) return;
+            var ok = await Dialogs.ConfirmAsync(
                 $"{outcome.QueuedChildrenCount} child task(s) are queued.\n" +
                 "Dequeue them and discard the planning session?");
             if (!ok) return;
@@ -1533,18 +1663,13 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         }
         else if (outcome.Result == DiscardPlanningResult.BlockedByRunningChildren)
         {
-            if (ConfirmAsync is null) return;
-            await ConfirmAsync(
+            if (Dialogs is null) return;
+            await Dialogs.ConfirmAsync(
                 $"{outcome.RunningChildrenCount} child task(s) are still running.\n" +
                 "Cancel them first, then try again.");
         }
     }
 
-    /// <summary>
-    /// Wired by the view via <see cref="ShowConfirmAsync"/>. Returns true when the user confirms.
-    /// </summary>
-    public Func<string, Task<bool>>? ConfirmAsync { get; set; }
-
     private bool CanRunPlanningOperation() => !PlanningOperation.IsRunning;
 
     [RelayCommand(CanExecute = nameof(CanRunPlanningOperation))]
@@ -1669,6 +1794,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
             entities = await db.Tasks
                 .Include(t => t.List)
                 .Include(t => t.Worktree)
+                .Include(t => t.Dependencies)
                 .Where(t => idSet.Contains(t.Id))
                 .ToListAsync(ct);
             dbOk = true;
@@ -1707,12 +1833,18 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         // reflects any of that after a Regroup — without this the tick would heal the row's data
         // while leaving a completed task sitting in the Open section under a stale count. Gated
         // on a real change so an idle tick stays free.
-        if (groupingChanged) Regroup();
+        if (groupingChanged)
+        {
+            await using var db2 = await _dbFactory.CreateDbContextAsync(ct);
+            await RefreshExternalDependencyCacheAsync(db2, DependencyLookupIds(Items), ct);
+            Regroup();
+        }
     }
 
     // The slice of a row that Regroup reads: which section it lands in, where it sits inside it,
     // and what its chain rail/after-chip says. Only fields UpdateFromEntity actually writes —
     // IsExpanded and HasPlanningChildren are owned elsewhere and would produce false positives.
-    private static (bool, DateTime?, string?, string?, PlanningPhase, int, string) GroupingKey(TaskRowViewModel r) =>
-        (r.Done, r.ScheduledFor, r.ParentTaskId, r.DependsOnTaskId, r.PlanningPhase, r.Number, r.Title);
+    private static (bool, DateTime?, string?, string, PlanningPhase, int, string) GroupingKey(TaskRowViewModel r) =>
+        (r.Done, r.ScheduledFor, r.ParentTaskId, string.Join(",", r.DependsOnTaskIds),
+         r.PlanningPhase, r.Number, r.Title);
 }

src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs

@@ -1,3 +1,5 @@
+using Avalonia;
+using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Threading;
 using System;
 using System.Threading;
@@ -5,7 +7,6 @@ using System.Threading.Tasks;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using ClaudeDo.Data;
-using ClaudeDo.Data.Git;
 using ClaudeDo.Data.Models;
 using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
@@ -52,7 +53,6 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
     private readonly UpdateCheckService _updateCheck = null!;
     private readonly InstallerLocator _installerLocator = null!;
     private readonly WorkerLocator _workerLocator = null!;
-    private readonly GitService? _git;
     private readonly IDbContextFactory<ClaudeDoDbContext>? _dbFactory;
     private readonly Func<WorktreesOverviewModalViewModel> _worktreesOverviewVmFactory = () => null!;
     private readonly Func<WeeklyReportModalViewModel> _weeklyReportVmFactory = () => null!;
@@ -68,7 +68,7 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
     // 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.
+    // Single dialog seam (set by MainWindow); propagated to the islands.
     private IDialogService? _dialogs;
     public IDialogService? Dialogs
     {
@@ -78,6 +78,7 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
             _dialogs = value;
             if (Lists is not null) Lists.Dialogs = value;
             if (Tasks is not null) Tasks.Dialogs = value;
+            if (Details is not null) Details.Dialogs = value;
         }
     }
 
@@ -121,11 +122,6 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
     [ObservableProperty] private string? _updateBannerLatestVersion;
     private bool _bannerDismissedThisSession;
 
-    // Persistent (not auto-clearing) banner: the running worker predates the selected list's
-    // merged HEAD, so "verified" claims made against the current process are stale. ClaudeDo-repo
-    // only — see RefreshStaleWorkerCheckAsync.
-    [ObservableProperty] private bool _isStaleWorkerBannerVisible;
-
     // planningTaskId -> subtaskId, for unit-merge conflicts an MCP session (not the UI) started.
     // Kept as a dictionary so a later conflict on the same planning task updates in place instead
     // of piling up duplicate entries.
@@ -145,7 +141,14 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
     [ObservableProperty]
     private bool _isWorkerLogVisible;
 
-    public bool ShowDetails => WindowWidth >= 1100;
+    /// <summary>The notes list has nothing to show a detail pane for, so the pane goes away and
+    /// the editor takes the space instead of leaving an empty column beside it.</summary>
+    public bool ShowDetails => WindowWidth >= 1100 && Tasks?.IsNotesList != true;
+
+    /// <summary>Widens the tasks island over the splitter and the details column when that column
+    /// is hidden — a fixed-width ColumnDefinition keeps its space even with an invisible child.</summary>
+    public int TasksColumnSpan => ShowDetails ? 1 : 3;
+
     public bool ShowLists => WindowWidth >= 780;
 
     private readonly System.Timers.Timer _clearTimer = new(30_000) { AutoReset = false };
@@ -168,10 +171,16 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
 
     partial void OnWindowWidthChanged(double value)
     {
-        OnPropertyChanged(nameof(ShowDetails));
+        NotifyDetailsVisibility();
         OnPropertyChanged(nameof(ShowLists));
     }
 
+    private void NotifyDetailsVisibility()
+    {
+        OnPropertyChanged(nameof(ShowDetails));
+        OnPropertyChanged(nameof(TasksColumnSpan));
+    }
+
     public void OnWorkerLogReceived(WorkerLogEntry entry)
     {
         var hhmm = entry.TimestampUtc.ToLocalTime().ToString("HH:mm");
@@ -315,8 +324,7 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         Func<MergeModalViewModel> mergeVmFactory,
         Func<RepoImportModalViewModel> repoImportVmFactory,
         MissionControlViewModel missionControl,
-        UsagePillViewModel usagePill,
-        GitService? git = null)
+        UsagePillViewModel usagePill)
     {
         Lists = lists; Tasks = tasks; Details = details; Worker = worker;
         MissionControl = missionControl;
@@ -324,6 +332,7 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         UsagePill.OpenMonitorRequested += () => _ = OpenUsageMonitor();
         MissionControl.OpenInApp = id => _ = RevealTaskAsync(id);
         MissionControl.OpenSettingsRequested = () => Lists.OpenSettingsCommand.Execute(null);
+        MissionControl.OpenRequested = OpenMissionControl;
         MissionControl.ErrorReported += FlashFooterError;
         // Keep the task rows' "Interactive" chip in step with Mission Control's open ConPTY panes.
         MissionControl.ConPtySessions.CollectionChanged += (_, _) => SyncInteractiveSessionChips();
@@ -336,12 +345,13 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         _usageMonitorVmFactory = usageMonitorVmFactory;
         _mergeVmFactory = mergeVmFactory;
         _repoImportVmFactory = repoImportVmFactory;
-        _git = git;
         Lists.SelectionChanged += (_, _) => Tasks.LoadForList(Lists.SelectedList);
-        Lists.SelectionChanged += (_, _) => _ = RefreshStaleWorkerCheckAsync();
         Tasks.SelectionChanged += (_, _) => Details.Bind(Tasks.SelectedTask, Tasks.SelectionSource);
-        Tasks.NotesRequested += () => Details.ShowNotes();
         Tasks.PrepRequested += () => Details.ShowPrep();
+        Tasks.PropertyChanged += (_, e) =>
+        {
+            if (e.PropertyName == nameof(TasksIslandViewModel.IsNotesList)) NotifyDetailsVisibility();
+        };
         Tasks.ErrorReported += FlashFooterError;
         Lists.ErrorReported += FlashFooterError;
         Lists.SuccessReported += FlashFooterSuccess;
@@ -363,7 +373,7 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         Lists.LetClaudeHandleRequested += req =>
         {
             OpenMissionControl();
-            _ = MissionControl.OpenMergeHelperConPtySessionAsync(req.ListId, req.TaskIds);
+            _ = MissionControl.OpenMergeHelperConPtySessionAsync(req.ListId, req.TaskIds, req.TriageModel);
         };
         Lists.MergeReviewsRequested += req =>
         {
@@ -402,7 +412,6 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         };
         Worker.OperationProgressEvent += OnOperationProgress;
         Worker.WorkerLogReceivedEvent += OnWorkerLogReceived;
-        Worker.ConnectionRestoredEvent += () => _ = RefreshStaleWorkerCheckAsync();
         Worker.PlanningMergeConflictEvent += OnPlanningMergeConflict;
         Worker.PlanningMergeAbortedEvent += OnPlanningMergeAborted;
         Worker.PlanningCompletedEvent += OnPlanningMergeCompleted;
@@ -455,8 +464,6 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         _connectTimer.Dispose();
         _primeStatusTimer.Stop();
         _primeStatusTimer.Dispose();
-        _staleWorkerCts?.Cancel();
-        _staleWorkerCts?.Dispose();
     }
 
     private void RefreshBannerFromStatus()
@@ -476,57 +483,6 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         }
     }
 
-    private CancellationTokenSource? _staleWorkerCts;
-
-    // Re-evaluates the stale-worker banner for the currently selected list. Cheap (one hub call +
-    // up to two git subprocesses) and only ever runs for a git-backed list, so it's fine to fire on
-    // every selection change / reconnect rather than caching.
-    private async Task RefreshStaleWorkerCheckAsync()
-    {
-        _staleWorkerCts?.Cancel();
-        var cts = new CancellationTokenSource();
-        _staleWorkerCts = cts;
-
-        var stale = await ComputeIsStaleWorkerAsync(Lists?.SelectedList?.WorkingDir, cts.Token);
-        if (cts.IsCancellationRequested) return;
-        IsStaleWorkerBannerVisible = stale;
-    }
-
-    private async Task<bool> ComputeIsStaleWorkerAsync(string? workingDir, CancellationToken ct)
-    {
-        if (_git is null || Worker is null || string.IsNullOrWhiteSpace(workingDir)) return false;
-
-        try
-        {
-            var buildInfo = await Worker.GetWorkerBuildInfoAsync();
-            var buildSha = buildInfo?.BuildSha;
-            if (string.IsNullOrWhiteSpace(buildSha)) return false;
-            if (!await _git.IsGitRepoAsync(workingDir, ct)) return false;
-
-            var head = await _git.RevParseHeadAsync(workingDir, ct);
-            var isAncestor = string.Equals(buildSha, head, StringComparison.OrdinalIgnoreCase)
-                ? (bool?)false // equal — never "stale" on a match, and no need to ask git
-                : await _git.IsAncestorAsync(workingDir, buildSha, head, ct);
-            return ShouldShowStaleWorkerBanner(buildSha, head, isAncestor);
-        }
-        catch
-        {
-            // Worker offline, dir no longer a repo, etc. — unknown, so stay quiet.
-            return false;
-        }
-    }
-
-    // Pure decision extracted for testability. isAncestor is the tri-state result of
-    // `git merge-base --is-ancestor buildSha head`: true = worker predates head (stale), false =
-    // equal or diverged (never claim "stale" on a match or an unrelated history), null = unknown
-    // (e.g. buildSha isn't a commit this repo knows about — never treat "unknown" as "stale").
-    internal static bool ShouldShowStaleWorkerBanner(string? buildSha, string? headSha, bool? isAncestor)
-    {
-        if (string.IsNullOrWhiteSpace(buildSha) || string.IsNullOrWhiteSpace(headSha)) return false;
-        if (string.Equals(buildSha, headSha, StringComparison.OrdinalIgnoreCase)) return false;
-        return isAncestor == true;
-    }
-
     [RelayCommand]
     private void OpenMissionControl()
     {
@@ -562,6 +518,19 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         if (Dialogs is not null) await Dialogs.ShowAboutAsync(vm);
     }
 
+    // One shared VM so the sheets are parsed once and the window keeps its selection/pin
+    // across reopens; the window itself is single-instance in the dialog service.
+    private CheatSheetsViewModel? _cheatSheets;
+
+    [RelayCommand]
+    private void OpenCheatSheet(string? key)
+    {
+        if (Dialogs is null) return;
+        _cheatSheets ??= new CheatSheetsViewModel();
+        if (!string.IsNullOrEmpty(key)) _cheatSheets.Select(key);
+        Dialogs.ShowCheatSheets(_cheatSheets);
+    }
+
     [RelayCommand]
     private async Task OpenLogVisualizer()
     {
@@ -665,30 +634,66 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         await _updateCheck.CheckNowAsync(CancellationToken.None);
     }
 
-    [ObservableProperty] private string? _restartWorkerStatus;
+    // How long to wait after launching the new worker process before deciding it survived
+    // (e.g. a port conflict kills it almost immediately — see #292 for the worker-side fix).
+    private const int RestartSurvivalCheckMs = 2000;
+
+    // Test seam: overrides the real kill-and-relaunch body, so tests can assert the
+    // success/failure footer routing without spawning a real worker process.
+    internal Func<Task>? RestartWorkerOperation { get; set; }
 
     [RelayCommand]
     private async Task RestartWorkerAsync()
     {
-        RestartWorkerStatus = Loc.T("vm.shell.restartingWorker");
         try
         {
-            await Task.Run(RestartWorkerService);
-            await FlashRestartStatusAsync("Worker restarted.");
+            await (RestartWorkerOperation ?? (() => Task.Run(RestartWorkerService)))();
+            FlashFooterSuccess("Worker restarted.");
         }
         catch (Exception ex)
         {
-            await FlashRestartStatusAsync($"Restart failed: {ex.Message}");
+            FlashFooterError($"Restart failed: {ex.Message} — check the worker log.");
         }
     }
 
     private void RestartWorkerService()
     {
-        var exe = _workerLocator.Find();
+        // Prefer the exe path of the worker that's actually running: _workerLocator.Find()
+        // walks up from AppContext.BaseDirectory looking for install.json and falls back to
+        // the registry's InstallLocation otherwise — on a debug build launched from the repo
+        // there's no install.json above it, so it returns the *installed* worker's path. That
+        // never matches the running debug process, so KillMatchingWorkerProcesses silently
+        // skips it (it only kills a process whose path equals the given exe) and this either
+        // launches a second worker that immediately dies on the already-bound port, or leaves
+        // the real one running untouched while nothing visibly changes.
+        var exe = RunningWorkerExePath() ?? _workerLocator.Find();
         if (exe is null) throw new InvalidOperationException("Worker executable not found.");
 
-        // Only kill the worker belonging to THIS installation — not any other
-        // ClaudeDo.Worker on the machine (e.g. a second install).
+        KillMatchingWorkerProcesses(exe);
+
+        var started = System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(exe) { UseShellExecute = true });
+        if (started is not null && started.WaitForExit(RestartSurvivalCheckMs))
+            throw new InvalidOperationException($"worker process exited immediately (code {started.ExitCode})");
+    }
+
+    private static string? RunningWorkerExePath()
+    {
+        foreach (var p in System.Diagnostics.Process.GetProcessesByName("ClaudeDo.Worker"))
+        {
+            try
+            {
+                if (p.MainModule?.FileName is { } path) return path;
+            }
+            catch { /* inaccessible */ }
+            finally { p.Dispose(); }
+        }
+        return null;
+    }
+
+    // Only kill the worker belonging to THIS installation — not any other
+    // ClaudeDo.Worker on the machine (e.g. a second install).
+    private static void KillMatchingWorkerProcesses(string exe)
+    {
         var exeFull = System.IO.Path.GetFullPath(exe);
         foreach (var p in System.Diagnostics.Process.GetProcessesByName("ClaudeDo.Worker"))
         {
@@ -704,16 +709,124 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
             catch { /* may have exited or be inaccessible */ }
             finally { p.Dispose(); }
         }
-        System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(exe) { UseShellExecute = true });
     }
 
-    private async Task FlashRestartStatusAsync(string text)
+    // Test seam: overrides the real kill-worker + close-window body.
+    internal Action? ShutdownOperation { get; set; }
+
+    [RelayCommand]
+    private async Task ShutdownAsync()
     {
-        RestartWorkerStatus = text;
-        await Task.Delay(3000);
-        if (RestartWorkerStatus == text) RestartWorkerStatus = null;
+        if (Dialogs is null) return;
+        var confirmed = await Dialogs.ConfirmAsync(Loc.T("vm.shell.shutdownConfirm"));
+        if (!confirmed) return;
+        (ShutdownOperation ?? ShutdownWorkerAndCloseApp)();
     }
 
+    private void ShutdownWorkerAndCloseApp()
+    {
+        var exe = _workerLocator.Find();
+        if (exe is not null) KillMatchingWorkerProcesses(exe);
+
+        // Closing just the MainWindow relies on ShutdownMode.OnMainWindowClose, which asks
+        // every open window to close and backs off if any of them cancels — and
+        // MissionControlWindow always cancels its own close (it hides instead, see
+        // MissionControlWindow.OnClosing), so the process never actually exited. Shutdown()
+        // force-closes every window, ignoring that cancellation.
+        if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
+            desktop.Shutdown();
+    }
+
+    private bool _updatingClaudeCli;
+
+    private bool CanUpdateClaudeCli() => !_updatingClaudeCli;
+
+    [RelayCommand(CanExecute = nameof(CanUpdateClaudeCli))]
+    private async Task UpdateClaudeCliAsync()
+    {
+        _updatingClaudeCli = true;
+        UpdateClaudeCliCommand.NotifyCanExecuteChanged();
+        try
+        {
+            var dto = Worker is null ? null : await Worker.GetClaudeBinAsync();
+            if (dto is null)
+            {
+                FlashFooterError("Update failed: worker offline.");
+                return;
+            }
+
+            var (success, message) = await RunClaudeUpdateAsync(dto);
+            if (success) FlashFooterSuccess(message);
+            else FlashFooterError(message);
+        }
+        finally
+        {
+            _updatingClaudeCli = false;
+            UpdateClaudeCliCommand.NotifyCanExecuteChanged();
+        }
+    }
+
+    private static async Task<(bool Success, string Message)> RunClaudeUpdateAsync(ClaudeBinDto dto)
+    {
+        var resolved = ClaudeDo.Data.Environment.ExecutableResolver.Resolve(dto.Value);
+        if (resolved is null) return (false, $"Update failed: '{dto.Value}' not found.");
+
+        var psi = resolved.IsShim
+            ? BuildShimUpdatePsi(resolved.Path)
+            : new System.Diagnostics.ProcessStartInfo { FileName = resolved.Path, ArgumentList = { "update" } };
+        psi.UseShellExecute = false;
+        psi.RedirectStandardOutput = true;
+        psi.RedirectStandardError = true;
+        psi.CreateNoWindow = true;
+
+        using var process = new System.Diagnostics.Process { StartInfo = psi };
+        var stdout = new System.Text.StringBuilder();
+        var stderr = new System.Text.StringBuilder();
+        process.OutputDataReceived += (_, e) => { if (e.Data is not null) stdout.AppendLine(e.Data); };
+        process.ErrorDataReceived += (_, e) => { if (e.Data is not null) stderr.AppendLine(e.Data); };
+
+        try { process.Start(); }
+        catch (Exception ex) { return (false, $"Update failed: {ex.Message}"); }
+
+        process.BeginOutputReadLine();
+        process.BeginErrorReadLine();
+
+        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(5));
+        var timedOut = false;
+        // On timeout: kill the tree, which unblocks WaitForExitAsync below and lets the
+        // async output readers drain/complete naturally (mirrors VerifyCommandRunner).
+        await using var ctr = cts.Token.Register(() =>
+        {
+            timedOut = true;
+            try { process.Kill(entireProcessTree: true); } catch { /* already exited */ }
+        });
+
+        await process.WaitForExitAsync(CancellationToken.None);
+
+        return timedOut
+            ? (false, "Update failed: timed out after 5 minutes.")
+            : SummarizeClaudeUpdateOutcome(process.ExitCode, stdout.ToString(), stderr.ToString());
+    }
+
+    private static System.Diagnostics.ProcessStartInfo BuildShimUpdatePsi(string shimPath)
+    {
+        var shim = ClaudeDo.Data.Environment.ExecutableResolver.BuildShimStartInfo(shimPath, new[] { "update" });
+        return new System.Diagnostics.ProcessStartInfo { FileName = shim.FileName, Arguments = shim.Arguments };
+    }
+
+    // Pure so a test can drive it with fake process output instead of spawning a real `claude`.
+    internal static (bool Success, string Message) SummarizeClaudeUpdateOutcome(int exitCode, string stdout, string stderr)
+    {
+        if (exitCode == 0)
+            return (true, LastNonEmptyLine(stdout) ?? "Claude CLI is already up to date.");
+
+        var detail = LastNonEmptyLine(stderr) ?? LastNonEmptyLine(stdout) ?? "";
+        return (false, $"Update failed (exit {exitCode}): {detail}");
+    }
+
+    private static string? LastNonEmptyLine(string text) =>
+        text.Split('\n').Select(l => l.Trim()).LastOrDefault(l => l.Length > 0);
+
     [RelayCommand]
     private void DismissBanner()
     {

src/ClaudeDo.Ui/ViewModels/MissionControl/ConPtyPaneViewModel.cs

@@ -2,6 +2,7 @@ using System;
 using System.ComponentModel;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
+using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
 
 namespace ClaudeDo.Ui.ViewModels.MissionControl;
@@ -18,6 +19,12 @@ public sealed partial class ConPtyPaneViewModel : ViewModelBase, IDisposable
     // Only a task-based pane can be submitted for review (an ad-hoc directory session has no task).
     public bool IsTaskBased => TaskId is not null;
 
+    /// <summary>Set by the host for a list-handler run ("Let Claude handle it" / "Let Claude merge
+    /// the reviews") pane -- shows the "Abandon run" action. Plain mutable property, not
+    /// <see cref="ObservableProperty"/>: the host sets it once right after construction, before the
+    /// pane is added to the visible collection, so no change notification is needed.</summary>
+    public bool IsListHandler { get; set; }
+
     [ObservableProperty] private string _displayTitle;
 
     [ObservableProperty] private InteractiveTerminalViewModel _terminal = new();
@@ -26,6 +33,10 @@ public sealed partial class ConPtyPaneViewModel : ViewModelBase, IDisposable
     /// flight, so a rapid double-click can't race two submissions for the same task.</summary>
     [ObservableProperty] private bool _isSubmitPending;
 
+    /// <summary>Set by the host while an abandon-run round trip (query open tasks, confirm,
+    /// cancel each, close pane) is in flight, so a rapid double-click can't race two runs.</summary>
+    [ObservableProperty] private bool _isAbandonPending;
+
     /// <summary>Raised when the terminal failed to start — the host surfaces this via the footer error strip.</summary>
     public event Action<string>? ErrorReported;
 
@@ -36,6 +47,18 @@ public sealed partial class ConPtyPaneViewModel : ViewModelBase, IDisposable
     /// commits the worktree and moves the task to WaitingForReview.</summary>
     public event Action<string>? SubmitForReviewRequested;
 
+    /// <summary>Raised when the user abandons a list-handler run (<see cref="IsListHandler"/>
+    /// only): the host looks up this round's still-open tasks, confirms with the user (naming the
+    /// count), cancels them, then closes this pane -- one action instead of closing the tile and
+    /// separately cancelling the queue.</summary>
+    public event Action<string>? AbandonRunRequested;
+
+    /// <summary>Raised with <c>(taskId, exitCode)</c> when a task-based session that had been running
+    /// dies non-zero. The host reports it to the worker, which decides whether this was a list
+    /// handler killed by the usage limit and worth reopening. Ad-hoc panes never raise it — there is
+    /// no task to reopen.</summary>
+    public event Action<string, int>? SessionDiedAfterStartup;
+
     /// <summary>Task-based pane — dedup'd by <see cref="TaskId"/>. Pass null for an ad-hoc pane
     /// (no task, never deduped); prefer <see cref="CreateAdHoc"/> at ad-hoc call sites.
     /// <paramref name="descriptorFactory"/> is resolved by the pane itself (in <see cref="Start"/>)
@@ -49,7 +72,38 @@ public sealed partial class ConPtyPaneViewModel : ViewModelBase, IDisposable
         TaskId = taskId;
         _displayTitle = displayTitle;
         _descriptorFactory = descriptorFactory;
-        Terminal.PropertyChanged += OnTerminalPropertyChanged;
+        Subscribe(Terminal);
+    }
+
+    // Terminal is swapped wholesale on Retry, so the handlers follow the property rather than being
+    // wired once at construction. (The initial value comes from the field initializer, which never
+    // runs through the setter -- hence the explicit Subscribe in the constructor.)
+    partial void OnTerminalChanging(InteractiveTerminalViewModel? oldValue, InteractiveTerminalViewModel newValue)
+    {
+        if (oldValue is not null) Unsubscribe(oldValue);
+    }
+
+    partial void OnTerminalChanged(InteractiveTerminalViewModel value) => Subscribe(value);
+
+    private void Subscribe(InteractiveTerminalViewModel terminal)
+    {
+        terminal.PropertyChanged += OnTerminalPropertyChanged;
+        terminal.ExitedAfterStartup += OnTerminalExitedAfterStartup;
+        terminal.ErrorReported += OnTerminalErrorReported;
+    }
+
+    private void Unsubscribe(InteractiveTerminalViewModel terminal)
+    {
+        terminal.PropertyChanged -= OnTerminalPropertyChanged;
+        terminal.ExitedAfterStartup -= OnTerminalExitedAfterStartup;
+        terminal.ErrorReported -= OnTerminalErrorReported;
+    }
+
+    private void OnTerminalErrorReported(string message) => ErrorReported?.Invoke(message);
+
+    private void OnTerminalExitedAfterStartup(int exitCode)
+    {
+        if (TaskId is { } id) SessionDiedAfterStartup?.Invoke(id, exitCode);
     }
 
     private readonly Func<System.Threading.Tasks.Task<TerminalLaunchDescriptor>> _descriptorFactory;
@@ -88,8 +142,22 @@ public sealed partial class ConPtyPaneViewModel : ViewModelBase, IDisposable
             SubmitForReviewCommand.NotifyCanExecuteChanged();
             RetryCommand.NotifyCanExecuteChanged();
         }
+
+        if (e.PropertyName is nameof(InteractiveTerminalViewModel.HasExitedAfterStartup)
+            or nameof(InteractiveTerminalViewModel.ExitCode))
+        {
+            OnPropertyChanged(nameof(ExitedBannerText));
+        }
     }
 
+    /// <summary>"Session ended (code N)" text for <see cref="InteractiveTerminalViewModel.HasExitedAfterStartup"/> —
+    /// computed here (rather than formatted in XAML) since <c>loc:Tr</c> has no binding-arg support.</summary>
+    public string ExitedBannerText => Loc.T("missionControl.conptyExited", Terminal.ExitCode ?? 0);
+
+    /// <summary>Types a message into this pane's live session and submits it (the worker's
+    /// pre-usage-limit warning). False when the session isn't running.</summary>
+    public System.Threading.Tasks.Task<bool> SendLineAsync(string text) => Terminal.SendLineAsync(text);
+
     [RelayCommand]
     private void Close() => CloseRequested?.Invoke(this);
 
@@ -104,23 +172,33 @@ public sealed partial class ConPtyPaneViewModel : ViewModelBase, IDisposable
 
     partial void OnIsSubmitPendingChanged(bool value) => SubmitForReviewCommand.NotifyCanExecuteChanged();
 
-    // A launch failure permanently occupies the TaskId dedupe slot unless the user can retry —
-    // re-opening the same task would otherwise just re-focus a dead tile.
-    private bool CanRetry() => Terminal.HasExited && Terminal.StartError is not null;
+    private bool CanAbandonRun() => IsListHandler && !IsAbandonPending;
+
+    [RelayCommand(CanExecute = nameof(CanAbandonRun))]
+    private void AbandonRun()
+    {
+        if (TaskId is { } id) AbandonRunRequested?.Invoke(id);
+    }
+
+    partial void OnIsAbandonPendingChanged(bool value) => AbandonRunCommand.NotifyCanExecuteChanged();
+
+    // A dead session permanently occupies the TaskId dedupe slot unless the user can retry — whether
+    // it died at launch (StartError) or after (HasExitedAfterStartup), the same descriptor factory
+    // can always relaunch it, so any HasExited state is retryable.
+    private bool CanRetry() => Terminal.HasExited;
 
     [RelayCommand(CanExecute = nameof(CanRetry))]
     private void Retry()
     {
-        Terminal.PropertyChanged -= OnTerminalPropertyChanged;
-        Terminal.Dispose();
-        Terminal = new InteractiveTerminalViewModel();
-        Terminal.PropertyChanged += OnTerminalPropertyChanged;
+        var dead = Terminal;
+        Terminal = new InteractiveTerminalViewModel(); // OnTerminalChanging/Changed move the handlers
+        dead.Dispose();
         Start();
     }
 
     public void Dispose()
     {
-        Terminal.PropertyChanged -= OnTerminalPropertyChanged;
+        Unsubscribe(Terminal);
         Terminal.Kill();
         Terminal.Dispose();
     }

src/ClaudeDo.Ui/ViewModels/MissionControlViewModel.cs

@@ -21,6 +21,8 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
     private readonly Action<string> _onTaskUpdated;
     private readonly Action _onConnectionRestored;
     private readonly Action<string, IReadOnlyList<string>, string> _onHandoffRequested;
+    private readonly Action<string, IReadOnlyList<string>> _onListHandlerStartRequested;
+    private readonly Action<string, string> _onHandlerUsageWarning;
 
     // Embedded ConPTY sessions (task-based only) — a manual cockpit detached from the
     // review/merge/status machinery.
@@ -56,6 +58,11 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
     // View-layer seam: open the app Settings modal from the Mission Control window.
     public Action? OpenSettingsRequested { get; set; }
 
+    // Set by the shell: bring Mission Control on screen. A ConPTY pane only launches its process once
+    // its view is attached, so a run started from outside the UI (start_list_handler MCP tool) or a
+    // handoff arriving while Mission Control is closed would otherwise sit there without a process.
+    public Action? OpenRequested { get; set; }
+
     public bool HasPanes => Panes.Count > 0;
 
     // Read-only activity strip. Beyond the queue itself (Queued/Running) it also carries the rows
@@ -72,6 +79,10 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
     // MissionControlView.OnNewSessionClicked).
     public Action? BrowseForSessionRequested { get; set; }
 
+    // View-layer seam: confirms the "abandon run" action, naming the open-task count. Wired by the
+    // view the same way TasksIslandViewModel/DetailsIslandViewModel are.
+    public Func<string, System.Threading.Tasks.Task<bool>>? ConfirmAsync { get; set; }
+
     public UsagePillViewModel UsagePill { get; }
 
     public MissionControlViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, IWorkerClient worker, UsagePillViewModel usagePill)
@@ -98,6 +109,11 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
         _onHandoffRequested = (taskId, survivingTaskIds, nextPhase) => { _ = OpenMergeHelperHandoffConPtySessionAsync(taskId, survivingTaskIds, nextPhase); };
         _worker.HandoffRequestedEvent += _onHandoffRequested;
 
+        _onListHandlerStartRequested = (listId, taskIds) => { OpenRequested?.Invoke(); _ = OpenMergeHelperConPtySessionAsync(listId, taskIds); };
+        _worker.ListHandlerStartRequestedEvent += _onListHandlerStartRequested;
+        _onHandlerUsageWarning = (taskId, message) => { _ = WarnHandlerSessionAsync(taskId, message); };
+        _worker.HandlerUsageWarningEvent += _onHandlerUsageWarning;
+
         _ = RefreshQueueAsync();
         _ = RefreshSessionTargetsAsync();
     }
@@ -163,7 +179,14 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
     internal async System.Threading.Tasks.Task RefreshSessionTargetsAsync()
     {
         SessionTargets.Clear();
-        // Browse goes in first so the menu stays usable even if the list query below fails.
+        // Home + browse go in first so the menu stays usable even if the list query below fails.
+        // Home is the target for quick general questions that belong to no project.
+        var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+        SessionTargets.Add(new SessionTargetViewModel
+        {
+            Label = Loc.T("missionControl.homeFolder"),
+            StartCommand = new RelayCommand(() => _ = OpenAdHocConPtySessionAsync(home)),
+        });
         SessionTargets.Add(new SessionTargetViewModel
         {
             Label = Loc.T("missionControl.browseForFolder"),
@@ -308,10 +331,10 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
     // creates one new ClaudeDo task per run to own the session (title/diff/result), deduped by
     // TaskId like OpenConPtySessionAsync. The handler still merges the tasks it handles itself
     // (no worktree of its own) — see TaskEntity.HandlerBaseCommit/HandlerHeadCommit.
-    public System.Threading.Tasks.Task OpenMergeHelperConPtySessionAsync(string listId, IReadOnlyList<string> taskIds)
+    public System.Threading.Tasks.Task OpenMergeHelperConPtySessionAsync(string listId, IReadOnlyList<string> taskIds, string? triageModel = null)
         => OpenListHandlerConPtySessionAsync(listId, taskIds,
             "missionControl.mergeHelperTitle", "missionControl.mergeHelperTaskTitle",
-            taskId => _worker.GetMergeHelperLaunchSpecAsync(taskIds, listId, taskId));
+            taskId => _worker.GetMergeHelperLaunchSpecAsync(taskIds, listId, taskId, triageModel));
 
     // Merge-only list-handler session over a list's WaitingForReview tasks (the review list's
     // "Let Claude merge the reviews"). Same host-task shape as the full run, but the session
@@ -363,7 +386,7 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
             }
 
             AddConPtyPane(new ConPtyPaneViewModel(taskId, title,
-                () => DescribeAsync(() => launchSpec(taskId))));
+                () => DescribeAsync(() => launchSpec(taskId))) { IsListHandler = true });
         }
         finally
         {
@@ -383,6 +406,7 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
         string taskId, IReadOnlyList<string> survivingTaskIds, string nextPhase)
     {
         if (string.IsNullOrEmpty(taskId) || survivingTaskIds is not { Count: > 0 }) return;
+        OpenRequested?.Invoke();
 
         foreach (var stale in ConPtySessions.Where(s => s.TaskId == taskId).ToList())
             CloseConPtySession(stale);
@@ -403,7 +427,21 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
         catch { /* best-effort title lookup */ }
 
         AddConPtyPane(new ConPtyPaneViewModel(taskId, title,
-            () => DescribeAsync(() => _worker.GetMergeHelperHandoffLaunchSpecAsync(taskId, survivingTaskIds, nextPhase))));
+            () => DescribeAsync(() => _worker.GetMergeHelperHandoffLaunchSpecAsync(taskId, survivingTaskIds, nextPhase)))
+            { IsListHandler = true });
+    }
+
+    // The 5h usage window is about to run out under this handler session: type the worker's warning
+    // into its pane so the session can hand off cleanly instead of dying mid-merge. The UI process
+    // owns the terminal, so this is the only place that can reach it at all. No pane (the tile was
+    // closed, or this is a second app instance) = nothing to warn, and that is not an error.
+    internal async System.Threading.Tasks.Task WarnHandlerSessionAsync(string taskId, string message)
+    {
+        if (string.IsNullOrEmpty(taskId) || string.IsNullOrEmpty(message)) return;
+        if (ConPtySessions.FirstOrDefault(s => s.TaskId == taskId) is not { } pane) return;
+
+        if (!await pane.SendLineAsync(message))
+            ErrorReported?.Invoke(Loc.T("missionControl.usageWarningNotDelivered"));
     }
 
     // Wires a freshly built pane and shows it immediately — the pane resolves its own launch spec,
@@ -411,12 +449,31 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
     private void AddConPtyPane(ConPtyPaneViewModel pane)
     {
         pane.ErrorReported += OnConPtyPaneError;
-        pane.CloseRequested += CloseConPtySession;
+        pane.CloseRequested += OnPaneCloseRequested;
         pane.SubmitForReviewRequested += OnPaneSubmitForReview;
+        pane.SessionDiedAfterStartup += OnPaneSessionDied;
+        pane.AbandonRunRequested += OnPaneAbandonRun;
         ConPtySessions.Add(pane);
         pane.Start();
     }
 
+    // A ConPTY session that had been running died. The UI process owns the terminal, so this is the
+    // only place the exit code exists -- report it and let the worker decide whether it was a list
+    // handler killed by the usage limit and worth reopening after the reset
+    // (HandlerRestartCoordinator). Every other pane is just a no-op there, so no filtering here.
+    private async void OnPaneSessionDied(string taskId, int exitCode)
+    {
+        try
+        {
+            await _worker.ReportInteractiveSessionExitedAsync(taskId, exitCode);
+        }
+        catch (Exception ex)
+        {
+            // A worker that is down cannot restart anything anyway; the dead tile is already visible.
+            ErrorReported?.Invoke(Loc.T("missionControl.conptyLaunchFailed", ex.Message));
+        }
+    }
+
     private static async System.Threading.Tasks.Task<TerminalLaunchDescriptor> DescribeAsync(
         Func<System.Threading.Tasks.Task<LaunchSpec>> fetch)
     {
@@ -451,12 +508,65 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
         }
     }
 
+    // Handler-run abort ("Not-Aus"): cancels every still-open (Queued/Running) task this handler
+    // round queued or started, then closes the pane -- one action instead of "close tile" + "cancel
+    // the tasks separately", which used to leave orphaned rows nobody merges. No open tasks (or no
+    // round entry at all -- 7-day retention, or a run predating this feature) closes the pane
+    // straight away, no confirmation needed. Guarded by IsAbandonPending like OnPaneSubmitForReview.
+    private async void OnPaneAbandonRun(string taskId)
+    {
+        if (ConPtySessions.FirstOrDefault(s => s.TaskId == taskId) is not { } pane || pane.IsAbandonPending)
+            return;
+
+        pane.IsAbandonPending = true;
+        try
+        {
+            var open = await _worker.GetHandlerOpenTasksAsync(taskId);
+            if (open.Count > 0)
+            {
+                if (ConfirmAsync is null) return;
+                if (!await ConfirmAsync(Loc.T("missionControl.abandonRunConfirm", open.Count))) return;
+
+                foreach (var task in open)
+                    await _worker.CancelTaskAsync(task.Id);
+            }
+
+            CloseConPtySession(pane);
+        }
+        catch (Exception ex)
+        {
+            ErrorReported?.Invoke(Loc.T("missionControl.abandonRunFailed", ex.Message));
+        }
+        finally
+        {
+            pane.IsAbandonPending = false;
+        }
+    }
+
+    // The tile's own X: a reflex click must not silently kill a live session the way it would a
+    // regular window. Confirm only when the terminal is actually running -- a dead one (StartError,
+    // or HasExited i.e. the #290 exited banner) is pure cleanup and closes straight away, same as it
+    // always did. Every other close path (handoff replacing a pane, submit-for-review, abandon-run)
+    // still calls CloseConPtySession directly and is unaffected.
+    private async void OnPaneCloseRequested(ConPtyPaneViewModel pane)
+    {
+        if (pane.Terminal.IsRunning)
+        {
+            if (ConfirmAsync is null) return;
+            if (!await ConfirmAsync(Loc.T("missionControl.closeSessionConfirm"))) return;
+        }
+
+        CloseConPtySession(pane);
+    }
+
     private void CloseConPtySession(ConPtyPaneViewModel pane)
     {
         if (!ConPtySessions.Contains(pane)) return;
         pane.ErrorReported -= OnConPtyPaneError;
-        pane.CloseRequested -= CloseConPtySession;
+        pane.CloseRequested -= OnPaneCloseRequested;
         pane.SubmitForReviewRequested -= OnPaneSubmitForReview;
+        pane.SessionDiedAfterStartup -= OnPaneSessionDied;
+        pane.AbandonRunRequested -= OnPaneAbandonRun;
         ConPtySessions.Remove(pane);
         pane.Dispose();
     }
@@ -500,13 +610,17 @@ public sealed partial class MissionControlViewModel : ViewModelBase, IDisposable
         _worker.TaskUpdatedEvent -= _onTaskUpdated;
         _worker.ConnectionRestoredEvent -= _onConnectionRestored;
         _worker.HandoffRequestedEvent -= _onHandoffRequested;
+        _worker.ListHandlerStartRequestedEvent -= _onListHandlerStartRequested;
+        _worker.HandlerUsageWarningEvent -= _onHandlerUsageWarning;
         ConPtySessions.CollectionChanged -= OnConPtySessionsChanged;
         Panes.CollectionChanged -= OnPanesChanged;
         foreach (var c in ConPtySessions.ToList())
         {
             c.ErrorReported -= OnConPtyPaneError;
-            c.CloseRequested -= CloseConPtySession;
+            c.CloseRequested -= OnPaneCloseRequested;
             c.SubmitForReviewRequested -= OnPaneSubmitForReview;
+            c.SessionDiedAfterStartup -= OnPaneSessionDied;
+            c.AbandonRunRequested -= OnPaneAbandonRun;
             c.Dispose();
         }
         ConPtySessions.Clear();

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

@@ -1,3 +1,5 @@
+using System;
+using System.Diagnostics;
 using System.IO;
 using System.Reflection;
 using ClaudeDo.Data;
@@ -10,8 +12,14 @@ namespace ClaudeDo.Ui.ViewModels.Modals;
 
 public sealed partial class AboutModalViewModel : ViewModelBase
 {
+    // MinVer sets AssemblyVersion to {Major}.0.0.0 for binding compat — Assembly.GetName().Version
+    // shows "2.0.0" no matter the release. FileVersion carries the real Major.Minor.Patch.
     public string AppVersion { get; } =
-        Assembly.GetExecutingAssembly().GetName().Version?.ToString(3) ?? "0.0.0";
+        Version.TryParse(
+            FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion,
+            out var version)
+            ? version.ToString(3)
+            : "0.0.0";
     public string DataFolderPath { get; } = Paths.AppDataRoot();
     public string LogsFolderPath { get; } = Path.Combine(Paths.AppDataRoot(), "logs");
     public string WorkerConfigPath { get; } = Path.Combine(Paths.AppDataRoot(), "worker.config.json");

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

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using ClaudeDo.Ui.Localization;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+
+namespace ClaudeDo.Ui.ViewModels.Modals;
+
+/// <summary>One cheat sheet: title from the file's leading <c># </c> heading, body is the rest.</summary>
+public sealed record CheatSheet(string Key, string Title, string Body);
+
+/// <summary>
+/// Backs the non-modal cheat-sheet window (Help → Cheat Sheets). Content lives as markdown
+/// under <c>Assets/CheatSheets/*.md</c> (embedded resources) and is rendered by the existing
+/// <c>MarkdownView</c>,
+/// so a new sheet is a new file — but the key list here stays explicit to keep the order
+/// deterministic and a missing resource visible instead of silently absent.
+/// </summary>
+public partial class CheatSheetsViewModel : ViewModelBase
+{
+    private static readonly string[] Keys =
+        ["git", "conventional-commits", "claude-cli", "claude-config", "dotnet-cli", "powershell"];
+
+    public ObservableCollection<CheatSheet> Sheets { get; } = [];
+
+    [ObservableProperty]
+    private CheatSheet? _selectedSheet;
+
+    /// <summary>Keeps the window above the shell so it can sit docked at a screen edge.</summary>
+    [ObservableProperty]
+    private bool _isPinned;
+
+    public Action? CloseAction { get; set; }
+
+    public CheatSheetsViewModel()
+    {
+        foreach (var key in Keys) Sheets.Add(Load(key));
+        SelectedSheet = Sheets.FirstOrDefault();
+    }
+
+    /// <summary>Preselects a sheet by key; unknown keys keep the current selection.</summary>
+    public void Select(string key)
+    {
+        var sheet = Sheets.FirstOrDefault(s => s.Key == key);
+        if (sheet is not null) SelectedSheet = sheet;
+    }
+
+    [RelayCommand]
+    private void Close() => CloseAction?.Invoke();
+
+    private static CheatSheet Load(string key)
+    {
+        var assembly = typeof(CheatSheetsViewModel).Assembly;
+        // Match by suffix rather than composing the logical name from RootNamespace — the
+        // prefix is a build detail, and a rename shouldn't silently blank the sheet.
+        var name = assembly.GetManifestResourceNames()
+            .FirstOrDefault(n => n.EndsWith($".CheatSheets.{key}.md", StringComparison.Ordinal));
+        var stream = name is null ? null : assembly.GetManifestResourceStream(name);
+        if (stream is null)
+            return new CheatSheet(key, key, Loc.T("modals.cheatSheets.missing", $"{key}.md"));
+
+        using var reader = new StreamReader(stream);
+        var text = reader.ReadToEnd().Replace("\r\n", "\n");
+
+        // The window shows the title in its own selector, so strip the leading heading
+        // rather than rendering it a second time inside the body.
+        var lines = new List<string>(text.Split('\n'));
+        var title = key;
+        var first = lines.FindIndex(l => !string.IsNullOrWhiteSpace(l));
+        if (first >= 0 && lines[first].StartsWith("# ", StringComparison.Ordinal))
+        {
+            title = lines[first][2..].Trim();
+            lines.RemoveRange(0, first + 1);
+        }
+        return new CheatSheet(key, title, string.Join('\n', lines).Trim());
+    }
+}

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

@@ -26,12 +26,24 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
     // True after the list was deleted, so the caller reloads the list nav instead of refreshing the row.
     public bool Deleted { get; private set; }
 
+    // False when the modal closed via Cancel or the window chrome — CreateListAsync uses this to
+    // roll the pre-created row back instead of leaving an untitled empty list behind.
+    public bool Saved { get; private set; }
+
     // Wired by the view to prompt yes/no before deleting and to surface a blocking-FK error.
     public Func<string, Task<bool>>? ConfirmAsync { get; set; }
     public Func<string, Task>? ShowErrorAsync { get; set; }
 
+    // Mirrors UsageMonitorModalViewModel.ErrorReported — the caller wires this into FlashFooterError.
+    public event Action<string>? ErrorReported;
+
     [ObservableProperty] private string _name = "";
     [ObservableProperty] private string _workingDir = "";
+    // Recomputed whenever WorkingDir changes (typing or Browse) — RepoScanner.IsRepo is the same
+    // check RepoImport uses, so a folder either scans in there or warns here, never neither.
+    [ObservableProperty]
+    [NotifyCanExecuteChangedFor(nameof(SaveCommand))]
+    private string _workingDirWarning = "";
     [ObservableProperty] private string _defaultCommitType = CommitTypeRegistry.DefaultType;
     // A manual list holds reminders: tasks created here start out manual (TaskEntity.IsManual).
     [ObservableProperty] private bool _isManual;
@@ -41,13 +53,62 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
     // Optional post-merge verification command (build/test), run in WorkingDir after a merge
     // lands; a non-zero exit keeps the task out of Done instead of silently reporting merged.
     [ObservableProperty] private string _verifyCommand = "";
+    // Per-list opt-in for PowerUse. A handler run on this list only goes unattended (no questions,
+    // harvests new work, longer handoff chain) when this AND the global switch in Settings →
+    // Execution are both on. Off by default — the global switch alone must never change a list's behaviour.
+    [ObservableProperty] private bool _powerUseAllowed;
     // Dropdown hidden entirely when no ticket-system base URL is configured (Settings → Files tab).
     // Icon key into the UI icon library (IconKeyConverter -> "Icon.<key>" StreamGeometry).
     [ObservableProperty] private string _icon = DefaultIcon;
-    [ObservableProperty] private bool _ticketsAvailable;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(ShowTicketProject))]
+    private bool _ticketsAvailable;
+
+    /// <summary>The dropdown needs a configured ticket system *and* a list — folders link to nothing.</summary>
+    public bool ShowTicketProject => TicketsAvailable && !IsFolder;
+
+    // ---- Folder mode ----
+    // A folder is a sidebar grouping, not a list: it carries only a name and an icon, so every
+    // other field/section collapses. Reached two ways — the "create a folder instead" toggle in
+    // the create flow (FolderId still null), and editing an existing folder (FolderId set).
+    // There is no list <-> folder conversion: the toggle is offered on create only.
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HeaderTitle))]
+    [NotifyPropertyChangedFor(nameof(DeleteLabel))]
+    [NotifyPropertyChangedFor(nameof(ShowTicketProject))]
+    private bool _isFolder;
+
+    /// <summary>True only while creating — an existing list can't become a folder or back.</summary>
+    [ObservableProperty] private bool _canToggleFolder;
+
+    private string? _folderId;
+
+    // Resolved rather than a {loc:Tr} key because the text depends on IsFolder.
+    public string HeaderTitle => Loc.T(IsFolder ? "modals.listSettings.folderTitle" : "modals.listSettings.title");
+
+    public string DeleteLabel => Loc.T(IsFolder ? "modals.listSettings.deleteFolder" : "modals.listSettings.deleteList");
     [ObservableProperty] private TicketProjectOption? _selectedTicketProject;
     public ObservableCollection<TicketProjectOption> TicketProjects { get; } = new();
 
+    // Gates Save/Delete while the core fields (name/agent/verify command) are still loading, so a
+    // save can't land before they're populated and clobber the list_config row with blanks. Ticket
+    // projects load separately (see LoadTicketProjectsAsync) and are NOT covered by this — Save's
+    // own tri-state handles that case instead.
+    [ObservableProperty]
+    [NotifyCanExecuteChangedFor(nameof(SaveCommand))]
+    [NotifyCanExecuteChangedFor(nameof(DeleteCommand))]
+    private bool _isLoading;
+
+    // Set when the core load (name/agent/verify command) threw — keeps Save gated even after
+    // IsLoading resets to false in LoadAsync's finally, so a failed load can't clobber the
+    // stored config with blank fields.
+    private bool _loadFailed;
+
+    // True once GetTicketProjectsAsync has completed successfully for the current load — Save
+    // only writes an explicit TicketProjectId when this is true, so a slow/unreachable ticket
+    // system leaves the stored link untouched instead of wiping it to "none".
+    private bool _ticketProjectsLoaded;
+
     public ObservableCollection<string> CommitTypeOptions { get; } = new(CommitTypeRegistry.Types);
 
     public const string DefaultIcon = "Folder";
@@ -83,6 +144,36 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
         Agent = new AgentConfigEditorViewModel(worker, AgentConfigScope.List);
     }
 
+    // Fires the load without blocking the caller, so the modal window can be shown right away
+    // instead of appearing only after seven serial hub round-trips (one of them a 10s-timeout
+    // ticket-system HTTP call) have finished — same pattern as UsageMonitorModalViewModel.BeginLoad.
+    public void BeginLoad(
+        string listId,
+        string name,
+        string? workingDir,
+        string defaultCommitType,
+        bool isManual = false,
+        bool findingsTracked = false,
+        string? icon = null,
+        bool canToggleFolder = false)
+    {
+        CanToggleFolder = canToggleFolder;
+        _ = LoadAsync(listId, name, workingDir, defaultCommitType, isManual, findingsTracked, icon);
+    }
+
+    /// <summary>
+    /// Opens the modal on an existing folder: name + icon only, no list config to load and
+    /// nothing to fetch from the worker, so this needs no async counterpart.
+    /// </summary>
+    public void BeginLoadFolder(string folderId, string name, string? icon)
+    {
+        _folderId = folderId;
+        IsFolder = true;
+        CanToggleFolder = false;
+        Name = name;
+        Icon = IconOptions.Contains(icon) ? icon! : DefaultIcon;
+    }
+
     public async Task LoadAsync(
         string listId,
         string name,
@@ -93,44 +184,100 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
         string? icon = null,
         CancellationToken ct = default)
     {
-        ListId = listId;
-        Name = name;
-        IsManual = isManual;
-        FindingsTracked = findingsTracked;
-        // An unknown/legacy key would leave the picker with no selection and silently reset the
-        // icon on the next save — fall back to the default instead.
-        Icon = IconOptions.Contains(icon) ? icon! : DefaultIcon;
-        WorkingDir = workingDir ?? "";
-        DefaultCommitType = string.IsNullOrWhiteSpace(defaultCommitType) ? CommitTypeRegistry.DefaultType : defaultCommitType;
-
-        await Agent.LoadForListAsync(listId, ct);
-        var cfg = await _worker.GetListConfigAsync(listId);
-        VerifyCommand = cfg?.VerifyCommand ?? "";
-
-        var ticketSettings = TicketSettingsTabViewModel.FeatureEnabled
-            ? await _worker.GetTicketSettingsAsync()
-            : null;
-        TicketsAvailable = !string.IsNullOrWhiteSpace(ticketSettings?.ApiBaseUrl);
-        TicketProjects.Clear();
-        if (TicketsAvailable)
+        ListConfigDto? cfg = null;
+        IsLoading = true;
+        _loadFailed = false;
+        try
         {
+            ListId = listId;
+            Name = name;
+            IsManual = isManual;
+            FindingsTracked = findingsTracked;
+            // An unknown/legacy key would leave the picker with no selection and silently reset the
+            // icon on the next save — fall back to the default instead.
+            Icon = IconOptions.Contains(icon) ? icon! : DefaultIcon;
+            WorkingDir = workingDir ?? "";
+            DefaultCommitType = string.IsNullOrWhiteSpace(defaultCommitType) ? CommitTypeRegistry.DefaultType : defaultCommitType;
+
+            await Agent.LoadForListAsync(listId, ct);
+            cfg = Agent.LastLoadedListConfig;
+            VerifyCommand = cfg?.VerifyCommand ?? "";
+            PowerUseAllowed = cfg?.PowerUseAllowed ?? false;
+        }
+        catch (Exception ex)
+        {
+            // BeginLoad fires this without awaiting it — catching here (instead of letting it
+            // propagate) turns what would be an unobserved task exception, with the modal stuck
+            // open and every field blank, into a reported error and a locked Save button.
+            _loadFailed = true;
+            ErrorReported?.Invoke(Loc.T("vm.listSettings.loadFailed", ex.Message));
+        }
+        finally { IsLoading = false; }
+
+        if (_loadFailed) return;
+
+        // Deliberately NOT awaited: an unreachable ticket system (10s HTTP timeout) must not hold
+        // up the rest of the modal. The dropdown just stays empty until this finishes.
+        _ = LoadTicketProjectsAsync(cfg?.TicketProjectId);
+    }
+
+    private async Task LoadTicketProjectsAsync(int? existingTicketProjectId)
+    {
+        _ticketProjectsLoaded = false;
+        TicketProjects.Clear();
+        try
+        {
+            var ticketSettings = TicketSettingsTabViewModel.FeatureEnabled
+                ? await _worker.GetTicketSettingsAsync()
+                : null;
+            TicketsAvailable = !string.IsNullOrWhiteSpace(ticketSettings?.ApiBaseUrl);
+            if (!TicketsAvailable)
+            {
+                SelectedTicketProject = null;
+                return;
+            }
+
             TicketProjects.Add(new TicketProjectOption(0, Loc.T("vm.listSettings.ticketProjectNone")));
             foreach (var p in await _worker.GetTicketProjectsAsync())
                 TicketProjects.Add(new TicketProjectOption(p.Id, $"{p.DepartmentName} / {p.Title}"));
 
-            SelectedTicketProject = cfg?.TicketProjectId is int id
+            SelectedTicketProject = existingTicketProjectId is int id
                 ? TicketProjects.FirstOrDefault(t => t.Id == id) ?? TicketProjects[0]
                 : TicketProjects[0];
+            _ticketProjectsLoaded = true;
         }
-        else
+        catch (Exception ex)
         {
-            SelectedTicketProject = null;
+            // Ticket system unreachable/slow — leave the dropdown as-is. Save's tri-state (below)
+            // skips writing TicketProjectId when _ticketProjectsLoaded is false, so the stored
+            // link survives instead of being wiped to "none".
+            ErrorReported?.Invoke(Loc.T("vm.listSettings.ticketProjectsLoadFailed", ex.Message));
         }
     }
 
-    [RelayCommand]
+    private bool CanSave() => !IsLoading && !_loadFailed && (IsFolder || string.IsNullOrEmpty(WorkingDirWarning));
+    private bool CanDelete() => !IsLoading;
+
+    // A manual list without a WorkingDir is untouched (empty is always valid) — this only fires
+    // for the "picked a folder that turns out not to be a repo" case the audit found: it would
+    // otherwise only surface as a Failed task the first time the worker tries to use it.
+    partial void OnWorkingDirChanged(string value)
+    {
+        if (string.IsNullOrWhiteSpace(value)) { WorkingDirWarning = ""; return; }
+        WorkingDirWarning = !Directory.Exists(value)
+            ? Loc.T("vm.listSettings.workingDirMissing")
+            : RepoScanner.IsRepo(value) ? "" : Loc.T("vm.listSettings.workingDirNotRepo");
+    }
+
+    [RelayCommand(CanExecute = nameof(CanSave))]
     private async Task SaveAsync()
     {
+        if (IsFolder)
+        {
+            await SaveFolderAsync();
+            return;
+        }
+
         await _worker.UpdateListAsync(new UpdateListDto(
             ListId,
             string.IsNullOrWhiteSpace(Name) ? Loc.T("vm.listSettings.untitled") : Name,
@@ -140,25 +287,66 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
             FindingsTracked,
             Icon));
 
-        // Tri-state: dropdown never shown (no base URL) -> null, leave the stored link alone.
-        // Dropdown shown -> always an explicit value, 0 for "— none —" to actively clear it.
-        // Never null here, or an explicit unlink would silently fail to reach the worker.
-        var ticketProjectId = TicketsAvailable ? (SelectedTicketProject?.Id ?? 0) : (int?)null;
+        // Tri-state: dropdown never shown (no base URL), or ticket projects failed/never loaded
+        // (e.g. an unreachable ticket system) -> null, leave the stored link alone. Dropdown shown
+        // and loaded -> always an explicit value, 0 for "— none —" to actively clear it. Never
+        // null in that case, or an explicit unlink would silently fail to reach the worker.
+        var ticketProjectId = TicketsAvailable && _ticketProjectsLoaded ? (SelectedTicketProject?.Id ?? 0) : (int?)null;
 
+        // Always explicit (never null) — this modal owns the checkbox, so unchecking it has to reach
+        // the worker as a real false rather than a "leave it alone".
         await Agent.SaveAsync(
             string.IsNullOrWhiteSpace(VerifyCommand) ? null : VerifyCommand,
-            ticketProjectId);
+            ticketProjectId,
+            PowerUseAllowed);
 
+        Saved = true;
         CloseAction?.Invoke();
     }
 
-    [RelayCommand]
+    private async Task SaveFolderAsync()
+    {
+        var name = string.IsNullOrWhiteSpace(Name) ? Loc.T("vm.listSettings.untitled") : Name;
+        await using var ctx = await _dbFactory.CreateDbContextAsync();
+        var lists = new ListRepository(ctx);
+
+        if (_folderId is null)
+        {
+            await lists.AddFolderAsync(new ListFolderEntity
+            {
+                Id = Guid.NewGuid().ToString("N"),
+                Name = name,
+                Icon = Icon,
+                CreatedAt = DateTime.UtcNow,
+            });
+            // The create flow pre-creates a list row for this modal to save against; a folder
+            // doesn't need it. Deleted=true (it genuinely is) makes the caller do a full reload,
+            // which is what picks the new folder up.
+            await lists.DeleteAsync(ListId);
+            Deleted = true;
+        }
+        else
+        {
+            await lists.RenameFolderAsync(_folderId, name, Icon);
+        }
+
+        Saved = true;
+        CloseAction?.Invoke();
+    }
+
+    [RelayCommand(CanExecute = nameof(CanDelete))]
     private async Task DeleteAsync()
     {
+        if (IsFolder)
+        {
+            await DeleteFolderAsync();
+            return;
+        }
+
         var displayName = string.IsNullOrWhiteSpace(Name) ? Loc.T("vm.listSettings.untitled") : Name;
         if (ConfirmAsync is not null)
         {
-            var ok = await ConfirmAsync($"Delete list \"{displayName}\" and all its tasks? This cannot be undone.");
+            var ok = await ConfirmAsync(Loc.T("vm.listSettings.confirmDeleteList", displayName));
             if (!ok) return;
         }
 
@@ -175,7 +363,35 @@ public sealed partial class ListSettingsModalViewModel : ViewModelBase
                 || ex.InnerException?.Message.Contains("FOREIGN KEY", StringComparison.OrdinalIgnoreCase) == true))
         {
             if (ShowErrorAsync is not null)
-                await ShowErrorAsync("This list has planning sessions with child tasks. Discard those first, then delete the list.");
+                await ShowErrorAsync(Loc.T("vm.listSettings.deleteBlockedPlanning"));
+            return;
+        }
+
+        Deleted = true;
+        CloseAction?.Invoke();
+    }
+
+    private async Task DeleteFolderAsync()
+    {
+        // Create mode with the folder toggle on: nothing has been written yet, so this is a cancel
+        // — and the caller's rollback drops the pre-created list row.
+        if (_folderId is null) { CloseAction?.Invoke(); return; }
+
+        var displayName = string.IsNullOrWhiteSpace(Name) ? Loc.T("vm.listSettings.untitled") : Name;
+        if (ConfirmAsync is not null)
+        {
+            var ok = await ConfirmAsync(Loc.T("vm.listSettings.confirmDeleteFolder", displayName));
+            if (!ok) return;
+        }
+
+        try
+        {
+            await using var ctx = await _dbFactory.CreateDbContextAsync();
+            await new ListRepository(ctx).DeleteFolderAsync(_folderId);
+        }
+        catch (Exception ex)
+        {
+            ErrorReported?.Invoke(ex.Message);
             return;
         }
 

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

@@ -67,6 +67,15 @@ public sealed partial class MergeHelperSelectionModalViewModel : ViewModelBase
 
     public ObservableCollection<MergeHelperTaskRowViewModel> Tasks { get; } = new();
 
+    /// <summary>Model choices for the triage session. Only opus/fable are offered on purpose —
+    /// triage is the dedupe/refine leverage point; cheaper models aren't worth a picker slot.</summary>
+    public IReadOnlyList<string> ModelOptions { get; } = new[] { "opus", "fable" };
+
+    [ObservableProperty] private string _selectedModel = Data.Models.ModelRegistry.HandlerTriageAlias;
+
+    /// <summary>Hidden in review mode — those runs start directly at the merge phase, no triage.</summary>
+    public bool ShowModelPicker => !_reviewMode;
+
     [ObservableProperty] private string _scopeLabel = "";
 
     public bool HasTasks => Tasks.Count > 0;
@@ -100,6 +109,7 @@ public sealed partial class MergeHelperSelectionModalViewModel : ViewModelBase
     {
         _reviewMode = true;
         ScopeLabel = Loc.T("modals.mergeHelper.scopeReview");
+        OnPropertyChanged(nameof(ShowModelPicker));
     }
 
     /// <summary>Groups a confirmed review-mode selection by owning list, preserving row order —

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

@@ -31,6 +31,10 @@ public sealed partial class MergeModalViewModel : ViewModelBase
     [ObservableProperty] private string? _warningMessage;
     [ObservableProperty] private string? _successMessage;
     [ObservableProperty][NotifyCanExecuteChangedFor(nameof(SubmitCommand))] private bool _hasConflict;
+
+    /// The merge was refused because the target working dir is dirty — offer the stash retry
+    /// instead of dead-ending on the error text.
+    [ObservableProperty] private bool _showStashRetry;
     [ObservableProperty] private IReadOnlyList<string> _conflictFiles = Array.Empty<string>();
 
     public Action? CloseAction { get; set; }
@@ -72,6 +76,14 @@ public sealed partial class MergeModalViewModel : ViewModelBase
             SelectedBranch = Branches.Contains(targets.DefaultBranch)
                 ? targets.DefaultBranch
                 : Branches.FirstOrDefault();
+
+            // Known dirty before anyone clicks Merge — offer the stash retry right away instead
+            // of making the user hit the "dirty_target" refusal first.
+            if (targets.TargetDirty)
+            {
+                WarningMessage = Loc.T("vm.merge.targetDirty");
+                ShowStashRetry = true;
+            }
         }
         catch (Exception ex)
         {
@@ -84,22 +96,29 @@ public sealed partial class MergeModalViewModel : ViewModelBase
         !IsBusy && !HasConflict && !string.IsNullOrWhiteSpace(SelectedBranch);
 
     [RelayCommand(CanExecute = nameof(CanSubmit))]
-    private async Task SubmitAsync()
+    private Task SubmitAsync() => RunMergeAsync(autostash: false);
+
+    /// Retry after "dirty_target": git stashes the target working tree's uncommitted changes,
+    /// merges, and restores them afterwards.
+    [RelayCommand(CanExecute = nameof(CanSubmit))]
+    private Task StashAndMergeAsync() => RunMergeAsync(autostash: true);
+
+    private async Task RunMergeAsync(bool autostash)
     {
         if (string.IsNullOrWhiteSpace(SelectedBranch)) return;
         IsBusy = true;
         ErrorMessage = null;
         WarningMessage = null;
         SuccessMessage = null;
+        ShowStashRetry = false;
         // Subscribed only for the duration of the call: the worker's broadcast reaches every
         // client, and a transient VM left on that event would outlive its window.
         ProgressMessage = Loc.T("vm.merge.progressMerging");
-        _worker.MergeProgressEvent += OnMergeProgress;
         _worker.OperationProgressEvent += OnOperationProgress;
         try
         {
             var result = await _worker.MergeTaskAsync(
-                TaskId, SelectedBranch!, RemoveWorktree, CommitMessage);
+                TaskId, SelectedBranch!, RemoveWorktree, CommitMessage, autostash);
 
             switch (result.Status)
             {
@@ -131,6 +150,12 @@ public sealed partial class MergeModalViewModel : ViewModelBase
                     // point of the gate.
                     ErrorMessage = result.ErrorMessage ?? Loc.T("vm.merge.verifyFailed");
                     break;
+                case "dirty_target":
+                    // Nothing landed -- the target working dir has uncommitted changes. Offer the
+                    // stash retry; git restores the changes after the merge.
+                    ErrorMessage = result.ErrorMessage ?? Loc.T("vm.merge.dirtyTarget");
+                    ShowStashRetry = true;
+                    break;
                 case "untracked_collision":
                     // Nothing landed -- the merge was refused before touching the repo. Show the
                     // real message (it names the colliding path and size); the locale string is
@@ -148,34 +173,23 @@ public sealed partial class MergeModalViewModel : ViewModelBase
         }
         finally
         {
-            _worker.MergeProgressEvent -= OnMergeProgress;
             _worker.OperationProgressEvent -= OnOperationProgress;
             ProgressMessage = null;
             IsBusy = false;
         }
     }
 
-    private void OnMergeProgress(string taskId, string phase, int elapsedSeconds)
-    {
-        if (taskId != TaskId) return;
-        // Rebasing is handled by OnOperationProgress (needs the branch total, which this
-        // elapsed-seconds-only forwarder drops) -- don't overwrite it with the generic fallback.
-        if (phase == MergePhaseRebasing) return;
-        ProgressMessage = phase switch
-        {
-            MergePhaseVerifying => Loc.T("vm.merge.progressVerifying", FormatElapsed(elapsedSeconds)),
-            _ => Loc.T("vm.merge.progressMerging"),
-        };
-    }
-
-    // Separate event: MergeProgressEvent forwards elapsed-seconds-only (verifying), but the
-    // rebase phase needs the branch count too, which only rides the untrimmed OperationProgress.
     private void OnOperationProgress(string opKey, string phase, int current, int total)
     {
-        if (opKey != TaskId || phase != MergePhaseRebasing) return;
-        ProgressMessage = total > 0
-            ? $"{Loc.T("ops.worker.rebasingAfterMerge")} ({current}/{total})"
-            : Loc.T("ops.worker.rebasingAfterMerge");
+        if (opKey != TaskId) return;
+        ProgressMessage = phase switch
+        {
+            MergePhaseRebasing => total > 0
+                ? $"{Loc.T("ops.worker.rebasingAfterMerge")} ({current}/{total})"
+                : Loc.T("ops.worker.rebasingAfterMerge"),
+            MergePhaseVerifying => Loc.T("vm.merge.progressVerifying", FormatElapsed(current)),
+            _ => Loc.T("vm.merge.progressMerging"),
+        };
     }
 
     /// Mirrors TaskMergeService.PhaseVerifying — a hub payload token, not a display string.

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

@@ -44,7 +44,7 @@ public sealed partial class RepoImportModalViewModel : ViewModelBase
 
     public int CreateCount => Repos.Count(r => r.IsChecked && !r.AlreadyAdded);
     public bool CanCreate => CreateCount > 0;
-    public string CreateButtonText => $"Create {CreateCount} list(s)";
+    public string CreateButtonText => Loc.T("vm.repoImport.createButton", CreateCount);
     public bool HasFolders => _folders.Count > 0;
 
     public RepoImportModalViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, IWorkerClient workerClient)

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

@@ -30,6 +30,7 @@ public sealed partial class FilesSettingsTabViewModel : ViewModelBase
     public string RetryPromptPath { get; } = PromptFiles.PathFor(PromptKind.Retry);
     public string DailyPrepPromptPath { get; } = PromptFiles.PathFor(PromptKind.DailyPrep);
     public string WeeklyReportPromptPath { get; } = PromptFiles.PathFor(PromptKind.WeeklyReport);
+    public string PowerUsePromptPath { get; } = PromptFiles.PathFor(PromptKind.PowerUseAddendum);
 
     public ObservableCollection<CustomizedPromptRowViewModel> CustomizedPrompts { get; } = new();
 

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

@@ -27,6 +27,18 @@ public sealed partial class GeneralSettingsTabViewModel : ViewModelBase
     // Off by default: auto-continues a usage-limit-failed task once the 5h window resets, and
     // wakes a gate-blocked queue exactly at that reset time instead of only the 30s backstop.
     [ObservableProperty] private bool _autoContinueOnUsageLimit;
+    // Cap on a list-handler run's wait<->merge handoff chain. 4 = two merge rounds (the long-standing
+    // default); raise it for runs meant to keep going for hours. Bounds a runaway chain, so never 0.
+    [ObservableProperty] private int _listHandlerMaxHandoffs = 4;
+    // PowerUse master switch: a handler run spends the rest of the window unattended. On its own it
+    // changes nothing — the run's LIST must also opt in (list settings → PowerUse).
+    [ObservableProperty] private bool _powerUseEnabled;
+    // Optional local-time window (HH:mm) narrowing when PowerUse applies; both blank = round the
+    // clock. Unparseable input is normalized to null on save, same as the worker does.
+    [ObservableProperty] private string? _powerUseWindowStart;
+    [ObservableProperty] private string? _powerUseWindowEnd;
+    // 5h-usage percentage at which a PowerUse handler session hands off. Clamped 50..99.
+    [ObservableProperty] private int _powerUseHandoffPct = 95;
     // Newline-separated path prefixes excluded from the weekly report.
     [ObservableProperty] private string _reportExcludedPaths = @"C:\Private";
     // 0=Sunday..6=Saturday (System.DayOfWeek); default Wednesday.
@@ -107,8 +119,13 @@ public sealed partial class GeneralSettingsTabViewModel : ViewModelBase
         foreach (var row in ModelPresets)
             if (row.MaxTurns is < 1 or > 200)
                 return $"Max turns for {row.Model} must be between 1 and 200.";
+        if (!IsValidWindowBound(PowerUseWindowStart) || !IsValidWindowBound(PowerUseWindowEnd))
+            return Loc.T("settings.general.powerUseWindowInvalid");
         return null;
     }
+
+    private static bool IsValidWindowBound(string? value)
+        => string.IsNullOrWhiteSpace(value) || PowerUseWindow.Parse(value) is not null;
 }
 
 /// <summary>One row of the per-model preset table. Single consumer, so it lives here.</summary>