feat(ui): add conflict resolution dialog for planning merge-all

Opens a modal when PlanningMergeConflict fires, listing conflicted files
with options to open in VS Code, continue, or abort the merge.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs

@@ -4,9 +4,12 @@ using System.Threading;
 using System.Threading.Tasks;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
+using ClaudeDo.Data;
 using ClaudeDo.Data.Models;
 using ClaudeDo.Ui.Services;
 using ClaudeDo.Ui.ViewModels.Islands;
+using ClaudeDo.Ui.ViewModels.Planning;
+using Microsoft.EntityFrameworkCore;
 
 namespace ClaudeDo.Ui.ViewModels;
 
@@ -27,6 +30,10 @@ public sealed partial class IslandsShellViewModel : ViewModelBase
 
     private readonly UpdateCheckService _updateCheck;
     private readonly InstallerLocator _installerLocator;
+    private readonly IDbContextFactory<ClaudeDoDbContext>? _dbFactory;
+
+    // Set by MainWindow to open the conflict resolution dialog.
+    public Func<ConflictResolutionViewModel, Task>? ShowConflictDialog { get; set; }
 
     [ObservableProperty] private bool _isUpdateBannerVisible;
     [ObservableProperty] private string? _updateBannerLatestVersion;
@@ -84,6 +91,47 @@ public sealed partial class IslandsShellViewModel : ViewModelBase
         WorkerLogText = null;
     }
 
+    private void OnPlanningMergeConflict(string planningTaskId, string subtaskId, IReadOnlyList<string> conflictedFiles)
+    {
+        // Already on UI thread (WorkerClient dispatches via Dispatcher.UIThread.Post).
+        _ = OpenConflictDialogAsync(planningTaskId, subtaskId, conflictedFiles);
+    }
+
+    private async Task OpenConflictDialogAsync(string planningTaskId, string subtaskId, IReadOnlyList<string> conflictedFiles)
+    {
+        if (ShowConflictDialog == null || _dbFactory == null) return;
+
+        string subtaskTitle = subtaskId;
+        string worktreePath = System.Environment.CurrentDirectory;
+        string targetBranch = Worker?.LastMergeAllTarget ?? "main";
+
+        try
+        {
+            await using var ctx = await _dbFactory.CreateDbContextAsync();
+            var entity = await ctx.Tasks
+                .Include(t => t.Worktree)
+                .AsNoTracking()
+                .FirstOrDefaultAsync(t => t.Id == subtaskId);
+            if (entity != null)
+            {
+                subtaskTitle = entity.Title;
+                if (entity.Worktree?.Path is { } p)
+                    worktreePath = p;
+            }
+        }
+        catch { /* Non-fatal: fall back to subtaskId and cwd */ }
+
+        var vm = new ConflictResolutionViewModel(
+            Worker!,
+            planningTaskId,
+            subtaskTitle,
+            targetBranch,
+            conflictedFiles,
+            worktreePath);
+
+        await ShowConflictDialog(vm);
+    }
+
     // For tests only — does NOT wire up events.
     internal IslandsShellViewModel() { }
 
@@ -93,11 +141,13 @@ public sealed partial class IslandsShellViewModel : ViewModelBase
         DetailsIslandViewModel details,
         WorkerClient worker,
         UpdateCheckService updateCheck,
-        InstallerLocator installerLocator)
+        InstallerLocator installerLocator,
+        IDbContextFactory<ClaudeDoDbContext> dbFactory)
     {
         Lists = lists; Tasks = tasks; Details = details; Worker = worker;
         _updateCheck = updateCheck;
         _installerLocator = installerLocator;
+        _dbFactory = dbFactory;
         Lists.SelectionChanged += (_, _) => Tasks.LoadForList(Lists.SelectedList);
         Tasks.SelectionChanged += (_, _) => Details.Bind(Tasks.SelectedTask);
         Tasks.TasksChanged     += (_, _) => _ = Lists.RefreshCountsAsync();
@@ -122,6 +172,7 @@ public sealed partial class IslandsShellViewModel : ViewModelBase
             }
         };
         Worker.WorkerLogReceivedEvent += OnWorkerLogReceived;
+        Worker.PlanningMergeConflictEvent += OnPlanningMergeConflict;
         _clearTimer.Elapsed += (_, _) =>
         {
             if (Dispatcher.UIThread.CheckAccess())

src/ClaudeDo.Ui/ViewModels/Planning/ConflictResolutionViewModel.cs

@@ -0,0 +1,83 @@
+using System.Diagnostics;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using ClaudeDo.Ui.Services;
+
+namespace ClaudeDo.Ui.ViewModels.Planning;
+
+public sealed partial class ConflictResolutionViewModel : ObservableObject
+{
+    private readonly IWorkerClient _worker;
+    private readonly string _planningTaskId;
+    private readonly string _worktreePath;
+
+    public string SubtaskTitle { get; }
+    public string TargetBranch { get; }
+    public IReadOnlyList<string> ConflictedFiles { get; }
+
+    [ObservableProperty] private string? _vsCodeError;
+    [ObservableProperty] private string? _actionError;
+
+    public Action? CloseRequested { get; set; }
+
+    public ConflictResolutionViewModel(
+        IWorkerClient worker,
+        string planningTaskId,
+        string subtaskTitle,
+        string targetBranch,
+        IReadOnlyList<string> conflictedFiles,
+        string worktreePath)
+    {
+        _worker = worker;
+        _planningTaskId = planningTaskId;
+        _worktreePath = worktreePath;
+        SubtaskTitle = subtaskTitle;
+        TargetBranch = targetBranch;
+        ConflictedFiles = conflictedFiles;
+    }
+
+    [RelayCommand]
+    private void OpenInVsCode()
+    {
+        try
+        {
+            var args = string.Join(" ", ConflictedFiles.Select(f => $"\"{f}\""));
+            Process.Start(new ProcessStartInfo
+            {
+                FileName = "code",
+                Arguments = args,
+                WorkingDirectory = _worktreePath,
+                UseShellExecute = true,
+            });
+            VsCodeError = null;
+        }
+        catch (Exception ex)
+        {
+            VsCodeError = $"Could not launch VS Code: {ex.Message}. Paths are listed above — copy them manually.";
+        }
+    }
+
+    [RelayCommand]
+    private async Task ContinueAsync()
+    {
+        ActionError = null;
+        try
+        {
+            await _worker.ContinuePlanningMergeAsync(_planningTaskId);
+            CloseRequested?.Invoke();
+        }
+        catch (Exception ex) { ActionError = ex.Message; }
+    }
+
+    [RelayCommand]
+    private async Task AbortAsync()
+    {
+        ActionError = null;
+        try
+        {
+            await _worker.AbortPlanningMergeAsync(_planningTaskId);
+            CloseRequested?.Invoke();
+        }
+        catch (Exception ex) { ActionError = ex.Message; }
+    }
+}