feat(logging): tag UI task actions with TaskId + debug trace lines

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

CLAUDE.md

@@ -44,16 +44,35 @@ Two-process system communicating over SignalR (`127.0.0.1:47821`):
 - Views use compiled bindings (`x:DataType`)
 - ViewModels use `[ObservableProperty]` and `[RelayCommand]` source generators
 
+## Working style (autonomous)
+
+For any non-trivial feature, bug, or change, run this loop without hand-holding:
+
+1. **Brainstorm first** (superpowers:brainstorming) — ask clarifying questions one at a time, propose 2–3 options with a recommendation, present a short design, get approval before building.
+2. **Write it down** — a spec in `docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md` and a step-by-step plan in `docs/superpowers/plans/` (superpowers:writing-plans). Commit the docs.
+3. **Implement on main** with superpowers:subagent-driven-development — one subagent per task, TDD, build + test, commit per task with Conventional Commits. Once the plan is approved, do NOT pause for re-approval between tasks; only stop for genuine decisions or blockers.
+4. **Trust but verify** — read each subagent's diff and run the build/tests yourself before marking a task done.
+5. **Bugs** → superpowers:systematic-debugging (find the root cause before any fix).
+6. **Never claim UI works without running it** — explicitly flag visual-verification gaps for the user to check.
+
+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 instead.
+`dotnet build ClaudeDo.slnx` requires .NET 9; on .NET 8 build individual projects with `-c Release` (a running Worker locks the `Debug` output).
 
 ```bash
-dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj      # pulls in Ui + Data
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release      # pulls in Ui + Data
-dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
-dotnet test tests/ClaudeDo.Worker.Tests                # also: Data.Tests, Ui.Tests, Installer.Tests, Releases.Tests
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release   # also: Data.Tests, Ui.Tests, Localization.Tests, Installer.Tests, Releases.Tests
 ```
 
+### 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/stroke icons must be authored as filled geometry, or rendered with a stroked `Path` — otherwise they render invisible.
+- **Localization:** `locales/en.json` and `locales/de.json` keys must stay in parity (Localization.Tests enforces it).
+- **Test fakes:** changing `IWorkerClient` / `WorkerHub` / ViewModel constructors breaks hand-rolled fakes in both test projects — update them.
+
 ## Docs
 
 - `docs/plan.md` — full architecture and design spec

ClaudeDo.slnx

@@ -6,6 +6,8 @@
     <Project Path="src/ClaudeDo.Worker/ClaudeDo.Worker.csproj" />
     <Project Path="src/ClaudeDo.Installer/ClaudeDo.Installer.csproj" />
     <Project Path="src/ClaudeDo.Releases/ClaudeDo.Releases.csproj" />
+    <Project Path="src/ClaudeDo.Localization/ClaudeDo.Localization.csproj" />
+    <Project Path="src/ClaudeDo.Logging/ClaudeDo.Logging.csproj" />
   </Folder>
   <Folder Name="/tests/">
     <Project Path="tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj" />
@@ -13,5 +15,6 @@
     <Project Path="tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj" />
     <Project Path="tests/ClaudeDo.Installer.Tests/ClaudeDo.Installer.Tests.csproj" />
     <Project Path="tests/ClaudeDo.Releases.Tests/ClaudeDo.Releases.Tests.csproj" />
+    <Project Path="tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj" />
   </Folder>
 </Solution>

docs/mailbox-proposal.md

@@ -1,6 +1,10 @@
 # Task Mailbox — Push Messages Into Running Sessions
 
-**Status:** proposal
+**Status:** PARKED (2026-06-04) — not building this.
+**Why parked:** The generic Claude-Mailbox plugin (the `mcp__mailbox__*` tools used in normal sessions) already covers the core need — cross-session messaging, inbox checks, a sender — at the harness level for any project. Integrating it directly into ClaudeDo (task/worktree-scoped inboxes, per-worktree CLAUDE.md + hook seeding, UI badges, `send_to_peer`) is a sizable build (migration + MCP tools + SignalR + UI + hooks) for marginal gain over the plugin. Revisit only if the generic plugin proves insufficient for the parallel-session workflow. The original proposal is kept below for reference.
+
+---
+
 **Context:** the user runs parallel Claude sessions (e.g. backend + frontend) and wants to push messages into a session while it's busy inside a subagent. A shared folder works for one-offs; this turns it into a first-class ClaudeDo feature so every future parallel-session project gets it for free.
 
 ## Problem

docs/open.md

@@ -1,286 +1,30 @@
 # ClaudeDo — Offene Punkte
 
-Stand: 2026-04-30. Neu erstellt nach Code-Audit gegen `plan.md`, `improvement-plan.md` und `mailbox-proposal.md`.
+Stand: 2026-06-04. **Nur noch offene Punkte.** Was erledigt ist, steht in den Commits und im Code — nicht hier.
-
-Die alte Version dieses Dokuments war auf 2026-04-13 ("nach Slice F") datiert und ignorierte die seither gelandeten Slices (Planning Sessions, Prime Claude, Self-Update, Externe MCP-Tools, editierbare Status/Tags, BlockedBy-Chains). Diese Version trennt sauber zwischen **erledigt**, **teilweise**, **offen** — und listet das, was inzwischen gebaut wurde, explizit als „shipped" auf, damit es nicht verloren geht.
-
-Legende: ✅ DONE — 🟡 PARTIAL — ⬜ OPEN — ⛔ DROPPED
 
 ---
 
-## 0. Was seit dem 2026-04-13 dazugekommen ist
+## Manuelle Verifikation (offen)
 
-Diese Slices gab es im alten Dokument noch nicht (oder nur als Platzhalter). Sie sind **fertig im Code**, brauchen aber jeweils noch ein paar Polish-Punkte (siehe Sektion 2/3).
+Kein Code-Aufwand, nur Durchspielen mit explizit notiertem Pass-Kriterium. Der Großteil der Pipeline ist laut User bereits in der Praxis getestet; hier das, was noch ein falsifizierbares Observable braucht.
 
-| Slice | Worker-Anker | UI-Anker | Status |
+- **Worktree-Pipeline:**
-|---|---|---|---|
+  - Worktree-Happy-Path → `worktrees.state='active'`, `head_commit` gesetzt, `diff_stat` non-empty, Branch `claudedo/<id>` auf Disk.
-| **Planning Sessions** (Plan B+C) | `Planning/PlanningSessionManager`, `PlanningChainCoordinator`, `PlanningMcpService` | `Views/Planning/PlanningDiffView`, `ConflictResolutionView`, `UnfinishedPlanningModalView` | ✅ Code, manuelle Verifikation siehe §1.1 |
+  - No-Changes-Run → `status='Done'`, `head_commit IS NULL`, `diff_stat IS NULL`.
-| **Prime Claude** (geplante Recurrence) | `Prime/PrimeScheduler`, `NextDueCalculator`, `PrimeRunner` | `ViewModels/Modals/PrimeClaudeTabViewModel`, `Views/Controls/ThemedDatePicker` | ✅ Code, manuelle Verifikation siehe §1.2 |
+  - Kein Git-Repo (`working_dir=C:\Temp`) → `status='Failed'`, **keine** `worktrees`-Row, Git-Fehler im Log.
-| **Self-Update System** (Gitea Releases) | — | `ClaudeDo.Releases` (`ReleaseClient`, `SelfUpdater`, `ChecksumVerifier`, `VersionComparer`), `ClaudeDo.Installer` (Pages/Steps/Core) | ✅ Code, manuelle Verifikation siehe §1.3 |
+- **Feature-Walkthroughs:** Planning-Session-Flow (Draft→Finalize→Chain), Prime/Daily-Prep-Trigger, Weekly-Report-Generierung, Self-Update (Banner → Update → „up to date").
-| **Externes MCP-Endpoint** (11 Tools für Drittsessions) | `External/ExternalMcpService` (`ListTaskLists`, `ListTasks`, `GetTask`, `AddTask`, `UpdateTask`, `UpdateTaskStatus`, `SetTaskTags`, `ListTags`, `DeleteTask`, `RunTaskNow`, `CancelTask`), `ExternalMcpAuthMiddleware` (X-ClaudeDo-Key) | — | ✅ Code, ohne Tests am Endpoint selbst |
+- **Worker-Autostart am Gerät:** Logoff/Logon-Autostart, Update-Pfad, Uninstall entfernt die Startup-`.lnk`.
-| **Editierbare Status & Tags** (entkoppelt vom `agent`-Tag) | `WorkerHub.SetTaskStatus`, `SetTaskTags`, `UpdateTaskAgentSettings`; Queue-Picker filtert nicht mehr nach `agent`-Tag | `DetailsIslandViewModel`, Status-/Tag-Kontextmenü in `TasksIslandView` | ✅ Code |
+
-| **BlockedBy-Chains** (sequenzielle Subtask-Ausführung) | `TaskStateService.BlockOn`/`UnblockAsync`, `QueuePicker` filter `BlockedByTaskId IS NULL`, `PlanningChainCoordinator.OnChildFinishedAsync` | Drittes Feld neben `Status` und `PlanningPhase` | ✅ Code, Migration `20260423154708_AddPlanningSupport` |
+## Offene Code-Punkte
-| **Worker-State-Konsolidierung** | `TaskStateService` ist alleiniger Owner von `Status`/`PlanningPhase`/`BlockedByTaskId`-Writes; `OverrideSlotService` ausgelagert; `QueueWaker` + `QueuePicker` getrennt | — | ✅ Code |
+
-| **MarkdownView / Tabbed Settings / About-Modal / Prime-Status-Footer / Doppelklick-Edit** | — | `Views/MarkdownView`, `SettingsModalView` als `TabControl`, `AboutModalView`, transient Prime-Status in Footer, `DoubleTapped` an List/Task-Rows | ✅ Code |
+- **Status-Bar Live-Update:** Prüfen, ob `RunNow`-Enable/Disable pro Task-Row bei Connection-Change sauber re-evaluiert. Connection-Status lebt in `IslandsShellViewModel` / `WorkerConnectionModalViewModel` (es gibt keinen `StatusBarViewModel` mehr). Erst messen, dann ggf. fixen. Klein.
 
 ---
 
-## 1. Verification (vor allem anderen)
+## Bewusst verworfen (nicht erneut vorschlagen)
 
-Der Großteil der Verification-Steps aus `plan.md` ist im Code abgedeckt — was fehlt ist die **manuelle Bestätigung mit explizit notiertem Pass-Kriterium**. Ohne falsifizierbare Observable produziert ein Manual-Run nur "sah ok aus".
+- **CI-Build/Test-Pipeline** — push-to-main + release-on-push deckt das ab; Tests laufen am Ende jeder Session.
-
+- **Real-`claude`-Smoke-Test als xUnit-Test** — kein Claude in `dotnet test`; bleibt manueller Check (siehe oben). Tests nutzen `FakeClaudeProcess`.
-### 1.0 Plan-Verification 1–13
+- **`architecture.md` / ADRs** — die per-Projekt-`CLAUDE.md`-Dateien sind die lebende Doku; ADRs lohnen solo nicht.
-
+- **Task-Mailbox-Integration** — geparkt; das generische `mcp__mailbox__*`-Plugin reicht (Begründung in `mailbox-proposal.md`).
-| # | Item | Status | Pass-Kriterium (was muss konkret zu sehen sein) |
+- **Tag-Negation, Tag-Multi-Select, Notes-`lists.kind`-Switch, Install-Service-Skript** — durch die aktuelle Architektur überholt (Tag-System entfernt, Notes/Autostart anders gelöst).
-|---|------|---|---|
-| 1 | Schema-Init | ✅ | `~/.todo-app/todo.db` + `*-wal` + `*-shm` existieren; EF-Migrationsverlauf in `__EFMigrationsHistory` enthält alle 8 Migrationen; Worker-Log: „listening on …" |
-| 1a | SignalR-Endpoint | ✅ | `curl http://127.0.0.1:47821/hub` → HTTP 400 (kein Handshake) |
-| 1b | Hub-Roundtrip `Ping` | 🟡 | UI-Statusbar zeigt „Connected"; `WorkerClient.PingAsync()` liefert `"pong"` (UI-Test fehlt) |
-| 2 | `claude --version` Preflight | ✅ | `Worker/Lifecycle/ClaudeCliPreflight.cs` + Wiring in `Program.cs`. Kaputter `claude_bin` → `LogCritical(...) + Environment.Exit(1)`. Skip via `CLAUDEDO_SKIP_CLI_PREFLIGHT=1`. Tests: `tests/.../Lifecycle/ClaudeCliPreflightTests.cs` |
-| 3 | Smoke-Spawn (`claude -p` Prompt „ping") | ⬜ | `task_runs`-Row mit `session_id NOT NULL`, `result` non-empty, `output_tokens > 0` |
-| 4 | E2E Happy Path (Non-Worktree) | ⬜ | Liste „Test" anlegen → Task „Schreibe ein Haiku über Intralogistik" → `tasks.status='Done'`, `tasks.result IS NOT NULL`, Logfile unter `~/.todo-app/logs/<taskId>.ndjson`, UI-Row mit Done-Badge |
-| 5 | Worktree Happy Path | ⬜ | Liste mit `working_dir` auf temp-Repo, Task mit Codeänderung → `worktrees.state='active'`, `head_commit IS NOT NULL`, `diff_stat` non-empty, Branch `claudedo/<id>` auf Disk |
-| 6 | No-Changes-Run | ⬜ | Prompt der nichts ändert → `tasks.status='Done'` aber `worktrees.head_commit IS NULL`, `diff_stat IS NULL` |
-| 7 | Kein Git-Repo | ⬜ | `working_dir=C:\Temp` (kein Repo) → `tasks.status='Failed'`, **keine** `worktrees`-Row, Worker-Log enthält Git-Fehler |
-| 8 | Merge-UI | 🟡 | `MergeTask`-Hub-Methode + `MergeModalView` vorhanden, manueller Run nicht durchgespielt → `worktrees.state='merged'`, im Ziel-Repo `git log` zeigt Commit, `git worktree list` ohne Branch |
-| 9 | Override-Parallelität | 🟡 | `OverrideSlotService`-Tests grün; UI-E2E nicht durchgespielt → `WorkerHub.GetActive` ≥ 2 Einträge bei Run+RunNow |
-| 10 | Schedule | 🟡 | `QueuePicker`-Tests grün; UI-E2E nicht → `scheduled_for=now+2min` bleibt Queued, dann automatisch Running, `started_at >= scheduled_for` |
-| 11 | Worker-Offline-Erkennung | 🟡 | `WorkerClient.OnServerConnectionClosed` + Auto-Reconnect implementiert (`WithAutomaticReconnect`); visuell prüfen: nach `taskkill` der Worker-Exe wechselt Statusbar in ≤ 5s auf „Offline", `RunNow`-Buttons disabled |
-| 12 | Live-Stream | 🟡 | `ClaudeProcess` streamt NDJSON via `TaskMessage`-Event, UI hat `LiveTail`; visuell prüfen: während Run laufen ndjson-Zeilen ein |
-| 13 | Wake-up (`WakeQueue` nach Anlage) | 🟡 | `QueueWaker.Wake()` wird bei Enqueue aufgerufen; visuell prüfen: Task wechselt in ≤ 1s auf Running (statt nach `queue_backstop_interval_ms`=30s) |
-
-**Empfohlener Sprint:** Steps 3–7 in einem Rutsch durchspielen (alles non-UI), parallel daneben 8–13 visuell beim normalen App-Lauf abhaken.
-
-### 1.1 Planning Sessions — Manual Verification (unverändert relevant)
-
-Bedingt durch Slice "Planning B/C". Ablauf identisch zur alten open.md:
-
-1. Manual-Task mit Title + TODO-Description anlegen.
-2. Rechtsklick → **Open planning Session** → Windows Terminal mit Claude CLI öffnet.
-3. In CLI: zwei Children via `mcp__claudedo__create_child_task` anlegen.
-4. UI: Drafts erscheinen eingerückt, italic, mit `DRAFT`-Badge; Parent zeigt `PLANNING`-Badge.
-5. Chevron klappt ein/aus.
-6. CLI `finalize` → Children werden Queued (erste) bzw. Queued+BlockedBy (Rest); Parent flippt von `Active` auf `Finalized` (`PLANNED`-Badge); erste Child startet automatisch.
-7. Neuer Planning-Task, Terminal ohne Finalize schließen → Rechtsklick öffnet Resume/Finalize-now/Discard-Modal.
-8. Delete-Versuch auf Parent mit Children → freundlicher Fehlerdialog, kein Delete.
-
-**Bekannte Follow-ups (non-blocking):**
-- ✅ `Border.badge.planned` (blau) wird jetzt bei `Finalized` angewendet — `TaskRowView` nutzt `Classes.planning`/`Classes.planned` gebunden an `IsPlanActive`/`IsPlanFinalized`; der Child-„PLANNED"-Badge nutzt direkt `planned`.
-- ✅ Tote `Instance`-Statics auf `BoolToItalicConverter` und `BoolToDraftOpacityConverter` entfernt (Registrierung läuft über das Resource-Dictionary in `App.axaml`).
-- ✅ `Ui.Tests` IWorkerClient-Fakes auf gemeinsame Basis `StubWorkerClient` rebased — kein Constructor-Drift mehr; die drei Fakes überschreiben nur ihre relevanten Member.
-
-### 1.2 Prime Claude — Manual Verification
-
-Slice "Prime" (Recurrence-Scheduler).
-
-1. Settings → Prime-Claude-Tab → Schedule mit `at: 09:00`, `every: workday`, `task_template: "Daily Standup"` anlegen.
-2. Test mit verschobenem `IPrimeClock` (oder Schedule mit `at: now+1min`) → bei Trigger erscheint Toast/Footer-Notification „Prime fired", neuer Task entsteht in der Ziel-Liste.
-3. Worker-Restart innerhalb des Schedule-Fensters → Catch-up läuft genau einmal (kein Doppelfeuer).
-4. Schedule editieren → `next_due_at` wird neu berechnet; UI-Anzeige aktualisiert.
-5. Schedule löschen → keine weiteren Trigger, keine ghost-Tasks.
-
-### 1.3 Self-Update — Manual Verification (aus alter open.md, weiterhin gültig)
-
-Voraussetzung: funktionierendes Gitea-Release unter `git.kuns.dev/releases/ClaudeDo` mit drei Assets — `ClaudeDo-<version>-win-x64.zip`, `ClaudeDo.Installer-<version>.exe`, `checksums.txt`.
-
-1. Baseline-Version (z.B. `0.2.x`) normal installieren.
-2. Neues Release `v0.3.0` mit frischem Installer + App-Zip + Checksums veröffentlichen.
-3. App starten → Banner erscheint: `Update available: v0.2.x → v0.3.0`.
-4. **Update now** klicken → App schließt, Installer öffnet im Update-Mode, läuft, restartet Worker.
-5. App neu starten → Banner weg; `Help → Check for updates` zeigt kurz „You're up to date (v0.3.0)".
-6. `v0.2.x`-Installer manuell starten → bietet Self-Update auf v0.3.0 an. **Update** → laufende Exe wird ersetzt, Wizard öffnet auf neuer Version.
-7. Schritt 6 mit **Continue anyway** → Wizard öffnet ohne Self-Update.
-8. Schritt 6 mit **Cancel** → Installer beendet ohne Aktion.
-9. Network-Kill in App und Installer beim Start → silent fallback (kein Error, kein Banner).
-
----
-
-## 2. UI-Polish
-
-### 2.1 Folder-Picker für `Working Directory` ⬜
-- **Datei:** `Views/ListSettingsModalView.axaml` + zugehöriges VM
-- **Aktuell:** plain `TextBox` — Pfad muss getippt werden.
-- **Soll:** Button „…" daneben → öffnet `IStorageProvider.OpenFolderPickerAsync`, schreibt Pfad ins Feld.
-- **Aufwand:** klein.
-
-### 2.2 Delete-Confirmation ⬜
-- **Aktuell:** Listen/Tasks-Delete läuft direkt ohne Rückfrage. Datenverlust-Risiko.
-- **Soll:** generischer `ConfirmDialog` (1× bauen, mehrfach nutzen), Mini-Dialog „Wirklich löschen?".
-- **Aufwand:** klein.
-
-### 2.3 Markdown-Rendering Result + Description ✅
-- `Views/MarkdownView.axaml` + Detail-Pane verwenden Markdown.Avalonia.
-
-### 2.4 Live-Log Auto-Scroll ⬜
-- **Datei:** `Views/DetailsIslandView.axaml(.cs)` (Live-Tail-Section)
-- **Aktuell:** ndjson-Zeilen werden angehängt, Scrollposition bleibt stehen.
-- **Soll:** Sticky-Bottom-Pattern — bei jeder neuen Zeile `ScrollToEnd()`, solange User nicht manuell hochgescrollt hat. Attached-Behavior reicht.
-
-### 2.5 Diff-Viewer 🟡
-- `DiffModalView.axaml` + `PlanningDiffView` existieren; integriert für Planning-Merges.
-- **Offen:** Task-Level-Diff (Worktree vs. main) noch nicht im Modal-Flow geprüft. Verwenden statt `Process.Start("cmd /k git diff …")`.
-
-### 2.6 Status-Bar Active-Tasks Live-Update ⬜
-- **Datei:** `ViewModels/StatusBarViewModel`
-- **Risiko:** `RunNowCommand.NotifyCanExecuteChanged` triggert nicht pro Item bei Connection-Change.
-- **Soll:** `WeakReferenceMessenger`-Connection-Change-Message; alle `TaskRowViewModel` lauschen.
-- **Aufwand:** klein, muss sauber gemacht werden.
-
-### 2.7 Settings-Dialog ✅
-- `SettingsModalView` als `TabControl`, Tabs: General, Prime Claude, etc. Persistiert in `~/.todo-app/ui.config.json` und `worker.config.json`.
-
-### 2.8 (NEU) Planning-Phase Badge-Farbe für `Finalized` ✅
-`Finalized` zeigt jetzt den blauen `planned`-Badge (Class-Binding in `TaskRowView`).
-
-### 2.9 (NEU) Tote Converter-Statics entfernen ✅
-`BoolToItalicConverter.Instance`, `BoolToDraftOpacityConverter.Instance` entfernt.
-
----
-
-## 3. Worker-Robustheit
-
-### 3.1 CLI-Preflight beim Worker-Start ✅
-- `src/ClaudeDo.Worker/Lifecycle/ClaudeCliPreflight.cs` + Wiring in `Program.cs`. Tests: `tests/.../Lifecycle/ClaudeCliPreflightTests.cs`. Skippable via `CLAUDEDO_SKIP_CLI_PREFLIGHT=1`.
-
-### 3.2 Worktree-Cleanup beim Anlege-Failed ⬜
-- **Datei:** `src/ClaudeDo.Worker/Runner/WorktreeManager.cs`
-- **Soll:** try/finally — bei Fehler zwischen `git worktree add` und DB-Insert `git worktree remove --force` als Best-Effort-Cleanup.
-- **Aufwand:** klein.
-
-### 3.3 Logging über file-Sink ⬜
-- ILogger ist überall verdrahtet, aber kein File-Sink konfiguriert.
-- **Soll:** Serilog oder `Karambolage.Extensions.Logging.File` — für Service-Modus zwingend, console-only ist im SCM-Fenster verloren.
-- **Aufwand:** klein.
-
-### 3.4 Tag-Negation / Exclusion ⬜
-- Tags sind weiterhin rein additiv (`list_tags ∪ task_tags`). Nach Slice „Editierbare Tags" weniger dringend, aber nicht gelöst.
-- **Soll:** entweder neue Tabelle `task_tag_exclusions` oder Prefix `!tag` im task_tags-Eintrag.
-- **Aufwand:** mittel — Schema + Repo + Tests + UI.
-
----
-
-## 4. Service-Deployment
-
-### 4.1 Worker-Autostart via Startup-Shortcut ✅ (ersetzt Scheduled Task + Windows-Service)
-- Der Worker läuft als `WinExe` (kein Konsolenfenster) + Serilog-File-Sink (`~/.todo-app/logs/worker-*.log`) + Single-Instance-Mutex.
-- Autostart über eine **Startup-Ordner-Verknüpfung** `ClaudeDo Worker.lnk` (`%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\`), die der Installer via `AutostartShortcut`/`ShortcutFactory` COM-Helper anlegt. Kein Scheduled Task, kein Windows-Service.
-- `StartWorkerStep` startet den Worker per `Process.Start`; `StopWorkerStep` beendet ihn per prozessbasiertem Kill.
-- Die App (`IslandsShellViewModel`) startet den Worker nicht selbst. Bei offline-Worker ~12s nach App-Start: einmaliges `WorkerConnectionModal` (Start Worker / Rerun Installer / Dismiss); Connection-Status-Pill in der Fußzeile ist ein Button zum erneuten Öffnen des Modals.
-- `UninstallRunner` löscht die Startup-`.lnk`; migriert ältere Installs durch best-effort-Löschen des Legacy-Scheduled-Tasks „ClaudeDoWorker" und des Legacy-Windows-Service.
-- **Manuelle E2E-Verifikation am Gerät ausstehend** (Logoff/Logon-Autostart, Update-Pfad, Uninstall).
-
-### 4.2 Pfad-Auflösung absolut ✅
-- `WorkerConfig.Load` expandiert `~`/`%USERPROFILE%` für alle Pfad-Felder.
-
-### 4.3 Install-Skripte / Doku ⬜
-- **Datei (neu):** `docs/install-service.md` ODER `scripts/install-service.cmd`
-- **Inhalt:** `dotnet publish` + `sc.exe create` + `sc.exe failure` + Hinweis auf `obj=` (User-Account) wegen Claude-CLI-Session.
-- **Aufwand:** klein.
-
-### 4.4 Installer-Projekt ✅
-- `ClaudeDo.Installer` (WPF) + `ClaudeDo.Releases` mit Pages/Steps/Core/Theme — Self-Update funktioniert (siehe §1.3).
-
----
-
-## 5. Tests / CI
-
-### 5.1 CI-Pipeline (Gitea Actions) ⬜
-- **Datei (neu):** `.gitea/workflows/ci.yml`
-- **Inhalt:** `dotnet restore` → `dotnet build` (csproj-weise wegen `.slnx`-Bug auf .NET 8) → `dotnet test`. Auf Push + PR.
-- **Achtung:** Pipeline darf NICHT die `.slnx` als Build-Target nehmen — explizite csproj-Liste in einem checked-in Build-Skript.
-- **Aufwand:** klein.
-
-### 5.2 SignalR-Hub-Tests ✅
-- `tests/ClaudeDo.Worker.Tests/Hub/PlanningHubTests.cs`, `AgentSettingsHubTests.cs` testen Hub-Methoden via Fakes (kein realer SignalR-Roundtrip, aber alle Code-Pfade abgedeckt).
-- **Optional verbleibt:** echter Roundtrip-Test mit `WebApplicationFactory<Program>` + `HubConnectionBuilder` für End-to-End-Validierung der SignalR-Pipeline. Niedriger Mehrwert solange Fakes alle Methoden treffen.
-
-### 5.3 Smoke-Test gegen echten `claude` ⬜
-- **Datei (neu):** `tests/ClaudeDo.Worker.Tests/Runner/ClaudeProcessSmokeTest.cs`
-- **Soll:** Real-CLI-Test mit `[Fact(Skip="...")]` ausgegraut, nur lokal aktiviert wenn `CLAUDE_AUTHENTICATED=1` Env-Var gesetzt ist.
-- **Aufwand:** klein.
-
-### 5.4 (NEU) ExternalMcpService-Tests ⬜
-- `External/ExternalMcpService` hat 11 Tools, aber nur partielle Coverage in `tests/.../External/ExternalMcpServiceTests.cs`. Für jedes Tool mindestens einen Happy-Path + einen Error-Pfad ergänzen.
-
----
-
-## 6. Dokumentation
-
-### 6.1 README.md ⬜
-- Komplett fehlt. Mind. 1× kurz: was ist es, wie starten (Worker + UI), wo Config, wie Self-Update.
-
-### 6.2 docs/architecture.md 🟡
-- In `plan.md` enthalten — entweder konsolidieren oder explizit ausgliedern. CLAUDE.md-Dateien pro Projekt sind aktuell de-facto-Architecture-Doc.
-
-### 6.3 ADRs ⬜
-- Vorschläge: „SignalR vs. SQLite-Polling für IPC", „Worktree pro Task", „TaskStateService als alleiniger State-Owner", „BlockedByTaskId statt Status='Waiting'", „External MCP als zweite WebApplication".
-- **Aufwand:** klein, hilfreich für später.
-
-### 6.4 (NEU) Mailbox-Proposal ⬜
-- `docs/mailbox-proposal.md` ist als Vorschlag vorhanden, nicht implementiert. Entscheidung: bauen, droppen oder parken? Wenn droppen → Datei entfernen, sonst klare Roadmap.
-
----
-
-## 7. Bekannte Code-Schulden / Smells
-
-| Stelle | Issue | Status |
-|---|---|---|
-| `WorkerHub.GetActive` returnt `IReadOnlyList<object>` mit anonymen Typen | Sollte expliziter `ActiveTaskDto` sein, den Worker UND UI teilen | ✅ (gibt bereits `IReadOnlyList<ActiveTaskDto>` zurück) |
-| `TaskRunner` führt eine `if (list.WorkingDir != null)`-Verzweigung mitten in der Methode | Strategy-Pattern wenn die Methode wächst, aktuell noch klein genug | ⬜ |
-| `App.Services` als public static `ServiceProvider` | Service-Locator-Antipattern, toleriert weil nur in `App.OnFrameworkInitializationCompleted` | ⬜ |
-| Embedded `schema.sql` ohne Versionierung | Durch EF-Core-Migrationen ersetzt | ✅ |
-| CRLF-Warnings beim Commit | `.gitattributes` mit `* text=auto eol=lf` (oder explizit pro Sprache) wäre sauberer | ✅ (`.gitattributes` angelegt) |
-| Tote Converter-Instances (`BoolToItalicConverter.Instance`, `BoolToDraftOpacityConverter.Instance`) | Per Resource-Dictionary registriert, Statics ungenutzt | ✅ (entfernt) |
-| 1 unausgeführter `// TODO` in `DetailsIslandViewModel` (`SendPromptAsync` ohne Hub-Methode) | Entweder Hub-Methode bauen oder TODO entfernen | ✅ (im Main-Code nicht mehr vorhanden) |
-
----
-
-## 8. Improvement Plan (improvement-plan.md, Stand 2026-04-13)
-
-| ID | Item | Status | Bemerkung |
-|---|---|---|---|
-| IP-1 | UI ↔ Worker Auto-Reconnect | ✅ | `WorkerClient` mit `WithAutomaticReconnect()` + Reconnect-Handler |
-| IP-2 | Listen-Modus „Notes" (non-autonomous) | ⬜ | Nach Slice „editierbare Status/Tags" weniger dringend (man kann jetzt einen Task ohne `agent`-Tag idle lassen), aber `lists.kind` als sauberer Mode-Switch fehlt. |
-| IP-3 | Doppelklick öffnet Edit-Dialog | ✅ | `DoubleTapped`-Handler in `ListsIslandView`, `TasksIslandView` |
-| IP-4 | Tag Multi-Select Control | ⬜ | Tags sind via Picker im Detail-Pane editierbar, aber kein dediziertes Multi-Select-Control mit Auto-Vervollständigung in Editor-Dialogen. |
-| IP-5 | Rechtsklick-Kontextmenü | ✅ | Listen + Tasks haben Context-Menüs (Edit, Delete, Run Now, Show Diff, Merge, Cancel, Status, Tags) |
-| IP-6 | Schema-Migration-Mechanismus | ✅ | EF-Core-Migrations + `__EFMigrationsHistory` |
-| IP-7 | Status-Bar Reconnect-States | ✅ | `connected`/`connecting`/`reconnecting`/`offline` farbcodiert |
-| IP-8 | Tag-Repository `GetAllKnownTagsAsync` | ✅ | `TagRepository.GetAllAsync` + `WorkerClient.GetAllTagsAsync` |
-
----
-
-## 9. Empfohlene Reihenfolge für die nächsten Sessions
-
-**Block 1 — Verification durchspielen** (kein neuer Code, nur Beweis):
-1. §1.0 Steps 3–7 manuell (Smoke + E2E + Worktree + No-Changes + Kein-Repo) — ist die Pipeline wirklich lebendig?
-2. §1.1 Planning-Walkthrough — nach den uncommitted Coordinator-Änderungen einmal durchspielen.
-3. §1.2 Prime-Walkthrough — Schedule-Trigger einmal beobachten.
-
-**Block 2 — Niedrig hängende UI-Polish** (eine Session):
-4. §2.1 Folder-Picker
-5. §2.2 Delete-Confirmation
-6. §2.4 Live-Log Auto-Scroll
-7. §2.6 Status-Bar Live-Update
-8. §2.8 Planning-Badge-Farbe + §2.9 tote Converter weg
-
-**Block 3 — Robustheit & Service-Deployment**:
-9. §3.2 Worktree-Cleanup
-10. §3.3 File-Sink-Logging
-11. §4.3 Install-Skripte/Doku
-
-**Block 4 — Sicherheitsnetz**:
-12. §5.1 Gitea-Actions CI-Pipeline (csproj-weise)
-13. §5.3 Smoke-Test gegen echten claude
-14. §5.4 ExternalMcpService-Tests vervollständigen
-
-**Block 5 — Dokumentation & Aufräumen**:
-15. §6.1 README
-16. §6.3 ADRs (mind. die fünf wichtigsten)
-17. §6.4 Mailbox-Proposal: bauen/droppen entscheiden
-18. §7 Smells: `ActiveTaskDto`, `.gitattributes`, TODO-Comment
-
-**Block 6 — Optional / wenn Bedarf konkret wird**:
-19. §3.4 Tag-Negation
-20. §IP-2 Notes-Modus
-21. §IP-4 Tag Multi-Select Control

docs/prompts-inventory.md

@@ -7,6 +7,22 @@ Snapshot of every string ClaudeDo sends to Claude CLI, plus the CLI-flag surface
 
 Date: 2026-04-24
 
+> **Update 2026-06-04 — prompts externalized.** All prose prompts now live as
+> editable files under `~/.todo-app/prompts/`, each seeded from a bundled default in
+> `src/ClaudeDo.Data/PromptFiles.cs` (read via `ReadOrDefault` / `Render`, which
+> substitutes only named `{tokens}`):
+> `system.md`, `planning-system.md`, `planning-initial.md` (`{title}`/`{description}`),
+> `retry.md`, `daily-prep.md` (`{date}`/`{maxTasks}`), `weekly-report.md`
+> (`{start}`/`{end}`; German output). The old `agent.md` and `planning.md` are
+> retired — `system.md` is the single appended system prompt (the agent/manual split
+> is gone), and the planning system prompt is `planning-system.md`. Daily-prep and
+> retry prompts are now English; retry leans on the resumed session and appends the
+> captured stderr only when it's a real error (not the generic "exited with code N").
+> The system prompt instructs the agent to emit `CLAUDEDO_BLOCKED: <reason>` on its
+> own line for any true blocker; `StreamAnalyzer` collects every marker, strips them
+> from the result, and `TaskRunner` folds them into the review result as a
+> "⚠ Roadblocks" section. All six prompt files are editable from Settings → Files.
+
 ---
 
 ## 1. Task-execution prompts (agent-tagged tasks → Claude CLI)

docs/superpowers/plans/2026-06-03-daily-prep-live-view.md

@@ -0,0 +1,517 @@
+# Daily Prep — Live Output View + Clear Day — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Stream the daily-prep run's output into a live, human-readable view (a new mode in the Details island), and add a "Clear Day" button that empties MyDay.
+
+**Architecture:** The worker broadcasts `PrepStarted/PrepLine/PrepFinished` over SignalR (mirroring `TaskStarted/TaskMessage/TaskFinished`). `PrimeRunner` forwards each Claude stdout line instead of discarding it. The UI `WorkerClient` re-raises these as events; `DetailsIslandViewModel` gains a `PrepLog` + `IsPrepMode` panel rendered with the existing terminal renderer. A `ClearMyDay` hub method bulk-clears `IsMyDay`. MyDay header gets "Vorbereitungs-Log" and "Tag leeren" buttons.
+
+**Tech Stack:** .NET 8, ASP.NET Core SignalR, EF Core (SQLite), Avalonia + CommunityToolkit.Mvvm, xUnit.
+
+**Spec:** `docs/superpowers/specs/2026-06-03-daily-prep-live-view-design.md`
+
+---
+
+## Build & test commands
+
+`.slnx` needs .NET 9; build/test individual csproj with `-c Release` (a running Worker may lock Debug).
+
+```bash
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+```
+
+UI cannot be GUI-smoke-tested headlessly — note that explicitly where it applies; the human verifies visuals.
+
+## Reference anchors (verify before editing — line numbers drift)
+
+- `src/ClaudeDo.Worker/Prime/Interfaces/IPrimeBroadcaster.cs` — currently only `PrimeFiredAsync`.
+- `src/ClaudeDo.Worker/Hub/HubBroadcaster.cs:13-57` — broadcast methods; `PrimeFired` at ~52-56.
+- `src/ClaudeDo.Worker/Prime/PrimeRunner.cs:31-79` — `FireAsync`; discard lambda at ~55-60; ctor at ~19-29.
+- `src/ClaudeDo.Worker/Hub/WorkerHub.cs:542-549` — `RunDailyPrepNow` (uses `_broadcaster`); DailyNote CRUD at 559-583 (shows the db-context pattern this hub uses).
+- `src/ClaudeDo.Ui/Services/Interfaces/IWorkerClient.cs:19` — `TaskMessageEvent`; `:55` — `RunDailyPrepNowAsync`.
+- `src/ClaudeDo.Ui/Services/WorkerClient.cs:99-122` — `TaskStarted/Finished/Message` hub.On; `:170-173` — `PrimeFired` hub.On (the pattern to copy).
+- `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs` — `IsNotesMode` ~56, `Log` ~193, ctor/subscriptions ~272-337, `OnTaskMessage` ~339-363 (stdout→`StreamLineFormatter`→`Log`), `ShowNotes` ~478-483.
+- `src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml:131-302` — body grid; task panel `IsVisible="{Binding !IsNotesMode}"`, notes panel `IsVisible="{Binding IsNotesMode}"`; `SessionTerminalView` embedded ~295.
+- `src/ClaudeDo.Ui/Views/Islands/SessionTerminalView.axaml:54-75` — `ItemsControl ItemsSource="{Binding Log}"` + the `LogLineViewModel` item template to reuse.
+- `src/ClaudeDo.Ui/ViewModels/Islands/TasksIslandViewModel.cs` — `NotesRequested` ~29, `OpenNotesCommand`+`PrepareDayCommand` ~33-45, `ShowNotesRow`/`IsMyDayList` ~65-66, both set in `LoadForList` ~212-213.
+- `src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml:69-84` — Notes + PrepareDay buttons (styling to copy).
+- `src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs:199-201` — island event wiring; `:225` — `PrimeFired` subscription.
+- Fakes to keep in sync: `tests/ClaudeDo.Ui.Tests/StubWorkerClient.cs`, `tests/ClaudeDo.Worker.Tests/UiVm/TasksIslandViewModelPlanningTests.cs` (`FakeWorkerClient`).
+
+---
+
+## Task 1: Worker — prep output broadcast + streaming
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Prime/Interfaces/IPrimeBroadcaster.cs`
+- Modify: `src/ClaudeDo.Worker/Hub/HubBroadcaster.cs`
+- Modify: `src/ClaudeDo.Worker/Prime/PrimeRunner.cs`
+- Test: `tests/ClaudeDo.Worker.Tests/Prime/PrimeRunnerTests.cs`
+
+- [ ] **Step 1: Write the failing test.** Extend `PrimeRunnerTests` with a fake `IPrimeBroadcaster` that records calls. The fake `IClaudeProcess` should invoke `onStdoutLine` with two sample lines and return `RunResult { ExitCode = 0, ResultMarkdown = "ok" }`.
+
+```csharp
+[Fact]
+public async Task FireAsync_streams_started_lines_and_finished()
+{
+    var broadcaster = new RecordingPrimeBroadcaster();
+    var claude = new FakeClaudeProcess(emitLines: new[] { "{\"a\":1}", "{\"b\":2}" }, exitCode: 0, result: "ok");
+    var runner = NewRunner(claude, broadcaster); // build with temp-sqlite dbFactory + fake clock + logger + broadcaster
+    var schedule = new PrimeScheduleDto(Guid.Empty, 0, TimeSpan.Zero, true, null, null);
+
+    var outcome = await runner.FireAsync(schedule, CancellationToken.None);
+
+    Assert.True(outcome.Success);
+    Assert.Equal(1, broadcaster.StartedCount);
+    Assert.Equal(new[] { "{\"a\":1}", "{\"b\":2}" }, broadcaster.Lines);
+    Assert.Single(broadcaster.FinishedResults);
+    Assert.True(broadcaster.FinishedResults[0]);
+}
+```
+
+`RecordingPrimeBroadcaster` implements `IPrimeBroadcaster`: `StartedCount`, `List<string> Lines`, `List<bool> FinishedResults`, and a no-op `PrimeFiredAsync`. If the existing `FakeClaudeProcess` cannot emit lines, add an optional `emitLines` parameter that loops `await onStdoutLine(line)` before returning.
+
+- [ ] **Step 2: Run — expect FAIL** (interface methods + ctor param missing).
+
+```bash
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter PrimeRunner
+```
+
+- [ ] **Step 3: Extend `IPrimeBroadcaster`:**
+
+```csharp
+public interface IPrimeBroadcaster
+{
+    Task PrimeFiredAsync(Guid scheduleId, bool success, string message, DateTimeOffset firedAt);
+    Task PrepStartedAsync();
+    Task PrepLineAsync(string line);
+    Task PrepFinishedAsync(bool success);
+}
+```
+
+(Keep the existing `PrimeFiredAsync` signature exactly as it is in the current file.)
+
+- [ ] **Step 4: Implement in `HubBroadcaster`** (add next to `PrimeFired`):
+
+```csharp
+    public Task PrepStarted() => _hub.Clients.All.SendAsync("PrepStarted");
+    public Task PrepLine(string line) => _hub.Clients.All.SendAsync("PrepLine", line);
+    public Task PrepFinished(bool success) => _hub.Clients.All.SendAsync("PrepFinished", success);
+
+    Task IPrimeBroadcaster.PrepStartedAsync() => PrepStarted();
+    Task IPrimeBroadcaster.PrepLineAsync(string line) => PrepLine(line);
+    Task IPrimeBroadcaster.PrepFinishedAsync(bool success) => PrepFinished(success);
+```
+
+(Match the existing explicit-interface style used for `PrimeFiredAsync`.)
+
+- [ ] **Step 5: Wire `PrimeRunner`.** Add `IPrimeBroadcaster _broadcaster` as a ctor param (and field). Rewrite the body of `FireAsync` after the gate check to:
+
+```csharp
+        if (!await _gate.WaitAsync(0, ct))
+            return new PrimeRunOutcome(false, "Daily prep already running");
+
+        var success = false;
+        try
+        {
+            await _broadcaster.PrepStartedAsync();
+
+            var cwd = Paths.AppDataRoot();
+            Directory.CreateDirectory(cwd);
+
+            int maxTasks;
+            await using (var dbCtx = await _dbFactory.CreateDbContextAsync(ct))
+            {
+                var settings = await new AppSettingsRepository(dbCtx).GetAsync(ct);
+                maxTasks = settings.DailyPrepMaxTasks < 1 ? 1 : settings.DailyPrepMaxTasks;
+            }
+
+            var today = DateOnly.FromDateTime(_clock.Now.LocalDateTime);
+            var prompt = DailyPrepPrompt.BuildPrompt(maxTasks, today);
+            var args = DailyPrepPrompt.BuildArgs(MaxTurns);
+
+            using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+            timeoutCts.CancelAfter(FireTimeout);
+
+            var result = await _claude.RunAsync(
+                arguments: args,
+                prompt: prompt,
+                workingDirectory: cwd,
+                onStdoutLine: line => _broadcaster.PrepLineAsync(line),
+                ct: timeoutCts.Token);
+
+            success = result.IsSuccess;
+            return success
+                ? new PrimeRunOutcome(true, "Daily prep complete")
+                : new PrimeRunOutcome(false, $"exit code {result.ExitCode}");
+        }
+        catch (OperationCanceledException) when (!ct.IsCancellationRequested)
+        {
+            return new PrimeRunOutcome(false, $"timed out after {FireTimeout.TotalMinutes:0} min");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Daily prep run failed");
+            return new PrimeRunOutcome(false, ex.Message);
+        }
+        finally
+        {
+            await _broadcaster.PrepFinishedAsync(success);
+            _gate.Release();
+        }
+```
+
+DI is unchanged: `AddSingleton<IPrimeRunner, PrimeRunner>()` resolves `IPrimeBroadcaster` (registered as `sp => sp.GetRequiredService<HubBroadcaster>()`).
+
+- [ ] **Step 6: Update existing `PrimeRunnerTests` ctor calls** to pass the recording broadcaster; build + run.
+
+```bash
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter PrimeRunner
+```
+
+- [ ] **Step 7: Commit.**
+
+```bash
+git add src/ClaudeDo.Worker/Prime src/ClaudeDo.Worker/Hub/HubBroadcaster.cs tests/ClaudeDo.Worker.Tests/Prime
+git commit -m "feat(daily-prep): stream prep output via PrepStarted/PrepLine/PrepFinished"
+```
+
+---
+
+## Task 2: Worker — `ClearMyDay` hub method
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Hub/WorkerHub.cs`
+- Test: a new/existing hub test under `tests/ClaudeDo.Worker.Tests/Hub/` (mirror an existing hub test that seeds a real SQLite db and constructs `WorkerHub`)
+
+- [ ] **Step 1: Write the failing test.** Seed three tasks: two with `IsMyDay=true` (one Idle, one Done), one with `IsMyDay=false`. Construct `WorkerHub` the way existing hub tests do (the same `null!` argument list, plus a recording `HubBroadcaster`/clients). Call `ClearMyDay()`; assert both MyDay rows are now `false`, the third is untouched, and the returned count is 2.
+
+```csharp
+[Fact]
+public async Task ClearMyDay_clears_all_isMyDay_tasks()
+{
+    // seed via the test's db helper ...
+    var hub = NewHub(/* ... */);
+    var cleared = await hub.ClearMyDay();
+
+    Assert.Equal(2, cleared);
+    await using var ctx = NewContext();
+    Assert.False(await ctx.Tasks.AnyAsync(t => t.IsMyDay));
+}
+```
+
+- [ ] **Step 2: Run — expect FAIL.**
+
+- [ ] **Step 3: Add the method** to `WorkerHub` (use the same db-context acquisition the neighbouring hub methods use — e.g. `_dbFactory`/repository field name found in the file — and the existing `_broadcaster` field):
+
+```csharp
+public async Task<int> ClearMyDay()
+{
+    await using var ctx = await _dbFactory.CreateDbContextAsync();
+    var ids = await ctx.Tasks.Where(t => t.IsMyDay).Select(t => t.Id).ToListAsync();
+    if (ids.Count == 0) return 0;
+
+    await ctx.Tasks.Where(t => t.IsMyDay)
+        .ExecuteUpdateAsync(s => s.SetProperty(t => t.IsMyDay, false));
+
+    foreach (var id in ids)
+        await _broadcaster.TaskUpdated(id);
+
+    return ids.Count;
+}
+```
+
+If `WorkerHub` does not already have an `IDbContextFactory<ClaudeDoDbContext>` field, use whatever data-access dependency the other hub methods use (read the file). Do NOT add a new ctor param unless unavoidable (it would break hub-test fakes — if you must, update all `new WorkerHub(...)` call sites).
+
+- [ ] **Step 4: Run — expect PASS.** Build Worker.
+
+- [ ] **Step 5: Commit.**
+
+```bash
+git add src/ClaudeDo.Worker/Hub/WorkerHub.cs tests/ClaudeDo.Worker.Tests/Hub
+git commit -m "feat(daily-prep): add ClearMyDay hub method"
+```
+
+---
+
+## Task 3: UI — WorkerClient prep events + ClearMyDayAsync
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/Services/Interfaces/IWorkerClient.cs`
+- Modify: `src/ClaudeDo.Ui/Services/WorkerClient.cs`
+- Modify fakes: `tests/ClaudeDo.Ui.Tests/StubWorkerClient.cs`, `tests/ClaudeDo.Worker.Tests/UiVm/TasksIslandViewModelPlanningTests.cs` (FakeWorkerClient)
+
+- [ ] **Step 1: Declare on `IWorkerClient`** (near `TaskMessageEvent` / `RunDailyPrepNowAsync`):
+
+```csharp
+event Action? PrepStartedEvent;
+event Action<string>? PrepLineEvent;
+event Action<bool>? PrepFinishedEvent;
+Task ClearMyDayAsync();
+```
+
+- [ ] **Step 2: Implement in `WorkerClient`.** Add the events; register hub callbacks mirroring the `PrimeFired` registration (~line 170):
+
+```csharp
+public event Action? PrepStartedEvent;
+public event Action<string>? PrepLineEvent;
+public event Action<bool>? PrepFinishedEvent;
+
+// in the hub-wiring section:
+_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)));
+
+public Task ClearMyDayAsync() => _connection.InvokeAsync("ClearMyDay");
+```
+
+(Use the exact connection field name and async-call style of neighbouring methods like `RunDailyPrepNowAsync` / `GenerateWeekReport`. `ClearMyDay` returns `int` on the hub; invoking it as a void `InvokeAsync("ClearMyDay")` is fine, or `InvokeAsync<int>` if you want the count.)
+
+- [ ] **Step 3: Update the fakes.** Add the three events (as `public event …` auto-implemented) and `ClearMyDayAsync() => Task.CompletedTask` to both `StubWorkerClient` and `FakeWorkerClient`. For the ClearDay command test (Task 5), give `StubWorkerClient` a `ClearMyDayCalls` counter incremented in `ClearMyDayAsync`.
+
+- [ ] **Step 4: Build App + both test projects; fix any remaining fake gaps.**
+
+```bash
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+```
+
+- [ ] **Step 5: Commit.**
+
+```bash
+git add src/ClaudeDo.Ui/Services tests
+git commit -m "feat(daily-prep): expose prep stream events and ClearMyDay on the UI worker client"
+```
+
+---
+
+## Task 4: UI — Details island prep mode + live log
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs`
+- Modify: `src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml`
+- Test: `tests/ClaudeDo.Ui.Tests/...DetailsIslandViewModel...` (mirror existing Details VM tests; if none, add a small test file)
+
+- [ ] **Step 1: Write the failing test.** Construct `DetailsIslandViewModel` with a `StubWorkerClient` (mirror existing construction). Then:
+
+```csharp
+[Fact]
+public void PrepLine_event_appends_to_PrepLog()
+{
+    var stub = new StubWorkerClient();
+    var vm = NewDetailsVm(stub);
+
+    stub.RaisePrepLine("{\"type\":\"assistant\",\"text\":\"hi\"}"); // helper that invokes PrepLineEvent
+    Assert.NotEmpty(vm.PrepLog);
+}
+
+[Fact]
+public void ShowPrep_sets_prep_mode_and_clears_notes_mode()
+{
+    var vm = NewDetailsVm(new StubWorkerClient());
+    vm.ShowPrep();
+    Assert.True(vm.IsPrepMode);
+    Assert.False(vm.IsNotesMode);
+}
+```
+
+Add `RaisePrepStarted/RaisePrepLine/RaisePrepFinished` helpers to `StubWorkerClient` that invoke the corresponding events.
+
+- [ ] **Step 2: Run — expect FAIL.**
+
+- [ ] **Step 3: Implement in `DetailsIslandViewModel`:**
+  - Add `[ObservableProperty] private bool _isPrepMode;` and `[ObservableProperty] private bool _isPrepRunning;`.
+  - Add `public ObservableCollection<LogLineViewModel> PrepLog { get; } = new();`.
+  - In the ctor, subscribe: `_worker.PrepStartedEvent += OnPrepStarted; _worker.PrepLineEvent += OnPrepLine; _worker.PrepFinishedEvent += OnPrepFinished;` (guard with the same `_worker is not null` pattern used for other events).
+  - Handlers:
+
+```csharp
+private void OnPrepStarted()
+{
+    PrepLog.Clear();
+    IsPrepRunning = true;
+}
+
+private void OnPrepLine(string line) => AppendStdoutLine(PrepLog, line);
+
+private void OnPrepFinished(bool success) => IsPrepRunning = false;
+```
+
+  - Factor the stdout-formatting currently inside `OnTaskMessage` into a reusable
+    `private void AppendStdoutLine(ObservableCollection<LogLineViewModel> target, string line)`
+    that runs the line through `StreamLineFormatter` and appends `LogLineViewModel`(s).
+    Have `OnTaskMessage`'s stdout branch call `AppendStdoutLine(Log, strippedLine)` so both
+    paths share one implementation. (Events arrive already on the UI thread via
+    `Dispatcher.UIThread.Post` in `WorkerClient`, so direct collection mutation is correct.)
+  - Add `public void ShowPrep()` mirroring `ShowNotes()`: call `Bind(null)`, set
+    `IsNotesMode = false`, `IsPrepMode = true`.
+  - In `ShowNotes()` add `IsPrepMode = false`. In `Bind(...)` reset both `IsNotesMode` and
+    `IsPrepMode` to false (find where `IsNotesMode` is reset; add `IsPrepMode` beside it).
+
+- [ ] **Step 4: Update `DetailsIslandView.axaml`.**
+  - Change the task-details panel visibility from `IsVisible="{Binding !IsNotesMode}"` to a
+    converter-free multi-condition. Avalonia lacks `&&` in bindings, so add a computed
+    property `public bool IsTaskDetailVisible => !IsNotesMode && !IsPrepMode;` to the VM
+    (raise its change notification from the `OnIsNotesModeChanged`/`OnIsPrepModeChanged`
+    partial methods generated by `[ObservableProperty]`) and bind the task panel to
+    `IsVisible="{Binding IsTaskDetailVisible}"`.
+  - Add a third panel after the notes panel:
+
+```xml
+<Panel IsVisible="{Binding IsPrepMode}">
+    <DockPanel>
+        <TextBlock DockPanel.Dock="Top" Margin="16,12"
+                   Text="{loc:Tr details.prepTitle}" Classes="h2"/>
+        <ScrollViewer>
+            <ItemsControl ItemsSource="{Binding PrepLog}"/>
+        </ScrollViewer>
+    </DockPanel>
+</Panel>
+```
+
+  The `ItemsControl` reuses the implicit `LogLineViewModel` `DataTemplate` that
+  `SessionTerminalView` relies on. If that template is defined locally inside
+  `SessionTerminalView.axaml` (not in a shared resource), either move it to a shared
+  `ResourceDictionary` (e.g. App resources) and reference it from both, or set the
+  `ItemsControl.ItemTemplate` to a copy of that template. Prefer sharing over copying.
+  Add `details.prepTitle` ("Daily prep" / "Tagesvorbereitung") to both locale json files.
+
+- [ ] **Step 5: Run UI tests — expect PASS; build App.**
+
+```bash
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+```
+
+- [ ] **Step 6: Commit.**
+
+```bash
+git add src/ClaudeDo.Ui src/ClaudeDo.Localization tests/ClaudeDo.Ui.Tests
+git commit -m "feat(daily-prep): add live prep-output mode to the Details island"
+```
+
+---
+
+## Task 5: UI — MyDay buttons + shell wiring
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/TasksIslandViewModel.cs`
+- Modify: `src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml`
+- Modify: `src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs`
+- Modify: `src/ClaudeDo.Localization/locales/en.json`, `de.json`
+- Test: `tests/ClaudeDo.Worker.Tests/UiVm/...` or `tests/ClaudeDo.Ui.Tests/...` (TasksIslandViewModel)
+
+- [ ] **Step 1: Write the failing tests.**
+
+```csharp
+[Fact]
+public async Task ClearDayCommand_calls_worker()
+{
+    var stub = new StubWorkerClient();
+    var vm = NewTasksVm(stub);
+    await vm.ClearDayCommand.ExecuteAsync(null);
+    Assert.Equal(1, stub.ClearMyDayCalls);
+}
+
+[Fact]
+public async Task PrepareDayCommand_raises_PrepRequested()
+{
+    var vm = NewTasksVm(new StubWorkerClient());
+    var raised = false;
+    vm.PrepRequested += () => raised = true;
+    await vm.PrepareDayCommand.ExecuteAsync(null);
+    Assert.True(raised);
+}
+```
+
+- [ ] **Step 2: Run — expect FAIL.**
+
+- [ ] **Step 3: Implement in `TasksIslandViewModel`:**
+  - Add `public event Action? PrepRequested;` next to `NotesRequested`.
+  - In `PrepareDayAsync` (the existing `[RelayCommand]`), raise `PrepRequested?.Invoke();`
+    in addition to the existing `RunDailyPrepNowAsync()` call.
+  - Add:
+
+```csharp
+[RelayCommand]
+private void ShowPrepLog() => PrepRequested?.Invoke();
+
+[RelayCommand]
+private async Task ClearDayAsync()
+{
+    if (_worker is null) return;
+    try { await _worker.ClearMyDayAsync(); }
+    catch { /* worker offline; broadcast will reconcile on return */ }
+}
+```
+
+- [ ] **Step 4: Add the two buttons** to the MyDay header in `TasksIslandView.axaml`,
+  immediately after the existing "Prepare day" button (~line 84), copying its styling
+  (`DockPanel.Dock="Top" Classes="btn" HorizontalAlignment="Stretch"
+  HorizontalContentAlignment="Left" Margin="16,0,16,8" IsVisible="{Binding IsMyDayList}"`):
+
+```xml
+<Button DockPanel.Dock="Top" Classes="btn" HorizontalAlignment="Stretch"
+        HorizontalContentAlignment="Left" Margin="16,0,16,8"
+        IsVisible="{Binding IsMyDayList}"
+        Command="{Binding ShowPrepLogCommand}"
+        Content="{loc:Tr tasks.prepLog}"/>
+<Button DockPanel.Dock="Top" Classes="btn" HorizontalAlignment="Stretch"
+        HorizontalContentAlignment="Left" Margin="16,0,16,8"
+        IsVisible="{Binding IsMyDayList}"
+        Command="{Binding ClearDayCommand}"
+        Content="{loc:Tr tasks.clearDay}"/>
+```
+
+  Add `tasks.prepLog` (en "Prep log" / de "Vorbereitungs-Log") and `tasks.clearDay`
+  (en "Clear day" / de "Tag leeren") to both locale json files.
+
+- [ ] **Step 5: Wire the shell.** In `IslandsShellViewModel` where `Tasks.NotesRequested`
+  is wired (~line 201), add:
+
+```csharp
+Tasks.PrepRequested += () => Details.ShowPrep();
+```
+
+- [ ] **Step 6: Run tests + build App.**
+
+```bash
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+```
+
+- [ ] **Step 7: Manual smoke (human, not headless):** start Worker + App, open MyDay, click
+  "Tag vorbereiten" → Details island opens in prep mode and streams readable lines; click
+  "Tag leeren" → MyDay empties; after a scheduled run, "Vorbereitungs-Log" opens the filled
+  log. Confirm the three buttons only appear on MyDay.
+
+- [ ] **Step 8: Commit.**
+
+```bash
+git add src/ClaudeDo.Ui src/ClaudeDo.Localization tests
+git commit -m "feat(daily-prep): add Prep-log and Clear-day buttons to MyDay header"
+```
+
+---
+
+## Final verification
+
+- [ ] Build Worker + App (Release).
+- [ ] `dotnet test` Worker.Tests, Ui.Tests, Localization.Tests — all green.
+- [ ] Manual: prep streams live into the Details island (manual opens it; scheduled fills it silently, opened via the button); Clear Day empties MyDay immediately.
+
+## Notes / risks
+
+- Mode flags `IsNotesMode` / `IsPrepMode` are mutually exclusive; the task-details panel
+  uses the computed `IsTaskDetailVisible`. Verify all three modes switch cleanly.
+- Reusing the `LogLineViewModel` template: prefer promoting it to a shared resource over
+  copying, to avoid drift between the session terminal and the prep log.
+- `ClearMyDay` broadcasts one `TaskUpdated` per affected id; MyDay is small (capped), so
+  this is fine.
+- Keep `PrimeRunner`'s "already running" early-return emitting no prep events.

docs/superpowers/plans/2026-06-03-daily-prep.md

@@ -0,0 +1,736 @@
+# Daily Prep ("Prime Claude") Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Turn the Prime Time warm-up into a daily preparation where Claude reads open tasks and moves an effort-aware, capped subset into MyDay, triggered by the Prime schedule and a manual button.
+
+**Architecture:** Agentic. Two new tools on the always-on `ExternalMcpService` (`get_daily_prep_candidates`, `set_my_day` with a server-side cap-guard). The existing `PrimeRunner` is rewritten to launch a headless `claude -p` run with a fixed parameterized prompt and `--allowedTools` for those two tools, relying on the already-registered `claudedo` MCP (no separate `--mcp-config`). A new `DailyPrepMaxTasks` app setting drives the cap. A manual hub method reuses the same runner with a single-flight guard.
+
+**Tech Stack:** .NET 8, ASP.NET Core, EF Core (SQLite), SignalR, ModelContextProtocol, Avalonia (CommunityToolkit.Mvvm), xUnit.
+
+**Spec:** `docs/superpowers/specs/2026-06-03-daily-prep-design.md`
+
+---
+
+## Deviation from spec (deliberate, to minimize churn)
+
+The spec proposed renaming `IPrimeRunner`/`PrimeRunner`/`PrimeScheduler` → `DailyPrep*`. **We keep the existing names and the `FireAsync(PrimeScheduleDto, ct)` signature** and only rewrite the runner body. This avoids touching the scheduler, DI registration, `IPrimeBroadcaster`, and the existing Prime tests for a pure rename. The per-schedule `PromptOverride` field becomes unused by the runner (left in the DB/UI untouched).
+
+## Build & test commands (this repo)
+
+`.slnx` needs .NET 9; on .NET 8 build/test individual projects. Use `-c Release` if a running Worker locks `Debug`.
+
+```bash
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj -c Release
+```
+
+Tests use **real SQLite + real git** (project convention). Mirror the setup already present in the test file you are extending.
+
+---
+
+## File Structure
+
+**Create**
+- `src/ClaudeDo.Data/Migrations/<timestamp>_DailyPrepMaxTasks.cs` (+ Designer, via `dotnet ef`)
+- `src/ClaudeDo.Worker/Prime/DailyPrepPrompt.cs` — pure prompt + args builder (easy to unit-test)
+
+**Modify**
+- `src/ClaudeDo.Data/Models/AppSettingsEntity.cs` — add `DailyPrepMaxTasks`
+- `src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs` — map column
+- `src/ClaudeDo.Data/Repositories/AppSettingsRepository.cs` — persist field in `UpdateAsync`
+- `src/ClaudeDo.Worker/External/ExternalMcpService.cs` — add 2 tools + DTOs
+- `src/ClaudeDo.Worker/Prime/PrimeRunner.cs` — rewrite body to daily prep + single-flight
+- `src/ClaudeDo.Worker/Hub/WorkerHub.cs` — add `DailyPrepMaxTasks` to AppSettings DTO + `RunDailyPrepNow`
+- `src/ClaudeDo.Ui/Services/WorkerClient.cs` — mirror `DailyPrepMaxTasks` in the UI AppSettings DTO + add `RunDailyPrepNow` call
+- `src/ClaudeDo.Ui/ViewModels/Modals/Settings/PrimeClaudeTabViewModel.cs` (+ its view) — numeric editor for `DailyPrepMaxTasks`
+- MyDay list header view + its ViewModel — "Tag vorbereiten" button + command
+
+**Test**
+- `tests/ClaudeDo.Data.Tests/...AppSettings...` — new field persists / default 5
+- `tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs` — candidate filter + set_my_day + cap-guard
+- `tests/ClaudeDo.Worker.Tests/Prime/DailyPrepPromptTests.cs` — prompt/args content
+- `tests/ClaudeDo.Worker.Tests/Prime/PrimeRunnerTests.cs` (if present) — single-flight + success/failure via `IClaudeProcess` fake
+
+---
+
+## Task 1: `DailyPrepMaxTasks` app setting
+
+**Files:**
+- Modify: `src/ClaudeDo.Data/Models/AppSettingsEntity.cs`
+- Modify: `src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs`
+- Modify: `src/ClaudeDo.Data/Repositories/AppSettingsRepository.cs`
+- Create (via `dotnet ef`): `src/ClaudeDo.Data/Migrations/<timestamp>_DailyPrepMaxTasks.cs`
+- Test: `tests/ClaudeDo.Data.Tests` (extend existing AppSettings repository test, or add `AppSettingsRepositoryTests.cs`)
+
+- [ ] **Step 1: Write the failing test**
+
+In a Data.Tests file (mirror the existing repo test harness that opens a real SQLite `ClaudeDoDbContext`):
+
+```csharp
+[Fact]
+public async Task DailyPrepMaxTasks_defaults_to_5_and_persists()
+{
+    await using var ctx = NewContext(); // existing helper that migrates a temp sqlite db
+    var repo = new AppSettingsRepository(ctx);
+
+    var initial = await repo.GetAsync();
+    Assert.Equal(5, initial.DailyPrepMaxTasks);
+
+    initial.DailyPrepMaxTasks = 8;
+    await repo.UpdateAsync(initial);
+
+    var reloaded = await repo.GetAsync();
+    Assert.Equal(8, reloaded.DailyPrepMaxTasks);
+}
+```
+
+- [ ] **Step 2: Run it — expect FAIL** (`AppSettingsEntity` has no `DailyPrepMaxTasks`).
+
+```bash
+dotnet test tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj -c Release --filter DailyPrepMaxTasks_defaults_to_5_and_persists
+```
+
+- [ ] **Step 3: Add the property** to `AppSettingsEntity.cs` after `StandupWeekday`:
+
+```csharp
+    // Max number of open tasks the daily prep ("Prime Claude") may place in MyDay.
+    public int DailyPrepMaxTasks { get; set; } = 5;
+```
+
+- [ ] **Step 4: Map the column** in `AppSettingsEntityConfiguration.cs`, after the `StandupWeekday` mapping (before `builder.HasData(...)`):
+
+```csharp
+        builder.Property(s => s.DailyPrepMaxTasks)
+            .HasColumnName("daily_prep_max_tasks").IsRequired().HasDefaultValue(5);
+```
+
+- [ ] **Step 5: Persist it** in `AppSettingsRepository.UpdateAsync`, after the `StandupWeekday` assignment:
+
+```csharp
+        row.DailyPrepMaxTasks = updated.DailyPrepMaxTasks < 1 ? 1 : updated.DailyPrepMaxTasks;
+```
+
+- [ ] **Step 6: Generate the migration** (regenerates the model snapshot — do NOT hand-edit the snapshot):
+
+```bash
+dotnet ef migrations add DailyPrepMaxTasks \
+  -p src/ClaudeDo.Data/ClaudeDo.Data.csproj \
+  -s src/ClaudeDo.Worker/ClaudeDo.Worker.csproj
+```
+
+Verify the generated `Up` contains an `AddColumn<int>("daily_prep_max_tasks", ... defaultValue: 5)` and an `UpdateData` setting the singleton row's `daily_prep_max_tasks` to 5. If `dotnet ef` is unavailable, hand-write the migration mirroring `20260603072822_WeeklyReport.cs` **and** add the matching `Property<int>("DailyPrepMaxTasks").HasColumnName("daily_prep_max_tasks")` line to `ClaudeDoDbContextModelSnapshot.cs` under the `AppSettingsEntity` builder.
+
+- [ ] **Step 7: Run the test — expect PASS.**
+
+- [ ] **Step 8: Commit.**
+
+```bash
+git add src/ClaudeDo.Data tests/ClaudeDo.Data.Tests
+git commit -m "feat(daily-prep): add DailyPrepMaxTasks app setting"
+```
+
+---
+
+## Task 2: `get_daily_prep_candidates` MCP tool
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/External/ExternalMcpService.cs`
+- Test: `tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs`
+
+Read `ExternalMcpServiceTests.cs` first and reuse its existing harness (how it builds an `ExternalMcpService` with a real SQLite context, `ListRepository`, `TaskRepository`, fake `HubBroadcaster`, etc.). The new tool reads **all** lists/tasks itself via the injected `_dbFactory`, so it needs no new constructor args.
+
+- [ ] **Step 1: Write the failing test.** Seed: a list with `WorkingDir = @"D:\work\repo"` holding two `Idle` tasks (one blocked, one not) and one `Done` task; a second list with `WorkingDir = @"C:\Private\secret"` holding one `Idle` task; a third list with `WorkingDir = null` holding one `Idle` task; and one `Idle` task with `IsMyDay = true` in the first list. Set `AppSettings.ReportExcludedPaths = "[\"C:\\\\Private\"]"`.
+
+```csharp
+[Fact]
+public async Task GetDailyPrepCandidates_filters_by_status_block_and_excluded_repo()
+{
+    // ... seed as described, using the file's existing seed helpers ...
+    var svc = NewService();
+
+    var result = await svc.GetDailyPrepCandidates(CancellationToken.None);
+
+    // Only the non-blocked, Idle, non-MyDay task in the non-excluded repo is a candidate.
+    Assert.Single(result.Candidates);
+    Assert.Equal("idle-unblocked", result.Candidates[0].Id);
+    // The Idle MyDay task is reported separately, not as a candidate.
+    Assert.Single(result.CurrentMyDay);
+    Assert.Equal(1, result.MaxTasks > 0 ? 1 : 1); // MaxTasks comes from AppSettings (default 5)
+    Assert.Equal(5, result.MaxTasks);
+}
+```
+
+- [ ] **Step 2: Run it — expect FAIL** (method missing).
+
+- [ ] **Step 3: Add the DTOs** near the other record declarations at the top of `ExternalMcpService.cs`:
+
+```csharp
+public sealed record DailyPrepCandidateDto(
+    string Id, string ListId, string ListName, string Title, string? Description,
+    bool IsStarred, DateTime? ScheduledFor, DateTime CreatedAt);
+
+public sealed record DailyPrepDataDto(
+    int MaxTasks,
+    IReadOnlyList<DailyPrepCandidateDto> Candidates,
+    IReadOnlyList<DailyPrepCandidateDto> CurrentMyDay);
+```
+
+- [ ] **Step 4: Add the tool method** to the `ExternalMcpService` class body:
+
+```csharp
+[McpServerTool, Description(
+    "Daily prep: returns the open tasks eligible for today's MyDay selection. " +
+    "candidates = Idle, not blocked, in a git repo not excluded from the weekly report, and not already in MyDay. " +
+    "currentMyDay = Idle tasks already flagged IsMyDay (count them toward the cap). " +
+    "maxTasks = the hard cap on total open MyDay tasks. Use set_my_day to add tasks (never exceed maxTasks).")]
+public async Task<DailyPrepDataDto> GetDailyPrepCandidates(CancellationToken cancellationToken)
+{
+    await using var ctx = await _dbFactory.CreateDbContextAsync(cancellationToken);
+
+    var settings = await new AppSettingsRepository(ctx).GetAsync(cancellationToken);
+    var excludes = DailyPrepFilter.ParseExcludes(settings.ReportExcludedPaths);
+    var maxTasks = settings.DailyPrepMaxTasks < 1 ? 1 : settings.DailyPrepMaxTasks;
+
+    var idle = await ctx.Tasks
+        .AsNoTracking()
+        .Include(t => t.List)
+        .Where(t => t.Status == TaskStatus.Idle)
+        .ToListAsync(cancellationToken);
+
+    var currentMyDay = idle
+        .Where(t => t.IsMyDay)
+        .OrderBy(t => t.SortOrder)
+        .Select(ToCandidate)
+        .ToList();
+
+    var candidates = idle
+        .Where(t => !t.IsMyDay
+                    && t.BlockedByTaskId == null
+                    && DailyPrepFilter.IsIncludedRepo(t.List?.WorkingDir, excludes))
+        .OrderBy(t => t.CreatedAt)
+        .Select(ToCandidate)
+        .ToList();
+
+    return new DailyPrepDataDto(maxTasks, candidates, currentMyDay);
+}
+
+private static DailyPrepCandidateDto ToCandidate(TaskEntity t) => new(
+    t.Id, t.ListId, t.List?.Name ?? "", t.Title, t.Description,
+    t.IsStarred, t.ScheduledFor, t.CreatedAt);
+```
+
+- [ ] **Step 5: Add the filter helper** as a small static class at the bottom of `ExternalMcpService.cs` (single-consumer helper lives beside its consumer, per repo convention):
+
+```csharp
+internal static class DailyPrepFilter
+{
+    public static string[] ParseExcludes(string? json)
+    {
+        if (string.IsNullOrWhiteSpace(json)) return [];
+        try
+        {
+            var list = System.Text.Json.JsonSerializer.Deserialize<List<string>>(json);
+            return list is null ? [] : list.Select(Normalize).Where(p => p.Length > 0).ToArray();
+        }
+        catch (System.Text.Json.JsonException) { return []; }
+    }
+
+    public static bool IsIncludedRepo(string? workingDir, string[] excludes)
+    {
+        if (string.IsNullOrWhiteSpace(workingDir)) return false; // not a repo → excluded
+        var norm = Normalize(workingDir);
+        return !excludes.Any(p => norm.StartsWith(p, StringComparison.OrdinalIgnoreCase));
+    }
+
+    private static string Normalize(string path) =>
+        path.Trim().Replace('/', '\\').TrimEnd('\\');
+}
+```
+
+Add `using ClaudeDo.Data.Repositories;` if not already present (it is, via existing usings).
+
+- [ ] **Step 6: Run the test — expect PASS.**
+
+- [ ] **Step 7: Commit.**
+
+```bash
+git add src/ClaudeDo.Worker/External/ExternalMcpService.cs tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs
+git commit -m "feat(daily-prep): add get_daily_prep_candidates MCP tool"
+```
+
+---
+
+## Task 3: `set_my_day` MCP tool with cap-guard
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/External/ExternalMcpService.cs`
+- Test: `tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs`
+
+- [ ] **Step 1: Write the failing tests.**
+
+```csharp
+[Fact]
+public async Task SetMyDay_sets_flag_and_sort_order()
+{
+    var svc = NewService();
+    var id = await SeedIdleTask("My task"); // existing/added helper returning task id
+
+    var dto = await svc.SetMyDay(id, isMyDay: true, sortOrder: 3, CancellationToken.None);
+
+    Assert.True(dto.IsMyDay);
+    Assert.Equal(3, dto.SortOrder);
+}
+
+[Fact]
+public async Task SetMyDay_rejects_when_cap_reached()
+{
+    // AppSettings.DailyPrepMaxTasks = 1 (set in seed)
+    var svc = NewService();
+    var first = await SeedIdleTask("a");
+    var second = await SeedIdleTask("b");
+    await svc.SetMyDay(first, true, null, CancellationToken.None);
+
+    var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+        () => svc.SetMyDay(second, true, null, CancellationToken.None));
+    Assert.Contains("limit", ex.Message, StringComparison.OrdinalIgnoreCase);
+}
+
+[Fact]
+public async Task SetMyDay_unset_is_always_allowed()
+{
+    var svc = NewService();
+    var id = await SeedIdleTask("a");
+    await svc.SetMyDay(id, true, null, CancellationToken.None);
+
+    var dto = await svc.SetMyDay(id, false, null, CancellationToken.None);
+    Assert.False(dto.IsMyDay);
+}
+```
+
+`SetMyDay` returns the existing `TaskDto`. Add a `SortOrder` field to `TaskDto` — see Step 3a. (`SeedIdleTask` / the `DailyPrepMaxTasks=1` seed reuse the file's existing seeding helpers.)
+
+- [ ] **Step 2: Run — expect FAIL.**
+
+- [ ] **Step 3a: Add `SortOrder` to `TaskDto`** (record + `ToDto`) so the result reflects ordering:
+
+In the `TaskDto` record add `int SortOrder` as the last positional member, and in `ToDto(TaskEntity t)` add `t.SortOrder` as the last argument. (Update any test that constructs `TaskDto` positionally — search the test project.)
+
+- [ ] **Step 3b: Add the tool method:**
+
+```csharp
+[McpServerTool, Description(
+    "Daily prep: set or clear a task's MyDay flag, optionally setting its sortOrder " +
+    "(use consecutive sortOrder values to keep related tasks together). " +
+    "Setting isMyDay=true is rejected if it would exceed the MyDay cap (DailyPrepMaxTasks open MyDay tasks); " +
+    "clearing (isMyDay=false) is always allowed.")]
+public async Task<TaskDto> SetMyDay(
+    string taskId,
+    bool isMyDay,
+    int? sortOrder,
+    CancellationToken cancellationToken)
+{
+    await using var ctx = await _dbFactory.CreateDbContextAsync(cancellationToken);
+
+    var task = await ctx.Tasks.FirstOrDefaultAsync(t => t.Id == taskId, cancellationToken)
+        ?? throw new InvalidOperationException($"Task {taskId} not found.");
+
+    if (isMyDay && !task.IsMyDay)
+    {
+        var settings = await new AppSettingsRepository(ctx).GetAsync(cancellationToken);
+        var max = settings.DailyPrepMaxTasks < 1 ? 1 : settings.DailyPrepMaxTasks;
+        var openMyDay = await ctx.Tasks.CountAsync(
+            t => t.IsMyDay && t.Status == TaskStatus.Idle, cancellationToken);
+        if (openMyDay >= max)
+            throw new InvalidOperationException(
+                $"MyDay limit {max} reached. Clear a task before adding another.");
+    }
+
+    task.IsMyDay = isMyDay;
+    if (sortOrder is not null) task.SortOrder = sortOrder.Value;
+    await ctx.SaveChangesAsync(cancellationToken);
+
+    await _broadcaster.TaskUpdated(taskId);
+    return ToDto(task);
+}
+```
+
+- [ ] **Step 4: Run — expect PASS.**
+
+- [ ] **Step 5: Commit.**
+
+```bash
+git add src/ClaudeDo.Worker/External/ExternalMcpService.cs tests/ClaudeDo.Worker.Tests
+git commit -m "feat(daily-prep): add set_my_day MCP tool with cap-guard"
+```
+
+---
+
+## Task 4: Rewrite `PrimeRunner` to run the daily prep
+
+**Files:**
+- Create: `src/ClaudeDo.Worker/Prime/DailyPrepPrompt.cs`
+- Modify: `src/ClaudeDo.Worker/Prime/PrimeRunner.cs`
+- Test: `tests/ClaudeDo.Worker.Tests/Prime/DailyPrepPromptTests.cs`, and extend `PrimeRunnerTests.cs` if it exists
+
+The runner needs the cap `X` (read from `AppSettings`) and today's date. Inject `IDbContextFactory<ClaudeDoDbContext>` into `PrimeRunner` (it is resolvable in the main app DI) and an `IPrimeClock` for the date (already registered).
+
+- [ ] **Step 1: Write failing prompt/args tests.**
+
+```csharp
+public class DailyPrepPromptTests
+{
+    [Fact]
+    public void Build_prompt_contains_cap_and_date()
+    {
+        var prompt = DailyPrepPrompt.BuildPrompt(maxTasks: 5, today: new DateOnly(2026, 6, 3));
+        Assert.Contains("5", prompt);
+        Assert.Contains("2026-06-03", prompt);
+        Assert.Contains("get_daily_prep_candidates", prompt);
+        Assert.Contains("set_my_day", prompt);
+    }
+
+    [Fact]
+    public void Build_args_allows_only_the_two_tools()
+    {
+        var args = DailyPrepPrompt.BuildArgs(maxTurns: 30);
+        Assert.Contains("--output-format stream-json", args);
+        Assert.Contains("--max-turns 30", args);
+        Assert.Contains("--allowedTools", args);
+        Assert.Contains("mcp__claudedo__get_daily_prep_candidates", args);
+        Assert.Contains("mcp__claudedo__set_my_day", args);
+    }
+}
+```
+
+- [ ] **Step 2: Run — expect FAIL.**
+
+- [ ] **Step 3: Create `DailyPrepPrompt.cs`:**
+
+```csharp
+namespace ClaudeDo.Worker.Prime;
+
+public static class DailyPrepPrompt
+{
+    public const string CandidatesTool = "mcp__claudedo__get_daily_prep_candidates";
+    public const string SetMyDayTool = "mcp__claudedo__set_my_day";
+
+    public static string BuildArgs(int maxTurns) =>
+        "-p --output-format stream-json --verbose --permission-mode acceptEdits " +
+        $"--max-turns {maxTurns} " +
+        $"--allowedTools {CandidatesTool} {SetMyDayTool}";
+
+    public static string BuildPrompt(int maxTasks, DateOnly today) =>
+        $"""
+        Du bereitest meinen Arbeitstag fuer {today:yyyy-MM-dd} vor.
+
+        1. Rufe {CandidatesTool} auf.
+        2. Behalte bereits als MyDay markierte offene Tasks (currentMyDay) — entferne sie nicht.
+        3. Fuelle bis maximal {maxTasks} offene Tasks GESAMT in MyDay auf (currentMyDay zaehlt mit). Niemals mehr.
+        4. Schaetze pro Kandidat grob den Aufwand und waehle eine machbare Mischung (nicht nur Grossbrocken).
+           Priorisiere isStarred, faellige (scheduledFor) und aeltere Tasks.
+        5. Lege thematisch verwandte Tasks durch aufeinanderfolgende sortOrder-Werte nebeneinander.
+        6. Setze die Auswahl via {SetMyDayTool}(taskId, true, sortOrder). Markiere nichts ausserhalb der Kandidatenliste.
+
+        Wenn es keine Kandidaten gibt, tue nichts.
+        """;
+}
+```
+
+- [ ] **Step 4: Run prompt tests — expect PASS.**
+
+- [ ] **Step 5: Rewrite `PrimeRunner.cs`:**
+
+```csharp
+using ClaudeDo.Data;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Runner;
+using Microsoft.EntityFrameworkCore;
+
+namespace ClaudeDo.Worker.Prime;
+
+public sealed class PrimeRunner : IPrimeRunner
+{
+    private static readonly TimeSpan FireTimeout = TimeSpan.FromMinutes(5);
+    private const int MaxTurns = 30;
+
+    private readonly IClaudeProcess _claude;
+    private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
+    private readonly IPrimeClock _clock;
+    private readonly ILogger<PrimeRunner> _logger;
+    private readonly SemaphoreSlim _gate = new(1, 1);
+
+    public PrimeRunner(
+        IClaudeProcess claude,
+        IDbContextFactory<ClaudeDoDbContext> dbFactory,
+        IPrimeClock clock,
+        ILogger<PrimeRunner> logger)
+    {
+        _claude = claude;
+        _dbFactory = dbFactory;
+        _clock = clock;
+        _logger = logger;
+    }
+
+    public async Task<PrimeRunOutcome> FireAsync(PrimeScheduleDto schedule, CancellationToken ct)
+    {
+        if (!await _gate.WaitAsync(0, ct))
+            return new PrimeRunOutcome(false, "Daily prep already running");
+
+        try
+        {
+            var cwd = Paths.AppDataRoot();
+            Directory.CreateDirectory(cwd);
+
+            int maxTasks;
+            await using (var dbCtx = await _dbFactory.CreateDbContextAsync(ct))
+            {
+                var settings = await new AppSettingsRepository(dbCtx).GetAsync(ct);
+                maxTasks = settings.DailyPrepMaxTasks < 1 ? 1 : settings.DailyPrepMaxTasks;
+            }
+
+            var today = DateOnly.FromDateTime(_clock.Now.LocalDateTime);
+            var prompt = DailyPrepPrompt.BuildPrompt(maxTasks, today);
+            var args = DailyPrepPrompt.BuildArgs(MaxTurns);
+
+            using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+            timeoutCts.CancelAfter(FireTimeout);
+
+            var result = await _claude.RunAsync(
+                arguments: args,
+                prompt: prompt,
+                workingDirectory: cwd,
+                onStdoutLine: _ => Task.CompletedTask,
+                ct: timeoutCts.Token);
+
+            return result.IsSuccess
+                ? new PrimeRunOutcome(true, "Daily prep complete")
+                : new PrimeRunOutcome(false, $"exit code {result.ExitCode}");
+        }
+        catch (OperationCanceledException) when (!ct.IsCancellationRequested)
+        {
+            return new PrimeRunOutcome(false, $"timed out after {FireTimeout.TotalMinutes:0} min");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Daily prep run failed");
+            return new PrimeRunOutcome(false, ex.Message);
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+}
+```
+
+- [ ] **Step 6: Fix the DI registration is unchanged** (`AddSingleton<IPrimeRunner, PrimeRunner>()` already works — the new ctor deps `IDbContextFactory` and `IPrimeClock` are registered). Build the Worker.
+
+```bash
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+```
+
+- [ ] **Step 7: Update/extend `PrimeRunnerTests.cs`** (if present) to match the new ctor: construct `PrimeRunner` with a fake `IClaudeProcess`, a real temp-SQLite `IDbContextFactory`, a fake `IPrimeClock`, and a logger. Add:
+
+```csharp
+[Fact]
+public async Task FireAsync_returns_already_running_when_gate_held()
+{
+    var runner = NewRunner(claudeDelay: TimeSpan.FromSeconds(2));
+    var schedule = new PrimeScheduleDto(Guid.Empty, 0, TimeSpan.Zero, true, null, null);
+
+    var first = runner.FireAsync(schedule, CancellationToken.None);
+    var second = await runner.FireAsync(schedule, CancellationToken.None);
+
+    Assert.False(second.Success);
+    Assert.Contains("already running", second.Message, StringComparison.OrdinalIgnoreCase);
+    await first;
+}
+```
+
+If no `PrimeRunnerTests.cs` exists, create one. The fake `IClaudeProcess` should optionally delay (to keep the gate held) and return a successful `RunResult { ExitCode = 0, ResultMarkdown = "ok" }`.
+
+- [ ] **Step 8: Run — expect PASS.**
+
+```bash
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter "DailyPrepPrompt|PrimeRunner"
+```
+
+- [ ] **Step 9: Commit.**
+
+```bash
+git add src/ClaudeDo.Worker/Prime tests/ClaudeDo.Worker.Tests/Prime
+git commit -m "feat(daily-prep): run daily prep from PrimeRunner via allowed MCP tools"
+```
+
+---
+
+## Task 5: Hub — `RunDailyPrepNow` + expose `DailyPrepMaxTasks`
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Hub/WorkerHub.cs`
+- Modify: `src/ClaudeDo.Ui/Services/WorkerClient.cs`
+
+Read `WorkerHub.cs` first. It already exposes a `GetAppSettings`/`UpdateAppSettings` pair backed by a DTO record (the one carrying `ReportExcludedPaths`, `StandupWeekday`).
+
+- [ ] **Step 1: Add `DailyPrepMaxTasks` to the hub AppSettings DTO record** (the record near the top of `WorkerHub.cs` that lists `ReportExcludedPaths`). Add `int DailyPrepMaxTasks` as a member. In the read mapping (`GetAppSettings`, where `row.ReportExcludedPaths` is read) add `row.DailyPrepMaxTasks`; in the write mapping (`UpdateAppSettings`, where `ReportExcludedPaths = dto.ReportExcludedPaths`) add `DailyPrepMaxTasks = dto.DailyPrepMaxTasks`.
+
+- [ ] **Step 2: Add the hub method.** Inject `IPrimeRunner` and `HubBroadcaster` if the hub does not already have them (the hub is constructed by SignalR via DI; both are registered singletons). Then:
+
+```csharp
+public async Task<bool> RunDailyPrepNow()
+{
+    var schedule = new PrimeScheduleDto(Guid.Empty, 0, TimeSpan.Zero, true, null, null);
+    var firedAt = DateTimeOffset.Now;
+    var outcome = await _primeRunner.FireAsync(schedule, Context.ConnectionAborted);
+    await _broadcaster.PrimeFired(Guid.Empty, outcome.Success, outcome.Message, firedAt);
+    return outcome.Success;
+}
+```
+
+Add `using ClaudeDo.Worker.Prime;` to `WorkerHub.cs` if missing.
+
+> **Caution (memory):** changing the `WorkerHub` constructor breaks hand-rolled hub-test fakes in `ClaudeDo.Worker.Tests` and possibly `ClaudeDo.Ui.Tests`. After editing, build the test projects and fix every `new WorkerHub(...)` / fake `IWorkerClient` construction the compiler flags.
+
+- [ ] **Step 3: Mirror the DTO in the UI** (`WorkerClient.cs`, the AppSettings DTO around line 498): add `int DailyPrepMaxTasks` to the record (same position as in the hub DTO). Add a `RunDailyPrepNow` client call:
+
+```csharp
+public Task<bool> RunDailyPrepNowAsync() =>
+    _connection.InvokeAsync<bool>("RunDailyPrepNow");
+```
+
+(Match the exact connection field/name and the async-wrapper style used by neighbouring calls like `GenerateWeekReport`.)
+
+- [ ] **Step 4: Build Worker + App + test projects; fix any broken fakes.**
+
+```bash
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+```
+
+- [ ] **Step 5: Commit.**
+
+```bash
+git add src/ClaudeDo.Worker/Hub/WorkerHub.cs src/ClaudeDo.Ui/Services/WorkerClient.cs tests
+git commit -m "feat(daily-prep): add RunDailyPrepNow hub method and expose DailyPrepMaxTasks"
+```
+
+---
+
+## Task 6: Settings UI — edit `DailyPrepMaxTasks`
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/ViewModels/Modals/Settings/PrimeClaudeTabViewModel.cs`
+- Modify: the Prime Claude tab markup in `src/ClaudeDo.Ui/Views/Modals/SettingsModalView.axaml`
+- Modify: `src/ClaudeDo.Ui/ViewModels/Modals/SettingsModalViewModel.cs` (load/save wiring, where other AppSettings fields are mapped)
+
+Read these three files first; mirror how an existing numeric AppSetting (e.g. `MaxParallelExecutions` or `WorktreeAutoCleanupDays`) is loaded from the hub DTO, bound, and saved back.
+
+- [ ] **Step 1: Add an observable property** to `PrimeClaudeTabViewModel.cs`:
+
+```csharp
+[ObservableProperty] private int _dailyPrepMaxTasks = 5;
+```
+
+- [ ] **Step 2: Wire load/save** in `SettingsModalViewModel.cs`: where the AppSettings DTO is read into the tabs, set `PrimeClaude.DailyPrepMaxTasks = dto.DailyPrepMaxTasks;`. Where the DTO is written, include `DailyPrepMaxTasks = PrimeClaude.DailyPrepMaxTasks`. (Use the exact tab property name for the Prime Claude tab in that VM.)
+
+- [ ] **Step 3: Add the editor** in the Prime Claude tab of `SettingsModalView.axaml`, near the schedule list:
+
+```xml
+<StackPanel Orientation="Horizontal" Spacing="8" VerticalAlignment="Center">
+    <TextBlock Text="{x:Static loc:L.Settings_DailyPrepMaxTasks}" VerticalAlignment="Center"/>
+    <NumericUpDown Minimum="1" Maximum="50" Increment="1" Width="100"
+                   Value="{Binding PrimeClaude.DailyPrepMaxTasks}"/>
+</StackPanel>
+```
+
+Add the `Settings_DailyPrepMaxTasks` key to both `locales/en.json` and `locales/de.json` (en: "Max tasks per day", de: "Max. Aufgaben pro Tag"). If the tab does not use localized labels yet, use a plain `Text="Max tasks per day"` string to match its current style.
+
+- [ ] **Step 4: Build the App; smoke-build the UI.**
+
+```bash
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+```
+
+- [ ] **Step 5: Commit.**
+
+```bash
+git add src/ClaudeDo.Ui src/ClaudeDo.Localization
+git commit -m "feat(daily-prep): add DailyPrepMaxTasks editor to Prime Claude settings"
+```
+
+---
+
+## Task 7: MyDay header — "Tag vorbereiten" button
+
+**Files:**
+- Modify: the ViewModel backing the MyDay list view (the one that exposes the smart-list header/toolbar; find it under `src/ClaudeDo.Ui/ViewModels/Islands/` — likely the tasks/list island VM that has access to `IWorkerClient`)
+- Modify: the corresponding view (`.axaml`) that renders the list header
+
+Read the island VM + view first. Find where the active list is known to be `smart:my-day` so the button can be shown only there (mirror any existing conditional header content). The VM already holds a worker-client reference used by other commands (e.g. RunNow) — reuse it.
+
+- [ ] **Step 1: Add the command** to the island VM:
+
+```csharp
+[RelayCommand]
+private async Task PrepareDayAsync()
+{
+    await _workerClient.RunDailyPrepNowAsync();
+}
+```
+
+(Use the VM's existing worker-client field name. The MyDay list refreshes automatically via the `TaskUpdated` broadcast the tools emit, so no manual reload is needed.)
+
+- [ ] **Step 2: Add an `IsMyDayList` (or reuse existing selected-list) guard** so the button only appears on the MyDay smart list. If the VM already exposes the selected list id, add:
+
+```csharp
+public bool IsMyDayList => SelectedListId == "smart:my-day";
+```
+
+and raise its change notification wherever `SelectedListId` changes (mirror existing patterns; if a `[NotifyPropertyChangedFor]` or manual `OnPropertyChanged` is already used for the selection, add this property to it).
+
+- [ ] **Step 3: Add the button** to the list header in the view, visible only on MyDay:
+
+```xml
+<Button Content="{x:Static loc:L.MyDay_PrepareDay}"
+        Command="{Binding PrepareDayCommand}"
+        IsVisible="{Binding IsMyDayList}"/>
+```
+
+Add `MyDay_PrepareDay` to `locales/en.json` ("Prepare day") and `locales/de.json` ("Tag vorbereiten"), or a plain string if the view is not localized.
+
+- [ ] **Step 4: Build the App.**
+
+```bash
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+```
+
+- [ ] **Step 5: Manual smoke (cannot be unit-tested):** start the Worker and App, open MyDay, click "Tag vorbereiten", confirm tasks appear (capped) and the button is hidden on other lists. Report results explicitly — do not claim UI success without running it.
+
+- [ ] **Step 6: Commit.**
+
+```bash
+git add src/ClaudeDo.Ui src/ClaudeDo.Localization
+git commit -m "feat(daily-prep): add Prepare-day button to MyDay header"
+```
+
+---
+
+## Final verification
+
+- [ ] `dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release`
+- [ ] `dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release`
+- [ ] `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release`
+- [ ] `dotnet test tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj -c Release`
+- [ ] `dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release`
+- [ ] End-to-end manual run: schedule fires (or button) → Claude calls the two tools → MyDay gets a capped subset; re-run keeps existing MyDay and tops up without exceeding the cap.
+
+## Notes / risks
+
+- Relies on the globally registered `claudedo` MCP (installer `RegisterMcpStep`). If absent, the prep run produces 0 changes — acceptable for v1.
+- `--permission-mode acceptEdits` + explicit `--allowedTools` pre-approves exactly the two tools so the headless run never blocks on a permission prompt.
+- The cap-guard counts `Idle && IsMyDay` tasks; it is the source of truth for the "never move everything in" invariant regardless of Claude's behavior.
+- Future phase (out of scope): external ticket sources (Jira) feed into `get_daily_prep_candidates` behind a task-source abstraction.

docs/superpowers/plans/2026-06-04-bundled-prompts-overhaul.md

@@ -0,0 +1,972 @@
+# Bundled Prompts Overhaul Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Externalize every bundled prose prompt into editable files with strong defaults, collapse system+agent, and add an inline `CLAUDEDO_BLOCKED:` roadblock protocol surfaced at review.
+
+**Architecture:** `PromptFiles` becomes the single source of prompt defaults + a pure token renderer. Each consumer (TaskRunner, PlanningSessionManager, DailyPrepPrompt, WeekReportPromptBuilder) reads its prompt via `PromptFiles`. `StreamAnalyzer` collects roadblock markers from streamed assistant text; the runner folds them into the review result.
+
+**Tech Stack:** .NET 8, xUnit, EF Core (no schema change in this plan).
+
+Spec: `docs/superpowers/specs/2026-06-04-bundled-prompts-overhaul-design.md`
+
+---
+
+## File structure
+
+- `src/ClaudeDo.Data/PromptFiles.cs` — new `PromptKind` members, new defaults, `RenderTemplate` + `ReadOrDefault` + `Render`.
+- `src/ClaudeDo.Worker/Runner/StreamAnalyzer.cs` — collect `Blocks` from assistant text.
+- `src/ClaudeDo.Worker/Runner/RunResult.cs` — carry `Blocks`.
+- `src/ClaudeDo.Worker/Runner/ClaudeProcess.cs` — pass `Blocks`; expose no-result prefix const.
+- `src/ClaudeDo.Worker/Runner/TaskRunner.cs` — drop agent file; retry via `retry.md`; fold blocks into review result.
+- `src/ClaudeDo.Worker/Planning/PlanningSessionManager.cs` — read planning prompts via `PromptFiles`.
+- `src/ClaudeDo.Worker/Prime/DailyPrepPrompt.cs` — read `daily-prep.md`.
+- `src/ClaudeDo.Worker/Report/WeekReportPromptBuilder.cs` — read `weekly-report.md`.
+- `src/ClaudeDo.Ui/ViewModels/Modals/Settings/FilesSettingsTabViewModel.cs` + its view — expose new prompt files, drop agent.
+- Tests in `tests/ClaudeDo.Data.Tests` and `tests/ClaudeDo.Worker.Tests`.
+
+Build commands (this repo is on .NET 8 — build per project, not the .slnx):
+```bash
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+dotnet test  tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj -c Release
+dotnet test  tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+```
+
+---
+
+## Task 1: PromptFiles — kinds, defaults, pure renderer
+
+**Files:**
+- Modify: `src/ClaudeDo.Data/PromptFiles.cs`
+- Test: `tests/ClaudeDo.Data.Tests/PromptFilesTests.cs` (create)
+
+- [ ] **Step 1: Write failing tests for the pure renderer**
+
+Create `tests/ClaudeDo.Data.Tests/PromptFilesTests.cs`:
+
+```csharp
+using ClaudeDo.Data;
+
+namespace ClaudeDo.Data.Tests;
+
+public class PromptFilesTests
+{
+    [Fact]
+    public void RenderTemplate_replaces_known_tokens()
+    {
+        var outp = PromptFiles.RenderTemplate(
+            "Plan for {date}, cap {maxTasks}.",
+            new Dictionary<string, string> { ["date"] = "2026-06-04", ["maxTasks"] = "5" });
+        Assert.Equal("Plan for 2026-06-04, cap 5.", outp);
+    }
+
+    [Fact]
+    public void RenderTemplate_leaves_unknown_braces_intact()
+    {
+        var outp = PromptFiles.RenderTemplate(
+            "## {Wochentag}, {dd.MM.yyyy} — {start}",
+            new Dictionary<string, string> { ["start"] = "01.06.2026" });
+        Assert.Equal("## {Wochentag}, {dd.MM.yyyy} — 01.06.2026", outp);
+    }
+
+    [Fact]
+    public void DefaultFor_system_mentions_blocked_marker_and_scope()
+    {
+        var d = PromptFiles.DefaultFor(PromptKind.System);
+        Assert.Contains("CLAUDEDO_BLOCKED:", d);
+        Assert.Contains("unattended", d, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void DefaultFor_planning_initial_has_title_and_description_tokens()
+    {
+        var d = PromptFiles.DefaultFor(PromptKind.PlanningInitial);
+        Assert.Contains("{title}", d);
+        Assert.Contains("{description}", d);
+    }
+
+    [Fact]
+    public void PathFor_planning_is_planning_system_file()
+    {
+        Assert.EndsWith("planning-system.md", PromptFiles.PathFor(PromptKind.Planning));
+    }
+}
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `dotnet test tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj -c Release`
+Expected: FAIL — `RenderTemplate`/`DefaultFor` don't exist, `PromptKind.PlanningInitial` undefined.
+
+- [ ] **Step 3: Rewrite PromptFiles.cs**
+
+Replace the entire contents of `src/ClaudeDo.Data/PromptFiles.cs` with:
+
+```csharp
+using System.Text;
+
+namespace ClaudeDo.Data;
+
+public enum PromptKind { System, Planning, PlanningInitial, Retry, DailyPrep, WeeklyReport }
+
+public static class PromptFiles
+{
+    public static string Root => Path.Combine(Paths.AppDataRoot(), "prompts");
+
+    public static string PathFor(PromptKind kind) => kind switch
+    {
+        PromptKind.System => Path.Combine(Root, "system.md"),
+        PromptKind.Planning => Path.Combine(Root, "planning-system.md"),
+        PromptKind.PlanningInitial => Path.Combine(Root, "planning-initial.md"),
+        PromptKind.Retry => Path.Combine(Root, "retry.md"),
+        PromptKind.DailyPrep => Path.Combine(Root, "daily-prep.md"),
+        PromptKind.WeeklyReport => Path.Combine(Root, "weekly-report.md"),
+        _ => throw new ArgumentOutOfRangeException(nameof(kind))
+    };
+
+    public static void EnsureExists(PromptKind kind)
+    {
+        Directory.CreateDirectory(Root);
+        var path = PathFor(kind);
+        if (File.Exists(path)) return;
+        File.WriteAllText(path, DefaultFor(kind));
+    }
+
+    public static string? ReadOrNull(PromptKind kind)
+    {
+        var path = PathFor(kind);
+        if (!File.Exists(path)) return null;
+        var content = File.ReadAllText(path).Trim();
+        return string.IsNullOrEmpty(content) ? null : content;
+    }
+
+    /// <summary>File content if present and non-empty, otherwise the bundled default.</summary>
+    public static string ReadOrDefault(PromptKind kind) => ReadOrNull(kind) ?? DefaultFor(kind);
+
+    /// <summary>Render a prompt: read file-or-default, then substitute named tokens.</summary>
+    public static string Render(PromptKind kind, IReadOnlyDictionary<string, string> values)
+        => RenderTemplate(ReadOrDefault(kind), values);
+
+    /// <summary>Replace only the given {name} tokens; any other braces pass through untouched.</summary>
+    public static string RenderTemplate(string template, IReadOnlyDictionary<string, string> values)
+    {
+        var sb = new StringBuilder(template);
+        foreach (var (key, val) in values)
+            sb.Replace("{" + key + "}", val);
+        return sb.ToString();
+    }
+
+    public static string DefaultFor(PromptKind kind) => kind switch
+    {
+        PromptKind.System => SystemDefault,
+        PromptKind.Planning => PlanningSystemDefault,
+        PromptKind.PlanningInitial => PlanningInitialDefault,
+        PromptKind.Retry => RetryDefault,
+        PromptKind.DailyPrep => DailyPrepDefault,
+        PromptKind.WeeklyReport => WeeklyReportDefault,
+        _ => ""
+    };
+
+    private const string SystemDefault = """
+        # Working Agreement
+
+        You are completing one well-defined task autonomously in a git repository.
+
+        ## Scope
+        - Do exactly what the task asks — no unrequested refactors, renames, dependency
+          changes, or "while I'm here" cleanup.
+        - If intent is ambiguous, state the assumption you're making and proceed with the
+          most reasonable reading. Stop only if you genuinely cannot move forward.
+        - Prefer three similar lines over a premature abstraction. Don't build for
+          hypothetical future needs.
+
+        ## Working in the repo
+        - Read a file before editing it. Match the conventions already in this codebase —
+          they override generic defaults.
+        - Prefer editing existing files to creating new ones. Don't write comments that
+          just restate the code.
+        - Validate only at real boundaries (user input, external APIs).
+
+        ## Finishing
+        - Before claiming done, verify: run the build and relevant tests, confirm they
+          pass, and report what you ran. If you couldn't verify something, say so plainly.
+        - Make focused commits using the repository's existing commit-message convention.
+
+        ## Safety
+        - Never force-push, hard-reset, or delete branches/files beyond the task's scope
+          without being asked.
+        - Don't introduce injection/XSS/secret-leak issues. Never commit credentials.
+
+        ## You are running unattended
+        You run autonomously with no human watching. There is no one to answer mid-task
+        questions, so never stop to ask — make the most reasonable decision, note the
+        assumption, and continue.
+
+        ## When you are blocked
+        If something genuinely prevents you from completing part of the task (missing
+        credentials, contradictory requirements, a destructive action you won't take
+        unasked), do NOT silently give up. Write this marker on its own line, then keep
+        working on whatever else you can:
+
+        CLAUDEDO_BLOCKED: <one short sentence describing what blocked you>
+
+        Emit it as many times as needed — once per distinct blocker. Use it only for true
+        blockers, not for routine decisions you can make yourself.
+        """;
+
+    private const string PlanningSystemDefault = """
+        You are the planning assistant for ClaudeDo. Your job is to break a task into
+        smaller, independently executable subtasks — the session ends by creating those
+        subtasks.
+
+        Start every session by invoking the `superpowers:brainstorming` skill (Skill
+        tool) and follow it end to end: clarifying questions one at a time, then 2–3
+        approaches with a recommendation, then a short design. Do not create any subtasks
+        until the user has approved the design.
+
+        You can ONLY shape this task's plan — you cannot edit files or touch other tasks.
+        The tools available to you are: CreateChildTask, ListChildTasks, UpdateChildTask,
+        DeleteChildTask, UpdatePlanningTask, and Finalize. Use nothing else.
+
+        Once the design is approved, create the child tasks with CreateChildTask, then
+        call Finalize. Keep each subtask concrete and self-contained with a clear
+        done-state, ordered so dependencies come first.
+        """;
+
+    private const string PlanningInitialDefault = """
+        # Task to plan: {title}
+
+        {description}
+        """;
+
+    private const string RetryDefault = """
+        The task did not complete on the previous attempt — you may have run out of
+        turns, hit an error, or stopped before finishing.
+
+        Review the work already done in this session and the current state of the
+        repository, identify what is still incomplete or broken, and finish the task.
+        Don't restart from scratch or repeat a failed approach. Verify the result
+        (build + tests) before you stop.
+        """;
+
+    private const string DailyPrepDefault = """
+        You are preparing my workday for {date}.
+
+        1. Call mcp__claudedo__get_daily_prep_candidates.
+        2. Keep tasks already marked MyDay (currentMyDay) — never remove them.
+        3. Fill MyDay to at most {maxTasks} open tasks TOTAL (currentMyDay counts). Never exceed it.
+        4. Estimate each candidate's effort and pick a feasible mix — not only big items.
+           Prioritize isStarred, due (scheduledFor), and older tasks.
+        5. Place related tasks next to each other using consecutive sortOrder values.
+        6. Apply via mcp__claudedo__set_my_day(taskId, true, sortOrder). Never mark anything
+           outside the candidate list.
+
+        If there are no candidates, do nothing.
+        """;
+
+    private const string WeeklyReportDefault = """
+        You are generating a concise weekly standup report for a software developer,
+        covering {start} to {end}.
+
+        Rules:
+        - Write the ENTIRE report in German.
+        - Group by day. One "## {Wochentag}, {dd.MM.yyyy}" section per day that has
+          activity (German weekday names). Omit days with no activity.
+        - Within each day: 3–5 first-person, past-tense bullets ("- Habe X umgesetzt",
+          "- Y behoben"). Merge related small work into one bullet.
+        - Drop trivia: typo fixes, pure exploration, false starts, tooling/log noise.
+        - Blend the developer's own notes and the derived activity into ONE deduplicated
+          bullet list per day. The notes are authoritative — never omit or contradict them.
+        - Name the project/repo when it adds clarity.
+        - Output ONLY the dated sections. No preamble, no intro, no closing remarks.
+
+        Two sections follow below: an activity log derived from Claude session history,
+        and the developer's own notes. Base the report on both; the notes are
+        authoritative where they conflict with the derived activity.
+        """;
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `dotnet test tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj -c Release`
+Expected: PASS (5 new tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Data/PromptFiles.cs tests/ClaudeDo.Data.Tests/PromptFilesTests.cs
+git commit -m "feat(prompts): externalize prompt kinds with defaults and token renderer"
+```
+
+---
+
+## Task 2: TaskRunner — drop agent file from system prompt merge
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Runner/TaskRunner.cs:382-386`
+
+- [ ] **Step 1: Remove the agent-file read and merge**
+
+In `ResolveConfigAsync`, replace:
+
+```csharp
+        var systemFile = PromptFiles.ReadOrNull(PromptKind.System);
+        var agentFile = PromptFiles.ReadOrNull(PromptKind.Agent);
+
+        var instructions = MergeInstructions(
+            systemFile, global.DefaultClaudeInstructions, listConfig?.SystemPrompt, task.SystemPrompt, agentFile);
+```
+
+with:
+
+```csharp
+        var systemFile = PromptFiles.ReadOrNull(PromptKind.System);
+
+        var instructions = MergeInstructions(
+            systemFile, global.DefaultClaudeInstructions, listConfig?.SystemPrompt, task.SystemPrompt);
+```
+
+- [ ] **Step 2: Build to verify it compiles**
+
+Run: `dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release`
+Expected: PASS (no reference to `PromptKind.Agent` remains).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/Runner/TaskRunner.cs
+git commit -m "refactor(prompts): collapse agent prompt into system prompt"
+```
+
+---
+
+## Task 3: Retry prompt from file + conditional stderr append
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Runner/ClaudeProcess.cs:101-103` (expose prefix const)
+- Modify: `src/ClaudeDo.Worker/Runner/TaskRunner.cs` (add `BuildRetryPrompt`, use it at ~L107)
+- Test: `tests/ClaudeDo.Worker.Tests/Runner/RetryPromptTests.cs` (create)
+
+- [ ] **Step 1: Write failing tests for the retry-prompt helper**
+
+Create `tests/ClaudeDo.Worker.Tests/Runner/RetryPromptTests.cs`:
+
+```csharp
+using ClaudeDo.Worker.Runner;
+
+namespace ClaudeDo.Worker.Tests.Runner;
+
+public class RetryPromptTests
+{
+    [Fact]
+    public void Generic_no_result_error_is_not_appended()
+    {
+        var prompt = TaskRunner.BuildRetryPrompt($"{ClaudeProcess.NoResultPrefix} 1 and no result.");
+        Assert.DoesNotContain("Captured error", prompt);
+        Assert.Contains("did not complete", prompt);
+    }
+
+    [Fact]
+    public void Real_error_is_appended()
+    {
+        var prompt = TaskRunner.BuildRetryPrompt("error CS1002: ; expected");
+        Assert.Contains("Captured error", prompt);
+        Assert.Contains("CS1002", prompt);
+    }
+
+    [Fact]
+    public void Null_error_yields_bare_prompt()
+    {
+        var prompt = TaskRunner.BuildRetryPrompt(null);
+        Assert.DoesNotContain("Captured error", prompt);
+    }
+}
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter RetryPromptTests`
+Expected: FAIL — `BuildRetryPrompt` / `NoResultPrefix` don't exist.
+
+- [ ] **Step 3: Expose the no-result prefix in ClaudeProcess**
+
+In `src/ClaudeDo.Worker/Runner/ClaudeProcess.cs`, add the const near the top of the class and use it in the error fallback. Replace:
+
+```csharp
+        var error = lastStderr.Length > 0
+            ? lastStderr.ToString().Trim()
+            : $"Claude exited with code {exitCode} and no result.";
+```
+
+with:
+
+```csharp
+        var error = lastStderr.Length > 0
+            ? lastStderr.ToString().Trim()
+            : $"{NoResultPrefix} {exitCode} and no result.";
+```
+
+and add inside the class (e.g. just below the fields):
+
+```csharp
+    public const string NoResultPrefix = "Claude exited with code";
+```
+
+- [ ] **Step 4: Add BuildRetryPrompt to TaskRunner and use it**
+
+In `src/ClaudeDo.Worker/Runner/TaskRunner.cs`, add this static method (next to `MergeInstructions`):
+
+```csharp
+    public static string BuildRetryPrompt(string? capturedError)
+    {
+        var basePrompt = PromptFiles.ReadOrDefault(PromptKind.Retry);
+        var isReal = !string.IsNullOrWhiteSpace(capturedError)
+            && !capturedError!.StartsWith(ClaudeProcess.NoResultPrefix, StringComparison.Ordinal);
+        return isReal
+            ? $"{basePrompt}\n\nCaptured error from the failed run:\n\n{capturedError!.Trim()}"
+            : basePrompt;
+    }
+```
+
+Then replace the inline retry prompt at ~L107:
+
+```csharp
+                    var retryPrompt = $"The previous attempt failed with:\n\n{result.ErrorMarkdown}\n\nTry again and fix the issues.";
+```
+
+with:
+
+```csharp
+                    var retryPrompt = BuildRetryPrompt(result.ErrorMarkdown);
+```
+
+- [ ] **Step 5: Run tests to verify they pass**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter RetryPromptTests`
+Expected: PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/Runner/ClaudeProcess.cs src/ClaudeDo.Worker/Runner/TaskRunner.cs tests/ClaudeDo.Worker.Tests/Runner/RetryPromptTests.cs
+git commit -m "feat(prompts): retry prompt from file, append only real captured errors"
+```
+
+---
+
+## Task 4: PlanningSessionManager reads planning prompts from files
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Planning/PlanningSessionManager.cs` (`BuildSystemPrompt` ~L366, `BuildInitialPrompt` ~L392)
+
+- [ ] **Step 1: Replace BuildSystemPrompt body**
+
+Replace the whole method body of `BuildSystemPrompt()` with:
+
+```csharp
+    private static string BuildSystemPrompt() => PromptFiles.ReadOrDefault(PromptKind.Planning);
+```
+
+(Delete the inline fallback string literal that followed.)
+
+- [ ] **Step 2: Replace BuildInitialPrompt body**
+
+Replace the whole method body of `BuildInitialPrompt(TaskEntity task)` with:
+
+```csharp
+    private static string BuildInitialPrompt(TaskEntity task) =>
+        PromptFiles.Render(PromptKind.PlanningInitial, new Dictionary<string, string>
+        {
+            ["title"] = task.Title,
+            ["description"] = task.Description ?? "",
+        });
+```
+
+Ensure `using ClaudeDo.Data;` is present (it is — `PromptFiles` lived there already via `ReadOrNull`).
+
+- [ ] **Step 3: Build to verify it compiles**
+
+Run: `dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release`
+Expected: PASS.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/Planning/PlanningSessionManager.cs
+git commit -m "refactor(prompts): planning prompts read from editable files"
+```
+
+---
+
+## Task 5: DailyPrepPrompt reads from file
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Prime/DailyPrepPrompt.cs`
+- Modify: `tests/ClaudeDo.Worker.Tests/Prime/DailyPrepPromptTests.cs`
+
+- [ ] **Step 1: Update DailyPrepPromptTests to assert the English default render**
+
+Replace the `Build_prompt_contains_cap_and_date` test body with:
+
+```csharp
+    [Fact]
+    public void Build_prompt_contains_cap_and_date()
+    {
+        var prompt = DailyPrepPrompt.BuildPrompt(maxTasks: 5, today: new DateOnly(2026, 6, 3));
+        Assert.Contains("5", prompt);
+        Assert.Contains("2026-06-03", prompt);
+        Assert.Contains("get_daily_prep_candidates", prompt);
+        Assert.Contains("set_my_day", prompt);
+        Assert.Contains("preparing my workday", prompt);
+    }
+```
+
+(The new assertion pins the English default; the file-read path is exercised by the same default when no `daily-prep.md` exists.)
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter DailyPrepPromptTests`
+Expected: FAIL — current German prompt has no "preparing my workday".
+
+- [ ] **Step 3: Rewrite BuildPrompt to read the file**
+
+In `src/ClaudeDo.Worker/Prime/DailyPrepPrompt.cs`, replace the `BuildPrompt` method with:
+
+```csharp
+    public static string BuildPrompt(int maxTasks, DateOnly today) =>
+        ClaudeDo.Data.PromptFiles.Render(
+            ClaudeDo.Data.PromptKind.DailyPrep,
+            new Dictionary<string, string>
+            {
+                ["date"] = today.ToString("yyyy-MM-dd"),
+                ["maxTasks"] = maxTasks.ToString(),
+            });
+```
+
+Leave `BuildArgs`, `LogPath`, and the tool-name consts unchanged.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter DailyPrepPromptTests`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/Prime/DailyPrepPrompt.cs tests/ClaudeDo.Worker.Tests/Prime/DailyPrepPromptTests.cs
+git commit -m "feat(prompts): daily-prep prompt from file, English default"
+```
+
+---
+
+## Task 6: WeekReportPromptBuilder reads instructions from file
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Report/WeekReportPromptBuilder.cs`
+- Check: `tests/ClaudeDo.Worker.Tests/Report/WeekReportPromptBuilderTests.cs`
+
+- [ ] **Step 1: Replace the inline Instructions with a file read**
+
+In `WeekReportPromptBuilder.Build`, replace:
+
+```csharp
+        var sb = new StringBuilder();
+        sb.AppendLine(string.Format(CultureInfo.InvariantCulture, Instructions,
+            start.ToString("dd.MM.yyyy", CultureInfo.InvariantCulture),
+            end.ToString("dd.MM.yyyy", CultureInfo.InvariantCulture)));
+        sb.AppendLine();
+```
+
+with:
+
+```csharp
+        var sb = new StringBuilder();
+        sb.AppendLine(ClaudeDo.Data.PromptFiles.Render(
+            ClaudeDo.Data.PromptKind.WeeklyReport,
+            new Dictionary<string, string>
+            {
+                ["start"] = start.ToString("dd.MM.yyyy", CultureInfo.InvariantCulture),
+                ["end"] = end.ToString("dd.MM.yyyy", CultureInfo.InvariantCulture),
+            }));
+        sb.AppendLine();
+```
+
+Then delete the now-unused `private const string Instructions = ...` block. (The `{Wochentag}`/`{dd.MM.yyyy}` literals inside the default survive because `RenderTemplate` only replaces `{start}`/`{end}`.)
+
+- [ ] **Step 2: Verify the existing builder test still passes**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter WeekReportPromptBuilderTests`
+Expected: PASS. If a test asserted exact old wording, update it to assert the date appears and that activity/notes sections render (the new default keeps German output rules).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/Report/WeekReportPromptBuilder.cs tests/ClaudeDo.Worker.Tests/Report/WeekReportPromptBuilderTests.cs
+git commit -m "feat(prompts): weekly-report instructions from file, point at data sections"
+```
+
+---
+
+## Task 7: StreamAnalyzer collects roadblock markers
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Runner/StreamAnalyzer.cs`
+- Test: `tests/ClaudeDo.Worker.Tests/Runner/StreamAnalyzerTests.cs`
+
+- [ ] **Step 1: Write failing tests**
+
+Append to `StreamAnalyzerTests`:
+
+```csharp
+    [Fact]
+    public void Collects_Blocked_Markers_From_Assistant_Text()
+    {
+        var analyzer = new StreamAnalyzer();
+        analyzer.ProcessLine("""{"type":"assistant","message":{"content":[{"type":"text","text":"working\nCLAUDEDO_BLOCKED: missing API key\nmoving on"}]}}""");
+        analyzer.ProcessLine("""{"type":"assistant","message":{"content":[{"type":"text","text":"CLAUDEDO_BLOCKED: cannot reach db"}]}}""");
+        analyzer.ProcessLine("""{"type":"result","result":"done","session_id":"s1"}""");
+        var result = analyzer.GetResult();
+        Assert.Equal(2, result.Blocks.Count);
+        Assert.Equal("missing API key", result.Blocks[0]);
+        Assert.Equal("cannot reach db", result.Blocks[1]);
+    }
+
+    [Fact]
+    public void Strips_Blocked_Markers_From_Result_Text()
+    {
+        var analyzer = new StreamAnalyzer();
+        analyzer.ProcessLine("""{"type":"result","result":"All set.\nCLAUDEDO_BLOCKED: no creds\nDone.","session_id":"s1"}""");
+        var result = analyzer.GetResult();
+        Assert.DoesNotContain("CLAUDEDO_BLOCKED", result.ResultMarkdown);
+        Assert.Single(result.Blocks);
+        Assert.Equal("no creds", result.Blocks[0]);
+    }
+
+    [Fact]
+    public void No_Markers_Means_Empty_Blocks()
+    {
+        var analyzer = new StreamAnalyzer();
+        analyzer.ProcessLine("""{"type":"result","result":"done","session_id":"s1"}""");
+        Assert.Empty(analyzer.GetResult().Blocks);
+    }
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter StreamAnalyzerTests`
+Expected: FAIL — `Blocks` doesn't exist.
+
+- [ ] **Step 3: Implement marker collection in StreamAnalyzer**
+
+In `src/ClaudeDo.Worker/Runner/StreamAnalyzer.cs`:
+
+Add to `StreamResult`:
+
+```csharp
+    public IReadOnlyList<string> Blocks { get; set; } = Array.Empty<string>();
+```
+
+Add a field and a constant to `StreamAnalyzer`:
+
+```csharp
+    private readonly List<string> _blocks = new();
+    private const string BlockedPrefix = "CLAUDEDO_BLOCKED:";
+```
+
+In the `case "result":` branch, after `_resultMarkdown` is assigned, scan and strip:
+
+```csharp
+                    if (root.TryGetProperty("result", out var resultProp))
+                        _resultMarkdown = StripAndCollect(resultProp.GetString());
+```
+
+In the `case "assistant":` branch, collect from text content (keep `_turnCount++`):
+
+```csharp
+                case "assistant":
+                    _turnCount++;
+                    CollectFromAssistant(root);
+                    break;
+```
+
+Add these helpers to the class:
+
+```csharp
+    private void CollectFromAssistant(JsonElement root)
+    {
+        if (!root.TryGetProperty("message", out var msg)) return;
+        if (!msg.TryGetProperty("content", out var content) || content.ValueKind != JsonValueKind.Array) return;
+        foreach (var block in content.EnumerateArray())
+            if (block.TryGetProperty("type", out var t) && t.GetString() == "text"
+                && block.TryGetProperty("text", out var txt))
+                ScanForBlocks(txt.GetString());
+    }
+
+    private void ScanForBlocks(string? text)
+    {
+        if (string.IsNullOrEmpty(text)) return;
+        foreach (var line in text.Split('\n'))
+        {
+            var trimmed = line.Trim();
+            if (trimmed.StartsWith(BlockedPrefix, StringComparison.Ordinal))
+                _blocks.Add(trimmed[BlockedPrefix.Length..].Trim());
+        }
+    }
+
+    private string? StripAndCollect(string? text)
+    {
+        if (string.IsNullOrEmpty(text)) return text;
+        ScanForBlocks(text);
+        var kept = text.Split('\n')
+            .Where(l => !l.Trim().StartsWith(BlockedPrefix, StringComparison.Ordinal));
+        return string.Join('\n', kept).Trim();
+    }
+```
+
+Add `Blocks = _blocks` to the `GetResult()` initializer:
+
+```csharp
+    public StreamResult GetResult() => new()
+    {
+        ResultMarkdown = FallbackResult(),
+        StructuredOutputJson = _structuredOutputJson,
+        SessionId = _sessionId,
+        TurnCount = _turnCount,
+        TokensIn = _tokensIn,
+        TokensOut = _tokensOut,
+        ApiRetryCount = _apiRetryCount,
+        Blocks = _blocks,
+    };
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter StreamAnalyzerTests`
+Expected: PASS (all old + 3 new).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/Runner/StreamAnalyzer.cs tests/ClaudeDo.Worker.Tests/Runner/StreamAnalyzerTests.cs
+git commit -m "feat(roadblock): collect and strip CLAUDEDO_BLOCKED markers in StreamAnalyzer"
+```
+
+---
+
+## Task 8: RunResult + ClaudeProcess carry Blocks
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Runner/RunResult.cs`
+- Modify: `src/ClaudeDo.Worker/Runner/ClaudeProcess.cs:89-113`
+
+- [ ] **Step 1: Add Blocks to RunResult**
+
+In `src/ClaudeDo.Worker/Runner/RunResult.cs`, add inside the class:
+
+```csharp
+    public IReadOnlyList<string> Blocks { get; init; } = Array.Empty<string>();
+```
+
+- [ ] **Step 2: Populate Blocks in both RunResult returns**
+
+In `ClaudeProcess.RunAsync`, add `Blocks = streamResult.Blocks,` to **both** the success `RunResult { ... }` (after `TokensOut`) and the error `RunResult { ... }` initializer.
+
+- [ ] **Step 3: Build to verify it compiles**
+
+Run: `dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release`
+Expected: PASS.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/Runner/RunResult.cs src/ClaudeDo.Worker/Runner/ClaudeProcess.cs
+git commit -m "feat(roadblock): carry blocks through RunResult"
+```
+
+---
+
+## Task 9: Fold roadblocks into the review result
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Runner/TaskRunner.cs` (`HandleSuccess` ~L319-352; add `ComposeReviewResult`)
+- Test: `tests/ClaudeDo.Worker.Tests/Runner/ReviewResultTests.cs` (create)
+
+- [ ] **Step 1: Write failing tests for the compose helper**
+
+Create `tests/ClaudeDo.Worker.Tests/Runner/ReviewResultTests.cs`:
+
+```csharp
+using ClaudeDo.Worker.Runner;
+
+namespace ClaudeDo.Worker.Tests.Runner;
+
+public class ReviewResultTests
+{
+    [Fact]
+    public void No_blocks_returns_result_unchanged()
+    {
+        Assert.Equal("done", TaskRunner.ComposeReviewResult("done", Array.Empty<string>()));
+    }
+
+    [Fact]
+    public void Blocks_are_appended_as_a_section()
+    {
+        var outp = TaskRunner.ComposeReviewResult("done", new[] { "no creds", "db down" });
+        Assert.Contains("⚠ Roadblocks", outp);
+        Assert.Contains("- no creds", outp);
+        Assert.Contains("- db down", outp);
+        Assert.Contains("done", outp);
+    }
+
+    [Fact]
+    public void Null_result_with_blocks_still_lists_them()
+    {
+        var outp = TaskRunner.ComposeReviewResult(null, new[] { "x" });
+        Assert.Contains("⚠ Roadblocks", outp);
+        Assert.Contains("- x", outp);
+    }
+}
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter ReviewResultTests`
+Expected: FAIL — `ComposeReviewResult` doesn't exist.
+
+- [ ] **Step 3: Add ComposeReviewResult and use it in HandleSuccess**
+
+In `TaskRunner`, add:
+
+```csharp
+    public static string? ComposeReviewResult(string? result, IReadOnlyList<string> blocks)
+    {
+        if (blocks.Count == 0) return result;
+        var section = "⚠ Roadblocks reported during the run:\n"
+            + string.Join('\n', blocks.Select(b => $"- {b}"));
+        return string.IsNullOrWhiteSpace(result) ? section : $"{result}\n\n{section}";
+    }
+```
+
+In `HandleSuccess`, compute the composed result once and pass it to both terminal writes:
+
+```csharp
+        var finishedAt = DateTime.UtcNow;
+        var reviewResult = ComposeReviewResult(result.ResultMarkdown, result.Blocks);
+        if (task.ParentTaskId is null && task.PlanningPhase == PlanningPhase.None)
+        {
+            await _state.SubmitForReviewAsync(task.Id, finishedAt, reviewResult, CancellationToken.None);
+            await _broadcaster.WorkerLog($"Finished \"{task.Title}\" (waiting for review)", WorkerLogLevel.Success, DateTime.UtcNow);
+            await _broadcaster.TaskFinished(slot, task.Id, "waiting_for_review", finishedAt);
+        }
+        else
+        {
+            await _state.CompleteAsync(task.Id, finishedAt, reviewResult, CancellationToken.None);
+            await _broadcaster.WorkerLog($"Finished \"{task.Title}\" (done)", WorkerLogLevel.Success, DateTime.UtcNow);
+            await _broadcaster.TaskFinished(slot, task.Id, "done", finishedAt);
+        }
+```
+
+(Make sure `using System.Linq;` is available — it is, via implicit usings.)
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter ReviewResultTests`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/Runner/TaskRunner.cs tests/ClaudeDo.Worker.Tests/Runner/ReviewResultTests.cs
+git commit -m "feat(roadblock): surface reported roadblocks in the review result"
+```
+
+---
+
+## Task 10: Files-settings UI exposes the new prompt files
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/ViewModels/Modals/Settings/FilesSettingsTabViewModel.cs`
+- Modify: the Files settings view (find with: `Grep "SystemPromptPath" src/ClaudeDo.Ui` → the `.axaml` binding to `OpenPromptCommand`)
+
+- [ ] **Step 1: Replace the prompt-path properties**
+
+In `FilesSettingsTabViewModel`, replace the three path properties with the new set (drop Agent, add the rest):
+
+```csharp
+    public string SystemPromptPath { get; } = PromptFiles.PathFor(PromptKind.System);
+    public string PlanningPromptPath { get; } = PromptFiles.PathFor(PromptKind.Planning);
+    public string PlanningInitialPromptPath { get; } = PromptFiles.PathFor(PromptKind.PlanningInitial);
+    public string RetryPromptPath { get; } = PromptFiles.PathFor(PromptKind.Retry);
+    public string DailyPrepPromptPath { get; } = PromptFiles.PathFor(PromptKind.DailyPrep);
+    public string WeeklyReportPromptPath { get; } = PromptFiles.PathFor(PromptKind.WeeklyReport);
+```
+
+(`OpenPromptCommand` already parses the `PromptKind` name from its parameter, so no command change is needed.)
+
+- [ ] **Step 2: Update the view**
+
+Open the Files settings `.axaml`. For the existing System/Planning/Agent rows: keep System, keep Planning, **remove the Agent row**, and add four rows mirroring the System row's markup — each binding its label/path to the new property and passing the matching `PromptKind` name as the `OpenPromptCommand` parameter:
+
+- `Planning` (system) → "Planning system prompt", `PlanningPromptPath`, parameter `Planning`
+- `PlanningInitial` → "Planning kickoff prompt", `PlanningInitialPromptPath`, parameter `PlanningInitial`
+- `Retry` → "Retry prompt", `RetryPromptPath`, parameter `Retry`
+- `DailyPrep` → "Daily-prep prompt", `DailyPrepPromptPath`, parameter `DailyPrep`
+- `WeeklyReport` → "Weekly-report prompt", `WeeklyReportPromptPath`, parameter `WeeklyReport`
+
+Use the exact same control template as the existing System row (same button + `CommandParameter` shape); only the bound property, label text, and parameter string differ.
+
+- [ ] **Step 3: Build the UI project**
+
+Run: `dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release`
+Expected: PASS.
+
+- [ ] **Step 4: Visual check (manual — flag for user)**
+
+Start the app, open Settings → Files tab. Confirm six "Open" prompt buttons appear (System, Planning system, Planning kickoff, Retry, Daily-prep, Weekly-report), no Agent row, and each opens/seeds the right file under `~/.todo-app/prompts/`. **This step cannot be verified by the agent — ask the user to confirm visually.**
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Ui/ViewModels/Modals/Settings/FilesSettingsTabViewModel.cs src/ClaudeDo.Ui/Views/**/*Files*.axaml
+git commit -m "feat(ui): expose all editable prompt files, drop agent prompt"
+```
+
+---
+
+## Task 11: Full build + test sweep
+
+- [ ] **Step 1: Build worker + app**
+
+Run:
+```bash
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+```
+Expected: PASS.
+
+- [ ] **Step 2: Run all affected test projects**
+
+Run:
+```bash
+dotnet test tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+```
+Expected: PASS.
+
+- [ ] **Step 3: Update docs**
+
+Update `docs/prompts-inventory.md` to note the externalized files and that `agent.md`/`planning.md` are retired in favor of `system.md`/`planning-system.md`. Note `CLAUDEDO_BLOCKED:` in the inventory.
+
+```bash
+git add docs/prompts-inventory.md
+git commit -m "docs: refresh prompt inventory for externalized prompts + roadblock marker"
+```
+
+---
+
+## Self-review notes
+
+- **Spec coverage:** system.md collapse (T2), planning prompts (T4), retry (T3), daily-prep English (T5), weekly-report + data pointer (T6), templating/`Render` (T1), roadblock detect/strip/route (T7–T9), file layout + migration via `EnsureExists`/new `PathFor` (T1), UI surface (T10). The "Out-of-scope improvements" system.md section is intentionally **deferred to the child-tasks plan** (it depends on the `SuggestImprovement` tool).
+- **Migration:** old `planning.md`/`agent.md` go inert automatically — `TaskRunner` no longer reads agent (T2), planning now reads `planning-system.md` (T1 PathFor). No code deletes the old files; harmless.
+- **Determinism:** content tests target `DefaultFor`/`RenderTemplate` (pure, no disk). Consumers fall back to the same default when no user file exists.

docs/superpowers/plans/2026-06-04-debug-logging-traceability.md

@@ -0,0 +1,725 @@
+# Debug Logging & Frontend↔Backend Traceability Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Build-configuration-driven logging — verbose in Debug builds (Rider run button), minimal `Warning`+ in Release (installed app) — with both processes writing one shared `claudedo-.log` and a `TaskId` correlation key threading UI→Worker→UI.
+
+**Architecture:** A new `ClaudeDo.Logging` library owns all Serilog setup: a `BuildConfig.IsDebug` runtime check (via the entry assembly's `DebuggableAttribute`, no `#if DEBUG`), a default-`TaskId` enricher, and a `LoggingSetup.Configure` method that branches sinks/levels on `IsDebug`. Worker and App both call it. `TaskId` rides Serilog `LogContext`, pushed at the per-task entry points on each side.
+
+**Tech Stack:** .NET 8, Serilog (core + File + Console sinks), Serilog.Extensions.Logging (App bridge), Serilog.AspNetCore (Worker, already present), xUnit.
+
+---
+
+### Task 1: Create the `ClaudeDo.Logging` project
+
+**Files:**
+- Create: `src/ClaudeDo.Logging/ClaudeDo.Logging.csproj`
+- Create: `src/ClaudeDo.Logging/Placeholder.cs` (temporary, removed in Task 2)
+- Modify: `ClaudeDo.slnx`
+
+- [ ] **Step 1: Create the csproj**
+
+Create `src/ClaudeDo.Logging/ClaudeDo.Logging.csproj`:
+
+```xml
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Serilog" Version="4.1.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="ClaudeDo.Worker.Tests" />
+  </ItemGroup>
+
+</Project>
+```
+
+> If NuGet reports a version conflict between `Serilog 4.1.0` and the `Serilog` core pulled transitively by `Serilog.AspNetCore 8.0.3` (Worker), align this `Serilog` version to whatever `Serilog.AspNetCore 8.0.3` resolves (check `dotnet list package --include-transitive`) and rebuild.
+
+- [ ] **Step 2: Add a temporary placeholder so the project compiles**
+
+Create `src/ClaudeDo.Logging/Placeholder.cs`:
+
+```csharp
+namespace ClaudeDo.Logging;
+
+internal static class Placeholder;
+```
+
+- [ ] **Step 3: Register the project in the solution**
+
+Edit `ClaudeDo.slnx` — add inside the `/src/` folder, after the `ClaudeDo.Localization` line:
+
+```xml
+    <Project Path="src/ClaudeDo.Logging/ClaudeDo.Logging.csproj" />
+```
+
+- [ ] **Step 4: Build the new project**
+
+Run: `dotnet build src/ClaudeDo.Logging/ClaudeDo.Logging.csproj -c Release`
+Expected: Build succeeded.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Logging/ClaudeDo.Logging.csproj src/ClaudeDo.Logging/Placeholder.cs ClaudeDo.slnx
+git commit -m "build(logging): scaffold ClaudeDo.Logging project"
+```
+
+---
+
+### Task 2: `DefaultTaskIdEnricher` (TDD)
+
+Adds `TaskId = "-"` to any log event that doesn't already carry a `TaskId` property, so the `[{TaskId}]` column never renders the raw token. A pushed `LogContext` value takes precedence (because `Enrich.FromLogContext()` runs first and the property is then already present).
+
+**Files:**
+- Create: `src/ClaudeDo.Logging/DefaultTaskIdEnricher.cs`
+- Delete: `src/ClaudeDo.Logging/Placeholder.cs`
+- Create: `tests/ClaudeDo.Worker.Tests/Logging/DefaultTaskIdEnricherTests.cs`
+- Modify: `tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj` (add project reference)
+
+- [ ] **Step 1: Reference `ClaudeDo.Logging` from the test project**
+
+Edit `tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj` — add to the existing `ProjectReference` ItemGroup:
+
+```xml
+    <ProjectReference Include="..\..\src\ClaudeDo.Logging\ClaudeDo.Logging.csproj" />
+```
+
+- [ ] **Step 2: Write the failing test**
+
+Create `tests/ClaudeDo.Worker.Tests/Logging/DefaultTaskIdEnricherTests.cs`:
+
+```csharp
+using ClaudeDo.Logging;
+using Serilog;
+using Serilog.Context;
+using Serilog.Core;
+using Serilog.Events;
+
+namespace ClaudeDo.Worker.Tests.Logging;
+
+public sealed class DefaultTaskIdEnricherTests
+{
+    private sealed class CollectingSink : ILogEventSink
+    {
+        public List<LogEvent> Events { get; } = new();
+        public void Emit(LogEvent logEvent) => Events.Add(logEvent);
+    }
+
+    [Fact]
+    public void AddsDash_WhenNoTaskIdInScope()
+    {
+        var sink = new CollectingSink();
+        using var logger = new LoggerConfiguration()
+            .Enrich.FromLogContext()
+            .Enrich.With(new DefaultTaskIdEnricher())
+            .WriteTo.Sink(sink)
+            .CreateLogger();
+
+        logger.Information("hello");
+
+        var prop = Assert.Single(sink.Events).Properties["TaskId"];
+        Assert.Equal("\"-\"", prop.ToString());
+    }
+
+    [Fact]
+    public void KeepsPushedTaskId_WhenInScope()
+    {
+        var sink = new CollectingSink();
+        using var logger = new LoggerConfiguration()
+            .Enrich.FromLogContext()
+            .Enrich.With(new DefaultTaskIdEnricher())
+            .WriteTo.Sink(sink)
+            .CreateLogger();
+
+        using (LogContext.PushProperty("TaskId", "task-42"))
+            logger.Information("hello");
+
+        var prop = Assert.Single(sink.Events).Properties["TaskId"];
+        Assert.Equal("\"task-42\"", prop.ToString());
+    }
+}
+```
+
+- [ ] **Step 3: Run the test to verify it fails**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter DefaultTaskIdEnricherTests`
+Expected: FAIL — `DefaultTaskIdEnricher` does not exist (compile error).
+
+- [ ] **Step 4: Implement the enricher and remove the placeholder**
+
+Delete `src/ClaudeDo.Logging/Placeholder.cs`.
+
+Create `src/ClaudeDo.Logging/DefaultTaskIdEnricher.cs`:
+
+```csharp
+using Serilog.Core;
+using Serilog.Events;
+
+namespace ClaudeDo.Logging;
+
+/// <summary>Ensures every log event carries a TaskId property (defaulting to "-")
+/// so the output template's [{TaskId}] column never renders the raw token.</summary>
+public sealed class DefaultTaskIdEnricher : ILogEventEnricher
+{
+    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
+    {
+        if (!logEvent.Properties.ContainsKey("TaskId"))
+            logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty("TaskId", "-"));
+    }
+}
+```
+
+- [ ] **Step 5: Run the test to verify it passes**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter DefaultTaskIdEnricherTests`
+Expected: PASS (2 tests).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/ClaudeDo.Logging/DefaultTaskIdEnricher.cs tests/ClaudeDo.Worker.Tests/Logging/DefaultTaskIdEnricherTests.cs tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj
+git rm src/ClaudeDo.Logging/Placeholder.cs
+git commit -m "feat(logging): default TaskId enricher with passing tests"
+```
+
+---
+
+### Task 3: `BuildConfig.IsDebug`
+
+Detects whether the entry assembly was compiled in the Debug configuration (JIT optimizer disabled) — the runtime replacement for `#if DEBUG`.
+
+**Files:**
+- Create: `src/ClaudeDo.Logging/BuildConfig.cs`
+- Create: `tests/ClaudeDo.Worker.Tests/Logging/BuildConfigTests.cs`
+
+- [ ] **Step 1: Write the failing test**
+
+The test asserts the property returns *some* bool without throwing, and that the underlying detection logic agrees with the test assembly's own `DebuggableAttribute` (the test runs under whatever config `dotnet test` used). We assert the helper's result equals a locally-computed expectation so it passes under both Debug and Release test runs.
+
+Create `tests/ClaudeDo.Worker.Tests/Logging/BuildConfigTests.cs`:
+
+```csharp
+using System.Diagnostics;
+using System.Reflection;
+using ClaudeDo.Logging;
+
+namespace ClaudeDo.Worker.Tests.Logging;
+
+public sealed class BuildConfigTests
+{
+    [Fact]
+    public void IsDebug_MatchesEntryAssemblyDebuggableAttribute()
+    {
+        var entry = Assembly.GetEntryAssembly();
+        var expected = entry?
+            .GetCustomAttribute<DebuggableAttribute>()
+            ?.IsJITOptimizerDisabled ?? false;
+
+        Assert.Equal(expected, BuildConfig.IsDebug);
+    }
+}
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter BuildConfigTests`
+Expected: FAIL — `BuildConfig` does not exist (compile error).
+
+- [ ] **Step 3: Implement `BuildConfig`**
+
+Create `src/ClaudeDo.Logging/BuildConfig.cs`:
+
+```csharp
+using System.Diagnostics;
+using System.Reflection;
+
+namespace ClaudeDo.Logging;
+
+/// <summary>Runtime build-configuration detection — the replacement for #if DEBUG.
+/// Debug builds compile with the JIT optimizer disabled; Release builds enable it.</summary>
+public static class BuildConfig
+{
+    public static bool IsDebug { get; } =
+        Assembly.GetEntryAssembly()
+            ?.GetCustomAttribute<DebuggableAttribute>()
+            ?.IsJITOptimizerDisabled ?? false;
+}
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter BuildConfigTests`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Logging/BuildConfig.cs tests/ClaudeDo.Worker.Tests/Logging/BuildConfigTests.cs
+git commit -m "feat(logging): runtime Debug-build detection via DebuggableAttribute"
+```
+
+---
+
+### Task 4: `LoggingSetup.Configure`
+
+The single shared configuration entry point. Applies enrichers, the output template, and branches sinks/levels on `BuildConfig.IsDebug`.
+
+**Files:**
+- Create: `src/ClaudeDo.Logging/LoggingSetup.cs`
+- Create: `tests/ClaudeDo.Worker.Tests/Logging/LoggingSetupTests.cs`
+
+- [ ] **Step 1: Write the failing test**
+
+Verifies a configured logger actually writes a `Warning` (emitted in both build configs) to a `claudedo-*.log` file under the given log root.
+
+Create `tests/ClaudeDo.Worker.Tests/Logging/LoggingSetupTests.cs`:
+
+```csharp
+using ClaudeDo.Logging;
+using Serilog;
+
+namespace ClaudeDo.Worker.Tests.Logging;
+
+public sealed class LoggingSetupTests
+{
+    [Fact]
+    public void Configure_WritesSharedLogFile()
+    {
+        var logRoot = Path.Combine(Path.GetTempPath(), "claudedo-logtest-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(logRoot);
+        try
+        {
+            var logger = LoggingSetup.Configure(new LoggerConfiguration(), "test", logRoot).CreateLogger();
+            logger.Warning("marker-{Marker}", "xyz");
+            logger.Dispose(); // flush + release the file handle
+
+            var files = Directory.GetFiles(logRoot, "claudedo-*.log");
+            var file = Assert.Single(files);
+            var contents = File.ReadAllText(file);
+            Assert.Contains("marker-", contents);
+            Assert.Contains("test/", contents); // {Process} tag in the template
+        }
+        finally
+        {
+            try { Directory.Delete(logRoot, recursive: true); } catch { /* best effort */ }
+        }
+    }
+}
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter LoggingSetupTests`
+Expected: FAIL — `LoggingSetup` does not exist (compile error).
+
+- [ ] **Step 3: Implement `LoggingSetup`**
+
+Create `src/ClaudeDo.Logging/LoggingSetup.cs`:
+
+```csharp
+using Serilog;
+using Serilog.Events;
+
+namespace ClaudeDo.Logging;
+
+public static class LoggingSetup
+{
+    private const string OutputTemplate =
+        "[{Timestamp:HH:mm:ss.fff} {Level:u3}] {Process}/{SourceContext} [{TaskId}] {Message:lj}{NewLine}{Exception}";
+
+    /// <summary>Apply the shared ClaudeDo logging configuration.
+    /// Debug builds: Debug level, console + shared file. Release builds: Warning level, shared file only.</summary>
+    /// <param name="processTag">"worker" or "app" — tags every line so the interleaved file is readable.</param>
+    /// <param name="logRoot">Directory for the shared claudedo-.log (created if missing).</param>
+    public static LoggerConfiguration Configure(LoggerConfiguration cfg, string processTag, string logRoot)
+    {
+        Directory.CreateDirectory(logRoot);
+        var logFile = Path.Combine(logRoot, "claudedo-.log");
+
+        cfg.Enrich.FromLogContext()
+           .Enrich.WithProperty("Process", processTag)
+           .Enrich.With(new DefaultTaskIdEnricher());
+
+        if (BuildConfig.IsDebug)
+        {
+            cfg.MinimumLevel.Debug()
+               .WriteTo.Console(outputTemplate: OutputTemplate)
+               .WriteTo.File(
+                   logFile,
+                   rollingInterval: RollingInterval.Day,
+                   retainedFileCountLimit: 2,
+                   shared: true,
+                   outputTemplate: OutputTemplate);
+        }
+        else
+        {
+            cfg.MinimumLevel.Warning()
+               .WriteTo.File(
+                   logFile,
+                   rollingInterval: RollingInterval.Day,
+                   retainedFileCountLimit: 2,
+                   shared: true,
+                   outputTemplate: OutputTemplate);
+        }
+
+        return cfg;
+    }
+}
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter LoggingSetupTests`
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Logging/LoggingSetup.cs tests/ClaudeDo.Worker.Tests/Logging/LoggingSetupTests.cs
+git commit -m "feat(logging): shared LoggingSetup with build-config sink branching"
+```
+
+---
+
+### Task 5: Wire the Worker to the shared setup
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/ClaudeDo.Worker.csproj`
+- Modify: `src/ClaudeDo.Worker/Program.cs:34-40`
+
+- [ ] **Step 1: Add the project reference**
+
+Edit `src/ClaudeDo.Worker/ClaudeDo.Worker.csproj` — add to the existing `ProjectReference` ItemGroup (the one with `ClaudeDo.Data`):
+
+```xml
+    <ProjectReference Include="..\ClaudeDo.Logging\ClaudeDo.Logging.csproj" />
+```
+
+- [ ] **Step 2: Replace the inline Serilog config**
+
+In `src/ClaudeDo.Worker/Program.cs`, replace lines 34-40:
+
+```csharp
+builder.Host.UseSerilog((ctx, lc) => lc
+    .MinimumLevel.Information()
+    .WriteTo.File(
+        System.IO.Path.Combine(logRoot, "worker-.log"),
+        rollingInterval: RollingInterval.Day,
+        retainedFileCountLimit: 7,
+        shared: true));
+```
+
+with:
+
+```csharp
+builder.Host.UseSerilog((ctx, lc) =>
+    ClaudeDo.Logging.LoggingSetup.Configure(lc, "worker", logRoot));
+```
+
+- [ ] **Step 3: Build the Worker**
+
+Run: `dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release`
+Expected: Build succeeded. (If the Worker is running and locks the Debug output, this Release build is unaffected.)
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/ClaudeDo.Worker.csproj src/ClaudeDo.Worker/Program.cs
+git commit -m "feat(logging): route Worker logging through shared LoggingSetup"
+```
+
+---
+
+### Task 6: Wire the App/Ui (currently log-silent) to the shared setup
+
+The App uses a plain `ServiceCollection` with **no** logging registered. Add the Serilog→`ILogger` bridge so all `ILogger<T>` injections across App/Ui flow to the shared sinks, and flush on shutdown.
+
+**Files:**
+- Modify: `src/ClaudeDo.App/ClaudeDo.App.csproj`
+- Modify: `src/ClaudeDo.App/Program.cs`
+
+- [ ] **Step 1: Add packages and the project reference**
+
+Edit `src/ClaudeDo.App/ClaudeDo.App.csproj` — add to the package `ItemGroup`:
+
+```xml
+    <PackageReference Include="Serilog.Extensions.Logging" Version="8.0.0" />
+```
+
+and to the `ProjectReference` ItemGroup:
+
+```xml
+    <ProjectReference Include="..\ClaudeDo.Logging\ClaudeDo.Logging.csproj" />
+```
+
+- [ ] **Step 2: Add the logging registration in `BuildServices`**
+
+In `src/ClaudeDo.App/Program.cs`, inside `BuildServices()`, immediately after the `var sc = new ServiceCollection();` line (currently line 78), insert:
+
+```csharp
+        var logRoot = Path.Combine(Path.GetDirectoryName(dbPath)!, "logs");
+        var serilogLogger = ClaudeDo.Logging.LoggingSetup
+            .Configure(new Serilog.LoggerConfiguration(), "app", logRoot)
+            .CreateLogger();
+        sc.AddLogging(b => b.AddSerilog(serilogLogger, dispose: true));
+```
+
+Add these usings to the top of `Program.cs` (the `AddSerilog` `ILoggingBuilder` extension lives in the `Serilog` namespace; `AddLogging` lives in `Microsoft.Extensions.DependencyInjection`, already imported):
+
+```csharp
+using Serilog;
+using Microsoft.Extensions.Logging;
+```
+
+> `dbPath` is already computed just above (`var dbPath = Paths.Expand(settings.DbPath);`). Its parent directory is `~/.todo-app`, so `logs` sits beside the Worker's log root.
+
+- [ ] **Step 3: Build the App**
+
+Run: `dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release`
+Expected: Build succeeded (pulls in Ui + Data + Logging).
+
+- [ ] **Step 4: Verify manually from Rider (visual-verification gap)**
+
+This is a Debug-build behavior that cannot be asserted in a Release test run. Launch the App from Rider's run button and confirm:
+- A `claudedo-*.log` appears in `~/.todo-app/logs/`.
+- Console output (Rider run window) shows `Debug`-level lines tagged `app/...`.
+
+Flag to the user that this step needs their eyes.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.App/ClaudeDo.App.csproj src/ClaudeDo.App/Program.cs
+git commit -m "feat(logging): wire App/Ui logging to shared LoggingSetup"
+```
+
+---
+
+### Task 7: Push `TaskId` into `LogContext` in the Worker
+
+Wraps the two per-task entry points so every nested log line (runner, state service, worktree, planning) carries the task's id automatically.
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Runner/TaskRunner.cs:47` (`RunAsync`) and `:171` (`ContinueAsync`)
+
+- [ ] **Step 1: Add the using directive**
+
+In `src/ClaudeDo.Worker/Runner/TaskRunner.cs`, add to the top usings:
+
+```csharp
+using Serilog.Context;
+```
+
+- [ ] **Step 2: Push TaskId at the top of `RunAsync`**
+
+In `RunAsync` (line 47), insert as the very first statement of the method body (before `string? mcpToken = null;`):
+
+```csharp
+        using var _taskScope = LogContext.PushProperty("TaskId", task.Id);
+```
+
+- [ ] **Step 3: Push TaskId at the top of `ContinueAsync`**
+
+In `ContinueAsync` (line 171), insert as the very first statement of the method body (before `TaskEntity task;`). The parameter is `taskId`:
+
+```csharp
+        using var _taskScope = LogContext.PushProperty("TaskId", taskId);
+```
+
+- [ ] **Step 4: Build the Worker**
+
+Run: `dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release`
+Expected: Build succeeded.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/Runner/TaskRunner.cs
+git commit -m "feat(logging): tag Worker task execution with TaskId for traceability"
+```
+
+---
+
+### Task 8: Push `TaskId` and add trace lines on the App side
+
+`WorkerClient` currently logs nothing. Inject `ILogger<WorkerClient>`, add a small helper that pushes `TaskId` + emits a `Debug` trace line, and route the fire-and-forget task-targeted hub calls through it. This produces the UI half of the UI→Worker→UI trace under a shared `TaskId`.
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/Services/WorkerClient.cs`
+- Modify: `src/ClaudeDo.App/Program.cs:101` (registration)
+
+- [ ] **Step 1: Add usings and the logger field/ctor param**
+
+In `src/ClaudeDo.Ui/Services/WorkerClient.cs`, add to the usings:
+
+```csharp
+using Microsoft.Extensions.Logging;
+using Serilog.Context;
+```
+
+Add a field beside `private readonly HubConnection _hub;` (line 32):
+
+```csharp
+    private readonly ILogger<WorkerClient> _logger;
+```
+
+Change the constructor signature (line 68) from:
+
+```csharp
+    public WorkerClient(string signalRUrl)
+    {
+```
+
+to:
+
+```csharp
+    public WorkerClient(string signalRUrl, ILogger<WorkerClient> logger)
+    {
+        _logger = logger;
+```
+
+- [ ] **Step 2: Add the task-scoped invoke helper**
+
+In `src/ClaudeDo.Ui/Services/WorkerClient.cs`, add this private method next to `TryInvokeAsync` (after line 241):
+
+```csharp
+    /// <summary>Invoke a task-targeted hub method under a TaskId log scope, emitting a debug trace line.</summary>
+    private async Task InvokeForTaskAsync(string taskId, string method, params object?[] args)
+    {
+        using (LogContext.PushProperty("TaskId", taskId))
+        {
+            _logger.LogDebug("UI invoking {Method} for task {TaskId}", method, taskId);
+            await _hub.InvokeCoreAsync(method, args);
+        }
+    }
+```
+
+- [ ] **Step 3: Route the fire-and-forget task actions through the helper**
+
+In the same file, replace each of these method bodies:
+
+`RunNowAsync` (line 243):
+```csharp
+    public Task RunNowAsync(string taskId)
+        => InvokeForTaskAsync(taskId, "RunNow", taskId);
+```
+
+`ContinueTaskAsync` (line 248):
+```csharp
+    public Task ContinueTaskAsync(string taskId, string followUpPrompt)
+        => InvokeForTaskAsync(taskId, "ContinueTask", taskId, followUpPrompt);
+```
+
+`ResetTaskAsync` (line 253):
+```csharp
+    public Task ResetTaskAsync(string taskId)
+        => InvokeForTaskAsync(taskId, "ResetTask", taskId);
+```
+
+`CancelTaskAsync` (line 267):
+```csharp
+    public Task CancelTaskAsync(string taskId)
+        => InvokeForTaskAsync(taskId, "CancelTask", taskId);
+```
+
+`ApproveReviewAsync` (line 389):
+```csharp
+    public Task ApproveReviewAsync(string taskId)
+        => InvokeForTaskAsync(taskId, "ApproveReview", taskId);
+```
+
+`RejectReviewToQueueAsync` (line 394):
+```csharp
+    public Task RejectReviewToQueueAsync(string taskId, string feedback)
+        => InvokeForTaskAsync(taskId, "RejectReviewToQueue", taskId, feedback);
+```
+
+`RejectReviewToIdleAsync` (line 399):
+```csharp
+    public Task RejectReviewToIdleAsync(string taskId)
+        => InvokeForTaskAsync(taskId, "RejectReviewToIdle", taskId);
+```
+
+`CancelReviewAsync` (line 404):
+```csharp
+    public Task CancelReviewAsync(string taskId)
+        => InvokeForTaskAsync(taskId, "CancelReview", taskId);
+```
+
+> These all previously did `await _hub.InvokeAsync(method, ...)` with no return value, so converting them to expression-bodied delegations preserves behavior. Do **not** touch methods that return DTOs (e.g. `MergeTaskAsync`) or the planning methods — keep this change scoped to the void task actions above.
+
+- [ ] **Step 4: Update the DI registration to pass the logger**
+
+In `src/ClaudeDo.App/Program.cs`, replace line 101:
+
+```csharp
+        sc.AddSingleton(sp => new WorkerClient(sp.GetRequiredService<AppSettings>().SignalRUrl));
+```
+
+with:
+
+```csharp
+        sc.AddSingleton(sp => new WorkerClient(
+            sp.GetRequiredService<AppSettings>().SignalRUrl,
+            sp.GetRequiredService<ILogger<WorkerClient>>()));
+```
+
+Add `using Microsoft.Extensions.Logging;` to the top of `Program.cs` if not already present.
+
+- [ ] **Step 5: Build the App**
+
+Run: `dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release`
+Expected: Build succeeded.
+
+> Note: `WorkerClient` is faked in tests via the `IWorkerClient` *interface* (hand-rolled fakes implement the interface, they do not subclass `WorkerClient`). This change adds a ctor parameter to the concrete class only and does not alter `IWorkerClient`, so the fakes are unaffected. Confirm by building the test projects in the next step.
+
+- [ ] **Step 6: Build the test projects to confirm fakes still compile**
+
+Run: `dotnet build tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release && dotnet build tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release`
+Expected: Build succeeded for both.
+
+- [ ] **Step 7: Run the full Worker.Tests suite**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release`
+Expected: PASS (all existing tests + the 4 new logging tests).
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add src/ClaudeDo.Ui/Services/WorkerClient.cs src/ClaudeDo.App/Program.cs
+git commit -m "feat(logging): tag UI task actions with TaskId + debug trace lines"
+```
+
+---
+
+## Final verification
+
+- [ ] **Build the whole desktop + worker stack in Release:**
+
+```bash
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+```
+
+- [ ] **Run the logging tests:**
+
+```bash
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter "FullyQualifiedName~Logging"
+```
+Expected: PASS (DefaultTaskIdEnricher × 2, BuildConfig × 1, LoggingSetup × 1).
+
+- [ ] **Manual smoke test (visual-verification gap — needs the user):**
+  1. Run the Worker and App from Rider (Debug build). Confirm both write to one `~/.todo-app/logs/claudedo-*.log` with `app/...` and `worker/...` lines.
+  2. Run a task; grep that file for the task's id — confirm UI (`UI invoking RunNow…`) and Worker lines share the same `[<taskId>]`.
+  3. Build/install the Release app; confirm the log is near-silent (no `Debug`/`Information` noise, `Warning`+ only) and no console window logging.

docs/superpowers/plans/2026-06-04-myday-icons-terminal-reuse.md

@@ -0,0 +1,147 @@
+# MyDay Icon Buttons + Terminal Reuse + Sort Icon Fix — Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: superpowers:subagent-driven-development. Steps use `- [ ]`.
+
+**Goal:** Move the "Clear day" and "Prep log" actions into the MyDay header icon row as icon buttons (broom + list), render the prep log in the real `SessionTerminalView` ("cool terminal") by making that control reusable, and fix the invisible Sort icon.
+
+**Approved design (chat):**
+- Header icon row (`TasksIslandView.axaml`, the Sort/Eye/Settings `icon-btn` StackPanel) gets two more `icon-btn`, both `IsVisible="{Binding IsMyDayList}"`, inserted after the Eye button: **broom** (`Icon.Broom`) → `ClearDayCommand`, **list** (`Icon.List`) → `ShowPrepLogCommand`. The two full-width text buttons "Prep log" and "Clear day" are removed. "Tag vorbereiten" stays as the full-width button (already opens the prep view via `PrepRequested`).
+- `SessionTerminalView` becomes reusable via StyledProperties so it renders both the task `Log` and the prep `PrepLog` with the same terminal look. The prep panel in `DetailsIslandView` embeds it instead of the copied `ItemsControl`.
+- **Sort icon bug:** `PathIcon` fills geometry; `Icon.Sort` is an open-line path (no enclosed area) → invisible. Replace with a filled geometry. New icons (Broom, List) are authored as filled geometries too.
+
+**Tech:** Avalonia (PathIcon/StreamGeometry, StyledProperty), CommunityToolkit.Mvvm, xUnit.
+
+## Build/test
+`.slnx` needs .NET 9 — build the csproj. Use `-c Release` if a Worker locks Debug.
+```bash
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj -c Release
+```
+GUI cannot be smoke-tested headlessly — note it; the human verifies visuals.
+
+---
+
+## Task A: Icons + reusable SessionTerminalView
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/Design/IslandStyles.axaml` (icon geometries)
+- Modify: `src/ClaudeDo.Ui/Views/Islands/SessionTerminalView.axaml` + `SessionTerminalView.axaml.cs`
+- Modify: `src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml` (both embeds)
+
+- [ ] **Step 1: Fix `Icon.Sort` + add `Icon.Broom`, `Icon.List`** as filled geometries in `IslandStyles.axaml` (in the `Styles.Resources` icon block). Replace the existing `Icon.Sort` line and add the two new ones:
+
+```xml
+<!-- Icon.Sort (filled bars, decreasing width) -->
+<StreamGeometry x:Key="Icon.Sort">M4 6 H20 V8 H4 Z M4 11 H16 V13 H4 Z M4 16 H11 V18 H4 Z</StreamGeometry>
+
+<!-- Icon.Broom (filled: handle + binding band + flared bristles) -->
+<StreamGeometry x:Key="Icon.Broom">M11 3 H13 V10 H11 Z M8.5 10 H15.5 V12 H8.5 Z M9 12 H15 L17 21 H7 Z</StreamGeometry>
+
+<!-- Icon.List (filled: square bullets + lines) -->
+<StreamGeometry x:Key="Icon.List">M4 5 H6 V7 H4 Z M8 5 H20 V7 H8 Z M4 11 H6 V13 H4 Z M8 11 H20 V13 H8 Z M4 17 H6 V19 H4 Z M8 17 H20 V19 H8 Z</StreamGeometry>
+```
+
+- [ ] **Step 2: Add StyledProperties to `SessionTerminalView`** (code-behind `SessionTerminalView.axaml.cs`). Add public StyledProperties and CLR wrappers:
+
+```csharp
+public static readonly StyledProperty<System.Collections.IEnumerable?> EntriesProperty =
+    AvaloniaProperty.Register<SessionTerminalView, System.Collections.IEnumerable?>(nameof(Entries));
+public static readonly StyledProperty<string?> LabelProperty =
+    AvaloniaProperty.Register<SessionTerminalView, string?>(nameof(Label));
+public static readonly StyledProperty<bool> IsRunningProperty =
+    AvaloniaProperty.Register<SessionTerminalView, bool>(nameof(IsRunning));
+public static readonly StyledProperty<bool> IsDoneProperty =
+    AvaloniaProperty.Register<SessionTerminalView, bool>(nameof(IsDone));
+public static readonly StyledProperty<bool> IsFailedProperty =
+    AvaloniaProperty.Register<SessionTerminalView, bool>(nameof(IsFailed));
+
+public System.Collections.IEnumerable? Entries { get => GetValue(EntriesProperty); set => SetValue(EntriesProperty, value); }
+public string? Label { get => GetValue(LabelProperty); set => SetValue(LabelProperty, value); }
+public bool IsRunning { get => GetValue(IsRunningProperty); set => SetValue(IsRunningProperty, value); }
+public bool IsDone { get => GetValue(IsDoneProperty); set => SetValue(IsDoneProperty, value); }
+public bool IsFailed { get => GetValue(IsFailedProperty); set => SetValue(IsFailedProperty, value); }
+```
+
+Replace the existing auto-scroll hook (which cast `DataContext as DetailsIslandViewModel` and watched `.Log.CollectionChanged`) with one that watches whichever collection `Entries` points at: in `OnPropertyChanged`, when `change.Property == EntriesProperty`, detach the old `INotifyCollectionChanged.CollectionChanged` handler and attach to the new value (if it implements `INotifyCollectionChanged`); the handler scrolls the existing ScrollViewer to the end (reuse the existing scroll logic / named ScrollViewer). Keep the named ScrollViewer's `x:Name`.
+
+- [ ] **Step 3: Repoint `SessionTerminalView.axaml` internal bindings to the control's own properties.** Give the root `UserControl` `x:Name="Root"`. Change:
+  - the `ItemsControl ItemsSource="{Binding Log}"` → `ItemsSource="{Binding #Root.Entries}"`
+  - the label `TextBlock` `Text="{Binding BranchLine, StringFormat='claude-session · {0}'}"` (or whatever it is) → `Text="{Binding #Root.Label}"`
+  - the LIVE chip `IsVisible="{Binding IsRunning}"` → `{Binding #Root.IsRunning}`; DONE → `#Root.IsDone`; FAILED → `#Root.IsFailed`.
+  Keep the `LogLineViewModel` item template as-is (it binds the item, not the VM). The `x:DataType` can stay `DetailsIslandViewModel` (element-name bindings to `#Root` don't depend on it) or be removed if it causes compile issues — verify the build.
+
+- [ ] **Step 4: Update both embeds in `DetailsIslandView.axaml`.**
+  - Task embed (currently `<islands:SessionTerminalView MaxHeight="420"/>`):
+    ```xml
+    <islands:SessionTerminalView MaxHeight="420"
+        Entries="{Binding Log}"
+        Label="{Binding BranchLine, StringFormat='claude-session · {0}'}"
+        IsRunning="{Binding IsRunning}" IsDone="{Binding IsDone}" IsFailed="{Binding IsFailed}"/>
+    ```
+    (Use the exact label binding the old internal header used — match the prior `StringFormat` text precisely so the task view is visually unchanged.)
+  - Prep panel: replace the whole copied `ItemsControl` (and its surrounding `ScrollViewer`/title) with:
+    ```xml
+    <islands:SessionTerminalView
+        Entries="{Binding PrepLog}" Label="daily-prep"
+        IsRunning="{Binding IsPrepRunning}"/>
+    ```
+    Keep the panel wrapper `<Panel IsVisible="{Binding IsPrepMode}">`. Drop the now-redundant `details.prepTitle` title TextBlock (the terminal header shows the `daily-prep` label). Leave the `details.prepTitle` locale key in place (harmless) OR remove it from both en/de if you prefer — if removing, run the localization test.
+
+- [ ] **Step 5: Build the App; confirm no binding/compile errors.**
+```bash
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+```
+(The existing DetailsIsland prep tests must still pass — `PrepLog`/`IsPrepMode`/`ShowPrep` are unchanged.)
+
+- [ ] **Step 6: Commit** (stage only Task A files; do NOT `git add -A`):
+```bash
+git commit -m "feat(daily-prep): reuse SessionTerminal for prep log; fix invisible Sort icon; add Broom/List icons"
+```
+
+---
+
+## Task B: MyDay header icon buttons
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml`
+- Modify: `src/ClaudeDo.Localization/locales/en.json`, `de.json`
+
+Depends on Task A (uses `Icon.Broom` / `Icon.List`).
+
+- [ ] **Step 1: Add two `icon-btn` to the header icon StackPanel** (the one with Sort/Eye/Settings), inserted right after the Eye button and before Settings, both MyDay-only:
+
+```xml
+<Button Classes="icon-btn" IsVisible="{Binding IsMyDayList}"
+        Command="{Binding ClearDayCommand}" ToolTip.Tip="{loc:Tr tasks.clearDayTip}">
+  <PathIcon Width="15" Height="15" Data="{StaticResource Icon.Broom}"/>
+</Button>
+<Button Classes="icon-btn" IsVisible="{Binding IsMyDayList}"
+        Command="{Binding ShowPrepLogCommand}" ToolTip.Tip="{loc:Tr tasks.prepLogTip}">
+  <PathIcon Width="15" Height="15" Data="{StaticResource Icon.List}"/>
+</Button>
+```
+
+- [ ] **Step 2: Remove the two full-width buttons** "Prep log" (`ShowPrepLogCommand`) and "Clear day" (`ClearDayCommand`) from the DockPanel button stack. Keep the "Prepare day" (`PrepareDayCommand`) full-width button and the Notes pinned-row button.
+
+- [ ] **Step 3: Locales.** Add `tasks.clearDayTip` (en "Clear day", de "Tag leeren") and `tasks.prepLogTip` (en "Prep log", de "Vorbereitungs-Log") to both json files. Remove the now-unused `tasks.clearDay` and `tasks.prepLog` keys from both (keep en/de in parity).
+
+- [ ] **Step 4: Build + test.**
+```bash
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj -c Release
+```
+
+- [ ] **Step 5: Manual smoke (human):** on MyDay the header shows Sort (now visible) + Eye + Broom + List + Settings; broom clears the day; list opens the prep terminal; "Tag vorbereiten" opens the prep terminal and streams; the three MyDay-only controls hide on other lists; the task session terminal still renders normally.
+
+- [ ] **Step 6: Commit** (stage only Task B files):
+```bash
+git commit -m "feat(daily-prep): move Clear-day and Prep-log into MyDay header icon row"
+```
+
+## Notes / risks
+- Element-name bindings (`#Root.*`) require the `UserControl` to have `x:Name="Root"`; verify compiled bindings accept them (they do in Avalonia).
+- The auto-scroll hook must re-subscribe when `Entries` changes; without it the prep log won't auto-scroll.
+- `ClearDayCommand` / `ShowPrepLogCommand` already exist on `TasksIslandViewModel` — no VM changes; existing VM tests remain valid.

docs/superpowers/plans/2026-06-04-plan-day-in-log-window.md

@@ -0,0 +1,120 @@
+# Move "Plan day" into the Prep-Log Window — Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: superpowers:subagent-driven-development. Steps use `- [ ]`.
+
+**Goal:** Guard daily-prep planning behind a second click. The MyDay header's full-width "Tag vorbereiten" button is removed; instead the user opens the prep-log window (list icon), sees the last run or an empty-state hint, and clicks a **"Plan day"** button inside that window to run the prep.
+
+**Approved flow:** Header list-icon (`ShowPrepLogCommand`) opens the prep window → if empty, an empty-state hint shows → "Plan day" button in the window runs `RunDailyPrepNowAsync()`.
+
+**Tech:** Avalonia + CommunityToolkit.Mvvm, xUnit.
+
+## Build/test
+```bash
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj -c Release
+```
+GUI not headlessly verifiable — note it; human verifies visuals.
+
+---
+
+## Task: relocate planning trigger + empty-state
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/TasksIslandViewModel.cs` (remove PrepareDay)
+- Modify: `src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml` (remove header button)
+- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs` (PlanDayCommand + empty-state)
+- Modify: `src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml` (prep panel toolbar + empty hint)
+- Modify: `src/ClaudeDo.Localization/locales/en.json`, `de.json`
+- Test: `tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandPrepModeTests.cs`, and the existing `TasksIslandDailyPrepTests.cs` (remove the obsolete prepare test)
+
+- [ ] **Step 1: Write/adjust tests first.**
+  - In `DetailsIslandPrepModeTests.cs` add:
+    ```csharp
+    [Fact]
+    public async Task PlanDayCommand_calls_worker()
+    {
+        var stub = new StubWorkerClient();
+        var vm = NewDetailsVm(stub);
+        await vm.PlanDayCommand.ExecuteAsync(null);
+        Assert.Equal(1, stub.RunDailyPrepNowCalls);
+    }
+
+    [Fact]
+    public void ShowPrepEmptyState_true_when_empty_and_not_running()
+    {
+        var vm = NewDetailsVm(new StubWorkerClient());
+        Assert.True(vm.ShowPrepEmptyState);
+    }
+    ```
+    `StubWorkerClient` needs a `RunDailyPrepNowCalls` counter incremented in `RunDailyPrepNowAsync` (add if missing; it currently likely returns `Task.FromResult(true)` — keep that and bump a counter).
+  - In `TasksIslandDailyPrepTests.cs` **remove** `PrepareDayCommand_raises_PrepRequested` (the command is being deleted). Keep `ClearDayCommand_calls_worker`.
+
+- [ ] **Step 2: Run — expect FAIL/compile error.**
+
+- [ ] **Step 3: `TasksIslandViewModel` — remove planning trigger.**
+  - Delete the `PrepareDayAsync` `[RelayCommand]` entirely.
+  - Keep the `PrepRequested` event and `ShowPrepLog` command (the list icon still raises `PrepRequested` to open the window).
+  - Grep the VM for any remaining `PrepareDay` references and remove them.
+
+- [ ] **Step 4: `TasksIslandView.axaml` — remove the header button.** Delete the full-width "Prepare day" `<Button … Command="{Binding PrepareDayCommand}" …>`. Leave the Notes pinned-row button, and the header icon buttons (broom = ClearDay, list = ShowPrepLog) untouched.
+
+- [ ] **Step 5: `DetailsIslandViewModel` — add PlanDayCommand + empty-state.**
+  - Add:
+    ```csharp
+    [RelayCommand]
+    private async Task PlanDayAsync()
+    {
+        if (_worker is null) return;
+        try { await _worker.RunDailyPrepNowAsync(); }
+        catch { /* worker offline; PrepStarted/PrepLine will reconcile */ }
+    }
+
+    public bool ShowPrepEmptyState => !IsPrepRunning && PrepLog.Count == 0;
+    ```
+  - Notify `ShowPrepEmptyState`: in the constructor add `PrepLog.CollectionChanged += (_, _) => OnPropertyChanged(nameof(ShowPrepEmptyState));`, and add `partial void OnIsPrepRunningChanged(bool value) => OnPropertyChanged(nameof(ShowPrepEmptyState));`.
+
+- [ ] **Step 6: `DetailsIslandView.axaml` — prep panel toolbar + empty hint.** In the `<Panel IsVisible="{Binding IsPrepMode}">`, wrap the existing `SessionTerminalView` in a `DockPanel`; dock a top toolbar row with the Plan-day button, and overlay/stack an empty-state hint:
+    ```xml
+    <Panel IsVisible="{Binding IsPrepMode}">
+      <DockPanel>
+        <Border DockPanel.Dock="Top" Padding="12,8">
+          <Button Classes="btn primary"
+                  Command="{Binding PlanDayCommand}"
+                  IsEnabled="{Binding !IsPrepRunning}"
+                  Content="{loc:Tr details.planDay}"/>
+        </Border>
+        <Panel>
+          <islands:SessionTerminalView
+              Entries="{Binding PrepLog}" Label="daily-prep"
+              IsRunning="{Binding IsPrepRunning}"/>
+          <TextBlock IsVisible="{Binding ShowPrepEmptyState}"
+                     HorizontalAlignment="Center" VerticalAlignment="Center"
+                     Foreground="{DynamicResource TextMuteBrush}"
+                     Text="{loc:Tr details.prepEmpty}"/>
+        </Panel>
+      </DockPanel>
+    </Panel>
+    ```
+    (Match the surrounding view's class names/brushes; use the existing button class style seen elsewhere, e.g. `Classes="btn"` — verify `primary` exists, else plain `btn`.)
+
+- [ ] **Step 7: Locales.** Add `details.planDay` (en "Plan day", de "Tag planen") and `details.prepEmpty` (en "No prep run today yet — click Plan day", de "Heute noch keine Vorbereitung — klick Tag planen") to both json files. Remove the now-unused `tasks.prepareDay` key from both (grep first to confirm no other reference). Keep en/de key parity.
+
+- [ ] **Step 8: Build + tests.**
+  ```bash
+  dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+  dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+  dotnet test tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj -c Release
+  ```
+
+- [ ] **Step 9: Manual smoke (human):** on MyDay there is no "Tag vorbereiten" button; the list icon opens the prep window showing the empty hint; "Plan day" runs the prep and streams; the hint disappears while running; after restart the persisted last run shows and "Plan day" is available to re-run.
+
+- [ ] **Step 10: Commit:**
+  ```bash
+  git commit -m "feat(daily-prep): trigger planning from inside the prep-log window with an empty-state hint"
+  ```
+
+## Notes / risks
+- `PrepRequested` and `ShowPrepLogCommand` stay — only `PrepareDayCommand` and its header button are removed.
+- `ShowPrepEmptyState` must re-notify on both `PrepLog` changes and `IsPrepRunning` changes, else the hint won't hide when a run starts or lines arrive.
+- Removing `tasks.prepareDay`: confirm via grep it has no remaining references before deleting (keep locale parity or the Localization.Tests parity check fails).

docs/superpowers/plans/2026-06-04-prep-log-persistence.md

@@ -0,0 +1,208 @@
+# Persist Daily-Prep Log Across Restarts — Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: superpowers:subagent-driven-development. Steps use `- [ ]`.
+
+**Goal:** The prep log currently lives only in memory (`DetailsIslandViewModel.PrepLog`), so after an app restart the prep terminal is empty. Persist the last prep run's output to a file in the worker and load it into the prep terminal when opened.
+
+**Root cause (confirmed):** `PrimeRunner.FireAsync` streams stdout lines via `_broadcaster.PrepLineAsync(line)` only — it writes no file and stores no record. `PrepLog` is an in-memory `ObservableCollection` populated only by live `PrepLine` events. Nothing persists → empty after restart.
+
+**Approach:** Worker writes each streamed line to `<appdata>/logs/daily-prep.log` (truncated at run start = last run only) using the existing `LogWriter`. A new hub method `GetLastPrepLog()` returns the file (tail-capped, like `get_task_log`). The UI loads it into `PrepLog` when the prep view opens, but only when `PrepLog` is empty and no run is in progress.
+
+**Tech:** ASP.NET Core SignalR, Avalonia + CommunityToolkit.Mvvm, xUnit.
+
+## Build/test
+```bash
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+```
+GUI not headlessly verifiable — note it; human verifies visuals.
+
+## Shared constant
+The prep-log path must be identical in `PrimeRunner` (writer) and `WorkerHub` (reader). Define it once and reference from both:
+`Path.Combine(ClaudeDo.Data.Paths.AppDataRoot(), "logs", "daily-prep.log")`.
+Add a small static helper so both sides agree, e.g. in `src/ClaudeDo.Worker/Prime/DailyPrepPrompt.cs` (already the prep "home"):
+```csharp
+public static string LogPath() =>
+    System.IO.Path.Combine(ClaudeDo.Data.Paths.AppDataRoot(), "logs", "daily-prep.log");
+```
+
+---
+
+## Task 1: Worker — write the prep log + serve it
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Prime/DailyPrepPrompt.cs` (add `LogPath()` helper)
+- Modify: `src/ClaudeDo.Worker/Prime/PrimeRunner.cs`
+- Modify: `src/ClaudeDo.Worker/Hub/WorkerHub.cs`
+- Test: `tests/ClaudeDo.Worker.Tests/Prime/PrimeRunnerTests.cs`
+
+- [ ] **Step 1: Add `DailyPrepPrompt.LogPath()`** (code above).
+
+- [ ] **Step 2: Write the failing test.** Extend the existing streaming test (or add one) asserting that after `FireAsync` with emitted stdout lines, the file at `DailyPrepPrompt.LogPath()` contains those lines, and that a prior run's content is replaced (truncate-on-start). Since the path is the real app-data logs dir, the test should delete the file first and clean up after; assert exact line content.
+
+```csharp
+[Fact]
+public async Task FireAsync_writes_last_run_to_prep_log_file()
+{
+    var path = DailyPrepPrompt.LogPath();
+    if (File.Exists(path)) File.Delete(path);
+
+    var claude = new FakeClaudeProcess(emitLines: new[] { "lineA", "lineB" }, exitCode: 0, result: "ok");
+    var runner = NewRunner(claude, new RecordingPrimeBroadcaster());
+    await runner.FireAsync(new PrimeScheduleDto(Guid.Empty, 0, TimeSpan.Zero, true, null, null), CancellationToken.None);
+
+    var contents = await File.ReadAllTextAsync(path);
+    Assert.Contains("lineA", contents);
+    Assert.Contains("lineB", contents);
+
+    // Truncation: a second run with different lines replaces the file.
+    var claude2 = new FakeClaudeProcess(emitLines: new[] { "lineC" }, exitCode: 0, result: "ok");
+    var runner2 = NewRunner(claude2, new RecordingPrimeBroadcaster());
+    await runner2.FireAsync(new PrimeScheduleDto(Guid.Empty, 0, TimeSpan.Zero, true, null, null), CancellationToken.None);
+    var after = await File.ReadAllTextAsync(path);
+    Assert.DoesNotContain("lineA", after);
+    Assert.Contains("lineC", after);
+}
+```
+
+- [ ] **Step 3: Run — expect FAIL.**
+
+- [ ] **Step 4: Write the file in `PrimeRunner.FireAsync`.** After the gate is acquired and before `RunAsync`: compute `var logPath = DailyPrepPrompt.LogPath();`, delete it if present (truncate → last run only), then create `await using var logWriter = new LogWriter(logPath);`. Change the stream callback to write AND broadcast:
+
+```csharp
+            var logPath = DailyPrepPrompt.LogPath();
+            try { if (File.Exists(logPath)) File.Delete(logPath); } catch { /* best effort */ }
+            await using var logWriter = new LogWriter(logPath);
+
+            await _broadcaster.PrepStartedAsync();
+            // ... build prompt/args/timeoutCts ...
+            var result = await _claude.RunAsync(
+                arguments: args, prompt: prompt, workingDirectory: cwd,
+                onStdoutLine: async line =>
+                {
+                    await logWriter.WriteLineAsync(line);
+                    await _broadcaster.PrepLineAsync(line);
+                },
+                ct: timeoutCts.Token);
+```
+
+Keep the existing `success`/`finally`/`PrepFinishedAsync`/gate logic. `using ClaudeDo.Worker.Runner;` is already present (LogWriter lives there). The `await using` LogWriter disposes (flushes) before the method returns.
+
+- [ ] **Step 5: Run — expect PASS.** Build the Worker.
+
+- [ ] **Step 6: Add `WorkerHub.GetLastPrepLog()`** (no ctor change — reads the static path):
+
+```csharp
+public Task<string> GetLastPrepLog()
+{
+    var path = DailyPrepPrompt.LogPath();
+    if (!File.Exists(path)) return Task.FromResult(string.Empty);
+
+    const int maxBytes = 256 * 1024;
+    var bytes = File.ReadAllBytes(path);
+    var text = bytes.Length <= maxBytes
+        ? System.Text.Encoding.UTF8.GetString(bytes)
+        : System.Text.Encoding.UTF8.GetString(bytes, bytes.Length - maxBytes, maxBytes);
+    return Task.FromResult(text);
+}
+```
+
+Add `using ClaudeDo.Worker.Prime;` to `WorkerHub.cs` if not present.
+
+- [ ] **Step 7: Build Worker; run the full Worker.Tests project.**
+
+```bash
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+```
+
+- [ ] **Step 8: Commit** (stage only Task 1 files):
+```bash
+git commit -m "feat(daily-prep): persist last prep run to a log file and serve it via GetLastPrepLog"
+```
+
+---
+
+## Task 2: UI — load the persisted prep log when opening
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/Services/Interfaces/IWorkerClient.cs`
+- Modify: `src/ClaudeDo.Ui/Services/WorkerClient.cs`
+- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs`
+- Modify fakes: `tests/ClaudeDo.Ui.Tests/StubWorkerClient.cs`, `tests/ClaudeDo.Worker.Tests/UiVm/TasksIslandViewModelPlanningTests.cs` (FakeWorkerClient)
+- Test: `tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandPrepModeTests.cs`
+
+- [ ] **Step 1: Declare on `IWorkerClient`:** `Task<string> GetLastPrepLogAsync();`
+
+- [ ] **Step 2: Implement in `WorkerClient`:** `public Task<string> GetLastPrepLogAsync() => _hub.InvokeAsync<string>("GetLastPrepLog");` (match neighbouring call style; if there is a `TryInvokeAsync` helper for resilience, mirror `GetWeekReportAsync` and return `?? string.Empty`).
+
+- [ ] **Step 3: Update fakes.** Add `public Task<string> GetLastPrepLogAsync() => Task.FromResult(string.Empty);` to both fakes. In `StubWorkerClient`, make it return a settable backing field, e.g. `public string LastPrepLog = ""; public Task<string> GetLastPrepLogAsync() => Task.FromResult(LastPrepLog);`.
+
+- [ ] **Step 4: Write the failing test.**
+
+```csharp
+[Fact]
+public async Task ShowPrep_loads_persisted_log_when_empty()
+{
+    var stub = new StubWorkerClient { LastPrepLog = "{\"type\":\"assistant\",\"text\":\"restored\"}" };
+    var vm = NewDetailsVm(stub);
+
+    vm.ShowPrep();
+    await Task.Delay(50); // allow the async load to run; or expose the load task to await deterministically
+
+    Assert.NotEmpty(vm.PrepLog);
+}
+```
+
+Prefer determinism over `Task.Delay`: have `ShowPrep` start the load and expose the in-flight `Task` (e.g. a `LoadLastPrepLogAsync()` method the test can call/await directly), then assert. Use whichever the existing test style favors.
+
+- [ ] **Step 5: Implement load in `DetailsIslandViewModel`.** Add a method and call it from `ShowPrep`:
+
+```csharp
+public void ShowPrep()
+{
+    Bind(null);
+    IsNotesMode = false;
+    IsPrepMode = true;
+    _ = LoadLastPrepLogIfEmptyAsync();
+}
+
+private async Task LoadLastPrepLogIfEmptyAsync()
+{
+    if (_worker is null || IsPrepRunning || PrepLog.Count > 0) return;
+    string text;
+    try { text = await _worker.GetLastPrepLogAsync(); }
+    catch { return; }
+    if (IsPrepRunning || PrepLog.Count > 0) return; // a live run may have started meanwhile
+    foreach (var line in text.Split('\n'))
+    {
+        var trimmed = line.TrimEnd('\r');
+        if (trimmed.Length > 0) AppendStdoutLine(PrepLog, trimmed);
+    }
+}
+```
+
+This reuses the existing `AppendStdoutLine(PrepLog, line)` formatter path, so persisted NDJSON renders identically to the live stream. The guards ensure it never overwrites a live run (`PrepStarted` clears `PrepLog` and sets `IsPrepRunning`) or an already-loaded log.
+
+- [ ] **Step 6: Build App + run UI tests.**
+
+```bash
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+```
+
+- [ ] **Step 7: Manual smoke (human):** run a prep, restart the app, open the prep log on MyDay → the last run's output is shown.
+
+- [ ] **Step 8: Commit** (stage only Task 2 files):
+```bash
+git commit -m "feat(daily-prep): load persisted prep log into the terminal on open"
+```
+
+## Notes / risks
+- `PrimeRunner` writes via the same `LogWriter` pattern `TaskRunner` uses; concurrency behavior matches existing code (no new locking introduced).
+- Path is shared via `DailyPrepPrompt.LogPath()` so writer and reader never diverge.
+- Load is guarded (`PrepLog empty && !IsPrepRunning`) to avoid clobbering a live stream — the order of `ShowPrep`'s flag set vs. the async load matters; re-check the guard after the await.
+- Last run only (file truncated each run); history is out of scope.

docs/superpowers/plans/2026-06-04-review-and-roadblock-ux.md

@@ -0,0 +1,74 @@
+# Review & Roadblock UX Implementation Plan
+
+> **For agentic workers:** execute task-by-task (subagent-driven-development). Steps use `- [ ]`.
+
+**Goal:** Move the task-row review actions into the Details panel, give the Details panel a real `WaitingForReview` state + a populated diff meter, and add a glanceable yellow roadblock indicator on the task card.
+
+**Architecture:** Persist a `RoadblockCount` on `TaskEntity` (set by the runner when it folds in `CLAUDEDO_BLOCKED` markers). The row shows a warning badge when count > 0; review controls relocate to `DetailsIslandView`.
+
+**Tech Stack:** .NET 8, Avalonia, EF Core (one migration), xUnit.
+
+**Coordination:** A second session (`claudedo-childloop`) is building the child-tasks/improvement-loop in a worktree and will rebase onto main *after* these commits. It also touches `DetailsIslandViewModel`, `TaskRowView.axaml`, `TaskStateService`, `TaskStatus`. This plan deliberately stays OUT of `TaskStateService` and the `TaskStatus` enum (persisting `RoadblockCount` from the runner via the repository instead).
+
+Build/test (per-project, .NET 8):
+```bash
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+dotnet test  tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj -c Release
+dotnet test  tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+```
+
+---
+
+## Task A — Persist RoadblockCount (Data + Worker, no UI)
+
+**Files:** `TaskEntity.cs`, `TaskEntityConfiguration.cs`, new migration, `TaskRepository.cs`, `TaskRunner.cs`; test in `tests/ClaudeDo.Data.Tests`.
+
+- Add `public int RoadblockCount { get; set; }` to `TaskEntity` (default 0).
+- Map it in `TaskEntityConfiguration` to column `roadblock_count` (default 0). Mirror the pattern used by an existing scalar column (e.g. how `DailyPrepMaxTasks`/other ints are configured).
+- Create EF migration `AddRoadblockCount` (run `dotnet ef migrations add AddRoadblockCount` against `src/ClaudeDo.Data`; if EF tooling is unavailable, hand-author the migration + Designer + snapshot edit mirroring the most recent migration). One column, default 0, no backfill needed.
+- Add `TaskRepository.SetRoadblockCountAsync(string taskId, int count, CancellationToken ct)` using `ExecuteUpdateAsync` on `RoadblockCount`.
+- In `TaskRunner.HandleSuccess`, BEFORE the terminal state write (`SubmitForReviewAsync`/`CompleteAsync`), call `SetRoadblockCountAsync(task.Id, result.Blocks.Count, CancellationToken.None)` so the `TaskUpdated` broadcast reflects it. (Do NOT route this through `TaskStateService`.)
+- Test: a `TaskRepository` test that sets a count and reads it back.
+- Commit: `feat(roadblock): persist roadblock count on the task`.
+
+**Acceptance:** a finished run with N roadblocks leaves `tasks.roadblock_count = N`; a clean run leaves 0.
+
+---
+
+## Task B — Detail panel: host review actions + real WaitingForReview state + diff meter
+
+**Files:** `DetailsIslandViewModel.cs`, `DetailsIslandView.axaml` (+ `.axaml.cs` if needed), locales if new keys; reuse `IWorkerClient.ApproveReview/RejectReviewToQueue/RejectReviewToIdle/CancelReview` (already exist).
+
+1. **WaitingForReview state:**
+   - In `StatusToStateKey` map `WaitingForReview => "review"` (was `"running"`); in `FinishedStatusToStateKey` map `"waiting_for_review" => "review"`.
+   - Add `public bool IsWaitingForReview => AgentState == "review";` and raise it in `OnAgentStateChanged`.
+   - Add a `vm.agentStatus.review` locale key (en + de, parity) for the status label.
+   - Confirm `IsAgentSectionEnabled => !IsRunning` still holds (review is no longer "running", so the agent settings section re-enables in review — correct).
+2. **Review actions (moved from the row):** add commands to `DetailsIslandViewModel` that call the worker for the selected task: `ApproveReviewCommand`, `RejectReviewCommand` (takes feedback text → `RejectReviewToQueueAsync`), `ParkReviewCommand` (`RejectReviewToIdleAsync`), `CancelReviewCommand` (`CancelReviewAsync`). Add a `ReviewFeedback` string property for the rejection comment. Mirror how the row's code-behind currently invokes these (see `TaskRowView.axaml.cs`).
+   - In `DetailsIslandView.axaml`, add a review section (visible when `IsWaitingForReview` and `IsTaskDetailVisible`) with Approve / Reject(+feedback box) / Park / Cancel, reusing the existing `tasks.approve/reject/park/cancel` + `tasks.feedback*` locale keys.
+3. **Diff meter:** in `RefreshWorktreeAsync`, after setting `row.DiffStat`, parse the `--stat` summary into additions/deletions and assign `DiffAdditions`/`DiffDeletions` (drives `DiffMeterRatio`). Add a small static parser `ParseDiffStat(string?) -> (int add, int del)` reading the "N insertions(+), M deletions(-)" tail; unit-test it.
+- Commit: `feat(ui): host review actions in the details panel; show review state and diff meter`.
+
+**Acceptance:** selecting a `WaitingForReview` task shows a "review" status (not "running"), the four review actions work from the detail panel, and the diff meter reflects real additions/deletions.
+
+---
+
+## Task C — Task row: remove review buttons, add roadblock badge
+
+**Files:** `TaskRowView.axaml`, `TaskRowView.axaml.cs`, `TaskRowViewModel.cs`; warning icon resource if missing.
+
+- Remove the review-actions `StackPanel` (lines ~142–157) and the now-unused `RejectAnchor` flyout (~250–279) from `TaskRowView.axaml`, and the corresponding click handlers (`OnApproveReviewClick`, `OnRejectReviewClick`, `OnParkReviewClick`, `OnCancelReviewClick`, reject-flyout handlers) from the code-behind. (Review now lives in the detail panel — Task B.)
+- `TaskRowViewModel`: add `int RoadblockCount` + `bool HasRoadblock => RoadblockCount > 0` + `string RoadblockTooltip` (e.g. `"{n} roadblock(s) reported — see details"`); map `RoadblockCount` in `FromEntity`.
+- `TaskRowView.axaml`: add a yellow warning `PathIcon` immediately left of the action area (in the chip row, before the status chip or before the star — pick the spot that reads as "left of the Done/action button"), `IsVisible="{Binding HasRoadblock}"`, `ToolTip.Tip="{Binding RoadblockTooltip}"`. Use a filled-geometry warning icon (PathIcon fills geometry — a stroke path renders invisible); if no `Icon.Warning` resource exists, add one (filled triangle + exclamation) to the icon resources, colored with a yellow/amber brush.
+- Commit: `feat(ui): roadblock badge on the task card; relocate review actions`.
+
+**Acceptance:** rows no longer show the four review buttons; a task with `RoadblockCount > 0` shows a yellow ⚠ left of the action button with a tooltip; review still fully works via the detail panel.
+
+---
+
+## Task D — Build + visual-check
+
+- Full build (`App` + `Worker`) and run Data + Worker test suites; all green.
+- **Manual (flag for user):** start the app, take a `WaitingForReview` task (the deploy roadblock task qualifies), confirm: row shows the ⚠ badge + no row review buttons; detail panel shows "review" state, working review actions, and a non-zero diff meter for the farewell/README tasks. The agent cannot verify GUI — ask the user.
+- Then ping `claudedo-childloop` via mailbox with the exact shared-file diffs so it can rebase.

docs/superpowers/specs/2026-06-03-daily-prep-design.md

@@ -0,0 +1,182 @@
+# Daily Prep ("Prime Claude") — Design
+
+Date: 2026-06-03
+
+## Overview
+
+Turn the existing Prime Time warm-up into a **daily preparation** ("Tagesvorbereitung").
+At a scheduled time (or on demand), Claude reads the open tasks, estimates effort,
+and selects a focused subset into the MyDay list — capped so it never moves
+everything in. Claude does the reasoning itself (agentic), via the already-registered
+ClaudeDo MCP. This replaces the current `"ping"` behavior entirely.
+
+A later phase will feed external tickets (Jira, possibly a second system) into the
+same candidate pool; that is out of scope for this spec.
+
+## Goals
+
+- Scheduled and manual ("Tag vorbereiten" button) daily prep.
+- Claude picks a subset of open tasks into MyDay, ordered so related tasks sit together.
+- Effort-aware selection, hard-capped at `X` open MyDay tasks.
+- Keep existing MyDay tasks across re-runs; only top up to `X`.
+- Candidates limited to tasks in repos that are **not** excluded from the weekly report.
+
+## Non-Goals
+
+- External ticket integration (Jira etc.) — future phase.
+- Group labels/headers in the MyDay view — grouping is ordering-only via `SortOrder`.
+- A user-editable prep prompt — the prompt is fixed, parameterized.
+
+## Key Decisions
+
+| Topic | Decision |
+| --- | --- |
+| Who reasons | Agentic — Claude decides via MCP tools. |
+| MyDay model | `TaskEntity.IsMyDay` flag (smart list `smart:my-day`). |
+| Grouping | Ordering only via existing `SortOrder` (no new field, no migration for grouping). |
+| Selection | Effort estimate, hard cap `X` tasks/day. |
+| Candidates | `Status == Idle`, `BlockedByTaskId == null`, list `WorkingDir` not under `ReportExcludedPaths`. |
+| Re-run | Keep existing MyDay tasks; top up to `X`. |
+| Trigger | Existing Prime schedule **and** a manual button. |
+| Ping | Removed — daily prep replaces it. |
+| Prompt | Fixed, with injected parameters (`X`, today's date). |
+| Tool access | Reuse the globally registered `claudedo` MCP — **no** separate `--mcp-config`. |
+
+## Architecture
+
+### 1. MCP tools (extend `ExternalMcpService`, port 47822)
+
+The worker already exposes `ExternalMcpService` as the `claudedo` MCP server. Add two tools;
+they automatically surface as `mcp__claudedo__get_daily_prep_candidates` and
+`mcp__claudedo__set_my_day`.
+
+- **`get_daily_prep_candidates()`** → JSON containing:
+  - `candidates[]`: open, non-blocked tasks in non-excluded repos, each with
+    `id, title, description, listName, isStarred, scheduledFor, age` (age derived from `CreatedAt`).
+  - `currentMyDay[]`: currently-`IsMyDay` open tasks (so Claude sees remaining capacity).
+  - Filter: `Status == Idle` AND `BlockedByTaskId == null` AND the task's list `WorkingDir`
+    does not start with any prefix in `AppSettings.ReportExcludedPaths`
+    (default `["C:\\Private"]`; case-insensitive prefix match, same semantics as the weekly report).
+
+- **`set_my_day(taskId, isMyDay, sortOrder?)`** →
+  - Sets `IsMyDay` and (optionally) `SortOrder` on the task via `TaskRepository`.
+  - Broadcasts `TaskUpdated` via `HubBroadcaster` so the UI updates live.
+  - **Cap-guard:** when `isMyDay == true`, count current open (`Idle`) tasks with
+    `IsMyDay == true`. If `count >= X`, reject with an error message
+    ("MyDay limit {X} reached"). `isMyDay == false` is always allowed.
+    `X = AppSettings.DailyPrepMaxTasks`. This guarantees the "never move everything in"
+    invariant server-side, independent of Claude's behavior.
+
+### 2. `DailyPrepRunner` (replaces ping logic)
+
+Rename `IPrimeRunner`/`PrimeRunner` → `IDailyPrepRunner`/`DailyPrepRunner` (the `"ping"`
+concept is gone). It:
+
+- Loads `AppSettings` (`X = DailyPrepMaxTasks`).
+- Builds the fixed prompt with injected parameters (`X`, today's date).
+- Invokes `claude -p --output-format stream-json --verbose` with:
+  - `--permission-mode` set so the headless run won't block on permission prompts,
+  - `--allowedTools mcp__claudedo__get_daily_prep_candidates mcp__claudedo__set_my_day`,
+  - `--max-turns 30` (constant), timeout 5 min (constant; larger than the old 60s ping).
+- **No `--mcp-config`** — relies on the globally registered `claudedo` MCP (the worker runs
+  as the user via the per-user logon Scheduled Task, so the headless run inherits the
+  user-scope registration and its auth).
+- Returns an outcome (e.g. number of tasks added) for broadcasting.
+
+### 3. Scheduler
+
+`PrimeScheduler` is unchanged in structure — it now calls `IDailyPrepRunner` instead of the
+ping runner. `NextDueCalculator` and the schedule model are untouched.
+
+### 4. Manual trigger
+
+- Worker hub method `RunDailyPrepNow()` invokes the same `DailyPrepRunner`.
+- UI button **"Tag vorbereiten"** in the MyDay list header.
+- **Single-flight guard:** if a prep run is already in progress, the trigger reports
+  "already running" and does not start a parallel run (applies to both schedule and button).
+
+### 5. Parameter config
+
+- New field **`DailyPrepMaxTasks`** (int, default `5`) on `AppSettingsEntity`.
+- Plumbing: EF config + migration, `AppSettingsRepository`, `WorkerHub` AppSettings DTO,
+  UI DTO mirror + `WorkerClient`, and a numeric editor in the Prime Claude settings tab.
+- `ReportExcludedPaths` is reused as-is (already on `AppSettings`).
+
+## Data Flow
+
+1. Trigger (schedule due **or** button) → `DailyPrepRunner.RunAsync`.
+2. Runner loads `AppSettings` (`X`), builds prompt, launches Claude.
+3. Claude → `get_daily_prep_candidates` → DB query returns filtered candidates + current MyDay.
+4. Claude estimates effort, tops up to **X total**, calls `set_my_day(id, true, sortOrder)`
+   for each chosen task (consecutive `sortOrder` for related tasks).
+5. `ExternalMcpService` writes `IsMyDay`/`SortOrder`, broadcasts `TaskUpdated` → MyDay list
+   updates live.
+6. Runner updates `LastRunAt`, broadcasts "prep done" (count added).
+
+## Fixed Prompt (parameterized)
+
+Content (parameters in `{}`):
+
+> Du bereitest meinen Arbeitstag für **{today}** vor.
+> 1. Rufe `get_daily_prep_candidates` auf.
+> 2. Behalte bereits als MyDay markierte offene Tasks.
+> 3. Fülle bis **maximal {X} offene Tasks gesamt** in MyDay auf — niemals mehr.
+> 4. Schätze pro Task grob den Aufwand; wähle eine machbare Mischung (nicht nur Großbrocken).
+>    Priorisiere `isStarred`, fällige (`scheduledFor`) und ältere Tasks.
+> 5. Lege thematisch verwandte Tasks durch aufeinanderfolgende `sortOrder`-Werte nebeneinander.
+> 6. Setze die Auswahl via `set_my_day(id, true, sortOrder)`. Markiere nichts außerhalb der
+>    Kandidatenliste.
+
+Injected parameters: `{today}` (date) and `{X}` (= `DailyPrepMaxTasks`).
+
+## Error Handling
+
+- No candidates → Claude marks nothing; runner reports "0 added".
+- Claude run fails / times out → log + failure broadcast (existing scheduler event channel);
+  `LastRunAt` is set on attempt, as today, to avoid tight retry loops.
+- `set_my_day` on an invalid/ineligible id → tool returns an error string; Claude adapts.
+- Cap exceeded → tool returns an error; Claude stops adding.
+- Concurrent trigger → single-flight guard reports "already running".
+
+## Testing
+
+Real SQLite + real git (project convention).
+
+- `get_daily_prep_candidates`: only `Idle`; blocked excluded; tasks in excluded repos
+  (`ReportExcludedPaths`) excluded; current MyDay tasks included.
+- `set_my_day`: sets flag + `SortOrder`; broadcasts `TaskUpdated`; cap-guard rejects at limit;
+  unset always allowed.
+- `DailyPrepRunner`: prompt contains `{X}` + date; args contain `--allowedTools` +
+  permission-mode + `--max-turns`; success/failure outcomes via an `IClaudeProcess` fake.
+- Rename `IPrimeRunner` → `IDailyPrepRunner` requires syncing `PrimeScheduler` tests/fakes.
+
+## Files to Create / Modify (high level)
+
+**Data**
+- `Models/AppSettingsEntity.cs` — add `DailyPrepMaxTasks`.
+- `Configuration/AppSettingsEntityConfiguration.cs` — map new column.
+- `Migrations/` — new migration for `daily_prep_max_tasks`.
+- `Repositories/AppSettingsRepository.cs` — persist new field.
+
+**Worker**
+- `External/ExternalMcpService.cs` — add `get_daily_prep_candidates`, `set_my_day` (+ cap-guard).
+- `Prime/PrimeRunner.cs` → `DailyPrepRunner.cs`; `Prime/Interfaces/IPrimeRunner.cs`
+  → `IDailyPrepRunner.cs`; prompt builder + arg builder.
+- `Prime/PrimeScheduler.cs` — depend on `IDailyPrepRunner`.
+- `Hub/WorkerHub.cs` — AppSettings DTO field; `RunDailyPrepNow()`.
+- `Program.cs` — DI registration update.
+
+**UI**
+- `Services/WorkerClient.cs` + AppSettings DTO mirror — new field; `RunDailyPrepNow` call.
+- Prime Claude settings tab VM/view — numeric editor for `DailyPrepMaxTasks`.
+- MyDay list header — "Tag vorbereiten" button + command (Lists/IslandsShell VM).
+
+**Tests**
+- `ClaudeDo.Worker.Tests` — MCP tools, runner, scheduler fakes.
+- `ClaudeDo.Data.Tests` — AppSettings persistence (if covered there).
+- `ClaudeDo.Ui.Tests` — settings VM / button wiring as applicable.
+
+## Future Phase (out of scope)
+
+External ticket sources (Jira, possibly a second system) feed into the candidate pool used by
+`get_daily_prep_candidates`, behind a task-source abstraction. Designed separately.

docs/superpowers/specs/2026-06-03-daily-prep-live-view-design.md

@@ -0,0 +1,151 @@
+# Daily Prep — Live Output View + Clear Day — Design
+
+Date: 2026-06-03
+
+## Overview
+
+Two follow-ups to the daily-prep ("Prime Claude") feature:
+
+1. **Live output view.** While Claude prepares the day, there is no feedback. Add a
+   live, human-readable view of the prep run's output, shown as a new content mode in
+   the existing right-hand **Details island** (mirroring how Daily Notes works — a mode
+   swap, not a separate window/column).
+2. **Clear Day button.** A MyDay-header button that clears the MyDay selection
+   immediately.
+
+## Goals
+
+- See the prep run's progress live, rendered with the same friendly terminal renderer
+  used for task runs (assistant text + tool calls like `set_my_day …`, not raw NDJSON).
+- Both manual (button) and scheduled prep runs stream into the log.
+- The manual button opens the prep view; a scheduled run fills the log silently and is
+  opened via a dedicated "Vorbereitungs-Log" button (the existing `PrimeStatus` footer
+  remains the hint that a run happened).
+- A "Tag leeren" button clears all MyDay tasks (any status) with no confirmation.
+
+## Non-Goals
+
+- No new island/column and no popup/overlay — reuse the Details island as a mode swap.
+- No persistence of prep output across app restarts (in-memory log only).
+- No undo for Clear Day (re-runnable via "Tag vorbereiten").
+
+## Key Decisions
+
+| Topic | Decision |
+| --- | --- |
+| Rendering | Reuse the existing `SessionTerminalView` / `StreamLineFormatter` renderer. |
+| Location | New `IsPrepMode` content panel inside the Details island (like `IsNotesMode`). |
+| Lifecycle | Manual click opens the view (UI-local); `PrepStarted/PrepLine/PrepFinished` events fill the log regardless of current mode; scheduled runs do not auto-open. |
+| Open after schedule | Dedicated "Vorbereitungs-Log" header button + existing `PrimeStatus` footer hint. |
+| Clear Day scope | All MyDay tasks regardless of status. |
+| Clear Day confirm | None — clear directly. |
+
+## Architecture
+
+### Feature A — Live prep output
+
+**Worker**
+- Extend `IPrimeBroadcaster` (`src/ClaudeDo.Worker/Prime/Interfaces/IPrimeBroadcaster.cs`)
+  with `PrepStartedAsync()`, `PrepLineAsync(string line)`, `PrepFinishedAsync(bool success)`.
+- Implement in `HubBroadcaster` (`src/ClaudeDo.Worker/Hub/HubBroadcaster.cs`) sending
+  SignalR events `PrepStarted`, `PrepLine` (string), `PrepFinished` (bool).
+- `PrimeRunner` (`src/ClaudeDo.Worker/Prime/PrimeRunner.cs`): inject `IPrimeBroadcaster`.
+  In `FireAsync`, after the single-flight gate is entered and a run will actually happen:
+  call `PrepStartedAsync()` before `RunAsync`; replace the discard lambda with
+  `async line => await _broadcaster.PrepLineAsync(line)`; call
+  `PrepFinishedAsync(result.IsSuccess)` after. The "already running" early-return path
+  emits nothing (no run occurs). Both scheduled and manual runs go through `FireAsync`,
+  so both stream.
+
+**UI**
+- `WorkerClient` (`src/ClaudeDo.Ui/Services/WorkerClient.cs`): register
+  `_hub.On<…>("PrepStarted"/"PrepLine"/"PrepFinished", …)` each via
+  `Dispatcher.UIThread.Post`, raising `PrepStartedEvent` / `PrepLineEvent(string)` /
+  `PrepFinishedEvent(bool)`. Declare these on `IWorkerClient`.
+- `DetailsIslandViewModel`: add `IsPrepMode` (bool), `IsPrepRunning` (bool), a dedicated
+  `PrepLog` (`ObservableCollection<LogLineViewModel>`), and `ShowPrep()` (calls
+  `Bind(null)`, sets `IsNotesMode=false`, `IsPrepMode=true`). Subscribe to the three prep
+  events in the ctor (always active, independent of mode):
+  - `PrepStarted` → clear `PrepLog`, `IsPrepRunning=true`.
+  - `PrepLine` → format the line with the same `StreamLineFormatter` path used by the
+    stdout branch of `OnTaskMessage`, append a `LogLineViewModel` to `PrepLog`.
+  - `PrepFinished` → `IsPrepRunning=false` (optionally append a status line).
+  Mode exclusivity: the normal task-details panel becomes visible on
+  `!IsNotesMode && !IsPrepMode`; `ShowNotes()` also sets `IsPrepMode=false`; `Bind(task)`
+  resets both flags.
+- `DetailsIslandView.axaml`: add a third `<Panel IsVisible="{Binding IsPrepMode}">` in the
+  body grid alongside the existing details/notes panels, rendering `PrepLog` in the
+  terminal style (reuse the `LogLineViewModel` item template used by `SessionTerminalView`).
+
+**Wiring**
+- `TasksIslandViewModel`: add a `PrepRequested` event (mirror `NotesRequested`).
+  `PrepareDayCommand` raises `PrepRequested` in addition to calling
+  `RunDailyPrepNowAsync()`. Add `ShowPrepLogCommand` that raises `PrepRequested`. Add the
+  "Vorbereitungs-Log" button to the MyDay header (`IsVisible="{Binding IsMyDayList}"`).
+- `IslandsShellViewModel`: wire `Tasks.PrepRequested += () => Details.ShowPrep()`.
+
+### Feature B — Clear Day
+
+**Worker**
+- `WorkerHub.ClearMyDay()` (`src/ClaudeDo.Worker/Hub/WorkerHub.cs`): query ids where
+  `IsMyDay == true`; `ExecuteUpdateAsync` setting `is_my_day = false`; broadcast
+  `TaskUpdated(id)` for each affected id (the UI reloads the current list on `TaskUpdated`).
+
+**UI**
+- `IWorkerClient.ClearMyDayAsync()` + `WorkerClient` impl invoking `"ClearMyDay"`.
+- `TasksIslandViewModel.ClearDayCommand` calls `_worker.ClearMyDayAsync()` (no confirm).
+  Add the "Tag leeren" button to the MyDay header next to "Tag vorbereiten".
+
+## Data Flow (live view)
+
+1. Trigger (schedule or button) → `PrimeRunner.FireAsync`.
+2. `PrepStartedAsync()` → SignalR `PrepStarted` → `WorkerClient.PrepStartedEvent` →
+   `DetailsIslandViewModel` clears `PrepLog`, sets `IsPrepRunning`.
+3. Each Claude stdout line → `PrepLineAsync(line)` → `PrepLine` → formatted, appended to
+   `PrepLog` (visible if the user is in prep mode; filled silently otherwise).
+4. Run ends → `PrepFinishedAsync(success)` → `PrepFinished` → `IsPrepRunning=false`.
+5. Manual button click also raised `PrepRequested` → `Details.ShowPrep()` (view open).
+   After a scheduled run, the user clicks "Vorbereitungs-Log" to open it.
+
+## Error Handling
+
+- Prep run fails/times out → `PrepFinished(false)`; the existing `PrimeFired` footer
+  status still reports failure.
+- "Already running" → no prep events emitted (no run happened); existing behavior intact.
+- `ClearMyDay` with zero MyDay tasks → no-op, no broadcasts.
+
+## Testing
+
+- Worker: `PrimeRunner` streams `PrepStarted` → N×`PrepLine` → `PrepFinished` (fake
+  `IClaudeProcess` invokes `onStdoutLine` with sample lines; fake `IPrimeBroadcaster`
+  records calls). `WorkerHub.ClearMyDay` clears all IsMyDay rows and broadcasts per id
+  (real SQLite, mirror existing hub tests).
+- UI: `DetailsIslandViewModel` appends to `PrepLog` on `PrepLineEvent` and `ShowPrep()`
+  sets the mode flags (mutual exclusivity with notes); `TasksIslandViewModel.ClearDayCommand`
+  calls `ClearMyDayAsync` (stub worker client).
+
+## Files (high level)
+
+**Modify**
+- `src/ClaudeDo.Worker/Prime/Interfaces/IPrimeBroadcaster.cs`
+- `src/ClaudeDo.Worker/Hub/HubBroadcaster.cs`
+- `src/ClaudeDo.Worker/Prime/PrimeRunner.cs`
+- `src/ClaudeDo.Worker/Hub/WorkerHub.cs` (ClearMyDay)
+- `src/ClaudeDo.Ui/Services/Interfaces/IWorkerClient.cs`
+- `src/ClaudeDo.Ui/Services/WorkerClient.cs`
+- `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs`
+- `src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml`
+- `src/ClaudeDo.Ui/ViewModels/Islands/TasksIslandViewModel.cs`
+- `src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml`
+- `src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs`
+- `src/ClaudeDo.Localization/locales/en.json`, `de.json` (button labels)
+
+**Test**
+- `tests/ClaudeDo.Worker.Tests/Prime/PrimeRunnerTests.cs`
+- `tests/ClaudeDo.Worker.Tests/Hub/…` (ClearMyDay)
+- `tests/ClaudeDo.Ui.Tests/…` (DetailsIslandViewModel prep events; TasksIslandViewModel ClearDay) + `StubWorkerClient`
+
+## Known fragility
+
+Changing `IWorkerClient` / `WorkerClient` / VM constructors breaks hand-rolled fakes
+(`StubWorkerClient`, `FakeWorkerClient`) in both test projects — update all of them.

docs/superpowers/specs/2026-06-03-localization-design.md

@@ -0,0 +1,114 @@
+# Localization (i18n) Support — Design
+
+**Date:** 2026-06-03
+**Status:** Approved (pending spec review)
+
+## Goal
+
+Add translation support to ClaudeDo. The user picks a language in the Settings modal and **all** UI text reflects it instantly (no restart). The WPF installer is localized the same way and gets its own language picker. Ship **English only** now, but the system is fully data-driven: adding a new language means dropping one JSON file into a folder — **no code changes, no rebuild**.
+
+## Decisions (from brainstorming)
+
+- **Languages:** English only at launch; extensible via translation files.
+- **Switching:** Live / instant — all bound UI text updates the moment the language changes.
+- **Storage:** Selected language stored in `~/.todo-app/ui.config.json` (the local UI config that also holds `DbPath`/`SignalRUrl`). Purely a UI concern — does **not** go through the worker/SignalR settings path.
+- **Installer:** Defaults to existing config language (upgrade) → OS culture → English. Shows a language picker in the wizard, live-switches its own UI, and writes the chosen language into `ui.config.json` so the app launches matching the installer.
+- **Locale files:** Loose `*.json` files in a `locales/` folder next to the running exe, scanned at startup to discover available languages.
+- **Code sharing:** A shared `ClaudeDo.Localization` project holds the loading/lookup/language-list logic, referenced by `ClaudeDo.Ui`, `ClaudeDo.App`, and `ClaudeDo.Installer`. Each UI framework keeps its own thin markup-extension binding layer (Avalonia ≠ WPF).
+
+## Architecture & Components
+
+### New shared project: `ClaudeDo.Localization`
+
+- **`LocaleStore`** — discovers and loads `*.json` files from the `locales/` folder next to the running exe. Parses each file's nested JSON, **flattens it into an internal `Dictionary<string,string>`** keyed by dot-path for O(1) lookup, and captures `metadata.code` / `metadata.name`. Exposes the list of available languages for the dropdowns.
+- **`ILocalizer` / `Localizer`** — singleton holding the *active* language dictionary. Members:
+  - indexer `this[string key]` → translated string (with fallback),
+  - `string Get(string key, params object[] args)` → `string.Format` for parameterized strings,
+  - `void SetLanguage(string code)` → swaps the active dictionary and raises `PropertyChanged` for the indexer so **all live bindings refresh** (this is what enables instant switching),
+  - `AvailableLanguages` (list of `{ code, name }`), `CurrentCode`.
+- **Fallback chain:** requested key in active language → same key in English → the key path string itself (a missing translation is visible, never a crash).
+- **OS-culture resolution:** helper that maps the current OS UI culture to an available locale code, falling back to English.
+
+### Per-framework binding layer (not shared)
+
+- **Avalonia:** a `{loc:Tr Some.Key}` markup extension that binds to `Localizer[key]` (Source = the singleton `Localizer`, Path = `[key]`). Language change raises the indexer `PropertyChanged`, refreshing every binding.
+- **WPF installer:** an equivalent markup extension doing the same against the installer's own `Localizer` instance.
+
+Both consume the **same JSON files and the same `LocaleStore`/`Localizer` logic** from the shared project.
+
+## Translation File Format
+
+`locales/en.json` (and future `de.json`, `fr.json`, …) — nested, human-friendly hierarchy:
+
+```json
+{
+  "metadata": { "code": "en", "name": "English" },
+  "settings": {
+    "save": "Save",
+    "cancel": "Cancel",
+    "general": { "model": "Model", "maxParallel": "Max parallel executions" }
+  },
+  "tasks": {
+    "addPlaceholder": "Add a task…",
+    "overdue": "OVERDUE"
+  },
+  "worktrees": { "autoCleanupDays": "{0} days" }
+}
+```
+
+- `metadata.code` is the language id stored in `ui.config.json` and matched to OS culture; `metadata.name` is the dropdown label.
+- **Lookup by dot-path key** (`"settings.general.model"`). On-disk file stays grouped/nested; the runtime flattens it for fast lookup. Authors edit a clean hierarchy.
+- **Parameters:** `{0}`, `{1}` placeholders resolved via `Get(key, args)`.
+- **Encoding:** UTF-8 — non-ASCII languages work out of the box.
+
+## Data Flow & Wiring
+
+### App config
+
+- Add `Language` (string, e.g. `"en"`) to `AppSettings` (`ClaudeDo.Ui/AppSettings.cs`) and to the installer mirror `InstallerAppSettings` (`ClaudeDo.Installer/Core/ConfigModels.cs`).
+- Add a `Save()` method to `AppSettings` (today the UI only reads it).
+
+### App startup (`ClaudeDo.App/Program.cs`)
+
+1. `AppSettings.Load()` reads `Language` (missing/empty → resolve from OS culture, else `"en"`).
+2. `LocaleStore` scans `locales/` next to the exe; `Localizer` is registered as a singleton and set to the configured language.
+3. UI renders; every `{loc:Tr ...}` binding pulls from the active dictionary.
+
+### Changing language in Settings (General tab)
+
+- New "Language" dropdown bound to `Localizer.AvailableLanguages`; selection bound to current code.
+- On change → `Localizer.SetLanguage(code)` (instant UI refresh) **and** `AppSettings.Language = code; AppSettings.Save()`. Local UI state only — not routed through worker/SignalR.
+
+### Installer (`ClaudeDo.Installer`)
+
+- On launch: default language = existing `ui.config.json` `Language` if present (upgrade), else OS culture, else English.
+- Wizard gets a language dropdown (same `LocaleStore`, installer's own markup extension) → live-switches the installer UI.
+- When writing `ui.config.json`, persists the chosen `Language` so the app launches matching the installer.
+
+### Build wiring
+
+- `locales/*.json` copied to output (`CopyToOutputDirectory`) for both App and Installer.
+- Installer packages the `locales/` folder so it lands beside the installed exe.
+
+## String-Extraction Scope
+
+Mechanical but large; done screen-by-screen so each commit is reviewable, building one `en.json` as the single source of truth.
+
+- **22 Avalonia `.axaml` views** — replace inline `Text="..."`, `Content="..."`, `PlaceholderText="..."`, and inline `ComboBoxItem` text with `{loc:Tr key}`.
+- **ViewModel strings** — user-facing literals built in C# (e.g. `HeaderTitle`, `StatusPill`, status text, parameterized messages) resolve via injected `ILocalizer` (`localizer.Get(...)`). Log messages and non-user-facing strings stay as-is. **Live-switch note:** a VM string resolved once will not refresh on language change. For VM-built user-facing text, either (a) prefer resolving in XAML via `{loc:Tr}` where possible, or (b) have the VM subscribe to the `Localizer` change event and re-raise `PropertyChanged` (or re-resolve) for its localized properties. Decide per-property during extraction.
+- **10 WPF installer files** — same treatment with the installer's markup extension; VM-driven headings (`Heading`, `NextButtonText`, etc.) go through `ILocalizer`.
+- **Enum-ish display values** (model names, permission modes, weekday names) — translate the *display* text while keeping the underlying value/binding intact.
+
+## Testing
+
+- `ClaudeDo.Localization` unit tests: load/flatten nested JSON, dot-path lookup, fallback chain (active→en→key), `{0}` formatting, OS-culture resolution.
+- `LocaleStore` discovery test (folder scan → available languages).
+- **Key-coverage test:** every locale file's flattened key set matches `en.json`; fails the build if `en.json` drifts from other locale files.
+- Settings round-trip test: `SetLanguage` updates `Localizer` **and** persists to `ui.config.json`.
+- Manual UI pass (user's visual review): confirm instant switching with a throwaway `de.json` stub during dev, then remove it.
+
+## Out of Scope (YAGNI)
+
+- Pluralization rules, RTL layout, per-string gender.
+- Translating the German weekly-report **body** (generated content — stays as-is).
+- Localizing log output and non-user-facing strings.

docs/superpowers/specs/2026-06-03-weekly-report-design.md

@@ -0,0 +1,226 @@
+# Weekly Report — Design
+
+**Date:** 2026-06-03
+**Status:** Approved (pending spec review)
+
+## Goal
+
+Generate a short, standup-focused report of what the user did over the past week,
+for the Wednesday standup. The report is built from the user's Claude Code session
+history across all repos, distilled and summarized by Claude. Personal repos under a
+configurable excluded path (default `C:\Private`) are left out. The user can author
+per-day bullet notes inside ClaudeDo (via the My Day list) that are folded into the
+report.
+
+## Decisions (from brainstorming)
+
+- **Data source:** all Claude Code history in `~/.claude/projects/*/*.jsonl`, both manual
+  sessions and ClaudeDo-run tasks, grouped by repo.
+- **Exclusion:** a configurable list of path prefixes (default `["C:\\Private"]`). Any
+  session whose `cwd` starts with an excluded prefix is dropped.
+- **Summarization:** Claude CLI summarizes. The Worker distills the logs, then runs a
+  single one-shot `claude -p` call via the existing `ClaudeProcess` and returns the
+  result markdown. No worktree, no task row, no queue.
+- **Period:** default "since last Wednesday → today", computed from a configurable
+  standup weekday. The range is adjustable in the modal.
+- **Signal fed to Claude:** user prompts (intent), assistant closing summaries, and the
+  user's daily notes. No git-commit scanning.
+- **Report shape:** German, grouped by day, first-person past-tense bullets, ~3-5
+  bullets/day with trivia merged/dropped, notes blended into one deduplicated list per
+  day. See the Report Prompt section.
+- **Placement:** a "Weekly Report" overlay modal opened from the toolbar, rendering via
+  the existing `MarkdownView`.
+- **Output:** view-only in-app (no export).
+- **Notes UI:** authored in the My Day list via a pinned non-task "Notes" pseudo-row that
+  repurposes the Details island into a bullet-notes editor. Per-day bullets with a day
+  navigator (prev/next arrows + date picker + Today).
+- **Report persistence:** generated reports are stored, keyed by exact date range, and
+  reused. Generation is button-driven (never automatic); a Regenerate button overwrites.
+
+## Architecture Overview
+
+```
+UI (WeeklyReportModal, Details-island notes mode)
+        │  SignalR
+        ▼
+WorkerHub  ── GetWeekReport / GenerateWeekReport / daily-notes CRUD
+        │
+        ├── WeekReportService  ──► ClaudeHistoryReader (scan ~/.claude/projects)
+        │        │                 (distilled activity)
+        │        ├── DailyNoteRepository (notes in window)
+        │        ├── ClaudeProcess (one-shot summarize)
+        │        └── WeekReportRepository (store/reuse)
+        └── DailyNoteRepository (CRUD)
+
+Data: DailyNoteEntity, WeekReportEntity + repositories + EF migration
+      AppSettingsEntity: ReportExcludedPaths, StandupWeekday
+```
+
+## Components
+
+### 1. Data layer (`ClaudeDo.Data`)
+
+**`DailyNoteEntity`** (table `daily_notes`)
+- `Id` (GUID string, init-only PK)
+- `Date` (date-only; the day the bullet belongs to)
+- `Text` (string, the bullet content)
+- `SortOrder` (int; ordering within a day)
+- `CreatedAt` (DateTime)
+
+**`DailyNoteRepository`** (async, CancellationToken, follows existing repo pattern)
+- `ListByDayAsync(DateOnly day)` — bullets for one day, ordered by `SortOrder`.
+- `ListBetweenAsync(DateOnly start, DateOnly end)` — bullets in a window (used by the report).
+- `AddAsync(DateOnly day, string text)` — appends a bullet (assigns next `SortOrder`).
+- `UpdateAsync(string id, string text)`
+- `DeleteAsync(string id)`
+
+**`WeekReportEntity`** (table `week_reports`)
+- `Id` (GUID string, init-only PK)
+- `StartDate`, `EndDate` (date-only; the report window — unique together)
+- `Markdown` (string; the generated report)
+- `GeneratedAt` (DateTime)
+
+**`WeekReportRepository`**
+- `GetByRangeAsync(DateOnly start, DateOnly end)` — stored report for an exact range, or null.
+- `UpsertAsync(DateOnly start, DateOnly end, string markdown)` — insert or overwrite by range.
+
+**`AppSettingsEntity`** — two new columns:
+- `ReportExcludedPaths` (string, JSON array of path prefixes; default `["C:\\Private"]`)
+- `StandupWeekday` (int, `DayOfWeek`; default `Wednesday` = 3)
+
+**Migration** — one EF migration adds `daily_notes`, `week_reports`, and the two
+`app_settings` columns. Entity configs in `Configuration/` (date-only and enum/JSON
+conversion via `ValueConverter`, per existing convention).
+
+### 2. Worker (`ClaudeDo.Worker`) — new `Report/` folder
+
+**`ClaudeHistoryReader`** (raw → distilled)
+- Input: date window + excluded path prefixes.
+- Enumerates `~/.claude/projects/*/*.jsonl`.
+- Parses each line as JSON; tolerant of malformed lines (skip, never throw).
+- Drops a session entirely if its `cwd` starts with any excluded prefix
+  (case-insensitive, normalized separators).
+- Keeps messages whose `timestamp` falls in `[start, end]`.
+- Extracts, per repo (`cwd`) → per day:
+  - **user prompts**: `type == "user"` text content (string or `content[].text`).
+    Skip tool-result-only user turns and queue/attachment/hook noise.
+  - **assistant closing summaries**: the final assistant text block of each turn/session.
+- Output: a structured model, e.g.
+  `IReadOnlyList<RepoActivity>` where `RepoActivity { RepoPath, Days: List<DayActivity{ Date, Prompts[], Summaries[] }> }`.
+
+**`WeekReportService`** (distilled → stored summary)
+- `GenerateAsync(start, end, ct)`:
+  1. Read settings (excluded paths, standup weekday).
+  2. `ClaudeHistoryReader` → distilled activity.
+  3. `DailyNoteRepository.ListBetweenAsync` → notes grouped by day.
+  4. Pivot the distilled activity (repo→day from the reader) into **day-major**
+     (day→repo) to match the day-grouped report, and build the prompt from the
+     template in the Report Prompt section. Empty window → produce a "no activity"
+     report without calling Claude.
+  5. Run `ClaudeProcess` once (`claude -p`, no worktree/agents; working dir = a neutral
+     dir). Read `RunResult.ResultMarkdown`.
+  6. `WeekReportRepository.UpsertAsync(start, end, markdown)`; return markdown.
+  7. On Claude failure, surface `RunResult.ErrorMarkdown` to the caller (do not store).
+- `GetStoredAsync(start, end)` → `WeekReportRepository.GetByRangeAsync`.
+
+Interfaces live in `Report/Interfaces/` per the area convention.
+
+#### Report Prompt
+
+`WeekReportService` assembles this prompt. Instructions are in English (more reliable
+steering); the output is forced to German. `{...}` are filled at build time.
+
+```
+You are generating a concise weekly standup report for a software developer.
+Summarize what they accomplished between {start:dd.MM.yyyy} and {end:dd.MM.yyyy}.
+
+Rules:
+- Write the ENTIRE report in German.
+- Group by day. One "## {Wochentag}, {dd.MM.yyyy}" section per day that has
+  activity (German weekday names). Omit days with no activity entirely.
+- Within each day: 3–5 first-person, past-tense bullets ("- Habe X umgesetzt",
+  "- Y behoben"). Merge related small work into one bullet.
+- Drop trivia: typo fixes, pure exploration, false starts, tooling/log noise.
+- Blend the developer's own notes and the derived activity into ONE deduplicated
+  bullet list per day. The developer's notes are authoritative — never omit or
+  contradict their substance.
+- Name the project/repo when it adds clarity.
+- Output ONLY the dated sections. No preamble, no intro, no closing remarks.
+
+== Activity (from session history) ==
+{day-major: for each day → for each repo → its prompts + closing summaries}
+
+== Developer notes ==
+{day-major: for each day → the bullets}
+```
+
+### 3. IPC (Hub + WorkerClient)
+
+**`WorkerHub`** new methods:
+- `GetWeekReport(string startIso, string endIso)` → stored markdown or null.
+- `GenerateWeekReport(string startIso, string endIso)` → generates, stores, returns markdown.
+- `GetDailyNotes(string dayIso)` → bullets for a day.
+- `AddDailyNote(string dayIso, string text)` → created bullet.
+- `UpdateDailyNote(string id, string text)`.
+- `DeleteDailyNote(string id)`.
+
+**`WorkerClient`** (UI) mirrors these, following the existing
+`WorkerPrimeScheduleApi`/AppSettings method pattern.
+
+### 4. UI (`ClaudeDo.Ui`)
+
+**Weekly Report modal** (`WeeklyReportModalView` + `WeeklyReportModalViewModel`)
+- Overlay modal in the `Modals/` pattern (like `WorktreesOverviewModalView`),
+  registered in `IslandsShellViewModel`, opened from a new toolbar button.
+- Date range: two `ThemedDatePicker`s, default "since last Wednesday → today" computed
+  from `StandupWeekday`.
+- On open and on range change: call `GetWeekReport`.
+  - Stored report exists → render markdown via `MarkdownView`, show `GeneratedAt`, show
+    a **Regenerate** button.
+  - None → empty state ("Not generated yet") + a **Generate** button.
+- **Generate**/**Regenerate**: call `GenerateWeekReport` with a busy/spinner state;
+  render the returned markdown. Generation only ever runs from these buttons.
+- View-only; no export.
+
+**Notes in My Day**
+- The My Day smart list (`smart:my-day`) pins a fixed, non-task "Notes" pseudo-row at
+  the top, recognized by the list/selection code (not a `TaskEntity`).
+- Selecting it puts the **Details island** into **notes mode** (task fields hidden,
+  notes editor shown). The island hosts a dedicated `NotesEditorViewModel` + small view
+  rather than swelling `DetailsIslandViewModel` (already ~978 lines); the bullet logic
+  stays isolated and testable.
+- **Day navigator** in the editor header: `<` / `>` arrows to step days, a
+  `ThemedDatePicker` to jump to any date, and a "Today" button. Defaults to today; the
+  pinned row's default day rolls over at midnight (no data lost — past days remain
+  reachable via the navigator).
+- **Bullet editing** for the selected day: list of bullets with add / inline-edit /
+  delete / reorder (`SortOrder`). Each operation goes through the daily-notes hub CRUD.
+
+### 5. Settings
+
+- Add the excluded-path list and the standup weekday to the existing Settings modal,
+  persisted via the new `app_settings` columns and the existing
+  `GetAppSettings`/`UpdateAppSettings` path.
+
+## Error Handling
+
+- Malformed/unreadable JSONL lines are skipped, never fatal.
+- Empty window → a "no activity" report, no Claude call.
+- Claude call failure → error surfaced in the modal; nothing stored.
+- Date ranges normalized to date-only; the stored report key is the exact (start, end).
+
+## Testing
+
+- **`ClaudeHistoryReader`** (Worker tests, fixture `.jsonl`): date-window filtering,
+  excluded-prefix dropping (case/separator normalization), prompt/summary extraction,
+  malformed-line tolerance, repo/day grouping.
+- **`WeekReportService`**: prompt-building from distilled activity + notes; empty-window
+  short-circuit; storage upsert; with a faked `ClaudeProcess`.
+- **`DailyNoteRepository`** and **`WeekReportRepository`**: CRUD / upsert / range lookup
+  against real SQLite (matches existing test style).
+
+## Out of Scope
+
+- Report export (clipboard/file) — view-only for now.
+- Git-commit scanning.
+- Editing or summarizing full transcripts; only prompts + closing summaries are used.

docs/superpowers/specs/2026-06-04-bundled-prompts-overhaul-design.md

@@ -0,0 +1,236 @@
+# Bundled Prompts Overhaul — Design
+
+Date: 2026-06-04
+
+## Goal
+
+Replace ClaudeDo's bundled prompts with a clean, professional baseline and make
+every prose prompt a user-editable file with a bundled default. Add a roadblock
+protocol so an autonomous run can flag problems mid-task without aborting.
+
+The execution-side defaults (`system.md`) ship as a moderate, **project-agnostic**
+engineering baseline — ClaudeDo users run tasks against their *own* repos, so no
+ClaudeDo-specific rules belong there. Everything is in English (tighter
+tokenization, more reliable instruction-following); the only German output is the
+weekly report, which a human reads.
+
+## File layout
+
+All prompts live under `~/.todo-app/prompts/` as editable files with bundled
+defaults seeded by `PromptFiles.EnsureExists` (which never overwrites a file the
+user already has). The `system` + `agent` prompts collapse into one `system.md`;
+the old `agent`/manual distinction was removed when tags were retired.
+
+| File | Replaces | Placeholders |
+|---|---|---|
+| `system.md` | system + agent (merged) | — |
+| `planning-system.md` | planning system prompt | — |
+| `planning-initial.md` | "analyze & break down" kickoff | `{title}`, `{description}` |
+| `retry.md` | "try again and fix" prompt | — |
+| `daily-prep.md` | daily-prep prompt | `{date}`, `{maxTasks}` |
+| `weekly-report.md` | weekly-report instructions | `{start}`, `{end}` |
+
+The task-execution prompt (title + description + `## Sub-Tasks` checkboxes) stays
+assembled in code — it is data-shaped, not prose.
+
+### Templating
+
+`PromptFiles` gains `Render(PromptKind kind, IReadOnlyDictionary<string,string> values)`
+that replaces **only** the known named tokens for that kind. Any other `{...}` in
+the file (e.g. the literal `{Wochentag}` / `{dd.MM.yyyy}` in the German report
+rules) passes through untouched. Daily-prep tool names are inlined as literals —
+`--allowedTools` already carries the real names, and inlining keeps the file from
+silently breaking if a user edits a placeholder.
+
+### Migration
+
+`EnsureExists` keeps its current semantics: it seeds a default only when the file
+is missing, never overwriting user edits. The old `planning.md` and `agent.md`
+become inert — `TaskRunner` stops reading `agent.md`, and the planning system
+prompt now reads `planning-system.md`. Old files are harmless to leave or delete.
+`PromptKind` changes: `Agent` is removed; `Planning` maps to `planning-system.md`;
+new kinds `PlanningInitial`, `Retry`, `DailyPrep`, `WeeklyReport` are added.
+
+## Roadblock protocol
+
+An autonomous run has no human watching, so it must not silently stop or block on
+a question. Instead the agent emits an inline marker whenever it hits a true
+blocker, **any number of times**, and keeps working on whatever it still can.
+
+- **Prompt side** (`system.md`): instruct the agent to write
+  `CLAUDEDO_BLOCKED: <one short sentence>` on its own line whenever something
+  genuinely prevents progress (missing credentials, contradictory requirements, a
+  destructive action it won't take unasked) — then continue with the rest of the
+  task. Reserved for true blockers, not routine decisions it can make itself.
+- **Detection** (`StreamAnalyzer`): as `assistant` messages stream, scan their
+  text content for lines matching `^CLAUDEDO_BLOCKED:` and collect each reason
+  into an ordered list (`Blocks`). This is live and cumulative — multiple problems
+  across one run are all captured, not just the last.
+- **Result wiring** (`StreamResult` → `RunResult` → run record): carry the
+  collected `Blocks`. Strip the marker lines from the displayed result text.
+- **Routing**: a run that finishes with blocks still goes to `WaitingForReview`
+  (standalone tasks) — it is "done as far as the agent could get". The review card
+  shows a ⚠ roadblock hint listing the collected problems. The user answers them
+  via the existing reject-rerun feedback path, which resumes the session with the
+  answers as the next-turn prompt — so the agent continues with the problems
+  resolved rather than restarting.
+
+## The prompts
+
+### `system.md`
+```markdown
+# Working Agreement
+
+You are completing one well-defined task autonomously in a git repository.
+
+## Scope
+- Do exactly what the task asks — no unrequested refactors, renames, dependency
+  changes, or "while I'm here" cleanup.
+- If intent is ambiguous, state the assumption you're making and proceed with the
+  most reasonable reading. Stop only if you genuinely cannot move forward.
+- Prefer three similar lines over a premature abstraction. Don't build for
+  hypothetical future needs.
+
+## Working in the repo
+- Read a file before editing it. Match the conventions already in this codebase —
+  they override generic defaults.
+- Prefer editing existing files to creating new ones. Don't write comments that
+  just restate the code.
+- Validate only at real boundaries (user input, external APIs).
+
+## Finishing
+- Before claiming done, verify: run the build and relevant tests, confirm they
+  pass, and report what you ran. If you couldn't verify something, say so plainly.
+- Make focused commits using the repository's existing commit-message convention.
+
+## Safety
+- Never force-push, hard-reset, or delete branches/files beyond the task's scope
+  without being asked.
+- Don't introduce injection/XSS/secret-leak issues. Never commit credentials.
+
+## You are running unattended
+You run autonomously with no human watching. There is no one to answer mid-task
+questions, so never stop to ask — make the most reasonable decision, note the
+assumption, and continue.
+
+## When you are blocked
+If something genuinely prevents you from completing part of the task (missing
+credentials, contradictory requirements, a destructive action you won't take
+unasked), do NOT silently give up. Write this marker on its own line, then keep
+working on whatever else you can:
+
+CLAUDEDO_BLOCKED: <one short sentence describing what blocked you>
+
+Emit it as many times as needed — once per distinct blocker. Use it only for true
+blockers, not for routine decisions you can make yourself.
+```
+
+> `system.md` also gains an **"Out-of-scope improvements"** section that tells the
+> agent to file follow-up work via the `SuggestImprovement` tool. That section is
+> defined in `2026-06-04-child-tasks-and-improvement-loop-design.md` and lands with
+> that feature.
+
+### `planning-system.md`
+```markdown
+You are the planning assistant for ClaudeDo. Your job is to break a task into
+smaller, independently executable subtasks — the session ends by creating those
+subtasks.
+
+Start every session by invoking the `superpowers:brainstorming` skill (Skill
+tool) and follow it end to end: clarifying questions one at a time, then 2–3
+approaches with a recommendation, then a short design. Do not create any subtasks
+until the user has approved the design.
+
+You can ONLY shape this task's plan — you cannot edit files or touch other tasks.
+The tools available to you are: CreateChildTask, ListChildTasks, UpdateChildTask,
+DeleteChildTask, UpdatePlanningTask, and Finalize. Use nothing else.
+
+Once the design is approved, create the child tasks with CreateChildTask, then
+call Finalize. Keep each subtask concrete and self-contained with a clear
+done-state, ordered so dependencies come first.
+```
+
+### `planning-initial.md`
+```markdown
+# Task to plan: {title}
+
+{description}
+```
+
+### `retry.md`
+```markdown
+The task did not complete on the previous attempt — you may have run out of
+turns, hit an error, or stopped before finishing.
+
+Review the work already done in this session and the current state of the
+repository, identify what is still incomplete or broken, and finish the task.
+Don't restart from scratch or repeat a failed approach. Verify the result
+(build + tests) before you stop.
+```
+Self-contained — no error injection. The runner appends the captured process
+output **only when it is a genuine error** (i.e. not the generic
+`"Claude exited with code N and no result."` fallback), since real session errors
+are already in the resumed context.
+
+### `daily-prep.md`
+```markdown
+You are preparing my workday for {date}.
+
+1. Call mcp__claudedo__get_daily_prep_candidates.
+2. Keep tasks already marked MyDay (currentMyDay) — never remove them.
+3. Fill MyDay to at most {maxTasks} open tasks TOTAL (currentMyDay counts). Never exceed it.
+4. Estimate each candidate's effort and pick a feasible mix — not only big items.
+   Prioritize isStarred, due (scheduledFor), and older tasks.
+5. Place related tasks next to each other using consecutive sortOrder values.
+6. Apply via mcp__claudedo__set_my_day(taskId, true, sortOrder). Never mark anything
+   outside the candidate list.
+
+If there are no candidates, do nothing.
+```
+
+### `weekly-report.md`
+```markdown
+You are generating a concise weekly standup report for a software developer,
+covering {start} to {end}.
+
+Rules:
+- Write the ENTIRE report in German.
+- Group by day. One "## {Wochentag}, {dd.MM.yyyy}" section per day that has
+  activity (German weekday names). Omit days with no activity.
+- Within each day: 3–5 first-person, past-tense bullets ("- Habe X umgesetzt",
+  "- Y behoben"). Merge related small work into one bullet.
+- Drop trivia: typo fixes, pure exploration, false starts, tooling/log noise.
+- Blend the developer's own notes and the derived activity into ONE deduplicated
+  bullet list per day. The notes are authoritative — never omit or contradict them.
+- Name the project/repo when it adds clarity.
+- Output ONLY the dated sections. No preamble, no intro, no closing remarks.
+
+Two sections follow below: an activity log derived from Claude session history,
+and the developer's own notes. Base the report on both; the notes are
+authoritative where they conflict with the derived activity.
+```
+
+## Touch points
+
+- `src/ClaudeDo.Data/PromptFiles.cs` — new `PromptKind` members, new defaults,
+  `Render` helper.
+- `src/ClaudeDo.Worker/Runner/TaskRunner.cs` — stop reading `agent.md`; use
+  `retry.md`; conditional stderr append on retry; carry/route `Blocks`.
+- `src/ClaudeDo.Worker/Runner/StreamAnalyzer.cs` — scan assistant text for
+  `CLAUDEDO_BLOCKED:` markers, collect `Blocks`, strip from result.
+- `src/ClaudeDo.Worker/Runner/ClaudeProcess.cs` / `RunResult` — carry `Blocks`.
+- `src/ClaudeDo.Worker/Planning/PlanningSessionManager.cs` — read
+  `planning-system.md` and `planning-initial.md` via `PromptFiles.Render`.
+- `src/ClaudeDo.Worker/Prime/DailyPrepPrompt.cs` — read `daily-prep.md`.
+- `src/ClaudeDo.Worker/Report/WeekReportPromptBuilder.cs` — read `weekly-report.md`.
+- UI — review card shows the ⚠ roadblock hint with collected problems.
+- `src/ClaudeDo.Ui/.../FilesSettingsTabViewModel.cs` — expose the new prompt files.
+- Tests — `PromptFiles` render/seed; `StreamAnalyzer` marker collection; planning/
+  prep/report builders read from files.
+
+## Out of scope
+
+- The in-code task-execution assembly (title/description/subtasks) is unchanged.
+- `ResultSchema` / `--output-schema` remains untouched.
+- No change to commit-message templating.
+```

docs/superpowers/specs/2026-06-04-child-tasks-and-improvement-loop-design.md

@@ -0,0 +1,186 @@
+# Reusable Child Tasks + Agent Improvement Loop — Design
+
+Date: 2026-06-04
+
+## Goal
+
+Let an executing task agent offload out-of-scope improvements it spots into
+**child tasks** that run automatically, so ClaudeDo can drive a self-improvement
+loop. Generalize the parent/child machinery that planning uses today into a
+reusable subsystem not bound to planning.
+
+Example: while implementing task X, Claude notices "this module should really be
+refactored, but that's out of scope" — instead of scope-creeping, it calls a tool
+that files the refactor as a child of X. The child runs on its own; once all of
+X's children finish, X surfaces for review with its whole tree visible.
+
+This builds on the bundled-prompts overhaul (`system.md` gains one instruction to
+use the offload tool). It is otherwise independent.
+
+## Lifecycle
+
+A new task status `WaitingForChildren` is added.
+
+```
+Running → WaitingForReview   standalone success, no children   (existing)
+Running → WaitingForChildren standalone success, ≥1 child       (new)
+Running → Done               planning child success            (existing)
+WaitingForChildren → WaitingForReview   all children terminal  (new)
+WaitingForChildren → Cancelled          cancel                 (new)
+```
+
+- Improvement-children are created `Idle` **during** the parent's run and stay
+  unqueued until the parent's own run finishes — this avoids the parent and a
+  child working the same repo concurrently.
+- When the parent's run succeeds and it has ≥1 non-terminal child, the parent goes
+  to `WaitingForChildren` and its children are enqueued (they then run under the
+  normal queue, governed by max-parallel — they are independent, not a forced
+  sequential chain like planning).
+- Children run automatically and reach `Done` on success without their own review
+  gate (a per-child review would stall the loop). Each child still produces its
+  own worktree/commit; those worktrees are surfaced under the parent for merge.
+- Children emit `CLAUDEDO_BLOCKED:` markers like any run (see the prompt-overhaul
+  spec). Each child's collected problems roll up onto the **parent's** review card,
+  so a parent in `WaitingForReview` shows "child N reported a problem" alongside
+  its own roadblocks.
+
+## Worktree topology & merge
+
+The correctness rule that makes this work:
+
+- **Children base off the parent's worktree HEAD, not the list's base branch.**
+  The parent's code work lives only on `claudedo/{parentId}` until merged, so a
+  child refactoring code the parent just wrote must branch from the parent's HEAD
+  to see it. (Planning children base off the target branch because a planning
+  parent writes no code — improvement parents do, hence the difference.) The
+  per-run worktree setup takes the base commit from the parent task's recorded
+  worktree HEAD when `ParentTaskId` is set and the parent is a non-planning task.
+- **Fan-out:** all children branch off the same parent HEAD and run independently
+  (parallel allowed). Parent-dependency is always satisfied; sibling overlaps
+  surface later as merge conflicts.
+- **Merge reuses the planning orchestrator,** generalized into a shared
+  "tree merge": build an integration branch off the target, then sequentially
+  `merge --no-ff` the **parent's own branch** followed by each child branch,
+  pausing on conflict (continue / abort), exactly as `PlanningMergeOrchestrator`
+  /`PlanningAggregator` do today. Approving the parent triggers this one guided
+  flow, merging parent + all children in as few steps as possible. Because
+  children descend from the parent HEAD, the parent's commits are shared ancestors
+  and merge cleanly ahead of the children.
+- The parent advances to `WaitingForReview` once **all** children are terminal —
+  counting `Done`, `Failed`, and `Cancelled`, so a failed child can't wedge the
+  parent forever. Failed/cancelled children are flagged on the review card.
+
+Planning parents keep their existing behavior (parent → `Done` when its chain
+finishes); they do not use `WaitingForChildren`.
+
+## Consolidating the child subsystem
+
+Today child handling is planning-coupled. Generalize:
+
+- **`TaskRepository.CreateChildAsync`** — drop the `parent.PlanningPhase != None`
+  guard. A child can attach to any existing parent. (Planning callers are
+  unaffected; their parents have a planning phase.) The child sets
+  `ParentTaskId = parentId`; the caller decides `CreatedBy`.
+- **Child-completion coordinator** — generalize planning's
+  `OnChildFinishedAsync` / `TryCompleteParentAsync` into a single component that,
+  on any child reaching a terminal state, checks the parent and applies a
+  **completion policy**:
+  - *planning parent* → finalize/Done (existing chain advancement stays in the
+    planning layer: unblock the next chained child).
+  - *improvement parent* (in `WaitingForChildren`, all children terminal) →
+    `WaitingForReview`.
+- `TaskStateService` remains the sole writer of `Status` and owns the new
+  transitions (`SubmitForChildrenAsync`, the `WaitingForChildren → WaitingForReview`
+  advance).
+
+## The offload tool
+
+A narrow MCP tool exposed only to task runs (not the general external surface):
+
+```
+SuggestImprovement(title, description) → { childTaskId }
+```
+
+- The **server** stamps everything — the agent cannot choose the parent, the
+  status, or queue anything directly:
+  - `ParentTaskId = <calling task id>`
+  - `CreatedBy = <calling task id>`  (unambiguous "agent-suggested improvement"
+    marker — distinct from `null` user/planning tasks and `"mcp"` external tasks)
+  - `Status = Idle`, same `ListId` as the parent.
+- **One layer deep:** the tool rejects the call if the calling task already has a
+  `ParentTaskId` (a child cannot spawn children).
+
+### Knowing the caller's identity
+
+The always-on external `claudedo` MCP is shared and can't tell which task is
+calling. So task runs get a **per-run MCP identity**, mirroring planning's
+per-session token:
+
+- `TaskRunner` mints a per-run token and writes a run-scoped `.mcp.json` (or
+  reuses the global server with a token header) so the offload tool resolves
+  token → calling task id server-side. A `TaskRunMcpContextAccessor` exposes the
+  current task id to the tool, the same way `PlanningMcpContextAccessor` does.
+- This is the reliable path for both correct provenance and the one-layer-deep
+  guard — the id is never supplied by the model.
+
+`system.md` gains a short instruction (from the prompt-overhaul spec):
+
+```markdown
+## Out-of-scope improvements
+If you notice worthwhile work that is genuinely outside this task's scope
+(a refactor, a follow-up, tech debt), do NOT do it here. File it with
+SuggestImprovement(title, description) and stay focused on the task at hand.
+```
+
+## UI
+
+- **Collapsible tree:** children group under their parent (by `ParentTaskId`).
+  Improvement-children are visually marked as agent-suggested (via
+  `CreatedBy == parentId`).
+- **New status chip** for `WaitingForChildren` (e.g. amber "waiting on N
+  improvements") with its own color in `StatusColorConverter`.
+- **Review card** for a parent in `WaitingForReview` lists child outcomes
+  (done/failed) and their rolled-up `CLAUDEDO_BLOCKED` problems, and drives the
+  shared tree-merge (parent + children) via the planning-style sequential flow
+  with conflict pause/continue/abort.
+
+## Data / migration
+
+- Add `WaitingForChildren` to the `TaskStatus` enum and its EF `ValueConverter`.
+  No new columns — `ParentTaskId` and `CreatedBy` already exist. No backfill
+  needed (no existing rows use the new value).
+
+## Touch points
+
+- `src/ClaudeDo.Data/Models/TaskStatus` (enum) + `TaskEntityConfiguration` — new value.
+- `src/ClaudeDo.Data/Repositories/TaskRepository.cs` — generalize `CreateChildAsync`.
+- `src/ClaudeDo.Worker/State/TaskStateService.cs` — `WaitingForChildren` transitions.
+- `src/ClaudeDo.Worker/Runner/TaskRunner.cs` — route to `WaitingForChildren` when
+  children exist; enqueue children on parent finish; mint per-run MCP token.
+- New: child-completion coordinator (generalized from planning) + the offload tool
+  (e.g. `TaskRunMcpService.SuggestImprovement`) + `TaskRunMcpContextAccessor` +
+  token auth (mirrors `PlanningTokenAuth`).
+- `src/ClaudeDo.Worker/Planning/*` — refactor planning to consume the shared
+  child-completion coordinator and the shared tree-merge; keep chain-specific
+  advancement local. Generalize `PlanningMergeOrchestrator` / `PlanningAggregator`
+  into a reusable tree-merge that also folds in the parent's own branch.
+- Worktree setup (`TaskRunner` / `WorktreeManager`) — base an improvement-child's
+  worktree on the parent task's recorded worktree HEAD instead of the list base.
+- UI — tree grouping, `WaitingForChildren` chip/color, parent review card with
+  child outcomes + rolled-up roadblocks + the merge flow.
+- Tests — offload tool stamps parent/createdBy + rejects nested calls;
+  parent → `WaitingForChildren` → `WaitingForReview` lifecycle; child worktree
+  bases off parent HEAD; tree-merge folds parent + children; planning regression
+  (still reaches Done).
+
+## Open questions for review
+
+1. **Failed child:** parent still advances to `WaitingForReview` with the failure
+   flagged (default), vs. parent → `Failed` if any child failed.
+
+## Out of scope
+
+- Multi-level nesting (only one layer deep by design).
+- Per-list "disable improvement offload" toggle (could come later; the tool is
+  always available to top-level runs for now).
+- Changes to how planning sets up its sequential chain.

docs/superpowers/specs/2026-06-04-debug-logging-traceability-design.md

@@ -0,0 +1,90 @@
+# Debug Logging & Frontend↔Backend Traceability — Design
+
+**Date:** 2026-06-04
+**Status:** Approved (pending spec review)
+
+## Goal
+
+Make debug logging rich enough to diagnose problems across the UI↔Worker boundary, while keeping the installed (production) build near-silent. Verbosity is decided by **build configuration, detected at runtime** — no runtime knob, no config field, no `#if DEBUG`:
+
+- **Debug build** (Rider run button) → verbose, console + file.
+- **Release build** (installed app) → minimal, file only.
+
+## Decisions (from brainstorming)
+
+1. **Mechanism:** runtime build-config detection via the entry assembly's `DebuggableAttribute` (JIT optimizer disabled ⇒ Debug build). A single `BuildConfig.IsDebug` helper drives ordinary `if` branching — no `#if DEBUG` directives. Rider's run button builds `Debug`; the installer ships `-c Release`.
+2. **Scope:** Worker **and** App/Ui. The desktop side currently has no log sink at all — UI/IPC failures vanish today.
+3. **Release behavior:** all three log `Warning`+ to file (not silent — capture crashes). Worker drops from its current `Information` to `Warning`.
+4. **One shared log file** across both processes, unified timeline.
+5. **Correlation:** TaskId-based (option A). Enrich log lines with `TaskId` when one is in scope. No changes to the SignalR contract (`IWorkerClient`/`WorkerHub` untouched → test fakes untouched).
+
+## Verbosity matrix
+
+| Process | Debug build | Release build |
+|---|---|---|
+| Worker | `Debug` level, console + shared file | `Warning` level, shared file |
+| App/Ui | `Debug` level, console + shared file | `Warning` level, shared file |
+
+## Shared log file
+
+- Single daily-rolling file: `~/.todo-app/logs/claudedo-.log` (Serilog appends the date).
+- `shared: true` on both processes' file sinks → Serilog coordinates multi-process writes via a global mutex.
+- `retainedFileCountLimit: 2`.
+- Each line is tagged with a `Process` property (`"worker"` / `"app"`) so the two sides are distinguishable in the interleaved timeline.
+
+> The existing `worker-.log` is replaced by `claudedo-.log`. Task-run NDJSON (`{taskId}_run{n}.ndjson`) and `daily-prep.log` are **out of scope** — they are data streams, not diagnostic logs, and stay exactly as they are.
+
+## Output template
+
+```
+[{Timestamp:HH:mm:ss.fff} {Level:u3}] {Process}/{SourceContext} [{TaskId}] {Message:lj}{NewLine}{Exception}
+```
+
+- `{Process}` — `worker` or `app`.
+- `{SourceContext}` — the `ILogger<T>` category (the logging class), so you see *which* component spoke.
+- `{TaskId}` — the correlation key, defaulted to `-` when no task is in scope (see enricher below).
+
+## Traceability (TaskId correlation)
+
+Use Serilog's `LogContext` (`.Enrich.FromLogContext()` on both processes) plus a small default enricher so `TaskId` is always present (renders `-` when absent — avoids the raw `{TaskId}` token leaking into output).
+
+Push the property at the entry points where a task is in scope; all nested `ILogger<T>` calls inherit it automatically:
+
+- **Worker:** wrap per-task execution in `TaskRunner` (the run/continue entry) with `using (LogContext.PushProperty("TaskId", task.Id))`. This covers the bulk of backend activity (runner, state transitions, worktree, planning) for free.
+- **App/Ui:** push `TaskId` in `WorkerClient` task-targeted calls (e.g. RunNow / Cancel / Continue / review actions) so the UI side of a task action carries the same key.
+
+Result: grep one `TaskId` in `claudedo-.log` and read the full UI→Worker→UI story in timestamp order.
+
+This adds **no parameters** to the SignalR surface — correlation rides on the existing `taskId` arguments already present in those calls.
+
+## Implementation surface
+
+A single shared helper keeps the two processes' Serilog setup from drifting.
+
+- **New project:** `ClaudeDo.Logging` — a small library both `ClaudeDo.App` and `ClaudeDo.Worker` reference (keeps `ClaudeDo.Data` free of any Serilog dependency). Contains:
+  - `BuildConfig.IsDebug` — checks the entry assembly's `DebuggableAttribute` (`IsJITOptimizerDisabled` ⇒ Debug build). Cached static.
+  - The output template and the default-TaskId enricher.
+  - `ConfigureLogger(LoggerConfiguration, processTag, logRoot)` — applies level/sink choices by branching on `BuildConfig.IsDebug` (Debug ⇒ `Debug` level + console + file; Release ⇒ `Warning` level + file only). Both processes call it so level/template/retention stay in sync.
+- **Worker `Program.cs:34`:** replace the inline `UseSerilog` body with a call into the shared helper (`processTag = "worker"`).
+- **App `Program.cs`:** add Serilog packages; build a logger via the shared helper (`Process = "app"`) and register it with `sc.AddLogging(b => b.AddSerilog(logger, dispose: true))`. App currently registers **no** logging at all, so this also makes `ILogger<T>` injection actually work UI-side. Remove/keep `.LogToTrace()` as appropriate (Avalonia internal trace, separate concern — leave it).
+- **App shutdown:** flush/close the logger (`Log.CloseAndFlush()` or dispose via the container's existing `finally`).
+
+### Packages to add (App project)
+
+- `Serilog.Extensions.Logging` (bridge `ILogger` → Serilog)
+- `Serilog.Sinks.File`
+- `Serilog.Sinks.Console`
+- (Worker already has Serilog + File sink; add `Serilog.Sinks.Console` for the Debug console output.)
+
+## Testing
+
+- This is logging wiring; per project policy, no tests that spawn the real Claude CLI and no heavy test scaffolding for log output.
+- Light verification: a unit-level check that the default enricher yields `-` when no `TaskId` is pushed, and (if practical) that `ConfigureLogger` wires the expected sinks. `BuildConfig.IsDebug` reflects the test assembly's own build config, so it can't be flipped within one run — assert each branch by passing the level/flag explicitly rather than relying on the ambient value, or verify the Release path and smoke-test Debug manually from Rider.
+- Manual smoke test (documented, not automated): run from Rider, confirm console + `claudedo-.log` show `Debug` lines with `Process`/`SourceContext`; run a task and confirm both `app` and `worker` lines share the same `[TaskId]`.
+
+## Out of scope
+
+- Runtime/config log-level knob.
+- Per-call correlation IDs for non-task flows (connect, config edits, prep) — TaskId-only for now; revisit if a non-task flow proves to be a black hole.
+- Changes to task-run NDJSON capture or `daily-prep.log`.
+- Any change to `IWorkerClient` / `WorkerHub` signatures.

docs/superpowers/specs/2026-06-04-inherited-settings-and-turns-design.md

@@ -0,0 +1,154 @@
+# Inherited settings display, per-task overrides, and Turns
+
+**Date:** 2026-06-04
+**Status:** Approved (design)
+
+## Problem
+
+Config inheritance is three-tier (Task → List → Global app settings). Today the UI
+only signals inheritance with a placeholder sentinel (`(inherit)` for tasks,
+`(default)` for lists) and, for tasks, a faint "Effective if inherited: {value}"
+hint under Model and Agent. Two gaps:
+
+1. You can't see the *actual resolved value* an inherited field will use, nor where
+   it comes from (List vs Global).
+2. **Max turns** is global-only (`AppSettingsEntity.DefaultMaxTurns` = 100). It is not
+   overridable per list or per task, unlike Model / SystemPrompt / AgentPath.
+
+## Goals
+
+- Show the real inherited value in-place, muted, with a **source-aware marker**
+  (`inherited · List` vs `inherited · Global`). Picking a value turns it into an
+  override; a reset affordance clears it back to inherited.
+- Add **Turns** (max turns) as an overridable field at both List and Task levels,
+  inheriting from the global default. Numeric box; empty = inherit.
+- Keep SystemPrompt as-is (it is additive, not override) but show what gets prepended.
+
+## Non-goals
+
+- No change to SystemPrompt merge semantics (stays additive/concatenated).
+- No new global settings; `DefaultMaxTurns` already exists.
+- No change to PermissionMode handling.
+
+## Inheritance semantics (reference)
+
+Resolved in `TaskRunner.BuildRunConfig` (~line 388):
+
+| Field        | Semantics  | Resolution                                             |
+|--------------|------------|--------------------------------------------------------|
+| Model        | override   | `task.Model ?? listConfig?.Model ?? global.DefaultModel` |
+| AgentPath    | override   | `task.AgentPath ?? listConfig?.AgentPath` (no global)  |
+| MaxTurns     | override   | **new:** `task.MaxTurns ?? listConfig?.MaxTurns ?? global.DefaultMaxTurns` |
+| SystemPrompt | additive   | merged: global + list + task + agent (unchanged)       |
+
+Lists inherit only from Global (no tier above them), so a list's inherited marker is
+always `inherited · Global`.
+
+## Design
+
+### 1. Data layer
+
+- `ListConfigEntity`: add `int? MaxTurns`.
+- `TaskEntity`: add `int? MaxTurns` (nullable override).
+- EF Core migration adding `max_turns` column to `list_config` and `tasks`
+  (nullable, no default — null = inherit).
+- `TaskRunner` BuildRunConfig: `MaxTurns: task.MaxTurns ?? listConfig?.MaxTurns ?? global.DefaultMaxTurns`.
+  `ClaudeRunConfig.MaxTurns` and `ClaudeArgsBuilder` already accept/emit `--max-turns`
+  when `> 0` — no change needed there.
+- `ListRepository.SetConfigAsync` (upsert) and `TaskRepository.UpdateAgentSettingsAsync`
+  extend to carry `maxTurns`.
+
+### 2. DTOs / transport
+
+Add `int? MaxTurns` to (Worker + Ui copies kept in sync):
+
+- `UpdateListConfigDto`, `ListConfigDto` (WorkerHub.cs + WorkerClient.cs)
+- `UpdateTaskAgentSettingsDto` (WorkerHub.cs + WorkerClient.cs)
+- `TaskConfigDto` (ConfigMcpTools.cs)
+
+`WorkerHub.UpdateListConfig` / `UpdateTaskAgentSettings` persist the new field via the
+repositories above. MCP `SetListConfig` / `SetTaskConfig` gain an optional `maxTurns`
+parameter to keep the agent-facing API at parity with the UI.
+
+### 3. Resolution helper (Ui)
+
+A small helper that, given `(taskValue, listValue, globalValue)`, returns
+`(effectiveValue, source)` where `source ∈ { Override, List, Global }`. Drives the
+marker text and muted/normal styling for Model, Agent, and Turns so the logic isn't
+duplicated per field or per editor. Lives in the Ui layer beside its consumers.
+
+### 4. UI rendering — inherited marker (source-aware)
+
+For **Model**, **Agent**, **Turns** in both `ListSettingsModalView` and the
+DetailsIsland "Agent settings (overrides)" expander:
+
+- Remove the `(inherit)` / `(default)` sentinel *row* from the control's item source.
+- When no override is set: control shows the **resolved value muted/greyed** (dropdown
+  shows e.g. "sonnet" dimmed; Turns box shows e.g. "100" as a muted placeholder), and a
+  small badge beside the field label reads `inherited · List` or `inherited · Global`.
+- On picking a value / typing a number: it becomes an override — text returns to normal
+  color, the badge flips to `override` (or hides), and a small **"↺ reset to inherited"**
+  affordance appears that clears the value back to null.
+- List modal: source is always Global → badge reads `inherited · Global`; reset clears
+  to the global default.
+- Turns: numeric box, empty = inherit (muted resolved number as placeholder); a typed
+  number is the override.
+
+**Rendering approach:** a small reusable `InheritedFieldHeader` control (label + badge +
+reset button), fed by the resolution helper's `source`, wraps each field. Keeps the three
+fields consistent and avoids per-field XAML duplication. Badge / muted styling uses
+existing design tokens. Visual polish pass is the user's.
+
+### 5. SystemPrompt (stays plain)
+
+SystemPrompt keeps its plain multi-line text box (additive, not override). Below it, a
+small **read-only, collapsed-by-default** hint shows the inherited prompts that will be
+prepended (global + list), labeled e.g. "Prepended automatically:". No marker, no reset —
+it never replaces, only appends.
+
+### 6. Localization
+
+New keys in `locales/en.json` + `locales/de.json` (parity enforced by Localization.Tests):
+marker text (`inherited · List`, `inherited · Global`, `override`), reset affordance
+label, Turns field label, and the SystemPrompt "prepended automatically" hint. Retire the
+now-unused `vm.details.effectiveIfInherited` key (and its German counterpart) if nothing
+else references it.
+
+## Affected files (indicative)
+
+- `src/ClaudeDo.Data/Models/ListConfigEntity.cs`, `TaskEntity.cs`
+- `src/ClaudeDo.Data/Migrations/` (new migration)
+- `src/ClaudeDo.Data/Repositories/ListRepository.cs`, `TaskRepository.cs`
+- `src/ClaudeDo.Data/Configuration/` (column mapping for `max_turns`)
+- `src/ClaudeDo.Worker/Runner/TaskRunner.cs`
+- `src/ClaudeDo.Worker/Hub/WorkerHub.cs`
+- `src/ClaudeDo.Worker/External/ConfigMcpTools.cs`
+- `src/ClaudeDo.Ui/Services/WorkerClient.cs` (+ `Interfaces/IWorkerClient.cs`)
+- `src/ClaudeDo.Ui/ViewModels/Modals/ListSettingsModalViewModel.cs` + view
+- `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs` + `DetailsIslandView.axaml`
+- `src/ClaudeDo.Ui/Views/Controls/` (new `InheritedFieldHeader`)
+- `src/ClaudeDo.Ui/` resolution helper
+- `locales/en.json`, `locales/de.json`
+
+## Testing
+
+- Data: migration applies; `MaxTurns` round-trips through `ListRepository.SetConfigAsync`
+  and `TaskRepository.UpdateAgentSettingsAsync`.
+- Worker: `BuildRunConfig` resolves MaxTurns via task → list → global precedence
+  (unit test on the resolution). Existing `ClaudeArgsBuilder` `--max-turns` behavior
+  unchanged.
+- Ui: resolution helper returns correct `(value, source)` for each of the
+  override / list / global cases across Model, Agent, Turns.
+- Localization: en/de key parity (existing Localization.Tests).
+- Test fakes: update hand-rolled `IWorkerClient` fakes in both test projects for the new
+  DTO fields (per known gotcha).
+- Visual verification of the marker / muted styling: flagged for the user (cannot be
+  asserted programmatically).
+
+## Open risks
+
+- DTO/ctor changes ripple into hand-rolled test fakes in Worker.Tests and Ui.Tests —
+  must be updated in the same change.
+- Removing the sentinel row from dropdowns changes selection binding; ensure null/empty
+  override state is represented without a sentinel item (e.g. dropdown `SelectedItem`
+  null when inherited).

src/ClaudeDo.App/App.axaml.cs

@@ -1,3 +1,4 @@
+using System;
 using Avalonia;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Markup.Xaml;
@@ -10,7 +11,12 @@ namespace ClaudeDo.App;
 
 public partial class App : Application
 {
-    public static ServiceProvider Services { get; set; } = null!;
+    private readonly IServiceProvider? _services;
+
+    // Parameterless ctor is required by the XAML previewer / designer.
+    public App() { }
+
+    public App(IServiceProvider services) => _services = services;
 
     public override void Initialize()
     {
@@ -21,14 +27,19 @@ public partial class App : Application
     {
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
+            var services = _services
+                ?? throw new InvalidOperationException("App was constructed without a service provider.");
+
+            FocusClearing.Install();
+
             desktop.MainWindow = new MainWindow
             {
-                DataContext = Services.GetRequiredService<IslandsShellViewModel>(),
+                DataContext = services.GetRequiredService<IslandsShellViewModel>(),
             };
 
             // Kick off the SignalR retry loop — reconnects indefinitely if the worker
             // is not up yet, or goes down and comes back.
-            _ = Services.GetRequiredService<WorkerClient>().StartAsync();
+            _ = services.GetRequiredService<WorkerClient>().StartAsync();
         }
 
         base.OnFrameworkInitializationCompleted();

src/ClaudeDo.App/ClaudeDo.App.csproj

@@ -24,9 +24,13 @@
     </PackageReference>
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.1" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.1" />
+    <PackageReference Include="Serilog.Extensions.Logging" Version="8.0.0" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\ClaudeDo.Ui\ClaudeDo.Ui.csproj" />
+    <ProjectReference Include="..\ClaudeDo.Logging\ClaudeDo.Logging.csproj" />
+    <ProjectReference Include="..\ClaudeDo.Localization\ClaudeDo.Localization.csproj" />
   </ItemGroup>
+  <Import Project="..\ClaudeDo.Localization\Locales.targets" />
 </Project>

src/ClaudeDo.App/Program.cs

@@ -1,16 +1,24 @@
 using Avalonia;
 using ClaudeDo.Data;
 using ClaudeDo.Data.Git;
+using ClaudeDo.Localization;
 using ClaudeDo.Releases;
 using ClaudeDo.Ui;
+using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
+using ClaudeDo.Ui.Services.Interfaces;
 using ClaudeDo.Ui.ViewModels;
 using ClaudeDo.Ui.ViewModels.Islands;
 using ClaudeDo.Ui.ViewModels.Modals;
 using ClaudeDo.Ui.ViewModels.Modals.Settings;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Serilog;
 using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
 using System.Net.Http;
 using System.Reflection;
 using System.Runtime.InteropServices;
@@ -29,7 +37,6 @@ sealed class Program
             SetCurrentProcessExplicitAppUserModelID("ClaudeDo.App");
 
         var services = BuildServices();
-        App.Services = services;
 
         using (var scope = services.CreateScope())
         {
@@ -39,7 +46,7 @@ sealed class Program
 
         try
         {
-            BuildAvaloniaApp()
+            ConfigureAppBuilder(AppBuilder.Configure(() => new App(services)))
                 .StartWithClassicDesktopLifetime(args);
         }
         finally
@@ -52,8 +59,12 @@ sealed class Program
         }
     }
 
+    // Parameterless entry point required by the XAML previewer / designer.
     public static AppBuilder BuildAvaloniaApp()
-        => AppBuilder.Configure<App>()
+        => ConfigureAppBuilder(AppBuilder.Configure<App>());
+
+    private static AppBuilder ConfigureAppBuilder(AppBuilder builder)
+        => builder
             .UsePlatformDetect()
 #if DEBUG
             .WithDeveloperTools()
@@ -68,8 +79,26 @@ sealed class Program
 
         var sc = new ServiceCollection();
 
+        var logRoot = Path.Combine(Path.GetDirectoryName(dbPath)!, "logs");
+        var serilogLogger = ClaudeDo.Logging.LoggingSetup
+            .Configure(new LoggerConfiguration(), "app", logRoot)
+            .CreateLogger();
+        sc.AddLogging(b => b.AddSerilog(serilogLogger, dispose: true));
+
         // Infrastructure
         sc.AddSingleton(settings);
+        var localesDir = Path.Combine(AppContext.BaseDirectory, "locales");
+        var localeStore = LocaleStore.Load(localesDir);
+        var initialLang = !string.IsNullOrWhiteSpace(settings.Language)
+            ? settings.Language
+            : CultureResolver.Resolve(
+                CultureInfo.CurrentUICulture.Name,
+                localeStore.Available.Select(l => l.Code).ToArray(),
+                fallback: "en");
+        var localizer = new Localizer(localeStore, initialLang);
+        TrExtension.Localizer = localizer;
+        ClaudeDo.Ui.Localization.Loc.Current = localizer;
+        sc.AddSingleton<ILocalizer>(localizer);
         sc.AddDbContextFactory<ClaudeDoDbContext>(opt =>
             opt.UseSqlite($"Data Source={dbPath}"));
         sc.AddScoped<ClaudeDoDbContext>(sp =>
@@ -77,7 +106,10 @@ sealed class Program
 
         // Services
         sc.AddSingleton<GitService>();
-        sc.AddSingleton(sp => new WorkerClient(sp.GetRequiredService<AppSettings>().SignalRUrl));
+        sc.AddSingleton(sp => new WorkerClient(
+            sp.GetRequiredService<AppSettings>().SignalRUrl,
+            sp.GetRequiredService<ILogger<WorkerClient>>()));
+        sc.AddSingleton<IWorkerClient>(sp => sp.GetRequiredService<WorkerClient>());
 
         // Release check + installer update
         sc.AddSingleton<HttpClient>(_ => new HttpClient { Timeout = TimeSpan.FromSeconds(10) });
@@ -100,6 +132,7 @@ sealed class Program
         sc.AddTransient<WorktreesOverviewModalViewModel>();
         sc.AddTransient<Func<WorktreesOverviewModalViewModel>>(sp => () => sp.GetRequiredService<WorktreesOverviewModalViewModel>());
         sc.AddSingleton<IPrimeScheduleApi, WorkerPrimeScheduleApi>();
+        sc.AddSingleton<INotesApi, WorkerNotesApi>();
         sc.AddTransient<PrimeClaudeTabViewModel>();
         sc.AddTransient<SettingsModalViewModel>();
         sc.AddTransient<MergeModalViewModel>();
@@ -107,6 +140,8 @@ sealed class Program
         sc.AddTransient<ListSettingsModalViewModel>();
         sc.AddTransient<RepoImportModalViewModel>();
         sc.AddTransient<Func<RepoImportModalViewModel>>(sp => () => sp.GetRequiredService<RepoImportModalViewModel>());
+        sc.AddTransient<WeeklyReportModalViewModel>();
+        sc.AddTransient<Func<WeeklyReportModalViewModel>>(sp => () => sp.GetRequiredService<WeeklyReportModalViewModel>());
 
         // Islands shell VMs
         sc.AddSingleton<ListsIslandViewModel>(sp =>
@@ -122,7 +157,8 @@ sealed class Program
             new DetailsIslandViewModel(
                 sp.GetRequiredService<IDbContextFactory<ClaudeDoDbContext>>(),
                 sp.GetRequiredService<WorkerClient>(),
-                sp));
+                sp,
+                sp.GetRequiredService<INotesApi>()));
         sc.AddSingleton<IslandsShellViewModel>();
 
         return sc.BuildServiceProvider();

src/ClaudeDo.Data/CLAUDE.md

@@ -4,12 +4,15 @@ Shared data layer: models, repositories, SQLite infrastructure, and git operatio
 
 ## Models
 
-- **TaskEntity** — Id, ListId, Title, Description, Status (`Idle|Queued|Running|WaitingForReview|Done|Failed|Cancelled`), PlanningPhase (`None|Active|Finalized` — parent-only), BlockedByTaskId (nullable FK to predecessor in a chain), ScheduledFor, Result, ReviewFeedback (nullable; reviewer's rejection comment, consumed and cleared by the runner on the next re-run), LogPath, timestamps, CommitType, Model / SystemPrompt / AgentPath (nullable overrides), IsStarred, IsMyDay, Notes, ParentTaskId, PlanningSessionId, PlanningSessionToken, PlanningFinalizedAt, CreatedBy. Legacy values `Manual`/`Planning`/`Planned`/`Draft`/`Waiting` were retired; existing rows backfill automatically via the `RetireLegacyTaskStatus` migration.
+- **TaskEntity** — Id, ListId, Title, Description, Status (`Idle|Queued|Running|WaitingForReview|Done|Failed|Cancelled`), PlanningPhase (`None|Active|Finalized` — parent-only), BlockedByTaskId (nullable FK to predecessor in a chain), ScheduledFor, Result, ReviewFeedback (nullable; reviewer's rejection comment, consumed and cleared by the runner on the next re-run), LogPath, timestamps, CommitType, Model / SystemPrompt / AgentPath / MaxTurns (nullable overrides), IsStarred, IsMyDay, Notes, ParentTaskId, PlanningSessionId, PlanningSessionToken, PlanningFinalizedAt, CreatedBy. Legacy values `Manual`/`Planning`/`Planned`/`Draft`/`Waiting` were retired; existing rows backfill automatically via the `RetireLegacyTaskStatus` migration.
 - **ListEntity** — Id, Name, WorkingDir, DefaultCommitType, CreatedAt
-- **ListConfigEntity** — ListId (PK, 1:1 with list), Model, SystemPrompt, AgentPath (all nullable)
+- **ListConfigEntity** — ListId (PK, 1:1 with list), Model, SystemPrompt, AgentPath, MaxTurns (all nullable)
 - **WorktreeEntity** — TaskId (PK, 1:1 with task), Path, BranchName, BaseCommit, HeadCommit, DiffStat, State (Active|Merged|Discarded|Kept)
 - **TaskRunEntity** — per-run record (session_id, tokens, turns, result, structured output, exit code, log path)
 - **PrimeScheduleEntity** — Id, Days (`[Flags] PrimeDays` weekday bitmask, stored as `days_of_week` int), TimeOfDay, Enabled, LastRunAt, PromptOverride, CreatedAt. Recurs on the selected weekdays; no date range.
+- **DailyNoteEntity** — Id, Date (DateOnly), Text, SortOrder, CreatedAt → table `daily_notes`
+- **WeekReportEntity** — Id, StartDate/EndDate (DateOnly), Markdown, GeneratedAt → table `week_reports`, unique index on (start_date, end_date)
+- **AppSettingsEntity** also carries `ReportExcludedPaths` (string?, JSON array of excluded path prefixes, column `report_excluded_paths`), `StandupWeekday` (int DayOfWeek, default Wednesday, column `standup_weekday`), and `DailyPrepMaxTasks` (int, default 5, column `daily_prep_max_tasks` — hard cap on how many open tasks the daily-prep / "Prime Claude" feature may place in MyDay)
 - **SubtaskEntity**, **AppSettingsEntity**, **AgentInfo** — existing helpers / settings / record for scanned agent files
 
 ## Repositories
@@ -20,6 +23,8 @@ All repositories use EF Core LINQ queries via `ClaudeDoDbContext`. The atomic `Q
 - **ListRepository** — CRUD, `GetConfigAsync` / `SetConfigAsync` (upsert) / `DeleteConfigAsync` for `list_config`
 - **WorktreeRepository** — CRUD, `UpdateHeadAsync`, `SetStateAsync`
 - **TaskRunRepository**, **SubtaskRepository**, **AppSettingsRepository**
+- **DailyNoteRepository** — `ListByDayAsync`, `ListBetweenAsync`, `AddAsync`, `UpdateAsync`, `DeleteAsync`
+- **WeekReportRepository** — `GetByRangeAsync`, `UpsertAsync`
 
 ## Infrastructure
 
@@ -34,7 +39,7 @@ All repositories use EF Core LINQ queries via `ClaudeDoDbContext`. The atomic `Q
 
 ## Schema
 
-Tables: `lists`, `tasks`, `worktrees`, `list_config`, `task_runs`, `subtasks`, `app_settings`, `prime_schedules`. Managed by EF Core migrations in the `Migrations/` folder. The `tasks` table holds `status`, `planning_phase` (default `none`), and `blocked_by_task_id` (FK to `tasks.id`, `ON DELETE SET NULL`).
+Tables: `lists`, `tasks`, `worktrees`, `list_config`, `task_runs`, `subtasks`, `app_settings`, `prime_schedules`, `daily_notes`, `week_reports`. Managed by EF Core migrations in the `Migrations/` folder. The `tasks` table holds `status`, `planning_phase` (default `none`), and `blocked_by_task_id` (FK to `tasks.id`, `ON DELETE SET NULL`). Migration `WeeklyReport` added `daily_notes`, `week_reports`, and the two new `app_settings` columns. Migration `DailyPrepMaxTasks` added the `daily_prep_max_tasks` column to `app_settings` (no new tables).
 
 ## Conventions
 

src/ClaudeDo.Data/ClaudeDoDbContext.cs

@@ -19,6 +19,8 @@ public class ClaudeDoDbContext : DbContext
     public DbSet<SubtaskEntity> Subtasks => Set<SubtaskEntity>();
     public DbSet<AppSettingsEntity> AppSettings => Set<AppSettingsEntity>();
     public DbSet<PrimeScheduleEntity> PrimeSchedules => Set<PrimeScheduleEntity>();
+    public DbSet<DailyNoteEntity> DailyNotes => Set<DailyNoteEntity>();
+    public DbSet<WeekReportEntity> WeekReports => Set<WeekReportEntity>();
 
     private static readonly ValueConverter<DateTime, DateTime> UtcConverter =
         new(v => v, v => DateTime.SpecifyKind(v, DateTimeKind.Utc));

src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs

@@ -37,6 +37,13 @@ public class AppSettingsEntityConfiguration : IEntityTypeConfiguration<AppSettin
         builder.Property(s => s.RepoImportFolders)
             .HasColumnName("repo_import_folders");
 
+        builder.Property(s => s.ReportExcludedPaths).HasColumnName("report_excluded_paths");
+        builder.Property(s => s.StandupWeekday).HasColumnName("standup_weekday")
+            .IsRequired().HasDefaultValue((int)DayOfWeek.Wednesday);
+
+        builder.Property(s => s.DailyPrepMaxTasks)
+            .HasColumnName("daily_prep_max_tasks").IsRequired().HasDefaultValue(5);
+
         builder.HasData(new AppSettingsEntity { Id = AppSettingsEntity.SingletonId });
     }
 }

src/ClaudeDo.Data/Configuration/DailyNoteEntityConfiguration.cs

@@ -0,0 +1,20 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ClaudeDo.Data.Configuration;
+
+public class DailyNoteEntityConfiguration : IEntityTypeConfiguration<DailyNoteEntity>
+{
+    public void Configure(EntityTypeBuilder<DailyNoteEntity> builder)
+    {
+        builder.ToTable("daily_notes");
+        builder.HasKey(n => n.Id);
+        builder.Property(n => n.Id).HasColumnName("id").ValueGeneratedNever();
+        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.CreatedAt).HasColumnName("created_at").IsRequired();
+        builder.HasIndex(n => n.Date);
+    }
+}

src/ClaudeDo.Data/Configuration/ListConfigEntityConfiguration.cs

@@ -15,5 +15,6 @@ public class ListConfigEntityConfiguration : IEntityTypeConfiguration<ListConfig
         builder.Property(c => c.Model).HasColumnName("model");
         builder.Property(c => c.SystemPrompt).HasColumnName("system_prompt");
         builder.Property(c => c.AgentPath).HasColumnName("agent_path");
+        builder.Property(c => c.MaxTurns).HasColumnName("max_turns");
     }
 }

src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs

@@ -14,8 +14,9 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
             TaskStatus.Idle             => "idle",
             TaskStatus.Queued           => "queued",
             TaskStatus.Running          => "running",
-            TaskStatus.WaitingForReview => "waiting_for_review",
+            TaskStatus.WaitingForReview    => "waiting_for_review",
-            TaskStatus.Done             => "done",
+            TaskStatus.WaitingForChildren  => "waiting_for_children",
+            TaskStatus.Done                => "done",
             TaskStatus.Failed           => "failed",
             TaskStatus.Cancelled        => "cancelled",
             _ => throw new ArgumentOutOfRangeException(nameof(v)),
@@ -27,8 +28,9 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
             "idle"               => TaskStatus.Idle,
             "queued"             => TaskStatus.Queued,
             "running"            => TaskStatus.Running,
-            "waiting_for_review" => TaskStatus.WaitingForReview,
+            "waiting_for_review"    => TaskStatus.WaitingForReview,
-            "done"               => TaskStatus.Done,
+            "waiting_for_children"  => TaskStatus.WaitingForChildren,
+            "done"                  => TaskStatus.Done,
             "failed"             => TaskStatus.Failed,
             "cancelled"          => TaskStatus.Cancelled,
             _ => throw new ArgumentOutOfRangeException(nameof(v)),
@@ -75,6 +77,7 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         builder.Property(t => t.ScheduledFor).HasColumnName("scheduled_for");
         builder.Property(t => t.Result).HasColumnName("result");
         builder.Property(t => t.ReviewFeedback).HasColumnName("review_feedback");
+        builder.Property(t => t.RoadblockCount).HasColumnName("roadblock_count").HasDefaultValue(0);
         builder.Property(t => t.LogPath).HasColumnName("log_path");
         builder.Property(t => t.CreatedAt).HasColumnName("created_at").IsRequired();
         builder.Property(t => t.StartedAt).HasColumnName("started_at");
@@ -83,6 +86,7 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         builder.Property(t => t.Model).HasColumnName("model");
         builder.Property(t => t.SystemPrompt).HasColumnName("system_prompt");
         builder.Property(t => t.AgentPath).HasColumnName("agent_path");
+        builder.Property(t => t.MaxTurns).HasColumnName("max_turns");
         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.Notes).HasColumnName("notes");

src/ClaudeDo.Data/Configuration/WeekReportEntityConfiguration.cs

@@ -0,0 +1,20 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ClaudeDo.Data.Configuration;
+
+public class WeekReportEntityConfiguration : IEntityTypeConfiguration<WeekReportEntity>
+{
+    public void Configure(EntityTypeBuilder<WeekReportEntity> builder)
+    {
+        builder.ToTable("week_reports");
+        builder.HasKey(r => r.Id);
+        builder.Property(r => r.Id).HasColumnName("id").ValueGeneratedNever();
+        builder.Property(r => r.StartDate).HasColumnName("start_date").IsRequired();
+        builder.Property(r => r.EndDate).HasColumnName("end_date").IsRequired();
+        builder.Property(r => r.Markdown).HasColumnName("markdown").IsRequired();
+        builder.Property(r => r.GeneratedAt).HasColumnName("generated_at").IsRequired();
+        builder.HasIndex(r => new { r.StartDate, r.EndDate }).IsUnique();
+    }
+}

src/ClaudeDo.Data/Migrations/20260603072822_WeeklyReport.Designer.cs

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

src/ClaudeDo.Data/Migrations/20260603072822_WeeklyReport.cs

@@ -0,0 +1,94 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class WeeklyReport : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "report_excluded_paths",
+                table: "app_settings",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "standup_weekday",
+                table: "app_settings",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 3);
+
+            migrationBuilder.CreateTable(
+                name: "daily_notes",
+                columns: table => new
+                {
+                    id = table.Column<string>(type: "TEXT", nullable: false),
+                    note_date = table.Column<DateOnly>(type: "TEXT", nullable: false),
+                    text = table.Column<string>(type: "TEXT", nullable: false),
+                    sort_order = table.Column<int>(type: "INTEGER", nullable: false),
+                    created_at = table.Column<DateTime>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_daily_notes", x => x.id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "week_reports",
+                columns: table => new
+                {
+                    id = table.Column<string>(type: "TEXT", nullable: false),
+                    start_date = table.Column<DateOnly>(type: "TEXT", nullable: false),
+                    end_date = table.Column<DateOnly>(type: "TEXT", nullable: false),
+                    markdown = table.Column<string>(type: "TEXT", nullable: false),
+                    generated_at = table.Column<DateTime>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_week_reports", x => x.id);
+                });
+
+            migrationBuilder.UpdateData(
+                table: "app_settings",
+                keyColumn: "id",
+                keyValue: 1,
+                columns: new[] { "report_excluded_paths", "standup_weekday" },
+                values: new object[] { null, 3 });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_daily_notes_note_date",
+                table: "daily_notes",
+                column: "note_date");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_week_reports_start_date_end_date",
+                table: "week_reports",
+                columns: new[] { "start_date", "end_date" },
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "daily_notes");
+
+            migrationBuilder.DropTable(
+                name: "week_reports");
+
+            migrationBuilder.DropColumn(
+                name: "report_excluded_paths",
+                table: "app_settings");
+
+            migrationBuilder.DropColumn(
+                name: "standup_weekday",
+                table: "app_settings");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260603141020_DailyPrepMaxTasks.Designer.cs

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

src/ClaudeDo.Data/Migrations/20260603141020_DailyPrepMaxTasks.cs

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

src/ClaudeDo.Data/Migrations/20260604101453_InheritableMaxTurns.Designer.cs

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

src/ClaudeDo.Data/Migrations/20260604101453_InheritableMaxTurns.cs

@@ -0,0 +1,38 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class InheritableMaxTurns : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "max_turns",
+                table: "tasks",
+                type: "INTEGER",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "max_turns",
+                table: "list_config",
+                type: "INTEGER",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "max_turns",
+                table: "tasks");
+
+            migrationBuilder.DropColumn(
+                name: "max_turns",
+                table: "list_config");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260604125720_AddRoadblockCount.Designer.cs

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

src/ClaudeDo.Data/Migrations/20260604125720_AddRoadblockCount.cs

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

src/ClaudeDo.Data/Migrations/ClaudeDoDbContextModelSnapshot.cs

@@ -27,6 +27,12 @@ namespace ClaudeDo.Data.Migrations
                         .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()
@@ -64,6 +70,16 @@ namespace ClaudeDo.Data.Migrations
                         .HasColumnType("TEXT")
                         .HasColumnName("repo_import_folders");
 
+                    b.Property<string>("ReportExcludedPaths")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("report_excluded_paths");
+
+                    b.Property<int>("StandupWeekday")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(3)
+                        .HasColumnName("standup_weekday");
+
                     b.Property<int>("WorktreeAutoCleanupDays")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("INTEGER")
@@ -91,17 +107,49 @@ namespace ClaudeDo.Data.Migrations
                         new
                         {
                             Id = 1,
+                            DailyPrepMaxTasks = 5,
                             DefaultClaudeInstructions = "",
                             DefaultMaxTurns = 100,
                             DefaultModel = "sonnet",
                             DefaultPermissionMode = "auto",
                             MaxParallelExecutions = 1,
+                            StandupWeekday = 3,
                             WorktreeAutoCleanupDays = 7,
                             WorktreeAutoCleanupEnabled = false,
                             WorktreeStrategy = "sibling"
                         });
                 });
 
+            modelBuilder.Entity("ClaudeDo.Data.Models.DailyNoteEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("note_date");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("sort_order");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.ToTable("daily_notes", (string)null);
+                });
+
             modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
                 {
                     b.Property<string>("ListId")
@@ -112,6 +160,10 @@ namespace ClaudeDo.Data.Migrations
                         .HasColumnType("TEXT")
                         .HasColumnName("agent_path");
 
+                    b.Property<int?>("MaxTurns")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("max_turns");
+
                     b.Property<string>("Model")
                         .HasColumnType("TEXT")
                         .HasColumnName("model");
@@ -300,6 +352,10 @@ namespace ClaudeDo.Data.Migrations
                         .HasColumnType("TEXT")
                         .HasColumnName("log_path");
 
+                    b.Property<int?>("MaxTurns")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("max_turns");
+
                     b.Property<string>("Model")
                         .HasColumnType("TEXT")
                         .HasColumnName("model");
@@ -339,6 +395,12 @@ namespace ClaudeDo.Data.Migrations
                         .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");
@@ -465,6 +527,37 @@ namespace ClaudeDo.Data.Migrations
                     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")

src/ClaudeDo.Data/Models/AppSettingsEntity.cs

@@ -20,4 +20,11 @@ public sealed class AppSettingsEntity
 
     // JSON array of parent folders remembered by the repo-import modal.
     public string? RepoImportFolders { get; set; }
+    // JSON array of path prefixes whose sessions are excluded from the weekly report.
+    public string? ReportExcludedPaths { get; set; }
+    // DayOfWeek the standup happens on; default Wednesday. Drives the report's default range.
+    public int StandupWeekday { get; set; } = (int)DayOfWeek.Wednesday;
+
+    // Max number of open tasks the daily prep ("Prime Claude") may place in MyDay.
+    public int DailyPrepMaxTasks { get; set; } = 5;
 }

src/ClaudeDo.Data/Models/DailyNoteEntity.cs

@@ -0,0 +1,10 @@
+namespace ClaudeDo.Data.Models;
+
+public sealed class DailyNoteEntity
+{
+    public string Id { get; init; } = Guid.NewGuid().ToString();
+    public DateOnly Date { get; set; }
+    public string Text { get; set; } = string.Empty;
+    public int SortOrder { get; set; }
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+}

src/ClaudeDo.Data/Models/ListConfigEntity.cs

@@ -6,6 +6,7 @@ public sealed class ListConfigEntity
     public string? Model { get; set; }
     public string? SystemPrompt { get; set; }
     public string? AgentPath { get; set; }
+    public int? MaxTurns { get; set; }
 
     // Navigation property
     public ListEntity List { get; set; } = null!;

src/ClaudeDo.Data/Models/TaskEntity.cs

@@ -6,6 +6,7 @@ public enum TaskStatus
     Queued,
     Running,
     WaitingForReview,
+    WaitingForChildren,
     Done,
     Failed,
     Cancelled,
@@ -30,6 +31,7 @@ public sealed class TaskEntity
     public DateTime? ScheduledFor { get; set; }
     public string? Result { get; set; }
     public string? ReviewFeedback { get; set; }
+    public int RoadblockCount { get; set; }
     public string? LogPath { get; set; }
     public required DateTime CreatedAt { get; init; }
     public DateTime? StartedAt { get; set; }
@@ -38,6 +40,7 @@ public sealed class TaskEntity
     public string? Model { get; set; }
     public string? SystemPrompt { get; set; }
     public string? AgentPath { get; set; }
+    public int? MaxTurns { get; set; }
     public bool IsStarred { get; set; }
     public bool IsMyDay { get; set; }
     public string? Notes { get; set; }

src/ClaudeDo.Data/Models/WeekReportEntity.cs

@@ -0,0 +1,10 @@
+namespace ClaudeDo.Data.Models;
+
+public sealed class WeekReportEntity
+{
+    public string Id { get; init; } = Guid.NewGuid().ToString();
+    public DateOnly StartDate { get; set; }
+    public DateOnly EndDate { get; set; }
+    public string Markdown { get; set; } = string.Empty;
+    public DateTime GeneratedAt { get; set; } = DateTime.UtcNow;
+}

src/ClaudeDo.Data/PromptFiles.cs

@@ -1,6 +1,8 @@
+using System.Text;
+
 namespace ClaudeDo.Data;
 
-public enum PromptKind { System, Planning, Agent }
+public enum PromptKind { System, Planning, PlanningInitial, Retry, DailyPrep, WeeklyReport, ImprovementChild }
 
 public static class PromptFiles
 {
@@ -9,8 +11,12 @@ public static class PromptFiles
     public static string PathFor(PromptKind kind) => kind switch
     {
         PromptKind.System => Path.Combine(Root, "system.md"),
-        PromptKind.Planning => Path.Combine(Root, "planning.md"),
+        PromptKind.Planning => Path.Combine(Root, "planning-system.md"),
-        PromptKind.Agent => Path.Combine(Root, "agent.md"),
+        PromptKind.PlanningInitial => Path.Combine(Root, "planning-initial.md"),
+        PromptKind.Retry => Path.Combine(Root, "retry.md"),
+        PromptKind.DailyPrep => Path.Combine(Root, "daily-prep.md"),
+        PromptKind.WeeklyReport => Path.Combine(Root, "weekly-report.md"),
+        PromptKind.ImprovementChild => Path.Combine(Root, "improvement-child.md"),
         _ => throw new ArgumentOutOfRangeException(nameof(kind))
     };
 
@@ -30,29 +36,169 @@ public static class PromptFiles
         return string.IsNullOrEmpty(content) ? null : content;
     }
 
-    private static string DefaultFor(PromptKind kind) => kind switch
+    /// <summary>File content if present and non-empty, otherwise the bundled default.</summary>
+    public static string ReadOrDefault(PromptKind kind) => ReadOrNull(kind) ?? DefaultFor(kind);
+
+    /// <summary>Render a prompt: read file-or-default, then substitute named tokens.</summary>
+    public static string Render(PromptKind kind, IReadOnlyDictionary<string, string> values)
+        => RenderTemplate(ReadOrDefault(kind), values);
+
+    /// <summary>Replace only the given {name} tokens; any other braces pass through untouched.</summary>
+    public static string RenderTemplate(string template, IReadOnlyDictionary<string, string> values)
     {
-        PromptKind.System =>
+        var sb = new StringBuilder(template);
-            "# System Prompt\n\n" +
+        foreach (var (key, val) in values)
-            "Baseline instructions appended to every task run.\n" +
+            sb.Replace("{" + key + "}", val);
-            "Edit this file to inject project-wide rules (style, conventions, hard constraints).\n",
+        return sb.ToString();
-        PromptKind.Planning =>
+    }
-            "You are a planning assistant for ClaudeDo.\n" +
+
-            "Your role is to help break down a task into smaller, actionable subtasks.\n" +
+    public static string DefaultFor(PromptKind kind) => kind switch
-            "Your final goal WILL ALWAYS be the creation of Subtasks.\n\n" +
+    {
-            "ALWAYS invoke the `superpowers:brainstorming` skill via the Skill tool at the\n" +
+        PromptKind.System => SystemDefault,
-            "start of every planning session, and follow its process end-to-end. It guides\n" +
+        PromptKind.Planning => PlanningSystemDefault,
-            "you through clarifying questions, approach exploration, and design approval\n" +
+        PromptKind.PlanningInitial => PlanningInitialDefault,
-            "BEFORE any subtasks are created. Do not create child tasks until the user has\n" +
+        PromptKind.Retry => RetryDefault,
-            "approved a design.\n\n" +
+        PromptKind.DailyPrep => DailyPrepDefault,
-            "NEVER change files yourself.\n\n" +
+        PromptKind.WeeklyReport => WeeklyReportDefault,
-            "ALWAYS use the available MCP tools (mcp__claudedo__*) to create child tasks once\n" +
+        PromptKind.ImprovementChild => ImprovementChildDefault,
-            "the design is approved. When you are done planning, finalize the session.\n\n" +
-            "Be concise and focused. Each subtask should be independently executable.\n",
-        PromptKind.Agent =>
-            "# Agent Prompt\n\n" +
-            "Appended to the system prompt for tasks tagged \"agent\" (auto-queued runs).\n" +
-            "Use this for autonomous-execution rules that don't apply to manual runs.\n",
         _ => ""
     };
+
+    private const string SystemDefault = """
+        # Working Agreement
+
+        You are completing one well-defined task autonomously in a git repository.
+
+        ## Scope
+        - Do exactly what the task asks — no unrequested refactors, renames, dependency
+          changes, or "while I'm here" cleanup.
+        - If intent is ambiguous, state the assumption you're making and proceed with the
+          most reasonable reading. Stop only if you genuinely cannot move forward.
+        - Prefer three similar lines over a premature abstraction. Don't build for
+          hypothetical future needs.
+
+        ## Out-of-scope improvements
+        If you notice worthwhile work that is genuinely outside this task's scope
+        (a refactor, a follow-up, tech debt), do NOT do it here. File it with
+        SuggestImprovement(title, description) and stay focused on the task at hand.
+
+        ## Working in the repo
+        - Read a file before editing it. Match the conventions already in this codebase —
+          they override generic defaults.
+        - Prefer editing existing files to creating new ones. Don't write comments that
+          just restate the code.
+        - Validate only at real boundaries (user input, external APIs).
+
+        ## Finishing
+        - Before claiming done, verify: run the build and relevant tests, confirm they
+          pass, and report what you ran. If you couldn't verify something, say so plainly.
+        - Make focused commits using the repository's existing commit-message convention.
+
+        ## Safety
+        - Never force-push, hard-reset, or delete branches/files beyond the task's scope
+          without being asked.
+        - Don't introduce injection/XSS/secret-leak issues. Never commit credentials.
+
+        ## You are running unattended
+        You run autonomously with no human watching. There is no one to answer mid-task
+        questions, so never stop to ask — make the most reasonable decision, note the
+        assumption, and continue.
+
+        ## When you are blocked
+        If something genuinely prevents you from completing part of the task (missing
+        credentials, contradictory requirements, a destructive action you won't take
+        unasked), do NOT silently give up. Write this marker on its own line, then keep
+        working on whatever else you can:
+
+        CLAUDEDO_BLOCKED: <one short sentence describing what blocked you>
+
+        Emit it as many times as needed — once per distinct blocker. Use it only for true
+        blockers, not for routine decisions you can make yourself.
+        """;
+
+    private const string ImprovementChildDefault = """
+        # Out-of-scope follow-up
+
+        You are an improvement follow-up that another task filed via SuggestImprovement.
+        It was deliberately scoped narrow. Do EXACTLY what this task's title and
+        description ask — nothing more.
+
+        - Make the smallest change that satisfies the task. No opportunistic refactors,
+          renames, reformatting, or "while I'm here" cleanup beyond what is asked.
+        - Touch as few files as possible. Do not restructure unrelated code.
+        - Do NOT file further improvements — improvements are one layer deep.
+        - Verify the build and relevant tests before finishing, and report what you ran.
+        - Make one focused commit using the repository's commit-message convention.
+        """;
+
+    private const string PlanningSystemDefault = """
+        You are the planning assistant for ClaudeDo. Your job is to break a task into
+        smaller, independently executable subtasks — the session ends by creating those
+        subtasks.
+
+        Start every session by invoking the `superpowers:brainstorming` skill (Skill
+        tool) and follow it end to end: clarifying questions one at a time, then 2–3
+        approaches with a recommendation, then a short design. Do not create any subtasks
+        until the user has approved the design.
+
+        You can ONLY shape this task's plan — you cannot edit files or touch other tasks.
+        The tools available to you are: CreateChildTask, ListChildTasks, UpdateChildTask,
+        DeleteChildTask, UpdatePlanningTask, and Finalize. Use nothing else.
+
+        Once the design is approved, create the child tasks with CreateChildTask, then
+        call Finalize. Keep each subtask concrete and self-contained with a clear
+        done-state, ordered so dependencies come first.
+        """;
+
+    private const string PlanningInitialDefault = """
+        # Task to plan: {title}
+
+        {description}
+        """;
+
+    private const string RetryDefault = """
+        The task did not complete on the previous attempt — you may have run out of
+        turns, hit an error, or stopped before finishing.
+
+        Review the work already done in this session and the current state of the
+        repository, identify what is still incomplete or broken, and finish the task.
+        Don't restart from scratch or repeat a failed approach. Verify the result
+        (build + tests) before you stop.
+        """;
+
+    private const string DailyPrepDefault = """
+        You are preparing my workday for {date}.
+
+        1. Call mcp__claudedo__get_daily_prep_candidates.
+        2. Keep tasks already marked MyDay (currentMyDay) — never remove them.
+        3. Fill MyDay to at most {maxTasks} open tasks TOTAL (currentMyDay counts). Never exceed it.
+        4. Estimate each candidate's effort and pick a feasible mix — not only big items.
+           Prioritize isStarred, due (scheduledFor), and older tasks.
+        5. Place related tasks next to each other using consecutive sortOrder values.
+        6. Apply via mcp__claudedo__set_my_day(taskId, true, sortOrder). Never mark anything
+           outside the candidate list.
+
+        If there are no candidates, do nothing.
+        """;
+
+    private const string WeeklyReportDefault = """
+        You are generating a concise weekly standup report for a software developer,
+        covering {start} to {end}.
+
+        Rules:
+        - Write the ENTIRE report in German.
+        - Group by day. One "## {Wochentag}, {dd.MM.yyyy}" section per day that has
+          activity (German weekday names). Omit days with no activity.
+        - Within each day: 3–5 first-person, past-tense bullets ("- Habe X umgesetzt",
+          "- Y behoben"). Merge related small work into one bullet.
+        - Drop trivia: typo fixes, pure exploration, false starts, tooling/log noise.
+        - Blend the developer's own notes and the derived activity into ONE deduplicated
+          bullet list per day. The notes are authoritative — never omit or contradict them.
+        - Name the project/repo when it adds clarity.
+        - Output ONLY the dated sections. No preamble, no intro, no closing remarks.
+
+        Two sections follow below: an activity log derived from Claude session history,
+        and the developer's own notes. Base the report on both; the notes are
+        authoritative where they conflict with the derived activity.
+        """;
 }

src/ClaudeDo.Data/Repositories/AppSettingsRepository.cs

@@ -50,6 +50,10 @@ public sealed class AppSettingsRepository
             ? null : updated.CentralWorktreeRoot;
         row.WorktreeAutoCleanupEnabled = updated.WorktreeAutoCleanupEnabled;
         row.WorktreeAutoCleanupDays = updated.WorktreeAutoCleanupDays;
+        row.ReportExcludedPaths = string.IsNullOrWhiteSpace(updated.ReportExcludedPaths)
+            ? null : updated.ReportExcludedPaths;
+        row.StandupWeekday = updated.StandupWeekday;
+        row.DailyPrepMaxTasks = updated.DailyPrepMaxTasks < 1 ? 1 : updated.DailyPrepMaxTasks;
 
         await _context.SaveChangesAsync(ct);
     }

src/ClaudeDo.Data/Repositories/DailyNoteRepository.cs

@@ -0,0 +1,59 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace ClaudeDo.Data.Repositories;
+
+public sealed class DailyNoteRepository
+{
+    private readonly ClaudeDoDbContext _context;
+
+    public DailyNoteRepository(ClaudeDoDbContext context) => _context = context;
+
+    public async Task<IReadOnlyList<DailyNoteEntity>> ListByDayAsync(DateOnly day, CancellationToken ct = default) =>
+        await _context.DailyNotes.AsNoTracking()
+            .Where(n => n.Date == day)
+            .OrderBy(n => n.SortOrder)
+            .ToListAsync(ct);
+
+    public async Task<IReadOnlyList<DailyNoteEntity>> ListBetweenAsync(
+        DateOnly start, DateOnly end, CancellationToken ct = default) =>
+        await _context.DailyNotes.AsNoTracking()
+            .Where(n => n.Date >= start && n.Date <= end)
+            .OrderBy(n => n.Date).ThenBy(n => n.SortOrder)
+            .ToListAsync(ct);
+
+    public async Task<DailyNoteEntity> AddAsync(DateOnly day, string text, CancellationToken ct = default)
+    {
+        var nextOrder = await _context.DailyNotes
+            .Where(n => n.Date == day)
+            .Select(n => (int?)n.SortOrder)
+            .MaxAsync(ct) ?? -1;
+
+        var note = new DailyNoteEntity
+        {
+            Date = day,
+            Text = text,
+            SortOrder = nextOrder + 1,
+            CreatedAt = DateTime.UtcNow,
+        };
+        _context.DailyNotes.Add(note);
+        await _context.SaveChangesAsync(ct);
+        return note;
+    }
+
+    public async Task UpdateAsync(string id, string text, CancellationToken ct = default)
+    {
+        var row = await _context.DailyNotes.FirstOrDefaultAsync(n => n.Id == id, ct);
+        if (row is null) return;
+        row.Text = text;
+        await _context.SaveChangesAsync(ct);
+    }
+
+    public async Task DeleteAsync(string id, CancellationToken ct = default)
+    {
+        var row = await _context.DailyNotes.FirstOrDefaultAsync(n => n.Id == id, ct);
+        if (row is null) return;
+        _context.DailyNotes.Remove(row);
+        await _context.SaveChangesAsync(ct);
+    }
+}

src/ClaudeDo.Data/Repositories/ListRepository.cs

@@ -65,6 +65,7 @@ public sealed class ListRepository
             existing.Model = config.Model;
             existing.SystemPrompt = config.SystemPrompt;
             existing.AgentPath = config.AgentPath;
+            existing.MaxTurns = config.MaxTurns;
         }
         await _context.SaveChangesAsync(ct);
     }

src/ClaudeDo.Data/Repositories/TaskRepository.cs

@@ -127,6 +127,13 @@ public sealed class TaskRepository
             .ExecuteUpdateAsync(s => s.SetProperty(t => t.LogPath, logPath), ct);
     }
 
+    public async Task SetRoadblockCountAsync(string taskId, int count, CancellationToken ct = default)
+    {
+        await _context.Tasks
+            .Where(t => t.Id == taskId)
+            .ExecuteUpdateAsync(s => s.SetProperty(t => t.RoadblockCount, count), ct);
+    }
+
     internal async Task<int> FlipAllRunningToFailedAsync(string reason, CancellationToken ct = default)
     {
         var resultText = "[stale] " + reason;
@@ -159,6 +166,7 @@ public sealed class TaskRepository
         string? model,
         string? systemPrompt,
         string? agentPath,
+        int? maxTurns = null,
         CancellationToken ct = default)
     {
         await _context.Tasks
@@ -166,7 +174,8 @@ public sealed class TaskRepository
             .ExecuteUpdateAsync(s => s
                 .SetProperty(t => t.Model, model)
                 .SetProperty(t => t.SystemPrompt, systemPrompt)
-                .SetProperty(t => t.AgentPath, agentPath), ct);
+                .SetProperty(t => t.AgentPath, agentPath)
+                .SetProperty(t => t.MaxTurns, maxTurns), ct);
     }
 
     #endregion
@@ -187,6 +196,7 @@ public sealed class TaskRepository
         string title,
         string? description,
         string? commitType,
+        string? createdBy = null,
         CancellationToken ct = default)
     {
         // AsNoTracking: SetPlanningStartedAsync mutates via ExecuteUpdate which
@@ -195,9 +205,6 @@ public sealed class TaskRepository
             .FirstOrDefaultAsync(t => t.Id == parentId, ct);
         if (parent is null)
             throw new InvalidOperationException($"Parent task {parentId} not found.");
-        if (parent.PlanningPhase == PlanningPhase.None)
-            throw new InvalidOperationException(
-                $"Parent task {parentId} is not in a planning phase; cannot attach children.");
 
         var maxSort = await _context.Tasks
             .Where(t => t.ListId == parent.ListId)
@@ -215,6 +222,7 @@ public sealed class TaskRepository
             CommitType = string.IsNullOrEmpty(commitType) ? parent.CommitType : commitType,
             ParentTaskId = parentId,
             SortOrder = (maxSort ?? -1) + 1,
+            CreatedBy = createdBy,
         };
         _context.Tasks.Add(child);
         await _context.SaveChangesAsync(ct);
@@ -385,6 +393,9 @@ public sealed class TaskRepository
     {
         var orphanIds = await _context.Tasks
             .Where(t => t.ParentTaskId != null && t.Status == TaskStatus.Queued)
+            // Agent-suggested improvement children (CreatedBy == ParentTaskId) legitimately
+            // queue under a non-planning parent — they are not orphaned planning-chain members.
+            .Where(t => t.CreatedBy == null || t.CreatedBy != t.ParentTaskId)
             .Where(t => !_context.Tasks.Any(p =>
                 p.Id == t.ParentTaskId && p.PlanningPhase != PlanningPhase.None))
             .Select(t => t.Id)

src/ClaudeDo.Data/Repositories/WeekReportRepository.cs

@@ -0,0 +1,38 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace ClaudeDo.Data.Repositories;
+
+public sealed class WeekReportRepository
+{
+    private readonly ClaudeDoDbContext _context;
+
+    public WeekReportRepository(ClaudeDoDbContext context) => _context = context;
+
+    public async Task<WeekReportEntity?> GetByRangeAsync(
+        DateOnly start, DateOnly end, CancellationToken ct = default) =>
+        await _context.WeekReports.AsNoTracking()
+            .FirstOrDefaultAsync(r => r.StartDate == start && r.EndDate == end, ct);
+
+    public async Task UpsertAsync(DateOnly start, DateOnly end, string markdown, CancellationToken ct = default)
+    {
+        var row = await _context.WeekReports
+            .FirstOrDefaultAsync(r => r.StartDate == start && r.EndDate == end, ct);
+        if (row is null)
+        {
+            _context.WeekReports.Add(new WeekReportEntity
+            {
+                StartDate = start,
+                EndDate = end,
+                Markdown = markdown,
+                GeneratedAt = DateTime.UtcNow,
+            });
+        }
+        else
+        {
+            row.Markdown = markdown;
+            row.GeneratedAt = DateTime.UtcNow;
+        }
+        await _context.SaveChangesAsync(ct);
+    }
+}

src/ClaudeDo.Installer/App.xaml.cs

@@ -1,7 +1,12 @@
+using System.Globalization;
+using System.IO;
+using System.Linq;
 using System.Net.Http;
 using System.Reflection;
 using System.Windows;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
+using ClaudeDo.Localization;
 using ClaudeDo.Releases;
 using ClaudeDo.Installer.Pages.InstallPage;
 using ClaudeDo.Installer.Pages.PathsPage;
@@ -22,6 +27,17 @@ public partial class App : Application
     {
         base.OnStartup(e);
 
+        // --- Initialize localizer as early as possible so all windows can use {loc:Tr} ---
+        var localesDir = Path.Combine(AppContext.BaseDirectory, "locales");
+        var localeStore = LocaleStore.Load(localesDir);
+        var existingSettings = InstallerAppSettings.Load();
+        var initialLang = !string.IsNullOrWhiteSpace(existingSettings.Language)
+            ? existingSettings.Language
+            : CultureResolver.Resolve(CultureInfo.CurrentUICulture.Name,
+                  localeStore.Available.Select(l => l.Code).ToArray(), "en");
+        var localizer = new Localizer(localeStore, initialLang);
+        TrExtension.Localizer = localizer;
+
         // --- Self-update pre-flight ---
         // Resolve current exe path. Assembly.Location may point to a .dll for apphost-based
         // .NET apps; swap to the .exe companion when that happens.
@@ -120,7 +136,7 @@ public partial class App : Application
 
         // --- Existing wizard start-up unchanged below this line ---
 
-        _services = BuildServices();
+        _services = BuildServices(localizer);
 
         var context = _services.GetRequiredService<InstallContext>();
         context.InstallerVersion = GetInstallerVersion();
@@ -183,9 +199,10 @@ public partial class App : Application
         return infoAttr?.InformationalVersion ?? "0.0.0";
     }
 
-    private static ServiceProvider BuildServices()
+    private static ServiceProvider BuildServices(ILocalizer localizer)
     {
         var sc = new ServiceCollection();
+        sc.AddSingleton(localizer);
 
         // Core
         sc.AddSingleton<InstallContext>();

src/ClaudeDo.Installer/CLAUDE.md

@@ -0,0 +1,110 @@
+# ClaudeDo.Installer
+
+WPF GUI installer, updater, and configuration tool for ClaudeDo. Not WiX/NSIS — the app is its own installer.
+
+Note: this is the one project where `System.Windows` is correct (WPF, not Avalonia).
+
+## Project Facts
+
+- `<UseWPF>true</UseWPF>`, `WinExe`, `net8.0-windows`
+- `<EnableWindowsTargeting>true</EnableWindowsTargeting>` — allows Linux CI to cross-compile
+- Single-file framework-dependent publish: `dotnet publish -r win-x64 -p:PublishSingleFile=true` (needs .NET 8 Desktop Runtime)
+- Entry point: `App.xaml` / `App.xaml.cs` (no `Program.cs`)
+- References: `ClaudeDo.Data`, `ClaudeDo.Releases`, `ClaudeDo.Localization`
+- Manifests: `app.manifest` (requireAdministrator, Release) / `app.debug.manifest` (asInvoker, Debug)
+- Only CLI arg: `--replace-self <old-path>` (self-update handoff)
+
+## Startup Sequence (`App.OnStartup`)
+
+1. Load locale
+2. Self-update preflight — `SelfUpdater.DecideUpdateAsync` checks Gitea API; if a newer installer exists, download + checksum verify + relaunch with `--replace-self <old-path>`
+3. Detect mode — `InstallModeDetector` reads `install.json` + Gitea API
+4. Open `WizardWindow` (FreshInstall / Update) or `SettingsWindow` (Config)
+
+## Modes (`Core/InstallerMode.cs`)
+
+| Mode | Condition | Window |
+|---|---|---|
+| `FreshInstall` | No `install.json` | Full wizard (all pages) |
+| `Update` | `install.json` present + newer release available | Wizard — Welcome + Install pages only |
+| `Config` | Current version, or Gitea API unreachable | `SettingsWindow` (settings / repair / uninstall) |
+
+## Install Pipelines
+
+Each step implements `IInstallStep`; `InstallerService` runs them sequentially, stops on failure.
+
+**FreshInstall:**
+`DownloadAndExtractStep` → `WriteConfigStep` → `InitDatabaseStep` → `RegisterMcpStep` (optional) → `RegisterAutostartStep` → `CreateShortcutsStep` → `WriteUninstallRegistryStep` → `WriteInstallManifestStep` → `StartWorkerStep`
+
+**Update:**
+`StopWorkerStep` → `DownloadAndExtractStep` → `RegisterAutostartStep` → `RegisterMcpStep` → `StartWorkerStep` → `WriteInstallManifestStep` → `WriteUninstallRegistryStep`
+
+**Repair** (via `SettingsViewModel`):
+`StopWorkerStep` → `DownloadAndExtractStep` → `RegisterAutostartStep` → `StartWorkerStep`
+
+**Uninstall** (`UninstallRunner`):
+Stop worker → remove legacy task/service → delete HKLM uninstall key + shortcuts → delete install dir (cmd.exe trampoline if uninstaller exe is inside it) → optionally delete `~/.todo-app`
+
+## Folder Layout
+
+```
+Installer/
+  Steps/    — one class per action (see pipeline lists above)
+  Core/     — InstallContext, InstallerMode, InstallModeDetector, InstallManifest(+Store),
+               ConfigModels, InstallerService, UninstallRunner, PageResolver,
+               AutostartShortcut, ShortcutFactory, ProcessRunner, DarkTitleBar
+              Interfaces/ — IInstallStep + StepResult/StepStatus/StepProgress, IInstallerPage
+  Pages/    — WelcomePage, PathsPage, ServicePage, UiSettingsPage, InstallPage
+               (each: ViewModel + View.xaml)
+  Views/    — WizardWindow(+WizardViewModel), SettingsWindow(+SettingsViewModel),
+               SelfUpdatePromptWindow
+```
+
+## Key Step Behaviors
+
+**`RegisterMcpStep`** — registers the external MCP endpoint with the Claude CLI:
+```
+claude mcp remove --scope user claudedo
+claude mcp add --transport http --scope user claudedo http://127.0.0.1:{ExternalMcpPort}/mcp
+```
+Non-fatal if `claude` CLI is missing or too old (prints the manual command). Server name: `claudedo`.
+
+**`RegisterAutostartStep`** — creates a per-user Startup-folder shortcut `ClaudeDo Worker.lnk` (`Environment.SpecialFolder.Startup`). Also migrates away from legacy mechanisms:
+- Deletes legacy Windows service: `sc.exe stop/delete ClaudeDoWorker`
+- Deletes legacy scheduled task: `schtasks /Delete /TN ClaudeDoWorker`
+
+No new service or scheduled task is created. Rationale: the worker must run in the user's interactive session so Claude CLI auth works.
+
+## `InstallContext` Defaults
+
+| Property | Default |
+|---|---|
+| `InstallDirectory` | `C:\Program Files\ClaudeDo` |
+| `DbPath` | `~/.todo-app/todo.db` |
+| `LogRoot` | `~/.todo-app/logs` |
+| `SandboxRoot` | `~/.todo-app/sandbox` |
+| `WorktreeRootStrategy` | `sibling` |
+| `SignalRPort` | `47821` |
+| `ExternalMcpPort` | `47822` |
+| `QueueBackstopIntervalMs` | `30000` |
+| `ClaudeBin` | `claude` |
+| `AutoStart` | `true` |
+| `SignalRUrl` | `http://127.0.0.1:47821/hub` |
+
+## Files Written by Install
+
+| Path | Content |
+|---|---|
+| `~/.todo-app/worker.config.json` | Worker config |
+| `~/.todo-app/ui.config.json` | UI config |
+| `~/.todo-app/todo.db` | SQLite DB (EF migrations) |
+| `<InstallDir>\install.json` | Install manifest |
+| `<InstallDir>\app\` | UI binaries |
+| `<InstallDir>\worker\` | Worker binaries |
+| `<InstallDir>\uninstaller\ClaudeDo.Installer.exe` | Uninstaller copy |
+| `HKLM\Software\Microsoft\Windows\CurrentVersion\Uninstall\ClaudeDo` | Uninstall registry key |
+| Start Menu shortcut | `ClaudeDo.lnk` |
+| Desktop shortcut (optional) | `ClaudeDo.lnk` |
+| `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\ClaudeDo Worker.lnk` | Worker autostart |
+
+The Apps & Features uninstall string and "Rerun Installer" both point at `<InstallDir>\uninstaller\ClaudeDo.Installer.exe` with no `/uninstall` flag — Config mode is detected from `install.json`.

src/ClaudeDo.Installer/ClaudeDo.Installer.csproj

@@ -46,6 +46,9 @@
   <ItemGroup>
     <ProjectReference Include="..\ClaudeDo.Data\ClaudeDo.Data.csproj" />
     <ProjectReference Include="..\ClaudeDo.Releases\ClaudeDo.Releases.csproj" />
+    <ProjectReference Include="..\ClaudeDo.Localization\ClaudeDo.Localization.csproj" />
   </ItemGroup>
 
+  <Import Project="..\ClaudeDo.Localization\Locales.targets" />
+
 </Project>

src/ClaudeDo.Installer/Core/ConfigModels.cs

@@ -77,6 +77,7 @@ public sealed class InstallerAppSettings
 {
     public string DbPath { get; set; } = "~/.todo-app/todo.db";
     public string SignalRUrl { get; set; } = "http://127.0.0.1:47821/hub";
+    public string Language { get; set; } = "";
 
     private static readonly JsonSerializerOptions ReadOpts = new()
     {

src/ClaudeDo.Installer/Core/InstallContext.cs

@@ -36,4 +36,7 @@ public sealed class InstallContext
     // WelcomePage — register the external MCP endpoint with the Claude CLI.
     public bool RegisterMcpWithClaude { get; set; } = true;
     public int ExternalMcpPort { get; set; } = 47_822;
+
+    // Language selection (persisted to ui.config.json)
+    public string Language { get; set; } = "";
 }

src/ClaudeDo.Installer/Localization/LocalizedString.cs

@@ -0,0 +1,22 @@
+using System.ComponentModel;
+using ClaudeDo.Localization;
+
+namespace ClaudeDo.Installer.Localization;
+
+public sealed class LocalizedString : INotifyPropertyChanged
+{
+    private readonly ILocalizer _localizer;
+    private readonly string _key;
+
+    public LocalizedString(ILocalizer localizer, string key)
+    {
+        _localizer = localizer;
+        _key = key;
+        _localizer.LanguageChanged += (_, _) =>
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
+    }
+
+    public string Value => _localizer[_key];
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+}

src/ClaudeDo.Installer/Localization/TrExtension.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Windows.Data;
+using System.Windows.Markup;
+using ClaudeDo.Localization;
+
+namespace ClaudeDo.Installer.Localization;
+
+public sealed class TrExtension : MarkupExtension
+{
+    public TrExtension() { }
+    public TrExtension(string key) => Key = key;
+
+    public string Key { get; set; } = "";
+
+    public static ILocalizer? Localizer { get; set; }
+
+    public override object ProvideValue(IServiceProvider serviceProvider)
+    {
+        var loc = Localizer ?? throw new InvalidOperationException("TrExtension.Localizer not initialized");
+        var binding = new Binding(nameof(LocalizedString.Value))
+        {
+            Source = new LocalizedString(loc, Key),
+            Mode = BindingMode.OneWay
+        };
+        return binding.ProvideValue(serviceProvider);
+    }
+}

src/ClaudeDo.Installer/Pages/InstallPage/InstallPageView.xaml

@@ -2,6 +2,7 @@
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:local="clr-namespace:ClaudeDo.Installer.Pages.InstallPage"
+             xmlns:loc="clr-namespace:ClaudeDo.Installer.Localization"
              d:DataContext="{d:DesignInstance local:InstallPageViewModel}"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
@@ -17,8 +18,8 @@
 
         <!-- Header -->
         <StackPanel Grid.Row="0" Margin="0,0,0,16">
-            <TextBlock Text="Installation" FontSize="18" FontWeight="SemiBold" Margin="0,0,0,4"/>
+            <TextBlock Text="{loc:Tr installer.install.title}" FontSize="18" FontWeight="SemiBold" Margin="0,0,0,4"/>
-            <TextBlock Text="Click Install to build and deploy ClaudeDo."
+            <TextBlock Text="{loc:Tr installer.install.subtitle}"
                        Foreground="{StaticResource TextSecondaryBrush}" TextWrapping="Wrap"/>
         </StackPanel>
 
@@ -89,11 +90,11 @@
 
         <!-- Action buttons -->
         <StackPanel Grid.Row="3" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,12,0,0">
-            <Button Content="Cancel" Command="{Binding CancelInstallCommand}"
+            <Button Content="{loc:Tr installer.nav.cancel}" Command="{Binding CancelInstallCommand}"
                     Visibility="{Binding IsInstalling, Converter={StaticResource BoolToVisConverter}}"
                     Margin="0,0,8,0"/>
 
-            <Button Content="Launch ClaudeDo" Command="{Binding LaunchAppCommand}"
+            <Button Content="{loc:Tr installer.install.launch}" Command="{Binding LaunchAppCommand}"
                     Style="{StaticResource AccentButton}"
                     Visibility="{Binding IsComplete, Converter={StaticResource BoolToVisConverter}}"/>
         </StackPanel>

src/ClaudeDo.Installer/Pages/InstallPage/InstallPageViewModel.cs

@@ -3,6 +3,7 @@ using System.Diagnostics;
 using System.Windows;
 using System.Windows.Controls;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 using ClaudeDo.Installer.Steps;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
@@ -29,7 +30,7 @@ public partial class InstallPageViewModel : ObservableObject, IInstallerPage
     private InstallPageView? _view;
     private CancellationTokenSource? _cts;
 
-    public string Title => "Install";
+    public string Title => TrExtension.Localizer?["installer.install.title"] ?? "Install";
     public string Icon => "\uE896";
     public int Order => 99;
     public bool ShowInWizard => true;

src/ClaudeDo.Installer/Pages/PathsPage/PathsPageView.xaml

@@ -2,6 +2,7 @@
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:local="clr-namespace:ClaudeDo.Installer.Pages.PathsPage"
+             xmlns:loc="clr-namespace:ClaudeDo.Installer.Localization"
              d:DataContext="{d:DesignInstance local:PathsPageViewModel}"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
@@ -9,28 +10,28 @@
 
     <ScrollViewer VerticalScrollBarVisibility="Auto">
         <StackPanel MaxWidth="520">
-            <TextBlock Text="Data Paths" FontSize="18" FontWeight="SemiBold" Margin="0,0,0,4"/>
+            <TextBlock Text="{loc:Tr installer.paths.title}" FontSize="18" FontWeight="SemiBold" Margin="0,0,0,4"/>
-            <TextBlock Text="Configure where ClaudeDo stores its data."
+            <TextBlock Text="{loc:Tr installer.paths.subtitle}"
                        Foreground="{StaticResource TextSecondaryBrush}" Margin="0,0,0,20"
                        TextWrapping="Wrap"/>
 
-            <Label Content="Database Path"/>
+            <Label Content="{loc:Tr installer.paths.databasePath}"/>
             <TextBox Text="{Binding DbPath, UpdateSourceTrigger=PropertyChanged}" Margin="0,0,0,12"/>
 
-            <Label Content="Log Directory"/>
+            <Label Content="{loc:Tr installer.paths.logDirectory}"/>
             <TextBox Text="{Binding LogRoot, UpdateSourceTrigger=PropertyChanged}" Margin="0,0,0,12"/>
 
-            <Label Content="Sandbox Root"/>
+            <Label Content="{loc:Tr installer.paths.sandboxRoot}"/>
             <TextBox Text="{Binding SandboxRoot, UpdateSourceTrigger=PropertyChanged}" Margin="0,0,0,12"/>
 
-            <Label Content="Worktree Strategy"/>
+            <Label Content="{loc:Tr installer.paths.worktreeStrategy}"/>
             <ComboBox SelectedItem="{Binding WorktreeRootStrategy}" Margin="0,0,0,12">
                 <sys:String xmlns:sys="clr-namespace:System;assembly=mscorlib">sibling</sys:String>
                 <sys:String xmlns:sys="clr-namespace:System;assembly=mscorlib">central</sys:String>
             </ComboBox>
 
             <StackPanel Visibility="{Binding IsCentralVisible, Converter={StaticResource BoolToVisConverter}}">
-                <Label Content="Central Worktree Root"/>
+                <Label Content="{loc:Tr installer.paths.centralWorktreeRoot}"/>
                 <TextBox Text="{Binding CentralWorktreeRoot, UpdateSourceTrigger=PropertyChanged}" Margin="0,0,0,12"/>
             </StackPanel>
 

src/ClaudeDo.Installer/Pages/PathsPage/PathsPageViewModel.cs

@@ -1,5 +1,6 @@
 using System.Windows.Controls;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 using CommunityToolkit.Mvvm.ComponentModel;
 
 namespace ClaudeDo.Installer.Pages.PathsPage;
@@ -9,7 +10,7 @@ public partial class PathsPageViewModel : ObservableObject, IInstallerPage
     private readonly InstallContext _context;
     private PathsPageView? _view;
 
-    public string Title => "Paths";
+    public string Title => TrExtension.Localizer?["installer.paths.title"] ?? "Paths";
     public string Icon => "\uE8B7";
     public int Order => 1;
     public bool ShowInWizard => true;

src/ClaudeDo.Installer/Pages/ServicePage/ServicePageView.xaml

@@ -2,6 +2,7 @@
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:local="clr-namespace:ClaudeDo.Installer.Pages.ServicePage"
+             xmlns:loc="clr-namespace:ClaudeDo.Installer.Localization"
              d:DataContext="{d:DesignInstance local:ServicePageViewModel}"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
@@ -9,37 +10,37 @@
 
     <ScrollViewer VerticalScrollBarVisibility="Auto">
         <StackPanel MaxWidth="520">
-            <TextBlock Text="Worker" FontSize="18" FontWeight="SemiBold" Margin="0,0,0,4"/>
+            <TextBlock Text="{loc:Tr installer.service.title}" FontSize="18" FontWeight="SemiBold" Margin="0,0,0,4"/>
-            <TextBlock Text="Configure the ClaudeDo background worker."
+            <TextBlock Text="{loc:Tr installer.service.subtitle}"
                        Foreground="{StaticResource TextSecondaryBrush}" Margin="0,0,0,20"
                        TextWrapping="Wrap"/>
 
-            <Label Content="SignalR Port"/>
+            <Label Content="{loc:Tr installer.service.signalRPort}"/>
             <TextBox Text="{Binding SignalRPort, UpdateSourceTrigger=PropertyChanged}" Margin="0,0,0,12"/>
 
-            <Label Content="Queue Backstop Interval (ms)"/>
+            <Label Content="{loc:Tr installer.service.queueBackstopInterval}"/>
             <TextBox Text="{Binding QueueBackstopIntervalMs, UpdateSourceTrigger=PropertyChanged}" Margin="0,0,0,12"/>
 
-            <Label Content="Claude CLI Path"/>
+            <Label Content="{loc:Tr installer.service.claudeCliPath}"/>
             <Grid Margin="0,0,0,12">
                 <Grid.ColumnDefinitions>
                     <ColumnDefinition Width="*"/>
                     <ColumnDefinition Width="Auto"/>
                 </Grid.ColumnDefinitions>
                 <TextBox Grid.Column="0" Text="{Binding ClaudeBin, UpdateSourceTrigger=PropertyChanged}"/>
-                <Button Grid.Column="1" Content="Browse..." Command="{Binding BrowseClaudeCommand}"
+                <Button Grid.Column="1" Content="{loc:Tr installer.nav.browse}" Command="{Binding BrowseClaudeCommand}"
                         Margin="8,0,0,0"/>
             </Grid>
 
             <Separator Margin="0,4,0,12"/>
 
-            <TextBlock Text="The worker runs as you (the logged-in user) via a per-user logon task, so it can use your Claude CLI authentication."
+            <TextBlock Text="{loc:Tr installer.service.autostartHint}"
                        Foreground="{StaticResource TextDimBrush}" FontSize="11" Margin="0,0,0,12"
                        TextWrapping="Wrap"/>
 
-            <CheckBox Content="Start worker automatically at logon" IsChecked="{Binding AutoStart}" Margin="0,0,0,12"/>
+            <CheckBox Content="{loc:Tr installer.service.autostart}" IsChecked="{Binding AutoStart}" Margin="0,0,0,12"/>
 
-            <Label Content="Restart Delay (ms)"/>
+            <Label Content="{loc:Tr installer.service.restartDelay}"/>
             <TextBox Text="{Binding RestartDelayMs, UpdateSourceTrigger=PropertyChanged}" Margin="0,0,0,12"/>
 
             <TextBlock Text="{Binding ValidationError}" Foreground="{StaticResource ErrorBrush}" FontSize="11"

src/ClaudeDo.Installer/Pages/ServicePage/ServicePageViewModel.cs

@@ -1,5 +1,6 @@
 using System.Windows.Controls;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using Microsoft.Win32;
@@ -11,7 +12,7 @@ public partial class ServicePageViewModel : ObservableObject, IInstallerPage
     private readonly InstallContext _context;
     private ServicePageView? _view;
 
-    public string Title => "Service";
+    public string Title => TrExtension.Localizer?["installer.service.title"] ?? "Service";
     public string Icon => "\uE912";
     public int Order => 2;
     public bool ShowInWizard => true;

src/ClaudeDo.Installer/Pages/UiSettingsPage/UiSettingsPageView.xaml

@@ -2,6 +2,7 @@
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:local="clr-namespace:ClaudeDo.Installer.Pages.UiSettingsPage"
+             xmlns:loc="clr-namespace:ClaudeDo.Installer.Localization"
              d:DataContext="{d:DesignInstance local:UiSettingsPageViewModel}"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
@@ -9,22 +10,22 @@
 
     <ScrollViewer VerticalScrollBarVisibility="Auto">
         <StackPanel MaxWidth="520">
-            <TextBlock Text="UI Settings" FontSize="18" FontWeight="SemiBold" Margin="0,0,0,4"/>
+            <TextBlock Text="{loc:Tr installer.uiSettings.title}" FontSize="18" FontWeight="SemiBold" Margin="0,0,0,4"/>
-            <TextBlock Text="Configure the ClaudeDo desktop UI connection settings."
+            <TextBlock Text="{loc:Tr installer.uiSettings.subtitle}"
                        Foreground="{StaticResource TextSecondaryBrush}" Margin="0,0,0,20"
                        TextWrapping="Wrap"/>
 
-            <CheckBox Content="Sync with service settings" IsChecked="{Binding IsSynced}" Margin="0,0,0,16"/>
+            <CheckBox Content="{loc:Tr installer.uiSettings.syncWithService}" IsChecked="{Binding IsSynced}" Margin="0,0,0,16"/>
 
-            <Label Content="SignalR URL"/>
+            <Label Content="{loc:Tr installer.uiSettings.signalRUrl}"/>
             <TextBox Text="{Binding SignalRUrl, UpdateSourceTrigger=PropertyChanged}"
                      IsReadOnly="{Binding IsSynced}" Margin="0,0,0,12"/>
 
-            <Label Content="Database Path"/>
+            <Label Content="{loc:Tr installer.paths.databasePath}"/>
             <TextBox Text="{Binding UiDbPath, UpdateSourceTrigger=PropertyChanged}"
                      IsReadOnly="{Binding IsSynced}" Margin="0,0,0,12"/>
 
-            <TextBlock Text="When synced, these values are derived from the Service and Paths pages."
+            <TextBlock Text="{loc:Tr installer.uiSettings.syncHint}"
                        Foreground="{StaticResource TextDimBrush}" FontSize="11" TextWrapping="Wrap"
                        Visibility="{Binding IsSynced, Converter={StaticResource BoolToVisConverter}}"
                        Margin="0,0,0,12"/>

src/ClaudeDo.Installer/Pages/UiSettingsPage/UiSettingsPageViewModel.cs

@@ -1,5 +1,6 @@
 using System.Windows.Controls;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 using CommunityToolkit.Mvvm.ComponentModel;
 
 namespace ClaudeDo.Installer.Pages.UiSettingsPage;
@@ -9,7 +10,7 @@ public partial class UiSettingsPageViewModel : ObservableObject, IInstallerPage
     private readonly InstallContext _context;
     private UiSettingsPageView? _view;
 
-    public string Title => "UI Settings";
+    public string Title => TrExtension.Localizer?["installer.uiSettings.title"] ?? "UI Settings";
     public string Icon => "\uE771";
     public int Order => 3;
     public bool ShowInWizard => true;

src/ClaudeDo.Installer/Pages/WelcomePage/WelcomePageView.xaml

@@ -2,6 +2,7 @@
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:local="clr-namespace:ClaudeDo.Installer.Pages.WelcomePage"
+             xmlns:loc="clr-namespace:ClaudeDo.Installer.Localization"
              d:DataContext="{d:DesignInstance local:WelcomePageViewModel}"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
@@ -14,7 +15,7 @@
             <TextBlock Text="{Binding Subheading}" TextWrapping="Wrap"
                        Foreground="{StaticResource TextSecondaryBrush}" Margin="0,0,0,24"/>
 
-            <Label Content="Install Directory"/>
+            <Label Content="{loc:Tr installer.welcome.installDirectory}"/>
             <Grid Margin="0,0,0,4">
                 <Grid.ColumnDefinitions>
                     <ColumnDefinition Width="*"/>
@@ -24,7 +25,7 @@
                          Text="{Binding InstallDirectory, UpdateSourceTrigger=PropertyChanged}"
                          IsEnabled="{Binding InstallDirEditable}"/>
                 <Button Grid.Column="1"
-                        Content="Browse..."
+                        Content="{loc:Tr installer.nav.browse}"
                         Margin="8,0,0,0"
                         Command="{Binding BrowseInstallCommand}"
                         IsEnabled="{Binding InstallDirEditable}"/>
@@ -32,10 +33,10 @@
             <TextBlock Text="{Binding InstallError}" Foreground="{StaticResource ErrorBrush}" FontSize="11"
                        Visibility="{Binding InstallError, Converter={StaticResource NullToCollapsedConverter}}"/>
 
-            <CheckBox Content="Register MCP server with Claude"
+            <CheckBox Content="{loc:Tr installer.welcome.registerMcp}"
                       IsChecked="{Binding RegisterMcp}"
                       Margin="0,24,0,0"/>
-            <TextBlock Text="Runs 'claude mcp add' so Claude can view and manage your ClaudeDo tasks. You can change this later."
+            <TextBlock Text="{loc:Tr installer.welcome.registerMcpHint}"
                        TextWrapping="Wrap" FontSize="11"
                        Foreground="{StaticResource TextSecondaryBrush}"
                        Margin="0,4,0,0"/>

src/ClaudeDo.Installer/Pages/WelcomePage/WelcomePageViewModel.cs

@@ -1,6 +1,7 @@
 using System.IO;
 using System.Windows.Controls;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Installer.Localization;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using Microsoft.Win32;
@@ -12,7 +13,7 @@ public partial class WelcomePageViewModel : ObservableObject, IInstallerPage
     private readonly InstallContext _context;
     private WelcomePageView? _view;
 
-    public string Title => "Welcome";
+    public string Title => TrExtension.Localizer?["installer.welcome.title"] ?? "Welcome";
     public string Icon => "\uE80F";
     public int Order => 0;
     public bool ShowInWizard => true;
@@ -37,17 +38,18 @@ public partial class WelcomePageViewModel : ObservableObject, IInstallerPage
             ? @"C:\Program Files\ClaudeDo"
             : _context.InstallDirectory;
 
+        var loc = TrExtension.Localizer;
         switch (_context.Mode)
         {
             case InstallerMode.FreshInstall:
-                Heading = "Install ClaudeDo";
+                Heading = loc?["installer.welcome.heading"] ?? "Install ClaudeDo";
-                Subheading = "Choose where to install ClaudeDo, then click Next.";
+                Subheading = loc?["installer.welcome.subheading"] ?? "Choose where to install ClaudeDo, then click Next.";
                 InstallDirEditable = true;
                 break;
 
             case InstallerMode.Update:
                 Heading = $"Update ClaudeDo  {_context.InstalledVersion ?? "?"}  ->  {_context.LatestVersion ?? "?"}";
-                Subheading = "Your tasks, config, and database will be preserved. Click Next to continue.";
+                Subheading = loc?["installer.welcome.updateSubheading"] ?? "Your tasks, config, and database will be preserved. Click Next to continue.";
                 InstallDirEditable = false; // stay where we were installed
                 break;
 

src/ClaudeDo.Installer/Steps/WriteConfigStep.cs

@@ -31,6 +31,7 @@ public sealed class WriteConfigStep : IInstallStep
             {
                 DbPath = Paths.Expand(ctx.UiDbPath),
                 SignalRUrl = ctx.SignalRUrl,
+                Language = ctx.Language,
             };
             uiCfg.Save();
             progress.Report("Written ui.config.json");

src/ClaudeDo.Installer/Views/SelfUpdatePromptWindow.xaml

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

src/ClaudeDo.Installer/Views/SettingsViewModel.cs

@@ -1,5 +1,6 @@
 using System.Windows;
 using ClaudeDo.Installer.Core;
+using ClaudeDo.Localization;
 using ClaudeDo.Releases;
 using ClaudeDo.Installer.Steps;
 using CommunityToolkit.Mvvm.ComponentModel;
@@ -10,6 +11,7 @@ namespace ClaudeDo.Installer.Views;
 public partial class SettingsViewModel : ObservableObject
 {
     private readonly InstallContext _context;
+    private readonly ILocalizer _localizer;
     private readonly IReleaseClient _releases;
     private readonly StopWorkerStep _stopService;
     private readonly StartWorkerStep _startService;
@@ -37,6 +39,7 @@ public partial class SettingsViewModel : ObservableObject
     public SettingsViewModel(
         PageResolver resolver,
         InstallContext context,
+        ILocalizer localizer,
         IReleaseClient releases,
         StopWorkerStep stopService,
         StartWorkerStep startService,
@@ -46,6 +49,7 @@ public partial class SettingsViewModel : ObservableObject
     {
         Pages = resolver.SettingsPages;
         _context = context;
+        _localizer = localizer;
         _releases = releases;
         _stopService = stopService;
         _startService = startService;
@@ -104,6 +108,7 @@ public partial class SettingsViewModel : ObservableObject
         {
             DbPath = _context.UiDbPath,
             SignalRUrl = _context.SignalRUrl,
+            Language = _localizer.CurrentCode,
         };
         uiCfg.Save();
 

src/ClaudeDo.Installer/Views/SettingsWindow.xaml

@@ -2,6 +2,7 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:views="clr-namespace:ClaudeDo.Installer.Views"
+        xmlns:loc="clr-namespace:ClaudeDo.Installer.Localization"
         Title="ClaudeDo Settings"
         Icon="/ClaudeTaskSetup.ico"
         Width="720" Height="520"
@@ -90,16 +91,16 @@
                 </StackPanel>
 
                 <CheckBox Grid.Column="1" IsChecked="{Binding RemoveAppData}"
-                          Content="Remove user data (tasks, logs, configs in ~/.todo-app)"
+                          Content="{loc:Tr installer.settings.removeUserData}"
                           Margin="0,0,12,0" VerticalAlignment="Center"/>
-                <Button Grid.Column="2" Content="Uninstall" Margin="0,0,8,0"
+                <Button Grid.Column="2" Content="{loc:Tr installer.settings.uninstall}" Margin="0,0,8,0"
                         Command="{Binding UninstallCommand}"/>
-                <Button Grid.Column="3" Content="Repair" Margin="0,0,8,0"
+                <Button Grid.Column="3" Content="{loc:Tr installer.settings.repair}" Margin="0,0,8,0"
                         Command="{Binding RepairCommand}"/>
-                <Button Grid.Column="4" Content="Save" Margin="0,0,8,0"
+                <Button Grid.Column="4" Content="{loc:Tr installer.settings.save}" Margin="0,0,8,0"
                         Command="{Binding SaveCommand}"
                         Style="{StaticResource AccentButton}"/>
-                <Button Grid.Column="5" Content="Close"
+                <Button Grid.Column="5" Content="{loc:Tr installer.settings.close}"
                         Command="{Binding CloseCommand}"/>
             </Grid>
         </Border>

src/ClaudeDo.Installer/Views/WizardViewModel.cs

@@ -3,6 +3,7 @@ using System.Windows;
 using ClaudeDo.Installer.Core;
 using ClaudeDo.Installer.Pages.InstallPage;
 using ClaudeDo.Installer.Pages.WelcomePage;
+using ClaudeDo.Localization;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 
@@ -11,8 +12,20 @@ namespace ClaudeDo.Installer.Views;
 public partial class WizardViewModel : ObservableObject
 {
     private readonly InstallContext _context;
+    private readonly ILocalizer _localizer;
 
     public IReadOnlyList<IInstallerPage> Pages { get; }
+    public IReadOnlyList<LanguageOption> Languages { get; }
+
+    [ObservableProperty]
+    private LanguageOption? _selectedLanguage;
+
+    partial void OnSelectedLanguageChanged(LanguageOption? value)
+    {
+        if (value is null) return;
+        _localizer.SetLanguage(value.Value.Code);
+        _context.Language = value.Value.Code;
+    }
 
     [ObservableProperty]
     [NotifyPropertyChangedFor(nameof(CanGoBack))]
@@ -24,14 +37,20 @@ public partial class WizardViewModel : ObservableObject
     public IInstallerPage CurrentPage => Pages[CurrentPageIndex];
     public bool CanGoBack => CurrentPageIndex > 0;
     public bool IsLastPage => CurrentPageIndex == Pages.Count - 1;
-    public string NextButtonText => IsLastPage ? "Install" : "Next \u2192";
+    public string NextButtonText => IsLastPage
+        ? (_localizer["installer.nav.install"])
+        : (_localizer["installer.nav.next"]);
 
     [ObservableProperty]
     private string? _validationError;
 
-    public WizardViewModel(PageResolver resolver, InstallContext context)
+    public WizardViewModel(PageResolver resolver, InstallContext context, ILocalizer localizer)
     {
         _context = context;
+        _localizer = localizer;
+        Languages = localizer.AvailableLanguages;
+        _selectedLanguage = Languages.FirstOrDefault(l => l.Code == localizer.CurrentCode);
+        _context.Language = localizer.CurrentCode;
 
         var all = resolver.WizardPages;
         Pages = context.Mode == InstallerMode.Update

src/ClaudeDo.Installer/Views/WizardWindow.xaml

@@ -2,6 +2,7 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:views="clr-namespace:ClaudeDo.Installer.Views"
+        xmlns:loc="clr-namespace:ClaudeDo.Installer.Localization"
         Title="ClaudeDo Installer"
         Icon="/ClaudeTaskSetup.ico"
         Width="720" Height="520"
@@ -27,40 +28,47 @@
         <Border Grid.Row="0" Background="{StaticResource IslandBgBrush}"
                 BorderBrush="{StaticResource BorderSubtleBrush}" BorderThickness="0,0,0,1"
                 Padding="20,14">
-            <ItemsControl ItemsSource="{Binding Pages}">
+            <DockPanel>
-                <ItemsControl.ItemsPanel>
+                <ComboBox DockPanel.Dock="Right"
-                    <ItemsPanelTemplate>
+                          ItemsSource="{Binding Languages}"
-                        <StackPanel Orientation="Horizontal"/>
+                          SelectedItem="{Binding SelectedLanguage, Mode=TwoWay}"
-                    </ItemsPanelTemplate>
+                          DisplayMemberPath="Name"
-                </ItemsControl.ItemsPanel>
+                          Width="150" HorizontalAlignment="Right" VerticalAlignment="Center"/>
-                <ItemsControl.ItemTemplate>
+                <ItemsControl ItemsSource="{Binding Pages}">
-                    <DataTemplate>
+                    <ItemsControl.ItemsPanel>
-                        <Border x:Name="StepBorder" CornerRadius="4" Padding="10,5" Margin="0,0,6,0"
+                        <ItemsPanelTemplate>
-                                BorderThickness="1">
+                            <StackPanel Orientation="Horizontal"/>
-                            <Border.Background>
+                        </ItemsPanelTemplate>
-                                <MultiBinding Converter="{StaticResource StepActiveConverter}" ConverterParameter="Background">
+                    </ItemsControl.ItemsPanel>
-                                    <Binding/>
+                    <ItemsControl.ItemTemplate>
-                                    <Binding RelativeSource="{RelativeSource AncestorType=Window}" Path="DataContext.CurrentPage"/>
+                        <DataTemplate>
-                                </MultiBinding>
+                            <Border x:Name="StepBorder" CornerRadius="4" Padding="10,5" Margin="0,0,6,0"
-                            </Border.Background>
+                                    BorderThickness="1">
-                            <Border.BorderBrush>
+                                <Border.Background>
-                                <MultiBinding Converter="{StaticResource StepActiveConverter}" ConverterParameter="BorderBrush">
+                                    <MultiBinding Converter="{StaticResource StepActiveConverter}" ConverterParameter="Background">
-                                    <Binding/>
-                                    <Binding RelativeSource="{RelativeSource AncestorType=Window}" Path="DataContext.CurrentPage"/>
-                                </MultiBinding>
-                            </Border.BorderBrush>
-                            <TextBlock Text="{Binding Title}" FontSize="12">
-                                <TextBlock.Foreground>
-                                    <MultiBinding Converter="{StaticResource StepActiveConverter}" ConverterParameter="Foreground">
                                         <Binding/>
                                         <Binding RelativeSource="{RelativeSource AncestorType=Window}" Path="DataContext.CurrentPage"/>
                                     </MultiBinding>
-                                </TextBlock.Foreground>
+                                </Border.Background>
-                            </TextBlock>
+                                <Border.BorderBrush>
-                        </Border>
+                                    <MultiBinding Converter="{StaticResource StepActiveConverter}" ConverterParameter="BorderBrush">
-                    </DataTemplate>
+                                        <Binding/>
-                </ItemsControl.ItemTemplate>
+                                        <Binding RelativeSource="{RelativeSource AncestorType=Window}" Path="DataContext.CurrentPage"/>
-            </ItemsControl>
+                                    </MultiBinding>
+                                </Border.BorderBrush>
+                                <TextBlock Text="{Binding Title}" FontSize="12">
+                                    <TextBlock.Foreground>
+                                        <MultiBinding Converter="{StaticResource StepActiveConverter}" ConverterParameter="Foreground">
+                                            <Binding/>
+                                            <Binding RelativeSource="{RelativeSource AncestorType=Window}" Path="DataContext.CurrentPage"/>
+                                        </MultiBinding>
+                                    </TextBlock.Foreground>
+                                </TextBlock>
+                            </Border>
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>
+            </DockPanel>
         </Border>
 
         <!-- Page Content -->
@@ -85,7 +93,7 @@
                            VerticalAlignment="Center" FontSize="12"
                            Visibility="{Binding ValidationError, Converter={StaticResource NullToCollapsedConverter}}"/>
 
-                <Button Grid.Column="1" Content="Back"
+                <Button Grid.Column="1" Content="{loc:Tr installer.nav.back}"
                         Command="{Binding GoBackCommand}"
                         IsEnabled="{Binding CanGoBack}"
                         Margin="0,0,8,0" MinWidth="80"/>

src/ClaudeDo.Localization/ClaudeDo.Localization.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <InternalsVisibleTo Include="ClaudeDo.Localization.Tests" />
+  </ItemGroup>
+  <Import Project="Locales.targets" />
+</Project>

src/ClaudeDo.Localization/CultureResolver.cs

@@ -0,0 +1,16 @@
+namespace ClaudeDo.Localization;
+
+public static class CultureResolver
+{
+    public static string Resolve(string cultureName, IReadOnlyCollection<string> available, string fallback = "en")
+    {
+        if (string.IsNullOrWhiteSpace(cultureName)) return fallback;
+
+        var exact = available.FirstOrDefault(c => string.Equals(c, cultureName, StringComparison.OrdinalIgnoreCase));
+        if (exact is not null) return exact;
+
+        var primary = cultureName.Split('-')[0];
+        var byPrimary = available.FirstOrDefault(c => string.Equals(c, primary, StringComparison.OrdinalIgnoreCase));
+        return byPrimary ?? fallback;
+    }
+}

src/ClaudeDo.Localization/ILocalizer.cs

@@ -0,0 +1,13 @@
+namespace ClaudeDo.Localization;
+
+public readonly record struct LanguageOption(string Code, string Name);
+
+public interface ILocalizer
+{
+    string this[string key] { get; }
+    string Get(string key, params object[] args);
+    string CurrentCode { get; }
+    IReadOnlyList<LanguageOption> AvailableLanguages { get; }
+    void SetLanguage(string code);
+    event EventHandler? LanguageChanged;
+}

src/ClaudeDo.Localization/LocaleFile.cs

@@ -0,0 +1,15 @@
+namespace ClaudeDo.Localization;
+
+public sealed class LocaleFile
+{
+    public LocaleFile(string code, string name, IReadOnlyDictionary<string, string> strings)
+    {
+        Code = code;
+        Name = name;
+        Strings = strings;
+    }
+
+    public string Code { get; }
+    public string Name { get; }
+    public IReadOnlyDictionary<string, string> Strings { get; }
+}

src/ClaudeDo.Localization/LocaleJson.cs

@@ -0,0 +1,46 @@
+using System.Text.Json;
+
+namespace ClaudeDo.Localization;
+
+public static class LocaleJson
+{
+    public static LocaleFile Parse(string json)
+    {
+        using var doc = JsonDocument.Parse(json);
+        var root = doc.RootElement;
+
+        var code = "";
+        var name = "";
+        if (root.TryGetProperty("metadata", out var meta) && meta.ValueKind == JsonValueKind.Object)
+        {
+            if (meta.TryGetProperty("code", out var c)) code = c.GetString() ?? "";
+            if (meta.TryGetProperty("name", out var n)) name = n.GetString() ?? "";
+        }
+
+        var strings = new Dictionary<string, string>(StringComparer.Ordinal);
+        foreach (var prop in root.EnumerateObject())
+        {
+            if (prop.NameEquals("metadata")) continue;
+            Flatten(prop.Name, prop.Value, strings);
+        }
+
+        return new LocaleFile(code, name, strings);
+    }
+
+    private static void Flatten(string prefix, JsonElement el, IDictionary<string, string> into)
+    {
+        switch (el.ValueKind)
+        {
+            case JsonValueKind.Object:
+                foreach (var p in el.EnumerateObject())
+                    Flatten($"{prefix}.{p.Name}", p.Value, into);
+                break;
+            case JsonValueKind.String:
+                into[prefix] = el.GetString() ?? "";
+                break;
+            default:
+                into[prefix] = el.ToString();
+                break;
+        }
+    }
+}

src/ClaudeDo.Localization/LocaleStore.cs

@@ -0,0 +1,31 @@
+namespace ClaudeDo.Localization;
+
+public sealed class LocaleStore
+{
+    private readonly Dictionary<string, LocaleFile> _byCode;
+
+    private LocaleStore(Dictionary<string, LocaleFile> byCode) => _byCode = byCode;
+
+    public IReadOnlyList<LocaleFile> Available => _byCode.Values.ToList();
+
+    public bool TryGet(string code, out LocaleFile? file) => _byCode.TryGetValue(code, out file);
+
+    public static LocaleStore Load(string folder)
+    {
+        var byCode = new Dictionary<string, LocaleFile>(StringComparer.OrdinalIgnoreCase);
+        if (Directory.Exists(folder))
+        {
+            foreach (var path in Directory.EnumerateFiles(folder, "*.json"))
+            {
+                try
+                {
+                    var file = LocaleJson.Parse(File.ReadAllText(path));
+                    if (!string.IsNullOrWhiteSpace(file.Code))
+                        byCode[file.Code] = file;
+                }
+                catch { /* skip malformed locale files */ }
+            }
+        }
+        return new LocaleStore(byCode);
+    }
+}

src/ClaudeDo.Localization/Locales.targets

@@ -0,0 +1,7 @@
+<Project>
+  <ItemGroup>
+    <Content Include="$(MSBuildThisFileDirectory)locales\*.json"
+             Link="locales\%(Filename)%(Extension)"
+             CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+</Project>

src/ClaudeDo.Localization/Localizer.cs

@@ -0,0 +1,55 @@
+namespace ClaudeDo.Localization;
+
+public sealed class Localizer : ILocalizer
+{
+    private readonly LocaleStore _store;
+    private readonly string _fallbackCode;
+    private LocaleFile? _active;
+    private LocaleFile? _fallback;
+
+    public Localizer(LocaleStore store, string code, string fallbackCode = "en")
+    {
+        _store = store;
+        _fallbackCode = fallbackCode;
+        _store.TryGet(fallbackCode, out _fallback);
+        SetLanguage(code);
+    }
+
+    public string CurrentCode { get; private set; } = "";
+
+    public IReadOnlyList<LanguageOption> AvailableLanguages =>
+        _store.Available.Select(f => new LanguageOption(f.Code, f.Name)).ToList();
+
+    public event EventHandler? LanguageChanged;
+
+    public string this[string key]
+    {
+        get
+        {
+            if (_active is not null && _active.Strings.TryGetValue(key, out var v)) return v;
+            if (_fallback is not null && _fallback.Strings.TryGetValue(key, out var fv)) return fv;
+            return key;
+        }
+    }
+
+    public string Get(string key, params object[] args)
+    {
+        var fmt = this[key];
+        return args.Length == 0 ? fmt : string.Format(fmt, args);
+    }
+
+    public void SetLanguage(string code)
+    {
+        if (_store.TryGet(code, out var f) && f is not null)
+        {
+            _active = f;
+            CurrentCode = f.Code;
+        }
+        else
+        {
+            _active = _fallback;
+            CurrentCode = _fallback?.Code ?? code;
+        }
+        LanguageChanged?.Invoke(this, EventArgs.Empty);
+    }
+}

src/ClaudeDo.Localization/locales/de.json

@@ -0,0 +1,406 @@
+{
+  "metadata": { "code": "de", "name": "Deutsch" },
+  "settings": {
+    "title": "EINSTELLUNGEN",
+    "save": "Speichern",
+    "cancel": "Abbrechen",
+    "language": "Sprache",
+    "tabGeneral": "Allgemein",
+    "tabWorktrees": "Worktrees",
+    "tabFiles": "Dateien",
+    "tabPrime": "Prime Claude",
+    "general": {
+      "defaultInstructions": "Standard-Anweisungen",
+      "defaultInstructionsPlaceholder": "Basis-Anweisungen, die auf jede Aufgabe angewendet werden",
+      "model": "Modell",
+      "maxTurns": "Max. Durchläufe",
+      "permission": "Berechtigung",
+      "maxParallelExecutions": "Max. parallele Ausführungen",
+      "maxParallelExecutionsHint": "Wie viele Aufgaben aus der Warteschlange der Worker gleichzeitig ausführt.",
+      "reportExcludedPaths": "Bericht: ausgeschlossene Pfade (einer pro Zeile)",
+      "standupWeekday": "Standup-Wochentag",
+      "weekdaySunday": "Sonntag",
+      "weekdayMonday": "Montag",
+      "weekdayTuesday": "Dienstag",
+      "weekdayWednesday": "Mittwoch",
+      "weekdayThursday": "Donnerstag",
+      "weekdayFriday": "Freitag",
+      "weekdaySaturday": "Samstag"
+    },
+    "worktrees": {
+      "strategy": "Strategie",
+      "centralWorktreeRoot": "Zentrales Worktree-Verzeichnis",
+      "autoCleanup": "Abgeschlossene Worktrees automatisch aufräumen nach",
+      "days": "Tagen",
+      "cleanupFinished": "Abgeschlossene Worktrees aufräumen",
+      "forceRemoveAll": "Alle Worktrees zwangsweise entfernen",
+      "confirmRemoveAll": "ALLE Worktrees entfernen? Nicht committete Arbeit geht verloren.",
+      "removeAll": "Alle entfernen"
+    },
+    "files": {
+      "agentsSection": "AGENTEN",
+      "agentsHint": "Mitgelieferte Standard-Agenten wiederherstellen. Vorhandene Dateien werden nicht überschrieben.",
+      "restoreDefaultAgents": "Standard-Agenten wiederherstellen",
+      "promptsSection": "PROMPTS",
+      "systemPrompt": "System",
+      "planningPrompt": "Planung (System)",
+      "planningInitialPrompt": "Planungs-Start",
+      "retryPrompt": "Wiederholung",
+      "dailyPrepPrompt": "Tagesplanung",
+      "weeklyReportPrompt": "Wochenbericht",
+      "openInEditor": "Im Editor öffnen"
+    },
+    "prime": {
+      "description": "Bereite dein Claude-Nutzungsfenster vor, indem an den von dir gewählten Tagen zu einer bestimmten Zeit ein einzelner nicht-interaktiver Ping ausgelöst wird. Läuft nur, solange ClaudeDo geöffnet ist. Wenn die App innerhalb von 30 Minuten vor der Zielzeit startet, wird der Ping sofort ausgelöst.",
+      "addSchedule": "+ Zeitplan hinzufügen",
+      "dailyPrepMaxTasks": "Max. Aufgaben pro Tag",
+      "dayMo": "Mo",
+      "dayTu": "Di",
+      "dayWe": "Mi",
+      "dayTh": "Do",
+      "dayFr": "Fr",
+      "daySa": "Sa",
+      "daySu": "So"
+    },
+    "inherit": {
+      "inheritedFromList": "geerbt · Liste",
+      "inheritedFromGlobal": "geerbt · Global",
+      "overrideBadge": "überschrieben",
+      "resetToInherited": "Auf geerbt zurücksetzen"
+    }
+  },
+  "tasks": {
+    "showCompletedTip": "Abgeschlossene anzeigen",
+    "listSettingsTip": "Listeneinstellungen",
+    "addPlaceholder": "Aufgabe hinzufügen…",
+    "enterKey": "ENTER",
+    "notesPinnedRow": "Notizen (Tagesnotizen)",
+    "clearDayTip": "Tag leeren",
+    "planMyDayTip": "Meinen Tag planen",
+    "overdue": "ÜBERFÄLLIG",
+    "tasks": "AUFGABEN",
+    "clearCompletedTip": "Alle abgeschlossenen löschen",
+    "ctxSendToQueue": "In Warteschlange einreihen",
+    "ctxRemoveFromQueue": "Aus Warteschlange entfernen",
+    "ctxCancelExecution": "Ausführung abbrechen",
+    "ctxMarkAs": "Markieren als",
+    "ctxMarkDone": "Erledigt",
+    "ctxMarkCancelled": "Abgebrochen",
+    "ctxRunInteractively": "Interaktiv ausführen",
+    "ctxOpenPlanningSession": "Planungssitzung öffnen",
+    "ctxResumePlanningSession": "Planungssitzung fortsetzen",
+    "ctxDiscardPlanningSession": "Planungssitzung verwerfen",
+    "ctxQueueSubtasks": "Teilaufgaben nacheinander einreihen",
+    "ctxScheduleFor": "Planen für...",
+    "ctxClearSchedule": "Zeitplan entfernen",
+    "badgeDraft": "ENTWURF",
+    "badgePlanned": "GEPLANT",
+    "approve": "Genehmigen",
+    "approveTip": "Genehmigen — als Erledigt markieren",
+    "reject": "Ablehnen",
+    "rejectTip": "Mit Feedback ablehnen und erneut ausführen",
+    "park": "Parken",
+    "parkTip": "Zur manuellen Bearbeitung auf Leerlauf zurücksetzen",
+    "cancel": "Abbrechen",
+    "cancelTip": "Diese Aufgabe abbrechen",
+    "removeFromQueueTip": "Aus Warteschlange entfernen",
+    "scheduleTitle": "Aufgabe planen",
+    "scheduleWhen": "WANN",
+    "scheduleConfirm": "Planen",
+    "rejectRerunTitle": "Ablehnen & erneut ausführen",
+    "reviewTitle": "Review",
+    "feedbackLabel": "FEEDBACK FÜR DEN AGENTEN",
+    "feedbackPlaceholder": "Was soll der Agent korrigieren?",
+    "rerun": "Erneut ausführen"
+  },
+  "lists": {
+    "heading": "Listen",
+    "searchPlaceholder": "Aufgaben suchen…",
+    "searchKbd": "Strg K",
+    "settingsTip": "Einstellungen",
+    "smartListsLabel": "INTELLIGENTE LISTEN",
+    "myListsLabel": "MEINE LISTEN",
+    "contextSettings": "Einstellungen...",
+    "contextWorktrees": "Worktrees…",
+    "contextOpenExplorer": "Im Explorer öffnen",
+    "contextOpenTerminal": "Im Terminal öffnen",
+    "newList": "Neue Liste",
+    "addReposTip": "Repos als Listen hinzufügen"
+  },
+  "details": {
+    "deleteTaskTip": "Aufgabe löschen",
+    "closeTip": "Schließen",
+    "copyTaskIdTip": "Aufgaben-ID kopieren",
+    "starTip": "Favorit",
+    "agentSettingsTip": "Agent-Einstellungen",
+    "agentSettingsHeading": "Agent-Einstellungen (Überschreibungen)",
+    "modelLabel": "Modell",
+    "maxTurnsLabel": "Max. Durchläufe",
+    "systemPromptLabel": "System-Prompt (angehängt)",
+    "systemPromptPrepended": "Wird automatisch vorangestellt:",
+    "agentFileLabel": "Agent-Datei",
+    "mergeLabel": "MERGE",
+    "mergeTargetLabel": "Merge-Ziel",
+    "reviewCombinedDiff": "Kombiniertes Diff prüfen",
+    "mergeAllSubtasks": "Alle Teilaufgaben mergen",
+    "childOutcomesLabel": "VERBESSERUNGEN",
+    "stepsLabel": "SCHRITTE",
+    "addStepPlaceholder": "Schritt hinzufügen...",
+    "detailsLabel": "DETAILS",
+    "copyDescriptionTip": "Beschreibung in die Zwischenablage kopieren",
+    "toggleEditPreviewTip": "Bearbeiten/Vorschau umschalten",
+    "previewBtn": "Vorschau",
+    "editBtn": "Bearbeiten",
+    "descriptionPlaceholder": "Aufgabendetails hinzufügen (Markdown unterstützt)...",
+    "prepTitle": "Tagesvorbereitung",
+    "planDay": "Tag planen",
+    "prepEmpty": "Heute noch keine Vorbereitung — klick Tag planen"
+  },
+  "agent": {
+    "stopTip": "Agent stoppen",
+    "sendToQueue": "In Warteschlange einreihen",
+    "sendToQueueTip": "Diese Aufgabe einreihen, damit der Worker sie übernimmt",
+    "removeFromQueue": "Aus Warteschlange entfernen",
+    "removeFromQueueTip": "Diese Aufgabe wieder aus der Warteschlange nehmen",
+    "worktreeLabel": "WORKTREE",
+    "copyPathTip": "Pfad kopieren",
+    "diffLabel": "DIFF",
+    "openDiff": "Diff öffnen",
+    "worktreeBtn": "Worktree",
+    "openWorktreeTip": "Worktree im Datei-Explorer öffnen",
+    "continue": "Fortsetzen",
+    "continueTip": "Die letzte Sitzung fortsetzen und weitermachen",
+    "resetAndRetry": "Zurücksetzen & erneut versuchen",
+    "resetAndRetryTip": "Den Worktree verwerfen und die Aufgabe erneut einreihen, um von vorn zu beginnen"
+  },
+  "notes": {
+    "today": "Heute",
+    "add": "Hinzufügen",
+    "newNotePlaceholder": "Neue Notiz…",
+    "save": "Speichern",
+    "delete": "Löschen"
+  },
+  "session": {
+    "chipLive": "LIVE",
+    "chipDone": "FERTIG",
+    "chipFailed": "FEHLGESCHLAGEN"
+  },
+  "modals": {
+    "about": {
+      "title": "ÜBER",
+      "version": "Version",
+      "data": "Daten",
+      "logs": "Logs",
+      "config": "Konfiguration",
+      "open": "Öffnen"
+    },
+    "workerConnection": {
+      "title": "WORKER NICHT ERREICHBAR",
+      "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"
+    },
+    "listSettings": {
+      "title": "LISTENEINSTELLUNGEN",
+      "deleteList": "Liste löschen",
+      "sectionGeneral": "ALLGEMEIN",
+      "name": "Name",
+      "workingDirectory": "Arbeitsverzeichnis",
+      "workingDirectoryPlaceholder": "(keines)",
+      "browse": "Durchsuchen...",
+      "defaultCommitType": "Standard-Commit-Typ",
+      "sectionAgent": "AGENT",
+      "resetAgentSettings": "Agent-Einstellungen zurücksetzen",
+      "model": "Modell",
+      "maxTurns": "Max. Durchläufe",
+      "systemPrompt": "System-Prompt (angehängt)",
+      "agentFile": "Agent-Datei"
+    },
+    "merge": {
+      "title": "WORKTREE MERGEN",
+      "windowTitle": "Worktree mergen",
+      "cancel": "Abbrechen",
+      "merge": "Mergen",
+      "targetBranch": "Ziel-Branch",
+      "removeWorktree": "Worktree nach dem Mergen entfernen",
+      "commitMessage": "Commit-Nachricht",
+      "conflictedFiles": "Konfliktdateien:"
+    },
+    "diff": {
+      "title": "DIFF",
+      "windowTitle": "Diff",
+      "merge": "Mergen…"
+    },
+    "worktree": {
+      "title": "Worktree"
+    },
+    "worktreesOverview": {
+      "refresh": "Aktualisieren",
+      "cleanupFinished": "Abgeschlossene aufräumen",
+      "columnTask": "AUFGABE",
+      "columnState": "STATUS",
+      "columnDiff": "DIFF",
+      "columnAge": "ALTER",
+      "phantom": "Phantom",
+      "phantomTooltip": "Verzeichnis fehlt auf der Festplatte",
+      "ctxShowDiff": "Diff anzeigen",
+      "ctxOpenInExplorer": "Im Explorer öffnen",
+      "ctxJumpToTask": "Zur Aufgabe springen",
+      "ctxMerge": "Mergen…",
+      "ctxDiscard": "Verwerfen",
+      "ctxKeep": "Behalten",
+      "ctxCopyBranch": "Branch kopieren",
+      "ctxCopyPath": "Pfad kopieren",
+      "ctxForceRemove": "Zwangsweise entfernen"
+    },
+    "repoImport": {
+      "title": "REPOS ALS LISTEN HINZUFÜGEN",
+      "windowTitle": "Repos als Listen hinzufügen",
+      "cancel": "Abbrechen",
+      "searchPlaceholder": "Repos suchen…",
+      "addFolder": "Ordner hinzufügen…",
+      "forgetFolders": "Ordner vergessen",
+      "alreadyAdded": "(bereits hinzugefügt)"
+    },
+    "unfinishedPlanning": {
+      "title": "UNVOLLENDETE PLANUNGSSITZUNG",
+      "windowTitle": "Unvollendete Planungssitzung",
+      "discard": "Verwerfen",
+      "finalize": "Abschließen",
+      "resume": "Fortsetzen",
+      "draftTasksSuffix": " Entwurfsaufgabe(n) warten auf Abschluss."
+    },
+    "weeklyReport": {
+      "title": "WOCHENBERICHT",
+      "windowTitle": "Wochenbericht",
+      "from": "Von",
+      "to": "Bis",
+      "generate": "Erstellen",
+      "regenerate": "Neu erstellen",
+      "emptyStateHint": "Noch kein Bericht für diesen Zeitraum. Klicke auf „Erstellen“."
+    }
+  },
+  "installer": {
+    "nav": {
+      "back": "Zurück",
+      "next": "Weiter →",
+      "install": "Installieren",
+      "browse": "Durchsuchen...",
+      "cancel": "Abbrechen"
+    },
+    "welcome": {
+      "title": "Willkommen",
+      "heading": "ClaudeDo installieren",
+      "subheading": "Wähle aus, wohin ClaudeDo installiert werden soll, und klicke dann auf Weiter.",
+      "updateSubheading": "Deine Aufgaben, Konfiguration und Datenbank bleiben erhalten. Klicke auf Weiter, um fortzufahren.",
+      "installDirectory": "Installationsverzeichnis",
+      "registerMcp": "MCP-Server bei Claude registrieren",
+      "registerMcpHint": "Führt 'claude mcp add' aus, damit Claude deine ClaudeDo-Aufgaben sehen und verwalten kann. Du kannst dies später ändern."
+    },
+    "paths": {
+      "title": "Datenpfade",
+      "subtitle": "Lege fest, wo ClaudeDo seine Daten speichert.",
+      "databasePath": "Datenbankpfad",
+      "logDirectory": "Log-Verzeichnis",
+      "sandboxRoot": "Sandbox-Verzeichnis",
+      "worktreeStrategy": "Worktree-Strategie",
+      "centralWorktreeRoot": "Zentrales Worktree-Verzeichnis"
+    },
+    "service": {
+      "title": "Worker",
+      "subtitle": "Konfiguriere den ClaudeDo-Hintergrund-Worker.",
+      "signalRPort": "SignalR-Port",
+      "queueBackstopInterval": "Warteschlangen-Backstop-Intervall (ms)",
+      "claudeCliPath": "Claude-CLI-Pfad",
+      "autostart": "Worker bei der Anmeldung automatisch starten",
+      "autostartHint": "Der Worker läuft als du (der angemeldete Benutzer) über eine benutzerbezogene Anmelde-Aufgabe, sodass er deine Claude-CLI-Authentifizierung nutzen kann.",
+      "restartDelay": "Neustart-Verzögerung (ms)"
+    },
+    "uiSettings": {
+      "title": "UI-Einstellungen",
+      "subtitle": "Konfiguriere die Verbindungseinstellungen der ClaudeDo-Desktop-Oberfläche.",
+      "syncWithService": "Mit Worker-Einstellungen synchronisieren",
+      "signalRUrl": "SignalR-URL",
+      "syncHint": "Bei Synchronisierung werden diese Werte aus den Seiten „Worker“ und „Datenpfade“ abgeleitet."
+    },
+    "install": {
+      "title": "Installation",
+      "subtitle": "Klicke auf Installieren, um ClaudeDo zu erstellen und bereitzustellen.",
+      "launch": "ClaudeDo starten"
+    },
+    "settings": {
+      "removeUserData": "Benutzerdaten entfernen (Aufgaben, Logs, Konfigurationen in ~/.todo-app)",
+      "uninstall": "Deinstallieren",
+      "repair": "Reparieren",
+      "save": "Speichern",
+      "close": "Schließen"
+    },
+    "selfUpdate": {
+      "heading": "Ein neuerer Installer ist verfügbar",
+      "update": "Aktualisieren",
+      "continueAnyway": "Trotzdem fortfahren"
+    }
+  },
+  "planning": {
+    "conflict": {
+      "windowTitle": "Merge-Konflikt",
+      "modalTitle": "MERGE-KONFLIKT",
+      "openInVsCode": "Alle in VS Code öffnen",
+      "resolved": "Ich habe gelöst — fortfahren",
+      "abort": "Diesen Merge abbrechen"
+    },
+    "diff": {
+      "windowTitle": "Planung — Kombiniertes Diff",
+      "modalTitle": "PLANUNG — KOMBINIERTES DIFF",
+      "previewCombined": "Kombinierte Vorschau",
+      "loading": "Wird geladen…"
+    }
+  },
+  "controls": {
+    "datePicker": {
+      "today": "Heute",
+      "tomorrow": "Morgen",
+      "nextMon": "Nächster Mo",
+      "clear": "Löschen",
+      "time": "Zeit",
+      "done": "Fertig"
+    }
+  },
+  "shell": {
+    "menu": {
+      "help": "Hilfe",
+      "checkForUpdates": "Nach Updates suchen",
+      "restartWorker": "Worker neu starten",
+      "worktrees": "Worktrees…",
+      "weeklyReport": "Wochenbericht…",
+      "about": "Über…",
+      "addRepos": "Repos als Listen hinzufügen…"
+    },
+    "update": {
+      "available": "Update verfügbar: v",
+      "updateNow": "Jetzt aktualisieren",
+      "dismiss": "Ausblenden"
+    }
+  },
+  "vm": {
+    "connection": { "online": "Online", "connecting": "Verbinden…", "offline": "Offline" },
+    "shell": { "restartingWorker": "Worker wird neu gestartet…" },
+    "agentStatus": { "idle": "Leerlauf", "queued": "In Warteschlange", "running": "Läuft", "review": "Prüfung", "children": "Wartet auf Verbesserungen", "done": "Fertig", "failed": "Fehlgeschlagen", "cancelled": "Abgebrochen" },
+    "taskStatus": { "idle": "Leerlauf", "queued": "In Warteschlange", "running": "Läuft", "waitingForReview": "Wartet auf Prüfung", "waitingForChildren": "Wartet auf Verbesserungen", "done": "Fertig", "failed": "Fehlgeschlagen", "cancelled": "Abgebrochen" },
+    "planningBadge": { "active": "PLANUNG", "finalized": "GEPLANT" },
+    "taskRow": { "createdPrefix": "Erstellt {0}", "stepsText": "{0}/{1} Schritte" },
+    "tasksIsland": { "completedHeader": "ABGESCHLOSSEN", "completedHeaderCount": "ABGESCHLOSSEN · {0}" },
+    "diff": { "loadFailed": "Diff konnte nicht geladen werden: {0}", "noChanges": "Keine Änderungen anzuzeigen." },
+    "planningDiff": { "hubError": "Kombinierte Vorschau konnte nicht erstellt werden (Hub-Fehler).", "conflict": "Kombinierte Vorschau nicht möglich: Teilaufgabe {0} steht im Konflikt mit einer früheren Teilaufgabe ({1} Dateien)." },
+    "merge": { "commitMessage": "Merge-Aufgabe: {0}", "workerOfflineBranches": "Worker offline — Branches können nicht aufgelistet werden.", "loadBranchesFailed": "Branches konnten nicht geladen werden: {0}", "merged": "Zusammengeführt.", "conflict": "Merge-Konflikt — Ziel-Branch wiederhergestellt. Manuell oder über Fortsetzen lösen, dann erneut versuchen.", "blocked": "Blockiert: {0}", "unknownStatus": "Unbekannter Status: {0}", "mergeFailed": "Merge fehlgeschlagen: {0}" },
+    "conflictResolution": { "vsCodeError": "VS Code konnte nicht gestartet werden: {0}. Die Pfade sind oben aufgeführt — kopiere sie manuell.", "subtaskPrefix": "Konflikte in Teilaufgabe: {0}", "targetPrefix": "Zusammenführen in: {0}" },
+    "settingsModal": { "workerOffline": "Worker offline — Einstellungen schreibgeschützt.", "saveFailed": "Speichern fehlgeschlagen: {0}" },
+    "weeklyReport": { "invalidRange": "Ungültiger Datumsbereich.", "generating": "Bericht wird erstellt…", "error": "Fehler: {0}" },
+    "filesTab": { "workerOffline": "Worker offline.", "noneBundled": "Keine Standard-Agenten mitgeliefert.", "allPresent": "Alle Standard-Agenten bereits vorhanden.", "restored": "{0} Standard-Agent(en) wiederhergestellt.", "restoreFailed": "Wiederherstellung fehlgeschlagen: {0}", "openFailed": "Öffnen 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." },
+    "worktreesOverview": { "titleAll": "Worktrees", "titleList": "Worktrees — {0}", "listFallback": "Liste", "cleanupFailed": "Aufräumen fehlgeschlagen.", "removed": "{0} Worktree(s) entfernt.", "discardFailed": "Worktree konnte nicht verworfen werden.", "keepFailed": "Worktree konnte nicht behalten werden.", "cannotForceRunning": "Eine laufende Aufgabe kann nicht zwangsweise entfernt werden.", "forceRemoveFailed": "Zwangsentfernung fehlgeschlagen." },
+    "listSettings": { "untitled": "Unbenannt" },
+    "lists": { "localSuffix": "{0} / lokal", "smartMyDay": "Mein Tag", "smartImportant": "Wichtig", "smartPlanned": "Geplant", "virtualQueue": "Warteschlange", "virtualRunning": "Läuft", "virtualReview": "Prüfung", "newList": "Neue Liste" }
+  }
+}

src/ClaudeDo.Localization/locales/en.json

@@ -0,0 +1,406 @@
+{
+  "metadata": { "code": "en", "name": "English" },
+  "settings": {
+    "title": "SETTINGS",
+    "save": "Save",
+    "cancel": "Cancel",
+    "language": "Language",
+    "tabGeneral": "General",
+    "tabWorktrees": "Worktrees",
+    "tabFiles": "Files",
+    "tabPrime": "Prime Claude",
+    "general": {
+      "defaultInstructions": "Default instructions",
+      "defaultInstructionsPlaceholder": "Baseline instructions applied to every task",
+      "model": "Model",
+      "maxTurns": "Max turns",
+      "permission": "Permission",
+      "maxParallelExecutions": "Max parallel executions",
+      "maxParallelExecutionsHint": "How many queued tasks the worker runs at once.",
+      "reportExcludedPaths": "Report: excluded paths (one per line)",
+      "standupWeekday": "Standup weekday",
+      "weekdaySunday": "Sunday",
+      "weekdayMonday": "Monday",
+      "weekdayTuesday": "Tuesday",
+      "weekdayWednesday": "Wednesday",
+      "weekdayThursday": "Thursday",
+      "weekdayFriday": "Friday",
+      "weekdaySaturday": "Saturday"
+    },
+    "worktrees": {
+      "strategy": "Strategy",
+      "centralWorktreeRoot": "Central worktree root",
+      "autoCleanup": "Auto-cleanup finished worktrees after",
+      "days": "days",
+      "cleanupFinished": "Cleanup finished worktrees",
+      "forceRemoveAll": "Force-remove all worktrees",
+      "confirmRemoveAll": "Remove ALL worktrees? Uncommitted work will be lost.",
+      "removeAll": "Remove All"
+    },
+    "files": {
+      "agentsSection": "AGENTS",
+      "agentsHint": "Restore bundled default agents. Existing files are not overwritten.",
+      "restoreDefaultAgents": "Restore default agents",
+      "promptsSection": "PROMPTS",
+      "systemPrompt": "System",
+      "planningPrompt": "Planning (system)",
+      "planningInitialPrompt": "Planning kickoff",
+      "retryPrompt": "Retry",
+      "dailyPrepPrompt": "Daily prep",
+      "weeklyReportPrompt": "Weekly report",
+      "openInEditor": "Open in editor"
+    },
+    "prime": {
+      "description": "Prime your Claude usage window by firing a single non-interactive ping on the days you choose, at a chosen time. Only runs while ClaudeDo is open. If the app starts within 30 minutes of the target time, the ping fires immediately.",
+      "addSchedule": "+ Add schedule",
+      "dailyPrepMaxTasks": "Max tasks per day",
+      "dayMo": "Mo",
+      "dayTu": "Tu",
+      "dayWe": "We",
+      "dayTh": "Th",
+      "dayFr": "Fr",
+      "daySa": "Sa",
+      "daySu": "Su"
+    },
+    "inherit": {
+      "inheritedFromList": "inherited · List",
+      "inheritedFromGlobal": "inherited · Global",
+      "overrideBadge": "override",
+      "resetToInherited": "Reset to inherited"
+    }
+  },
+  "tasks": {
+    "showCompletedTip": "Show completed",
+    "listSettingsTip": "List settings",
+    "addPlaceholder": "Add a task…",
+    "enterKey": "ENTER",
+    "notesPinnedRow": "Notes (daily notes)",
+    "clearDayTip": "Clear day",
+    "planMyDayTip": "Plan My Day",
+    "overdue": "OVERDUE",
+    "tasks": "TASKS",
+    "clearCompletedTip": "Clear all completed",
+    "ctxSendToQueue": "Send to queue",
+    "ctxRemoveFromQueue": "Remove from queue",
+    "ctxCancelExecution": "Cancel execution",
+    "ctxMarkAs": "Mark as",
+    "ctxMarkDone": "Done",
+    "ctxMarkCancelled": "Cancelled",
+    "ctxRunInteractively": "Run interactively",
+    "ctxOpenPlanningSession": "Open planning Session",
+    "ctxResumePlanningSession": "Resume planning Session",
+    "ctxDiscardPlanningSession": "Discard planning session",
+    "ctxQueueSubtasks": "Queue subtasks sequentially",
+    "ctxScheduleFor": "Schedule for...",
+    "ctxClearSchedule": "Clear schedule",
+    "badgeDraft": "DRAFT",
+    "badgePlanned": "PLANNED",
+    "approve": "Approve",
+    "approveTip": "Approve — mark Done",
+    "reject": "Reject",
+    "rejectTip": "Reject with feedback and re-run",
+    "park": "Park",
+    "parkTip": "Send back to Idle for manual editing",
+    "cancel": "Cancel",
+    "cancelTip": "Cancel this task",
+    "removeFromQueueTip": "Remove from queue",
+    "scheduleTitle": "Schedule task",
+    "scheduleWhen": "WHEN",
+    "scheduleConfirm": "Schedule",
+    "rejectRerunTitle": "Reject & re-run",
+    "reviewTitle": "Review",
+    "feedbackLabel": "FEEDBACK FOR THE AGENT",
+    "feedbackPlaceholder": "What should the agent fix?",
+    "rerun": "Re-run"
+  },
+  "lists": {
+    "heading": "Lists",
+    "searchPlaceholder": "Search tasks…",
+    "searchKbd": "Ctrl K",
+    "settingsTip": "Settings",
+    "smartListsLabel": "SMART LISTS",
+    "myListsLabel": "MY LISTS",
+    "contextSettings": "Settings...",
+    "contextWorktrees": "Worktrees…",
+    "contextOpenExplorer": "Open in Explorer",
+    "contextOpenTerminal": "Open in Terminal",
+    "newList": "New list",
+    "addReposTip": "Add repos as lists"
+  },
+  "details": {
+    "deleteTaskTip": "Delete task",
+    "closeTip": "Close",
+    "copyTaskIdTip": "Copy task ID",
+    "starTip": "Star",
+    "agentSettingsTip": "Agent settings",
+    "agentSettingsHeading": "Agent settings (overrides)",
+    "modelLabel": "Model",
+    "maxTurnsLabel": "Max turns",
+    "systemPromptLabel": "System prompt (appended)",
+    "systemPromptPrepended": "Prepended automatically:",
+    "agentFileLabel": "Agent file",
+    "mergeLabel": "MERGE",
+    "mergeTargetLabel": "Merge target",
+    "reviewCombinedDiff": "Review combined diff",
+    "mergeAllSubtasks": "Merge all subtasks",
+    "childOutcomesLabel": "IMPROVEMENTS",
+    "stepsLabel": "STEPS",
+    "addStepPlaceholder": "Add a step...",
+    "detailsLabel": "DETAILS",
+    "copyDescriptionTip": "Copy description to clipboard",
+    "toggleEditPreviewTip": "Toggle edit/preview",
+    "previewBtn": "Preview",
+    "editBtn": "Edit",
+    "descriptionPlaceholder": "Add task details (markdown supported)...",
+    "prepTitle": "Daily prep",
+    "planDay": "Plan day",
+    "prepEmpty": "No prep run today yet — click Plan day"
+  },
+  "agent": {
+    "stopTip": "Stop agent",
+    "sendToQueue": "Send to queue",
+    "sendToQueueTip": "Queue this task for the worker to pick up",
+    "removeFromQueue": "Remove from queue",
+    "removeFromQueueTip": "Take this task back out of the queue",
+    "worktreeLabel": "WORKTREE",
+    "copyPathTip": "Copy path",
+    "diffLabel": "DIFF",
+    "openDiff": "Open diff",
+    "worktreeBtn": "Worktree",
+    "openWorktreeTip": "Open worktree in file explorer",
+    "continue": "Continue",
+    "continueTip": "Resume the last session and keep going",
+    "resetAndRetry": "Reset & retry",
+    "resetAndRetryTip": "Discard the worktree and re-queue the task to run from scratch"
+  },
+  "notes": {
+    "today": "Today",
+    "add": "Add",
+    "newNotePlaceholder": "New note…",
+    "save": "Save",
+    "delete": "Delete"
+  },
+  "session": {
+    "chipLive": "LIVE",
+    "chipDone": "DONE",
+    "chipFailed": "FAILED"
+  },
+  "modals": {
+    "about": {
+      "title": "ABOUT",
+      "version": "Version",
+      "data": "Data",
+      "logs": "Logs",
+      "config": "Config",
+      "open": "Open"
+    },
+    "workerConnection": {
+      "title": "WORKER NOT REACHABLE",
+      "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"
+    },
+    "listSettings": {
+      "title": "LIST SETTINGS",
+      "deleteList": "Delete list",
+      "sectionGeneral": "GENERAL",
+      "name": "Name",
+      "workingDirectory": "Working directory",
+      "workingDirectoryPlaceholder": "(none)",
+      "browse": "Browse...",
+      "defaultCommitType": "Default commit type",
+      "sectionAgent": "AGENT",
+      "resetAgentSettings": "Reset agent settings",
+      "model": "Model",
+      "maxTurns": "Max turns",
+      "systemPrompt": "System prompt (appended)",
+      "agentFile": "Agent file"
+    },
+    "merge": {
+      "title": "MERGE WORKTREE",
+      "windowTitle": "Merge worktree",
+      "cancel": "Cancel",
+      "merge": "Merge",
+      "targetBranch": "Target branch",
+      "removeWorktree": "Remove worktree after merge",
+      "commitMessage": "Commit message",
+      "conflictedFiles": "Conflicted files:"
+    },
+    "diff": {
+      "title": "DIFF",
+      "windowTitle": "Diff",
+      "merge": "Merge…"
+    },
+    "worktree": {
+      "title": "Worktree"
+    },
+    "worktreesOverview": {
+      "refresh": "Refresh",
+      "cleanupFinished": "Cleanup finished",
+      "columnTask": "TASK",
+      "columnState": "STATE",
+      "columnDiff": "DIFF",
+      "columnAge": "AGE",
+      "phantom": "phantom",
+      "phantomTooltip": "Directory missing on disk",
+      "ctxShowDiff": "Show diff",
+      "ctxOpenInExplorer": "Open in Explorer",
+      "ctxJumpToTask": "Jump to task",
+      "ctxMerge": "Merge…",
+      "ctxDiscard": "Discard",
+      "ctxKeep": "Keep",
+      "ctxCopyBranch": "Copy branch",
+      "ctxCopyPath": "Copy path",
+      "ctxForceRemove": "Force remove"
+    },
+    "repoImport": {
+      "title": "ADD REPOS AS LISTS",
+      "windowTitle": "Add repos as lists",
+      "cancel": "Cancel",
+      "searchPlaceholder": "Search repos…",
+      "addFolder": "Add folder…",
+      "forgetFolders": "Forget folders",
+      "alreadyAdded": "(already added)"
+    },
+    "unfinishedPlanning": {
+      "title": "UNFINISHED PLANNING SESSION",
+      "windowTitle": "Unfinished planning session",
+      "discard": "Discard",
+      "finalize": "Finalize",
+      "resume": "Resume",
+      "draftTasksSuffix": " draft task(s) waiting to be finalized."
+    },
+    "weeklyReport": {
+      "title": "WEEKLY REPORT",
+      "windowTitle": "Weekly Report",
+      "from": "From",
+      "to": "To",
+      "generate": "Generate",
+      "regenerate": "Regenerate",
+      "emptyStateHint": "No report for this range yet. Click “Generate”."
+    }
+  },
+  "installer": {
+    "nav": {
+      "back": "Back",
+      "next": "Next →",
+      "install": "Install",
+      "browse": "Browse...",
+      "cancel": "Cancel"
+    },
+    "welcome": {
+      "title": "Welcome",
+      "heading": "Install ClaudeDo",
+      "subheading": "Choose where to install ClaudeDo, then click Next.",
+      "updateSubheading": "Your tasks, config, and database will be preserved. Click Next to continue.",
+      "installDirectory": "Install Directory",
+      "registerMcp": "Register MCP server with Claude",
+      "registerMcpHint": "Runs 'claude mcp add' so Claude can view and manage your ClaudeDo tasks. You can change this later."
+    },
+    "paths": {
+      "title": "Data Paths",
+      "subtitle": "Configure where ClaudeDo stores its data.",
+      "databasePath": "Database Path",
+      "logDirectory": "Log Directory",
+      "sandboxRoot": "Sandbox Root",
+      "worktreeStrategy": "Worktree Strategy",
+      "centralWorktreeRoot": "Central Worktree Root"
+    },
+    "service": {
+      "title": "Worker",
+      "subtitle": "Configure the ClaudeDo background worker.",
+      "signalRPort": "SignalR Port",
+      "queueBackstopInterval": "Queue Backstop Interval (ms)",
+      "claudeCliPath": "Claude CLI Path",
+      "autostart": "Start worker automatically at logon",
+      "autostartHint": "The worker runs as you (the logged-in user) via a per-user logon task, so it can use your Claude CLI authentication.",
+      "restartDelay": "Restart Delay (ms)"
+    },
+    "uiSettings": {
+      "title": "UI Settings",
+      "subtitle": "Configure the ClaudeDo desktop UI connection settings.",
+      "syncWithService": "Sync with service settings",
+      "signalRUrl": "SignalR URL",
+      "syncHint": "When synced, these values are derived from the Service and Paths pages."
+    },
+    "install": {
+      "title": "Installation",
+      "subtitle": "Click Install to build and deploy ClaudeDo.",
+      "launch": "Launch ClaudeDo"
+    },
+    "settings": {
+      "removeUserData": "Remove user data (tasks, logs, configs in ~/.todo-app)",
+      "uninstall": "Uninstall",
+      "repair": "Repair",
+      "save": "Save",
+      "close": "Close"
+    },
+    "selfUpdate": {
+      "heading": "A newer installer is available",
+      "update": "Update",
+      "continueAnyway": "Continue anyway"
+    }
+  },
+  "planning": {
+    "conflict": {
+      "windowTitle": "Merge conflict",
+      "modalTitle": "MERGE CONFLICT",
+      "openInVsCode": "Open all in VS Code",
+      "resolved": "I've resolved — continue",
+      "abort": "Abort this merge"
+    },
+    "diff": {
+      "windowTitle": "Planning — Combined diff",
+      "modalTitle": "PLANNING — COMBINED DIFF",
+      "previewCombined": "Preview combined",
+      "loading": "Loading…"
+    }
+  },
+  "controls": {
+    "datePicker": {
+      "today": "Today",
+      "tomorrow": "Tomorrow",
+      "nextMon": "Next Mon",
+      "clear": "Clear",
+      "time": "Time",
+      "done": "Done"
+    }
+  },
+  "shell": {
+    "menu": {
+      "help": "Help",
+      "checkForUpdates": "Check for updates",
+      "restartWorker": "Restart worker",
+      "worktrees": "Worktrees…",
+      "weeklyReport": "Weekly Report…",
+      "about": "About…",
+      "addRepos": "Add repos as lists…"
+    },
+    "update": {
+      "available": "Update available: v",
+      "updateNow": "Update now",
+      "dismiss": "Dismiss"
+    }
+  },
+  "vm": {
+    "connection": { "online": "Online", "connecting": "Connecting…", "offline": "Offline" },
+    "shell": { "restartingWorker": "Restarting worker…" },
+    "agentStatus": { "idle": "Idle", "queued": "Queued", "running": "Running", "review": "Review", "children": "Waiting for Improvements", "done": "Done", "failed": "Failed", "cancelled": "Cancelled" },
+    "taskStatus": { "idle": "Idle", "queued": "Queued", "running": "Running", "waitingForReview": "Waiting for Review", "waitingForChildren": "Waiting for Improvements", "done": "Done", "failed": "Failed", "cancelled": "Cancelled" },
+    "planningBadge": { "active": "PLANNING", "finalized": "PLANNED" },
+    "taskRow": { "createdPrefix": "Created {0}", "stepsText": "{0}/{1} steps" },
+    "tasksIsland": { "completedHeader": "COMPLETED", "completedHeaderCount": "COMPLETED · {0}" },
+    "diff": { "loadFailed": "Failed to load diff: {0}", "noChanges": "No changes to show." },
+    "planningDiff": { "hubError": "Could not build combined preview (hub error).", "conflict": "Cannot build combined preview: subtask {0} conflicts with an earlier subtask ({1} files)." },
+    "merge": { "commitMessage": "Merge task: {0}", "workerOfflineBranches": "Worker offline — cannot list branches.", "loadBranchesFailed": "Failed to load branches: {0}", "merged": "Merged.", "conflict": "Merge conflict — target branch restored. Resolve manually or via Continue, then retry.", "blocked": "Blocked: {0}", "unknownStatus": "Unknown status: {0}", "mergeFailed": "Merge failed: {0}" },
+    "conflictResolution": { "vsCodeError": "Could not launch VS Code: {0}. Paths are listed above — copy them manually.", "subtaskPrefix": "Conflicts in subtask: {0}", "targetPrefix": "Merging into: {0}" },
+    "settingsModal": { "workerOffline": "Worker offline — settings read-only.", "saveFailed": "Save failed: {0}" },
+    "weeklyReport": { "invalidRange": "Invalid date range.", "generating": "Generating report…", "error": "Error: {0}" },
+    "filesTab": { "workerOffline": "Worker offline.", "noneBundled": "No default agents bundled.", "allPresent": "All default agents already present.", "restored": "Restored {0} default agent(s).", "restoreFailed": "Restore failed: {0}", "openFailed": "Open 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)." },
+    "worktreesOverview": { "titleAll": "Worktrees", "titleList": "Worktrees — {0}", "listFallback": "list", "cleanupFailed": "Cleanup failed.", "removed": "Removed {0} worktree(s).", "discardFailed": "Failed to discard worktree.", "keepFailed": "Failed to keep worktree.", "cannotForceRunning": "Cannot force-remove a running task.", "forceRemoveFailed": "Force remove failed." },
+    "listSettings": { "untitled": "Untitled" },
+    "lists": { "localSuffix": "{0} / local", "smartMyDay": "My Day", "smartImportant": "Important", "smartPlanned": "Planned", "virtualQueue": "Queue", "virtualRunning": "Running", "virtualReview": "Review", "newList": "New list" }
+  }
+}

src/ClaudeDo.Logging/BuildConfig.cs

@@ -0,0 +1,14 @@
+using System.Diagnostics;
+using System.Reflection;
+
+namespace ClaudeDo.Logging;
+
+/// <summary>Runtime build-configuration detection — the replacement for #if DEBUG.
+/// Debug builds compile with the JIT optimizer disabled; Release builds enable it.</summary>
+public static class BuildConfig
+{
+    public static bool IsDebug { get; } =
+        Assembly.GetEntryAssembly()
+            ?.GetCustomAttribute<DebuggableAttribute>()
+            ?.IsJITOptimizerDisabled ?? false;
+}

src/ClaudeDo.Logging/ClaudeDo.Logging.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Serilog" Version="4.1.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="ClaudeDo.Worker.Tests" />
+  </ItemGroup>
+
+</Project>

src/ClaudeDo.Logging/DefaultTaskIdEnricher.cs

@@ -0,0 +1,15 @@
+using Serilog.Core;
+using Serilog.Events;
+
+namespace ClaudeDo.Logging;
+
+/// <summary>Ensures every log event carries a TaskId property (defaulting to "-")
+/// so the output template's [{TaskId}] column never renders the raw token.</summary>
+public sealed class DefaultTaskIdEnricher : ILogEventEnricher
+{
+    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
+    {
+        if (!logEvent.Properties.ContainsKey("TaskId"))
+            logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty("TaskId", "-"));
+    }
+}

src/ClaudeDo.Logging/LoggingSetup.cs

@@ -0,0 +1,44 @@
+using Serilog;
+using Serilog.Events;
+
+namespace ClaudeDo.Logging;
+
+public static class LoggingSetup
+{
+    private const string OutputTemplate =
+        "[{Timestamp:HH:mm:ss.fff} {Level:u3}] {Process}/{SourceContext} [{TaskId}] {Message:lj}{NewLine}{Exception}";
+
+    public static LoggerConfiguration Configure(LoggerConfiguration cfg, string processTag, string logRoot)
+    {
+        Directory.CreateDirectory(logRoot);
+        var logFile = Path.Combine(logRoot, "claudedo-.log");
+
+        cfg.Enrich.FromLogContext()
+           .Enrich.WithProperty("Process", processTag)
+           .Enrich.With(new DefaultTaskIdEnricher());
+
+        if (BuildConfig.IsDebug)
+        {
+            cfg.MinimumLevel.Debug()
+               .WriteTo.Console(outputTemplate: OutputTemplate)
+               .WriteTo.File(
+                   logFile,
+                   rollingInterval: RollingInterval.Day,
+                   retainedFileCountLimit: 2,
+                   shared: true,
+                   outputTemplate: OutputTemplate);
+        }
+        else
+        {
+            cfg.MinimumLevel.Warning()
+               .WriteTo.File(
+                   logFile,
+                   rollingInterval: RollingInterval.Day,
+                   retainedFileCountLimit: 2,
+                   shared: true,
+                   outputTemplate: OutputTemplate);
+        }
+
+        return cfg;
+    }
+}

src/ClaudeDo.Ui/AppSettings.cs

@@ -7,6 +7,7 @@ public sealed class AppSettings
 {
     public string DbPath { get; set; } = "~/.todo-app/todo.db";
     public string SignalRUrl { get; set; } = "http://127.0.0.1:47821/hub";
+    public string Language { get; set; } = "";
 
     private static readonly string ConfigPath = Paths.Expand("~/.todo-app/ui.config.json");
 
@@ -27,4 +28,12 @@ public sealed class AppSettings
         }
         return new();
     }
+
+    public void Save()
+    {
+        var dir = Path.GetDirectoryName(ConfigPath);
+        if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
+        var json = JsonSerializer.Serialize(this, new JsonSerializerOptions { WriteIndented = true });
+        File.WriteAllText(ConfigPath, json);
+    }
 }

src/ClaudeDo.Ui/CLAUDE.md

@@ -17,9 +17,14 @@ MVVM with CommunityToolkit.Mvvm source generators:
 - **TaskEditorView** — Modal dialog for task create/edit
 - **ListEditorView** — Modal dialog for list create/edit
 - **StatusBarView** — Connection status indicator, active task display
-- **ListSettingsModalView** — edits list name, working dir, default commit type, and per-list Model/SystemPrompt/AgentPath; also deletes the list (and its tasks) via a confirmed "Delete list" button. Opened via context menu or gear button on a list row.
+- **ListSettingsModalView** — edits list name, working dir, default commit type, and per-list Model/SystemPrompt/AgentPath/MaxTurns, each showing the inherited (global) value with a source-aware "inherited · Global / override" badge and a reset-to-inherited button; also deletes the list (and its tasks) via a confirmed "Delete list" button. Opened via context menu or gear button on a list row.
 - **RepoImportModalView** — bulk-creates lists from git repos discovered under chosen parent folders. Opened via the folder button beside "New list" in the Lists island, or the "Add repos as lists…" Help-menu item. Repos already wired to a list show as disabled/"(already added)".
-- **DetailsIslandView** — contains an "Agent settings (overrides)" expander with per-task Model/SystemPrompt/AgentPath, showing inherited effective values. Disabled while task is running.
+- **DetailsIslandView** — contains an "Agent settings (overrides)" expander with per-task Model/MaxTurns/AgentPath (override semantics, each showing the resolved inherited value as a placeholder plus a source-aware "inherited · List / inherited · Global / override" badge and reset button via the reusable `InheritedBadge` control + `InheritanceResolver`) and a SystemPrompt text box (additive — shows the inherited prompt as a "prepended automatically" note). Disabled while task is running. When notes mode is active (`IsNotesMode`), it hosts **NotesEditorView** instead of the task detail. When prep mode is active (`IsPrepMode`), it hosts the daily-prep panel (Plan day button, empty-state hint, embedded **SessionTerminalView**). The task header, metadata footer (delete/close), and **AgentStripView** are gated on `IsTaskDetailVisible` — they are hidden in both notes and prep mode.
+- **WeeklyReportModalView** — opened from Help menu ("Wochenbericht…"); date-range pickers default to "since last standup weekday → today"; Generate/Regenerate button; renders markdown via MarkdownView; reports are cached per range.
+- **NotesEditorView** — day navigator (prev/next/date-picker/Today), bullet add/edit/delete for daily notes.
+- **SessionTerminalView** — reusable log terminal; exposes StyledProperties `Entries`, `Label`, `IsRunning`, `IsDone`, `IsFailed`. Used for both the task `Log` and the prep `PrepLog`.
+- **SettingsModalView** — Prime Claude tab contains a `DailyPrepMaxTasks` numeric editor.
+- **TasksIslandView** (MyDay header) — icon buttons visible only when `IsMyDayList`: broom icon = `ClearDayCommand`, stroked-sun icon ("Plan My Day") = `ShowPrepLogCommand`.
 
 All views use compiled bindings (`x:DataType`).
 
@@ -31,10 +36,15 @@ All views use compiled bindings (`x:DataType`).
 - **TaskItemViewModel** / **ListItemViewModel** — lightweight display VMs
 - **TaskEditorViewModel** / **ListEditorViewModel** — dialog VMs with validation
 - **StatusBarViewModel** — connection state and active tasks
+- **WeeklyReportModalViewModel** — drives the weekly report modal
+- **NotesEditorViewModel** — manages daily note bullet CRUD for the selected day
+- **DetailsIslandViewModel** gains `IsNotesMode`, `ShowNotes()`, and hosts `NotesEditorViewModel`. Also gains daily-prep mode: `IsPrepMode`, `PrepLog` (`ObservableCollection<LogLineViewModel>`), `ShowPrep()`, `PlanDayCommand` (calls `RunDailyPrepNowAsync`), `ShowPrepEmptyState`, and computed `IsTaskDetailVisible` (= `!IsNotesMode && !IsPrepMode`). Subscribes to `PrepStartedEvent`, `PrepLineEvent`, `PrepFinishedEvent`; streams lines into `PrepLog` via `StreamLineFormatter` (same path as task logs). On open, if log is empty and no run is in progress, loads persisted last run via `GetLastPrepLogAsync`.
+- **TasksIslandViewModel** gains a pinned "Notes" pseudo-row (`ShowNotesRow`, `OpenNotesCommand`, `NotesRequested` event) that switches the Details island to notes mode. Also gains `IsMyDayList` (true when selected list is `smart:my-day`), `ShowPrepLogCommand` (raises `PrepRequested` event → shell calls `Details.ShowPrep()`), and `ClearDayCommand` (calls `ClearMyDayAsync`).
 
 ## Services
 
-- **WorkerClient** — SignalR client connecting to `http://127.0.0.1:47821/hub`. Auto-reconnect with exponential backoff. Methods: StartAsync, RunNowAsync, CancelTaskAsync, WakeQueueAsync, ContinueTaskAsync, ResetTaskAsync, GetAgentsAsync, UpdateAppSettingsAsync, UpdateListAsync, UpdateListConfigAsync, GetListConfigAsync, UpdateTaskAgentSettingsAsync. Events: TaskStarted, TaskFinished, TaskMessage, TaskUpdated, WorktreeUpdated, ListUpdated
+- **WorkerClient** / **IWorkerClient** — SignalR client connecting to `http://127.0.0.1:47821/hub`. Auto-reconnect with exponential backoff. Methods: StartAsync, RunNowAsync, CancelTaskAsync, WakeQueueAsync, ContinueTaskAsync, ResetTaskAsync, GetAgentsAsync, UpdateAppSettingsAsync, UpdateListAsync, UpdateListConfigAsync, GetListConfigAsync, UpdateTaskAgentSettingsAsync, `GetWeekReportAsync`, `GenerateWeekReportAsync`, `GetDailyNotesAsync`, `AddDailyNoteAsync`, `UpdateDailyNoteAsync`, `DeleteDailyNoteAsync`, `RunDailyPrepNowAsync`, `ClearMyDayAsync`, `GetLastPrepLogAsync`. Events: TaskStarted, TaskFinished, TaskMessage, TaskUpdated, WorktreeUpdated, ListUpdated, `PrepStartedEvent`, `PrepLineEvent`, `PrepFinishedEvent`
+- **INotesApi** / **WorkerNotesApi** — thin wrapper over the daily-note WorkerClient methods (mirrors `IPrimeScheduleApi`). UI DTO: `DailyNoteDto(Id, Date, Text, SortOrder)`.
 
 ## Converters
 
@@ -50,3 +60,4 @@ Editor dialogs use `TaskCompletionSource<bool>` — the dialog sets the result o
 - Context menus are on both list items and task items
 - Right-click selects the item before showing the context menu
 - "Run Now" CanExecute re-evaluates when worker connection state changes
+- Icon gotcha: `PathIcon` fills geometry. Line-art/stroke icons must be defined as filled geometry or rendered as a stroked `Path` (e.g. `Icon.PlanDay` via the `Path.plan-icon` style); a pure stroke path used with `PathIcon` is invisible.

src/ClaudeDo.Ui/ClaudeDo.Ui.csproj

@@ -2,6 +2,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\ClaudeDo.Data\ClaudeDo.Data.csproj" />
+    <ProjectReference Include="..\ClaudeDo.Localization\ClaudeDo.Localization.csproj" />
     <ProjectReference Include="..\ClaudeDo.Releases\ClaudeDo.Releases.csproj" />
   </ItemGroup>
 
@@ -10,7 +11,9 @@
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.1" />
     <PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="8.0.11" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.2" />
     <PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />
+    <PackageReference Include="Serilog" Version="4.1.0" />
   </ItemGroup>
 
   <ItemGroup>

src/ClaudeDo.Ui/Converters/StatusColorConverter.cs

@@ -17,6 +17,7 @@ public class StatusColorConverter : IValueConverter
             "running" => Brushes.Orange,
             "waitingforreview" => Brushes.MediumPurple,
             "waiting_for_review" => Brushes.MediumPurple,
+            "waitingforchildren" => Brushes.DarkOrange,
             "done" => Brushes.Green,
             "failed" => Brushes.Red,
             "manual" => Brushes.Gray,

src/ClaudeDo.Ui/Design/IslandStyles.axaml

@@ -70,8 +70,11 @@
     <!-- Icon.Trash -->
     <StreamGeometry x:Key="Icon.Trash">M4 7h16M10 11v6M14 11v6M5 7l1 13a1 1 0 0 0 1 1h10a1 1 0 0 0 1-1l1-13M9 7V4h6v3</StreamGeometry>
 
-    <!-- Icon.Sort -->
+    <!-- Icon.Broom (filled: handle + binding band + flared bristles) -->
-    <StreamGeometry x:Key="Icon.Sort">M7 4v16M7 20l-3-3M7 4l-3 3M14 8h7M14 12h5M14 16h3</StreamGeometry>
+    <StreamGeometry x:Key="Icon.Broom">M11 3 H13 V10 H11 Z M8.5 10 H15.5 V12 H8.5 Z M9 12 H15 L17 21 H7 Z</StreamGeometry>
+
+    <!-- Icon.PlanDay (stroke-rendered via Path.plan-icon — sun over horizon) -->
+    <StreamGeometry x:Key="Icon.PlanDay">M3,20 L21,20 M8.4,11 a3.6,3.6 0 1,0 7.2,0 a3.6,3.6 0 1,0 -7.2,0 M12,4.5 L12,3 M6,11 L4.5,11 M18,11 L19.5,11 M7.5,6.5 L6.4,5.4 M16.5,6.5 L17.6,5.4</StreamGeometry>
 
     <!-- Icon.X -->
     <StreamGeometry x:Key="Icon.X">M6 6l12 12M18 6L6 18</StreamGeometry>
@@ -82,6 +85,12 @@
     <!-- Icon.ArrowOut — filled arrow for "open external" button -->
     <StreamGeometry x:Key="Icon.ArrowOut">M13 4 H20 V11 H18 V7.4 L11.4 14 L10 12.6 L16.6 6 H13 Z M4 6 H10 V8 H6 V18 H16 V14 H18 V20 H4 Z</StreamGeometry>
 
+    <!-- Icon.Warning — filled triangle with exclamation (roadblock badge) -->
+    <StreamGeometry x:Key="Icon.Warning">F0 M12 3 L22 20 H2 Z M11 9 H13 V14 H11 Z M11 16 H13 V18 H11 Z</StreamGeometry>
+
+    <!-- Icon.AgentSuggested — filled diamond (agent-suggested child badge) -->
+    <StreamGeometry x:Key="Icon.AgentSuggested">M12 3 L20 12 L12 21 L4 12 Z</StreamGeometry>
+
     <!-- Icon.Settings (gear) -->
     <StreamGeometry x:Key="Icon.Settings">M12 8a4 4 0 1 0 0 8 4 4 0 0 0 0-8z M19.43 12.98c.04-.32.07-.64.07-.98s-.03-.66-.07-.98l2.11-1.65a.5.5 0 0 0 .12-.64l-2-3.46a.5.5 0 0 0-.61-.22l-2.49 1a7.03 7.03 0 0 0-1.69-.98l-.38-2.65a.5.5 0 0 0-.5-.42h-4a.5.5 0 0 0-.5.42l-.38 2.65c-.61.25-1.17.59-1.69.98l-2.49-1a.5.5 0 0 0-.61.22l-2 3.46a.5.5 0 0 0 .12.64l2.11 1.65c-.04.32-.07.65-.07.98s.03.66.07.98l-2.11 1.65a.5.5 0 0 0-.12.64l2 3.46a.5.5 0 0 0 .61.22l2.49-1c.52.4 1.08.73 1.69.98l.38 2.65a.5.5 0 0 0 .5.42h4a.5.5 0 0 0 .5-.42l.38-2.65c.61-.25 1.17-.59 1.69-.98l2.49 1a.5.5 0 0 0 .61-.22l2-3.46a.5.5 0 0 0-.12-.64l-2.11-1.65z</StreamGeometry>
 
@@ -168,6 +177,14 @@
     <Setter Property="Foreground" Value="{StaticResource StatusReviewBrush}" />
   </Style>
 
+  <Style Selector="Border.chip.children">
+    <Setter Property="Background"  Value="#332A1A" />
+    <Setter Property="BorderBrush" Value="#4D3A1A" />
+  </Style>
+  <Style Selector="Border.chip.children > TextBlock">
+    <Setter Property="Foreground" Value="#E0A030" />
+  </Style>
+
   <Style Selector="Border.chip.error">
     <Setter Property="Background"  Value="{StaticResource ErrorTintBrush}" />
     <Setter Property="BorderBrush" Value="{StaticResource ErrorTintBorderBrush}" />
@@ -244,6 +261,17 @@
     <Setter Property="TextElement.Foreground" Value="{StaticResource TextBrush}" />
   </Style>
 
+  <!-- Stroke-rendered icon (for line-art geometries that PathIcon would fill away) -->
+  <Style Selector="Button.icon-btn Path.plan-icon">
+    <Setter Property="Stroke"          Value="{StaticResource TextBrush}" />
+    <Setter Property="StrokeThickness" Value="1.7" />
+    <Setter Property="StrokeLineCap"   Value="Round" />
+    <Setter Property="StrokeJoin"      Value="Round" />
+  </Style>
+  <Style Selector="Button.icon-btn:pointerover Path.plan-icon">
+    <Setter Property="Stroke" Value="{StaticResource AccentBrush}" />
+  </Style>
+
   <!-- ============================================================ -->
   <!-- INPUTS                                                       -->
   <!-- ============================================================ -->
@@ -371,6 +399,10 @@
     <Setter Property="Background"  Value="{StaticResource ReviewTintBrush}" />
     <Setter Property="BorderBrush" Value="{StaticResource ReviewTintBorderBrush}" />
   </Style>
+  <Style Selector="Border.agent-strip.children">
+    <Setter Property="Background"  Value="#332A1A" />
+    <Setter Property="BorderBrush" Value="#4D3A1A" />
+  </Style>
   <Style Selector="Border.agent-strip.error">
     <Setter Property="Background"  Value="{StaticResource ErrorTintBrush}" />
     <Setter Property="BorderBrush" Value="{StaticResource ErrorTintBorderBrush}" />

src/ClaudeDo.Ui/Localization/Loc.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using ClaudeDo.Localization;
+
+namespace ClaudeDo.Ui.Localization;
+
+/// Ambient access to the active localizer for code-built (ViewModel) strings.
+/// Set once at startup. Defaults to a key-echo localizer so unit tests that
+/// construct ViewModels without startup wiring do not crash.
+public static class Loc
+{
+    private static ILocalizer _current = new KeyEchoLocalizer();
+
+    public static ILocalizer Current
+    {
+        get => _current;
+        set
+        {
+            if (_current is not null) _current.LanguageChanged -= OnInnerChanged;
+            _current = value;
+            _current.LanguageChanged += OnInnerChanged;
+            OnInnerChanged(value, EventArgs.Empty);
+        }
+    }
+
+    public static event EventHandler? LanguageChanged;
+
+    private static void OnInnerChanged(object? sender, EventArgs e) =>
+        LanguageChanged?.Invoke(sender, e);
+
+    public static string T(string key) => Current[key];
+    public static string T(string key, params object[] args) => Current.Get(key, args);
+
+    private sealed class KeyEchoLocalizer : ILocalizer
+    {
+        public string this[string key] => key;
+        public string Get(string key, params object[] args) => key;
+        public string CurrentCode => "en";
+        public IReadOnlyList<LanguageOption> AvailableLanguages => Array.Empty<LanguageOption>();
+        public void SetLanguage(string code) { }
+        public event EventHandler? LanguageChanged { add { } remove { } }
+    }
+}

src/ClaudeDo.Ui/Localization/LocalizedString.cs

@@ -0,0 +1,22 @@
+using System.ComponentModel;
+using ClaudeDo.Localization;
+
+namespace ClaudeDo.Ui.Localization;
+
+public sealed class LocalizedString : INotifyPropertyChanged
+{
+    private readonly ILocalizer _localizer;
+    private readonly string _key;
+
+    public LocalizedString(ILocalizer localizer, string key)
+    {
+        _localizer = localizer;
+        _key = key;
+        _localizer.LanguageChanged += (_, _) =>
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
+    }
+
+    public string Value => _localizer[_key];
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+}

src/ClaudeDo.Ui/Localization/TrExtension.cs

@@ -0,0 +1,25 @@
+using Avalonia.Data;
+using Avalonia.Markup.Xaml;
+using ClaudeDo.Localization;
+
+namespace ClaudeDo.Ui.Localization;
+
+public sealed class TrExtension : MarkupExtension
+{
+    public TrExtension() { }
+    public TrExtension(string key) => Key = key;
+
+    public string Key { get; set; } = "";
+
+    public static ILocalizer? Localizer { get; set; }
+
+    public override object ProvideValue(IServiceProvider serviceProvider)
+    {
+        var loc = Localizer ?? throw new InvalidOperationException("TrExtension.Localizer not initialized");
+        return new Binding(nameof(LocalizedString.Value))
+        {
+            Source = new LocalizedString(loc, Key),
+            Mode = BindingMode.OneWay
+        };
+    }
+}