Merge branch 'main' into feat/poweruse-list-handler

Kollision mit #264 (Handoff-Budget im Brief sichtbar machen): beide Seiten haben
HandoffRoundTracker, HandoffMcpTools und InteractiveLaunchSpecService angefasst.

Der Konflikt war inhaltlich, nicht nur textuell. #264 liest den Cap an zwei
Stellen aus der Konstante (GetStatus und das roundInfo-Rendering), waehrend
dieser Branch ihn zum Parameter aus app_settings gemacht hat. Ein reiner
Text-Merge haette kompiliert und trotzdem gelogen: Register haette den
konfigurierten Cap durchgesetzt, waehrend der Brief dem Modell weiter "2 Runden
uebrig" gemeldet haette, obwohl es 39 hat.

Aufgeloest so, dass der Cap eine einzige Quelle hat:
- GetStatus(taskId, maxHandoffs) nimmt den Cap als Parameter, mit demselben
  Clamp wie Register. Die Rechnerei liegt damit an einer Stelle.
- GetHandoffStatus liest das Setting und gibt es weiter.
- Das roundInfo-Rendering benutzt GetStatus statt eigener Arithmetik.

Zwei Tests nageln genau diesen Drift fest, damit er beim naechsten Merge nicht
unbemerkt zurueckkommt: einer auf GetHandoffStatus, einer auf den Brief.

MaxHandoffs -> DefaultMaxHandoffs in #264s vier Test-Referenzen; die laufen alle
mit Default-Settings, die Semantik bleibt.

tests/ClaudeDo.Data.Tests/ForeignKeyTests.cs

@@ -70,17 +70,23 @@ public sealed class ForeignKeyTests : IDisposable
     }
 
     [Fact]
-    public async Task DependsOnTaskId_is_nulled_when_predecessor_deleted_on_fresh_context()
+    public async Task Dependency_edge_is_dropped_when_predecessor_deleted_on_fresh_context()
     {
+        // The cascade on task_dependencies is what the old single column got from ON DELETE
+        // SET NULL: the dependent must come out pickable, not blocked on a task that's gone.
         var listId = Guid.NewGuid().ToString();
         var predecessorId = Guid.NewGuid().ToString();
+        var otherId = Guid.NewGuid().ToString();
         var dependentId = Guid.NewGuid().ToString();
 
         await using (var ctx = Open())
         {
             ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", 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 });
+            ctx.Tasks.Add(new TaskEntity { Id = otherId, Number = 3, ListId = listId, Title = "Other", Status = TaskStatus.Idle, CreatedAt = DateTime.UtcNow });
+            ctx.Tasks.Add(new TaskEntity { Id = dependentId, Number = 2, ListId = listId, Title = "Dependent", Status = TaskStatus.Idle, CreatedAt = DateTime.UtcNow });
+            ctx.TaskDependencies.Add(new TaskDependencyEntity { TaskId = dependentId, DependsOnTaskId = predecessorId });
+            ctx.TaskDependencies.Add(new TaskDependencyEntity { TaskId = dependentId, DependsOnTaskId = otherId });
             await ctx.SaveChangesAsync();
         }
 
@@ -93,8 +99,9 @@ public sealed class ForeignKeyTests : IDisposable
 
         await using (var ctx = Open())
         {
-            var dependent = await ctx.Tasks.AsNoTracking().FirstAsync(t => t.Id == dependentId);
-            Assert.Null(dependent.DependsOnTaskId);
+            var dependent = await ctx.Tasks.AsNoTracking().Include(t => t.Dependencies)
+                .FirstAsync(t => t.Id == dependentId);
+            Assert.Equal([otherId], dependent.DependsOnTaskIds);
         }
     }
 

tests/ClaudeDo.Data.Tests/TaskDependencyMigrationTests.cs

@@ -0,0 +1,100 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace ClaudeDo.Data.Tests;
+
+/// <summary>
+/// AddTaskDependencies moves every <c>tasks.depends_on_task_id</c> value into the new
+/// <c>task_dependencies</c> table and then drops the column. Runs a real <c>Migrate()</c> — the
+/// EnsureCreated fixtures every other Data.Tests file uses skip migrations entirely and would
+/// never notice a data copy that silently dropped rows (see
+/// <c>.claudedo/traps/ef-migration-parallel-designer-collision.md</c>).
+/// </summary>
+public sealed class TaskDependencyMigrationTests : IDisposable
+{
+    private const string PreviousMigrationId = "20260902102003_AddExpectsNoDiff";
+
+    private readonly string _dbPath;
+    private readonly DbContextOptions<ClaudeDoDbContext> _options;
+
+    public TaskDependencyMigrationTests()
+    {
+        _dbPath = Path.Combine(Path.GetTempPath(), $"claudedo_deps_{Guid.NewGuid():N}.db");
+        _options = new DbContextOptionsBuilder<ClaudeDoDbContext>()
+            .UseSqlite($"Data Source={_dbPath}")
+            .Options;
+    }
+
+    public void Dispose()
+    {
+        Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
+        foreach (var suffix in new[] { "", "-wal", "-shm" })
+            try { File.Delete(_dbPath + suffix); } catch { }
+    }
+
+    [Fact]
+    public void Existing_depends_on_links_survive_as_one_element_sets()
+    {
+        SeedLegacyDatabase();
+
+        using (var ctx = new ClaudeDoDbContext(_options))
+            ctx.Database.Migrate();
+
+        using var check = new ClaudeDoDbContext(_options);
+        Assert.Empty(check.Database.GetPendingMigrations());
+
+        var edges = check.TaskDependencies.AsNoTracking()
+            .OrderBy(d => d.TaskId)
+            .Select(d => new { d.TaskId, d.DependsOnTaskId })
+            .ToList();
+        Assert.Equal(2, edges.Count);
+        Assert.Equal(("t2", "t1"), (edges[0].TaskId, edges[0].DependsOnTaskId));
+        Assert.Equal(("t3", "t2"), (edges[1].TaskId, edges[1].DependsOnTaskId));
+
+        // The tasks themselves are untouched, and the independent one gained no edge.
+        Assert.Equal(4, check.Tasks.Count());
+        Assert.DoesNotContain("t4", edges.Select(e => e.TaskId));
+    }
+
+    [Fact]
+    public void Column_is_gone_after_the_migration()
+    {
+        SeedLegacyDatabase();
+
+        using var ctx = new ClaudeDoDbContext(_options);
+        ctx.Database.Migrate();
+
+        var conn = ctx.Database.GetDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = "SELECT COUNT(*) FROM pragma_table_info('tasks') WHERE name = 'depends_on_task_id'";
+        Assert.Equal(0L, Convert.ToInt64(cmd.ExecuteScalar()));
+        conn.Close();
+    }
+
+    // Migrates *to* the migration before this one, then seeds via raw SQL: EnsureCreated would
+    // build today's schema (no depends_on_task_id column at all), so there'd be nothing to copy.
+    private void SeedLegacyDatabase()
+    {
+        using var seed = new ClaudeDoDbContext(_options);
+        seed.Database.GetService<IMigrator>().Migrate(PreviousMigrationId);
+
+        var conn = seed.Database.GetDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = """
+            INSERT INTO lists (id, name, created_at) VALUES ('l1', 'List', '2026-01-01 00:00:00');
+            INSERT INTO tasks (id, number, list_id, title, status, created_at)
+            VALUES ('t1', 1, 'l1', 'first', 'done', '2026-01-01 00:00:00');
+            INSERT INTO tasks (id, number, list_id, title, status, created_at, depends_on_task_id)
+            VALUES ('t2', 2, 'l1', 'second', 'queued', '2026-01-01 00:00:00', 't1');
+            INSERT INTO tasks (id, number, list_id, title, status, created_at, depends_on_task_id)
+            VALUES ('t3', 3, 'l1', 'third', 'queued', '2026-01-01 00:00:00', 't2');
+            INSERT INTO tasks (id, number, list_id, title, status, created_at)
+            VALUES ('t4', 4, 'l1', 'independent', 'idle', '2026-01-01 00:00:00');
+            """;
+        cmd.ExecuteNonQuery();
+        conn.Close();
+    }
+}

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

@@ -74,10 +74,15 @@ public class TasksIslandChainTests : IDisposable
                 Title = t.Id,
                 CreatedAt = DateTime.UtcNow,
                 Status = t.Status,
-                DependsOnTaskId = t.DependsOnTaskId,
                 ParentTaskId = t.ParentTaskId,
                 SortOrder = t.SortOrder,
             });
+            if (t.DependsOnTaskId is not null)
+                db.TaskDependencies.Add(new TaskDependencyEntity
+                {
+                    TaskId = t.Id,
+                    DependsOnTaskId = t.DependsOnTaskId,
+                });
         }
         await db.SaveChangesAsync();
         return numbers;
@@ -225,8 +230,7 @@ public class TasksIslandChainTests : IDisposable
 
         await using (var db = NewContext())
         {
-            var entity = await db.Tasks.FirstAsync(t => t.Id == "later");
-            entity.DependsOnTaskId = "head";
+            db.TaskDependencies.Add(new TaskDependencyEntity { TaskId = "later", DependsOnTaskId = "head" });
             await db.SaveChangesAsync();
         }
 
@@ -236,4 +240,30 @@ public class TasksIslandChainTests : IDisposable
         Assert.True(updated.ShowAsChainMember);
         Assert.Equal(1, updated.ChainStep);
     }
+
+    [Fact]
+    public async Task FanIn_RendersFlatWithEveryPredecessorInTheLabel()
+    {
+        // Two independent predecessors is not a chain -- the rail can only draw one line, so the
+        // row stays flat and the label has to name both, or it misreports what it waits for.
+        var numbers = await SeedAsync(
+            ("a", TaskStatus.Idle, null, null, 0),
+            ("b", TaskStatus.Idle, null, null, 1),
+            ("wiring", TaskStatus.Idle, "a", null, 2));
+        await using (var db = NewContext())
+        {
+            db.TaskDependencies.Add(new TaskDependencyEntity { TaskId = "wiring", DependsOnTaskId = "b" });
+            await db.SaveChangesAsync();
+        }
+
+        var vm = BuildViewModel();
+        await LoadAndWaitAsync(vm, UserList("list1", "Default"));
+
+        var wiring = vm.Items.First(r => r.Id == "wiring");
+        Assert.False(wiring.ShowAsChainMember);
+        Assert.Null(wiring.ChainStep);
+        Assert.NotNull(wiring.ChainAfterLabel);
+        Assert.Contains(numbers["a"].ToString(), wiring.ChainAfterLabel);
+        Assert.Contains(numbers["b"].ToString(), wiring.ChainAfterLabel);
+    }
 }

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

@@ -73,9 +73,14 @@ public class TasksIslandClassifyItemsTests : IDisposable
                 Title = t.Id,
                 CreatedAt = DateTime.UtcNow,
                 Status = t.Status,
-                DependsOnTaskId = t.DependsOnTaskId,
                 SortOrder = t.SortOrder,
             });
+            if (t.DependsOnTaskId is not null)
+                db.TaskDependencies.Add(new TaskDependencyEntity
+                {
+                    TaskId = t.Id,
+                    DependsOnTaskId = t.DependsOnTaskId,
+                });
         }
         await db.SaveChangesAsync();
     }

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

@@ -266,8 +266,7 @@ public class TasksIslandReconcileTickTests : IDisposable
 
         await using (var db = NewContext())
         {
-            var t = await db.Tasks.FirstAsync(x => x.Id == "DEP");
-            t.DependsOnTaskId = "HEAD";
+            db.TaskDependencies.Add(new TaskDependencyEntity { TaskId = "DEP", DependsOnTaskId = "HEAD" });
             await db.SaveChangesAsync();
         }
 

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

@@ -408,8 +408,7 @@ public sealed class BatchMcpToolsTests : IDisposable
         var listId = await SeedListAsync();
         var predecessor = await SeedTaskAsync(listId, "predecessor", TaskStatus.Idle);
         var task = await SeedTaskAsync(listId, "blocked", TaskStatus.Queued);
-        task.DependsOnTaskId = predecessor.Id;
-        await _tasks.UpdateAsync(task);
+        await _ctx.SeedDependsOnAsync(task.Id, predecessor.Id);
         var sut = BuildSut();
 
         var results = await sut.BatchGetTasks(new[] { task.Id }, cancellationToken: CancellationToken.None);

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

@@ -118,6 +118,10 @@ public sealed class ExternalMcpServiceTests : IDisposable
         return id;
     }
 
+    // The dependency set has no defined order, and the ids are random GUIDs -- sort both sides.
+    private static List<string> Sorted(params string[] ids) => ids.OrderBy(x => x).ToList();
+    private static List<string> Sorted(IEnumerable<string> ids) => ids.OrderBy(x => x).ToList();
+
     private async Task<TaskEntity> SeedTaskAsync(
         string listId, string title = "t", TaskStatus status = TaskStatus.Idle, string? parentId = null)
     {
@@ -444,8 +448,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
         var listId = await SeedListAsync();
         var predecessor = await SeedTaskAsync(listId, status: TaskStatus.Idle);
         var task = await SeedTaskAsync(listId, status: TaskStatus.Queued);
-        task.DependsOnTaskId = predecessor.Id;
-        await _tasks.UpdateAsync(task, CancellationToken.None);
+        await _ctx.SeedDependsOnAsync(task.Id, predecessor.Id);
         var sut = BuildSut(CreateQueue());
 
         var dto = await sut.GetTask(task.Id, CancellationToken.None);
@@ -460,8 +463,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
         var listId = await SeedListAsync();
         var predecessor = await SeedTaskAsync(listId, status: TaskStatus.Done);
         var task = await SeedTaskAsync(listId, status: TaskStatus.Queued);
-        task.DependsOnTaskId = predecessor.Id;
-        await _tasks.UpdateAsync(task, CancellationToken.None);
+        await _ctx.SeedDependsOnAsync(task.Id, predecessor.Id);
         var sut = BuildSut(CreateQueue());
 
         var dto = await sut.GetTask(task.Id, CancellationToken.None);
@@ -478,8 +480,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
         var listId = await SeedListAsync();
         var predecessor = await SeedTaskAsync(listId, status: TaskStatus.Idle);
         var task = await SeedTaskAsync(listId, status: TaskStatus.Idle);
-        task.DependsOnTaskId = predecessor.Id;
-        await _tasks.UpdateAsync(task, CancellationToken.None);
+        await _ctx.SeedDependsOnAsync(task.Id, predecessor.Id);
         var sut = BuildSut(CreateQueue());
 
         var dto = await sut.GetTask(task.Id, CancellationToken.None);
@@ -493,8 +494,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
         var listId = await SeedListAsync();
         var predecessor = await SeedTaskAsync(listId, "predecessor", TaskStatus.Idle);
         var blocked = await SeedTaskAsync(listId, "blocked", TaskStatus.Queued);
-        blocked.DependsOnTaskId = predecessor.Id;
-        await _tasks.UpdateAsync(blocked, CancellationToken.None);
+        await _ctx.SeedDependsOnAsync(blocked.Id, predecessor.Id);
         var unblocked = await SeedTaskAsync(listId, "unblocked", TaskStatus.Queued);
         var sut = BuildSut(CreateQueue());
 
@@ -513,8 +513,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
         var listId = await SeedListAsync();
         var predecessor = await SeedTaskAsync(listId, "predecessor", TaskStatus.Idle);
         var blocked = await SeedTaskAsync(listId, "blocked", TaskStatus.Queued);
-        blocked.DependsOnTaskId = predecessor.Id;
-        await _tasks.UpdateAsync(blocked, CancellationToken.None);
+        await _ctx.SeedDependsOnAsync(blocked.Id, predecessor.Id);
         var sut = BuildSut(CreateQueue());
 
         var result = await sut.ListTasks(listId, includeDescription: true, cancellationToken: CancellationToken.None);
@@ -555,10 +554,10 @@ public sealed class ExternalMcpServiceTests : IDisposable
 
         var dto = await sut.UpdateTask(task.Id, dependsOnTaskId: predecessor.Id, cancellationToken: CancellationToken.None);
 
-        Assert.Equal(predecessor.Id, dto.DependsOnTaskId);
+        Assert.Equal([predecessor.Id], dto.DependsOnTaskIds);
         Assert.True(dto.Blocked);
         var loaded = await _tasks.GetByIdAsync(task.Id);
-        Assert.Equal(predecessor.Id, loaded!.DependsOnTaskId);
+        Assert.Equal([predecessor.Id], loaded!.DependsOnTaskIds);
     }
 
     [Fact]
@@ -572,7 +571,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
 
         var dto = await sut.UpdateTask(task.Id, dependsOnTaskId: "", cancellationToken: CancellationToken.None);
 
-        Assert.Null(dto.DependsOnTaskId);
+        Assert.Empty(dto.DependsOnTaskIds!);
         Assert.False(dto.Blocked);
     }
 
@@ -589,6 +588,75 @@ public sealed class ExternalMcpServiceTests : IDisposable
             sut.UpdateTask(a.Id, dependsOnTaskId: b.Id, cancellationToken: CancellationToken.None));
     }
 
+    [Fact]
+    public async Task UpdateTask_WithDependsOnTaskIds_SetsSeveralPredecessors()
+    {
+        var listId = await SeedListAsync();
+        var a = await SeedTaskAsync(listId, "a", TaskStatus.Idle);
+        var b = await SeedTaskAsync(listId, "b", TaskStatus.Idle);
+        var task = await SeedTaskAsync(listId, status: TaskStatus.Queued);
+        var sut = BuildSut(CreateQueue());
+
+        var dto = await sut.UpdateTask(
+            task.Id, dependsOnTaskIds: [a.Id, b.Id], cancellationToken: CancellationToken.None);
+
+        Assert.Equal(Sorted(a.Id, b.Id), Sorted(dto.DependsOnTaskIds!));
+        Assert.True(dto.Blocked);
+        // Naming only the first predecessor would send a caller off to unblock the wrong task.
+        Assert.Contains(a.Id, dto.BlockedReason);
+        Assert.Contains(b.Id, dto.BlockedReason);
+    }
+
+    [Fact]
+    public async Task UpdateTask_WithEmptyDependsOnTaskIds_ClearsTheWholeSet()
+    {
+        var listId = await SeedListAsync();
+        var a = await SeedTaskAsync(listId, "a", TaskStatus.Idle);
+        var b = await SeedTaskAsync(listId, "b", TaskStatus.Idle);
+        var task = await SeedTaskAsync(listId, status: TaskStatus.Queued);
+        var sut = BuildSut(CreateQueue());
+        await sut.UpdateTask(task.Id, dependsOnTaskIds: [a.Id, b.Id], cancellationToken: CancellationToken.None);
+
+        var dto = await sut.UpdateTask(task.Id, dependsOnTaskIds: [], cancellationToken: CancellationToken.None);
+
+        Assert.Empty(dto.DependsOnTaskIds!);
+        Assert.False(dto.Blocked);
+    }
+
+    [Fact]
+    public async Task UpdateTask_LegacyScalarDependsOnTaskId_StillReplacesTheWholeSet()
+    {
+        // Back-compat: existing callers and prompts only know the scalar form. It has to keep
+        // behaving as "this is the one predecessor", not append to whatever is already there.
+        var listId = await SeedListAsync();
+        var a = await SeedTaskAsync(listId, "a", TaskStatus.Idle);
+        var b = await SeedTaskAsync(listId, "b", TaskStatus.Idle);
+        var task = await SeedTaskAsync(listId, status: TaskStatus.Queued);
+        var sut = BuildSut(CreateQueue());
+        await sut.UpdateTask(task.Id, dependsOnTaskIds: [a.Id, b.Id], cancellationToken: CancellationToken.None);
+
+        var dto = await sut.UpdateTask(task.Id, dependsOnTaskId: a.Id, cancellationToken: CancellationToken.None);
+
+        Assert.Equal([a.Id], dto.DependsOnTaskIds);
+    }
+
+    [Fact]
+    public async Task UpdateTask_WithCyclicDependsOnTaskIds_Throws()
+    {
+        var listId = await SeedListAsync();
+        var a = await SeedTaskAsync(listId, "a", TaskStatus.Idle);
+        var b = await SeedTaskAsync(listId, "b", TaskStatus.Idle);
+        var c = await SeedTaskAsync(listId, "c", TaskStatus.Idle);
+        var innocent = await SeedTaskAsync(listId, "innocent", TaskStatus.Idle);
+        var sut = BuildSut(CreateQueue());
+        await sut.UpdateTask(b.Id, dependsOnTaskId: a.Id, cancellationToken: CancellationToken.None);
+        await sut.UpdateTask(c.Id, dependsOnTaskId: b.Id, cancellationToken: CancellationToken.None);
+
+        // a -> {innocent, c} closes a -> c -> b -> a over three edges.
+        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            sut.UpdateTask(a.Id, dependsOnTaskIds: [innocent.Id, c.Id], cancellationToken: CancellationToken.None));
+    }
+
     [Fact]
     public async Task ReviewTask_Approve_SetsDone()
     {
@@ -1488,11 +1556,29 @@ public sealed class ExternalMcpServiceTests : IDisposable
         var dto = await sut.AddTask(
             listId, "t", dependsOnTaskId: predecessor.Id, queueImmediately: true, cancellationToken: CancellationToken.None);
 
-        Assert.Equal(predecessor.Id, dto.Task.DependsOnTaskId);
+        Assert.Equal([predecessor.Id], dto.Task.DependsOnTaskIds);
         Assert.True(dto.Task.Blocked);
         Assert.Contains(predecessor.Id, dto.Task.BlockedReason);
         var loaded = await _tasks.GetByIdAsync(dto.Task.Id);
-        Assert.Equal(predecessor.Id, loaded!.DependsOnTaskId);
+        Assert.Equal([predecessor.Id], loaded!.DependsOnTaskIds);
+    }
+
+    [Fact]
+    public async Task AddTask_WithDependsOnTaskIds_PersistsEveryLink()
+    {
+        var listId = await SeedListAsync();
+        var a = await SeedTaskAsync(listId, "a", TaskStatus.Idle);
+        var b = await SeedTaskAsync(listId, "b", TaskStatus.Done);
+        var sut = NewService();
+
+        var dto = await sut.AddTask(
+            listId, "t", dependsOnTaskIds: [a.Id, b.Id], queueImmediately: true,
+            cancellationToken: CancellationToken.None);
+
+        Assert.Equal(Sorted(a.Id, b.Id), Sorted(dto.Task.DependsOnTaskIds!));
+        Assert.True(dto.Task.Blocked);
+        var loaded = await _tasks.GetByIdAsync(dto.Task.Id);
+        Assert.Equal(Sorted(a.Id, b.Id), Sorted(loaded!.DependsOnTaskIds));
     }
 
     [Fact]

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

@@ -106,7 +106,7 @@ public sealed class ExternalMcpToolSchemaTests
         "list_runs", "get_run", "get_task_log",
         "list_agents",
         "reset_failed_task", "submit_task_for_review",
-        "handoff_list_handler",
+        "handoff_list_handler", "get_handoff_status",
         "get_app_settings",
         "wait_for_task_change",
         "get_queue_state",

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

@@ -209,6 +209,63 @@ public sealed class HandoffMcpToolsTests : IDisposable
             secondSut.HandoffListHandler(handlerTask.Id, survivors, "wait", CancellationToken.None));
     }
 
+    [Theory]
+    [InlineData(1, 3)]
+    [InlineData(2, 2)]
+    [InlineData(4, 0)]
+    public void HandoffRoundTracker_GetState_ReportsCountAfterNRegistrations(int registrations, int expectedRemaining)
+    {
+        var tracker = new HandoffRoundTracker();
+        var taskId = Guid.NewGuid().ToString();
+
+        for (var i = 0; i < registrations; i++)
+            tracker.Register(taskId, "wait");
+
+        var (count, sealedState) = tracker.GetState(taskId);
+        Assert.Equal(registrations, count);
+        Assert.Equal(expectedRemaining, HandoffRoundTracker.DefaultMaxHandoffs - count);
+        Assert.False(sealedState);
+    }
+
+    [Fact]
+    public void HandoffRoundTracker_GetState_UnregisteredTask_ReturnsZero()
+    {
+        var tracker = new HandoffRoundTracker();
+        var (count, sealedState) = tracker.GetState(Guid.NewGuid().ToString());
+        Assert.Equal(0, count);
+        Assert.False(sealedState);
+    }
+
+    [Fact]
+    public void HandoffRoundTracker_Register_DoesNotMutateStateVisibleFromGetState_BeyondItsOwnCall()
+    {
+        var tracker = new HandoffRoundTracker();
+        var taskId = Guid.NewGuid().ToString();
+
+        tracker.Register(taskId, "wait");
+        var (beforeCount, _) = tracker.GetState(taskId);
+        Assert.Equal(1, beforeCount);
+
+        // GetState itself must be read-only -- calling it repeatedly must not advance the round.
+        tracker.GetState(taskId);
+        tracker.GetState(taskId);
+        var (afterCount, _) = tracker.GetState(taskId);
+        Assert.Equal(beforeCount, afterCount);
+    }
+
+    [Fact]
+    public void HandoffRoundTracker_RejectedHandoff_ErrorNamesTheNextAction()
+    {
+        var tracker = new HandoffRoundTracker();
+        var taskId = Guid.NewGuid().ToString();
+        tracker.Register(taskId, "merge_final");
+
+        var result = tracker.Register(taskId, "wait");
+
+        Assert.True(result.Rejected);
+        Assert.Contains("new handler run", result.Error, StringComparison.OrdinalIgnoreCase);
+    }
+
     [Fact]
     public async Task HandoffListHandler_RaisedCapSetting_AllowsMoreRoundsBeforeCoercing()
     {
@@ -258,6 +315,30 @@ public sealed class HandoffMcpToolsTests : IDisposable
         Assert.Equal("merge_final", second.NextPhase);
     }
 
+    /// GetHandoffStatus must report against the SAME cap HandoffListHandler enforces. Reading it
+    /// off the constant would understate a raised budget and make the tool lie about how much room
+    /// the chain has left.
+    [Fact]
+    public async Task GetHandoffStatus_RaisedCap_ReportsConfiguredRemaining()
+    {
+        await SetMaxHandoffsAsync(40);
+
+        var listId = await SeedListAsync();
+        var handlerTask = await SeedTaskAsync(listId);
+        var survivor = await SeedTaskAsync(listId, TaskStatus.WaitingForReview, title: "Survivor");
+        var tracker = new HandoffRoundTracker();
+        var survivors = new[] { survivor.Id };
+
+        await BuildSut(tracker).HandoffListHandler(handlerTask.Id, survivors, "wait", CancellationToken.None);
+        await BuildSut(tracker).HandoffListHandler(handlerTask.Id, survivors, "merge", CancellationToken.None);
+
+        var status = await BuildSut(tracker).GetHandoffStatus(handlerTask.Id, CancellationToken.None);
+
+        Assert.Equal(2, status.Round);
+        Assert.Equal(38, status.Remaining);
+        Assert.False(status.Final);
+    }
+
     [Fact]
     public async Task HandoffListHandler_TwoHandlerTasks_DoNotShareACounter()
     {
@@ -280,4 +361,64 @@ public sealed class HandoffMcpToolsTests : IDisposable
         Assert.False(resultB.Coerced);
         Assert.Equal("wait", resultB.NextPhase);
     }
+
+    [Fact]
+    public async Task GetHandoffStatus_NeverHandedOff_ReportsZeroRoundFullBudget()
+    {
+        var listId = await SeedListAsync();
+        var handlerTask = await SeedTaskAsync(listId);
+
+        var sut = BuildSut();
+        var status = await sut.GetHandoffStatus(handlerTask.Id, CancellationToken.None);
+
+        Assert.Equal(handlerTask.Id, status.TaskId);
+        Assert.Equal(handlerTask.Number, status.Number);
+        Assert.Equal(0, status.Round);
+        Assert.Equal(HandoffRoundTracker.DefaultMaxHandoffs, status.Remaining);
+        Assert.False(status.Final);
+    }
+
+    [Fact]
+    public async Task GetHandoffStatus_AfterHandoffs_ReflectsTrackerState()
+    {
+        var listId = await SeedListAsync();
+        var handlerTask = await SeedTaskAsync(listId);
+        var survivor = await SeedTaskAsync(listId, TaskStatus.WaitingForReview, title: "Survivor");
+        var tracker = new HandoffRoundTracker();
+        var survivors = new[] { survivor.Id };
+
+        await BuildSut(tracker).HandoffListHandler(handlerTask.Id, survivors, "wait", CancellationToken.None);
+        await BuildSut(tracker).HandoffListHandler(handlerTask.Id, survivors, "merge", CancellationToken.None);
+
+        var status = await BuildSut(tracker).GetHandoffStatus(handlerTask.Id, CancellationToken.None);
+
+        Assert.Equal(2, status.Round);
+        Assert.Equal(HandoffRoundTracker.DefaultMaxHandoffs - 2, status.Remaining);
+        Assert.False(status.Final);
+    }
+
+    [Fact]
+    public async Task GetHandoffStatus_AfterMergeFinal_ReportsFinal()
+    {
+        var listId = await SeedListAsync();
+        var handlerTask = await SeedTaskAsync(listId);
+        var survivor = await SeedTaskAsync(listId, TaskStatus.WaitingForReview, title: "Survivor");
+        var tracker = new HandoffRoundTracker();
+        var survivors = new[] { survivor.Id };
+
+        await BuildSut(tracker).HandoffListHandler(handlerTask.Id, survivors, "merge_final", CancellationToken.None);
+
+        var status = await BuildSut(tracker).GetHandoffStatus(handlerTask.Id, CancellationToken.None);
+
+        Assert.True(status.Final);
+        Assert.Equal(1, status.Round);
+    }
+
+    [Fact]
+    public async Task GetHandoffStatus_UnknownTask_Throws()
+    {
+        var sut = BuildSut();
+        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            sut.GetHandoffStatus("missing", CancellationToken.None));
+    }
 }

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

@@ -220,8 +220,7 @@ public sealed class TaskWaitMcpToolsTests : IDisposable
     {
         var dependency = await SeedTaskAsync(TaskStatus.Idle);
         var task = await SeedTaskAsync(TaskStatus.Queued);
-        task.DependsOnTaskId = dependency.Id;
-        await _tasks.UpdateAsync(task);
+        await _ctx.SeedDependsOnAsync(task.Id, dependency.Id);
         var sut = BuildSut();
         var sw = Stopwatch.StartNew();
 
@@ -240,8 +239,7 @@ public sealed class TaskWaitMcpToolsTests : IDisposable
     {
         var dependency = await SeedTaskAsync(TaskStatus.Done);
         var task = await SeedTaskAsync(TaskStatus.Queued);
-        task.DependsOnTaskId = dependency.Id;
-        await _tasks.UpdateAsync(task);
+        await _ctx.SeedDependsOnAsync(task.Id, dependency.Id);
         var sut = BuildSut();
         var sw = Stopwatch.StartNew();
 

tests/ClaudeDo.Worker.Tests/Hub/MergeHelperTaskHubTests.cs

@@ -64,7 +64,7 @@ public sealed class MergeHelperTaskHubTests : IDisposable
         var wtManager = new WorktreeManager(git, factory, new WorkerConfig(), NullLogger<WorktreeManager>.Instance);
         var interactiveLaunchSpec = new InteractiveLaunchSpecService(
             factory, new FakeSessionSkillSeeder(), new FakeSessionSkillRegistry(), wtManager, git,
-            new WorkerConfig { ClaudeBin = "claude" });
+            new WorkerConfig { ClaudeBin = "claude" }, new ClaudeDo.Worker.External.HandoffRoundTracker());
         var built = TaskStateServiceBuilder.Build(factory);
         var reviewSubmission = new InteractiveReviewSubmissionService(factory, git, built.State, wtManager);
 

tests/ClaudeDo.Worker.Tests/Infrastructure/TestDependencies.cs

@@ -0,0 +1,20 @@
+using ClaudeDo.Data;
+using ClaudeDo.Data.Models;
+
+namespace ClaudeDo.Worker.Tests.Infrastructure;
+
+internal static class TestDependencies
+{
+    /// <summary>
+    /// Seeds task_dependencies rows straight through the context. The production writer is
+    /// <c>TaskStateService.SetDependsOnAsync</c>, which most read-path fixtures don't build —
+    /// this is the "arrange" shortcut, not a second writer.
+    /// </summary>
+    public static async Task SeedDependsOnAsync(
+        this ClaudeDoDbContext ctx, string taskId, params string[] dependsOnTaskIds)
+    {
+        ctx.TaskDependencies.AddRange(dependsOnTaskIds.Select(id =>
+            new TaskDependencyEntity { TaskId = taskId, DependsOnTaskId = id }));
+        await ctx.SaveChangesAsync();
+    }
+}

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

@@ -908,7 +908,7 @@ file sealed class ApproveObservingTaskStateService : ITaskStateService
     public Task<TransitionResult> FinalizePlanningAsync(string parentId, CancellationToken ct) => _inner.FinalizePlanningAsync(parentId, ct);
     public Task<TransitionResult> BlockOnAsync(string taskId, string predecessorTaskId, CancellationToken ct) => _inner.BlockOnAsync(taskId, predecessorTaskId, ct);
     public Task<TransitionResult> UnblockAsync(string taskId, CancellationToken ct) => _inner.UnblockAsync(taskId, ct);
-    public Task<TransitionResult> SetDependsOnAsync(string taskId, string? dependsOnTaskId, CancellationToken ct) => _inner.SetDependsOnAsync(taskId, dependsOnTaskId, ct);
+    public Task<TransitionResult> SetDependsOnAsync(string taskId, IReadOnlyList<string> dependsOnTaskIds, CancellationToken ct) => _inner.SetDependsOnAsync(taskId, dependsOnTaskIds, ct);
     public Task TryAdvanceParentAsync(string parentId) => _inner.TryAdvanceParentAsync(parentId);
     public Task<int> RecoverStaleRunningAsync(string reason, CancellationToken ct) => _inner.RecoverStaleRunningAsync(reason, ct);
 }

tests/ClaudeDo.Worker.Tests/Queue/QueuePickerTests.cs

@@ -50,7 +50,7 @@ public sealed class QueuePickerTests : IDisposable
         bool taskAgentTag = false,
         int? sortOrder = null,
         bool isManual = false,
-        string? dependsOn = null)
+        params string[] dependsOn)
     {
         var task = new TaskEntity
         {
@@ -61,11 +61,12 @@ public sealed class QueuePickerTests : IDisposable
             CreatedAt = createdAt ?? DateTime.UtcNow,
             ScheduledFor = scheduledFor,
             BlockedByTaskId = blockedBy,
-            DependsOnTaskId = dependsOn,
             CommitType = "feat",
             IsManual = isManual,
         };
         await _tasks.AddAsync(task);
+        if (dependsOn.Length > 0)
+            await _ctx.SeedDependsOnAsync(task.Id, dependsOn);
         if (sortOrder is not null)
         {
             task.SortOrder = sortOrder.Value;
@@ -117,7 +118,7 @@ public sealed class QueuePickerTests : IDisposable
     {
         var listId = await CreateListAsync();
         var dependency = await SeedAsync(listId, status: TaskStatus.Idle);
-        await SeedAsync(listId, dependsOn: dependency.Id);
+        await SeedAsync(listId, dependsOn: [dependency.Id]);
 
         // The dependency is only Idle (not Done), so both stay unclaimed: the dependent is
         // gated on depends_on_task_id, and the dependency itself was never queued.
@@ -129,7 +130,7 @@ public sealed class QueuePickerTests : IDisposable
     {
         var listId = await CreateListAsync();
         var dependency = await SeedAsync(listId, status: TaskStatus.Done);
-        var dependent = await SeedAsync(listId, dependsOn: dependency.Id);
+        var dependent = await SeedAsync(listId, dependsOn: [dependency.Id]);
 
         var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
 
@@ -142,7 +143,7 @@ public sealed class QueuePickerTests : IDisposable
     {
         var listId = await CreateListAsync();
         var dependency = await SeedAsync(listId, status: TaskStatus.Failed);
-        await SeedAsync(listId, dependsOn: dependency.Id);
+        await SeedAsync(listId, dependsOn: [dependency.Id]);
         var independent = await SeedAsync(listId, createdAt: DateTime.UtcNow.AddMinutes(1));
 
         // A Failed dependency does not cascade-cancel or auto-unblock the dependent (unlike the
@@ -155,6 +156,55 @@ public sealed class QueuePickerTests : IDisposable
         Assert.Null(second);
     }
 
+    [Fact]
+    public async Task ClaimNextAsync_Skips_TaskWhoseDependsOnCancelled()
+    {
+        var listId = await CreateListAsync();
+        var dependency = await SeedAsync(listId, status: TaskStatus.Cancelled);
+        await SeedAsync(listId, dependsOn: [dependency.Id]);
+
+        Assert.Null(await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None));
+    }
+
+    [Fact]
+    public async Task ClaimNextAsync_Skips_TaskWithOneOfTwoDependenciesUnmet()
+    {
+        var listId = await CreateListAsync();
+        var done = await SeedAsync(listId, status: TaskStatus.Done);
+        var running = await SeedAsync(listId, status: TaskStatus.Running);
+        await SeedAsync(listId, dependsOn: [done.Id, running.Id]);
+
+        Assert.Null(await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None));
+    }
+
+    [Fact]
+    public async Task ClaimNextAsync_Claims_TaskOnceAllDependenciesAreDone()
+    {
+        var listId = await CreateListAsync();
+        var first = await SeedAsync(listId, status: TaskStatus.Done);
+        var second = await SeedAsync(listId, status: TaskStatus.Done);
+        var dependent = await SeedAsync(listId, dependsOn: [first.Id, second.Id]);
+
+        var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
+
+        Assert.NotNull(picked);
+        Assert.Equal(dependent.Id, picked!.Id);
+    }
+
+    [Fact]
+    public async Task ClaimNextAsync_Claims_TaskWithoutAnyDependency()
+    {
+        // The gating clause is "no edge whose predecessor isn't done" — a task with zero edges
+        // must stay eligible, which the doubly-negated form is easy to get wrong.
+        var listId = await CreateListAsync();
+        var task = await SeedAsync(listId);
+
+        var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
+
+        Assert.NotNull(picked);
+        Assert.Equal(task.Id, picked!.Id);
+    }
+
     [Fact]
     public async Task ClaimNextAsync_Picks_TasksWithoutAgentTag()
     {

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

@@ -3,6 +3,7 @@ using ClaudeDo.Data.Git;
 using ClaudeDo.Data.Models;
 using ClaudeDo.Data.Repositories;
 using ClaudeDo.Worker.Config;
+using ClaudeDo.Worker.External;
 using ClaudeDo.Worker.Planning;
 using ClaudeDo.Worker.Runner;
 using ClaudeDo.Worker.Skills;
@@ -72,11 +73,12 @@ public sealed class InteractiveLaunchSpecServiceTests : IDisposable
             => Task.FromResult<IReadOnlyList<SessionSkillEntity>>(Installed);
     }
 
-    private InteractiveLaunchSpecService BuildService() =>
+    private InteractiveLaunchSpecService BuildService(HandoffRoundTracker? handoffRounds = null) =>
         new(_db.CreateFactory(), _seeder, _registry,
             new WorktreeManager(new GitService(), _db.CreateFactory(), new WorkerConfig(), NullLogger<WorktreeManager>.Instance),
             new GitService(),
-            new WorkerConfig { ClaudeBin = _claudeStubPath });
+            new WorkerConfig { ClaudeBin = _claudeStubPath },
+            handoffRounds ?? new HandoffRoundTracker());
 
     private async Task<string> SeedListAsync(string? workingDir = null, string name = "L")
     {
@@ -636,6 +638,43 @@ public sealed class InteractiveLaunchSpecServiceTests : IDisposable
         await ctx.SaveChangesAsync();
     }
 
+    private async Task SetMaxHandoffsAsync(int value)
+    {
+        using var ctx = _db.CreateContext();
+        await new AppSettingsRepository(ctx).GetAsync();
+        var row = await ctx.AppSettings.FirstAsync(s => s.Id == AppSettingsEntity.SingletonId);
+        row.ListHandlerMaxHandoffs = value;
+        await ctx.SaveChangesAsync();
+    }
+
+    /// The handoff brief reports the budget the chain is ACTUALLY bounded by. Recomputing it from
+    /// HandoffRoundTracker.DefaultMaxHandoffs would compile, look fine, and quietly tell the model
+    /// it has 2 rounds left when the configured cap gives it 39 — so pin the configured value.
+    [Fact]
+    public async Task BuildForMergeHelperHandoffAsync_RaisedCap_BriefReportsConfiguredBudget()
+    {
+        var repo = Path.Combine(_tempDir, "capBrief");
+        Directory.CreateDirectory(repo);
+        var listId = await SeedListAsync(workingDir: repo, name: "Alpha");
+        var handler = Guid.NewGuid().ToString();
+        var survivor = Guid.NewGuid().ToString();
+        await SeedTaskAsync(handler, listId, TaskStatus.Idle, title: "List handler: Alpha");
+        await SeedTaskAsync(survivor, listId, TaskStatus.WaitingForReview, title: "Survivor task");
+
+        await SetMaxHandoffsAsync(40);
+
+        var tracker = new HandoffRoundTracker();
+        tracker.Register(handler, "wait", 40);
+
+        var svc = BuildService(tracker);
+        var spec = await svc.BuildForMergeHelperHandoffAsync(handler, new[] { survivor }, "wait", CancellationToken.None);
+        var sessionDir = TrackSessionDir(spec);
+        var brief = await File.ReadAllTextAsync(Path.Combine(sessionDir, "handoff.md"));
+
+        Assert.Contains("round 1 of 40", brief);
+        Assert.Contains("39 more possible", brief);
+    }
+
     private async Task SetPowerUseAllowedAsync(string listId, bool value)
     {
         using var ctx = _db.CreateContext();
@@ -1134,7 +1173,13 @@ public sealed class InteractiveLaunchSpecServiceTests : IDisposable
 
         var beforeCount = await CountTasksAsync();
 
-        var svc = BuildService();
+        // In production, HandoffMcpTools.HandoffListHandler calls Register BEFORE the hub asks
+        // this service to build the spec -- simulate that here so the brief's round info is
+        // demonstrably read from HandoffRoundTracker, not recomputed.
+        var tracker = new HandoffRoundTracker();
+        tracker.Register(handlerTaskId, nextPhase);
+
+        var svc = BuildService(tracker);
         var spec = await svc.BuildForMergeHelperHandoffAsync(handlerTaskId, new[] { survivor }, nextPhase, CancellationToken.None);
         var sessionDir = TrackSessionDir(spec);
 
@@ -1181,6 +1226,11 @@ public sealed class InteractiveLaunchSpecServiceTests : IDisposable
         Assert.Contains(survivor, handoffBrief);
         Assert.Contains("phase 3", handoffBrief, StringComparison.OrdinalIgnoreCase);
 
+        // Round info always names the current round and the total cap -- this is the ONE
+        // Register call above, and this test leaves ListHandlerMaxHandoffs at its default,
+        // so round 1 of DefaultMaxHandoffs.
+        Assert.Contains($"round 1 of {HandoffRoundTracker.DefaultMaxHandoffs}", handoffBrief);
+
         if (expectFinalNote)
         {
             Assert.Contains("FINAL round", handoffBrief);

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

@@ -102,6 +102,17 @@ public sealed class TaskStateServiceTests : IDisposable
         return await new TaskRepository(ctx).GetByIdAsync(id) ?? throw new InvalidOperationException($"task {id} not found");
     }
 
+    private async Task<List<string>> GetDependsOnAsync(string id)
+    {
+        await using var ctx = _factory.CreateDbContext();
+        return await ctx.TaskDependencies.Where(d => d.TaskId == id)
+            .Select(d => d.DependsOnTaskId).ToListAsync();
+    }
+
+    // The dependency set has no defined order, and the ids are random GUIDs -- sort both sides.
+    private static List<string> Sorted(params string[] ids) => ids.OrderBy(x => x).ToList();
+    private static List<string> Sorted(IEnumerable<string> ids) => ids.OrderBy(x => x).ToList();
+
     // ─── EnqueueAsync ─────────────────────────────────────────────────────
 
     [Fact]
@@ -659,31 +670,55 @@ public sealed class TaskStateServiceTests : IDisposable
     // ─── SetDependsOnAsync ────────────────────────────────────────────────
 
     [Fact]
-    public async Task SetDependsOnAsync_SetsDependsOnTaskId()
+    public async Task SetDependsOnAsync_SetsDependsOnTaskIds()
     {
         var predecessor = await SeedTaskAsync(TaskStatus.Idle);
         var task = await SeedTaskAsync(TaskStatus.Queued);
 
-        var result = await _sut.SetDependsOnAsync(task, predecessor, default);
+        var result = await _sut.SetDependsOnAsync(task, [predecessor], default);
 
         Assert.True(result.Ok);
-        var t = await GetTaskAsync(task);
-        Assert.Equal(predecessor, t.DependsOnTaskId);
+        Assert.Equal([predecessor], await GetDependsOnAsync(task));
     }
 
     [Fact]
-    public async Task SetDependsOnAsync_Null_ClearsDependsOnTaskId_AndWakesQueue()
+    public async Task SetDependsOnAsync_SetsSeveralPredecessors()
+    {
+        var a = await SeedTaskAsync(TaskStatus.Idle);
+        var b = await SeedTaskAsync(TaskStatus.Idle);
+        var task = await SeedTaskAsync(TaskStatus.Queued);
+
+        Assert.True((await _sut.SetDependsOnAsync(task, [a, b], default)).Ok);
+
+        Assert.Equal(Sorted(a, b), Sorted(await GetDependsOnAsync(task)));
+    }
+
+    [Fact]
+    public async Task SetDependsOnAsync_ReplacingSet_KeepsOverlapAndDropsTheRest()
+    {
+        var a = await SeedTaskAsync(TaskStatus.Idle);
+        var b = await SeedTaskAsync(TaskStatus.Idle);
+        var c = await SeedTaskAsync(TaskStatus.Idle);
+        var task = await SeedTaskAsync(TaskStatus.Queued);
+        Assert.True((await _sut.SetDependsOnAsync(task, [a, b], default)).Ok);
+
+        Assert.True((await _sut.SetDependsOnAsync(task, [b, c], default)).Ok);
+
+        Assert.Equal(Sorted(b, c), Sorted(await GetDependsOnAsync(task)));
+    }
+
+    [Fact]
+    public async Task SetDependsOnAsync_Empty_ClearsDependsOnTaskIds_AndWakesQueue()
     {
         var predecessor = await SeedTaskAsync(TaskStatus.Idle);
         var task = await SeedTaskAsync(TaskStatus.Queued);
-        await _sut.SetDependsOnAsync(task, predecessor, default);
+        await _sut.SetDependsOnAsync(task, [predecessor], default);
         var wakesBefore = _built.WakeCount();
 
-        var result = await _sut.SetDependsOnAsync(task, null, default);
+        var result = await _sut.SetDependsOnAsync(task, [], default);
 
         Assert.True(result.Ok);
-        var t = await GetTaskAsync(task);
-        Assert.Null(t.DependsOnTaskId);
+        Assert.Empty(await GetDependsOnAsync(task));
         Assert.True(_built.WakeCount() > wakesBefore);
     }
 
@@ -692,11 +727,10 @@ public sealed class TaskStateServiceTests : IDisposable
     {
         var task = await SeedTaskAsync(TaskStatus.Queued);
 
-        var result = await _sut.SetDependsOnAsync(task, task, default);
+        var result = await _sut.SetDependsOnAsync(task, [task], default);
 
         Assert.False(result.Ok);
-        var t = await GetTaskAsync(task);
-        Assert.Null(t.DependsOnTaskId);
+        Assert.Empty(await GetDependsOnAsync(task));
     }
 
     [Fact]
@@ -704,7 +738,7 @@ public sealed class TaskStateServiceTests : IDisposable
     {
         var task = await SeedTaskAsync(TaskStatus.Queued);
 
-        var result = await _sut.SetDependsOnAsync(task, "does-not-exist", default);
+        var result = await _sut.SetDependsOnAsync(task, ["does-not-exist"], default);
 
         Assert.False(result.Ok);
     }
@@ -714,7 +748,7 @@ public sealed class TaskStateServiceTests : IDisposable
     {
         var predecessor = await SeedTaskAsync(TaskStatus.Idle);
 
-        var result = await _sut.SetDependsOnAsync("does-not-exist", predecessor, default);
+        var result = await _sut.SetDependsOnAsync("does-not-exist", [predecessor], default);
 
         Assert.False(result.Ok);
     }
@@ -724,15 +758,14 @@ public sealed class TaskStateServiceTests : IDisposable
     {
         var a = await SeedTaskAsync(TaskStatus.Queued);
         var b = await SeedTaskAsync(TaskStatus.Queued);
-        var setup = await _sut.SetDependsOnAsync(b, a, default);
+        var setup = await _sut.SetDependsOnAsync(b, [a], default);
         Assert.True(setup.Ok);
 
         // a -> b would close the loop a -> b -> a.
-        var result = await _sut.SetDependsOnAsync(a, b, default);
+        var result = await _sut.SetDependsOnAsync(a, [b], default);
 
         Assert.False(result.Ok);
-        var t = await GetTaskAsync(a);
-        Assert.Null(t.DependsOnTaskId);
+        Assert.Empty(await GetDependsOnAsync(a));
     }
 
     [Fact]
@@ -741,15 +774,31 @@ public sealed class TaskStateServiceTests : IDisposable
         var a = await SeedTaskAsync(TaskStatus.Queued);
         var b = await SeedTaskAsync(TaskStatus.Queued);
         var c = await SeedTaskAsync(TaskStatus.Queued);
-        Assert.True((await _sut.SetDependsOnAsync(b, a, default)).Ok);
-        Assert.True((await _sut.SetDependsOnAsync(c, b, default)).Ok);
+        Assert.True((await _sut.SetDependsOnAsync(b, [a], default)).Ok);
+        Assert.True((await _sut.SetDependsOnAsync(c, [b], default)).Ok);
 
         // a -> c would close the loop a -> c -> b -> a.
-        var result = await _sut.SetDependsOnAsync(a, c, default);
+        var result = await _sut.SetDependsOnAsync(a, [c], default);
 
         Assert.False(result.Ok);
     }
 
+    [Fact]
+    public async Task SetDependsOnAsync_CycleViaOneOfSeveralProposedEdges_Rejected()
+    {
+        // Only the second proposed edge closes a loop -- the check must look at every one of
+        // them, not just the first, and must leave the whole set unwritten when one fails.
+        var a = await SeedTaskAsync(TaskStatus.Queued);
+        var b = await SeedTaskAsync(TaskStatus.Queued);
+        var innocent = await SeedTaskAsync(TaskStatus.Idle);
+        Assert.True((await _sut.SetDependsOnAsync(b, [a], default)).Ok);
+
+        var result = await _sut.SetDependsOnAsync(a, [innocent, b], default);
+
+        Assert.False(result.Ok);
+        Assert.Empty(await GetDependsOnAsync(a));
+    }
+
     // ─── RecoverStaleRunningAsync ─────────────────────────────────────────
 
     [Fact]