refactor(worker/state): introduce TaskStateService and route mutations through it

Slice 2 of the worker state consolidation refactor (spec sections 2 and 8).

Adds Worker/State/ITaskStateService + TaskStateService as the single component
that mutates Status, PlanningPhase, and BlockedByTaskId. Each transition is one
atomic ExecuteUpdate with a WHERE filter on the expected source status, so
parallel claims are TOCTOU-free. Side effects (queue wake on -> Queued, hub
TaskUpdated broadcast, chain advance + parent completion on terminal child)
are owned by the service so callers no longer need to remember them.

Migrated callers (mechanical, behavior preserved):
- TaskRunner: HandleSuccess/HandleFailure/MarkFailed/RunAsync/ContinueAsync
- StaleTaskRecovery: bulk recover stale Running tasks
- TaskResetService: status flip (worktree cleanup stays in service)
- PlanningSessionManager.StartAsync: status flip via state, token write via repo
- PlanningChainCoordinator.OnChildFinishedAsync: routes the next-sibling write
  through state.UnblockAsync (Slice 4 finishes the rewrite)
- ExternalMcpService.UpdateTaskStatus: Queued case via state.EnqueueAsync

Repo Mark*Async helpers (MarkRunning/MarkDone/MarkFailed/FlipAllRunningToFailed)
are now internal; ClaudeDo.Data grants InternalsVisibleTo to ClaudeDo.Worker
and ClaudeDo.Worker.Tests for the existing repo-level tests.

DI: TaskStateService is registered as Singleton in both the main app and the
external-MCP app; the queue-wake delegate captures sp -> QueueService.WakeQueue
to break the TaskStateService -> QueueService -> TaskRunner -> TaskStateService
construction cycle. PlanningChainCoordinator takes Func<ITaskStateService> for
the same reason; Slice 3 will replace both with IQueueWaker.

Tests: TaskStateServiceTests covers happy + reject for every transition, the
parallel StartRunningAsync claim race, child-terminal chain advancement, and
stale recovery. Existing service/repo tests are updated to construct the new
state-service via a TaskStateServiceBuilder helper. Pre-existing constructor
drift in QueueService/ExternalMcp/PlanningHub tests is patched to keep the
test project building (the surrounding test logic is otherwise untouched).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

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

@@ -94,7 +94,8 @@ public sealed class ExternalMcpServiceTests : IDisposable
     // we never call its WakeQueue/RunNow/CancelTask paths, so a real QueueService
     // built with the same approach used in QueueServiceTests is sufficient.
     private ExternalMcpService BuildSut(QueueService queue) =>
-        new(_tasks, _lists, queue, _broadcaster, _tags);
+        new(_tasks, _lists, queue, _broadcaster, _tags,
+            TaskStateServiceBuilder.Build(_db.CreateFactory()).State);
 
     private QueueService CreateQueue()
     {
@@ -113,7 +114,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
         var wtManager = new WorktreeManager(new GitService(), dbFactory, cfg, NullLogger<WorktreeManager>.Instance);
         var argsBuilder = new ClaudeArgsBuilder();
         var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, cfg,
-            NullLogger<TaskRunner>.Instance);
+            NullLogger<TaskRunner>.Instance, TaskStateServiceBuilder.Build(dbFactory).State);
         return new QueueService(dbFactory, runner, cfg, NullLogger<QueueService>.Instance);
     }
 

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

@@ -50,7 +50,7 @@ public sealed class PlanningHubTests : IDisposable
     {
         var hub = new WorkerHub(
             null!, null!, null!, null!, null!, null!, null!, null!,
-            _planning, _launcher, null!, null!);
+            _planning, _launcher, null!, null!, null!);
         hub.Clients = new FakeHubCallerClients(_proxy);
         hub.Context = new FakeHubCallerContext();
         return hub;

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

@@ -0,0 +1,39 @@
+using ClaudeDo.Worker.Hub;
+using Microsoft.AspNetCore.SignalR;
+
+namespace ClaudeDo.Worker.Tests.Infrastructure;
+
+public sealed record CapturedHubCall(string Method, object?[] Args);
+
+public sealed class CapturingClientProxy : IClientProxy
+{
+    public readonly List<CapturedHubCall> Calls = new();
+
+    public Task SendCoreAsync(string method, object?[] args, CancellationToken cancellationToken = default)
+    {
+        Calls.Add(new CapturedHubCall(method, args));
+        return Task.CompletedTask;
+    }
+}
+
+public sealed class CapturingHubClients : IHubClients
+{
+    public CapturingClientProxy AllProxy { get; } = new();
+    public IClientProxy All => AllProxy;
+    public IClientProxy AllExcept(IReadOnlyList<string> excludedConnectionIds) => AllProxy;
+    public IClientProxy Client(string connectionId) => AllProxy;
+    public IClientProxy Clients(IReadOnlyList<string> connectionIds) => AllProxy;
+    public IClientProxy Group(string groupName) => AllProxy;
+    public IClientProxy GroupExcept(string groupName, IReadOnlyList<string> excludedConnectionIds) => AllProxy;
+    public IClientProxy Groups(IReadOnlyList<string> groupNames) => AllProxy;
+    public IClientProxy User(string userId) => AllProxy;
+    public IClientProxy Users(IReadOnlyList<string> userIds) => AllProxy;
+}
+
+public sealed class CapturingHubContext : IHubContext<WorkerHub>
+{
+    private readonly CapturingHubClients _clients = new();
+    public CapturingClientProxy Proxy => _clients.AllProxy;
+    public IHubClients Clients => _clients;
+    public IGroupManager Groups => throw new NotImplementedException();
+}

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

@@ -0,0 +1,37 @@
+using ClaudeDo.Data;
+using ClaudeDo.Worker.Hub;
+using ClaudeDo.Worker.Planning;
+using ClaudeDo.Worker.State;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging.Abstractions;
+
+namespace ClaudeDo.Worker.Tests.Infrastructure;
+
+/// Test-only helper that wires TaskStateService and PlanningChainCoordinator
+/// against a shared DB factory, breaking the Func cycle between them.
+public static class TaskStateServiceBuilder
+{
+    public sealed record Built(
+        TaskStateService State,
+        PlanningChainCoordinator Chain,
+        CapturingHubContext Hub,
+        Func<int> WakeCount);
+
+    public static Built Build(IDbContextFactory<ClaudeDoDbContext> dbFactory)
+    {
+        var hub = new CapturingHubContext();
+        var broadcaster = new HubBroadcaster(hub);
+        var wakeCount = new int[1];
+
+        TaskStateService? state = null;
+        var chain = new PlanningChainCoordinator(dbFactory, () => state!);
+        state = new TaskStateService(
+            dbFactory,
+            broadcaster,
+            () => Interlocked.Increment(ref wakeCount[0]),
+            chain,
+            NullLogger<TaskStateService>.Instance);
+
+        return new Built(state, chain, hub, () => Volatile.Read(ref wakeCount[0]));
+    }
+}

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

@@ -17,7 +17,7 @@ public sealed class PlanningChainCoordinatorTests : IDisposable
     public PlanningChainCoordinatorTests()
     {
         _factory = _db.CreateFactory();
-        _sut = new PlanningChainCoordinator(_factory);
+        _sut = TaskStateServiceBuilder.Build(_factory).Chain;
         _listId = Guid.NewGuid().ToString();
         using var ctx = _factory.CreateDbContext();
         ctx.Lists.Add(new ListEntity

tests/ClaudeDo.Worker.Tests/Services/QueueServiceSlotGuardTests.cs

@@ -54,7 +54,7 @@ public sealed class QueueServiceSlotGuardTests : IDisposable
         var wtManager = new WorktreeManager(new ClaudeDo.Data.Git.GitService(), dbFactory, _cfg, NullLogger<WorktreeManager>.Instance);
         var argsBuilder = new ClaudeArgsBuilder();
         var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, _cfg,
-            NullLogger<TaskRunner>.Instance);
+            NullLogger<TaskRunner>.Instance, TaskStateServiceBuilder.Build(dbFactory).State);
         var service = new QueueService(dbFactory, runner, _cfg, NullLogger<QueueService>.Instance);
         return (service, fake);
     }

tests/ClaudeDo.Worker.Tests/Services/QueueServiceTests.cs

@@ -55,7 +55,7 @@ public sealed class QueueServiceTests : IDisposable
         var wtManager = new WorktreeManager(new GitService(), dbFactory, _cfg, NullLogger<WorktreeManager>.Instance);
         var argsBuilder = new ClaudeArgsBuilder();
         var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, _cfg,
-            NullLogger<TaskRunner>.Instance);
+            NullLogger<TaskRunner>.Instance, TaskStateServiceBuilder.Build(dbFactory).State);
         var service = new QueueService(dbFactory, runner, _cfg, NullLogger<QueueService>.Instance);
         return (service, fake);
     }

tests/ClaudeDo.Worker.Tests/Services/StaleTaskRecoveryTests.cs

@@ -54,7 +54,8 @@ public sealed class StaleTaskRecoveryTests : IDisposable
         await _tasks.AddAsync(running);
         await _tasks.AddAsync(queued);
 
-        var recovery = new StaleTaskRecovery(_db.CreateFactory(), NullLogger<StaleTaskRecovery>.Instance);
+        var built = TaskStateServiceBuilder.Build(_db.CreateFactory());
+        var recovery = new StaleTaskRecovery(built.State, NullLogger<StaleTaskRecovery>.Instance);
         await recovery.StartAsync(CancellationToken.None);
 
         var r = await _tasks.GetByIdAsync(running.Id);

tests/ClaudeDo.Worker.Tests/Services/TaskResetServiceTests.cs

@@ -34,10 +34,12 @@ public class TaskResetServiceTests : IDisposable
     {
         var fakeHub = new RecordingHubContext();
         var broadcaster = new HubBroadcaster(fakeHub);
+        var built = TaskStateServiceBuilder.Build(db.CreateFactory());
         var svc = new TaskResetService(
             db.CreateFactory(),
             wtMgr,
             broadcaster,
+            built.State,
             NullLogger<TaskResetService>.Instance);
         return (svc, fakeHub.Proxy);
     }
@@ -111,7 +113,7 @@ public class TaskResetServiceTests : IDisposable
         {
             var updated = await new TaskRepository(ctx).GetByIdAsync(task.Id);
             Assert.NotNull(updated);
-            Assert.Equal(TaskStatus.Manual, updated!.Status);
+            Assert.Equal(TaskStatus.Idle, updated!.Status);
             Assert.Null(updated.Result);
             Assert.Null(updated.StartedAt);
             Assert.Null(updated.FinishedAt);

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

@@ -0,0 +1,383 @@
+using ClaudeDo.Data;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.State;
+using ClaudeDo.Worker.Tests.Infrastructure;
+using Microsoft.EntityFrameworkCore;
+using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
+
+namespace ClaudeDo.Worker.Tests.State;
+
+public sealed class TaskStateServiceTests : IDisposable
+{
+    private readonly DbFixture _db = new();
+    private readonly TestDbContextFactory _factory;
+    private readonly TaskStateServiceBuilder.Built _built;
+    private readonly ITaskStateService _sut;
+    private readonly string _listId;
+
+    public TaskStateServiceTests()
+    {
+        _factory = _db.CreateFactory();
+        _built = TaskStateServiceBuilder.Build(_factory);
+        _sut = _built.State;
+
+        _listId = Guid.NewGuid().ToString();
+        using var ctx = _factory.CreateDbContext();
+        ctx.Lists.Add(new ListEntity
+        {
+            Id = _listId,
+            Name = "Test",
+            CreatedAt = DateTime.UtcNow,
+            DefaultCommitType = "chore",
+        });
+        ctx.SaveChanges();
+    }
+
+    public void Dispose() => _db.Dispose();
+
+    private async Task<string> SeedTaskAsync(TaskStatus status, string? parentId = null, int sortOrder = 0)
+    {
+        var id = Guid.NewGuid().ToString();
+        await using var ctx = _factory.CreateDbContext();
+        ctx.Tasks.Add(new TaskEntity
+        {
+            Id = id,
+            ListId = _listId,
+            Title = "task",
+            Status = status,
+            CreatedAt = DateTime.UtcNow,
+            ParentTaskId = parentId,
+            SortOrder = sortOrder,
+        });
+        await ctx.SaveChangesAsync();
+        return id;
+    }
+
+    private async Task<TaskStatus> GetStatusAsync(string id)
+    {
+        await using var ctx = _factory.CreateDbContext();
+        return await ctx.Tasks.Where(t => t.Id == id).Select(t => t.Status).FirstAsync();
+    }
+
+    private async Task<TaskEntity> GetTaskAsync(string id)
+    {
+        await using var ctx = _factory.CreateDbContext();
+        return await new TaskRepository(ctx).GetByIdAsync(id) ?? throw new InvalidOperationException($"task {id} not found");
+    }
+
+    // ─── EnqueueAsync ─────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task EnqueueAsync_FromIdle_TransitionsToQueued_AndWakesQueue()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Idle);
+        var wakesBefore = _built.WakeCount();
+
+        var result = await _sut.EnqueueAsync(id, default);
+
+        Assert.True(result.Ok);
+        Assert.Equal(TaskStatus.Queued, await GetStatusAsync(id));
+        Assert.True(_built.WakeCount() > wakesBefore);
+        Assert.Contains(_built.Hub.Proxy.Calls, c => c.Method == "TaskUpdated");
+    }
+
+    [Fact]
+    public async Task EnqueueAsync_FromRunning_Rejects_AndDoesNotMutate()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Running);
+
+        var result = await _sut.EnqueueAsync(id, default);
+
+        Assert.False(result.Ok);
+        Assert.Equal(TaskStatus.Running, await GetStatusAsync(id));
+    }
+
+    // ─── StartRunningAsync ────────────────────────────────────────────────
+
+    [Fact]
+    public async Task StartRunningAsync_FromQueued_TransitionsToRunning_AndStampsStartedAt()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Queued);
+        var startedAt = new DateTime(2026, 4, 27, 10, 0, 0, DateTimeKind.Utc);
+
+        var result = await _sut.StartRunningAsync(id, startedAt, default);
+
+        Assert.True(result.Ok);
+        var t = await GetTaskAsync(id);
+        Assert.Equal(TaskStatus.Running, t.Status);
+        Assert.Equal(startedAt, t.StartedAt);
+    }
+
+    [Fact]
+    public async Task StartRunningAsync_FromRunning_Rejects()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Running);
+
+        var result = await _sut.StartRunningAsync(id, DateTime.UtcNow, default);
+
+        Assert.False(result.Ok);
+    }
+
+    [Fact]
+    public async Task StartRunningAsync_TwoParallelClaims_ExactlyOneWins()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Queued);
+        var startedAt = DateTime.UtcNow;
+
+        // Two concurrent calls: only one ExecuteUpdate should affect a row.
+        var t1 = Task.Run(() => _sut.StartRunningAsync(id, startedAt, default));
+        var t2 = Task.Run(() => _sut.StartRunningAsync(id, startedAt, default));
+        var results = await Task.WhenAll(t1, t2);
+
+        var winners = results.Count(r => r.Ok);
+        Assert.Equal(1, winners);
+        Assert.Equal(TaskStatus.Running, await GetStatusAsync(id));
+    }
+
+    // ─── CompleteAsync ────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task CompleteAsync_FromRunning_TransitionsToDone()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Running);
+
+        var result = await _sut.CompleteAsync(id, DateTime.UtcNow, "ok", default);
+
+        Assert.True(result.Ok);
+        var t = await GetTaskAsync(id);
+        Assert.Equal(TaskStatus.Done, t.Status);
+        Assert.Equal("ok", t.Result);
+        Assert.NotNull(t.FinishedAt);
+    }
+
+    [Fact]
+    public async Task CompleteAsync_FromQueued_Rejects()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Queued);
+
+        var result = await _sut.CompleteAsync(id, DateTime.UtcNow, "ok", default);
+
+        Assert.False(result.Ok);
+        Assert.Equal(TaskStatus.Queued, await GetStatusAsync(id));
+    }
+
+    // ─── FailAsync ────────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task FailAsync_FromRunning_TransitionsToFailed()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Running);
+
+        var result = await _sut.FailAsync(id, DateTime.UtcNow, "boom", default);
+
+        Assert.True(result.Ok);
+        var t = await GetTaskAsync(id);
+        Assert.Equal(TaskStatus.Failed, t.Status);
+        Assert.Equal("boom", t.Result);
+    }
+
+    [Fact]
+    public async Task FailAsync_FromDone_Rejects()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Done);
+
+        var result = await _sut.FailAsync(id, DateTime.UtcNow, "boom", default);
+
+        Assert.False(result.Ok);
+        Assert.Equal(TaskStatus.Done, await GetStatusAsync(id));
+    }
+
+    // ─── CancelAsync ──────────────────────────────────────────────────────
+
+    [Fact]
+    public async Task CancelAsync_FromRunning_TransitionsToCancelled()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Running);
+
+        var result = await _sut.CancelAsync(id, DateTime.UtcNow, default);
+
+        Assert.True(result.Ok);
+        Assert.Equal(TaskStatus.Cancelled, await GetStatusAsync(id));
+    }
+
+    [Fact]
+    public async Task CancelAsync_FromDone_Rejects()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Done);
+
+        var result = await _sut.CancelAsync(id, DateTime.UtcNow, default);
+
+        Assert.False(result.Ok);
+        Assert.Equal(TaskStatus.Done, await GetStatusAsync(id));
+    }
+
+    // ─── ResetToIdleAsync ─────────────────────────────────────────────────
+
+    [Fact]
+    public async Task ResetToIdleAsync_FromFailed_ClearsTimestamps()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Failed);
+        await using (var ctx = _factory.CreateDbContext())
+        {
+            await ctx.Tasks.Where(t => t.Id == id)
+                .ExecuteUpdateAsync(s => s
+                    .SetProperty(t => t.StartedAt, DateTime.UtcNow.AddMinutes(-5))
+                    .SetProperty(t => t.FinishedAt, DateTime.UtcNow.AddMinutes(-1))
+                    .SetProperty(t => t.Result, "old"));
+        }
+
+        var result = await _sut.ResetToIdleAsync(id, default);
+
+        Assert.True(result.Ok);
+        var t = await GetTaskAsync(id);
+        Assert.Equal(TaskStatus.Idle, t.Status);
+        Assert.Null(t.StartedAt);
+        Assert.Null(t.FinishedAt);
+        Assert.Null(t.Result);
+    }
+
+    [Fact]
+    public async Task ResetToIdleAsync_FromRunning_Rejects()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Running);
+
+        var result = await _sut.ResetToIdleAsync(id, default);
+
+        Assert.False(result.Ok);
+        Assert.Equal(TaskStatus.Running, await GetStatusAsync(id));
+    }
+
+    // ─── StartPlanningAsync ───────────────────────────────────────────────
+
+    [Fact]
+    public async Task StartPlanningAsync_FromManual_FlipsStatus_AndPlanningPhase()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Manual);
+
+        var result = await _sut.StartPlanningAsync(id, default);
+
+        Assert.True(result.Ok);
+        var t = await GetTaskAsync(id);
+        Assert.Equal(TaskStatus.Planning, t.Status);
+        Assert.Equal(PlanningPhase.Active, t.PlanningPhase);
+    }
+
+    [Fact]
+    public async Task StartPlanningAsync_FromRunning_Rejects()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Running);
+
+        var result = await _sut.StartPlanningAsync(id, default);
+
+        Assert.False(result.Ok);
+    }
+
+    // ─── FinalizePlanningAsync ────────────────────────────────────────────
+
+    [Fact]
+    public async Task FinalizePlanningAsync_OnActivePhase_TransitionsToFinalized()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Manual);
+        await _sut.StartPlanningAsync(id, default);
+
+        var result = await _sut.FinalizePlanningAsync(id, default);
+
+        Assert.True(result.Ok);
+        var t = await GetTaskAsync(id);
+        Assert.Equal(PlanningPhase.Finalized, t.PlanningPhase);
+        Assert.NotNull(t.PlanningFinalizedAt);
+    }
+
+    [Fact]
+    public async Task FinalizePlanningAsync_OnNonePhase_Rejects()
+    {
+        var id = await SeedTaskAsync(TaskStatus.Manual);
+
+        var result = await _sut.FinalizePlanningAsync(id, default);
+
+        Assert.False(result.Ok);
+    }
+
+    // ─── BlockOnAsync / UnblockAsync ─────────────────────────────────────
+
+    [Fact]
+    public async Task BlockOnAsync_SetsBlockedByTaskId()
+    {
+        var pred = await SeedTaskAsync(TaskStatus.Queued);
+        var task = await SeedTaskAsync(TaskStatus.Queued);
+
+        var result = await _sut.BlockOnAsync(task, pred, default);
+
+        Assert.True(result.Ok);
+        var t = await GetTaskAsync(task);
+        Assert.Equal(pred, t.BlockedByTaskId);
+    }
+
+    [Fact]
+    public async Task UnblockAsync_ClearsBlockedByTaskId_AndWakesQueue()
+    {
+        var pred = await SeedTaskAsync(TaskStatus.Queued);
+        var task = await SeedTaskAsync(TaskStatus.Queued);
+        await _sut.BlockOnAsync(task, pred, default);
+        var wakesBefore = _built.WakeCount();
+
+        var result = await _sut.UnblockAsync(task, default);
+
+        Assert.True(result.Ok);
+        var t = await GetTaskAsync(task);
+        Assert.Null(t.BlockedByTaskId);
+        Assert.True(_built.WakeCount() > wakesBefore);
+    }
+
+    [Fact]
+    public async Task UnblockAsync_OnWaitingTask_FlipsToQueued()
+    {
+        // Bridge to legacy chain layout: a Status=Waiting sibling becomes Queued on unblock.
+        var task = await SeedTaskAsync(TaskStatus.Waiting);
+
+        var result = await _sut.UnblockAsync(task, default);
+
+        Assert.True(result.Ok);
+        Assert.Equal(TaskStatus.Queued, await GetStatusAsync(task));
+    }
+
+    // ─── RecoverStaleRunningAsync ─────────────────────────────────────────
+
+    [Fact]
+    public async Task RecoverStaleRunningAsync_FlipsAllRunningToFailed_ReturnsCount()
+    {
+        var r1 = await SeedTaskAsync(TaskStatus.Running);
+        var r2 = await SeedTaskAsync(TaskStatus.Running);
+        var q = await SeedTaskAsync(TaskStatus.Queued);
+
+        var count = await _sut.RecoverStaleRunningAsync("worker restart", default);
+
+        Assert.Equal(2, count);
+        Assert.Equal(TaskStatus.Failed, await GetStatusAsync(r1));
+        Assert.Equal(TaskStatus.Failed, await GetStatusAsync(r2));
+        Assert.Equal(TaskStatus.Queued, await GetStatusAsync(q));
+        var t = await GetTaskAsync(r1);
+        Assert.StartsWith("[stale] ", t.Result);
+    }
+
+    // ─── Child terminal → chain advance ───────────────────────────────────
+
+    [Fact]
+    public async Task CompleteAsync_OnChild_AdvancesNextWaitingSibling()
+    {
+        var parent = await SeedTaskAsync(TaskStatus.Planned);
+        var c0 = await SeedTaskAsync(TaskStatus.Running, parentId: parent, sortOrder: 0);
+        var c1 = await SeedTaskAsync(TaskStatus.Waiting, parentId: parent, sortOrder: 1);
+        var c2 = await SeedTaskAsync(TaskStatus.Waiting, parentId: parent, sortOrder: 2);
+
+        var result = await _sut.CompleteAsync(c0, DateTime.UtcNow, "ok", default);
+
+        Assert.True(result.Ok);
+        Assert.Equal(TaskStatus.Done, await GetStatusAsync(c0));
+        // Next sibling was Waiting → chain coordinator unblocks → Queued.
+        Assert.Equal(TaskStatus.Queued, await GetStatusAsync(c1));
+        // Subsequent sibling untouched.
+        Assert.Equal(TaskStatus.Waiting, await GetStatusAsync(c2));
+    }
+}