feat(claude-do): depends_on als Menge statt Einzelfeld

Ein Task kann jetzt auf beliebig viele Vorgaenger warten. Die Einzelspalte tasks.depends_on_task_id wird durch die Beziehungstabelle task_dependencies ersetzt (Composite-PK, beide FKs ON DELETE CASCADE -- das reproduziert das alte ON DELETE SET NULL: geloeschter Vorgaenger = Kante weg = Task wieder pickbar). BlockedByTaskId bleibt unberuehrt. - Migration AddTaskDependencies kopiert jede bestehende depends_on_task_id verlustfrei in die Tabelle, bevor die Spalte fallengelassen wird - QueuePicker gatet per doppelt negiertem NOT EXISTS: kein Task mit 0 Kanten wird blockiert, alle Kanten muessen done sein, eine Kante auf einen verschwundenen Task blockiert weiter - SetDependsOnAsync ersetzt die ganze Menge; Zykluspruefung ist jetzt eine BFS ueber den Graphen, faengt also auch A->B->C->A - blockedReason nennt alle offenen Vorgaenger (External/TaskBlocking, von ExternalMcpService und TaskWaitMcpTools gemeinsam genutzt) - add_task/update_task nehmen dependsOnTaskIds; die alte Skalarform bleibt als Ein-Element-Menge inkl. ""-Clear-Sentinel gueltig - UI: Fan-in-Zeile bleibt flach und listet alle Vorgaenger im After-Label, die lineare Kette rendert unveraendert
2026-09-02 15:08:05 +02:00
parent 84d955dfc7
commit c25732cff8
31 changed files with 1893 additions and 206 deletions
@@ -4,9 +4,10 @@ Shared data layer: models, repositories, SQLite infrastructure, and git operatio

 ## Models

- **TaskEntity** — Id, ListId, Title, Description, Status, PlanningPhase, BlockedByTaskId (FK to predecessor in a chain), DependsOnTaskId (FK to a user/MCP-declared predecessor, distinct from BlockedByTaskId), ScheduledFor, Result, ReviewFeedback, LogPath, timestamps, CommitType, Model / SystemPrompt / AgentPath / MaxTurns / PermissionMode (nullable overrides), IsStarred, IsMyDay, IsManual, Notes, ParentTaskId, PlanningSessionId / PlanningSessionToken / PlanningFinalizedAt, CreatedBy, HandlerBaseCommit / HandlerHeadCommit, InteractiveSessionId, TicketRef, Number (global immutable human-readable alias).
+- **TaskEntity** — Id, ListId, Title, Description, Status, PlanningPhase, BlockedByTaskId (FK to predecessor in a chain), Dependencies (n user/MCP-declared predecessors via `task_dependencies`, distinct from BlockedByTaskId), ScheduledFor, Result, ReviewFeedback, LogPath, timestamps, CommitType, Model / SystemPrompt / AgentPath / MaxTurns / PermissionMode (nullable overrides), IsStarred, IsMyDay, IsManual, Notes, ParentTaskId, PlanningSessionId / PlanningSessionToken / PlanningFinalizedAt, CreatedBy, HandlerBaseCommit / HandlerHeadCommit, InteractiveSessionId, TicketRef, Number (global immutable human-readable alias).
  - `TicketRef` (`ticket_ref`, nullable string) — link to an external ticket, format `<provider>:<id>` (currently always `bandel:<ticketId>`). Set by the ticket import, otherwise null. → `ClaudeDo.Worker/CLAUDE.md` Tickets section.
-  - Status / PlanningPhase / BlockedByTaskId / DependsOnTaskId semantics + allowed transitions: `ClaudeDo.Worker/CLAUDE.md` → Status Model.
+  - Status / PlanningPhase / BlockedByTaskId / dependency-set semantics + allowed transitions: `ClaudeDo.Worker/CLAUDE.md` → Status Model.
+  - `Dependencies` (`ICollection<TaskDependencyEntity>`) + the `[NotMapped] DependsOnTaskIds` id projection. **Only populated where the query `Include`s it** — `TaskRepository.GetByIdAsync`/`GetByNumberAsync`/`GetByListIdAsync` do, and so do the `TasksIslandViewModel` row-hydration queries. The queue gate itself is raw SQL in `QueuePicker` and never reads the nav, so a forgotten Include misreports the UI/MCP `blocked` flag but can never let a blocked task run. ⚠️ `TaskRepository.UpdateAsync` marks **only the root entity** Modified (`Entry().State`, not `Update()`) — `Update()` marks the loaded graph, and an all-key `task_dependencies` row has nothing to SET.
  - `HandlerBaseCommit`/`HandlerHeadCommit` = the review range for a **worktree-less "list handler" host task** ("Let Claude handle it"), which commits straight into the list's working dir instead of a per-task worktree. Everything that reads a task's diff falls back to this pair whenever `Worktree` is null → [conpty-sessions](../../docs/explore-notes/conpty-sessions.md).
  - `InteractiveSessionId` = the claude session id an embedded ConPTY interactive task session runs under, persisted by `InteractiveLaunchSpecService` before launch so a closed/aborted session can be resumed → [conpty-sessions](../../docs/explore-notes/conpty-sessions.md).
  - `Number` (INTEGER NOT NULL, unique index `idx_tasks_number`) — a global, monotonically increasing display alias for tasks. **Never reused**: deleting a task leaves a gap in numbering, ensuring that a task number that appears in a log or report always points to the same task (if it exists). Allocated by `TaskNumberAllocator.AddWithNumberAsync` on every insert via a persistent counter (`app_settings.next_task_number`). **Why not `MAX(number) + 1`:** deleting the highest-numbered task would free its number for reuse, breaking the immutability guarantee. The allocator uses an `UPDATE…RETURNING` statement to claim numbers atomically, retrying up to 5 times if a uniqueness collision occurs (the counter advances on each attempt, so retries always allocate fresh numbers). The one-time backfill for pre-existing rows lived in the `AddTaskNumbers` migration, squashed away 2026-08-26.
@@ -20,6 +21,7 @@ Shared data layer: models, repositories, SQLite infrastructure, and git operatio
 - **DailyNoteEntity** — Id, Date (DateOnly), Text, SortOrder, CreatedAt → `daily_notes`
 - **WeekReportEntity** — Id, StartDate/EndDate (DateOnly), Markdown, GeneratedAt → `week_reports`, unique index on (start_date, end_date)
 - **TaskAttachmentEntity** — Id, TaskId (FK, ON DELETE CASCADE), FileName, ByteSize, CreatedAt → `task_attachments`
+- **TaskDependencyEntity** — one declared "run after" edge: TaskId + DependsOnTaskId, composite PK, table `task_dependencies`. Both FKs are `ON DELETE CASCADE`, which is what the old single `depends_on_task_id` column got from `ON DELETE SET NULL`: deleting a predecessor drops the edge so the dependent becomes pickable instead of blocked on a task that's gone. Written **only** by `TaskStateService.SetDependsOnAsync`.
 - **SubtaskEntity**, **AgentInfo** — subtasks / record for scanned agent files

 ### AppSettingsEntity
@@ -103,6 +105,7 @@ Tables (one per line so parallel migrations don't collide on the same line):
 - `daily_notes`
 - `week_reports`
 - `task_attachments`
+- `task_dependencies`

 Managed by EF Core migrations in `Migrations/`. **The 40 incremental migrations were squashed into
 a single `20260826094154_InitialCreate` on 2026-08-26** — the schema history is git history now,
@@ -112,8 +115,9 @@ not a migration chain. Consequences:
  (pre-EF databases without a history, and databases whose history still lists the old chain ending
  at `20260825063230_AddPrimeActionKind`). A database that stopped *mid*-chain can no longer be
  upgraded and throws with a reinstall message instead of being stamped onto a schema it lacks.
-  Covered by `MigrationBaselineTests` — the only test that runs a real `Migrate()` (every other
-  Data.Tests fixture uses `EnsureCreated`, which skips migrations entirely). Its fixture builds the
+  Covered by `MigrationBaselineTests` — one of only two tests that run a real `Migrate()`
+  (`TaskDependencyMigrationTests` is the other; every other Data.Tests fixture uses
+  `EnsureCreated`, which skips migrations entirely). Its fixture builds the
  legacy database by migrating **to** `InitialCreate` and seeding rows with raw SQL: `EnsureCreated`
  would build *today's* schema, so every post-squash migration would then re-add an existing column
  ("duplicate column name"). Assert "nothing pending", never "InitialCreate is the only history row".
@@ -122,10 +126,12 @@ not a migration chain. Consequences:
  Release` — `Data` is its own startup project (it holds the `Design` package and a design-time
  factory), and `--configuration Release` is needed because a running Worker locks `Debug`.

-`tasks` holds `status`, `planning_phase` (default `none`),
-`blocked_by_task_id` (FK to `tasks.id`, `ON DELETE SET NULL`), and `depends_on_task_id` (same FK
-shape, but a separate column — see Worker/CLAUDE.md → Status Model for why it isn't unified with
-`blocked_by_task_id`).
+`tasks` holds `status`, `planning_phase` (default `none`) and `blocked_by_task_id` (FK to
+`tasks.id`, `ON DELETE SET NULL`). The user/MCP-declared predecessors live in `task_dependencies`
+instead — a **set**, so a task can wait on n of them; see Worker/CLAUDE.md → Status Model for why
+it isn't unified with `blocked_by_task_id`. `AddTaskDependencies` (2026-09-02) migrated the former
+single `tasks.depends_on_task_id` column into that table (each value became a one-element set) and
+dropped it; the `Down` direction is inherently lossy for more than one edge.

 ## Conventions

@@ -41,6 +41,7 @@ public class ClaudeDoDbContext : DbContext
        => optionsBuilder.AddInterceptors(SqliteForeignKeyInterceptor.Instance);

    public DbSet<TaskEntity> Tasks => Set<TaskEntity>();
+    public DbSet<TaskDependencyEntity> TaskDependencies => Set<TaskDependencyEntity>();
    public DbSet<ListEntity> Lists => Set<ListEntity>();
    public DbSet<ListConfigEntity> ListConfigs => Set<ListConfigEntity>();
    public DbSet<WorktreeEntity> Worktrees => Set<WorktreeEntity>();
@@ -0,0 +1,32 @@
+using ClaudeDo.Data.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ClaudeDo.Data.Configuration;
+
+public class TaskDependencyEntityConfiguration : IEntityTypeConfiguration<TaskDependencyEntity>
+{
+    public void Configure(EntityTypeBuilder<TaskDependencyEntity> builder)
+    {
+        builder.ToTable("task_dependencies");
+
+        builder.HasKey(d => new { d.TaskId, d.DependsOnTaskId });
+        builder.Property(d => d.TaskId).HasColumnName("task_id");
+        builder.Property(d => d.DependsOnTaskId).HasColumnName("depends_on_task_id");
+
+        // Cascade on both sides reproduces what the old single depends_on_task_id column got from
+        // ON DELETE SET NULL: deleting the predecessor drops the edge, so the dependent becomes
+        // pickable rather than blocked forever on a task that no longer exists.
+        builder.HasOne<TaskEntity>()
+            .WithMany(t => t.Dependencies)
+            .HasForeignKey(d => d.TaskId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasOne<TaskEntity>()
+            .WithMany()
+            .HasForeignKey(d => d.DependsOnTaskId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasIndex(d => d.DependsOnTaskId).HasDatabaseName("idx_task_dependencies_depends_on");
+    }
+}
@@ -75,7 +75,6 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
        builder.Property(t => t.PlanningPhase).HasColumnName("planning_phase").IsRequired()
            .HasConversion(PhaseConverter).HasDefaultValue(PlanningPhase.None);
        builder.Property(t => t.BlockedByTaskId).HasColumnName("blocked_by_task_id");
-        builder.Property(t => t.DependsOnTaskId).HasColumnName("depends_on_task_id");
        builder.Property(t => t.ScheduledFor).HasColumnName("scheduled_for");
        builder.Property(t => t.Result).HasColumnName("result");
        builder.Property(t => t.ReviewFeedback).HasColumnName("review_feedback");
@@ -124,12 +123,8 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
            .HasForeignKey(t => t.BlockedByTaskId)
            .OnDelete(DeleteBehavior.SetNull);

-        // DependsOn: user/MCP-declared predecessor. SetNull on delete so the dependent becomes
-        // pickable rather than blocked forever on a task that no longer exists.
-        builder.HasOne<TaskEntity>()
-            .WithMany()
-            .HasForeignKey(t => t.DependsOnTaskId)
-            .OnDelete(DeleteBehavior.SetNull);
+        // DependsOn edges live in task_dependencies (a task can declare n predecessors) —
+        // configured in TaskDependencyEntityConfiguration, which also owns the Dependencies nav.

        builder.HasOne(t => t.List)
            .WithMany(l => l.Tasks)
@@ -146,6 +141,5 @@ public class TaskEntityConfiguration : IEntityTypeConfiguration<TaskEntity>
        builder.HasIndex(t => new { t.ListId, t.SortOrder }).HasDatabaseName("idx_tasks_list_sort");
        builder.HasIndex(t => t.ParentTaskId).HasDatabaseName("idx_tasks_parent_task_id");
        builder.HasIndex(t => t.BlockedByTaskId).HasDatabaseName("idx_tasks_blocked_by");
-        builder.HasIndex(t => t.DependsOnTaskId).HasDatabaseName("idx_tasks_depends_on");
    }
 }
@@ -0,0 +1,104 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <summary>
+    /// Turns the single <c>tasks.depends_on_task_id</c> column into a set: one row per declared
+    /// "run after" edge in <c>task_dependencies</c>. Hand-edited after scaffolding so the data copy
+    /// sits between CreateTable and DropColumn — the scaffolded order dropped the column first and
+    /// would have discarded every existing link.
+    /// </summary>
+    public partial class AddTaskDependencies : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "task_dependencies",
+                columns: table => new
+                {
+                    task_id = table.Column<string>(type: "TEXT", nullable: false),
+                    depends_on_task_id = table.Column<string>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_task_dependencies", x => new { x.task_id, x.depends_on_task_id });
+                    table.ForeignKey(
+                        name: "FK_task_dependencies_tasks_depends_on_task_id",
+                        column: x => x.depends_on_task_id,
+                        principalTable: "tasks",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_task_dependencies_tasks_task_id",
+                        column: x => x.task_id,
+                        principalTable: "tasks",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "idx_task_dependencies_depends_on",
+                table: "task_dependencies",
+                column: "depends_on_task_id");
+
+            // Every existing link becomes a one-element set. The old FK was ON DELETE SET NULL, so
+            // a surviving value always points at an existing task and can't violate the new FK.
+            migrationBuilder.Sql("""
+                INSERT INTO task_dependencies (task_id, depends_on_task_id)
+                SELECT id, depends_on_task_id FROM tasks WHERE depends_on_task_id IS NOT NULL
+                """);
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_tasks_tasks_depends_on_task_id",
+                table: "tasks");
+
+            migrationBuilder.DropIndex(
+                name: "idx_tasks_depends_on",
+                table: "tasks");
+
+            migrationBuilder.DropColumn(
+                name: "depends_on_task_id",
+                table: "tasks");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "depends_on_task_id",
+                table: "tasks",
+                type: "TEXT",
+                nullable: true);
+
+            // Inherently lossy: a task with several predecessors keeps only one. There is no
+            // single-column shape that could hold the rest.
+            migrationBuilder.Sql("""
+                UPDATE tasks SET depends_on_task_id = (
+                    SELECT td.depends_on_task_id FROM task_dependencies td
+                    WHERE td.task_id = tasks.id
+                    ORDER BY td.depends_on_task_id
+                    LIMIT 1
+                )
+                """);
+
+            migrationBuilder.DropTable(
+                name: "task_dependencies");
+
+            migrationBuilder.CreateIndex(
+                name: "idx_tasks_depends_on",
+                table: "tasks",
+                column: "depends_on_task_id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_tasks_tasks_depends_on_task_id",
+                table: "tasks",
+                column: "depends_on_task_id",
+                principalTable: "tasks",
+                principalColumn: "id",
+                onDelete: ReferentialAction.SetNull);
+        }
+    }
+}
@@ -475,6 +475,24 @@ namespace ClaudeDo.Data.Migrations
                    b.ToTable("task_attachments", (string)null);
                });

+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskDependencyEntity", b =>
+                {
+                    b.Property<string>("TaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("DependsOnTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("depends_on_task_id");
+
+                    b.HasKey("TaskId", "DependsOnTaskId");
+
+                    b.HasIndex("DependsOnTaskId")
+                        .HasDatabaseName("idx_task_dependencies_depends_on");
+
+                    b.ToTable("task_dependencies", (string)null);
+                });
+
            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
                {
                    b.Property<string>("Id")
@@ -504,10 +522,6 @@ namespace ClaudeDo.Data.Migrations
                        .HasColumnType("TEXT")
                        .HasColumnName("created_by");

-                    b.Property<string>("DependsOnTaskId")
-                        .HasColumnType("TEXT")
-                        .HasColumnName("depends_on_task_id");
-
                    b.Property<string>("Description")
                        .HasColumnType("TEXT")
                        .HasColumnName("description");
@@ -675,9 +689,6 @@ namespace ClaudeDo.Data.Migrations
                    b.HasIndex("BlockedByTaskId")
                        .HasDatabaseName("idx_tasks_blocked_by");

-                    b.HasIndex("DependsOnTaskId")
-                        .HasDatabaseName("idx_tasks_depends_on");
-
                    b.HasIndex("ListId")
                        .HasDatabaseName("idx_tasks_list_id");

@@ -912,6 +923,21 @@ namespace ClaudeDo.Data.Migrations
                    b.Navigation("Task");
                });

+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskDependencyEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
+                        .WithMany()
+                        .HasForeignKey("DependsOnTaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
+                        .WithMany("Dependencies")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
                {
                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
@@ -919,11 +945,6 @@ namespace ClaudeDo.Data.Migrations
                        .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")
@@ -973,6 +994,8 @@ namespace ClaudeDo.Data.Migrations
                {
                    b.Navigation("Children");

+                    b.Navigation("Dependencies");
+
                    b.Navigation("Runs");

                    b.Navigation("Subtasks");
@@ -0,0 +1,13 @@
+namespace ClaudeDo.Data.Models;
+
+/// <summary>
+/// One declared "task must run after task" edge. A task can carry n of them; the queue picker
+/// claims it only once every predecessor reached <see cref="TaskStatus.Done"/>.
+/// Deliberately separate from <see cref="TaskEntity.BlockedByTaskId"/>, the planning chain's own
+/// internal single link — see ClaudeDo.Worker/CLAUDE.md → Status Model.
+/// </summary>
+public sealed class TaskDependencyEntity
+{
+    public required string TaskId { get; init; }
+    public required string DependsOnTaskId { get; init; }
+}
@@ -1,3 +1,5 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
 namespace ClaudeDo.Data.Models;

 public enum TaskStatus
@@ -33,12 +35,17 @@ public sealed class TaskEntity
    public PlanningPhase PlanningPhase { get; set; } = PlanningPhase.None;
    public string? BlockedByTaskId { get; set; }

-    // A user/MCP-declared predecessor, distinct from BlockedByTaskId (the planning chain's own
-    // internal link): the picker also skips a Queued task while this is set and the referenced
-    // task's Status isn't Done. Unlike the chain, a Failed/Cancelled dependency does NOT cascade
-    // or auto-resolve -- the dependent just stays blocked and reports why (see TaskStateService.
-    // SetDependsOnAsync and QueuePicker).
-    public string? DependsOnTaskId { get; set; }
+    // User/MCP-declared predecessors, distinct from BlockedByTaskId (the planning chain's own
+    // internal link): the picker skips a Queued task until EVERY predecessor reached Done.
+    // Unlike the chain, a Failed/Cancelled dependency does NOT cascade or auto-resolve -- the
+    // dependent just stays blocked and reports why (see TaskStateService.SetDependsOnAsync and
+    // QueuePicker). Only loaded where a read path Includes it; the picker gates in raw SQL and
+    // never relies on this collection.
+    public ICollection<TaskDependencyEntity> Dependencies { get; set; } = new List<TaskDependencyEntity>();
+
+    [NotMapped]
+    public IReadOnlyList<string> DependsOnTaskIds =>
+        Dependencies.Select(d => d.DependsOnTaskId).ToList();
    public DateTime? ScheduledFor { get; set; }
    public string? Result { get; set; }
    public string? ReviewFeedback { get; set; }
@@ -34,7 +34,10 @@ public sealed class TaskRepository
        var tracked = _context.Tasks.Local.FirstOrDefault(t => t.Id == entity.Id);
        if (tracked is not null && !ReferenceEquals(tracked, entity))
            _context.Entry(tracked).State = Microsoft.EntityFrameworkCore.EntityState.Detached;
-        _context.Tasks.Update(entity);
+        // Entry().State instead of Update(): Update marks the whole loaded graph Modified, which
+        // for the all-key task_dependencies rows means an UPDATE with nothing to set. Dependency
+        // edges are written only by TaskStateService.SetDependsOnAsync.
+        _context.Entry(entity).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
        await _context.SaveChangesAsync(ct);
    }

@@ -46,17 +49,20 @@ public sealed class TaskRepository

    public async Task<TaskEntity?> GetByIdAsync(string taskId, CancellationToken ct = default)
    {
-        return await _context.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Id == taskId, ct);
+        return await _context.Tasks.AsNoTracking().Include(t => t.Dependencies)
+            .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);
+        return await _context.Tasks.AsNoTracking().Include(t => t.Dependencies)
+            .FirstOrDefaultAsync(t => t.Number == number, ct);
    }

    public async Task<List<TaskEntity>> GetByListIdAsync(string listId, CancellationToken ct = default)
    {
        return await _context.Tasks
+            .Include(t => t.Dependencies)
            .Where(t => t.ListId == listId)
            .OrderBy(t => t.SortOrder).ThenBy(t => t.CreatedAt)
            .ToListAsync(ct);