diff --git a/src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs b/src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs index dbf294ba..0fb606e9 100644 --- a/src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs +++ b/src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs @@ -13,6 +13,9 @@ public class AppSettingsEntityConfiguration : IEntityTypeConfiguration 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) diff --git a/src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs b/src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs index dba832a8..87374c1d 100644 --- a/src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs +++ b/src/ClaudeDo.Data/Configuration/TaskEntityConfiguration.cs @@ -66,6 +66,7 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration 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 .WithOne(w => w.Task) .HasForeignKey(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"); diff --git a/src/ClaudeDo.Data/Migrations/20260811081530_AddTaskNumbers.Designer.cs b/src/ClaudeDo.Data/Migrations/20260811081530_AddTaskNumbers.Designer.cs new file mode 100644 index 00000000..101a3d0c --- /dev/null +++ b/src/ClaudeDo.Data/Migrations/20260811081530_AddTaskNumbers.Designer.cs @@ -0,0 +1,950 @@ +// +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 + { + /// + 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("Id") + .HasColumnType("INTEGER") + .HasColumnName("id"); + + b.Property("CentralWorktreeRoot") + .HasColumnType("TEXT") + .HasColumnName("central_worktree_root"); + + b.Property("DailyPrepMaxTasks") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(5) + .HasColumnName("daily_prep_max_tasks"); + + b.Property("DefaultClaudeInstructions") + .IsRequired() + .ValueGeneratedOnAdd() + .HasColumnType("TEXT") + .HasDefaultValue("") + .HasColumnName("default_claude_instructions"); + + b.Property("DefaultMaxTurns") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(40) + .HasColumnName("default_max_turns"); + + b.Property("DefaultModel") + .IsRequired() + .ValueGeneratedOnAdd() + .HasColumnType("TEXT") + .HasDefaultValue("sonnet") + .HasColumnName("default_model"); + + b.Property("DefaultPermissionMode") + .IsRequired() + .ValueGeneratedOnAdd() + .HasColumnType("TEXT") + .HasDefaultValue("bypassPermissions") + .HasColumnName("default_permission_mode"); + + b.Property("MaxParallelExecutions") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(1) + .HasColumnName("max_parallel_executions"); + + b.Property("MaxTurnsCeiling") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(80) + .HasColumnName("max_turns_ceiling"); + + b.Property("ModelPresets") + .HasColumnType("TEXT") + .HasColumnName("model_presets"); + + b.Property("NextTaskNumber") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(1) + .HasColumnName("next_task_number"); + + b.Property("RepoImportFolders") + .HasColumnType("TEXT") + .HasColumnName("repo_import_folders"); + + b.Property("ReportExcludedPaths") + .HasColumnType("TEXT") + .HasColumnName("report_excluded_paths"); + + b.Property("SessionSkills") + .HasColumnType("TEXT") + .HasColumnName("session_skills"); + + b.Property("StandupWeekday") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(3) + .HasColumnName("standup_weekday"); + + b.Property("UsageGateFiveHourPct") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(80) + .HasColumnName("usage_gate_five_hour_pct"); + + b.Property("UsageGateSevenDayPct") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(90) + .HasColumnName("usage_gate_seven_day_pct"); + + b.Property("UsageThrottleFiveHourHardPct") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(65) + .HasColumnName("usage_throttle_five_hour_hard_pct"); + + b.Property("UsageThrottleFiveHourSoftPct") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(50) + .HasColumnName("usage_throttle_five_hour_soft_pct"); + + b.Property("UsageThrottleSevenDayHardPct") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(65) + .HasColumnName("usage_throttle_seven_day_hard_pct"); + + b.Property("UsageThrottleSevenDaySoftPct") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(50) + .HasColumnName("usage_throttle_seven_day_soft_pct"); + + b.Property("WorktreeAutoCleanupDays") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(7) + .HasColumnName("worktree_auto_cleanup_days"); + + b.Property("WorktreeAutoCleanupEnabled") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(false) + .HasColumnName("worktree_auto_cleanup_enabled"); + + b.Property("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("Id") + .HasColumnType("TEXT") + .HasColumnName("id"); + + b.Property("CreatedAt") + .HasColumnType("TEXT") + .HasColumnName("created_at"); + + b.Property("Date") + .HasColumnType("TEXT") + .HasColumnName("note_date"); + + b.Property("SortOrder") + .HasColumnType("INTEGER") + .HasColumnName("sort_order"); + + b.Property("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("ListId") + .HasColumnType("TEXT") + .HasColumnName("list_id"); + + b.Property("AgentPath") + .HasColumnType("TEXT") + .HasColumnName("agent_path"); + + b.Property("MaxTurns") + .HasColumnType("INTEGER") + .HasColumnName("max_turns"); + + b.Property("Model") + .HasColumnType("TEXT") + .HasColumnName("model"); + + b.Property("SerializeOnFileOverlap") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(false) + .HasColumnName("serialize_on_file_overlap"); + + b.Property("SessionSkills") + .HasColumnType("TEXT") + .HasColumnName("session_skills"); + + b.Property("SystemPrompt") + .HasColumnType("TEXT") + .HasColumnName("system_prompt"); + + b.Property("VerifyCommand") + .HasColumnType("TEXT") + .HasColumnName("verify_command"); + + b.HasKey("ListId"); + + b.ToTable("list_config", (string)null); + }); + + modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b => + { + b.Property("Id") + .HasColumnType("TEXT") + .HasColumnName("id"); + + b.Property("CreatedAt") + .HasColumnType("TEXT") + .HasColumnName("created_at"); + + b.Property("DefaultCommitType") + .IsRequired() + .ValueGeneratedOnAdd() + .HasColumnType("TEXT") + .HasDefaultValue("chore") + .HasColumnName("default_commit_type"); + + b.Property("FindingsTracked") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(false) + .HasColumnName("findings_tracked"); + + b.Property("IsManual") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(false) + .HasColumnName("is_manual"); + + b.Property("Name") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("name"); + + b.Property("SortOrder") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(0) + .HasColumnName("sort_order"); + + b.Property("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("Id") + .HasColumnType("TEXT") + .HasColumnName("id"); + + b.Property("CreatedAt") + .HasColumnType("TEXT") + .HasColumnName("created_at"); + + b.Property("Days") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(31) + .HasColumnName("days_of_week"); + + b.Property("Enabled") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(true) + .HasColumnName("enabled"); + + b.Property("LastRunAt") + .HasColumnType("TEXT") + .HasColumnName("last_run_at"); + + b.Property("PromptOverride") + .HasColumnType("TEXT") + .HasColumnName("prompt_override"); + + b.Property("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("Name") + .HasColumnType("TEXT") + .HasColumnName("name"); + + b.Property("AddedAt") + .HasColumnType("TEXT") + .HasColumnName("added_at"); + + b.Property("Description") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("description"); + + b.Property("PinnedRef") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("pinned_ref"); + + b.Property("SourceUrl") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("source_url"); + + b.Property("Subpath") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("subpath"); + + b.HasKey("Name"); + + b.ToTable("session_skills", (string)null); + }); + + modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b => + { + b.Property("Id") + .HasColumnType("TEXT") + .HasColumnName("id"); + + b.Property("Completed") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(false) + .HasColumnName("completed"); + + b.Property("CreatedAt") + .HasColumnType("TEXT") + .HasColumnName("created_at"); + + b.Property("OrderNum") + .HasColumnType("INTEGER") + .HasColumnName("order_num"); + + b.Property("TaskId") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("task_id"); + + b.Property("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("Id") + .HasColumnType("TEXT") + .HasColumnName("id"); + + b.Property("ByteSize") + .HasColumnType("INTEGER") + .HasColumnName("byte_size"); + + b.Property("CreatedAt") + .HasColumnType("TEXT") + .HasColumnName("created_at"); + + b.Property("FileName") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("file_name"); + + b.Property("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("Id") + .HasColumnType("TEXT") + .HasColumnName("id"); + + b.Property("AgentPath") + .HasColumnType("TEXT") + .HasColumnName("agent_path"); + + b.Property("BlockedByTaskId") + .HasColumnType("TEXT") + .HasColumnName("blocked_by_task_id"); + + b.Property("CommitType") + .IsRequired() + .ValueGeneratedOnAdd() + .HasColumnType("TEXT") + .HasDefaultValue("chore") + .HasColumnName("commit_type"); + + b.Property("CreatedAt") + .HasColumnType("TEXT") + .HasColumnName("created_at"); + + b.Property("CreatedBy") + .HasColumnType("TEXT") + .HasColumnName("created_by"); + + b.Property("DependsOnTaskId") + .HasColumnType("TEXT") + .HasColumnName("depends_on_task_id"); + + b.Property("Description") + .HasColumnType("TEXT") + .HasColumnName("description"); + + b.Property("FailureMaxTurns") + .HasColumnType("INTEGER") + .HasColumnName("failure_max_turns"); + + b.Property("FailureReason") + .HasColumnType("TEXT") + .HasColumnName("failure_reason"); + + b.Property("FailureTurnsUsed") + .HasColumnType("INTEGER") + .HasColumnName("failure_turns_used"); + + b.Property("FinishedAt") + .HasColumnType("TEXT") + .HasColumnName("finished_at"); + + b.Property("HandlerBaseCommit") + .HasColumnType("TEXT") + .HasColumnName("handler_base_commit"); + + b.Property("HandlerHeadCommit") + .HasColumnType("TEXT") + .HasColumnName("handler_head_commit"); + + b.Property("InteractiveSessionId") + .HasColumnType("TEXT") + .HasColumnName("interactive_session_id"); + + b.Property("IsManual") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(false) + .HasColumnName("is_manual"); + + b.Property("IsMyDay") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(false) + .HasColumnName("is_my_day"); + + b.Property("IsStarred") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(false) + .HasColumnName("is_starred"); + + b.Property("ListId") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("list_id"); + + b.Property("LogPath") + .HasColumnType("TEXT") + .HasColumnName("log_path"); + + b.Property("MaxTurns") + .HasColumnType("INTEGER") + .HasColumnName("max_turns"); + + b.Property("Model") + .HasColumnType("TEXT") + .HasColumnName("model"); + + b.Property("Notes") + .HasColumnType("TEXT") + .HasColumnName("notes"); + + b.Property("Number") + .HasColumnType("INTEGER") + .HasColumnName("number"); + + b.Property("ParentTaskId") + .HasColumnType("TEXT") + .HasColumnName("parent_task_id"); + + b.Property("PlanningFinalizedAt") + .HasColumnType("TEXT") + .HasColumnName("planning_finalized_at"); + + b.Property("PlanningPhase") + .IsRequired() + .ValueGeneratedOnAdd() + .HasColumnType("TEXT") + .HasDefaultValue("none") + .HasColumnName("planning_phase"); + + b.Property("PlanningSessionId") + .HasColumnType("TEXT") + .HasColumnName("planning_session_id"); + + b.Property("PlanningSessionToken") + .HasColumnType("TEXT") + .HasColumnName("planning_session_token"); + + b.Property("Result") + .HasColumnType("TEXT") + .HasColumnName("result"); + + b.Property("ReviewFeedback") + .HasColumnType("TEXT") + .HasColumnName("review_feedback"); + + b.Property("RoadblockCount") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(0) + .HasColumnName("roadblock_count"); + + b.Property("ScheduledFor") + .HasColumnType("TEXT") + .HasColumnName("scheduled_for"); + + b.Property("ScopeGlobs") + .HasColumnType("TEXT") + .HasColumnName("scope_globs"); + + b.Property("SessionSkills") + .HasColumnType("TEXT") + .HasColumnName("session_skills"); + + b.Property("SortOrder") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(0) + .HasColumnName("sort_order"); + + b.Property("StartedAt") + .HasColumnType("TEXT") + .HasColumnName("started_at"); + + b.Property("Status") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("status"); + + b.Property("SystemPrompt") + .HasColumnType("TEXT") + .HasColumnName("system_prompt"); + + b.Property("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("Id") + .HasColumnType("TEXT") + .HasColumnName("id"); + + b.Property("CacheReadTokens") + .HasColumnType("INTEGER") + .HasColumnName("cache_read_tokens"); + + b.Property("CacheWriteTokens") + .HasColumnType("INTEGER") + .HasColumnName("cache_write_tokens"); + + b.Property("ErrorMarkdown") + .HasColumnType("TEXT") + .HasColumnName("error_markdown"); + + b.Property("Errors") + .HasColumnType("TEXT") + .HasColumnName("errors"); + + b.Property("ExitCode") + .HasColumnType("INTEGER") + .HasColumnName("exit_code"); + + b.Property("FinishedAt") + .HasColumnType("TEXT") + .HasColumnName("finished_at"); + + b.Property("IsRetry") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(false) + .HasColumnName("is_retry"); + + b.Property("LogPath") + .HasColumnType("TEXT") + .HasColumnName("log_path"); + + b.Property("Model") + .HasColumnType("TEXT") + .HasColumnName("model"); + + b.Property("Prompt") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("prompt"); + + b.Property("ResultMarkdown") + .HasColumnType("TEXT") + .HasColumnName("result_markdown"); + + b.Property("ResultSubtype") + .HasColumnType("TEXT") + .HasColumnName("result_subtype"); + + b.Property("RunNumber") + .HasColumnType("INTEGER") + .HasColumnName("run_number"); + + b.Property("SessionId") + .HasColumnType("TEXT") + .HasColumnName("session_id"); + + b.Property("StartedAt") + .HasColumnType("TEXT") + .HasColumnName("started_at"); + + b.Property("StructuredOutputJson") + .HasColumnType("TEXT") + .HasColumnName("structured_output"); + + b.Property("TaskId") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("task_id"); + + b.Property("TerminalReason") + .HasColumnType("TEXT") + .HasColumnName("terminal_reason"); + + b.Property("TokensIn") + .HasColumnType("INTEGER") + .HasColumnName("tokens_in"); + + b.Property("TokensOut") + .HasColumnType("INTEGER") + .HasColumnName("tokens_out"); + + b.Property("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("Id") + .HasColumnType("TEXT") + .HasColumnName("id"); + + b.Property("EndDate") + .HasColumnType("TEXT") + .HasColumnName("end_date"); + + b.Property("GeneratedAt") + .HasColumnType("TEXT") + .HasColumnName("generated_at"); + + b.Property("Markdown") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("markdown"); + + b.Property("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("TaskId") + .HasColumnType("TEXT") + .HasColumnName("task_id"); + + b.Property("BaseCommit") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("base_commit"); + + b.Property("BranchName") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("branch_name"); + + b.Property("CreatedAt") + .HasColumnType("TEXT") + .HasColumnName("created_at"); + + b.Property("DiffStat") + .HasColumnType("TEXT") + .HasColumnName("diff_stat"); + + b.Property("HeadCommit") + .HasColumnType("TEXT") + .HasColumnName("head_commit"); + + b.Property("MergeCommit") + .HasColumnType("TEXT") + .HasColumnName("merge_commit"); + + b.Property("Path") + .IsRequired() + .HasColumnType("TEXT") + .HasColumnName("path"); + + b.Property("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 + } + } +} diff --git a/src/ClaudeDo.Data/Migrations/20260811081530_AddTaskNumbers.cs b/src/ClaudeDo.Data/Migrations/20260811081530_AddTaskNumbers.cs new file mode 100644 index 00000000..5f367379 --- /dev/null +++ b/src/ClaudeDo.Data/Migrations/20260811081530_AddTaskNumbers.cs @@ -0,0 +1,67 @@ +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace ClaudeDo.Data.Migrations +{ + /// + public partial class AddTaskNumbers : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.AddColumn( + name: "number", + table: "tasks", + type: "INTEGER", + nullable: false, + defaultValue: 0); + + migrationBuilder.AddColumn( + 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); + } + + /// + 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"); + } + } +} diff --git a/src/ClaudeDo.Data/Migrations/ClaudeDoDbContextModelSnapshot.cs b/src/ClaudeDo.Data/Migrations/ClaudeDoDbContextModelSnapshot.cs index 8a9f4888..79216225 100644 --- a/src/ClaudeDo.Data/Migrations/ClaudeDoDbContextModelSnapshot.cs +++ b/src/ClaudeDo.Data/Migrations/ClaudeDoDbContextModelSnapshot.cs @@ -76,6 +76,12 @@ namespace ClaudeDo.Data.Migrations .HasColumnType("TEXT") .HasColumnName("model_presets"); + b.Property("NextTaskNumber") + .ValueGeneratedOnAdd() + .HasColumnType("INTEGER") + .HasDefaultValue(1) + .HasColumnName("next_task_number"); + b.Property("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("Number") + .HasColumnType("INTEGER") + .HasColumnName("number"); + b.Property("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"); diff --git a/src/ClaudeDo.Data/Models/AppSettingsEntity.cs b/src/ClaudeDo.Data/Models/AppSettingsEntity.cs index 122344bf..12dc4a0b 100644 --- a/src/ClaudeDo.Data/Models/AppSettingsEntity.cs +++ b/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; diff --git a/src/ClaudeDo.Data/Models/TaskEntity.cs b/src/ClaudeDo.Data/Models/TaskEntity.cs index 5f4f1078..ded967f7 100644 --- a/src/ClaudeDo.Data/Models/TaskEntity.cs +++ b/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; } diff --git a/src/ClaudeDo.Data/Repositories/TaskRepository.cs b/src/ClaudeDo.Data/Repositories/TaskRepository.cs index db5879c7..c3d52c11 100644 --- a/src/ClaudeDo.Data/Repositories/TaskRepository.cs +++ b/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 GetByNumberAsync(int number, CancellationToken ct = default) + { + return await _context.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Number == number, ct); + } + public async Task> 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; } diff --git a/src/ClaudeDo.Data/TaskNumberAllocator.cs b/src/ClaudeDo.Data/TaskNumberAllocator.cs new file mode 100644 index 00000000..b51edf7c --- /dev/null +++ b/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; + } + } + } +} diff --git a/tests/ClaudeDo.Data.Tests/ForeignKeyTests.cs b/tests/ClaudeDo.Data.Tests/ForeignKeyTests.cs index b2c51577..a07bee03 100644 --- a/tests/ClaudeDo.Data.Tests/ForeignKeyTests.cs +++ b/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(); } diff --git a/tests/ClaudeDo.Data.Tests/MoveToListTests.cs b/tests/ClaudeDo.Data.Tests/MoveToListTests.cs index 5e4b8fa7..6960020a 100644 --- a/tests/ClaudeDo.Data.Tests/MoveToListTests.cs +++ b/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(); diff --git a/tests/ClaudeDo.Data.Tests/TaskNumberAllocatorTests.cs b/tests/ClaudeDo.Data.Tests/TaskNumberAllocatorTests.cs new file mode 100644 index 00000000..93be3071 --- /dev/null +++ b/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 _options; + private readonly ClaudeDoDbContext _ctx; + + public TaskNumberAllocatorTests() + { + _dbPath = Path.Combine(Path.GetTempPath(), $"claudedo_tasknum_{Guid.NewGuid():N}.db"); + _options = new DbContextOptionsBuilder() + .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 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(); + 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); + } +} diff --git a/tests/ClaudeDo.Data.Tests/TaskNumberMigrationTests.cs b/tests/ClaudeDo.Data.Tests/TaskNumberMigrationTests.cs new file mode 100644 index 00000000..40116620 --- /dev/null +++ b/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 _options; + + public TaskNumberMigrationTests() + { + _dbPath = Path.Combine(Path.GetTempPath(), $"claudedo_tasknum_migration_{Guid.NewGuid():N}.db"); + _options = new DbContextOptionsBuilder() + .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(); + 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(); + } +} diff --git a/tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs b/tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs index 4bb9bead..769eff87 100644 --- a/tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs +++ b/tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs @@ -61,6 +61,7 @@ public sealed class ExternalMcpServiceTests : IDisposable private readonly HubBroadcaster _broadcaster; private readonly List _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)); diff --git a/tests/ClaudeDo.Worker.Tests/External/QueueStateMcpToolsTests.cs b/tests/ClaudeDo.Worker.Tests/External/QueueStateMcpToolsTests.cs index 8d99d0d2..6ba88bad 100644 --- a/tests/ClaudeDo.Worker.Tests/External/QueueStateMcpToolsTests.cs +++ b/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. diff --git a/tests/ClaudeDo.Worker.Tests/Planning/PlanningAggregatorTests.cs b/tests/ClaudeDo.Worker.Tests/Planning/PlanningAggregatorTests.cs index 993b40b3..a1ccaea8 100644 --- a/tests/ClaudeDo.Worker.Tests/Planning/PlanningAggregatorTests.cs +++ b/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(); diff --git a/tests/ClaudeDo.Worker.Tests/Planning/PlanningChainCoordinatorTests.cs b/tests/ClaudeDo.Worker.Tests/Planning/PlanningChainCoordinatorTests.cs index dbde5531..dcdfad93 100644 --- a/tests/ClaudeDo.Worker.Tests/Planning/PlanningChainCoordinatorTests.cs +++ b/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(); diff --git a/tests/ClaudeDo.Worker.Tests/Planning/PlanningMergeOrchestratorTests.cs b/tests/ClaudeDo.Worker.Tests/Planning/PlanningMergeOrchestratorTests.cs index b100eb6f..58a34efc 100644 --- a/tests/ClaudeDo.Worker.Tests/Planning/PlanningMergeOrchestratorTests.cs +++ b/tests/ClaudeDo.Worker.Tests/Planning/PlanningMergeOrchestratorTests.cs @@ -47,6 +47,7 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable private readonly List _dbs = new(); private readonly List _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(); diff --git a/tests/ClaudeDo.Worker.Tests/Planning/TreeMergeTests.cs b/tests/ClaudeDo.Worker.Tests/Planning/TreeMergeTests.cs index 16fa15f0..e47c2cfe 100644 --- a/tests/ClaudeDo.Worker.Tests/Planning/TreeMergeTests.cs +++ b/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(); diff --git a/tests/ClaudeDo.Worker.Tests/Runner/StandaloneChildrenRoutingTests.cs b/tests/ClaudeDo.Worker.Tests/Runner/StandaloneChildrenRoutingTests.cs index 52051def..2c536469 100644 --- a/tests/ClaudeDo.Worker.Tests/Runner/StandaloneChildrenRoutingTests.cs +++ b/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(); } diff --git a/tests/ClaudeDo.Worker.Tests/State/TaskStateServiceTests.cs b/tests/ClaudeDo.Worker.Tests/State/TaskStateServiceTests.cs index febfa831..da7886c9 100644 --- a/tests/ClaudeDo.Worker.Tests/State/TaskStateServiceTests.cs +++ b/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 _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, diff --git a/tests/ClaudeDo.Worker.Tests/SuggestImprovementTests.cs b/tests/ClaudeDo.Worker.Tests/SuggestImprovementTests.cs index c8e68541..f1c67afd 100644 --- a/tests/ClaudeDo.Worker.Tests/SuggestImprovementTests.cs +++ b/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(); } diff --git a/tests/ClaudeDo.Worker.Tests/UiVm/TasksIslandViewModelPlanningTests.cs b/tests/ClaudeDo.Worker.Tests/UiVm/TasksIslandViewModelPlanningTests.cs index de56ecf1..0d94b351 100644 --- a/tests/ClaudeDo.Worker.Tests/UiVm/TasksIslandViewModelPlanningTests.cs +++ b/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(); diff --git a/tests/ClaudeDo.Worker.Tests/Usage/RunningTaskProbeTests.cs b/tests/ClaudeDo.Worker.Tests/Usage/RunningTaskProbeTests.cs index 3eeedecb..85aa9e4b 100644 --- a/tests/ClaudeDo.Worker.Tests/Usage/RunningTaskProbeTests.cs +++ b/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, }); diff --git a/tests/ClaudeDo.Worker.Tests/WaitingForChildrenLifecycleTests.cs b/tests/ClaudeDo.Worker.Tests/WaitingForChildrenLifecycleTests.cs index ed4d455d..fb8f1ed5 100644 --- a/tests/ClaudeDo.Worker.Tests/WaitingForChildrenLifecycleTests.cs +++ b/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(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,