feat(worker): approve drives the unit merge for parents with children

ApproveReview routes a parent that has children through
PlanningMergeOrchestrator (merge parent + each Done child, set parent Done,
conflict continue/abort) instead of the parent-only ApproveAndMergeAsync.
Childless tasks are unchanged. Removes the now-redundant MergeAllPlanning hub
method (UI rewiring follows separately).

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

src/ClaudeDo.Worker/Hub/WorkerHub.cs

@@ -441,6 +441,16 @@ public sealed class WorkerHub : Microsoft.AspNetCore.SignalR.Hub
     public Task<MergeResultDto> ApproveReview(string taskId, string targetBranch)
         => HubGuard(async () =>
         {
+            bool hasChildren;
+            await using (var ctx = await _dbFactory.CreateDbContextAsync(CancellationToken.None))
+                hasChildren = await ctx.Tasks.AnyAsync(t => t.ParentTaskId == taskId, CancellationToken.None);
+
+            if (hasChildren)
+            {
+                await _planningMergeOrchestrator.StartAsync(taskId, targetBranch ?? "", CancellationToken.None);
+                return new MergeResultDto(TaskMergeService.StatusMerged, Array.Empty<string>(), null);
+            }
+
             var r = await _mergeService.ApproveAndMergeAsync(taskId, targetBranch ?? "", CancellationToken.None);
             if (r.Status == TaskMergeService.StatusBlocked)
                 throw new HubException(r.ErrorMessage ?? "approve failed");
@@ -550,10 +560,6 @@ public sealed class WorkerHub : Microsoft.AspNetCore.SignalR.Hub
             };
         }, "planning task not found");
 
-    public Task MergeAllPlanning(string planningTaskId, string targetBranch)
-        => HubGuard(() => _planningMergeOrchestrator.StartAsync(planningTaskId, targetBranch ?? "", CancellationToken.None),
-            "planning task not found");
-
     public async Task ContinuePlanningMerge(string planningTaskId)
     {
         try { await _planningMergeOrchestrator.ContinueAsync(planningTaskId, CancellationToken.None); }

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

@@ -352,4 +352,78 @@ public sealed class PlanningMergeOrchestratorTests : IDisposable
         await ctx.SaveChangesAsync();
         return (parentId, running);
     }
+
+    // ─── ApproveReview routing ──────────────────────────────────────────────
+
+    /// <summary>
+    /// Improvement parent (PlanningPhase.None) in WaitingForReview with two Done children
+    /// that each have an Active worktree → orchestrator merges both and marks the parent Done.
+    /// This mirrors the ApproveReview hub path for a parent-with-children.
+    /// </summary>
+    [Fact]
+    public async Task StartAsync_ImprovementParentInWaitingForReview_MergesBothChildrenAndLeavesDone()
+    {
+        var db = NewDb();
+        var repo = NewRepo();
+        GitRepoFixture.RunGit(repo.RepoDir, "branch", "-m", "main");
+
+        var (parentId, subA, subB) = await SeedImprovementParentWithTwoDoneChildrenAsync(db, repo);
+
+        var (orch, calls) = BuildOrchestrator(db);
+
+        await orch.StartAsync(parentId, "main", CancellationToken.None);
+
+        using var ctx = db.CreateContext();
+        var parent = ctx.Tasks.Single(t => t.Id == parentId);
+        Assert.Equal(TaskStatus.Done, parent.Status);
+        Assert.NotNull(parent.FinishedAt);
+
+        Assert.Equal(WorktreeState.Merged, ctx.Worktrees.Single(w => w.TaskId == subA).State);
+        Assert.Equal(WorktreeState.Merged, ctx.Worktrees.Single(w => w.TaskId == subB).State);
+
+        Assert.Contains(calls, c => c.Method == "PlanningMergeStarted");
+        Assert.Equal(2, calls.Count(c => c.Method == "PlanningSubtaskMerged"));
+        Assert.Contains(calls, c => c.Method == "PlanningCompleted" && (string)c.Args[0]! == parentId);
+    }
+
+    private async Task<(string parentId, string subA, string subB)> SeedImprovementParentWithTwoDoneChildrenAsync(
+        DbFixture db, GitRepoFixture repo)
+    {
+        using var ctx = db.CreateContext();
+
+        var listId = Guid.NewGuid().ToString();
+        ctx.Lists.Add(new ListEntity
+        {
+            Id = listId, Name = "test", CreatedAt = DateTime.UtcNow,
+            WorkingDir = repo.RepoDir,
+        });
+
+        var parentId = Guid.NewGuid().ToString();
+        // Improvement parent: PlanningPhase.None, status WaitingForReview (after children finished)
+        ctx.Tasks.Add(new TaskEntity
+        {
+            Id = parentId, ListId = listId, Title = "improve", CreatedAt = DateTime.UtcNow,
+            Status = TaskStatus.WaitingForReview, PlanningPhase = PlanningPhase.None, SortOrder = 0,
+        });
+
+        var subA = Guid.NewGuid().ToString();
+        var subB = Guid.NewGuid().ToString();
+        ctx.Tasks.Add(new TaskEntity
+        {
+            Id = subA, ListId = listId, Title = "child A", CreatedAt = DateTime.UtcNow,
+            ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 1,
+        });
+        ctx.Tasks.Add(new TaskEntity
+        {
+            Id = subB, ListId = listId, Title = "child B", CreatedAt = DateTime.UtcNow,
+            ParentTaskId = parentId, Status = TaskStatus.Done, SortOrder = 2,
+        });
+        await ctx.SaveChangesAsync();
+
+        SeedWorktree(ctx, repo, subA, "fileA.txt", "content A");
+        SeedWorktree(ctx, repo, subB, "fileB.txt", "content B");
+        await ctx.SaveChangesAsync();
+
+        return (parentId, subA, subB);
+    }
 }