fix(notes): Shift+Enter in the capture box, not just in the note rows

The previous fix put AcceptsReturn on the rows in the DataTemplate and
missed the box you actually type new notes into, which still had it off
and only a KeyBinding for Enter — so Shift+Enter there did nothing.

Both now go through the same tunnel handler: Enter files the note,
Shift+Enter is left to the TextBox for the line break. The KeyBinding is
gone; with AcceptsReturn on it could never have fired anyway, because
TextBox consumes Enter in its own OnKeyDown before bindings or bubbling
handlers run.

Verified against the running app: a note typed with Shift+Enter is
stored as "fe\r\ndwa".

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

CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## v2.12.0 — 2026-08-28
+
+### Features
+
+- wählbares Listen-Icon und aufgeräumter Task-Detail-Header (c31f79d3)
+- Mission Control als Session-Hub (22e70ffc)
+
+### Fixes
+
+- make re-approve after revert_merge do a real merge, not a silent no-op (8d597df4)
+- survive a worker restart when cancelling a mid-merge unit-merge parent (1affb397)
+
+### Documentation
+
+- update for v2.11.0 (bbdb0223)
+
 ## v2.11.0 — 2026-08-27
 
 ### Features

docs/open.md

@@ -76,6 +76,13 @@ zugleich der erste Test dieser Annahme: schlägt einer davon mit einem Deseriali
 
 ## Offene Verifikation (2026-07-27)
 
+- **Empty-Repo-Hardening (2026-07-30)** — Worker/App neu starten (laufende Instanz hat den
+  Fix noch nicht), dann auf dem Task „HEy this is a Test" (Test List → `C:\Dev\TestRepo`,
+  aktuell 0 Commits) „Open ConPTY session" klicken: muss jetzt starten und in `C:\Dev\TestRepo`
+  genau einen leeren Commit „chore: initialize repository (ClaudeDo)" hinterlassen. Idealerweise
+  auch einmal auf dem Zweit-PC gegentesten (dort zusätzlich: Task-Run auf einem PC ohne
+  `git config user.name/email` — Auto-Commit darf nicht mehr scheitern).
+
 - **List handler (2026-07-27)** — visual pass: the Broom button is gone from the lists footer,
   the context-menu item appears only on lists with a working dir, and the selection dialog has no
   LIST column. (Der real-Claude-Smoke-Run der fünf Phasen ist am 2026-07-29 gelaufen — 6/6 sauber

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

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

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

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

global.json

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

src/ClaudeDo.App/Program.cs

@@ -165,13 +165,13 @@ sealed class Program
         sc.AddSingleton<TasksIslandViewModel>(sp =>
             new TasksIslandViewModel(
                 sp.GetRequiredService<IDbContextFactory<ClaudeDoDbContext>>(),
-                sp.GetRequiredService<IWorkerClient>()));
+                sp.GetRequiredService<IWorkerClient>(),
+                sp.GetRequiredService<INotesApi>()));
         sc.AddSingleton<DetailsIslandViewModel>(sp =>
             new DetailsIslandViewModel(
                 sp.GetRequiredService<IDbContextFactory<ClaudeDoDbContext>>(),
                 sp.GetRequiredService<IWorkerClient>(),
                 sp,
-                sp.GetRequiredService<INotesApi>(),
                 sp.GetRequiredService<MergeCoordinator>()));
         sc.AddSingleton<UsagePillViewModel>(sp =>
             new UsagePillViewModel(sp.GetRequiredService<IWorkerClient>()));

src/ClaudeDo.Data/CLAUDE.md

@@ -80,10 +80,15 @@ dir(s) via an optional `AttachmentStore` ctor param (defaults to the production
 - Merge: ff-only, no-ff, abort, mid-merge detection (`MERGE_HEAD`), conflicted files
 - Revert: `RevertMergeCommitAsync` (`git revert --no-edit -m 1 <sha>`), `RevertAbortAsync`, `IsMidRevertAsync` (`REVERT_HEAD`, mirrors `IsMidMergeAsync`)
 - `PreviewMergeAsync` (non-destructive check via `git merge-tree --write-tree`), `CountChangedFilesAsync`, rev-parse, is-git-repo
+- Empty repos: `HasHeadCommitAsync` (HEAD resolves to a real commit) and `EnsureHeadCommitAsync` — a fresh `git init` repo (unborn HEAD) gets an empty bootstrap commit via plumbing only (mktree/commit-tree/update-ref), so the user's index and working tree stay untouched; identity is passed inline, so it also works with no git config, and a broken HEAD throws instead of guessing
+- Identity fallback: `CommitAsync` retries once as the ClaudeDo identity when the machine has none configured
 
 ⚠️ **Revert never resets or rewrites** — it always produces a new commit, because the working
 directory it operates on is shared with other concurrent sessions.
 
+⚠️ **Git stdin is BOM-less UTF-8** — `Encoding.UTF8` writes a BOM preamble, which git rejects
+as input (`mktree` fails with "input format error", and commit messages would carry it).
+
 ## Schema
 
 Tables (one per line so parallel migrations don't collide on the same line):

src/ClaudeDo.Data/Configuration/DailyNoteEntityConfiguration.cs

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

src/ClaudeDo.Data/Git/GitService.cs

@@ -25,7 +25,16 @@ public sealed class GitService
     {
         var (exitCode, stdout, stderr) = await RunGitAsync(dir, ["rev-parse", "HEAD"], ct);
         if (exitCode != 0)
+        {
+            // Unborn HEAD (fresh `git init`, no commits) — the raw git stderr ("ambiguous
+            // argument 'HEAD'") is useless to a user; call sites should have run
+            // EnsureHeadCommitAsync, this message is the safety net for any that didn't.
+            if (stderr.Contains("ambiguous argument 'HEAD'", StringComparison.Ordinal) ||
+                stderr.Contains("unknown revision", StringComparison.Ordinal))
+                throw new InvalidOperationException(
+                    $"The repository at {dir} has no commits yet (unborn or broken HEAD) — ClaudeDo needs at least one commit to work in it.");
             throw new InvalidOperationException($"git rev-parse HEAD failed (exit {exitCode}): {stderr}");
+        }
         return stdout.Trim();
     }
 
@@ -55,6 +64,67 @@ public sealed class GitService
         return exitCode == 0 ? stdout.Trim() : null;
     }
 
+    /// <summary>HEAD resolves to a commit (false for a fresh `git init` repo or a broken HEAD).</summary>
+    public async Task<bool> HasHeadCommitAsync(string dir, CancellationToken ct = default)
+    {
+        // ^{commit} forces the object to actually exist and be a commit — a bare
+        // `--verify HEAD` happily accepts a detached HEAD pointing at a missing object.
+        var (exitCode, _, _) = await RunGitAsync(dir, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], ct);
+        return exitCode == 0;
+    }
+
+    private const string FallbackUserName = "ClaudeDo";
+    private const string FallbackUserEmail = "claudedo@local";
+
+    // Two parallel task starts on the same empty repo must create exactly one initial commit.
+    private static readonly SemaphoreSlim BootstrapGate = new(1, 1);
+
+    /// <summary>
+    /// Guarantees HEAD resolves to a commit so worktrees can be created. A repo with an
+    /// unborn HEAD (fresh `git init`) gets an empty initial commit built from plumbing only
+    /// (hash-object/commit-tree/update-ref) — the user's index and working tree are never
+    /// touched, so staged and untracked files stay exactly as they were. Identity is passed
+    /// inline, so this also works on machines with no git identity configured. A repo whose
+    /// HEAD is broken (not a symbolic ref and not resolvable) throws instead of guessing.
+    /// </summary>
+    /// <returns>true if a bootstrap commit was created; false if HEAD already resolved.</returns>
+    public async Task<bool> EnsureHeadCommitAsync(string dir, CancellationToken ct = default)
+    {
+        if (await HasHeadCommitAsync(dir, ct)) return false;
+
+        var (symExit, symRef, _) = await RunGitAsync(dir, ["symbolic-ref", "--quiet", "HEAD"], ct);
+        if (symExit != 0)
+            throw new InvalidOperationException(
+                $"The repository at {dir} has a broken HEAD (detached onto a missing commit, or a corrupt .git/HEAD). Repair the repository manually.");
+
+        await BootstrapGate.WaitAsync(ct);
+        try
+        {
+            if (await HasHeadCommitAsync(dir, ct)) return false;
+
+            var (treeExit, treeSha, treeErr) = await RunGitAsync(dir, ["mktree"], ct, stdinData: "");
+            if (treeExit != 0)
+                throw new InvalidOperationException($"git mktree failed (exit {treeExit}): {treeErr}");
+
+            var (commitExit, commitSha, commitErr) = await RunGitAsync(dir,
+                ["-c", $"user.name={FallbackUserName}", "-c", $"user.email={FallbackUserEmail}",
+                 "commit-tree", treeSha.Trim(), "-m", "chore: initialize repository (ClaudeDo)"], ct);
+            if (commitExit != 0)
+                throw new InvalidOperationException($"git commit-tree failed (exit {commitExit}): {commitErr}");
+
+            var (refExit, _, refErr) = await RunGitAsync(dir,
+                ["update-ref", symRef.Trim(), commitSha.Trim()], ct);
+            if (refExit != 0)
+                throw new InvalidOperationException($"git update-ref failed (exit {refExit}): {refErr}");
+
+            return true;
+        }
+        finally
+        {
+            BootstrapGate.Release();
+        }
+    }
+
     public async Task WorktreeAddAsync(string repoDir, string branchName, string worktreePath, string baseCommit, CancellationToken ct = default)
     {
         await WorktreeAddGate.WaitAsync(ct);
@@ -135,10 +205,24 @@ public sealed class GitService
     {
         // Use -F - (read message from stdin) to handle multi-line messages safely.
         var (exitCode, _, stderr) = await RunGitAsync(worktreePath, ["commit", "-F", "-"], ct, stdinData: message);
+        if (exitCode != 0 && IsMissingIdentityError(stderr))
+        {
+            // A machine without git identity configured must not fail every auto-commit —
+            // retry once as ClaudeDo. The happy path pays no preflight cost.
+            (exitCode, _, stderr) = await RunGitAsync(worktreePath,
+                ["-c", $"user.name={FallbackUserName}", "-c", $"user.email={FallbackUserEmail}",
+                 "commit", "-F", "-"], ct, stdinData: message);
+        }
         if (exitCode != 0)
             throw new InvalidOperationException($"git commit failed (exit {exitCode}): {stderr}");
     }
 
+    private static bool IsMissingIdentityError(string stderr) =>
+        stderr.Contains("tell me who you are", StringComparison.OrdinalIgnoreCase) ||
+        stderr.Contains("empty ident", StringComparison.OrdinalIgnoreCase) ||
+        stderr.Contains("no email was given", StringComparison.OrdinalIgnoreCase) ||
+        stderr.Contains("unable to auto-detect email address", StringComparison.OrdinalIgnoreCase);
+
     public async Task<string> GetDiffAsync(
         string worktreePath, IReadOnlyList<string>? paths = null, CancellationToken ct = default)
     {
@@ -584,7 +668,9 @@ public sealed class GitService
             CreateNoWindow = true,
             StandardOutputEncoding = Encoding.UTF8,
             StandardErrorEncoding = Encoding.UTF8,
-            StandardInputEncoding = stdinData is not null ? Encoding.UTF8 : null,
+            // BOM-less: Encoding.UTF8 writes a BOM preamble, which git rejects as input
+            // (mktree "input format error") and would prepend to stdin commit messages.
+            StandardInputEncoding = stdinData is not null ? new UTF8Encoding(false) : null,
         };
         psi.ArgumentList.Add("-C");
         psi.ArgumentList.Add(workDir);

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

@@ -0,0 +1,982 @@
+// <auto-generated />
+using System;
+using ClaudeDo.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    [DbContext(typeof(ClaudeDoDbContext))]
+    [Migration("20260828185839_AddDailyNoteFromAgent")]
+    partial class AddDailyNoteFromAgent
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.11");
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.AppSettingsEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("AutoContinueOnUsageLimit")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("auto_continue_on_usage_limit");
+
+                    b.Property<string>("CentralWorktreeRoot")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("central_worktree_root");
+
+                    b.Property<int>("DailyPrepMaxTasks")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(5)
+                        .HasColumnName("daily_prep_max_tasks");
+
+                    b.Property<string>("DefaultClaudeInstructions")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("")
+                        .HasColumnName("default_claude_instructions");
+
+                    b.Property<int>("DefaultMaxTurns")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(40)
+                        .HasColumnName("default_max_turns");
+
+                    b.Property<string>("DefaultModel")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sonnet")
+                        .HasColumnName("default_model");
+
+                    b.Property<string>("DefaultPermissionMode")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("bypassPermissions")
+                        .HasColumnName("default_permission_mode");
+
+                    b.Property<int>("MaxParallelExecutions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1)
+                        .HasColumnName("max_parallel_executions");
+
+                    b.Property<int>("MaxTurnsCeiling")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(80)
+                        .HasColumnName("max_turns_ceiling");
+
+                    b.Property<string>("ModelPresets")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model_presets");
+
+                    b.Property<int>("NextTaskNumber")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1)
+                        .HasColumnName("next_task_number");
+
+                    b.Property<string>("RepoImportFolders")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("repo_import_folders");
+
+                    b.Property<string>("ReportExcludedPaths")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("report_excluded_paths");
+
+                    b.Property<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    b.Property<int>("StandupWeekday")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(3)
+                        .HasColumnName("standup_weekday");
+
+                    b.Property<int>("UsageGateFiveHourPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(80)
+                        .HasColumnName("usage_gate_five_hour_pct");
+
+                    b.Property<int>("UsageGateSevenDayPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(90)
+                        .HasColumnName("usage_gate_seven_day_pct");
+
+                    b.Property<int>("UsageThrottleFiveHourHardPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(65)
+                        .HasColumnName("usage_throttle_five_hour_hard_pct");
+
+                    b.Property<int>("UsageThrottleFiveHourSoftPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(50)
+                        .HasColumnName("usage_throttle_five_hour_soft_pct");
+
+                    b.Property<int>("UsageThrottleSevenDayHardPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(65)
+                        .HasColumnName("usage_throttle_seven_day_hard_pct");
+
+                    b.Property<int>("UsageThrottleSevenDaySoftPct")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(50)
+                        .HasColumnName("usage_throttle_seven_day_soft_pct");
+
+                    b.Property<int>("WorktreeAutoCleanupDays")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(7)
+                        .HasColumnName("worktree_auto_cleanup_days");
+
+                    b.Property<bool>("WorktreeAutoCleanupEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("worktree_auto_cleanup_enabled");
+
+                    b.Property<string>("WorktreeStrategy")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sibling")
+                        .HasColumnName("worktree_strategy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("app_settings", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            AutoContinueOnUsageLimit = false,
+                            DailyPrepMaxTasks = 5,
+                            DefaultClaudeInstructions = "",
+                            DefaultMaxTurns = 40,
+                            DefaultModel = "sonnet",
+                            DefaultPermissionMode = "auto",
+                            MaxParallelExecutions = 1,
+                            MaxTurnsCeiling = 80,
+                            NextTaskNumber = 1,
+                            StandupWeekday = 3,
+                            UsageGateFiveHourPct = 80,
+                            UsageGateSevenDayPct = 90,
+                            UsageThrottleFiveHourHardPct = 65,
+                            UsageThrottleFiveHourSoftPct = 50,
+                            UsageThrottleSevenDayHardPct = 65,
+                            UsageThrottleSevenDaySoftPct = 50,
+                            WorktreeAutoCleanupDays = 7,
+                            WorktreeAutoCleanupEnabled = false,
+                            WorktreeStrategy = "sibling"
+                        });
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.DailyNoteEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("note_date");
+
+                    b.Property<bool>("FromAgent")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("from_agent");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("sort_order");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date");
+
+                    b.ToTable("daily_notes", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
+                {
+                    b.Property<string>("ListId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("list_id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<int?>("MaxTurns")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("max_turns");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("PermissionMode")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("permission_mode");
+
+                    b.Property<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.Property<int?>("TicketProjectId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ticket_project_id");
+
+                    b.Property<string>("VerifyCommand")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("verify_command");
+
+                    b.HasKey("ListId");
+
+                    b.ToTable("list_config", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DefaultCommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("default_commit_type");
+
+                    b.Property<bool>("FindingsTracked")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("findings_tracked");
+
+                    b.Property<string>("Icon")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("icon");
+
+                    b.Property<bool>("IsManual")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_manual");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<string>("WorkingDir")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("working_dir");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SortOrder")
+                        .HasDatabaseName("idx_lists_sort");
+
+                    b.ToTable("lists", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<int>("Days")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(31)
+                        .HasColumnName("days_of_week");
+
+                    b.Property<bool>("Enabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true)
+                        .HasColumnName("enabled");
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("ping")
+                        .HasColumnName("action_kind");
+
+                    b.Property<DateTimeOffset?>("LastRunAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_run_at");
+
+                    b.Property<string>("PromptOverride")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt_override");
+
+                    b.Property<TimeSpan>("TimeOfDay")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time_of_day");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("prime_schedules", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SessionSkillEntity", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<DateTimeOffset>("AddedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("added_at");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<string>("PinnedRef")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("pinned_ref");
+
+                    b.Property<string>("SourceUrl")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("source_url");
+
+                    b.Property<string>("Subpath")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("subpath");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("session_skills", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("Completed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("completed");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<int>("OrderNum")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("order_num");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_subtasks_task_id");
+
+                    b.ToTable("subtasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<long>("ByteSize")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("byte_size");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("file_name");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_task_attachments_task_id");
+
+                    b.ToTable("task_attachments", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<string>("BlockedByTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("blocked_by_task_id");
+
+                    b.Property<string>("CommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("commit_type");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by");
+
+                    b.Property<string>("DependsOnTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("depends_on_task_id");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<int?>("FailureMaxTurns")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("failure_max_turns");
+
+                    b.Property<string>("FailureReason")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("failure_reason");
+
+                    b.Property<int?>("FailureTurnsUsed")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("failure_turns_used");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<string>("HandlerBaseCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("handler_base_commit");
+
+                    b.Property<string>("HandlerHeadCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("handler_head_commit");
+
+                    b.Property<string>("InteractiveSessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("interactive_session_id");
+
+                    b.Property<bool>("IsManual")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_manual");
+
+                    b.Property<bool>("IsMyDay")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_my_day");
+
+                    b.Property<bool>("IsStarred")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_starred");
+
+                    b.Property<string>("ListId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("list_id");
+
+                    b.Property<string>("LogPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("log_path");
+
+                    b.Property<int?>("MaxTurns")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("max_turns");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("notes");
+
+                    b.Property<int>("Number")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("number");
+
+                    b.Property<string>("ParentTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("parent_task_id");
+
+                    b.Property<string>("PermissionMode")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("permission_mode");
+
+                    b.Property<DateTime?>("PlanningFinalizedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_finalized_at");
+
+                    b.Property<string>("PlanningPhase")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("none")
+                        .HasColumnName("planning_phase");
+
+                    b.Property<string>("PlanningSessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_session_id");
+
+                    b.Property<string>("PlanningSessionToken")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_session_token");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result");
+
+                    b.Property<string>("ReviewFeedback")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("review_feedback");
+
+                    b.Property<int>("RoadblockCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("roadblock_count");
+
+                    b.Property<DateTime?>("ScheduledFor")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("scheduled_for");
+
+                    b.Property<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("status");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.Property<string>("TicketRef")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ticket_ref");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.Property<DateTime?>("UsageLimitAutoContinuedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("usage_limit_auto_continued_at");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockedByTaskId")
+                        .HasDatabaseName("idx_tasks_blocked_by");
+
+                    b.HasIndex("DependsOnTaskId")
+                        .HasDatabaseName("idx_tasks_depends_on");
+
+                    b.HasIndex("ListId")
+                        .HasDatabaseName("idx_tasks_list_id");
+
+                    b.HasIndex("Number")
+                        .IsUnique()
+                        .HasDatabaseName("idx_tasks_number");
+
+                    b.HasIndex("ParentTaskId")
+                        .HasDatabaseName("idx_tasks_parent_task_id");
+
+                    b.HasIndex("Status")
+                        .HasDatabaseName("idx_tasks_status");
+
+                    b.HasIndex("ListId", "SortOrder")
+                        .HasDatabaseName("idx_tasks_list_sort");
+
+                    b.ToTable("tasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<int?>("CacheReadTokens")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cache_read_tokens");
+
+                    b.Property<int?>("CacheWriteTokens")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("cache_write_tokens");
+
+                    b.Property<string>("ErrorMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("error_markdown");
+
+                    b.Property<string>("Errors")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("errors");
+
+                    b.Property<int?>("ExitCode")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("exit_code");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<bool>("IsRetry")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_retry");
+
+                    b.Property<string>("LogPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("log_path");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("Prompt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt");
+
+                    b.Property<string>("ResultMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result_markdown");
+
+                    b.Property<string>("ResultSubtype")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result_subtype");
+
+                    b.Property<int>("RunNumber")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("run_number");
+
+                    b.Property<string>("SessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_id");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("StructuredOutputJson")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("structured_output");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("TerminalReason")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("terminal_reason");
+
+                    b.Property<int?>("TokensIn")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("tokens_in");
+
+                    b.Property<int?>("TokensOut")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("tokens_out");
+
+                    b.Property<int?>("TurnCount")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("turn_count");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_task_runs_task_id");
+
+                    b.ToTable("task_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WeekReportEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("end_date");
+
+                    b.Property<DateTime>("GeneratedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("generated_at");
+
+                    b.Property<string>("Markdown")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("markdown");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("start_date");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StartDate", "EndDate")
+                        .IsUnique();
+
+                    b.ToTable("week_reports", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
+                {
+                    b.Property<string>("TaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("BaseCommit")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("base_commit");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("branch_name");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DiffStat")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("diff_stat");
+
+                    b.Property<string>("HeadCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("head_commit");
+
+                    b.Property<string>("MergeCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("merge_commit");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("path");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("active")
+                        .HasColumnName("state");
+
+                    b.HasKey("TaskId");
+
+                    b.ToTable("worktrees", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
+                        .WithOne("Config")
+                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("List");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany("Subtasks")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany()
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
+                        .WithMany()
+                        .HasForeignKey("BlockedByTaskId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnTaskId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
+                        .WithMany("Tasks")
+                        .HasForeignKey("ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentTaskId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("List");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany("Runs")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithOne("Worktree")
+                        .HasForeignKey("ClaudeDo.Data.Models.WorktreeEntity", "TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Navigation("Config");
+
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Navigation("Children");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Subtasks");
+
+                    b.Navigation("Worktree");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

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

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

src/ClaudeDo.Data/Migrations/ClaudeDoDbContextModelSnapshot.cs

@@ -205,6 +205,10 @@ namespace ClaudeDo.Data.Migrations
                         .HasColumnType("TEXT")
                         .HasColumnName("note_date");
 
+                    b.Property<bool>("FromAgent")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("from_agent");
+
                     b.Property<int>("SortOrder")
                         .HasColumnType("INTEGER")
                         .HasColumnName("sort_order");

src/ClaudeDo.Data/Models/DailyNoteEntity.cs

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

src/ClaudeDo.Data/Repositories/DailyNoteRepository.cs

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

src/ClaudeDo.Localization/locales/de.json

@@ -177,7 +177,6 @@
     "listSettingsTip": "Listeneinstellungen",
     "addPlaceholder": "Aufgabe hinzufügen…",
     "enterKey": "ENTER",
-    "notesPinnedRow": "Notizen (Tagesnotizen)",
     "clearDayTip": "Tag leeren",
     "planMyDayTip": "Meinen Tag planen",
     "overdue": "ÜBERFÄLLIG",
@@ -299,8 +298,11 @@
   },
   "notes": {
     "today": "Heute",
-    "add": "Hinzufügen",
+    "yesterday": "Gestern",
-    "newNotePlaceholder": "Neue Notiz…"
+    "newNotePlaceholder": "Neue Notiz…",
+    "emptyHint": "Noch nichts notiert. Tippen, Enter, fertig.",
+    "deleteTip": "Notiz löschen",
+    "fromAgentTip": "Von Claude notiert"
   },
   "session": {
     "chipLive": "LIVE",
@@ -763,7 +765,7 @@
     "detailsIsland": { "verifyFailed": "Merge ist erfolgt, aber das Verifikationskommando der Liste ist fehlgeschlagen — die Aufgabe wurde nicht auf 'Erledigt' gesetzt.", "untrackedCollision": "Merge abgelehnt — er würde eine unversionierte Datei im Ziel-Arbeitsverzeichnis überschreiben.", "stopOffline": "Worker offline — Task kann nicht gestoppt werden.", "stopFailed": "Stoppen fehlgeschlagen: {0}", "enqueueFailed": "In die Warteschlange stellen fehlgeschlagen: {0}", "dequeueFailed": "Aus der Warteschlange entfernen fehlgeschlagen: {0}", "resetAndRetryFailed": "Zurücksetzen & erneut versuchen fehlgeschlagen: {0}", "toggleDoneFailed": "Erledigt-Status konnte nicht aktualisiert werden: {0}" },
     "mergeSection": { "openWorktreeFailed": "Worktree konnte nicht geöffnet werden: {0}" },
     "about": { "openPathFailed": "Pfad konnte nicht geöffnet werden: {0}" },
-    "lists": { "localSuffix": "{0} / lokal", "smartMyDay": "Mein Tag", "smartImportant": "Wichtig", "smartPlanned": "Geplant", "virtualQueue": "Warteschlange", "virtualRunning": "Läuft", "virtualReview": "Prüfung", "newList": "Neue Liste", "findingsNotFound": "Für diese Liste gibt es noch keine Findings.", "findingsOpenFailed": "Findings-Ordner konnte nicht geöffnet werden: {0}", "openInExplorerFailed": "Pfad konnte nicht geöffnet werden: {0}" },
+    "lists": { "localSuffix": "{0} / lokal", "smartMyDay": "Mein Tag", "smartImportant": "Wichtig", "smartPlanned": "Geplant", "smartNotes": "Notizen", "virtualQueue": "Warteschlange", "virtualRunning": "Läuft", "virtualReview": "Prüfung", "newList": "Neue Liste", "findingsNotFound": "Für diese Liste gibt es noch keine Findings.", "findingsOpenFailed": "Findings-Ordner konnte nicht geöffnet werden: {0}", "openInExplorerFailed": "Pfad konnte nicht geöffnet werden: {0}" },
     "repoImport": { "loadFailed": "Gespeicherte Ordner konnten nicht geladen werden: {0}", "saveFailed": "Ordner konnten nicht gespeichert werden: {0}" }
   },
   "ops": {

src/ClaudeDo.Localization/locales/en.json

@@ -177,7 +177,6 @@
     "listSettingsTip": "List settings",
     "addPlaceholder": "Add a task…",
     "enterKey": "ENTER",
-    "notesPinnedRow": "Notes (daily notes)",
     "clearDayTip": "Clear day",
     "planMyDayTip": "Plan My Day",
     "overdue": "OVERDUE",
@@ -299,8 +298,11 @@
   },
   "notes": {
     "today": "Today",
-    "add": "Add",
+    "yesterday": "Yesterday",
-    "newNotePlaceholder": "New note…"
+    "newNotePlaceholder": "New note…",
+    "emptyHint": "Nothing noted yet. Type, hit Enter, done.",
+    "deleteTip": "Delete note",
+    "fromAgentTip": "Written by Claude"
   },
   "session": {
     "chipLive": "LIVE",
@@ -763,7 +765,7 @@
     "detailsIsland": { "verifyFailed": "Merge landed, but the list's verify command failed — the task was kept out of Done.", "untrackedCollision": "Merge refused — it would overwrite an untracked file in the target working directory.", "stopOffline": "Worker offline — can't stop the task.", "stopFailed": "Stop failed: {0}", "enqueueFailed": "Queue failed: {0}", "dequeueFailed": "Remove from queue failed: {0}", "resetAndRetryFailed": "Reset & retry failed: {0}", "toggleDoneFailed": "Couldn't update done state: {0}" },
     "mergeSection": { "openWorktreeFailed": "Couldn't open worktree: {0}" },
     "about": { "openPathFailed": "Couldn't open path: {0}" },
-    "lists": { "localSuffix": "{0} / local", "smartMyDay": "My Day", "smartImportant": "Important", "smartPlanned": "Planned", "virtualQueue": "Queue", "virtualRunning": "Running", "virtualReview": "Review", "newList": "New list", "findingsNotFound": "No findings yet for this list.", "findingsOpenFailed": "Couldn't open findings folder: {0}", "openInExplorerFailed": "Couldn't open path: {0}" },
+    "lists": { "localSuffix": "{0} / local", "smartMyDay": "My Day", "smartImportant": "Important", "smartPlanned": "Planned", "smartNotes": "Notes", "virtualQueue": "Queue", "virtualRunning": "Running", "virtualReview": "Review", "newList": "New list", "findingsNotFound": "No findings yet for this list.", "findingsOpenFailed": "Couldn't open findings folder: {0}", "openInExplorerFailed": "Couldn't open path: {0}" },
     "repoImport": { "loadFailed": "Couldn't load remembered folders: {0}", "saveFailed": "Couldn't save folders: {0}" }
   },
   "ops": {

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

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

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

@@ -30,6 +30,9 @@ public interface IWorkerClient : INotifyPropertyChanged
     /// task to carry out nextPhase ("wait" | "merge" | "wait_final" | "merge_final").</summary>
     event Action<string, IReadOnlyList<string>, string>? HandoffRequestedEvent;
 
+    /// <summary>An agent added a note through the MCP tool — an open notes editor reloads.</summary>
+    event Action? NotesUpdatedEvent;
+
     event Action? PrepStartedEvent;
     event Action<string>? PrepLineEvent;
     event Action<bool>? PrepFinishedEvent;
@@ -172,6 +175,8 @@ public interface IWorkerClient : INotifyPropertyChanged
     Task<AppSettingsDto?> GetAppSettingsAsync();
     Task UpdateAppSettingsAsync(AppSettingsDto dto);
     Task<List<DailyNoteDto>> GetDailyNotesAsync(DateOnly day);
+    /// <summary>Both ends inclusive.</summary>
+    Task<List<DailyNoteDto>> GetDailyNotesBetweenAsync(DateOnly start, DateOnly end);
     Task<DailyNoteDto?> AddDailyNoteAsync(DateOnly day, string text);
     Task UpdateDailyNoteAsync(string id, string text);
     Task DeleteDailyNoteAsync(string id);

src/ClaudeDo.Ui/Services/ReportDtos.cs

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

src/ClaudeDo.Ui/Services/WorkerClient.cs

@@ -54,6 +54,7 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public event Action<string>? ListUpdatedEvent;
     public event Action<WorkerLogEntry>? WorkerLogReceivedEvent;
 
+    public event Action? NotesUpdatedEvent;
     public event Action? PrepStartedEvent;
     public event Action<string>? PrepLineEvent;
     public event Action<bool>? PrepFinishedEvent;
@@ -213,6 +214,7 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
             Dispatcher.UIThread.Post(() => PrimeFired?.Invoke(new PrimeFiredEvent(id, ok, msg, when)));
         });
 
+        _hub.On("NotesUpdated", () => Dispatcher.UIThread.Post(() => NotesUpdatedEvent?.Invoke()));
         _hub.On("PrepStarted", () => Dispatcher.UIThread.Post(() => PrepStartedEvent?.Invoke()));
         _hub.On<string>("PrepLine", line => Dispatcher.UIThread.Post(() => PrepLineEvent?.Invoke(line)));
         _hub.On<bool>("PrepFinished", ok => Dispatcher.UIThread.Post(() => PrepFinishedEvent?.Invoke(ok)));
@@ -475,6 +477,9 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
     public async Task<List<DailyNoteDto>> GetDailyNotesAsync(DateOnly day)
         => await TryInvokeAsync<List<DailyNoteDto>>("GetDailyNotes", IsoDay(day)) ?? new List<DailyNoteDto>();
 
+    public async Task<List<DailyNoteDto>> GetDailyNotesBetweenAsync(DateOnly start, DateOnly end)
+        => await TryInvokeAsync<List<DailyNoteDto>>("GetDailyNotesBetween", IsoDay(start), IsoDay(end)) ?? new List<DailyNoteDto>();
+
     public async Task<DailyNoteDto?> AddDailyNoteAsync(DateOnly day, string text)
         => await InvokeTimedAsync<DailyNoteDto>("AddDailyNote", () => _hub.InvokeAsync<DailyNoteDto>("AddDailyNote", IsoDay(day), text));
 

src/ClaudeDo.Ui/Services/WorkerNotesApi.cs

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

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

@@ -20,7 +20,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
     private readonly IWorkerClient _worker;
     private readonly IServiceProvider _services;
-    private readonly INotesApi _notesApi;
     private readonly MergeCoordinator _merge;
 
     // ── Section view models ───────────────────────────────────────────────────
@@ -39,29 +38,20 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     private readonly Action<string, string?> _workerPlanningMergeAbortedHandler;
     private readonly Action<string> _workerPlanningCompletedHandler;
 
-    [ObservableProperty] private bool _isNotesMode;
     [ObservableProperty] private bool _isPrepMode;
 
-    public bool IsTaskDetailVisible => !IsNotesMode && !IsPrepMode;
+    public bool IsTaskDetailVisible => !IsPrepMode;
 
-    /// <summary>Centered placeholder shown when no task is selected — hidden in Notes/Prep mode,
+    /// <summary>Centered placeholder shown when no task is selected — hidden in Prep mode,
     /// where <see cref="IsTaskDetailVisible"/> is already false.</summary>
     public bool IsEmptyStateVisible => Task is null && IsTaskDetailVisible;
 
-    partial void OnIsNotesModeChanged(bool value)
-    {
-        OnPropertyChanged(nameof(IsTaskDetailVisible));
-        OnPropertyChanged(nameof(IsEmptyStateVisible));
-    }
-
     partial void OnIsPrepModeChanged(bool value)
     {
         OnPropertyChanged(nameof(IsTaskDetailVisible));
         OnPropertyChanged(nameof(IsEmptyStateVisible));
     }
 
-    public NotesEditorViewModel Notes { get; private set; } = null!;
-
     // Current task row (set by IslandsShellViewModel via Bind)
     [ObservableProperty]
     [NotifyCanExecuteChangedFor(nameof(EnqueueCommand))]
@@ -324,13 +314,11 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         IDbContextFactory<ClaudeDoDbContext> dbFactory,
         IWorkerClient worker,
         IServiceProvider services,
-        INotesApi notesApi,
         MergeCoordinator merge)
     {
         _dbFactory = dbFactory;
         _worker = worker;
         _services = services;
-        _notesApi = notesApi;
         _merge = merge;
 
         Monitor = new TaskMonitorViewModel(dbFactory, worker);
@@ -374,8 +362,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
             if (e.PropertyName == nameof(OperationStatus.IsRunning)) ParkReviewCommand.NotifyCanExecuteChanged();
         };
 
-        Notes = new NotesEditorViewModel(_notesApi);
-        Notes.ErrorReported += msg => { if (ShowErrorAsync is not null) _ = ShowErrorAsync(msg); };
         Subtasks.CollectionChanged += (_, _) => NotifyStepsChanged();
         Subtasks.CollectionChanged += (_, _) => Merge.SyncChildOutcomes(HasChildOutcomes, Subtasks.Count);
         Attachments.CollectionChanged += (_, _) => OnPropertyChanged(nameof(FilesBadge));
@@ -592,18 +578,9 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
         catch { }
     }
 
-    public void ShowNotes()
-    {
-        Bind(null, "notes");
-        IsPrepMode = false;
-        IsNotesMode = true;
-        _ = Notes.LoadDayAsync(DateOnly.FromDateTime(DateTime.Today));
-    }
-
     public void ShowPrep()
     {
         Bind(null, "prep");
-        IsNotesMode = false;
         IsPrepMode = true;
         _ = Prep.LoadLastPrepLogIfEmptyAsync();
     }
@@ -612,7 +589,6 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase, IDisposable
     /// logged with the bind timing so rebind churn can be attributed to a trigger.</param>
     public void Bind(TaskRowViewModel? row, string source = "?")
     {
-        IsNotesMode = false;
         IsPrepMode = false;
         _loadCts?.Cancel();
         _loadCts?.Dispose();

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

@@ -22,6 +22,10 @@ public sealed record MergeHelperRequest(string ListId, IReadOnlyList<string> Tas
 
 public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
 {
+    /// <summary>The day-log list. A smart list with no tasks in it: selecting it makes the tasks
+    /// island show the notes editor instead of rows.</summary>
+    public const string NotesListId = "smart:notes";
+
     private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
     private readonly IServiceProvider? _services;
     private readonly IWorkerClient? _worker;
@@ -255,6 +259,7 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
         "smart:my-day"    => "vm.lists.smartMyDay",
         "smart:important" => "vm.lists.smartImportant",
         "smart:planned"   => "vm.lists.smartPlanned",
+        NotesListId       => "vm.lists.smartNotes",
         "virtual:queued"  => "vm.lists.virtualQueue",
         "virtual:running" => "vm.lists.virtualRunning",
         "virtual:review"  => "vm.lists.virtualReview",
@@ -279,6 +284,7 @@ public sealed partial class ListsIslandViewModel : ViewModelBase, IDisposable
             new ListNavItemViewModel { Id = "smart:my-day",    Name = Loc.T("vm.lists.smartMyDay"),      Kind = ListKind.Smart,   IconKey = "Sun" },
             new ListNavItemViewModel { Id = "smart:important", Name = Loc.T("vm.lists.smartImportant"),  Kind = ListKind.Smart,   IconKey = "Star" },
             new ListNavItemViewModel { Id = "smart:planned",   Name = Loc.T("vm.lists.smartPlanned"),    Kind = ListKind.Smart,   IconKey = "Calendar" },
+            new ListNavItemViewModel { Id = NotesListId,       Name = Loc.T("vm.lists.smartNotes"),      Kind = ListKind.Smart,   IconKey = "Text" },
             new ListNavItemViewModel { Id = "virtual:queued",  Name = Loc.T("vm.lists.virtualQueue"),    Kind = ListKind.Virtual, IconKey = "Inbox" },
             new ListNavItemViewModel { Id = "virtual:running", Name = Loc.T("vm.lists.virtualRunning"),  Kind = ListKind.Virtual, IconKey = "Activity" },
             new ListNavItemViewModel { Id = "virtual:review",  Name = Loc.T("vm.lists.virtualReview"),   Kind = ListKind.Virtual, IconKey = "Eye" },

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

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

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

@@ -9,6 +9,7 @@ using ClaudeDo.Data.Models;
 using ClaudeDo.Data.Repositories;
 using ClaudeDo.Ui.Localization;
 using ClaudeDo.Ui.Services;
+using ClaudeDo.Ui.Services.Interfaces;
 using ClaudeDo.Ui.ViewModels.Modals;
 using Microsoft.EntityFrameworkCore;
 using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
@@ -62,18 +63,10 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
 
     public event EventHandler? FocusAddTaskRequested;
     public event EventHandler? TasksChanged;
-    public event Action? NotesRequested;
     public event Action? PrepRequested;
     public event Action<string>? ErrorReported;
     public void RequestFocusAddTask() => FocusAddTaskRequested?.Invoke(this, EventArgs.Empty);
 
-    [RelayCommand]
-    private void OpenNotes()
-    {
-        SelectFrom(null, "notes");
-        NotesRequested?.Invoke();
-    }
-
     [RelayCommand]
     private void ShowPrepLog() => PrepRequested?.Invoke();
 
@@ -118,8 +111,17 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
     private bool _hasCompleted;
     [ObservableProperty] private bool _showOpenLabel;
     [ObservableProperty] private string _completedHeader = "";
-    [ObservableProperty] private bool _showNotesRow;
     [ObservableProperty] private bool _isMyDayList;
+
+    /// <summary>The notes list is content, not a task list — the island swaps its rows for the
+    /// notes editor instead of showing an empty task list.</summary>
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsTasksEmptyHintVisible))]
+    [NotifyPropertyChangedFor(nameof(IsTasksEmptyRepoHintVisible))]
+    private bool _isNotesList;
+
+    /// <summary>Null only in tests that construct the island without a notes API.</summary>
+    public NotesEditorViewModel? Notes { get; }
     [ObservableProperty]
     [NotifyPropertyChangedFor(nameof(IsTasksEmptyRepoHintVisible))]
     private bool _isLetClaudeVisible;
@@ -128,7 +130,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
 
     /// <summary>No visible tasks below the add-task row — every item lands in one of
     /// Overdue/Open/Completed, so all-false here always means the list has zero items.</summary>
-    public bool IsTasksEmptyHintVisible => !HasOverdue && !HasOpen && !HasCompleted;
+    public bool IsTasksEmptyHintVisible => !HasOverdue && !HasOpen && !HasCompleted && !IsNotesList;
 
     /// <summary>Extra empty-state line for a User list with no linked working dir, where the
     /// execution features (queue, Let Claude handle it, Quick session) are unavailable. Derived
@@ -182,10 +184,20 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
 
     private readonly EventHandler _langChangedHandler;
 
-    public TasksIslandViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, IWorkerClient? worker = null)
+    public TasksIslandViewModel(
+        IDbContextFactory<ClaudeDoDbContext> dbFactory,
+        IWorkerClient? worker = null,
+        INotesApi? notesApi = null)
     {
         _dbFactory = dbFactory;
         _worker = worker;
+        if (notesApi is not null)
+        {
+            Notes = new NotesEditorViewModel(notesApi);
+            Notes.ErrorReported += msg => ErrorReported?.Invoke(msg);
+            if (worker is not null)
+                worker.NotesUpdatedEvent += () => { if (IsNotesList) _ = Notes.LoadAsync(); };
+        }
         _completedHeaderRow = new() { ActionCommand = ClearCompletedCommand };
         CompletedHeader = Loc.T("vm.tasksIsland.completedHeader");
         if (_worker is not null)
@@ -417,14 +429,14 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         HasOpen       = false;
         HasCompleted  = false;
         ShowOpenLabel = false;
-        ShowNotesRow  = false;
         if (listChanged) SelectFrom(null, "list-change");
         if (list is null) { IsLetClaudeVisible = false; IsQuickClaudeVisible = false; IsMergeReviewsVisible = false; LoadTask = Task.CompletedTask; return; }
 
         HeaderTitle = list.Name;
         HeaderEyebrow = DateTime.Now.ToString("dddd · MMM dd", CultureInfo.InvariantCulture).ToUpperInvariant();
-        ShowNotesRow = list.Id == "smart:my-day";
         IsMyDayList  = list.Id == "smart:my-day";
+        IsNotesList  = list.Id == ListsIslandViewModel.NotesListId;
+        if (IsNotesList && Notes is not null) _ = Notes.LoadAsync();
         IsLetClaudeVisible = list.Kind == ListKind.User && !string.IsNullOrWhiteSpace(list.WorkingDir);
         IsQuickClaudeVisible = IsLetClaudeVisible;
         IsMergeReviewsVisible = list.Id == "virtual:review";
@@ -796,7 +808,8 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         var running = Items.Count(i => i.Status == TaskStatus.Running);
         var review  = Items.Count(i => i.Status == TaskStatus.Done && i.Branch != null);
 
-        Subtitle = open == 1 ? "1 open task" : $"{open} open tasks";
+        // The notes list holds no tasks — an "0 open tasks" line under its header is just noise.
+        Subtitle = IsNotesList ? "" : open == 1 ? "1 open task" : $"{open} open tasks";
 
         if (running > 0 || review > 0)
         {

src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs

@@ -145,7 +145,14 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
     [ObservableProperty]
     private bool _isWorkerLogVisible;
 
-    public bool ShowDetails => WindowWidth >= 1100;
+    /// <summary>The notes list has nothing to show a detail pane for, so the pane goes away and
+    /// the editor takes the space instead of leaving an empty column beside it.</summary>
+    public bool ShowDetails => WindowWidth >= 1100 && Tasks?.IsNotesList != true;
+
+    /// <summary>Widens the tasks island over the splitter and the details column when that column
+    /// is hidden — a fixed-width ColumnDefinition keeps its space even with an invisible child.</summary>
+    public int TasksColumnSpan => ShowDetails ? 1 : 3;
+
     public bool ShowLists => WindowWidth >= 780;
 
     private readonly System.Timers.Timer _clearTimer = new(30_000) { AutoReset = false };
@@ -168,10 +175,16 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
 
     partial void OnWindowWidthChanged(double value)
     {
-        OnPropertyChanged(nameof(ShowDetails));
+        NotifyDetailsVisibility();
         OnPropertyChanged(nameof(ShowLists));
     }
 
+    private void NotifyDetailsVisibility()
+    {
+        OnPropertyChanged(nameof(ShowDetails));
+        OnPropertyChanged(nameof(TasksColumnSpan));
+    }
+
     public void OnWorkerLogReceived(WorkerLogEntry entry)
     {
         var hhmm = entry.TimestampUtc.ToLocalTime().ToString("HH:mm");
@@ -340,8 +353,11 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
         Lists.SelectionChanged += (_, _) => Tasks.LoadForList(Lists.SelectedList);
         Lists.SelectionChanged += (_, _) => _ = RefreshStaleWorkerCheckAsync();
         Tasks.SelectionChanged += (_, _) => Details.Bind(Tasks.SelectedTask, Tasks.SelectionSource);
-        Tasks.NotesRequested += () => Details.ShowNotes();
         Tasks.PrepRequested += () => Details.ShowPrep();
+        Tasks.PropertyChanged += (_, e) =>
+        {
+            if (e.PropertyName == nameof(TasksIslandViewModel.IsNotesList)) NotifyDetailsVisibility();
+        };
         Tasks.ErrorReported += FlashFooterError;
         Lists.ErrorReported += FlashFooterError;
         Lists.SuccessReported += FlashFooterSuccess;

src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml

@@ -125,17 +125,12 @@
                       DragCompleted="OnSplitterDragCompleted"/>
       </Grid>
 
-      <!-- Empty state: no task selected, outside Notes/Prep mode -->
+      <!-- Empty state: no task selected, outside Prep mode -->
       <TextBlock IsVisible="{Binding IsEmptyStateVisible}"
                  Text="{loc:Tr details.emptyState}"
                  Foreground="{DynamicResource TextMuteBrush}"
                  HorizontalAlignment="Center" VerticalAlignment="Center"/>
 
-      <!-- Notes mode -->
-      <Panel IsVisible="{Binding IsNotesMode}">
-        <islands:NotesEditorView DataContext="{Binding Notes}"/>
-      </Panel>
-
       <!-- Daily-prep mode -->
       <Panel IsVisible="{Binding IsPrepMode}">
         <DockPanel>

src/ClaudeDo.Ui/Views/Islands/NotesEditorView.axaml

@@ -1,38 +1,113 @@
 <UserControl xmlns="https://github.com/avaloniaui"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:vm="using:ClaudeDo.Ui.ViewModels.Islands"
-             xmlns:ctl="using:ClaudeDo.Ui.Views.Controls"
              xmlns:loc="using:ClaudeDo.Ui.Localization"
              x:Class="ClaudeDo.Ui.Views.Islands.NotesEditorView"
              x:DataType="vm:NotesEditorViewModel">
-  <DockPanel Margin="16">
-    <StackPanel DockPanel.Dock="Top" Orientation="Horizontal" Spacing="8">
-      <Button Classes="btn" Content="&#x2039;" Command="{Binding PrevDayCommand}"/>
-      <ctl:ThemedDatePicker SelectedDate="{Binding CurrentDate, Mode=TwoWay}"/>
-      <Button Classes="btn" Content="&#x203A;" Command="{Binding NextDayCommand}"/>
-      <Button Classes="btn" Content="{loc:Tr notes.today}" Command="{Binding TodayCommand}"/>
-      <TextBlock Classes="meta" VerticalAlignment="Center" Text="{Binding CurrentDayLabel}"/>
-    </StackPanel>
 
-    <DockPanel DockPanel.Dock="Top" Margin="0,12,0,8">
+  <UserControl.Styles>
-      <Button DockPanel.Dock="Right" Classes="btn" Content="{loc:Tr notes.add}" Margin="8,0,0,0"
+    <!-- A note reads as text, not as a form field: the box only shows itself under the pointer
-              Command="{Binding AddBulletCommand}"/>
+         and while it has focus. -->
-      <TextBox PlaceholderText="{loc:Tr notes.newNotePlaceholder}" Text="{Binding NewBulletText}">
+    <Style Selector="TextBox.note">
-        <TextBox.KeyBindings>
+      <Setter Property="Background" Value="Transparent"/>
-          <KeyBinding Gesture="Enter" Command="{Binding AddBulletCommand}"/>
+      <Setter Property="BorderThickness" Value="0"/>
-        </TextBox.KeyBindings>
+      <Setter Property="Padding" Value="4,3"/>
-      </TextBox>
+      <Setter Property="MinHeight" Value="0"/>
-    </DockPanel>
+    </Style>
+    <Style Selector="TextBox.note /template/ Border#PART_BorderElement">
+      <Setter Property="Background" Value="Transparent"/>
+      <Setter Property="BorderThickness" Value="0"/>
+    </Style>
 
-    <ScrollViewer>
+    <Style Selector="Border.note-row">
-      <ItemsControl ItemsSource="{Binding Bullets}">
+      <Setter Property="CornerRadius" Value="6"/>
-        <ItemsControl.ItemTemplate>
+      <Setter Property="Padding" Value="10,1,6,1"/>
-          <DataTemplate x:DataType="vm:NoteBulletViewModel">
+      <Setter Property="Margin" Value="4,1"/>
-            <TextBox Text="{Binding Text}" Margin="0,2"
+    </Style>
-                     LostFocus="OnBulletLostFocus"/>
+    <Style Selector="Border.note-row:pointerover">
-          </DataTemplate>
+      <Setter Property="Background" Value="{DynamicResource PeatSoftBrush}"/>
-        </ItemsControl.ItemTemplate>
+    </Style>
-      </ItemsControl>
+    <!-- Row actions stay out of the way until the row is hovered. -->
-    </ScrollViewer>
+    <Style Selector="Border.note-row Button.note-del">
+      <Setter Property="Opacity" Value="0"/>
+    </Style>
+    <Style Selector="Border.note-row:pointerover Button.note-del">
+      <Setter Property="Opacity" Value="1"/>
+    </Style>
+  </UserControl.Styles>
+
+  <DockPanel LastChildFill="True">
+
+    <!-- Today's capture box: Enter files the note and leaves the caret here for the next one. -->
+    <Border DockPanel.Dock="Top" Classes="add-task" Margin="16,14,16,10">
+      <Grid ColumnDefinitions="Auto,*,Auto">
+        <Border Grid.Column="0" Classes="add-task-plus" VerticalAlignment="Center">
+          <PathIcon Width="12" Height="12" Data="{StaticResource Icon.Plus}"
+                    Foreground="{DynamicResource TextFaintBrush}"/>
+        </Border>
+        <!-- Enter/Shift+Enter are handled in the code-behind's tunnel handler, same as the note
+             rows: a KeyBinding would never fire, because AcceptsReturn makes TextBox consume
+             Enter first. -->
+        <TextBox Grid.Column="1" x:Name="NewNoteBox" Classes="add-task-input"
+                 PlaceholderText="{loc:Tr notes.newNotePlaceholder}"
+                 Text="{Binding NewBulletText, Mode=TwoWay}"
+                 AcceptsReturn="True" TextWrapping="Wrap"
+                 VerticalAlignment="Center" Margin="12,0,0,0"/>
+        <Border Grid.Column="2" Classes="kbd kbd-enter" VerticalAlignment="Center"
+                IsVisible="{Binding #NewNoteBox.IsFocused}">
+          <TextBlock Text="{loc:Tr tasks.enterKey}"/>
+        </Border>
+      </Grid>
+    </Border>
+
+    <Panel>
+      <ScrollViewer>
+        <ItemsControl x:Name="RowsHost" ItemsSource="{Binding Rows}" Margin="10,0,10,12">
+          <ItemsControl.DataTemplates>
+
+            <DataTemplate DataType="vm:NoteDayHeaderViewModel">
+              <TextBlock Classes="eyebrow section-label" Margin="14,12,14,4" Text="{Binding Label}"/>
+            </DataTemplate>
+
+            <DataTemplate DataType="vm:NoteBulletViewModel">
+              <Border Classes="note-row">
+                <Grid ColumnDefinitions="Auto,*,Auto,Auto">
+                  <Ellipse Grid.Column="0" Width="4" Height="4" Margin="0,0,10,0"
+                           VerticalAlignment="Center"
+                           Fill="{DynamicResource TextFaintBrush}"/>
+                  <!-- AcceptsReturn/TextWrapping are set here, not in the style above: TextBox
+                       reads AcceptsReturn in its own OnKeyDown, which runs before any handler a
+                       style or the XAML could attach. Enter is intercepted in the tunnel phase
+                       (see code-behind) so the split still wins over the newline. -->
+                  <TextBox Grid.Column="1" Classes="note" Text="{Binding Text, Mode=TwoWay}"
+                           AcceptsReturn="True" TextWrapping="Wrap"
+                           LostFocus="OnBulletLostFocus"/>
+                  <PathIcon Grid.Column="2" Width="12" Height="12" Margin="6,0"
+                            VerticalAlignment="Center"
+                            IsVisible="{Binding FromAgent}"
+                            ToolTip.Tip="{loc:Tr notes.fromAgentTip}"
+                            Data="{StaticResource Icon.AgentSuggested}"
+                            Foreground="{DynamicResource TextFaintBrush}"/>
+                  <Button Grid.Column="3" Classes="icon-btn note-del"
+                          VerticalAlignment="Center"
+                          ToolTip.Tip="{loc:Tr notes.deleteTip}"
+                          Click="OnDeleteBulletClick">
+                    <PathIcon Classes="danger" Data="{StaticResource Icon.Trash}" Width="12" Height="12"/>
+                  </Button>
+                </Grid>
+              </Border>
+            </DataTemplate>
+
+          </ItemsControl.DataTemplates>
+        </ItemsControl>
+      </ScrollViewer>
+
+      <TextBlock IsVisible="{Binding IsEmpty}"
+                 Text="{loc:Tr notes.emptyHint}"
+                 Foreground="{DynamicResource TextMuteBrush}"
+                 MaxWidth="260" TextAlignment="Center" TextWrapping="Wrap"
+                 HorizontalAlignment="Center" VerticalAlignment="Center"
+                 IsHitTestVisible="False"/>
+    </Panel>
   </DockPanel>
 </UserControl>

src/ClaudeDo.Ui/Views/Islands/NotesEditorView.axaml.cs

@@ -1,12 +1,74 @@
 using Avalonia.Controls;
+using Avalonia.Input;
 using Avalonia.Interactivity;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
 using ClaudeDo.Ui.ViewModels.Islands;
 
 namespace ClaudeDo.Ui.Views.Islands;
 
 public partial class NotesEditorView : UserControl
 {
-    public NotesEditorView() => InitializeComponent();
+    private NotesEditorViewModel? _vm;
+
+    public NotesEditorView()
+    {
+        InitializeComponent();
+        DataContextChanged += OnDataContextChanged;
+        // Tunnel, not bubble: with AcceptsReturn on, TextBox.OnKeyDown consumes Enter (any
+        // modifier) before a bubbling handler ever sees it. Taking Enter in the tunnel phase
+        // keeps the split chain, and letting Shift+Enter through leaves the newline to the box.
+        AddHandler(KeyDownEvent, OnBulletKeyDown, RoutingStrategies.Tunnel);
+    }
+
+
+    private void OnDataContextChanged(object? sender, EventArgs e)
+    {
+        if (_vm is not null) _vm.FocusRequested -= FocusBullet;
+        _vm = DataContext as NotesEditorViewModel;
+        if (_vm is not null) _vm.FocusRequested += FocusBullet;
+    }
+
+    /// <summary>Rows the VM just inserted have no container yet — wait for the layout pass that
+    /// creates it before reaching for the TextBox inside.</summary>
+    private void FocusBullet(NoteBulletViewModel bullet) =>
+        Dispatcher.UIThread.Post(
+            () => RowsHost.ContainerFromItem(bullet)?.FindDescendantOfType<TextBox>()?.Focus(),
+            DispatcherPriority.Loaded);
+
+    private void OnBulletKeyDown(object? sender, KeyEventArgs e)
+    {
+        // Source, not sender: the tunnel handler is attached to the whole view, so it sees the
+        // capture box at the top as well as the note rows. Both need the same Enter/Shift+Enter
+        // split, and neither can get it from a KeyBinding — with AcceptsReturn on, TextBox eats
+        // Enter in its own OnKeyDown before any bubbling handler or binding runs.
+        if (e.Source is not TextBox box || DataContext is not NotesEditorViewModel vm) return;
+        var shift = e.KeyModifiers.HasFlag(KeyModifiers.Shift);
+
+        if (ReferenceEquals(box, NewNoteBox))
+        {
+            if (e.Key == Key.Enter && !shift)
+            {
+                e.Handled = true;
+                vm.AddBulletCommand.Execute(null);
+            }
+            return;
+        }
+
+        if (box.DataContext is not NoteBulletViewModel bullet) return;
+
+        // Shift+Enter falls through to the TextBox and breaks the line — a note can be several.
+        if (e.Key == Key.Enter && !shift)
+        {
+            e.Handled = true;
+            vm.SplitBulletCommand.Execute(bullet);
+        }
+        else if (e.Key == Key.Back && string.IsNullOrEmpty(box.Text))
+        {
+            e.Handled = true;
+            vm.DeleteBulletCommand.Execute(bullet);
+        }
+    }
 
     private void OnBulletLostFocus(object? sender, RoutedEventArgs e)
     {
@@ -15,4 +77,11 @@ public partial class NotesEditorView : UserControl
             && vm.CommitBulletCommand.CanExecute(bullet))
             vm.CommitBulletCommand.Execute(bullet);
     }
+
+    private void OnDeleteBulletClick(object? sender, RoutedEventArgs e)
+    {
+        if (sender is Button { DataContext: NoteBulletViewModel bullet }
+            && DataContext is NotesEditorViewModel vm)
+            vm.DeleteBulletCommand.Execute(bullet);
+    }
 }

src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml

@@ -31,6 +31,7 @@
             <TextBlock Text="{Binding StatusPill}"/>
           </Border>
           <Button Classes="icon-btn" Classes.active="{Binding IsShowingCompleted}"
+                  IsVisible="{Binding !IsNotesList}"
                   Command="{Binding ToggleShowCompletedCommand}"
                   ToolTip.Tip="{loc:Tr tasks.showCompletedTip}">
             <PathIcon Width="15" Height="15" Data="{StaticResource Icon.Eye}"/>
@@ -60,7 +61,8 @@
               <Path Classes="icon-stroke" Data="{StaticResource Icon.PlanDay}"/>
             </Viewbox>
           </Button>
-          <Button Classes="icon-btn" Command="{Binding OpenListSettingsCommand}" ToolTip.Tip="{loc:Tr tasks.listSettingsTip}">
+          <Button Classes="icon-btn" IsVisible="{Binding !IsNotesList}"
+                  Command="{Binding OpenListSettingsCommand}" ToolTip.Tip="{loc:Tr tasks.listSettingsTip}">
             <PathIcon Width="15" Height="15" Data="{StaticResource Icon.Settings}"/>
           </Button>
         </StackPanel>
@@ -68,7 +70,8 @@
     </Border>
 
     <!-- Add-task row -->
-    <Border DockPanel.Dock="Top" Classes="add-task" Margin="16,14,16,8">
+    <Border DockPanel.Dock="Top" Classes="add-task" Margin="16,14,16,8"
+            IsVisible="{Binding !IsNotesList}">
       <Grid ColumnDefinitions="Auto,*,Auto">
         <Border Grid.Column="0" Classes="add-task-plus" VerticalAlignment="Center">
           <PathIcon Width="12" Height="12" Data="{StaticResource Icon.Plus}"
@@ -90,14 +93,6 @@
       </Grid>
     </Border>
 
-    <!-- Notes pinned row (My Day only) -->
-    <Button DockPanel.Dock="Top"
-            Classes="btn" HorizontalAlignment="Stretch" HorizontalContentAlignment="Left"
-            Margin="16,0,16,8"
-            IsVisible="{Binding ShowNotesRow}"
-            Command="{Binding OpenNotesCommand}"
-            Content="{loc:Tr tasks.notesPinnedRow}"/>
-
     <!-- Task list: one flat, virtualized ListBox. Rows is HeaderRow | TaskRowViewModel — group
          headers are regular entries, not a separate ItemsControl per section, so a
          VirtualizingStackPanel actually bounds the realized container count.
@@ -106,6 +101,7 @@
          unreachable. -->
     <Panel>
       <ListBox x:Name="RowsListBox"
+               IsVisible="{Binding !IsNotesList}"
                ItemsSource="{Binding Rows}"
                Background="Transparent"
                BorderThickness="0">
@@ -172,6 +168,11 @@
                    Foreground="{DynamicResource TextMuteBrush}"
                    TextAlignment="Center" TextWrapping="Wrap"/>
       </StackPanel>
+
+      <!-- The notes list is not a task list: same island slot, different content. -->
+      <Panel IsVisible="{Binding IsNotesList}">
+        <islands:NotesEditorView DataContext="{Binding Notes}"/>
+      </Panel>
     </Panel>
 
   </DockPanel>

src/ClaudeDo.Ui/Views/MainWindow.axaml

@@ -144,7 +144,7 @@
                     ResizeDirection="Columns"
                     ResizeBehavior="PreviousAndNext"/>
 
-      <Border Grid.Column="2" Classes="island" Margin="3">
+      <Border Grid.Column="2" Grid.ColumnSpan="{Binding TasksColumnSpan}" Classes="island" Margin="3">
         <islands:TasksIslandView DataContext="{Binding Tasks}"/>
       </Border>
 

src/ClaudeDo.Worker/External/NotesMcpTools.cs

@@ -0,0 +1,59 @@
+using System.ComponentModel;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Hub;
+using ModelContextProtocol.Server;
+
+namespace ClaudeDo.Worker.External;
+
+public sealed record AddNoteResult(bool Saved, string Id, int AgentNotesToday, int RemainingToday);
+
+[McpServerToolType]
+public sealed class NotesMcpTools
+{
+    /// <summary>Agent-written notes allowed per day. The user's own notes are never counted or
+    /// capped — this only stops an agent from burying the day in its own bullets.</summary>
+    public const int DailyAgentCap = 10;
+
+    /// <summary>A note is a line, not a report. Longer output belongs in a task or a finding.</summary>
+    public const int MaxLength = 500;
+
+    private readonly DailyNoteRepository _notes;
+    private readonly HubBroadcaster _broadcaster;
+
+    public NotesMcpTools(DailyNoteRepository notes, HubBroadcaster broadcaster)
+    {
+        _notes = notes;
+        _broadcaster = broadcaster;
+    }
+
+    [McpServerTool, Description(
+        "Add one short line to the user's notes for today — the day log they read in ClaudeDo, " +
+        "not a log for you. Write only what the user would want to reread later and would " +
+        "otherwise lose: a decision they made, something you found that changes their plans, " +
+        "something they asked you to remember for the day. Task status, your progress and " +
+        "anything already visible in the task list are noise here. When unsure, don't. " +
+        "Capped at 10 agent notes per day; you cannot edit or delete notes, so a bad one stays " +
+        "until the user removes it.")]
+    public async Task<AddNoteResult> AddNote(
+        [Description("The note itself: one plain sentence, no markdown, no prefix, max 500 characters.")] string text,
+        CancellationToken cancellationToken = default)
+    {
+        var trimmed = (text ?? "").Trim();
+        if (trimmed.Length == 0)
+            throw new InvalidOperationException("text is required.");
+        if (trimmed.Length > MaxLength)
+            throw new InvalidOperationException(
+                $"Note is {trimmed.Length} characters, the limit is {MaxLength}. Shorten it to one line.");
+
+        var today = DateOnly.FromDateTime(DateTime.Today);
+        var used = await _notes.CountAgentNotesAsync(today, cancellationToken);
+        if (used >= DailyAgentCap)
+            throw new InvalidOperationException(
+                $"Daily cap reached: {DailyAgentCap} agent notes already written today. " +
+                "Nothing was saved — tell the user instead of retrying.");
+
+        var note = await _notes.AddAsync(today, trimmed, fromAgent: true, cancellationToken);
+        await _broadcaster.NotesUpdated();
+        return new AddNoteResult(true, note.Id, used + 1, DailyAgentCap - used - 1);
+    }
+}

src/ClaudeDo.Worker/Hub/HubBroadcaster.cs

@@ -37,6 +37,10 @@ public sealed class HubBroadcaster : IPrimeBroadcaster, IRefineBroadcaster
     public Task HandoffRequested(string taskId, IReadOnlyList<string> survivingTaskIds, string nextPhase) =>
         _hub.Clients.All.SendAsync("HandoffRequested", taskId, survivingTaskIds, nextPhase);
 
+    /// <summary>An agent wrote a note through MCP — the open notes editor reloads.</summary>
+    public Task NotesUpdated() =>
+        _hub.Clients.All.SendAsync("NotesUpdated");
+
     public Task ListUpdated(string listId) =>
         _hub.Clients.All.SendAsync("ListUpdated", listId);
 

src/ClaudeDo.Worker/Hub/WorkerHub.cs

@@ -970,14 +970,25 @@ public sealed class WorkerHub : Microsoft.AspNetCore.SignalR.Hub
     {
         using var ctx = _dbFactory.CreateDbContext();
         var notes = await new DailyNoteRepository(ctx).ListByDayAsync(Day(dayIso));
-        return notes.Select(n => new DailyNoteDto(n.Id, n.Date.ToString("yyyy-MM-dd"), n.Text, n.SortOrder)).ToList();
+        return notes.Select(Dto).ToList();
     }
 
+    /// <summary>Both ends inclusive — the editor loads today plus its recent history in one call.</summary>
+    public async Task<List<DailyNoteDto>> GetDailyNotesBetween(string startIso, string endIso)
+    {
+        using var ctx = _dbFactory.CreateDbContext();
+        var notes = await new DailyNoteRepository(ctx).ListBetweenAsync(Day(startIso), Day(endIso));
+        return notes.Select(Dto).ToList();
+    }
+
+    private static DailyNoteDto Dto(Data.Models.DailyNoteEntity n) =>
+        new(n.Id, n.Date.ToString("yyyy-MM-dd"), n.Text, n.SortOrder, n.FromAgent);
+
     public async Task<DailyNoteDto> AddDailyNote(string dayIso, string text)
     {
         using var ctx = _dbFactory.CreateDbContext();
         var n = await new DailyNoteRepository(ctx).AddAsync(Day(dayIso), text);
-        return new DailyNoteDto(n.Id, n.Date.ToString("yyyy-MM-dd"), n.Text, n.SortOrder);
+        return Dto(n);
     }
 
     public async Task UpdateDailyNote(string id, string text)

src/ClaudeDo.Worker/Planning/PlanningSessionManager.cs

@@ -98,6 +98,9 @@ public sealed class PlanningSessionManager
         if (!await _git.IsGitRepoAsync(listWorkingDir, ct))
             throw new InvalidOperationException($"Working directory is not a git repository: {listWorkingDir}");
 
+        // A fresh `git init` repo has no HEAD commit to base the planning worktree on.
+        await _git.EnsureHeadCommitAsync(listWorkingDir, ct);
+
         var appSettings = await settings.GetAsync(ct);
         var worktreePath = WorktreePathFor(taskId, appSettings.WorktreeStrategy, appSettings.CentralWorktreeRoot, listWorkingDir);
         var branchName = BranchNameFor(taskId);

src/ClaudeDo.Worker/Program.cs

@@ -355,7 +355,9 @@ if (cfg.ExternalMcpPort > 0)
     externalBuilder.Services.AddScoped<TaskWaitMcpTools>();
     externalBuilder.Services.AddScoped<QueueStateMcpTools>();
     externalBuilder.Services.AddScoped<AttachmentMcpTools>();
+    externalBuilder.Services.AddScoped<DailyNoteRepository>();
     externalBuilder.Services.AddScoped<FindingsMcpTools>();
+    externalBuilder.Services.AddScoped<NotesMcpTools>();
     externalBuilder.Services.AddMcpServer()
         .WithHttpTransport(o => o.Stateless = true)
         .WithRequestFilters(f => f.AddCallToolFilter(ExternalMcpExceptionFilter.Wrap))
@@ -371,7 +373,8 @@ if (cfg.ExternalMcpPort > 0)
         .WithTools<TaskWaitMcpTools>()
         .WithTools<QueueStateMcpTools>()
         .WithTools<AttachmentMcpTools>()
-        .WithTools<FindingsMcpTools>();
+        .WithTools<FindingsMcpTools>()
+        .WithTools<NotesMcpTools>();
     externalBuilder.WebHost.UseUrls($"http://127.0.0.1:{cfg.ExternalMcpPort}");
 
     externalApp = externalBuilder.Build();

src/ClaudeDo.Worker/Report/DailyNoteDto.cs

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

src/ClaudeDo.Worker/Runner/WorktreeManager.cs

@@ -46,6 +46,10 @@ public sealed class WorktreeManager
         if (!await _git.IsGitRepoAsync(workingDir, ct))
             throw new InvalidOperationException($"working_dir is not a git repository: {workingDir}");
 
+        // A fresh `git init` repo has no HEAD commit to base a worktree on — bootstrap one.
+        if (await _git.EnsureHeadCommitAsync(workingDir, ct))
+            _logger.LogInformation("Repository at {Dir} had no commits; created an empty bootstrap commit", workingDir);
+
         var baseCommit = await ResolveBaseCommitAsync(task, workingDir, ct);
         // Use the full task id (dashes stripped) in the branch name so
         // two GUIDs sharing an 8-char prefix cannot collide on the same branch.

tests/ClaudeDo.Ui.Tests/StubWorkerClient.cs

@@ -26,6 +26,7 @@ public abstract class StubWorkerClient : IWorkerClient
     public event Action<string, string, string>? TaskQuestionAskedEvent;
     public event Action<string, string>? TaskQuestionResolvedEvent;
     public event Action<string, IReadOnlyList<string>, string>? HandoffRequestedEvent;
+    public event Action? NotesUpdatedEvent;
     public event Action? PrepStartedEvent;
     public event Action<string>? PrepLineEvent;
     public event Action<bool>? PrepFinishedEvent;
@@ -163,6 +164,7 @@ public abstract class StubWorkerClient : IWorkerClient
     public virtual Task<(bool Ok, string? Error)> SetWorktreeStateAsync(string taskId, WorktreeState newState) => Task.FromResult((true, (string?)null));
     public virtual Task<ForceRemoveResultDto?> ForceRemoveWorktreeAsync(string taskId) => Task.FromResult<ForceRemoveResultDto?>(null);
     public virtual Task<List<DailyNoteDto>> GetDailyNotesAsync(DateOnly day) => Task.FromResult(new List<DailyNoteDto>());
+    public virtual Task<List<DailyNoteDto>> GetDailyNotesBetweenAsync(DateOnly start, DateOnly end) => Task.FromResult(new List<DailyNoteDto>());
     public virtual Task<DailyNoteDto?> AddDailyNoteAsync(DateOnly day, string text) => Task.FromResult<DailyNoteDto?>(null);
     public virtual Task UpdateDailyNoteAsync(string id, string text) => Task.CompletedTask;
     public virtual Task DeleteDailyNoteAsync(string id) => Task.CompletedTask;

tests/ClaudeDo.Ui.Tests/TestDoubles.cs

@@ -23,6 +23,7 @@ public sealed class NullServiceProvider : IServiceProvider
 public sealed class StubNotesApi : INotesApi
 {
     public Task<List<DailyNoteDto>> ListAsync(DateOnly day) => Task.FromResult(new List<DailyNoteDto>());
+    public Task<List<DailyNoteDto>> ListBetweenAsync(DateOnly start, DateOnly end) => 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;

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandConflictSeamTests.cs

@@ -48,7 +48,7 @@ public class DetailsIslandConflictSeamTests : IDisposable
     private DetailsIslandViewModel BuildVm(StubWorkerClient worker, MergeCoordinator merge)
     {
         var factory = new TestDbFactory(NewContext);
-        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider(), new StubNotesApi(), merge);
+        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider(), merge);
     }
 
     [Fact]

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandDeleteTaskTests.cs

@@ -56,7 +56,7 @@ public class DetailsIslandDeleteTaskTests : IDisposable
     private DetailsIslandViewModel BuildVm(RecordingWorkerClient worker)
     {
         var factory = new TestDbFactory(NewContext);
-        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider(), new StubNotesApi(), new ClaudeDo.Ui.Services.MergeCoordinator());
+        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider(), new ClaudeDo.Ui.Services.MergeCoordinator());
     }
 
     [Fact]

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandDescriptionSaveRaceTests.cs

@@ -59,7 +59,7 @@ public class DetailsIslandDescriptionSaveRaceTests : IDisposable
     }
 
     private DetailsIslandViewModel BuildVm() =>
-        new(new TestDbFactory(NewContext), new FakeWorker(), new NullServiceProvider(), new StubNotesApi(),
+        new(new TestDbFactory(NewContext), new FakeWorker(), new NullServiceProvider(),
             new ClaudeDo.Ui.Services.MergeCoordinator());
 
     private async Task<TaskEntity> ReadTaskAsync(string id)

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandEmptyStateTests.cs

@@ -38,7 +38,7 @@ public class DetailsIslandEmptyStateTests : IDisposable
     private DetailsIslandViewModel NewDetailsVm(StubWorkerClient stub)
     {
         var factory = new TestDbFactory(NewContext);
-        return new DetailsIslandViewModel(factory, stub, new NullServiceProvider(), new StubNotesApi(), new ClaudeDo.Ui.Services.MergeCoordinator());
+        return new DetailsIslandViewModel(factory, stub, new NullServiceProvider(), new ClaudeDo.Ui.Services.MergeCoordinator());
     }
 
     [Fact]
@@ -60,17 +60,6 @@ public class DetailsIslandEmptyStateTests : IDisposable
         Assert.False(vm.IsEmptyStateVisible);
     }
 
-    [Fact]
-    public void IsEmptyStateVisible_false_in_notes_mode_even_without_a_task()
-    {
-        var vm = NewDetailsVm(new DefaultStub());
-
-        vm.ShowNotes();
-
-        Assert.True(vm.IsNotesMode);
-        Assert.Null(vm.Task);
-        Assert.False(vm.IsEmptyStateVisible);
-    }
 
     [Fact]
     public void IsEmptyStateVisible_false_in_prep_mode_even_without_a_task()

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandErrorFeedbackTests.cs

@@ -86,7 +86,7 @@ public class DetailsIslandErrorFeedbackTests : IDisposable
     {
         var factory = new TestDbFactory(NewContext);
         return new DetailsIslandViewModel(
-            factory, worker, new NullServiceProvider(), new StubNotesApi(), new ClaudeDo.Ui.Services.MergeCoordinator());
+            factory, worker, new NullServiceProvider(), new ClaudeDo.Ui.Services.MergeCoordinator());
     }
 
     [Fact]

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandHandlerRangeTests.cs

@@ -48,7 +48,7 @@ public class DetailsIslandHandlerRangeTests : IDisposable
     {
         var factory = new TestDbFactory(NewContext);
         return new DetailsIslandViewModel(
-            factory, new FakeWorkerClient(), new NullServiceProvider(), new StubNotesApi(), new MergeCoordinator());
+            factory, new FakeWorkerClient(), new NullServiceProvider(), new MergeCoordinator());
     }
 
     [Fact]

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandPlanningTests.cs

@@ -47,7 +47,7 @@ public class DetailsIslandPlanningTests : IDisposable
     private DetailsIslandViewModel BuildVm(StubWorkerClient worker)
     {
         var factory = new TestDbFactory(NewContext);
-        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider(), new StubNotesApi(), new ClaudeDo.Ui.Services.MergeCoordinator());
+        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider(), new ClaudeDo.Ui.Services.MergeCoordinator());
     }
 
     // Connected worker whose review calls fail the way the hub does when the task

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandPrepModeTests.cs

@@ -37,7 +37,7 @@ public class DetailsIslandPrepModeTests : IDisposable
     private DetailsIslandViewModel NewDetailsVm(StubWorkerClient stub)
     {
         var factory = new TestDbFactory(NewContext);
-        return new DetailsIslandViewModel(factory, stub, new NullServiceProvider(), new StubNotesApi(), new ClaudeDo.Ui.Services.MergeCoordinator());
+        return new DetailsIslandViewModel(factory, stub, new NullServiceProvider(), new ClaudeDo.Ui.Services.MergeCoordinator());
     }
 
 
@@ -53,13 +53,12 @@ public class DetailsIslandPrepModeTests : IDisposable
     }
 
     [Fact]
-    public void ShowPrep_sets_prep_mode_and_clears_notes_mode()
+    public void ShowPrep_sets_prep_mode_and_hides_the_task_detail()
     {
         var vm = NewDetailsVm(new DefaultStub());
         vm.ShowPrep();
 
         Assert.True(vm.IsPrepMode);
-        Assert.False(vm.IsNotesMode);
         Assert.False(vm.IsTaskDetailVisible);
     }
 

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandResetAndRetryTests.cs

@@ -48,7 +48,7 @@ public class DetailsIslandResetAndRetryTests : IDisposable
     {
         var factory = new TestDbFactory(NewContext);
         return new DetailsIslandViewModel(
-            factory, worker, new NullServiceProvider(), new StubNotesApi(), new ClaudeDo.Ui.Services.MergeCoordinator());
+            factory, worker, new NullServiceProvider(), new ClaudeDo.Ui.Services.MergeCoordinator());
     }
 
     [Fact]

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandReviewActionsTests.cs

@@ -50,7 +50,7 @@ public class DetailsIslandReviewActionsTests : IDisposable
     private DetailsIslandViewModel BuildVm(StubWorkerClient worker)
     {
         var factory = new TestDbFactory(NewContext);
-        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider(), new StubNotesApi(), new ClaudeDo.Ui.Services.MergeCoordinator());
+        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider(), new ClaudeDo.Ui.Services.MergeCoordinator());
     }
 
     [Fact]

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandRoadblockReplyTests.cs

@@ -63,7 +63,7 @@ public class DetailsIslandRoadblockReplyTests : IDisposable
     private DetailsIslandViewModel BuildVm(StubWorkerClient worker)
     {
         var factory = new TestDbFactory(NewContext);
-        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider(), new StubNotesApi(), new ClaudeDo.Ui.Services.MergeCoordinator());
+        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider(), new ClaudeDo.Ui.Services.MergeCoordinator());
     }
 
     private static DetailsIslandViewModel PrepareDoneTaskWithRoadblock(DetailsIslandViewModel vm, string taskId = "task-rb-1")

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandTabsTests.cs

@@ -38,7 +38,7 @@ public class DetailsIslandTabsTests : IDisposable
     private DetailsIslandViewModel NewVm()
     {
         var factory = new TestDbFactory(NewContext);
-        return new DetailsIslandViewModel(factory, new DefaultStub(), new NullServiceProvider(), new StubNotesApi(), new ClaudeDo.Ui.Services.MergeCoordinator());
+        return new DetailsIslandViewModel(factory, new DefaultStub(), new NullServiceProvider(), new ClaudeDo.Ui.Services.MergeCoordinator());
     }
 
     [Fact]

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandTaskIdBadgeTests.cs

@@ -40,7 +40,7 @@ public class DetailsIslandTaskIdBadgeTests : IDisposable
     private DetailsIslandViewModel NewVm()
     {
         var factory = new TestDbFactory(NewContext);
-        return new DetailsIslandViewModel(factory, new DefaultStub(), new NullServiceProvider(), new StubNotesApi(), new ClaudeDo.Ui.Services.MergeCoordinator());
+        return new DetailsIslandViewModel(factory, new DefaultStub(), new NullServiceProvider(), new ClaudeDo.Ui.Services.MergeCoordinator());
     }
 
     [Fact]

tests/ClaudeDo.Ui.Tests/ViewModels/DetailsIslandTaskUpdatedTests.cs

@@ -57,7 +57,7 @@ public class DetailsIslandTaskUpdatedTests : IDisposable
     }
 
     private DetailsIslandViewModel BuildVm(StubWorkerClient worker) =>
-        new(new TestDbFactory(NewContext), worker, new NullServiceProvider(), new StubNotesApi(),
+        new(new TestDbFactory(NewContext), worker, new NullServiceProvider(),
             new ClaudeDo.Ui.Services.MergeCoordinator());
 
     [Fact]

tests/ClaudeDo.Ui.Tests/ViewModels/NotesEditorViewModelTests.cs

@@ -6,42 +6,110 @@ namespace ClaudeDo.Ui.Tests.ViewModels;
 
 public class NotesEditorViewModelTests
 {
+    private static readonly DateOnly Today = DateOnly.FromDateTime(DateTime.Today);
+
     private sealed class FakeNotes : INotesApi
     {
         public readonly List<DailyNoteDto> Store = new();
         private int _seq;
+
         public Task<List<DailyNoteDto>> ListAsync(DateOnly day) =>
-            Task.FromResult(Store.Where(n => n.Date == day.ToString("yyyy-MM-dd")).ToList());
+            Task.FromResult(Store.Where(n => n.Date == Iso(day)).ToList());
+
+        public Task<List<DailyNoteDto>> ListBetweenAsync(DateOnly start, DateOnly end) =>
+            Task.FromResult(Store
+                .Where(n => DateOnly.Parse(n.Date) >= start && DateOnly.Parse(n.Date) <= end)
+                .ToList());
+
         public Task<DailyNoteDto?> AddAsync(DateOnly day, string text)
         {
-            var dto = new DailyNoteDto($"id{_seq++}", day.ToString("yyyy-MM-dd"), text, Store.Count);
+            var dto = new DailyNoteDto($"id{_seq++}", Iso(day), text, Store.Count, false);
             Store.Add(dto);
             return Task.FromResult<DailyNoteDto?>(dto);
         }
+
         public Task UpdateAsync(string id, string text)
         {
             var i = Store.FindIndex(n => n.Id == id);
             if (i >= 0) Store[i] = Store[i] with { Text = text };
             return Task.CompletedTask;
         }
+
         public Task DeleteAsync(string id) { Store.RemoveAll(n => n.Id == id); return Task.CompletedTask; }
+
+        public void Seed(DateOnly day, string text, bool fromAgent = false) =>
+            Store.Add(new DailyNoteDto($"id{_seq++}", Iso(day), text, Store.Count, fromAgent));
+
+        private static string Iso(DateOnly d) => d.ToString("yyyy-MM-dd");
     }
 
     private sealed class ThrowingNotes : INotesApi
     {
         public string ExceptionMessage { get; init; } = "worker offline";
         public Task<List<DailyNoteDto>> ListAsync(DateOnly day) => Task.FromResult(new List<DailyNoteDto>());
+        public Task<List<DailyNoteDto>> ListBetweenAsync(DateOnly start, DateOnly end) => Task.FromResult(new List<DailyNoteDto>());
         public Task<DailyNoteDto?> AddAsync(DateOnly day, string text) => throw new Exception(ExceptionMessage);
         public Task UpdateAsync(string id, string text) => Task.CompletedTask;
         public Task DeleteAsync(string id) => Task.CompletedTask;
     }
 
+    private static async Task<(NotesEditorViewModel vm, FakeNotes api)> LoadedAsync(Action<FakeNotes>? seed = null)
+    {
+        var api = new FakeNotes();
+        seed?.Invoke(api);
+        var vm = new NotesEditorViewModel(api);
+        await vm.LoadAsync();
+        return (vm, api);
+    }
+
+    private static List<NoteBulletViewModel> Bullets(NotesEditorViewModel vm) =>
+        vm.Rows.OfType<NoteBulletViewModel>().ToList();
+
+    [Fact]
+    public async Task LoadAsync_groups_notes_by_day_with_today_first()
+    {
+        var (vm, _) = await LoadedAsync(api =>
+        {
+            api.Seed(Today.AddDays(-2), "vorgestern");
+            api.Seed(Today, "heute");
+        });
+
+        var headers = vm.Rows.OfType<NoteDayHeaderViewModel>().ToList();
+        Assert.Equal(Today, headers[0].Day);
+        Assert.True(headers[0].IsToday);
+        Assert.Equal(Today.AddDays(-2), headers[1].Day);
+        Assert.Equal("heute", ((NoteBulletViewModel)vm.Rows[1]).Text);
+    }
+
+    [Fact]
+    public async Task LoadAsync_keeps_todays_header_when_there_is_nothing_yet()
+    {
+        var (vm, _) = await LoadedAsync();
+
+        Assert.Single(vm.Rows);
+        Assert.True(vm.IsEmpty);
+    }
+
+    [Fact]
+    public async Task AddBullet_files_the_note_under_today_and_clears_the_box()
+    {
+        var (vm, api) = await LoadedAsync(api => api.Seed(Today.AddDays(-1), "gestern"));
+
+        vm.NewBulletText = "Standup vorbereitet";
+        await vm.AddBulletCommand.ExecuteAsync(null);
+
+        Assert.Equal("Standup vorbereitet", ((NoteBulletViewModel)vm.Rows[1]).Text);
+        Assert.Equal("", vm.NewBulletText);
+        Assert.False(vm.IsEmpty);
+        Assert.Equal(2, api.Store.Count);
+    }
+
     [Fact]
     public async Task AddBullet_WhenApiThrows_RaisesErrorReported_AndKeepsDraftText()
     {
         var api = new ThrowingNotes();
         var vm = new NotesEditorViewModel(api);
-        await vm.LoadDayAsync(new DateOnly(2026, 6, 1));
+        await vm.LoadAsync();
 
         string? reportedError = null;
         vm.ErrorReported += msg => reportedError = msg;
@@ -50,73 +118,123 @@ public class NotesEditorViewModelTests
         await vm.AddBulletCommand.ExecuteAsync(null);
 
         Assert.Equal(api.ExceptionMessage, reportedError);
-        Assert.Empty(vm.Bullets);
+        Assert.Empty(Bullets(vm));
         Assert.Equal("Standup vorbereitet", vm.NewBulletText);
     }
 
     [Fact]
-    public async Task AddBullet_PersistsAndAppears_ForCurrentDay()
+    public async Task SplitBullet_saves_the_edit_then_opens_an_empty_row_below_and_focuses_it()
     {
-        var api = new FakeNotes();
+        var (vm, api) = await LoadedAsync(api => api.Seed(Today, "erste"));
-        var vm = new NotesEditorViewModel(api);
+        NoteBulletViewModel? focused = null;
-        await vm.LoadDayAsync(new DateOnly(2026, 6, 1));
+        vm.FocusRequested += b => focused = b;
 
-        vm.NewBulletText = "Standup vorbereitet";
+        var first = Bullets(vm)[0];
-        await vm.AddBulletCommand.ExecuteAsync(null);
+        first.Text = "erste, bearbeitet";
+        await vm.SplitBulletCommand.ExecuteAsync(first);
 
-        Assert.Single(vm.Bullets);
+        var rows = Bullets(vm);
-        Assert.Equal("Standup vorbereitet", vm.Bullets[0].Text);
+        Assert.Equal(2, rows.Count);
-        Assert.Equal("", vm.NewBulletText);
+        Assert.Same(rows[1], focused);
+        Assert.True(rows[1].IsNew);
+        Assert.Equal("erste, bearbeitet", api.Store[0].Text);
+        // The empty row is UI-only until it gets text, so Enter on a blank line leaves nothing behind.
         Assert.Single(api.Store);
     }
 
     [Fact]
-    public async Task PrevAndNextDay_NavigateAndReload()
+    public async Task SplitBullet_on_an_emptied_note_deletes_it_and_adds_no_row()
     {
-        var api = new FakeNotes();
+        var (vm, api) = await LoadedAsync(api => api.Seed(Today, "weg damit"));
-        await api.AddAsync(new DateOnly(2026, 5, 31), "gestern");
-        var vm = new NotesEditorViewModel(api);
-        await vm.LoadDayAsync(new DateOnly(2026, 6, 1));
-        Assert.Empty(vm.Bullets);
 
-        await vm.PrevDayCommand.ExecuteAsync(null);
+        var only = Bullets(vm)[0];
-        Assert.Equal(new DateOnly(2026, 5, 31), vm.CurrentDay);
+        only.Text = "   ";
-        Assert.Single(vm.Bullets);
+        await vm.SplitBulletCommand.ExecuteAsync(only);
 
-        await vm.NextDayCommand.ExecuteAsync(null);
+        Assert.Empty(Bullets(vm));
-        Assert.Equal(new DateOnly(2026, 6, 1), vm.CurrentDay);
+        Assert.Empty(api.Store);
-        Assert.Empty(vm.Bullets);
+        Assert.True(vm.IsEmpty);
+    }
+
+    [Fact]
+    public async Task CommitBullet_persists_a_new_row_and_gives_it_an_id()
+    {
+        var (vm, api) = await LoadedAsync(api => api.Seed(Today, "erste"));
+        await vm.SplitBulletCommand.ExecuteAsync(Bullets(vm)[0]);
+
+        var fresh = Bullets(vm)[1];
+        fresh.Text = "zweite";
+        await vm.CommitBulletCommand.ExecuteAsync(fresh);
+
+        Assert.False(fresh.IsNew);
+        Assert.Equal(2, api.Store.Count);
+        Assert.Equal("zweite", api.Store[1].Text);
+    }
+
+    [Fact]
+    public async Task DeleteBullet_removes_it_and_focuses_the_note_above()
+    {
+        var (vm, api) = await LoadedAsync(api => { api.Seed(Today, "eins"); api.Seed(Today, "zwei"); });
+        NoteBulletViewModel? focused = null;
+        vm.FocusRequested += b => focused = b;
+
+        var second = Bullets(vm)[1];
+        await vm.DeleteBulletCommand.ExecuteAsync(second);
+
+        Assert.Single(Bullets(vm));
+        Assert.Equal("eins", focused?.Text);
+        Assert.Single(api.Store);
+    }
+
+    [Fact]
+    public async Task DeleteBullet_on_the_first_note_of_the_day_does_not_reach_into_the_header()
+    {
+        var (vm, _) = await LoadedAsync(api => api.Seed(Today, "einzige"));
+        var focusCalls = 0;
+        vm.FocusRequested += _ => focusCalls++;
+
+        await vm.DeleteBulletCommand.ExecuteAsync(Bullets(vm)[0]);
+
+        Assert.Equal(0, focusCalls);
+        Assert.True(vm.IsEmpty);
     }
 
     [Fact]
     public async Task CommitBullet_EmptyText_RemovesFromStoreAndList()
     {
-        var api = new FakeNotes();
+        var (vm, api) = await LoadedAsync(api => api.Seed(Today, "weg damit"));
-        var vm = new NotesEditorViewModel(api);
-        await vm.LoadDayAsync(new DateOnly(2026, 6, 1));
-        vm.NewBulletText = "weg damit";
-        await vm.AddBulletCommand.ExecuteAsync(null);
 
-        vm.Bullets[0].Text = "   ";
+        var only = Bullets(vm)[0];
-        await vm.CommitBulletCommand.ExecuteAsync(vm.Bullets[0]);
+        only.Text = "   ";
+        await vm.CommitBulletCommand.ExecuteAsync(only);
 
-        Assert.Empty(vm.Bullets);
+        Assert.Empty(Bullets(vm));
         Assert.Empty(api.Store);
     }
 
     [Fact]
     public async Task CommitBullet_NonEmptyText_PersistsEdit()
     {
-        var api = new FakeNotes();
+        var (vm, api) = await LoadedAsync(api => api.Seed(Today, "original"));
-        var vm = new NotesEditorViewModel(api);
-        await vm.LoadDayAsync(new DateOnly(2026, 6, 1));
-        vm.NewBulletText = "original";
-        await vm.AddBulletCommand.ExecuteAsync(null);
 
-        vm.Bullets[0].Text = "geändert";
+        var only = Bullets(vm)[0];
-        await vm.CommitBulletCommand.ExecuteAsync(vm.Bullets[0]);
+        only.Text = "geaendert";
+        await vm.CommitBulletCommand.ExecuteAsync(only);
 
-        Assert.Single(vm.Bullets);
+        Assert.Single(Bullets(vm));
-        Assert.Equal("geändert", api.Store[0].Text);
+        Assert.Equal("geaendert", api.Store[0].Text);
+    }
+
+    [Fact]
+    public async Task Agent_written_notes_are_marked_so_the_view_can_flag_them()
+    {
+        var (vm, _) = await LoadedAsync(api =>
+        {
+            api.Seed(Today, "von mir");
+            api.Seed(Today, "von Claude", fromAgent: true);
+        });
+
+        Assert.False(Bullets(vm)[0].FromAgent);
+        Assert.True(Bullets(vm)[1].FromAgent);
     }
 }

tests/ClaudeDo.Worker.Tests/External/NotesMcpToolsTests.cs

@@ -0,0 +1,77 @@
+using ClaudeDo.Data;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.External;
+using ClaudeDo.Worker.Hub;
+using ClaudeDo.Worker.Tests.Infrastructure;
+
+namespace ClaudeDo.Worker.Tests.External;
+
+public sealed class NotesMcpToolsTests : IDisposable
+{
+    private readonly DbFixture _db = new();
+    private readonly ClaudeDoDbContext _ctx;
+    private readonly DailyNoteRepository _notes;
+    private readonly NotesMcpTools _sut;
+    private static readonly DateOnly Today = DateOnly.FromDateTime(DateTime.Today);
+
+    public NotesMcpToolsTests()
+    {
+        _ctx = _db.CreateContext();
+        _notes = new DailyNoteRepository(_ctx);
+        _sut = new NotesMcpTools(_notes, new HubBroadcaster(new CapturingHubContext()));
+    }
+
+    public void Dispose() { _ctx.Dispose(); _db.Dispose(); }
+
+    [Fact]
+    public async Task AddNote_stores_it_on_today_flagged_as_agent_written()
+    {
+        var result = await _sut.AddNote("  Mika decided to keep the daily grouping.  ");
+
+        Assert.True(result.Saved);
+        var row = Assert.Single(await _notes.ListByDayAsync(Today));
+        Assert.Equal("Mika decided to keep the daily grouping.", row.Text);
+        Assert.True(row.FromAgent);
+        Assert.Equal(NotesMcpTools.DailyAgentCap - 1, result.RemainingToday);
+    }
+
+    [Fact]
+    public async Task AddNote_refuses_once_the_daily_cap_is_used_up_and_saves_nothing()
+    {
+        for (var i = 0; i < NotesMcpTools.DailyAgentCap; i++)
+            await _sut.AddNote($"note {i}");
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => _sut.AddNote("one too many"));
+
+        Assert.Contains("cap", ex.Message, StringComparison.OrdinalIgnoreCase);
+        Assert.Equal(NotesMcpTools.DailyAgentCap, (await _notes.ListByDayAsync(Today)).Count);
+    }
+
+    [Fact]
+    public async Task Notes_the_user_wrote_do_not_count_against_the_agent_cap()
+    {
+        for (var i = 0; i < NotesMcpTools.DailyAgentCap; i++)
+            await _notes.AddAsync(Today, $"mine {i}");
+
+        var result = await _sut.AddNote("still allowed");
+
+        Assert.Equal(1, result.AgentNotesToday);
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("   ")]
+    public async Task AddNote_rejects_empty_text(string text) =>
+        await Assert.ThrowsAsync<InvalidOperationException>(() => _sut.AddNote(text));
+
+    [Fact]
+    public async Task AddNote_rejects_text_past_the_length_limit()
+    {
+        var tooLong = new string('x', NotesMcpTools.MaxLength + 1);
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => _sut.AddNote(tooLong));
+
+        Assert.Contains(NotesMcpTools.MaxLength.ToString(), ex.Message);
+        Assert.Empty(await _notes.ListByDayAsync(Today));
+    }
+}

tests/ClaudeDo.Worker.Tests/Runner/GitServiceBootstrapTests.cs

@@ -0,0 +1,139 @@
+using ClaudeDo.Data.Git;
+using ClaudeDo.Worker.Tests.Infrastructure;
+
+namespace ClaudeDo.Worker.Tests.Runner;
+
+// Covers the empty-repo (unborn HEAD) hardening: HasHeadCommitAsync, EnsureHeadCommitAsync
+// (plumbing-only bootstrap commit), the friendly RevParseHeadAsync unborn message, and the
+// CommitAsync git-identity fallback. All tests run real git against throwaway repos.
+public class GitServiceBootstrapTests : IDisposable
+{
+    private readonly List<string> _tempDirs = new();
+    private readonly GitService _git = new();
+
+    private static bool GitAvailable => GitRepoFixture.IsGitAvailable();
+
+    // A repo straight out of `git init` — no commits, and deliberately NO identity
+    // configured: the bootstrap must not depend on machine-level git config.
+    private string InitEmptyRepo()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), $"claudedo_emptyrepo_{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dir);
+        GitRepoFixture.RunGit(dir, "init", "-b", "main");
+        _tempDirs.Add(dir);
+        return dir;
+    }
+
+    [Fact]
+    public async Task HasHeadCommit_FalseOnEmptyRepo_TrueAfterCommit()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var dir = InitEmptyRepo();
+        Assert.False(await _git.HasHeadCommitAsync(dir));
+
+        GitRepoFixture.RunGit(dir, "-c", "user.name=t", "-c", "user.email=t@t", "commit", "--allow-empty", "-m", "x");
+        Assert.True(await _git.HasHeadCommitAsync(dir));
+    }
+
+    [Fact]
+    public async Task EnsureHeadCommit_BootstrapsEmptyRepo_Once()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var dir = InitEmptyRepo();
+
+        Assert.True(await _git.EnsureHeadCommitAsync(dir));
+
+        // HEAD now resolves and RevParseHeadAsync works — the original failure mode is gone.
+        var head = await _git.RevParseHeadAsync(dir);
+        Assert.Matches("^[0-9a-f]{40,64}$", head);
+
+        // The bootstrap commit is empty: nothing of the user's ends up in it.
+        var tree = GitRepoFixture.RunGit(dir, "ls-tree", "HEAD").Trim();
+        Assert.Equal(string.Empty, tree);
+
+        // Idempotent: a repo with a HEAD commit is left alone.
+        Assert.False(await _git.EnsureHeadCommitAsync(dir));
+        Assert.Equal(head, await _git.RevParseHeadAsync(dir));
+    }
+
+    [Fact]
+    public async Task EnsureHeadCommit_LeavesStagedFilesStaged()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var dir = InitEmptyRepo();
+        File.WriteAllText(Path.Combine(dir, "mine.txt"), "user work\n");
+        GitRepoFixture.RunGit(dir, "add", "mine.txt");
+
+        Assert.True(await _git.EnsureHeadCommitAsync(dir));
+
+        // Still staged (index vs HEAD shows it as pending), NOT committed.
+        var staged = GitRepoFixture.RunGit(dir, "diff", "--cached", "--name-only").Trim();
+        Assert.Equal("mine.txt", staged);
+        var tree = GitRepoFixture.RunGit(dir, "ls-tree", "HEAD").Trim();
+        Assert.Equal(string.Empty, tree);
+    }
+
+    [Fact]
+    public async Task EnsureHeadCommit_CorruptHead_ThrowsClearError()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var dir = InitEmptyRepo();
+        // Detach HEAD onto a commit that doesn't exist — not an unborn branch, a broken repo.
+        File.WriteAllText(Path.Combine(dir, ".git", "HEAD"), new string('f', 40) + "\n");
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => _git.EnsureHeadCommitAsync(dir));
+        Assert.Contains(dir, ex.Message);
+    }
+
+    [Fact]
+    public async Task RevParseHead_EmptyRepo_ReportsNoCommitsInsteadOfRawGitError()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var dir = InitEmptyRepo();
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => _git.RevParseHeadAsync(dir));
+        Assert.Contains("no commits yet", ex.Message);
+        Assert.Contains(dir, ex.Message);
+        Assert.DoesNotContain("ambiguous argument", ex.Message);
+    }
+
+    [Fact]
+    public async Task CommitAsync_MissingIdentity_FallsBackToClaudeDoIdentity()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        var dir = InitEmptyRepo();
+        GitRepoFixture.RunGit(dir, "-c", "user.name=t", "-c", "user.email=t@t", "commit", "--allow-empty", "-m", "seed");
+        // Empty local identity overrides any machine-level config, so the first commit
+        // attempt fails with git's identity error no matter where this test runs.
+        GitRepoFixture.RunGit(dir, "config", "user.name", "");
+        GitRepoFixture.RunGit(dir, "config", "user.email", "");
+
+        File.WriteAllText(Path.Combine(dir, "work.txt"), "content\n");
+        await _git.AddAllAsync(dir);
+
+        await _git.CommitAsync(dir, "feat(test): identity fallback");
+
+        var author = GitRepoFixture.RunGit(dir, "log", "-1", "--format=%an <%ae>").Trim();
+        Assert.Equal("ClaudeDo <claudedo@local>", author);
+    }
+
+    public void Dispose()
+    {
+        foreach (var dir in _tempDirs)
+        {
+            try
+            {
+                if (!Directory.Exists(dir)) continue;
+                foreach (var file in Directory.EnumerateFiles(dir, "*", SearchOption.AllDirectories))
+                    File.SetAttributes(file, FileAttributes.Normal);
+                Directory.Delete(dir, true);
+            }
+            catch { /* best effort */ }
+        }
+    }
+}

tests/ClaudeDo.Worker.Tests/Runner/WorktreeManagerTests.cs

@@ -191,6 +191,34 @@ public class WorktreeManagerTests : IDisposable
         Assert.Contains("hello.txt", row.DiffStat);
     }
 
+    [Fact]
+    public async Task CreateAsync_EmptyRepo_BootstrapsInitialCommit()
+    {
+        if (!GitAvailable) { Assert.True(true, "git not available -- skipping"); return; }
+
+        // Fresh `git init`, zero commits, no identity configured — the cross-PC failure
+        // that surfaced as "git rev-parse HEAD failed: ambiguous argument 'HEAD'".
+        var repoDir = Path.Combine(Path.GetTempPath(), $"claudedo_emptyrepo_{Guid.NewGuid():N}");
+        Directory.CreateDirectory(repoDir);
+        GitRepoFixture.RunGit(repoDir, "init", "-b", "main");
+        _tempDirs.Add(repoDir);
+
+        var (task, list) = MakeEntities(repoDir);
+        var (mgr, db) = await CreateManagerAsync(task, list);
+
+        var ctx = await mgr.CreateAsync(task, list, CancellationToken.None);
+        _worktreeCleanups.Add((repoDir, ctx.WorktreePath));
+
+        Assert.True(Directory.Exists(ctx.WorktreePath));
+        // The base commit is the auto-created bootstrap commit.
+        var head = GitRepoFixture.RunGit(repoDir, "rev-parse", "HEAD").Trim();
+        Assert.Equal(head, ctx.BaseCommit);
+
+        using var readCtx = db.CreateContext();
+        var row = await new WorktreeRepository(readCtx).GetByTaskIdAsync(task.Id);
+        Assert.Equal(WorktreeState.Active, row!.State);
+    }
+
     [Fact]
     public async Task CreateAsync_NonGitDir_Throws_NoRow()
     {

tests/ClaudeDo.Worker.Tests/UiVm/TasksIslandViewModelPlanningTests.cs

@@ -112,6 +112,7 @@ sealed class FakeWorkerClient : IWorkerClient
     public Task<int> GetPendingDraftCountAsync(string taskId, CancellationToken ct = default) => Task.FromResult(0);
     public Task<IReadOnlyList<WorkerLogEntry>> GetRecentLogsAsync() => Task.FromResult<IReadOnlyList<WorkerLogEntry>>(System.Array.Empty<WorkerLogEntry>());
 
+    public event Action? NotesUpdatedEvent;
     public event Action? PrepStartedEvent;
     public event Action<string>? PrepLineEvent;
     public event Action<bool>? PrepFinishedEvent;
@@ -153,6 +154,7 @@ sealed class FakeWorkerClient : IWorkerClient
     public Task<bool> RunDailyPrepNowAsync() => Task.FromResult(false);
     public Task ClearMyDayAsync() => Task.CompletedTask;
     public Task<List<DailyNoteDto>> GetDailyNotesAsync(DateOnly day) => Task.FromResult(new List<DailyNoteDto>());
+    public Task<List<DailyNoteDto>> GetDailyNotesBetweenAsync(DateOnly start, DateOnly end) => Task.FromResult(new List<DailyNoteDto>());
     public Task<DailyNoteDto?> AddDailyNoteAsync(DateOnly day, string text) => Task.FromResult<DailyNoteDto?>(null);
     public Task UpdateDailyNoteAsync(string id, string text) => Task.CompletedTask;
     public Task DeleteDailyNoteAsync(string id) => Task.CompletedTask;