Merge remote-tracking branch 'gitea-ssh/main'

Paths.MigrateLegacyAppDataRoot war ungetestet: Verschieben von ~/.todo-app
nach ~/.claudeDo, Pfad-Rewrite in den Config-Dateien und der No-Op-Fall.

.claude/settings.local.json

@@ -1,4 +1,7 @@
 {
+  "worktree": {
+    "baseRef": "head"
+  },
   "permissions": {
     "allow": [
       "Bash(git add:*)",

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
@@ -76,7 +76,7 @@ dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
 
 ### 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/README.md

@@ -20,6 +20,7 @@ These sit **between** the CLAUDE.md files and the code:
 | [review-merge](review-merge.md) | Approve=merge-unit, verify gate, `MergeCommit`/revert, diff stack, conflict resolver |
 | [conpty-sessions](conpty-sessions.md) | Interactive/planning/list-handler launch specs + the arg-flattening gotcha |
 | [installer-preflight](installer-preflight.md) | CLI version/login/auto-mode research, the `ExecutableResolver`/shim root cause, and the Installer's `Checks/`+`SystemCheckPage` implementation status |
+| [list-virtualization-spike](list-virtualization-spike.md) | Phase 2a gate spike: virtualized `ListBox` + the existing ghost-drag `InputHitTest` model, verified headless |
 
 ## Rules
 

docs/explore-notes/conpty-sessions.md

@@ -1,7 +1,7 @@
 # ConPTY interactive sessions & launch specs
 
 > **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
-> Last verified against commit `8dbdfb3` (2026-08-06).
+> Last verified against commit `79b3580` (2026-08-11).
 > Drift check: `git log --oneline bdee731..HEAD -- src/ClaudeDo.Worker/Planning src/ClaudeDo.Worker/Hub src/ClaudeDo.Worker/Runner/ClaudeArgsBuilder.cs src/ClaudeDo.Ui/ViewModels/MissionControlViewModel.cs src/ClaudeDo.Ui/Views/InteractiveTerminalView.axaml`
 > Stable structure only (no line numbers). See docs/explore-notes/README.md.
 
@@ -18,7 +18,7 @@ Autonomous queue tasks are **not** covered here — they stay on the stream-json
 | Task session | `GetInteractiveLaunchSpec` | Effort from the task/list model preset |
 | Ad-hoc | `GetAdHocLaunchSpec` | Effort from the global default |
 | Planning | (planning start/resume) | Effort from `PlanningAlias`; uses `--permission-mode default`, **not** `plan` |
-| List handler | `GetMergeHelperLaunchSpec` | Effort from list config; `--permission-mode auto` (unattended) |
+| List handler | `GetMergeHelperLaunchSpec` / `GetMergeHelperHandoffLaunchSpec` | Model + effort fixed per role (`ModelRegistry.HandlerTriageAlias`/`HandlerWaitAlias`/`HandlerMergeAlias`), **not** from list config; `--permission-mode` via `PermissionModeResolver` (unattended) |
 
 ## ⚠️ Gotcha: never pass task free-text as a CLI argument
 
@@ -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`.
 
@@ -54,8 +54,16 @@ so a token like `"C:\repo\"` never closes and every following argument is swallo
 preceding **variadic** flag. A list working dir stored as `C:\Dev\Repos\Bandel.Hub\` therefore
 fed `--add-dir` the repo, `--append-system-prompt-file`, its value **and** the positional kickoff:
 the CLI warned `brief.md is not a directory` and the session opened with no prompt at all
-(2026-08-06). `BuildForMergeHelperAsync`/`BuildForMergeHelperHandoffAsync` now run the repo
-through `TrimTrailingSeparator`; session dirs the worker builds never carry one.
+(2026-08-06). `BuildForMergeHelperAsync`/`BuildForMergeHelperHandoffAsync` run the repo through
+`TrimTrailingSeparator`; session dirs the worker builds never carry one.
+
+The same data bit the UI's "Open in terminal" on 2026-08-10 (`wt -d "C:\…\StaplerTracking\"` →
+`Could not access starting directory "C:\…\StaplerTracking""`), so the fix moved to the write side:
+**`ListRepository.AddAsync`/`UpdateAsync` normalize `WorkingDir` via `Paths.TrimTrailingSeparator`**,
+which covers every writer (UI create, repo import, hub `UpdateList`, MCP `CreateList`/`UpdateList`) —
+the UI and worker keep their own defensive trim for rows written before that. Anything new that puts
+a **user-supplied** path on a command line should use `Paths.TrimTrailingSeparator` and, on the
+`ProcessStartInfo` side, `ArgumentList` rather than an interpolated `Arguments` string.
 
 Diagnosing this from code or a PowerShell repro is a dead end — PowerShell quotes correctly, so
 every repro passes. Read the real command line instead:
@@ -91,9 +99,30 @@ launch even started.
 
 ## List handler ("Let Claude handle it")
 
-`BuildForMergeHelperAsync` uses `--permission-mode auto` so it runs unattended. The
-`--allowedTools` allowlist is the security boundary:
-`mcp__claudedo__*,Read,Grep,Glob,Edit,Bash,WebFetch,WebSearch,Skill`.
+`BuildForMergeHelperAsync`/`BuildForMergeHelperHandoffAsync` resolve `--permission-mode` via
+`PermissionModeResolver` (currently always `auto`, since none of the handler roles run on haiku)
+so the session runs unattended. The `--allowedTools` allowlist is the security boundary:
+`mcp__claudedo__*,Read,Grep,Glob,Edit,Bash,WebFetch,WebSearch,Skill,Task` (`Task` lets the Merge
+role delegate diff reviews to sonnet subagents).
+
+The run now spans up to **five** phase-scoped sessions instead of two, chained via
+`handoff_list_handler(taskId, survivingTaskIds, nextPhase)`: opus Triage → sonnet Wait → opus
+Merge → (only if Merge started reruns) sonnet Wait(final) → opus Merge(final). `nextPhase` (`wait`
+| `merge` | `wait_final` | `merge_final`, validated by `MergeHelperPhase.Validate`) picks both the
+system prompt (`PromptKind.MergeHelperWait`/`MergeHelperMerge`) and the model
+(`ModelRegistry.HandlerWaitAlias`/`HandlerMergeAlias`) for the next session; the `_final` variants
+share the same prompt/model as their non-final counterpart and differ only in one extra line
+rendered into the handoff kickoff file (`PromptKind.MergeHelperHandoff`) marking the final round
+and forbidding further reruns.
+
+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
+the next one — every tile is a live process with the full `mcp__claudedo__*` surface, and the
+outgoing session is only ever told to end its turn, never to exit. This keeps the one-pane-per-
+`TaskId` invariant that `ConPtySessions` relies on elsewhere (`OpenConPtySessionAsync`'s dedupe,
+`OnPaneSubmitForReview`) — both use a plain `FirstOrDefault(s => s.TaskId == taskId)`, not a
+"newest wins" lookup.
 
 `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)).
@@ -234,7 +263,8 @@ Autonomous and interactive sessions do **not** share a system prompt. Per start
 | Planning session start | `InteractiveLaunchSpecService.BuildPlanningStart` → `WindowsTerminalLauncher.BuildPlanningStartArgs` | `--append-system-prompt-file <path>` (`PromptKind.Planning`) |
 | Planning session resume | `InteractiveLaunchSpecService.BuildPlanningResume` → `WindowsTerminalLauncher.BuildPlanningResumeArgs` | none — only `--permission-mode default --allowedTools <planning allowlist> --resume <id>` |
 | List handler ("Let Claude handle it"), triage | `InteractiveLaunchSpecService.BuildForMergeHelperAsync` | `--append-system-prompt-file <path>` (`PromptKind.MergeHelperTriage` — phases 0–2 only), always fresh — this path never resumes |
-| List handler, post-handoff | `InteractiveLaunchSpecService.BuildForMergeHelperHandoffAsync` | `--append-system-prompt-file <path>` (`PromptKind.MergeHelperExecute` — phases 3–5 only), fresh session dir, same handler task id |
+| List handler, post-handoff (wait/wait_final) | `InteractiveLaunchSpecService.BuildForMergeHelperHandoffAsync` | `--append-system-prompt-file <path>` (`PromptKind.MergeHelperWait` — phase 3 only), fresh session dir, same handler task id |
+| List handler, post-handoff (merge/merge_final) | `InteractiveLaunchSpecService.BuildForMergeHelperHandoffAsync` | `--append-system-prompt-file <path>` (`PromptKind.MergeHelperMerge` — phases 4–5 only), fresh session dir, same handler task id |
 
 So every interactive resume (task session and planning) drops the system prompt entirely — it's
 not that they inherit the autonomous one, it's that **no** `claude` process on any resume path

docs/explore-notes/external-mcp.md

@@ -1,8 +1,8 @@
 # External MCP tool surface
 
 > **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
-> Last verified against commit `20bce9b` (2026-08-06).
-> Drift check: `git log --oneline 20bce9b..HEAD -- src/ClaudeDo.Worker/External`
+> Last verified against commit `38af549` (2026-08-11).
+> Drift check: `git log --oneline 38af549..HEAD -- src/ClaudeDo.Worker/External`
 > Stable structure only (no line numbers). See docs/explore-notes/README.md.
 
 Covers `src/ClaudeDo.Worker/External/` — the always-on MCP tools ClaudeDo exposes to general
@@ -14,11 +14,34 @@ need no `--mcp-config`.
 and git/merge operations. They deliberately do **not** expose multi-turn control, planning
 session internals, or app-settings writes. Auth via an optional `X-ClaudeDo-Key` header.
 
-## Hard conventions (enforced by tests)
+## Task ID resolution and numbering
+
+Every tool parameter accepting a task id — `taskId`, `parentId`, `taskIds` arrays, and similar —
+is wired through `TaskIdResolver`, which resolves:
+- `#123` (with or without the `#` prefix) → look up by `TaskEntity.Number`
+- Bare GUID string → use as-is
+- Unknown number → `InvalidOperationException` (`no task with number 123`)
+
+This is **not** ambiguous: a GUID is never all-digits, so a pure-integer parameter is always a
+number, not a partial GUID. All task-returning tools (`GetTask`, `ListTasks`, `AddTask`,
+`BatchGetTasks`, etc.) stamp the resolved task's `Number` in the DTO — both `TaskDto` and the
+lean `TaskRefDto` carry an `int Number` field. **Branch names and worktree paths** (`claudedo/{id}`)
+continue to use the GUID; the number is a display alias, never the identity.
+
+Every tool description carries a shared boilerplate clause (defined in `McpToolDocs.TaskNumberHint`)
+instructing the agent to **refer to tasks as `#<number>` when reporting results to the user** —
+without this the agent sees the number in every payload but never learns to speak it.
+
+## Conventions
+
+### Test-enforced
 
 1. **Every optional/filter parameter needs a C# default value** (e.g. `string? status = null`).
    The MCP schema only marks a parameter optional when it has one — nullability alone does
    not do it. `ExternalMcpToolSchemaTests` guards this by reflection.
+
+### Not test-enforced, but strongly observed
+
 2. **No tool returns bare `Task` or a nullable payload directly.** An MCP client cannot tell
    an empty/omitted response apart from a dropped one.
    - *Write* tools return a small confirmation record — `{ ok/deleted/removed/reset/started:
@@ -32,13 +55,15 @@ session internals, or app-settings writes. Auth via an optional `X-ClaudeDo-Key`
      `ListTasksResult`/`BatchGetTaskResult`, where exactly one of the lean (`TaskRefDto`) and
      full (`TaskDto`, incl. Description/Result) fields is populated per the flag — keeps a
      list of verbosely-described tasks from blowing past the response size limit by default.
+
 3. **Description style is documented in `McpToolDocs`** (same folder) and shared boilerplate
    lives there as `const` strings. Rules: the first sentence says what the tool does *and* when
    to reach for it (MCP clients rank tools by that text, so the trigger must not sit behind
    return-shape prose); parameters are documented with `[Description]` **on the parameter**, not
    in the tool description; result fields appear only where the caller must branch on them
    before calling (`isEmpty`, `truncated`, `conflicts`, `available`); no design rationale or
-   "since this feature was introduced" history. Not test-enforced — review it in PRs.
+   "since this feature was introduced" history.
+
 4. `ExternalMcpExceptionFilter.Wrap` is registered as a call-tool filter so
    `InvalidOperationException` / `ArgumentException` messages survive as `McpException` —
    otherwise the SDK's catch-all replaces any non-`McpException` with a generic
@@ -54,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`.
 
@@ -106,6 +132,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
@@ -145,7 +183,16 @@ directory is shared with other concurrent sessions.
 single-task. Every tool returns a per-item result array (`{ id/index, ok, error?, … }`) — a
 failing item never aborts the rest — and rejects batches over **100 items**.
 `BatchGetTasks` mirrors `ListTasks`'s `includeDescription` flag (default `false`): a found item's
-`BatchGetTaskResult` carries `task` (lean) or `taskFull` (full), never both.
+`BatchGetTaskResult` carries `task` (lean `TaskRefDto`) or `taskFull`, never both. `taskFull` is
+`BatchTaskDetailDto` — a batch-only shape, **not** `TaskDto` (`get_task` is untouched) — whose
+Description/Result are cut to `descriptionMaxChars` (default 1500, was unlimited) with
+`*Truncated`/`*FullLength` flagging it, and which `fields` (an optional name allow-list, e.g.
+`['title','roadblockText']`) can narrow further; unrequested fields come back `null`.
+`roadblockText` pulls just the bullet lines after `TaskRunner.ComposeReviewResult`'s roadblock
+marker out of `Result`, without needing the rest of it. The whole per-call response is also
+capped (`BatchMcpTools.MaxResponseChars`) — over that, the call throws naming which parameter to
+adjust instead of shipping an oversized payload (the incident that prompted this: 8 tasks'
+full Description/Result serialized to a single 51k-char line).
 
 **`GetTaskLog`** — latest run's log, tail-capped at 256 KB.
 

docs/explore-notes/list-virtualization-spike.md

@@ -0,0 +1,114 @@
+# List virtualization spike (Phase 2a gate)
+
+> **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
+> Last verified against commit `6a2a19c` (2026-08-10).
+> Drift check: `git log --oneline 6a2a19c..HEAD -- src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml.cs src/ClaudeDo.Ui/Views/Controls/TaskDragController.cs`
+> Stable structure only (no line numbers). See docs/explore-notes/README.md.
+
+Gate task for [ui-reaktivitaet-und-listen-performance-design](../superpowers/specs/2026-08-07-ui-reaktivitaet-und-listen-performance-design.md)
+Phase 2, Risk 1. Answers the five open questions before any rework of the real
+`TasksIslandView`/`TasksIslandViewModel`. No production code changed for this spike.
+
+## Method
+
+A throwaway Avalonia-headless xUnit test (`Avalonia.Headless` + `Avalonia.Themes.Fluent`,
+temporarily added to `ClaudeDo.Ui.Tests`, removed again after this report was written — not
+committed) built a plain `ListBox` with an explicit `VirtualizingStackPanel` and 1000 mixed
+items (≈14% "complex" two-line/badge rows, mirroring the 68px/90–110px split from the design
+doc), then drove it programmatically: forced layout/render passes, scrolled the `ScrollViewer`,
+called the same `TopLevel.InputHitTest` the production drag code uses, and counted realized
+`ListBoxItem` containers via the visual tree. No screenshots — every number below came from an
+actual headless run of that harness on 2026-08-10.
+
+One harness-only wrinkle: `InputHitTest` walks the **compositor's rendered scene**, not just the
+layout tree, so the test had to call `window.CaptureRenderedFrame()` after each layout-affecting
+change before hit-testing. A real windowed app renders every frame continuously, so this isn't a
+production concern — noted here only so the method is reproducible.
+
+## Q1 — Does a virtualized `ListBox` actually bound the number of realized containers at 1000 items?
+
+**Geht.** Realized `ListBoxItem` count stayed at 22–23 across the whole scroll range (top, 25%,
+50%, 75%, bottom) with 1000 source items in the list:
+
+```
+realized containers @ top:        22
+realized containers @ 25% scroll: 22
+realized containers @ 50% scroll: 22
+realized containers @ 75% scroll: 23
+realized containers @ 100% scroll: 22
+```
+
+Matches the design doc's estimate (~19 visible + overscan ≈ 22–25) almost exactly. The
+`ListBox`/`VirtualizingStackPanel` combination genuinely recycles containers instead of building
+one per item.
+
+## Q2 — Does the existing ghost-drag `InputHitTest` model survive container recycling?
+
+**Geht.** Scrolled from top to 60% (forcing recycling), then called `TopLevel.InputHitTest` at the
+*same screen point* both times — exactly what `RowButtonAt`/`ListItemUnder` in
+`TasksIslandView.axaml.cs` do live during a drag:
+
+```
+hit-test @ top, screen point (450,600):        Task[8]
+hit-test @ 60% scroll, same screen point:      Task[577]
+expected DataContext at that point (geometry): Task[577]
+```
+
+The hit-test result matches the geometrically-correct row after recycling, and correctly changed
+(it did *not* keep returning the stale top-of-list row). The production pattern —
+`topLevel.InputHitTest(pt)` then walk ancestors to the row `Button`/`ListBoxItem` — is
+recycling-safe: it's a live geometric query against whatever is currently realized, with no
+per-row state to go stale.
+
+## Q3 — Variable row heights (68px vs 90–110px): does the scrollbar/`Extent` estimate drift?
+
+**Geht, mit einer Einschränkung.** Measured actual template heights in this harness: header
+57px, simple task row 53px, complex (two-line + badges) row 90px. Hand-summing all 1000 rows by
+their real measured height gives 58275px; `VirtualizingStackPanel`'s reported `Extent.Height` was
+58228px — **0.1% error**. Avalonia's own extent bookkeeping for variable-height virtualized rows
+is not the "gross estimate that drifts" risk the design doc worried about.
+
+The real risk is a **hand-rolled** pixel↔index conversion. Scrolling to `index * 68px` (a naive
+"assume every row is 68px" offset) while targeting logical row #700 actually landed on row
+**#790** — a 90-row drift, because ~14% of the preceding rows were taller. Anything that
+computes a scroll offset from `index * fixedRowHeight` (a natural shortcut for a "scroll to
+selected row" or a custom auto-scroll speed curve) will misfire. The existing
+`ScrollSelectedIntoView` in `TasksIslandView.axaml.cs` already avoids this trap — it finds the
+realized control by `DataContext` and calls `BringIntoView()`, not index-times-height math. Phase
+2b must keep using `ListBox.ScrollIntoView(item)` / `Control.BringIntoView()`, never index
+arithmetic, for any "jump to row" behavior.
+
+## Q4 — Is auto-scroll-while-dragging feasible with the existing central-pointer-handler model?
+
+**Geht.** Auto-scroll doesn't exist today and has to be built, but the mechanism it needs — the
+same UI-thread pointer-moved handler (or a `DispatcherTimer` it starts) mutating
+`ScrollViewer.Offset` directly while a drag is in progress — was exercised directly: nudging
+`Offset` by 400px in one synchronous step kept the realized-container count constant (22 before,
+22 after) and an immediate subsequent `InputHitTest` at the same screen point resolved correctly
+to the new row under the cursor (`Task[388]`), with no async delay or stale state. Since
+`TasksIslandView`'s drag handlers already run on the UI thread via tunnelled pointer events, a
+`DispatcherTimer` (or a direct `Offset` nudge inside `OnPointerMovedDrag` when the cursor is near
+the list's top/bottom edge) has no threading obstacle. This still needs to be built in Phase 2b;
+this spike only confirms the approach isn't blocked by virtualization/recycling.
+
+## Q5 — Mixed item types (header rows vs. task rows) via a template selector, under virtualization
+
+**Geht.** Used `ListBox.DataTemplates` with two `FuncDataTemplate<T>` entries keyed by type
+(`HeaderRow` / `TaskRow`) instead of an explicit `IDataTemplate.Match` selector — Avalonia's
+implicit per-type template lookup is the idiomatic equivalent and needs no selector class. Both
+types showed up among the realized containers throughout scrolling
+(`Q5 distinct realized DataContext types: HeaderRow, TaskRow`), confirming the design's flat
+`Rows` (`HeaderRow | TaskRowViewModel`) collection will virtualize and template correctly.
+
+## Recommendation for Phase 2b
+
+**Geht — proceed**, with two carry-overs into the implementation:
+
+1. Any "scroll to row" logic (selection scroll, auto-scroll speed/targeting) must go through
+   `ScrollIntoView`/`BringIntoView` against the realized control, never `index * rowHeight` math
+   (Q3).
+2. Auto-scroll is new work, not a retrofit risk — build it as an `Offset` nudge from the existing
+   UI-thread drag handlers (Q4).
+
+No evidence surfaced against the Phase 2 design as written. The `ITaskListFilter` risk (#3 in the
+design doc) is unrelated to virtualization and out of this spike's scope.

docs/explore-notes/review-merge.md

@@ -1,7 +1,8 @@
 # Review, merge & conflict resolution
 
 > **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
-> Last verified against `2f3f938` (2026-08-07), which finished the diff-viewer rework:
+> 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.
@@ -75,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`
@@ -82,6 +100,17 @@ gating `CanMergeAll`. The worker-side guard remains the actual correctness fix;
 just avoids inviting a click the worker would reject. `CancelReviewAsync`'s catch now raises
 `ErrorReported` (→ shell `FlashFooterError`) instead of swallowing the rejection silently.
 
+## Merge commit message
+
+`MergeAsync` takes a `commitMessage`, but **every caller passes it blank** and lets
+`TaskMergeService.DefaultMergeMessage` build `CommitMessageBuilder.BuildMerge(task.CommitType,
+list.Name, task.Title, task.Id)` → `fix(my-list): merge <title>` + `ClaudeDo-Task:` trailer. Same
+`type(scope)` shape as the task's own worktree commits, so merges stay Conventional-Commits-clean.
+The only non-blank caller is the user editing the field in the merge modal, which is prefilled from
+`GetMergeTargets().DefaultCommitMessage` (the UI can't build it — it knows neither the commit type
+nor the list name). Callers used to hand-roll `"Merge task: {title}"` / `"Merge {branch}"` /
+`"Merge subtask"`; don't add a fourth.
+
 ## Post-merge verify gate
 
 A list can set `ListConfigEntity.VerifyCommand` (List Settings modal → Verification).
@@ -110,11 +139,61 @@ but `ApproveAndMergeAsync` still runs the verify command (same per-repo gate, wo
 `list.WorkingDir`) before the task may reach `Done`. Without that, the run that lands the most on
 the target branch at once would be the one run nothing checks.
 
+**The gate is what makes a merge look broken.** A verify command that builds and tests a solution
+occupies the whole `MergeTask` hub call — measured at ~5m 46s on this repo. `TaskMergeService`
+therefore broadcasts `MergeProgress(taskId, phase, elapsedSeconds)`: `PhaseMerging` before the
+per-repo gate wait, `PhaseVerifying` when the verify starts and again on every
+`ProgressReportInterval` tick (30 s, shared with the MCP progress reports), plus one
+`WorkerLog` Info line so the footer strip shows it too. The merge modal renders that as a spinner
+plus phase text; without it the only feedback was the disabled Submit button, which reads as a
+dead app for minutes while the merge has in fact already landed.
+
 **Serialization:** a process-wide `ConcurrentDictionary<string, SemaphoreSlim>` keyed by
 `list.WorkingDir` serializes `MergeAsync` / `ContinueMergeAsync` (git ops + verify) per repo,
 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
+clean `git merge-tree` result *before* anything is merged. It never touches the real working tree:
+the tree `PreviewMergeAsync` would write is wrapped in a throwaway commit
+(`GitService.CommitTreeAsync`, parent = the target branch's current tip) and checked out into a
+detached-HEAD scratch worktree under the OS temp dir (`GitService.WorktreeAddDetachedAsync`), which
+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
+`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 =
+not run; `-1` = timed out or failed to start; mirrors the post-merge gate's convention),
+`VerifyDurationMs`, `VerifyOutputTail` (tail of output, only populated on non-zero exit, via the
+same `TailOutput` helper the post-merge gate uses).
+
 ## `MergeCommit` and revert
 
 `WorktreeEntity.MergeCommit` (nullable) is the SHA of the merge commit this worktree's branch

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
@@ -29,9 +32,11 @@ fails open**. That is the single most important invariant here.
 | `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 +114,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 +207,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

docs/open.md

@@ -44,6 +44,36 @@ verifiziert und deshalb hier entfernt. Es bleiben die Entscheidungen, die daran
 
 ---
 
+## Offene Verifikation (2026-08-27, Ticketsystem-Anbindung)
+
+> **PAUSIERT.** `TicketSettingsTabViewModel.FeatureEnabled = false` versteckt Settings-Tab,
+> Projekt-Dropdown und Kontextmenü-Eintrag; zum Reaktivieren die Konstante umlegen. Grund: die
+> API ist unter `http://bandelapis.fb-tuning.local` nicht erreichbar (*connection actively
+> refused* — nichts lauscht dort). Kein ClaudeDo-Bug und kein CORS; wahrscheinlich fehlt eine
+> IIS-Hostname-Bindung oder der Port stimmt nicht (`deploy/deploy-iis-winrm.ps1` der API notiert,
+> dass srv-04b diese Sites *by IP:port rather than by hostname* erreicht). Wird mit dem
+> API-Kollegen geklärt. Die Punkte unten bleiben stehen, bis die Erreichbarkeit steht.
+
+Tasks 1–9 sind implementiert und gemergt (Build + Tests grün, `_broadcaster.TaskUpdated` genau
+einmal in `TaskStateService.cs`), aber **kein Smoke-Test gegen die echte Bandel-API ist
+gelaufen**. Die fünf Punkte aus der „Manuellen Verifikation" des Specs
+(`docs/superpowers/specs/2026-08-27-ticketsystem-integration-design.md`):
+
+- [ ] PAT in den Settings hinterlegen, „Verbindung testen" → korrekter Benutzername + Scopes.
+- [ ] Liste mit Projekt `393 Bandel.LagerApp` verknüpfen, „Update from Ticketsystem" → nur
+      eigene, offene Tickets erscheinen als Tasks.
+- [ ] Einen Task laufen lassen → Ticket steht im Ticketsystem auf `InBearbeitung`.
+- [ ] Approve/Merge → Ticket steht auf `Fertig`.
+- [ ] Base-URL leeren → Menüeintrag verschwindet, keine Netzwerkaufrufe mehr.
+
+**Wichtig:** die Response-Shapes der Bandel-API (`BandelEnvelope<T>`, `TicketIdentity`,
+`TicketBoardItem`, `SidebarDepartment`/`SidebarProject`, `TicketDtos.cs`) wurden aus dem
+**Quellcode** von `Bandel.APIs` abgeleitet, **nie live gegen die echte API verifiziert** — es gab
+keinen einzigen echten Netzwerkaufruf während der Implementierung. Die Punkte 1–4 oben sind
+zugleich der erste Test dieser Annahme: schlägt einer davon mit einem Deserialisierungs- oder
+404/Formatfehler fehl, ist das erwartbar und kein Regressions-Bug — dann müssen die DTOs in
+`src/ClaudeDo.Worker/Tickets/TicketDtos.cs` an die tatsächliche Antwort angepasst werden.
+
 ## Offene Verifikation (2026-07-27)
 
 - **List handler (2026-07-27)** — visual pass: the Broom button is gone from the lists footer,
@@ -81,6 +111,21 @@ verifiziert und deshalb hier entfernt. Es bleiben die Entscheidungen, die daran
   `dotnet test` invocation as the configured command) — only fast synthetic commands (`exit N`,
   `ping` for timeout) were exercised.
 
+## Offene Verifikation (2026-08-11, Task numbers in UI)
+
+Slice 4 der Task-Numbers-Features (UI-Display) ist gemerged (commit 38af549); Build + Tests grün,
+aber **nicht visuell verifiziert**:
+
+- **Task Row Display:** `TaskRowViewModel.Number` (Zeile 39, TaskRowViewModel.cs) zeigt die
+  Nummer als `#<number>` dimmed vor dem Titel in der Row an (`TaskRowView.axaml` Zeile 45+). Prüfen:
+  offene Task in der Übersicht hat sichtbar `#<number>` vor dem Titel.
+- **Detail Pane Header:** `DetailsIslandViewModel.TaskIdBadge` (Zeile 77, DetailsIslandViewModel.cs)
+  zeigt jetzt `#<number>` statt des alten GUID-Präfix. Prüfen: Task-Detail-Chip zeigt
+  `#<number>`.
+- **Worker Log Messages:** Geschäftsereignisse in `TaskRunner` (Zeile 199+), `TaskMergeService`
+  (Zeile 174+), und `TaskResetService` (Zeile 84+) prefixen Task-Titel mit `#<number>`. Prüfen:
+  Footer Worker-Log zeigt Task-Messages wie „`#42 finished`" statt nur dem GUID.
+
 ## Offene Verifikation (2026-08-06, Fix-Batch aus der Sichtprüfung)
 
 Fünf Findings der Sichtprüfung sind gefixt, Build + Tests grün, aber **noch nicht in der App

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

@@ -0,0 +1,521 @@
+# Feedback für langlaufende Operationen — Vorgaben für die Umsetzung
+
+> **Dieses Dokument ist absichtlich kein Task-Skript.** Es enthält die Vorgaben pro Gruppe.
+> Die konkreten Tasks schreibt der **Merge-Helper je Gruppe** beim Ausführen — er kennt dann
+> den tatsächlichen Codestand. Was hier steht, ist bindend; was hier nicht steht, entscheidet
+> er. Checkboxen stehen auf Paketebene, damit der Fortschritt sichtbar bleibt.
+
+**Design:** `docs/superpowers/specs/2026-08-11-operation-feedback-design.md` — dort stehen die
+Belege (Datei:Zeile) und die Begründungen. Dieses Dokument wiederholt sie nicht.
+
+**Ziel:** Jede Operation, die länger als ~300 ms dauern kann, zeigt an, dass sie läuft, was sie
+tut und wie lange sie schon läuft — über **einen** Mechanismus statt pro Fall neu gebaut.
+
+---
+
+## Ausführungsmodell
+
+```
+P0 (Fundament)  ──  muss ALLEIN und ZUERST landen
+   │
+   ├── Gruppe A  UI-Stille      Merge-Helper 1
+   ├── Gruppe B  UI-Freeze      Merge-Helper 2
+   └── Gruppe C  Worker-Stille  Merge-Helper 3
+
+Gruppe D  MCP-Stille  Merge-Helper 4  ──  unabhängig von P0, kann sofort starten
+```
+
+**Ein Merge-Helper pro Gruppe.** Nach P0 laufen A, B, C und D parallel. Jede Gruppe hält sich
+strikt an ihr Datei-Eigentum — das ist die einzige Absicherung gegen gegenseitiges
+Überschreiben, weil alle im gemeinsamen `main`-Checkout arbeiten.
+
+### Datei-Eigentum (bindend)
+
+| Gruppe | Besitzt exklusiv | Darf **nicht** anfassen |
+|---|---|---|
+| **P0** | `Ui/Services/OperationStatus.cs` (neu), `Ui/Views/Controls/OperationIndicator.axaml(.cs)` (neu), **beide `locales/*.json`**, `Ui/Services/WorkerClient.cs` (nur Timing-Hook) | alles andere |
+| **A** | Island-VMs, Modal-VMs, deren AXAML, `Ui/Services/UpdateCheckService.cs` | `locales/*`, `WorkerClient`, `IWorkerClient`, Worker-Projekt |
+| **B** | `Ui/ViewModels/Modals/DiffViewerViewModel.cs`, `Ui/Views/Controls/DiffTextView.axaml.cs` | `locales/*`, Island-VMs, Worker-Projekt |
+| **C** | `Worker/Hub/HubBroadcaster.cs`, `Worker/Hub/WorkerHub.cs`, `Ui/Services/WorkerClient.cs`, `IWorkerClient.cs`, `StubWorkerClient.cs`, `Worker/Lifecycle/*Recovery.cs`, `Worker/Runner/WorktreeManager.cs`, `Worker/Worktrees/WorktreeMaintenanceService.cs` | `locales/*`, Island-VMs, `Worker/External/*` |
+| **D** | `Worker/External/*McpTools.cs`, `Worker/External/ExternalMcpService.cs`, `Worker/Lifecycle/TaskMergeService.cs` (nur die Progress-Schleife) | `locales/*`, alles im Ui-Projekt |
+
+**Locale-Regel:** Nur P0 schreibt in `en.json`/`de.json`. Braucht eine Gruppe doch einen Key,
+den P0 nicht vorgesehen hat: als **letzte** Änderung des Pakets anhängen und im Merge-Helper
+als bekannte Konfliktstelle behandeln. Nie mitten in der Gruppe.
+
+---
+
+## Vorgaben für den Merge-Helper selbst
+
+Gilt für alle vier Gruppen:
+
+- **Agent-Modell:** `sonnet` für Implementierer und Reviewer. Nie haiku, nie opus, nie Fable.
+- **`maxTurns` explizit auf 200 setzen.** `model_presets` ist NULL, sonst bekommt ein
+  sonnet-Task 30 Turns und stirbt mit „exited with code 1 and no result".
+- **`serializeOnFileOverlap` auf der Gruppenliste einschalten.** Innerhalb einer Gruppe
+  fassen mehrere Pakete dieselben Dateien an.
+- **Bauen:** `dotnet build ClaudeDo.slnx` schlägt auf .NET 8 fehl. Einzelprojekte mit
+  `-c Release` bauen (ein laufender Worker sperrt `Debug`):
+  ```
+  dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
+  dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
+  ```
+- **Testen — pro Gruppe die relevanten Projekte:**
+  ```
+  A, B   dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+         dotnet test tests/ClaudeDo.Localization.Tests/... -c Release   (nur wenn Keys berührt)
+  C      Ui.Tests + ClaudeDo.Worker.Tests  (Worker.Tests enthält auch UiVm-Tests)
+  D      dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+  P0     Ui.Tests + Localization.Tests
+  ```
+  Fällt ein Test innerhalb der Verify-Kette, erst die Suite **allein** laufen lassen — die
+  `Ui.Tests` haben eine bekannte reihenfolgen-abhängige Flakiness, die nichts mit dem Merge zu
+  tun hat.
+- **Nie `git add -A`.** Immer explizit nach Pfad stagen und `git commit -- <pfade>` — der
+  `main`-Checkout ist von parallelen Sessions geteilt, ein blankes Commit fegt fremde WIP mit.
+- **Nach dem Batch-Merge `main` selbst prüfen.** Approve baut und testet nicht. Neun grüne
+  Branches haben `main` schon zweimal zerlegt, davon einmal durch eine Test-Kollision, die ein
+  reiner src-Build nicht sieht. Also: Build **und** die betroffenen Testprojekte.
+- **Vor Approve prüfen, ob der Branch überhaupt etwas enthält** (`changedFileCount`). Ein
+  blockierter Task wird sonst `Done` mit leerem Branch.
+- **Keine EF-Migration** in diesem Vorhaben. Parallele Migrationen aus Geschwister-Branches
+  löschen sich beim SQLite-Table-Rebuild gegenseitig die Spalten, und die Tests bemerken es
+  nicht (`EnsureCreated`).
+- **Keine Tests, die die echte `claude`-CLI starten.**
+- **Visuelle Prüfung ist nicht durch Tests ersetzbar.** Jedes Paket in A und B endet mit einer
+  offenen visuellen Prüfung für den Nutzer. Nie behaupten, die UI funktioniere.
+
+---
+
+## P0 — Fundament
+
+- [x] **P0-1 — `OperationStatus` + `OperationIndicator` + Locale-Keys**
+- [x] **P0-2 — Timing-Hook für die Messung**
+- [x] **P0-3 — Regel in den CLAUDE.md-Dateien**
+
+> **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–C4.
+
+**Vorbedingung:** keine. Muss allein landen, bevor A/B/C starten.
+
+### Der Vertrag (bindend — 19 Pakete hängen daran)
+
+`src/ClaudeDo.Ui/Services/OperationStatus.cs`, eine `ObservableObject`-Klasse:
+
+| Member | Verhalten |
+|---|---|
+| `bool IsRunning` | **sofort** `true` bei `Begin`. Treibt `CanExecute`, verhindert Doppelklick |
+| `bool ShowIndicator` | erst nach **300 ms** `true`. Kein Flackern bei schnellen Calls |
+| `string? Label` | lokalisierter Text |
+| `string Elapsed` | `mm:ss`, **lokal getickt** |
+| `bool IsStalled` | `true` nach **60 s ohne `Report`** |
+| `IDisposable Begin(string label)` | startet; `Dispose` beendet **auch im Exception-Fall** |
+| `void Report(string label)` | überschreibt `Label` mid-flight, setzt die Stall-Uhr zurück |
+
+**Nachbesserung 1 (bindend):** `IsStalled` bemisst sich an der Zeit **seit dem letzten
+`Report`**, nicht an der Gesamtdauer. Ein regulär mehrminütiges Verify-Gate darf sich nicht
+selbst als hängend melden. Eine Operation ohne jeden `Report` gilt nach 60 s als stalled — das
+ist genau der Fall, der heute wie ein Absturz aussieht.
+
+Benutzung im ViewModel:
+
+```csharp
+using var op = Approve.Begin(Loc.T("ops.merge.merging"));
+var result = await _worker.ApproveReviewAsync(...);
+```
+
+### Weitere Vorgaben
+
+- **Zeitquelle injizierbar** über `TimeProvider` (in .NET 8 vorhanden). **Kein statischer
+  `DispatcherTimer`** — geteilter statischer State ist die Ursache der reihenfolgen-abhängigen
+  Flakiness in den `Ui.Tests`. Timer-Callbacks kommen vom Threadpool und müssen auf den
+  Dispatcher gepostet werden.
+- **Mehrere `OperationStatus` pro VM sind erwünscht.** `WorktreesOverviewModalViewModel`
+  braucht getrennte für Refresh, Cleanup und Merge — sonst blockiert ein laufender Refresh die
+  Cleanup-Anzeige.
+- **`OperationStatus` transportiert keine Fehler.** Fehlerbehandlung bleibt unverändert über
+  `ShowErrorAsync` / `ErrorReported` / `FlashFooterError`.
+- **`OperationIndicator`** nutzt `Ellipse.spinner` aus `Design/IslandStyles.axaml` (14×14,
+  Accent, 0.9 s Rotation) plus Label und Elapsed. Ohne dieses Control wird die
+  Spinner-StackPanel aus `MergeModalView.axaml` acht Mal von Hand nachgebaut. Werte aus
+  `Tokens.axaml` verwenden, keine Inline-Zahlen.
+- **Locale-Keys:** neuer Top-Level-Namespace `ops` in `en.json` und `de.json`, Parität wird von
+  `Localization.Tests` erzwungen. P0 legt die Keys für **A und C** vorab an — abgeleitet aus den
+  Paketlisten unten.
+
+**Nachbesserung 3 (bindend):** **Gruppe D braucht keine Locale-Keys.**
+MCP-Progress-Meldungen gehen an Agenten, nicht an den Nutzer, und bleiben englische
+Klartext-Strings.
+
+### P0-2: Messung an genau einer Stelle
+
+Zwei Hooks, nicht zwanzig:
+1. In `WorkerClient` jeden Hub-Invoke mit Dauer loggen.
+2. Im DB-Pfad der Islands dasselbe.
+
+Ein Tag Nutzung liefert eine sortierte Liste echter Ausreißer. **A5 und C werten sie aus**,
+statt zu raten. Bild 2 und 4 brauchen keine Messung.
+
+Faustregel für den Zweifelsfall: instrumentiert wird, was git aufruft, Netz nutzt, einen
+Prozess startet, oder O(n) über unbegrenzt viele DB-Zeilen läuft. Einzelzeilen-Reads nicht.
+
+### Definition of Done für P0
+
+`OperationStatus` hat Unit-Tests mit einem Fake-`TimeProvider` für: 300-ms-Grace, 60-s-Stall
+**ab letztem Report**, Elapsed-Formatierung, `Dispose` nach Exception, `Report` überschreibt
+Label und setzt die Stall-Uhr zurück. `Localization.Tests` grün. Kein VM ist umgestellt — P0
+liefert nur das Werkzeug.
+
+### Task-Entwürfe (grob)
+
+**P0-1 · `OperationStatus` + `OperationIndicator` + `ops`-Locale-Keys**
+Baue das Primitive nach dem Vertrag oben, dazu das Anzeige-Control und den neuen
+Locale-Namespace `ops` in beiden Sprachdateien. Keys für Gruppe A und C vorab anlegen, für D
+keine. Zeitquelle über `TimeProvider`, kein statischer Timer.
+*Dateien:* `Ui/Services/OperationStatus.cs` (neu), `Ui/Views/Controls/OperationIndicator.axaml(.cs)` (neu), `Localization/locales/{en,de}.json`, `tests/ClaudeDo.Ui.Tests/`
+*Fertig wenn:* Unit-Tests für Grace, Stall-ab-Report, Elapsed, Dispose-nach-Exception, Report-Reset. Localization.Tests grün. Kein ViewModel angefasst.
+
+**P0-2 · Timing-Hook für die Messung**
+Zwei Hooks: Dauer jedes Hub-Invokes in `WorkerClient`, Dauer des DB-Pfads der Islands. Ziel
+sind auswertbare Zahlen, keine Anzeige. Ausgabe so, dass sie nach einem Tag Nutzung sortierbar
+ist.
+*Dateien:* `Ui/Services/WorkerClient.cs`, der gemeinsame DB-Zugriffspfad der Island-VMs
+*Fertig wenn:* Beide Hooks aktiv, Overhead vernachlässigbar, das Format ist dokumentiert.
+
+**P0-3 · Feedback-Regel in den CLAUDE.md-Dateien**
+`src/ClaudeDo.Ui/CLAUDE.md`: jeder `IWorkerClient`-Call in einem `[RelayCommand]` läuft durch
+eine `OperationStatus`, Anzeige über `OperationIndicator`. `src/ClaudeDo.Worker/CLAUDE.md`: ein
+MCP-Tool, das über ~5 s laufen kann, reportet Progress.
+*Fertig wenn:* Beide Regeln stehen, jeweils mit einem Satz Begründung.
+
+---
+
+## Gruppe A — Bild 1: UI-Stille
+
+- [x] **A1 — Detail-Pane** ⚠️ *der gemeldete Fall*
+- [x] **A2 — WorktreesOverview**
+- [x] **A3 — Settings-Tabs** — ohne OnlineInbox-SignIn, siehe Nachzügler unten
+- [x] **A4 — Reports und Planning-UI** — ohne die beiden Planning-Calls im `DiffViewerViewModel`
+- [x] ~~**A5 — Island-DB-Pfade nach Messdaten**~~ — **abgesagt** (2026-08-13): kein DB-Pfad über
+  500 ms (höchster p95 372 ms), die Ausreißer saßen alle auf der Hub-Seite. Wie vorgesehen
+  geschlossen, ohne Code.
+
+**Nachzügler (kein Task):** drei Locale-Keys aus P0 sind ungenutzt geblieben —
+`ops.onlineInbox.signingIn` (A3), `ops.planning.buildingIntegrationBranch` und
+`ops.planning.loadingAggregate` (A4). Die beiden Planning-Calls liegen in
+`DiffViewerViewModel.cs`, einer Datei aus Gruppe B, die A4 nicht anfassen durfte.
+
+**Vorbedingung:** P0 gemergt.
+
+### Vorgaben
+
+- **A1 zuerst.** `DetailsIslandViewModel.ApproveReviewAsync` ist der gemeldete Schmerz. Dazu im
+  selben Paket: `SubmitForReviewAsync`, `RejectReviewAsync`, `ParkReviewAsync` und
+  `MergeSectionViewModel.PreviewMergeAsync`.
+- **A1 abonniert `IWorkerClient.MergeProgressEvent`**, um das Label mid-flight von „merging" auf
+  „verifying" zu schärfen. Das Event existiert seit `cad0582`.
+
+  **Nachbesserung 2 (bindend):** A verlässt sich darauf, dass dieses Event **bestehen bleibt**.
+  C1 baut den generischen Kanal darunter, muss `MergeProgressEvent` aber als dünnen Forwarder
+  erhalten. Andernfalls müsste C `DetailsIslandViewModel` ändern — eine Datei aus Gruppe A —
+  und die Parallelität wäre zerstört. **A darf keinen anderen Kanal verwenden.**
+- **Abo nur für die Dauer des Calls.** Der Worker broadcastet an alle Clients; ein dauerhaft
+  registriertes VM bekommt Events für fremde Tasks. `MergeModalViewModel` macht es richtig
+  vor: `+=` im `try`, `-=` im `finally`, plus `if (taskId != TaskId) return;`.
+- **A2:** `IsBusy` existiert dort schon, schaltet aber nur `IsEnabled`. Die Anzeige fehlt
+  komplett. Betrifft Refresh, Cleanup, Reset, ForceRemove und Batch-Merge — Batch-Merge
+  zusätzlich mit Zeilen-Status, weil dort N Tasks sequenziell durchlaufen.
+- **A3:** SessionSkill-Install ist ein `git clone` — der offensichtlichste Kandidat. Dazu
+  Update/Restore-Defaults, OnlineInbox-SignIn, RepoImport-Scan, Update-Check.
+- **A4:** GenerateWeekReport, RunDailyPrepNow, BuildPlanningIntegrationBranch,
+  GetPlanningAggregate, Finalize/QueuePlanningSubtasks. `DiffViewerViewModel.IsLoadingCombined`
+  existiert bereits und bleibt — nicht doppeln.
+- **A5 erst nach Auswertung von P0-2.** Nur Stellen umstellen, die die Messung als Ausreißer
+  zeigt. Kein Umstellen auf Verdacht.
+- **`DetailsIslandViewModel` ist groß.** Nicht umstrukturieren, nur die Commands anfassen.
+- **Bereits saubere Flächen nicht anfassen:** `MergeModalViewModel`,
+  `ConflictResolverViewModel`, `DiffViewerViewModel.IsLoadingCombined`,
+  `UsageMonitorModalViewModel`.
+
+### Definition of Done pro Paket
+
+Jeder umgestellte Command: `IsRunning` während des Laufs gesetzt, `CanExecute` gesperrt,
+Zustand nach einer Exception zurückgesetzt — als Test in `ClaudeDo.Ui.Tests`. Kein
+handgebauter Spinner, immer `OperationIndicator`. **Visuelle Prüfung offen und explizit
+benannt** (Grace-Periode und Layout kann kein Test bestätigen).
+
+### Task-Entwürfe (grob)
+
+**A1 · Detail-Pane: Approve, Submit, Reject, Park, Preview** ⚠️ *der gemeldete Fall*
+Fünf Commands im Detail-Pane bekommen je eine `OperationStatus` und einen `OperationIndicator`
+neben dem auslösenden Button. Approve abonniert zusätzlich `MergeProgressEvent` **nur für die
+Dauer des Calls** und filtert auf die eigene TaskId, um das Label von „merging" auf „verifying"
+zu schärfen. `DetailsIslandViewModel` nicht umstrukturieren.
+*Dateien:* `Ui/ViewModels/Islands/DetailsIslandViewModel.cs`, `MergeSectionViewModel.cs`, `Ui/Views/Islands/Detail/*`
+*Fertig wenn:* Approve zeigt während des Verify-Gates Phase und Elapsed, Button ist gesperrt, Zustand nach Fehler zurückgesetzt. Visuelle Prüfung offen.
+
+**A2 · WorktreesOverview: Anzeige für alle fünf Aktionen**
+`IsBusy` existiert, schaltet aber nur `IsEnabled`. Getrennte `OperationStatus` für Refresh,
+Cleanup, Reset, ForceRemove und Batch-Merge — der Batch-Merge zusätzlich mit Zeilen-Status, weil
+er N Tasks sequenziell durchläuft.
+*Dateien:* `Ui/ViewModels/Modals/WorktreesOverviewModalViewModel.cs`, `Ui/Views/Modals/WorktreesOverviewModalView.axaml`
+*Fertig wenn:* Jede der fünf Aktionen zeigt sichtbar, dass sie läuft; ein laufender Refresh blockiert die Cleanup-Anzeige nicht. Visuelle Prüfung offen.
+
+**A3 · Settings-Tabs: Skill-Install, Restore-Defaults, OnlineInbox, RepoImport, Update-Check**
+Fünf Flächen, bei denen `IsBusy` heute nur den Button sperrt. Der Skill-Install ist ein
+`git clone` und der offensichtlichste Kandidat.
+*Dateien:* `Ui/ViewModels/Modals/Settings/*`, `Ui/ViewModels/Modals/RepoImportModalViewModel.cs`, `Ui/Services/UpdateCheckService.cs`, `Ui/Views/Modals/SettingsModalView.axaml`
+*Fertig wenn:* Alle fünf zeigen Aktivität; der Skill-Install zeigt zusätzlich, dass geklont wird. Visuelle Prüfung offen.
+
+**A4 · Reports und Planning-UI**
+GenerateWeekReport, RunDailyPrepNow, BuildPlanningIntegrationBranch, GetPlanningAggregate,
+Finalize/QueuePlanningSubtasks. `DiffViewerViewModel.IsLoadingCombined` existiert bereits und
+bleibt unangetastet.
+*Dateien:* `Ui/ViewModels/Modals/WeeklyReportModalViewModel.cs`, Planning-Pfade in `DetailsIslandViewModel`/`TasksIslandViewModel`, zugehörige AXAML
+*Fertig wenn:* Report-Generierung und Planning-Integration zeigen Aktivität; kein Doppel-Indikator im Combined-Diff. Visuelle Prüfung offen.
+
+**A5 · Island-DB-Pfade nach Messdaten**
+**Erst die Zahlen aus P0-2 auswerten**, dann nur die Ausreißer umstellen. Kandidaten:
+`ClearCompleted`, Drag-Reorder über viele Zeilen, Laden großer Listen. Nichts auf Verdacht.
+*Dateien:* nach Messergebnis
+*Fertig wenn:* Die Auswertung ist im Task dokumentiert, und jede umgestellte Stelle ist durch eine Messung begründet. Wenn nichts über der Schwelle liegt: Task mit Begründung schließen, nichts bauen.
+
+---
+
+## Gruppe B — Bild 2: UI-Freeze
+
+- [x] **B1 — `UnifiedDiffParser.Parse` auslagern**
+- [x] **B2 — `DiffAlignment.Build` Grenze**
+- [x] **B3 — Guard-Test gegen Dispatcher-Blockade**
+
+**Vorbedingung:** P0 gemergt (für den Indikator in B1).
+
+### Vorgaben
+
+- **Reihenfolge ist zwingend: erst auslagern, dann anzeigen.** Ein Spinner auf einem
+  blockierten UI-Thread wird nicht gezeichnet. B1 verschiebt `UnifiedDiffParser.Parse` nach
+  `Task.Run` und setzt danach den Indikator.
+- **`UnifiedDiffParser` ist statisch und rein** — thread-safe, `Task.Run` ist unkritisch. Das
+  Zurückschreiben der Ergebnisse in Observable-Collections muss auf dem UI-Thread passieren.
+- **B2 braucht eine Entscheidung, die der Merge-Helper trifft:** `DiffAlignment.Build` läuft in
+  `DiffTextView.axaml.cs` — in einem Control, nicht in einem VM. Entweder Grenze („ab N Zeilen
+  auslagern") oder inkrementeller Aufbau. Die Wahl gehört ins Paket, nicht hierher; die
+  Vorgabe ist nur: **eine sichtbare Grenze definieren, keine unbegrenzte Synchron-Arbeit.**
+- **AvaloniaEdit-Fallen** (belegt, nicht neu ausprobieren): `this.TryGetResource` in einem
+  Control findet Brushes aus `Tokens.axaml` **nie** und scheitert lautlos; Brushes und Typeface
+  nicht im Konstruktor auflösen. `ScrollToVerticalOffset` ist in v12 ein No-op — schreiben über
+  `ScrollViewer.Offset`, lesen über `TextView.ScrollOffsetChanged`.
+- Gemeinsames Editor-Boilerplate gehört in `Views/Controls/DiffEditorSetup.cs`, nicht ein
+  drittes Mal kopiert.
+
+### Definition of Done
+
+B3 ist der einzige Test im Vorhaben, der Blockade prüft: großes Diff-Fixture, Nachweis, dass
+der Dispatcher weiter Nachrichten verarbeitet. Visuelle Prüfung offen (Verhalten bei großem
+Diff, Indikator während des Parsens).
+
+### Task-Entwürfe (grob)
+
+**B1 · `UnifiedDiffParser.Parse` vom UI-Thread nehmen**
+Beide Aufrufstellen im `DiffViewerViewModel` nach `Task.Run` verschieben, danach den
+`OperationIndicator` setzen. Reihenfolge ist zwingend: erst auslagern, dann anzeigen — ein
+Spinner auf einem blockierten Dispatcher wird nicht gezeichnet. Das Zurückschreiben in
+Observable-Collections muss auf dem UI-Thread passieren.
+*Dateien:* `Ui/ViewModels/Modals/DiffViewerViewModel.cs`
+*Fertig wenn:* Kein synchroner Parse mehr im VM, Indikator während des Parsens sichtbar. Visuelle Prüfung mit einem großen Diff offen.
+
+**B2 · `DiffAlignment.Build` — Grenze gegen unbegrenzte Synchron-Arbeit**
+`Build` läuft in einem Control, nicht in einem VM. Der ausführende Agent entscheidet zwischen
+Auslagern ab einer Zeilenzahl und inkrementellem Aufbau — die Vorgabe ist nur: **eine
+sichtbare, begründete Grenze**. AvaloniaEdit-Fallen aus dem Vorgaben-Abschnitt beachten
+(`TryGetResource` scheitert lautlos, `ScrollToVerticalOffset` ist ein No-op).
+*Dateien:* `Ui/Views/Controls/DiffTextView.axaml.cs`, gemeinsames Boilerplate nach `DiffEditorSetup.cs`
+*Fertig wenn:* Die gewählte Grenze ist im Code kommentiert und begründet; große Diffs blockieren nicht mehr unbegrenzt. Visuelle Prüfung offen.
+
+**B3 · Guard-Test: großer Diff blockiert den Dispatcher nicht**
+Headless-Test mit großem Diff-Fixture, der nachweist, dass der Dispatcher während Parse und
+Build weiter Nachrichten verarbeitet. Der einzige Blockade-Test im Vorhaben — soll auch
+zukünftige Regressionen fangen.
+*Dateien:* `tests/ClaudeDo.Ui.Tests/`, Fixture im Testprojekt
+*Fertig wenn:* Der Test fällt gegen den Stand **vor** B1/B2 und ist danach grün.
+
+---
+
+## Gruppe C — Bild 3: Worker-Stille
+
+- [x] **C1 — generischer `OperationProgress`-Kanal**
+- [ ] **C2 — Startup-Recovery sichtbar**
+- [ ] **C3 — Worktree-Anlage sichtbar**
+- [ ] **C4 — Rebase-after-Merge und WorktreeMaintenance**
+- [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–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.
+
+**Vorbedingung:** P0 gemergt. Die Abhängigkeit zur Parallelsession ist mit `cad0582`
+aufgelöst.
+
+### Vorgaben
+
+- **Der Kanal:**
+  ```
+  OperationProgress(string opKey, string phase, int current, int total)
+  ```
+  `opKey` = TaskId bei task-gebundenen Operationen, sonst ein stabiler String
+  (`"worktree-cleanup"`, `"startup-recovery"`, `"planning-integration:<taskId>"`).
+- **Kein Elapsed auf der Leitung.** Das UI tickt lokal. Die heutige Implementierung lässt den
+  Worker alle 30 s ticken — damit zeigt sie die ersten 30 Sekunden nur „merging". C1 stellt das
+  um.
+- **`MergeProgressEvent` bleibt als Forwarder** (siehe Nachbesserung 2 unter Gruppe A). Vier
+  Zeilen. Entfernen erst, wenn A und C beide gemergt sind — nicht in dieser Gruppe.
+- **`current`/`total` wird als Text gezeigt, nie als Prozentbalken.** Die meisten Operationen
+  haben kein sinnvolles Total.
+- **C3 zuerst prüfen, nicht bauen:**
+  `docs/superpowers/specs/2026-08-07-ui-reaktivitaet-und-listen-performance-design.md` führt
+  `WorktreeManager.cs:103` als DB-Write-ohne-Broadcast. Ob das inzwischen geschlossen ist,
+  gehört geprüft, bevor es doppelt behoben wird.
+- **C5 ist der wackeligste Punkt im Design.** Periodische Dienste (Usage, OnlineSync, Prime,
+  Queue) dürfen **nur Aktivität und Fehler** melden, keinen Tick-Strom. Wenn der Merge-Helper
+  beim Umsetzen zum Schluss kommt, dass C5 nur Rauschen erzeugt: **weglassen und begründen**,
+  statt es durchzuziehen.
+- **Test-Fakes wachsen mit.** Ein neues Event auf `IWorkerClient`/`WorkerHub` bricht
+  handgeschriebene Fakes in **beiden** Testprojekten — `tests/ClaudeDo.Ui.Tests/StubWorkerClient.cs`
+  und die UiVm-Tests unter `tests/ClaudeDo.Worker.Tests/`.
+- **Broadcast-Sparsamkeit:** vor einem „fehlenden Broadcast" immer den Aufrufer prüfen. Im
+  08-07-Spec war ein gemeldetes Loch in Wahrheit schon vom Aufrufer abgedeckt, und der Fix
+  wäre ein Duplikat gewesen.
+
+### Definition of Done
+
+Progress-Callbacks in `ClaudeDo.Worker.Tests` mit einem Fake gezählt — keine echten Timeouts,
+keine echte CLI. UI-Seite: die Anzeige beim Worker-Start ersetzt „reconnecting" durch die
+laufende Recovery-Phase. Visuelle Prüfung offen.
+
+### Task-Entwürfe (grob)
+
+**C1 · Generischer `OperationProgress`-Kanal, `MergeProgress` darauf umstellen**
+Neues Hub-Event `OperationProgress(opKey, phase, current, total)`, ohne Elapsed auf der Leitung.
+Der Merge-Pfad sendet darüber. **`MergeProgressEvent` bleibt als vierzeiliger Forwarder** —
+Gruppe A hängt daran und darf nicht angefasst werden. Fakes in beiden Testprojekten mitziehen.
+*Dateien:* `Worker/Hub/HubBroadcaster.cs`, `Worker/Hub/WorkerHub.cs`, `Ui/Services/WorkerClient.cs`, `IWorkerClient.cs`, `tests/ClaudeDo.Ui.Tests/StubWorkerClient.cs`, UiVm-Fakes in `Worker.Tests`
+*Fertig wenn:* Merge-Phasen laufen über den neuen Kanal, das UI tickt Elapsed lokal, `MergeProgressEvent` funktioniert unverändert weiter, beide Testprojekte grün.
+
+**C2 · Worker-Startup-Recovery sichtbar machen**
+Die sechs Recovery-Services beim Worker-Start melden Phase und `i/n` über den Kanal
+(`opKey = "startup-recovery"`). Das UI ersetzt „reconnecting" durch die laufende Phase.
+*Dateien:* `Worker/Lifecycle/*Recovery.cs`, Anzeige im `IslandsShellViewModel`-Umfeld
+*Fertig wenn:* Beim Worker-Start ist sichtbar, welche Recovery läuft. Visuelle Prüfung offen.
+
+**C3 · Worktree-Anlage beim Task-Start sichtbar machen**
+**Zuerst prüfen**, ob der im 08-07-Spec gemeldete Broadcast-Gap in `WorktreeManager` inzwischen
+geschlossen ist — nicht doppelt beheben. Danach die stille Lücke zwischen `Queued` und erster
+Ausgabe an der Task-Zeile sichtbar machen.
+*Dateien:* `Worker/Runner/WorktreeManager.cs`, Task-Row-Anzeige
+*Fertig wenn:* Das Prüfergebnis steht im Task; die Anlage-Phase ist an der Zeile sichtbar. Visuelle Prüfung offen.
+
+**C4 · Rebase-after-Merge und WorktreeMaintenance in den Kanal**
+`RebaseOthersAfterMergeAsync` läuft heute innerhalb des Merge-Calls **nach** dem
+Phasen-Broadcast und ist damit vollständig unsichtbar. Dazu der Hintergrunddienst über alle
+Worktrees, mit `i/n`.
+*Dateien:* `Worker/Lifecycle/TaskMergeService.cs` (Rebase-Abschnitt), `Worker/Worktrees/WorktreeMaintenanceService.cs`
+*Fertig wenn:* Beide melden Fortschritt; ein Merge zeigt nach dem Verify-Gate die Rebase-Phase statt Stille.
+
+**C5 · Periodische Dienste — optional, Abbruch erlaubt**
+Usage, OnlineSync, Prime, Queue sollen **nur Aktivität und Fehler** melden, keinen Tick-Strom.
+Der wackeligste Punkt im Design: kommt der ausführende Agent zum Schluss, dass das nur
+Anzeige-Rauschen erzeugt, **weglassen und begründen** statt durchziehen.
+*Dateien:* `Worker/Usage/`, `Worker/Online/`, `Worker/Prime/`, `Worker/Queue/`
+*Fertig wenn:* Entweder sparsame Meldungen ohne Rauschen — oder eine begründete Absage im Task.
+
+---
+
+## Gruppe D — Bild 4: MCP-Stille
+
+- [x] **D1 — `ProgressReporter` extrahieren**
+- [x] **D2 — die `batch_*`-Tools** — es sind **sieben**, nicht acht (die Achterzahl unten war ein
+  Zählfehler beim Schreiben des Plans)
+- [x] **D3 — Worktree- und Diff-Tools** — drei davon; `batch_cleanup_task_worktrees` lief über D2
+- [x] **D4 — Rest und Doku-Regel** — fand zwei echte Lücken, die D1–D3 offen gelassen hatten:
+  `continue_merge` reichte sein Progress-Token nicht ins Post-Merge-Verify-Gate, und der
+  Unit-Merge-Drain im `PlanningMergeOrchestrator` verlor es nach dem ersten Tick. Dazu
+  `list_worktrees`.
+
+**Vorbedingung:** keine. Kann sofort starten, parallel zu P0.
+
+### Vorgaben
+
+- **Warum das zählt:** ohne Progress bricht der MCP-Client bei Stille nach 300 s ab, während
+  der Worker weiterarbeitet. Das ist die dokumentierte Ursache dafür, dass ein Merge zwar
+  durchläuft, den Task aber nie auf `Done` bringt und Abhängige dauerhaft blockiert.
+- **D1:** `TaskMergeService.RunReportingProgressAsync` ist die einzige existierende
+  Progress-Schleife. Als eigenständige Klasse extrahieren, plus ein Overload für
+  Element-Fortschritt (`i/n`). Nicht kopieren — extrahieren, damit es eine Implementierung
+  bleibt.
+- **`TaskMergeService` ist die einzige Datei, die D mit C teilt.** D fasst dort ausschließlich
+  die Progress-Schleife an. Wenn beide Gruppen gleichzeitig laufen, ist das die Stelle, die der
+  Merge-Helper im Auge behalten muss.
+- **Keine Locale-Keys** (Nachbesserung 3). Englische Klartext-Strings.
+- **Zielumfang:** die 7 `batch_*`-Tools mit `i/n`, dann `cleanup_task_worktree`,
+  `batch_cleanup_task_worktrees`, `get_task_diff`, `preview_merge_set`. Bereits versorgt und
+  nicht anzufassen: die 5 Tools in `ExternalMcpService` mit `IProgress`, `TaskWaitMcpTools`,
+  `merge_task`/`review_task`.
+- **D4 schreibt die Regel ins Worker-`CLAUDE.md`:** ein MCP-Tool, das über ~5 s laufen kann,
+  reportet Progress. Ohne die Regel wiederholt sich das Muster beim nächsten Tool.
+
+### Definition of Done
+
+Für jedes umgestellte Tool ein Test in `ClaudeDo.Worker.Tests`, der mit einem Fake-`IProgress`
+zählt, dass Meldungen kommen — bei `batch_*` mindestens eine pro Element. Keine visuelle
+Prüfung nötig, diese Gruppe hat keine UI.
+
+### Task-Entwürfe (grob)
+
+**D1 · `ProgressReporter` extrahieren**
+`TaskMergeService.RunReportingProgressAsync` als eigenständige Klasse herauslösen, plus einen
+Overload für Element-Fortschritt (`i/n`). **Extrahieren, nicht kopieren** — es soll eine
+Implementierung bleiben. Dies ist die einzige Datei, die D mit C teilt; nur die Progress-Schleife
+anfassen.
+*Dateien:* `Worker/Lifecycle/TaskMergeService.cs`, neue Klasse im Worker-Projekt
+*Fertig wenn:* Der Merge-Pfad nutzt die extrahierte Klasse, Verhalten unverändert, bestehende Merge-Tests grün.
+
+**D2 · Die sieben `batch_*`-Tools mit Element-Fortschritt**
+Jedes `batch_*`-Tool reportet pro verarbeitetem Element. Grund: ohne Meldung bricht der
+MCP-Client nach 300 s Stille ab, während der Worker weiterläuft — genau der Mechanismus, der
+einen Merge durchlaufen lässt, den Task aber nie auf `Done` bringt.
+*Dateien:* `Worker/External/BatchMcpTools.cs`
+*Fertig wenn:* Pro Tool ein Test mit Fake-`IProgress`, der mindestens eine Meldung je Element zählt. Englische Klartext-Strings, keine Locale-Keys.
+
+**D3 · Worktree- und Diff-Tools mit Progress**
+`cleanup_task_worktree`, `batch_cleanup_task_worktrees`, `get_task_diff`, `preview_merge_set`.
+Bereits versorgt und **nicht** anzufassen: die fünf Tools mit `IProgress` in
+`ExternalMcpService`, `TaskWaitMcpTools`, `merge_task`, `review_task`.
+*Dateien:* die betroffenen `Worker/External/*McpTools.cs`, `ExternalMcpService.cs`
+*Fertig wenn:* Jedes der vier Tools meldet Fortschritt, mit Test.
+
+**D4 · Restliche Long-Runner und die Regel im Worker-`CLAUDE.md`**
+Verbleibende Tools durchgehen, die über ~5 s laufen können, und die Regel festschreiben: ein
+MCP-Tool über ~5 s reportet Progress. Ohne die Regel wiederholt sich das Muster beim nächsten
+Tool.
+*Dateien:* restliche `Worker/External/*McpTools.cs`, `src/ClaudeDo.Worker/CLAUDE.md`
+*Fertig wenn:* Die Regel steht mit Begründung; die durchgegangenen Tools sind im Task aufgelistet — auch die, die bewusst nichts bekommen.
+
+---
+
+## Was nach allen vier Gruppen offen bleibt
+
+- ~~**Visuelle Prüfung** für alle Pakete in A und B~~ — **am 2026-08-17 durch**, ohne Fund
+  (Worktrees-Übersicht, Settings/Skill-Install, WeeklyReport, großer Diff, Detail-Pane-Approve).
+- ~~**Auswertung von P0-2**~~ — am 2026-08-13 ausgewertet, siehe A5.
+- **`MergeProgressEvent`-Forwarder entfernen**, sobald A und C beide gemergt sind. Ein
+  Aufräum-Task, kein Paket.
+- **Bewusst nicht gebaut:** Cancel, Footer-Anzeige für laufende Operationen, Prozentbalken,
+  Änderungen am Installer (der hat bereits eine vollständige Progress-Pipeline).

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/specs/2026-08-10-findings-store-design.md

@@ -0,0 +1,262 @@
+# Findings-Store — Design
+
+Stand: 2026-08-10.
+
+Persistenter, projektgebundener Speicher für **Fallen und Invarianten**, den Agents im
+Moment des Schmerzes selbst befüllen und in späteren Sessions vor dem Erkunden lesen.
+Ziel ist Token-Ersparnis durch verhinderte Fehlläufe.
+
+---
+
+## 1. Ausgangslage
+
+Auslöser war die Frage, ob ein Code-Knowledge-Graph (Graphify-Bauart) das
+Wiedererkunden in jeder Session einspart. Die Messung sagt: nein, nicht in dieser Form.
+
+### Die Zahlen (aus `docs/usage-optimization.md`, 2026-08-05)
+
+- Kontext-Resend = **99,3 %** des Rohverbrauchs. Jeder Kontext-Token wird im Schnitt
+  **~425× nachberechnet**. Das gilt symmetrisch: für gespartes *und* für geladenes Wissen.
+- **Explore-note ersetzt Exploration:** Note 4,6k tok in Turn 5 eines 60-Turn-Runs
+  → 4,6k × 55 ≈ **250k**. Ersparte Exploration (~8k tok Findings ab Turn 10) ≈ **400k**.
+  Netto ~150k, Faktor 1,6. Wird die Note geladen, ohne gebraucht zu werden: **−250k**.
+- **Ein verhinderter Retry:** ~11 Mio Token. **27 % der Tasks brauchten einen Retry.**
+
+Faktor 27 zwischen den beiden Klassen. Deshalb ist der Inhalt dieses Stores **nicht**
+„Architektur-Map, damit ich nicht neu erkunden muss" (400k-Klasse), sondern „Agent läuft
+in die bekannte Falle und der Run ist Müll" (11-Mio-Klasse).
+
+### Was heute schon da ist
+
+| Ebene | Größe | Ladeverhalten |
+|---|---:|---|
+| `CLAUDE.md` (root) | 6,4 KB ≈ 1,6k tok | immer |
+| `src/*/CLAUDE.md` (6×) | 1,5–14 KB | beim Arbeiten im Verzeichnis |
+| `docs/explore-notes/` (6 Notes) | 11–18 KB, 92 KB gesamt | on demand, **ganze Datei** |
+| Auto-Memory (`~/.claude/projects/.../memory/`) | 55 Dateien, 397 KB | Index immer (nur interaktiv) |
+
+Die Sektionen der Notes sind bereits 12–36 Zeilen (~150–450 tok) — also schon
+knotengroß. Und `conpty-sessions.md` markiert Fallen bereits konventionell als
+`## ⚠️ Gotcha: …` (5 Stück). Die anderen Notes tragen dieselbe Art Wissen unmarkiert im
+Fließtext. **Das Wissen ist zu großen Teilen schon geschrieben, nur nicht einsammelbar.**
+
+---
+
+## 2. Verworfene Alternativen
+
+- **Code-Knowledge-Graph (Graphify o. ä.).** Ein tree-sitter-Graph liefert Call-Kanten —
+  genau die Klasse, die Grep exakt und billig liefert (Grep = 5–8 % des Kontexts; Read =
+  60–68 %, das Problem ist zu viel *lesen*, nicht Finden). Der wertvolle Inhalt ist
+  semantisch und nicht ableitbar („Approve = merge the whole unit", „no directory arg may
+  end in a separator"). Dazu: Build-/Staleness-Pipeline über N parallele Worktrees und
+  Merge-Konflikte auf einem Graph-Artefakt im Repo. AXAML wird ohnehin nicht geparst.
+- **DB-Tabelle + UI-Editor.** Kuration passiert in VSCode, damit entfällt der einzige
+  Vorteil. Agent-Zugriff bräuchte ein Lese-Tool statt `Read`; Agents könnten veraltete
+  Einträge nicht selbst korrigieren.
+- **Hook-Injektion der Findings in den System-Prompt.** Früh und groß in den Prefix ist
+  das teuerste Muster überhaupt (Befund 5), auch wenn nichts davon gebraucht wird.
+- **Post-Merge-Trigger.** Ursprünglicher Entwurf. Hinfällig, weil der Aufrufer des Tools
+  den Kontext bereits hat — siehe §4.
+- **Retro-Distill aus alten Transkripten.** Zurückgestellt, siehe §8.
+
+---
+
+## 3. Speicher
+
+```
+<working-dir>/.claudedo/
+  INDEX.md              # eine Zeile je Finding — die einzige Datei, die immer gelesen wird
+  traps/<slug>.md       # ein Finding je Datei, ~150–300 tok
+```
+
+`maps/` ist reserviert, aber **nicht Teil von v1**.
+
+Ordner liegt im Repo-Root, das er beschreibt — maximale Erkennbarkeit, reist bei
+Bedarf mit. `.claudedo` ist als Name frei; die Worktrees liegen unter dem *Geschwister*-Pfad
+`.claudedo-worktrees`, und `TranscriptUsageReader` prüft auf das exakte Segment, also kein
+Fehlalarm bei der Scope-Erkennung.
+
+### Finding-Format
+
+```markdown
+---
+slug: conpty-arg-quoting
+scope: src/ClaudeDo.Worker/Planning
+source-task: 5d627df8
+verified-against: e10634b
+---
+
+# Ein Verzeichnis-Argument, das auf `\` endet, frisst alle folgenden Argumente
+
+<2–6 Sätze: was passiert, warum es nicht danach aussieht, was man stattdessen tut.>
+```
+
+### INDEX.md
+
+```markdown
+# Findings
+
+- [conpty-arg-quoting](traps/conpty-arg-quoting.md) — Dir-Arg auf `\` escapet sein eigenes Quote
+- [shared-worktree-partial-commit](traps/shared-worktree-partial-commit.md) — nie blank committen
+```
+
+Reine Routing-Ebene: Titel + einzeiliger Aufhänger + Pfad. Ablauf im Agenten:
+Index lesen (~700 tok) → ein bis zwei Findings lesen (~400 tok), statt 4 600 für eine
+ganze Note.
+
+### Einchecken oder nicht — Toggle je Liste
+
+Beim Anlegen einer Liste: **„`.claudedo` einchecken"**, Default **aus**.
+
+- **Aus** → `/.claudedo/` wird nach `.git/info/exclude` geschrieben (per-Clone,
+  unsichtbar fürs Repo, **keine getrackte Datei angefasst**). Mechanik existiert bereits in
+  `SessionSkillSeeder.AppendExcludeLineAsync` (auflösen über
+  `git rev-parse --git-path info/exclude`) — wiederverwenden, nicht neu bauen.
+- **An** → nichts tun, der Nutzer commitet den Ordner selbst.
+
+### Worktree-Regeln (hart)
+
+- **Geschrieben wird ausschließlich im Haupt-Checkout, nie in einem Worktree.** Sonst
+  entstehen `INDEX.md`-Merge-Konflikte über parallele Tasks — exakt das Problem, das oben
+  gegen den Graph-Ansatz spricht.
+- **Gelesen wird über den absoluten Pfad auf den Haupt-Checkout.** Eine Regel für beide
+  Toggle-Stellungen; in „aus" existiert der Ordner im Worktree ohnehin nicht.
+- Falls der Store getrackt ist und der Distiller committet: pfad-skopiert
+  (`git commit -- .claudedo`), nie blank — der Haupt-Checkout wird von parallelen
+  Sessions geteilt.
+- Ein Finding je Datei heißt: parallele Schreiber kollidieren nicht. Umkämpft ist nur
+  `INDEX.md`; das Tool serialisiert dessen Rewrite prozessintern.
+
+---
+
+## 4. Schreibweg — ein MCP-Tool
+
+`save_finding(slug, title, body, scope = "", list = "")` am bestehenden `claudedo`-MCP-Server.
+
+Signatur folgt den zwei test-erzwungenen Konventionen des Servers: jeder optionale
+Parameter hat einen C#-Defaultwert, und das Tool gibt kein blankes `Task` und keine
+nullable Payload zurück (→ `docs/explore-notes/external-mcp.md`). Beschreibungsstil nach
+`External/McpToolDocs.cs`.
+
+### Welcher Store wird beschrieben?
+
+Der MCP-Server ist global, der Store projektgebunden — die Zuordnung muss explizit sein:
+
+1. **Autonomer Run:** aus dem Aufrufkontext (`TaskRunMcpContext`) → Task → Liste →
+   `working_dir`. Der `list`-Parameter wird ignoriert.
+2. **Interaktive Session ohne Task-Kontext:** `list` (Name oder Id) entscheidet. Fehlt er
+   und es existiert **genau eine** Liste, wird diese genommen; bei mehreren gibt das Tool
+   einen Fehler zurück, der die verfügbaren Listen nennt. Nie raten.
+
+Geschrieben wird immer in `<list.working_dir>/.claudedo/` — also den Haupt-Checkout,
+auch wenn der Aufrufer in einem Worktree läuft.
+
+Bewusst ein **dummes Schreib-Tool**, kein „generiere mir Findings"-Tool: der Aufrufer hat
+den Kontext bereits. Ein zweiter Claude-Lauf (RefineRunner-Bauart) würde ihn aus
+Transkripten rekonstruieren — teurer und schlechter.
+
+**Genau ein Tool.** Gelesen wird mit `Read` auf die Dateien; das kostet nichts und braucht
+kein Tool. Der Server exponiert bereits ~60 Tools, eines mehr ist im Prefix Rauschen —
+fünf wären es nicht.
+
+**Verhalten:**
+- Gleicher `slug` → **überschreiben**, nicht anlegen. Dedupe gehört ins Tool, nicht in die
+  Prompt-Disziplin.
+- Schreibt `traps/<slug>.md` **und** aktualisiert die Zeile in `INDEX.md` atomar.
+- `verified-against` wird vom Tool aus dem aktuellen HEAD des Haupt-Checkouts gesetzt,
+  nicht vom Aufrufer.
+- `source-task` wird aus dem Aufrufkontext gesetzt, wenn vorhanden (autonome Runs),
+  sonst leer (interaktive Sessions).
+
+### Aufrufwege
+
+1. **Im Run.** Ein Task-Agent tritt in eine Falle und hält sie fest. Höchste Qualität —
+   er hat gerade Turns dafür verbrannt. Billigster Weg, kein zusätzlicher Prozess.
+2. **Merge-Helper-Abschlussphase.** Der List-Handler sweept am Ende nach, was ihm über den
+   Batch hinweg auffiel. Er sieht Diffs, nicht das Straucheln — daher Ergänzung zu (1),
+   kein Ersatz.
+3. **Interaktive Sessions.** Der `claudedo`-MCP ist global registriert, das Tool steht
+   dort ohne Weiteres zur Verfügung.
+4. **VSCode.** Nutzer korrigiert und löscht direkt in den Dateien.
+
+### Aufnahmehürde
+
+Ein Finding ist nur, was **dauerhaft**, **nicht offensichtlich** und **verhaltensändernd**
+ist: „X sieht aus wie Y, ist aber Z — mach stattdessen W". Ein gefixter Bug ist **kein**
+Finding, das ist Git-Historie.
+
+Diese Hürde steht in der Tool-Beschreibung. Sie ist kein Stilhinweis, sondern die
+Betriebsbedingung: `INDEX.md` wird immer gelesen; bei ~15 tok je Zeile sind 50 Findings
+≈ 750 tok, 300 Findings ≈ 4 500 tok — ab da kostet der Index so viel wie früher eine ganze
+Note und die Ersparnis ist weg. Deshalb zusätzlich eine **Warnschwelle bei 80 Einträgen**,
+die das Tool im Ergebnis zurückmeldet.
+
+---
+
+## 5. Leseweg
+
+ClaudeDo hängt einen Satz an den System-Prompt seiner eigenen Runs
+(`--append-system-prompt`, wie heute schon für andere Zwecke genutzt):
+
+> Findings-Index für dieses Projekt: `<abs>/.claudedo/INDEX.md`. Lies ihn, bevor du den
+> Code erkundest, und öffne nur die Findings, die zu deiner Aufgabe passen.
+
+~30 Token, komplett in ClaudeDo gekapselt, **keine CLAUDE.md wird angefasst** — weder die
+des Projekts noch die globale.
+
+Interaktive Sessions bekommen diesen Zeiger nicht (ClaudeDo startet sie nicht). Sie können
+schreiben, aber nicht automatisch lesen. Wer das will, setzt selbst eine Zeile in seine
+globale CLAUDE.md — außerhalb des Scopes dieses Features.
+
+---
+
+## 6. UI
+
+Ein Button an der Liste: **„Findings öffnen"** → öffnet `<working-dir>/.claudedo/` im
+Datei-Explorer bzw. der Standardanwendung. **Kein In-App-Editor** — Kuration passiert in
+VSCode.
+
+Dazu der Toggle aus §3 im Dialog „Liste anlegen" und in den Listen-Einstellungen.
+
+---
+
+## 7. Scope-Grenze (bewusst akzeptiert)
+
+Die Kapselung in ClaudeDo deckelt den Lese-Nutzen auf den Agent-Anteil: laut Messung
+**18,4 %** des Verbrauchs (interaktiv = 81,6 %). Das ist kein Argument gegen das Feature —
+Retries passieren ausschließlich auf der Agent-Seite, und dort sitzt der 11-Mio-Hebel.
+Aber „Token-Ersparnis" heißt hier: Ersparnis in den 18 %, nicht auf dem Konto insgesamt.
+
+---
+
+## 8. Nicht in v1
+
+- **`maps/`** — Subsystem-Maps. Ordner reserviert, Inhalt später. Die bestehenden
+  `docs/explore-notes/` bleiben unangetastet.
+- **Retro-Distill aus Transkripten.** Erst interessant, wenn belegt ist, dass Findings
+  überhaupt wirken. Rohmaterial bleibt verfügbar: vollständiges NDJSON je Run unter
+  `~/.todo-app/logs/{taskId}_run{N}.ndjson`, `ResultMarkdown` in `task_runs`,
+  `WorktreeEntity.BaseCommit/HeadCommit/MergeCommit` für den nachträglichen Diff.
+- **Ernte der bestehenden `⚠️ Gotcha:`-Sektionen** aus `docs/explore-notes/` in den Store.
+  Naheliegender erster Füllstand, aber eine eigene, manuelle Aktion.
+- **Wirkungsmessung** (welches Finding wurde je gelesen, hat es einen Retry verhindert).
+  Braucht ein eigenes Konzept; Dateien tragen keinen Zähler.
+- **Automatischer Staleness-Check** gegen `verified-against`. Frontmatter trägt den Commit,
+  ausgewertet wird er in v1 nur vom Menschen.
+
+---
+
+## 9. Testbarkeit
+
+- `save_finding`: Neuanlage, Überschreiben bei gleichem Slug, Index-Update, Slug-Validierung
+  (kein Pfad-Escape), Warnschwelle bei 80 Einträgen, paralleler Index-Rewrite.
+- Store-Auflösung: Task-Kontext schlägt `list`; genau eine Liste ohne `list` → Treffer;
+  mehrere Listen ohne `list` → Fehler statt Raten; Schreibziel ist der Haupt-Checkout,
+  auch wenn der Aufrufer in einem Worktree sitzt.
+- Die beiden `external-mcp`-Konventionen (Default je optionalem Parameter, kein blankes
+  `Task`/nullable Payload) sind test-erzwungen — die bestehenden Tests greifen automatisch.
+- Toggle: `.git/info/exclude`-Zeile wird genau einmal geschrieben (Idempotenz) — die
+  bestehenden Tests zu `SessionSkillSeeder` sind die Vorlage.
+- Kein Test darf die echte `claude`-CLI starten.
+- `IWorkerClient` / `WorkerHub` / ViewModel-Konstruktoren ändern → handgeschriebene Fakes in
+  **beiden** Testprojekten mitziehen.

docs/superpowers/specs/2026-08-11-dependency-chain-display-design.md

@@ -0,0 +1,73 @@
+# Dependency chain display — Design
+
+**Date:** 2026-08-11
+**Status:** approved, not implemented
+
+## Problem
+
+`DependsOnTaskId` is invisible in the UI. `TaskRowViewModel` has no `DependsOnTaskId` property
+and `TaskRowView.axaml` renders nothing for it — a chained task looks exactly like an unrelated
+one. The execution order the user declared is not readable anywhere in the list.
+
+## Target
+
+A chain renders as a group: the head full width, its dependents indented behind a vertical rail,
+each carrying a small circular step badge on the rail.
+
+```
+┌──────────────────────────────────────────┐
+│  chain head (full width, no badge)       │
+└──────────────────────────────────────────┘
+  ╷ ┌────────────────────────────────────┐
+ (1)│  first dependent                   │
+  ╷ └────────────────────────────────────┘
+  ╷ ┌────────────────────────────────────┐
+ (2)│  second                            │
+  ╷ └────────────────────────────────────┘
+  ╷ ┌────────────────────────────────────┐
+ (2)│  parallel to the second            │
+  ╷ └────────────────────────────────────┘
+  ╷ ┌────────────────────────────────────┐
+ (3)│  third                             │
+    └────────────────────────────────────┘
+```
+
+## Model reading
+
+- **Step number = hop distance from the chain head**, not a running counter. `DependsOnTaskId` is
+  a single FK, so several tasks may share one predecessor → same depth → **same number**. Two
+  rows showing `2` means "these two are both unblocked by step 1", which is the intended reading.
+- **Chain head** = a task with no `DependsOnTaskId` that at least one other task points at. A task
+  with no dependents and no dependency is not a chain and renders exactly as today.
+- Cycles are impossible (`TaskStateService.SetDependsOnAsync` rejects them), so the depth walk
+  always terminates. Still cap the walk defensively.
+
+## Decisions
+
+**One indent level only — parent wins.** The 24 px indent track already exists for planning
+children (`TaskRowView.axaml:22-28`, gated on `ShowAsChild`). A planning child that *also* has a
+`DependsOnTaskId` keeps the parent indent and shows its chain membership as a small inline
+chip (`after #123`) instead of a second indent level. No nesting, no 48 px rows.
+
+**The group is pulled together; the head carries it.** Chain members are re-ordered to sit
+directly under their head regardless of `SortOrder`, so displayed order always equals execution
+order. Dragging the head moves the whole group; members are not individually draggable.
+
+**Head not in view → no orphan rails.** Exact precedent exists: `ParentInView` /`ShowAsChild`
+(`TaskRowViewModel.cs:75`, computed in `Regroup` at `TasksIslandViewModel.cs:543`). Same
+treatment — if the head is filtered out (other list, My Day, completed group), the row renders
+flat with the `after #123` chip instead of a dangling rail.
+
+**Badge has no `#`.** If task numbers (`2026-08-11-task-numbers-design.md`) also land, a row
+would show a rail badge and a `#412` title prefix. The rail badge is a step position, not an
+identity — render it bare (`2`), never `#2`.
+
+## Slices
+
+| # | Slice | Depends on |
+|---|---|---|
+| 1 | VM: `DependsOnTaskId` + depth/head computation in `Regroup`, group pull-together, drag semantics | — |
+| 2 | View: rail, step badge, `after …` chip, locale keys | 1 |
+
+Slice 1 exposes the contract Slice 2 binds to: `ShowAsChainMember`, `ChainStep`,
+`ChainAfterLabel`.

docs/superpowers/specs/2026-08-11-operation-feedback-design.md

@@ -0,0 +1,313 @@
+# Feedback für langlaufende Operationen
+
+**Datum:** 2026-08-11
+**Status:** Design freigegeben, Implementierung offen
+**Auslöser:** Ein Merge über das Detail-Pane blockierte minutenlang ohne jede Anzeige.
+
+## Problem
+
+Langlaufende Operationen geben kein Feedback. Der Nutzer klickt, nichts passiert sichtbar,
+die App liest sich als abgestürzt. Der gemeldete Fall war ein Merge mit Verify-Gate, aber das
+ist ein Symptom eines Musters: Feedback wird **pro Fall ad-hoc** gebaut
+(`PrepStarted/Line/Finished`, `RefineStarted/Finished`, `PlanningMerge*`, `MergeProgress`),
+und dabei geht regelmäßig eine Hälfte verloren oder eine Fläche wird vergessen.
+
+Belegend: `HubBroadcaster.MergeProgress` existierte bereits, während `WorkerClient` noch
+keinen Listener hatte — Sender ohne Empfänger. Das wurde parallel zu diesem Design in einer
+anderen Session nachgezogen (siehe *Abhängigkeit zur Parallelarbeit*), deckt aber nur das
+MergeModal ab, nicht den Approve-Pfad im Detail-Pane.
+
+## Vier Fehlerbilder
+
+Die Analyse trennt vier Klassen, die **verschiedene** Lösungen brauchen. Sie zusammen als
+„fehlendes Feedback" zu behandeln war der Fehler der bisherigen Einzelfall-Fixes.
+
+### Bild 1 — Stiller Await im UI
+
+Ein `[RelayCommand]` awaitet einen Call, ohne Busy-State, ohne Anzeige. Der Button bleibt
+klickbar (Doppelklick-Risiko), es gibt keinen Hinweis, dass etwas läuft.
+
+| Stelle | Befund |
+|---|---|
+| `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs:1206` `ApproveReviewAsync` | **Der gemeldete Fall.** Kein Busy-Flag, kein Indikator; das Verify-Gate kann den Call Minuten halten |
+| `DetailsIslandViewModel.cs:1244` `SubmitForReviewAsync` | kein Busy-Flag (`MissionControlViewModel` hat für denselben Call ein `IsSubmitPending`, das Detail-Pane nicht) |
+| `DetailsIslandViewModel.cs` `RejectReviewAsync`, `ParkReviewAsync` | kein Busy-Flag; Fehler werden verschluckt (`catch { return; }`) |
+| `src/ClaudeDo.Ui/ViewModels/Islands/MergeSectionViewModel.cs:121` `PreviewMergeAsync` | kein Indikator |
+| `WorktreesOverviewModalViewModel` (`IsBusy` vorhanden) | `IsBusy` schaltet in `WorktreesOverviewModalView.axaml:107-108` **nur** Buttons aus — kein Spinner, kein Text. Betrifft Cleanup, Reset, ForceRemove, Refresh, Batch-Merge |
+| Settings-Tabs: `SessionSkillsSettingsTabViewModel`, `FilesSettingsTabViewModel`, `OnlineInboxSettingsViewModel` | dito — `IsEnabled="{Binding !IsBusy}"`, keine Anzeige. Skill-Install ist ein `git clone` |
+| `WeeklyReportModalViewModel`, `RepoImportModalViewModel` | `IsBusy` nur als CanExecute-Gate |
+| Islands ↔ SQLite direkt | Die Islands sprechen direkt mit der DB (`new TaskRepository(ctx)` u.ä., ~15 Stellen allein in `DetailsIslandViewModel`). Meist schnell; `ClearCompleted`, Drag-Reorder über viele Zeilen und das Laden großer Listen nicht zwingend |
+
+Bereits sauber gelöst und **nicht** anzufassen: `MergeModalViewModel` (Spinner + Phase +
+Elapsed), `ConflictResolverViewModel` (`IsBusy` + Text), `DiffViewerViewModel.IsLoadingCombined`,
+`UsageMonitorModalViewModel` (Spinner).
+
+### Bild 2 — UI-Thread-Freeze
+
+Eine andere Fehlerklasse: hier hilft kein Indikator, weil der Dispatcher blockiert ist und
+der Spinner nicht gezeichnet werden könnte. Erst auslagern, dann anzeigen.
+
+| Stelle | Befund |
+|---|---|
+| `src/ClaudeDo.Ui/ViewModels/Modals/DiffViewerViewModel.cs:182` und `:260` | `UnifiedDiffParser.Parse(raw)` läuft **synchron auf dem UI-Thread** |
+| `src/ClaudeDo.Ui/Views/Controls/DiffTextView.axaml.cs:102` | `DiffAlignment.Build(File?.Lines)` ebenfalls |
+
+Im gesamten `ClaudeDo.Ui`-Projekt gibt es **zwei** `Task.Run`-Offloads (`RepoScanner`,
+`RestartWorkerService`). CPU-Arbeit auf dem UI-Thread ist damit die Norm, nicht die Ausnahme.
+
+### Bild 3 — Worker-Stille
+
+Operationen ohne UI-Auslöser. Kein Client erfährt, dass sie laufen; die UI zeigt im
+Startfall nur „reconnecting".
+
+| Stelle | Warum langsam |
+|---|---|
+| 6× `src/ClaudeDo.Worker/Lifecycle/*Recovery.cs` beim Worker-Start (`OrphanRecovery`, `StaleTaskRecovery`, `PromptFileRecovery`, `AttachmentOrphanRecovery`, `PlanningLineageRecovery`, `LegacyWorktreeFolderRecovery`) | git + DB über alle Tasks/Worktrees |
+| `src/ClaudeDo.Worker/Runner/WorktreeManager.cs` — Worktree-Anlage beim Task-Start | `git worktree add` + Branch; stille Lücke zwischen `Queued` und erster Ausgabe |
+| `src/ClaudeDo.Worker/Worktrees/WorktreeMaintenanceService.cs` | Hintergrund-git über alle Worktrees |
+| `TaskMergeService.RebaseOthersAfterMergeAsync` | läuft **innerhalb** des Merge-Calls, **nach** dem Phasen-Broadcast — vollständig unsichtbar |
+| `PlanningAggregator`, `PlanningMergeOrchestrator` | ein Merge pro Subtask |
+| `OnlineSyncService`, `UsageMonitorService`, `PrimeScheduler`, `QueueService` | periodisch, Netz/git |
+
+Querverweis: `docs/superpowers/specs/2026-08-07-ui-reaktivitaet-und-listen-performance-design.md`
+führt `WorktreeManager.cs:103` als DB-Write-ohne-Broadcast (Loch 3). C3 muss prüfen, ob das
+inzwischen geschlossen ist, statt es doppelt zu beheben.
+
+### Bild 4 — MCP-Stille
+
+Trifft nicht die UI, sondern Agenten-Runs. Nur drei Dateien reporten Progress:
+`ExternalMcpService` (5 Tools), `TaskWaitMcpTools`, `TaskMergeService`. Ohne Progress laufen
+u.a. die 8 `batch_*`-Tools, `cleanup_task_worktree`, `get_task_diff`, `preview_merge_set`.
+
+Das ist die dokumentierte Ursache des Traps „MCP 300s idle abort leaves merges stuck": der
+Client bricht bei Stille ab, während der Worker weiterarbeitet, und der Task bleibt hängen.
+
+### Bewusst ausgeschlossen: der Installer
+
+`ClaudeDo.Installer` hat eine vollständige `IProgress<string>`-Step-Pipeline mit Live-Anzeige
+(`Core/InstallerService.cs`, `Steps/*`, `Pages/InstallPage`). Das ist die beste Progress-Fläche
+im Repo und braucht nichts.
+
+## Design
+
+### 1. UI-Primitive: `OperationStatus`
+
+Eine `ObservableObject`-Klasse, die ein ViewModel als Property exponiert. Mehrere pro VM sind
+erlaubt und erwünscht — `WorktreesOverviewModalViewModel` braucht getrennte für Refresh,
+Cleanup und Merge, sonst blockiert ein laufender Refresh die Cleanup-Anzeige.
+
+| Property | Verhalten |
+|---|---|
+| `IsRunning` | sofort `true` → treibt `CanExecute`, verhindert Doppelklick |
+| `ShowIndicator` | erst nach **300 ms** `true` → kein Flackern bei schnellen Calls |
+| `Label` | lokalisierter Text, **mid-flight überschreibbar** (`Report(label)`) |
+| `Elapsed` | `mm:ss`, **lokal getickt** |
+| `IsStalled` | `true`, wenn **60 s ohne Aktualisierung** vergangen sind → Hinweis „läuft weiter, Worker antwortet noch" |
+
+`IsStalled` bemisst sich an der Zeit seit dem letzten `Report`, **nicht** an der Gesamtdauer.
+Sonst würde ein regulär mehrminütiges Verify-Gate fälschlich als hängend gemeldet. Eine
+Operation ohne jeden `Report` gilt nach 60 s als stalled — das ist der Fall, der heute wie ein
+Absturz aussieht.
+
+Benutzung:
+
+```csharp
+using var op = Approve.Begin(Loc.T("ops.merge.merging"));
+var result = await _worker.ApproveReviewAsync(...);
+```
+
+`Dispose` beendet die Operation auch im Exception-Fall.
+
+**Zeitquelle ist injizierbar** (`TimeProvider`, in .NET 8 vorhanden), kein statischer
+`DispatcherTimer`. Ein geteilter statischer Timer wäre genau die Sorte Shared State, die die
+`Ui.Tests` reihenfolgen-abhängig flaky macht. Timer-Callbacks kommen vom Threadpool und müssen
+auf den Dispatcher gepostet werden.
+
+**Fehlerbehandlung bleibt unverändert.** Weiter über `ShowErrorAsync` / `ErrorReported` /
+`FlashFooterError`. `OperationStatus` transportiert keine Fehler.
+
+### 2. UI-Control: `OperationIndicator`
+
+`src/ClaudeDo.Ui/Views/Controls/OperationIndicator.axaml` — Spinner (`Ellipse.spinner` aus
+`IslandStyles`) + Label + Elapsed, gebunden an eine `OperationStatus`. Ohne das Control wird
+die Spinner-StackPanel aus `MergeModalView.axaml:28-30` acht Mal von Hand nachgebaut.
+
+Alle Texte über Locale-Keys im Namespace `ops.*`; en/de-Parität erzwingen die
+`Localization.Tests`.
+
+### 3. Worker-Kanal: ein generisches Progress-Event
+
+Der Worker sendet nur, was das UI **nicht erraten kann** — interne Phasen und Zählstände. Beim
+Klick weiß das UI selbst, was es angestoßen hat.
+
+```
+OperationProgress(string opKey, string phase, int current, int total)
+```
+
+- `opKey` = TaskId bei task-gebundenen Operationen, sonst ein stabiler String
+  (`"worktree-cleanup"`, `"startup-recovery"`, `"planning-integration:<taskId>"`)
+- **Kein Elapsed auf der Leitung** — das tickt das UI
+- `current`/`total` erlaubt echten Fortschritt („Worktree 3/12"), was das heutige
+  `MergeProgress` nicht kann
+
+Dieses Event **ersetzt** `MergeProgress`. Begründung, dass sich die Verallgemeinerung lohnt:
+es gibt drei Produzenten (Merge-Phasen, Worktree-Cleanup, Planning-Integration), nicht einen.
+
+**Aber `IWorkerClient.MergeProgressEvent` bleibt als dünner Forwarder bestehen.** Sonst
+zerstört C1 die Gruppen-Isolation: A1 abonniert dieses Event, und ein Rename würde C zwingen,
+`DetailsIslandViewModel` zu ändern — eine Datei, die Gruppe A besitzt. Der Forwarder kostet
+vier Zeilen und hält die vier Sessions unabhängig. Er darf später entfernt werden, wenn A und
+C beide gemergt sind.
+
+### 4. MCP: `ProgressReporter` als eigene Klasse
+
+`TaskMergeService.RunReportingProgressAsync` (Zeile ~175) ist die einzige existierende
+Progress-Schleife. Sie wird als eigenständige Klasse extrahiert, sodass jedes MCP-Tool sie
+nutzen kann, statt die Schleife zu kopieren. Zusätzlich ein Overload für Element-Fortschritt
+(`i/n`) für die `batch_*`-Tools.
+
+## Festgelegte Grenzen
+
+Bewusst **nicht** Teil dieses Designs:
+
+- **Kein Cancel.** Nur Sichtbarkeit. Ein Abbruch wäre bei einem Merge ohnehin irreführend: das
+  Verify-Gate läuft, wenn der Merge-Commit längst geschrieben ist — „abbrechen" könnte nur
+  *aufhören zu warten* bedeuten, nicht zurückrollen. Ohne Cancel entfällt der
+  `opId`-Handshake; die Korrelation läuft über `taskId` bzw. das offene Modal.
+- **Keine Footer-Anzeige für laufende Operationen.** Anzeige am auslösenden Control und an der
+  Task-Zeile / im Detail-Pane. Der Footer bleibt für Fehler (`FlashFooterError`) und den
+  Worker-Log.
+- **Keine Prozent-Balken.** Die meisten Operationen haben kein sinnvolles Total.
+  `current/total` wird als Text gezeigt, nicht als Balken.
+- **Keine EF-Migration.** Damit entfällt der Trap paralleler Migrationen.
+
+## Messung
+
+„Erst messen, dann instrumentieren" gilt für Bild 1 und 3 — aber an **einer** Stelle, nicht an
+zwanzig:
+
+1. Ein Timing-Hook in `WorkerClient` loggt jeden Hub-Invoke mit Dauer.
+2. Ein zweiter im DB-Pfad der Islands.
+
+Ein Tag Nutzung liefert eine sortierte Liste echter Ausreißer. A5 und C entscheiden danach,
+statt zu raten. Bild 2 und 4 brauchen keine Messung — der Befund ist aus dem Code eindeutig.
+
+Faustregel für den Zweifelsfall: instrumentiert wird, was git aufruft, Netz nutzt, einen
+Prozess startet, oder O(n) über unbegrenzt viele DB-Zeilen läuft. Einzelzeilen-Reads nicht.
+
+## Parallelisierung: vier Merge-Helper-Gruppen
+
+Der Zuschnitt folgt dem **Datei-Eigentum**, nicht der Fachlichkeit — nur so können vier
+Sessions gleichzeitig laufen, ohne sich zu überschreiben.
+
+```
+P0 (Fundament, muss allein zuerst landen)
+ ├── Gruppe A  Bild 1: UI-Stille     (5 Pakete)
+ └── Gruppe B  Bild 2: UI-Freeze     (3 Pakete)
+
+Gruppe D  Bild 4: MCP     (4 Pakete)  ← braucht P0 NICHT, kann sofort starten
+Gruppe C  Bild 3: Worker  (5 Pakete)  ← nach P0
+```
+
+| Gruppe | Exklusiv besessene Dateien |
+|---|---|
+| **P0** | `OperationStatus.cs`, `OperationIndicator.axaml`, **beide `locales/*.json`** |
+| **A** | Island-VMs, Modal-VMs und deren AXAML |
+| **B** | `DiffViewerViewModel.cs`, `DiffTextView.axaml.cs` |
+| **C** | `HubBroadcaster`, `WorkerHub`, `WorkerClient`, `IWorkerClient`, `StubWorkerClient`, `Lifecycle/*Recovery`, `WorktreeManager` |
+| **D** | `Worker/External/*McpTools`, `ExternalMcpService` |
+
+**Der einzige echte Konfliktkandidat sind die Locale-Dateien.** A und C brauchen Keys — D
+nicht: MCP-Progress-Meldungen gehen an Agenten, nicht an den Nutzer, und bleiben englische
+Klartext-Strings ohne Locale-Eintrag.
+
+Regel: **P0 legt die Keys für A und C vorab an**, danach fasst keine Gruppe die JSONs mehr an.
+Braucht eine Gruppe doch einen nicht vorgesehenen Key, hängt sie ihn als **letzte** Änderung
+des Pakets an und behandelt ihn im Merge-Helper als bekannte Konfliktstelle.
+
+Drei erzwungene Serialisierungen:
+- `TaskMergeService` — die Parallelsession arbeitet dort; C1 danach.
+- `WorkerClient.cs` — P0-2 setzt dort den Timing-Hook, C ändert dieselbe Datei. P0 liegt
+  ohnehin vor C, damit unkritisch — aber C darf nicht vor P0 starten.
+- Innerhalb jeder Gruppe `serializeOnFileOverlap` auf der Liste setzen.
+
+Ergänzung zum Datei-Eigentum: `Services/UpdateCheckService.cs` gehört zu **A** (Paket A3),
+`Services/WorkerClient.cs` zu **C**. Beide liegen im selben Ordner, sind aber verschiedene
+Dateien.
+
+### Abhängigkeit zur Parallelarbeit
+
+Während dieses Designs hat eine andere Session im gemeinsamen `main`-Checkout das
+Merge-Feedback für das **MergeModal** implementiert — inzwischen committet als
+`cad0582 fix(merge): conventional merge-commit default and live verify progress`:
+Phasen-Broadcast in `TaskMergeService`,
+`HubBroadcaster.MergeProgress`, `IWorkerClient.MergeProgressEvent`,
+`MergeModalViewModel.ProgressMessage`, Spinner in `MergeModalView.axaml`, plus Tests.
+
+Konsequenzen:
+- Der Merge-Fall im MergeModal ist **Vorarbeit**, nicht neu zu bauen.
+- Zwei Nachbesserungen bleiben: A1 schließt den Approve-Pfad im Detail-Pane an, C1 stellt
+  Elapsed auf UI-lokalen Tick um (die Implementierung lässt den Worker alle 30 s ticken —
+  die ersten 30 Sekunden zeigt sie nur „merging").
+- Der Blocker ist damit aufgelöst: C hängt nur noch an P0, nicht mehr an der Parallelsession.
+
+## Pakete
+
+### P0 — Fundament
+
+| # | Inhalt |
+|---|---|
+| P0-1 | `OperationStatus` + `OperationIndicator` + `ops.*`-Keys **für alle vier Gruppen vorab** + `Ui.Tests` mit Fake-`TimeProvider` |
+| P0-2 | Timing-Hook in `WorkerClient` + im DB-Pfad der Islands |
+| P0-3 | Regel in `src/ClaudeDo.Ui/CLAUDE.md` und `src/ClaudeDo.Worker/CLAUDE.md`: jeder `IWorkerClient`-Call in einem `[RelayCommand]` läuft durch eine `OperationStatus`; MCP-Tools über ~5 s reporten Progress |
+
+### Gruppe A — Bild 1: UI-Stille
+
+| # | Inhalt |
+|---|---|
+| A1 | Detail-Pane: Approve & Merge, Submit for review, Reject, Park, Preview-Merge. Abonniert das Merge-Phasen-Event zum Nachschärfen des Labels |
+| A2 | WorktreesOverview: Refresh, Cleanup, Reset, ForceRemove, Batch-Merge (inkl. Zeilen-Status) |
+| A3 | Settings-Tabs: SessionSkill install/update, Restore-Defaults, OnlineInbox-SignIn, RepoImport-Scan, Update-Check |
+| A4 | Reports und Planning-UI: GenerateWeekReport, RunDailyPrepNow, BuildPlanningIntegrationBranch, GetPlanningAggregate, Finalize/QueuePlanningSubtasks |
+| A5 | Island-DB-Pfade — **nur die, die P0-2 als Ausreißer zeigt** |
+
+### Gruppe B — Bild 2: UI-Freeze
+
+| # | Inhalt |
+|---|---|
+| B1 | `UnifiedDiffParser.Parse` nach `Task.Run` + Indikator im DiffViewer |
+| B2 | `DiffAlignment.Build`: Grenze definieren (ab N Zeilen auslagern oder inkrementell aufbauen) |
+| B3 | Guard-Test: Parse/Build über ein großes Fixture blockiert den Dispatcher nicht |
+
+### Gruppe C — Bild 3: Worker-Stille
+
+| # | Inhalt |
+|---|---|
+| C1 | `OperationProgress(opKey, phase, current, total)` ersetzt `MergeProgress`; Elapsed auf UI-lokalen Tick |
+| C2 | Startup-Recovery sichtbar (6 Services) — Anzeige im Shell statt nur „reconnecting" |
+| C3 | Worktree-Anlage beim Task-Start sichtbar an der Task-Zeile. Vorher prüfen, ob der Broadcast-Gap aus dem 08-07-Spec schon geschlossen ist |
+| C4 | `RebaseOthersAfterMergeAsync` und `WorktreeMaintenanceService` in den Kanal |
+| C5 | Periodische Dienste (Usage, OnlineSync, Prime, Queue): nur Aktivität und Fehler, kein Tick-Spam |
+
+### Gruppe D — Bild 4: MCP
+
+| # | Inhalt |
+|---|---|
+| D1 | `ProgressReporter` aus `TaskMergeService.RunReportingProgressAsync` extrahieren, inkl. `i/n`-Overload |
+| D2 | Die 8 `batch_*`-Tools mit Element-Fortschritt |
+| D3 | Worktree- und Diff-Tools: `cleanup_task_worktree`, `batch_cleanup_task_worktrees`, `get_task_diff`, `preview_merge_set` |
+| D4 | Restliche Long-Runner + Doku-Regel im Worker-`CLAUDE.md` |
+
+## Test-Strategie
+
+- **`OperationStatus`**: reine Unit-Tests mit Fake-`TimeProvider` — 300-ms-Grace, 60-s-Stall,
+  Elapsed-Formatierung, `Dispose` im Exception-Fall, `Report` überschreibt Label.
+- **VM-Tests** (`Ui.Tests`, headless): Command setzt `IsRunning`, `CanExecute` sperrt während
+  des Laufs, Zustand ist nach einer Exception zurückgesetzt. Fakes: `StubWorkerClient` muss
+  bei jedem neuen Event mitwachsen.
+- **B3** ist der einzige Test, der Blockierung prüft: großes Diff-Fixture, Messung, dass der
+  Dispatcher weiter Nachrichten verarbeitet.
+- **Worker/MCP** (`Worker.Tests`): Progress-Callbacks werden mit einem Fake-`IProgress`
+  gezählt; keine echte Claude-CLI, keine echten Timeouts.
+- **Visuell**: jedes Paket in A und B hat eine offene visuelle Prüfung. Spinner, Grace-Periode
+  und Layout kann kein Test bestätigen — das läuft über den Nutzer.

docs/superpowers/specs/2026-08-11-task-numbers-design.md

@@ -0,0 +1,116 @@
+# Task Numbers (`#123`) — Design
+
+**Date:** 2026-08-11
+**Status:** approved, not implemented
+
+## Problem
+
+Tasks are only addressable by GUID. Every report from Claude reads
+"task `0ef5ga…` is done", which is unreadable and untraceable for the user. A short,
+stable, human-speakable handle is needed.
+
+## Decision
+
+Add a **global, monotonically increasing integer** `TaskEntity.Number`, displayed as `#123`.
+
+- **Global, not per list.** Per-list numbering would make `#123` ambiguous across the ~15
+  lists and would force a list argument into every lookup. Global costs nothing and is
+  unambiguous.
+- **Alias, not identity.** The GUID stays the primary key and stays in branch names
+  (`claudedo/{id}`), worktree paths, and the `ClaudeDo-Task:` commit trailer. `Number` is
+  purely a display + lookup alias.
+- **Immutable, never reused.** A number that appeared in a log must never later point at a
+  different task. Deleting tasks leaves gaps — that is correct and intended.
+
+## Allocation
+
+`MAX(number) + 1` is **wrong**: deleting the newest task frees its number for reuse.
+Use a persistent counter instead.
+
+- `app_settings.next_task_number` (INTEGER NOT NULL, singleton row — same table as
+  `MaxTurnsCeiling` etc.).
+- Allocation is one statement, atomic under SQLite's single-writer model:
+  `UPDATE app_settings SET next_task_number = next_task_number + 1
+   WHERE id = 1 RETURNING next_task_number - 1`
+  executed in the **same transaction** as the task insert.
+- `tasks.number` gets a **UNIQUE index** (`idx_tasks_number`) so a collision is a DB error,
+  not silent corruption. On a unique violation, retry the allocation (bounded, 5 attempts).
+
+Only **two** insert sites exist and both must allocate — every other creation path
+(UI, `add_task`, `batch_add_tasks`, Online Inbox sync, merge-helper handler task,
+planning children) routes through one of them:
+
+- `TaskRepository.AddAsync` (`src/ClaudeDo.Data/Repositories/TaskRepository.cs:20`)
+- `TaskRepository.AddChildAsync` (same file, ~line 297)
+
+Do **not** reuse `SortOrder` — it is per list and mutable via drag & drop.
+
+## Migration + backfill
+
+One migration, created **alone** (never in parallel with another migration — sibling
+migrations off the same parent silently drop each other's columns on a SQLite table rebuild):
+
+1. `ALTER TABLE tasks ADD COLUMN number INTEGER NOT NULL DEFAULT 0`
+2. Backfill in creation order:
+   `UPDATE tasks SET number = (SELECT COUNT(*) FROM tasks t2
+    WHERE t2.created_at < tasks.created_at OR (t2.created_at = tasks.created_at AND t2.id <= tasks.id))`
+   (or the equivalent `ROW_NUMBER()` window function).
+3. `ALTER TABLE app_settings ADD COLUMN next_task_number INTEGER NOT NULL DEFAULT 1`
+   then set it to `(SELECT COALESCE(MAX(number), 0) + 1 FROM tasks)`.
+4. Create the unique index **after** the backfill.
+
+⚠️ Tests use `EnsureCreated`, which bypasses migrations — the backfill needs a test that
+explicitly runs `Migrate()` against a DB seeded with pre-migration rows.
+
+## Resolution: `#123` → GUID
+
+New `TaskIdResolver` in `src/ClaudeDo.Worker/External/`:
+
+- Input `#123` or bare `123` (a GUID is never all-digits, so this is unambiguous) → look up
+  by number.
+- Anything else → passed through as a GUID.
+- Unknown number → a clear MCP error (`no task with number 123`), never a silent null.
+
+Wired at the top of every MCP tool taking a task id (~44 parameters across `External/`),
+including the id arrays of the `batch_*` tools.
+
+## Output surface
+
+Two central mappers cover most tools:
+
+- `ExternalMcpService.ToDto` (line ~1629) → `TaskDto`
+- `ExternalMcpService.GetTaskRefAsync` (line ~335) → `TaskRefDto`
+
+Add `Number` to both. Then the DTOs that carry a bare task id and bypass those mappers:
+`RunTaskNowResult`, `MergeTaskResultDto`, `PossibleDuplicateDto`, `SubsetRelationDto`,
+`FileOverlapDto`, the `BatchMcpTools` results, `TaskWaitMcpTools`, `QueueStateMcpTools`,
+`RunHistoryMcpTools`.
+
+`McpToolDocs` gets a shared clause instructing the agent to **refer to tasks as `#<number>`
+when reporting to the user**. Without this the number is present in the payload but never
+spoken — this clause is the actual point of the feature.
+
+## UI surface
+
+- `TaskRowViewModel.Number` → dim `#123` in the row, tokenized (no inline literals).
+- Detail pane header.
+- `HubBroadcaster.WorkerLog` business events in `TaskRunner` / `TaskMergeService` /
+  `TaskResetService` say `#123` instead of the GUID.
+
+## Out of scope (possible follow-up)
+
+Branch names and worktree folder names (`claudedo/123-<slug>`, `123-<slug>`). Cheap once
+numbers exist, but a separate change — it touches merge, self-heal, and the merge helper.
+
+## Slices
+
+| # | Slice | Depends on |
+|---|---|---|
+| 1 | Schema, counter, allocator, backfill migration + tests | — |
+| 2 | MCP output: `Number` in all task-carrying DTOs | 1 |
+| 3 | MCP input: `TaskIdResolver` + `McpToolDocs` reporting clause | 2 |
+| 4 | UI: row/detail display + worker-log messages | 1 |
+| 5 | Docs: `CLAUDE.md` (Data, Worker), explore-notes | 3, 4 |
+
+2 and 3 both edit `ExternalMcpService.cs` heavily, so 3 waits for 2 rather than running
+beside it. 4 touches disjoint files and can run beside 2.

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.

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/Program.cs

@@ -52,8 +52,14 @@ sealed class Program
             // Dispose the container so WorkerClient.DisposeAsync runs —
             // cancels the retry loop and closes the SignalR connection cleanly
             // instead of abandoning it.
-            try { services.DisposeAsync().AsTask().GetAwaiter().GetResult(); }
-            catch { /* best effort on shutdown */ }
+            try
+            {
+                services.DisposeAsync().AsTask().GetAwaiter().GetResult();
+            }
+            catch
+            {
+                /* best effort on shutdown */
+            }
         }
     }
 
@@ -102,7 +108,9 @@ sealed class Program
         sc.AddSingleton<IWorkerClient>(sp => sp.GetRequiredService<WorkerClient>());
 
         // Release check + installer update
-        sc.AddSingleton<HttpClient>(_ => new HttpClient { Timeout = TimeSpan.FromSeconds(10) });
+        sc.AddSingleton<HttpClient>(_ =>
+            new HttpClient(new SocketsHttpHandler { PooledConnectionLifetime = TimeSpan.FromMinutes(5) })
+                { Timeout = TimeSpan.FromSeconds(10) });
         sc.AddSingleton<IReleaseClient>(sp => new ReleaseClient(sp.GetRequiredService<HttpClient>()));
         sc.AddSingleton<InstallerLocator>();
         sc.AddSingleton<WorkerLocator>();
@@ -111,24 +119,26 @@ sealed class Program
             var releases = sp.GetRequiredService<IReleaseClient>();
             var informational = Assembly.GetEntryAssembly()?
                 .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion;
-            // Strip MinVer build metadata ("+sha") and any prerelease suffix for the update-compare.
+            // Strip MinVer build metadata ("+sha") only — keep the prerelease suffix
+            // (e.g. "-alpha.0.14"), VersionComparer needs it to tell a dev build on
+            // main apart from a tagged release of the same numeric core.
             var version = (informational ?? "0.0.0").Split('+')[0];
             return new UpdateCheckService(releases, version);
         });
 
         // Conflict-merge coordinator: single seam the shell wires to its resolver entry.
         sc.AddSingleton<MergeCoordinator>();
-        sc.AddSingleton<IMergeCoordinator>(sp => sp.GetRequiredService<MergeCoordinator>());
 
         // ViewModels
         sc.AddTransient<DiffViewerViewModel>();
         sc.AddTransient<Func<DiffViewerViewModel>>(sp => () => sp.GetRequiredService<DiffViewerViewModel>());
         sc.AddTransient<WorktreesOverviewModalViewModel>();
-        sc.AddTransient<Func<WorktreesOverviewModalViewModel>>(sp => () => sp.GetRequiredService<WorktreesOverviewModalViewModel>());
+        sc.AddTransient<Func<WorktreesOverviewModalViewModel>>(sp =>
+            () => sp.GetRequiredService<WorktreesOverviewModalViewModel>());
         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>();
@@ -137,9 +147,11 @@ sealed class Program
         sc.AddTransient<RepoImportModalViewModel>();
         sc.AddTransient<Func<RepoImportModalViewModel>>(sp => () => sp.GetRequiredService<RepoImportModalViewModel>());
         sc.AddTransient<WeeklyReportModalViewModel>();
-        sc.AddTransient<Func<WeeklyReportModalViewModel>>(sp => () => sp.GetRequiredService<WeeklyReportModalViewModel>());
+        sc.AddTransient<Func<WeeklyReportModalViewModel>>(sp =>
+            () => sp.GetRequiredService<WeeklyReportModalViewModel>());
         sc.AddTransient<UsageMonitorModalViewModel>();
-        sc.AddTransient<Func<UsageMonitorModalViewModel>>(sp => () => sp.GetRequiredService<UsageMonitorModalViewModel>());
+        sc.AddTransient<Func<UsageMonitorModalViewModel>>(sp =>
+            () => sp.GetRequiredService<UsageMonitorModalViewModel>());
         sc.AddSingleton<Func<string, ClaudeDo.Ui.ViewModels.Conflicts.ConflictResolverViewModel>>(sp =>
             taskId => new ClaudeDo.Ui.ViewModels.Conflicts.ConflictResolverViewModel(
                 sp.GetRequiredService<IWorkerClient>(), taskId));
@@ -160,7 +172,7 @@ sealed class Program
                 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,16 +4,19 @@ 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), ScheduledFor, Result, ReviewFeedback, LogPath, timestamps, CommitType, Model / SystemPrompt / AgentPath / MaxTurns (nullable overrides), IsStarred, IsMyDay, IsManual, Notes, ParentTaskId, PlanningSessionId / PlanningSessionToken / PlanningFinalizedAt, CreatedBy, HandlerBaseCommit / HandlerHeadCommit, InteractiveSessionId.
-  - Status / PlanningPhase / BlockedByTaskId semantics + allowed transitions: `ClaudeDo.Worker/CLAUDE.md` → Status Model.
+- **TaskEntity** — Id, ListId, Title, Description, Status, PlanningPhase, BlockedByTaskId (FK to predecessor in a chain), DependsOnTaskId (FK to a user/MCP-declared predecessor, distinct from BlockedByTaskId), ScheduledFor, Result, ReviewFeedback, LogPath, timestamps, CommitType, Model / SystemPrompt / AgentPath / MaxTurns / PermissionMode (nullable overrides), IsStarred, IsMyDay, IsManual, Notes, ParentTaskId, PlanningSessionId / PlanningSessionToken / PlanningFinalizedAt, CreatedBy, HandlerBaseCommit / HandlerHeadCommit, InteractiveSessionId, TicketRef, Number (global immutable human-readable alias).
+  - `TicketRef` (`ticket_ref`, nullable string) — link to an external ticket, format `<provider>:<id>` (currently always `bandel:<ticketId>`). Set by the ticket import, otherwise null. → `ClaudeDo.Worker/CLAUDE.md` Tickets section.
+  - Status / PlanningPhase / BlockedByTaskId / DependsOnTaskId semantics + allowed transitions: `ClaudeDo.Worker/CLAUDE.md` → Status Model.
   - `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).
-  - Legacy status values `Manual`/`Planning`/`Planned`/`Draft`/`Waiting` were retired; existing rows backfill via the `RetireLegacyTaskStatus` migration.
+  - `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`)
-- **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).
+- **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`
@@ -33,6 +36,7 @@ Beyond the basics it carries:
 | `DailyPrepMaxTasks` | `daily_prep_max_tasks` | 5 | Hard cap on MyDay tasks the daily prep may place. |
 | `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. |
 
 All four usage percentages are clamped 0..100 by `AppSettingsRepository.UpdateAsync`.
 Gate/throttle semantics → [usage-monitoring](../../docs/explore-notes/usage-monitoring.md).
@@ -48,10 +52,10 @@ Gate/throttle semantics → [usage-monitoring](../../docs/explore-notes/usage-mo
 All use EF Core LINQ via `ClaudeDoDbContext`. The atomic `Queued → Running` claim lives in the
 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`.
+- **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`
 - **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
@@ -61,9 +65,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
 
@@ -72,7 +76,7 @@ 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
@@ -95,9 +99,28 @@ Tables (one per line so parallel migrations don't collide on the same line):
 - `week_reports`
 - `task_attachments`
 
-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`), and
-`blocked_by_task_id` (FK to `tasks.id`, `ON DELETE SET NULL`).
+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` — the only test that runs a real `Migrate()` (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`),
+`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`).
 
 ## Conventions
 

src/ClaudeDo.Data/ClaudeDoDbContext.cs

@@ -73,11 +73,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 +109,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 +119,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

@@ -13,6 +13,9 @@ public class AppSettingsEntityConfiguration : IEntityTypeConfiguration<AppSettin
         builder.HasKey(s => s.Id);
         builder.Property(s => s.Id).HasColumnName("id").ValueGeneratedNever();
 
+        builder.Property(s => s.NextTaskNumber)
+            .HasColumnName("next_task_number").IsRequired().HasDefaultValue(1);
+
         builder.Property(s => s.DefaultClaudeInstructions)
             .HasColumnName("default_claude_instructions").IsRequired().HasDefaultValue(string.Empty);
         builder.Property(s => s.DefaultModel)
@@ -64,6 +67,9 @@ 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.HasData(new AppSettingsEntity { Id = AppSettingsEntity.SingletonId });
     }
 }

src/ClaudeDo.Data/Configuration/ListConfigEntityConfiguration.cs

@@ -18,5 +18,7 @@ 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.PermissionMode).HasColumnName("permission_mode");
+        builder.Property(c => c.TicketProjectId).HasColumnName("ticket_project_id");
     }
 }

src/ClaudeDo.Data/Configuration/ListEntityConfiguration.cs

@@ -18,6 +18,7 @@ public class ListEntityConfiguration : IEntityTypeConfiguration<ListEntity>
         builder.Property(l => l.DefaultCommitType).HasColumnName("default_commit_type").IsRequired().HasDefaultValue("chore");
         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.HasIndex(l => l.SortOrder).HasDatabaseName("idx_lists_sort");
 

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/TaskEntityConfiguration.cs

@@ -66,6 +66,7 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
 
         builder.HasKey(t => t.Id);
         builder.Property(t => t.Id).HasColumnName("id");
+        builder.Property(t => t.Number).HasColumnName("number").IsRequired();
         builder.Property(t => t.ListId).HasColumnName("list_id").IsRequired();
         builder.Property(t => t.Title).HasColumnName("title").IsRequired();
         builder.Property(t => t.Description).HasColumnName("description");
@@ -74,10 +75,15 @@ 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");
         builder.Property(t => t.RoadblockCount).HasColumnName("roadblock_count").HasDefaultValue(0);
+        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");
@@ -87,6 +93,7 @@ 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);
@@ -96,6 +103,7 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         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");
@@ -115,6 +123,13 @@ 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);
+
         builder.HasOne(t => t.List)
             .WithMany(l => l.Tasks)
             .HasForeignKey(t => t.ListId)
@@ -124,10 +139,12 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
             .WithOne(w => w.Task)
             .HasForeignKey<WorktreeEntity>(w => w.TaskId);
 
+        builder.HasIndex(t => t.Number).IsUnique().HasDatabaseName("idx_tasks_number");
         builder.HasIndex(t => t.ListId).HasDatabaseName("idx_tasks_list_id");
         builder.HasIndex(t => t.Status).HasDatabaseName("idx_tasks_status");
         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/Configuration/TaskRunEntityConfiguration.cs

@@ -30,6 +30,9 @@ public class TaskRunEntityConfiguration : IEntityTypeConfiguration<TaskRunEntity
         builder.Property(r => r.StartedAt).HasColumnName("started_at");
         builder.Property(r => r.FinishedAt).HasColumnName("finished_at");
         builder.Property(r => r.Model).HasColumnName("model");
+        builder.Property(r => r.ResultSubtype).HasColumnName("result_subtype");
+        builder.Property(r => r.TerminalReason).HasColumnName("terminal_reason");
+        builder.Property(r => r.Errors).HasColumnName("errors");
 
         builder.HasOne(r => r.Task)
             .WithMany(t => t.Runs)

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

@@ -1,13 +0,0 @@
-using ClaudeDo.Data.Models;
-using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
-
-namespace ClaudeDo.Data.Filtering.Filters;
-
-public sealed class ReviewFilter : ITaskListFilter
-{
-    public string Id => "virtual:review";
-    public bool Matches(TaskEntity t) =>
-        t.Status == TaskStatus.WaitingForReview;
-    public bool ShouldCount(TaskEntity t) => Matches(t);
-    public bool MatchesAsContext(TaskEntity t, IReadOnlyList<TaskEntity> all) => false;
-}

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

@@ -1,16 +0,0 @@
-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, Func<TaskEntity, bool> flag) : ITaskListFilter
-{
-    public string Id => id;
-    public bool Matches(TaskEntity t) => flag(t);
-    public bool ShouldCount(TaskEntity t) => flag(t) && t.Status != TaskStatus.Done;
-    public bool MatchesAsContext(TaskEntity t, IReadOnlyList<TaskEntity> all) => false;
-}

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

@@ -1,18 +0,0 @@
-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) : ITaskListFilter
-{
-    public string Id => id;
-    public bool Matches(TaskEntity t) => t.Status == status;
-    public bool ShouldCount(TaskEntity t) => t.Status == status;
-    public bool MatchesAsContext(TaskEntity t, IReadOnlyList<TaskEntity> all) =>
-        PlanningRules.IsPlanningParent(t) &&
-        PlanningRules.HasMatchingChild(t, all, c => c.Status == status);
-}

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

@@ -1,24 +0,0 @@
-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 : ITaskListFilter
-{
-    private readonly string _listId;
-
-    public UserListFilter(string listId)
-    {
-        _listId = listId;
-        Id = $"user:{listId}";
-    }
-
-    public string Id { get; }
-    public bool Matches(TaskEntity t) => t.ListId == _listId;
-    public bool ShouldCount(TaskEntity t) => t.ListId == _listId && t.Status != TaskStatus.Done;
-    public bool MatchesAsContext(TaskEntity t, IReadOnlyList<TaskEntity> all) => false;
-}

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

@@ -1,26 +0,0 @@
-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>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/ConflictMarkerParser.cs

@@ -25,10 +25,13 @@ public sealed record MergeSegment
     /// <summary>"Theirs" side (the incoming branch) when <see cref="IsConflict"/> is true.</summary>
     public string Theirs { get; init; } = "";
 
-    public static MergeSegment Stable(string text) => new() { Text = text };
+    /// <summary>1-based line number in the file where this segment starts (the marker line for a conflict).</summary>
+    public int StartLine { get; init; } = 1;
 
-    public static MergeSegment Conflict(string ours, string? @base, string theirs) =>
-        new() { IsConflict = true, Ours = ours, Base = @base, Theirs = theirs };
+    public static MergeSegment Stable(string text, int startLine = 1) => new() { Text = text, StartLine = startLine };
+
+    public static MergeSegment Conflict(string ours, string? @base, string theirs, int startLine = 1) =>
+        new() { IsConflict = true, Ours = ours, Base = @base, Theirs = theirs, StartLine = startLine };
 }
 
 /// <summary>
@@ -49,22 +52,25 @@ public static class ConflictMarkerParser
         var segments = new List<MergeSegment>();
         var lines = SplitKeepLineEndings(fileText);
         var stable = new StringBuilder();
+        var stableStartLine = 1;
         var i = 0;
 
         while (i < lines.Count)
         {
             if (!IsMarker(lines[i], OursMarker))
             {
+                if (stable.Length == 0) stableStartLine = i + 1;
                 stable.Append(lines[i++]);
                 continue;
             }
 
             if (stable.Length > 0)
             {
-                segments.Add(MergeSegment.Stable(stable.ToString()));
+                segments.Add(MergeSegment.Stable(stable.ToString(), stableStartLine));
                 stable.Clear();
             }
 
+            var conflictStartLine = i + 1;
             i++; // consume "<<<<<<<"
             var ours = new StringBuilder();
             while (i < lines.Count && !IsMarker(lines[i], BaseMarker) && !IsMarker(lines[i], SepMarker))
@@ -88,11 +94,11 @@ public static class ConflictMarkerParser
 
             if (i < lines.Count && IsMarker(lines[i], TheirsMarker)) i++; // consume ">>>>>>>"
 
-            segments.Add(MergeSegment.Conflict(ours.ToString(), @base, theirs.ToString()));
+            segments.Add(MergeSegment.Conflict(ours.ToString(), @base, theirs.ToString(), conflictStartLine));
         }
 
         if (stable.Length > 0)
-            segments.Add(MergeSegment.Stable(stable.ToString()));
+            segments.Add(MergeSegment.Stable(stable.ToString(), stableStartLine));
 
         return segments;
     }

src/ClaudeDo.Data/Git/GitService.cs

@@ -3,7 +3,10 @@ using System.Text;
 
 namespace ClaudeDo.Data.Git;
 
-public sealed record MergePreview(bool Supported, bool Clean, IReadOnlyList<string> ConflictFiles);
+// TreeOid is only populated when Clean — the tree `merge-tree --write-tree` would produce,
+// usable to materialize the merge result into a scratch worktree without touching the real
+// working tree, index, or refs (see GitService.CommitTreeAsync / WorktreeAddDetachedAsync).
+public sealed record MergePreview(bool Supported, bool Clean, IReadOnlyList<string> ConflictFiles, string? TreeOid = null);
 
 public sealed class GitService
 {
@@ -42,6 +45,16 @@ public sealed class GitService
         };
     }
 
+    /// <summary>
+    /// The merge base of two refs, or null when git can't find one (e.g. an unresolvable ref) —
+    /// callers treat that as "can't evaluate", not "no common history".
+    /// </summary>
+    public async Task<string?> MergeBaseAsync(string repoDir, string refA, string refB, CancellationToken ct = default)
+    {
+        var (exitCode, stdout, _) = await RunGitAsync(repoDir, ["merge-base", refA, refB], ct);
+        return exitCode == 0 ? stdout.Trim() : null;
+    }
+
     public async Task WorktreeAddAsync(string repoDir, string branchName, string worktreePath, string baseCommit, CancellationToken ct = default)
     {
         await WorktreeAddGate.WaitAsync(ct);
@@ -70,9 +83,12 @@ public sealed class GitService
         }
     }
 
+    // --untracked-files=all: without it, a brand-new untracked directory collapses into a single
+    // "?? dir/" entry instead of listing the files inside it — callers matching against specific
+    // paths (e.g. the untracked-collision guard) need the individual files.
     public async Task<string> GetStatusPorcelainAsync(string workingDirectory, CancellationToken ct = default)
     {
-        var (exitCode, stdout, stderr) = await RunGitAsync(workingDirectory, ["status", "--porcelain"], ct);
+        var (exitCode, stdout, stderr) = await RunGitAsync(workingDirectory, ["status", "--porcelain", "--untracked-files=all"], ct);
         if (exitCode != 0)
             throw new InvalidOperationException($"git status --porcelain failed (exit {exitCode}): {stderr}");
         return stdout;
@@ -123,16 +139,20 @@ public sealed class GitService
             throw new InvalidOperationException($"git commit failed (exit {exitCode}): {stderr}");
     }
 
-    public async Task<string> GetDiffAsync(string worktreePath, CancellationToken ct = default)
+    public async Task<string> GetDiffAsync(
+        string worktreePath, IReadOnlyList<string>? paths = null, CancellationToken ct = default)
     {
-        var (exitCode, stdout, stderr) = await RunGitAsync(worktreePath,
-            ["diff", "HEAD"], ct);
+        var args = new List<string> { "diff", "HEAD" };
+        AppendPathFilter(args, paths);
+        var (exitCode, stdout, stderr) = await RunGitAsync(worktreePath, args, ct);
         if (exitCode != 0)
             throw new InvalidOperationException($"git diff HEAD failed (exit {exitCode}): {stderr}");
         // If nothing staged vs HEAD, try the index (untracked is never in diff)
         if (string.IsNullOrWhiteSpace(stdout))
         {
-            var (e2, s2, _) = await RunGitAsync(worktreePath, ["diff", "--cached"], ct);
+            var cachedArgs = new List<string> { "diff", "--cached" };
+            AppendPathFilter(cachedArgs, paths);
+            var (e2, s2, _) = await RunGitAsync(worktreePath, cachedArgs, ct);
             if (e2 == 0) return s2;
         }
         return stdout;
@@ -143,14 +163,19 @@ public sealed class GitService
     /// (committed-on-branch changes + uncommitted work). Used for viewing a Claude
     /// task's total impact relative to where the branch started.
     /// </summary>
-    public async Task<string> GetBranchDiffAsync(string worktreePath, string baseRef, CancellationToken ct = default)
+    public async Task<string> GetBranchDiffAsync(
+        string worktreePath, string baseRef, IReadOnlyList<string>? paths = null, CancellationToken ct = default)
     {
-        var (exitCode, stdout, _) = await RunGitAsync(worktreePath,
-            ["diff", baseRef], ct);
+        var args = new List<string> { "diff", baseRef };
+        AppendPathFilter(args, paths);
+        var (exitCode, stdout, _) = await RunGitAsync(worktreePath, args, ct);
         if (exitCode == 0 && !string.IsNullOrWhiteSpace(stdout))
             return stdout;
-        // Fallback: whatever the worktree has vs HEAD (uncommitted only).
-        return await GetDiffAsync(worktreePath, ct);
+        // Fallback: whatever the worktree has vs HEAD (uncommitted only). The same pathspec has to
+        // come along — a filter makes an empty ranged diff the common case (the caller asked for
+        // paths this range never touched), and an unfiltered fallback would answer that with the
+        // whole worktree diff, the exact opposite of what was requested.
+        return await GetDiffAsync(worktreePath, paths, ct);
     }
 
     /// <summary>
@@ -158,31 +183,36 @@ public sealed class GitService
     /// task's changes after its worktree has been merged away (the commits survive on
     /// the target branch even though the worktree directory and branch ref are gone).
     /// </summary>
-    public async Task<string> GetCommitRangeDiffAsync(string repoDir, string baseCommit, string headCommit, CancellationToken ct = default)
+    public async Task<string> GetCommitRangeDiffAsync(
+        string repoDir, string baseCommit, string headCommit, IReadOnlyList<string>? paths = null, CancellationToken ct = default)
     {
-        var (exitCode, stdout, stderr) = await RunGitAsync(repoDir,
-            ["diff", $"{baseCommit}..{headCommit}"], ct);
+        var args = new List<string> { "diff", $"{baseCommit}..{headCommit}" };
+        AppendPathFilter(args, paths);
+        var (exitCode, stdout, stderr) = await RunGitAsync(repoDir, args, ct);
         if (exitCode != 0)
             throw new InvalidOperationException($"git diff {baseCommit}..{headCommit} failed (exit {exitCode}): {stderr}");
         return stdout;
     }
 
-    public async Task<string> DiffStatAsync(string worktreePath, string baseCommit, string headCommit, CancellationToken ct = default)
+    public async Task<string> DiffStatAsync(
+        string worktreePath, string baseCommit, string headCommit, IReadOnlyList<string>? paths = null, CancellationToken ct = default)
     {
-        var (exitCode, stdout, stderr) = await RunGitAsync(worktreePath,
-            ["diff", "--stat", $"{baseCommit}..{headCommit}"], ct);
+        var args = new List<string> { "diff", "--stat", $"{baseCommit}..{headCommit}" };
+        AppendPathFilter(args, paths);
+        var (exitCode, stdout, stderr) = await RunGitAsync(worktreePath, args, ct);
         if (exitCode != 0)
             throw new InvalidOperationException($"git diff --stat failed (exit {exitCode}): {stderr}");
         return stdout.Trim();
     }
 
-    public async Task<string> GetFileDiffAsync(string worktreePath, string? baseCommit, string relativePath, CancellationToken ct = default)
+    // Appends a `-- <paths>` pathspec filter so git itself narrows the diff instead of the
+    // caller filtering the result after the fact (works identically for --stat and full diffs).
+    // No-op when paths is null/empty so existing callers see no behavior change.
+    private static void AppendPathFilter(List<string> args, IReadOnlyList<string>? paths)
     {
-        string[] args = string.IsNullOrEmpty(baseCommit)
-            ? ["diff", "--", relativePath]
-            : ["diff", $"{baseCommit}..HEAD", "--", relativePath];
-        var (_, stdout, _) = await RunGitAsync(worktreePath, args, ct);
-        return stdout;
+        if (paths is not { Count: > 0 }) return;
+        args.Add("--");
+        args.AddRange(paths);
     }
 
     public async Task WorktreeRemoveAsync(string repoDir, string worktreePath, bool force = false, CancellationToken ct = default)
@@ -346,6 +376,32 @@ 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>
     /// Non-destructive mergeability probe via `git merge-tree --write-tree`. Writes only
     /// loose objects — the working tree, index, and refs are left untouched.
@@ -357,7 +413,8 @@ public sealed class GitService
             ["merge-tree", "--write-tree", "--name-only", targetBranch, sourceBranch], ct);
 
         if (exitCode == 0)
-            return new MergePreview(true, true, Array.Empty<string>());
+            // stdout is just the written tree's oid on a clean merge.
+            return new MergePreview(true, true, Array.Empty<string>(), stdout.Trim());
 
         if (exitCode == 1)
         {
@@ -377,6 +434,62 @@ public sealed class GitService
         return new MergePreview(false, false, Array.Empty<string>());
     }
 
+    /// <summary>Resolves <paramref name="revision"/> (a branch, tag, or SHA) to a full commit SHA.</summary>
+    public async Task<string> RevParseAsync(string repoDir, string revision, CancellationToken ct = default)
+    {
+        var (exitCode, stdout, stderr) = await RunGitAsync(repoDir, ["rev-parse", revision], ct);
+        if (exitCode != 0)
+            throw new InvalidOperationException($"git rev-parse '{revision}' failed (exit {exitCode}): {stderr}");
+        return stdout.Trim();
+    }
+
+    /// <summary>
+    /// Creates a new commit object wrapping <paramref name="treeOid"/> with <paramref name="parentSha"/>
+    /// as its single parent, writing only a loose object — no ref is created or moved.
+    /// </summary>
+    public async Task<string> CommitTreeAsync(
+        string repoDir, string treeOid, string parentSha, string message, CancellationToken ct = default)
+    {
+        var (exitCode, stdout, stderr) = await RunGitAsync(repoDir,
+            ["commit-tree", treeOid, "-p", parentSha, "-m", message], ct);
+        if (exitCode != 0)
+            throw new InvalidOperationException($"git commit-tree failed (exit {exitCode}): {stderr}");
+        return stdout.Trim();
+    }
+
+    /// <summary>
+    /// Materializes <paramref name="commitish"/> into a new, branchless worktree at
+    /// <paramref name="worktreePath"/> (detached HEAD) — used to build/verify a merge-tree
+    /// result without ever creating a branch or touching the real working tree.
+    /// </summary>
+    public async Task WorktreeAddDetachedAsync(
+        string repoDir, string worktreePath, string commitish, CancellationToken ct = default)
+    {
+        await WorktreeAddGate.WaitAsync(ct);
+        try
+        {
+            const int maxAttempts = 3;
+            for (var attempt = 1; ; attempt++)
+            {
+                var (exitCode, _, stderr) = await RunGitAsync(repoDir,
+                    ["worktree", "add", "--detach", worktreePath, commitish], ct);
+                if (exitCode == 0)
+                    return;
+
+                var transient = stderr.Contains("commondir", StringComparison.OrdinalIgnoreCase)
+                    || stderr.Contains("failed to read", StringComparison.OrdinalIgnoreCase);
+                if (!transient || attempt >= maxAttempts)
+                    throw new InvalidOperationException($"git worktree add --detach failed (exit {exitCode}): {stderr}");
+
+                await Task.Delay(150 * attempt, ct);
+            }
+        }
+        finally
+        {
+            WorktreeAddGate.Release();
+        }
+    }
+
     /// <summary>Count of files that differ on <paramref name="sourceBranch"/> since its merge base with the target.</summary>
     public async Task<int> CountChangedFilesAsync(
         string repoDir, string targetBranch, string sourceBranch, CancellationToken ct = default)
@@ -389,6 +502,43 @@ public sealed class GitService
             .Count(s => s.Length > 0);
     }
 
+    /// <summary>Files that differ between two exact refs (2-dot, no merge-base resolution) -- used to see
+    /// what a target branch itself picked up since a task's fork point, as opposed to
+    /// <see cref="CountChangedFilesAsync"/>'s 3-dot count of a branch's own changes.</summary>
+    public async Task<IReadOnlyList<string>> GetChangedFileNamesAsync(
+        string repoDir, string fromRef, string toRef, CancellationToken ct = default)
+    {
+        var (exitCode, stdout, _) = await RunGitAsync(repoDir,
+            ["diff", "--name-only", $"{fromRef}..{toRef}"], ct);
+        if (exitCode != 0) return Array.Empty<string>();
+        return stdout
+            .Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+            .Where(s => s.Length > 0)
+            .ToList();
+    }
+
+    /// <summary>
+    /// Rebases the branch checked out at <paramref name="worktreePath"/> onto <paramref name="ontoRef"/>.
+    /// On conflict or any other failure the rebase is aborted before returning, so the worktree is left
+    /// exactly as it was rather than stranded mid-rebase; <c>ConflictFiles</c> is best-effort and only
+    /// populated when the failure was an actual conflict.
+    /// </summary>
+    public async Task<(int ExitCode, string Stderr, IReadOnlyList<string> ConflictFiles)> RebaseAsync(
+        string worktreePath, string ontoRef, CancellationToken ct = default)
+    {
+        var (exitCode, _, stderr) = await RunGitAsync(worktreePath, ["rebase", ontoRef], ct);
+        if (exitCode == 0)
+            return (0, stderr, Array.Empty<string>());
+
+        List<string> conflictFiles;
+        try { conflictFiles = await ListConflictedFilesAsync(worktreePath, ct); }
+        catch { conflictFiles = new(); }
+
+        await RunGitAsync(worktreePath, ["rebase", "--abort"], ct);
+        return (exitCode, stderr, conflictFiles);
+    }
+
+
     private static async Task<(int ExitCode, string Stdout, string Stderr)> RunGitAsync(
         string workDir, IEnumerable<string> args, CancellationToken ct, string? stdinData = null, bool trimOutput = true)
     {

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/20260424212250_AddTaskCreatedBy.cs

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

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/20260604125720_AddRoadblockCount.cs

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

src/ClaudeDo.Data/Migrations/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/20260727114206_AddModelPresetsAndManualFlag.cs

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

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/20260805074906_AddUsageGateAndRunModel.cs

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

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/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.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.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
-        }
-    }
-}