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>

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/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/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",
-    "newNotePlaceholder": "Neue Notiz…"
+    "yesterday": "Gestern",
+    "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",
-    "newNotePlaceholder": "New note…"
+    "yesterday": "Yesterday",
+    "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);
-        set { var d = DateOnly.FromDateTime(value); if (d != CurrentDay) _ = LoadDayAsync(d); }
+        Today = DateOnly.FromDateTime(DateTime.Today);
+        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)
-    {
-        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 static NoteBulletViewModel Bullet(DailyNoteDto n) =>
+        new(n.Id, Day(n), n.Text, n.FromAgent);
 
-    private NoteBulletViewModel MakeBullet(string id, string text) =>
-        new(id, text);
+    private void RefreshEmpty() => IsEmpty = !Rows.OfType<NoteBulletViewModel>().Any();
 
+    /// <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);
-            if (dto is not null) Bullets.Add(MakeBullet(dto.Id, dto.Text));
+            var dto = await _api.AddAsync(Today, 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));
-    [RelayCommand] private Task NextDay() => LoadDayAsync(CurrentDay.AddDays(1));
-    [RelayCommand] private Task Today() => LoadDayAsync(DateOnly.FromDateTime(DateTime.Today));
+    /// <summary>Enter inside a note: save it, then open an empty row underneath and focus it.</summary>
+    [RelayCommand]
+    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);
-            Bullets.Remove(b);
-            return;
+            if (text.Length == 0)
+            {
+                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">
-      <Button DockPanel.Dock="Right" Classes="btn" Content="{loc:Tr notes.add}" Margin="8,0,0,0"
-              Command="{Binding AddBulletCommand}"/>
-      <TextBox PlaceholderText="{loc:Tr notes.newNotePlaceholder}" Text="{Binding NewBulletText}">
-        <TextBox.KeyBindings>
-          <KeyBinding Gesture="Enter" Command="{Binding AddBulletCommand}"/>
-        </TextBox.KeyBindings>
-      </TextBox>
-    </DockPanel>
+  <UserControl.Styles>
+    <!-- A note reads as text, not as a form field: the box only shows itself under the pointer
+         and while it has focus. -->
+    <Style Selector="TextBox.note">
+      <Setter Property="Background" Value="Transparent"/>
+      <Setter Property="BorderThickness" Value="0"/>
+      <Setter Property="Padding" Value="4,3"/>
+      <Setter Property="MinHeight" Value="0"/>
+    </Style>
+    <Style Selector="TextBox.note /template/ Border#PART_BorderElement">
+      <Setter Property="Background" Value="Transparent"/>
+      <Setter Property="BorderThickness" Value="0"/>
+    </Style>
 
-    <ScrollViewer>
-      <ItemsControl ItemsSource="{Binding Bullets}">
-        <ItemsControl.ItemTemplate>
-          <DataTemplate x:DataType="vm:NoteBulletViewModel">
-            <TextBox Text="{Binding Text}" Margin="0,2"
-                     LostFocus="OnBulletLostFocus"/>
-          </DataTemplate>
-        </ItemsControl.ItemTemplate>
-      </ItemsControl>
-    </ScrollViewer>
+    <Style Selector="Border.note-row">
+      <Setter Property="CornerRadius" Value="6"/>
+      <Setter Property="Padding" Value="10,1,6,1"/>
+      <Setter Property="Margin" Value="4,1"/>
+    </Style>
+    <Style Selector="Border.note-row:pointerover">
+      <Setter Property="Background" Value="{DynamicResource PeatSoftBrush}"/>
+    </Style>
+    <!-- Row actions stay out of the way until the row is hovered. -->
+    <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/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);

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 = new NotesEditorViewModel(api);
-        await vm.LoadDayAsync(new DateOnly(2026, 6, 1));
+        var (vm, api) = await LoadedAsync(api => api.Seed(Today, "erste"));
+        NoteBulletViewModel? focused = null;
+        vm.FocusRequested += b => focused = b;
 
-        vm.NewBulletText = "Standup vorbereitet";
-        await vm.AddBulletCommand.ExecuteAsync(null);
+        var first = Bullets(vm)[0];
+        first.Text = "erste, bearbeitet";
+        await vm.SplitBulletCommand.ExecuteAsync(first);
 
-        Assert.Single(vm.Bullets);
-        Assert.Equal("Standup vorbereitet", vm.Bullets[0].Text);
-        Assert.Equal("", vm.NewBulletText);
+        var rows = Bullets(vm);
+        Assert.Equal(2, rows.Count);
+        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();
-        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);
+        var (vm, api) = await LoadedAsync(api => api.Seed(Today, "weg damit"));
 
-        await vm.PrevDayCommand.ExecuteAsync(null);
-        Assert.Equal(new DateOnly(2026, 5, 31), vm.CurrentDay);
-        Assert.Single(vm.Bullets);
+        var only = Bullets(vm)[0];
+        only.Text = "   ";
+        await vm.SplitBulletCommand.ExecuteAsync(only);
 
-        await vm.NextDayCommand.ExecuteAsync(null);
-        Assert.Equal(new DateOnly(2026, 6, 1), vm.CurrentDay);
-        Assert.Empty(vm.Bullets);
+        Assert.Empty(Bullets(vm));
+        Assert.Empty(api.Store);
+        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 = new NotesEditorViewModel(api);
-        await vm.LoadDayAsync(new DateOnly(2026, 6, 1));
-        vm.NewBulletText = "weg damit";
-        await vm.AddBulletCommand.ExecuteAsync(null);
+        var (vm, api) = await LoadedAsync(api => api.Seed(Today, "weg damit"));
 
-        vm.Bullets[0].Text = "   ";
-        await vm.CommitBulletCommand.ExecuteAsync(vm.Bullets[0]);
+        var only = Bullets(vm)[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 = new NotesEditorViewModel(api);
-        await vm.LoadDayAsync(new DateOnly(2026, 6, 1));
-        vm.NewBulletText = "original";
-        await vm.AddBulletCommand.ExecuteAsync(null);
+        var (vm, api) = await LoadedAsync(api => api.Seed(Today, "original"));
 
-        vm.Bullets[0].Text = "geändert";
-        await vm.CommitBulletCommand.ExecuteAsync(vm.Bullets[0]);
+        var only = Bullets(vm)[0];
+        only.Text = "geaendert";
+        await vm.CommitBulletCommand.ExecuteAsync(only);
 
-        Assert.Single(vm.Bullets);
-        Assert.Equal("geändert", api.Store[0].Text);
+        Assert.Single(Bullets(vm));
+        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/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;