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

@@ -11,10 +11,13 @@ Two-process system communicating over SignalR (`127.0.0.1:47821`):
 - **ClaudeDo.Data** — SQLite data layer, repositories, models, GitService
 - **ClaudeDo.Worker** — ASP.NET Core hosted service, task queue, Claude CLI runner
 - **ClaudeDo.Localization** — `locales/en.json` + `locales/de.json` and the lookup service
+- **ClaudeDo.Releases** — Gitea release client (`IReleaseClient`), used by the Ui update check and the Installer
 - **ClaudeDo.Installer** — WPF (`UseWPF`) setup app; install/update/uninstall step pipeline
 - **tests/** — six xUnit projects (Worker, Data, Ui, Localization, Installer, Releases); Worker.Tests run real SQLite and real git
 
-Each project has its own `CLAUDE.md` — those are the living per-project docs.
+Per-project `CLAUDE.md` files exist for **App, Data, Installer, Ui, Worker, and Worker.Tests** —
+those are the living per-project docs. Localization, Releases, and the other five test projects
+have none; this file plus the code is all there is for them.
 
 ## Tech Stack
 
@@ -26,10 +29,10 @@ Each project has its own `CLAUDE.md` — those are the living per-project docs.
 
 ## 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
@@ -39,7 +42,7 @@ Each project has its own `CLAUDE.md` — those are the living per-project docs.
 - EF Core migrations manage schema (Migrations/ folder in ClaudeDo.Data)
 - `IDbContextFactory<ClaudeDoDbContext>` used by singleton consumers (e.g. Worker)
 - Entity configuration via `IEntityTypeConfiguration<T>` in Configuration/ folder
-- Task status flow: Idle | Queued -> Running -> WaitingForReview -> Done | Failed | Cancelled. A task that spawns/has children passes through WaitingForChildren first, then surfaces for review once every child is terminal — this is the single parent model for both planning and improvement parents (planning/improvement *children* themselves go straight to Done, only the parent is reviewed). From review you can approve, reject-rerun (Queued, resumes the session with feedback), reject-park (Idle), or cancel. Approve is the single review+merge action: a childless task merges its own worktree then Done (conflicts keep it in WaitingForReview); a task with children drives the unit merge (parent worktree if any + each Done child in order, with conflict continue/abort). Tasks with no active worktree (sandbox run) approve straight to Done. In the detail pane, **Approve & Merge is gated behind opening the diff**: when there is something to inspect (worktree diff / merged range / children combined diff) the button stays disabled until the diff or combined-diff viewer has been opened once, and re-locks per run (any state change resets it); tasks with nothing to inspect are never gated. The row-level quick-approve in the task list is an intentional bypass.
+- Task status flow: `Idle | Queued -> Running -> WaitingForReview -> Done | Failed | Cancelled`; a task with children passes through `WaitingForChildren` first. **Approve is the single review+merge action** (no separate "Merge all"), and in the detail pane it's gated behind opening the diff. Full transition table → `src/ClaudeDo.Worker/CLAUDE.md`; merge/review/gate mechanics → `docs/explore-notes/review-merge.md`.
 - Worktree state flow: Active -> Merged | Discarded | Kept
 - The queue picker claims tasks by `Status=Queued` (with `BlockedByTaskId IS NULL`); the legacy tag system was removed
 - Interfaces live in an `Interfaces/` subfolder beside their consumers (namespace unchanged)
@@ -73,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.
 
@@ -84,4 +87,4 @@ dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
 - `docs/improvement-plan.md` — improvement snapshot from 2026-04-13 (historical)
 - `docs/prompts-inventory.md`, `docs/mailbox-proposal.md` — reference material (mailbox integration is parked)
 - `CHANGELOG.md` — Keep a Changelog format, maintained on release
-- `docs/explore-notes/` — distilled maps of complex subsystems from deep exploration (detail too fine for a CLAUDE.md). **Before** deep-exploring a subsystem, check for a matching note first; **after** a deep explore, distill durable findings back and bump its "verified against" commit. Always verify against current code before trusting. See `docs/explore-notes/README.md`.
+- `docs/explore-notes/` — distilled maps of complex subsystems (detail too fine for a CLAUDE.md, read on demand). **Before** deep-exploring a subsystem, check for a matching note first; **after** a deep explore, distill durable findings back and bump its "verified against" commit. Always verify against current code before trusting. See `docs/explore-notes/README.md`. Current notes: `worker-task-pipeline`, `usage-monitoring`, `external-mcp`, `review-merge`, `conpty-sessions`, `installer-preflight`.

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

@@ -10,6 +10,18 @@ These sit **between** the CLAUDE.md files and the code:
   too fine-grained for a CLAUDE.md but stable enough to be worth caching. Read on demand.
 - **code** — the only source of truth.
 
+## Index
+
+| Note | Covers |
+|---|---|
+| [worker-task-pipeline](worker-task-pipeline.md) | `TaskRunner` end-to-end: config resolution, worktree, CLI invocation, streaming, commit |
+| [usage-monitoring](usage-monitoring.md) | OAuth usage endpoint, gate, throttle, per-run token accounting, usage pill/modal |
+| [external-mcp](external-mcp.md) | The `claudedo` MCP tool surface + its two test-enforced conventions |
+| [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
 
 - **Only stable structure.** Flows, responsibilities, entry points, invariants, relative

docs/explore-notes/conpty-sessions.md

@@ -0,0 +1,303 @@
+# ConPTY interactive sessions & launch specs
+
+> **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
+> 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.
+
+Covers `InteractiveLaunchSpecService` and the four kinds of embedded ConPTY session the UI
+process hosts (real `claude` TUI in a Mission Control tile).
+
+Autonomous queue tasks are **not** covered here — they stay on the stream-json path via
+`TaskRunner`. See [worker-task-pipeline.md](worker-task-pipeline.md).
+
+## The four session kinds
+
+| Kind | Hub spec method | Notes |
+|---|---|---|
+| 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` / `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
+
+**No ConPTY path ever passes task free-text (title / description / brief) as a CLI argument.**
+Every one of them writes it to a file first and hands `claude` a single-line kickoff pointing at
+that file, exposed via `--add-dir`.
+
+Two independent reasons:
+
+1. The ConPTY host flattens `Args` into **one command line** to spawn the process, and `claude`
+   re-splits that line on whitespace. Any token starting with `-` in real task text (e.g. `->`,
+   `--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 `~/.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`.
+
+## Argument ordering
+
+Every spec passes `--effort <level>` from the relevant model's preset. It **leads** the args —
+except for a fresh task session with a brief, where `--add-dir <sessionDir>` must come first so
+`--effort` (a single-value flag) can sit directly before the positional kickoff.
+
+`--model` is deliberately **NOT** forced on an interactive session — the user can still switch
+models in the TUI.
+
+### ⚠️ Gotcha: no directory arg may end in a separator
+
+`PtyTerminalSession` hands `Args` to `TerminalControl.Args`, which the library flattens into ONE
+Windows command line with each token quoted. Windows argv rules read `\"` as an *escaped* quote,
+so a token like `"C:\repo\"` never closes and every following argument is swallowed by the
+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` 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:
+`Get-CimInstance Win32_Process -Filter "Name = 'claude.exe'"`.
+
+## Resuming a task session (`TaskEntity.InteractiveSessionId`)
+
+`claude --session-id <uuid>` lets the caller pre-assign a conversation's session id instead of
+waiting for the CLI to generate one. `BuildForTaskAsync` uses this so a closed or aborted
+interactive task session can be resumed even if it never got far enough to write anything to its
+own transcript:
+
+1. **Resume check.** If the task isn't on a freshly (re)created worktree, `BuildForTaskAsync`
+   picks a session to resume with `task.InteractiveSessionId ?? run?.SessionId` — this task's own
+   last *interactive* conversation takes precedence over the latest *autonomous* run's session,
+   since they're distinct conversations even against the same worktree. A task that has only ever
+   run autonomously still resumes into that run's session the first time it's opened interactively
+   (this is the pre-existing behavior `run?.SessionId` alone used to provide).
+2. **Fresh path.** If neither is available (never run any way, or `isFreshWorktree`), a new
+   `Guid.NewGuid()` is generated and persisted to `TaskEntity.InteractiveSessionId` via
+   `TaskRepository.SetInteractiveSessionIdAsync` — **before** the `LaunchSpec` is returned, i.e.
+   before the ConPTY host ever spawns `claude`. `BuildFreshTaskArgsAsync` then passes it as
+   `--session-id <guid>`, placed as the single-value flag directly before the positional kickoff
+   (or, with no brief, right after `--effort`).
+3. **Fresh worktree wins.** `isFreshWorktree` forces `run` to `null` *and* is checked before
+   reading `task.InteractiveSessionId`, so a recreated worktree never resumes a stale id from
+   either source — it always takes the fresh path, which overwrites the stale
+   `InteractiveSessionId` with the new one.
+
+Net effect: reopening an interactive session for a task (pane closed, process killed, whatever)
+resumes the same claude conversation, because the id was committed to the DB before the previous
+launch even started.
+
+## List handler ("Let Claude handle it")
+
+`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)).
+
+### The host task and its commit range
+
+The handler run **owns a real ClaudeDo task**, created by `CreateMergeHelperTask` (hub) →
+`InteractiveLaunchSpecService.CreateMergeHelperTaskAsync`, called by the UI *before* it opens
+the tile:
+
+- One new task per run in that list, `Idle` + `IsManual=true` (never queued).
+- Title/description localized via `missionControl.mergeHelperTaskTitle` /
+  `mergeHelperTaskDescriptionHeader`.
+- `TaskEntity.HandlerBaseCommit` stamped to the list repo's current HEAD.
+
+The host task **never gets a worktree of its own** — the handler commits straight into the
+list's working dir and merges the tasks it handles itself. Consequences:
+
+- `SubmitTaskForReview` branches on whether the task has a `WorktreeEntity`: with one, it
+  commits the worktree; without one, it stamps `HandlerHeadCommit` to the list repo's current
+  HEAD. Both paths then flip the task `Idle`/`Failed` → `WaitingForReview`.
+- `GetTaskDiff` and the UI's `DetailsIslandViewModel` / `MergeSectionViewModel` fall back to the
+  `HandlerBaseCommit`..`HandlerHeadCommit` range whenever `Worktree` is null.
+
+### UI flow
+
+`MergeHelperSelectionModalViewModel` — checkbox picker over one list's non-terminal, non-manual
+tasks, pre-ticking the actionable ones. **List-scoped only** (`Configure(listId, listName)`, no
+global scope). Opened from the list row's context menu, which is hidden when the list has no
+working dir.
+
+On confirm: `ListsIslandViewModel` raises `LetClaudeHandleRequested` → shell →
+`MissionControlViewModel.OpenMergeHelperConPtySessionAsync`, which calls
+`CreateMergeHelperTaskAsync` and then opens a **task-based** tile (deduped by `TaskId` like
+`OpenConPtySessionAsync`, **not** `CreateAdHoc`) running the five-phase handler prompt.
+
+## Tile lifecycle
+
+`ConPtyPaneViewModel` resolves its own launch spec — the ctor takes a descriptor **factory**,
+the host wires handlers and then calls `Start()`. So the tile appears **immediately** with its
+spinner while the worker is still preparing the worktree. A failed launch keeps the tile with an
+inline error banner instead of the tile never appearing.
+
+`SubmitForReviewCommand.CanExecute` also gates on `Terminal.IsStarting` / `StartError` /
+`HasExited` (not just `IsTaskBased`) — a starting or dead pane can't offer a review it would only
+have the worker reject, and `MissionControlViewModel.OnPaneSubmitForReview` sets the pane's
+`IsSubmitPending` flag for the duration of the round trip so a rapid double-click can't race two
+`SubmitTaskForReviewAsync` calls. A failed launch also offers `RetryCommand` (visible whenever
+`HasExited && StartError != null`) — it swaps in a fresh `InteractiveTerminalViewModel` and calls
+`Start()` again on the **same** pane/`TaskId` dedupe slot, since `PtyTerminalSession` throws on a
+second `StartAsync` call and can't be restarted in place.
+
+### ⚠️ Gotcha: the terminal library kills its child on visual-tree detach
+
+`Iciclecreek.Avalonia.Terminal`'s `TerminalView.OnDetachedFromLogicalTree` calls
+`CleanupProcess()` (kills the PTY child) unless `BeginReparent()` suppressed it — and Mission
+Control detaches pane views routinely (`RebuildOverviewGrid` recreates everything on any pane
+add/remove/column change; focus-mode tab switches re-present content). Two-part defense (since
+`aac84e4`):
+
+1. `PtyTerminalSession.StartAsync` puts the control in **permanent reparent mode** right after
+   `LaunchProcess()` — `EndReparent` is deliberately never called. Teardown is explicit only:
+   `ConPtyPaneViewModel.Dispose` → `Terminal.Kill()` (pane close, VM disposal via DI on exit).
+2. `ConPtyPaneHost` (the DataTemplate content for a pane) reparents **one long-lived
+   `ConPtyPaneView` per pane VM** (`ConditionalWeakTable`, view pins its own `DataContext`)
+   instead of letting the template instantiate a fresh view — a fresh view would render a dead,
+   empty terminal because the running session is bound to the original `TerminalControl`.
+   Hosts only steal the view while `IsEffectivelyVisible`; the layout toggle posts a reclaim
+   pass (`MissionControlView.ReclaimVisiblePaneHosts`) so the now-visible layout re-steals.
+
+`Ellipse.spinner` (IslandStyles) is the shared indeterminate spinner — used for a starting pane
+(`InteractiveTerminalViewModel.IsStarting`) and in place of the refine button while
+`TaskRowViewModel.IsRefining`.
+
+### ⚠️ Gotcha: env-var launch race across sessions
+
+`PtyTerminalSession.StartAsync` applies `TerminalLaunchDescriptor.Env` via
+`Environment.SetEnvironmentVariable` onto the **whole UI process** (Porta.Pty has no per-launch
+env seam — it always inherits the calling process's environment), then calls
+`TerminalControl.LaunchProcess()`. Two sessions starting back-to-back (e.g. planning sessions for
+two different tasks) could interleave: task B's `SetEnvironmentVariable` calls could land between
+task A's env-set and its `LaunchProcess()` fork, so task A's `claude` process inherits B's env
+(e.g. `CLAUDEDO_PLANNING_TOKEN`) and fails its own MCP auth. Fixed by serializing the
+set-env-then-launch critical section behind a process-wide `static SemaphoreSlim(1,1)` in
+`PtyTerminalSession`. Env leakage onto the whole process *after* a launch has forked remains a
+documented limitation — only the fork-time race is closed.
+
+### ⚠️ Gotcha: open-path dedupe races
+
+`MissionControlViewModel.OpenConPtySessionAsync` / `OpenPlanningConPtySessionAsync` dedupe by
+`TaskId` against `ConPtySessions`, but the check ran before an **awaited** DB title lookup and
+only `AddConPtyPane` registers the pane — two rapid invocations for the same task (e.g. a
+double-click) could both pass the dedupe check before either pane existed, opening two panes.
+`OpenMergeHelperConPtySessionAsync` was worse: it awaits `CreateMergeHelperTaskAsync` (which mints
+a brand-new task id every call) *before* any `TaskId` dedupe is even possible, so a double-trigger
+always minted two host tasks in the DB.
+
+Fixed with synchronous, pre-await claims: `_pendingTaskOpens` (shared by the two `TaskId`-keyed
+open paths) and `_pendingMergeHelperLists` (keyed by `listId`, guarding the whole method since
+there's no `TaskId` yet to dedupe on) are `HashSet<string>` fields checked-and-added at method
+entry, before any `await`, and released in a `finally`. A second overlapping call for the same key
+bails out immediately instead of racing past the collection-based dedupe.
+
+## Focus / key handling
+
+`InteractiveTerminalView` lives in `MissionControlWindow`, so the `FocusClearing` Escape handler
+(scoped to `MainWindow` via `AddClassHandler<MainWindow>`) never runs there — **Escape always
+reaches the PTY**. See the note in `src/ClaudeDo.Ui/CLAUDE.md`.
+
+`TaskRowViewModel.HasInteractiveSession` shows an accent "Interactive" chip instead of "Parked";
+tapping it jumps to that Mission Control pane. `TasksIslandViewModel.SyncInteractiveSessions`
+mirrors Mission Control's open panes onto the rows.
+
+### Queueing is gated on an open session (UI-only, since `d84607f`)
+
+A task-based session leaves the row `Idle` (sessions never write `Status`), so nothing on the
+worker side distinguishes it from a plain idle task. `TaskRowViewModel.CanSendToQueue` and
+`MissionControlViewModel.EnqueueTaskAsync` (drag-to-queue onto the Command Center window) both
+check for an open session before queueing — the row via `HasInteractiveSession`, the drag path via
+`ConPtySessions.Any(s => s.TaskId == taskId)` (Mission Control's own authoritative pane list,
+since the mirrored bool on the row could lag). Queueing a task open in a hand-driven ConPTY pane
+would otherwise let the picker spawn an autonomous `claude` process into the same worktree the
+user is editing. Both enqueue paths (`TasksIslandViewModel.SendToQueueAsync` and
+`MissionControlViewModel.EnqueueTaskAsync`) also route through `IWorkerClient.SetTaskStatusAsync`
+(hub `SetTaskStatus` → `TaskStateService.EnqueueAsync`) instead of a raw EF write, so the
+manual/draft-child guards apply on both paths too.
+
+## System-prompt matrix (autonomous vs. interactive)
+
+Autonomous and interactive sessions do **not** share a system prompt. Per start path:
+
+| Start path | Entry point | System prompt |
+|---|---|---|
+| Autonomous run/continue/retry | `TaskRunner.ResolveConfigAsync` → `ClaudeArgsBuilder.Build` | `--append-system-prompt <text>`, recomputed and re-sent on **every** invocation including a `--resume` continue (`PromptKind.System` + improvement/list/task overrides) |
+| Interactive task session, fresh | `InteractiveLaunchSpecService.BuildForTaskAsync` → `BuildFreshTaskArgsAsync` | none — no `--append-system-prompt(-file)` at all |
+| Interactive task session, resume | `InteractiveLaunchSpecService.BuildForTaskAsync` → `WindowsTerminalLauncher.BuildResumeArgs` | none — only `--resume <id>` (+ `--effort`) |
+| Ad-hoc directory session | `InteractiveLaunchSpecService.BuildForDirectoryAsync` | none |
+| 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 (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
+ever passes `--append-system-prompt(-file)`.
+
+### Does `--resume` bring back a prior `--append-system-prompt`? No.
+
+Checked by reading real session transcripts (`~/.claude/projects/<cwd>/<sessionId>.jsonl`) for
+several autonomous ClaudeDo task runs, including ones with multiple invocations (initial run +
+`ContinueAsync`/retry on the same session id, confirmed via that project's `task_runs` history).
+Grepped for the `PromptKind.System` default text ("You are completing one well-defined task
+autonomously...") and for any `"type":"system"` entry or `message.role == "system"` anywhere in
+those files: the prompt text only ever showed up as ordinary tool-result content (e.g. a task
+that happened to read `PromptFiles.cs`'s own source), never as a persisted system/config entry.
+No session transcript — autonomous or interactive — carries a system-role message or a
+per-session record of the CLI flags it was launched with; there is no sidecar file next to the
+`.jsonl` either. The system prompt is purely a per-process request parameter the CLI builds fresh
+from that invocation's own flags, never replayed from a resumed session's history. This matches
+why `TaskRunner.ContinueAsync` (autonomous) explicitly re-resolves and re-passes
+`--append-system-prompt` on every continue instead of relying on `--resume` to carry it —
+if inheritance worked, that re-resolution would be redundant.
+
+**Conclusion: no leak.** An interactive resume (task or planning) does not pick up the autonomous
+run's `--append-system-prompt` text — including the "commit your work" / `CLAUDEDO_BLOCKED`
+instructions from `PromptKind.System`. It simply runs with the `claude` CLI's own baseline system
+prompt, same as every other path in this table that passes no system-prompt flag. No code change
+needed here.
+
+## Related hub methods
+
+`GetInteractiveLaunchSpec`, `GetAdHocLaunchSpec`, `GetMergeHelperLaunchSpec`,
+`CreateMergeHelperTask`, `SubmitTaskForReview`.
+
+Planning sessions: `StartPlanningSession`, `ResumePlanningSession`, `DiscardPlanningSession`,
+`FinalizePlanningSession`, `QueuePlanningSubtasks`, `GetPendingDraftCount`,
+`GetPlanningAggregate`, `BuildPlanningIntegrationBranch`.

docs/explore-notes/external-mcp.md

@@ -0,0 +1,268 @@
+# External MCP tool surface
+
+> **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
+> 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
+Claude sessions. Registered explicitly in `Program.cs`'s external app via `.WithTools<T>()`.
+Server name `claudedo`, registered globally by the installer's `RegisterMcpStep`, so callers
+need no `--mcp-config`.
+
+**Scope boundary:** these tools cover *starting* and *observing* sessions plus task/list CRUD
+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.
+
+## 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:
+     true, <id>, ... }` (`DeleteListResult`, `RunTaskNowResult`, `ResetFailedTaskResult`,
+     `RemoveAttachmentResult`; `SetListConfigResult` / `SetTaskConfigResult` additionally echo
+     the resulting config so the caller can see which fields were set vs. cleared to null).
+   - *Read* tools that may have nothing to return use an explicit `Found` / `Available` flag
+     alongside the nullable payload (`TaskConfigResult`, `BatchGetTaskResult`, `TaskLogResult`).
+   - The same flag-alongside-nullable-payload idiom also covers "which of two shapes did you
+     get": `ListTasks`/`BatchGetTasks` take `includeDescription` (default `false`) and return
+     `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.
+
+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
+   *"An error occurred invoking 'X'."*
+
+## Tool classes
+
+### `ExternalMcpService` — task CRUD, execution, git
+
+Task: `ListTaskLists`, `ListTasks`, `GetTask`, `AddTask`, `AddSubtask`, `UpdateTask`,
+`UpdateTaskStatus`, `ReviewTask`, `RunTaskNow`, `ContinueTask`, `CancelTask`, `DeleteTask`.
+(`GetTaskStatusValues` was removed — a whole tool entry for static reference text. `GetTask`'s
+description is now the canonical place for what each status means.)
+
+Worktree/git: `GetTaskWorktree`, `GetTaskDiff`, `MergeTask`, `ContinueMerge`, `AbortMerge`,
+`VerifyMerges`, `PreviewMerge`, `PreviewMergeSet`, `RevertMerge`, `ListWorktrees`,
+`CleanupTaskWorktree`.
+
+Daily prep: `GetDailyPrepCandidates`, `SetMyDay`.
+
+### Other classes
+
+| Class | Tools |
+|---|---|
+| `BatchMcpTools` | `BatchGetTasks`, `BatchAddTasks`, `BatchUpdateTaskStatus`, `BatchCancelTasks`, `BatchDeleteTasks`, `BatchSetMyDay`, `BatchCleanupTaskWorktrees` |
+| `ListMcpTools` | `CreateList`, `UpdateList`, `DeleteList` |
+| `ConfigMcpTools` | `GetListConfig`, `SetListConfig`, `GetTaskConfig`, `SetTaskConfig`, `GetEffectiveRunConfig` |
+| `RunHistoryMcpTools` | `ListRuns`, `GetRun`, `GetTaskLog` |
+| `AgentMcpTools` | `ListAgents` |
+| `LifecycleMcpTools` | `ResetFailedTask` |
+| `AppSettingsMcpTools` | `GetAppSettings` (read-only) |
+| `TaskWaitMcpTools` | `WaitForTaskChange` |
+| `QueueStateMcpTools` | `GetQueueState` |
+| `AttachmentMcpTools` | `AddTaskAttachment`, `ListTaskAttachments`, `RemoveTaskAttachment` |
+
+## Per-tool behaviour worth knowing
+
+**`ListTasks`** — `includeDescription=false` (default) returns lean `TaskRefDto` references in
+`tasks` (`tasksFull` null); `includeDescription=true` returns full `TaskDto`s (incl.
+Description/Result) in `tasksFull` instead (`tasks` null). Filtering by `createdBy`/`status`
+happens before the lean/full projection either way.
+
+**`UpdateTaskStatus`** accepts `Idle` / `Queued` / `Cancelled` / `Done` only.
+- `Cancelled` goes through `TaskStateService.CancelAsync(..., allowFromIdle: true)` — the
+  **only** caller that opts into cancelling from `Idle`. `PlanningChainCoordinator` relies on
+  `Idle` staying a no-op there by default, because a child parked back to `Idle` mid-chain is
+  a manual opt-out signal.
+- `Done` goes through `TaskStateService.ForceSetStatusAsync` (the same unconditional write the
+  UI's "set status freely" affordance uses) but is **refused** for a task with an active
+  worktree, since that would skip `review_task`'s merge.
+
+**`AddTask`** — always creates the task; also returns `possibleDuplicates` (up to 3, id/title/status
+only, no descriptions) — open (non-terminal) tasks in the *same list* whose normalized title
+overlaps strongly with the new one. Cheap word-overlap heuristic (`ExternalMcpService`'s
+`FindPossibleDuplicatesAsync`/`NormalizeTitleWords`), no embeddings/LLM call, no blocking —
+the caller just gets a heads-up to relay. `BatchAddTasks` carries the same field per item.
+
+**`ReviewTask`** — `approve` / `reject_rerun` / `reject_park` / `cancel` for a
+`WaitingForReview` task. Approve is review+merge exactly like the hub's `ApproveReview`: unit
+merge for parents, worktree merge into optional `targetBranch` for childless tasks. Conflicts
+are reported in `ReviewTaskResult`.
+- A parent's approve also returns `emptyChildren`: the `Done` children about to be unit-merged
+  whose own review range contributed nothing (computed the same way as `PreviewMerge`'s
+  `isEmpty`, before the merge starts so it reflects what's about to be approved). Surfaces a
+  child that reported `CLAUDEDO_BLOCKED` and committed no code — previously that child reached
+  `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
+status / conflictFiles / changedFileCount / `behind` / `isEmpty`. Unlike
+`TaskMergeService.PreviewAsync`'s silent *"unavailable"*, this **throws a clear error** when the
+task has neither an active worktree nor a handler commit range, or the list's working dir is
+missing.
+- `isEmpty` = the review range contributed nothing — zero files changed against the worktree's
+  base commit, or (for a worktree-less list-handler host task) `HandlerBaseCommit ==
+  HandlerHeadCommit`. Distinguishes a genuinely empty branch from one that merely made a small
+  change (`changedFileCount: 0` alone reads as "tiny", not "nothing to review") — the gap that
+  let two blocked planning children reach `Done` with unmerged empty branches unnoticed.
+- A worktree-less handler task has no separate branch to `merge-tree`-preview (its commits
+  already sit in `list.WorkingDir`) — `PreviewMergeCoreAsync` falls back to a synthetic `clean`
+  preview over its own `HandlerBaseCommit..HandlerHeadCommit` diff-stat instead of throwing
+  "has no worktree".
+
+**`PreviewMergeSet`** — same preview for a batch (each entry also carries `isEmpty`), plus a
+file→tasks overlap report built from each task's own diff-stat. ⚠️ That overlap report is a
+**same-file-name hint only** — it is blind to cross-file collisions (e.g. the CS0103 case that
+motivated it). A task that fails to preview gets `error` set and is excluded from the overlap
+instead of aborting the batch.
+
+**`RevertMerge`** — undoes a previously merged task's merge commit on `targetBranch` via
+`git revert -m 1`. Always a **new commit**, never a reset/rewrite, because the target working
+directory is shared with other concurrent sessions.
+- Requires the task to be `Done` with a `Merged` worktree carrying a recorded
+  `WorktreeEntity.MergeCommit`. A task merged before that field existed has none and is
+  **refused rather than guessed** via `git log`.
+- On success the task returns to `WaitingForReview` and the worktree moves to `Kept` — not
+  `Active` (its directory/branch are typically already gone from the original merge's cleanup)
+  and not `Merged`/`Discarded` (`WorktreeMaintenanceService` sweeps those).
+- A conflicting revert is aborted immediately; no half-resolved state is left in the tree.
+
+**`BatchMcpTools`** — best-effort loops over the `ExternalMcpService` single-entity methods.
+**Sequential**, because the scoped `DbContext` is not thread-safe. Merge/review stay
+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 `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.
+
+**`WaitForTaskChange(taskIds, timeoutSeconds = 60, treatWaitingForChildrenAsBusy = false)`** —
+blocks until any given task leaves `Queued`/`Running`, or times out. Returns immediately for a
+task already outside those two (unknown ids reported as status `"NotFound"`, also immediate).
+- Implemented as an **async DB poll** (short-lived `DbContext` per check, 500 ms delay, no
+  held connection, no busy loop) rather than hooking `HubBroadcaster` — deliberately isolated
+  so it can't regress the existing broadcast callers.
+- `timeoutSeconds` is clamped server-side to `TaskWaitMcpTools.MaxTimeoutSeconds` (900 s),
+  comfortably under the `MCP_TOOL_TIMEOUT` (930 s) every ClaudeDo-owned claude launcher sets —
+  `ClaudeProcess` for headless queue runs, `InteractiveLaunchSpecService` for every embedded
+  ConPTY session (list handler, planning, interactive resume) — so the tool reports
+  `timedOut: true` instead of racing the client's own abort. A caller running claude with a
+  different (or default: 60 s) `MCP_TOOL_TIMEOUT` will still see its own client-side timeout
+  fire first; the server has no way to detect or compensate for that.
+- **`treatWaitingForChildrenAsBusy` pitfall (default `false`, backward-compatible):** a planning
+  parent with children goes `Running` → `WaitingForChildren` while children are still working,
+  and by default that already counts as "changed" (it's outside `Queued`/`Running`) — so waiting
+  on a parent returns immediately even though the unit isn't done. Set the flag to keep polling
+  through `WaitingForChildren`; the call then only reports changed once the parent reaches
+  `WaitingForReview` or a terminal status. Does not list or watch the parent's children —
+  callers still need their own ids for that.
+- Replaced the list handler's old "sleep + poll `get_task` in a loop" Phase 3 instruction.
+
+**`GetQueueState()`** — read-only snapshot so a caller doesn't have to infer queue state from
+`maxParallelExecutions` or repeated `wait_for_task_change` rounds:
+`{ configuredSlots, effectiveSlots, activeSlots: [{ slot, taskId, startedAt }], waitingTaskIds }`.
+- `configuredSlots`/`effectiveSlots` reuse `QueueService.GetSlotCountsAsync` — the same
+  configured-vs-throttled computation `QueueService.ExecuteAsync` uses each tick (see
+  [usage-monitoring](usage-monitoring.md) for the throttle staging) — so this tool can't drift
+  from the queue's actual refill decision.
+- `activeSlots` reuses `QueueService.GetActive()` (already the source for the Hub's `GetActive`):
+  `slot` is `"queue"` for a normal queue slot or `"override"` for the single
+  `run_task_now`/`continue_task` slot.
+- `waitingTaskIds` is a fresh read-only query mirroring `QueuePicker.ClaimNextAsync`'s
+  eligibility filter and order (`Queued`, unblocked, non-manual, due, `sort_order` then
+  `created_at`) — it does not claim or mutate anything.
+
+**`AttachmentMcpTools`** — re-attaching the same `fileName` overwrites. Add/remove refuse on a
+`Running` task.
+
+**`GetDailyPrepCandidates`** — Idle, non-blocked tasks in a git repo **not** excluded by
+`AppSettings.ReportExcludedPaths` and not already `IsMyDay`, plus the current Idle MyDay tasks
+and `maxTasks` (= `DailyPrepMaxTasks`). Repo-exclusion logic lives in the `DailyPrepFilter`
+helper in the same file.
+
+**`SetMyDay`** — sets `IsMyDay` (+ optional `SortOrder`). A server-side cap-guard rejects
+turning on MyDay beyond `DailyPrepMaxTasks` open (Idle) MyDay tasks.
+
+**`GetEffectiveRunConfig`** — read-only report of what a task will *actually* run with (model,
+max turns, effort, permission mode, agent path, whether a system prompt is set, skill names),
+each with its source (`task`/`list`/`preset`/`global`); max turns additionally reports the raw
+requested value and whether it was clamped to `AppSettings.MaxTurnsCeiling`. Unlike
+`GetAppSettings`/`GetTaskConfig` (raw, possibly-unused config values), this goes through the same
+`EffectiveRunConfigResolver.Resolve` that `TaskRunner` itself runs with — see
+[worker-task-pipeline](./worker-task-pipeline.md)'s model/effort/max-turns section — so it can't
+drift from the real run. Reads (not writes) `AppSettingsRepository.GetAsync`, which backfills
+`model_presets` on first read after a null column; that backfill is pre-existing shared behavior,
+not a new side effect introduced by this tool.
+
+## Model / max-turns on task creation
+
+Task-generating tools (`AddTask`, planning `CreateChildTask`, `SuggestImprovement`) accept an
+optional `model`, alias-validated via `ModelRegistry.NormalizeAlias` (`haiku`/`sonnet`/`opus`,
+blank = inherit), so Claude can assign the cheapest capable model at creation time — the
+planning/system/improvement prompts instruct it to do so, using
+`ModelRegistry.ByCostAscending` as the cost order.
+
+Planning's `CreateChildTask` **additionally** accepts an optional `maxTurns` (positive int;
+`0`/negative rejected with `ArgumentException`, null = inherit list/global default) so the
+planner can raise the turn budget for a subtask it knows will run long.
+`SuggestImprovement` and `AddTask` do **not** expose it.

docs/explore-notes/installer-preflight.md

@@ -0,0 +1,252 @@
+# Installer preflight: CLI version gate & environment checks
+
+> **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
+> Last verified against commit `bdee731` (2026-08-05).
+> Drift check: `git log --oneline bdee731..HEAD -- src/ClaudeDo.Worker/Lifecycle/ClaudeCliPreflight.cs src/ClaudeDo.Worker/ClaudeDo.Worker.csproj src/ClaudeDo.App/ClaudeDo.App.csproj .gitea/workflows/release.yml src/ClaudeDo.Installer/Checks src/ClaudeDo.Data/Environment/ExecutableResolver.cs`
+> Stable structure only (no line numbers). See docs/explore-notes/README.md.
+
+## Implementation status (as of 2026-08-05)
+
+The research below (§1–5) led to an implementation, but it is **not on `main` yet** — it exists
+on two unmerged task branches:
+
+- `claudedo/06aca9b3afec4b939f59b627bfe21737` — `src/ClaudeDo.Installer/Checks/*`
+  (`GitCheck`, `GitIdentityCheck`, `WriteAccessCheck`, `PortCheck`, `ClaudeCliCheck`,
+  `ClaudeVersionCheck`, `ClaudeAuthCheck`, `PermissionModeAutoCheck`, `EnvironmentCheckService`,
+  `ClaudeCliLookup`) plus `SystemCheckPage` (the Fresh-Install wizard page hosting them) and its
+  own copy of `src/ClaudeDo.Data/Environment/ExecutableResolver.cs`.
+- `claudedo/40272c0bb3b14562b59c022d09c382b6` — the original `ExecutableResolver.cs`, plus wiring
+  it into `ClaudeDo.Worker`'s `ClaudeCliPreflight` and `ClaudeProcess` (the actual root-cause fix:
+  both used to spawn `claude` with `UseShellExecute = false` and no `.cmd`/`.bat` shim resolution,
+  so an npm-installed `claude.cmd` was invisible to the Worker even though it worked in a shell).
+
+The two branches were authored independently and each vendored its own copy of
+`ExecutableResolver.cs` (identical except `06aca9b3` adds a `FallbackDirectories()` diagnostic
+helper); merging both cleanly requires picking one copy, not literally running `git merge` twice.
+Two planned follow-up tasks — a "Claude Help Me" button and a Config-mode Diagnose section —
+never got past a blocked first step, precisely because this prerequisite work wasn't on `main`
+when they ran. See `Environment Checks` in `src/ClaudeDo.Installer/CLAUDE.md` and `docs/open.md`
+for the current gap and the manual verification checklist.
+
+What's confirmed as **matching the research below**: `ClaudeVersionCheck.MinimumVersion` is
+`2.1.220`, exactly the "verified-floor, not a proven minimum" constant from §3. `ClaudeAuthCheck`
+uses `claude auth status --json` exactly as recommended in §4, parsing only the `loggedIn` field.
+`PermissionModeAutoCheck` is the static "is `auto` listed in `--help`" check recommended in §2 —
+real org/model/plan eligibility is deliberately **not** checked, matching the recommendation not
+to build that (a real task run surfaces a startup rejection fast enough on its own). No .NET
+Desktop Runtime check was implemented as an `IEnvironmentCheck` (§5's registry-key detection
+remains a documented-but-unbuilt option, not currently gating anything).
+
+---
+
+Pure research, no code changed. Answers the five questions from the "Root Cause
+`--permission-mode auto`" task. Sources: the locally installed CLI (`claude --version` /
+`--help`), the official docs at `code.claude.com` (fetched 2026-08-05), and this repo's own
+csproj/workflow files.
+
+## 1. Why can `--permission-mode auto` fail?
+
+**It is very rarely a CLI-version problem.** Per the official permission-modes doc
+(`code.claude.com/docs/en/permission-modes#eliminate-prompts-with-auto-mode`), auto mode
+requires **all** of:
+
+- **Plan**: any plan (Free/Pro/Max/Team/Enterprise) qualifies in principle.
+- **Organization**: on Team/Enterprise, on by default; an admin can disable it org-wide via
+  `permissions.disableAutoMode: "disable"` in managed settings. When disabled this way, the CLI
+  **"rejects `--permission-mode auto` at startup"** (verbatim from the doc) — not a runtime
+  fallback, a hard reject.
+- **Model**: on the Anthropic API / Claude Platform on AWS — Opus 4.6+, Sonnet 4.6+, or Fable 5.
+  On Bedrock / Vertex / Foundry / signed-in gateway sessions — only Sonnet 5, Opus 4.7+, Fable 5.
+  Older models (Sonnet 4.5, Opus 4.5, Haiku, claude-3-*) are **not supported on any provider**.
+  A per-org `availableModels` restriction that only allows an old model would silently make
+  auto mode unavailable even on a Team/Enterprise org that hasn't touched `disableAutoMode`.
+- **Provider opt-in (historical)**: on Bedrock/Vertex/Foundry/gateway, CLI **v2.1.158–v2.1.206**
+  required `CLAUDE_CODE_ENABLE_AUTO_MODE=1`; **v2.1.207** removed that requirement. This does
+  **not** apply to a normal claude.ai / Console (Anthropic API) login — only to those four
+  provider types.
+
+A separate, easy-to-hit trap: `defaultMode: "auto"` in **project or local** settings
+(`.claude/settings.json`, `.claude/settings.local.json`) is silently **ignored** since v2.1.142
+— it must live in `~/.claude/settings.json` (user scope). A repo that ships `defaultMode: auto`
+in its own `.claude/settings.json` will start in Manual mode with **no error at all**. This
+doesn't apply to ClaudeDo's case (it passes `--permission-mode auto` as an explicit CLI flag,
+not via a checked-in settings file), but is worth knowing if the failure mode was "silently
+starts in Manual" rather than "CLI errors out".
+
+Quoted from the docs, verbatim: *"If Claude Code reports auto mode as unavailable, one of these
+requirements is unmet; this is not a transient outage."*
+
+**Not verifiable**: which of the above actually hit the colleague — we have no diagnostic from
+their machine (no `claude auth status --json` output, no `claude --version`, no org name). Do
+not guess; if this recurs, capture `claude auth status --json` and `claude --version` from the
+affected machine before further debugging.
+
+## 2. How to reliably detect whether `auto` is supported
+
+**Static, cheap, always safe (no API call):**
+- `claude --version` — semver string, e.g. `2.1.220 (Claude Code)`.
+- `claude --help` — the `--permission-mode <mode>` line lists the accepted enum. Confirmed by
+  testing an invalid value locally:
+  ```
+  $ claude -p "test" --permission-mode bogus
+  error: option '--permission-mode <mode>' argument 'bogus' is invalid. Allowed choices are
+  acceptEdits, auto, bypassPermissions, manual, dontAsk, plan.
+  ```
+  This is validated by the CLI's arg parser (Commander.js) **before any network call** — exits
+  1 immediately. So checking that `auto` is one of the listed choices is a legitimate, free,
+  fast static check — but it only proves the *flag* is recognized, **not** that auto mode is
+  actually usable (org/model/plan gating happens later, at session start, not at arg-parse time).
+- `claude auth status --json` — cheap, local/fast, **does not send a prompt**. Returns:
+  ```json
+  { "loggedIn": true, "authMethod": "claude.ai", "apiProvider": "firstParty",
+    "email": "...", "orgId": "...", "orgName": "...", "subscriptionType": "team" }
+  ```
+  This is the answer to question 4 (see below) and also gives `subscriptionType`/`orgName` —
+  useful context but **still not a direct "is auto mode eligible" answer** (doesn't report the
+  active model or `disableAutoMode` policy).
+
+**No cheap subcommand exists for full eligibility.** Checked `claude auto-mode --help`: it only
+has `config` (effective auto-mode *rule* config — allow/deny lists, not eligibility),
+`defaults` (same, shipped defaults), `critique`, and `reset`. None report plan/model/org
+eligibility. `claude doctor` (non-interactive) does **not** report auto-mode eligibility either
+— it explicitly says *"For a full setup checkup that can also fix issues, run `/doctor` in a
+session"*; the in-session `/doctor` slash command is the one the docs say proposes
+`defaultMode: auto` when eligible, but that requires an interactive session, not a scriptable
+preflight.
+
+**Dynamic (real probe) is the only way to fully confirm eligibility**, and per the docs an
+org-disabled or otherwise-ineligible account **rejects at startup** (fast, before any model
+turn) — so a probe doesn't have to be a full expensive run. A minimal probe such as
+`claude -p "ok" --permission-mode auto --max-turns 1 --output-format json` would fail fast on
+ineligibility (reject at startup) but still costs one real turn + tokens on the success path,
+and still requires a working prompt/response round trip on the happy path. **Recommendation**:
+don't build this into an automated preflight; a static version+flag check plus `auth status`
+covers the reliably-detectable ground, and a real first task run will surface an auto-mode
+rejection immediately and cheaply (fails at startup, not mid-task) if it's actually unavailable.
+**Implemented as:** `PermissionModeAutoCheck` (Warning) — the static flag-listed check only.
+
+## 3. Minimum CLI version for the flags ClaudeDo uses
+
+Flags used (from `ClaudeArgsBuilder` per `src/ClaudeDo.Worker/CLAUDE.md`): `--permission-mode
+auto`, `--effort`, `--agents`, `--json-schema`, `--append-system-prompt`, `--output-format
+stream-json --verbose`, `--resume`, and (installer) `claude mcp add --transport http --scope
+user`.
+
+**Not verifiable precisely.** All eight of these are foundational, long-established flags.
+The official changelog (`raw.githubusercontent.com/anthropics/claude-code/main/CHANGELOG.md`)
+only retains roughly the last ~40 entries (oldest visible: `2.1.181`); auto mode itself, and
+`--json-schema`/`--resume`/`mcp add --transport` all clearly predate that window (the earliest
+found reference is a *bug fix* mentioning "sessions created before v2.1.85" for `--resume`,
+implying `--resume` existed well before 2.1.85). There is no accessible source that pins an
+"introduced in vX" date for any of these eight flags — guessing one would violate the task's
+explicit instruction not to invent a source-less root cause.
+
+What **is** sourced, from the docs fetched 2026-08-05:
+- `--json-schema` + invalid-schema handling: before v2.1.205, an invalid schema was silently
+  ignored (returned unstructured text); v2.1.205 made it a hard `Error: --json-schema is not a
+  valid JSON Schema` exit. Not a "does it exist" gate, but changes error-handling behavior
+  ClaudeDo might currently rely on failing loudly.
+- `--output-format stream-json --verbose` + `system/init.capabilities` array requires v2.1.205+
+  (absent before). Not currently consumed by ClaudeDo per the Worker CLAUDE.md's stream handling
+  description, so not a hard requirement today.
+- `system/init.mcp_server_errors` field requires v2.1.219+. Not currently consumed by ClaudeDo.
+- Manual-mode label/`manual` alias requires v2.1.200+ — irrelevant, ClaudeDo passes `auto`
+  explicitly, never `manual`.
+- Auto mode's Bedrock/Vertex/Foundry/gateway opt-in-env-var requirement was removed in v2.1.207
+  — irrelevant for a direct claude.ai/Console login (this machine: `apiProvider: "firstParty"`).
+
+**Decided constant** (see below) is therefore **the newest version we can positively confirm
+works end-to-end on this machine** (`2.1.220`), not a proven theoretical minimum — because no
+lower true minimum is derivable from available sources without guessing.
+**Implemented as:** `ClaudeVersionCheck.MinimumVersion = new Version(2, 1, 220)` (Error).
+
+## 4. Detecting "CLI is logged in" without sending a prompt
+
+`claude auth status --json` (confirmed working, instant, no API/model call):
+```json
+{ "loggedIn": true, "authMethod": "claude.ai", "apiProvider": "firstParty",
+  "email": "...", "orgId": "...", "orgName": "...", "subscriptionType": "team" }
+```
+This is the CLI's own maintained answer — cheaper and more robust than parsing
+`.credentials.json` directly (format may be internal/undocumented and is a hard-blocked file
+for this task's own tooling; the docs page confirms it lives at
+`%USERPROFILE%\.claude\.credentials.json` on Windows but say nothing about its schema being a
+stable public contract). `claude auth status --text` is available for a human-readable variant;
+`--json` is the default and the right one for a preflight to parse.
+**Implemented as:** `ClaudeAuthCheck` (Error) — parses only the `loggedIn` boolean; any other
+field, or a non-zero exit code, or unparseable JSON, becomes `Unknown` rather than `Failed`.
+
+## 5. .NET runtimes required by the published `app\` / `worker\` artifacts
+
+From `.gitea/workflows/release.yml` (the only build/publish pipeline in this repo) and the two
+csproj files:
+
+- **`ClaudeDo.App`** (`net8.0`, Avalonia, `WinExe`) — published via
+  `dotnet publish ... -r win-x64 --self-contained true`. **Self-contained**: bundles its own
+  .NET 8 runtime. **No .NET runtime needs to be pre-installed** on the target machine for the
+  app itself.
+- **`ClaudeDo.Worker`** (`net8.0`, `Microsoft.NET.Sdk.Web`, ASP.NET Core) — same treatment:
+  `-r win-x64 --self-contained true`. Also fully self-contained; no ASP.NET Core runtime needs
+  to be pre-installed.
+- **`ClaudeDo.Installer`** (`net8.0-windows`, WPF) is the one exception: published
+  `--self-contained false -p:PublishSingleFile=true` — **framework-dependent**. The csproj
+  comment explains why: *"the WPF runtime pack isn't distributed for cross-compile on Linux CI,
+  which made self-contained bundles crash on startup with AV in the apphost."* The target
+  machine **must** have the **.NET 8 Desktop Runtime (x64)** installed before running
+  `ClaudeDo.Installer.exe` — this is the actual runtime-preflight gap, not the app/worker.
+
+**How to check on a target machine**:
+- `dotnet --list-runtimes` — look for a `Microsoft.WindowsDesktop.App 8.0.x` line (Desktop
+  Runtime, required by the installer). Requires the `dotnet` CLI itself to be on PATH; not
+  guaranteed present on a fresh machine that never installed the SDK, only the runtime — in
+  that case `dotnet` may not exist at all even though the runtime DLLs do.
+- Registry fallback (works even without the `dotnet` CLI on PATH):
+  `HKLM\SOFTWARE\dotnet\Setup\InstalledVersions\x64\sharedfx\Microsoft.WindowsDesktop.App` —
+  each installed version is a subkey/value here. This is the standard documented detection
+  mechanism for .NET Desktop Runtime presence on Windows and is what most installer-detection
+  tooling (e.g. Squirrel, WiX bundles) uses instead of shelling out to `dotnet`.
+- **Not independently verified in this task**: the exact registry key shape wasn't inspected
+  live (would require reading `HKLM\SOFTWARE\dotnet\...` on this machine, which is standard
+  .NET installer-detection convention, but out of scope to screenshot/dump here since the task
+  is docs-only and this is a well-documented, non-project-specific Windows convention).
+  **Not implemented** as an `IEnvironmentCheck` — none of the shipped checks verify the Desktop
+  Runtime; if the Installer itself is running at all, .NET 8 Desktop Runtime is implicitly
+  present (framework-dependent publish would otherwise fail to launch).
+
+## Beschlossene Konstanten
+
+| Constant | Value | Confidence |
+|---|---|---|
+| Minimum CLI version | `2.1.220` | **Verified-floor, not a proven minimum.** This is the newest version confirmed installed and working end-to-end on a dev machine for every flag ClaudeDo uses. No lower true minimum could be sourced (see §3) — treat any lower value as a guess. |
+| Credentials file path | `%USERPROFILE%\.claude\.credentials.json` (Windows) | Sourced from official docs; content/schema not inspected (hard-blocked secrets file). |
+| Login-check command | `claude auth status --json` | Verified locally, instant, no model call. Fields: `loggedIn`, `authMethod`, `apiProvider`, `email`, `orgId`, `orgName`, `subscriptionType`. |
+| App/Worker runtime requirement | **None** — self-contained win-x64 publish | Sourced from `.gitea/workflows/release.yml`. |
+| Installer runtime requirement | **.NET 8 Desktop Runtime (x64)** must be pre-installed | Sourced from `.gitea/workflows/release.yml` comment + `ClaudeDo.Installer.csproj`. |
+
+## Erkennungsstrategie pro Check
+
+| Check | Type | Command | Expected pass output | Implemented as |
+|---|---|---|---|---|
+| git present + version | static | `git --version` (via `ExecutableResolver`) | resolves, exit 0 | `GitCheck` (Error) |
+| git identity set | static | `git config --get user.name` / `user.email` | both non-empty | `GitIdentityCheck` (Warning) |
+| install dir + data dir writable | static | probe-file write/delete | succeeds | `WriteAccessCheck` (Error) |
+| SignalR/ExternalMcp ports free | static | `TcpListener` bind probe + owning-process lookup | free, or owned by running `ClaudeDo.Worker` | `PortCheck` (Warning) |
+| CLI present + version | static | `claude --version` | `X.Y.Z (Claude Code)`; parse and compare `X.Y.Z >= 2.1.220` | `ClaudeCliCheck` (Error) / `ClaudeVersionCheck` (Error) |
+| `auto` recognized as a flag value | static | `claude --help` (or trigger the parse error path) | `--permission-mode <mode>` help text lists `auto` among the choices | `PermissionModeAutoCheck` (Warning) |
+| CLI logged in | static/cheap | `claude auth status --json` | exit 0, `loggedIn: true` | `ClaudeAuthCheck` (Error) |
+| Auto mode actually eligible (org/model/plan) | **not statically detectable** | none exists | N/A — see §2; don't build this, let a real task run surface a fast startup rejection instead | not implemented (by design) |
+| .NET Desktop Runtime present (installer only) | static | `dotnet --list-runtimes` (if `dotnet` on PATH) or registry `HKLM\SOFTWARE\dotnet\Setup\InstalledVersions\x64\sharedfx\Microsoft.WindowsDesktop.App` | a `Microsoft.WindowsDesktop.App 8.0.x` entry exists | not implemented (see §5) |
+| App/Worker runtime present | **not needed** | — | self-contained, nothing to check | not implemented (not needed) |
+
+## Not verifiable (explicit)
+
+- The actual root cause on the colleague's machine — no diagnostic data was captured from it.
+- Exact stderr/exit-code wording the CLI prints when auto mode is rejected at startup for an
+  ineligible org/model (docs state the *behavior* — "rejects `--permission-mode auto` at
+  startup" — but not the literal message; this machine's account is eligible, so it couldn't be
+  reproduced locally).
+- A true (not just "newest confirmed") minimum SemVer for `--effort`, `--agents`,
+  `--json-schema`, `--append-system-prompt`, `--resume`, `claude mcp add --transport http
+  --scope user` — all predate the retrievable changelog window.
+- Live inspection of the `HKLM\SOFTWARE\dotnet\Setup\InstalledVersions` registry shape on this
+  machine (documented Windows convention, not independently screenshotted here).

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

@@ -0,0 +1,318 @@
+# Review, merge & conflict resolution
+
+> **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
+> 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.
+
+Covers the review→merge path: `TaskStateService` review transitions, `TaskMergeService`,
+`PlanningMergeOrchestrator`, the post-merge verify gate, and the UI conflict resolver.
+
+## Approve = merge the whole unit
+
+`ApproveReview` (hub) and `review_task` approve (MCP) are the **single** review+merge action.
+There is no separate "Merge all" entry.
+
+- **Task with children** → drives `PlanningMergeOrchestrator`: merges the parent worktree if
+  `Active`, then each `Done` child in order, then sets the parent `Done`. A mid-merge conflict
+  pauses for `ContinuePlanningMerge` / `AbortPlanningMerge`.
+- **Childless task** → `TaskMergeService.ApproveAndMergeAsync`. A conflict keeps the task in
+  `WaitingForReview`.
+- **No active worktree** (sandbox run) → straight to `Done`.
+
+Review transitions all live in `TaskStateService`: `SubmitForReviewAsync`,
+`SubmitForChildrenAsync`, `ApproveReviewAsync`, `RejectToQueueAsync`, `RejectToIdleAsync`,
+`ClearReviewFeedbackAsync`.
+
+`ReviewFeedback` (nullable string on `TaskEntity`) is the reviewer's rejection comment: set by
+`RejectToQueueAsync`, consumed and cleared by `QueueService` on the next re-run, where it
+becomes the next-turn prompt of the resumed Claude session.
+
+## Unified parent model
+
+Every parent — planning **or** improvement — flows
+`… → WaitingForChildren → WaitingForReview → Done`, advanced by the single
+`TaskStateService.TryAdvanceParentAsync`. It surfaces any `WaitingForChildren` parent for
+review once all children are terminal; failed/cancelled children are **annotated on the
+result, not wedged**.
+
+- A planning parent enters `WaitingForChildren` at `FinalizePlanningAsync` (or
+  `WaitingForReview` directly if it has no children).
+- An improvement parent enters it from `TaskRunner.HandleSuccess` when its run spawned children.
+- Planning/improvement **children** go straight to `Done` — no individual review. Only the
+  parent is reviewed.
+
+A child that hits a roadblock (fails, or reports `CLAUDEDO_BLOCKED` roadblocks) does **not**
+advance the parent — the parent stays in `WaitingForChildren` until every child is terminal.
+The UI surfaces blocked children on the parent's Session tab (`ChildOutcomes` + a "children
+need attention" band) so the roadblock is visible without forcing a transition.
+
+A blocked planning/improvement child still goes straight to `Done` per the unified parent model
+above — it committed nothing, but nothing prevents its (empty) branch from being unit-merged
+like any other `Done` child once the parent is approved. The MCP surface has no UI equivalent of
+`ChildOutcomes`, so `review_task`'s approve on a parent additionally returns `emptyChildren` (the
+`Done` children whose review range is empty) and every task-returning tool exposes
+`TaskRefDto.roadblockCount` → [external-mcp.md](external-mcp.md) → `ReviewTask`/`PreviewMerge`.
+An empty branch is still mergeable by design (some tasks — e.g. an audit — legitimately produce
+no diff); this is a visibility fix, not a merge gate.
+
+## Cancel is blocked while a unit merge is draining
+
+`ApproveReview` on a task with children awaits `PlanningMergeOrchestrator.StartAsync` /
+`DrainAsync` synchronously — the parent sits in `WaitingForReview` for the whole (potentially
+minutes-long, one-child-at-a-time) drain. Without a guard, a concurrent `CancelReview` (UI or
+`update_task_status`/`cancel_task` via MCP) could flip the parent to `Cancelled` mid-drain while
+the orchestrator kept merging children's worktrees onto the target branch; `FinalizeParentDoneAsync`
+then finds the parent no longer `WaitingForReview` and gives up, leaving the merged children's
+diffs stranded with no rollback.
+
+`TaskStateService.CancelAsync` now rejects with a `TransitionResult` reason whenever
+`PlanningMergeOrchestrator.HasActiveMerge(taskId)` is true for the task being cancelled, before any
+DB write. Cycle note: `TaskStateService` can't take a direct constructor dependency on
+`PlanningMergeOrchestrator` (which itself depends on `ITaskStateService`), so it takes a lazily-resolved
+`Func<IActiveMergeState>` instead — same cycle-breaking shape as the existing `Func<ITaskStateService>`
+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`
+gating `CanMergeAll`. The worker-side guard remains the actual correctness fix; the button gate
+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).
+Null/blank (the default) = **no gate**, behavior bit-identical to before the feature existed.
+
+When set, `TaskMergeService` runs it via `VerifyCommandRunner` (`cmd.exe /c <command>`,
+10-minute fixed timeout, output tail-captured) in `list.WorkingDir` right after a successful
+`MergeNoFfAsync` / `ContinueMergeAsync` **and** worktree cleanup, but **before** the task is
+allowed to reach `Done`.
+
+| Outcome | Effect |
+|---|---|
+| Exit 0 | Unchanged flow — worktree `Merged`, task `Done` if it was `WaitingForReview`. |
+| Non-zero exit or timeout | The git merge is **deliberately left in place** (no auto-revert — that's a separate, unbuilt feature). The worktree is still marked `Merged` (it's already gone from disk when `removeWorktree` was requested), but the task stays out of `Done`. |
+
+On failure `MergeResult.Status` comes back `TaskMergeService.StatusVerifyFailed`
+(`"verify_failed"`) with an output excerpt in `ErrorMessage`. This flows through
+`MergeResultDto` (hub) and `ReviewTaskResult` (`review_task`) unchanged, because both already
+treat any non-`blocked`/`conflict` status generically. All three UI merge entry points handle it
+explicitly (detail-pane Approve, merge modal, worktrees batch) — a generic fallback there showed
+the raw status string instead of the failure.
+
+**Worktree-less approvals are gated too.** A task with no active `WorktreeEntity` — a sandbox run,
+or a list-handler task that commits straight into `list.WorkingDir` — skips the merge entirely,
+but `ApproveAndMergeAsync` still runs the verify command (same per-repo gate, working dir =
+`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
+produced on the target branch. Stamped by `TaskMergeService` the moment a merge/continue-merge
+succeeds, written **only** by `WorktreeRepository.SetMergedAsync` (which atomically sets
+`State=Merged` and stamps the SHA in one update).
+
+It is the only thing that makes `revert_merge` possible without heuristically searching
+`git log` — see [external-mcp.md](external-mcp.md) → `RevertMerge`. Null for any worktree
+merged before the field existed.
+
+## Review gate in the UI
+
+**Approve & Merge is gated behind opening the diff.** When there is something to inspect
+(worktree diff / merged range / children combined diff), the button stays disabled until the
+diff or combined-diff viewer has been opened once. The gate **re-locks per run** — any state
+change resets it. Tasks with nothing to inspect are never gated.
+
+The row-level quick-approve in the task list is an **intentional bypass**.
+
+Implementation: `MergeSectionViewModel` owns merge-target selection, the mergeability
+indicator (`MergePreviewPresenter` over `PreviewMergeAsync`), and `OpenDiffAsync` /
+`ReviewCombinedDiffCommand` — both build a `DiffViewerViewModel`, call `ShowDiffViewer`, and
+fire the `DiffViewed` callback. `HasReviewableDiff` reports whether anything is inspectable
+and feeds the gate.
+
+## Conflict resolver (in-app Rider-style 3-pane merge editor)
+
+`ConflictResolverViewModel` + `Views/Conflicts/ConflictResolverView`. Handles **both**
+single-task and planning unit-merge conflicts.
+
+### Model
+
+Single-task mode starts the conflict merge, then parses each conflicted file into stable and
+conflict `MergeFileSegment`s via the worker's `GetMergeConflictDocuments`. Types live in
+`ConflictModels`: `MergeFile` / `MergeFileSegment` / `MergeConflictBlock`.
+
+Exposed per active file: `ActiveOursText` / `ActiveResultText` / `ActiveTheirsText`
+(reconstructed from `MergeFile.OursText/ResultText/TheirsText`; Result seeds unresolved
+conflicts with Ours), plus `ActiveFile` / `SelectFileCommand` (multi-file switcher),
+`Current` / `Next` / `Previous` (focused-conflict nav), a per-file `PositionText` readout,
+per-block `AcceptOurs/Theirs/Both/Base` + `MergeFile.Compose`, and `CanContinue` gated on
+**every file resolved + no binary**. Each file is written via `WriteConflictResolution`.
+
+**Planning mode** via `OpenForPlanningAsync(parentId, subtaskId)` loads the current subtask's
+mid-merge conflicts **without re-starting the merge** and routes continue/abort to
+`ContinuePlanningMerge` / `AbortPlanningMerge`, so a unit-merge conflict re-opens the editor
+per subtask via the `PlanningMergeConflict` broadcast.
+
+**Except when an MCP session is driving the merge.** `PlanningMergeOrchestrator.StartAsync` takes
+an `externallyDriven` bool (default `false`; `ExternalMcpService.review_task`'s parent-with-children
+path passes `true`, since a running Claude session — not the UI — will resolve conflicts via
+`continue_merge`/`abort_merge`). The flag rides along on the `PlanningMergeConflict` broadcast
+(4th arg); `IslandsShellViewModel.OnPlanningMergeConflict` only auto-opens the resolver when it's
+`false` — otherwise it shows a persistent, non-auto-dismissing banner
+(`IsExternalMergeBannerVisible`) with a manual "Open resolver" button, cleared on
+`PlanningMergeAborted`/`PlanningCompleted`. This exists because two parties (a human and the
+driving session) could otherwise end up editing the same shared checkout at once.
+`PlanningMergeOrchestrator.GetActiveExternalConflictsAsync` (hub: `GetActiveExternalPlanningMergeConflicts`)
+re-derives this state by checking `GitService.IsMidMergeAsync` rather than trusting the in-memory
+flag alone, so a UI restart mid-merge (or a stale entry left behind if something resolved the
+repo outside the normal Continue/Abort path) can't show a phantom banner — the Ui calls it on
+`ConnectionRestoredEvent`. The childless single-task conflict path
+(`TaskMergeService.ApproveAndMergeAsync`) has no equivalent broadcast — it only sends the generic
+`TaskUpdated` — so it never auto-opened the resolver and needed no change.
+
+### View
+
+Three **AvaloniaEdit** panes showing the whole file: MAIN/ours (read-only) | editable Result |
+INCOMING/theirs (read-only). TextMate highlighting by extension (theme `StyleInclude` in
+`App.axaml`).
+
+- A code-behind `IBackgroundRenderer` tints each conflict block (unresolved/resolved) across
+  panes. Tints live in `Tokens.axaml` (`Merge*TintBrush`).
+- An `IReadOnlySectionProvider` + `TextAnchor` regions keep **only conflict spans** editable in
+  Result; edits flow back to the block.
+- Each unresolved conflict starts **EMPTY** (a thin marker bar).
+- The between-pane gutter controls **toggle** each side in/out of the result: `›`/`‹` add
+  MAIN/INCOMING in click order (first pick on top), clicking again removes that side — so a
+  conflict can take main, incoming, both, or **neither**.
+- `FilesSummary` shows how many files still have conflicts. The three panes share a
+  proportional synced vertical scroll.
+- A conflict overview ruler right of the Result pane (`ConflictMap`) maps every conflict in the
+  file proportionally; click a tick to jump. Useful for long files.
+
+### Entry points
+
+Review **Approve** on conflict, and the **Merge** button in the Diff window (a conflicting
+`MergeTask` hands off via `RequestConflictResolution`).
+
+## Hub methods
+
+- Review/merge: `ApproveReview(taskId, targetBranch) -> MergeResultDto`,
+  `ContinuePlanningMerge` / `AbortPlanningMerge`, `PreviewMerge(taskId, targetBranch) ->
+  MergePreviewDto`, `RejectReviewToQueue`, `RejectReviewToIdle`, `CancelReview`, `MergeTask`,
+  `GetMergeTargets`
+- Single-task conflict resolver: `StartConflictMerge`, `GetMergeConflictDocuments`,
+  `WriteConflictResolution`, `ContinueConflictMerge`, `AbortConflictMerge` — note the
+  service-level `TaskMergeService.ContinueMergeAsync` / `AbortMergeAsync` keep their own names.
+- Broadcast events: `PlanningMergeStarted`, `PlanningSubtaskMerged`, `PlanningMergeConflict`,
+  `PlanningMergeAborted`, `PlanningCompleted`
+
+## Diff stack (UI)
+
+`UnifiedDiffParser` (static) parses `git diff` output into `DiffFileViewModel`s, detecting
+added/deleted/renamed/binary files and per-line numbers. `DiffModels.cs` holds the shared types
+(`DiffLineViewModel`, `DiffFileViewModel`, `DiffLineKind`, `DiffFileStatus`, `SubtaskDiffRow`,
+`DiffTreeNodeViewModel`, `DiffTree`).
+
+`DiffViewerViewModel` is one unified read-only viewer with two modes:
+- **Files** — dirty worktree / branch-vs-base / commit-range. Loads via `GitService`, folder
+  file-tree left + per-file diff pane right, Merge button for a live branch source.
+- **Planning** — per-subtask diffs via `GetPlanningAggregateAsync`, subtask list left + one
+  editor per file right (`PlanningFiles`), combined integration-branch toggle.
+
+Both modes render through `DiffAlignment` (pure — pairs diff lines into side-by-side rows and
+computes word-diff spans) and `DiffTextView` (AvaloniaEdit + TextMate highlighting keyed off the
+file extension, unified/split layout, optional line wrap, synced scrolling). Files mode hosts one
+`DiffTextView` for the selected file; Planning mode hosts one per file in `PlanningFiles` so each
+gets its own grammar (one editor can only carry one TextMate grammar). The split/wrap toggles
+persist to `ui.config.json` via `AppSettings` and reach the per-file editors in Planning mode
+too.

docs/explore-notes/usage-monitoring.md

@@ -0,0 +1,259 @@
+# Usage monitoring, gate & throttle
+
+> **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
+> 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).
+
+**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
+`~/.claude/.credentials.json`. ClaudeDo reads that token, never refreshes it, never logs it.
+
+Because the endpoint is undocumented and can change without notice, **every consumer
+fails open**. That is the single most important invariant here.
+
+## Components (`Usage/`)
+
+| Type | Role |
+|---|---|
+| `UsageModels` | `UsageBucket` / `UsageLimitRow` / `UsageSnapshot`. `UsageBucket.Utilization` is already a 0–100 percent — compare directly against thresholds, don't rescale. |
+| `ClaudeOAuthUsageClient` | Reads the token, calls the endpoint. Defensive parsing: missing/null buckets → null, missing `limits` → empty list. |
+| `UsageState` | Threadsafe singleton. A failed poll **never** overwrites the last good snapshot — it only sets `LastError`. |
+| `UsageMonitorService` | `BackgroundService`; polls on `usage_poll_interval_seconds` (default 60, clamped to min 15 on config load), one poll at startup. Logs a failure at most once per distinct error message. Broadcasts `HubBroadcaster.UsageUpdated` after **every** tick, success or failure. |
+| `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` | 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`;
+plus `Usage/TokenTracker/Interfaces/ITokenTrackerClient`.
+
+## The gate (hard pause)
+
+Thresholds: `AppSettings.UsageGateFiveHourPct` / `UsageGateSevenDayPct` (defaults 80/90).
+Blocked once `five_hour >= UsageGateFiveHourPct` **or** `seven_day >= UsageGateSevenDayPct`
+(`>=`, not `>`). Threshold `0` = that bucket never gates.
+
+What it pauses: **only the queue's slot-fill loop** — new queued tasks don't start.
+Unaffected: already-running runs, `RunNow`, `ContinueTask`, interactive ConPTY sessions,
+planning sessions, daily prep (all bypass the queue).
+
+**Fail-open**: no snapshot yet, a failed last poll, or an app-settings read error all
+resolve to not-blocked.
+
+There is **no persistent pause state**. Recovery is just the queue's 30 s backstop timer
+(`queue_backstop_interval_ms`) re-evaluating the gate on its own once usage drops back
+under the threshold. A blocked↔free transition is logged and broadcast (`WorkerLog`, Warn
+on block / Info on resume) exactly **once per change**, not every tick.
+
+## The throttle (staged parallelism)
+
+`UsageThrottle.EffectiveSlots(configuredSlots, fiveHourPct, fiveHourThresholds, sevenDayPct,
+sevenDayThresholds)` — pure static, no state. `UsageThresholds(SoftPct, HardPct, GatePct)` is the
+per-bucket triple (same file).
+
+Thresholds are **per bucket** (`usage_throttle_five_hour_{soft,hard}_pct` /
+`usage_throttle_seven_day_{soft,hard}_pct`, defaults 50/65 each) because the 5h and 7d windows fill
+at very different rates. Each bucket is staged independently and the **strictest** bucket wins —
+not "whichever is more utilized", so a bucket that is lower but tightly configured can be the one
+that throttles:
+
+| Utilization (per bucket) | That bucket's slots |
+|---|---|
+| below soft | full configured `max_parallel_executions` |
+| `>= softPct` | capped at 2 |
+| `>= hardPct` | capped at 1 |
+| `>= gatePct` | 0 — same hard block as `UsageGate` |
+
+A threshold of `0` disables that stage for that bucket, and a bucket with no reading (null) never
+throttles. The `0` return is deliberately kept in sync with `UsageGate`'s hard block because both
+read the same gate thresholds — change one, change both.
+
+Only **new** slot fills are affected; a run already occupying a slot when the stage tightens
+runs to completion. Same fail-open policy: no snapshot means no throttling.
+
+The effective stage (configured vs. effective slots + the decisive bucket, `ThrottleBucket`
+= `"five_hour"` / `"seven_day"`) rides along on `UsageSnapshotDto` purely for UI display.
+It does **not** change what the gate gates on.
+
+## Queue integration (`Queue/QueueService`)
+
+Per loop tick:
+
+1. `GetEffectiveMaxParallelAsync` reads `AppSettings.MaxParallelExecutions` and steps it
+   down via `UsageThrottle.EffectiveSlots` against the current `UsageState` snapshot.
+   A missing/failed snapshot fails open to the configured value. A **stage change** (not
+   every tick) logs once.
+2. Separately, `IUsageGate.EvaluateAsync` — if blocked, the slot-fill loop is skipped
+   entirely for that tick.
+
+## Per-run token accounting
+
+`task_runs` stores four raw token fields: `tokens_in` / `tokens_out` /
+`cache_read_tokens` / `cache_write_tokens`.
+
+These are **not** read from the stream-json `result` event's `usage.input_tokens` — that is
+only the uncached remainder of a single API call and undercounts the real prompt size by
+orders of magnitude once caching kicks in.
+
+Instead `TaskRunner.ApplyUsageAsync` calls
+`ITranscriptUsageReader.ReadSessionTotalsAsync(sessionId)` — the session transcript's
+cumulative raw totals across every assistant message, located by `{sessionId}.jsonl` — and
+stores the **delta** against prior `task_runs` rows sharing the same `session_id`, so a
+`--resume`'d run doesn't double-count turns already billed to an earlier run.
+
+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
+
+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.
+
+There is no history-wide `ReadAsync` any more; `WorkerConfig` is still a constructor parameter
+purely so the DI registration and call sites stayed untouched.
+
+## 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
+
+- **`UsagePillViewModel`** — one shared instance backs the `UsagePill` control in both the
+  footer and the Mission Control header. Loads via `GetUsageSnapshotAsync`, updates live off
+  `IWorkerClient.UsageUpdatedEvent`. Dot state priority is mutually exclusive:
+  **blocked > stale > warn > normal**. `IsThrottled` (effective slots below configured, and
+  not gate-blocked) adds a tooltip line naming effective/configured slots + decisive bucket.
+  The pill's click handler (`IslandsShellViewModel.OpenUsageMonitor`) **shows the window before
+  loading** (`BeginLoad`) — awaiting the load first made the pill feel like a dead click, because
+  the first `GetModelUsage` per worker process scans the whole transcript history.
+- **Draggable stage markers** — each of the two real gauges carries three markers (soft/hard/gate).
+  `UsageGaugeBar` (`Views/Controls`) draws them against its own width and does the pointer work;
+  the math is a pure static, `UsageThresholdDrag` (in the modal VM's file), which keeps
+  soft ≤ hard ≤ gate and treats a neighbour of `0` as off. Release fires the row's
+  `CommitCommand` → read-modify-write via `GetAppSettings` + `UpdateAppSettings`, so only the
+  dragged bucket's three fields change. Plan-dependent `weekly_scoped` gauges are read-only.
+- **Legend = numeric editor.** Under each adjustable bar sit three legend rows whose colour swatches
+  match the markers (soft `TextDimBrush`, hard `StatusReviewBrush`, gate `StatusErrorBrush`), each
+  with a `NumericUpDown`. `NumericUpDown` has no commit command, so the box's `Tag`
+  (`soft`/`hard`/`gate`) plus two code-behind handlers (`LostFocus`, Enter) call the row's
+  `CommitSoft`/`CommitHard`/`CommitGate` command. Those run the typed value through the **same**
+  `UsageThresholdDrag.Apply` clamp as a drag, so a box can't invert the order and only the edited
+  stage moves. ⚠️ The `KeepLastNumber` converter is mandatory on those bindings — see the
+  `NumericUpDown` null gotcha in `src/ClaudeDo.Ui/CLAUDE.md`.
+  Rows are updated **in place** on each snapshot (keyed by limit kind) so a poll landing mid-drag
+  doesn't replace the bound instance.
+- **`UsageMonitorModalViewModel`** — opened from the pill. Renders one gauge **per row** in
+  `UsageSnapshotDto.Limits` — deliberately **dynamic**, because the `seven_day_opus` /
+  `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 — 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)` — 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
+
+`app_settings`: `usage_gate_five_hour_pct` / `usage_gate_seven_day_pct` (80/90),
+`usage_throttle_five_hour_{soft,hard}_pct` / `usage_throttle_seven_day_{soft,hard}_pct` (50/65 per
+bucket). All six clamped 0..100 by `AppSettingsRepository.UpdateAsync`, which does **not** enforce
+soft ≤ hard ≤ gate — the ordering is a UI-side drag constraint, and an out-of-order stored config
+degrades instead of throwing. Worker config: `usage_poll_interval_active_seconds` /
+`usage_poll_interval_idle_seconds`.
+
+The gate percentages are editable in **two** places that both write the same `app_settings` row:
+Settings → General (typed) and the usage-monitor gauges (dragged). The throttle stages are
+gauge-only — `SettingsModalViewModel` therefore carries them load→save verbatim so saving Settings
+can't reset a dragged value.

docs/explore-notes/worker-task-pipeline.md

@@ -1,6 +1,6 @@
 > **Explore-note — verify before trusting.** Distilled map of a subsystem, not authoritative.
-> Last verified against commit `896d4b5` (2026-07-23).
-> Drift check: `git log --oneline 896d4b5..HEAD -- src/ClaudeDo.Worker`
+> Last verified against commit `cc90600` (2026-08-06).
+> Drift check: `git log --oneline cc90600..HEAD -- src/ClaudeDo.Worker`
 > Stable structure only (no line numbers). See docs/explore-notes/README.md.
 
 # Worker: Task Execution Pipeline
@@ -28,9 +28,11 @@ How a task moves Queued → Running → terminal, across `src/ClaudeDo.Worker`
 
 5. **Run Preparation** — `TaskRunner.RunAsync()` (Runner/TaskRunner.cs)
    - Loads task, list config, subtasks, attachments from the DB.
+   - `StartRunningAsync()` (only if not pre-claimed): atomic claim to Running, **before any
+     resource is created**. A rejected claim (task already Running) bails out immediately —
+     no worktree, no MCP token file. Broadcasts TaskStarted.
    - `PrepareRunDirectoryAsync()`: worktree (via WorktreeManager) if the list has a WorkingDir,
      else sandbox. Generates a per-run MCP token, writes MCP config to disk.
-   - `StartRunningAsync()` (only if not pre-claimed): atomic Queued → Running. Broadcasts TaskStarted.
 
 6. **Claude Execution** — `TaskRunner.RunOnceAsync()` (Runner/TaskRunner.cs)
    - Creates a TaskRunEntity, points the task at the run's log path.
@@ -50,9 +52,47 @@ How a task moves Queued → Running → terminal, across `src/ClaudeDo.Worker`
    - **Done** CompleteAsync (Running → Done) — top-level success.
    - **WaitingForReview** SubmitForReviewAsync (Running → WaitingForReview) — review gate.
    - **WaitingForChildren** SubmitForChildrenAsync (Running → WaitingForChildren) — blocks on children.
+     Advances to WaitingForReview via `TryAdvanceParentAsync` once every remaining child is
+     terminal (Done/Failed/Cancelled) — including zero children left, e.g. after the last child
+     is deleted (`WorkerHub.DeleteTask` / `ExternalMcpService.DeleteTask` both call it).
    - **Failed** FailAsync (Running/Queued → Failed).
    - **Cancelled** CancelAsync (Running/Queued/WaitingForReview/WaitingForChildren → Cancelled).
 
+## Model, effort & max-turns resolution
+
+*(section added at commit `f6cb825`, 2026-08-05; resolver extraction added same day)*
+
+The resolution below lives in `Runner/EffectiveRunConfigResolver.Resolve` (not inlined in
+`TaskRunner` anymore) so `TaskRunner.ResolveConfigAsync` and the read-only
+`get_effective_run_config` MCP tool (`External/ConfigMcpTools.cs`) share one codepath and can't
+report different numbers for the same task. The tool additionally surfaces, per field, whether
+it came from the task/list/preset/global layer, and — for max turns — the raw requested value
+plus whether it was clamped.
+
+Step 6 builds the CLI args. Model and turn budget resolve like this:
+
+1. **Effective model** — task override → list config → `AppSettings.DefaultModel`.
+2. **Preset row** — `ModelPresets.For(global.ModelPresets, model, global.DefaultMaxTurns)`.
+   The model string is resolved through `ModelRegistry.TryNormalizeAlias` **first**, so a full
+   CLI model id (e.g. `claude-sonnet-4-6`, not just the bare `sonnet`/`opus`/`haiku`/`fable`
+   aliases) still hits its alias's preset row instead of missing every lookup. Only a model
+   that normalizes to nothing recognized falls back to a synthesized row using
+   `AppSettings.DefaultMaxTurns` — **never a hardcoded number, and it never throws**: an
+   unknown model must not block a run.
+3. The preset supplies `--effort` and the **global** max-turns default. Task/list `MaxTurns`
+   overrides still win over it.
+4. **Ceiling clamp** — `TaskRunner.ResolveMaxTurns` hard-clamps the resolved value to
+   `AppSettings.MaxTurnsCeiling` (default 80). An override above the ceiling still starts, just
+   capped, and a Warn logs the task id + requested + effective value.
+
+⚠️ **Trap:** if `app_settings.model_presets` is somehow null, the fallback path decides the turn
+budget — which is why `AppSettingsRepository.GetAsync` backfills shipping defaults on the first
+read after null. Ship preset turns are low (haiku 20, sonnet 30, opus 40, fable 25), so a task
+that genuinely needs a long run must set its own `MaxTurns`.
+
+Prompt composition: `TaskPromptComposer.Compose` injects attachment **absolute paths** as a
+read-only "## Reference files" section.
+
 ## Component Responsibilities
 
 **Queue/**
@@ -73,14 +113,18 @@ How a task moves Queued → Running → terminal, across `src/ClaudeDo.Worker`
 - `TaskStateService` — all task status transitions; guards preconditions; signals queue/hub.
 
 **Lifecycle/** (startup recovery)
-- `StaleTaskRecovery` — tasks stuck Running after a crash/restart → Failed.
+- `StaleTaskRecovery` — tasks stuck Running after a crash/restart → Failed. The underlying
+  `TaskStateService.RecoverStaleRunningAsync` bulk-flips Running→Failed, then re-runs the same
+  chain/parent-advance side effects as a normal `FailAsync` (per recovered id, best-effort) so a
+  crash mid-chain-child or mid-improvement-child doesn't leave a successor blocked forever or a
+  `WaitingForChildren` parent wedged.
 - `OrphanRecovery` — dequeues children whose parent is no longer planning (stays attached).
 - `AttachmentOrphanRecovery` — cleans orphaned attachment files.
 - `TaskResetService` — manual reset to Idle.
 - `TaskMergeService` — conflict resolution for worktree merges.
 
 **Hub/**
-- `HubBroadcaster` — single SignalR broadcast point (TaskStarted/TaskUpdated/TaskMessage/RunCreated…).
+- `HubBroadcaster` — single SignalR broadcast point (TaskStarted/TaskUpdated/TaskMessage/WorktreeUpdated…).
 - `WorkerHub` — SignalR hub + client methods.
 
 **Agents/**
@@ -113,6 +157,15 @@ Program.cs (DI setup)
 - **Slot limit** — respects MaxParallelExecutions; a backstop timer wakes even if a Wake() is missed.
 - **Pre-claimed tasks** — the dispatcher pre-claims via the picker; the override slot
   (RunNow/ContinueTask) must call StartRunningAsync if a task is not pre-claimed.
+- **Claim before create** — `TaskRunner.RunAsync`'s unclaimed path calls `StartRunningAsync`
+  *before* `PrepareRunDirectoryAsync`. RunNow racing the picker for the same Queued row used to
+  create the worktree first and only claim afterwards, so the losing dispatch could hit
+  WorktreeManager's branch-collision self-heal and force-remove the winner's live worktree
+  mid-run. `OverrideSlotService.RunNow` also fast-rejects a task already Running in the DB
+  (defense in depth; the picker's atomic SQL claim is the real arbiter either way).
+  `RunCancellationRegistry.Register` refuses (and logs) a second registration for the same task
+  id instead of silently overwriting the first, so a losing dispatch's cleanup can't unregister
+  the winner's CTS out from under it.
 - **Terminal writes** — use `CancellationToken.None`; a task is never left Running after crash/cancel.
 - **Per-run MCP tokens** — each run gets a unique token scoping tool access; unregistered on end.
 - **Auto-retry** — one automatic retry if a session exists and the first run failed.

docs/open.md

@@ -1,53 +1,38 @@
 # ClaudeDo — Offene Punkte
 
-Stand: 2026-07-24. Diese Datei listet die **aktiv verifizierten Findings** aus der Verifikations-Session vom 2026-07-24. Die laufende Verifikations-Checkliste (Pass/Fail je Abschnitt, inkl. noch offener Abschnitte §7–§11 und Kanten) lebt in `docs/verification-handoff.md`. Erledigtes steht in den Commits/im Code, nicht hier.
+Stand: 2026-08-06. Der Findings-Block von 2026-07-24 wurde am 2026-08-06 **gegen den Code
+nachverifiziert** (statisch, nicht in der laufenden App); alles, was inzwischen gefixt ist, ist
+hier entfernt — Erledigtes steht in den Commits/im Code, nicht hier. Die alte Verifikations-
+Checkliste lebt in `docs/verification-handoff.md`.
 
 ---
 
-## Bugs (verifiziert 2026-07-24)
+## Bugs (offen)
 
-- **OUTCOME-Karte rendert rohes Structured-Output-JSON:** `TaskMonitorViewModel.ApplyOutcome` (ClaudeDo.Ui) setzt bei Tasks ohne Roadblock-Marker `SessionOutcome = result` wörtlich (Zeile ~261). Der Worker legt in `task.Result` das rohe `{"summary":…,"files_changed":[…]}` ab (die lesbare Fassung steht in `task_runs.resultMarkdown`), also zeigt die Detail-Insel OUTCOME als JSON-Blob statt als Text. Fix: (a) UI parst ein JSON-Result und zeigt `summary`, oder (b) Worker schreibt `summary`/`resultMarkdown` statt des JSON in `task.Result`. Verifiziert am Task `verif §1 diff matrix`. Deckt sich mit Memory `worker_testing_findings`.
-- **Approve & Merge schluckt einen „blocked"-Merge still:** `DetailsIslandViewModel.ApproveReviewAsync` reagiert nur auf `result.Status == "conflict"` (öffnet den Resolver); bei `"blocked"` (z.B. Ziel-Working-Tree hat uncommittete getrackte Änderungen) und anderen Nicht-`merged`/Nicht-`conflict`-Status passiert **nichts** — kein Footer-Fehler, kein Dialog (der `catch` greift nur bei Exceptions, „blocked" ist aber ein normaler Rückgabewert mit `ErrorMessage`). User sieht „Klick tut nichts". Doppelt verifiziert (Konflikt-Approve UND sauberer additiver Approve `verif §1b`, beide bei dirty `main`-Checkout still). Fix: bei `blocked`/unerwartetem Status `result.ErrorMessage` via `ShowErrorAsync`/`FlashFooterError` surfacen. Verstößt gegen `feedback_ui_error_surfacing`. (Der Konflikt-Resolver + 3-Pane-Editor funktionieren, sobald der Ziel-Tree sauber ist.)
-- **„Waiting for Improvements" für Planning-Parents (Terminologie):** `taskStatus.waitingForChildren` = „Waiting for Improvements" (en.json:504), `agentStatus.children` dito (503), `childOutcomesLabel` = „IMPROVEMENTS" (191). Seit dem unified-parent-Modell gilt `WaitingForChildren` für Planning **und** Improvement-Parents — „Improvements" ist für einen Planning-Parent falsch. Auf neutrales „Waiting for Subtasks"/„Subtasks" umstellen (en **und** de — Localization.Tests-Parität). Verifiziert §3.
-- **Kind-Rows aktualisieren nach Parent-Planning-Transitionen nicht live:** Parent-getriebene Änderungen propagieren nicht auf die Kind-`TaskRowViewModel`s ohne Listen-Reload. (a) Nach „Finalize planning" bleiben Kind-Rows auf „Draft" (`IsDraft`) statt „Planned" (`IsPlanned`) — der geänderte `ParentFinalized` kommt nicht über das Parent-`TaskUpdated`-Broadcast an. (b) Nach „Discard" bleiben die (in der DB gelöschten) Draft-Kind-Rows sichtbar, bis die Liste neu geladen wird. Gemeinsame Ursache: die Kinderliste/-zustände werden bei Parent-Transitionen nicht live neu aufgelöst. Doppelt verifiziert §3 (Finalize **und** Discard, 2026-07-24).
-- **AskUser-Frage erscheint NUR in Mission Control, nicht in der Task-Detail-Insel:** Der `ask_user`-Banner (Frage + Antwort-Eingabe) lebt ausschließlich in `MonitorPaneView` (Mission Control). Die Detail-Insel (`DetailsIslandView`) streamt zwar den Live-Log eines laufenden Tasks, zeigt aber **kein** Frage-Banner — ein Nutzer, der nur die Detailansicht offen hat, sieht nicht, dass der Run auf eine Antwort wartet, und läuft nach 3 min in den Timeout-Fallback. Verifiziert §7 (User schaute Detailansicht, Frage war unsichtbar; erst in Mission Control sichtbar). Fix: Frage-Banner + Inline-Antwort auch in der Detail-Insel für den gebundenen laufenden Task surfacen (VM-Zustand liegt bereits in `TaskMonitorViewModel`, müsste für die Detail-Insel repliziert/geteilt werden). **Von Mika bei der §7-Verifikation ausdrücklich gewünscht** („vermisse diese Interaktion in der Detail-Ansicht"). §7.
-- **„New session"-Button (Mission Control) unsichtbar — Icon.Plus ist Strich-Only:** `Icon.Plus` = `M12 5v14M5 12h14` (IslandStyles.axaml:61) ist reine Linien-Geometrie ohne Fläche; im `<PathIcon>` (MissionControlView.axaml:38, füllt Geometrie) rendert sie **unsichtbar** → der Ad-hoc-„New session"-Button erscheint leer und ist nicht auffindbar (Feature + VM `OpenAdHocConPtySessionAsync` + Tests funktionieren, nur das Icon fehlt sichtbar). Fix: Icon.Plus als gefüllte Geometrie authoren ODER als gestricheltes `Path` rendern (Icon-Gotcha in CLAUDE.md). **Andere `Icon.Plus`-Verwendungen mitprüfen.** Verifiziert §5.
+- **Verwaiste git-Worktrees sind für die App unsichtbar** (gefunden 2026-08-06). In `C:\Private\ClaudeDo` waren nach dem Cleanup 22 git-registrierte Worktrees + 26 `claudedo/*`-Branches vorhanden, die ClaudeDo-DB kannte davon nur zwei. Die Worktrees-Übersicht listet ausschließlich Zeilen aus `worktrees`, also kann der Nutzer diese Reste nicht über die App entfernen — und es gibt keinen Sweep dafür (`OrphanRecovery` räumt nur Task-Zeilen auf, keine Worktrees). Wunsch: entweder ein Startup-Abgleich `git worktree list` ↔ DB, der Unbekannte als „untracked" in die Übersicht aufnimmt, oder mindestens eine Warnung mit Anzahl.
 
-## UX / Nits (verifiziert 2026-07-24)
+## UX / Nits (offen)
 
-- **„Resume planning session" ist grundsätzlich kaputt (Session-Id wird nie erfasst) + Fehler wird verschluckt:** Im UnfinishedPlanning-Modal macht **Resume** nichts. Ursache: `PlanningSessionManager.ResumeAsync` (PlanningSessionManager.cs:238) bricht mit `InvalidOperationException("No Claude session ID captured yet; cannot resume.")` ab, wenn `task.PlanningSessionId` leer ist — und der Setter `TaskRepository.UpdatePlanningSessionIdAsync` (TaskRepository.cs:322) hat **keinen einzigen Aufrufer** im Worker, d.h. `planning_session_id` wird nie befüllt (verifiziert an `verif §3 resume-discard`: `planning_session_id=NULL`, Token gesetzt, Drafts angelegt). Resume kann also **nie** erfolgreich sein. Zusätzlich verschluckt `TasksIslandViewModel.ResumePlanningSessionAsync` den ganzen Block in einem leeren `catch { }` (~Zeile 870) → der Button ist ein **stummer No-op**, kein Footer-Fehler, kein Dialog (verstößt gegen `feedback_ui_error_surfacing`). Hintergrund: die wt-Planning-Session ist interaktiv; ClaudeDo erfasst die claude-Session-Id dort nicht (analog zur bewusst nicht persistierten ConPTY-Session-Id, §5). Fix-Optionen: (a) beim Planning-Start/-Lauf die claude-Session-Id erfassen und via `UpdatePlanningSessionIdAsync` persistieren, damit Resume echt resumen kann; ODER (b) Resume entfernen/deaktivieren, wenn keine Session-Id vorliegt; in JEDEM Fall den Fehler statt des leeren `catch` surfacen. Verifiziert §3. §3.
-- **Attachments: erster Drag&Drop der Session schlug einmalig fehl („An error occurred"):** Beim allerersten Drop-to-attach einer UI-Session zeigte die `DropStatus`-Zeile inline einen generischen Fehler und es wurde nichts persistiert (kein File, keine DB-Row); alle folgenden Drops derselben Session + der „Add file…"-Picker + Remove funktionierten fehlerfrei. Nicht reproduzierbar nach dem ersten Mal (App-Neustart nötig, um die „erster-Drop"-Bedingung wiederherzustellen). Kandidaten: transiente SQLite-Contention (der UI-Prozess schreibt `todo.db` direkt via `new TaskAttachmentRepository`, während der Worker dieselbe DB hält) ODER ein Fehler im Drop-Stream-Pfad (`IStorageFile.OpenReadAsync` im Code-Behind, außerhalb des `try` in `AddFilesAsync`). Falls es erneut auftritt: `AddFilesAsync`/`OnDrop` mit robusterem Error-Logging versehen (die genaue Exception-Message fehlt, weil `DropStatus` nur `{fileName}: {ex.Message}` zeigt). Verifiziert §9 (einmalig beobachtet). §9.
-- **Agent-Settings-Gear weicht vom übrigen Settings-Icon ab:** Der Agent-Settings-Flyout-Button (`TaskHeaderBar.axaml:68`) rendert ein Unicode-Glyph `⚙` (`<TextBlock Text="⚙">`), während die Listen-Nav (`ListsIslandView.axaml:56`) und die Listen-Settings (`TasksIslandView.axaml:47`) das gefüllte `Icon.Settings`-PathIcon (Gear-StreamGeometry, IslandStyles.axaml:110) nutzen → optisch ein anderes Zahnrad. Angleichen: den `⚙`-TextBlock durch `<PathIcon Data="{StaticResource Icon.Settings}" .../>` ersetzen. Verifiziert §8 (User-Sichtprüfung). §8.
-- **Session-Skills-Tab hat keinen Empty-State:** Bei 0 installierten Skills zeigt der Skills-Tab (Settings) nur eine nackte leere Fläche unter der Install-Zeile — kein erklärender Hinweis (z.B. „Noch keine Skills installiert — GitHub-URL oben einfügen"). Verifiziert §8 (frischer Zustand vor ponytail-Install). Kleiner Empty-State-Text ergänzen.
+- **Planning-aktiver Parent zeigt weiter „Idle":** Parent in `planning_phase=active` hat `Status=Idle` (korrekt im Modell), aber `TaskRowViewModel.StatusLabel` (Zeile 132) kennt nur `HasInteractiveSession`/`IsParked` als Overrides — der `PlanningBadge` ersetzt den Chip nicht sichtbar → liest sich wie ein normaler Idle-Task. Wunsch: klarer „Planning/Draft aktiv"-Zustand, der Idle überschreibt. (Kinder zeigen korrekt „Draft".)
+- **Blocked-by-Kette nicht sichtbar:** Nach Finalize ist die sequentielle Kette korrekt gesetzt (child[i] blocked-by child[i-1]), aber die UI stellt Reihenfolge/Abhängigkeit nicht dar — es gibt nur den „waiting"-Chip. Wunsch: Kette visualisieren (z.B. „wartet auf <Vorgänger>").
+- **Dequeue-„X" fehlt auf wartenden (blockierten) Kettengliedern:** `CanRemoveFromQueue = IsQueued || HasQueuedSubtasks` (TaskRowViewModel.cs:99), `IsQueued` verlangt leeres `blocked_by`. Ein gequeuetes, aber blockiertes Kind (`IsWaiting`) bekommt daher kein Remove-from-queue-X — nur Parent + erstes (entsperrtes) Kind.
+- **Session-Skills-Tab hat keinen Empty-State:** Bei 0 installierten Skills zeigt der Skills-Tab (Settings) nur eine nackte leere Fläche unter der Install-Zeile — kein erklärender Hinweis (z.B. „Noch keine Skills installiert — GitHub-URL oben einfügen"). Im `sessionSkillsTab`-Locale-Namespace (en.json:674) gibt es keinen `empty`-Key.
+- **Modal-Bodies sind unten abgeschnitten** (Sichtprüfung 2026-08-06, beobachtet in den Listen-Settings: der Hinweistext unter „Verify command" ist mitten in der Zeile vom Footer weggeschnitten und lässt sich nicht herunterscrollen; laut Mika „fast überall" in den Settings-Modals). Gemeinsames Muster: `<ScrollViewer Padding="20,16">` als Modal-Body — in `ListSettingsModalView:36`, `MergeModalView:33`, `WorktreesOverviewModalView:131`, `AboutModalView:20`, `MergeHelperSelectionModal:47`, `RepoImportModalView:45`, `LogVisualizerView:45` sowie `WorkConsole:295/395`. **Vermutete** Ursache (nicht verifiziert): das untere `Padding` des ScrollViewers zählt nicht zum scrollbaren Extent, die letzten Pixel sind also unerreichbar. Erst am echten Fall nachmessen, dann ggf. einheitlich das Padding vom ScrollViewer auf ein `Margin` des inneren Inhalts umziehen.
+- **Usage-Monitor-Modal: Analyse-Tabellen ausbaufähig** (Sichtprüfung 2026-08-06; Gauges, Info-Bänder, Presets/Custom-Range und Refresh-Button sind in Ordnung). Models-Tab: die Spaltenköpfe „OTHER CACHE" und „SHARE" kollidieren zu `OTHER CACHISHARE`; `claude-haiku-4-5-20251001` läuft in die IN-Spalte; alle Zahlen linksbündig und ohne Tausendertrenner (`506830708`). Tasks-Tab: Task-Titel wird ohne Ellipse hart an der LIST-Spalte abgeschnitten, der LIST-Text ebenfalls; MODEL ist bei Runs von vor der `task_runs.model`-Spalte leer (besser „—"). Wunsch: Zahlen rechtsbündig + `#,##0` (oder k/M), Spaltenbreiten/Truncation fixen.
+- **Conflict-Resolver: mehrere Konfliktdateien schlecht erkennbar:** Beim 2-Datei-Konflikt schwer zu sehen, dass zwei Dateien betroffen sind (File-Switcher/Anzahl zu unauffällig). Prominentere Datei-Liste / „x von y Dateien".
+- **Attachments: erster Drag&Drop der Session schlug einmalig fehl („An error occurred"):** Beim allerersten Drop-to-attach einer UI-Session zeigte die `DropStatus`-Zeile inline einen generischen Fehler und es wurde nichts persistiert (kein File, keine DB-Row); alle folgenden Drops derselben Session + der „Add file…"-Picker + Remove funktionierten fehlerfrei. Nicht reproduzierbar nach dem ersten Mal. Kandidaten: transiente SQLite-Contention (der UI-Prozess schreibt `todo.db` direkt via `new TaskAttachmentRepository`, während der Worker dieselbe DB hält) ODER ein Fehler im Drop-Stream-Pfad (`IStorageFile.OpenReadAsync` im Code-Behind, außerhalb des `try` in `AddFilesAsync`). Falls es erneut auftritt: `AddFilesAsync`/`OnDrop` mit robusterem Error-Logging versehen.
 
-- **Diff-Viewer: reiner Rename schwach dargestellt:** Rename korrekt erkannt (`UnifiedDiffParser` → `DiffFileStatus.Renamed`, Badge `StatusCode="R"`), aber der File-Tree zeigt nur den neuen Namen + „+0 −0" ohne „alt → neu"-Pfad; liest sich wie „keine Änderung". Optional: alten Pfad + „renamed"-Label anzeigen. §1.
-- **Header-TurnsText zeigt `0/max` für abgeschlossene Runs:** `TurnsText => {Turns}/{EffectiveMaxTurns}` — `Turns` wird beim Laden eines terminalen Tasks nicht aus `task_runs.turnCount` restauriert (nur live gefüllt). Kosmetisch. §1.
-- **Conflict-Resolver: Continue/Merge-Button klickbar trotz offener Konflikte:** Gate greift funktional (merged erst wenn alle Konflikte in allen Dateien gelöst), aber der Button ist nicht disabled/gegraut → früher Klick ist ein stummer No-op. Besser: disabled bis `AllResolved`, oder Hinweis „N Konflikte in M Dateien offen". §4.
-- **Conflict-Resolver: mehrere Konfliktdateien schlecht erkennbar:** Beim 2-Datei-Konflikt schwer zu sehen, dass zwei Dateien betroffen sind (File-Switcher/Anzahl zu unauffällig). Prominentere Datei-Liste / „x von y Dateien". §4.
-- **Planning-aktiver Parent zeigt weiter „Idle":** Parent in `planning_phase=active` hat `Status=Idle` (korrekt im Modell), aber der Row-Status-Chip zeigt „Idle"; der `PlanningBadge` ersetzt das nicht sichtbar → liest sich wie ein normaler Idle-Task. Wunsch: klarer „Planning/Draft aktiv"-Zustand, der Idle überschreibt. (Kinder zeigen korrekt „Draft".) §3.
-- **Blocked-by-Kette nicht sichtbar:** Nach Finalize ist die sequentielle Kette korrekt gesetzt (child[i] blocked-by child[i-1]), aber die UI stellt die Reihenfolge/Abhängigkeit nicht dar. Wunsch: Kette visualisieren (z.B. „wartet auf <Vorgänger>"), nicht nur der „waiting"-Chip nach dem Queueen. §3.
-- **Dequeue-„X" fehlt auf wartenden (blockierten) Kettengliedern:** `CanRemoveFromQueue = IsQueued || HasQueuedSubtasks`, `IsQueued` verlangt leeres `blocked_by`. Ein gequeuetes, aber blockiertes Kind (`IsWaiting`) bekommt daher kein Remove-from-queue-X — nur Parent + erstes (entsperrtes) Kind. §3.
-- **„Open ConPTY session" erneut = Prompt wird neu gesendet, kein Resume:** Da die ConPTY-Session-Id bewusst nicht persistiert wird, startet ein erneutes „Open ConPTY session" auf demselben Task eine frische Session und sendet den Task-Prompt erneut (re-runt die Arbeit im selben Worktree) statt zu resumen. So designt, aber UX-Falle — evtl. „Resume"-Affordance oder Re-Open-Warnung. §5.
+## Feature-Wünsche
 
-## Feature-Wünsche (aus der Session)
+- **Conflict-Resolver: farbliches Hervorheben eingefügter Zeilen im Result-Pane** (grüner „flow" der übernommenen Zeilen).
+- **Die Handler-Session soll „Submit for review" selbst auslösen können** (Sichtprüfung 2026-08-06). Aktuell ist der Abschluss eines List-Handler-Laufs ein reiner Handgriff über die Schaltfläche in der Mission-Control-Kachel — die Session selbst hat kein Werkzeug dafür, obwohl sie am besten weiß, wann sie fertig ist. Wunsch: ein MCP-Tool auf der In-Task-Oberfläche, das denselben Pfad wie der Button nimmt.
+- **Handoff-Kachel besser beschriften** (Sichtprüfung 2026-08-06). Die zweite Kachel heißt `Merge Helper — <Liste> (Handoff)` bzw. „(Übergabe)" (`missionControl.mergeHelperHandoffTitleSuffix`, en.json/de.json:297). „Handoff" ist internes Vokabular und sagt nicht, was die Session tut. Besser etwas, das die Rolle nennt (Ausführen + Mergen der verbliebenen Tasks, Phasen 3-5).
 
-- **Conflict-Resolver: farbliches Hervorheben eingefügter Zeilen im Result-Pane** (grüner „flow" der übernommenen Zeilen). §4.
-- Als ClaudeDo-Tasks in Liste „Claude do" erfasst: **Approve erzwingt Diff/Review vor Merge** (koppelt den blocked-Merge-Silent-Fail-Fix) und **interaktive Planning-Session über embedded ConPTY statt externem wt-Fenster** (koppelt den Planning-Permission-Prompt).
+## Design-Entscheidungen (27.07.-Batch, Sichtprüfung am 2026-08-06 abgeschlossen)
 
-## Sichtprüfung offen (2026-07-27, Batch „Claude do"-Liste)
-
-Alles gebaut + unit-getestet, aber **nicht visuell verifiziert** — Mika prüft:
-
-- **Ctrl+K fokussiert die Suche, `#` ist wieder tippbar** (Binding war `OemQuestion` = `#` auf DE-Layout).
-- **Titel-Edit in der Detail-Insel persistiert** (400 ms debounced, wie die Beschreibung); Row-Titel + Merge-Kontext ziehen mit.
-- **Spinner beim ConPTY-Start:** Tile erscheint sofort mit „Sitzung wird gestartet…" und deckt Launch-Spec-Roundtrip + Spawn ab. **Nicht** abgedeckt: die Sekunden, die die claude-TUI danach zum ersten Frame braucht (dafür bräuchte es einen Hook auf `TerminalControl.DataReceived`). Bei Launch-Fehler bleibt das Tile jetzt mit Inline-Banner stehen statt zu verschwinden.
-- **Spinner beim Refine** ersetzt den Refine-Button in der Row, solange der Run läuft.
-- **Interactive-Chip** statt „Parked" auf Tasks mit offener ConPTY-Session; Klick öffnet Mission Control und fokussiert die Pane. Accent-Tint (bewusst dieselbe „live"-Familie wie Running, klar unterschieden vom slate-blauen Parked).
-- **Diff-Viewer:** rechter Abstand der `+n −n`-Zahlen im File-Tree.
-- **Manual-Tasks:** MANUAL-Badge, Kontextmenü-Toggle, Listen-Checkbox „Manuelle Liste"; Queue/Refine/Planning ausgeblendet, ConPTY bleibt.
-- **Settings → Allgemein:** Tabelle „Vorgaben pro Modell" (Effort + Max. Durchläufe je haiku/sonnet/opus/fable). Ersetzt das einzelne globale „Max. Durchläufe"-Feld.
-
-Offene Entscheidungen dazu:
+Der Sichtprüfungs-Block dieses Batches (Ctrl+K/`#`, Titel-Edit, ConPTY-/Refine-Spinner,
+Interactive-Chip, Diff-Viewer-Abstände, Manual-Tasks, Vorgaben-pro-Modell-Tabelle) ist von Mika
+verifiziert und deshalb hier entfernt. Es bleiben die Entscheidungen, die daran hängen:
 
 - Interaktive ConPTY-Sessions bekommen `--effort`, aber **kein** `--model` — die Session läuft weiter unter dem Modell aus Mikas Claude-Config, der Effort kommt aus dem Preset des Modells, das ClaudeDo für die Task auflösen würde. Falls ClaudeDo auch interaktiv das Modell erzwingen soll, ist das ein Folge-Task.
 - `AppSettings.DefaultMaxTurns` ist jetzt tatsächlich verdrahtet (`ModelPresets.For(..., global.DefaultMaxTurns)` in `TaskRunner.ResolveConfigAsync`): reiner Fallback für ein Modell, das auch nach `ModelRegistry.TryNormalizeAlias` auf keine Preset-Zeile trifft — vorher war das Feld tot (hartkodierte 30). Hat weiterhin keinen eigenen Editor mehr (nur die Preset-Tabelle pro Modell); Spalte könnte später entfallen, falls das nie zutrifft.
@@ -55,34 +40,66 @@ Offene Entscheidungen dazu:
 ## Beobachtung (offen — Entscheidung Mika)
 
 - **`--permission-mode auto` + Modell `haiku` → Writes werden denied:** Kontrolliert verifiziert (CLI 2.1.207): unter dem Default-Mode `auto` bekommt **sonnet** Writes auto-approved (`permission_denials:[]`), **haiku** wird `denied` (`permission_denials:[Write]`, keine Datei) — eine haiku-Task macht unter `auto` still nichts und landet ohne Änderung in `WaitingForReview`. Normalbetrieb (Default = sonnet) nicht betroffen. KEINE CLI-Regression, sondern modellabhängiges `auto`-Verhalten. Optionen falls es nervt: haiku aus der Auswahl nehmen, ODER Runner auf `acceptEdits`/`bypassPermissions` (modell-unabhängig). Mika: erstmal beobachten. Siehe Memory `auto_permission_haiku_footgun`.
+- ~~**`QueueServiceTests.UsageGate_TransitionLogging_FiresOncePerChange` ist zeitbasiert flaky**~~ — **am 2026-08-06 gefixt**: der feste `Task.Delay(200)` ist durch die schon im selben File vorhandene `AssertStableCountAsync` ersetzt (pollt bis der erste Backstop-Tick geloggt hat, wartet dann eine Karenzzeit und stellt sicher, dass kein weiterer Tick nachlegt). Historischer Befund zur Einordnung: Schlägt reproduzierbar fehl (`Expected 1, Actual 0` Warn-Log-Aufrufe), sowohl solo (`--filter`) als auch im Vollauf, auf einem sauberen `git worktree add` gegen `main` (bdee731) — also **kein** durch diese Abschluss-Session verursachter Regress (die Session hat keine `.cs`-Datei angefasst). Ursache: der Test verlässt sich auf einen festen `Task.Delay(200)`, um mehrere 50-ms-Backstop-Ticks abzuwarten (Kommentar im Test: „Several backstop ticks (50ms interval) all observe the same blocked state"); auf einer stark ausgelasteten Maschine (hier: viele parallele ClaudeDo-Worktrees/Builds) reicht das Fenster nicht immer. Zum Vergleich: derselbe Test lief in einer zweiten, isolierten Verifikation (Scratch-Merge für den Environment-Checks-Task) sauber durch (876/876). Fix wäre ein Poll-basiertes Warten statt fixem Sleep — aber außerhalb des Scopes dieser Doku/Verifikations-Session (keine Code-Änderung angefasst).
 
 ---
 
+## 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,
   the context-menu item appears only on lists with a working dir, and the selection dialog has no
-  LIST column. Plus a real-Claude smoke run of the five phases (dedupe questions, enhancements
-  landing in task descriptions, queued execution, merges).
+  LIST column. (Der real-Claude-Smoke-Run der fünf Phasen ist am 2026-07-29 gelaufen — 6/6 sauber
+  gemerged; nur die Sichtprüfung ist noch offen.)
 
 ## Offene Verifikation (2026-08-05)
 
-- **List handler owns a task (2026-08-05)** — build + unit tests all green, but **not visually
-  verified**: start "Let Claude handle it" on a list, confirm exactly one new task appears in that
-  list (`Idle`, MANUAL badge, title "List handler: <list>"), the Mission Control tile is
-  task-based (Submit for review button present), Submit for review flips it to
-  `WaitingForReview`, and the detail pane's diff/merge card shows the full range of everything the
-  run merged to main (via the new `HandlerBaseCommit`/`HandlerHeadCommit` fallback — no
-  `WorktreeEntity` is created for this task, so the diff comes from `list.WorkingDir` directly).
-- **Roadblock reply field (2026-08-05)** — build + unit tests all green, but **not visually
-  verified**: on a `Done` (or `WaitingForReview`/`Failed`/`Cancelled`) task with a reported
-  roadblock, the ROADBLOCK card shows a reply textbox + Send button under the roadblock text.
-  Check layout/spacing against the AskUser question card it's modeled on, Enter-to-send, the
-  disabled state + hint text when there's no session ID to resume, and that an override-slot-busy
-  error shows up in the footer log strip (not a modal) with the typed text still in the field.
-  Approve should go straight to `Done` with no merge attempt. Design choice: the review range
-  lives as two new nullable columns directly on `TaskEntity` (not a phantom `WorktreeEntity` row),
-  specifically so `list_worktrees`/the Worktrees overview never see it.
+- **List handler owns a task (2026-08-05)** — **visuell verifiziert am 2026-08-06** (Lauf über die
+  Liste `ClaudeDoTests` mit 4 Tasks, davon 2 absichtliche Dubletten): genau ein neuer Task, Mission-
+  Control-Tile task-basiert mit „Submit for review", Dedupe hat die Dublette erkannt,
+  Beschreibungen wurden angereichert, Submit → `WaitingForReview`, und die Diff-Karte zeigte alle
+  drei Dateien des Laufs. Korrektur zur Erwartung oben: der Task-Chip liest sich **„Interactive"**,
+  nicht `Idle` — das ist korrekt so (`HasInteractiveSession` überschreibt den Status-Chip, solange
+  die ConPTY-Session läuft). Die drei dabei gefundenen Punkte stehen unter „Bugs" bzw.
+  „Feature-Wünsche".
+- **Roadblock reply field (2026-08-05)** — **Kernfunktion am 2026-08-06 verifiziert**: auf einem
+  Task mit gemeldetem Roadblock erscheint das Antwortfeld unter dem Roadblock-Text, die Antwort
+  setzt die Session fort, und der Task landet danach sauber auf `WaitingForReview`. Dabei ist der
+  Bug oben aufgefallen (Feld deaktiviert, solange der Task seit vor dem Lauf offen ist). Layout der
+  Roadblock-Karte ist in Ordnung. **Noch offen:** Enter-zum-Senden, und dass ein „Override-Slot
+  besetzt"-Fehler im Footer-Strip landet (nicht als Modal) mit dem getippten Text weiterhin im
+  Feld. Design-Entscheidung dazu: der Review-Bereich lebt als zwei nullable Spalten
+  direkt auf `TaskEntity` (kein Phantom-`WorktreeEntity`), damit `list_worktrees`/die
+  Worktrees-Übersicht ihn nie sehen.
 
 - **Post-merge verify gate (2026-08-05)** — build + unit tests all green (incl. real-process
   `VerifyCommandRunner` exit-code/output/timeout tests and `TaskMergeService` success/failure/
@@ -94,12 +111,75 @@ Offene Entscheidungen dazu:
   `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
+nachgeprüft** (der laufende Build ist älter — erst nach Neuinstallation testbar):
+
+- **NumericUpDown-Leeren wirft nicht mehr:** neuer `KeepLastNumberConverter` bildet beim
+  ConvertBack `null` auf `BindingOperations.DoNothing` ab, an allen acht nicht-nullbaren
+  NumericUpDowns im Settings-Modal verdrahtet. Prüfen: Wert löschen und neu tippen — keine
+  Exception, alter Wert bleibt stehen, bis eine echte Zahl kommt. Damit ist auch der offene Rest
+  von „MaxTurnsCeiling ändern → Hinweistexte ziehen mit" nachholbar.
+- **Verify-Gate greift jetzt auch ohne Worktree:** Approve auf einem List-Handler-Task mit
+  fehlschlagendem `VerifyCommand` muss `verify_failed` liefern und den Task aus `Done` halten
+  (vorher ging er kommentarlos auf `Done`).
+- **`verify_failed` im Merge-Modal und in der Worktrees-Übersicht:** Modal zeigt statt „Unknown
+  status" den echten Fehlertext und schließt sich **nicht** automatisch; die Batch-Übersicht
+  zeigt `VerifyFailed` und markiert die Zeile trotzdem als `Merged` (der Merge ist ja gelandet).
+- **Roadblock-Reply/Continue live:** Task offen lassen, während er in den Roadblock läuft — das
+  Antwortfeld und Continue müssen **ohne** erneutes Öffnen aktiv werden.
+- **Cleanup-Log:** ein Worktree-Cleanup über veraltete DB-Zeilen darf keine WARN-Flut mehr im
+  Footer erzeugen (die „schon erledigt"-Fälle gehen auf Debug).
+- **Handoff schließt die alte Kachel:** beim Übergang von Phase 2 auf Phase 3 muss die alte
+  Merge-Helper-Kachel verschwinden und die neue an ihrer Stelle stehen — keine leere Geister-Pane
+  mehr. (Entscheidung Mika 2026-08-06: automatisch schließen statt Output erhalten.)
+
+## Offene Verifikation (2026-08-06, Resume planning session)
+
+`planning_session_id` wurde nie befüllt (der Setter hatte keinen Aufrufer), weil die interaktive
+Planning-Session ihre claude-Session-Id nie zurückmeldet — Resume konnte deshalb nie
+funktionieren. `PlanningSessionManager.ResumeAsync` liest die Id jetzt beim ersten Resume aus dem
+Transkript, das Claude Code unter `~/.claude/projects/<encodiertes cwd>/<sessionId>.jsonl` für den
+Planning-Worktree ablegt (`PlanningTranscriptLocator`), und persistiert sie. Unit-Tests grün,
+**nicht visuell verifiziert**:
+
+- Planning-Session starten, Fenster/Pane schließen, Task erneut öffnen → „Resume" muss die
+  ConPTY-Pane mit der **fortgesetzten** Unterhaltung öffnen (nicht mit leerem Verlauf).
+- Ohne Transkript (z. B. Session nie wirklich gestartet): Fehlermeldung „No Claude session
+  transcript found…" landet sichtbar im Footer-Error-Strip (`Terminal.StartError` →
+  `ErrorReported`), nicht still.
+- **Risiko:** das Verzeichnis-Encoding (`~/.claude/projects/`, jedes Nicht-Alphanumerische wird
+  `-`) ist undokumentiertes CLI-Verhalten — ändert es sich, findet der Locator nichts und Resume
+  meldet sauber „cannot resume" (fail-safe, kein falscher Resume).
+
 ## Offene Verifikation (2026-08-05, Usage Monitor)
 
-- **Visueller Pass Usage-Pill** (Footer **und** Mission-Control-Header): Text/Tooltip,
-  Dot-Zustände normal/warn/stale/blocked, Dark/Light.
-- **Visueller Pass Usage-Monitor-Modal**: Gauges (dynamisch aus `limits[]`), Modell-/Task-
-  Tabellen, Info-Bänder (stale/gate-blocked), 7d/30d-Presets + Custom-Range, Dark/Light.
+> **Kein Light-Theme.** `App.axaml:6` setzt `RequestedThemeVariant="Dark"` fest, es gibt keinen
+> Umschalter und `Tokens.axaml` kennt keine Light-Variante. „Dark/Light"-Checks sind deshalb
+> überall aus dieser Datei entfernt — sie waren nie erfüllbar.
+
+- **Visueller Pass Usage-Pill** (Footer **und** Mission-Control-Header) — **am 2026-08-06
+  verifiziert**: Text/Tooltip lesbar, Dot-Zustände plausibel, Pill in Footer und
+  Mission-Control-Header identisch.
+- **Visueller Pass Usage-Monitor-Modal** — **am 2026-08-06 verifiziert**: Gauges (dynamisch aus
+  `limits[]`), Info-Bänder (der Throttle-Hinweis „Queue throttled: 1/3 slots (7d)" stand real an),
+  7d/30d-Presets + Custom-Range. Die Analyse-Tabellen sind ausbaufähig → siehe „UX / Nits".
 - **E2E Gate**: das Gate greift real, sobald ein Bucket (`five_hour`/`seven_day`) die
   konfigurierte Schwelle reißt — Queue-Nachschub pausiert, laufende Runs/`RunNow`/ConPTY/
   Planning/Prime bleiben unberührt — und die Queue nimmt nach dem Reset selbstständig wieder
@@ -108,6 +188,84 @@ Offene Entscheidungen dazu:
   undokumentiert und kann sich ändern; bei Ausfall/Formatänderung ist das Gate wirkungslos
   (fail-open by design — kein Blocker, aber der Schutz fällt dann aus, ohne dass es auffällt).
 
+### Nachtrag 2026-08-05: 429-Fix (Poll-Kadenz + Refresh-Button)
+
+Der 60s-Poll lief in 429s. Neu: aktivitätsabhängige Kadenz (5 Min. solange ein Task `Running`
+ist, sonst 15 Min.), 429-Backoff mit `Retry-After`, und ein „Jetzt aktualisieren"-Button im
+Usage-Monitor-Modal (`RefreshUsage` → `UsageMonitorService.RefreshNowAsync`, 10s-Cooldown).
+Unit-Tests grün, **offen**:
+
+- **Visueller Pass Refresh-Button** im Modal — **am 2026-08-06 verifiziert** (Button, Hinweiszeile
+  „Polled every 5 min while a task runs, otherwise every 15 min.").
+- **E2E:** über ≥20 Min. mit und ohne laufenden Task beobachten, dass keine 429s mehr im
+  Worker-Log auftauchen und die Pill trotzdem aktuell bleibt.
+- **Beachten:** die Pill wird jetzt erst nach 3× 15 Min. als `stale` markiert — ein echter
+  Endpoint-Ausfall fällt vorher nur über `LastError` auf (der `IsStale` sofort setzt).
+
+## Offene Verifikation (2026-08-05, Max-Turns-Ceiling)
+
+Build + unit tests grün (`ResolveMaxTurns`-Klemmung, Repository-Backfill von `model_presets`,
+Migration `AddMaxTurnsCeiling` gegen eine Scratch-DB angewendet), aber **nicht visuell
+verifiziert**:
+
+- Agent-Settings-Editor (Task **und** Liste): Max-Turns-Feld auf einen Wert über der Ceiling
+  (Default 80) setzen, Hinweistext unter dem `NumericUpDown` erscheint ("Runs are capped at
+  {N} turns…").
+- Settings → Allgemein → Vorgaben pro Modell: eine Zeile über 80 setzen, derselbe Hinweistext
+  erscheint unter der Zeile.
+- `MaxTurnsCeiling` ist seit `2975f90` selbst editierbar (Settings → Allgemein,
+  `SettingsModalView.axaml`) — Feld prüfen: Wert ändern, speichern, Hinweistexte oben ziehen mit.
+
+## Offene Verifikation (2026-08-05, Environment Checks / SystemCheckPage)
+
+Checks + SystemCheckPage (`claudedo/06aca9b3…`) und das ExecutableResolver-Wiring im Worker
+(`claudedo/40272c0b…`) sind seit 2026-08-06 auf `main` gemerged; die frühere „erst mergen"-
+Voraussetzung ist erledigt. Details → `installer-preflight` in `docs/explore-notes/README.md`
+und der Abschnitt „Environment Checks" in `src/ClaudeDo.Installer/CLAUDE.md`.
+
+**Update (2026-08-06):** beide Folge-Features sind jetzt implementiert und auf `main`.
+
+- Diagnose-Sektion (Config-Modus/`SettingsWindow`): `Pages/DiagnosePage/` + geteilte
+  `Checks/CheckListViewModel.cs`/`Checks/CheckListView.xaml` (auch von `SystemCheckPage`
+  genutzt, keine zweite Implementierung). Unit-getestet
+  (`tests/ClaudeDo.Installer.Tests/Pages/DiagnosePage/DiagnosePageViewModelTests.cs`).
+- „Claude Help Me"-Button: `Core/ClaudeHelpLauncher.cs` + `SystemCheckPageViewModel`/-View,
+  unit-getestet (`tests/ClaudeDo.Installer.Tests/Core/ClaudeHelpLauncherTests.cs`).
+
+Beides **nicht visuell verifiziert**:
+
+- [x] Help-Me-Button ist deaktiviert, wenn `claude-cli` nicht `Ok` ist oder `claude-auth`
+      `Failed` ist (bleibt aktiv bei `Unknown`), mit erklärendem Tooltip — unit-getestet.
+- [ ] „Claude Help Me" öffnet tatsächlich ein Terminal mit laufender Claude-Session, und die
+      Session hat den Diagnose-Report gelesen — **nicht verifiziert** (der eigentliche
+      Terminal-Start/`wt.exe`-Zusammenspiel und die Session-Qualität sind nur über die
+      injizierte `IProcessLauncher`-Fake getestet, nie mit einem echten Terminal/CLI).
+- [ ] Platzierung des Help-Me-Buttons: er sitzt seit dem Merge der Diagnose-Sektion in einer
+      **eigenen Zeile unter** dem geteilten Check-Listen-Footer (der reservierte Slot *im*
+      Footer entfiel mit der Extraktion nach `CheckListView.xaml`). Optisch prüfen, ob das
+      so bleiben soll oder ob der Button in den geteilten Footer gehört.
+- [ ] Diagnose-Sektion im Config-Modus: Öffnen von SettingsWindow löst keinen Prüflauf aus, Klick
+      auf „Erneut prüfen" schon; zeigt die echten installierten Pfade/Ports (nicht die
+      InstallContext-Defaults), und der laufende Worker auf dem konfigurierten SignalR-Port gilt
+      nicht als Konflikt — **unit-verifiziert, visueller Durchlauf noch offen.**
+
+Weitere Punkte, gebaut + unit-getestet auf `main`, aber **nicht visuell verifiziert**:
+
+- [ ] SystemCheckPage: Layout, Icon-/Farbwirkung der vier Status (Ok grün / Warnung orange /
+      Fehler rot / Unbekannt grau — `StatusGreenBrush`/`StatusOrangeBrush`/`StatusRedBrush`/
+      `StatusGrayBrush`), Lesbarkeit der Hint-Texte, DE und EN.
+- [ ] Weiter-Button gesperrt bei einem echten blockierenden Fehler (z. B. `claude` nicht im
+      PATH → `claude-cli` Error/Failed), und der Grund ist in der Zusammenfassungszeile
+      sichtbar (nennt den/die blockierenden Check(s) namentlich).
+- [ ] „Erneut prüfen" wechselt einen Status live (z. B. git-Identity setzen → Warnung
+      verschwindet), ohne dass ein zweiter paralleler Lauf startet, wenn währenddessen erneut
+      geklickt wird.
+- [ ] Update-Modus zeigt die SystemCheckPage **nicht** (Wizard bleibt Welcome + Install).
+- [ ] Auf einem Rechner mit npm-installiertem `claude.cmd`: `claude-cli`-Check findet es
+      (Detail-Text „Resolved via a shim…"), und ein Task läuft im Worker durch (bestätigt, dass
+      `ClaudeProcess`/`ClaudeCliPreflight` den Shim über `cmd.exe /c` tatsächlich startet, nicht
+      nur, dass der Check ihn findet).
+
 ---
 
 ## Bewusst verworfen (nicht erneut vorschlagen)

docs/superpowers/plans/2026-08-07-handler-run-links.md

@@ -0,0 +1,939 @@
+# Handler-Run Links Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** A "Let Claude handle it" run records which tasks it processed, shows them as a list on the handler task's detail pane, and wears a HANDLER badge instead of MANUAL.
+
+**Architecture:** One new nullable column `TaskEntity.HandlerTaskId` (1:n, last run wins) stamped at handler-task creation from the selection the UI already passes down. The badge is a display-only computed property on `TaskRowViewModel`, driven by the existing `HandlerBaseCommit`. The panel reuses `ChildOutcomeRowViewModel` and the existing refresh path.
+
+**Tech Stack:** .NET 8, EF Core (SQLite), Avalonia 12 + CommunityToolkit.Mvvm, xUnit.
+
+**Spec:** `docs/superpowers/specs/2026-08-07-handler-run-links-design.md`
+
+---
+
+## File Structure
+
+**Modified:**
+- `src/ClaudeDo.Data/Models/TaskEntity.cs` — new `HandlerTaskId` property
+- `src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs` — column mapping + index
+- `src/ClaudeDo.Data/Repositories/TaskRepository.cs` — `SetHandlerTaskIdAsync`
+- `src/ClaudeDo.Worker/Runner/InteractiveLaunchSpecService.cs` — stamp after creating the handler task
+- `src/ClaudeDo.Ui/ViewModels/Islands/TaskRowViewModel.cs` — `HandlerBaseCommit`, `IsHandlerRun`, `HandlerBadge`, `ManualBadge` precedence
+- `src/ClaudeDo.Ui/Views/Islands/TaskRowView.axaml` — HANDLER badge border
+- `src/ClaudeDo.Ui/Design/IslandStyles.axaml` — `HandlerBadgeBrush` + `Border.badge.handler`
+- `src/ClaudeDo.Localization/locales/en.json` + `de.json` — `tasks.badgeHandler`, `tasks.handlerTip`
+- `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs` — `HandledTasks` collection, loader, clear, refresh
+- `src/ClaudeDo.Ui/Views/Islands/Detail/WorkConsole.axaml` — HANDLED TASKS panel
+- `src/ClaudeDo.Data/CLAUDE.md`, `src/ClaudeDo.Ui/CLAUDE.md`, `docs/explore-notes/conpty-sessions.md` — docs
+
+**Created:**
+- `src/ClaudeDo.Data/Migrations/<timestamp>_AddHandlerTaskId.cs` (+ Designer, + snapshot update) — generated
+- `tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryHandlerLinkTests.cs`
+- `tests/ClaudeDo.Ui.Tests/ViewModels/TaskRowViewModelHandlerBadgeTests.cs`
+- `tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandHandledTasksTests.cs`
+
+---
+
+## Task 1: Data — `HandlerTaskId` column and migration
+
+**Files:**
+- Modify: `src/ClaudeDo.Data/Models/TaskEntity.cs:60-61`
+- Modify: `src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs:96-97` and `:127-131`
+- Create: `src/ClaudeDo.Data/Migrations/<timestamp>_AddHandlerTaskId.cs` (generated)
+
+- [ ] **Step 1: Add the property**
+
+In `src/ClaudeDo.Data/Models/TaskEntity.cs`, directly after the existing `HandlerHeadCommit` line (`public string? HandlerHeadCommit { get; set; }`), add:
+
+```csharp
+
+    // Id of the "list handler" run task that processed this task ("Let Claude handle it").
+    // 1:n and last-run-wins -- a second handler run over the same task overwrites it. Deliberately
+    // NOT ParentTaskId: that is the planning-child relation and drives the indented tree rendering.
+    // No FK: a deleted handler task must not cascade into the tasks it merely touched.
+    public string? HandlerTaskId { get; set; }
+```
+
+- [ ] **Step 2: Map the column and index it**
+
+In `src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs`, after the line
+`builder.Property(t => t.HandlerHeadCommit).HasColumnName("handler_head_commit");` add:
+
+```csharp
+        builder.Property(t => t.HandlerTaskId).HasColumnName("handler_task_id");
+```
+
+At the end of `Configure`, after the line
+`builder.HasIndex(t => t.BlockedByTaskId).HasDatabaseName("idx_tasks_blocked_by");` add:
+
+```csharp
+        builder.HasIndex(t => t.HandlerTaskId).HasDatabaseName("idx_tasks_handler_task_id");
+```
+
+Do **not** add a `HasOne`/`HasForeignKey` relationship — the column is intentionally FK-less.
+
+- [ ] **Step 3: Generate the migration**
+
+Run from the repo root:
+
+```bash
+dotnet ef migrations add AddHandlerTaskId --project src/ClaudeDo.Data/ClaudeDo.Data.csproj --startup-project src/ClaudeDo.Worker/ClaudeDo.Worker.csproj
+```
+
+Expected: creates `src/ClaudeDo.Data/Migrations/<timestamp>_AddHandlerTaskId.cs` + `.Designer.cs` and updates `ClaudeDoDbContextModelSnapshot.cs`. The `Up` method must contain exactly one `AddColumn<string>(name: "handler_task_id", table: "tasks", nullable: true)` and one `CreateIndex(name: "idx_tasks_handler_task_id", table: "tasks", column: "handler_task_id")`. If it contains anything else, another agent's uncommitted model change leaked in — delete the migration, coordinate, retry.
+
+If `dotnet ef` is unavailable, hand-author the migration + Designer mirroring
+`src/ClaudeDo.Data/Migrations/20260806111454_AddInteractiveSessionId.cs`, and add
+`Property<string>("HandlerTaskId").HasColumnType("TEXT").HasColumnName("handler_task_id");`
+plus the index to the `TaskEntity` builder in `ClaudeDoDbContextModelSnapshot.cs`.
+
+- [ ] **Step 4: Build**
+
+Run: `dotnet build src/ClaudeDo.Data/ClaudeDo.Data.csproj -c Release`
+Expected: `Build succeeded`, 0 errors.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Data/Models/TaskEntity.cs src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs src/ClaudeDo.Data/Migrations
+git commit -- src/ClaudeDo.Data/Models/TaskEntity.cs src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs src/ClaudeDo.Data/Migrations -m "feat(data): add handler_task_id to link handled tasks to their handler run"
+```
+
+⚠️ Always commit with explicit paths (`git commit -- <paths>`), never a bare `git commit` — the
+main checkout is shared with concurrent sessions.
+
+---
+
+## Task 2: Data — `SetHandlerTaskIdAsync` repository method
+
+**Files:**
+- Modify: `src/ClaudeDo.Data/Repositories/TaskRepository.cs` (after `SetHandlerHeadCommitAsync`, currently `:394-403`)
+- Test: `tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryHandlerLinkTests.cs` (create)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryHandlerLinkTests.cs`:
+
+```csharp
+using ClaudeDo.Data;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Tests.Infrastructure;
+using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
+
+namespace ClaudeDo.Worker.Tests.Repositories;
+
+/// Covers the handler-run link: SetHandlerTaskIdAsync stamps the tasks a "Let Claude handle it"
+/// run processed, so the handler task's detail pane can list them after the run.
+public sealed class TaskRepositoryHandlerLinkTests : IDisposable
+{
+    private readonly DbFixture _db = new();
+    private readonly ClaudeDoDbContext _ctx;
+    private readonly TaskRepository _tasks;
+    private readonly ListRepository _lists;
+
+    public TaskRepositoryHandlerLinkTests()
+    {
+        _ctx = _db.CreateContext();
+        _tasks = new TaskRepository(_ctx);
+        _lists = new ListRepository(_ctx);
+    }
+
+    public void Dispose()
+    {
+        _ctx.Dispose();
+        _db.Dispose();
+    }
+
+    private async Task<string> CreateListAsync()
+    {
+        var listId = Guid.NewGuid().ToString();
+        await _lists.AddAsync(new ListEntity
+        {
+            Id = listId,
+            Name = "Test List",
+            CreatedAt = DateTime.UtcNow,
+        });
+        return listId;
+    }
+
+    private async Task<string> AddTaskAsync(string listId)
+    {
+        var id = Guid.NewGuid().ToString();
+        await _tasks.AddAsync(new TaskEntity
+        {
+            Id = id,
+            ListId = listId,
+            Title = "T",
+            Status = TaskStatus.Idle,
+            CreatedAt = DateTime.UtcNow,
+        });
+        return id;
+    }
+
+    [Fact]
+    public async Task SetHandlerTaskIdAsync_StampsAllGivenTasks()
+    {
+        var listId = await CreateListAsync();
+        var a = await AddTaskAsync(listId);
+        var b = await AddTaskAsync(listId);
+        var handlerId = await AddTaskAsync(listId);
+
+        var affected = await _tasks.SetHandlerTaskIdAsync(new[] { a, b }, handlerId);
+
+        Assert.Equal(2, affected);
+        Assert.Equal(handlerId, (await _tasks.GetByIdAsync(a))!.HandlerTaskId);
+        Assert.Equal(handlerId, (await _tasks.GetByIdAsync(b))!.HandlerTaskId);
+        Assert.Null((await _tasks.GetByIdAsync(handlerId))!.HandlerTaskId);
+    }
+
+    [Fact]
+    public async Task SetHandlerTaskIdAsync_IgnoresUnknownIds()
+    {
+        var listId = await CreateListAsync();
+        var a = await AddTaskAsync(listId);
+        var handlerId = await AddTaskAsync(listId);
+
+        var affected = await _tasks.SetHandlerTaskIdAsync(
+            new[] { a, "does-not-exist" }, handlerId);
+
+        Assert.Equal(1, affected);
+        Assert.Equal(handlerId, (await _tasks.GetByIdAsync(a))!.HandlerTaskId);
+    }
+
+    [Fact]
+    public async Task SetHandlerTaskIdAsync_SecondRunOverwrites()
+    {
+        var listId = await CreateListAsync();
+        var a = await AddTaskAsync(listId);
+        var firstHandler = await AddTaskAsync(listId);
+        var secondHandler = await AddTaskAsync(listId);
+
+        await _tasks.SetHandlerTaskIdAsync(new[] { a }, firstHandler);
+        await _tasks.SetHandlerTaskIdAsync(new[] { a }, secondHandler);
+
+        Assert.Equal(secondHandler, (await _tasks.GetByIdAsync(a))!.HandlerTaskId);
+    }
+
+    [Fact]
+    public async Task SetHandlerTaskIdAsync_EmptyList_IsNoOp()
+    {
+        var listId = await CreateListAsync();
+        var handlerId = await AddTaskAsync(listId);
+
+        var affected = await _tasks.SetHandlerTaskIdAsync(Array.Empty<string>(), handlerId);
+
+        Assert.Equal(0, affected);
+    }
+}
+```
+
+- [ ] **Step 2: Run the tests to verify they fail**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter "FullyQualifiedName~TaskRepositoryHandlerLinkTests"`
+Expected: compile error — `TaskRepository` does not contain a definition for `SetHandlerTaskIdAsync`.
+
+- [ ] **Step 3: Implement the method**
+
+In `src/ClaudeDo.Data/Repositories/TaskRepository.cs`, directly after `SetHandlerHeadCommitAsync`, add:
+
+```csharp
+    // Links the tasks a "list handler" run processed back to the handler's own task, so the
+    // handler's detail pane can list them after the run. Stamped from the user's selection at
+    // creation time -- that way tasks the handler later cancels as duplicates stay visible.
+    // Unknown ids are silently skipped. Returns the number of rows actually stamped.
+    public async Task<int> SetHandlerTaskIdAsync(
+        IReadOnlyList<string> taskIds,
+        string handlerTaskId,
+        CancellationToken ct = default)
+    {
+        if (taskIds.Count == 0) return 0;
+
+        var ids = taskIds.Where(id => id != handlerTaskId).Distinct().ToList();
+        if (ids.Count == 0) return 0;
+
+        return await _context.Tasks
+            .Where(t => ids.Contains(t.Id))
+            .ExecuteUpdateAsync(s => s
+                .SetProperty(t => t.HandlerTaskId, handlerTaskId), ct);
+    }
+```
+
+- [ ] **Step 4: Run the tests to verify they pass**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter "FullyQualifiedName~TaskRepositoryHandlerLinkTests"`
+Expected: `Passed! - Failed: 0, Passed: 4`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Data/Repositories/TaskRepository.cs tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryHandlerLinkTests.cs
+git commit -- src/ClaudeDo.Data/Repositories/TaskRepository.cs tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryHandlerLinkTests.cs -m "feat(data): add SetHandlerTaskIdAsync to stamp handled tasks"
+```
+
+---
+
+## Task 3: Worker — stamp the selection when the handler task is created
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Runner/InteractiveLaunchSpecService.cs:409-450`
+- Test: `tests/ClaudeDo.Worker.Tests/Runner/InteractiveLaunchSpecServiceTests.cs` (append a `[Fact]` in the `── CreateMergeHelperTaskAsync ──` region, currently starting at `:747`)
+
+Note: `CreateMergeHelperTaskAsync` already receives `IReadOnlyList<string> taskIds` — the UI →
+`IWorkerClient` → `WorkerHub` chain needs **no** change.
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `tests/ClaudeDo.Worker.Tests/Runner/InteractiveLaunchSpecServiceTests.cs` inside the same test class, after the existing `CreateMergeHelperTaskAsync_CreatesIdleManualTask_StampsHandlerBaseCommit` test:
+
+```csharp
+    [Fact]
+    public async Task CreateMergeHelperTaskAsync_StampsHandlerTaskIdOnSelectedTasks()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var repo = CreateRepo();
+        var listId = await SeedListAsync(workingDir: repo.RepoDir, name: "Alpha");
+        var t1 = Guid.NewGuid().ToString();
+        var t2 = Guid.NewGuid().ToString();
+        await SeedTaskAsync(t1, listId, TaskStatus.WaitingForReview, title: "First task");
+        await SeedTaskAsync(t2, listId, TaskStatus.Idle, title: "Second task");
+
+        var svc = BuildService();
+        var handlerId = await svc.CreateMergeHelperTaskAsync(
+            new[] { t1, t2 }, listId, "List handler: Alpha", "Tasks handled by this run:", CancellationToken.None);
+
+        using var readCtx = _db.CreateContext();
+        var tasks = new TaskRepository(readCtx);
+        Assert.Equal(handlerId, (await tasks.GetByIdAsync(t1))!.HandlerTaskId);
+        Assert.Equal(handlerId, (await tasks.GetByIdAsync(t2))!.HandlerTaskId);
+        // The handler never links to itself.
+        Assert.Null((await tasks.GetByIdAsync(handlerId))!.HandlerTaskId);
+    }
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter "FullyQualifiedName~CreateMergeHelperTaskAsync_StampsHandlerTaskIdOnSelectedTasks"`
+Expected: FAIL — `Assert.Equal() Failure: Values differ … Actual: null`.
+
+- [ ] **Step 3: Stamp the selection**
+
+In `src/ClaudeDo.Worker/Runner/InteractiveLaunchSpecService.cs`, in `CreateMergeHelperTaskAsync`, replace:
+
+```csharp
+        await taskRepo.AddAsync(handlerTask, ct);
+
+        return handlerTask.Id;
+```
+
+with:
+
+```csharp
+        await taskRepo.AddAsync(handlerTask, ct);
+
+        // Link the selection back to this run BEFORE the session starts: the handler cancels
+        // duplicates in phase 1, and those still belong in the "what was this run supposed to do"
+        // list. Stamping later (e.g. at handoff) would lose them.
+        await taskRepo.SetHandlerTaskIdAsync(taskIds, handlerTask.Id, ct);
+
+        return handlerTask.Id;
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter "FullyQualifiedName~CreateMergeHelperTaskAsync"`
+Expected: `Passed! - Failed: 0` (all five `CreateMergeHelperTaskAsync` tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Worker/Runner/InteractiveLaunchSpecService.cs tests/ClaudeDo.Worker.Tests/Runner/InteractiveLaunchSpecServiceTests.cs
+git commit -- src/ClaudeDo.Worker/Runner/InteractiveLaunchSpecService.cs tests/ClaudeDo.Worker.Tests/Runner/InteractiveLaunchSpecServiceTests.cs -m "feat(handler): link the selected tasks to the handler run task"
+```
+
+---
+
+## Task 4: Ui — HANDLER badge instead of MANUAL
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/TaskRowViewModel.cs:40,51,234-240,308-329`
+- Modify: `src/ClaudeDo.Ui/Views/Islands/TaskRowView.axaml:141-144`
+- Modify: `src/ClaudeDo.Ui/Design/IslandStyles.axaml:114-118` and `:987-990`
+- Modify: `src/ClaudeDo.Localization/locales/en.json:163-164`, `src/ClaudeDo.Localization/locales/de.json:163-164`
+- Test: `tests/ClaudeDo.Ui.Tests/ViewModels/TaskRowViewModelHandlerBadgeTests.cs` (create)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/ClaudeDo.Ui.Tests/ViewModels/TaskRowViewModelHandlerBadgeTests.cs`:
+
+```csharp
+using ClaudeDo.Data.Models;
+using ClaudeDo.Ui.ViewModels.Islands;
+using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
+
+namespace ClaudeDo.Ui.Tests.ViewModels;
+
+/// A "list handler" host task is IsManual=true so automation skips it, but MANUAL reads wrong on
+/// it -- the HANDLER badge must win and MANUAL must disappear.
+public class TaskRowViewModelHandlerBadgeTests
+{
+    [Fact]
+    public void HandlerTask_ShowsHandlerBadge_AndSuppressesManualBadge()
+    {
+        var row = new TaskRowViewModel { Id = "t1" };
+        row.IsManual = true;
+        row.HandlerBaseCommit = "base123";
+
+        Assert.True(row.IsHandlerRun);
+        Assert.NotNull(row.HandlerBadge);
+        Assert.Null(row.ManualBadge);
+    }
+
+    [Fact]
+    public void PlainManualTask_StillShowsManualBadge()
+    {
+        var row = new TaskRowViewModel { Id = "t2" };
+        row.IsManual = true;
+
+        Assert.False(row.IsHandlerRun);
+        Assert.Null(row.HandlerBadge);
+        Assert.NotNull(row.ManualBadge);
+    }
+
+    [Fact]
+    public void UpdateFromEntity_MirrorsHandlerBaseCommit()
+    {
+        var row = new TaskRowViewModel { Id = "t3" };
+        row.UpdateFromEntity(new TaskEntity
+        {
+            Id = "t3",
+            ListId = "l1",
+            Title = "List handler: Alpha",
+            Status = TaskStatus.Idle,
+            IsManual = true,
+            HandlerBaseCommit = "base123",
+            CreatedAt = DateTime.UtcNow,
+        });
+
+        Assert.Equal("base123", row.HandlerBaseCommit);
+        Assert.True(row.IsHandlerRun);
+    }
+}
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run: `dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release --filter "FullyQualifiedName~TaskRowViewModelHandlerBadgeTests"`
+Expected: compile error — `TaskRowViewModel` has no `HandlerBaseCommit` / `IsHandlerRun` / `HandlerBadge`.
+
+- [ ] **Step 3: Add the properties**
+
+In `src/ClaudeDo.Ui/ViewModels/Islands/TaskRowViewModel.cs`, after the `_isManual` field
+declaration (`[ObservableProperty] private bool _isManual;`), add:
+
+```csharp
+    // Mirror of TaskEntity.HandlerBaseCommit -- non-null marks this row as a "list handler" run
+    // host task ("Let Claude handle it"), which wears HANDLER instead of MANUAL.
+    [ObservableProperty] private string? _handlerBaseCommit;
+```
+
+Replace the `ManualBadge` line (currently `public string? ManualBadge => IsManual ? Loc.T("tasks.badgeManual") : null;`) with:
+
+```csharp
+    public bool IsHandlerRun => !string.IsNullOrEmpty(HandlerBaseCommit);
+
+    public string? HandlerBadge => IsHandlerRun ? Loc.T("tasks.badgeHandler") : null;
+
+    // HANDLER outranks MANUAL: a handler host task is IsManual only so automation skips it, and
+    // "MANUAL" would read as a hand-written reminder. The two badges never show together.
+    public bool ShowManualBadge => IsManual && !IsHandlerRun;
+
+    public string? ManualBadge => ShowManualBadge ? Loc.T("tasks.badgeManual") : null;
+```
+
+Add a change hook next to the existing `OnIsManualChanged` partial method:
+
+```csharp
+    partial void OnHandlerBaseCommitChanged(string? value)
+    {
+        OnPropertyChanged(nameof(IsHandlerRun));
+        OnPropertyChanged(nameof(HandlerBadge));
+        OnPropertyChanged(nameof(ShowManualBadge));
+        OnPropertyChanged(nameof(ManualBadge));
+    }
+```
+
+Inside the existing `OnIsManualChanged`, next to the existing `OnPropertyChanged(nameof(ManualBadge));` line, add:
+
+```csharp
+        OnPropertyChanged(nameof(ShowManualBadge));
+```
+
+In `UpdateFromEntity`, after the line `IsManual          = t.IsManual;` add:
+
+```csharp
+        HandlerBaseCommit = t.HandlerBaseCommit;
+```
+
+Also add `HandlerBadge` to `RefreshLocalized`, next to the existing `PlanningBadge` line:
+
+```csharp
+        OnPropertyChanged(nameof(HandlerBadge));
+        OnPropertyChanged(nameof(ManualBadge));
+```
+
+- [ ] **Step 4: Add the locale keys**
+
+In `src/ClaudeDo.Localization/locales/en.json`, after `"manualTip": ...` (line 164) add:
+
+```json
+    "badgeHandler": "HANDLER",
+    "handlerTip": "Handler run — see the tasks it processed in the detail pane",
+```
+
+In `src/ClaudeDo.Localization/locales/de.json`, after `"manualTip": ...` (line 164) add:
+
+```json
+    "badgeHandler": "HANDLER",
+    "handlerTip": "Handler-Run — die bearbeiteten Tasks stehen im Detailbereich",
+```
+
+- [ ] **Step 5: Add the badge style and brush**
+
+In `src/ClaudeDo.Ui/Design/IslandStyles.axaml`, after the line
+`<SolidColorBrush x:Key="ManualBadgeBrush"   Color="{StaticResource TextFaintColor}"/>` add:
+
+```xml
+    <SolidColorBrush x:Key="HandlerBadgeBrush" Color="{StaticResource PeatSoftColor}"/>
+```
+
+After the existing `Border.badge.manual` style block add:
+
+```xml
+  <!-- handler → peat: a "Let Claude handle it" run host, not a hand-written reminder -->
+  <Style Selector="Border.badge.handler">
+    <Setter Property="Background" Value="{DynamicResource HandlerBadgeBrush}"/>
+  </Style>
+```
+
+- [ ] **Step 6: Render the badge**
+
+In `src/ClaudeDo.Ui/Views/Islands/TaskRowView.axaml`, replace the manual badge block (lines 141-144):
+
+```xml
+              <Border Classes="badge manual" IsVisible="{Binding IsManual}"
+                      ToolTip.Tip="{loc:Tr tasks.manualTip}">
+                <TextBlock Text="{Binding ManualBadge}"/>
+              </Border>
+```
+
+with:
+
+```xml
+              <Border Classes="badge manual" IsVisible="{Binding ShowManualBadge}"
+                      ToolTip.Tip="{loc:Tr tasks.manualTip}">
+                <TextBlock Text="{Binding ManualBadge}"/>
+              </Border>
+              <Border Classes="badge handler" IsVisible="{Binding IsHandlerRun}"
+                      ToolTip.Tip="{loc:Tr tasks.handlerTip}">
+                <TextBlock Text="{Binding HandlerBadge}"/>
+              </Border>
+```
+
+Only the `IsVisible` binding changed on the manual border (`IsManual` → `ShowManualBadge`); the
+handler border is new. No converter is needed — `ShowManualBadge` is already a `bool`.
+
+- [ ] **Step 7: Run tests to verify they pass**
+
+Run: `dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release --filter "FullyQualifiedName~TaskRowViewModelHandlerBadgeTests"`
+Expected: `Passed! - Failed: 0, Passed: 3`.
+
+Run: `dotnet test tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj -c Release`
+Expected: `Passed! - Failed: 0` (en/de key parity).
+
+Run: `dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release`
+Expected: `Build succeeded` — this compiles the AXAML.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add src/ClaudeDo.Ui/ViewModels/Islands/TaskRowViewModel.cs src/ClaudeDo.Ui/Views/Islands/TaskRowView.axaml src/ClaudeDo.Ui/Design/IslandStyles.axaml src/ClaudeDo.Localization/locales/en.json src/ClaudeDo.Localization/locales/de.json tests/ClaudeDo.Ui.Tests/ViewModels/TaskRowViewModelHandlerBadgeTests.cs
+git commit -- src/ClaudeDo.Ui/ViewModels/Islands/TaskRowViewModel.cs src/ClaudeDo.Ui/Views/Islands/TaskRowView.axaml src/ClaudeDo.Ui/Design/IslandStyles.axaml src/ClaudeDo.Localization/locales/en.json src/ClaudeDo.Localization/locales/de.json tests/ClaudeDo.Ui.Tests/ViewModels/TaskRowViewModelHandlerBadgeTests.cs -m "feat(ui): show a HANDLER badge on list-handler run tasks"
+```
+
+---
+
+## Task 5: Ui — "HANDLED TASKS" panel on the handler's detail pane
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs:248-255`, `:581-584`, `:685`, `:814-833`
+- Modify: `src/ClaudeDo.Ui/Views/Islands/Detail/WorkConsole.axaml:414-434`
+- Test: `tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandHandledTasksTests.cs` (create)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandHandledTasksTests.cs`:
+
+```csharp
+using ClaudeDo.Data;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Ui.Services;
+using ClaudeDo.Ui.ViewModels.Islands;
+using Microsoft.EntityFrameworkCore;
+using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
+
+namespace ClaudeDo.Ui.Tests.ViewModels;
+
+/// Covers the handler-run link: binding a "list handler" host task lists every task stamped with
+/// its id, including ones the handler cancelled as duplicates.
+public class DetailsIslandHandledTasksTests : IDisposable
+{
+    private readonly string _dbPath;
+
+    public DetailsIslandHandledTasksTests()
+    {
+        _dbPath = Path.Combine(Path.GetTempPath(), $"claudedo_details_handled_test_{Guid.NewGuid():N}.db");
+        using var ctx = NewContext();
+        ctx.Database.EnsureCreated();
+    }
+
+    public void Dispose()
+    {
+        try { File.Delete(_dbPath); } catch { }
+        try { File.Delete(_dbPath + "-wal"); } catch { }
+        try { File.Delete(_dbPath + "-shm"); } catch { }
+    }
+
+    private ClaudeDoDbContext NewContext()
+    {
+        var opts = new DbContextOptionsBuilder<ClaudeDoDbContext>()
+            .UseSqlite($"Data Source={_dbPath}")
+            .Options;
+        return new ClaudeDoDbContext(opts);
+    }
+
+    private sealed class TestDbFactory : IDbContextFactory<ClaudeDoDbContext>
+    {
+        private readonly Func<ClaudeDoDbContext> _create;
+        public TestDbFactory(Func<ClaudeDoDbContext> create) => _create = create;
+        public ClaudeDoDbContext CreateDbContext() => _create();
+    }
+
+    private sealed class NullServiceProvider : IServiceProvider
+    {
+        public object? GetService(Type serviceType) => null;
+    }
+
+    private sealed class StubNotesApi : ClaudeDo.Ui.Services.Interfaces.INotesApi
+    {
+        public Task<List<DailyNoteDto>> ListAsync(DateOnly day) =>
+            Task.FromResult(new List<DailyNoteDto>());
+        public Task<DailyNoteDto?> AddAsync(DateOnly day, string text) =>
+            Task.FromResult<DailyNoteDto?>(null);
+        public Task UpdateAsync(string id, string text) => Task.CompletedTask;
+        public Task DeleteAsync(string id) => Task.CompletedTask;
+    }
+
+    private sealed class FakeWorkerClient : StubWorkerClient
+    {
+        public override bool IsConnected => true;
+    }
+
+    private DetailsIslandViewModel BuildVm()
+    {
+        var factory = new TestDbFactory(NewContext);
+        return new DetailsIslandViewModel(
+            factory, new FakeWorkerClient(), new NullServiceProvider(), new StubNotesApi(), new MergeCoordinator());
+    }
+
+    [Fact]
+    public async Task Bind_HandlerTask_ListsHandledTasksWithTheirStatus()
+    {
+        const string listId = "list-1";
+        const string handlerId = "handler-task-1";
+
+        await using (var ctx = NewContext())
+        {
+            ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", WorkingDir = @"C:\repo", CreatedAt = DateTime.UtcNow });
+            ctx.Tasks.Add(new TaskEntity
+            {
+                Id = handlerId, ListId = listId, Title = "List handler: L",
+                Status = TaskStatus.WaitingForReview, IsManual = true,
+                HandlerBaseCommit = "base123", HandlerHeadCommit = "head456",
+                CreatedAt = DateTime.UtcNow,
+            });
+            ctx.Tasks.Add(new TaskEntity
+            {
+                Id = "done-1", ListId = listId, Title = "Merged task",
+                Status = TaskStatus.Done, HandlerTaskId = handlerId,
+                SortOrder = 0, CreatedAt = DateTime.UtcNow,
+            });
+            ctx.Tasks.Add(new TaskEntity
+            {
+                Id = "dupe-1", ListId = listId, Title = "Duplicate the handler cancelled",
+                Status = TaskStatus.Cancelled, HandlerTaskId = handlerId,
+                SortOrder = 1, CreatedAt = DateTime.UtcNow,
+            });
+            ctx.Tasks.Add(new TaskEntity
+            {
+                Id = "unrelated-1", ListId = listId, Title = "Not part of the run",
+                Status = TaskStatus.Idle, CreatedAt = DateTime.UtcNow,
+            });
+            await ctx.SaveChangesAsync();
+        }
+
+        var vm = BuildVm();
+        vm.Bind(new TaskRowViewModel { Id = handlerId, Status = TaskStatus.WaitingForReview });
+
+        var deadline = DateTime.UtcNow.AddSeconds(5);
+        while (DateTime.UtcNow < deadline && vm.HandledTasks.Count == 0)
+            await Task.Delay(20);
+
+        Assert.Equal(2, vm.HandledTasks.Count);
+        Assert.True(vm.HasHandledTasks);
+        Assert.Equal("Merged task", vm.HandledTasks[0].Title);
+        Assert.Equal(TaskStatus.Done, vm.HandledTasks[0].Status);
+        Assert.Equal(TaskStatus.Cancelled, vm.HandledTasks[1].Status);
+        Assert.DoesNotContain(vm.HandledTasks, r => r.Id == "unrelated-1");
+    }
+
+    [Fact]
+    public async Task Bind_PlainTask_HasNoHandledTasks()
+    {
+        const string listId = "list-1";
+        const string taskId = "plain-1";
+
+        await using (var ctx = NewContext())
+        {
+            ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
+            ctx.Tasks.Add(new TaskEntity
+            {
+                Id = taskId, ListId = listId, Title = "Plain",
+                Status = TaskStatus.Idle, CreatedAt = DateTime.UtcNow,
+            });
+            await ctx.SaveChangesAsync();
+        }
+
+        var vm = BuildVm();
+        vm.Bind(new TaskRowViewModel { Id = taskId, Status = TaskStatus.Idle });
+        await Task.Delay(300);
+
+        Assert.Empty(vm.HandledTasks);
+        Assert.False(vm.HasHandledTasks);
+    }
+}
+```
+
+- [ ] **Step 2: Run the tests to verify they fail**
+
+Run: `dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release --filter "FullyQualifiedName~DetailsIslandHandledTasksTests"`
+Expected: compile error — `DetailsIslandViewModel` has no `HandledTasks` / `HasHandledTasks`.
+
+- [ ] **Step 3: Add the collection**
+
+In `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs`, after the line
+`public ObservableCollection<ChildOutcomeRowViewModel> ChildOutcomes { get; } = new();` add:
+
+```csharp
+    // Tasks a "list handler" run processed ("Let Claude handle it"), linked via
+    // TaskEntity.HandlerTaskId. Separate from ChildOutcomes on purpose: that collection is the
+    // planning/improvement parent's children and feeds the merge card's combined diff, which a
+    // handler run must not touch (it commits straight to the list's working dir).
+    public ObservableCollection<ChildOutcomeRowViewModel> HandledTasks { get; } = new();
+```
+
+After the line `public bool HasChildOutcomes => ChildOutcomes.Count > 0;` add:
+
+```csharp
+    public bool HasHandledTasks => HandledTasks.Count > 0;
+```
+
+- [ ] **Step 4: Clear it on rebind**
+
+In the same file, in the rebind reset block, after the line `ChildOutcomes.Clear();` add:
+
+```csharp
+        HandledTasks.Clear();
+```
+
+and after `OnPropertyChanged(nameof(HasChildOutcomes));` in that same block add:
+
+```csharp
+        OnPropertyChanged(nameof(HasHandledTasks));
+```
+
+- [ ] **Step 5: Load it on bind**
+
+In the same file, directly after the line `await LoadChildOutcomesAsync(row.Id, ct);` add:
+
+```csharp
+            await LoadHandledTasksAsync(row.Id, ct);
+```
+
+Then add the loader immediately after the closing brace of `LoadChildOutcomesAsync`:
+
+```csharp
+    // Tasks stamped with this handler run's id. Ordered like the task list itself so the panel
+    // reads in the same order the user picked them.
+    private async System.Threading.Tasks.Task LoadHandledTasksAsync(string handlerTaskId, CancellationToken ct)
+    {
+        try
+        {
+            await using var ctx = await _dbFactory.CreateDbContextAsync(ct);
+            var handled = await ctx.Tasks
+                .AsNoTracking()
+                .Include(t => t.Worktree)
+                .Where(t => t.HandlerTaskId == handlerTaskId)
+                .OrderBy(t => t.SortOrder).ThenBy(t => t.CreatedAt)
+                .ToListAsync(ct);
+            ct.ThrowIfCancellationRequested();
+            if (handled.Count == 0) return;
+
+            HandledTasks.Clear();
+            foreach (var h in handled)
+                HandledTasks.Add(new ChildOutcomeRowViewModel
+                {
+                    Id = h.Id,
+                    Title = h.Title,
+                    Status = h.Status,
+                    RoadblockCount = h.RoadblockCount,
+                    WorktreeState = h.Worktree?.State ?? ClaudeDo.Data.Models.WorktreeState.Active,
+                });
+            OnPropertyChanged(nameof(HasHandledTasks));
+        }
+        catch (OperationCanceledException) { }
+        catch { /* best-effort */ }
+    }
+```
+
+- [ ] **Step 6: Keep the rows live**
+
+In the same file, in `RefreshChildOutcomeAsync`, replace:
+
+```csharp
+        var row = ChildOutcomes.FirstOrDefault(c => c.Id == childTaskId);
+        if (row is null) return;
+```
+
+with:
+
+```csharp
+        // The same refresh serves both lists: a planning parent's children and a handler run's
+        // handled tasks. Only one of them can hold a given id.
+        var row = ChildOutcomes.FirstOrDefault(c => c.Id == childTaskId)
+                  ?? HandledTasks.FirstOrDefault(c => c.Id == childTaskId);
+        if (row is null) return;
+```
+
+- [ ] **Step 7: Render the panel**
+
+In `src/ClaudeDo.Ui/Views/Islands/Detail/WorkConsole.axaml`, directly after the closing
+`</StackPanel>` of the existing `<!-- Child outcomes -->` block, add:
+
+```xml
+            <!-- Handled tasks (list handler run) -->
+            <StackPanel Spacing="6" IsVisible="{Binding HasHandledTasks}">
+              <TextBlock Classes="section-label" Text="HANDLED TASKS" />
+              <ItemsControl ItemsSource="{Binding HandledTasks}">
+                <ItemsControl.ItemTemplate>
+                  <DataTemplate x:DataType="vm:ChildOutcomeRowViewModel">
+                    <Grid ColumnDefinitions="*,Auto,Auto" Margin="0,2">
+                      <TextBlock Grid.Column="0" Text="{Binding Title}"
+                                 TextTrimming="CharacterEllipsis"
+                                 VerticalAlignment="Center" />
+                      <TextBlock Grid.Column="1" Text="{Binding RoadblockText}"
+                                 IsVisible="{Binding HasRoadblock}"
+                                 Foreground="#E0A030"
+                                 Margin="8,0" VerticalAlignment="Center" />
+                      <TextBlock Grid.Column="2" Text="{Binding StatusLabel}"
+                                 Opacity="0.75" VerticalAlignment="Center" />
+                    </Grid>
+                  </DataTemplate>
+                </ItemsControl.ItemTemplate>
+              </ItemsControl>
+            </StackPanel>
+```
+
+- [ ] **Step 8: Run the tests to verify they pass**
+
+Run: `dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release --filter "FullyQualifiedName~DetailsIslandHandledTasksTests"`
+Expected: `Passed! - Failed: 0, Passed: 2`.
+
+Run: `dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release`
+Expected: `Build succeeded`.
+
+- [ ] **Step 9: Commit**
+
+```bash
+git add src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs src/ClaudeDo.Ui/Views/Islands/Detail/WorkConsole.axaml tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandHandledTasksTests.cs
+git commit -- src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs src/ClaudeDo.Ui/Views/Islands/Detail/WorkConsole.axaml tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandHandledTasksTests.cs -m "feat(ui): list the tasks a handler run processed on its detail pane"
+```
+
+---
+
+## Task 6: Full verification and docs
+
+**Files:**
+- Modify: `src/ClaudeDo.Data/CLAUDE.md` (TaskEntity field list)
+- Modify: `src/ClaudeDo.Ui/CLAUDE.md` (TaskRowViewModel + DetailsIslandViewModel bullets)
+- Modify: `docs/explore-notes/conpty-sessions.md` (list handler → host task section)
+
+- [ ] **Step 1: Run every affected test project**
+
+```bash
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Data.Tests/ClaudeDo.Data.Tests.csproj -c Release
+dotnet test tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj -c Release
+```
+
+Expected: `Failed: 0` in all four. If a hand-rolled fake in a test project fails to compile,
+it is one of the known `IWorkerClient`/ViewModel-ctor fakes — update it; do not skip the test.
+
+- [ ] **Step 2: Update `src/ClaudeDo.Data/CLAUDE.md`**
+
+In the `TaskEntity` bullet, append `HandlerTaskId` to the field enumeration (after
+`HandlerBaseCommit / HandlerHeadCommit`), and add a sub-bullet under the existing
+`HandlerBaseCommit`/`HandlerHeadCommit` sub-bullet:
+
+```markdown
+  - `HandlerTaskId` = back-link from a task to the **list handler run** that processed it (1:n, last run wins, no FK). Stamped from the user's selection when the handler task is created, so tasks the handler later cancels as duplicates stay listed. Deliberately not `ParentTaskId` — that is the planning-child relation and drives the indented tree.
+```
+
+- [ ] **Step 3: Update `src/ClaudeDo.Ui/CLAUDE.md`**
+
+In the `DetailsIslandViewModel` bullet, after the `ChildOutcomes` mention, add
+`, plus `HandledTasks` (tasks a list-handler run processed, via `HandlerTaskId`)`.
+
+In the `TaskRowViewModel` sentence, after the `IsManual` clause, add
+`, `IsHandlerRun` (→ HANDLER badge, which outranks MANUAL)`.
+
+- [ ] **Step 4: Update `docs/explore-notes/conpty-sessions.md`**
+
+In the "The host task and its commit range" section, add after the existing description:
+
+```markdown
+`CreateMergeHelperTaskAsync` also stamps `TaskEntity.HandlerTaskId` on every selected task
+(`TaskRepository.SetHandlerTaskIdAsync`) before the session starts, so the handler task's detail
+pane can list what the run was meant to process — including tasks phase 1 cancels as duplicates.
+The handler never links to itself.
+```
+
+Bump that note's "verified against" commit line to the current HEAD.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/ClaudeDo.Data/CLAUDE.md src/ClaudeDo.Ui/CLAUDE.md docs/explore-notes/conpty-sessions.md
+git commit -- src/ClaudeDo.Data/CLAUDE.md src/ClaudeDo.Ui/CLAUDE.md docs/explore-notes/conpty-sessions.md -m "docs(handler): document the handler-run task link"
+```
+
+- [ ] **Step 6: Report the visual-verification gap**
+
+The build and tests cannot confirm any of this renders correctly. Explicitly hand these to Mika:
+
+1. HANDLER badge colour and legibility on a handler task row (light **and** dark theme), and that MANUAL is gone from that row while still present on a normal manual reminder.
+2. The HANDLED TASKS panel on the handler task's Session tab: position relative to OUTCOMES, spacing, and behaviour with ~20 handled tasks (scroll).
+3. That a real "Let Claude handle it" run over a multi-task selection produces a populated panel after the run, including a phase-1-cancelled duplicate.

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-06-19-feature-unification-design.md

@@ -35,7 +35,7 @@ the engine.
 | A1 | Diff viewing | `DiffModalViewModel` (worktree + commit-range), `WorktreeModalViewModel` (file-tree + per-file), `PlanningDiffViewModel` (per-subtask + integration) | `UnifiedDiffParser`, `DiffLinesView` (good) |
 | A2 | Agent-config editing | `ListSettingsModalViewModel` (list scope), `AgentSettingsSectionViewModel` (task scope); global lives in `SettingsModalViewModel` | `InheritanceResolver`, `InheritedBadge` (good) |
 | A3 | Worktree actions | `WorktreesOverviewModalViewModel` per-row cmds (Merge/Discard/Keep/ForceRemove/ShowDiff/Jump) vs `MergeSectionViewModel` (Merge/OpenDiff) | same `IWorkerClient` calls |
-| A4 | Merge display | `AgentStripView` re-displays `MergeSectionViewModel` state | — |
+| A4 | Merge display | ~~`AgentStripView` re-displays `MergeSectionViewModel` state~~ — resolved 2026-08-06: `AgentStripView` was dead (never bound after the task-detail redesign); deleted instead of unified | — |
 
 ### Bucket B — entry-point sprawl (one backend, many hand-wired doors)
 
@@ -43,7 +43,7 @@ the engine.
 |---|---|---|---|
 | B1 | Conflict-resolution seam | 5 copies of `Func<string,string,Task>? RequestConflictResolution` | `WorktreesOverviewModalViewModel.cs:83`, `DiffModalViewModel.cs:75`, `MergeModalViewModel.cs:33`, `MergeSectionViewModel.cs:51`, `DetailsIslandViewModel.cs:347` (delegates). Threaded through `MainWindow.axaml.cs:81`, `IslandsShellViewModel.cs:49/202`, `DiffModalViewModel.cs:103`, `MergeSectionViewModel.cs:159` |
 | B2 | Diff (open) | 3–4 | MergeSection "Open Diff", TaskHeaderBar "Review Merged Diff", WorktreesOverview "Show Diff", Planning "Review Combined" |
-| B3 | List Settings dialog | 3 | Lists context menu, Tasks header button, shell bridge `IslandsShellViewModel.cs:190-194` |
+| B3 | List Settings dialog | 2 (was 3 — Lists context menu entry removed 2026-08-06) | Tasks header button, double-click on a list row, shell bridge `IslandsShellViewModel.cs:190-194` |
 | B4 | Worktrees Overview | 2–3 | Repos menu (global), Lists context menu (per-list) |
 | B5 | Repo Import | 2 | Repos menu, Lists footer button |
 

docs/superpowers/specs/2026-08-06-planning-chain-fork-base-design.md

@@ -0,0 +1,235 @@
+# Planning-Chain Children: Fork Base Commit (Design Options, No Implementation)
+
+**Date:** 2026-08-06
+**Status:** Options evaluated, recommendation given — decision pending (Mika)
+**Scope:** Analysis only. No production code changed by this document.
+
+## Problem
+
+The planning chain gives **ordering**, not **code inheritance**. `PlanningChainCoordinator.SetupChainAsync`
+(`src/ClaudeDo.Worker/Planning/PlanningChainCoordinator.cs:36-72`) links children via
+`BlockedByTaskId` (child[i] blocks on child[i-1]) so they run one at a time. But each child's
+worktree is still created from **main's current HEAD**, not from the predecessor's branch, so
+child N+1 never sees child N's (unmerged) work.
+
+**Observed failure (unit `44241dcb`, "Installer: Environment-Checks", 2026-08-05):** 7 of 9
+children succeeded; the two that depended on a sibling's output could not:
+
+- `4e196058` ("Claude Help Me" button) — reported: *"the task spec assumes an existing
+  SystemCheckPage/EnvironmentCheckReport/ExecutableResolver, but that code only exists on an
+  unmerged sibling branch (claudedo/06aca9b3...). A fast-forward merge of that branch was
+  attempted ... but was denied twice by the auto-mode permission classifier. No implementation
+  work was done."*
+- `c22cdd06` (Diagnose section) — *"Blocked before implementation could start."*
+
+Both correctly reported `CLAUDEDO_BLOCKED` and committed nothing (`ahead: 0`). A second-order
+symptom of the same root cause: `ExecutableResolver.cs` was independently created **twice**
+(`40272c0b`, `06aca9b3`, near-identical) and collided as an add/add conflict at unit-merge time.
+
+## Ist-Zustand (verified against commit `816f247`, 2026-08-06)
+
+### Where the base commit is chosen
+
+`WorktreeManager.ResolveBaseCommitAsync` — `src/ClaudeDo.Worker/Runner/WorktreeManager.cs:191-207`:
+
+```csharp
+private async Task<string> ResolveBaseCommitAsync(TaskEntity task, string workingDir, CancellationToken ct)
+{
+    if (task.ParentTaskId is not null)
+    {
+        var parent = ...;
+        if (parent is not null && parent.PlanningPhase == PlanningPhase.None)
+        {
+            var parentWt = await new WorktreeRepository(ctx).GetByTaskIdAsync(task.ParentTaskId, ct);
+            var parentHead = parentWt?.HeadCommit ?? parentWt?.BaseCommit;
+            if (parentHead is not null)
+                return parentHead;
+        }
+    }
+    return await _git.RevParseHeadAsync(workingDir, ct);   // planning children land here
+}
+```
+
+**A "don't fork from main" mechanism already exists** — but only for *improvement* children
+(a non-planning parent's own follow-up subtasks), which base off `task.ParentTaskId`'s worktree
+HEAD. The guard `parent.PlanningPhase == PlanningPhase.None` explicitly **excludes** planning
+children: their `ParentTaskId` points at the planning parent (which has no worktree of its own),
+not at a sibling, so this branch never fires for them and they fall through to `RevParseHeadAsync`
+= main HEAD. This is a deliberate exclusion in the existing code, not an oversight — it simply
+never anticipated that a planning child's *predecessor in the chain* (not its parent) might be
+the thing to inherit from.
+
+Called from `WorktreeManager.CreateAsync` (`:35`), invoked by `TaskRunner` (`Runner/TaskRunner.cs:309`)
+at the moment a task transitions to `Running` — i.e. worktree creation happens per-run, not once
+at plan-finalize time.
+
+### Children already run strictly sequentially — this is not a new constraint
+
+`SetupChainAsync` sets `BlockedByTaskId` on every child but the first
+(`Planning/PlanningChainCoordinator.cs:61-69`); the queue picker only claims rows with
+`BlockedByTaskId IS NULL`. `OnChildFinishedAsync` (`:92-120`) unblocks the successor **only**
+after the predecessor reaches `Done` (and cascades cancellation down the chain on
+Failed/Cancelled). `OverrideSlotService.RunNow` (`Queue/OverrideSlotService.cs:32-42`) is the one
+path that bypasses this — it calls `StartRunningAsync` directly with no `BlockedByTaskId` check,
+so a user can manually force a later child to run out of turn.
+
+Net: under the normal (queue-driven) path, by the time child N+1's worktree is created, child N
+is already terminal. Forking N+1 from N's branch tip instead of main's HEAD does **not** introduce
+any new concurrency constraint on the normal path — the sequencing already exists. It only matters
+for the `RunNow` bypass edge case (see Option 1 below).
+
+### The merge side already treats the unit as a sequential chain, twice over
+
+`PlanningMergeOrchestrator.DrainAsync` (`Planning/PlanningMergeOrchestrator.cs:183-229`) merges
+`Done` children into `targetBranch` **one at a time, in `SortOrder`**, via
+`TaskMergeService.MergeAsync`; the first conflict pauses the whole drain
+(`PlanningMergeConflict`, state kept for `ContinueAsync`/`AbortAsync`), and the first
+non-conflict failure **aborts the drain outright** — remaining children are never merged and the
+parent never reaches `Done` (`:208-215`).
+
+`PlanningAggregator.BuildIntegrationBranchAsync` (`Planning/PlanningAggregator.cs:81-126`) — used
+for the pre-approve combined-diff preview — does the same thing again: builds a scratch
+integration branch off `targetBranch` and `MergeNoFfAsync`s each child's branch in, in
+`SortOrder`, stopping at the first conflict.
+
+So **both** the actual unit-merge and its preview already model the child set as an ordered
+sequence where one bad link can stall everything downstream. The only place in the whole pipeline
+that still treats planning children as N independent forks of main is worktree creation.
+
+## Options evaluated
+
+### Option 1 — child forks from the predecessor's branch
+
+Extend `ResolveBaseCommitAsync` (or a planning-specific sibling of it) to also handle planning
+children: look up the chain predecessor via `BlockedByTaskId` (not `ParentTaskId` — that points at
+the planning parent, which has no worktree) and use its `WorktreeEntity.HeadCommit ?? BaseCommit`
+the same way the improvement-child path already does.
+
+**What actually breaks, given the Ist-Zustand above:**
+
+- *Not* a new concurrency constraint (see above) — the chain already serializes execution.
+- *Not* a new "one failure blocks everyone" behavior at merge time — `DrainAsync` already aborts
+  the whole drain on the first non-conflict failure, and the integration-branch preview already
+  stops at the first conflict. Option 1 brings execution-time behavior in line with what merge-time
+  behavior already is, rather than introducing a new failure mode.
+- **Genuinely new:** child N+1's branch now contains N's commits as ancestors. When N is later
+  merged into `targetBranch` with `--no-ff` and N+1 is merged afterward, N+1's diff against N's
+  content is empty (identical trees) — merges cleanly as a no-op for that slice, verified by the
+  same mechanism `DrainAsync` already uses. No new conflict class is introduced; if anything this
+  *removes* one: the `ExecutableResolver.cs` add/add collision would not have occurred, since N+1
+  would start from a tree that already has the file.
+- **Genuinely new edge case:** `OverrideSlotService.RunNow` on a chain member whose predecessor
+  hasn't produced a `WorktreeEntity`/`HeadCommit` yet. Needs an explicit fallback to main HEAD —
+  the same `?? ` pattern the improvement-child branch already uses for a predecessor with no
+  `HeadCommit` (never committed) covers most of this; a predecessor that was never even *run* needs
+  the same fallback-to-`RevParseHeadAsync` the code already falls through to today.
+- **Genuinely new edge case:** a discarded/failed predecessor's worktree row still carries its last
+  `HeadCommit`/`BaseCommit` (the row isn't deleted on discard, only `State` flips) — same as the
+  improvement-child path already tolerates, so no new handling needed there.
+- Children still go straight to `Done` with no individual review (Unified Parent Model), so there
+  is no "reject and rewrite a middle child after a successor already forked from it" scenario to
+  worry about — that action doesn't exist in the current state machine.
+
+**Price:** deeper branch chains (cosmetic — they're squashed away by the sequential merge/prune
+regardless); one new fallback path for the `RunNow` bypass. Meaningfully smaller than it first
+looks, because it extends an existing pattern (improvement children) into a lane whose execution
+and merge sides are *already* sequential — it only fixes the one place that wasn't.
+
+### Option 2 — merge predecessor to main immediately on success, before the successor starts
+
+Keeps children independent worktrees (forked from main-as-it-is-now, updated after each merge),
+but requires a real merge to `main` per child, outside of Approve.
+
+**Breaks:**
+
+- Directly contradicts the documented invariant "**Approve is the single review+merge action**"
+  (`src/ClaudeDo.Worker/CLAUDE.md` → Status Model; `docs/explore-notes/review-merge.md` → "Approve
+  = merge the whole unit"). Unreviewed work would land on `main` automatically, mid-chain, before
+  the parent — or the user — ever sees it.
+- Requires calling `TaskMergeService.MergeAsync` from `OnChildFinishedAsync` (state-transition
+  code), duplicating what `PlanningMergeOrchestrator` already owns, and doing it against a
+  `VerifyCommand`-gated repo N times instead of once — if the gate is configured, a mid-chain
+  verify failure now has to be handled somewhere there's currently no error path for it (parent is
+  still `WaitingForChildren`, not under merge orchestration yet).
+- Unavoidably touches `TaskStateService`/status-transition semantics, which this task's scope
+  explicitly excludes ("Die Status-Logik oder `TaskStateService` anfassen" is out of scope) — this
+  option cannot be implemented without doing exactly that.
+
+**Verdict:** rejected outright — it isn't just costly, it conflicts with a stated architectural
+invariant and this task's own non-goals.
+
+### Option 3 — child may merge the predecessor's branch into its own worktree if it needs to
+
+Least invasive to the base-commit mechanism; delegates the decision to the agent at runtime.
+
+**Breaks:**
+
+- This is *exactly* what the blocked child in the observed incident already tried, and it was
+  denied twice by the auto-mode permission classifier. The real blocker isn't a missing
+  capability, it's that `git merge` trips the classifier's "risky/hard-to-reverse" heuristic
+  regardless of target — even though a merge confined to the task's own isolated worktree (never
+  touching the shared `workingDir`) is materially lower-risk than a merge on a shared checkout.
+  Fixing this option means carving a narrower permission rule (allow `git merge` only inside a
+  path under the task's own worktree root), which is a security-policy change, not a merge-model
+  change.
+- Even with permission granted, it still relies on the agent (a) noticing it's missing a
+  prerequisite, (b) correctly identifying which sibling branch has it, and (c) successfully
+  resolving any conflict that surfaces — three separate failure points per occurrence, decided
+  fresh by an LLM each time rather than encoded once in the pipeline.
+- Doesn't help children that fail *before* they'd even think to look (e.g., a child whose first
+  action is reading a file that doesn't exist yet has no signal to act on).
+
+**Verdict:** possible as a narrow permission-scope fix layered *on top of* Option 1 (so an agent
+that still needs something from further back than its immediate predecessor isn't stuck), but not
+a substitute for it — on its own it reproduces the exact failure mode from the incident, just with
+one fewer denial.
+
+### Option 4 — change nothing; require independent children at planning time
+
+Zero code changes; pushes the constraint into plan quality.
+
+**Breaks:**
+
+- No enforcement exists today (`PlanningSessionManager` doesn't validate structural independence
+  between proposed subtasks), and reliably detecting "child B depends on code child A will write"
+  from a plan draft is itself an unsolved code-review problem — not something a prompt tweak
+  guarantees.
+- A shared-foundation-plus-N-consumers decomposition (exactly the `44241dcb` shape: environment
+  checks feeding two UI consumers) is often the *correct* decomposition, not a planning mistake.
+  Banning it either forces over-merging into one giant child (defeating the purpose of splitting)
+  or requires the planner to reject a structurally sound plan.
+- Reproduces the observed failure verbatim under the same conditions: nothing about this option
+  would have caught `44241dcb` before it shipped two dead children.
+
+**Verdict:** cheapest to write down, but doesn't fix the problem — it relocates it to "the plan
+looked independent but wasn't," which is what already happened.
+
+## Recommendation
+
+**Option 1**, with the `RunNow`-bypass fallback described above, and with Option 3's narrower
+permission-scope fix as an optional follow-up (not a prerequisite) for cases where a child needs
+something from further back in the chain than its immediate predecessor.
+
+**Why:** Option 1 is not a new mechanism — it's closing the one gap in a pattern that already
+exists twice in this codebase: `WorktreeManager.ResolveBaseCommitAsync` already forks improvement
+children from their parent's HEAD instead of main, and both `PlanningMergeOrchestrator.DrainAsync`
+and `PlanningAggregator.BuildIntegrationBranchAsync` already treat the child set as an ordered
+merge sequence where the first failure stalls everything after it. Planning-child worktree
+creation is the outlier, not the rule. Extending the existing predecessor-lookup pattern (keyed
+off `BlockedByTaskId` instead of `ParentTaskId` for this lane) makes the "sees predecessor's work"
+guarantee hold everywhere the chain already implies it, without touching `TaskStateService`, the
+review model, or introducing a merge-time failure mode that doesn't already exist. Options 2 and 4
+either conflict with a stated invariant/this task's own non-goals, or fail to address the incident
+at all; Option 3 alone reproduces the incident's exact failure.
+
+**Price to pay knowingly:** a chain member that never got a chance to run (no `WorktreeEntity` yet)
+needs an explicit main-HEAD fallback when its successor is forced via `RunNow` — a few lines,
+mirroring the null-coalescing fallback the improvement-child path already has. No other new failure
+surface was found.
+
+## Explicitly out of scope (per task)
+
+- Implementing Option 1 or any other option — Mika decides first.
+- Any change to `TaskStateService` or status-transition logic.
+- Changing blocked-child visibility/behavior — that's task `001ee94a`, running in parallel; it only
+  touches MCP visibility, no production code overlap with this document.

docs/superpowers/specs/2026-08-07-diff-side-by-side-design.md

@@ -0,0 +1,225 @@
+# Diff Viewer: Side-by-Side, Syntax Highlighting, Word Diff
+
+Date: 2026-08-07
+Status: approved (design), not implemented
+
+## Problem
+
+The diff viewer renders every change as a flat unified stream. Reading what actually changed
+inside a modified line means mentally aligning a `−` row with a `+` row several rows below it.
+The user reads diffs faster side by side.
+
+Three gaps, all in the same surface:
+
+1. No side-by-side mode.
+2. No syntax highlighting — the merge editor (`ConflictResolverView`) already has it via
+   TextMate, the diff viewer does not.
+3. No intra-line (word) highlighting, so a one-character change looks like a whole-line rewrite.
+
+## Current state
+
+| Concern | Where |
+|---|---|
+| Parsing | `src/ClaudeDo.Ui/ViewModels/Modals/UnifiedDiffParser.cs` → `DiffFileViewModel.Lines` |
+| Models | `src/ClaudeDo.Ui/ViewModels/Modals/DiffModels.cs` (`DiffLineViewModel{Kind,OldNo,NewNo,Text}`, `DiffLineKind{Add,Del,Ctx,File}`) |
+| Rendering | `src/ClaudeDo.Ui/Views/Controls/DiffLinesView.axaml` — non-virtualized `ItemsControl`, one `Border`+`Grid`+4 `TextBlock`s per line, `TextWrapping="NoWrap"` |
+| Host | `src/ClaudeDo.Ui/Views/Modals/DiffViewerView.axaml` — Files mode (line 154, `SelectedFile.Lines`) and Planning mode (line 162, flattened `DiffLines` across all files) |
+| Highlighting reference | `src/ClaudeDo.Ui/Views/Conflicts/ConflictResolverView.axaml.cs:80-83` — `RegistryOptions(ThemeName.DarkPlus)` + `InstallTextMate` + `SetGrammar` by file extension |
+
+`Avalonia.AvaloniaEdit`, `AvaloniaEdit.TextMate` and `TextMateSharp.Grammars` are already
+referenced in `ClaudeDo.Ui.csproj`.
+
+## Decision
+
+Replace `DiffLinesView` with an AvaloniaEdit-based control. TextMate highlighting is bound to
+the `TextEditor` control; it cannot be lifted into `TextBlock` inlines without reimplementing
+the scope→brush layer that `AvaloniaEdit.TextMate` already provides. Building split/wrap/word
+diff on the `TextBlock` model first and swapping the renderer later would be throwaway work.
+
+Side effect worth having: AvaloniaEdit virtualizes, which removes the current non-virtualized
+`ItemsControl` as a scaling limit on large diffs.
+
+Rejected: keeping the `ItemsControl` and hand-rolling highlighting from `TextMateSharp`
+tokenization — same output, materially more code, and a second highlighting path to maintain
+alongside the merge editor's.
+
+## Layout semantics
+
+Left pane is the **old** state, right pane is the **new** state — each side carries the complete
+version of the hunk, not "removals here, additions there".
+
+```
+        LEFT (old)                       RIGHT (new)
+   12  public void Save()            12  public void Save()
+   13      var x = 1;                13      var x = 2;      ← word diff on `1` / `2`
+   14      Log("old");                ·  (filler)
+    ·  (filler)                      14      Log("new");
+   15  }                             15  }
+```
+
+## Components
+
+### 1. `DiffAlignment` (new, pure)
+
+`src/ClaudeDo.Ui/ViewModels/Modals/DiffAlignment.cs`
+
+Turns `IReadOnlyList<DiffLineViewModel>` into a render-ready `AlignedDiff`. No Avalonia types,
+fully unit-testable.
+
+```csharp
+public enum AlignedSide { Ctx, Del, Add, Filler, Gap }
+
+public readonly record struct TextSpan(int Start, int Length);
+
+public sealed record SplitRow(
+    AlignedSide LeftKind,  int? OldNo, string LeftText,  IReadOnlyList<TextSpan> LeftSpans,
+    AlignedSide RightKind, int? NewNo, string RightText, IReadOnlyList<TextSpan> RightSpans);
+
+public sealed record UnifiedRow(
+    AlignedSide Kind, int? OldNo, int? NewNo, string Text, IReadOnlyList<TextSpan> Spans);
+
+public sealed record AlignedDiff(
+    IReadOnlyList<SplitRow> SplitRows,   string LeftText, string RightText,
+    IReadOnlyList<UnifiedRow> UnifiedRows, string UnifiedText);
+```
+
+Row index `i` maps to document line `i + 1` in the corresponding text. That mapping is the
+contract the margin and both renderers depend on.
+
+**Pairing.** Walk the lines. A `Ctx` run emits rows with the same text on both sides. A change
+block (a `Del` run followed by an `Add` run) pairs index-wise up to `min(delCount, addCount)`;
+the overhang gets `Filler` rows on the opposite side.
+
+**Gaps.** The parser drops `@@` headers, so a skipped region shows up as a jump in `OldNo`/`NewNo`
+between consecutive lines. `DiffAlignment` detects that jump and inserts a `Gap` row on both
+sides. The parser is not touched.
+
+**Word diff.** Only for `(Del, Add)` rows that are paired 1:1. Tokenize each side into runs of
+word characters / whitespace / single punctuation, run an LCS over the tokens, and emit the
+changed token runs as character spans per side.
+
+Two guards, both `const` and both covered by tests:
+- Skip when either side exceeds `MaxWordDiffChars = 2000` — LCS cost, and such lines are
+  unreadable as word diffs anyway.
+- Skip when token similarity is below `MinWordDiffSimilarity = 0.5` (common tokens / max token
+  count). Below that the two lines are unrelated rewrites and per-word tinting is noise.
+
+### 2. `DiffTextView` (new control, replaces `DiffLinesView`)
+
+`src/ClaudeDo.Ui/Views/Controls/DiffTextView.axaml` + `.axaml.cs`
+
+Styled properties:
+
+| Property | Type | Meaning |
+|---|---|---|
+| `File` | `DiffFileViewModel?` | Source; the control aligns it and caches the `AlignedDiff` per file instance |
+| `Mode` | `DiffViewMode` (`Unified`\|`Split`) | Layout |
+| `WrapLines` | `bool` | Bound to each editor's `WordWrap` |
+
+Two `TextEditor`s in a two-column grid, both `IsReadOnly=true`, `ShowLineNumbers=false`.
+`Unified` mode collapses the right editor and spans the left one across both columns, feeding
+it `UnifiedText`. `Split` mode shows both, fed `LeftText` / `RightText`.
+
+Per editor:
+- **TextMate**: one shared `RegistryOptions(ThemeName.DarkPlus)`; grammar resolved from
+  `File.Path`'s extension via `GetLanguageByExtension` → `GetScopeByLanguageId` → `SetGrammar`,
+  exactly as `ConflictResolverView.ApplyGrammar` does. No extension match → no grammar, plain text.
+- **`DiffLineNumberMargin : AbstractMargin`** — draws line numbers from the row list. Split: old
+  numbers left, new numbers right. Unified: two number columns in one margin. `Filler` and `Gap`
+  rows draw nothing.
+- **`DiffLineBackgroundRenderer : IBackgroundRenderer`** — full-width tint per visual line by
+  row kind: add / del / filler / gap / ctx.
+- **`WordDiffRenderer : IBackgroundRenderer`** — stronger tint over the changed spans, via
+  `BackgroundGeometryBuilder` at `lineStartOffset + span.Start`.
+
+Both renderers resolve rows through a single `Func<int, RowInfo?>` keyed by document line.
+
+**Highlighting on fragments.** Only hunks are in the document, not whole files, so TextMate's
+line-by-line state can be wrong at a fragment boundary (a line inside a block comment may be
+highlighted as code). Accepted — the same is true of every fragment-based diff viewer.
+
+**Colors.** Line tints stay the existing low-alpha `RunningTintBrush` / `ErrorTintBrush` so
+syntax foregrounds remain legible. The per-line foreground recolor from `DiffLinesView`
+(green/red text) is dropped — syntax colors take over. `Filler` gets a new dim token brush,
+`Gap` renders as a dim `⋯` separator row.
+
+**Scroll sync** (split only), modeled on `ConflictResolverView.HookScrollSync` — find each
+editor's descendant `ScrollViewer`, guard re-entry with a `_syncing` flag:
+- `WrapLines = false`: sync `Offset.Y` directly. Line heights match, so alignment is exact.
+- `WrapLines = true`: line heights diverge. Sync on the first visible document line instead
+  (`ScrollToLine`), which keeps the top of the viewport aligned and lets rows drift downward.
+
+### 3. Host changes
+
+`DiffViewerView.axaml`:
+- Header gains a segmented Unified/Split toggle and a wrap toggle.
+- Files mode: `DiffLinesView Lines="{Binding SelectedFile.Lines}"` → `DiffTextView File="{Binding SelectedFile}"`.
+- Planning mode: the flattened single-stream `DiffLines` view is replaced by an `ItemsControl`
+  over the subtask's parsed files, each item a file header plus its own `DiffTextView`. One
+  editor can only carry one grammar, so per-file editors are required for highlighting to work
+  at all here. `DiffViewerViewModel` exposes the parsed per-file list for the selected subtask;
+  `DiffLines` and `UnifiedDiffParser.Flatten` lose their last consumer and are removed.
+
+`DiffLinesView.axaml` + `.axaml.cs` are deleted once both usages are migrated.
+
+### 4. Persistence
+
+`src/ClaudeDo.Ui/AppSettings.cs` (`~/.todo-app/ui.config.json`) already holds UI-only
+preferences (`Language`, `AccentPreset`) with plain `Load()`/`Save()`. Two properties are added
+there:
+
+```csharp
+public string DiffViewMode { get; set; } = "unified";   // "unified" | "split"
+public bool DiffWrapLines { get; set; }
+```
+
+`DiffViewerViewModel` takes the injected `AppSettings`, seeds its toggles on open and calls
+`Save()` when either changes. No database column, no EF migration, no hub method — a view
+preference does not belong in `AppSettingsEntity`.
+
+### 5. Localization
+
+New keys in both `locales/en.json` and `locales/de.json` (Localization.Tests enforces parity):
+`diff.view.unified`, `diff.view.split`, `diff.view.wrap`.
+
+## Testing
+
+`tests/ClaudeDo.Ui.Tests` — `DiffAlignment` is pure and carries the logic worth testing:
+
+- Context-only diff → identical rows on both sides, no fillers.
+- Equal-size change block → 1:1 pairing, no fillers.
+- Unequal change block (3 del / 5 add) → 3 paired rows + 2 right-side rows with left fillers.
+- Add-only and delete-only blocks → fillers on the opposite side throughout.
+- Non-contiguous line numbers → exactly one `Gap` row inserted.
+- Word diff: single-token change yields one span per side at the right offsets.
+- Word diff skipped above `MaxWordDiffChars` and below `MinWordDiffSimilarity`.
+- Row index ↔ document line mapping holds for both `SplitRows` and `UnifiedRows`.
+- Binary file and empty-content file → empty `AlignedDiff`, no crash.
+
+`AppSettings` round-trip: persisted mode and wrap survive `Save()`/`Load()`.
+
+Rendering (margin, both renderers, scroll sync, TextMate colors) is not unit-testable here and
+is an explicit manual visual pass — see Open items.
+
+## Known limitations
+
+1. **Wrap + split drift.** With wrap on, the two panes align at the top of the viewport but rows
+   drift apart further down. Per-line vertical alignment as VS Code does it is out of scope.
+2. **Fragment highlighting.** See above — highlighting state can be wrong at hunk boundaries.
+3. **Editors per file in Planning mode.** A subtask touching many files instantiates one editor
+   per file. Same cost as viewing those files individually in Files mode; not capped. If it
+   proves slow, the fix is lazy instantiation on expand, not a silent truncation.
+
+## Open items (manual verification)
+
+- Visual pass on both modes: tints legible over DarkPlus syntax colors; line numbers aligned;
+  filler and gap rows readable.
+- Scroll sync with wrap off (exact) and wrap on (top-anchored).
+- Planning mode with a multi-file subtask.
+- Toggle state survives an app restart.
+
+## Docs to update on completion
+
+- `src/ClaudeDo.Ui/CLAUDE.md` — Views/Controls list and the "Diff & Conflicts" section still
+  name `DiffLinesView`.
+- `docs/explore-notes/review-merge.md` — diff stack description + "verified against" commit.

docs/superpowers/specs/2026-08-07-handler-run-links-design.md

@@ -0,0 +1,169 @@
+# Handler-Run: Verknüpfung zu den behandelten Tasks
+
+**Date:** 2026-08-07
+**Status:** Design approved (Mika), implementation pending
+**Verified against:** commit `c792765`
+
+## Problem
+
+Ein "Let Claude handle it"-Run besitzt seit 2026-08-05 einen echten Task (`IsManual=true`,
+`HandlerBaseCommit`/`HandlerHeadCommit`, Diff über Commit-Range). Was fehlt: **welche Tasks der Run
+behandelt hat, ist nirgends persistiert.** Die Auswahl lebt nur in der ConPTY-Session und im
+Transcript; `HandoffMcpTools.HandoffListHandler` (`src/ClaudeDo.Worker/External/HandoffMcpTools.cs:28-45`)
+bekommt `survivingTaskIds` als flüchtige Liste.
+
+Folge: Nachdem ein Run durch ist und der Diff sichtbar wird, lässt sich nicht mehr nachvollziehen,
+*was alles gemacht werden sollte* und *welcher Task was produziert hat*. Duplikate, die der Handler
+in Phase 1 gecancelt hat, verschwinden vollständig aus dem Blickfeld.
+
+Zweitens zeigt der Handler-Task in der Liste das Badge **MANUAL**, weil er `IsManual=true` setzt —
+irreführend, denn es ist kein manueller Reminder.
+
+## Ist-Zustand
+
+### Es gibt kein Task-Kind
+
+`TaskEntity` hat **kein `Kind`/`Type`-Enum**. Task-"Arten" sind heute Feld-Kombinationen:
+
+| Feld | Bedeutung |
+|---|---|
+| `IsManual` | manueller Reminder — Queue/Daily-Prep/Refine überspringen ihn |
+| `ParentTaskId` | Kind einer Planning-/Improvement-Session |
+| `PlanningPhase` | Planning-Parent |
+| `BlockedByTaskId` | Kettenglied, Queue-Picker überspringt es |
+| `HandlerBaseCommit` | worktree-loser List-Handler-Host (`src/ClaudeDo.Data/Models/TaskEntity.cs:60-61`) |
+
+Ein Handler-Task ist also allein durch `HandlerBaseCommit != null` identifiziert.
+
+### `ParentTaskId` ist belegt
+
+`TaskRepository.CreateChildAsync` (`src/ClaudeDo.Data/Repositories/TaskRepository.cs:306`) setzt es
+für Planning-Kinder; `TaskRowViewModel.IsChild`/`ShowAsChild`
+(`src/ClaudeDo.Ui/ViewModels/Islands/TaskRowViewModel.cs:59,66`) hängen daran und rücken die Zeile
+im Baum ein. Ein Recycling für Handler→behandelte Tasks würde die Auswahl optisch unter den Handler
+schieben und mit echten Planning-Kindern kollidieren.
+
+### Badge-Infrastruktur existiert
+
+`TaskRowView.axaml:129-144` rendert DRAFT / PLANNED / PLANNING / MANUAL über
+`Border Classes="badge <variant>"`. Basis-Style und Varianten liegen in
+`src/ClaudeDo.Ui/Design/IslandStyles.axaml:963-990`, die Brushes als theme-fähige Tokens in
+`Tokens.axaml`. Loc-Keys: `tasks.badgeManual`, `tasks.manualTip` (en.json:163-164).
+
+### Kinder-Panel existiert
+
+`DetailsIslandViewModel.LoadChildOutcomesAsync`
+(`src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs:704-748`) lädt
+`Where(t => t.ParentTaskId == parentTaskId)` in `ChildOutcomes` (`:248`) und rendert pro Zeile
+Id/Titel/Status/RoadblockCount/WorktreeState via `ChildOutcomeRowViewModel`; Refresh läuft über
+`TaskUpdated`/`WorktreeUpdated` (`:814-833`).
+
+## Entscheidungen
+
+| Frage | Entscheidung | Begründung |
+|---|---|---|
+| Neues `TaskKind`-Enum? | **Nein** | Es gäbe kein Enum zu erweitern — es wäre das erste überhaupt, inkl. Migration und Rückwirkung auf Queue/Filter/UI. Der Bedarf ist eine Beziehung, kein Typ. |
+| `ParentTaskId` wiederverwenden? | **Nein** | belegt durch Planning-Kinder, kollidiert mit Einrückungs-Logik |
+| 1:n oder n:m? | **1:n**, eine nullable Spalte | Historie "welcher Run hat den Task mal berührt" bringt nichts, wenn ohnehin der letzte Run derjenige ist, dessen Diff man ansieht. Join-Tabelle = doppelter Code für einen Randfall. |
+| Wann stempeln? | **Beim Anlegen des Handler-Tasks** | Die UI kennt die Auswahl bereits. Erfasst auch die Tasks, die der Handler in Phase 1 als Duplikat cancelt — genau das "was sollte alles gemacht werden". Ein Stempeln erst in `handoff_list_handler` würde Dedupe-Verlierer verlieren und bei Abbruch vor Phase 2 gar nichts verknüpfen. |
+| Umfang der Anzeige | **Nur Liste + Endstatus** | Kein Phasen-Protokoll, kein Per-Task-Diff im Panel — der Diff hängt ohnehin am jeweiligen Task. |
+
+## Design
+
+### 1. Daten
+
+Neue nullable Spalte auf `TaskEntity`:
+
+```csharp
+/// <summary>Id des Handler-Task-Runs, der diesen Task behandelt hat (null = keiner).</summary>
+public string? HandlerTaskId { get; set; }
+```
+
+Konfiguration in `TaskEntityConfiguration`: `HasIndex(t => t.HandlerTaskId)`, kein FK-Constraint
+(konsistent mit `BlockedByTaskId`-Handhabung; ein gelöschter Handler-Task soll die behandelten Tasks
+nicht kaskadierend anfassen). EF-Core-Migration `AddHandlerTaskId`.
+
+Ein zweiter Run über dieselben Tasks überschreibt die Zuordnung — gewollt (1:n).
+
+### 2. Schreiben
+
+Die Auswahl wird durchgereicht: UI → `IWorkerClient.CreateMergeHelperTaskAsync` → 
+`WorkerHub.CreateMergeHelperTask` (`src/ClaudeDo.Worker/Hub/WorkerHub.cs:827-838`) →
+`InteractiveLaunchSpecService.CreateMergeHelperTaskAsync`. Nach dem Anlegen des Handler-Tasks setzt
+eine neue Repository-Methode die Zuordnung in einem Batch-Update:
+
+```csharp
+Task<int> SetHandlerTaskIdAsync(IReadOnlyList<string> taskIds, string handlerTaskId, CancellationToken ct);
+```
+
+Der Handler-Task selbst bekommt **kein** `HandlerTaskId` (kein Selbstbezug). Unbekannte Ids werden
+still übersprungen.
+
+### 3. Badge
+
+`TaskRowViewModel`:
+
+```csharp
+public bool IsHandlerRun => !string.IsNullOrEmpty(HandlerBaseCommit);
+public string? HandlerBadge => IsHandlerRun ? Loc.T("tasks.badgeHandler") : null;
+public string? ManualBadge => IsManual && !IsHandlerRun ? Loc.T("tasks.badgeManual") : null;
+```
+
+`HandlerBaseCommit` muss dafür auf das Row-ViewModel und in dessen Mapping aufgenommen werden.
+HANDLER hat Vorrang vor MANUAL — beide Badges nie gleichzeitig.
+
+In `TaskRowView.axaml` analog zu `:141-144` ein `Border Classes="badge handler"` mit
+`ToolTip.Tip="{loc:Tr tasks.handlerTip}"`. In `IslandStyles.axaml` eine `.badge.handler`-Variante
+mit `{DynamicResource HandlerBadgeBrush}`, Token in `Tokens.axaml` für Light und Dark.
+
+Neue Loc-Keys in en.json **und** de.json (Parität ist testgeprüft):
+
+- `tasks.badgeHandler` — "HANDLER" / "HANDLER"
+- `tasks.handlerTip` — "Handler run — lists the tasks it processed" / "Handler-Run — listet die
+  Tasks, die er bearbeitet hat"
+
+### 4. Anzeige
+
+Im Detail-Bereich eines Handler-Tasks eine Liste der behandelten Tasks, parallel zum bestehenden
+Kinder-Panel:
+
+- Neue Collection `HandledTasks` auf `DetailsIslandViewModel`, befüllt von `LoadHandledTasksAsync`
+  mit `Where(t => t.HandlerTaskId == taskId)`, sortiert wie die Kinder-Liste.
+- Zeilen wiederverwenden `ChildOutcomeRowViewModel` (Id, Titel, Status, RoadblockCount,
+  WorktreeState) — keine neue Row-Klasse.
+- Refresh über dieselben `TaskUpdated`-Events wie `ChildOutcomes`; der bestehende
+  `RefreshChildOutcomeAsync`-Pfad (`:814-833`) wird um die zweite Collection erweitert.
+- Sichtbar nur wenn `HandledTasks.Count > 0`.
+- **Keine Klick-Interaktion** — das bestehende `ChildOutcomes`-Template ist eine reine Anzeige
+  (Titel / Roadblock / Status, kein Tapped-Handler). Die neue Liste bleibt identisch; "zum Task
+  springen" wäre neues Verhalten und ist hier nicht enthalten.
+
+### 5. Fehlerfälle
+
+- Handler-Task gelöscht → `HandlerTaskId` der behandelten Tasks zeigt ins Leere; die Tasks bleiben
+  normal nutzbar, das Panel existiert schlicht nicht mehr. Kein Cleanup nötig.
+- Behandelter Task gelöscht → verschwindet aus der Liste (Query läuft live gegen die Tasks).
+- Leere Auswahl → kein Stempeln, Panel bleibt unsichtbar.
+
+## Tests
+
+| Ebene | Test |
+|---|---|
+| Data | `SetHandlerTaskIdAsync` stempelt alle übergebenen Ids, ignoriert unbekannte, überschreibt eine vorhandene Zuordnung |
+| Worker | `CreateMergeHelperTaskAsync` stempelt die übergebene Auswahl und **nicht** den Handler-Task selbst |
+| Ui | `TaskRowViewModel`: HANDLER schlägt MANUAL (`IsManual=true` + `HandlerBaseCommit` gesetzt → nur HANDLER) |
+| Ui | `DetailsIslandViewModel`: `HandledTasks` lädt nach `HandlerTaskId`, aktualisiert sich auf `TaskUpdated` |
+| Localization | Parität en/de — deckt der bestehende Test automatisch ab |
+
+## Bewusst nicht enthalten
+
+- Kein `TaskKind`-Enum.
+- Keine n:m-Historie über mehrere Runs.
+- Kein Phasen-Protokoll (Dedupe-Begründungen, Umformulierungen) — nur das Ergebnis.
+- Kein Per-Task-Diff im Panel; der Diff bleibt am jeweiligen Task.
+- Kein Badge auf den *behandelten* Tasks.
+
+## Offen
+
+- **Sichtprüfung durch Mika:** Badge-Farbe im Light- und Dark-Theme, Position des Panels im
+  Detail-Bereich, Verhalten bei vielen behandelten Tasks (Scroll).

docs/superpowers/specs/2026-08-07-ui-reaktivitaet-und-listen-performance-design.md

@@ -0,0 +1,173 @@
+# UI-Reaktivität und Listen-Performance
+
+**Datum:** 2026-08-07
+**Status:** Design freigegeben, Implementierung offen
+
+## Problem
+
+Zwei Symptome, die als eines gemeldet wurden:
+
+1. **Stale UI.** Ein Task bleibt in der Liste auf `Queued` stehen, obwohl der Worker ihn längst auf `Running` gesetzt hat. Ebenso tauchen extern angelegte Tasks (Online-Inbox, List-Handler) erst nach einem manuellen Neuladen auf. Modals und Overlays zeigen den Stand vom Öffnungszeitpunkt.
+2. **Langsames Laden.** Eine Liste mit ~125 erledigten Tasks braucht 1–2 Sekunden zum Öffnen. Ziel sind Listen mit bis zu ~1000 erledigten Tasks.
+
+## Analyse
+
+### Reaktivität: es fehlt kein Event, es fehlt die Selbstheilung
+
+Der Broadcast-Pfad ist im Grundsatz korrekt: der Worker schreibt in die DB, committet, und sendet danach eine ID über SignalR (`HubBroadcaster`); die UI lädt die Entity frisch nach. WAL-Sichtbarkeit und EF-Change-Tracking wurden als Ursache **ausgeschlossen** — die UI nutzt `IDbContextFactory` mit kurzlebigen Kontexten, und WAL-Reader sehen Commits sofort.
+
+Das eigentliche Problem: **ein einziger verlorener Event ist permanent.** Der einzige Reconcile-Trigger ist heute `ConnectionRestoredEvent`, also ein Verbindungsabbruch. Es gibt drei Wege, auf denen ein Update verloren geht:
+
+| # | Loch | Ort |
+|---|---|---|
+| 1 | Blankes `catch { }` um den gesamten Delta-Pfad. Eine einzige transiente Exception (z.B. `SQLITE_BUSY`) lässt die Zeile dauerhaft auf dem alten Stand — ohne Log, ohne Retry. | `src/ClaudeDo.Ui/ViewModels/Islands/TasksIslandViewModel.cs:224` |
+| 2 | `QueuePicker.ClaimNextAsync` committet `status='running'` sofort. Wirft danach etwas in `RunInSlotAsync` oder im ungeschützten Setup-Block von `TaskRunner.ContinueAsync` (Zeilen 218–238 liegen außerhalb jedes `try`), fängt der Catch das ab und **loggt nur** — kein `FailAsync`, kein Broadcast. DB sagt Running, die UI erfährt es nie. | `src/ClaudeDo.Worker/Queue/QueueService.cs:349-352` |
+| 3 | DB-Writes ohne Broadcast. | `src/ClaudeDo.Worker/Runner/WorktreeManager.cs:103`, `src/ClaudeDo.Worker/Online/OnlineSyncService.cs:131` |
+
+**Korrektur (2026-08-07, bei der Umsetzung gefunden):** `InteractiveLaunchSpecService.cs:447` stand hier ursprünglich als drittes Loch. Das war falsch. Die Service-Methode broadcastet zwar selbst nicht, aber ihr einziger Produktions-Aufrufer `WorkerHub.CreateMergeHelperTask` (`src/ClaudeDo.Worker/Hub/WorkerHub.cs:818`) sendet direkt danach `TaskUpdated` — seit Commit `c07c1f7` vom 2026-08-05, abgesichert durch `MergeHelperTaskHubTests.CreateMergeHelperTask_CreatesIdleManualTask_StampsBaseCommit_Broadcasts`. Der ursprüngliche Befund hatte den DB-Write gesehen, aber den Aufrufer nicht geprüft. Ein Broadcast im Service wäre ein Duplikat gewesen.
+
+Dazu zwei kleinere Befunde:
+
+- **Race im Delta-Pfad.** `OnWorkerTaskUpdated` ist `async void` und hängt an *zwei* Events (`TaskUpdatedEvent` und `WorktreeUpdatedEvent`, `TasksIslandViewModel.cs:117-118`). Der Full-Reload-Zweig ist per `_loadCts` gegen Überholen abgesichert, der Delta-Zweig nicht — ein älterer Read kann einen neueren überschreiben.
+- ~~**Kein Busy-Timeout konfiguriert.**~~ **Widerlegt (2026-08-07, empirisch geprüft).** Die Vermutung war, die blanken Connection-Strings (`src/ClaudeDo.App/Program.cs:95`, `src/ClaudeDo.Worker/Program.cs:61`) ließen einen `SQLITE_BUSY` sofort durchschlagen. Das stimmt nicht: Microsoft.Data.Sqlite 8.0.11 setzt `DefaultTimeout` **von sich aus auf 30 Sekunden**, mit oder ohne das Keyword — gemessen an `SqliteConnectionStringBuilder("Data Source=x.db").DefaultTimeout` → `30`, ebenso `SqliteConnection.DefaultTimeout` und `SqliteCommand.CommandTimeout`. Ein Contention-Test (Writer hält 2s, zweiter Writer parallel) zeigt, dass der zweite wartet und nach ~2030 ms durchkommt, statt zu werfen. Der ursprünglich dafür gemachte Commit `f62dbb9` war ein No-op mit irreführendem Kommentar und wurde mit `ac58679` zurückgenommen. Die tatsächliche Absicherung gegen transiente Lesefehler leistet der Retry im Delta-Pfad, nicht ein Timeout.
+- **`RunCreated` ist ein totes Event.** Wird in `TaskRunner.cs:358` gesendet, hat aber keinen einzigen Abonnenten in der UI.
+
+### Performance: der Engpass ist das Rendering, nicht die Datenbank
+
+SQLite ist hier **nicht** der Engpass, und ein DB-Wechsel würde nichts verbessern. Die Kosten verteilen sich so:
+
+| Posten | bei 125 Zeilen |
+|---|---|
+| SQLite-Read, 125 Zeilen × ~30 Spalten, 2 Joins | < 1 ms |
+| EF-Materialisierung | ~1–5 ms |
+| **Avalonia baut ~8.500 Controls mit Bindings** | **~1.000–1.500 ms** |
+
+Eine `TaskRowView` erzeugt **~68 Controls eager**: ~50 für Struktur und Inhalt plus 18 `MenuItem`-Deklarationen des inline deklarierten ContextMenus (`TaskRowView.axaml:35-85`). Die Liste ist **nicht virtualisiert**: drei `ItemsControl` (Overdue/Open/Completed) liegen in einem gemeinsamen `ScrollViewer` ohne `ItemsPanel`-Override (`TasksIslandView.axaml:100,119,152`). `ItemsControl` nutzt per Default ein normales `StackPanel`, und der gemeinsame `ScrollViewer` gibt allen dreien unbegrenzte Höhe — deshalb würde auch ein bloßes Setzen von `VirtualizingStackPanel` nichts bewirken.
+
+Zeilenhöhe ~68px, verfügbare Listenhöhe auf 2560×1440 ~1250px → **~19 Zeilen gleichzeitig sichtbar**.
+
+| | Controls | geschätzt |
+|---|---|---|
+| heute, 125 Tasks | ~8.500 | 1–2 s |
+| heute, 1000 Tasks | ~68.000 | ~10 s+ |
+| virtualisiert (19 sichtbar + Overscan ≈ 25 Zeilen) | ~1.700 | ~250 ms |
+| + ContextMenu lazy | ~1.250 | ~180 ms |
+
+Entscheidend: die virtualisierten Werte sind **konstant** und gelten für 125 wie für 10.000 Zeilen.
+
+Nebenbefund: `LoadForList` (`TasksIslandViewModel.cs:305-309`) hat **kein `.Where()` vor `ToListAsync()`** — es lädt die komplette `tasks`-Tabelle aller Listen mit zwei Joins und filtert danach in C#. Die vorhandenen Indizes (`idx_tasks_list_id`, `idx_tasks_status`) werden dadurch nie genutzt. Bei der heutigen DB-Größe unkritisch, aber es skaliert mit der DB-Gesamtgröße statt mit der Listengröße.
+
+### Drag & Drop: architektonisch virtualisierungsfähig
+
+Die Task-Liste nutzt **kein** Avalonia-`DragDrop` pro Item, sondern ein eigenes Ghost-Drag:
+
+- Vier Pointer-Handler hängen **zentral** an der `TasksIslandView` (`TasksIslandView.axaml.cs:40-43`, Tunnel-Routing) — keine pro-Zeile registrierten Handler, die beim Container-Recycling leaken könnten.
+- Das Ziel wird per `InputHitTest` live ermittelt (`TasksIslandView.axaml.cs:304-329`) — kein Index-Hack, recycling-sicher.
+- Drop-Hints sind reine ViewModel-Properties (`TaskRowViewModel.cs:25-26`, `DropHintAbove`/`DropHintBelow`).
+- Der Ghost ist ein `RenderTargetBitmap`-Snapshot in einem separaten Topmost-Fenster (`Views/Controls/TaskDragController.cs`), losgelöst vom Visual Tree.
+
+Anzupassen sind:
+
+- `FindNextInSameSection` und `SectionFor` (`TasksIslandViewModel.cs:366-374`, `:622-628`) iterieren per `IndexOf` über die drei UI-Collections. Die flache Master-Collection `Items` existiert bereits (`TasksIslandViewModel.cs:55`) und ist korrekt sortiert — das ist der Grund, warum das Flatten bezahlbar ist.
+- **Auto-Scroll beim Ziehen fehlt komplett.** Fällt heute weniger auf, weil alle Container realisiert sind; bei einer virtualisierten Liste ist es Pflicht.
+- **Bestehender Bug:** Zieht man über eine Gruppengrenze, prüft `ReorderAsync` (`TasksIslandViewModel.cs:560-563`) zwar die Sektion, verschiebt bei ungleichen Sektionen aber nur `Items` ohne anschließendes `Regroup()`. `SortOrder` landet in der DB, die UI zeigt nichts.
+- **Kein Präzedenzfall:** im gesamten `ClaudeDo.Ui`-Projekt existiert kein `VirtualizingStackPanel` und kein `ItemsRepeater`.
+
+### Drag-Optik
+
+Heute laufen zwei Darstellungen derselben Zeile gleichzeitig: der Bitmap-Ghost am Cursor **und** die Originalzeile mit `Opacity 0.55`, `scale(1.03)`, BoxShadow und Accent-Rand (`IslandStyles.axaml:441-446`). `scale(1.03)` ändert kein Layout und überlappt daher die Nachbarzeilen. Das Feedback für das Drop-Ziel ist der ganz normale `:pointerover`-Hover (`IslandStyles.axaml:433-435`, setzt nur `BorderBrush`) — dasselbe Signal wie beim harmlosen Drüberfahren; einen eigenen `drop-target`-Style gibt es nur für die Lists-Island (`Border.list-item.drop-target`). Zusätzlich laufen `BrushTransition` (0.12s) und `ThicknessTransition` auf `Margin` (0.15s) auch während des Drags mit, was die Rückmeldung verschwimmen lässt.
+
+## Verworfene Alternativen
+
+| Alternative | Warum verworfen |
+|---|---|
+| **SQLite ersetzen** | Kein Engpass. Der DB-Read liegt unter 1 ms; die Zeit steckt zu >95% im Aufbau des Visual Tree. Monatelange Arbeit für null messbaren Gewinn. |
+| **Nur Task-Titel laden, Rest lazy beim Öffnen** | Richtige Intuition, falsche Ebene. Spart Bytes aus einer lokalen Datei, die in unter 1 ms gelesen wird. Die 125 Zeilen werden weiterhin als 125 vollständige `TaskRowView` gebaut. Um wirklich zu sparen, müsste das Zeilen-Template entkernt werden — also genau die Chips und Icons entfallen, wegen derer die Liste nützlich ist. Als *Zusatz* (schlanke Projektion für Speicher/Materialisierung) sinnvoll, als Hauptmaßnahme nicht. |
+| **Completed einklappen + „mehr laden"** | Billig und sofort wirksam, aber aufgeklappt mit 1000 Zeilen hängt es wieder. Bleibt als **Fallback**, falls der Virtualisierungs-Spike scheitert. |
+| **Completed archivieren** | Löst das Problem durch Vermeidung; der Wunsch war ausdrücklich, 1000 erledigte Tasks sehen zu können. |
+| **`Revision`-Spalte / Change-Feed** | Strukturell sauber (verlorene Events wären egal, Race gelöst), aber Migration plus Anpassung jedes Schreibpfads. Für eine Single-User-Desktop-App mit lokaler DB Overkill; der Reconcile-Tick erreicht dasselbe Ziel deutlich billiger. Bleibt als Eskalation, falls Phase 3 in der Praxis nicht reicht. |
+| **Nur die Löcher stopfen (ohne Reconcile)** | Behebt die bekannten Fälle, lässt die Architektur „ein verlorener Event = permanent stale" aber intakt. Das nächste Loch kommt mit dem nächsten Feature. |
+
+## Design
+
+### Phase 1 — Reaktivitäts-Löcher schließen
+
+Unabhängig von Phase 2 und 3, kann sofort starten.
+
+| Fix | Ort |
+|---|---|
+| `catch { }` ersetzen durch Log + einmaligen Retry. **Kein** Footer-Error — das ist ein Hintergrund-Refresh, keine Nutzeraktion. | `TasksIslandViewModel.cs:224` |
+| Catch-Block ruft `_state.FailAsync` (das selbst broadcastet), statt nur zu loggen; `OperationCanceledException` bleibt ausgenommen | `QueueService.cs:349-352` |
+| `WorktreeUpdated` nach dem Insert broadcasten | `Runner/WorktreeManager.cs:103` |
+| `TaskUpdated` nach dem Insert broadcasten | `Online/OnlineSyncService.cs:131` |
+| Monotone Sequenznummer pro TaskId im Delta-Pfad; Ergebnisse mit veralteter Sequenz verwerfen | `OnWorkerTaskUpdated` |
+| `RunCreated` ersatzlos entfernen (totes Event ohne Abonnent) | `HubBroadcaster`, `TaskRunner.cs:358` |
+
+Der ungeschützte Setup-Block in `TaskRunner.ContinueAsync` (Zeilen 218–238) wird **nicht** separat umgebaut: sobald `RunInSlotAsync` im Fehlerfall `FailAsync` ruft, ist jede dort geworfene Exception abgedeckt — der Task landet auf `Failed` und der Broadcast erfolgt. Ein zweiter Schutzwall wäre doppelt.
+
+### Phase 2 — Flache virtualisierte Liste
+
+**Datenmodell.** `Regroup()` erzeugt statt drei Collections **eine** `Rows`-Collection vom Union-Typ (`HeaderRow` | `TaskRowViewModel`), abgeleitet aus der bereits vorhandenen flachen `Items`. Gruppenüberschriften werden zu regulären Einträgen:
+
+```
+Rows
+ [0]  HeaderRow   "Überfällig (3)"
+ [1]  TaskRow     …
+ [4]  HeaderRow   "Offen (12)"
+ …
+ [17] HeaderRow   "Erledigt (125)"
+ …
+```
+
+**View.** Eine `ListBox` mit `VirtualizingStackPanel` und einem DataTemplate-Selector (Header / Task) ersetzt die drei `ItemsControl` und den umschließenden `ScrollViewer`.
+
+**Drag.** `FindNextInSameSection`, `SectionFor` und `ReorderAsync` rechnen gegen `Items` statt gegen die UI-Collections. Auto-Scroll beim Ziehen an den Listenrand wird neu gebaut. Der Cross-Section-Reorder-Bug wird im selben Zug behoben, da die Sektionsgrenzen in der flachen Struktur ohnehin explizit modelliert werden müssen.
+
+**Zeilenkosten.** Das ContextMenu wird bei `ContextRequested` im Code-Behind aufgebaut statt als 18 `MenuItem`s pro Template-Instanz.
+
+**Query.** `.Where()` wandert vor `ToListAsync()`, damit die Query mit der Listengröße statt der DB-Gesamtgröße skaliert. Erfordert Umbau von `ITaskListFilter` von In-Memory-Prädikaten (`Matches(TaskEntity)`) auf `IQueryable`-Expressions.
+
+**Drag-Optik (Variante A).** Ghost folgt dem Cursor; die Originalzeile kollabiert zu einer leeren, gestrichelten Lücke, die beim Ziehen an die jeweilige Zielposition mitwandert.
+
+```
+   ┌──────────────────────┐
+   │ Fix login bug        │
+   ├──────────────────────┤
+   │ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ │ ← leerer Slot, wandert mit
+   ├──────────────────────┤
+   │ Rebase branch        │
+   └──────────────────────┘
+        ┌────────────────┐
+        │ Update deps    │ ← Ghost am Cursor
+        └────────────────┘
+```
+
+Begleitend: `scale(1.03)` und BoxShadow auf der gezogenen Zeile entfallen; der normale `:pointerover`-Hover wird während eines aktiven Drags per `dragging`-Klasse am Container unterdrückt; Transitions sind während des Drags aus.
+
+### Phase 3 — Reconcile-Tick
+
+Setzt Phase 2 voraus: auf einer Liste, die 1–2 s zum Laden braucht, würde ein periodischer Abgleich alles verschlimmern.
+
+Ein Timer (3–5 s) gleicht die **sichtbaren** Rows gegen die lokale SQLite ab und **patcht ausschließlich Properties** — er baut nie Zeilen neu und löst nie einen `LoadForList` aus. Bei einer lokalen DB und wenigen Dutzend sichtbaren Zeilen ist das ein einzelner indizierter Query.
+
+Damit ist jeder verlorene Event nach spätestens einem Tick geheilt, unabhängig davon, wo er fehlte. Derselbe Tick versorgt zusätzlich die langlebigen Overlays: Worktrees-Overview, LogVisualizer und die MergeHelper-Auswahl.
+
+Kurzlebige Modals (Settings, ListSettings, RepoImport, WeeklyReport, ConflictResolver) bleiben bewusst statisch — ein Dialog, der sich unter den Fingern des Nutzers ändert, ist schlechter als einer, der den Stand vom Öffnen zeigt.
+
+## Tests
+
+- **Worker.Tests:** Broadcast-Assertions über einen Fake-Broadcaster auf allen in Phase 1 gefixten Pfaden — insbesondere, dass der Fehlerfall in `RunInSlotAsync` einen Broadcast auslöst.
+- **Ui.Tests:** Der Reconcile-Tick patcht abweichende Properties; ein Ergebnis mit veralteter Sequenznummer wird verworfen; `Regroup()` erzeugt die korrekte `Rows`-Folge inklusive Header-Positionen und -Zählern.
+- **Nicht automatisiert testbar:** Ladezeit und Drag-Optik. Beides erfordert eine manuelle Gegenmessung mit einer großen Liste durch den Nutzer.
+
+Keine Tests, die die echte `claude`-CLI starten.
+
+## Risiken
+
+1. **Kein Virtualisierungs-Präzedenzfall im Projekt.** Das HitTest-basierte Custom-Drag ist theoretisch tragfähig, aber nie gegen recycelte Container verifiziert. **Die erste Aufgabe in Phase 2 ist ein Spike**, kein Umbau: eine virtualisierte Liste mit dem bestehenden Drag, inklusive Recycling während eines aktiven Drags und Auto-Scroll. Scheitert der Spike, ist der Fallback „Completed einklappen + nachladen".
+2. **Variable Zeilenhöhen.** 68 px im Normalfall, 90–110 px bei zweizeiligem Titel oder mehreren Badges. `VirtualizingStackPanel` beherrscht das, aber die Scrollbar springt dabei gern, weil die Gesamthöhe geschätzt wird. Muss im Spike mitgeprüft werden.
+3. **`ITaskListFilter`-Umbau.** Die Umstellung auf `IQueryable`-Expressions berührt die Filter-Registry (`src/ClaudeDo.Data/Filtering/`) und damit auch die virtuellen Listen. Kann bei Bedarf aus Phase 2 herausgelöst und nachgezogen werden — der Performance-Gewinn liegt heute ohnehin fast vollständig beim Rendering.
+
+## Reihenfolge
+
+Phase 1 → Phase 2 (Spike zuerst) → Phase 3. Phase 1 ist unabhängig und kann parallel oder vorab laufen.

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"/>
@@ -22,6 +21,7 @@
             <converters:BoolToItalicConverter      x:Key="BoolToItalic"/>
             <converters:BoolToDraftOpacityConverter x:Key="BoolToDraftOpacity"/>
             <converters:LogKindForegroundConverter  x:Key="LogKindForeground"/>
+            <converters:KeepLastNumberConverter     x:Key="KeepLastNumber"/>
 
         </ResourceDictionary>
     </Application.Resources>

src/ClaudeDo.App/App.axaml.cs

@@ -3,7 +3,9 @@ using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Markup.Xaml;
+using Avalonia.Threading;
 using ClaudeDo.Ui;
+using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
 using ClaudeDo.Ui.ViewModels;
 using ClaudeDo.Ui.Views;
@@ -40,9 +42,22 @@ public partial class App : Application
             // modeless Mission Control window is still open.
             desktop.ShutdownMode = ShutdownMode.OnMainWindowClose;
 
+            var shell = services.GetRequiredService<IslandsShellViewModel>();
+
+            // Last-resort backstop: an exception escaping a dispatcher job kills the process, and
+            // ClaudeDo hosts third-party UI (the ConPTY terminal control) whose async void key and
+            // render handlers have done exactly that — one bad keystroke took the whole app down,
+            // losing every open session. Swallowing is the lesser evil here: the failing job is
+            // already dead either way, and the user still gets told via the footer error strip.
+            Dispatcher.UIThread.UnhandledException += (_, e) =>
+            {
+                e.Handled = true;
+                shell.FlashFooterError(Loc.T("vm.shell.unexpectedError", e.Exception.Message));
+            };
+
             desktop.MainWindow = new MainWindow
             {
-                DataContext = services.GetRequiredService<IslandsShellViewModel>(),
+                DataContext = shell,
             };
 
             // Kick off the SignalR retry loop — reconnects indefinitely if the worker

src/ClaudeDo.App/CLAUDE.md

@@ -8,19 +8,13 @@ Desktop entry point for the ClaudeDo application. Configures DI, initializes the
 - `App.axaml` / `App.axaml.cs` — Avalonia application lifecycle, main window creation, static `ServiceProvider` accessor
 - `ViewLocator.cs` — reflection-based IDataTemplate that maps ViewModels to Views by naming convention
 
-## Dependencies
-
-- Avalonia 12.0.0 (Desktop, Fluent theme, Inter fonts)
-- CommunityToolkit.Mvvm 8.4.1
-- Microsoft.Extensions.DependencyInjection 8.0.1
-- Microsoft.AspNetCore.SignalR.Client 8.0.11
-- Microsoft.Data.Sqlite 8.0.11
-- Project references: ClaudeDo.Data, ClaudeDo.Ui
+Project references: `ClaudeDo.Data`, `ClaudeDo.Ui`. Package versions are in the `.csproj` — see
+the root CLAUDE.md for the tech stack.
 
 ## DI Registration Pattern
 
-- **Singletons**: `IDbContextFactory`, all Repositories, GitService, WorkerClient, `IReleaseClient`, `UpdateCheckService`, `IPrimeScheduleApi`/`WorkerPrimeScheduleApi`, `INotesApi`/`WorkerNotesApi`, `InstallerLocator` / `WorkerLocator`, the island VMs (`ListsIslandViewModel`, `TasksIslandViewModel`, `DetailsIslandViewModel`) and `IslandsShellViewModel` (the window's DataContext)
-- **Transients**: modal VMs (`SettingsModalViewModel`, `MergeModalViewModel`, `ListSettingsModalViewModel`, `RepoImportModalViewModel`, `WeeklyReportModalViewModel`, `DiffViewerViewModel`, `WorktreesOverviewModalViewModel`, `PrimeClaudeTabViewModel`), several exposed as `Func<T>` factories for on-demand dialog creation (`Func<DiffViewerViewModel>` for the diff viewer); `ConflictResolverViewModel` via a `Func<string, ConflictResolverViewModel>` factory keyed by taskId (singleton factory, handed to `IslandsShellViewModel.ConflictResolverFactory`)
+- **Singletons** — `IDbContextFactory`, all repositories, `GitService`, `WorkerClient`, `IReleaseClient`, `UpdateCheckService`, `IPrimeScheduleApi`, `INotesApi`, `InstallerLocator`/`WorkerLocator`, the three island VMs, and `IslandsShellViewModel` (the window's DataContext)
+- **Transients** — modal VMs, several exposed as `Func<T>` factories for on-demand dialog creation (e.g. `Func<DiffViewerViewModel>`). `ConflictResolverViewModel` uses a `Func<string, ConflictResolverViewModel>` factory keyed by taskId (singleton factory, handed to `IslandsShellViewModel.ConflictResolverFactory`).
 
 ## Notes
 

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,52 +4,127 @@ Shared data layer: models, repositories, SQLite infrastructure, and git operatio
 
 ## Models
 
-- **TaskEntity** — Id, ListId, Title, Description, Status (`Idle|Queued|Running|WaitingForChildren|WaitingForReview|Done|Failed|Cancelled`), PlanningPhase (`None|Active|Finalized` — parent-only), BlockedByTaskId (nullable FK to predecessor in a chain), ScheduledFor, Result, ReviewFeedback (nullable; reviewer's rejection comment, consumed and cleared by the runner on the next re-run), LogPath, timestamps, CommitType, Model / SystemPrompt / AgentPath / MaxTurns (nullable overrides), IsStarred, IsMyDay, IsManual (reminder only the user can do — automation skips it), Notes, ParentTaskId, PlanningSessionId, PlanningSessionToken, PlanningFinalizedAt, CreatedBy, HandlerBaseCommit / HandlerHeadCommit (nullable; review range for a worktree-less "list handler" host task — Mission Control's "Let Claude handle it" — which commits straight into the list's working dir instead of a per-task worktree: `HandlerBaseCommit` is stamped to the list repo's HEAD when the host task is created, `HandlerHeadCommit` when it's submitted for review; the Worker's `SubmitTaskForReview`/`GetTaskDiff` and the Ui's `DetailsIslandViewModel`/`MergeSectionViewModel` fall back to this pair whenever `Worktree` is null). Legacy values `Manual`/`Planning`/`Planned`/`Draft`/`Waiting` were retired; existing rows backfill automatically via the `RetireLegacyTaskStatus` migration.
+- **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).
+  - `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 with list), Model, SystemPrompt, AgentPath, MaxTurns, SessionSkills, VerifyCommand (all nullable). `VerifyCommand` is an optional post-merge gate (see `ClaudeDo.Worker/CLAUDE.md` → TaskMergeService): null/blank = today's behavior, no gate.
-- **WorktreeEntity** — TaskId (PK, 1:1 with task), Path, BranchName, BaseCommit, HeadCommit, DiffStat, MergeCommit (nullable; SHA of the merge commit this worktree's branch produced on the target branch, stamped by `TaskMergeService` the moment a merge/continue-merge succeeds — the only thing that makes `revert_merge` possible without heuristically searching `git log`; null for any worktree merged before this field existed), State (Active|Merged|Discarded|Kept)
-- **TaskRunEntity** — per-run record (session_id, tokens, turns, result, structured output, exit code, log path, nullable `Model` — the model the run actually executed with, column `model`)
-- **PrimeScheduleEntity** — Id, Days (`[Flags] PrimeDays` weekday bitmask, stored as `days_of_week` int), TimeOfDay, Enabled, LastRunAt, PromptOverride, CreatedAt. Recurs on the selected weekdays; no date range.
-- **DailyNoteEntity** — Id, Date (DateOnly), Text, SortOrder, CreatedAt → table `daily_notes`
-- **WeekReportEntity** — Id, StartDate/EndDate (DateOnly), Markdown, GeneratedAt → table `week_reports`, unique index on (start_date, end_date)
-- **TaskAttachmentEntity** — Id, TaskId (FK to tasks, ON DELETE CASCADE), FileName, ByteSize, CreatedAt → table `task_attachments`
-- **AppSettingsEntity** also carries `ReportExcludedPaths` (string?, JSON array of excluded path prefixes, column `report_excluded_paths`), `StandupWeekday` (int DayOfWeek, default Wednesday, column `standup_weekday`), and `DailyPrepMaxTasks` (int, default 5, column `daily_prep_max_tasks` — hard cap on how many open tasks the daily-prep / "Prime Claude" feature may place in MyDay) , `ModelPresets` (string?, JSON array of `ModelPreset` rows, column `model_presets`), and `UsageGateFiveHourPct` / `UsageGateSevenDayPct` (int, defaults 80/90, columns `usage_gate_five_hour_pct` / `usage_gate_seven_day_pct` — percentage of the 5h/7d Claude usage window at which the autonomous queue pauses; `0` = gate off; `AppSettingsRepository.UpdateAsync` clamps both to 0..100)
-- **ModelPresets** / **ModelPreset** — per-model run defaults (`Model`, `Effort`, `MaxTurns`): one row per `ModelRegistry.Aliases` entry, supplying the **global** effort and max-turns defaults. `Parse`/`Serialize` normalize (unknown models dropped, missing aliases filled from `Defaults`, effort validated, turns clamped 1–200) and never throw — a malformed settings row must not stop a run. `For(presets, model, fallbackMaxTurns = 30)` always returns a usable row: `model` is resolved through `ModelRegistry.TryNormalizeAlias` first, so a full CLI model id (e.g. `claude-sonnet-4-6`) still hits its alias's preset row instead of missing every lookup and falling through; only a model that normalizes to nothing recognized falls back to a synthesized row (`EffortRegistry.DefaultLevel` + `fallbackMaxTurns` — callers pass `AppSettings.DefaultMaxTurns` here so that setting has a real effect instead of a hardcoded number). Ship defaults: haiku medium/20, sonnet high/30, opus high/40, fable high/25.
-- **ModelRegistry.TryNormalizeAlias** — non-throwing counterpart to `NormalizeAlias` for the run path: exact alias match, then substring match against a full model id, else `null`. Never throws, unlike `NormalizeAlias` (which stays the strict, throwing validator for `add_task`/planning model input).
-- **EffortRegistry** — the `--effort` levels (`low|medium|high|xhigh|max`) + `NormalizeLevel` (blank → null = don't pass the flag)
-- **SubtaskEntity**, **AppSettingsEntity**, **AgentInfo** — existing helpers / settings / record for scanned agent files
+- **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, 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`
+- **SubtaskEntity**, **AgentInfo** — subtasks / record for scanned agent files
+
+### AppSettingsEntity
+
+Beyond the basics it carries:
+
+| Property | Column | Default | Note |
+|---|---|---|---|
+| `DefaultMaxTurns` | `default_max_turns` | **40** | Lowered from 100; `AddMaxTurnsCeiling` backfilled the seeded row. |
+| `MaxTurnsCeiling` | `max_turns_ceiling` | 80 | Hard ceiling every resolved max-turns value (task/list/global) is clamped to before a run. `UpdateAsync` clamps to min 1. |
+| `ModelPresets` | `model_presets` | seeded | JSON array of `ModelPreset` rows. ⚠️ `AppSettingsRepository.GetAsync` **backfills shipping defaults on the first read after it's null**, so it's never null once a run has started. |
+| `UsageGateFiveHourPct` / `UsageGateSevenDayPct` | `usage_gate_*_pct` | 80 / 90 | Queue pause thresholds; `0` = off. |
+| `UsageThrottle{FiveHour,SevenDay}{Soft,Hard}Pct` | `usage_throttle_{five_hour,seven_day}_{soft,hard}_pct` | 50 / 65 per bucket | Staged parallelism below the hard gate, **per bucket**; `0` = that stage off. Edited by dragging the usage-monitor gauges. |
+| `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).
+
+### Model / effort registries
+
+- **ModelPresets / ModelPreset** — per-model run defaults (`Model`, `Effort`, `MaxTurns`), one row per `ModelRegistry.Aliases` entry, supplying the **global** effort and max-turns defaults. Ship defaults: haiku medium/20, sonnet high/30, opus high/40, fable high/25. `Parse`/`Serialize` normalize (unknown models dropped, missing aliases filled from `Defaults`, effort validated, turns clamped 1–200) and **never throw** — a malformed settings row must not stop a run. `For(presets, model, fallbackMaxTurns)` always returns a usable row; resolution order and the fallback trap → [worker-task-pipeline](../../docs/explore-notes/worker-task-pipeline.md).
+- **ModelRegistry** — `NormalizeAlias` is the strict, **throwing** validator for `add_task`/planning model input. `TryNormalizeAlias` is the non-throwing counterpart for the run path (exact alias match, then substring match against a full model id, else `null`). `ByCostAscending` = the cost order the prompts use.
+- **EffortRegistry** — the `--effort` levels (`low|medium|high|xhigh|max`) + `NormalizeLevel` (blank → null = don't pass the flag).
 
 ## Repositories
 
-All repositories use EF Core LINQ queries via `ClaudeDoDbContext`. The atomic `Queued -> Running` claim lives in the Worker's `QueuePicker` (uses `FromSqlRaw`), not here.
+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` (model / system-prompt / agent-path overrides). Status-mutation primitives `MarkRunningAsync` / `MarkDoneAsync` / `MarkFailedAsync` / `FlipAllRunningToFailedAsync` are `internal` and called only by `TaskStateService` in the worker. `CreateChildAsync` produces children with `Status=Idle, PlanningPhase=None`; once their parent's `PlanningPhase` becomes `Finalized`, the chain coordinator queues them.
-- **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)
-- **TaskRunRepository**, **SubtaskRepository**, **AppSettingsRepository**
-- **DailyNoteRepository** — `ListByDayAsync`, `ListBetweenAsync`, `AddAsync`, `UpdateAsync`, `DeleteAsync`
-- **WeekReportRepository** — `GetByRangeAsync`, `UpsertAsync`
-- **TaskAttachmentRepository** — `AddAsync`, `UpdateAsync`, `GetAsync(taskId, fileName)`, `ListByTaskIdAsync`, `DeleteAsync(taskId, fileName)`, `DeleteAllForTaskAsync`
+- **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)`. 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
+dir(s) via an optional `AttachmentStore` ctor param (defaults to the production store).
 
 ## Infrastructure
 
-- **ClaudeDoDbContext** — EF Core DbContext; configured with WAL mode and foreign keys via `UseSqlite` options
-- **IDbContextFactory<ClaudeDoDbContext>** — registered in DI; used by singleton consumers (e.g. Worker hosted service)
-- **Paths** — expands `~` and `%USERPROFILE%`, resolves relative paths. App root: `~/.todo-app`
-- **AppSettings** — loads `~/.todo-app/ui.config.json` (DbPath, SignalRUrl)
-- **AttachmentStore** — dependency-free file store; default root `~/.todo-app/attachments/<taskId>/`. `SaveAsync` enforces a 5 MB cap and path-traversal/containment guard. Also exposes `DeleteFile`, `DeleteTaskDir`, `TaskDir`, `Root`, and `EnumerateTaskIds` (used by the worker orphan sweep). Attachment files live outside git worktrees intentionally.
+- **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 `~/.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
 
-- **GitService** — async wrapper around git CLI (ProcessStartInfo, no shell). Worktree ops (add — serialized to avoid a commondir race —, remove, prune, list paths for branch), branch ops (current, list local, checkout, delete), staging/commit (status porcelain, add-all, add-path, commit via stdin), diffs (working tree, branch vs base, commit range `base..head` — used to show a merged task's diff after the worktree is gone —, per-file, diff-stat, committed files, has-changes), merge (ff-only, no-ff, abort, mid-merge detection, conflicted files), revert (`RevertMergeCommitAsync` — `git revert --no-edit -m 1 <sha>`, reverts a merge commit against its first parent; `RevertAbortAsync`; `IsMidRevertAsync` — `REVERT_HEAD` presence, mirrors `IsMidMergeAsync`'s `MERGE_HEAD`), `PreviewMergeAsync` (non-destructive mergeability check via `git merge-tree --write-tree`), `CountChangedFilesAsync`, rev-parse, is-git-repo. Revert never resets/rewrites — it always produces a new commit, because the working directory it operates on is shared with other concurrent sessions.
+**GitService** — async wrapper around the git CLI (`ProcessStartInfo`, no shell):
+
+- 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), 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
+
+⚠️ **Revert never resets or rewrites** — it always produces a new commit, because the working
+directory it operates on is shared with other concurrent sessions.
 
 ## Schema
 
-Tables: `lists`, `tasks`, `worktrees`, `list_config`, `task_runs`, `subtasks`, `app_settings`, `prime_schedules`, `daily_notes`, `week_reports`, `task_attachments`. Managed by EF Core migrations in the `Migrations/` folder. The `tasks` table holds `status`, `planning_phase` (default `none`), and `blocked_by_task_id` (FK to `tasks.id`, `ON DELETE SET NULL`). Migration `WeeklyReport` added `daily_notes`, `week_reports`, and the two new `app_settings` columns. Migration `DailyPrepMaxTasks` added the `daily_prep_max_tasks` column to `app_settings` (no new tables). Migration `AddTaskAttachments` created the `task_attachments` table. Migration `AddModelPresetsAndManualFlag` added `app_settings.model_presets` plus the `is_manual` flags on `tasks` and `lists`. Migration `AddHandlerCommitRange` added the nullable `handler_base_commit`/`handler_head_commit` columns to `tasks`. Migration `AddUsageGateAndRunModel` added `app_settings.usage_gate_five_hour_pct`/`usage_gate_seven_day_pct` (defaults 80/90) and the nullable `task_runs.model` column. Migration `AddWorktreeMergeCommit` added the nullable `worktrees.merge_commit` column. Migration `AddVerifyCommand` added the nullable `list_config.verify_command` column. `TaskRepository.DeleteAsync` and `ListRepository.DeleteAsync` also delete the on-disk attachment dir(s) via an optional `AttachmentStore` ctor param (defaults to the production store).
+Tables (one per line so parallel migrations don't collide on the same line):
+- `lists`
+- `tasks`
+- `worktrees`
+- `list_config`
+- `task_runs`
+- `subtasks`
+- `app_settings`
+- `prime_schedules`
+- `daily_notes`
+- `week_reports`
+- `task_attachments`
+
+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
 
-- Enum <-> string mapping via EF Core `ValueConverter` (configured in `IEntityTypeConfiguration<T>`)
-- Entity configurations live in the `Configuration/` folder
+- Enum ↔ string mapping via EF Core `ValueConverter`, configured in `IEntityTypeConfiguration<T>`
+- Entity configurations live in `Configuration/`
 - Primary keys are `init`-only strings (GUIDs assigned at creation)
 - All methods are async with CancellationToken where applicable

src/ClaudeDo.Data/ClaudeDo.Data.csproj

@@ -17,6 +17,7 @@
   <ItemGroup>
     <InternalsVisibleTo Include="ClaudeDo.Worker" />
     <InternalsVisibleTo Include="ClaudeDo.Worker.Tests" />
+    <InternalsVisibleTo Include="ClaudeDo.Data.Tests" />
   </ItemGroup>
 
 </Project>

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,15 +13,21 @@ 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)
             .HasColumnName("default_model").IsRequired().HasDefaultValue("sonnet");
         builder.Property(s => s.DefaultMaxTurns)
-            .HasColumnName("default_max_turns").IsRequired().HasDefaultValue(30);
+            .HasColumnName("default_max_turns").IsRequired().HasDefaultValue(40);
         builder.Property(s => s.DefaultPermissionMode)
             .HasColumnName("default_permission_mode").IsRequired().HasDefaultValue("bypassPermissions");
 
+        builder.Property(s => s.MaxTurnsCeiling)
+            .HasColumnName("max_turns_ceiling").IsRequired().HasDefaultValue(80);
+
         builder.Property(s => s.MaxParallelExecutions)
             .HasColumnName("max_parallel_executions").IsRequired().HasDefaultValue(1);
 
@@ -52,6 +58,18 @@ public class AppSettingsEntityConfiguration : IEntityTypeConfiguration<AppSettin
         builder.Property(s => s.UsageGateSevenDayPct)
             .HasColumnName("usage_gate_seven_day_pct").IsRequired().HasDefaultValue(90);
 
+        builder.Property(s => s.UsageThrottleFiveHourSoftPct)
+            .HasColumnName("usage_throttle_five_hour_soft_pct").IsRequired().HasDefaultValue(50);
+        builder.Property(s => s.UsageThrottleFiveHourHardPct)
+            .HasColumnName("usage_throttle_five_hour_hard_pct").IsRequired().HasDefaultValue(65);
+        builder.Property(s => s.UsageThrottleSevenDaySoftPct)
+            .HasColumnName("usage_throttle_seven_day_soft_pct").IsRequired().HasDefaultValue(50);
+        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);
@@ -95,6 +102,8 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
         builder.Property(t => t.SessionSkills).HasColumnName("session_skills");
         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");
@@ -114,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)
@@ -123,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

@@ -24,10 +24,15 @@ public class TaskRunEntityConfiguration : IEntityTypeConfiguration<TaskRunEntity
         builder.Property(r => r.TurnCount).HasColumnName("turn_count");
         builder.Property(r => r.TokensIn).HasColumnName("tokens_in");
         builder.Property(r => r.TokensOut).HasColumnName("tokens_out");
+        builder.Property(r => r.CacheReadTokens).HasColumnName("cache_read_tokens");
+        builder.Property(r => r.CacheWriteTokens).HasColumnName("cache_write_tokens");
         builder.Property(r => r.LogPath).HasColumnName("log_path");
         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/Environment/ExecutableResolver.cs

@@ -0,0 +1,116 @@
+using SysEnvironment = System.Environment;
+
+namespace ClaudeDo.Data.Environment;
+
+public sealed record ResolvedExecutable(string Path, bool IsShim);
+
+public sealed record ShimStartInfo(string FileName, string Arguments);
+
+/// <summary>
+/// Resolves a command the way Windows' CreateProcess/PATH search does, but also finds
+/// non-.exe shims (.cmd/.bat/.ps1) that UseShellExecute=false alone would miss.
+/// </summary>
+public static class ExecutableResolver
+{
+    private const string DefaultPathExt = ".COM;.EXE;.BAT;.CMD";
+
+    // Known npm/claude install locations to try when PATH search comes up empty.
+    private static readonly string[] FallbackDirectoryTemplates =
+    {
+        "%APPDATA%\\npm",
+        "%LOCALAPPDATA%\\Programs\\claude",
+        "%USERPROFILE%\\.local\\bin",
+    };
+
+    public static ResolvedExecutable? Resolve(string command, string? pathOverride = null, string? pathExtOverride = null)
+    {
+        var pathExts = ParsePathExt(pathExtOverride);
+
+        if (LooksLikePath(command))
+        {
+            return ResolveAsPath(command, pathExts);
+        }
+
+        var directories = ParsePath(pathOverride);
+        foreach (var dir in directories)
+        {
+            var resolved = ResolveInDirectory(dir, command, pathExts);
+            if (resolved is not null) return resolved;
+        }
+
+        foreach (var template in FallbackDirectoryTemplates)
+        {
+            var dir = SysEnvironment.ExpandEnvironmentVariables(template);
+            var resolved = ResolveInDirectory(dir, command, pathExts);
+            if (resolved is not null) return resolved;
+        }
+
+        return null;
+    }
+
+    /// <summary>Expanded fallback directories tried when PATH search comes up empty (for diagnostics).</summary>
+    public static IReadOnlyList<string> FallbackDirectories() =>
+        FallbackDirectoryTemplates.Select(SysEnvironment.ExpandEnvironmentVariables).ToList();
+
+    public static ShimStartInfo BuildShimStartInfo(string shimPath, IReadOnlyList<string> arguments)
+    {
+        var parts = new List<string> { "/c", Quote(shimPath) };
+        parts.AddRange(arguments.Select(Quote));
+        return new ShimStartInfo("cmd.exe", string.Join(' ', parts));
+    }
+
+    private static bool LooksLikePath(string command) =>
+        command.Contains(Path.DirectorySeparatorChar) || command.Contains(Path.AltDirectorySeparatorChar);
+
+    private static ResolvedExecutable? ResolveAsPath(string command, IReadOnlyList<string> pathExts)
+    {
+        if (File.Exists(command)) return new ResolvedExecutable(command, IsShimExtension(Path.GetExtension(command)));
+
+        if (Path.HasExtension(command)) return null;
+
+        foreach (var ext in pathExts)
+        {
+            var candidate = command + ext;
+            if (File.Exists(candidate)) return new ResolvedExecutable(candidate, IsShimExtension(ext));
+        }
+
+        return null;
+    }
+
+    private static ResolvedExecutable? ResolveInDirectory(string directory, string command, IReadOnlyList<string> pathExts)
+    {
+        if (!Directory.Exists(directory)) return null;
+
+        if (Path.HasExtension(command))
+        {
+            var candidate = Path.Combine(directory, command);
+            return File.Exists(candidate) ? new ResolvedExecutable(candidate, IsShimExtension(Path.GetExtension(candidate))) : null;
+        }
+
+        foreach (var ext in pathExts)
+        {
+            var candidate = Path.Combine(directory, command + ext);
+            if (File.Exists(candidate)) return new ResolvedExecutable(candidate, IsShimExtension(ext));
+        }
+
+        return null;
+    }
+
+    private static bool IsShimExtension(string extension) =>
+        !extension.Equals(".exe", StringComparison.OrdinalIgnoreCase)
+        && !extension.Equals(".com", StringComparison.OrdinalIgnoreCase);
+
+    private static IReadOnlyList<string> ParsePathExt(string? pathExtOverride)
+    {
+        var raw = pathExtOverride ?? SysEnvironment.GetEnvironmentVariable("PATHEXT") ?? DefaultPathExt;
+        return raw.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+    }
+
+    private static IReadOnlyList<string> ParsePath(string? pathOverride)
+    {
+        var raw = pathOverride ?? SysEnvironment.GetEnvironmentVariable("PATH") ?? "";
+        return raw.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+    }
+
+    private static string Quote(string value) => value.Contains(' ') ? $"\"{value}\"" : value;
+}

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
 {
@@ -26,6 +29,32 @@ public sealed class GitService
         return stdout.Trim();
     }
 
+    /// <summary>
+    /// True if <paramref name="ancestorSha"/> is an ancestor of (or equal to) <paramref name="descendantSha"/>,
+    /// via `git merge-base --is-ancestor`. Null means the answer can't be determined (e.g. the commit is
+    /// unknown in this repo) — callers must treat that as "unknown", never as "not an ancestor".
+    /// </summary>
+    public async Task<bool?> IsAncestorAsync(string repoDir, string ancestorSha, string descendantSha, CancellationToken ct = default)
+    {
+        var (exitCode, _, _) = await RunGitAsync(repoDir, ["merge-base", "--is-ancestor", ancestorSha, descendantSha], ct);
+        return exitCode switch
+        {
+            0 => true,
+            1 => false,
+            _ => null,
+        };
+    }
+
+    /// <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);
@@ -54,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;
@@ -107,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;
@@ -127,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>
@@ -142,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)
@@ -330,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.
@@ -341,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)
         {
@@ -361,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)
@@ -373,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
-        }
-    }
-}