fix: Interactive sessions no longer Instantly start working

ClaudeDo-Task: d2ae3831-733f-4d40-93d7-70c93da11590

CHANGELOG.md

@@ -1,5 +1,342 @@
 # Changelog
 
+## v2.16.0 — 2026-09-16
+
+### Features
+
+- dirty Ziel-Verzeichnis beim Oeffnen des Merge-Dialogs melden statt nach dem Fehlschlag (09bcd696)
+- preview_merge_set flags removed symbols and locale-key overlaps (684b0115)
+- Bilder aus der Zwischenablage ins interaktive Terminal einfuegen (56161e4e)
+- poll the OAuth usage endpoint as fast as its measured rate limit allows (50b6b56f)
+
+### Fixes
+
+- duplizierter Confirm-Dialog mit "Delete"-Knopf – zusammenfuehren und lokalisieren (86cc309b)
+- Worktrees-Uebersicht zeigt Task-Nummern, DIFF-Spalte trimmt statt abzuschneiden (1325ab94)
+- Diff-Viewer scrollt jetzt auch horizontal synchron (4ff5383b)
+- Ordner-Toggle in der Sidebar schluckt schnelle Klicks (5cdfb14f)
+- preview_merge braucht einen runVerify-Parameter wie preview_merge_set (7452f6cf)
+- depends_on-Nachfolger schon beim gelandeten Merge freigeben (c874bf7e)
+- Worker-Neustart trifft nun den tatsaechlich laufenden Prozess (9a41bed0)
+- Shutdown terminates the app even with secondary windows open (103eb9a6)
+
+### Documentation
+
+- update for v2.16.0 (31dfaffc)
+- update for v2.15.0 (18394dd6)
+
+## v2.15.0 — 2026-09-11
+
+### Features
+
+- Stash-Option fuer uncommittete Aenderungen im Ziel-Tree (251b70ce)
+
+### Documentation
+
+- update for v2.14.0 (8e2d37e6)
+
+## v2.14.0 — 2026-09-10
+
+### Features
+
+- Listen und Ordner in einer gemischten Sidebar-Reihenfolge (bfb1c652)
+- confirm before closing a running ConPTY session (eb623714)
+- worker-menu Shutdown ends worker + app after confirm (1bdf2027)
+- chain a normal parent's children on WaitingForChildren (d2648f96)
+- localize WorkConsole, DescriptionStepsCard and the ROADBLOCK label (8e6f0d16)
+- surface depends_on blocking in status chip, chain label, and detail pane (4cf601e4)
+- Worker-Menü "Update Claude CLI" führt claude update aus (dbee4a0d)
+- triage model picker (opus/fable) in the merge helper start modal (1177463a)
+- collapsible folders for the list sidebar (25c9a619)
+- list_folders table plus lists.folder_id (13e860f0)
+
+### Fixes
+
+- Import broadcastet TaskUpdated fuer neue Tasks (1770b677)
+- ConnectedClientTracker in den externen MCP-Container teilen (3d09323e)
+- de.json-Konsistenz-Pass und restliche harte EN-Strings (d6696c33)
+- force English git output for locale-fragile stderr matches (5ecf6f75)
+- make diff-stat parsing locale-safe and dedupe the two parsers (29ea18c4)
+- report failed paste/drop in the interactive terminal (0cec0a77)
+- surface worker connect/restart failures instead of no-opting (b4b62254)
+- validate PowerUse window, explain effort and Prime Claude in Settings (951c2fe9)
+- start_list_handler ehrlich machen, wenn keine App verbunden ist (451c0184)
+- warn and block save when a list's working dir isn't a git repo (3348736e)
+- show a banner when a ConPTY session dies after startup (256bea5f)
+- merge duplicate top-level "checks" block in en/de.json (741f66fe)
+- translate max_turns failure text to English (0fcfe7c5)
+- route WeekReportService permission-mode through PermissionModeResolver (1c768529)
+- report startup port conflicts instead of crashing silently (c9d4823f)
+
+### Documentation
+
+- record list folders in the Data and Ui CLAUDE.md (5477ae53)
+- update for v2.13.6 (ec1e60be)
+
+## v2.13.6 — 2026-09-07
+
+### Features
+
+- Home-Ordner als Sitzungsziel in Mission Control (f231f08a)
+- Einfuegen und Datei-Drop im interaktiven Terminal (23491d3b)
+- Cheat-Sheet-Fenster im Hilfe-Menue (0db9fade)
+- PowerUse-Einstellungen nach Settings -> Ausfuehrung verschieben (7c7c33d6)
+
+### Documentation
+
+- update for v2.13.5 (c7392e08)
+
+## v2.13.5 — 2026-09-03
+
+### Fixes
+
+- Version im About-Dialog aus der FileVersion lesen (cccfe2ec)
+
+### Refactoring
+
+- "Nach Updates suchen" ins Hilfe-Menue verschieben (c16c7b97)
+
+### Documentation
+
+- update for v2.13.4 (a8ec5507)
+
+## v2.13.4 — 2026-09-03
+
+### Fixes
+
+- interaktive Session ohne Arbeitsverzeichnis im User-Verzeichnis starten (f70503d0)
+
+### Documentation
+
+- update for v2.13.3 (9360cd2f)
+
+## v2.13.3 — 2026-09-03
+
+### Fixes
+
+- raise SignalR MaximumParallelInvocationsPerClient (e64d5705)
+
+### Documentation
+
+- update for v2.13.2 (fc25ee45)
+
+## v2.13.2 — 2026-09-03
+
+### Features
+
+- Handler-Run per Knopf abbrechen (bd5aa265)
+
+### Fixes
+
+- strip CLAUDE_CODE_CHILD_SESSION/CLAUDECODE before every ConPTY launch (51ee5050)
+- Dequeue-X auf blockierten Queue-Zeilen anzeigen und Kette konsistent halten (df3e7ba0)
+- report and gate ListSettingsModal load failures instead of swallowing them (a1b20d9f)
+- move ScrollViewer padding to inner content in modal bodies (e0c6b670)
+- Mission Control oeffnen, wenn ein Handler-Run per MCP startet oder ein Handoff eintrifft (b05b6fba)
+
+### Performance
+
+- show list settings modal before its seven-round-trip load finishes (f24654df)
+
+### Documentation
+
+- remove stale session-skills empty-state entry (2bd48ea1)
+- update for v2.13.1 (eb3aee41)
+- update for v2.13.0 (2b873322)
+
+## v2.13.1 — 2026-09-02
+
+### Fixes
+
+- Mission Control oeffnen, wenn ein Handler-Run per MCP startet oder ein Handoff eintrifft (9f64ba50)
+
+## v2.13.0 — 2026-09-02
+
+### Features
+
+- Handler-Session vor dem Usage-Limit warnen und Handoff bis zum Reset zurueckhalten (fe818651)
+- start_list_handler MCP-Tool startet einen List-Handler-Run wie der Button (c2166a0d)
+- Handler-Session nach Usage-Limit-Reset automatisch neu starten (016b9203)
+- PowerUse-Zeitfenster + Handoff-Schwellwert als Settings (69898be5)
+- PowerUse-Toggle im Usage-Monitor, Opt-in pro Liste (19375254)
+- PowerUse-Addendum an die Handler-Prompts, Cap aus den Settings (453d61ca)
+- PowerUse-Flags und konfigurierbares Handoff-Budget (3cf9628f)
+- depends_on als Menge statt Einzelfeld (c25732cf)
+- surface the handoff round budget in the merge-helper handoff brief (81a5fc5d)
+- add ExpectsNoDiff flag for verification/audit tasks (0b506f52)
+- add dependency audit and diff-review threshold to list-handler prompts (9e805646)
+- add "move to list" to the task row context menu (80fe188a)
+- notes get their own list, a day log and an Enter chain (0f04b796)
+- add_note MCP tool with a per-day agent cap (ae0c7d37)
+
+### Fixes
+
+- carry ExpectsNoDiff into the relocated merge MCP tools (4ee1d05f)
+- stop Ui.Tests order-dependent flakiness on shared Loc.Current (dc1e67d0)
+- add failureReason field to batch_get_tasks (91220177)
+- make locale-parity test able to detect a malformed locale file (4c78a5d6)
+- don't leave an orphaned list behind on cancel (56bc1651)
+- stop treating git worktrees and submodules as repos (b6e5876b)
+- fix Bandel ticket sync and reactivate the integration (30d0611b)
+- Shift+Enter in the capture box, not just in the note rows (f6405804)
+- let Shift+Enter break the line, and clear the leftovers around the editor (b90c5855)
+- auto-bootstrap commit-less repos before creating worktrees (e0748ba3)
+- bootstrap commit-less repos and survive missing git identity (de44196b)
+
+### Performance
+
+- switch to workstation GC to cut idle memory (c347e4fc)
+
+### Refactoring
+
+- share StubWorkerClient between Ui.Tests and Worker.Tests (9f90e75a)
+- remove the stale-worker banner (6be62f02)
+
+### Documentation
+
+- Handler-Prompt praezisieren (Wave-Plan, Task-Split, review_task-Aufruf) (20b3b4ce)
+- Test-Scoping fuer Implementer-Tasks, PowerUse in den Explore-Notes (416997d7)
+- plan for multi-dependency depends_on relation table (84d955df)
+- empty-repo hardening notes + verification item (cf093e31)
+- spec + plan for empty-repo (unborn HEAD) hardening (fea8236e)
+- update for v2.12.0 (1d6cd49b)
+
+## v2.12.0 — 2026-08-28
+
+### Features
+
+- wählbares Listen-Icon und aufgeräumter Task-Detail-Header (c31f79d3)
+- Mission Control als Session-Hub (22e70ffc)
+
+### Fixes
+
+- make re-approve after revert_merge do a real merge, not a silent no-op (8d597df4)
+- survive a worker restart when cancelling a mid-merge unit-merge parent (1affb397)
+
+### Documentation
+
+- update for v2.11.0 (bbdb0223)
+
+## v2.11.0 — 2026-08-27
+
+### Features
+
+- Listeneinstellungen mit Kategorie-Sidebar (4e55f916)
+- Ticketsystem-Anbindung hinter einen Aus-Schalter legen (8329c925)
+- Ticket-Projekt pro Liste und Import ueber das Kontextmenue (e91ade9c)
+- Settings-Tab fuer die Ticketsystem-Anbindung (020f93d5)
+- Ticket-Settings, Projektliste und Import ueber den Hub (f0a3a186)
+- Ticket-Import pro Liste (2e236736)
+- Ticket-Status-Rueckmeldung ueber TaskStateService (5aafeb6c)
+- BandelTicketClient fuer die Ticketsystem-REST-API (10652780)
+- TicketSystemConfig + ticket_api_base_url in worker.config.json (2a3c937f)
+- ticket_ref auf tasks, ticket_project_id auf list_config (3171690b)
+- claude_bin im Dateien-Tab setzbar, mit Auflösungs-Check (13b81cac)
+- Throttle-Stufen im Ausfuehrung-Tab sichtbar machen (31d53b00)
+- Permission-Modus pro Liste und pro Task ueberschreibbar (4464dc6f)
+- Listen-Einstellungen — Checkbox fuer serialize_on_file_overlap (5cc99bfe)
+- Review-Merge-Button — Claude nimmt Waiting-for-Review pro Liste ab (741c7ac5)
+- verify once per batch via skipVerify + verify_merges (168ab1cd)
+- run both MCP servers stateless (69fcceb2)
+- add the Prime action radio group to settings (f3cb34b9)
+- add the action kind to the settings viewmodels (57be4961)
+- add Prime action-kind strings in en and de (514f142a)
+- carry the action kind through the hub and validate custom prompts (4e8e0334)
+- branch PrimeRunner on the schedule action kind (cf6a6b62)
+- migrate prime_schedules with action_kind defaulting to ping (71d2972a)
+- add PrimeActionKind to the schedule entity (022eaf38)
+- open the TokenTracker dashboard from the usage monitor (3003cfa5)
+- show cost columns and the TokenTracker hint card in the usage monitor (074c0e4d)
+- surface TokenTracker status and cost in the usage monitor (bac0d69a)
+- add TokenTracker analytics strings in en and de (66f743dd)
+- add TokenTracker status, refresh and install to the worker client (3c3bb306)
+- serve model and task usage from the TokenTracker export (44337d4b)
+- cache the TokenTracker export with single-flight refresh (3f3638c1)
+- run the TokenTracker CLI through the shared executable resolver (a9218045)
+- pin the TokenTracker CLI invocations (d6b22ea5)
+- hold the last good TokenTracker export fail-open (580d4e07)
+- aggregate TokenTracker sessions by model and per task (2fca0cc4)
+- parse the TokenTracker sessions export defensively (106f9a37)
+- add TokenTracker export models and test fixture (16952b64)
+- reproduce TokenTracker session_hash for task attribution (1cb574bd)
+- Improve App Prompts (79438c00)
+- Toggle "Continue on session limit reset" für Usage-Limit-Abbrüche (07dd7570)
+- confirm main-window close when Mission Control sessions are open (0892883a)
+- "Worktree öffnen" im Kontextmenü der Task-Zeile (ac9b0dab)
+- update_task kann isManual setzen + List-Handler stellt seinen Task auf Review (ea2271cc)
+- Usage-Monitor zeigt Reset-Uhrzeit hinter der Restzeit (8f983851)
+- Erststart-Banner und Textkette Repo→Task→Queue→Review (UX-Struktur C) (111dd0fb)
+- Settings-Modal auf Sidebar-Kategorien umbauen (56c3719e)
+- Task-Zeile entdichten und Kontextmenü gruppieren (UX-Struktur A) (51dc7bd6)
+- surface startup recovery via OperationProgress channel (6ec81f65)
+- report worktree-creation phase on OperationProgress (eba0d842)
+- surface rebase and worktree-maintenance progress on OperationProgress (42de97e1)
+- Empty States für Detail-Pane und Task-Liste (UX-Audit #4) (9159f1b5)
+
+### Fixes
+
+- Base-URL ohne Schema laesst die Ticket-Anbindung scheitern (3322152b)
+- Import-Erfolgsmeldung nicht mehr als Fehler einfaerben (2fe2ac83)
+- MergeHelperSelectionModal — Task-Nummer anzeigen, Titel wrappen, Status-Spalte verbreitern (24e1d648)
+- Branch-Zeile im Detail-Header — Icon stroked rendern, ohne Task ausblenden (18755910)
+- Review-Merge-Button-Icon stroked rendern statt gefuellt — Linien waren unsichtbar (d7a3aa80)
+- block delete on interactive-session tasks, clear ghost selection (c1ab042d)
+- store ScheduledFor as real UTC instead of mislabeled local time (f70aec49)
+- make modify/delete and rename/delete merge conflicts visible instead of silently staging them (533a287e)
+- close status-force bypasses on Running tasks (299c7b74)
+- allow the done toggle from any non-Running status (f80af122)
+- restore the Settings modal body and tidy the Prime schedule row (d71c0cea)
+- close the typographic quote that made de.json unparseable (9ab17d82)
+- failureReason "usage_limit" nachziehen + Worktree-Gate prüft die Platte (29171b10)
+- Usage-Limit-Auto-Continue verbrennt nicht mehr alle Kandidaten außer dem ersten (3dfae30f)
+- thread handler task id into list-handler kickoff prompts (9c4a63d2)
+- UsagePillViewModel loads snapshot on connection restore (7f94bf4a)
+- Description-Editbox nutzt volle Kartenhoehe statt 320px-Deckel (a6d165a1)
+- route done-toggle and dequeue through guarded TaskStateService transitions (7f337b36)
+- Reactivität — Description-Save-Race, UsageMonitor-Leak, Listen-Live-Refresh (52efe3ec)
+- notify IsTasksEmptyRepoHintVisible on every list switch (b997af44)
+- Aktions- und Bestätigungs-Konsistenz (UX-Audit #3) (2935eef7)
+- surface precondition hints for silently-disabled review buttons (UX-Audit #2) (dbb73bae)
+- silent no-ops raise ErrorReported instead of swallowing failures (UX-Audit #1) (99bb5be5)
+- propagate unit-merge failures instead of reporting success (f2058430)
+- Stuck-Running-Fenster in Continue- und Stop-Pfad schließen (389c9126)
+
+### Refactoring
+
+- Datei-Scope-Serialisierung entfernen (84219a9f)
+- OnlineTokenStore zu DpapiTokenStore verallgemeinert (41bfc242)
+- Icon-Faerbung zentral im ICON-PAINTING-Block (1ef67760)
+- drop the remaining single-implementation interfaces (0f007c53)
+- merge the one-expression converters into SimpleConverters.cs (c593be2f)
+- declare the SignalR wire DTOs once in ClaudeDo.Data (8930b564)
+- squash the 40 migrations into one InitialCreate (39d82413)
+- collapse single-implementation interfaces (296251e2)
+- delete unreachable members and redundant package refs (81994aad)
+- drop the transcript aggregation path in favour of TokenTracker (40879705)
+- dedupe path-open helper across five view models (b2a1b790)
+- derive TaskRowViewModel CanX/DisabledReason pairs from one gate method (baba9216)
+- unify list-linked-repo predicate into RepoLinkage (9578c950)
+- dedupe FormatRemaining between UsagePill and UsageMonitorModal (e164f1e3)
+
+### Documentation
+
+- Ticketsystem-Anbindung als pausiert vermerken (cb69e2a7)
+- Ticketsystem-Anbindung in den CLAUDE.md-Dateien (fb1ceac1)
+- IsConfigured-Kosten praezise beschreiben (e9dfea90)
+- Implementierungsplan, Base-URL in worker.config.json (5a13ad44)
+- Design fuer die Ticketsystem-Anbindung (63184ea3)
+- neue Config-Felder + Migration-Fixture-Falle in den CLAUDE.md-Dateien (d474fd13)
+- bump review-merge verified-against to 168ab1cd (187f5fc5)
+- document the schedule action kinds (a1d74ab4)
+- implementation plan for schedule action kinds (2dec590d)
+- add the TokenTracker analytics implementation plan (884b990e)
+- document TokenTracker as the analytics backend (c0bf7db6)
+- spec per-schedule action kind (Ping/FillMyDay/Custom) (a873eaa9)
+- spec for TokenTracker as the token-analytics backend (0e74650d)
+- C5 periodische Dienste abgesagt — kein Mehrwert über bestehende Broadcasts (29868962)
+- design and plan for the four structural UX themes (4cf08f81)
+- update for v2.10.0 (925ba655)
+
 ## v2.10.0 — 2026-08-17
 
 ### Features

CLAUDE.md

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

README.md

@@ -374,7 +374,7 @@ updates`.
 
 ## Where your data lives
 
-Everything is under `%USERPROFILE%\.todo-app`:
+Everything is under `%USERPROFILE%\.claudeDo`:
 
 | Path | What |
 |---|---|

docs/explore-notes/conpty-sessions.md

@@ -33,7 +33,7 @@ Two independent reasons:
    `--abort`) is then misread as an unknown option.
 2. A raw multi-line positional prompt truncates at its **first newline** regardless.
 
-A fresh task session's brief lives at `~/.todo-app/task-sessions/<taskId>/brief.md`
+A fresh task session's brief lives at `~/.claudeDo/task-sessions/<taskId>/brief.md`
 (`InteractiveLaunchSpecService.BuildFreshTaskArgsAsync`). A task with neither title nor
 description skips the file **and** the positional arg entirely — it still gets `--session-id`.
 
@@ -97,6 +97,48 @@ Net effect: reopening an interactive session for a task (pane closed, process ki
 resumes the same claude conversation, because the id was committed to the DB before the previous
 launch even started.
 
+## Session handoff (`handoff_session`)
+
+Task and ad-hoc tiles can hand off to a fresh session in the same tile. The **paneId is the pane's
+`IdentityKey`**: the task id for a task tile, a GUID minted by `OpenAdHocConPtySessionAsync` for an
+ad-hoc one.
+
+**The model never passes an id** (it guesses GUIDs). Instead, every such spec gets
+`--mcp-config ~/.claudeDo/pane-sessions/<paneId>/mcp.json`, which adds a second entry,
+`claudedo_pane`. It points at the same external MCP, with headers `X-ClaudeDo-Pane` and
+`X-ClaudeDo-Session` (plus `X-ClaudeDo-Key` when one is configured). An `AddListToolsFilter`
+(`SessionHandoffMcpTools.FilterByPane`) splits the tool list by that header:
+- `claudedo_pane` lists only `handoff_session`;
+- the plain `claudedo` entry lists everything except `handoff_session`.
+
+The hint (`handoff-hint.md`, via `--append-system-prompt-file`) says when to call
+`mcp__claudedo_pane__handoff_session(brief)` and what goes into the brief, and contains no ids. Ad-hoc
+tiles get a pre-assigned `--session-id` so the header has one. With `ExternalMcpPort = 0` the tile
+gets neither the entry nor the hint.
+
+`handoff_session(brief)` writes `pane-sessions/<paneId>/handoffs/<guid>/brief.md` (first line:
+`Handed off from session <id>`) and broadcasts `SessionHandoffRequested(paneId, briefPath)`. The
+worker has no pane registry: the UI looks up the pane by `IdentityKey`, takes its `Cwd` (from the
+resolved launch spec) and its `TaskId`, and closes it. It then reopens the tile at the same slot
+with the same `IdentityKey` via `GetSessionHandoffLaunchSpec` → `BuildHandoffAsync`. For a task
+tile, the new session id replaces `InteractiveSessionId`, so reopening the task resumes the
+handed-off session. The old transcript remains under `~/.claude/projects/`.
+
+## Recent sessions
+
+Every task, ad-hoc and handoff tile launch (only those — `paneId != null`) records its session in
+`mission_control_sessions` from inside `InteractiveLaunchSpecService`, which is where the session id
+is known. A handoff's predecessor comes from the brief's first line
+(`SessionHandoffMcpTools.ReadHandedOffFrom`), and it inherits the predecessor's title and task.
+The clock button in the Mission Control header opens a flyout (`RefreshRecentSessionsAsync`, last 14
+days / 50 rows, read straight from the DB). `NestHandoffs` groups each chain under its origin.
+- **Resume**: a task's *current* `InteractiveSessionId` reopens the task tile (deduped by TaskId).
+  Any other session gets a fresh ad-hoc tile via `GetResumeSessionLaunchSpec` → `BuildResumeAsync`
+  (`--resume <id>` in the recorded cwd, handoff hint included).
+- **Brief**: `ShellOpen.Path(brief.md)`, which opens the file in the default editor.
+- Not guarded: resuming a session that is still live in another ad-hoc tile, since panes don't
+  track their session id.
+
 ## List handler ("Let Claude handle it")
 
 `BuildForMergeHelperAsync`/`BuildForMergeHelperHandoffAsync` resolve `--permission-mode` via
@@ -115,6 +157,22 @@ share the same prompt/model as their non-final counterpart and differ only in on
 rendered into the handoff kickoff file (`PromptKind.MergeHelperHandoff`) marking the final round
 and forbidding further reruns.
 
+The chain length is bounded server-side by `HandoffRoundTracker`, whose cap comes from
+`AppSettingsEntity.ListHandlerMaxHandoffs` (default 4 = two merge rounds; `HandoffMcpTools` reads it
+per call and `Register` clamps to min 1, so 0 can never mean "unbounded"). Past the cap a
+`wait`/`merge` request is silently coerced to its `_final` counterpart — check the result's
+`coerced` flag — and any handoff after a `merge_final` round throws.
+
+**PowerUse.** When `AppSettingsEntity.PowerUseEnabled` (Settings → Execution) **and** the
+list's own `ListConfigEntity.PowerUseAllowed` are both set, `InteractiveLaunchSpecService.
+ComposeHandlerPromptAsync` appends `PromptKind.PowerUseAddendum` to whichever handler prompt the
+phase resolved to. The addendum is written as an *override* of the base prompt's interactive rules
+(never ask, decide and record instead; resolve or abort conflicts rather than leaving them in the
+tree; harvest new tasks when a round would starve). Both keys are required on purpose: the global
+switch can stay on overnight without turning an unrelated list's handler run unattended. A run that
+is not in PowerUse gets a byte-identical prompt to the pre-PowerUse behaviour — there is deliberately
+no second set of handler prompts to keep in sync.
+
 Each handoff hands the SAME handler task id to a NEW tile, and `MissionControlViewModel.
 OpenMergeHelperHandoffConPtySessionAsync` closes the outgoing phase's pane (`CloseConPtySession`,
 which disposes its `PtyTerminalSession` and kills the underlying `claude` process) before opening
@@ -127,6 +185,43 @@ outgoing session is only ever told to end its turn, never to exit. This keeps th
 `MCP_TOOL_TIMEOUT` is 200 s here — `TaskWaitMcpTools` clamps its own timeout to 170 s to stay
 comfortably under it (see [external-mcp.md](external-mcp.md)).
 
+### Auto-restart after the usage limit
+
+A handler session that dies mid-phase used to be a silent dead tile: `InteractiveTerminalViewModel.
+OnSessionProcessExited` only raised a visible banner for a death **inside** its 5 s
+`StartupGraceWindow`. It now raises `ExitedAfterStartup` for a later non-zero exit; the pane
+forwards it as `SessionDiedAfterStartup(taskId, exitCode)` and `MissionControlViewModel` reports it
+via `WorkerHub.ReportInteractiveSessionExited`. Every task-based pane reports — the UI does no
+filtering, because the exit code is the *only* thing it knows.
+
+`HandlerRestartCoordinator` (Worker) decides the rest and **fails closed** — unlike the usage gate,
+every missing signal means "don't relaunch":
+
+- **Which round was running** comes from `HandlerRoundState`, a JSON file at
+  `~/.claudeDo/handler-rounds.json` (one `HandlerRound` per handler task id, deliberately not a DB
+  column). `BuildForMergeHelperAsync` writes the opening round as phase `"triage"`;
+  `BuildForMergeHelperHandoffAsync` writes each subsequent `MergeHelperPhase`. Without it the phase
+  and task set exist *only* in the transient `HandoffRequested` broadcast, so a dead tile could not
+  be reopened. A `"triage"` round is never reopened — there is no handoff spec for it.
+- **Was it really the usage limit?** A ConPTY session has no captured stdout, so `TaskRunner.
+  IsUsageLimitMessage` (which matches the CLI's own "session limit" text) has nothing to read. The
+  corroborating witness is `UsageState.Snapshot.FiveHour.Utilization ≥ 95`
+  (`HandlerRestartCoordinator.UsageLimitProofPct`) at the moment of death. A crash at 40 % is not
+  restarted; no snapshot at all is not restarted.
+- **PowerUse only** — both keys, exactly like the prompt addendum above.
+- **One restart per round**, claimed via `HandlerRoundState.TryClaimAutoRestart` before the wait, so
+  a restart that dies again stays dead. `HandlerRoundState.Save` carries `AutoRestartUsed` over when
+  the phase is unchanged, because the restart's own launch-spec build writes the round again — a
+  naive overwrite would hand out a fresh budget every time and loop all night.
+- The restart waits out `FiveHour.ResetsAt`, then re-broadcasts `HandoffRequested` with the
+  persisted phase + task set, which the UI already handles by reopening the tile. It goes **around**
+  `handoff_list_handler`, so `HandoffRoundTracker.Register` is never called and the run loses no
+  handoff budget.
+
+Sibling to `UsageLimitAutoContinueCoordinator`, not an extension of it: that one only ever sees
+headless runs (`FailureReason == "usage_limit"`, resumed through the override slot), and a ConPTY
+session has no `task_runs` row to classify.
+
 ### The host task and its commit range
 
 The handler run **owns a real ClaudeDo task**, created by `CreateMergeHelperTask` (hub) →

docs/explore-notes/external-mcp.md

@@ -79,7 +79,8 @@ Task: `ListTaskLists`, `ListTasks`, `GetTask`, `AddTask`, `AddSubtask`, `UpdateT
 description is now the canonical place for what each status means.)
 
 Worktree/git: `GetTaskWorktree`, `GetTaskDiff`, `MergeTask`, `ContinueMerge`, `AbortMerge`,
-`PreviewMerge`, `PreviewMergeSet`, `RevertMerge`, `ListWorktrees`, `CleanupTaskWorktree`.
+`VerifyMerges`, `PreviewMerge`, `PreviewMergeSet`, `RevertMerge`, `ListWorktrees`,
+`CleanupTaskWorktree`.
 
 Daily prep: `GetDailyPrepCandidates`, `SetMyDay`.
 
@@ -97,6 +98,7 @@ Daily prep: `GetDailyPrepCandidates`, `SetMyDay`.
 | `TaskWaitMcpTools` | `WaitForTaskChange` |
 | `QueueStateMcpTools` | `GetQueueState` |
 | `AttachmentMcpTools` | `AddTaskAttachment`, `ListTaskAttachments`, `RemoveTaskAttachment` |
+| `ListHandlerMcpTools` | `StartListHandler` |
 
 ## Per-tool behaviour worth knowing
 
@@ -131,6 +133,18 @@ are reported in `ReviewTaskResult`.
   `Done` and merged silently with `changedFileCount: 0`, indistinguishable from a small-but-real
   change. `TaskRefDto.roadblockCount` (on every task-returning tool, stamped by `TaskRunner` from
   `result.Blocks.Count`) is the MCP-visible signal for *why* a child is empty.
+- `skipVerify=true` (also on `MergeTask`/`ContinueMerge`) is batch mode: the merge lands but the
+  list's verify command is deferred and the task stays `WaitingForReview` with mergeStatus
+  `merged_verify_pending`. One `VerifyMerges` call after the batch runs the verify once and
+  promotes them — see [review-merge.md](review-merge.md) → batch verify.
+
+**`VerifyMerges`** — `verify_merges(taskIds)`: runs the list's verify command ONCE (same per-repo
+merge gate) and promotes each listed task to Done via `ApproveReviewAsync` on success. Explicit
+ids on purpose — auto-promoting every `WaitingForReview` task would sweep up the handler's own
+task and deliberately parked `verify_failed` tasks. Eligibility per task: `WaitingForReview` AND
+(worktree `Merged` OR no worktree); an `Active` worktree means the branch never landed and is
+refused per-entry (the rest still promote). All ids must share one list. `verify_failed` promotes
+nothing; the merges stay in place.
 
 **`PreviewMerge`** — non-destructive `git merge-tree --write-tree` mergeability check for one
 task's worktree branch against `targetBranch` (default: the repo's current branch). Returns
@@ -222,6 +236,13 @@ task already outside those two (unknown ids reported as status `"NotFound"`, als
 **`AttachmentMcpTools`** — re-attaching the same `fileName` overwrites. Add/remove refuse on a
 `Running` task.
 
+**`StartListHandler`** — the worker only broadcasts `ListHandlerStartRequested`; the connected
+ClaudeDo App does the actual work (creates the handler task, opens the triage ConPTY tile). Before
+broadcasting it checks `ConnectedClientTracker` (a `WorkerHub.OnConnectedAsync`/`OnDisconnectedAsync`-driven
+singleton count) — with zero connected clients the broadcast would reach nobody, so the tool
+returns `Requested: false` plus a `Reason` instead of claiming success. Does not queue or retry the
+request for a later connect.
+
 **`GetDailyPrepCandidates`** — Idle, non-blocked tasks in a git repo **not** excluded by
 `AppSettings.ReportExcludedPaths` and not already `IsMyDay`, plus the current Idle MyDay tasks
 and `maxTasks` (= `DailyPrepMaxTasks`). Repo-exclusion logic lives in the `DailyPrepFilter`

docs/explore-notes/review-merge.md

@@ -1,8 +1,8 @@
 # Review, merge & conflict resolution
 
 > **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
-> Last verified against `fc9df7f` (2026-08-11), which added the conventional merge-commit default
-> and the `MergeProgress` broadcast.
+> Last verified against `168ab1cd` (2026-08-26), which added the batch verify
+> (`skipVerify` + `verify_merges`).
 > Planning mode renders per file and `DiffLinesView` is retired.
 > Drift check: `git log --oneline 20bce9b..HEAD -- src/ClaudeDo.Worker/Lifecycle src/ClaudeDo.Worker/State src/ClaudeDo.Worker/Planning src/ClaudeDo.Ui/ViewModels/Conflicts src/ClaudeDo.Worker/External`
 > Stable structure only (no line numbers). See docs/explore-notes/README.md.
@@ -76,6 +76,23 @@ DB write. Cycle note: `TaskStateService` can't take a direct constructor depende
 handed to `PlanningChainCoordinator`. `IActiveMergeState` (`Planning/Interfaces/`) is `PlanningMergeOrchestrator`'s
 only public surface `TaskStateService` needs.
 
+`HasActiveMerge` also stays true through the window between the last child merging and
+`FinalizeParentDoneAsync` returning (a separate `State.IsFinalizing` flag — `CurrentSubtaskId` is
+already null there since no subtask is left to merge). Without it, a `Cancel` racing the finalize
+call's own `ApproveReviewAsync` could slip past the guard for that whole call. `StartAsync` also now
+requires the parent to already be `WaitingForReview` — for planning **and** improvement parents —
+before touching anything; previously only planning parents got an (indirect, children-only) check,
+so a stale UI click or a second caller on an improvement parent that had already left
+`WaitingForReview` could still drive a partial child merge before the final approve refused.
+
+Unit-merge failures used to vanish silently: a child merge that came back
+`blocked`/`verify_failed`/`untracked_collision` (not `conflict`) was only logged server-side, and
+`ApproveReview`/`review_task` approve always reported success (`StatusMerged`) regardless.
+`StartAsync`/`ContinueAsync`/the private `DrainAsync` now return a `PlanningMergeResult(Status,
+Reason)` that both hub paths propagate as the real status, and `PlanningMergeAborted` carries that
+reason so the UI's `IslandsShellViewModel.OnPlanningMergeAborted` can `FlashFooterError` it instead
+of only clearing the banner.
+
 The UI mirrors this as polish: `DetailsIslandViewModel.IsMergeDraining` (set on
 `PlanningMergeStartedEvent`, cleared on `PlanningMergeAborted`/`PlanningCompleted` for the bound
 task) gates `CancelReviewCommand`'s `CanExecute` — same shape as `WorktreesOverviewModalViewModel.IsMerging`
@@ -136,6 +153,27 @@ dead app for minutes while the merge has in fact already landed.
 so a verify run can't be interrupted by a second merge landing in the same working dir
 mid-build.
 
+### Batch verify (skipVerify + verify_merges)
+
+Per-merge verify made an N-task batch pay N × ~7 min, each run testing the same moving main.
+`MergeAsync`/`ContinueMergeAsync`/`ApproveAndMergeAsync` take `skipVerify` (MCP-only —
+`review_task`/`merge_task`/`continue_merge` expose it; the UI approve never passes it): the merge
+lands normally but the gate AND the Done transition are deferred — status
+`merged_verify_pending`, task stays `WaitingForReview` with a `Merged` worktree (the same shape
+`verify_failed` leaves behind). `TaskMergeService.RunListVerifyAsync` (tool `verify_merges`) then
+runs the command once under the same per-repo gate and promotes the explicitly listed tasks via
+`ApproveReviewAsync`. Explicit ids, not a query — auto-promotion would sweep up the handler's own
+submitted task and parked `verify_failed` tasks. A task whose worktree is still `Active` is
+refused per-entry (branch never landed → would go Done with an unmerged branch).
+
+`PlanningMergeOrchestrator` threads `skipVerify` through the unit merge (`State.SkipVerify`), so
+children no longer pay the gate per child; when any child came back `merged_verify_pending` the
+drain skips `FinalizeParentDoneAsync` (a finalize would grant a Done nothing verified), still
+broadcasts `PlanningCompleted` (the drain IS complete; the UI banner must clear), and returns
+`merged_verify_pending` — the parent is promoted later by `verify_merges` like any other task.
+The merge-helper Merge prompt approves with `skipVerify=true` and calls `verify_merges` once
+after the last merge; the invariant "no Done without a green verify" stays server-enforced.
+
 ### Verify in the preview, not just post-merge
 
 `TaskMergeService.PreviewAsync(taskId, targetBranch, runVerify, ct)` can additionally build/test a
@@ -146,9 +184,9 @@ detached-HEAD scratch worktree under the OS temp dir (`GitService.WorktreeAddDet
 is always removed afterward (`finally`, non-cancellable cleanup). No verify command configured, or
 `runVerify=false`, reproduces the pre-existing preview exactly — no delay, no scratch worktree.
 
-Wired into `ExternalMcpService`: `preview_merge` (single task) always requests a verify run when the
-list has a command configured; `preview_merge_set` only does when its `runVerify` parameter is
-explicitly set (default `false`) — a set preview never starts N builds unasked. The Hub's
+Wired into `ExternalMcpService`: both `preview_merge` (single task) and `preview_merge_set` only
+request a verify run when their `runVerify` parameter is explicitly set (default `false`) — a
+preview never starts a build unasked. The Hub's
 `PreviewMerge` (the UI's live mergeability indicator) always passes `runVerify: false`, since
 running a build on every poll would be a bad regression; `MergePreviewDto` carries the
 verify fields anyway so a future UI entry point can opt in. Result fields: `VerifyExitCode` (null =

docs/explore-notes/usage-monitoring.md

@@ -1,15 +1,18 @@
 # Usage monitoring, gate & throttle
 
 > **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
-> Last verified against commit `f6cb825` (2026-08-05), plus the uncommitted per-bucket-throttle /
-> draggable-gauge change of 2026-08-06 (this note already describes that newer state).
-> Drift check: `git log --oneline f6cb825..HEAD -- src/ClaudeDo.Worker/Usage src/ClaudeDo.Worker/Queue src/ClaudeDo.Ui/ViewModels/UsagePillViewModel.cs`
+> Last verified against commit `bf56cd8c` (2026-08-24).
+> Drift check: `git log --oneline bf56cd8c..HEAD -- src/ClaudeDo.Worker/Usage src/ClaudeDo.Worker/Queue src/ClaudeDo.Ui/ViewModels/UsagePillViewModel.cs`
 > Stable structure only (no line numbers). See docs/explore-notes/README.md.
 
 Covers `src/ClaudeDo.Worker/Usage/`, the queue's throttle/gate integration, per-run token
 accounting, and the UI surfaces (usage pill + usage monitor modal).
 
-## Data source
+**Two independent data sources, on purpose.** Limits/gate/throttle come from the OAuth poll
+below; the *analytics* (per-model and per-task breakdown, cost) come from the external
+TokenTracker CLI. Neither one can break the other.
+
+## Data source (limits, gate, throttle)
 
 `GET https://api.anthropic.com/api/oauth/usage` — an **undocumented** Anthropic endpoint,
 authenticated with the Bearer access token Claude Code itself keeps fresh at
@@ -18,6 +21,11 @@ authenticated with the Bearer access token Claude Code itself keeps fresh at
 Because the endpoint is undocumented and can change without notice, **every consumer
 fails open**. That is the single most important invariant here.
 
+**Measured 2026-09-16** (clean burst against the live endpoint, Worker otherwise idle): exactly
+5 requests succeed, the 6th 429s with `Retry-After: 300` — a flat 5-requests-per-5-minute quota,
+no `ratelimit-*`/`x-ratelimit-*` headers on either the 200s or the 429. The quota is per-account,
+not per-process, so a manual refresh or another consumer of the same OAuth token shares it.
+
 ## Components (`Usage/`)
 
 | Type | Role |
@@ -25,13 +33,15 @@ fails open**. That is the single most important invariant here.
 | `UsageModels` | `UsageBucket` / `UsageLimitRow` / `UsageSnapshot`. `UsageBucket.Utilization` is already a 0–100 percent — compare directly against thresholds, don't rescale. |
 | `ClaudeOAuthUsageClient` | Reads the token, calls the endpoint. Defensive parsing: missing/null buckets → null, missing `limits` → empty list. |
 | `UsageState` | Threadsafe singleton. A failed poll **never** overwrites the last good snapshot — it only sets `LastError`. |
-| `UsageMonitorService` | `BackgroundService`; polls on `usage_poll_interval_seconds` (default 60, clamped to min 15 on config load), one poll at startup. Logs a failure at most once per distinct error message. Broadcasts `HubBroadcaster.UsageUpdated` after **every** tick, success or failure. |
+| `UsageMonitorService` | `BackgroundService`; polls on `usage_poll_interval_active_seconds` / `usage_poll_interval_idle_seconds` (default 120 each, clamped to min 90 on config load), one poll at startup. Logs a failure at most once per distinct error message. Broadcasts `HubBroadcaster.UsageUpdated` after **every** tick, success or failure. |
 | `UsageSnapshotBuilder` | Builds the Hub-facing `UsageSnapshotDto` from `UsageState` + `IUsageGate` + `AppSettings`. The one shared place for stale/threshold/gate logic — `WorkerHub.GetUsageSnapshot` and `UsageMonitorService` must not diverge. |
 | `UsageGate` | Hard pause decision → `UsageGateDecision(IsBlocked, Reason)`. |
 | `UsageThrottle` | Pure static staging of parallelism ahead of the gate. |
-| `TranscriptUsageReader` | Aggregates token usage from Claude Code transcripts. |
+| `TranscriptUsageReader` | Reads **one** session's cumulative totals for per-run accounting. **No** aggregation — the date/model/scope roll-up moved to `TokenTracker/`. |
+| `TokenTracker/` | The external analytics backend: cost + per-model/per-task breakdown. Own section below. |
 
-Interfaces in `Usage/Interfaces/`: `IUsageClient`, `ITranscriptUsageReader`, `IUsageGate`.
+Interfaces in `Usage/Interfaces/`: `IUsageClient`, `ITranscriptUsageReader`, `IUsageGate`;
+plus `Usage/TokenTracker/Interfaces/ITokenTrackerClient`.
 
 ## The gate (hard pause)
 
@@ -109,18 +119,67 @@ stores the **delta** against prior `task_runs` rows sharing the same `session_id
 
 A missing/unreadable transcript leaves all four fields `null`; it never fails the run.
 
+`ReadSessionTotalsAsync` **stays** — it is the per-run source of truth and is deliberately *not*
+routed through TokenTracker, whose export has no per-run granularity (it aggregates a whole
+session, which a `--resume`'d task spreads over several runs).
+
 ### `TranscriptUsageReader` details
 
-Reads `~/.claude/projects/**/*.jsonl`, aggregating by date / model / scope (ClaudeDo vs
-Other), deduped by `requestId`, with a per-file length+mtime cache.
+Locates a single `{sessionId}.jsonl` under `~/.claude/projects/**`, sums the raw `usage` fields of
+every assistant message, deduped by `requestId` (falling back to `message.id`), with a per-file
+length+mtime cache. `<synthetic>`-model lines are skipped — they are not real API calls.
 
-`ReadAsync` **skips any file whose mtime predates the window start minus one day** — it cannot hold
-a record inside the range, and the full history is large (measured 2026-08-06: 501 files / 230 MB /
-77k lines ≈ 1.7 s to parse cold; a 7-day range touches ~190 files / ~106 MB). The one-day slack
-absorbs local-vs-UTC skew between mtime and record timestamps. `ReadSessionTotalsAsync` is
-unaffected — it looks up a single `{sessionId}.jsonl`.
+There is no history-wide `ReadAsync` any more; `WorkerConfig` is still a constructor parameter
+purely so the DI registration and call sites stayed untouched.
 
-`<synthetic>`-model lines are skipped **everywhere** — they are not real API calls.
+## Analytics via TokenTracker
+
+The per-model / per-task / cost view comes from **TokenTracker**, an external MIT-licensed CLI
+(`tokentracker-cli`, npm) that reads the same local Claude transcripts. Everything lives in
+`Usage/TokenTracker/`; the pure parts (`SessionHash`, `TokenTrackerArgs`,
+`TokenTrackerExportParser`, `TokenTrackerAggregator`) have no I/O and are unit-tested, only
+`TokenTrackerClient` (processes) and `TokenTrackerService` (cache coordination) touch the world.
+
+- **Invocation:** `tokentracker sessions --from <d> --to <d> --no-git --format json`
+  (`TokenTrackerArgs`). `--no-git` matters — without it TokenTracker runs `git log` inside every
+  session's working directory. We **never** call `tokentracker init`: that would write hooks into
+  the user's global `~/.claude/settings.json` and switch on cloud sync. Install is an explicit
+  `npm i -g tokentracker-cli`, never `npx`. Resolution goes through the shared
+  `ExecutableResolver` because an npm CLI is a `.cmd` shim.
+- **The join:** the export never carries a raw session id, only `session_hash` =
+  `sha256("claude\0" + sessionId)` hex, first 24 chars (`SessionHash.ForClaudeSession`,
+  mirroring TokenTracker's `lib/session-analytics.js`). That hash set — built from
+  `task_runs.session_id` — is also what decides the **ClaudeDo vs. other** scope split. Note this
+  is *narrower* than the old cwd-based split: an interactive or planning session has no
+  `task_runs` row and therefore counts as "other".
+- **One wide fetch, local filtering:** `TokenTrackerService.WindowDays` = 90. TokenTracker's
+  `buildSessionAnalytics` walks the whole history regardless of `--from`/`--to` (v0.88.4 returns
+  the same rows either way), so narrowing the request buys nothing while making every range switch
+  pay again. Range switching is then pure in-memory filtering in `TokenTrackerAggregator`.
+- **Freshness:** `EnsureFreshAsync(maxAge)`. No export at all → the caller awaits the fetch;
+  an export older than **15 minutes** → served immediately while a refresh runs behind the
+  caller's back. `RefreshAsync` is single-flight (a second caller waits for the in-flight run
+  instead of spawning another process). The probe (CLI present? Node ≥ 20?) is cached until an
+  install forces it.
+- **Version check:** the export's `version` field is compared against
+  `TokenTrackerExportParser.SupportedFormatVersion` (11). A mismatch is treated as a **failure**
+  — the state keeps the last good export and reports the version in `LastError`.
+- **Fail-open everywhere:** `TokenTrackerState` mirrors `UsageState` — a failed or unparseable
+  fetch never overwrites a good export, it only sets `LastError`. CLI missing → empty analytics
+  plus a hint card in the UI. Nothing here can throw into the queue.
+- **Local dashboard:** `tokentracker serve --port <p> --no-open --no-sync`, started by the worker on
+  demand (`ITokenTrackerClient.StartDashboardAsync`) for the "Open TokenTracker dashboard" button.
+  Three things this path has to get right: TokenTracker's default port **7680 is not free** on
+  Windows (Delivery Optimization holds `[::]:7680`) and `serve` exits instead of falling back, so
+  we scan 7680–7689 with a **dual-stack** bind probe (an IPv4-only probe calls 7680 free and the
+  spawn then dies); `--no-open` because the CLI would open the browser before the server answers,
+  so we poll `GET http://127.0.0.1:<p>/` (30 s cap) and let the **UI** open the URL; and the child
+  is a `cmd.exe` shim, so shutdown kills the **process tree** or node keeps listening. The
+  spawned server is reused while alive and dies with the worker (`TokenTrackerClient` is
+  `IDisposable`, registered as a singleton) — a worker *crash* leaks it until the port is scanned
+  past.
+- **Limits, gate and throttle do *not* come from TokenTracker.** They are the OAuth poll above.
+  A broken or absent TokenTracker costs you the cost columns, nothing else.
 
 ## UI surfaces
 
@@ -153,17 +212,41 @@ unaffected — it looks up a single `{sessionId}.jsonl`.
   `seven_day_sonnet`-style buckets the raw API returns are plan-dependent and come back
   `null` on plans that don't have them; a fixed gauge layout would break. Also shows model
   usage (`GetModelUsageAsync`, ClaudeDo-vs-Other split per model) and top-task usage
-  (`GetTaskUsageAsync`) over a 7d/30d preset or custom range.
+  (`GetTaskUsageAsync`) over a 7d/30d preset or custom range — both with a **cost** column, the
+  task table additionally with retries.
+- **Analytics header vs. hint card** — the modal shows exactly one of the two. With TokenTracker
+  present: total tokens + total cost, a freshness stamp, a manual `RefreshAnalytics` button and an
+  **Open TokenTracker dashboard** button (spinner while the server boots; everything this modal
+  deliberately doesn't show lives there).
+  Without it: a hint card explaining what TokenTracker is (local only, no `init`, no cloud sync)
+  plus an `Install TokenTracker` button — which is hidden and replaced by a Node-version hint when
+  Node < 20 or Node is missing, because the install would just fail. Install progress and every
+  failure go through `ErrorReported` into the shell's footer log strip, not a private banner.
 
 ## Hub surface
 
 - `GetUsageSnapshot() -> UsageSnapshotDto` — percentages/limits/`FetchedAtUtc` are null and
   `IsStale=true` when no snapshot has landed yet. `IsStale` also trips on a failed last poll
   or a snapshot older than 3× `usage_poll_interval_seconds`.
-- `GetModelUsage(from, to)` — thin wrapper over `ITranscriptUsageReader.ReadAsync`.
-- `GetTaskUsage(from, to)` — top consumers from `task_runs` joined to task/list, grouped per
-  task. Null token columns count as **0**, never drop the row. `Model` comes from that task's
-  most recent run. Sorted by total tokens descending, capped at 100.
+- `GetModelUsage(from, to)` — filters + aggregates the **cached TokenTracker export**
+  (`TokenTrackerAggregator.ByModel`). Returns an empty list rather than throwing when TokenTracker
+  is unconfigured or no export landed. `Sessions` replaced the old assistant-message count — the
+  export has no message granularity.
+- `GetTaskUsage(from, to)` — unchanged source: top consumers from `task_runs` joined to task/list,
+  grouped per task. Null token columns count as **0**, never drop the row. `Model` comes from that
+  task's most recent run. Sorted by total tokens descending, capped at 100. Cost/retries/
+  productive/one-shot are an **enrichment** via the `session_hash` join — a missing export just
+  leaves those columns empty, it never triggers a fetch (`GetModelUsage` is what does).
+- `GetTokenTrackerStatus()` — probe + state, as `TokenTrackerStatusDto(Installed, Version, NodeOk,
+  NodeVersion, LastFetchedUtc, LastError, FormatVersion, SessionCount)`. Never throws; an
+  unconfigured worker comes back as not-installed with a reason.
+- `RefreshTokenTracker()` — forces a fetch, then re-probes and returns the status.
+- `OpenTokenTrackerDashboard()` — brings up the local dashboard server and returns
+  `TokenTrackerDashboardDto(Ok, Url, Error)`; the UI opens the browser (`ShellOpen.Url`, which
+  refuses anything that isn't http/https). Never throws — a failure also lands in `WorkerLog`.
+- `InstallTokenTracker()` — `npm i -g tokentracker-cli`, streaming npm's output line by line into
+  `WorkerLog` (npm writes progress to stderr; forwarding it is what keeps a multi-minute global
+  install from looking hung), then force-re-probes.
 - `UsageUpdated` event carries the same `UsageSnapshotDto`.
 
 ## Settings columns
@@ -176,6 +259,7 @@ degrades instead of throwing. Worker config: `usage_poll_interval_active_seconds
 `usage_poll_interval_idle_seconds`.
 
 The gate percentages are editable in **two** places that both write the same `app_settings` row:
-Settings → General (typed) and the usage-monitor gauges (dragged). The throttle stages are
+Settings → Execution (typed) and the usage-monitor gauges (dragged). The throttle stages are
 gauge-only — `SettingsModalViewModel` therefore carries them load→save verbatim so saving Settings
-can't reset a dragged value.
+can't reset a dragged value. PowerUse (switch, time window, handoff %) used to be usage-monitor-only
+and is now typed on the same Settings tab, so it needs no such round-trip.

docs/open.md

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

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

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

docs/superpowers/plans/2026-08-11-operation-feedback.md

@@ -96,7 +96,7 @@ Gilt für alle vier Gruppen:
 > **Stand 2026-08-17.** P0, A (außer A5), B, C1 und D sind gemergt; der visuelle Pass über A und B
 > ist durch, ohne Fund. Nachtrag zu P0-2: der Timing-Sink liegt seit dem Release-Vorlauf hinter
 > `CLAUDEDO_OP_TIMING=1` und ist **standardmäßig aus** — die 63 `InvokeTimedAsync`-Call-Sites
-> bleiben bewusst stehen. Offen: C2–C5.
+> bleiben bewusst stehen. Offen: C2–C4.
 
 **Vorbedingung:** keine. Muss allein landen, bevor A/B/C starten.
 
@@ -349,9 +349,15 @@ zukünftige Regressionen fangen.
 - [ ] **C2 — Startup-Recovery sichtbar**
 - [ ] **C3 — Worktree-Anlage sichtbar**
 - [ ] **C4 — Rebase-after-Merge und WorktreeMaintenance**
-- [ ] **C5 — periodische Dienste**
+- [x] ~~**C5 — periodische Dienste**~~ — **abgesagt** (2026-08-21): Usage/Prime/OnlineSync
+  melden Aktivität schon über bestehende Broadcasts (`UsageUpdated`,
+  `PrimeFired`/`PrepStarted`/`PrepLine`/`PrepFinished`, `TaskUpdated` bei neuen Online-Tasks);
+  Fehler aller vier Dienste laufen automatisch über `BroadcastLogSink` in den WorkerLog-Footer.
+  `QueueService` meldet seine einzigen bedeutsamen Zustandswechsel (Gate/Throttle) bereits
+  change-gated über `WorkerLog`. Ein zusätzlicher `OperationProgress`-Kanal wäre Duplikat statt
+  Mehrwert, mit echtem Tick-Strom-Risiko am Backstop-Timer.
 
-> **Einzige offene Gruppe.** C2–C5 sind unblockiert (C1 ist gemergt). Woran man den Reststand
+> **Einzige offene Gruppe.** C2–C4 sind unblockiert (C1 ist gemergt, C5 abgesagt). Woran man den Reststand
 > erkennt: die vier Keys `ops.worker.startupRecovery`, `.creatingWorktree`, `.rebasingAfterMerge`
 > und `.maintainingWorktrees` liegen ungenutzt in beiden Sprachdateien.
 

docs/superpowers/plans/2026-08-20-ux-struktur.md

@@ -0,0 +1,122 @@
+# UX-Struktur — Vorgaben für die Umsetzung
+
+**Design:** `docs/superpowers/specs/2026-08-20-ux-struktur-design.md`. Dort stehen die
+Entscheidungen und Belege; dieses Dokument wiederholt sie nicht, es schneidet die Arbeit.
+
+**Ausführungsmodell: eine strikte Kette.** Alle drei Pakete ändern `locales/en.json` und
+`locales/de.json` — die überlappen immer. Deshalb läuft nichts parallel.
+
+```
+#189 → #190 → #191 → #192  (mechanische Audit-Fixes, bereits delegiert)
+                        │
+                        └── A  Task-Zeile + Kontextmenü
+                                │
+                                └── B  Settings-Sidebar
+                                        │
+                                        └── C  Erststart-Banner + Textkette
+```
+
+Jedes Paket hängt per `dependsOn` am Vorgänger. Der Picker holt es erst, wenn der Vorgänger
+**Done** (also gemergt) ist.
+
+## Datei-Eigentum (bindend)
+
+| Paket | Besitzt | Darf **nicht** anfassen |
+|---|---|---|
+| **A** | `Ui/Views/Islands/TaskRowView.axaml(.cs)`, `Ui/ViewModels/Islands/TaskRowViewModel.cs`, `Ui/Views/Islands/Detail/TaskHeaderBar.axaml`, `locales/*` | `WorkConsole.axaml`, Settings-Dateien, `ListsIsland*` |
+| **B** | `Ui/Views/Modals/SettingsModalView.axaml(.cs)`, `Ui/ViewModels/Modals/SettingsModalViewModel.cs`, `Ui/ViewModels/Modals/Settings/*`, `locales/*` | alles im Islands-Ordner |
+| **C** | `Ui/Views/Islands/ListsIslandView.axaml(.cs)`, `Ui/ViewModels/Islands/ListsIslandViewModel.cs`, `Ui/Views/Islands/Detail/WorkConsole.axaml` (nur die eine Approve-Gate-Zeile), `Ui/Views/Islands/TasksIslandView.axaml` (nur Empty-State-Texte aus #192 nachschärfen), `locales/*` | `TaskRowView*`, Settings-Dateien |
+
+Alle drei dürfen `tests/ClaudeDo.Ui.Tests` erweitern — aber nur eigene neue Testdateien bzw.
+eigene neue Testmethoden anlegen, keine fremden umschreiben.
+
+## Vorgaben für alle drei Pakete
+
+- **Modell:** `sonnet`. **`maxTurns` explizit 200** — `model_presets` ist NULL, sonst gibt es
+  30 Turns und „exited with code 1 and no result".
+- **Bauen** (`.slnx` scheitert auf .NET 8, laufender Worker sperrt `Debug`):
+  ```
+  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
+  ```
+- **Nur eigene Dateien stagen** (`git commit -- <pfade>`), nie `git add -A` — der `main`-Checkout
+  ist mit parallelen Sessions geteilt.
+- **Keine Funktion still entfernen.** Wo etwas aus einer Oberfläche verschwindet, im
+  Abschlussbericht benennen, wo es jetzt liegt.
+- **Locale-Parity** ist Testsache (Localization.Tests) — beide Dateien im gleichen Commit.
+- **Visuelle Verifikation im Abschlussbericht als offen markieren.** Mika macht den visuellen
+  Pass; kein Task darf behaupten, die UI sei geprüft.
+
+---
+
+## Paket A — Task-Zeile + Kontextmenü
+
+Themen 1 und 3 des Designs zusammen, weil sie dieselben drei Dateien anfassen.
+
+- [ ] **A1 Kontextmenü umbauen.** Gruppe 1 (Send to queue, Remove from queue, Cancel execution,
+      Open quick session, Refine task) immer sichtbar, bei nicht erfüllter Bedingung
+      `IsEnabled=false` + Grund. Untermenüs „Mark as", „Planning", „Schedule" nach der Tabelle im
+      Design; Untermenü-Kopf disabled wenn leer. Der „Delete task…"-Eintrag aus #191 bleibt als
+      abgesetzte Gruppe unten. `MakeItem` bekommt einen `reason`-Parameter.
+- [ ] **A2 Disabled-Gründe am VM.** `SendToQueueDisabledReason`, `CancelDisabledReason`,
+      `QuickSessionDisabledReason`, `RefineDisabledReason`, `PlanningDisabledReason` (`string?`)
+      auf `TaskRowViewModel`, mit Change-Notification an den passenden Stellen. Unit-Tests pro
+      Zustand.
+- [ ] **A3 Tooltip-Fähigkeit verifizieren.** Headless prüfen, ob Avalonia 12 einen `ToolTip` auf
+      einem `IsEnabled=false` MenuItem anzeigt. Ja → Tooltip. Nein → Grund als Suffix im Header.
+      Das Ergebnis gehört in den Abschlussbericht (es ist eine Projekt-Erkenntnis, kein Detail).
+- [ ] **A4 Hover-/Selektions-Aktionen.** `IsHovered` + `ShowRowActions => IsHovered || IsSelected`
+      am `TaskRowViewModel`; `PointerEntered`/`PointerExited` in `TaskRowView.axaml.cs`.
+      Refine-Button, ungesetzter Star und Dequeue-X werden damit AND-verknüpft; `IsRefining`-Spinner
+      bleibt ausgenommen. Grid-Spalten unverändert lassen, damit die Zeile nicht springt.
+- [ ] **A5 Branch verlagern.** Branch-Chip aus `TaskRowView.axaml` entfernen und den Branch-Namen
+      in `TaskHeaderBar.axaml` als Meta-Zeile aufnehmen (er steht bisher nirgends im Detail-Pane).
+      Ohne A5 darf der Chip nicht entfernt werden.
+
+**Fertig, wenn:** Build grün, Ui.Tests + Localization.Tests grün, und der Bericht sagt für jedes
+verschwundene Zeilen-Element, wo es jetzt erreichbar ist.
+
+---
+
+## Paket B — Settings-Sidebar
+
+- [ ] **B1 Host umbauen.** TabStrip des bestehenden `TabControl` ausblenden, links eine
+      Sidebar-`ListBox` mit Gruppen-Labels BASIS/ERWEITERT, die `SelectedIndex` bindet.
+      Panel-Inhalte bleiben, wo sie sind. Fensterbreite 580 → 700.
+      `SettingsCategory(Key, Label, Group, IsVisible, RequiresRepo)` + `Categories` +
+      `SelectedCategory` am `SettingsModalViewModel`.
+- [ ] **B2 General aufteilen.** „Allgemein" (Sprache, Accent, Default-Instructions) und
+      „Ausführung" (Model, Permission, Model-Presets, MaxTurns-Ceiling, Parallelität, Usage-Gate).
+      Kategorie „Berichte" neu mit Standup-Wochentag + Report-Excluded-Paths. Reihenfolge der
+      Kategorien: Allgemein, Ausführung, Prime Claude | Worktrees, Dateien & Prompts,
+      Session Skills, Berichte, Online Inbox.
+- [ ] **B3 Session Skills zusammenlegen.** Checkbox-Liste aus General entfernen; in der Kategorie
+      „Session Skills" pro installiertem Skill eine Zeile mit Checkbox (global aktiv) +
+      Update/Remove, darunter das Install-Feld. **Speichern/Laden der Auswahl muss nachweislich
+      unverändert funktionieren** — Test dafür ist Pflicht, das ist die einzige echte
+      Regressionsstelle des Pakets.
+- [ ] **B4 Repo-Hinweis.** `HasLinkedRepo` am `SettingsModalViewModel` (keine Liste mit
+      `WorkingDir` → false). Hinweisstreifen oben in Worktrees, Prime Claude, Session Skills und
+      Berichte: „Wirkt erst mit verknüpftem Repo" + Link, der den Repo-Import öffnet.
+
+**Fertig, wenn:** Build grün, Tests grün, jede der acht Kategorien einmal aufrufbar, und Save →
+Reopen zeigt alle Werte unverändert (inkl. Skill-Auswahl).
+
+---
+
+## Paket C — Erststart-Banner + Textkette
+
+- [ ] **C1 Banner.** `HasNoLinkedRepo` am `ListsIslandViewModel` (true, solange keine User-Liste
+      ein `WorkingDir` hat; neu berechnet beim Listen-Load und nach List-CRUD/List-Settings-Save).
+      Banner unter dem Lists-Island-Header, optisch wie das Update-Banner des Shells, Button ruft
+      `OpenRepoImportCommand`. Kein Dismiss.
+- [ ] **C2 Textkette abstimmen.** Die Empty-State-Texte aus #192 so nachschärfen, dass Banner →
+      „Liste ohne Repo" → „Liste mit Repo, aber leer" als ein Weg lesbar sind; der letzte nennt
+      „Send to queue" und den Worktree.
+- [ ] **C3 Review-Zeile.** Am Approve-Gate-Hinweis in `WorkConsole.axaml` (den #190 baut) eine
+      Zeile ergänzen, die sagt, dass Approve gleichzeitig das Mergen der ganzen Einheit ist.
+      Nur diese eine Stelle in der Datei anfassen.
+
+**Fertig, wenn:** Build grün, Tests grün, und die vier Texte im Bericht als zusammenhängende
+Kette zitiert sind (damit Mika sie ohne App lesen kann).

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

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

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

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

docs/superpowers/specs/2026-08-20-ux-struktur-design.md

@@ -0,0 +1,227 @@
+# UX-Struktur: Kontextmenü, Settings, Task-Zeile, Erststart — Design
+
+**Stand:** 2026-08-20 · Codestand `f9a8ed7` · Freigegeben von Mika im Brainstorming
+
+Die vier strukturellen Themen aus dem UX-Audit vom 2026-08-20. Die *mechanischen* Befunde
+desselben Audits laufen bereits als Tasks **#189** (Silent No-Ops → Footer-Fehler), **#190**
+(Precondition-Hinweise), **#191** (Aktions-/Bestätigungs-Konsistenz), **#192** (Empty States).
+Dieses Design setzt auf deren Ergebnis auf und wiederholt es nicht.
+
+**Was hier nicht drinsteht:** die Audit-Befunde selbst (Memory `ux_audit_2026_08_20.md`) und die
+Mechanik von Review/Merge (`docs/explore-notes/review-merge.md`).
+
+---
+
+## Gemeinsame Randbedingungen
+
+- Alle drei Umsetzungs-Tasks laufen **nach #192**. Sie fassen dieselben Views an, und #189–#192
+  ändern Locale-Dateien, `TaskRowView.axaml.cs`, `DetailsIslandViewModel` und die Empty-State-Keys.
+- **Keine Funktion verschwindet still.** Wo etwas aus einer Oberfläche verschwindet, muss dieses
+  Design sagen, wo es stattdessen erreichbar ist — und der Task muss das belegen.
+- Neue Texte immer als Keys in `locales/en.json` **und** `locales/de.json` (Localization.Tests
+  erzwingt Parity).
+- Visuelle Verifikation macht Mika. Jeder Task markiert sie im Abschlussbericht als offen.
+
+---
+
+## 1. Task-Kontextmenü restrukturieren
+
+**Problem.** `TaskRowView.axaml.cs` baut ~18 flache MenuItems mit vier Separatoren. Kernaktionen
+(Queue rein/raus, Abbrechen) stehen visuell gleichwertig neben Planning-Session-Lifecycle und
+My-Day-Verwaltung. Zusätzlich werden Einträge bei nicht erfüllter Bedingung komplett ausgeblendet
+— das Menü hat je Zustand ein anderes Layout, und der User erfährt nie, dass eine Aktion
+existiert.
+
+**Entscheidung: gruppieren und verschachteln.** Das Menü bleibt die vollständige Action-Surface
+für einen Task (keine Verlagerung ins Detail-Pane — das ist selbst schon dicht).
+
+```
+Send to queue                       [disabled + Grund]
+Remove from queue                   [disabled + Grund]
+Cancel execution                    [disabled + Grund]
+Open quick session                  [disabled + Grund]
+Refine task                         [disabled + Grund]      ← neu (siehe Thema 3)
+─────────────────────────────
+Mark as                          ▸  Done · Cancelled · ─ · Mark manual / Mark as Claude task
+Planning                         ▸  Open · Resume · Finalize · Discard
+Schedule                         ▸  Schedule for… · Clear schedule · ─ · Add to My Day / Remove from My Day
+─────────────────────────────
+Delete task…                        (aus #191, bleibt unten abgesetzt)
+```
+
+**Sichtbarkeitsregeln.**
+
+| Ebene | Regel |
+|---|---|
+| Gruppe 1 (5 Einträge) | **Immer sichtbar**, Position fix. Bedingung nicht erfüllt → `IsEnabled=false` + Grund. |
+| Untermenü-Einträge | Heutige Ausblende-Logik bleibt — die Auswahl ist dort exklusiv (Manual ⇄ Claude-Task, Add ⇄ Remove My Day). |
+| Untermenü-Kopf | `IsEnabled=false`, wenn er leer wäre (z.B. „Planning" auf einem Manual-Task). |
+| Delete | Wie #191 es baut, nur eigene Gruppe unten. |
+
+**Grund-Anzeige.** Primär `ToolTip.Tip` am disabled MenuItem. **Verifikationspflicht:** Der Task
+muss headless prüfen, ob Avalonia 12 Tooltips auf `IsEnabled=false` MenuItems überhaupt anzeigt.
+Wenn nicht → Grund als Suffix im Header (`"Send to queue — kein Repo verknüpft"`). Kein
+stillschweigendes Weglassen; wenn beides nicht geht, muss der Task es als Befund melden.
+
+**Wo die Gründe herkommen.** Neue berechnete Properties auf `TaskRowViewModel` neben den
+bestehenden `CanX`, z.B. `SendToQueueDisabledReason`, `CancelDisabledReason`,
+`QuickSessionDisabledReason`, `RefineDisabledReason`, `PlanningDisabledReason` (jeweils `string?`,
+`null` = kein Grund nötig). Keine Bedingungslogik in der View.
+
+**Struktur im Code.** Das Menü wird weiterhin erst beim Öffnen gebaut (kein Rendering-Overhead
+pro Zeile). `MakeItem` bekommt einen optionalen `reason`-Parameter und schaltet auf `IsEnabled`
+statt `IsVisible` um, wenn der Aufrufer das verlangt.
+
+**Ergebnis:** 18 flache Einträge → 9 Top-Level-Zeilen, davon 5 mit fixer Position.
+
+---
+
+## 2. Settings-Modal entzerren
+
+**Problem.** Der General-Tab mischt 10+ Konzeptgruppen (Sprache, Accent, Default-Instructions,
+Model, Permission, Model-Presets-Tabelle, MaxTurns-Ceiling, Parallelität, Usage-Gate-Prozente,
+Report-Excluded-Paths, Standup-Wochentag, Session-Skills-Checkboxen). Session Skills stehen
+**doppelt** (Auswahl in General, Verwaltung im Skills-Tab). Und die sechs Tabs füllen den
+580 px breiten TabStrip bereits aus — ein siebter passt nicht.
+
+**Entscheidung: Sidebar-Navigation mit zwei Gruppen.**
+
+```
+┌ Einstellungen ─────────────────────────────────────────┐
+│ BASIS              │  [Panel der gewählten Kategorie]  │
+│  Allgemein         │                                   │
+│  Ausführung        │                                   │
+│  Prime Claude      │                                   │
+│                    │                                   │
+│ ERWEITERT          │                                   │
+│  Worktrees         │                                   │
+│  Dateien & Prompts │                                   │
+│  Session Skills    │                                   │
+│  Berichte          │                                   │
+│  Online Inbox      │  (nur wenn ShowOnlineInbox)       │
+└────────────────────┴───────────────────────────────────┘
+                                   [Abbrechen] [Speichern]
+```
+
+**Kategorien-Inhalt.**
+
+| Kategorie | Inhalt | Herkunft |
+|---|---|---|
+| Allgemein | Sprache, Accent-Preset, Default-Claude-Instructions | General |
+| Ausführung | Default-Model, Permission-Mode, Model-Presets-Tabelle, MaxTurns-Ceiling, Max parallele Ausführungen, Usage-Gate (5h/7d %) | General |
+| Prime Claude | Schedules + Daily-Prep-Max-Tasks | unverändert |
+| Worktrees | Strategie, Root, Auto-Cleanup, Cleanup-/Reset-Aktionen | unverändert |
+| Dateien & Prompts | Agents-Restore, Prompt-Pfade, Customized-Prompts | unverändert (Files) |
+| Session Skills | **zusammengelegt**: je installierter Skill eine Zeile mit Checkbox (global aktiv) + Update/Remove; darunter Install-URL | Skills-Tab + Checkbox-Liste aus General |
+| Berichte | Standup-Wochentag, Report-Excluded-Paths | General (neu herausgelöst) |
+| Online Inbox | unverändert, weiter an `ShowOnlineInbox` gekoppelt | unverändert |
+
+**Session-Skills-Zusammenlegung.** Die Checkbox-Liste im General-Tab entfällt. Beide VMs
+(`GeneralSettingsTabViewModel.SessionSkills`, `SessionSkillsSettingsTabViewModel`) speisen künftig
+**eine** Liste; die Auswahl (global aktive Skills) wird weiterhin über denselben Pfad gespeichert
+wie heute. Der Task muss belegen, dass Speichern/Laden der Auswahl unverändert funktioniert —
+das ist die einzige Stelle mit echtem Regressionsrisiko.
+
+**Repo-Hinweis statt Verstecken.** Nichts wird ausgeblendet (verschwindende Einstellungen
+irritieren in einem Power-Tool mehr als Dichte). Stattdessen zeigen **Worktrees, Prime Claude,
+Session Skills und Berichte** oben einen Hinweisstreifen, solange keine Liste ein `WorkingDir`
+hat: *„Wirkt erst mit verknüpftem Repo"* + Link, der den Repo-Import öffnet. Dafür eine neue
+Property `HasLinkedRepo` am `SettingsModalViewModel`.
+
+**Umsetzung risikoarm.** Das `TabControl` **bleibt** als Content-Host: nur der TabStrip wird
+ausgeblendet, und eine Sidebar-`ListBox` bindet `SelectedIndex`. Die vorhandenen Panel-Inhalte
+wandern damit nahezu unverändert mit (General wird gesplittet, Skills gemerged, Berichte neu).
+Keine Neuschrift der 556 AXAML-Zeilen, compiled bindings bleiben intakt. Sidebar-Modell:
+`SettingsCategory(Key, Label, Group, IsVisible, RequiresRepo)` in `SettingsModalViewModel.Categories`.
+Fensterbreite 580 → 700.
+
+---
+
+## 3. TaskRow-Dichte
+
+**Problem.** Eine Zeile kann 16 Elemente zeigen. Die Maximaldichte trifft real fast nur einen
+`WaitingForReview`-Task in einer Smart-List (Status-, List-, Branch-, Diff-Chip plus Icons und
+Buttons) — aber genau dort ist die Zeile am schwersten zu lesen.
+
+**Entscheidung: Zustand bleibt, Aktionen auf Hover-oder-Selektion, reine Metadaten raus.**
+
+| Klasse | Elemente |
+|---|---|
+| **Immer sichtbar (Zustand)** | Chevron (Planning-Parent), Done-Toggle, `#Nummer`, Titel, die vier Badges (DRAFT/PLANNED/Planning/MANUAL), Roadblock-Icon, Agent-Suggested-Icon, Status-Chip (bleibt tappbar → Mission Control), Diff-Chip, List-Chip (nur Smart-Lists, wie heute), Chain-Chip/Chain-Step-Badge, **gesetzter** Star |
+| **Hover ODER Selektion (Aktion)** | Refine-Button, **ungesetzter** Star, Dequeue-X |
+| **Aus der Zeile raus** | Branch-Chip |
+
+**Kein Funktionsverlust.** Refine, Star und Dequeue bleiben über das Kontextmenü erreichbar —
+„Remove from queue" existiert dort, „Refine task" wird in Thema 1 neu ergänzt. Selektion als
+zweiter Trigger deckt Tastaturbedienung ab.
+
+**Ausnahme.** Der Refine-**Spinner** (`IsRefining`) bleibt immer sichtbar. Ein laufender Refine
+darf nicht verschwinden, wenn die Maus die Zeile verlässt.
+
+**Branch-Chip: Verlagerung, nicht Löschung.** Der Branch-Name steht heute **nirgends** im
+Detail-Pane (geprüft gegen `DetailsIslandView.axaml` und `Views/Islands/Detail/*.axaml` —
+kein Treffer außer der Merge-Target-ComboBox). Er muss deshalb im selben Task in die
+`TaskHeaderBar` als Meta-Zeile aufgenommen werden. `WorkConsole.axaml` fasst dieser Task
+**nicht** an (Datei-Eigentum, siehe Plan).
+
+**Umsetzung.** `TaskRowViewModel` bekommt `IsHovered` (gesetzt über `PointerEntered`/
+`PointerExited` in `TaskRowView.axaml.cs`) und ein berechnetes
+`ShowRowActions => IsHovered || IsSelected`. Die neuen Sichtbarkeiten sind **AND**-Verknüpfungen
+mit den bestehenden `CanRefine` / `CanRemoveFromQueue` / `IsStarred` — keine bestehende Bedingung
+wird ersetzt. Layout-Sprünge vermeiden: die Buttons behalten ihre Grid-Spalten
+(`Auto,Auto,32`), es wechselt nur die Sichtbarkeit innerhalb fester Breite.
+
+**Ergebnis:** Worst case ohne Hover 16 → 9 Elemente.
+
+---
+
+## 4. Erststart
+
+**Problem.** Nach dem Seeding existieren nur My Day / Important / Planned und kein Repo. Es gibt
+kein Onboarding; die Empty States aus #192 beschreiben den Ist-Zustand, aber nicht die Reihenfolge
+Repo → Liste → Task → Queue → Review.
+
+**Entscheidung: kein Onboarding-Konstrukt.** Ein zustandsgetriebenes Banner plus eine abgestimmte
+Textkette. Explizit **kein** Wizard, **kein** Willkommens-Modal, **kein** Onboarding-Zustand in
+DB oder Config.
+
+**Banner** im Lists-Island direkt unter dem Header, optisch wie das bestehende Update-Banner des
+Shells (kein neues Stil-Vokabular):
+
+```
+┌──────────────────────────────────────────────┐
+│ Noch kein Repo verknüpft. ClaudeDo führt     │
+│ Tasks in einem Git-Repo aus.                 │
+│                        [ Repo importieren ]  │
+└──────────────────────────────────────────────┘
+```
+
+- Sichtbar, solange **keine User-Liste ein `WorkingDir` hat**. Neue Property `HasNoLinkedRepo`
+  am `ListsIslandViewModel`, neu berechnet beim Listen-Load und nach List-CRUD /
+  List-Settings-Save.
+- **Kein Dismiss, kein persistierter Zustand.** Wer sein einziges Repo entfernt, bekommt den Weg
+  zurück wieder gezeigt.
+- Der Button ruft das vorhandene `OpenRepoImportCommand` (dritter Einstieg neben dem Header-Button
+  und `Menü → Add repos`).
+
+**Textkette.** Die Stellen müssen als ein Weg lesbar sein. Die Keys aus #192 existieren zu diesem
+Zeitpunkt schon und werden nur nachgeschärft:
+
+1. Banner → *Repo importieren*
+2. Task-Liste leer, Liste **ohne** Repo (#192) → *Diese Liste hat kein Repo; in den List-Settings
+   verknüpfen*
+3. Task-Liste leer, Liste **mit** Repo (#192) → *Task anlegen, dann Rechtsklick → „Send to queue" —
+   Claude arbeitet ihn in einem eigenen Worktree ab*
+4. Review-Stufe: am Approve-Gate-Hinweis (den #190 in `WorkConsole.axaml` baut) **eine** Zeile
+   ergänzen, die sagt, dass Approve gleichzeitig das Mergen ist.
+
+Punkt 3 erklärt die Queue genau dort, wo der erste Task entsteht. Punkt 4 schließt die Lücke,
+dass der erste fertige Run in einem Zustand landet, den nichts ankündigt.
+
+---
+
+## Nicht Teil dieses Designs
+
+- Der WorkConsole-Git-Tab (laut Audit das dichteste Panel der App) — eigenes Thema.
+- Mission Control und der Diff-Viewer.
+- Alles, was #189–#192 schon abdecken.

docs/superpowers/specs/2026-08-24-prime-action-kind-design.md

@@ -0,0 +1,144 @@
+# Prime Claude: per-schedule action kind
+
+**Date:** 2026-08-24
+**Status:** approved
+
+## Problem
+
+`PrimeRunner.FireAsync` is hardcoded to one action: build `DailyPrepPrompt`, run `claude -p`
+with the two MyDay MCP tools, let Claude fill MyDay. A Prime schedule is therefore always a
+"fill my day" run, even when all the user wants is to open the usage window, or to run some
+other recurring instruction.
+
+## Goal
+
+Each Prime schedule picks one of three actions:
+
+| Kind | What it does |
+|---|---|
+| `Ping` | Fires one throwaway `claude -p` turn to open the usage window. Nothing else. **Default for new schedules.** |
+| `FillMyDay` | Today's behaviour: daily-prep prompt, MyDay selection capped by `DailyPrepMaxTasks`. |
+| `Custom` | Runs the schedule's own prompt with the ClaudeDo MCP tools available. |
+
+## Data
+
+New enum in `ClaudeDo.Data.Models`:
+
+```csharp
+public enum PrimeActionKind { Ping = 0, FillMyDay = 1, Custom = 2 }
+```
+
+`PrimeScheduleEntity` gains `public PrimeActionKind Kind { get; set; } = PrimeActionKind.Ping;`,
+mapped in `PrimeScheduleEntityConfiguration` to column `action_kind`, required, default value
+`PrimeActionKind.Ping` — the same shape as the existing `days_of_week` mapping.
+
+Migration `AddPrimeActionKind`, based on `20260821155619_AddUsageLimitAutoContinue` (current
+head — check for a newer head before scaffolding; sibling migrations off the same parent
+silently drop each other's columns on a SQLite table rebuild).
+
+**Existing rows migrate to `Ping`** (column default 0, no data backfill). This is a deliberate
+behaviour change requested by the user: today's schedules stop filling MyDay until he switches
+them back in Settings. Do not "helpfully" backfill them to `FillMyDay`.
+
+`prompt_override` is reused rather than split, with a role that depends on `Kind`:
+
+| Kind | `prompt_override` means |
+|---|---|
+| `Ping` | ignored |
+| `FillMyDay` | an *addition*, appended to the daily-prep prompt (unchanged from today) |
+| `Custom` | the *entire* prompt, used verbatim |
+
+`PrimeScheduleRepository.UpsertAsync` must copy `Kind` onto the existing row alongside
+`Days`/`TimeOfDay`/`Enabled`/`PromptOverride`. Forgetting it is silent — the update just keeps
+the old kind.
+
+## Worker
+
+`PrimeScheduleDto` gains `PrimeActionKind Kind`. `PrimeScheduler.ToDto` maps it.
+
+`PrimeRunner.FireAsync` keeps its single-flight `SemaphoreSlim` gate (it guards *all* kinds —
+two schedules must never overlap regardless of kind) and its `FireTimeout`, then branches:
+
+| Kind | Prompt | CLI args | Log file | `PrepStarted`/`PrepLine`/`PrepFinished` |
+|---|---|---|---|---|
+| `Ping` | fixed one-liner, not user-editable | `-p --output-format stream-json --verbose --permission-mode default --max-turns 1 --strict-mcp-config` | none | not raised |
+| `FillMyDay` | `DailyPrepPrompt.BuildPrompt(maxTasks, today, promptOverride)` | unchanged (`DailyPrepPrompt.BuildArgs`) | `daily-prep.log`, truncated per run | raised |
+| `Custom` | `promptOverride` verbatim | `-p --output-format stream-json --verbose --permission-mode acceptEdits --max-turns 30 --allowedTools mcp__claudedo` | none | not raised |
+
+`--strict-mcp-config` without a `--mcp-config` argument loads no MCP server at all, so a Ping
+cannot reach ClaudeDo's tools even if the model tries. Combined with `--max-turns 1` a Ping is
+one turn and done.
+
+`Custom` deliberately gets **only** the ClaudeDo MCP server — no Read/Write/Edit/Bash. An
+unattended 07:00 run should be able to create and queue tasks, not touch the filesystem.
+
+All three kinds still:
+- run in `Paths.AppDataRoot()` as cwd,
+- update `last_run_at` (in `PrimeScheduler.FireAsync`, unchanged),
+- broadcast `PrimeFired(scheduleId, success, message, firedAt)`, which drives the footer flash.
+
+`WorkerHub.RunDailyPrepNow` builds its synthetic `PrimeScheduleDto` with
+`Kind: PrimeActionKind.FillMyDay`. The "Plan day" button in the MyDay panel means "fill my day"
+and must keep meaning that no matter how the schedules are configured.
+
+`WorkerHub.UpsertPrimeSchedule` rejects `Kind == Custom` with a blank `PromptOverride`, so a
+schedule can never fire `claude -p ""` at 07:00.
+
+## UI
+
+`PrimeScheduleRowViewModel` gains `[ObservableProperty] PrimeActionKind _kind` plus three
+derived booleans for radio binding — `IsPing`, `IsFillMyDay`, `IsCustom`. Setting a boolean to
+`true` sets `Kind`; `OnKindChanged` raises change notifications for all three. Three booleans
+rather than an enum-to-bool converter keeps compiled bindings straightforward.
+
+`PrimeClaudeTabViewModel.AddSchedule` creates rows with `Kind: PrimeActionKind.Ping`.
+
+`PrimeClaudeTabViewModel.Validate` adds: a `Custom` row with a blank prompt returns an error
+naming the row's time.
+
+`SettingsModalView.axaml`, Prime tab, inside the schedule `DataTemplate`:
+
+- A horizontal row of three `RadioButton`s bound to `IsPing`/`IsFillMyDay`/`IsCustom`.
+  **`GroupName` must be per-row unique** (bind it to the row `Id`) — a shared group name makes
+  every schedule in the `ItemsControl` share one selection.
+- The prompt `TextBox` is hidden when `IsPing`, and its label switches between the existing
+  "Prompt addition" (FillMyDay) and a new "Prompt" (Custom).
+- The `DailyPrepMaxTasks` `NumericUpDown` below the list is disabled when no row is
+  `FillMyDay`, via a computed `AnyFillMyDay` on the tab VM that recomputes on row add/remove
+  and on `Kind` changes. A live number that controls nothing is worse than a greyed-out one.
+
+New locale keys in both `en.json` and `de.json` (parity is test-enforced):
+`settings.prime.actionLabel`, `actionPing`, `actionFillMyDay`, `actionCustom`, `actionHint`,
+`customPromptLabel`, `customPromptPlaceholder`, `maxTasksDisabledHint`. The tab's existing
+`description` is reworded — it currently claims every schedule fires a ping.
+
+The validation message stays a hardcoded English string in `PrimeClaudeTabViewModel.Validate`,
+matching the messages already there ("select at least one day.").
+
+## Tests
+
+**Worker.Tests**
+- `PrimeRunnerTests`: one test per kind against the fake CLI runner asserting the args and the
+  prompt handed to it; a `Ping` run writes no log file and raises no `Prep*` events; a
+  `FillMyDay` run still does both.
+- `PrimeScheduleRepositoryTests`: `Kind` round-trips, and `UpsertAsync` on an existing row
+  updates it.
+- Migration default: a schedule row created before the column exists reads back as `Ping`.
+
+**Ui.Tests**
+- `PrimeClaudeTabViewModelTests`: a new row defaults to `Ping`; setting `IsCustom` flips `Kind`
+  and clears the other two; `Validate` rejects `Custom` with a blank prompt; `AnyFillMyDay`
+  tracks row changes.
+
+`Localization.Tests` covers the new keys' en/de parity automatically.
+
+## Out of scope
+
+- No new log file or log viewer for Ping/Custom. The existing `daily-prep.log` and its
+  `ShowPrepLogCommand` viewer stay exactly as they are, now fed only by `FillMyDay`.
+- No per-kind model/effort override — all kinds use whatever the Prime path uses today.
+
+## Visual verification gap
+
+The radio-group layout inside the schedule card, the hidden/relabelled prompt box, and the
+disabled `DailyPrepMaxTasks` field cannot be verified headlessly. The user does the visual pass.

docs/superpowers/specs/2026-08-24-tokentracker-usage-analytics-design.md

@@ -0,0 +1,198 @@
+# TokenTracker als Auswertungs-Backend für die Token-Analytics
+
+**Datum:** 2026-08-24
+**Status:** freigegeben, Implementierung offen
+
+## Problem
+
+ClaudeDo pflegt zwei eigene Token-Datenpfade:
+
+1. `ClaudeOAuthUsageClient` (170 Zeilen) — pollt `https://api.anthropic.com/api/oauth/usage`
+   für die 5h-/7d-Limits. Speist Pill, Gauges, `UsageGate` und `UsageThrottle`.
+2. `TranscriptUsageReader` (161 Zeilen) — parst `~/.claude/projects/**/*.jsonl` und aggregiert
+   nach Datum/Modell/Scope für die Analytics-Ansicht im Usage-Monitor.
+
+Pfad 2 ist der teure und undankbare Teil: ein Voll-Scan über die Transkript-Historie (gemessen
+2026-08-06: 501 Dateien / 230 MB, ein 7-Tage-Range berührt ~190 Dateien / ~106 MB), eigener
+mtime/Length-Cache, `requestId`-Dedupe, `<synthetic>`-Filter — und trotzdem ohne Kosten in USD,
+weil wir keine Preistabelle pflegen.
+
+[TokenTracker](https://github.com/xiufengsun/TokenTracker) (MIT, Node 20+) macht genau diese
+Auswertung als Kernprodukt, inklusive gepflegter Preistabelle. Ziel: die **Auswertung** abgeben,
+die **Darstellung** in ClaudeDo behalten.
+
+## Nicht-Ziel: Limits, Gate, Throttle
+
+Die 5h-/7d-Limits bleiben bei unserem eigenen OAuth-Poll. Begründung (gegen den installierten
+TokenTracker verifiziert, 2026-08-24):
+
+- `~/.tokentracker/tracker/claude-usage-limits-cache.json` hat **exakt die Shape unserer
+  OAuth-Antwort** (`five_hour` / `seven_day` / `seven_day_opus` / `weekly_scoped` /
+  `extra_usage`) — dieselbe Quelle, kein inhaltlicher Gewinn.
+- Der Cache war zum Prüfzeitpunkt **13 Tage alt** (`cached_at: 2026-08-11`), während die
+  Token-Queue desselben Tools von heute war. Ein Gate, das über das Starten von Tasks
+  entscheidet, darf nicht an einem Cache hängen, der still veraltet.
+
+`UsageState`, `UsageMonitorService`, `UsageSnapshotBuilder`, `UsageGate`, `UsageThrottle`,
+`UsagePillViewModel` und die Gauges bleiben unangetastet.
+
+## Datenquelle
+
+`tokentracker sessions --from YYYY-MM-DD --to YYYY-MM-DD --no-git --format json`
+
+Dokumentiert in `tokentracker --help`. Liefert pro Session:
+
+```json
+{
+  "session_hash": "51d4de2afadecd97f9a600ad",
+  "source": "claude",
+  "project_key": "ClaudeDo",
+  "model": "claude-opus-5",
+  "started_at": "2026-08-24T07:38:03.653Z",
+  "ended_at": "2026-08-24T07:48:04.728Z",
+  "turns": 1, "edit_turns": 0, "retry_turns": 0,
+  "tokens": { "input_tokens": 32, "cached_input_tokens": 1063433,
+              "cache_creation_input_tokens": 67524, "output_tokens": 14048,
+              "reasoning_output_tokens": 0, "total_tokens": 1145037 },
+  "total_tokens": 1145037,
+  "cost_usd": 1.3051015,
+  "productive": false, "first_pass": false, "one_shot": false,
+  "provenance": { "source": "local-session-log", "content_retained": false },
+  "version": 11
+}
+```
+
+Dazu fertige Aggregate `totals` und `by_model` (die wir nicht verwenden, siehe *Caching*).
+
+### Verifizierte Eigenschaften
+
+| Behauptung | Befund |
+|---|---|
+| Rein lokal | `buildSessionAnalytics` liest `~/.claude/projects/**` direkt (`lib/session-analytics.js:976-979`). Kein Account, kein Netzwerk, keine Hooks nötig. |
+| Kein `init` erforderlich | Der Export funktioniert mit dem bloßen npm-Paket. |
+| Join auf unsere Runs möglich | `session_hash = sha256("claude\0" + sessionId).hex[0..24]` (`lib/session-analytics.js:88`), deterministisch in .NET nachrechenbar. |
+| Worktree-Sessions enthalten | Drei ClaudeDo-Worktree-Sessions aus `~/.claude/projects/…claudedo-worktrees-…` per Hash im Export gefunden (2026-08-24). Der Kommentar auf `:149` über „throwaway per-agent checkouts" betrifft nur die Projekt-Attribution, nicht das Verwerfen von Sessions. |
+| `project_key` ist für uns unbrauchbar | Bei Worktrees fällt er teils auf die nackte Worktree-GUID zurück (`11da6ebb-…` u. a. im Export). Deshalb joinen wir über `session_hash`, nie über `project_key`. |
+| Laufzeit | **11,5 s** für einen 1-Tages-Range (gecacht). `buildSessionAnalytics` läuft immer über die gesamte Historie; `--from`/`--to` filtern erst in `summarizeSessions`. Also kein Performance-Gewinn gegenüber unserem Reader (1,7 s kalt) — der Gewinn liegt bei Kosten, Effizienzmetriken und entfallender Pflege. |
+
+### Warum kein `tokentracker init`
+
+`init` schreibt `Stop`- und `SessionEnd`-Hooks in die **globale** `~/.claude/settings.json` und
+aktiviert Cloud-Sync (`cloud-sync-pref.enabled: true`) zu `srctyff5.us-east.insforge.app`. Der
+Upload enthält u. a. `project_ref` — auf dieser Maschine `https://git.kuns.dev/releases/ClaudeDo`,
+also einen internen Hostnamen. Das ist eine zu weitgehende Nebenwirkung, um sie hinter einen
+Button in ClaudeDo zu legen. ClaudeDo ruft ausschließlich `sessions` auf und nie `init`.
+Wer Dashboard und Cloud-Sync will, richtet das selbst ein.
+
+## Architektur
+
+Neuer Ordner `src/ClaudeDo.Worker/Usage/TokenTracker/`:
+
+| Typ | Rolle |
+|---|---|
+| `ITokenTrackerClient` (in `Interfaces/`) | `Task<TokenTrackerExport?> ExportAsync(DateOnly from, DateOnly to, CancellationToken)` + `Task<TokenTrackerProbe> ProbeAsync(CancellationToken)` |
+| `TokenTrackerClient` | Startet den Prozess, liest stdout, parst JSON. Timeout 120 s, danach Prozessbaum killen. Auflösung der Binary über `ExecutableResolver` (`ClaudeDo.Data`) wie beim `claude`-CLI, inklusive `.cmd`-Shim-Start über `cmd.exe /c`. **Nie `npx`** — das würde still nachladen. |
+| `TokenTrackerProbe` | `(bool Installed, string? Version, bool NodeOk, string? NodeVersion, string? Error)`. `tokentracker -v` und `node --version`; Ergebnis gecacht bis zu einem expliziten Re-Probe. |
+| `TokenTrackerState` | Threadsafe Singleton nach Vorbild von `UsageState`: letztes gutes `TokenTrackerExport`, `FetchedAtUtc`, `LastError`. **Ein Fehler überschreibt nie ein gutes Snapshot.** |
+| `TokenTrackerModels` | `TokenTrackerExport`, `TokenTrackerSession`, `TokenTrackerProbe`. |
+| `TokenTrackerAggregator` | Pure statisch: filtert `sessions[]` auf einen Range und aggregiert nach Modell bzw. nach Task. Keine I/O, voll testbar. |
+| `TokenTrackerInstaller` | Führt `npm i -g tokentracker-cli` aus und streamt stdout/stderr zeilenweise an den Aufrufer; danach Re-Probe. |
+
+### Caching und Refresh
+
+- Ein Fetch holt ein **90-Tage-Fenster** und wird gecacht. Alle Ansichten (7d/30d/custom) werden
+  lokal aus `sessions[]` gefiltert und aggregiert — daher verwenden wir `totals`/`by_model` aus dem
+  Export nicht, sondern rechnen selbst aus den Session-Zeilen. Range-Wechsel im Modal sind damit
+  instant, die 11,5 s fallen nur beim Refresh an.
+- Refresh-Auslöser: Modal-Open, wenn das Snapshot älter als 15 min ist (im Hintergrund, nie
+  UI-blockierend), plus ein manueller Refresh-Button. Die UI zeigt „Stand: hh:mm".
+- Ist gar kein Snapshot da, zeigt der Analytics-Block einen Ladezustand, nie leere Nullwerte.
+
+### Versionsschutz
+
+`sessions` ist kein zugesagter API-Vertrag. Wir prüfen das `version`-Feld der Session-Zeilen
+(aktuell `11`). Bei unbekannter Version zeigt der Analytics-Block einen Klartext-Hinweis
+(„Auswertung nicht verfügbar: unerwartetes TokenTracker-Format vX") statt Zahlen zu erfinden.
+Fehlende Felder werden defensiv als `null`/`0` behandelt, ein Parse-Fehler landet in
+`LastError` und lässt das letzte gute Snapshot stehen.
+
+## Hub-Oberfläche
+
+- **`GetModelUsage(from, to)`** behält Namen und Aufrufer, speist sich aber aus
+  `TokenTrackerState`. `ModelUsageRowDto` bekommt ein zusätzliches `double? CostUsd`.
+  Der Scope-Split `claudedo` / `other` kommt jetzt aus der **`session_hash`-Mitgliedschaft in
+  `task_runs`** statt aus der Pfad-Heuristik des alten Readers — das ist genauer, weil
+  Worktree-Pfade und die GUID-Fallbacks von `project_key` keine Rolle mehr spielen.
+- **`GetTaskUsage(from, to)`** bleibt `task_runs`-basiert (sofort verfügbar, funktioniert ohne
+  TokenTracker). `TaskUsageRowDto` wird um `double? CostUsd`, `int? Retries`, `bool? Productive`,
+  `bool? OneShot` erweitert. Gefüllt werden diese Felder über die `SessionId` der Runs des Tasks →
+  Hash → passende TokenTracker-Session; ohne Snapshot bleiben sie `null`.
+- **Neu `GetTokenTrackerStatus()`** → `TokenTrackerStatusDto(bool Installed, string? Version,
+  bool NodeOk, string? NodeVersion, DateTime? LastFetchedUtc, string? LastError,
+  int? FormatVersion)`.
+- **Neu `RefreshTokenTrackerAsync()`** → erzwingt einen Fetch (für den Refresh-Button).
+- **Neu `InstallTokenTrackerAsync()`** → startet `npm i -g tokentracker-cli`; Fortschritt läuft
+  über den bestehenden `OperationProgress`-Kanal, Ausgabezeilen über `WorkerLog`.
+
+`IWorkerClient` und `WorkerClient` in `ClaudeDo.Ui` spiegeln alles.
+
+## UI
+
+Nur der Analytics-Teil des Usage-Monitors ändert sich; Gauges, Legenden, Drag-Marker und die
+Pill bleiben wie sie sind.
+
+**Mit TokenTracker:**
+
+- Kopfzeile des Analytics-Blocks: Total Tokens **und Total Cost (USD)** für den Range,
+  plus „Stand: hh:mm" und Refresh-Button.
+- Breakdown pro Modell: Tokens (In/Out/Cache) + USD, weiterhin mit ClaudeDo-/Other-Split.
+- Breakdown pro Task: bestehende Spalten + USD + Retries + Effizienz-Marker
+  (`productive` / `one_shot`).
+
+**Ohne TokenTracker** steht an derselben Stelle eine Hinweis-Karte:
+
+> Die Token-Auswertung übernimmt TokenTracker (MIT, läuft rein lokal, liest keine Prompts).
+> ClaudeDo ruft nur den lokalen Export auf und aktiviert **kein** `init`, keine Hooks und keinen
+> Cloud-Sync.
+
+mit Button **TokenTracker installieren** → `npm i -g tokentracker-cli`. Die Ausgabezeilen laufen
+über `WorkerLog` in die Footer-Leiste, die Karte selbst zeigt die jeweils letzte Zeile als
+Statuszeile; danach automatischer Re-Probe. Fehlt Node 20+, zeigt die Karte statt des Buttons den
+Node-Hinweis samt Versionsangabe. Die Task-Tabelle bleibt in diesem Zustand funktionsfähig, nur
+ohne die USD-/Effizienz-Spalten. Fehler beim Installieren gehen über `FlashFooterError`, nicht in
+ein `catch {}`.
+
+## Was entfällt
+
+- `TranscriptUsageReader.ReadAsync` samt Datums-/Modell-/Scope-Aggregation, mtime/Length-Cache,
+  `requestId`-Dedupe und dem 106-MB-Scan (~120 der 161 Zeilen).
+- `ITranscriptUsageReader` schrumpft auf `ReadSessionTotalsAsync`.
+- `UsageAggregateRow` / `UsageScope`, falls nach dem Umbau ohne Konsumenten.
+
+`ReadSessionTotalsAsync` **bleibt**: das Per-Run-Accounting in `TaskRunner.ApplyUsageAsync`
+schreibt `task_runs.tokens_*` direkt am Ende eines Runs und darf nicht auf einen 11 s
+dauernden Batch-Export warten.
+
+## Tests
+
+- Ein anonymisiertes, eingechecktes Export-Fixture (JSON) für Parser und `TokenTrackerAggregator`:
+  Range-Filter, Modell-Aggregation, Task-Aggregation, Kostensummen.
+- `session_hash`-Test: bekannte Session-ID → erwarteter Hash (Gegenprobe zu
+  `sha256("claude\0" + id)[0..24]`).
+- Join-Test: `task_runs`-Zeilen mit Session-IDs + Fixture → erwartete USD/Effizienz pro Task.
+- Fail-open-Tests: Binary fehlt, Exit-Code ≠ 0, Timeout, kaputtes JSON, unbekannte
+  `version` — jeweils letztes gutes Snapshot bleibt stehen, `LastError` gesetzt.
+- **Kein Test ruft das echte CLI auf** (analog zur Regel für den `claude`-CLI). `ITokenTrackerClient`
+  wird gefakt.
+- Fakes in `Worker.Tests` und `Ui.Tests` nachziehen: `IWorkerClient`, `WorkerHub` und die
+  erweiterten DTOs brechen die handgeschriebenen Fakes in beiden Projekten.
+
+## Offene Verifikationspunkte
+
+- Visueller Pass für den umgebauten Analytics-Block und die Hinweis-Karte (beide Zustände:
+  installiert / nicht installiert) — muss der Nutzer prüfen.
+- Einmal echt gegen ein System ohne TokenTracker: Probe, Hinweis-Karte, Install-Button,
+  Re-Probe, erste Auswertung.
+- Nach dem Umbau `docs/explore-notes/usage-monitoring.md` fortschreiben (Abschnitte
+  *Per-run token accounting*, *UI surfaces*, *Hub surface*) und den „verified against"-Commit
+  anheben.

docs/superpowers/specs/2026-08-27-ticketsystem-integration-design.md

@@ -0,0 +1,210 @@
+# Ticketsystem-Anbindung (Bandel TicketSystem)
+
+Datum: 2026-08-27
+Status: Design freigegeben, Umsetzung offen
+
+## Ziel
+
+Tickets aus dem hauseigenen Ticketsystem (`Bandel.APIs`) pro Projekt in eine ClaudeDo-Liste
+importieren und den Ticket-Status automatisch nachziehen, während der Task durch die Queue läuft.
+
+Das Feature ist **vollständig optional**: ohne konfigurierte Base-URL passiert nichts — kein
+Netzwerkverkehr, kein Hook, kein sichtbarer Menüeintrag.
+
+## Nicht-Ziele (bewusst weggelassen)
+
+| Weggelassen | Wann nachrüsten |
+|---|---|
+| Polling / Hintergrund-Sync | Wenn der manuelle Import spürbar nervt |
+| Zwei-Wege-Sync (Ticket-Änderung → Task) | Wenn Titel/Beschreibung real auseinanderlaufen |
+| Jira-Provider + `ITicketProvider`-Interface | Wenn Jira tatsächlich kommt — Interface-Extract ist ein Rider-Refactor von 30 s |
+| Update bereits importierter Tickets | Würde Task-Notizen überschreiben; erst mit klarer Merge-Regel |
+| Kommentar ans Ticket beim Merge | Wenn die Rückverfolgbarkeit fehlt |
+
+Der einzige Vorgriff auf Jira ist das Provider-Präfix in `TaskEntity.TicketRef` (`bandel:1234`).
+Das kostet nichts und erspart später eine Migration.
+
+## Externe API
+
+Base-URL: `http://bandelapis.fb-tuning.local`
+Auth: derselbe Personal Access Token (`tsp_…`), den auch der Ticket-MCP nutzt.
+Die relevanten Endpunkte akzeptieren `[Authorize(AuthenticationSchemes = "Bearer,Pat")]`.
+
+| Zweck | Endpoint | Scope |
+|---|---|---|
+| Token-Inhaber ermitteln | `GET /api/ticketsystem/pat/me` | — (keine Scope-Policy) |
+| Projekte je Abteilung | `GET /api/Navigation/sidebar` | `pat:projects:read` |
+| Board eines Projekts | `GET /api/Board/project/{projectId}` | `pat:board:read` |
+| Status setzen | `PATCH /api/Ticket/{id}/status` | `pat:tickets:write` |
+
+Antworten sind in `BandelApiResponse<T>` gewrappt (`{ Success, Data, Message, ErrorCode }`).
+Das Board liefert `GetTicketSummaryDto` mit u. a. `Id`, `Title`, `Description`, `StatusId`,
+`StatusName`, `AssigneeID`, `AssigneeName`.
+
+Ticket-Status: `0 Keine`, `1 Offen`, `2 InBearbeitung`, `3 Fertig`, `4 Archiviert`.
+
+> **Nicht verifiziert:** Die API läuft auf srv-04b, gegen den hier nicht geprobt wurde. Die
+> Endpunkte und DTO-Felder stammen aus dem Quellcode von `Bandel.APIs`, nicht aus einem
+> Live-Aufruf. Der erste manuelle Smoke-Test muss die tatsächlichen Response-Shapes bestätigen
+> (siehe „Manuelle Verifikation").
+
+## Konfiguration
+
+### Global
+
+- Base-URL: `ticket_api_base_url` in `~/.claudeDo/worker.config.json`. Null/leer = Feature aus.
+  > Der Plan weicht hier bewusst vom ursprünglichen Entwurf ab (der eine Spalte in
+  > `AppSettingsEntity` vorsah): `WorkerConfig.SaveKey` kann das read-modify-write bereits
+  > generisch, `claude_bin` ist der Präzedenzfall für ein UI-schreibbares Feld in dieser Datei,
+  > und weil `WorkerConfig` ein DI-Singleton ist, kommt der Hook in `TaskStateService` ohne
+  > DB-Abfrage aus. Spart zugleich eine Migrationsspalte.
+- PAT: DPAPI-verschlüsselt in `~/.claudeDo/ticket.pat`, **CurrentUser-Scope**.
+  `OnlineTokenStore` macht das bereits exakt so — ihm fehlt nur ein Dateiname-Parameter im
+  parameterlosen Ctor. Der wird zum optionalen Argument, die Klasse wandert nach
+  `ClaudeDo.Worker/` (raus aus `Online/`) und wird von beiden Features genutzt.
+  **Kein neuer Krypto-Code.**
+
+Der Token landet nie in `worker.config.json` und nie in der DB.
+
+### Pro Liste
+
+- `ListConfigEntity.TicketProjectId` (`int?`, Spalte `ticket_project_id`).
+  Null = Liste ist nicht mit einem Ticket-Projekt verknüpft.
+
+> ⚠️ **Verbatim-Copy-Falle:** `ListRepository.SetConfigAsync` überschreibt jede Spalte mit dem
+> übergebenen Entity. Jeder Writer (`set_list_config` MCP-Tool, Listen-Settings-Modal) muss
+> `TicketProjectId` mitführen, sonst setzt der nächste fremde Schreibvorgang die Verknüpfung
+> still zurück — derselbe Fehler, der `SessionSkills` schon einmal getroffen hat.
+
+## Datenmodell
+
+- `TaskEntity.TicketRef` (`string?`, Spalte `ticket_ref`) — Format `<provider>:<id>`, aktuell
+  immer `bandel:<ticketId>`. Kein Index nötig; der Import filtert über die Liste, nicht global.
+- `ListConfigEntity.TicketProjectId` (`int?`)
+- `AppSettingsEntity.TicketApiBaseUrl` (`string?`)
+
+Eine EF-Migration mit drei Spalten über drei Tabellen.
+
+> ⚠️ **Migrations-Kollision:** Parallel entstandene Migrationen vom selben Elternknoten löschen
+> sich bei einem SQLite-Table-Rebuild gegenseitig die Spalten weg, und die Tests laufen mit
+> `EnsureCreated` und merken es nicht. Diese Migration entsteht als einzelne, nachdem alle
+> parallelen Tasks gemergt sind — nicht in einem Nebenläufer.
+
+## Import: „Update from Ticketsystem"
+
+Einstieg: Kontextmenü der Liste in `ListsIslandView.axaml`, direkt über „Einstellungen".
+Sichtbar nur, wenn Base-URL gesetzt **und** die Liste ein `TicketProjectId` hat.
+
+Ablauf (Worker, über eine neue Hub-Methode `ImportTicketsAsync(listId)`):
+
+1. `GET /api/ticketsystem/pat/me` → `UserName` des Token-Inhabers.
+2. `GET /api/Board/project/{TicketProjectId}` → Board-Items.
+3. Filtern auf `StatusId == 1` (Offen) **und** `AssigneeName == UserName`
+   (Ordinal, case-insensitive). Alles andere wird ignoriert.
+4. Bereits vorhandene `TicketRef`-Werte der Liste laden; Treffer überspringen.
+5. Pro verbleibendem Ticket ein Task via `TaskRepository.AddAsync`:
+   - `Status = Idle`, `ListId` = die Liste
+   - `Title` = Ticket-Titel
+   - `Description` = Ticket-Beschreibung + Leerzeile + `Ticket #<id>`
+   - `TicketRef = "bandel:<id>"`
+   - `CreatedBy = "ticketsystem"`
+6. Ergebnis als Footer-Meldung: „12 Tickets geprüft, 3 neue Tasks."
+
+Der Import erzeugt nur `Idle`-Tasks — er queued nichts. Ob und wann etwas läuft, bleibt eine
+bewusste Nutzeraktion.
+
+**Warum Board-Filter statt `GET /api/Board/global/{userId}`:** Das globale Board wählt Items über
+Zuweisung *oder* Reporter *oder* PersonInCharge aus. Das ist breiter als „mir zugewiesen".
+Der Namensvergleich ist bewusst gewählt (`/pat/me` liefert keine UserId, und Benutzernamen
+ändern sich hier nicht).
+
+## Write-back: Hook in `TaskStateService`
+
+`TaskStateService` ist der einzige Ort im System, der `Status` schreibt. Ein Hook dort deckt
+Queue-Picker, Merge/Approve, Cancel, Reset und beide MCP-Oberflächen gleichzeitig ab — jede
+andere Stelle wäre ein Teilabdeckungs-Fix.
+
+| Task-Status | Ticket-Status |
+|---|---|
+| `Running`, `WaitingForReview` | `2 InBearbeitung` |
+| `Done` | `3 Fertig` |
+| alles andere (`Idle`, `Queued`, `WaitingForChildren`, `Failed`, `Cancelled`) | **kein Schreiben** |
+
+`1 Offen` wird nie geschrieben: das ist der Eingangszustand. Ein fehlgeschlagener oder
+abgebrochener Task lässt das Ticket bewusst auf `InBearbeitung` stehen — die Arbeit ist
+angefangen, nicht zurückgegeben.
+
+Auslösebedingungen (alle müssen gelten, sonst passiert nichts):
+
+- `task.TicketRef` ist gesetzt und beginnt mit `bandel:`
+- `TicketApiBaseUrl` ist konfiguriert und ein PAT liegt vor
+- der Zielstatus unterscheidet sich vom letzten geschriebenen (kein redundanter PATCH bei
+  `Running → WaitingForReview`, beide mappen auf `2`)
+
+Der Aufruf ist fire-and-forget mit `try/catch`: ein Fehler wird als Warnung geloggt (landet über
+`BroadcastLogSink` im Footer-Log-Strip) und beendet den Statuswechsel **nie**. Das Ticketsystem
+darf die Queue nicht anhalten können.
+
+## UI
+
+### Settings-Modal — neuer Tab „Ticketsystem"
+
+Unter „Erweitert", wie der Online-Inbox-Tab (`SettingsModalView.axaml`, `ErweitertCategories`):
+
+- Base-URL (Textfeld)
+- Personal Access Token (maskiert; gespeichert = Anzeige „gesetzt", nicht der Wert)
+- Button „Verbindung testen" → `GET /api/ticketsystem/pat/me`, zeigt Benutzername und die
+  gewährten Scopes an. Fehlt `pat:board:read` oder `pat:tickets:write`, wird das als Hinweis
+  ausgegeben — das ist der häufigste Konfigurationsfehler.
+
+Neues `TicketSettingsTabViewModel` neben `OnlineInboxSettingsViewModel`, gleiches Muster
+(`LoadAsync`, `IsBusy`, `StatusMessage`).
+
+### Listen-Settings-Modal — Projektzuordnung
+
+Ein Dropdown „Ticket-Projekt" mit den Projekten aus `GET /api/Navigation/sidebar`, gruppiert
+nach Abteilung, plus „— keins —". Lädt beim Öffnen des Modals, nur wenn eine Base-URL
+konfiguriert ist; sonst ist das Feld ausgeblendet.
+
+### Lokalisierung
+
+Alle neuen Strings in `locales/en.json` **und** `locales/de.json`. Die Parität wird von
+`Localization.Tests` erzwungen — beide Dateien müssen zusätzlich einzeln als JSON parsebar
+bleiben, ein kaputtes `de.json` wird sonst still verschluckt.
+
+## Fehlerbehandlung
+
+| Fall | Verhalten |
+|---|---|
+| Base-URL nicht gesetzt | Feature komplett inaktiv, Menüeintrag versteckt |
+| PAT fehlt/ungültig (401) | Import bricht mit Footer-Fehler ab; Write-back loggt Warnung |
+| Scope fehlt (403) | Wie 401, Meldung nennt den fehlenden Scope |
+| API nicht erreichbar | Timeout 10 s, Footer-Fehler, kein Retry |
+| Write-back schlägt fehl | Warnung im Log, Task-Statuswechsel geht durch |
+| Ticket im Ticketsystem gelöscht | PATCH liefert 404 → Warnung, `TicketRef` bleibt stehen |
+
+Kein `catch {}` ohne Meldung — Nutzeraktionen, die scheitern, erscheinen im Footer-Strip.
+
+## Tests
+
+Alle mit gefaktem `HttpMessageHandler`, kein echter Netzwerkaufruf, kein echtes `claude`:
+
+- Status-Mapping: jeder `TaskStatus` → erwarteter Ticket-Status bzw. „kein Aufruf"
+- Kein redundanter PATCH bei `Running → WaitingForReview`
+- Kein Aufruf ohne `TicketRef`, ohne Base-URL, ohne PAT
+- Write-back-Fehler (401/404/Timeout) lässt den Statuswechsel durchgehen
+- Import: filtert korrekt auf Assignee + `StatusId == 1`
+- Import: überspringt bereits importierte Tickets, legt keine Duplikate an
+- `SetConfigAsync` erhält `TicketProjectId`, wenn ein anderer Writer die Config anfasst
+- Locale-Parität en/de
+
+## Manuelle Verifikation (nicht automatisierbar)
+
+1. PAT in den Settings hinterlegen, „Verbindung testen" → korrekter Benutzername + Scopes.
+2. Liste mit Projekt `393 Bandel.LagerApp` verknüpfen, „Update from Ticketsystem" → nur eigene,
+   offene Tickets erscheinen als Tasks.
+3. Einen Task laufen lassen → Ticket steht im Ticketsystem auf `InBearbeitung`.
+4. Approve/Merge → Ticket steht auf `Fertig`.
+5. Base-URL leeren → Menüeintrag verschwindet, keine Netzwerkaufrufe mehr.
+
+Punkte 1–4 bestätigen zugleich die aus dem Quellcode abgeleiteten Response-Shapes.

global.json

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

src/ClaudeDo.App/App.axaml

@@ -13,7 +13,6 @@
             </ResourceDictionary.MergedDictionaries>
 
             <!-- Converters -->
-            <converters:NotNullToBoolConverter x:Key="NotNullToBool"/>
             <converters:StrikeIfTrueConverter  x:Key="StrikeIfTrue"/>
             <converters:EqStatusConverter      x:Key="EqStatus"/>
             <converters:UpperCaseConverter     x:Key="UpperCase"/>

src/ClaudeDo.App/App.axaml.cs

@@ -52,6 +52,7 @@ public partial class App : Application
             Dispatcher.UIThread.UnhandledException += (_, e) =>
             {
                 e.Handled = true;
+                Serilog.Log.Error(e.Exception, "Unhandled exception on the UI dispatcher");
                 shell.FlashFooterError(Loc.T("vm.shell.unexpectedError", e.Exception.Message));
             };
 

src/ClaudeDo.App/ClaudeDo.App.csproj

@@ -26,6 +26,8 @@
     </PackageReference>
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.1" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.1" />
+    <PackageReference Include="Serilog" Version="4.0.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>

src/ClaudeDo.App/Program.cs

@@ -13,6 +13,7 @@ using ClaudeDo.Ui.ViewModels.Modals;
 using ClaudeDo.Ui.ViewModels.Modals.Settings;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
+using Serilog;
 using System;
 using System.Globalization;
 using System.IO;
@@ -20,6 +21,7 @@ using System.Linq;
 using System.Net.Http;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Threading.Tasks;
 
 namespace ClaudeDo.App;
 
@@ -34,6 +36,35 @@ sealed class Program
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             SetCurrentProcessExplicitAppUserModelID("ClaudeDo.App");
 
+        var logRoot = Path.Combine(Paths.AppDataRoot(), "logs");
+        Directory.CreateDirectory(logRoot);
+        Log.Logger = new LoggerConfiguration()
+            .MinimumLevel.Information()
+            .WriteTo.File(
+                Path.Combine(logRoot, "ui-.log"),
+                rollingInterval: RollingInterval.Day,
+                retainedFileCountLimit: 7,
+                shared: true)
+            .CreateLogger();
+
+        var version = Assembly.GetEntryAssembly()?
+            .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion
+            ?? "0.0.0";
+        Log.Information("ClaudeDo.App starting (version: {version})", version);
+
+        // Last-resort net: any exception that misses every other handler still gets one
+        // Fatal line in the log before the process dies.
+        AppDomain.CurrentDomain.UnhandledException += (_, e) =>
+        {
+            Log.Fatal(e.ExceptionObject as Exception, "Unhandled exception, terminating (is_terminating: {is_terminating})", e.IsTerminating);
+            Log.CloseAndFlush();
+        };
+        TaskScheduler.UnobservedTaskException += (_, e) =>
+        {
+            Log.Error(e.Exception, "Unobserved task exception");
+            e.SetObserved();
+        };
+
         var services = BuildServices();
 
         using (var scope = services.CreateScope())
@@ -42,6 +73,8 @@ sealed class Program
             ClaudeDoDbContext.MigrateAndConfigure(db);
         }
 
+        ClipboardImageTempStore.DeleteOlderThan(TimeSpan.FromHours(24), DateTime.UtcNow);
+
         try
         {
             ConfigureAppBuilder(AppBuilder.Configure(() => new App(services)))
@@ -60,6 +93,8 @@ sealed class Program
             {
                 /* best effort on shutdown */
             }
+
+            Log.CloseAndFlush();
         }
     }
 
@@ -128,7 +163,6 @@ sealed class Program
 
         // Conflict-merge coordinator: single seam the shell wires to its resolver entry.
         sc.AddSingleton<MergeCoordinator>();
-        sc.AddSingleton<IMergeCoordinator>(sp => sp.GetRequiredService<MergeCoordinator>());
 
         // ViewModels
         sc.AddTransient<DiffViewerViewModel>();
@@ -139,7 +173,7 @@ sealed class Program
         sc.AddTransient<MergeHelperSelectionModalViewModel>();
         sc.AddSingleton<IPrimeScheduleApi, WorkerPrimeScheduleApi>();
         sc.AddSingleton<INotesApi, WorkerNotesApi>();
-        sc.AddSingleton<IOnlineLoginService, OnlineLoginService>();
+        sc.AddSingleton<OnlineLoginService>();
         sc.AddTransient<PrimeClaudeTabViewModel>();
         sc.AddTransient<SettingsModalViewModel>();
         sc.AddTransient<MergeModalViewModel>();
@@ -166,14 +200,14 @@ sealed class Program
         sc.AddSingleton<TasksIslandViewModel>(sp =>
             new TasksIslandViewModel(
                 sp.GetRequiredService<IDbContextFactory<ClaudeDoDbContext>>(),
-                sp.GetRequiredService<IWorkerClient>()));
+                sp.GetRequiredService<IWorkerClient>(),
+                sp.GetRequiredService<INotesApi>()));
         sc.AddSingleton<DetailsIslandViewModel>(sp =>
             new DetailsIslandViewModel(
                 sp.GetRequiredService<IDbContextFactory<ClaudeDoDbContext>>(),
                 sp.GetRequiredService<IWorkerClient>(),
                 sp,
-                sp.GetRequiredService<INotesApi>(),
-                sp.GetRequiredService<IMergeCoordinator>()));
+                sp.GetRequiredService<MergeCoordinator>()));
         sc.AddSingleton<UsagePillViewModel>(sp =>
             new UsagePillViewModel(sp.GetRequiredService<IWorkerClient>()));
         sc.AddSingleton<MissionControlViewModel>(sp =>

src/ClaudeDo.Data/AttachmentStore.cs

@@ -7,7 +7,7 @@ public sealed class AttachmentStore
     private readonly string _root;
 
     public AttachmentStore(string? root = null)
-        => _root = root ?? Paths.Expand("~/.todo-app/attachments");
+        => _root = root ?? Path.Combine(Paths.AppDataRoot(), "attachments");
 
     public string Root => _root;
 

src/ClaudeDo.Data/CLAUDE.md

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

src/ClaudeDo.Data/ClaudeDoDbContext.cs

@@ -41,7 +41,9 @@ public class ClaudeDoDbContext : DbContext
         => optionsBuilder.AddInterceptors(SqliteForeignKeyInterceptor.Instance);
 
     public DbSet<TaskEntity> Tasks => Set<TaskEntity>();
+    public DbSet<TaskDependencyEntity> TaskDependencies => Set<TaskDependencyEntity>();
     public DbSet<ListEntity> Lists => Set<ListEntity>();
+    public DbSet<ListFolderEntity> ListFolders => Set<ListFolderEntity>();
     public DbSet<ListConfigEntity> ListConfigs => Set<ListConfigEntity>();
     public DbSet<WorktreeEntity> Worktrees => Set<WorktreeEntity>();
     public DbSet<TaskRunEntity> TaskRuns => Set<TaskRunEntity>();
@@ -52,6 +54,7 @@ public class ClaudeDoDbContext : DbContext
     public DbSet<DailyNoteEntity> DailyNotes => Set<DailyNoteEntity>();
     public DbSet<WeekReportEntity> WeekReports => Set<WeekReportEntity>();
     public DbSet<SessionSkillEntity> SessionSkills => Set<SessionSkillEntity>();
+    public DbSet<MissionControlSessionEntity> MissionControlSessions => Set<MissionControlSessionEntity>();
 
     private static readonly ValueConverter<DateTime, DateTime> UtcConverter =
         new(v => v, v => DateTime.SpecifyKind(v, DateTimeKind.Utc));
@@ -73,11 +76,19 @@ public class ClaudeDoDbContext : DbContext
         }
     }
 
+    // The 40 incremental migrations were squashed into a single InitialCreate on 2026-08-26.
+    // Any database that already carries the full pre-squash schema has to be re-stamped to the
+    // squashed id, or Migrate() would run CREATE TABLE over live tables.
+    private const string SquashedMigrationId = "20260826094154_InitialCreate";
+    private const string LastPreSquashMigrationId = "20260825063230_AddPrimeActionKind";
+
     /// <summary>
     /// Applies EF Core migrations and sets WAL mode. Safe for both fresh and existing databases.
-    /// Existing databases (created by the old schema.sql) have their tables but no
-    /// __EFMigrationsHistory — this method detects that case and baselines the initial
-    /// migration so EF skips re-creating tables that already exist.
+    /// Existing databases are baselined onto <see cref="SquashedMigrationId"/> instead of being
+    /// re-created: ones with tables but no __EFMigrationsHistory (created by the old schema.sql),
+    /// and ones whose history still lists the pre-squash chain. A database that stopped *mid*-chain
+    /// can no longer be upgraded — the incremental migrations are gone — and throws instead of
+    /// being silently stamped onto a schema it doesn't have.
     /// </summary>
     public static void MigrateAndConfigure(ClaudeDoDbContext db)
     {
@@ -101,8 +112,6 @@ public class ClaudeDoDbContext : DbContext
                 fkCmd.ExecuteNonQuery();
             }
 
-            // If the 'lists' table exists but __EFMigrationsHistory does not,
-            // this is a pre-EF database. Baseline the InitialCreate migration.
             using (var cmd = conn.CreateCommand())
             {
                 cmd.CommandText = "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='lists'";
@@ -113,16 +122,42 @@ public class ClaudeDoDbContext : DbContext
 
                 if (hasLists && !hasHistory)
                 {
-                    cmd.CommandText = """
+                    // Pre-EF database: tables, no history at all.
+                    cmd.CommandText = $"""
                         CREATE TABLE "__EFMigrationsHistory" (
                             "MigrationId" TEXT NOT NULL CONSTRAINT "PK___EFMigrationsHistory" PRIMARY KEY,
                             "ProductVersion" TEXT NOT NULL
                         );
                         INSERT INTO "__EFMigrationsHistory" ("MigrationId", "ProductVersion")
-                        VALUES ('20260416064948_InitialCreate', '8.0.11');
+                        VALUES ('{SquashedMigrationId}', '8.0.11');
                         """;
                     cmd.ExecuteNonQuery();
                 }
+                else if (hasLists && hasHistory)
+                {
+                    cmd.CommandText = $"""SELECT COUNT(*) FROM "__EFMigrationsHistory" WHERE "MigrationId" = '{SquashedMigrationId}'""";
+                    var alreadySquashed = Convert.ToInt64(cmd.ExecuteScalar()) > 0;
+
+                    if (!alreadySquashed)
+                    {
+                        cmd.CommandText = """SELECT MAX("MigrationId") FROM "__EFMigrationsHistory" """;
+                        var newest = cmd.ExecuteScalar() as string ?? "";
+
+                        if (newest != LastPreSquashMigrationId)
+                            throw new InvalidOperationException(
+                                $"This database was last migrated by '{newest}', but the migration history was " +
+                                $"squashed into '{SquashedMigrationId}' and the incremental migrations no longer " +
+                                "exist. Reinstall ClaudeDo against a fresh database (or restore a backup taken " +
+                                $"after '{LastPreSquashMigrationId}').");
+
+                        cmd.CommandText = $"""
+                            DELETE FROM "__EFMigrationsHistory";
+                            INSERT INTO "__EFMigrationsHistory" ("MigrationId", "ProductVersion")
+                            VALUES ('{SquashedMigrationId}', '8.0.11');
+                            """;
+                        cmd.ExecuteNonQuery();
+                    }
+                }
             }
         }
         finally

src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs

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

src/ClaudeDo.Data/Configuration/DailyNoteEntityConfiguration.cs

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

src/ClaudeDo.Data/Configuration/ListConfigEntityConfiguration.cs

@@ -18,7 +18,8 @@ public class ListConfigEntityConfiguration : IEntityTypeConfiguration<ListConfig
         builder.Property(c => c.MaxTurns).HasColumnName("max_turns");
         builder.Property(c => c.SessionSkills).HasColumnName("session_skills");
         builder.Property(c => c.VerifyCommand).HasColumnName("verify_command");
-        builder.Property(c => c.SerializeOnFileOverlap).HasColumnName("serialize_on_file_overlap")
-            .IsRequired().HasDefaultValue(false);
+        builder.Property(c => c.PermissionMode).HasColumnName("permission_mode");
+        builder.Property(c => c.TicketProjectId).HasColumnName("ticket_project_id");
+        builder.Property(c => c.PowerUseAllowed).HasColumnName("power_use_allowed");
     }
 }

src/ClaudeDo.Data/Configuration/ListEntityConfiguration.cs

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

src/ClaudeDo.Data/Configuration/ListFolderEntityConfiguration.cs

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

src/ClaudeDo.Data/Configuration/MissionControlSessionEntityConfiguration.cs

@@ -0,0 +1,22 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ClaudeDo.Data.Configuration;
+
+public class MissionControlSessionEntityConfiguration : IEntityTypeConfiguration<MissionControlSessionEntity>
+{
+    public void Configure(EntityTypeBuilder<MissionControlSessionEntity> builder)
+    {
+        builder.ToTable("mission_control_sessions");
+        builder.HasKey(s => s.SessionId);
+        builder.Property(s => s.SessionId).HasColumnName("session_id").ValueGeneratedNever();
+        builder.Property(s => s.Cwd).HasColumnName("cwd").IsRequired();
+        builder.Property(s => s.TaskId).HasColumnName("task_id");
+        builder.Property(s => s.Title).HasColumnName("title").IsRequired();
+        builder.Property(s => s.StartedAt).HasColumnName("started_at").IsRequired();
+        builder.Property(s => s.PredecessorSessionId).HasColumnName("predecessor_session_id");
+        builder.Property(s => s.BriefPath).HasColumnName("brief_path");
+        builder.HasIndex(s => s.StartedAt);
+    }
+}

src/ClaudeDo.Data/Configuration/PrimeScheduleEntityConfiguration.cs

@@ -1,11 +1,27 @@
 using ClaudeDo.Data.Models;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 
 namespace ClaudeDo.Data.Configuration;
 
 public class PrimeScheduleEntityConfiguration : IEntityTypeConfiguration<PrimeScheduleEntity>
 {
+    private static string KindToString(PrimeActionKind v)
+        => v == PrimeActionKind.Ping ? "ping"
+         : v == PrimeActionKind.FillMyDay ? "fill_my_day"
+         : v == PrimeActionKind.Custom ? "custom"
+         : throw new ArgumentOutOfRangeException(nameof(v));
+
+    private static PrimeActionKind KindFromString(string v)
+        => v == "ping" ? PrimeActionKind.Ping
+         : v == "fill_my_day" ? PrimeActionKind.FillMyDay
+         : v == "custom" ? PrimeActionKind.Custom
+         : throw new ArgumentOutOfRangeException(nameof(v));
+
+    private static readonly ValueConverter<PrimeActionKind, string> KindConverter =
+        new(v => KindToString(v), v => KindFromString(v));
+
     public void Configure(EntityTypeBuilder<PrimeScheduleEntity> builder)
     {
         builder.ToTable("prime_schedules");
@@ -15,6 +31,9 @@ public class PrimeScheduleEntityConfiguration : IEntityTypeConfiguration<PrimeSc
 
         builder.Property(s => s.Days).HasColumnName("days_of_week")
             .IsRequired().HasDefaultValue(PrimeDays.Weekdays);
+        builder.Property(s => s.Kind).HasColumnName("action_kind")
+            .IsRequired().HasDefaultValue(PrimeActionKind.Ping)
+            .HasConversion(KindConverter);
         builder.Property(s => s.TimeOfDay).HasColumnName("time_of_day").IsRequired();
         builder.Property(s => s.Enabled).HasColumnName("enabled").IsRequired().HasDefaultValue(true);
         builder.Property(s => s.LastRunAt).HasColumnName("last_run_at");

src/ClaudeDo.Data/Configuration/TaskDependencyEntityConfiguration.cs

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

src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs

@@ -75,7 +75,6 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         builder.Property(t => t.PlanningPhase).HasColumnName("planning_phase").IsRequired()
             .HasConversion(PhaseConverter).HasDefaultValue(PlanningPhase.None);
         builder.Property(t => t.BlockedByTaskId).HasColumnName("blocked_by_task_id");
-        builder.Property(t => t.DependsOnTaskId).HasColumnName("depends_on_task_id");
         builder.Property(t => t.ScheduledFor).HasColumnName("scheduled_for");
         builder.Property(t => t.Result).HasColumnName("result");
         builder.Property(t => t.ReviewFeedback).HasColumnName("review_feedback");
@@ -83,6 +82,7 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         builder.Property(t => t.FailureReason).HasColumnName("failure_reason");
         builder.Property(t => t.FailureTurnsUsed).HasColumnName("failure_turns_used");
         builder.Property(t => t.FailureMaxTurns).HasColumnName("failure_max_turns");
+        builder.Property(t => t.UsageLimitAutoContinuedAt).HasColumnName("usage_limit_auto_continued_at");
         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");
@@ -92,16 +92,18 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         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.PermissionMode).HasColumnName("permission_mode");
         builder.Property(t => t.IsStarred).HasColumnName("is_starred").HasDefaultValue(false);
         builder.Property(t => t.IsMyDay).HasColumnName("is_my_day").HasDefaultValue(false);
         builder.Property(t => t.IsManual).HasColumnName("is_manual").HasDefaultValue(false);
+        builder.Property(t => t.ExpectsNoDiff).HasColumnName("expects_no_diff").HasDefaultValue(false);
         builder.Property(t => t.Notes).HasColumnName("notes");
         builder.Property(t => t.SortOrder).HasColumnName("sort_order").IsRequired().HasDefaultValue(0);
         builder.Property(t => t.SessionSkills).HasColumnName("session_skills");
-        builder.Property(t => t.ScopeGlobs).HasColumnName("scope_globs");
         builder.Property(t => t.HandlerBaseCommit).HasColumnName("handler_base_commit");
         builder.Property(t => t.HandlerHeadCommit).HasColumnName("handler_head_commit");
         builder.Property(t => t.InteractiveSessionId).HasColumnName("interactive_session_id");
+        builder.Property(t => t.TicketRef).HasColumnName("ticket_ref");
 
         builder.Property(t => t.ParentTaskId).HasColumnName("parent_task_id");
         builder.Property(t => t.PlanningSessionId).HasColumnName("planning_session_id");
@@ -121,12 +123,8 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
             .HasForeignKey(t => t.BlockedByTaskId)
             .OnDelete(DeleteBehavior.SetNull);
 
-        // DependsOn: user/MCP-declared predecessor. SetNull on delete so the dependent becomes
-        // pickable rather than blocked forever on a task that no longer exists.
-        builder.HasOne<TaskEntity>()
-            .WithMany()
-            .HasForeignKey(t => t.DependsOnTaskId)
-            .OnDelete(DeleteBehavior.SetNull);
+        // DependsOn edges live in task_dependencies (a task can declare n predecessors) —
+        // configured in TaskDependencyEntityConfiguration, which also owns the Dependencies nav.
 
         builder.HasOne(t => t.List)
             .WithMany(l => l.Tasks)
@@ -143,6 +141,5 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         builder.HasIndex(t => new { t.ListId, t.SortOrder }).HasDatabaseName("idx_tasks_list_sort");
         builder.HasIndex(t => t.ParentTaskId).HasDatabaseName("idx_tasks_parent_task_id");
         builder.HasIndex(t => t.BlockedByTaskId).HasDatabaseName("idx_tasks_blocked_by");
-        builder.HasIndex(t => t.DependsOnTaskId).HasDatabaseName("idx_tasks_depends_on");
     }
 }

src/ClaudeDo.Data/Filtering/Filters/ReviewFilter.cs

@@ -1,12 +0,0 @@
-using System.Linq.Expressions;
-using ClaudeDo.Data.Models;
-using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
-
-namespace ClaudeDo.Data.Filtering.Filters;
-
-public sealed class ReviewFilter : TaskListFilterBase
-{
-    public override string Id => "virtual:review";
-    protected override Expression<Func<TaskEntity, bool>> MatchExpr => t => t.Status == TaskStatus.WaitingForReview;
-    public override bool ShouldCount(TaskEntity t) => Matches(t);
-}

src/ClaudeDo.Data/Filtering/Filters/SmartFlagFilter.cs

@@ -1,18 +0,0 @@
-using System.Linq.Expressions;
-using ClaudeDo.Data.Models;
-using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
-
-namespace ClaudeDo.Data.Filtering.Filters;
-
-/// <summary>
-/// Filter for a smart list keyed off a boolean/nullable task flag
-/// (My Day, Important, Planned). Counts only non-done matches.
-/// </summary>
-public sealed class SmartFlagFilter(string id, Expression<Func<TaskEntity, bool>> flag) : TaskListFilterBase
-{
-    private readonly Func<TaskEntity, bool> _flag = flag.Compile();
-
-    public override string Id => id;
-    protected override Expression<Func<TaskEntity, bool>> MatchExpr => flag;
-    public override bool ShouldCount(TaskEntity t) => _flag(t) && t.Status != TaskStatus.Done;
-}

src/ClaudeDo.Data/Filtering/Filters/StatusFilter.cs

@@ -1,19 +0,0 @@
-using System.Linq.Expressions;
-using ClaudeDo.Data.Models;
-using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
-
-namespace ClaudeDo.Data.Filtering.Filters;
-
-/// <summary>
-/// Virtual list filter matching tasks by a single status (Queued, Running).
-/// Planning parents appear contextually when they host a matching child.
-/// </summary>
-public sealed class StatusFilter(string id, TaskStatus status) : TaskListFilterBase
-{
-    public override string Id => id;
-    protected override Expression<Func<TaskEntity, bool>> MatchExpr => t => t.Status == status;
-    public override bool ShouldCount(TaskEntity t) => t.Status == status;
-    public override bool MatchesAsContext(TaskEntity t, IReadOnlyList<TaskEntity> all) =>
-        PlanningRules.IsPlanningParent(t) &&
-        PlanningRules.HasMatchingChild(t, all, c => c.Status == status);
-}

src/ClaudeDo.Data/Filtering/Filters/TaskListFilterBase.cs

@@ -1,27 +0,0 @@
-using System.Linq.Expressions;
-using ClaudeDo.Data.Models;
-
-namespace ClaudeDo.Data.Filtering.Filters;
-
-/// <summary>
-/// Base for <see cref="ITaskListFilter"/> implementations: subclasses express their
-/// primary-match condition once as an expression tree (<see cref="MatchExpr"/>), which
-/// doubles as a SQL-translatable predicate (<see cref="MatchExpression"/>) and, compiled
-/// on first use, as the in-memory <see cref="Matches"/> predicate.
-/// </summary>
-public abstract class TaskListFilterBase : ITaskListFilter
-{
-    private Func<TaskEntity, bool>? _compiled;
-
-    public abstract string Id { get; }
-
-    protected abstract Expression<Func<TaskEntity, bool>> MatchExpr { get; }
-
-    public Expression<Func<TaskEntity, bool>> MatchExpression => MatchExpr;
-
-    public bool Matches(TaskEntity t) => (_compiled ??= MatchExpr.Compile())(t);
-
-    public abstract bool ShouldCount(TaskEntity t);
-
-    public virtual bool MatchesAsContext(TaskEntity t, IReadOnlyList<TaskEntity> all) => false;
-}

src/ClaudeDo.Data/Filtering/Filters/UserListFilter.cs

@@ -1,24 +0,0 @@
-using System.Linq.Expressions;
-using ClaudeDo.Data.Models;
-using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
-
-namespace ClaudeDo.Data.Filtering.Filters;
-
-/// <summary>
-/// Filter for any user-defined list. Constructed on demand from the list id —
-/// one instance per list.
-/// </summary>
-public sealed class UserListFilter : TaskListFilterBase
-{
-    private readonly string _listId;
-
-    public UserListFilter(string listId)
-    {
-        _listId = listId;
-        Id = $"user:{listId}";
-    }
-
-    public override string Id { get; }
-    protected override Expression<Func<TaskEntity, bool>> MatchExpr => t => t.ListId == _listId;
-    public override bool ShouldCount(TaskEntity t) => t.ListId == _listId && t.Status != TaskStatus.Done;
-}

src/ClaudeDo.Data/Filtering/Interfaces/ITaskListFilter.cs

@@ -1,30 +0,0 @@
-using System.Linq.Expressions;
-using ClaudeDo.Data.Models;
-
-namespace ClaudeDo.Data.Filtering;
-
-/// <summary>
-/// Strategy that defines which tasks belong to a single list. One implementation
-/// per list kind; consumers (counters, list loader) ask the registry for the
-/// right strategy and never branch on the list id themselves.
-/// </summary>
-public interface ITaskListFilter
-{
-    /// <summary>The list id this filter applies to (e.g. "virtual:queued", "user:abc").</summary>
-    string Id { get; }
-
-    /// <summary>True if <paramref name="t"/> is a primary citizen of this list — appears as a row.</summary>
-    bool Matches(TaskEntity t);
-
-    /// <summary>The primary-match predicate as an expression tree, so EF Core can push it into SQL.</summary>
-    Expression<Func<TaskEntity, bool>> MatchExpression { get; }
-
-    /// <summary>True if <paramref name="t"/> should be counted in this list's badge.</summary>
-    bool ShouldCount(TaskEntity t);
-
-    /// <summary>
-    /// True if <paramref name="t"/> is shown as a contextual row (not a primary citizen,
-    /// but appears to host children that match). Default: nothing extra.
-    /// </summary>
-    bool MatchesAsContext(TaskEntity t, IReadOnlyList<TaskEntity> all) => false;
-}

src/ClaudeDo.Data/Filtering/TaskListFilterRegistry.cs

@@ -1,8 +1,84 @@
-using ClaudeDo.Data.Filtering.Filters;
+using System.Linq.Expressions;
+using ClaudeDo.Data.Models;
 using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
 
 namespace ClaudeDo.Data.Filtering;
 
+/// <summary>
+/// Strategy that defines which tasks belong to a single list. One subclass per list kind;
+/// consumers (counters, list loader) ask the registry for the right strategy and never branch
+/// on the list id themselves.
+///
+/// Subclasses express their primary-match condition once as an expression tree
+/// (<see cref="MatchExpression"/>), which doubles as a SQL-translatable predicate for EF Core
+/// and, compiled on first use, as the in-memory <see cref="Matches"/> predicate.
+/// </summary>
+public abstract class TaskListFilter
+{
+    private Func<TaskEntity, bool>? _compiled;
+
+    /// <summary>The list id this filter applies to (e.g. "virtual:queued", "user:abc").</summary>
+    public abstract string Id { get; }
+
+    /// <summary>The primary-match predicate as an expression tree, so EF Core can push it into SQL.</summary>
+    public abstract Expression<Func<TaskEntity, bool>> MatchExpression { get; }
+
+    /// <summary>True if <paramref name="t"/> is a primary citizen of this list — appears as a row.</summary>
+    public bool Matches(TaskEntity t) => (_compiled ??= MatchExpression.Compile())(t);
+
+    /// <summary>True if <paramref name="t"/> should be counted in this list's badge.</summary>
+    public abstract bool ShouldCount(TaskEntity t);
+
+    /// <summary>
+    /// True if <paramref name="t"/> is shown as a contextual row (not a primary citizen,
+    /// but appears to host children that match). Default: nothing extra.
+    /// </summary>
+    public virtual bool MatchesAsContext(TaskEntity t, IReadOnlyList<TaskEntity> all) => false;
+}
+
+/// <summary>
+/// Filter for a smart list keyed off a boolean/nullable task flag
+/// (My Day, Important, Planned). Counts only non-done matches.
+/// </summary>
+public sealed class SmartFlagFilter(string id, Expression<Func<TaskEntity, bool>> flag) : TaskListFilter
+{
+    public override string Id => id;
+    public override Expression<Func<TaskEntity, bool>> MatchExpression => flag;
+    public override bool ShouldCount(TaskEntity t) => Matches(t) && t.Status != TaskStatus.Done;
+}
+
+/// <summary>
+/// Virtual list filter matching tasks by a single status (Queued, Running).
+/// Planning parents appear contextually when they host a matching child.
+/// </summary>
+public sealed class StatusFilter(string id, TaskStatus status) : TaskListFilter
+{
+    public override string Id => id;
+    public override Expression<Func<TaskEntity, bool>> MatchExpression => t => t.Status == status;
+    public override bool ShouldCount(TaskEntity t) => t.Status == status;
+    public override bool MatchesAsContext(TaskEntity t, IReadOnlyList<TaskEntity> all) =>
+        PlanningRules.IsPlanningParent(t) &&
+        PlanningRules.HasMatchingChild(t, all, c => c.Status == status);
+}
+
+public sealed class ReviewFilter : TaskListFilter
+{
+    public override string Id => "virtual:review";
+    public override Expression<Func<TaskEntity, bool>> MatchExpression => t => t.Status == TaskStatus.WaitingForReview;
+    public override bool ShouldCount(TaskEntity t) => Matches(t);
+}
+
+/// <summary>
+/// Filter for any user-defined list. Constructed on demand from the list id —
+/// one instance per list.
+/// </summary>
+public sealed class UserListFilter(string listId) : TaskListFilter
+{
+    public override string Id { get; } = $"user:{listId}";
+    public override Expression<Func<TaskEntity, bool>> MatchExpression => t => t.ListId == listId;
+    public override bool ShouldCount(TaskEntity t) => t.ListId == listId && t.Status != TaskStatus.Done;
+}
+
 /// <summary>
 /// Resolves a list id (e.g. "virtual:queued", "user:abc") to the filter that
 /// owns its semantics. Smart and virtual filters are singletons; user-list
@@ -12,8 +88,8 @@ public sealed class TaskListFilterRegistry
 {
     public const string UserListPrefix = "user:";
 
-    private static readonly IReadOnlyDictionary<string, ITaskListFilter> BuiltIn =
-        new Dictionary<string, ITaskListFilter>(StringComparer.Ordinal)
+    private static readonly IReadOnlyDictionary<string, TaskListFilter> BuiltIn =
+        new Dictionary<string, TaskListFilter>(StringComparer.Ordinal)
         {
             ["smart:my-day"]    = new SmartFlagFilter("smart:my-day", t => t.IsMyDay),
             ["smart:important"] = new SmartFlagFilter("smart:important", t => t.IsStarred),
@@ -26,7 +102,7 @@ public sealed class TaskListFilterRegistry
     /// <summary>
     /// Resolve a filter for a list id, or null if the id is unknown.
     /// </summary>
-    public ITaskListFilter? Resolve(string listId)
+    public TaskListFilter? Resolve(string listId)
     {
         if (BuiltIn.TryGetValue(listId, out var f)) return f;
         if (listId.StartsWith(UserListPrefix, StringComparison.Ordinal))

src/ClaudeDo.Data/Git/GitService.cs

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

src/ClaudeDo.Data/Migrations/20260416064948_InitialCreate.Designer.cs

@@ -1,482 +0,0 @@
-// <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("20260416064948_InitialCreate")]
-    partial class InitialCreate
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "8.0.11");
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("lists", (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.TagEntity", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("id");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Name")
-                        .IsUnique();
-
-                    b.ToTable("tags", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1L,
-                            Name = "agent"
-                        },
-                        new
-                        {
-                            Id = 2L,
-                            Name = "manual"
-                        });
-                });
-
-            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>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    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>("Result")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result");
-
-                    b.Property<DateTime?>("ScheduledFor")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("scheduled_for");
-
-                    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("ListId")
-                        .HasDatabaseName("idx_tasks_list_id");
-
-                    b.HasIndex("Status")
-                        .HasDatabaseName("idx_tasks_status");
-
-                    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.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("list_tags", b =>
-                {
-                    b.Property<string>("list_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("list_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("list_tags", (string)null);
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.Property<string>("task_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("task_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("task_tags", (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.ListEntity", "List")
-                        .WithMany("Tasks")
-                        .HasForeignKey("ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            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("list_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", null)
-                        .WithMany()
-                        .HasForeignKey("list_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("task_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Navigation("Config");
-
-                    b.Navigation("Tasks");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Navigation("Runs");
-
-                    b.Navigation("Subtasks");
-
-                    b.Navigation("Worktree");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260416064948_InitialCreate.cs

@@ -1,298 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class InitialCreate : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.CreateTable(
-                name: "lists",
-                columns: table => new
-                {
-                    id = table.Column<string>(type: "TEXT", nullable: false),
-                    name = table.Column<string>(type: "TEXT", nullable: false),
-                    created_at = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    working_dir = table.Column<string>(type: "TEXT", nullable: true),
-                    default_commit_type = table.Column<string>(type: "TEXT", nullable: false, defaultValue: "chore")
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_lists", x => x.id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "tags",
-                columns: table => new
-                {
-                    id = table.Column<long>(type: "INTEGER", nullable: false)
-                        .Annotation("Sqlite:Autoincrement", true),
-                    name = table.Column<string>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_tags", x => x.id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "list_config",
-                columns: table => new
-                {
-                    list_id = table.Column<string>(type: "TEXT", nullable: false),
-                    model = table.Column<string>(type: "TEXT", nullable: true),
-                    system_prompt = table.Column<string>(type: "TEXT", nullable: true),
-                    agent_path = table.Column<string>(type: "TEXT", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_list_config", x => x.list_id);
-                    table.ForeignKey(
-                        name: "FK_list_config_lists_list_id",
-                        column: x => x.list_id,
-                        principalTable: "lists",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "tasks",
-                columns: table => new
-                {
-                    id = table.Column<string>(type: "TEXT", nullable: false),
-                    list_id = table.Column<string>(type: "TEXT", nullable: false),
-                    title = table.Column<string>(type: "TEXT", nullable: false),
-                    description = table.Column<string>(type: "TEXT", nullable: true),
-                    status = table.Column<string>(type: "TEXT", nullable: false),
-                    scheduled_for = table.Column<DateTime>(type: "TEXT", nullable: true),
-                    result = table.Column<string>(type: "TEXT", nullable: true),
-                    log_path = table.Column<string>(type: "TEXT", nullable: true),
-                    created_at = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    started_at = table.Column<DateTime>(type: "TEXT", nullable: true),
-                    finished_at = table.Column<DateTime>(type: "TEXT", nullable: true),
-                    commit_type = table.Column<string>(type: "TEXT", nullable: false, defaultValue: "chore"),
-                    model = table.Column<string>(type: "TEXT", nullable: true),
-                    system_prompt = table.Column<string>(type: "TEXT", nullable: true),
-                    agent_path = table.Column<string>(type: "TEXT", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_tasks", x => x.id);
-                    table.ForeignKey(
-                        name: "FK_tasks_lists_list_id",
-                        column: x => x.list_id,
-                        principalTable: "lists",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "list_tags",
-                columns: table => new
-                {
-                    list_id = table.Column<string>(type: "TEXT", nullable: false),
-                    tag_id = table.Column<long>(type: "INTEGER", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_list_tags", x => new { x.list_id, x.tag_id });
-                    table.ForeignKey(
-                        name: "FK_list_tags_lists_list_id",
-                        column: x => x.list_id,
-                        principalTable: "lists",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_list_tags_tags_tag_id",
-                        column: x => x.tag_id,
-                        principalTable: "tags",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "subtasks",
-                columns: table => new
-                {
-                    id = table.Column<string>(type: "TEXT", nullable: false),
-                    task_id = table.Column<string>(type: "TEXT", nullable: false),
-                    title = table.Column<string>(type: "TEXT", nullable: false),
-                    completed = table.Column<bool>(type: "INTEGER", nullable: false, defaultValue: false),
-                    order_num = table.Column<int>(type: "INTEGER", nullable: false),
-                    created_at = table.Column<DateTime>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_subtasks", x => x.id);
-                    table.ForeignKey(
-                        name: "FK_subtasks_tasks_task_id",
-                        column: x => x.task_id,
-                        principalTable: "tasks",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "task_runs",
-                columns: table => new
-                {
-                    id = table.Column<string>(type: "TEXT", nullable: false),
-                    task_id = table.Column<string>(type: "TEXT", nullable: false),
-                    run_number = table.Column<int>(type: "INTEGER", nullable: false),
-                    session_id = table.Column<string>(type: "TEXT", nullable: true),
-                    is_retry = table.Column<bool>(type: "INTEGER", nullable: false, defaultValue: false),
-                    prompt = table.Column<string>(type: "TEXT", nullable: false),
-                    result_markdown = table.Column<string>(type: "TEXT", nullable: true),
-                    structured_output = table.Column<string>(type: "TEXT", nullable: true),
-                    error_markdown = table.Column<string>(type: "TEXT", nullable: true),
-                    exit_code = table.Column<int>(type: "INTEGER", nullable: true),
-                    turn_count = table.Column<int>(type: "INTEGER", nullable: true),
-                    tokens_in = table.Column<int>(type: "INTEGER", nullable: true),
-                    tokens_out = table.Column<int>(type: "INTEGER", nullable: true),
-                    log_path = table.Column<string>(type: "TEXT", nullable: true),
-                    started_at = table.Column<DateTime>(type: "TEXT", nullable: true),
-                    finished_at = table.Column<DateTime>(type: "TEXT", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_task_runs", x => x.id);
-                    table.ForeignKey(
-                        name: "FK_task_runs_tasks_task_id",
-                        column: x => x.task_id,
-                        principalTable: "tasks",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "task_tags",
-                columns: table => new
-                {
-                    task_id = table.Column<string>(type: "TEXT", nullable: false),
-                    tag_id = table.Column<long>(type: "INTEGER", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_task_tags", x => new { x.task_id, x.tag_id });
-                    table.ForeignKey(
-                        name: "FK_task_tags_tags_tag_id",
-                        column: x => x.tag_id,
-                        principalTable: "tags",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_task_tags_tasks_task_id",
-                        column: x => x.task_id,
-                        principalTable: "tasks",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "worktrees",
-                columns: table => new
-                {
-                    task_id = table.Column<string>(type: "TEXT", nullable: false),
-                    path = table.Column<string>(type: "TEXT", nullable: false),
-                    branch_name = table.Column<string>(type: "TEXT", nullable: false),
-                    base_commit = table.Column<string>(type: "TEXT", nullable: false),
-                    head_commit = table.Column<string>(type: "TEXT", nullable: true),
-                    diff_stat = table.Column<string>(type: "TEXT", nullable: true),
-                    state = table.Column<string>(type: "TEXT", nullable: false, defaultValue: "active"),
-                    created_at = table.Column<DateTime>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_worktrees", x => x.task_id);
-                    table.ForeignKey(
-                        name: "FK_worktrees_tasks_task_id",
-                        column: x => x.task_id,
-                        principalTable: "tasks",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.InsertData(
-                table: "tags",
-                columns: new[] { "id", "name" },
-                values: new object[,]
-                {
-                    { 1L, "agent" },
-                    { 2L, "manual" }
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_list_tags_tag_id",
-                table: "list_tags",
-                column: "tag_id");
-
-            migrationBuilder.CreateIndex(
-                name: "idx_subtasks_task_id",
-                table: "subtasks",
-                column: "task_id");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_tags_name",
-                table: "tags",
-                column: "name",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "idx_task_runs_task_id",
-                table: "task_runs",
-                column: "task_id");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_task_tags_tag_id",
-                table: "task_tags",
-                column: "tag_id");
-
-            migrationBuilder.CreateIndex(
-                name: "idx_tasks_list_id",
-                table: "tasks",
-                column: "list_id");
-
-            migrationBuilder.CreateIndex(
-                name: "idx_tasks_status",
-                table: "tasks",
-                column: "status");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "list_config");
-
-            migrationBuilder.DropTable(
-                name: "list_tags");
-
-            migrationBuilder.DropTable(
-                name: "subtasks");
-
-            migrationBuilder.DropTable(
-                name: "task_runs");
-
-            migrationBuilder.DropTable(
-                name: "task_tags");
-
-            migrationBuilder.DropTable(
-                name: "worktrees");
-
-            migrationBuilder.DropTable(
-                name: "tags");
-
-            migrationBuilder.DropTable(
-                name: "tasks");
-
-            migrationBuilder.DropTable(
-                name: "lists");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260420075929_AddTaskFlagsAndNotes.Designer.cs

@@ -1,498 +0,0 @@
-// <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("20260420075929_AddTaskFlagsAndNotes")]
-    partial class AddTaskFlagsAndNotes
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "8.0.11");
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("lists", (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.TagEntity", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("id");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Name")
-                        .IsUnique();
-
-                    b.ToTable("tags", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1L,
-                            Name = "agent"
-                        },
-                        new
-                        {
-                            Id = 2L,
-                            Name = "manual"
-                        });
-                });
-
-            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>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    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>("Result")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result");
-
-                    b.Property<DateTime?>("ScheduledFor")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("scheduled_for");
-
-                    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("ListId")
-                        .HasDatabaseName("idx_tasks_list_id");
-
-                    b.HasIndex("Status")
-                        .HasDatabaseName("idx_tasks_status");
-
-                    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.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("list_tags", b =>
-                {
-                    b.Property<string>("list_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("list_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("list_tags", (string)null);
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.Property<string>("task_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("task_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("task_tags", (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.ListEntity", "List")
-                        .WithMany("Tasks")
-                        .HasForeignKey("ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            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("list_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", null)
-                        .WithMany()
-                        .HasForeignKey("list_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("task_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Navigation("Config");
-
-                    b.Navigation("Tasks");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Navigation("Runs");
-
-                    b.Navigation("Subtasks");
-
-                    b.Navigation("Worktree");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260420075929_AddTaskFlagsAndNotes.cs

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

src/ClaudeDo.Data/Migrations/20260421113614_AddAppSettings.Designer.cs

@@ -1,572 +0,0 @@
-// <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("20260421113614_AddAppSettings")]
-    partial class AddAppSettings
-    {
-        /// <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>("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 = 30,
-                            DefaultModel = "sonnet",
-                            DefaultPermissionMode = "bypassPermissions",
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("lists", (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.TagEntity", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("id");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Name")
-                        .IsUnique();
-
-                    b.ToTable("tags", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1L,
-                            Name = "agent"
-                        },
-                        new
-                        {
-                            Id = 2L,
-                            Name = "manual"
-                        });
-                });
-
-            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>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    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>("Result")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result");
-
-                    b.Property<DateTime?>("ScheduledFor")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("scheduled_for");
-
-                    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("ListId")
-                        .HasDatabaseName("idx_tasks_list_id");
-
-                    b.HasIndex("Status")
-                        .HasDatabaseName("idx_tasks_status");
-
-                    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.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("list_tags", b =>
-                {
-                    b.Property<string>("list_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("list_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("list_tags", (string)null);
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.Property<string>("task_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("task_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("task_tags", (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.ListEntity", "List")
-                        .WithMany("Tasks")
-                        .HasForeignKey("ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            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("list_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", null)
-                        .WithMany()
-                        .HasForeignKey("list_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("task_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Navigation("Config");
-
-                    b.Navigation("Tasks");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Navigation("Runs");
-
-                    b.Navigation("Subtasks");
-
-                    b.Navigation("Worktree");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260421113614_AddAppSettings.cs

@@ -1,45 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddAppSettings : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.CreateTable(
-                name: "app_settings",
-                columns: table => new
-                {
-                    id = table.Column<int>(type: "INTEGER", nullable: false),
-                    default_claude_instructions = table.Column<string>(type: "TEXT", nullable: false, defaultValue: ""),
-                    default_model = table.Column<string>(type: "TEXT", nullable: false, defaultValue: "sonnet"),
-                    default_max_turns = table.Column<int>(type: "INTEGER", nullable: false, defaultValue: 30),
-                    default_permission_mode = table.Column<string>(type: "TEXT", nullable: false, defaultValue: "bypassPermissions"),
-                    worktree_strategy = table.Column<string>(type: "TEXT", nullable: false, defaultValue: "sibling"),
-                    central_worktree_root = table.Column<string>(type: "TEXT", nullable: true),
-                    worktree_auto_cleanup_enabled = table.Column<bool>(type: "INTEGER", nullable: false, defaultValue: false),
-                    worktree_auto_cleanup_days = table.Column<int>(type: "INTEGER", nullable: false, defaultValue: 7)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_app_settings", x => x.id);
-                });
-
-            migrationBuilder.InsertData(
-                table: "app_settings",
-                columns: new[] { "id", "central_worktree_root", "default_claude_instructions", "default_max_turns", "default_model", "default_permission_mode", "worktree_auto_cleanup_days", "worktree_strategy" },
-                values: new object[] { 1, null, "", 30, "sonnet", "bypassPermissions", 7, "sibling" });
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "app_settings");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260422120000_AddTaskSortOrder.Designer.cs

@@ -1,581 +0,0 @@
-// <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("20260422120000_AddTaskSortOrder")]
-    partial class AddTaskSortOrder
-    {
-        /// <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>("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 = 30,
-                            DefaultModel = "sonnet",
-                            DefaultPermissionMode = "bypassPermissions",
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("lists", (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.TagEntity", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("id");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Name")
-                        .IsUnique();
-
-                    b.ToTable("tags", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1L,
-                            Name = "agent"
-                        },
-                        new
-                        {
-                            Id = 2L,
-                            Name = "manual"
-                        });
-                });
-
-            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>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    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>("Result")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result");
-
-                    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("ListId")
-                        .HasDatabaseName("idx_tasks_list_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.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("list_tags", b =>
-                {
-                    b.Property<string>("list_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("list_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("list_tags", (string)null);
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.Property<string>("task_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("task_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("task_tags", (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.ListEntity", "List")
-                        .WithMany("Tasks")
-                        .HasForeignKey("ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            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("list_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", null)
-                        .WithMany()
-                        .HasForeignKey("list_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("task_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Navigation("Config");
-
-                    b.Navigation("Tasks");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Navigation("Runs");
-
-                    b.Navigation("Subtasks");
-
-                    b.Navigation("Worktree");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260422120000_AddTaskSortOrder.cs

@@ -1,48 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddTaskSortOrder : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<int>(
-                name: "sort_order",
-                table: "tasks",
-                type: "INTEGER",
-                nullable: false,
-                defaultValue: 0);
-
-            // Backfill existing rows with a per-list dense order (0..N-1) by creation time
-            // so today's UI order is preserved after the migration.
-            migrationBuilder.Sql("""
-                WITH ordered AS (
-                    SELECT id, (row_number() OVER (PARTITION BY list_id ORDER BY created_at) - 1) AS rn
-                    FROM tasks
-                )
-                UPDATE tasks SET sort_order = (SELECT rn FROM ordered WHERE ordered.id = tasks.id);
-                """);
-
-            migrationBuilder.CreateIndex(
-                name: "idx_tasks_list_sort",
-                table: "tasks",
-                columns: new[] { "list_id", "sort_order" });
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropIndex(
-                name: "idx_tasks_list_sort",
-                table: "tasks");
-
-            migrationBuilder.DropColumn(
-                name: "sort_order",
-                table: "tasks");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260423154708_AddPlanningSupport.Designer.cs

@@ -1,609 +0,0 @@
-// <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("20260423154708_AddPlanningSupport")]
-    partial class AddPlanningSupport
-    {
-        /// <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>("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 = 30,
-                            DefaultModel = "sonnet",
-                            DefaultPermissionMode = "bypassPermissions",
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("lists", (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.TagEntity", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("id");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Name")
-                        .IsUnique();
-
-                    b.ToTable("tags", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1L,
-                            Name = "agent"
-                        },
-                        new
-                        {
-                            Id = 2L,
-                            Name = "manual"
-                        });
-                });
-
-            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>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    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>("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<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("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.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("list_tags", b =>
-                {
-                    b.Property<string>("list_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("list_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("list_tags", (string)null);
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.Property<string>("task_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("task_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("task_tags", (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.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("list_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", null)
-                        .WithMany()
-                        .HasForeignKey("list_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("task_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            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/20260423154708_AddPlanningSupport.cs

@@ -1,79 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddPlanningSupport : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<string>(
-                name: "parent_task_id",
-                table: "tasks",
-                type: "TEXT",
-                nullable: true);
-
-            migrationBuilder.AddColumn<DateTime>(
-                name: "planning_finalized_at",
-                table: "tasks",
-                type: "TEXT",
-                nullable: true);
-
-            migrationBuilder.AddColumn<string>(
-                name: "planning_session_id",
-                table: "tasks",
-                type: "TEXT",
-                nullable: true);
-
-            migrationBuilder.AddColumn<string>(
-                name: "planning_session_token",
-                table: "tasks",
-                type: "TEXT",
-                nullable: true);
-
-            migrationBuilder.CreateIndex(
-                name: "idx_tasks_parent_task_id",
-                table: "tasks",
-                column: "parent_task_id");
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_tasks_tasks_parent_task_id",
-                table: "tasks",
-                column: "parent_task_id",
-                principalTable: "tasks",
-                principalColumn: "id",
-                onDelete: ReferentialAction.Restrict);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropForeignKey(
-                name: "FK_tasks_tasks_parent_task_id",
-                table: "tasks");
-
-            migrationBuilder.DropIndex(
-                name: "idx_tasks_parent_task_id",
-                table: "tasks");
-
-            migrationBuilder.DropColumn(
-                name: "parent_task_id",
-                table: "tasks");
-
-            migrationBuilder.DropColumn(
-                name: "planning_finalized_at",
-                table: "tasks");
-
-            migrationBuilder.DropColumn(
-                name: "planning_session_id",
-                table: "tasks");
-
-            migrationBuilder.DropColumn(
-                name: "planning_session_token",
-                table: "tasks");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260424212250_AddTaskCreatedBy.Designer.cs

@@ -1,613 +0,0 @@
-// <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("20260424212250_AddTaskCreatedBy")]
-    partial class AddTaskCreatedBy
-    {
-        /// <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>("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 = "bypassPermissions",
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("lists", (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.TagEntity", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("id");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Name")
-                        .IsUnique();
-
-                    b.ToTable("tags", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1L,
-                            Name = "agent"
-                        },
-                        new
-                        {
-                            Id = 2L,
-                            Name = "manual"
-                        });
-                });
-
-            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>("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>("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<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("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.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("list_tags", b =>
-                {
-                    b.Property<string>("list_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("list_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("list_tags", (string)null);
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.Property<string>("task_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("task_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("task_tags", (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.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("list_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", null)
-                        .WithMany()
-                        .HasForeignKey("list_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("task_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            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/20260427082248_AddPlanningPhaseAndBlockedBy.Designer.cs

@@ -1,632 +0,0 @@
-// <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("20260427082248_AddPlanningPhaseAndBlockedBy")]
-    partial class AddPlanningPhaseAndBlockedBy
-    {
-        /// <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>("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",
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("lists", (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.TagEntity", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("id");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Name")
-                        .IsUnique();
-
-                    b.ToTable("tags", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1L,
-                            Name = "agent"
-                        },
-                        new
-                        {
-                            Id = 2L,
-                            Name = "manual"
-                        });
-                });
-
-            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<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.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("list_tags", b =>
-                {
-                    b.Property<string>("list_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("list_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("list_tags", (string)null);
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.Property<string>("task_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("task_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("task_tags", (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("list_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", null)
-                        .WithMany()
-                        .HasForeignKey("list_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("task_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            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/20260427082248_AddPlanningPhaseAndBlockedBy.cs

@@ -1,74 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddPlanningPhaseAndBlockedBy : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<string>(
-                name: "blocked_by_task_id",
-                table: "tasks",
-                type: "TEXT",
-                nullable: true);
-
-            migrationBuilder.AddColumn<string>(
-                name: "planning_phase",
-                table: "tasks",
-                type: "TEXT",
-                nullable: false,
-                defaultValue: "none");
-
-            migrationBuilder.UpdateData(
-                table: "app_settings",
-                keyColumn: "id",
-                keyValue: 1,
-                column: "default_permission_mode",
-                value: "auto");
-
-            migrationBuilder.CreateIndex(
-                name: "idx_tasks_blocked_by",
-                table: "tasks",
-                column: "blocked_by_task_id");
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_tasks_tasks_blocked_by_task_id",
-                table: "tasks",
-                column: "blocked_by_task_id",
-                principalTable: "tasks",
-                principalColumn: "id",
-                onDelete: ReferentialAction.SetNull);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropForeignKey(
-                name: "FK_tasks_tasks_blocked_by_task_id",
-                table: "tasks");
-
-            migrationBuilder.DropIndex(
-                name: "idx_tasks_blocked_by",
-                table: "tasks");
-
-            migrationBuilder.DropColumn(
-                name: "blocked_by_task_id",
-                table: "tasks");
-
-            migrationBuilder.DropColumn(
-                name: "planning_phase",
-                table: "tasks");
-
-            migrationBuilder.UpdateData(
-                table: "app_settings",
-                keyColumn: "id",
-                keyValue: 1,
-                column: "default_permission_mode",
-                value: "bypassPermissions");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260427130058_RetireLegacyTaskStatus.Designer.cs

@@ -1,632 +0,0 @@
-// <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("20260427130058_RetireLegacyTaskStatus")]
-    partial class RetireLegacyTaskStatus
-    {
-        /// <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>("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",
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("lists", (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.TagEntity", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("id");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Name")
-                        .IsUnique();
-
-                    b.ToTable("tags", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1L,
-                            Name = "agent"
-                        },
-                        new
-                        {
-                            Id = 2L,
-                            Name = "manual"
-                        });
-                });
-
-            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<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.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("list_tags", b =>
-                {
-                    b.Property<string>("list_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("list_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("list_tags", (string)null);
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.Property<string>("task_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("task_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("task_tags", (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("list_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", null)
-                        .WithMany()
-                        .HasForeignKey("list_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("task_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            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/20260427130058_RetireLegacyTaskStatus.cs

@@ -1,51 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class RetireLegacyTaskStatus : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            // manual / draft -> idle
-            migrationBuilder.Sql("UPDATE tasks SET status = 'idle' WHERE status IN ('manual', 'draft');");
-
-            // planning -> idle + planning_phase=active
-            migrationBuilder.Sql("UPDATE tasks SET status = 'idle', planning_phase = 'active' WHERE status = 'planning';");
-
-            // planned -> idle + planning_phase=finalized
-            migrationBuilder.Sql("UPDATE tasks SET status = 'idle', planning_phase = 'finalized' WHERE status = 'planned';");
-
-            // waiting -> queued + blocked_by_task_id derived from sort_order chain.
-            // SQLite 3.25+ supports window functions (LAG).
-            migrationBuilder.Sql(@"
-WITH ordered AS (
-  SELECT id,
-         LAG(id) OVER (PARTITION BY parent_task_id ORDER BY sort_order, created_at) AS prev_id
-  FROM tasks
-  WHERE status = 'waiting'
-)
-UPDATE tasks
-SET status = 'queued',
-    blocked_by_task_id = (SELECT prev_id FROM ordered WHERE ordered.id = tasks.id)
-WHERE id IN (SELECT id FROM ordered);");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            // Best-effort and lossy: cancelled is folded back into failed,
-            // (idle, finalized) -> planned, (idle, active) -> planning,
-            // queued + blocked_by_task_id != null -> waiting.
-            // Manual/Draft distinction is unrecoverable — anything previously
-            // 'manual' or 'draft' stays 'idle' on the way back.
-            migrationBuilder.Sql("UPDATE tasks SET status = 'failed' WHERE status = 'cancelled';");
-            migrationBuilder.Sql("UPDATE tasks SET status = 'planned' WHERE status = 'idle' AND planning_phase = 'finalized';");
-            migrationBuilder.Sql("UPDATE tasks SET status = 'planning' WHERE status = 'idle' AND planning_phase = 'active';");
-            migrationBuilder.Sql("UPDATE tasks SET status = 'waiting', blocked_by_task_id = NULL WHERE status = 'queued' AND blocked_by_task_id IS NOT NULL;");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260428064951_AddPrimeSchedules.Designer.cs

@@ -1,679 +0,0 @@
-// <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("20260428064951_AddPrimeSchedules")]
-    partial class AddPrimeSchedules
-    {
-        /// <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>("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",
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    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<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.Property<bool>("WorkdaysOnly")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("workdays_only");
-
-                    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.TagEntity", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("id");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Name")
-                        .IsUnique();
-
-                    b.ToTable("tags", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1L,
-                            Name = "agent"
-                        },
-                        new
-                        {
-                            Id = 2L,
-                            Name = "manual"
-                        });
-                });
-
-            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<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.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("list_tags", b =>
-                {
-                    b.Property<string>("list_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("list_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("list_tags", (string)null);
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.Property<string>("task_id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<long>("tag_id")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("task_id", "tag_id");
-
-                    b.HasIndex("tag_id");
-
-                    b.ToTable("task_tags", (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("list_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", null)
-                        .WithMany()
-                        .HasForeignKey("list_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("task_tags", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TagEntity", null)
-                        .WithMany()
-                        .HasForeignKey("tag_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("task_id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            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/20260428064951_AddPrimeSchedules.cs

@@ -1,41 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddPrimeSchedules : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.CreateTable(
-                name: "prime_schedules",
-                columns: table => new
-                {
-                    id = table.Column<Guid>(type: "TEXT", nullable: false),
-                    start_date = table.Column<DateOnly>(type: "TEXT", nullable: false),
-                    end_date = table.Column<DateOnly>(type: "TEXT", nullable: false),
-                    time_of_day = table.Column<TimeSpan>(type: "TEXT", nullable: false),
-                    workdays_only = table.Column<bool>(type: "INTEGER", nullable: false, defaultValue: true),
-                    enabled = table.Column<bool>(type: "INTEGER", nullable: false, defaultValue: true),
-                    last_run_at = table.Column<DateTimeOffset>(type: "TEXT", nullable: true),
-                    prompt_override = table.Column<string>(type: "TEXT", nullable: true),
-                    created_at = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_prime_schedules", x => x.id);
-                });
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "prime_schedules");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260519044715_RemoveTags.Designer.cs

@@ -1,587 +0,0 @@
-// <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("20260519044715_RemoveTags")]
-    partial class RemoveTags
-    {
-        /// <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>("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",
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    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<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.Property<bool>("WorkdaysOnly")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("workdays_only");
-
-                    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<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.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/20260519044715_RemoveTags.cs

@@ -1,115 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class RemoveTags : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "list_tags");
-
-            migrationBuilder.DropTable(
-                name: "task_tags");
-
-            migrationBuilder.DropTable(
-                name: "tags");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.CreateTable(
-                name: "tags",
-                columns: table => new
-                {
-                    id = table.Column<long>(type: "INTEGER", nullable: false)
-                        .Annotation("Sqlite:Autoincrement", true),
-                    name = table.Column<string>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_tags", x => x.id);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "list_tags",
-                columns: table => new
-                {
-                    list_id = table.Column<string>(type: "TEXT", nullable: false),
-                    tag_id = table.Column<long>(type: "INTEGER", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_list_tags", x => new { x.list_id, x.tag_id });
-                    table.ForeignKey(
-                        name: "FK_list_tags_lists_list_id",
-                        column: x => x.list_id,
-                        principalTable: "lists",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_list_tags_tags_tag_id",
-                        column: x => x.tag_id,
-                        principalTable: "tags",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "task_tags",
-                columns: table => new
-                {
-                    task_id = table.Column<string>(type: "TEXT", nullable: false),
-                    tag_id = table.Column<long>(type: "INTEGER", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_task_tags", x => new { x.task_id, x.tag_id });
-                    table.ForeignKey(
-                        name: "FK_task_tags_tags_tag_id",
-                        column: x => x.tag_id,
-                        principalTable: "tags",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_task_tags_tasks_task_id",
-                        column: x => x.task_id,
-                        principalTable: "tasks",
-                        principalColumn: "id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.InsertData(
-                table: "tags",
-                columns: new[] { "id", "name" },
-                values: new object[,]
-                {
-                    { 1L, "agent" },
-                    { 2L, "manual" }
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_list_tags_tag_id",
-                table: "list_tags",
-                column: "tag_id");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_tags_name",
-                table: "tags",
-                column: "name",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_task_tags_tag_id",
-                table: "task_tags",
-                column: "tag_id");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260529142614_AddRepoImportFolders.Designer.cs

@@ -1,591 +0,0 @@
-// <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("20260529142614_AddRepoImportFolders")]
-    partial class AddRepoImportFolders
-    {
-        /// <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<string>("RepoImportFolders")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("repo_import_folders");
-
-                    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",
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    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<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.Property<bool>("WorkdaysOnly")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("workdays_only");
-
-                    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<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.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/20260529142614_AddRepoImportFolders.cs

@@ -1,35 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddRepoImportFolders : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<string>(
-                name: "repo_import_folders",
-                table: "app_settings",
-                type: "TEXT",
-                nullable: true);
-
-            migrationBuilder.UpdateData(
-                table: "app_settings",
-                keyColumn: "id",
-                keyValue: 1,
-                column: "repo_import_folders",
-                value: null);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "repo_import_folders",
-                table: "app_settings");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260601114247_AddListSortOrder.Designer.cs

@@ -1,600 +0,0 @@
-// <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("20260601114247_AddListSortOrder")]
-    partial class AddListSortOrder
-    {
-        /// <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<string>("RepoImportFolders")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("repo_import_folders");
-
-                    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",
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.Property<bool>("WorkdaysOnly")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("workdays_only");
-
-                    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<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.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/20260601114247_AddListSortOrder.cs

@@ -1,48 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddListSortOrder : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<int>(
-                name: "sort_order",
-                table: "lists",
-                type: "INTEGER",
-                nullable: false,
-                defaultValue: 0);
-
-            // Backfill existing rows with a dense order (0..N-1) by creation time
-            // so today's sidebar order is preserved after the migration.
-            migrationBuilder.Sql("""
-                WITH ordered AS (
-                    SELECT id, (row_number() OVER (ORDER BY created_at) - 1) AS rn
-                    FROM lists
-                )
-                UPDATE lists SET sort_order = (SELECT rn FROM ordered WHERE ordered.id = lists.id);
-                """);
-
-            migrationBuilder.CreateIndex(
-                name: "idx_lists_sort",
-                table: "lists",
-                column: "sort_order");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropIndex(
-                name: "idx_lists_sort",
-                table: "lists");
-
-            migrationBuilder.DropColumn(
-                name: "sort_order",
-                table: "lists");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260601133737_AddMaxParallelExecutions.Designer.cs

@@ -1,607 +0,0 @@
-// <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("20260601133737_AddMaxParallelExecutions")]
-    partial class AddMaxParallelExecutions
-    {
-        /// <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<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,
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.Property<bool>("WorkdaysOnly")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("workdays_only");
-
-                    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<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.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/20260601133737_AddMaxParallelExecutions.cs

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

src/ClaudeDo.Data/Migrations/20260601140000_NormalizeListIdFormat.Designer.cs

@@ -1,607 +0,0 @@
-// <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("20260601140000_NormalizeListIdFormat")]
-    partial class NormalizeListIdFormat
-    {
-        /// <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<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,
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.Property<bool>("WorkdaysOnly")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("workdays_only");
-
-                    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<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.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/20260601140000_NormalizeListIdFormat.cs

@@ -1,52 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class NormalizeListIdFormat : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            // SQLite: PRAGMA foreign_keys must run outside a transaction.
-            migrationBuilder.Sql("PRAGMA foreign_keys = OFF;", suppressTransaction: true);
-
-            // Normalize tasks.list_id: 32-char compact hex → 36-char dashed UUID
-            migrationBuilder.Sql("""
-                UPDATE tasks
-                SET list_id = substr(list_id,1,8)||'-'||substr(list_id,9,4)||'-'||substr(list_id,13,4)||'-'||substr(list_id,17,4)||'-'||substr(list_id,21,12)
-                WHERE length(list_id) = 32;
-                """);
-
-            // Normalize list_config.list_id (also the PK of that table)
-            migrationBuilder.Sql("""
-                UPDATE list_config
-                SET list_id = substr(list_id,1,8)||'-'||substr(list_id,9,4)||'-'||substr(list_id,13,4)||'-'||substr(list_id,17,4)||'-'||substr(list_id,21,12)
-                WHERE length(list_id) = 32;
-                """);
-
-            // Normalize lists.id (PK — must come last)
-            migrationBuilder.Sql("""
-                UPDATE lists
-                SET id = substr(id,1,8)||'-'||substr(id,9,4)||'-'||substr(id,13,4)||'-'||substr(id,17,4)||'-'||substr(id,21,12)
-                WHERE length(id) = 32;
-                """);
-
-            migrationBuilder.Sql("PRAGMA foreign_keys = ON;", suppressTransaction: true);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.Sql("PRAGMA foreign_keys = OFF;", suppressTransaction: true);
-
-            migrationBuilder.Sql("UPDATE tasks SET list_id = replace(list_id,'-','') WHERE length(list_id) = 36;");
-            migrationBuilder.Sql("UPDATE list_config SET list_id = replace(list_id,'-','') WHERE length(list_id) = 36;");
-            migrationBuilder.Sql("UPDATE lists SET id = replace(id,'-','') WHERE length(id) = 36;");
-
-            migrationBuilder.Sql("PRAGMA foreign_keys = ON;", suppressTransaction: true);
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260601150820_AddReviewFeedback.Designer.cs

@@ -1,611 +0,0 @@
-// <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("20260601150820_AddReviewFeedback")]
-    partial class AddReviewFeedback
-    {
-        /// <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<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,
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.Property<bool>("WorkdaysOnly")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("workdays_only");
-
-                    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.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/20260601150820_AddReviewFeedback.cs

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

src/ClaudeDo.Data/Migrations/20260602060000_PrimeWeekdays.Designer.cs

@@ -1,603 +0,0 @@
-// <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("20260602060000_PrimeWeekdays")]
-    partial class PrimeWeekdays
-    {
-        /// <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<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,
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            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.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/20260602060000_PrimeWeekdays.cs

@@ -1,48 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class PrimeWeekdays : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<int>(
-                name: "days_of_week",
-                table: "prime_schedules",
-                type: "INTEGER",
-                nullable: false,
-                defaultValue: 31);
-
-            migrationBuilder.Sql(
-                "UPDATE prime_schedules SET days_of_week = CASE WHEN workdays_only = 1 THEN 31 ELSE 127 END;");
-
-            migrationBuilder.DropColumn(name: "start_date", table: "prime_schedules");
-            migrationBuilder.DropColumn(name: "end_date", table: "prime_schedules");
-            migrationBuilder.DropColumn(name: "workdays_only", table: "prime_schedules");
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<DateOnly>(
-                name: "start_date", table: "prime_schedules",
-                type: "TEXT", nullable: false, defaultValue: new DateOnly(2000, 1, 1));
-            migrationBuilder.AddColumn<DateOnly>(
-                name: "end_date", table: "prime_schedules",
-                type: "TEXT", nullable: false, defaultValue: new DateOnly(2099, 12, 31));
-            migrationBuilder.AddColumn<bool>(
-                name: "workdays_only", table: "prime_schedules",
-                type: "INTEGER", nullable: false, defaultValue: true);
-
-            migrationBuilder.Sql(
-                "UPDATE prime_schedules SET workdays_only = CASE WHEN days_of_week = 127 THEN 0 ELSE 1 END;");
-
-            migrationBuilder.DropColumn(name: "days_of_week", table: "prime_schedules");
-        }
-    }
-}

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

@@ -1,675 +0,0 @@
-// <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

@@ -1,94 +0,0 @@
-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

@@ -1,682 +0,0 @@
-// <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

@@ -1,36 +0,0 @@
-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

@@ -1,690 +0,0 @@
-// <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/20260604125720_AddRoadblockCount.Designer.cs

@@ -1,696 +0,0 @@
-// <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/20260609000000_UniqueListName.Designer.cs

@@ -1,696 +0,0 @@
-// <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("20260609000000_UniqueListName")]
-    partial class UniqueListName
-    {
-        /// <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/20260609000000_UniqueListName.cs

@@ -1,30 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class UniqueListName : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            // Remove duplicate list rows that have no tasks — keep the oldest rowid.
-            // This handles the startup-race case where both App and Worker seeded
-            // the same default list names concurrently.
-            migrationBuilder.Sql("""
-                DELETE FROM lists
-                WHERE (SELECT COUNT(*) FROM tasks WHERE list_id = lists.id) = 0
-                  AND rowid NOT IN (
-                      SELECT MIN(l2.rowid) FROM lists l2 WHERE l2.name = lists.name
-                  )
-                """);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-        }
-    }
-}

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

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

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

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

src/ClaudeDo.Data/Migrations/20260703072917_AddSessionSkills.Designer.cs

@@ -1,786 +0,0 @@
-// <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("20260703072917_AddSessionSkills")]
-    partial class AddSessionSkills
-    {
-        /// <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<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    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>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    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.SessionSkillEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<DateTimeOffset>("AddedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("added_at");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<string>("PinnedRef")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("pinned_ref");
-
-                    b.Property<string>("SourceUrl")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("source_url");
-
-                    b.Property<string>("Subpath")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("subpath");
-
-                    b.HasKey("Name");
-
-                    b.ToTable("session_skills", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<bool>("Completed")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("completed");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("OrderNum")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("order_num");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_subtasks_task_id");
-
-                    b.ToTable("subtasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<long>("ByteSize")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("byte_size");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("FileName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("file_name");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_attachments_task_id");
-
-                    b.ToTable("task_attachments", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("AgentPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("agent_path");
-
-                    b.Property<string>("BlockedByTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("blocked_by_task_id");
-
-                    b.Property<string>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("CreatedBy")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_by");
-
-                    b.Property<string>("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<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("status");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("BlockedByTaskId")
-                        .HasDatabaseName("idx_tasks_blocked_by");
-
-                    b.HasIndex("ListId")
-                        .HasDatabaseName("idx_tasks_list_id");
-
-                    b.HasIndex("ParentTaskId")
-                        .HasDatabaseName("idx_tasks_parent_task_id");
-
-                    b.HasIndex("Status")
-                        .HasDatabaseName("idx_tasks_status");
-
-                    b.HasIndex("ListId", "SortOrder")
-                        .HasDatabaseName("idx_tasks_list_sort");
-
-                    b.ToTable("tasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("ErrorMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("error_markdown");
-
-                    b.Property<int?>("ExitCode")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("exit_code");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<bool>("IsRetry")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_retry");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<string>("Prompt")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt");
-
-                    b.Property<string>("ResultMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result_markdown");
-
-                    b.Property<int>("RunNumber")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("run_number");
-
-                    b.Property<string>("SessionId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_id");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("StructuredOutputJson")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("structured_output");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<int?>("TokensIn")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("tokens_in");
-
-                    b.Property<int?>("TokensOut")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("tokens_out");
-
-                    b.Property<int?>("TurnCount")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("turn_count");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_runs_task_id");
-
-                    b.ToTable("task_runs", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WeekReportEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTime>("GeneratedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("generated_at");
-
-                    b.Property<string>("Markdown")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("markdown");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("StartDate", "EndDate")
-                        .IsUnique();
-
-                    b.ToTable("week_reports", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
-                {
-                    b.Property<string>("TaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("BaseCommit")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("base_commit");
-
-                    b.Property<string>("BranchName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("branch_name");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("DiffStat")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("diff_stat");
-
-                    b.Property<string>("HeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("head_commit");
-
-                    b.Property<string>("Path")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("path");
-
-                    b.Property<string>("State")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("active")
-                        .HasColumnName("state");
-
-                    b.HasKey("TaskId");
-
-                    b.ToTable("worktrees", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithOne("Config")
-                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Subtasks")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany()
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("BlockedByTaskId")
-                        .OnDelete(DeleteBehavior.SetNull);
-
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithMany("Tasks")
-                        .HasForeignKey("ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Parent")
-                        .WithMany("Children")
-                        .HasForeignKey("ParentTaskId")
-                        .OnDelete(DeleteBehavior.Restrict);
-
-                    b.Navigation("List");
-
-                    b.Navigation("Parent");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Runs")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithOne("Worktree")
-                        .HasForeignKey("ClaudeDo.Data.Models.WorktreeEntity", "TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Navigation("Config");
-
-                    b.Navigation("Tasks");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Navigation("Children");
-
-                    b.Navigation("Runs");
-
-                    b.Navigation("Subtasks");
-
-                    b.Navigation("Worktree");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260703072917_AddSessionSkills.cs

@@ -1,75 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddSessionSkills : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<string>(
-                name: "session_skills",
-                table: "tasks",
-                type: "TEXT",
-                nullable: true);
-
-            migrationBuilder.AddColumn<string>(
-                name: "session_skills",
-                table: "list_config",
-                type: "TEXT",
-                nullable: true);
-
-            migrationBuilder.AddColumn<string>(
-                name: "session_skills",
-                table: "app_settings",
-                type: "TEXT",
-                nullable: true);
-
-            migrationBuilder.CreateTable(
-                name: "session_skills",
-                columns: table => new
-                {
-                    name = table.Column<string>(type: "TEXT", nullable: false),
-                    source_url = table.Column<string>(type: "TEXT", nullable: false),
-                    pinned_ref = table.Column<string>(type: "TEXT", nullable: false),
-                    subpath = table.Column<string>(type: "TEXT", nullable: false),
-                    description = table.Column<string>(type: "TEXT", nullable: false),
-                    added_at = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_session_skills", x => x.name);
-                });
-
-            migrationBuilder.UpdateData(
-                table: "app_settings",
-                keyColumn: "id",
-                keyValue: 1,
-                column: "session_skills",
-                value: null);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "session_skills");
-
-            migrationBuilder.DropColumn(
-                name: "session_skills",
-                table: "tasks");
-
-            migrationBuilder.DropColumn(
-                name: "session_skills",
-                table: "list_config");
-
-            migrationBuilder.DropColumn(
-                name: "session_skills",
-                table: "app_settings");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260727114206_AddModelPresetsAndManualFlag.Designer.cs

@@ -1,802 +0,0 @@
-// <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("20260727114206_AddModelPresetsAndManualFlag")]
-    partial class AddModelPresetsAndManualFlag
-    {
-        /// <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>("ModelPresets")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model_presets");
-
-                    b.Property<string>("RepoImportFolders")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("repo_import_folders");
-
-                    b.Property<string>("ReportExcludedPaths")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("report_excluded_paths");
-
-                    b.Property<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("StandupWeekday")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(3)
-                        .HasColumnName("standup_weekday");
-
-                    b.Property<int>("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>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    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<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SortOrder")
-                        .HasDatabaseName("idx_lists_sort");
-
-                    b.ToTable("lists", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("Days")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(31)
-                        .HasColumnName("days_of_week");
-
-                    b.Property<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("prime_schedules", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SessionSkillEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<DateTimeOffset>("AddedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("added_at");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<string>("PinnedRef")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("pinned_ref");
-
-                    b.Property<string>("SourceUrl")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("source_url");
-
-                    b.Property<string>("Subpath")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("subpath");
-
-                    b.HasKey("Name");
-
-                    b.ToTable("session_skills", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<bool>("Completed")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("completed");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("OrderNum")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("order_num");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_subtasks_task_id");
-
-                    b.ToTable("subtasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<long>("ByteSize")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("byte_size");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("FileName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("file_name");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_attachments_task_id");
-
-                    b.ToTable("task_attachments", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("AgentPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("agent_path");
-
-                    b.Property<string>("BlockedByTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("blocked_by_task_id");
-
-                    b.Property<string>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("CreatedBy")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_by");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<bool>("IsMyDay")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_my_day");
-
-                    b.Property<bool>("IsStarred")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_starred");
-
-                    b.Property<string>("ListId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("list_id");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<int?>("MaxTurns")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("max_turns");
-
-                    b.Property<string>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Notes")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("notes");
-
-                    b.Property<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<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("status");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("BlockedByTaskId")
-                        .HasDatabaseName("idx_tasks_blocked_by");
-
-                    b.HasIndex("ListId")
-                        .HasDatabaseName("idx_tasks_list_id");
-
-                    b.HasIndex("ParentTaskId")
-                        .HasDatabaseName("idx_tasks_parent_task_id");
-
-                    b.HasIndex("Status")
-                        .HasDatabaseName("idx_tasks_status");
-
-                    b.HasIndex("ListId", "SortOrder")
-                        .HasDatabaseName("idx_tasks_list_sort");
-
-                    b.ToTable("tasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("ErrorMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("error_markdown");
-
-                    b.Property<int?>("ExitCode")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("exit_code");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<bool>("IsRetry")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_retry");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<string>("Prompt")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt");
-
-                    b.Property<string>("ResultMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result_markdown");
-
-                    b.Property<int>("RunNumber")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("run_number");
-
-                    b.Property<string>("SessionId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_id");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("StructuredOutputJson")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("structured_output");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<int?>("TokensIn")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("tokens_in");
-
-                    b.Property<int?>("TokensOut")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("tokens_out");
-
-                    b.Property<int?>("TurnCount")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("turn_count");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_runs_task_id");
-
-                    b.ToTable("task_runs", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WeekReportEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTime>("GeneratedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("generated_at");
-
-                    b.Property<string>("Markdown")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("markdown");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("StartDate", "EndDate")
-                        .IsUnique();
-
-                    b.ToTable("week_reports", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
-                {
-                    b.Property<string>("TaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("BaseCommit")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("base_commit");
-
-                    b.Property<string>("BranchName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("branch_name");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("DiffStat")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("diff_stat");
-
-                    b.Property<string>("HeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("head_commit");
-
-                    b.Property<string>("Path")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("path");
-
-                    b.Property<string>("State")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("active")
-                        .HasColumnName("state");
-
-                    b.HasKey("TaskId");
-
-                    b.ToTable("worktrees", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithOne("Config")
-                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Subtasks")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany()
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("BlockedByTaskId")
-                        .OnDelete(DeleteBehavior.SetNull);
-
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithMany("Tasks")
-                        .HasForeignKey("ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Parent")
-                        .WithMany("Children")
-                        .HasForeignKey("ParentTaskId")
-                        .OnDelete(DeleteBehavior.Restrict);
-
-                    b.Navigation("List");
-
-                    b.Navigation("Parent");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Runs")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithOne("Worktree")
-                        .HasForeignKey("ClaudeDo.Data.Models.WorktreeEntity", "TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Navigation("Config");
-
-                    b.Navigation("Tasks");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Navigation("Children");
-
-                    b.Navigation("Runs");
-
-                    b.Navigation("Subtasks");
-
-                    b.Navigation("Worktree");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260805065217_AddHandlerCommitRange.Designer.cs

@@ -1,810 +0,0 @@
-// <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("20260805065217_AddHandlerCommitRange")]
-    partial class AddHandlerCommitRange
-    {
-        /// <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>("ModelPresets")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model_presets");
-
-                    b.Property<string>("RepoImportFolders")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("repo_import_folders");
-
-                    b.Property<string>("ReportExcludedPaths")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("report_excluded_paths");
-
-                    b.Property<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("StandupWeekday")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(3)
-                        .HasColumnName("standup_weekday");
-
-                    b.Property<int>("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>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    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<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SortOrder")
-                        .HasDatabaseName("idx_lists_sort");
-
-                    b.ToTable("lists", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("Days")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(31)
-                        .HasColumnName("days_of_week");
-
-                    b.Property<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("prime_schedules", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SessionSkillEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<DateTimeOffset>("AddedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("added_at");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<string>("PinnedRef")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("pinned_ref");
-
-                    b.Property<string>("SourceUrl")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("source_url");
-
-                    b.Property<string>("Subpath")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("subpath");
-
-                    b.HasKey("Name");
-
-                    b.ToTable("session_skills", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<bool>("Completed")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("completed");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("OrderNum")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("order_num");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_subtasks_task_id");
-
-                    b.ToTable("subtasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<long>("ByteSize")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("byte_size");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("FileName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("file_name");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_attachments_task_id");
-
-                    b.ToTable("task_attachments", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("AgentPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("agent_path");
-
-                    b.Property<string>("BlockedByTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("blocked_by_task_id");
-
-                    b.Property<string>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("CreatedBy")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_by");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<string>("HandlerBaseCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_base_commit");
-
-                    b.Property<string>("HandlerHeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_head_commit");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<bool>("IsMyDay")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_my_day");
-
-                    b.Property<bool>("IsStarred")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_starred");
-
-                    b.Property<string>("ListId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("list_id");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<int?>("MaxTurns")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("max_turns");
-
-                    b.Property<string>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Notes")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("notes");
-
-                    b.Property<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<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("status");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("BlockedByTaskId")
-                        .HasDatabaseName("idx_tasks_blocked_by");
-
-                    b.HasIndex("ListId")
-                        .HasDatabaseName("idx_tasks_list_id");
-
-                    b.HasIndex("ParentTaskId")
-                        .HasDatabaseName("idx_tasks_parent_task_id");
-
-                    b.HasIndex("Status")
-                        .HasDatabaseName("idx_tasks_status");
-
-                    b.HasIndex("ListId", "SortOrder")
-                        .HasDatabaseName("idx_tasks_list_sort");
-
-                    b.ToTable("tasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("ErrorMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("error_markdown");
-
-                    b.Property<int?>("ExitCode")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("exit_code");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<bool>("IsRetry")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_retry");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<string>("Prompt")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt");
-
-                    b.Property<string>("ResultMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result_markdown");
-
-                    b.Property<int>("RunNumber")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("run_number");
-
-                    b.Property<string>("SessionId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_id");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("StructuredOutputJson")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("structured_output");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<int?>("TokensIn")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("tokens_in");
-
-                    b.Property<int?>("TokensOut")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("tokens_out");
-
-                    b.Property<int?>("TurnCount")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("turn_count");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_runs_task_id");
-
-                    b.ToTable("task_runs", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WeekReportEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTime>("GeneratedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("generated_at");
-
-                    b.Property<string>("Markdown")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("markdown");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("StartDate", "EndDate")
-                        .IsUnique();
-
-                    b.ToTable("week_reports", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
-                {
-                    b.Property<string>("TaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("BaseCommit")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("base_commit");
-
-                    b.Property<string>("BranchName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("branch_name");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("DiffStat")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("diff_stat");
-
-                    b.Property<string>("HeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("head_commit");
-
-                    b.Property<string>("Path")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("path");
-
-                    b.Property<string>("State")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("active")
-                        .HasColumnName("state");
-
-                    b.HasKey("TaskId");
-
-                    b.ToTable("worktrees", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithOne("Config")
-                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Subtasks")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany()
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("BlockedByTaskId")
-                        .OnDelete(DeleteBehavior.SetNull);
-
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithMany("Tasks")
-                        .HasForeignKey("ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Parent")
-                        .WithMany("Children")
-                        .HasForeignKey("ParentTaskId")
-                        .OnDelete(DeleteBehavior.Restrict);
-
-                    b.Navigation("List");
-
-                    b.Navigation("Parent");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Runs")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithOne("Worktree")
-                        .HasForeignKey("ClaudeDo.Data.Models.WorktreeEntity", "TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Navigation("Config");
-
-                    b.Navigation("Tasks");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Navigation("Children");
-
-                    b.Navigation("Runs");
-
-                    b.Navigation("Subtasks");
-
-                    b.Navigation("Worktree");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260805074906_AddUsageGateAndRunModel.Designer.cs

@@ -1,828 +0,0 @@
-// <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("20260805074906_AddUsageGateAndRunModel")]
-    partial class AddUsageGateAndRunModel
-    {
-        /// <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>("ModelPresets")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model_presets");
-
-                    b.Property<string>("RepoImportFolders")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("repo_import_folders");
-
-                    b.Property<string>("ReportExcludedPaths")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("report_excluded_paths");
-
-                    b.Property<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("StandupWeekday")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(3)
-                        .HasColumnName("standup_weekday");
-
-                    b.Property<int>("UsageGateFiveHourPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(80)
-                        .HasColumnName("usage_gate_five_hour_pct");
-
-                    b.Property<int>("UsageGateSevenDayPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(90)
-                        .HasColumnName("usage_gate_seven_day_pct");
-
-                    b.Property<int>("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,
-                            UsageGateFiveHourPct = 80,
-                            UsageGateSevenDayPct = 90,
-                            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>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    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<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SortOrder")
-                        .HasDatabaseName("idx_lists_sort");
-
-                    b.ToTable("lists", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("Days")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(31)
-                        .HasColumnName("days_of_week");
-
-                    b.Property<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("prime_schedules", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SessionSkillEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<DateTimeOffset>("AddedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("added_at");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<string>("PinnedRef")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("pinned_ref");
-
-                    b.Property<string>("SourceUrl")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("source_url");
-
-                    b.Property<string>("Subpath")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("subpath");
-
-                    b.HasKey("Name");
-
-                    b.ToTable("session_skills", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<bool>("Completed")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("completed");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("OrderNum")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("order_num");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_subtasks_task_id");
-
-                    b.ToTable("subtasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<long>("ByteSize")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("byte_size");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("FileName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("file_name");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_attachments_task_id");
-
-                    b.ToTable("task_attachments", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("AgentPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("agent_path");
-
-                    b.Property<string>("BlockedByTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("blocked_by_task_id");
-
-                    b.Property<string>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("CreatedBy")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_by");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<string>("HandlerBaseCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_base_commit");
-
-                    b.Property<string>("HandlerHeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_head_commit");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<bool>("IsMyDay")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_my_day");
-
-                    b.Property<bool>("IsStarred")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_starred");
-
-                    b.Property<string>("ListId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("list_id");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<int?>("MaxTurns")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("max_turns");
-
-                    b.Property<string>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Notes")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("notes");
-
-                    b.Property<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<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("status");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("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>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Prompt")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt");
-
-                    b.Property<string>("ResultMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result_markdown");
-
-                    b.Property<int>("RunNumber")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("run_number");
-
-                    b.Property<string>("SessionId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_id");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("StructuredOutputJson")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("structured_output");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<int?>("TokensIn")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("tokens_in");
-
-                    b.Property<int?>("TokensOut")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("tokens_out");
-
-                    b.Property<int?>("TurnCount")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("turn_count");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_runs_task_id");
-
-                    b.ToTable("task_runs", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WeekReportEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTime>("GeneratedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("generated_at");
-
-                    b.Property<string>("Markdown")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("markdown");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("StartDate", "EndDate")
-                        .IsUnique();
-
-                    b.ToTable("week_reports", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
-                {
-                    b.Property<string>("TaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("BaseCommit")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("base_commit");
-
-                    b.Property<string>("BranchName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("branch_name");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("DiffStat")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("diff_stat");
-
-                    b.Property<string>("HeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("head_commit");
-
-                    b.Property<string>("Path")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("path");
-
-                    b.Property<string>("State")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("active")
-                        .HasColumnName("state");
-
-                    b.HasKey("TaskId");
-
-                    b.ToTable("worktrees", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithOne("Config")
-                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Subtasks")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany()
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("BlockedByTaskId")
-                        .OnDelete(DeleteBehavior.SetNull);
-
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithMany("Tasks")
-                        .HasForeignKey("ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Parent")
-                        .WithMany("Children")
-                        .HasForeignKey("ParentTaskId")
-                        .OnDelete(DeleteBehavior.Restrict);
-
-                    b.Navigation("List");
-
-                    b.Navigation("Parent");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Runs")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithOne("Worktree")
-                        .HasForeignKey("ClaudeDo.Data.Models.WorktreeEntity", "TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Navigation("Config");
-
-                    b.Navigation("Tasks");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Navigation("Children");
-
-                    b.Navigation("Runs");
-
-                    b.Navigation("Subtasks");
-
-                    b.Navigation("Worktree");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260805090016_AddVerifyCommand.Designer.cs

@@ -1,832 +0,0 @@
-// <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("20260805090016_AddVerifyCommand")]
-    partial class AddVerifyCommand
-    {
-        /// <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>("ModelPresets")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model_presets");
-
-                    b.Property<string>("RepoImportFolders")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("repo_import_folders");
-
-                    b.Property<string>("ReportExcludedPaths")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("report_excluded_paths");
-
-                    b.Property<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("StandupWeekday")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(3)
-                        .HasColumnName("standup_weekday");
-
-                    b.Property<int>("UsageGateFiveHourPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(80)
-                        .HasColumnName("usage_gate_five_hour_pct");
-
-                    b.Property<int>("UsageGateSevenDayPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(90)
-                        .HasColumnName("usage_gate_seven_day_pct");
-
-                    b.Property<int>("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,
-                            UsageGateFiveHourPct = 80,
-                            UsageGateSevenDayPct = 90,
-                            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>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("VerifyCommand")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("verify_command");
-
-                    b.HasKey("ListId");
-
-                    b.ToTable("list_config", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("DefaultCommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("default_commit_type");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SortOrder")
-                        .HasDatabaseName("idx_lists_sort");
-
-                    b.ToTable("lists", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("Days")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(31)
-                        .HasColumnName("days_of_week");
-
-                    b.Property<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("prime_schedules", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SessionSkillEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<DateTimeOffset>("AddedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("added_at");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<string>("PinnedRef")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("pinned_ref");
-
-                    b.Property<string>("SourceUrl")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("source_url");
-
-                    b.Property<string>("Subpath")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("subpath");
-
-                    b.HasKey("Name");
-
-                    b.ToTable("session_skills", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<bool>("Completed")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("completed");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("OrderNum")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("order_num");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_subtasks_task_id");
-
-                    b.ToTable("subtasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<long>("ByteSize")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("byte_size");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("FileName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("file_name");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_attachments_task_id");
-
-                    b.ToTable("task_attachments", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("AgentPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("agent_path");
-
-                    b.Property<string>("BlockedByTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("blocked_by_task_id");
-
-                    b.Property<string>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("CreatedBy")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_by");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<string>("HandlerBaseCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_base_commit");
-
-                    b.Property<string>("HandlerHeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_head_commit");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<bool>("IsMyDay")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_my_day");
-
-                    b.Property<bool>("IsStarred")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_starred");
-
-                    b.Property<string>("ListId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("list_id");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<int?>("MaxTurns")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("max_turns");
-
-                    b.Property<string>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Notes")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("notes");
-
-                    b.Property<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<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("status");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("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>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Prompt")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt");
-
-                    b.Property<string>("ResultMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result_markdown");
-
-                    b.Property<int>("RunNumber")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("run_number");
-
-                    b.Property<string>("SessionId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_id");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("StructuredOutputJson")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("structured_output");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<int?>("TokensIn")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("tokens_in");
-
-                    b.Property<int?>("TokensOut")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("tokens_out");
-
-                    b.Property<int?>("TurnCount")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("turn_count");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_runs_task_id");
-
-                    b.ToTable("task_runs", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WeekReportEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateOnly>("EndDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("end_date");
-
-                    b.Property<DateTime>("GeneratedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("generated_at");
-
-                    b.Property<string>("Markdown")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("markdown");
-
-                    b.Property<DateOnly>("StartDate")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("start_date");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("StartDate", "EndDate")
-                        .IsUnique();
-
-                    b.ToTable("week_reports", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
-                {
-                    b.Property<string>("TaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("BaseCommit")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("base_commit");
-
-                    b.Property<string>("BranchName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("branch_name");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("DiffStat")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("diff_stat");
-
-                    b.Property<string>("HeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("head_commit");
-
-                    b.Property<string>("Path")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("path");
-
-                    b.Property<string>("State")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("active")
-                        .HasColumnName("state");
-
-                    b.HasKey("TaskId");
-
-                    b.ToTable("worktrees", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithOne("Config")
-                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Subtasks")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany()
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("BlockedByTaskId")
-                        .OnDelete(DeleteBehavior.SetNull);
-
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithMany("Tasks")
-                        .HasForeignKey("ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Parent")
-                        .WithMany("Children")
-                        .HasForeignKey("ParentTaskId")
-                        .OnDelete(DeleteBehavior.Restrict);
-
-                    b.Navigation("List");
-
-                    b.Navigation("Parent");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Runs")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithOne("Worktree")
-                        .HasForeignKey("ClaudeDo.Data.Models.WorktreeEntity", "TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Navigation("Config");
-
-                    b.Navigation("Tasks");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Navigation("Children");
-
-                    b.Navigation("Runs");
-
-                    b.Navigation("Subtasks");
-
-                    b.Navigation("Worktree");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260805090016_AddVerifyCommand.cs

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

src/ClaudeDo.Data/Migrations/20260805091910_AddWorktreeMergeCommit.Designer.cs

@@ -1,832 +0,0 @@
-// <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("20260805091910_AddWorktreeMergeCommit")]
-    partial class AddWorktreeMergeCommit
-    {
-        /// <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>("ModelPresets")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model_presets");
-
-                    b.Property<string>("RepoImportFolders")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("repo_import_folders");
-
-                    b.Property<string>("ReportExcludedPaths")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("report_excluded_paths");
-
-                    b.Property<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("StandupWeekday")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(3)
-                        .HasColumnName("standup_weekday");
-
-                    b.Property<int>("UsageGateFiveHourPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(80)
-                        .HasColumnName("usage_gate_five_hour_pct");
-
-                    b.Property<int>("UsageGateSevenDayPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(90)
-                        .HasColumnName("usage_gate_seven_day_pct");
-
-                    b.Property<int>("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,
-                            UsageGateFiveHourPct = 80,
-                            UsageGateSevenDayPct = 90,
-                            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>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    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<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SortOrder")
-                        .HasDatabaseName("idx_lists_sort");
-
-                    b.ToTable("lists", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("Days")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(31)
-                        .HasColumnName("days_of_week");
-
-                    b.Property<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("prime_schedules", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SessionSkillEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<DateTimeOffset>("AddedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("added_at");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<string>("PinnedRef")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("pinned_ref");
-
-                    b.Property<string>("SourceUrl")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("source_url");
-
-                    b.Property<string>("Subpath")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("subpath");
-
-                    b.HasKey("Name");
-
-                    b.ToTable("session_skills", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<bool>("Completed")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("completed");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("OrderNum")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("order_num");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_subtasks_task_id");
-
-                    b.ToTable("subtasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<long>("ByteSize")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("byte_size");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("FileName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("file_name");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_attachments_task_id");
-
-                    b.ToTable("task_attachments", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("AgentPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("agent_path");
-
-                    b.Property<string>("BlockedByTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("blocked_by_task_id");
-
-                    b.Property<string>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("CreatedBy")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_by");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<string>("HandlerBaseCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_base_commit");
-
-                    b.Property<string>("HandlerHeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_head_commit");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<bool>("IsMyDay")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_my_day");
-
-                    b.Property<bool>("IsStarred")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_starred");
-
-                    b.Property<string>("ListId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("list_id");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<int?>("MaxTurns")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("max_turns");
-
-                    b.Property<string>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Notes")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("notes");
-
-                    b.Property<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<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("status");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("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>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Prompt")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt");
-
-                    b.Property<string>("ResultMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result_markdown");
-
-                    b.Property<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>("MergeCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("merge_commit");
-
-                    b.Property<string>("Path")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("path");
-
-                    b.Property<string>("State")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("active")
-                        .HasColumnName("state");
-
-                    b.HasKey("TaskId");
-
-                    b.ToTable("worktrees", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithOne("Config")
-                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Subtasks")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany()
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("BlockedByTaskId")
-                        .OnDelete(DeleteBehavior.SetNull);
-
-                    b.HasOne("ClaudeDo.Data.Models.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/20260805091910_AddWorktreeMergeCommit.cs

@@ -1,28 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddWorktreeMergeCommit : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<string>(
-                name: "merge_commit",
-                table: "worktrees",
-                type: "TEXT",
-                nullable: true);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "merge_commit",
-                table: "worktrees");
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260805132052_AddMaxTurnsCeiling.Designer.cs

@@ -1,843 +0,0 @@
-// <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("20260805132052_AddMaxTurnsCeiling")]
-    partial class AddMaxTurnsCeiling
-    {
-        /// <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(40)
-                        .HasColumnName("default_max_turns");
-
-                    b.Property<string>("DefaultModel")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("sonnet")
-                        .HasColumnName("default_model");
-
-                    b.Property<string>("DefaultPermissionMode")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("bypassPermissions")
-                        .HasColumnName("default_permission_mode");
-
-                    b.Property<int>("MaxParallelExecutions")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(1)
-                        .HasColumnName("max_parallel_executions");
-
-                    b.Property<int>("MaxTurnsCeiling")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(80)
-                        .HasColumnName("max_turns_ceiling");
-
-                    b.Property<string>("ModelPresets")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model_presets");
-
-                    b.Property<string>("RepoImportFolders")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("repo_import_folders");
-
-                    b.Property<string>("ReportExcludedPaths")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("report_excluded_paths");
-
-                    b.Property<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("StandupWeekday")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(3)
-                        .HasColumnName("standup_weekday");
-
-                    b.Property<int>("UsageGateFiveHourPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(80)
-                        .HasColumnName("usage_gate_five_hour_pct");
-
-                    b.Property<int>("UsageGateSevenDayPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(90)
-                        .HasColumnName("usage_gate_seven_day_pct");
-
-                    b.Property<int>("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 = 40,
-                            DefaultModel = "sonnet",
-                            DefaultPermissionMode = "auto",
-                            MaxParallelExecutions = 1,
-                            MaxTurnsCeiling = 80,
-                            StandupWeekday = 3,
-                            UsageGateFiveHourPct = 80,
-                            UsageGateSevenDayPct = 90,
-                            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>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("VerifyCommand")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("verify_command");
-
-                    b.HasKey("ListId");
-
-                    b.ToTable("list_config", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("DefaultCommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("default_commit_type");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SortOrder")
-                        .HasDatabaseName("idx_lists_sort");
-
-                    b.ToTable("lists", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("Days")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(31)
-                        .HasColumnName("days_of_week");
-
-                    b.Property<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("prime_schedules", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SessionSkillEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<DateTimeOffset>("AddedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("added_at");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<string>("PinnedRef")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("pinned_ref");
-
-                    b.Property<string>("SourceUrl")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("source_url");
-
-                    b.Property<string>("Subpath")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("subpath");
-
-                    b.HasKey("Name");
-
-                    b.ToTable("session_skills", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<bool>("Completed")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("completed");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("OrderNum")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("order_num");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_subtasks_task_id");
-
-                    b.ToTable("subtasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<long>("ByteSize")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("byte_size");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("FileName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("file_name");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_attachments_task_id");
-
-                    b.ToTable("task_attachments", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("AgentPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("agent_path");
-
-                    b.Property<string>("BlockedByTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("blocked_by_task_id");
-
-                    b.Property<string>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("CreatedBy")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_by");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<string>("HandlerBaseCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_base_commit");
-
-                    b.Property<string>("HandlerHeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_head_commit");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<bool>("IsMyDay")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_my_day");
-
-                    b.Property<bool>("IsStarred")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_starred");
-
-                    b.Property<string>("ListId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("list_id");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<int?>("MaxTurns")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("max_turns");
-
-                    b.Property<string>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Notes")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("notes");
-
-                    b.Property<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<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("status");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("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>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Prompt")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt");
-
-                    b.Property<string>("ResultMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result_markdown");
-
-                    b.Property<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>("MergeCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("merge_commit");
-
-                    b.Property<string>("Path")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("path");
-
-                    b.Property<string>("State")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("active")
-                        .HasColumnName("state");
-
-                    b.HasKey("TaskId");
-
-                    b.ToTable("worktrees", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithOne("Config")
-                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Subtasks")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany()
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("BlockedByTaskId")
-                        .OnDelete(DeleteBehavior.SetNull);
-
-                    b.HasOne("ClaudeDo.Data.Models.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/20260805132052_AddMaxTurnsCeiling.cs

@@ -1,63 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ClaudeDo.Data.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddMaxTurnsCeiling : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AlterColumn<int>(
-                name: "default_max_turns",
-                table: "app_settings",
-                type: "INTEGER",
-                nullable: false,
-                defaultValue: 40,
-                oldClrType: typeof(int),
-                oldType: "INTEGER",
-                oldDefaultValue: 30);
-
-            migrationBuilder.AddColumn<int>(
-                name: "max_turns_ceiling",
-                table: "app_settings",
-                type: "INTEGER",
-                nullable: false,
-                defaultValue: 80);
-
-            migrationBuilder.UpdateData(
-                table: "app_settings",
-                keyColumn: "id",
-                keyValue: 1,
-                columns: new[] { "default_max_turns", "max_turns_ceiling" },
-                values: new object[] { 40, 80 });
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "max_turns_ceiling",
-                table: "app_settings");
-
-            migrationBuilder.AlterColumn<int>(
-                name: "default_max_turns",
-                table: "app_settings",
-                type: "INTEGER",
-                nullable: false,
-                defaultValue: 30,
-                oldClrType: typeof(int),
-                oldType: "INTEGER",
-                oldDefaultValue: 40);
-
-            migrationBuilder.UpdateData(
-                table: "app_settings",
-                keyColumn: "id",
-                keyValue: 1,
-                column: "default_max_turns",
-                value: 100);
-        }
-    }
-}

src/ClaudeDo.Data/Migrations/20260805132801_AddRunCacheTokens.Designer.cs

@@ -1,844 +0,0 @@
-// <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("20260805132801_AddRunCacheTokens")]
-    partial class AddRunCacheTokens
-    {
-        /// <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>("ModelPresets")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model_presets");
-
-                    b.Property<string>("RepoImportFolders")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("repo_import_folders");
-
-                    b.Property<string>("ReportExcludedPaths")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("report_excluded_paths");
-
-                    b.Property<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("StandupWeekday")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(3)
-                        .HasColumnName("standup_weekday");
-
-                    b.Property<int>("UsageGateFiveHourPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(80)
-                        .HasColumnName("usage_gate_five_hour_pct");
-
-                    b.Property<int>("UsageGateSevenDayPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(90)
-                        .HasColumnName("usage_gate_seven_day_pct");
-
-                    b.Property<int>("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,
-                            UsageGateFiveHourPct = 80,
-                            UsageGateSevenDayPct = 90,
-                            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>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("VerifyCommand")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("verify_command");
-
-                    b.HasKey("ListId");
-
-                    b.ToTable("list_config", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("DefaultCommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("default_commit_type");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SortOrder")
-                        .HasDatabaseName("idx_lists_sort");
-
-                    b.ToTable("lists", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("Days")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(31)
-                        .HasColumnName("days_of_week");
-
-                    b.Property<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("prime_schedules", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SessionSkillEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<DateTimeOffset>("AddedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("added_at");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<string>("PinnedRef")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("pinned_ref");
-
-                    b.Property<string>("SourceUrl")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("source_url");
-
-                    b.Property<string>("Subpath")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("subpath");
-
-                    b.HasKey("Name");
-
-                    b.ToTable("session_skills", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<bool>("Completed")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("completed");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("OrderNum")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("order_num");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_subtasks_task_id");
-
-                    b.ToTable("subtasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<long>("ByteSize")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("byte_size");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("FileName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("file_name");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_attachments_task_id");
-
-                    b.ToTable("task_attachments", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("AgentPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("agent_path");
-
-                    b.Property<string>("BlockedByTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("blocked_by_task_id");
-
-                    b.Property<string>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("CreatedBy")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_by");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<string>("HandlerBaseCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_base_commit");
-
-                    b.Property<string>("HandlerHeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_head_commit");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<bool>("IsMyDay")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_my_day");
-
-                    b.Property<bool>("IsStarred")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_starred");
-
-                    b.Property<string>("ListId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("list_id");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<int?>("MaxTurns")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("max_turns");
-
-                    b.Property<string>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Notes")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("notes");
-
-                    b.Property<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<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("status");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("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<int?>("CacheReadTokens")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("cache_read_tokens");
-
-                    b.Property<int?>("CacheWriteTokens")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("cache_write_tokens");
-
-                    b.Property<string>("ErrorMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("error_markdown");
-
-                    b.Property<int?>("ExitCode")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("exit_code");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<bool>("IsRetry")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_retry");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<string>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Prompt")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt");
-
-                    b.Property<string>("ResultMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result_markdown");
-
-                    b.Property<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>("MergeCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("merge_commit");
-
-                    b.Property<string>("Path")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("path");
-
-                    b.Property<string>("State")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("active")
-                        .HasColumnName("state");
-
-                    b.HasKey("TaskId");
-
-                    b.ToTable("worktrees", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithOne("Config")
-                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Subtasks")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany()
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("BlockedByTaskId")
-                        .OnDelete(DeleteBehavior.SetNull);
-
-                    b.HasOne("ClaudeDo.Data.Models.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/20260805132801_AddRunCacheTokens.cs

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

src/ClaudeDo.Data/Migrations/20260805133429_AddUsageThrottleThresholds.Designer.cs

@@ -1,850 +0,0 @@
-// <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("20260805133429_AddUsageThrottleThresholds")]
-    partial class AddUsageThrottleThresholds
-    {
-        /// <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>("ModelPresets")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model_presets");
-
-                    b.Property<string>("RepoImportFolders")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("repo_import_folders");
-
-                    b.Property<string>("ReportExcludedPaths")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("report_excluded_paths");
-
-                    b.Property<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("StandupWeekday")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(3)
-                        .HasColumnName("standup_weekday");
-
-                    b.Property<int>("UsageGateFiveHourPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(80)
-                        .HasColumnName("usage_gate_five_hour_pct");
-
-                    b.Property<int>("UsageGateSevenDayPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(90)
-                        .HasColumnName("usage_gate_seven_day_pct");
-
-                    b.Property<int>("UsageThrottleHardPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(65)
-                        .HasColumnName("usage_throttle_hard_pct");
-
-                    b.Property<int>("UsageThrottleSoftPct")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(50)
-                        .HasColumnName("usage_throttle_soft_pct");
-
-                    b.Property<int>("WorktreeAutoCleanupDays")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(7)
-                        .HasColumnName("worktree_auto_cleanup_days");
-
-                    b.Property<bool>("WorktreeAutoCleanupEnabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("worktree_auto_cleanup_enabled");
-
-                    b.Property<string>("WorktreeStrategy")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("sibling")
-                        .HasColumnName("worktree_strategy");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("app_settings", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            Id = 1,
-                            DailyPrepMaxTasks = 5,
-                            DefaultClaudeInstructions = "",
-                            DefaultMaxTurns = 100,
-                            DefaultModel = "sonnet",
-                            DefaultPermissionMode = "auto",
-                            MaxParallelExecutions = 1,
-                            StandupWeekday = 3,
-                            UsageGateFiveHourPct = 80,
-                            UsageGateSevenDayPct = 90,
-                            UsageThrottleHardPct = 65,
-                            UsageThrottleSoftPct = 50,
-                            WorktreeAutoCleanupDays = 7,
-                            WorktreeAutoCleanupEnabled = false,
-                            WorktreeStrategy = "sibling"
-                        });
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.DailyNoteEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<DateOnly>("Date")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("note_date");
-
-                    b.Property<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>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("VerifyCommand")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("verify_command");
-
-                    b.HasKey("ListId");
-
-                    b.ToTable("list_config", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("DefaultCommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("default_commit_type");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<string>("WorkingDir")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("working_dir");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SortOrder")
-                        .HasDatabaseName("idx_lists_sort");
-
-                    b.ToTable("lists", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<DateTimeOffset>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("Days")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(31)
-                        .HasColumnName("days_of_week");
-
-                    b.Property<bool>("Enabled")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(true)
-                        .HasColumnName("enabled");
-
-                    b.Property<DateTimeOffset?>("LastRunAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("last_run_at");
-
-                    b.Property<string>("PromptOverride")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt_override");
-
-                    b.Property<TimeSpan>("TimeOfDay")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("time_of_day");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("prime_schedules", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SessionSkillEntity", b =>
-                {
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("name");
-
-                    b.Property<DateTimeOffset>("AddedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("added_at");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<string>("PinnedRef")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("pinned_ref");
-
-                    b.Property<string>("SourceUrl")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("source_url");
-
-                    b.Property<string>("Subpath")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("subpath");
-
-                    b.HasKey("Name");
-
-                    b.ToTable("session_skills", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<bool>("Completed")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("completed");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<int>("OrderNum")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("order_num");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("title");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_subtasks_task_id");
-
-                    b.ToTable("subtasks", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<long>("ByteSize")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("byte_size");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("FileName")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("file_name");
-
-                    b.Property<string>("TaskId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("task_id");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TaskId")
-                        .HasDatabaseName("idx_task_attachments_task_id");
-
-                    b.ToTable("task_attachments", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("id");
-
-                    b.Property<string>("AgentPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("agent_path");
-
-                    b.Property<string>("BlockedByTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("blocked_by_task_id");
-
-                    b.Property<string>("CommitType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("chore")
-                        .HasColumnName("commit_type");
-
-                    b.Property<DateTime>("CreatedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_at");
-
-                    b.Property<string>("CreatedBy")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("created_by");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("description");
-
-                    b.Property<DateTime?>("FinishedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("finished_at");
-
-                    b.Property<string>("HandlerBaseCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_base_commit");
-
-                    b.Property<string>("HandlerHeadCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("handler_head_commit");
-
-                    b.Property<bool>("IsManual")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_manual");
-
-                    b.Property<bool>("IsMyDay")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_my_day");
-
-                    b.Property<bool>("IsStarred")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(false)
-                        .HasColumnName("is_starred");
-
-                    b.Property<string>("ListId")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("list_id");
-
-                    b.Property<string>("LogPath")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("log_path");
-
-                    b.Property<int?>("MaxTurns")
-                        .HasColumnType("INTEGER")
-                        .HasColumnName("max_turns");
-
-                    b.Property<string>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Notes")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("notes");
-
-                    b.Property<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<string>("SessionSkills")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("session_skills");
-
-                    b.Property<int>("SortOrder")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("INTEGER")
-                        .HasDefaultValue(0)
-                        .HasColumnName("sort_order");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("started_at");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("status");
-
-                    b.Property<string>("SystemPrompt")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("system_prompt");
-
-                    b.Property<string>("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>("Model")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("model");
-
-                    b.Property<string>("Prompt")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("prompt");
-
-                    b.Property<string>("ResultMarkdown")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("result_markdown");
-
-                    b.Property<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>("MergeCommit")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("merge_commit");
-
-                    b.Property<string>("Path")
-                        .IsRequired()
-                        .HasColumnType("TEXT")
-                        .HasColumnName("path");
-
-                    b.Property<string>("State")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT")
-                        .HasDefaultValue("active")
-                        .HasColumnName("state");
-
-                    b.HasKey("TaskId");
-
-                    b.ToTable("worktrees", (string)null);
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
-                        .WithOne("Config")
-                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("List");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany("Subtasks")
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
-                        .WithMany()
-                        .HasForeignKey("TaskId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Task");
-                });
-
-            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
-                {
-                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
-                        .WithMany()
-                        .HasForeignKey("BlockedByTaskId")
-                        .OnDelete(DeleteBehavior.SetNull);
-
-                    b.HasOne("ClaudeDo.Data.Models.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
-        }
-    }
-}