feat(data): add task numbers schema, allocator, and backfill migration

TaskEntity.Number is a global, monotonically increasing, never-reused
integer (displayed as #123), allocated from AppSettingsEntity.NextTaskNumber
via a single UPDATE...RETURNING statement rather than MAX(number)+1, which
would reissue a deleted task's number. Both insert paths (TaskRepository.
AddAsync and CreateChildAsync) route through the new TaskNumberAllocator,
with a bounded retry on a unique-index collision. One migration adds the
columns, backfills existing rows in creation order, and creates the unique
index afterwards. Data-layer only; MCP/UI wiring is later slices.

src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs

@@ -13,6 +13,9 @@ public class AppSettingsEntityConfiguration : IEntityTypeConfiguration<AppSettin
         builder.HasKey(s => s.Id);
         builder.Property(s => s.Id).HasColumnName("id").ValueGeneratedNever();
 
+        builder.Property(s => s.NextTaskNumber)
+            .HasColumnName("next_task_number").IsRequired().HasDefaultValue(1);
+
         builder.Property(s => s.DefaultClaudeInstructions)
             .HasColumnName("default_claude_instructions").IsRequired().HasDefaultValue(string.Empty);
         builder.Property(s => s.DefaultModel)

src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs

@@ -66,6 +66,7 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
 
         builder.HasKey(t => t.Id);
         builder.Property(t => t.Id).HasColumnName("id");
+        builder.Property(t => t.Number).HasColumnName("number").IsRequired();
         builder.Property(t => t.ListId).HasColumnName("list_id").IsRequired();
         builder.Property(t => t.Title).HasColumnName("title").IsRequired();
         builder.Property(t => t.Description).HasColumnName("description");
@@ -136,6 +137,7 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
             .WithOne(w => w.Task)
             .HasForeignKey<WorktreeEntity>(w => w.TaskId);
 
+        builder.HasIndex(t => t.Number).IsUnique().HasDatabaseName("idx_tasks_number");
         builder.HasIndex(t => t.ListId).HasDatabaseName("idx_tasks_list_id");
         builder.HasIndex(t => t.Status).HasDatabaseName("idx_tasks_status");
         builder.HasIndex(t => new { t.ListId, t.SortOrder }).HasDatabaseName("idx_tasks_list_sort");

src/ClaudeDo.Data/Migrations/20260811081530_AddTaskNumbers.Designer.cs

@@ -0,0 +1,950 @@
+// <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("20260811081530_AddTaskNumbers")]
+    partial class AddTaskNumbers
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.11");
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.AppSettingsEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<string>("CentralWorktreeRoot")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("central_worktree_root");
+
+                    b.Property<int>("DailyPrepMaxTasks")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(5)
+                        .HasColumnName("daily_prep_max_tasks");
+
+                    b.Property<string>("DefaultClaudeInstructions")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("")
+                        .HasColumnName("default_claude_instructions");
+
+                    b.Property<int>("DefaultMaxTurns")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(40)
+                        .HasColumnName("default_max_turns");
+
+                    b.Property<string>("DefaultModel")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sonnet")
+                        .HasColumnName("default_model");
+
+                    b.Property<string>("DefaultPermissionMode")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("bypassPermissions")
+                        .HasColumnName("default_permission_mode");
+
+                    b.Property<int>("MaxParallelExecutions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1)
+                        .HasColumnName("max_parallel_executions");
+
+                    b.Property<int>("MaxTurnsCeiling")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(80)
+                        .HasColumnName("max_turns_ceiling");
+
+                    b.Property<string>("ModelPresets")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model_presets");
+
+                    b.Property<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,
+                            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<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<bool>("SerializeOnFileOverlap")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("serialize_on_file_overlap");
+
+                    b.Property<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.Property<string>("VerifyCommand")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("verify_command");
+
+                    b.HasKey("ListId");
+
+                    b.ToTable("list_config", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DefaultCommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("default_commit_type");
+
+                    b.Property<bool>("FindingsTracked")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("findings_tracked");
+
+                    b.Property<bool>("IsManual")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_manual");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<string>("WorkingDir")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("working_dir");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SortOrder")
+                        .HasDatabaseName("idx_lists_sort");
+
+                    b.ToTable("lists", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<int>("Days")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(31)
+                        .HasColumnName("days_of_week");
+
+                    b.Property<bool>("Enabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true)
+                        .HasColumnName("enabled");
+
+                    b.Property<DateTimeOffset?>("LastRunAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_run_at");
+
+                    b.Property<string>("PromptOverride")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt_override");
+
+                    b.Property<TimeSpan>("TimeOfDay")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time_of_day");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("prime_schedules", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SessionSkillEntity", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<DateTimeOffset>("AddedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("added_at");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<string>("PinnedRef")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("pinned_ref");
+
+                    b.Property<string>("SourceUrl")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("source_url");
+
+                    b.Property<string>("Subpath")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("subpath");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("session_skills", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("Completed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("completed");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<int>("OrderNum")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("order_num");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_subtasks_task_id");
+
+                    b.ToTable("subtasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskAttachmentEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<long>("ByteSize")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("byte_size");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("file_name");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_task_attachments_task_id");
+
+                    b.ToTable("task_attachments", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<string>("BlockedByTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("blocked_by_task_id");
+
+                    b.Property<string>("CommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("commit_type");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by");
+
+                    b.Property<string>("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<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>("ScopeGlobs")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("scope_globs");
+
+                    b.Property<string>("SessionSkills")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_skills");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("status");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockedByTaskId")
+                        .HasDatabaseName("idx_tasks_blocked_by");
+
+                    b.HasIndex("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/20260811081530_AddTaskNumbers.cs

@@ -0,0 +1,67 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddTaskNumbers : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "number",
+                table: "tasks",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "next_task_number",
+                table: "app_settings",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 1);
+
+            // Backfill in creation order (tiebreak by id) so pre-existing tasks get a stable,
+            // gapless 1..N numbering. Must run before the unique index below.
+            migrationBuilder.Sql("""
+                UPDATE tasks
+                SET number = (
+                    SELECT COUNT(*) FROM tasks t2
+                    WHERE t2.created_at < tasks.created_at
+                       OR (t2.created_at = tasks.created_at AND t2.id <= tasks.id)
+                );
+                """);
+
+            migrationBuilder.Sql("""
+                UPDATE app_settings
+                SET next_task_number = (SELECT COALESCE(MAX(number), 0) + 1 FROM tasks)
+                WHERE id = 1;
+                """);
+
+            migrationBuilder.CreateIndex(
+                name: "idx_tasks_number",
+                table: "tasks",
+                column: "number",
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "idx_tasks_number",
+                table: "tasks");
+
+            migrationBuilder.DropColumn(
+                name: "number",
+                table: "tasks");
+
+            migrationBuilder.DropColumn(
+                name: "next_task_number",
+                table: "app_settings");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/ClaudeDoDbContextModelSnapshot.cs

@@ -76,6 +76,12 @@ namespace ClaudeDo.Data.Migrations
                         .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");
@@ -164,6 +170,7 @@ namespace ClaudeDo.Data.Migrations
                             DefaultPermissionMode = "auto",
                             MaxParallelExecutions = 1,
                             MaxTurnsCeiling = 80,
+                            NextTaskNumber = 1,
                             StandupWeekday = 3,
                             UsageGateFiveHourPct = 80,
                             UsageGateSevenDayPct = 90,
@@ -548,6 +555,10 @@ namespace ClaudeDo.Data.Migrations
                         .HasColumnType("TEXT")
                         .HasColumnName("notes");
 
+                    b.Property<int>("Number")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("number");
+
                     b.Property<string>("ParentTaskId")
                         .HasColumnType("TEXT")
                         .HasColumnName("parent_task_id");
@@ -632,6 +643,10 @@ namespace ClaudeDo.Data.Migrations
                     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");
 

src/ClaudeDo.Data/Models/AppSettingsEntity.cs

@@ -6,6 +6,11 @@ public sealed class AppSettingsEntity
 
     public int Id { get; set; } = SingletonId;
 
+    // Persistent counter backing TaskNumberAllocator: the next task number to hand out. Lives on
+    // the singleton row so allocation is a single atomic UPDATE...RETURNING in the task's own
+    // insert transaction, never a MAX(number)+1 recompute.
+    public int NextTaskNumber { get; set; } = 1;
+
     public string DefaultClaudeInstructions { get; set; } = string.Empty;
     public string DefaultModel { get; set; } = "sonnet";
     public int DefaultMaxTurns { get; set; } = 40;

src/ClaudeDo.Data/Models/TaskEntity.cs

@@ -22,6 +22,10 @@ public enum PlanningPhase
 public sealed class TaskEntity
 {
     public required string Id { get; init; }
+    // Global, monotonically increasing, never-reused display/lookup handle shown as `#123`.
+    // Allocated by TaskNumberAllocator from AppSettingsEntity.NextTaskNumber -- never MAX(number)+1,
+    // which would reissue a deleted task's number. The GUID Id stays the real identity everywhere else.
+    public int Number { get; set; }
     public required string ListId { get; init; }
     public required string Title { get; set; }
     public string? Description { get; set; }

src/ClaudeDo.Data/Repositories/TaskRepository.cs

@@ -26,8 +26,7 @@ public sealed class TaskRepository
             .MaxAsync(ct);
         entity.SortOrder = (maxSort ?? -1) + 1;
 
-        _context.Tasks.Add(entity);
-        await _context.SaveChangesAsync(ct);
+        await TaskNumberAllocator.AddWithNumberAsync(_context, entity, ct);
     }
 
     public async Task UpdateAsync(TaskEntity entity, CancellationToken ct = default)
@@ -50,6 +49,11 @@ public sealed class TaskRepository
         return await _context.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Id == taskId, ct);
     }
 
+    public async Task<TaskEntity?> GetByNumberAsync(int number, CancellationToken ct = default)
+    {
+        return await _context.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Number == number, ct);
+    }
+
     public async Task<List<TaskEntity>> GetByListIdAsync(string listId, CancellationToken ct = default)
     {
         return await _context.Tasks
@@ -309,8 +313,7 @@ public sealed class TaskRepository
             Model = ModelRegistry.NormalizeAlias(model),
             MaxTurns = maxTurns,
         };
-        _context.Tasks.Add(child);
-        await _context.SaveChangesAsync(ct);
+        await TaskNumberAllocator.AddWithNumberAsync(_context, child, ct);
         return child;
     }
 

src/ClaudeDo.Data/TaskNumberAllocator.cs

@@ -0,0 +1,46 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace ClaudeDo.Data;
+
+// Allocates TaskEntity.Number and inserts the task. Never MAX(number)+1 -- that would reissue a
+// deleted task's number. Allocation is a single atomic UPDATE...RETURNING against the
+// app_settings singleton row, which SQLite's single-writer model already serializes.
+//
+// The allocation and the insert are deliberately two separate statements, each committed on its
+// own, rather than one shared transaction: a shared transaction would roll the counter bump back
+// together with a failed insert, so a retry would hand out the exact same (still colliding)
+// number every time and the bounded retry below would be pointless. Committing the bump
+// unconditionally means a retry after a collision always advances to a fresh number, at the cost
+// of burning the collided number as an unused gap -- which is fine, gaps are expected.
+public static class TaskNumberAllocator
+{
+    private const int MaxAttempts = 5;
+
+    public static async Task AddWithNumberAsync(
+        ClaudeDoDbContext context, TaskEntity entity, CancellationToken ct = default)
+    {
+        for (var attempt = 1; ; attempt++)
+        {
+            var settings = await context.AppSettings.FromSqlRaw(
+                """
+                UPDATE app_settings SET next_task_number = next_task_number + 1
+                WHERE id = {0}
+                RETURNING *
+                """, AppSettingsEntity.SingletonId).AsNoTracking().ToListAsync(ct);
+
+            entity.Number = settings[0].NextTaskNumber - 1;
+            context.Tasks.Add(entity);
+
+            try
+            {
+                await context.SaveChangesAsync(ct);
+                return;
+            }
+            catch (DbUpdateException) when (attempt < MaxAttempts)
+            {
+                context.Entry(entity).State = EntityState.Detached;
+            }
+        }
+    }
+}

tests/ClaudeDo.Data.Tests/ForeignKeyTests.cs

@@ -47,8 +47,8 @@ public sealed class ForeignKeyTests : IDisposable
         await using (var ctx = Open())
         {
             ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = parentId, ListId = listId, Title = "Predecessor", Status = TaskStatus.Idle, CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = childId, ListId = listId, Title = "Blocked", Status = TaskStatus.Idle, BlockedByTaskId = parentId, CreatedAt = DateTime.UtcNow });
+            ctx.Tasks.Add(new TaskEntity { Id = parentId, Number = 1, ListId = listId, Title = "Predecessor", Status = TaskStatus.Idle, CreatedAt = DateTime.UtcNow });
+            ctx.Tasks.Add(new TaskEntity { Id = childId, Number = 2, ListId = listId, Title = "Blocked", Status = TaskStatus.Idle, BlockedByTaskId = parentId, CreatedAt = DateTime.UtcNow });
             await ctx.SaveChangesAsync();
         }
 
@@ -79,8 +79,8 @@ public sealed class ForeignKeyTests : IDisposable
         await using (var ctx = Open())
         {
             ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = predecessorId, ListId = listId, Title = "Predecessor", Status = TaskStatus.Idle, CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = dependentId, ListId = listId, Title = "Dependent", Status = TaskStatus.Idle, DependsOnTaskId = predecessorId, CreatedAt = DateTime.UtcNow });
+            ctx.Tasks.Add(new TaskEntity { Id = predecessorId, Number = 1, ListId = listId, Title = "Predecessor", Status = TaskStatus.Idle, CreatedAt = DateTime.UtcNow });
+            ctx.Tasks.Add(new TaskEntity { Id = dependentId, Number = 2, ListId = listId, Title = "Dependent", Status = TaskStatus.Idle, DependsOnTaskId = predecessorId, CreatedAt = DateTime.UtcNow });
             await ctx.SaveChangesAsync();
         }
 

tests/ClaudeDo.Data.Tests/MoveToListTests.cs

@@ -42,16 +42,16 @@ public sealed class MoveToListTests : IDisposable
         await SeedListsAsync("source", "target");
         _ctx.Tasks.Add(new TaskEntity
         {
-            Id = "t1", ListId = "source", Title = "Task", CreatedAt = DateTime.UtcNow, SortOrder = 0,
+            Id = "t1", Number = 1, ListId = "source", Title = "Task", CreatedAt = DateTime.UtcNow, SortOrder = 0,
         });
         // Existing tasks already in the target list, so we can assert the moved task lands after them.
         _ctx.Tasks.Add(new TaskEntity
         {
-            Id = "existing1", ListId = "target", Title = "Existing 1", CreatedAt = DateTime.UtcNow, SortOrder = 0,
+            Id = "existing1", Number = 2, ListId = "target", Title = "Existing 1", CreatedAt = DateTime.UtcNow, SortOrder = 0,
         });
         _ctx.Tasks.Add(new TaskEntity
         {
-            Id = "existing2", ListId = "target", Title = "Existing 2", CreatedAt = DateTime.UtcNow, SortOrder = 1,
+            Id = "existing2", Number = 3, ListId = "target", Title = "Existing 2", CreatedAt = DateTime.UtcNow, SortOrder = 1,
         });
         await _ctx.SaveChangesAsync();
         _ctx.ChangeTracker.Clear();
@@ -69,16 +69,16 @@ public sealed class MoveToListTests : IDisposable
         await SeedListsAsync("source", "target");
         _ctx.Tasks.Add(new TaskEntity
         {
-            Id = "parent", ListId = "source", Title = "Parent", CreatedAt = DateTime.UtcNow, SortOrder = 0,
+            Id = "parent", Number = 1, ListId = "source", Title = "Parent", CreatedAt = DateTime.UtcNow, SortOrder = 0,
         });
         _ctx.Tasks.Add(new TaskEntity
         {
-            Id = "child", ListId = "source", Title = "Child", CreatedAt = DateTime.UtcNow,
+            Id = "child", Number = 2, ListId = "source", Title = "Child", CreatedAt = DateTime.UtcNow,
             SortOrder = 1, ParentTaskId = "parent",
         });
         _ctx.Tasks.Add(new TaskEntity
         {
-            Id = "grandchild", ListId = "source", Title = "Grandchild", CreatedAt = DateTime.UtcNow,
+            Id = "grandchild", Number = 3, ListId = "source", Title = "Grandchild", CreatedAt = DateTime.UtcNow,
             SortOrder = 2, ParentTaskId = "child",
         });
         await _ctx.SaveChangesAsync();

tests/ClaudeDo.Data.Tests/TaskNumberAllocatorTests.cs

@@ -0,0 +1,148 @@
+using ClaudeDo.Data;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Data.Repositories;
+using Microsoft.EntityFrameworkCore;
+using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
+
+namespace ClaudeDo.Data.Tests;
+
+public sealed class TaskNumberAllocatorTests : IDisposable
+{
+    private readonly string _dbPath;
+    private readonly DbContextOptions<ClaudeDoDbContext> _options;
+    private readonly ClaudeDoDbContext _ctx;
+
+    public TaskNumberAllocatorTests()
+    {
+        _dbPath = Path.Combine(Path.GetTempPath(), $"claudedo_tasknum_{Guid.NewGuid():N}.db");
+        _options = new DbContextOptionsBuilder<ClaudeDoDbContext>()
+            .UseSqlite($"Data Source={_dbPath}")
+            .Options;
+        _ctx = new ClaudeDoDbContext(_options);
+        _ctx.Database.EnsureCreated();
+    }
+
+    public void Dispose()
+    {
+        _ctx.Dispose();
+        foreach (var suffix in new[] { "", "-wal", "-shm" })
+            try { File.Delete(_dbPath + suffix); } catch { }
+    }
+
+    private async Task<string> SeedListAsync(string id = "l1")
+    {
+        _ctx.Lists.Add(new ListEntity { Id = id, Name = "Test List", CreatedAt = DateTime.UtcNow });
+        await _ctx.SaveChangesAsync();
+        return id;
+    }
+
+    private static TaskEntity NewTask(string listId, string title = "T")
+        => new()
+        {
+            Id = Guid.NewGuid().ToString(),
+            ListId = listId,
+            Title = title,
+            Status = TaskStatus.Idle,
+            CreatedAt = DateTime.UtcNow,
+        };
+
+    [Fact]
+    public async Task AddAsync_assigns_increasing_unique_numbers()
+    {
+        await SeedListAsync();
+        var repo = new TaskRepository(_ctx);
+
+        var first = NewTask("l1");
+        await repo.AddAsync(first);
+        var second = NewTask("l1");
+        await repo.AddAsync(second);
+
+        Assert.True(first.Number > 0);
+        Assert.True(second.Number > first.Number);
+    }
+
+    [Fact]
+    public async Task CreateChildAsync_also_allocates_a_number()
+    {
+        await SeedListAsync();
+        var parent = NewTask("l1");
+        await new TaskRepository(_ctx).AddAsync(parent);
+
+        var child = await new TaskRepository(_ctx).CreateChildAsync(parent.Id, "Child", null, null);
+
+        Assert.True(child.Number > 0);
+        Assert.NotEqual(parent.Number, child.Number);
+    }
+
+    [Fact]
+    public async Task Deleting_the_highest_numbered_task_does_not_recycle_its_number()
+    {
+        await SeedListAsync();
+        var repo = new TaskRepository(_ctx);
+
+        var t1 = NewTask("l1");
+        await repo.AddAsync(t1);
+        var t2 = NewTask("l1");
+        await repo.AddAsync(t2);
+        Assert.True(t2.Number > t1.Number);
+
+        await repo.DeleteAsync(t2.Id);
+
+        var t3 = NewTask("l1");
+        await repo.AddAsync(t3);
+
+        Assert.True(t3.Number > t2.Number);
+        Assert.NotEqual(t2.Number, t3.Number);
+    }
+
+    [Fact]
+    public async Task Repeated_creation_never_assigns_the_same_number_twice()
+    {
+        var listId = await SeedListAsync();
+
+        var numbers = new List<int>();
+        for (var i = 0; i < 20; i++)
+        {
+            await using var ctx = new ClaudeDoDbContext(_options);
+            var task = NewTask(listId, $"T{i}");
+            await new TaskRepository(ctx).AddAsync(task);
+            numbers.Add(task.Number);
+        }
+
+        Assert.Equal(numbers.Count, numbers.Distinct().Count());
+    }
+
+    [Fact]
+    public async Task Concurrent_creation_never_assigns_the_same_number_twice()
+    {
+        var listId = await SeedListAsync();
+
+        var tasks = Enumerable.Range(0, 10).Select(async i =>
+        {
+            await using var ctx = new ClaudeDoDbContext(_options);
+            var task = NewTask(listId, $"C{i}");
+            await new TaskRepository(ctx).AddAsync(task);
+            return task.Number;
+        });
+
+        var numbers = await Task.WhenAll(tasks);
+
+        Assert.Equal(numbers.Length, numbers.Distinct().Count());
+        Assert.All(numbers, n => Assert.True(n > 0));
+    }
+
+    [Fact]
+    public async Task GetByNumberAsync_finds_the_task_and_returns_null_for_unknown_numbers()
+    {
+        await SeedListAsync();
+        var task = NewTask("l1");
+        await new TaskRepository(_ctx).AddAsync(task);
+
+        var found = await new TaskRepository(_ctx).GetByNumberAsync(task.Number);
+        var missing = await new TaskRepository(_ctx).GetByNumberAsync(task.Number + 999);
+
+        Assert.NotNull(found);
+        Assert.Equal(task.Id, found!.Id);
+        Assert.Null(missing);
+    }
+}

tests/ClaudeDo.Data.Tests/TaskNumberMigrationTests.cs

@@ -0,0 +1,84 @@
+using ClaudeDo.Data;
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace ClaudeDo.Data.Tests;
+
+// EnsureCreated (used by every other Data.Tests fixture) builds the schema straight from the
+// current model and skips migrations entirely, so it can never exercise the AddTaskNumbers
+// backfill. This test runs a real Migrate() against a database seeded with pre-migration rows.
+public sealed class TaskNumberMigrationTests : IDisposable
+{
+    private const string MigrationBeforeTaskNumbers = "20260810115437_AddFailureReason";
+
+    private readonly string _dbPath;
+    private readonly DbContextOptions<ClaudeDoDbContext> _options;
+
+    public TaskNumberMigrationTests()
+    {
+        _dbPath = Path.Combine(Path.GetTempPath(), $"claudedo_tasknum_migration_{Guid.NewGuid():N}.db");
+        _options = new DbContextOptionsBuilder<ClaudeDoDbContext>()
+            .UseSqlite($"Data Source={_dbPath}")
+            .Options;
+    }
+
+    public void Dispose()
+    {
+        foreach (var suffix in new[] { "", "-wal", "-shm" })
+            try { File.Delete(_dbPath + suffix); } catch { }
+    }
+
+    [Fact]
+    public async Task Migrate_backfills_task_numbers_in_creation_order_with_id_tiebreak()
+    {
+        await using (var ctx = new ClaudeDoDbContext(_options))
+        {
+            var migrator = ctx.Database.GetInfrastructure().GetRequiredService<IMigrator>();
+            migrator.Migrate(MigrationBeforeTaskNumbers);
+
+            var conn = ctx.Database.GetDbConnection();
+            await conn.OpenAsync();
+
+            await ExecAsync(conn, """
+                INSERT INTO lists (id, name, created_at) VALUES ('l1', 'List', '2026-01-01 00:00:00.0000000');
+                """);
+
+            // Inserted out of creation order, and 'd'/'c' share a timestamp to exercise the id tiebreak.
+            await ExecAsync(conn, InsertTaskSql("d", "2026-01-03 00:00:00.0000000"));
+            await ExecAsync(conn, InsertTaskSql("a", "2026-01-01 00:00:00.0000000"));
+            await ExecAsync(conn, InsertTaskSql("c", "2026-01-03 00:00:00.0000000"));
+            await ExecAsync(conn, InsertTaskSql("b", "2026-01-02 00:00:00.0000000"));
+
+            migrator.Migrate();
+        }
+
+        await using var verify = new ClaudeDoDbContext(_options);
+        var byId = await verify.Tasks.AsNoTracking().ToDictionaryAsync(t => t.Id, t => t.Number);
+
+        Assert.Equal(1, byId["a"]);
+        Assert.Equal(2, byId["b"]);
+        Assert.Equal(3, byId["c"]);
+        Assert.Equal(4, byId["d"]);
+
+        var numbers = byId.Values.OrderBy(n => n).ToList();
+        Assert.Equal(new[] { 1, 2, 3, 4 }, numbers);
+
+        var settings = await verify.AppSettings.AsNoTracking().FirstAsync(s => s.Id == AppSettingsEntity.SingletonId);
+        Assert.Equal(5, settings.NextTaskNumber);
+    }
+
+    private static string InsertTaskSql(string id, string createdAt) => $"""
+        INSERT INTO tasks (id, list_id, title, status, created_at)
+        VALUES ('{id}', 'l1', 'Task {id}', 'idle', '{createdAt}');
+        """;
+
+    private static async Task ExecAsync(System.Data.Common.DbConnection conn, string sql)
+    {
+        await using var cmd = conn.CreateCommand();
+        cmd.CommandText = sql;
+        await cmd.ExecuteNonQueryAsync();
+    }
+}

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

@@ -61,6 +61,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
     private readonly HubBroadcaster _broadcaster;
     private readonly List<GitRepoFixture> _repos = new();
     private readonly List<(string repoDir, string wtPath)> _worktreeCleanups = new();
+    private int _numberSeed;
 
     private static bool GitAvailable => GitRepoFixture.IsGitAvailable();
 
@@ -120,6 +121,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
             ParentTaskId = parentId,
             CreatedAt = DateTime.UtcNow,
             CommitType = "chore",
+            Number = ++_numberSeed,
         };
         await _tasks.AddAsync(task);
         return task;
@@ -532,9 +534,9 @@ public sealed class ExternalMcpServiceTests : IDisposable
         {
             ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", WorkingDir = repo.RepoDir, CreatedAt = DateTime.UtcNow });
             ctx.Tasks.Add(new TaskEntity { Id = parentId, ListId = listId, Title = "plan", CreatedAt = DateTime.UtcNow,
-                Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.Finalized });
+                Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.Finalized, Number = ++_numberSeed });
             ctx.Tasks.Add(new TaskEntity { Id = childId, ListId = listId, Title = "child", CreatedAt = DateTime.UtcNow,
-                ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1 });
+                ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1, Number = ++_numberSeed });
 
             var wtPath = Path.Combine(Path.GetTempPath(), $"wt_{Guid.NewGuid():N}");
             _worktreeCleanups.Add((repo.RepoDir, wtPath));
@@ -582,11 +584,11 @@ public sealed class ExternalMcpServiceTests : IDisposable
         {
             ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", WorkingDir = repo.RepoDir, CreatedAt = DateTime.UtcNow });
             ctx.Tasks.Add(new TaskEntity { Id = parentId, ListId = listId, Title = "plan", CreatedAt = DateTime.UtcNow,
-                Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.Finalized });
+                Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.Finalized, Number = ++_numberSeed });
             ctx.Tasks.Add(new TaskEntity { Id = normalChildId, ListId = listId, Title = "normal child", CreatedAt = DateTime.UtcNow,
-                ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1 });
+                ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1, Number = ++_numberSeed });
             ctx.Tasks.Add(new TaskEntity { Id = blockedChildId, ListId = listId, Title = "blocked child", CreatedAt = DateTime.UtcNow,
-                ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2, RoadblockCount = 1 });
+                ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2, RoadblockCount = 1, Number = ++_numberSeed });
 
             var normalWtPath = Path.Combine(Path.GetTempPath(), $"wt_{Guid.NewGuid():N}");
             _worktreeCleanups.Add((repo.RepoDir, normalWtPath));
@@ -773,6 +775,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
             Status = TaskStatus.Idle,
             CreatedAt = DateTime.UtcNow,
             CommitType = "chore",
+            Number = ++_numberSeed,
         };
         await _tasks.AddAsync(idleUnblocked);
 
@@ -786,6 +789,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
             BlockedByTaskId = "idle-unblocked",
             CreatedAt = DateTime.UtcNow,
             CommitType = "chore",
+            Number = ++_numberSeed,
         };
         await _tasks.AddAsync(idleBlocked);
 
@@ -798,6 +802,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
             Status = TaskStatus.Done,
             CreatedAt = DateTime.UtcNow,
             CommitType = "chore",
+            Number = ++_numberSeed,
         };
         await _tasks.AddAsync(doneTask);
 
@@ -811,6 +816,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
             IsMyDay = true,
             CreatedAt = DateTime.UtcNow,
             CommitType = "chore",
+            Number = ++_numberSeed,
         };
         await _tasks.AddAsync(myDayTask);
 
@@ -826,6 +832,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
             Status = TaskStatus.Idle,
             CreatedAt = DateTime.UtcNow,
             CommitType = "chore",
+            Number = ++_numberSeed,
         };
         await _tasks.AddAsync(excludedRepoTask);
 
@@ -841,6 +848,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
             Status = TaskStatus.Idle,
             CreatedAt = DateTime.UtcNow,
             CommitType = "chore",
+            Number = ++_numberSeed,
         };
         await _tasks.AddAsync(noRepoTask);
 
@@ -1792,9 +1800,9 @@ public sealed class ExternalMcpServiceTests : IDisposable
         {
             ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", WorkingDir = repo.RepoDir, CreatedAt = DateTime.UtcNow });
             ctx.Tasks.Add(new TaskEntity { Id = parentId, ListId = listId, Title = "plan", CreatedAt = DateTime.UtcNow,
-                Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.Finalized });
+                Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.Finalized, Number = ++_numberSeed });
             ctx.Tasks.Add(new TaskEntity { Id = childId, ListId = listId, Title = "child", CreatedAt = DateTime.UtcNow,
-                ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1 });
+                ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1, Number = ++_numberSeed });
 
             var wtPath = Path.Combine(Path.GetTempPath(), $"wt_{Guid.NewGuid():N}");
             _worktreeCleanups.Add((repo.RepoDir, wtPath));

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

@@ -22,6 +22,7 @@ public sealed class QueueStateMcpToolsTests : IDisposable
     private readonly ListRepository _listRepo;
     private readonly WorkerConfig _cfg;
     private readonly string _tempDir;
+    private int _numberSeed;
 
     public QueueStateMcpToolsTests()
     {
@@ -86,6 +87,7 @@ public sealed class QueueStateMcpToolsTests : IDisposable
             IsManual = isManual,
             BlockedByTaskId = blockedByTaskId,
             ScheduledFor = scheduledFor,
+            Number = ++_numberSeed,
         };
         // Bypass TaskRepository.AddAsync, which overwrites SortOrder with max(listId)+1 --
         // these tests need to control SortOrder directly to exercise queue pick order.

tests/ClaudeDo.Worker.Tests/Planning/PlanningAggregatorTests.cs

@@ -67,7 +67,7 @@ public class PlanningAggregatorTests : IDisposable
         ctx.Tasks.Add(new TaskEntity
         {
             Id = parentId, ListId = listId, Title = "plan", CreatedAt = DateTime.UtcNow,
-            Status = TaskStatus.Idle, PlanningPhase = PlanningPhase.Active, SortOrder = 0,
+            Status = TaskStatus.Idle, PlanningPhase = PlanningPhase.Active, SortOrder = 0, Number = 1,
         });
 
         // Two children (sorted A then B).
@@ -76,12 +76,12 @@ public class PlanningAggregatorTests : IDisposable
         ctx.Tasks.Add(new TaskEntity
         {
             Id = subA, ListId = listId, Title = "child A", CreatedAt = DateTime.UtcNow,
-            ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1,
+            ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1, Number = 2,
         });
         ctx.Tasks.Add(new TaskEntity
         {
             Id = subB, ListId = listId, Title = "child B", CreatedAt = DateTime.UtcNow,
-            ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2,
+            ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2, Number = 3,
         });
         await ctx.SaveChangesAsync();
 
@@ -171,19 +171,19 @@ public class PlanningAggregatorTests : IDisposable
         ctx.Tasks.Add(new TaskEntity
         {
             Id = parentId, ListId = listId, Title = "plan", CreatedAt = DateTime.UtcNow,
-            Status = TaskStatus.Idle, PlanningPhase = PlanningPhase.Active, SortOrder = 0,
+            Status = TaskStatus.Idle, PlanningPhase = PlanningPhase.Active, SortOrder = 0, Number = 1,
         });
         var subA = Guid.NewGuid().ToString();
         var subB = Guid.NewGuid().ToString();
         ctx.Tasks.Add(new TaskEntity
         {
             Id = subA, ListId = listId, Title = "A", CreatedAt = DateTime.UtcNow,
-            ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1,
+            ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1, Number = 2,
         });
         ctx.Tasks.Add(new TaskEntity
         {
             Id = subB, ListId = listId, Title = "B", CreatedAt = DateTime.UtcNow,
-            ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2,
+            ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2, Number = 3,
         });
         await ctx.SaveChangesAsync();
 

tests/ClaudeDo.Worker.Tests/Planning/PlanningChainCoordinatorTests.cs

@@ -13,6 +13,7 @@ public sealed class PlanningChainCoordinatorTests : IDisposable
     private readonly TestDbContextFactory _factory;
     private readonly PlanningChainCoordinator _sut;
     private readonly string _listId;
+    private int _numberSeed;
 
     public PlanningChainCoordinatorTests()
     {
@@ -43,6 +44,7 @@ public sealed class PlanningChainCoordinatorTests : IDisposable
             CreatedAt = DateTime.UtcNow,
             Status = TaskStatus.Idle,
             PlanningPhase = PlanningPhase.Finalized,
+            Number = ++_numberSeed,
         });
         for (int i = 0; i < childCount; i++)
         {
@@ -55,6 +57,7 @@ public sealed class PlanningChainCoordinatorTests : IDisposable
                 Status = childStatus,
                 ParentTaskId = parentId,
                 SortOrder = i,
+                Number = ++_numberSeed,
             });
         }
         await ctx.SaveChangesAsync();

tests/ClaudeDo.Worker.Tests/Planning/PlanningMergeOrchestratorTests.cs

@@ -47,6 +47,7 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
     private readonly List<DbFixture> _dbs = new();
     private readonly List<GitRepoFixture> _repos = new();
     private readonly List<(string repoDir, string wtPath)> _wtCleanups = new();
+    private int _numberSeed;
 
     private DbFixture NewDb() { var d = new DbFixture(); _dbs.Add(d); return d; }
     private GitRepoFixture NewRepo() { var r = new GitRepoFixture(); _repos.Add(r); return r; }
@@ -102,6 +103,7 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
         {
             Id = parentId, ListId = listId, Title = "plan", CreatedAt = DateTime.UtcNow,
             Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.Finalized, SortOrder = 0,
+            Number = ++_numberSeed,
         });
 
         var subA = Guid.NewGuid().ToString();
@@ -110,11 +112,13 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
         {
             Id = subA, ListId = listId, Title = "child A", CreatedAt = DateTime.UtcNow,
             ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1,
+            Number = ++_numberSeed,
         });
         ctx.Tasks.Add(new TaskEntity
         {
             Id = subB, ListId = listId, Title = "child B", CreatedAt = DateTime.UtcNow,
             ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2,
+            Number = ++_numberSeed,
         });
         await ctx.SaveChangesAsync();
 
@@ -170,14 +174,15 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
         {
             Id = parentId, ListId = listId, Title = "plan", CreatedAt = DateTime.UtcNow,
             Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.Finalized, SortOrder = 0,
+            Number = ++_numberSeed,
         });
         var subA = Guid.NewGuid().ToString();
         var subB = Guid.NewGuid().ToString();
         var subC = Guid.NewGuid().ToString();
         ctx.Tasks.AddRange(
-            new TaskEntity { Id = subA, ListId = listId, Title = "A", CreatedAt = DateTime.UtcNow, ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1 },
-            new TaskEntity { Id = subB, ListId = listId, Title = "B", CreatedAt = DateTime.UtcNow, ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2 },
-            new TaskEntity { Id = subC, ListId = listId, Title = "C", CreatedAt = DateTime.UtcNow, ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 3 }
+            new TaskEntity { Id = subA, ListId = listId, Title = "A", CreatedAt = DateTime.UtcNow, ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1, Number = ++_numberSeed },
+            new TaskEntity { Id = subB, ListId = listId, Title = "B", CreatedAt = DateTime.UtcNow, ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2, Number = ++_numberSeed },
+            new TaskEntity { Id = subC, ListId = listId, Title = "C", CreatedAt = DateTime.UtcNow, ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 3, Number = ++_numberSeed }
         );
         await ctx.SaveChangesAsync();
 
@@ -509,6 +514,7 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
         {
             Id = parentId, ListId = listId, Title = "plan", CreatedAt = DateTime.UtcNow,
             Status = TaskStatus.Idle, PlanningPhase = PlanningPhase.Finalized, SortOrder = 0,
+            Number = ++_numberSeed,
         });
         var running = Guid.NewGuid().ToString();
         ctx.Tasks.Add(new TaskEntity
@@ -516,6 +522,7 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
             Id = running, ListId = listId, Title = "still running",
             CreatedAt = DateTime.UtcNow, ParentTaskId = parentId,
             Status = TaskStatus.Running, SortOrder = 1,
+            Number = ++_numberSeed,
         });
         await ctx.SaveChangesAsync();
         SeedWorktreeWithFile(ctx, repo, running, "fileR.txt", "R\n");
@@ -574,6 +581,7 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
         {
             Id = parentId, ListId = listId, Title = "improve", CreatedAt = DateTime.UtcNow,
             Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.None, SortOrder = 0,
+            Number = ++_numberSeed,
         });
 
         var subA = Guid.NewGuid().ToString();
@@ -582,11 +590,13 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
         {
             Id = subA, ListId = listId, Title = "child A", CreatedAt = DateTime.UtcNow,
             ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1,
+            Number = ++_numberSeed,
         });
         ctx.Tasks.Add(new TaskEntity
         {
             Id = subB, ListId = listId, Title = "child B", CreatedAt = DateTime.UtcNow,
             ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2,
+            Number = ++_numberSeed,
         });
         await ctx.SaveChangesAsync();
 
@@ -642,6 +652,7 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
         {
             Id = parentId, ListId = listId, Title = "improve", CreatedAt = DateTime.UtcNow,
             Status = TaskStatus.Cancelled, PlanningPhase = PlanningPhase.None, SortOrder = 0,
+            Number = ++_numberSeed,
         });
 
         var subA = Guid.NewGuid().ToString();
@@ -650,11 +661,13 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
         {
             Id = subA, ListId = listId, Title = "child A", CreatedAt = DateTime.UtcNow,
             ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1,
+            Number = ++_numberSeed,
         });
         ctx.Tasks.Add(new TaskEntity
         {
             Id = subB, ListId = listId, Title = "child B", CreatedAt = DateTime.UtcNow,
             ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2,
+            Number = ++_numberSeed,
         });
         await ctx.SaveChangesAsync();
 

tests/ClaudeDo.Worker.Tests/Planning/TreeMergeTests.cs

@@ -74,9 +74,9 @@ public sealed class TreeMergeTests : IDisposable
         using (var ctx = db.CreateContext())
         {
             ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", WorkingDir = repo.RepoDir, CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = parentId, ListId = listId, Title = "Parent",
+            ctx.Tasks.Add(new TaskEntity { Id = parentId, ListId = listId, Title = "Parent", Number = 1,
                 Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.None, SortOrder = 0, CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = childId, ListId = listId, Title = "Child",
+            ctx.Tasks.Add(new TaskEntity { Id = childId, ListId = listId, Title = "Child", Number = 2,
                 Status = TaskStatus.Done, ParentTaskId = parentId, SortOrder = 1, CreatedAt = DateTime.UtcNow });
             await ctx.SaveChangesAsync();
 

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

@@ -33,9 +33,9 @@ public sealed class StandaloneChildrenRoutingTests : IDisposable
         using (var ctx = _db.CreateContext())
         {
             ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", WorkingDir = null, CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "p1", ListId = "l1", Title = "Parent",
+            ctx.Tasks.Add(new TaskEntity { Id = "p1", ListId = "l1", Title = "Parent", Number = 1,
                 Status = TaskStatus.Running, CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "kid", ListId = "l1", Title = "Improve",
+            ctx.Tasks.Add(new TaskEntity { Id = "kid", ListId = "l1", Title = "Improve", Number = 2,
                 Status = TaskStatus.Idle, ParentTaskId = "p1", CreatedBy = "p1", CreatedAt = DateTime.UtcNow });
             await ctx.SaveChangesAsync();
         }
@@ -63,7 +63,7 @@ public sealed class StandaloneChildrenRoutingTests : IDisposable
         using (var ctx = _db.CreateContext())
         {
             ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", WorkingDir = null, CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "solo", ListId = "l1", Title = "Solo",
+            ctx.Tasks.Add(new TaskEntity { Id = "solo", ListId = "l1", Title = "Solo", Number = 1,
                 Status = TaskStatus.Running, CreatedAt = DateTime.UtcNow });
             await ctx.SaveChangesAsync();
         }

tests/ClaudeDo.Worker.Tests/State/TaskStateServiceTests.cs

@@ -25,6 +25,7 @@ public sealed class TaskStateServiceTests : IDisposable
     private readonly ITaskStateService _sut;
     private readonly string _listId;
     private readonly List<GitRepoFixture> _repos = new();
+    private int _numberSeed;
 
     private static bool GitAvailable => GitRepoFixture.IsGitAvailable();
 
@@ -75,6 +76,7 @@ public sealed class TaskStateServiceTests : IDisposable
             Id = id,
             ListId = _listId,
             Title = "task",
+            Number = ++_numberSeed,
             Status = status,
             PlanningPhase = phase,
             CreatedAt = DateTime.UtcNow,

tests/ClaudeDo.Worker.Tests/SuggestImprovementTests.cs

@@ -12,6 +12,7 @@ namespace ClaudeDo.Worker.Tests;
 public sealed class SuggestImprovementTests : IDisposable
 {
     private readonly DbFixture _db = new();
+    private int _numberSeed;
     public void Dispose() => _db.Dispose();
 
     private static TaskRunMcpContextAccessor AccessorFor(string callerTaskId)
@@ -26,7 +27,7 @@ public sealed class SuggestImprovementTests : IDisposable
         using var ctx = _db.CreateContext();
         if (!ctx.Lists.Any())
             ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", CreatedAt = DateTime.UtcNow });
-        ctx.Tasks.Add(new TaskEntity { Id = id, ListId = "l1", Title = "Caller",
+        ctx.Tasks.Add(new TaskEntity { Id = id, ListId = "l1", Title = "Caller", Number = ++_numberSeed,
             Status = TaskStatus.Running, ParentTaskId = parentId, CommitType = "feat", CreatedAt = DateTime.UtcNow });
         await ctx.SaveChangesAsync();
     }

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

@@ -348,6 +348,7 @@ public class TasksIslandViewModelPlanningTests
 public sealed class TasksIslandViewModelMyDayTests : IDisposable
 {
     private readonly DbFixture _db = new();
+    private int _numberSeed;
     public void Dispose() => _db.Dispose();
 
     [Fact]
@@ -361,6 +362,7 @@ public sealed class TasksIslandViewModelMyDayTests : IDisposable
             ctx.Tasks.Add(new TaskEntity
             {
                 Id = taskId, ListId = listId, Title = "T", CreatedAt = DateTime.UtcNow,
+                Number = ++_numberSeed,
                 Status = TaskStatus.Idle, IsMyDay = false,
             });
             await ctx.SaveChangesAsync();
@@ -391,16 +393,19 @@ public sealed class TasksIslandViewModelMyDayTests : IDisposable
             ctx.Tasks.Add(new TaskEntity
             {
                 Id = parentId, ListId = listId, Title = "P", CreatedAt = DateTime.UtcNow,
+                Number = ++_numberSeed,
                 Status = TaskStatus.WaitingForChildren, PlanningPhase = PlanningPhase.Finalized, IsMyDay = true,
             });
             ctx.Tasks.Add(new TaskEntity
             {
                 Id = child1, ListId = listId, Title = "C1", CreatedAt = DateTime.UtcNow,
+                Number = ++_numberSeed,
                 Status = TaskStatus.Idle, ParentTaskId = parentId, IsMyDay = true,
             });
             ctx.Tasks.Add(new TaskEntity
             {
                 Id = child2, ListId = listId, Title = "C2", CreatedAt = DateTime.UtcNow,
+                Number = ++_numberSeed,
                 Status = TaskStatus.Idle, ParentTaskId = parentId, IsMyDay = true,
             });
             await ctx.SaveChangesAsync();

tests/ClaudeDo.Worker.Tests/Usage/RunningTaskProbeTests.cs

@@ -8,6 +8,7 @@ namespace ClaudeDo.Worker.Tests.Usage;
 public sealed class RunningTaskProbeTests : IDisposable
 {
     private readonly DbFixture _db = new();
+    private int _numberSeed;
 
     public void Dispose() => _db.Dispose();
 
@@ -21,6 +22,7 @@ public sealed class RunningTaskProbeTests : IDisposable
             Id = Guid.NewGuid().ToString(),
             ListId = list.Id,
             Title = $"task-{status}",
+            Number = ++_numberSeed,
             Status = status,
             CreatedAt = DateTime.UtcNow,
         });

tests/ClaudeDo.Worker.Tests/WaitingForChildrenLifecycleTests.cs

@@ -13,6 +13,7 @@ public sealed class WaitingForChildrenLifecycleTests : IDisposable
     private readonly DbFixture _db = new();
     private readonly TestDbContextFactory _factory;
     private readonly TaskStateServiceBuilder.Built _built;
+    private int _numberSeed;
 
     public WaitingForChildrenLifecycleTests()
     {
@@ -25,7 +26,7 @@ public sealed class WaitingForChildrenLifecycleTests : IDisposable
     {
         using var ctx = _db.CreateContext();
         ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", CreatedAt = DateTime.UtcNow });
-        ctx.Tasks.Add(new TaskEntity { Id = "p1", ListId = "l1", Title = "Parent",
+        ctx.Tasks.Add(new TaskEntity { Id = "p1", ListId = "l1", Title = "Parent", Number = ++_numberSeed,
             Status = TaskStatus.Running, CreatedAt = DateTime.UtcNow });
         await ctx.SaveChangesAsync();
         return "p1";
@@ -58,11 +59,11 @@ public sealed class WaitingForChildrenLifecycleTests : IDisposable
         using var ctx = _db.CreateContext();
         if (!ctx.Lists.Any())
             ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", CreatedAt = DateTime.UtcNow });
-        ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent",
+        ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent", Number = ++_numberSeed,
             Status = Enum.Parse<TaskStatus>(parentStatus), Result = "parent ran", CreatedAt = DateTime.UtcNow });
         int i = 0;
         foreach (var cs in childStatuses)
-            ctx.Tasks.Add(new TaskEntity { Id = $"c{i++}", ListId = "l1", Title = "Child",
+            ctx.Tasks.Add(new TaskEntity { Id = $"c{i++}", ListId = "l1", Title = "Child", Number = ++_numberSeed,
                 Status = cs, ParentTaskId = "par", CreatedAt = DateTime.UtcNow });
         await ctx.SaveChangesAsync();
     }
@@ -103,9 +104,9 @@ public sealed class WaitingForChildrenLifecycleTests : IDisposable
         using var ctx = _db.CreateContext();
         if (!ctx.Lists.Any())
             ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", CreatedAt = DateTime.UtcNow });
-        ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent",
+        ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent", Number = ++_numberSeed,
             Status = TaskStatus.WaitingForChildren, PlanningPhase = parentPhase, CreatedAt = DateTime.UtcNow });
-        ctx.Tasks.Add(new TaskEntity { Id = "kid", ListId = "l1", Title = "Child",
+        ctx.Tasks.Add(new TaskEntity { Id = "kid", ListId = "l1", Title = "Child", Number = ++_numberSeed,
             Status = TaskStatus.Idle, ParentTaskId = "par", CreatedAt = DateTime.UtcNow });
         await ctx.SaveChangesAsync();
     }
@@ -135,11 +136,11 @@ public sealed class WaitingForChildrenLifecycleTests : IDisposable
         using (var ctx = _db.CreateContext())
         {
             ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent",
+            ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent", Number = ++_numberSeed,
                 Status = TaskStatus.WaitingForChildren, CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "c1", ListId = "l1", Title = "Child1",
+            ctx.Tasks.Add(new TaskEntity { Id = "c1", ListId = "l1", Title = "Child1", Number = ++_numberSeed,
                 Status = TaskStatus.Running, ParentTaskId = "par", CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "c2", ListId = "l1", Title = "Child2",
+            ctx.Tasks.Add(new TaskEntity { Id = "c2", ListId = "l1", Title = "Child2", Number = ++_numberSeed,
                 Status = TaskStatus.Running, ParentTaskId = "par", BlockedByTaskId = "c1",
                 CreatedAt = DateTime.UtcNow });
             await ctx.SaveChangesAsync();
@@ -168,7 +169,7 @@ public sealed class WaitingForChildrenLifecycleTests : IDisposable
         using (var ctx = _db.CreateContext())
         {
             ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent",
+            ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent", Number = ++_numberSeed,
                 Status = TaskStatus.WaitingForChildren, CreatedAt = DateTime.UtcNow });
             await ctx.SaveChangesAsync();
         }
@@ -189,11 +190,11 @@ public sealed class WaitingForChildrenLifecycleTests : IDisposable
         using (var ctx = _db.CreateContext())
         {
             ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent",
+            ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent", Number = ++_numberSeed,
                 Status = TaskStatus.WaitingForChildren, CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "c_running", ListId = "l1", Title = "Running child",
+            ctx.Tasks.Add(new TaskEntity { Id = "c_running", ListId = "l1", Title = "Running child", Number = ++_numberSeed,
                 Status = TaskStatus.Running, ParentTaskId = "par", CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "c_queued", ListId = "l1", Title = "Queued child",
+            ctx.Tasks.Add(new TaskEntity { Id = "c_queued", ListId = "l1", Title = "Queued child", Number = ++_numberSeed,
                 Status = TaskStatus.Queued, ParentTaskId = "par", BlockedByTaskId = "c_running",
                 CreatedAt = DateTime.UtcNow });
             await ctx.SaveChangesAsync();
@@ -220,9 +221,9 @@ public sealed class WaitingForChildrenLifecycleTests : IDisposable
         using (var ctx = _db.CreateContext())
         {
             ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent",
+            ctx.Tasks.Add(new TaskEntity { Id = "par", ListId = "l1", Title = "Parent", Number = ++_numberSeed,
                 Status = TaskStatus.WaitingForChildren, CreatedAt = DateTime.UtcNow });
-            ctx.Tasks.Add(new TaskEntity { Id = "c_running", ListId = "l1", Title = "Running child",
+            ctx.Tasks.Add(new TaskEntity { Id = "c_running", ListId = "l1", Title = "Running child", Number = ++_numberSeed,
                 Status = TaskStatus.Running, ParentTaskId = "par", CreatedAt = DateTime.UtcNow });
             await ctx.SaveChangesAsync();
         }
@@ -261,6 +262,7 @@ public sealed class WaitingForChildrenLifecycleTests : IDisposable
             Id = id,
             ListId = "l1",
             Title = "Parent",
+            Number = ++_numberSeed,
             Status = TaskStatus.Idle,
             PlanningPhase = PlanningPhase.Active,
             CreatedAt = DateTime.UtcNow,
@@ -277,6 +279,7 @@ public sealed class WaitingForChildrenLifecycleTests : IDisposable
             Id = childId,
             ListId = "l1",
             Title = "Child",
+            Number = ++_numberSeed,
             Status = status,
             ParentTaskId = parentId,
             CreatedAt = DateTime.UtcNow,