Merge remote-tracking branch 'origin/main'

TryInvokeAsync swallowed all exceptions including HubException, so a
blocked merge (uncommitted changes in target, mid-merge state, inactive
worktree) returned null silently — the task stayed WaitingForReview with
no feedback shown.  Switch to a direct _hub.InvokeAsync so both VM
catch blocks (TasksIsland ErrorReported, DetailsIsland ShowErrorAsync)
actually fire.

Add regression tests for both call sites verifying that a throwing
worker causes the error to be reported.

src/ClaudeDo.App/App.axaml.cs

@@ -3,6 +3,7 @@ using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Markup.Xaml;
+using ClaudeDo.Ui;
 using ClaudeDo.Ui.Services;
 using ClaudeDo.Ui.ViewModels;
 using ClaudeDo.Ui.Views;
@@ -22,6 +23,8 @@ public partial class App : Application
     public override void Initialize()
     {
         AvaloniaXamlLoader.Load(this);
+        if (_services?.GetService<AppSettings>() is { } settings)
+            AccentPresetService.Apply(AccentPresets.Find(settings.AccentPreset));
     }
 
     public override void OnFrameworkInitializationCompleted()

src/ClaudeDo.Localization/locales/de.json

@@ -31,7 +31,11 @@
       "weekdayFriday": "Freitag",
       "weekdaySaturday": "Samstag",
       "sessionSkills": "Session-Skills",
-      "sessionSkillsHint": "Gilt für jede Aufgabe. Kombiniert sich mit Listen- und Aufgaben-Auswahl."
+      "sessionSkillsHint": "Gilt für jede Aufgabe. Kombiniert sich mit Listen- und Aufgaben-Auswahl.",
+      "accentPreset": "Akzentfarbe",
+      "accentPresetMoss": "Moos",
+      "accentPresetPeat": "Torf",
+      "accentPresetSea": "Meer"
     },
     "worktrees": {
       "strategy": "Strategie",
@@ -117,6 +121,7 @@
   },
   "tasks": {
     "showCompletedTip": "Abgeschlossene anzeigen",
+    "letClaudeTip": "Claude machen lassen",
     "listSettingsTip": "Listeneinstellungen",
     "addPlaceholder": "Aufgabe hinzufügen…",
     "enterKey": "ENTER",

src/ClaudeDo.Localization/locales/en.json

@@ -31,7 +31,11 @@
       "weekdayFriday": "Friday",
       "weekdaySaturday": "Saturday",
       "sessionSkills": "Session skills",
-      "sessionSkillsHint": "Applied to every task. Combines with list- and task-level selections."
+      "sessionSkillsHint": "Applied to every task. Combines with list- and task-level selections.",
+      "accentPreset": "Accent color",
+      "accentPresetMoss": "Moss",
+      "accentPresetPeat": "Peat",
+      "accentPresetSea": "Sea"
     },
     "worktrees": {
       "strategy": "Strategy",
@@ -117,6 +121,7 @@
   },
   "tasks": {
     "showCompletedTip": "Show completed",
+    "letClaudeTip": "Let Claude handle it",
     "listSettingsTip": "List settings",
     "addPlaceholder": "Add a task…",
     "enterKey": "ENTER",

src/ClaudeDo.Ui/AccentPresets.cs

@@ -0,0 +1,43 @@
+using Avalonia.Media;
+using ClaudeDo.Ui.Localization;
+using ClaudeDo.Ui.ViewModels;
+using CommunityToolkit.Mvvm.ComponentModel;
+
+namespace ClaudeDo.Ui;
+
+public sealed record AccentPreset(string Name, string Accent, string Dim, string Soft, string Glow);
+
+public static class AccentPresets
+{
+    // Hue 88 — moss/sage green (original)
+    public static readonly AccentPreset Moss = new("moss", "#FF7C9166", "#FF64785A", "#FF3E4B39", "#387C9166");
+    // Hue ~40 — warm earthy brown/terra
+    public static readonly AccentPreset Peat = new("peat", "#FF9A7B5C", "#FF7F6449", "#FF4D3C2C", "#389A7B5C");
+    // Hue ~180 — cool teal/sea-green
+    public static readonly AccentPreset Sea  = new("sea",  "#FF5B8F8C", "#FF4A7573", "#FF263D3C", "#385B8F8C");
+
+    public static readonly IReadOnlyList<AccentPreset> All = [Moss, Peat, Sea];
+    public static AccentPreset Default => Moss;
+
+    public static AccentPreset Find(string? name) =>
+        All.FirstOrDefault(p => p.Name == name) ?? Default;
+}
+
+public sealed partial class AccentPresetSwatchViewModel : ViewModelBase
+{
+    public AccentPreset Preset { get; }
+
+    [ObservableProperty] private bool _isSelected;
+
+    public Color DisplayColor { get; }
+
+    public string DisplayName =>
+        Loc.T($"settings.general.accentPreset{char.ToUpperInvariant(Preset.Name[0])}{Preset.Name.Substring(1)}");
+
+    public AccentPresetSwatchViewModel(AccentPreset preset, bool selected)
+    {
+        Preset = preset;
+        _isSelected = selected;
+        DisplayColor = Color.Parse(preset.Accent);
+    }
+}

src/ClaudeDo.Ui/AppSettings.cs

@@ -8,6 +8,7 @@ public sealed class AppSettings
     public string DbPath { get; set; } = "~/.todo-app/todo.db";
     public string SignalRUrl { get; set; } = "http://127.0.0.1:47821/hub";
     public string Language { get; set; } = "";
+    public string AccentPreset { get; set; } = "";
 
     private static readonly string ConfigPath = Paths.Expand("~/.todo-app/ui.config.json");
 

src/ClaudeDo.Ui/Services/AccentPresetService.cs

@@ -0,0 +1,24 @@
+using Avalonia;
+using Avalonia.Media;
+
+namespace ClaudeDo.Ui.Services;
+
+public static class AccentPresetService
+{
+    public static void Apply(AccentPreset preset)
+    {
+        if (Application.Current is not { } app) return;
+
+        SetBrushColor(app, "AccentBrush",     preset.Accent);
+        SetBrushColor(app, "AccentDimBrush",  preset.Dim);
+        SetBrushColor(app, "AccentSoftBrush", preset.Soft);
+        SetBrushColor(app, "AccentGlowBrush", preset.Glow);
+        SetBrushColor(app, "MossBrush",       preset.Accent);
+    }
+
+    private static void SetBrushColor(Application app, string key, string hex)
+    {
+        if (app.TryGetResource(key, null, out var value) && value is SolidColorBrush brush)
+            brush.Color = Color.Parse(hex);
+    }
+}

src/ClaudeDo.Ui/Services/WorkerClient.cs

@@ -450,10 +450,10 @@ public partial class WorkerClient : ObservableObject, IAsyncDisposable, IWorkerC
         await _hub.InvokeAsync("SetTaskStatus", taskId, status.ToString());
     }
 
-    public Task<MergeResultDto?> ApproveReviewAsync(string taskId, string targetBranch)
+    public async Task<MergeResultDto?> ApproveReviewAsync(string taskId, string targetBranch)
     {
         LastApproveTarget = targetBranch;
-        return TryInvokeAsync<MergeResultDto>("ApproveReview", taskId, targetBranch);
+        return await _hub.InvokeAsync<MergeResultDto>("ApproveReview", taskId, targetBranch);
     }
 
     public Task<MergePreviewDto?> PreviewMergeAsync(string taskId, string targetBranch)

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

@@ -72,6 +72,12 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
     [ObservableProperty] private string _completedHeader = "";
     [ObservableProperty] private bool _showNotesRow;
     [ObservableProperty] private bool _isMyDayList;
+    [ObservableProperty] private bool _isLetClaudeVisible;
+
+    public event EventHandler? LetClaudeHandleRequested;
+
+    [RelayCommand]
+    private void LetClaudeHandle() => LetClaudeHandleRequested?.Invoke(this, EventArgs.Empty);
 
     internal Task? LoadTask { get; private set; }
 
@@ -211,8 +217,11 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
 
     private void OnCurrentListPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
     {
-        if (e.PropertyName == nameof(ListNavItemViewModel.Name) && sender is ListNavItemViewModel vm)
+        if (sender is not ListNavItemViewModel vm) return;
+        if (e.PropertyName == nameof(ListNavItemViewModel.Name))
             HeaderTitle = vm.Name;
+        else if (e.PropertyName == nameof(ListNavItemViewModel.WorkingDir))
+            IsLetClaudeVisible = vm.Kind == ListKind.User && !string.IsNullOrWhiteSpace(vm.WorkingDir);
     }
 
     public void LoadForList(ListNavItemViewModel? list)
@@ -237,12 +246,13 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         HasCompleted  = false;
         ShowOpenLabel = false;
         ShowNotesRow  = false;
-        if (list is null) { LoadTask = Task.CompletedTask; return; }
+        if (list is null) { IsLetClaudeVisible = false; LoadTask = Task.CompletedTask; return; }
 
         HeaderTitle = list.Name;
         HeaderEyebrow = DateTime.Now.ToString("dddd · MMM dd", CultureInfo.InvariantCulture).ToUpperInvariant();
         ShowNotesRow = list.Id == "smart:my-day";
         IsMyDayList  = list.Id == "smart:my-day";
+        IsLetClaudeVisible = list.Kind == ListKind.User && !string.IsNullOrWhiteSpace(list.WorkingDir);
 
         LoadTask = LoadForListAsync(list, ct);
     }
@@ -443,6 +453,7 @@ public sealed partial class TasksIslandViewModel : ViewModelBase, IDisposable
         row.ShowListChip = _currentList?.Kind == ListKind.Virtual;
         Items.Add(row);
         Regroup();
+        SelectedTask = row;
         NewTaskTitle = "";
         UpdateSubtitle();
         TasksChanged?.Invoke(this, EventArgs.Empty);

src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs

@@ -251,6 +251,11 @@ public sealed partial class IslandsShellViewModel : ViewModelBase, IDisposable
             if (Lists.SelectedList is { } row)
                 Lists.OpenListSettingsCommand.Execute(row);
         };
+        Tasks.LetClaudeHandleRequested += (_, _) =>
+        {
+            if (Lists.SelectedList is { } row)
+                Lists.LetClaudeHandleListCommand.Execute(row);
+        };
         Details.CloseDetail = () => Tasks.SelectedTask = null;
         Details.DeleteFromList = row =>
         {

src/ClaudeDo.Ui/ViewModels/Modals/Settings/GeneralSettingsTabViewModel.cs

@@ -4,6 +4,7 @@ using ClaudeDo.Localization;
 using ClaudeDo.Ui.Services;
 using ClaudeDo.Ui.ViewModels.Agent;
 using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
 
 namespace ClaudeDo.Ui.ViewModels.Modals.Settings;
 
@@ -27,6 +28,27 @@ public sealed partial class GeneralSettingsTabViewModel : ViewModelBase
 
     public ObservableCollection<SelectableSkillViewModel> SessionSkills { get; } = new();
 
+    public ObservableCollection<AccentPresetSwatchViewModel> AccentPresetSwatches { get; } = new();
+    private Action<string>? _persistAccent;
+
+    public void InitAccentPresets(string saved, Action<string> persist)
+    {
+        _persistAccent = persist;
+        var current = AccentPresets.Find(saved);
+        AccentPresetSwatches.Clear();
+        foreach (var p in AccentPresets.All)
+            AccentPresetSwatches.Add(new AccentPresetSwatchViewModel(p, p.Name == current.Name));
+    }
+
+    [RelayCommand]
+    private void SelectAccentPreset(AccentPreset preset)
+    {
+        foreach (var s in AccentPresetSwatches)
+            s.IsSelected = s.Preset.Name == preset.Name;
+        AccentPresetService.Apply(preset);
+        _persistAccent?.Invoke(preset.Name);
+    }
+
     /// <summary>One editable row per model alias: the effort and turn budget a run gets under that
     /// model. Supplies the global defaults; list- and task-level max-turns overrides still win.</summary>
     public ObservableCollection<ModelPresetRowViewModel> ModelPresets { get; } = new();

src/ClaudeDo.Ui/ViewModels/Modals/SettingsModalViewModel.cs

@@ -36,6 +36,11 @@ public sealed partial class SettingsModalViewModel : ViewModelBase
             appSettings.Language = code;
             appSettings.Save();
         });
+        General.InitAccentPresets(appSettings.AccentPreset, preset =>
+        {
+            appSettings.AccentPreset = preset;
+            appSettings.Save();
+        });
         Worktrees = new WorktreesSettingsTabViewModel(worker);
         Files = new FilesSettingsTabViewModel(worker);
         Prime = prime;

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

@@ -47,6 +47,13 @@
             <MenuItem Header="{loc:Tr tasks.ctxMarkAs}">
               <MenuItem Header="{loc:Tr tasks.ctxMarkDone}"      Tag="Done"      Click="OnSetStatusClick"/>
               <MenuItem Header="{loc:Tr tasks.ctxMarkCancelled}" Tag="Cancelled" Click="OnSetStatusClick"/>
+              <Separator/>
+              <MenuItem Header="{loc:Tr tasks.ctxMarkManual}"
+                        IsVisible="{Binding !IsManual}"
+                        Click="OnToggleManualClick"/>
+              <MenuItem Header="{loc:Tr tasks.ctxMarkClaudeTask}"
+                        IsVisible="{Binding IsManual}"
+                        Click="OnToggleManualClick"/>
             </MenuItem>
             <Separator/>
             <MenuItem Header="{loc:Tr tasks.ctxOpenConPtySession}"
@@ -77,13 +84,6 @@
             <MenuItem Header="{loc:Tr tasks.ctxRemoveFromMyDay}"
                       IsVisible="{Binding IsMyDay}"
                       Click="OnRemoveFromMyDayClick"/>
-            <Separator/>
-            <MenuItem Header="{loc:Tr tasks.ctxMarkManual}"
-                      IsVisible="{Binding !IsManual}"
-                      Click="OnToggleManualClick"/>
-            <MenuItem Header="{loc:Tr tasks.ctxMarkClaudeTask}"
-                      IsVisible="{Binding IsManual}"
-                      Click="OnToggleManualClick"/>
           </ContextMenu>
         </Border.ContextMenu>
         <Grid ColumnDefinitions="0,18,32,*,Auto,Auto,32" Margin="6,8,10,8">

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

@@ -33,6 +33,10 @@
                   ToolTip.Tip="{loc:Tr tasks.showCompletedTip}">
             <PathIcon Width="15" Height="15" Data="{StaticResource Icon.Eye}"/>
           </Button>
+          <Button Classes="icon-btn" IsVisible="{Binding IsLetClaudeVisible}"
+                  Command="{Binding LetClaudeHandleCommand}" ToolTip.Tip="{loc:Tr tasks.letClaudeTip}">
+            <PathIcon Width="15" Height="15" Data="{StaticResource Icon.Broom}"/>
+          </Button>
           <Button Classes="icon-btn" IsVisible="{Binding IsMyDayList}"
                   Command="{Binding ClearDayCommand}" ToolTip.Tip="{loc:Tr tasks.clearDayTip}">
             <PathIcon Width="15" Height="15" Data="{StaticResource Icon.Broom}"/>

src/ClaudeDo.Ui/Views/Modals/SettingsModalView.axaml

@@ -2,6 +2,7 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:vm="using:ClaudeDo.Ui.ViewModels.Modals"
         xmlns:settings="using:ClaudeDo.Ui.ViewModels.Modals.Settings"
+        xmlns:ui="using:ClaudeDo.Ui"
         xmlns:agent="using:ClaudeDo.Ui.ViewModels.Agent"
         xmlns:services="using:ClaudeDo.Ui.Services"
         xmlns:ctl="using:ClaudeDo.Ui.Views.Controls"
@@ -61,6 +62,39 @@
                   </ComboBox.ItemTemplate>
                 </ComboBox>
               </StackPanel>
+              <StackPanel Spacing="4">
+                <TextBlock Classes="field-label" Text="{loc:Tr settings.general.accentPreset}"/>
+                <ItemsControl ItemsSource="{Binding General.AccentPresetSwatches}">
+                  <ItemsControl.ItemsPanel>
+                    <ItemsPanelTemplate>
+                      <StackPanel Orientation="Horizontal" Spacing="8"/>
+                    </ItemsPanelTemplate>
+                  </ItemsControl.ItemsPanel>
+                  <ItemsControl.ItemTemplate>
+                    <DataTemplate x:DataType="ui:AccentPresetSwatchViewModel">
+                      <Button Padding="6,4"
+                              Command="{Binding $parent[ItemsControl].((vm:SettingsModalViewModel)DataContext).General.SelectAccentPresetCommand}"
+                              CommandParameter="{Binding Preset}">
+                        <StackPanel Spacing="4">
+                          <Grid Width="32" Height="32">
+                            <Border Width="32" Height="32" CornerRadius="16"
+                                    BorderBrush="{DynamicResource AccentBrush}" BorderThickness="2"
+                                    IsVisible="{Binding IsSelected}"/>
+                            <Ellipse Width="22" Height="22"
+                                     HorizontalAlignment="Center" VerticalAlignment="Center">
+                              <Ellipse.Fill>
+                                <SolidColorBrush Color="{Binding DisplayColor}"/>
+                              </Ellipse.Fill>
+                            </Ellipse>
+                          </Grid>
+                          <TextBlock Text="{Binding DisplayName}"
+                                     HorizontalAlignment="Center" FontSize="11"/>
+                        </StackPanel>
+                      </Button>
+                    </DataTemplate>
+                  </ItemsControl.ItemTemplate>
+                </ItemsControl>
+              </StackPanel>
               <StackPanel Spacing="4">
                 <TextBlock Classes="field-label" Text="{loc:Tr settings.general.defaultInstructions}"/>
                 <TextBox AcceptsReturn="True" TextWrapping="Wrap" Height="110"

src/ClaudeDo.Worker/CLAUDE.md

@@ -33,7 +33,7 @@ Interfaces (e.g. `IQueueWaker`, `IPrimeClock`, `ITaskStateService`) live in an `
 - **OverrideSlotService** — owns `RunNow` / `ContinueTask`; goes through `TaskStateService.StartRunningAsync` (caller-driven, serialized by slot lock).
 - **StaleTaskRecovery** — startup-only service; calls `TaskStateService.RecoverStaleRunningAsync` to flip orphaned `Running` rows to `Failed`.
 - **External/*** — always-on MCP tools for general Claude sessions, scoped to *starting* and *observing* sessions (no worktree/merge, multi-turn, planning, or app-settings writes). Auth via optional `X-ClaudeDo-Key` header. Registered explicitly in `Program.cs`'s external app via `.WithTools<T>()`. Every optional/filter parameter across these tools must carry a C# default value (e.g. `string? status = null`) — the MCP schema only marks a parameter optional when it has one; nullability alone doesn't do it (`ExternalMcpToolSchemaTests` guards this by reflection). `ExternalMcpExceptionFilter.Wrap` is registered as a call-tool filter so `InvalidOperationException`/`ArgumentException` messages survive as `McpException` — otherwise the SDK's own catch-all replaces any non-`McpException` with a generic "An error occurred invoking 'X'." Organized by concern:
-  - `ExternalMcpService` — task CRUD + execution: `ListTaskLists`, `ListTasks`, `GetTask`, `AddTask`, `AddSubtask`, `UpdateTask`, `UpdateTaskStatus` (`Idle` / `Queued` / `Cancelled` — `Cancelled` goes through `TaskStateService.CancelAsync(..., allowFromIdle: true)`, the only caller that opts into cancelling from `Idle`; `PlanningChainCoordinator` relies on `Idle` staying a no-op there by default, since a child parked back to `Idle` mid-chain is a manual opt-out signal), `GetTaskStatusValues`, `ReviewTask` (`approve` / `reject_rerun` / `reject_park` / `cancel` for a WaitingForReview task; approve is review+merge exactly like the hub's `ApproveReview` — unit merge for parents, worktree merge into optional `targetBranch` for childless tasks, conflicts reported in the `ReviewTaskResult`), `RunTaskNow`, `ContinueTask`, `CancelTask`, `DeleteTask`; worktree/git: `GetTaskWorktree`, `GetTaskDiff`, `MergeTask`, `ListWorktrees`, `CleanupTaskWorktree`
+  - `ExternalMcpService` — task CRUD + execution: `ListTaskLists`, `ListTasks`, `GetTask`, `AddTask`, `AddSubtask`, `UpdateTask`, `UpdateTaskStatus` (`Idle` / `Queued` / `Cancelled` / `Done` — `Cancelled` goes through `TaskStateService.CancelAsync(..., allowFromIdle: true)`, the only caller that opts into cancelling from `Idle`; `PlanningChainCoordinator` relies on `Idle` staying a no-op there by default, since a child parked back to `Idle` mid-chain is a manual opt-out signal; `Done` goes through `TaskStateService.ForceSetStatusAsync` — same unconditional write the UI's "set status freely" affordance uses — but is refused here with an active-worktree task, since that would skip `review_task`'s merge), `GetTaskStatusValues`, `ReviewTask` (`approve` / `reject_rerun` / `reject_park` / `cancel` for a WaitingForReview task; approve is review+merge exactly like the hub's `ApproveReview` — unit merge for parents, worktree merge into optional `targetBranch` for childless tasks, conflicts reported in the `ReviewTaskResult`), `RunTaskNow`, `ContinueTask`, `CancelTask`, `DeleteTask`; worktree/git: `GetTaskWorktree`, `GetTaskDiff`, `MergeTask`, `ListWorktrees`, `CleanupTaskWorktree`
   - `BatchMcpTools` — best-effort batch variants that loop the `ExternalMcpService` single-entity methods (sequential — the scoped DbContext is not thread-safe; merge/review stay single-task): `BatchGetTasks`, `BatchAddTasks`, `BatchUpdateTaskStatus`, `BatchCancelTasks`, `BatchDeleteTasks`, `BatchSetMyDay`, `BatchCleanupTaskWorktrees`. Every tool returns a per-item result array ({ id/index, ok, error?, … }) — a failing item never aborts the rest — and rejects batches over 100 items.
   - `ListMcpTools` — `CreateList`, `UpdateList`, `DeleteList`
   - `ConfigMcpTools` — `GetListConfig`, `SetListConfig`, `GetTaskConfig`, `SetTaskConfig`

src/ClaudeDo.Worker/External/BatchMcpTools.cs

@@ -93,8 +93,8 @@ public sealed class BatchMcpTools
     }
 
     [McpServerTool, Description(
-        "Set the status of many tasks at once. status is 'Idle' (reset to editable) or " +
-        "'Queued' (enqueue for execution) only — same rule as update_task_status. " +
+        "Set the status of many tasks at once. status is 'Idle', 'Queued', 'Cancelled' or 'Done' only — " +
+        "same rule as update_task_status ('Done' is refused per-item for a task with an active worktree). " +
         "Returns one result per id: { taskId, ok, error }. Max 100 ids.")]
     public async Task<IReadOnlyList<BatchTaskResult>> BatchUpdateTaskStatus(
         string[] taskIds, string status, CancellationToken cancellationToken)

src/ClaudeDo.Worker/External/ExternalMcpService.cs

@@ -264,10 +264,12 @@ public sealed class ExternalMcpService
     }
 
     [McpServerTool, Description(
-        "Update a task's status. Only 'Idle', 'Queued' and 'Cancelled' are permitted externally — " +
+        "Update a task's status. Only 'Idle', 'Queued', 'Cancelled' and 'Done' are permitted externally — " +
         "use run_task_now for execution control, and review_task to act on a WaitingForReview task. " +
         "Settable: Idle (reset to editable), Queued (enqueue for execution), " +
-        "Cancelled (retire the task without deleting it; it can be reset to Idle later). " +
+        "Cancelled (retire the task without deleting it; it can be reset to Idle later), " +
+        "Done (mark complete; refused if the task has an active worktree — use review_task to approve " +
+        "and merge that worktree instead). " +
         "Full lifecycle: Idle → Queued → Running → WaitingForReview → Done | Failed | Cancelled.")]
     public async Task<TaskDto> UpdateTaskStatus(
         string taskId,
@@ -300,6 +302,20 @@ public sealed class ExternalMcpService
                     throw new InvalidOperationException(cancelResult.Reason ?? "Cannot cancel task.");
                 break;
 
+            case TaskStatus.Done:
+                await using (var ctx = await _dbFactory.CreateDbContextAsync(cancellationToken))
+                {
+                    var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, cancellationToken);
+                    if (wt is not null && wt.State == WorktreeState.Active)
+                        throw new InvalidOperationException(
+                            "Task has an active worktree — use review_task to approve and merge instead.");
+                }
+
+                var doneResult = await _state.ForceSetStatusAsync(taskId, TaskStatus.Done, cancellationToken);
+                if (!doneResult.Ok)
+                    throw new InvalidOperationException(doneResult.Reason ?? "Cannot set task to Done.");
+                break;
+
             default:
                 throw new InvalidOperationException(
                     $"Status '{target}' is not settable externally. Use run_task_now or review_task.");

src/ClaudeDo.Worker/State/TaskStateService.cs

@@ -329,9 +329,15 @@ public sealed class TaskStateService : ITaskStateService
     public async Task<TransitionResult> ForceSetStatusAsync(string taskId, TaskStatus status, CancellationToken ct)
     {
         await using var ctx = await _dbFactory.CreateDbContextAsync(ct);
-        var affected = await ctx.Tasks
-            .Where(t => t.Id == taskId)
-            .ExecuteUpdateAsync(s => s.SetProperty(t => t.Status, status), ct);
+        var affected = status == TaskStatus.Done
+            ? await ctx.Tasks
+                .Where(t => t.Id == taskId)
+                .ExecuteUpdateAsync(s => s
+                    .SetProperty(t => t.Status, status)
+                    .SetProperty(t => t.FinishedAt, DateTime.UtcNow), ct)
+            : await ctx.Tasks
+                .Where(t => t.Id == taskId)
+                .ExecuteUpdateAsync(s => s.SetProperty(t => t.Status, status), ct);
 
         if (affected == 0)
             return new TransitionResult(false, "Task not found.");

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

@@ -137,4 +137,28 @@ public class DetailsIslandReviewActionsTests : IDisposable
         Assert.True(vm.ShowReviewDiffHint);
         Assert.False(vm.ApproveReviewCommand.CanExecute(null));
     }
+
+    private sealed class ThrowingWorkerClient : StubWorkerClient
+    {
+        public override bool IsConnected => true;
+        public string ExceptionMessage { get; init; } = "blocked: target working tree has uncommitted changes";
+        public override Task<MergeResultDto?> ApproveReviewAsync(string taskId, string targetBranch) =>
+            throw new Exception(ExceptionMessage);
+    }
+
+    [Fact]
+    public async Task ApproveReview_WhenWorkerThrows_CallsShowErrorAsync()
+    {
+        var worker = new ThrowingWorkerClient();
+        var vm = BuildVm(worker);
+        vm.Bind(new TaskRowViewModel { Id = "task-err-1", Status = TaskStatus.WaitingForReview });
+        vm.Monitor.ApplyState(TaskStatus.WaitingForReview);
+
+        string? reportedError = null;
+        vm.ShowErrorAsync = msg => { reportedError = msg; return Task.CompletedTask; };
+
+        await vm.ApproveReviewCommand.ExecuteAsync(null);
+
+        Assert.Equal(worker.ExceptionMessage, reportedError);
+    }
 }

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

@@ -0,0 +1,76 @@
+using ClaudeDo.Data;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Ui.ViewModels.Islands;
+using Microsoft.EntityFrameworkCore;
+
+namespace ClaudeDo.Ui.Tests.ViewModels;
+
+public class TasksIslandAddAndSelectTests : IDisposable
+{
+    private readonly string _dbPath;
+
+    public TasksIslandAddAndSelectTests()
+    {
+        _dbPath = Path.Combine(Path.GetTempPath(), $"claudedo_ui_addselect_{Guid.NewGuid():N}.db");
+        using var ctx = NewContext();
+        ctx.Database.EnsureCreated();
+    }
+
+    public void Dispose()
+    {
+        try { File.Delete(_dbPath); } catch { }
+        try { File.Delete(_dbPath + "-wal"); } catch { }
+        try { File.Delete(_dbPath + "-shm"); } catch { }
+    }
+
+    private ClaudeDoDbContext NewContext()
+    {
+        var opts = new DbContextOptionsBuilder<ClaudeDoDbContext>()
+            .UseSqlite($"Data Source={_dbPath}")
+            .Options;
+        return new ClaudeDoDbContext(opts);
+    }
+
+    private sealed class TestDbFactory : IDbContextFactory<ClaudeDoDbContext>
+    {
+        private readonly Func<ClaudeDoDbContext> _create;
+        public TestDbFactory(Func<ClaudeDoDbContext> create) => _create = create;
+        public ClaudeDoDbContext CreateDbContext() => _create();
+    }
+
+    private async Task SeedListAsync()
+    {
+        await using var db = NewContext();
+        db.Lists.Add(new ListEntity { Id = "L1", Name = "Work", CreatedAt = DateTime.UtcNow });
+        await db.SaveChangesAsync();
+    }
+
+    [Fact]
+    public async Task AddAsync_SelectsNewTask()
+    {
+        await SeedListAsync();
+        var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker: null);
+        vm.LoadForList(new ListNavItemViewModel { Id = "user:L1", Name = "Work", Kind = ListKind.User });
+        await vm.LoadTask!;
+
+        vm.NewTaskTitle = "My new task";
+        await vm.AddCommand.ExecuteAsync(null);
+
+        Assert.NotNull(vm.SelectedTask);
+        Assert.Equal("My new task", vm.SelectedTask!.Title);
+    }
+
+    [Fact]
+    public async Task AddAsync_EmptyTitle_DoesNotChangeSelection()
+    {
+        await SeedListAsync();
+        var vm = new TasksIslandViewModel(new TestDbFactory(NewContext), worker: null);
+        vm.LoadForList(new ListNavItemViewModel { Id = "user:L1", Name = "Work", Kind = ListKind.User });
+        await vm.LoadTask!;
+
+        vm.NewTaskTitle = "";
+        await vm.AddCommand.ExecuteAsync(null);
+
+        Assert.Null(vm.SelectedTask);
+    }
+}

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

@@ -0,0 +1,66 @@
+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 TasksIslandApproveReviewTests : IDisposable
+{
+    private readonly string _dbPath;
+
+    public TasksIslandApproveReviewTests()
+    {
+        _dbPath = Path.Combine(Path.GetTempPath(), $"claudedo_approve_test_{Guid.NewGuid():N}.db");
+        using var ctx = NewContext();
+        ctx.Database.EnsureCreated();
+    }
+
+    public void Dispose()
+    {
+        try { File.Delete(_dbPath); } catch { }
+        try { File.Delete(_dbPath + "-wal"); } catch { }
+        try { File.Delete(_dbPath + "-shm"); } catch { }
+    }
+
+    private ClaudeDoDbContext NewContext()
+    {
+        var opts = new DbContextOptionsBuilder<ClaudeDoDbContext>()
+            .UseSqlite($"Data Source={_dbPath}")
+            .Options;
+        return new ClaudeDoDbContext(opts);
+    }
+
+    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 ThrowingWorkerClient : StubWorkerClient
+    {
+        public string ExceptionMessage { get; init; } = "blocked: target working tree has uncommitted changes";
+        public override Task<MergeResultDto?> ApproveReviewAsync(string taskId, string targetBranch) =>
+            throw new Exception(ExceptionMessage);
+    }
+
+    [Fact]
+    public async Task ApproveReview_WhenWorkerThrows_RaisesErrorReported()
+    {
+        var worker = new ThrowingWorkerClient();
+        var factory = new TestDbFactory(NewContext);
+        var vm = new TasksIslandViewModel(factory, worker);
+
+        string? reportedError = null;
+        vm.ErrorReported += msg => reportedError = msg;
+
+        var row = new TaskRowViewModel { Id = "task-err-2", Status = TaskStatus.WaitingForReview };
+        await vm.ApproveReviewCommand.ExecuteAsync(row);
+
+        Assert.NotNull(reportedError);
+        Assert.Contains(worker.ExceptionMessage, reportedError);
+    }
+}

tests/ClaudeDo.Worker.Tests/External/BatchMcpToolsTests.cs

@@ -189,6 +189,22 @@ public sealed class BatchMcpToolsTests : IDisposable
         Assert.Equal(TaskStatus.Queued, (await _tasks.GetByIdAsync(t2.Id))!.Status);
     }
 
+    [Fact]
+    public async Task BatchUpdateTaskStatus_Done_MixedWorktreeState_ReportsPerItemAndDoesNotAbort()
+    {
+        var listId = await SeedListAsync();
+        var noWorktree = await SeedTaskAsync(listId, "no-wt", TaskStatus.Idle);
+        var missing = "does-not-exist";
+        var sut = BuildSut();
+
+        var results = await sut.BatchUpdateTaskStatus(
+            new[] { noWorktree.Id, missing }, "Done", CancellationToken.None);
+
+        Assert.True(results.Single(r => r.TaskId == noWorktree.Id).Ok);
+        Assert.False(results.Single(r => r.TaskId == missing).Ok);
+        Assert.Equal(TaskStatus.Done, (await _tasks.GetByIdAsync(noWorktree.Id))!.Status);
+    }
+
     [Fact]
     public async Task BatchTools_RejectEmptyBatch()
     {

tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs

@@ -395,17 +395,47 @@ public sealed class ExternalMcpServiceTests : IDisposable
     }
 
     [Fact]
-    public async Task UpdateTaskStatus_Done_StillRejected()
+    public async Task UpdateTaskStatus_WaitingForReview_StillRejected()
     {
         var listId = await SeedListAsync();
         var task = await SeedTaskAsync(listId, status: TaskStatus.Idle);
         var sut = BuildSut(CreateQueue());
 
         var ex = await Assert.ThrowsAsync<InvalidOperationException>(
-            () => sut.UpdateTaskStatus(task.Id, "Done", CancellationToken.None));
+            () => sut.UpdateTaskStatus(task.Id, "WaitingForReview", CancellationToken.None));
         Assert.Contains("not settable externally", ex.Message);
     }
 
+    [Fact]
+    public async Task UpdateTaskStatus_Done_NoWorktree_SetsDoneAndFinishedAt()
+    {
+        var listId = await SeedListAsync();
+        var task = await SeedTaskAsync(listId, status: TaskStatus.Idle);
+        var sut = BuildSut(CreateQueue());
+
+        var dto = await sut.UpdateTaskStatus(task.Id, "Done", CancellationToken.None);
+
+        Assert.Equal("Done", dto.Status);
+        var loaded = await _tasks.GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.Done, loaded!.Status);
+        Assert.NotNull(loaded.FinishedAt);
+    }
+
+    [Fact]
+    public async Task UpdateTaskStatus_Done_WithActiveWorktree_Throws()
+    {
+        if (!GitAvailable) return;
+        var (task, _, _) = await SeedWorktreeAsync(TaskStatus.WaitingForReview);
+        var sut = BuildSut(CreateQueue());
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+            () => sut.UpdateTaskStatus(task.Id, "Done", CancellationToken.None));
+
+        Assert.Contains("active worktree", ex.Message, StringComparison.OrdinalIgnoreCase);
+        var loaded = await _tasks.GetByIdAsync(task.Id);
+        Assert.Equal(TaskStatus.WaitingForReview, loaded!.Status);
+    }
+
     private ExternalMcpService NewService() => BuildSut(CreateQueue());
 
     private async Task<string> SeedIdleTask(string title = "t")