fix(ui): stop the reconcile ticks from destroying user state

The 4s reconcile tick was added to three long-lived surfaces. On two of
them it reloads by rebuilding every row instance, which silently threw
away whatever the user had built up since the overlay opened; on the
third it healed a row's data but left it in the wrong section.

- WorktreesOverview: LoadAsync clears Rows, SelectedCount, ConflictRows
  and BatchProgress, so batch-merge ticks, the highlighted row and a
  finished batch's outcome badges were wiped every four seconds --
  assembling a multi-worktree selection was impossible. Carry that state
  across the reload, keyed by task id, and re-point SelectedRow at the
  fresh instance (or clear it when the worktree is gone).
- MergeHelperSelection: the remember/restore had no re-entrancy guard, so
  a second tick entering between the first one's reload and its restore
  snapshotted rows already back at IsTickedByDefault and wrote that
  default back, re-ticking what the user had unticked. One tick at a time,
  and hold the row instances instead of a value snapshot so a tick landed
  during the await survives.
- TasksIsland: the tick deliberately never called Regroup because Phase 2b
  owned Rows in parallel. 2b has landed, so a healed task that went Done
  stayed in the Open section under a stale count, and a healed depends-on
  link never pulled its dependent under the chain head. Regroup when a
  patch moved a grouping input, gated on a cheap key so an idle tick stays
  free.

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

@@ -0,0 +1,120 @@
+using ClaudeDo.Data.Models;
+using ClaudeDo.Ui.Services;
+using ClaudeDo.Ui.ViewModels.Modals;
+using Xunit;
+using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
+
+namespace ClaudeDo.Ui.Tests.ViewModels;
+
+// The overview's 4s reconcile tick goes through LoadAsync, which rebuilds every row instance and
+// resets SelectedCount/ConflictRows/BatchProgress. Left bare, that wipes the user's batch-merge
+// ticks and the highlighted row every four seconds — assembling a multi-worktree selection would
+// be impossible. The tick has to carry that state across the reload.
+public class WorktreesOverviewReconcileTickTests
+{
+    private sealed class FakeWorker : StubWorkerClient
+    {
+        public List<WorktreeOverviewDto> Worktrees { get; set; } = new();
+        public override Task<List<WorktreeOverviewDto>> GetWorktreesOverviewAsync(string? listId)
+            => Task.FromResult(Worktrees.ToList());
+        public override Task<MergeTargetsDto?> GetMergeTargetsAsync(string taskId)
+            => Task.FromResult<MergeTargetsDto?>(new MergeTargetsDto("main", new[] { "main" }));
+    }
+
+    private sealed class NoopMergeCoordinator : IMergeCoordinator
+    {
+        public Task ResolveConflictAsync(string taskId, string targetBranch) => Task.CompletedTask;
+    }
+
+    private static WorktreeOverviewDto Wt(string taskId, WorktreeState state = WorktreeState.Active) =>
+        new(taskId, $"Task {taskId}", TaskStatus.WaitingForReview, "L1", "Work",
+            $@"C:\wt\{taskId}", $"claudedo/{taskId}", "base0", state, "+1 -0",
+            DateTime.UtcNow, PathExistsOnDisk: true);
+
+    private static async Task<(WorktreesOverviewModalViewModel Vm, FakeWorker Worker)> BuildLoadedAsync()
+    {
+        var worker = new FakeWorker { Worktrees = { Wt("a"), Wt("b"), Wt("c") } };
+        var vm = new WorktreesOverviewModalViewModel(
+            worker, () => throw new InvalidOperationException("no diff vm in this test"), new NoopMergeCoordinator());
+        vm.Configure("L1", "Work");
+        await vm.LoadAsync();
+        return (vm, worker);
+    }
+
+    [Fact]
+    public async Task Tick_keeps_the_batch_merge_ticks()
+    {
+        var (vm, _) = await BuildLoadedAsync();
+
+        vm.Rows.Single(r => r.TaskId == "a").IsChecked = true;
+        vm.Rows.Single(r => r.TaskId == "c").IsChecked = true;
+        Assert.Equal(2, vm.SelectedCount);
+
+        await vm.ReconcileTickAsync();
+
+        Assert.True(vm.Rows.Single(r => r.TaskId == "a").IsChecked);
+        Assert.False(vm.Rows.Single(r => r.TaskId == "b").IsChecked);
+        Assert.True(vm.Rows.Single(r => r.TaskId == "c").IsChecked);
+        Assert.Equal(2, vm.SelectedCount);
+    }
+
+    [Fact]
+    public async Task Tick_re_points_the_selected_row_at_the_fresh_instance()
+    {
+        var (vm, _) = await BuildLoadedAsync();
+
+        vm.SelectRow(vm.Rows.Single(r => r.TaskId == "b"));
+
+        await vm.ReconcileTickAsync();
+
+        Assert.NotNull(vm.SelectedRow);
+        Assert.Equal("b", vm.SelectedRow!.TaskId);
+        // Not the stale pre-reload instance: it must be the row actually in the collection.
+        Assert.Contains(vm.Rows, r => ReferenceEquals(r, vm.SelectedRow));
+        Assert.True(vm.SelectedRow.IsSelected);
+    }
+
+    [Fact]
+    public async Task Tick_clears_the_selection_when_that_worktree_is_gone()
+    {
+        var (vm, worker) = await BuildLoadedAsync();
+
+        vm.SelectRow(vm.Rows.Single(r => r.TaskId == "b"));
+        worker.Worktrees.RemoveAll(w => w.TaskId == "b");
+
+        await vm.ReconcileTickAsync();
+
+        Assert.Null(vm.SelectedRow);
+    }
+
+    [Fact]
+    public async Task Tick_keeps_a_finished_batch_outcome_and_its_conflict_row()
+    {
+        var (vm, _) = await BuildLoadedAsync();
+
+        vm.Rows.Single(r => r.TaskId == "a").MergeOutcome = BatchMergeOutcome.Merged;
+        vm.Rows.Single(r => r.TaskId == "b").MergeOutcome = BatchMergeOutcome.Conflict;
+
+        await vm.ReconcileTickAsync();
+
+        Assert.Equal(BatchMergeOutcome.Merged, vm.Rows.Single(r => r.TaskId == "a").MergeOutcome);
+        Assert.Equal(BatchMergeOutcome.Conflict, vm.Rows.Single(r => r.TaskId == "b").MergeOutcome);
+        Assert.Single(vm.ConflictRows);
+        Assert.Equal("b", vm.ConflictRows[0].TaskId);
+    }
+
+    [Fact]
+    public async Task Tick_leaves_a_newly_appeared_worktree_unticked()
+    {
+        var (vm, worker) = await BuildLoadedAsync();
+
+        vm.Rows.Single(r => r.TaskId == "a").IsChecked = true;
+        worker.Worktrees.Add(Wt("d"));
+
+        await vm.ReconcileTickAsync();
+
+        Assert.True(vm.Rows.Single(r => r.TaskId == "a").IsChecked);
+        Assert.False(vm.Rows.Single(r => r.TaskId == "d").IsChecked);
+        Assert.Equal(1, vm.SelectedCount);
+    }
+}