fix(worker): route done-toggle and dequeue through guarded TaskStateService transitions

The task-list done toggle (both islands) and RemoveFromQueue wrote TaskEntity.Status directly via EF, bypassing TaskStateService: no TaskUpdated broadcast, no guard against a concurrent picker claim (lost update), and no status-based filter. Added guarded MarkDoneAsync/UnmarkDoneAsync/DequeueToIdleAsync transitions plus matching hub methods (SetTaskDone/UnsetTaskDone/DequeueTask) and IWorkerClient wrappers; the three UI call sites now route through the hub with optimistic-then-revert row updates and ErrorReported on failure. RemoveFromQueueAsync dequeues each queued child individually through the same guarded path instead of cascading via a raw EF update. Also closes two hub guard gaps: UpdateListConfig's delete branch now preserves a list's SerializeOnFileOverlap flag instead of dropping it, and SubmitTaskForReview's Idle/Failed status gate now runs before either mutation branch so a Done/Cancelled task can't get committed or stamped and then rejected.
2026-08-21 11:47:24 +02:00
parent ce98f65ca5
commit 7f337b36c7
20 changed files with 806 additions and 49 deletions
@@ -73,6 +73,8 @@ public class DetailsIslandErrorFeedbackTests : IDisposable
        public override bool IsConnected => Connected;
        public Exception? ThrowOnCancelTask;
        public Exception? ThrowOnSetTaskStatus;
+        public Exception? ThrowOnSetTaskDone;
+        public Exception? ThrowOnUnsetTaskDone;

        public override Task CancelTaskAsync(string taskId)
        {
@@ -85,6 +87,18 @@ public class DetailsIslandErrorFeedbackTests : IDisposable
            if (ThrowOnSetTaskStatus is not null) throw ThrowOnSetTaskStatus;
            return Task.FromResult<BaseDirtyWarningDto?>(null);
        }
+
+        public override Task SetTaskDoneAsync(string taskId)
+        {
+            if (ThrowOnSetTaskDone is not null) throw ThrowOnSetTaskDone;
+            return Task.CompletedTask;
+        }
+
+        public override Task UnsetTaskDoneAsync(string taskId)
+        {
+            if (ThrowOnUnsetTaskDone is not null) throw ThrowOnUnsetTaskDone;
+            return Task.CompletedTask;
+        }
    }

    private DetailsIslandViewModel BuildVm(StubWorkerClient worker)
@@ -179,4 +193,60 @@ public class DetailsIslandErrorFeedbackTests : IDisposable
        Assert.NotNull(reportedError);
        Assert.Contains("reset offline", reportedError);
    }
+
+    [Fact]
+    public async Task ToggleDone_MarkDone_WhenWorkerThrows_ReportsError_AndRevertsTask()
+    {
+        var worker = new ThrowingWorkerClient { ThrowOnSetTaskDone = new Exception("mark done offline") };
+        var vm = BuildVm(worker);
+        vm.Bind(new TaskRowViewModel { Id = "task-toggle-done-throw", Status = TaskStatus.Idle, Done = false });
+        vm.Monitor.ApplyState(TaskStatus.Idle);
+
+        string? reportedError = null;
+        vm.ErrorReported += msg => reportedError = msg;
+
+        await vm.ToggleDoneCommand.ExecuteAsync(null);
+
+        Assert.NotNull(reportedError);
+        Assert.Contains("mark done offline", reportedError);
+        Assert.False(vm.Task!.Done);
+        Assert.Equal(TaskStatus.Idle, vm.Task!.Status);
+    }
+
+    [Fact]
+    public async Task ToggleDone_Untoggle_WhenWorkerThrows_ReportsError_AndRevertsTask()
+    {
+        var worker = new ThrowingWorkerClient { ThrowOnUnsetTaskDone = new Exception("unmark done offline") };
+        var vm = BuildVm(worker);
+        vm.Bind(new TaskRowViewModel { Id = "task-untoggle-done-throw", Status = TaskStatus.Done, Done = true });
+        vm.Monitor.ApplyState(TaskStatus.Done);
+
+        string? reportedError = null;
+        vm.ErrorReported += msg => reportedError = msg;
+
+        await vm.ToggleDoneCommand.ExecuteAsync(null);
+
+        Assert.NotNull(reportedError);
+        Assert.Contains("unmark done offline", reportedError);
+        Assert.True(vm.Task!.Done);
+        Assert.Equal(TaskStatus.Done, vm.Task!.Status);
+    }
+
+    [Fact]
+    public async Task ToggleDone_MarkDone_WhenWorkerSucceeds_UpdatesTask_NoError()
+    {
+        var worker = new ThrowingWorkerClient();
+        var vm = BuildVm(worker);
+        vm.Bind(new TaskRowViewModel { Id = "task-toggle-done-ok", Status = TaskStatus.Idle, Done = false });
+        vm.Monitor.ApplyState(TaskStatus.Idle);
+
+        string? reportedError = null;
+        vm.ErrorReported += msg => reportedError = msg;
+
+        await vm.ToggleDoneCommand.ExecuteAsync(null);
+
+        Assert.Null(reportedError);
+        Assert.True(vm.Task!.Done);
+        Assert.Equal(TaskStatus.Done, vm.Task!.Status);
+    }
 }
@@ -57,6 +57,10 @@ public class TasksIslandErrorFeedbackTests : IDisposable
        public Exception? ThrowOnCancelTask;
        public Exception? ThrowOnRejectToQueue;
        public Exception? ThrowOnRejectToIdle;
+        public Exception? ThrowOnSetTaskDone;
+        public Exception? ThrowOnUnsetTaskDone;
+        public Exception? ThrowOnDequeueTask;
+        public readonly List<string> DequeuedTaskIds = new();

        public override Task<BaseDirtyWarningDto?> SetTaskStatusAsync(string taskId, TaskStatus status)
        {
@@ -81,6 +85,25 @@ public class TasksIslandErrorFeedbackTests : IDisposable
            if (ThrowOnRejectToIdle is not null) throw ThrowOnRejectToIdle;
            return Task.CompletedTask;
        }
+
+        public override Task SetTaskDoneAsync(string taskId)
+        {
+            if (ThrowOnSetTaskDone is not null) throw ThrowOnSetTaskDone;
+            return Task.CompletedTask;
+        }
+
+        public override Task UnsetTaskDoneAsync(string taskId)
+        {
+            if (ThrowOnUnsetTaskDone is not null) throw ThrowOnUnsetTaskDone;
+            return Task.CompletedTask;
+        }
+
+        public override Task DequeueTaskAsync(string taskId)
+        {
+            DequeuedTaskIds.Add(taskId);
+            if (ThrowOnDequeueTask is not null) throw ThrowOnDequeueTask;
+            return Task.CompletedTask;
+        }
    }

    [Fact]
@@ -146,4 +169,113 @@ public class TasksIslandErrorFeedbackTests : IDisposable
        Assert.NotNull(reportedError);
        Assert.Contains("reject-to-idle offline", reportedError);
    }
+
+    [Fact]
+    public async Task ToggleDone_MarkDone_WhenWorkerThrows_RaisesErrorReported_AndRevertsRow()
+    {
+        var worker = new ThrowingWorkerClient { ThrowOnSetTaskDone = new Exception("mark done offline") };
+        var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker);
+
+        string? reportedError = null;
+        vm.ErrorReported += msg => reportedError = msg;
+
+        var row = new TaskRowViewModel { Id = "task-toggle-done-1", Status = TaskStatus.Idle, Done = false };
+        await vm.ToggleDoneCommand.ExecuteAsync(row);
+
+        Assert.NotNull(reportedError);
+        Assert.Contains("mark done offline", reportedError);
+        Assert.False(row.Done);
+        Assert.Equal(TaskStatus.Idle, row.Status);
+    }
+
+    [Fact]
+    public async Task ToggleDone_Untoggle_WhenWorkerThrows_RaisesErrorReported_AndRevertsRow()
+    {
+        var worker = new ThrowingWorkerClient { ThrowOnUnsetTaskDone = new Exception("unmark done offline") };
+        var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker);
+
+        string? reportedError = null;
+        vm.ErrorReported += msg => reportedError = msg;
+
+        var row = new TaskRowViewModel { Id = "task-toggle-done-2", Status = TaskStatus.Done, Done = true };
+        await vm.ToggleDoneCommand.ExecuteAsync(row);
+
+        Assert.NotNull(reportedError);
+        Assert.Contains("unmark done offline", reportedError);
+        Assert.True(row.Done);
+        Assert.Equal(TaskStatus.Done, row.Status);
+    }
+
+    [Fact]
+    public async Task ToggleDone_MarkDone_WhenWorkerSucceeds_UpdatesRow_NoError()
+    {
+        var worker = new ThrowingWorkerClient();
+        var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker);
+
+        string? reportedError = null;
+        vm.ErrorReported += msg => reportedError = msg;
+
+        var row = new TaskRowViewModel { Id = "task-toggle-done-3", Status = TaskStatus.Idle, Done = false };
+        await vm.ToggleDoneCommand.ExecuteAsync(row);
+
+        Assert.Null(reportedError);
+        Assert.True(row.Done);
+        Assert.Equal(TaskStatus.Done, row.Status);
+    }
+
+    [Fact]
+    public async Task RemoveFromQueue_WhenWorkerThrows_RaisesErrorReported_AndRevertsRow()
+    {
+        var worker = new ThrowingWorkerClient { ThrowOnDequeueTask = new Exception("dequeue offline") };
+        var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker);
+
+        string? reportedError = null;
+        vm.ErrorReported += msg => reportedError = msg;
+
+        var row = new TaskRowViewModel { Id = "task-dequeue-1", Status = TaskStatus.Queued };
+        await vm.RemoveFromQueueCommand.ExecuteAsync(row);
+
+        Assert.NotNull(reportedError);
+        Assert.Contains("dequeue offline", reportedError);
+        Assert.Equal(TaskStatus.Queued, row.Status);
+    }
+
+    [Fact]
+    public async Task RemoveFromQueue_CascadesToQueuedChildren_ViaGuardedHubCall()
+    {
+        var listId = Guid.NewGuid().ToString();
+        var parentId = Guid.NewGuid().ToString();
+        var childId = Guid.NewGuid().ToString();
+        await using (var db = NewContext())
+        {
+            db.Lists.Add(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
+            db.Tasks.Add(new TaskEntity
+            {
+                Id = parentId, ListId = listId, Title = "parent", Status = TaskStatus.Queued,
+                Number = 1, CreatedAt = DateTime.UtcNow,
+            });
+            db.Tasks.Add(new TaskEntity
+            {
+                Id = childId, ListId = listId, Title = "child", Status = TaskStatus.Queued,
+                Number = 2, ParentTaskId = parentId, BlockedByTaskId = parentId, CreatedAt = DateTime.UtcNow,
+            });
+            await db.SaveChangesAsync();
+        }
+
+        var worker = new ThrowingWorkerClient();
+        var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker);
+        var parentRow = new TaskRowViewModel { Id = parentId, Status = TaskStatus.Queued, HasQueuedSubtasks = true };
+        var childRow = new TaskRowViewModel { Id = childId, ParentTaskId = parentId, Status = TaskStatus.Queued, BlockedByTaskId = parentId };
+        vm.Items.Add(parentRow);
+        vm.Items.Add(childRow);
+
+        await vm.RemoveFromQueueCommand.ExecuteAsync(parentRow);
+
+        Assert.Contains(childId, worker.DequeuedTaskIds);
+        Assert.Contains(parentId, worker.DequeuedTaskIds);
+        Assert.Equal(TaskStatus.Idle, childRow.Status);
+        Assert.Null(childRow.BlockedByTaskId);
+        Assert.Equal(TaskStatus.Idle, parentRow.Status);
+        Assert.False(parentRow.HasQueuedSubtasks);
+    }
 }
@@ -1,5 +1,6 @@
 using ClaudeDo.Data;
 using ClaudeDo.Data.Models;
+using ClaudeDo.Ui.Services;
 using ClaudeDo.Ui.ViewModels.Islands;
 using Microsoft.EntityFrameworkCore;
 using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
@@ -39,8 +40,31 @@ public class TasksIslandRemoveFromQueueTests : IDisposable
        public ClaudeDoDbContext CreateDbContext() => _create();
    }

-    private TasksIslandViewModel BuildViewModel() =>
-        new(new TestDbFactory(NewContext), worker: null);
+    // RemoveFromQueueAsync now routes the dequeue through IWorkerClient.DequeueTaskAsync (the
+    // guarded TaskStateService transition) instead of writing the DB directly. This fake performs
+    // the same write the real hub would, against the same DB, so these tests still exercise the
+    // ViewModel's cascade/read logic without needing a live worker.
+    private sealed class DequeuingWorkerClient : StubWorkerClient
+    {
+        private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
+        public DequeuingWorkerClient(IDbContextFactory<ClaudeDoDbContext> dbFactory) => _dbFactory = dbFactory;
+
+        public override async Task DequeueTaskAsync(string taskId)
+        {
+            await using var db = await _dbFactory.CreateDbContextAsync();
+            var entity = await db.Tasks.FirstOrDefaultAsync(t => t.Id == taskId && t.Status == TaskStatus.Queued);
+            if (entity is null) return;
+            entity.Status = TaskStatus.Idle;
+            entity.BlockedByTaskId = null;
+            await db.SaveChangesAsync();
+        }
+    }
+
+    private TasksIslandViewModel BuildViewModel()
+    {
+        var factory = new TestDbFactory(NewContext);
+        return new(factory, worker: new DequeuingWorkerClient(factory));
+    }

    private async Task SeedParentWithChainAsync(
        string parentId,