refactor(ui): test planning detail pane via real ViewModel and restore merge-all IsEnabled binding

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

src/ClaudeDo.Ui/AssemblyInfo.cs

@@ -0,0 +1,2 @@
+using System.Runtime.CompilerServices;
+[assembly: InternalsVisibleTo("ClaudeDo.Ui.Tests")]

src/ClaudeDo.Ui/Services/IWorkerClient.cs

@@ -1,7 +1,14 @@
+using System.ComponentModel;
+using ClaudeDo.Data.Models;
+
 namespace ClaudeDo.Ui.Services;
 
-public interface IWorkerClient
+public interface IWorkerClient : INotifyPropertyChanged
 {
+    bool IsConnected { get; }
+
+    event Action<string, string, DateTime>? TaskStartedEvent;
+    event Action<string, string, string, DateTime>? TaskFinishedEvent;
     event Action<string>? TaskUpdatedEvent;
     event Action<string>? WorktreeUpdatedEvent;
     event Action<string, string>? TaskMessageEvent;
@@ -13,6 +20,13 @@ public interface IWorkerClient
     event Action<string>? PlanningCompletedEvent;
 
     Task WakeQueueAsync();
+    Task RunNowAsync(string taskId);
+    Task ContinueTaskAsync(string taskId, string followUpPrompt);
+    Task ResetTaskAsync(string taskId);
+    Task CancelTaskAsync(string taskId);
+    Task<List<AgentInfo>> GetAgentsAsync();
+    Task<ListConfigDto?> GetListConfigAsync(string listId);
+    Task UpdateTaskAgentSettingsAsync(UpdateTaskAgentSettingsDto dto);
     Task StartPlanningSessionAsync(string taskId, CancellationToken ct = default);
     Task ResumePlanningSessionAsync(string taskId, CancellationToken ct = default);
     Task DiscardPlanningSessionAsync(string taskId, CancellationToken ct = default);

src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs

@@ -16,7 +16,7 @@ namespace ClaudeDo.Ui.ViewModels.Islands;
 public sealed partial class DetailsIslandViewModel : ViewModelBase
 {
     private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
-    private readonly WorkerClient _worker;
+    private readonly IWorkerClient _worker;
     private readonly IServiceProvider _services;
 
     // Current task row (set by IslandsShellViewModel via Bind)
@@ -151,7 +151,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase
     // Set by the view so DeleteTaskCommand can show an error message
     public Func<string, System.Threading.Tasks.Task>? ShowErrorAsync { get; set; }
 
-    public DetailsIslandViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, WorkerClient worker, IServiceProvider services)
+    public DetailsIslandViewModel(IDbContextFactory<ClaudeDoDbContext> dbFactory, IWorkerClient worker, IServiceProvider services)
     {
         _dbFactory = dbFactory;
         _worker = worker;
@@ -545,7 +545,7 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase
         catch { /* best-effort */ }
     }
 
-    private void RecomputeCanMergeAll()
+    internal void RecomputeCanMergeAll()
     {
         var notDone = Subtasks.Count(c => c.Status != ClaudeDo.Data.Models.TaskStatus.Done);
         if (notDone > 0)

src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml

@@ -157,6 +157,7 @@
               <Button Content="Review combined diff"
                       Command="{Binding ReviewCombinedDiffCommand}"/>
               <Button Content="Merge all subtasks"
+                      IsEnabled="{Binding CanMergeAll}"
                       Command="{Binding MergeAllCommand}"
                       ToolTip.Tip="{Binding MergeAllDisabledReason}"/>
             </StackPanel>

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

@@ -1,45 +1,52 @@
 using System.Collections.ObjectModel;
+using System.ComponentModel;
+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;
 
 namespace ClaudeDo.Ui.Tests.ViewModels;
 
-public class DetailsIslandPlanningTests
+public class DetailsIslandPlanningTests : IDisposable
 {
-    // Minimal shim exercising RecomputeCanMergeAll logic without needing WorkerClient
+    private readonly string _dbPath;
-    private sealed class PlanningVmShim
-    {
-        public ObservableCollection<SubtaskRowViewModel> Subtasks { get; } = new();
-        public bool CanMergeAll { get; private set; }
-        public string? MergeAllDisabledReason { get; private set; }
 
-        public void RecomputeCanMergeAll()
+    public DetailsIslandPlanningTests()
     {
-            var notDone = Subtasks.Count(c => c.Status != TaskStatus.Done);
+        _dbPath = Path.Combine(Path.GetTempPath(), $"claudedo_details_test_{Guid.NewGuid():N}.db");
-            if (notDone > 0)
+        using var ctx = NewContext();
+        ctx.Database.EnsureCreated();
+    }
+
+    public void Dispose()
     {
-                CanMergeAll = false;
+        try { File.Delete(_dbPath); } catch { }
-                MergeAllDisabledReason = $"{notDone} subtask(s) not done";
+        try { File.Delete(_dbPath + "-wal"); } catch { }
-                return;
+        try { File.Delete(_dbPath + "-shm"); } catch { }
     }
-            var badWt = Subtasks.FirstOrDefault(c =>
+
-                c.WorktreeState == WorktreeState.Discarded ||
+    private ClaudeDoDbContext NewContext()
-                c.WorktreeState == WorktreeState.Kept);
-            if (badWt is not null)
     {
-                CanMergeAll = false;
+        var opts = new DbContextOptionsBuilder<ClaudeDoDbContext>()
-                MergeAllDisabledReason = "at least one worktree was discarded/kept";
+            .UseSqlite($"Data Source={_dbPath}")
-                return;
+            .Options;
-            }
+        return new ClaudeDoDbContext(opts);
-            CanMergeAll = true;
-            MergeAllDisabledReason = null;
     }
+
+    private sealed class TestDbFactory : IDbContextFactory<ClaudeDoDbContext>
+    {
+        private readonly Func<ClaudeDoDbContext> _create;
+        public TestDbFactory(Func<ClaudeDoDbContext> create) => _create = create;
+        public ClaudeDoDbContext CreateDbContext() => _create();
     }
 
     private sealed class FakeWorkerClient : IWorkerClient
     {
+        public event PropertyChangedEventHandler? PropertyChanged;
+        public event Action<string, string, DateTime>? TaskStartedEvent;
+        public event Action<string, string, string, DateTime>? TaskFinishedEvent;
         public event Action<string>? TaskUpdatedEvent;
         public event Action<string>? WorktreeUpdatedEvent;
         public event Action<string, string>? TaskMessageEvent;
@@ -49,9 +56,17 @@ public class DetailsIslandPlanningTests
         public event Action<string>? PlanningMergeAbortedEvent;
         public event Action<string>? PlanningCompletedEvent;
 
+        public bool IsConnected => false;
         public MergeTargetsDto? MergeTargetsResult { get; set; }
 
         public Task WakeQueueAsync() => Task.CompletedTask;
+        public Task RunNowAsync(string taskId) => Task.CompletedTask;
+        public Task ContinueTaskAsync(string taskId, string followUpPrompt) => Task.CompletedTask;
+        public Task ResetTaskAsync(string taskId) => Task.CompletedTask;
+        public Task CancelTaskAsync(string taskId) => Task.CompletedTask;
+        public Task<List<AgentInfo>> GetAgentsAsync() => Task.FromResult(new List<AgentInfo>());
+        public Task<ListConfigDto?> GetListConfigAsync(string listId) => Task.FromResult<ListConfigDto?>(null);
+        public Task UpdateTaskAgentSettingsAsync(UpdateTaskAgentSettingsDto dto) => Task.CompletedTask;
         public Task StartPlanningSessionAsync(string taskId, CancellationToken ct = default) => Task.CompletedTask;
         public Task ResumePlanningSessionAsync(string taskId, CancellationToken ct = default) => Task.CompletedTask;
         public Task DiscardPlanningSessionAsync(string taskId, CancellationToken ct = default) => Task.CompletedTask;
@@ -65,70 +80,135 @@ public class DetailsIslandPlanningTests
         public Task MergeAllPlanningAsync(string planningTaskId, string targetBranch) => Task.CompletedTask;
         public Task ContinuePlanningMergeAsync(string planningTaskId) => Task.CompletedTask;
         public Task AbortPlanningMergeAsync(string planningTaskId) => Task.CompletedTask;
+    }
 
-        public void FireTaskUpdated(string id) => TaskUpdatedEvent?.Invoke(id);
+    private sealed class NullServiceProvider : IServiceProvider
-        public void FireWorktreeUpdated(string id) => WorktreeUpdatedEvent?.Invoke(id);
+    {
+        public object? GetService(Type serviceType) => null;
+    }
+
+    private DetailsIslandViewModel BuildVm(FakeWorkerClient worker)
+    {
+        var factory = new TestDbFactory(NewContext);
+        return new DetailsIslandViewModel(factory, worker, new NullServiceProvider());
     }
 
     private static SubtaskRowViewModel MakeSubtask(TaskStatus status, WorktreeState wt = WorktreeState.Active) =>
         new() { Id = Guid.NewGuid().ToString(), Title = "t", Status = status, WorktreeState = wt };
 
+    // ── CanMergeAll tests exercising the real VM ─────────────────────────────
+
     [Fact]
     public void CanMergeAll_AllChildrenDoneActiveWorktrees_True()
     {
-        var shim = new PlanningVmShim();
+        var vm = BuildVm(new FakeWorkerClient());
-        shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
+        vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
-        shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
+        vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
 
-        shim.RecomputeCanMergeAll();
+        vm.RecomputeCanMergeAll();
 
-        Assert.True(shim.CanMergeAll);
+        Assert.True(vm.CanMergeAll);
-        Assert.Null(shim.MergeAllDisabledReason);
+        Assert.Null(vm.MergeAllDisabledReason);
     }
 
     [Fact]
     public void CanMergeAll_AnyChildNotDone_FalseWithReason()
     {
-        var shim = new PlanningVmShim();
+        var vm = BuildVm(new FakeWorkerClient());
-        shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
+        vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
-        shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
+        vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
-        shim.Subtasks.Add(MakeSubtask(TaskStatus.Running, WorktreeState.Active));
+        vm.Subtasks.Add(MakeSubtask(TaskStatus.Running, WorktreeState.Active));
 
-        shim.RecomputeCanMergeAll();
+        vm.RecomputeCanMergeAll();
 
-        Assert.False(shim.CanMergeAll);
+        Assert.False(vm.CanMergeAll);
-        Assert.NotNull(shim.MergeAllDisabledReason);
+        Assert.NotNull(vm.MergeAllDisabledReason);
-        Assert.Contains("1 subtask", shim.MergeAllDisabledReason, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("1 subtask", vm.MergeAllDisabledReason, StringComparison.OrdinalIgnoreCase);
-        Assert.Contains("not done", shim.MergeAllDisabledReason, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("not done", vm.MergeAllDisabledReason, StringComparison.OrdinalIgnoreCase);
     }
 
     [Fact]
     public void CanMergeAll_AnyChildDiscarded_FalseWithReason()
     {
-        var shim = new PlanningVmShim();
+        var vm = BuildVm(new FakeWorkerClient());
-        shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
+        vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
-        shim.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Discarded));
+        vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Discarded));
 
-        shim.RecomputeCanMergeAll();
+        vm.RecomputeCanMergeAll();
 
-        Assert.False(shim.CanMergeAll);
+        Assert.False(vm.CanMergeAll);
-        Assert.NotNull(shim.MergeAllDisabledReason);
+        Assert.NotNull(vm.MergeAllDisabledReason);
         Assert.True(
-            shim.MergeAllDisabledReason!.Contains("discarded", StringComparison.OrdinalIgnoreCase) ||
+            vm.MergeAllDisabledReason!.Contains("discarded", StringComparison.OrdinalIgnoreCase) ||
-            shim.MergeAllDisabledReason.Contains("kept", StringComparison.OrdinalIgnoreCase));
+            vm.MergeAllDisabledReason.Contains("kept", StringComparison.OrdinalIgnoreCase));
     }
 
     [Fact]
-    public void MergeTargetBranches_LoadedFromWorkerOnPlanningParent()
+    public void CanMergeAll_AnyChildKept_FalseWithReason()
     {
-        var fake = new FakeWorkerClient();
+        var vm = BuildVm(new FakeWorkerClient());
-        fake.MergeTargetsResult = new MergeTargetsDto("main", new[] { "main", "dev" });
+        vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Active));
+        vm.Subtasks.Add(MakeSubtask(TaskStatus.Done, WorktreeState.Kept));
 
-        var result = fake.GetMergeTargetsAsync("any-task-id").GetAwaiter().GetResult();
+        vm.RecomputeCanMergeAll();
 
-        Assert.NotNull(result);
+        Assert.False(vm.CanMergeAll);
-        Assert.Equal("main", result!.DefaultBranch);
+        Assert.NotNull(vm.MergeAllDisabledReason);
-        Assert.Contains("main", result.LocalBranches);
+        Assert.True(
-        Assert.Contains("dev", result.LocalBranches);
+            vm.MergeAllDisabledReason!.Contains("kept", StringComparison.OrdinalIgnoreCase) ||
+            vm.MergeAllDisabledReason.Contains("discarded", StringComparison.OrdinalIgnoreCase));
+    }
+
+    // ── Branch-load test exercising the VM via Bind ──────────────────────────
+
+    [Fact]
+    public async Task MergeTargetBranches_LoadedFromWorkerOnPlanningParent()
+    {
+        // Seed a Planning parent with one child that has a worktree
+        const string parentId = "parent-1";
+        const string childId  = "child-1";
+        const string listId   = "list-1";
+
+        await using (var ctx = NewContext())
+        {
+            ctx.Lists.Add(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
+            ctx.Tasks.Add(new TaskEntity
+            {
+                Id = parentId, ListId = listId, Title = "Parent",
+                Status = TaskStatus.Planning, CreatedAt = DateTime.UtcNow,
+            });
+            ctx.Tasks.Add(new TaskEntity
+            {
+                Id = childId, ListId = listId, Title = "Child",
+                Status = TaskStatus.Done, ParentTaskId = parentId, CreatedAt = DateTime.UtcNow,
+            });
+            ctx.Set<WorktreeEntity>().Add(new WorktreeEntity
+            {
+                TaskId = childId, Path = "/tmp/wt", BranchName = "branch",
+                BaseCommit = "abc", CreatedAt = DateTime.UtcNow,
+            });
+            await ctx.SaveChangesAsync();
+        }
+
+        var fake = new FakeWorkerClient
+        {
+            MergeTargetsResult = new MergeTargetsDto("main", new[] { "main", "dev" }),
+        };
+
+        var vm = BuildVm(fake);
+
+        // Bind triggers BindAsync → LoadPlanningChildrenAsync → GetMergeTargetsAsync
+        var parentRow = new TaskRowViewModel { Id = parentId };
+        parentRow.Status = TaskStatus.Planning;
+        vm.Bind(parentRow);
+
+        // Wait for the background load to settle
+        var deadline = DateTime.UtcNow.AddSeconds(5);
+        while (DateTime.UtcNow < deadline && vm.MergeTargetBranches.Count == 0)
+            await Task.Delay(20);
+
+        Assert.Contains("main", vm.MergeTargetBranches);
+        Assert.Contains("dev",  vm.MergeTargetBranches);
+        Assert.Equal("main", vm.SelectedMergeTarget);
     }
 }