diff --git a/docs/superpowers/plans/2026-04-22-agent-settings-ui.md b/docs/superpowers/plans/2026-04-22-agent-settings-ui.md
new file mode 100644
index 0000000..1c8077f
--- /dev/null
+++ b/docs/superpowers/plans/2026-04-22-agent-settings-ui.md
@@ -0,0 +1,1223 @@
+# Agent Settings UI Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Restore the ability to configure Model / SystemPrompt / AgentPath per list (via a new modal) and per task (via an expander in DetailsIsland), persisting through SignalR hub methods to the existing DB schema.
+
+**Architecture:** UI → new `WorkerHub` methods (`UpdateList`, `UpdateListConfig`, `UpdateTaskAgentSettings`, `GetListConfig`) → existing repositories in `ClaudeDo.Data` (schema already in place). Worker broadcasts `ListUpdated` so the lists island refreshes. Per-task settings auto-save on change, debounced. The DB columns/tables already exist; `TaskRunner` + `ClaudeArgsBuilder` already consume them.
+
+**Tech Stack:** .NET 8, Avalonia 12, CommunityToolkit.Mvvm, EF Core, SignalR (hub on `127.0.0.1:47821`), xUnit integration tests with real SQLite.
+
+**Build tip (from project memory):** `dotnet build ClaudeDo.slnx` fails on .NET 8. Build individual csproj files:
+```
+dotnet build src/ClaudeDo.Data/ClaudeDo.Data.csproj
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj
+dotnet build src/ClaudeDo.Ui/ClaudeDo.Ui.csproj
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj
+```
+
+---
+
+## File Structure
+
+New files:
+- `src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml`
+- `src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml.cs`
+- `src/ClaudeDo.Ui/ViewModels/Modals/ListSettingsModalViewModel.cs`
+- `tests/ClaudeDo.Worker.Tests/Repositories/ListRepositoryDeleteConfigTests.cs`
+- `tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryAgentSettingsTests.cs`
+- `tests/ClaudeDo.Worker.Tests/Hub/AgentSettingsHubTests.cs`
+
+Modified files:
+- `src/ClaudeDo.Data/Repositories/ListRepository.cs` — add `DeleteConfigAsync`
+- `src/ClaudeDo.Data/Repositories/TaskRepository.cs` — add `UpdateAgentSettingsAsync`
+- `src/ClaudeDo.Worker/Hub/WorkerHub.cs` — add 4 methods + DTOs
+- `src/ClaudeDo.Worker/Hub/HubBroadcaster.cs` — add `ListUpdatedAsync`
+- `src/ClaudeDo.Ui/Services/WorkerClient.cs` — add 4 methods + `ListUpdatedEvent`
+- `src/ClaudeDo.Ui/ViewModels/Modals/SettingsModalViewModel.cs` (no changes expected, only for reference)
+- `src/ClaudeDo.App/App.axaml.cs` (or DI extension file) — register `ListSettingsModalViewModel`
+- `src/ClaudeDo.Ui/Views/Islands/ListsIslandView.axaml` — add context menu + gear button
+- `src/ClaudeDo.Ui/ViewModels/Islands/ListsIslandViewModel.cs` — add `OpenSettingsCommand`, subscribe `ListUpdated`
+- `src/ClaudeDo.Ui/ViewModels/Islands/ListNavItemViewModel.cs` — expose list fields needed by modal
+- `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs` — add agent-settings fields + auto-save
+- `src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml` — add "Agent settings" expander
+- `src/ClaudeDo.Data/CLAUDE.md` — refresh with new repo methods + ListConfigEntity
+- `src/ClaudeDo.Worker/CLAUDE.md` — document new hub methods + `ListUpdated`
+- `src/ClaudeDo.Ui/CLAUDE.md` — document list settings modal + details expander
+
+---
+
+## Task 1: Add `ListRepository.DeleteConfigAsync`
+
+**Files:**
+- Modify: `src/ClaudeDo.Data/Repositories/ListRepository.cs`
+- Test: `tests/ClaudeDo.Worker.Tests/Repositories/ListRepositoryDeleteConfigTests.cs`
+
+The existing `ListRepository.SetConfigAsync` upserts but never deletes. The UI needs a way to fully remove a list config row (when the user clears all three agent fields).
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/ClaudeDo.Worker.Tests/Repositories/ListRepositoryDeleteConfigTests.cs`:
+
+```csharp
+using ClaudeDo.Data.Models;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Tests.Infrastructure;
+using Xunit;
+
+namespace ClaudeDo.Worker.Tests.Repositories;
+
+public sealed class ListRepositoryDeleteConfigTests : IAsyncLifetime
+{
+    private readonly TempDatabase _db = new();
+
+    public async Task InitializeAsync() => await _db.InitializeAsync();
+    public async Task DisposeAsync() => await _db.DisposeAsync();
+
+    [Fact]
+    public async Task DeleteConfigAsync_RemovesExistingRow()
+    {
+        await using var ctx = _db.CreateContext();
+        var repo = new ListRepository(ctx);
+
+        var listId = Guid.NewGuid().ToString();
+        await repo.AddAsync(new ListEntity
+        {
+            Id = listId,
+            Name = "L",
+            CreatedAt = DateTime.UtcNow,
+        });
+        await repo.SetConfigAsync(new ListConfigEntity
+        {
+            ListId = listId,
+            Model = "opus",
+            SystemPrompt = "hello",
+            AgentPath = "/tmp/a.md",
+        });
+
+        var removed = await repo.DeleteConfigAsync(listId);
+
+        Assert.True(removed);
+        Assert.Null(await repo.GetConfigAsync(listId));
+    }
+
+    [Fact]
+    public async Task DeleteConfigAsync_ReturnsFalseWhenAbsent()
+    {
+        await using var ctx = _db.CreateContext();
+        var repo = new ListRepository(ctx);
+
+        var removed = await repo.DeleteConfigAsync(Guid.NewGuid().ToString());
+
+        Assert.False(removed);
+    }
+}
+```
+
+> If `TempDatabase` / `Infrastructure` namespace differs, match the existing test infrastructure pattern seen in other `*RepositoryTests` files in `tests/ClaudeDo.Worker.Tests/Repositories/`. Read one existing test file first to confirm the exact helper class name and SQLite setup call.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj --filter "FullyQualifiedName~ListRepositoryDeleteConfigTests"
+```
+Expected: FAIL with `'ListRepository' does not contain a definition for 'DeleteConfigAsync'`.
+
+- [ ] **Step 3: Add the method**
+
+In `src/ClaudeDo.Data/Repositories/ListRepository.cs`, add below `SetConfigAsync`:
+
+```csharp
+public async Task<bool> DeleteConfigAsync(string listId, CancellationToken ct = default)
+{
+    var affected = await _context.ListConfigs
+        .Where(c => c.ListId == listId)
+        .ExecuteDeleteAsync(ct);
+    return affected > 0;
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+```
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj --filter "FullyQualifiedName~ListRepositoryDeleteConfigTests"
+```
+Expected: 2 tests passed.
+
+- [ ] **Step 5: Commit**
+
+```
+git add src/ClaudeDo.Data/Repositories/ListRepository.cs tests/ClaudeDo.Worker.Tests/Repositories/ListRepositoryDeleteConfigTests.cs
+git commit -m "feat(data): add ListRepository.DeleteConfigAsync"
+```
+
+---
+
+## Task 2: Add `TaskRepository.UpdateAgentSettingsAsync`
+
+**Files:**
+- Modify: `src/ClaudeDo.Data/Repositories/TaskRepository.cs`
+- Test: `tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryAgentSettingsTests.cs`
+
+Focused method so the UI can update the three override columns without loading the entity.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryAgentSettingsTests.cs`:
+
+```csharp
+using ClaudeDo.Data.Models;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Tests.Infrastructure;
+using Xunit;
+
+namespace ClaudeDo.Worker.Tests.Repositories;
+
+public sealed class TaskRepositoryAgentSettingsTests : IAsyncLifetime
+{
+    private readonly TempDatabase _db = new();
+
+    public async Task InitializeAsync() => await _db.InitializeAsync();
+    public async Task DisposeAsync() => await _db.DisposeAsync();
+
+    private async Task<string> SeedTaskAsync()
+    {
+        await using var ctx = _db.CreateContext();
+        var listId = Guid.NewGuid().ToString();
+        var taskId = Guid.NewGuid().ToString();
+        await new ListRepository(ctx).AddAsync(new ListEntity
+        {
+            Id = listId, Name = "L", CreatedAt = DateTime.UtcNow,
+        });
+        await new TaskRepository(ctx).AddAsync(new TaskEntity
+        {
+            Id = taskId, ListId = listId, Title = "T", CreatedAt = DateTime.UtcNow,
+        });
+        return taskId;
+    }
+
+    [Fact]
+    public async Task UpdateAgentSettingsAsync_SetsAllThreeFields()
+    {
+        var taskId = await SeedTaskAsync();
+
+        await using var ctx = _db.CreateContext();
+        var repo = new TaskRepository(ctx);
+
+        await repo.UpdateAgentSettingsAsync(taskId, "opus", "system!", "/tmp/a.md");
+
+        var entity = await repo.GetByIdAsync(taskId);
+        Assert.NotNull(entity);
+        Assert.Equal("opus", entity!.Model);
+        Assert.Equal("system!", entity.SystemPrompt);
+        Assert.Equal("/tmp/a.md", entity.AgentPath);
+    }
+
+    [Fact]
+    public async Task UpdateAgentSettingsAsync_NullsClearColumns()
+    {
+        var taskId = await SeedTaskAsync();
+
+        await using (var ctx = _db.CreateContext())
+        {
+            await new TaskRepository(ctx).UpdateAgentSettingsAsync(taskId, "opus", "s", "/a.md");
+        }
+
+        await using (var ctx = _db.CreateContext())
+        {
+            var repo = new TaskRepository(ctx);
+            await repo.UpdateAgentSettingsAsync(taskId, null, null, null);
+
+            var entity = await repo.GetByIdAsync(taskId);
+            Assert.NotNull(entity);
+            Assert.Null(entity!.Model);
+            Assert.Null(entity.SystemPrompt);
+            Assert.Null(entity.AgentPath);
+        }
+    }
+}
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj --filter "FullyQualifiedName~TaskRepositoryAgentSettingsTests"
+```
+Expected: FAIL with `'TaskRepository' does not contain a definition for 'UpdateAgentSettingsAsync'`.
+
+- [ ] **Step 3: Add the method**
+
+In `src/ClaudeDo.Data/Repositories/TaskRepository.cs`, add at the end of the `#region Status transitions` block (or a new `#region Agent settings` right after):
+
+```csharp
+public async Task UpdateAgentSettingsAsync(
+    string taskId,
+    string? model,
+    string? systemPrompt,
+    string? agentPath,
+    CancellationToken ct = default)
+{
+    await _context.Tasks
+        .Where(t => t.Id == taskId)
+        .ExecuteUpdateAsync(s => s
+            .SetProperty(t => t.Model, model)
+            .SetProperty(t => t.SystemPrompt, systemPrompt)
+            .SetProperty(t => t.AgentPath, agentPath), ct);
+}
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+```
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj --filter "FullyQualifiedName~TaskRepositoryAgentSettingsTests"
+```
+Expected: 2 tests passed.
+
+- [ ] **Step 5: Commit**
+
+```
+git add src/ClaudeDo.Data/Repositories/TaskRepository.cs tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryAgentSettingsTests.cs
+git commit -m "feat(data): add TaskRepository.UpdateAgentSettingsAsync"
+```
+
+---
+
+## Task 3: Hub methods + DTOs + `ListUpdated` broadcast
+
+**Files:**
+- Modify: `src/ClaudeDo.Worker/Hub/HubBroadcaster.cs`
+- Modify: `src/ClaudeDo.Worker/Hub/WorkerHub.cs`
+- Test: `tests/ClaudeDo.Worker.Tests/Hub/AgentSettingsHubTests.cs`
+
+Add four hub methods (`UpdateList`, `UpdateListConfig`, `UpdateTaskAgentSettings`, `GetListConfig`) plus a `ListUpdated` broadcast event.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/ClaudeDo.Worker.Tests/Hub/AgentSettingsHubTests.cs`:
+
+> Pattern notes: the worker test project usually calls hub methods by invoking repositories/services directly when no SignalR host is spun up. Read an existing hub-adjacent test (if one exists) to confirm. If no precedent, assert the underlying persistence via repo calls — the hub methods are thin wrappers.
+
+```csharp
+using ClaudeDo.Data.Models;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Tests.Infrastructure;
+using Xunit;
+
+namespace ClaudeDo.Worker.Tests.Hub;
+
+// These tests exercise the hub behavior by invoking the underlying repository
+// chain the hub calls. The hub itself is a thin wrapper around these repos;
+// full SignalR integration testing is covered manually per the spec.
+public sealed class AgentSettingsHubTests : IAsyncLifetime
+{
+    private readonly TempDatabase _db = new();
+    public async Task InitializeAsync() => await _db.InitializeAsync();
+    public async Task DisposeAsync() => await _db.DisposeAsync();
+
+    [Fact]
+    public async Task UpdateListConfig_AllNull_DeletesRow()
+    {
+        await using var ctx = _db.CreateContext();
+        var repo = new ListRepository(ctx);
+
+        var listId = Guid.NewGuid().ToString();
+        await repo.AddAsync(new ListEntity { Id = listId, Name = "L", CreatedAt = DateTime.UtcNow });
+        await repo.SetConfigAsync(new ListConfigEntity
+        {
+            ListId = listId, Model = "opus", SystemPrompt = null, AgentPath = null,
+        });
+
+        // Simulate hub: all three null => delete.
+        const string? model = null; const string? sp = null; const string? ap = null;
+        if (model is null && sp is null && ap is null)
+            await repo.DeleteConfigAsync(listId);
+        else
+            await repo.SetConfigAsync(new ListConfigEntity
+            {
+                ListId = listId, Model = model, SystemPrompt = sp, AgentPath = ap,
+            });
+
+        Assert.Null(await repo.GetConfigAsync(listId));
+    }
+}
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+It actually passes since it only calls existing code. The purpose of this test is to encode the hub's "all-null → delete" contract so that Task 3's code changes don't break it.
+
+```
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj --filter "FullyQualifiedName~AgentSettingsHubTests"
+```
+Expected: 1 passed (the test is a spec/guardrail, not a red-green).
+
+- [ ] **Step 3: Add the broadcaster event**
+
+In `src/ClaudeDo.Worker/Hub/HubBroadcaster.cs`, add a new method alongside the existing `TaskUpdatedAsync`:
+
+```csharp
+public Task ListUpdatedAsync(string listId) =>
+    _hub.Clients.All.SendAsync("ListUpdated", listId);
+```
+
+- [ ] **Step 4: Add DTOs + hub methods**
+
+In `src/ClaudeDo.Worker/Hub/WorkerHub.cs`, add these `record` DTOs at the top (alongside `ActiveTaskDto`, `AppSettingsDto`, etc.):
+
+```csharp
+public record UpdateListDto(string Id, string Name, string? WorkingDir, string DefaultCommitType);
+public record UpdateListConfigDto(string ListId, string? Model, string? SystemPrompt, string? AgentPath);
+public record UpdateTaskAgentSettingsDto(string TaskId, string? Model, string? SystemPrompt, string? AgentPath);
+public record ListConfigDto(string? Model, string? SystemPrompt, string? AgentPath);
+```
+
+Then add these methods to the `WorkerHub` class (place at the end, before the closing brace):
+
+```csharp
+public async Task UpdateList(UpdateListDto dto)
+{
+    using var ctx = _dbFactory.CreateDbContext();
+    var repo = new ListRepository(ctx);
+    var entity = await repo.GetByIdAsync(dto.Id);
+    if (entity is null) throw new HubException("list not found");
+
+    entity.Name = dto.Name;
+    entity.WorkingDir = string.IsNullOrWhiteSpace(dto.WorkingDir) ? null : dto.WorkingDir;
+    entity.DefaultCommitType = string.IsNullOrWhiteSpace(dto.DefaultCommitType) ? "chore" : dto.DefaultCommitType;
+    await repo.UpdateAsync(entity);
+
+    await _broadcaster.ListUpdatedAsync(dto.Id);
+}
+
+public async Task UpdateListConfig(UpdateListConfigDto dto)
+{
+    using var ctx = _dbFactory.CreateDbContext();
+    var repo = new ListRepository(ctx);
+
+    var model = Nullify(dto.Model);
+    var systemPrompt = Nullify(dto.SystemPrompt);
+    var agentPath = Nullify(dto.AgentPath);
+
+    if (model is null && systemPrompt is null && agentPath is null)
+    {
+        await repo.DeleteConfigAsync(dto.ListId);
+    }
+    else
+    {
+        await repo.SetConfigAsync(new ListConfigEntity
+        {
+            ListId = dto.ListId,
+            Model = model,
+            SystemPrompt = systemPrompt,
+            AgentPath = agentPath,
+        });
+    }
+
+    await _broadcaster.ListUpdatedAsync(dto.ListId);
+}
+
+public async Task<ListConfigDto?> GetListConfig(string listId)
+{
+    using var ctx = _dbFactory.CreateDbContext();
+    var repo = new ListRepository(ctx);
+    var config = await repo.GetConfigAsync(listId);
+    if (config is null) return null;
+    return new ListConfigDto(config.Model, config.SystemPrompt, config.AgentPath);
+}
+
+public async Task UpdateTaskAgentSettings(UpdateTaskAgentSettingsDto dto)
+{
+    using var ctx = _dbFactory.CreateDbContext();
+    var repo = new TaskRepository(ctx);
+    await repo.UpdateAgentSettingsAsync(
+        dto.TaskId,
+        Nullify(dto.Model),
+        Nullify(dto.SystemPrompt),
+        Nullify(dto.AgentPath));
+
+    await _broadcaster.TaskUpdatedAsync(dto.TaskId);
+}
+
+private static string? Nullify(string? s) => string.IsNullOrWhiteSpace(s) ? null : s;
+```
+
+If `_broadcaster.TaskUpdatedAsync` has a different signature in the existing broadcaster, adapt the call to match — read `HubBroadcaster.cs` for the exact name.
+
+- [ ] **Step 5: Build worker**
+
+```
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj
+```
+Expected: build succeeded, 0 errors.
+
+- [ ] **Step 6: Run the guardrail test**
+
+```
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj --filter "FullyQualifiedName~AgentSettingsHubTests"
+```
+Expected: passed.
+
+- [ ] **Step 7: Commit**
+
+```
+git add src/ClaudeDo.Worker/Hub/WorkerHub.cs src/ClaudeDo.Worker/Hub/HubBroadcaster.cs tests/ClaudeDo.Worker.Tests/Hub/AgentSettingsHubTests.cs
+git commit -m "feat(worker): add hub methods for list and task agent settings"
+```
+
+---
+
+## Task 4: WorkerClient — 4 new methods + `ListUpdatedEvent`
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/Services/WorkerClient.cs`
+
+Add client-side DTOs (mirroring the hub DTOs, or import from `ClaudeDo.Worker` if cross-project references allow — else redeclare as simple records in the UI project), client methods, and subscribe to the new `ListUpdated` event.
+
+- [ ] **Step 1: Inspect current WorkerClient shape**
+
+Open `src/ClaudeDo.Ui/Services/WorkerClient.cs` and find where `UpdateAppSettings`, `TaskUpdatedEvent`, and the hub event subscriptions are declared. The new code will mirror the exact pattern used there (naming, event signature, async wrapper).
+
+- [ ] **Step 2: Add client DTOs**
+
+At the top of `WorkerClient.cs` (or in a nested namespace if the file already has DTO records, e.g. `AppSettingsDto`), add:
+
+```csharp
+public sealed record UpdateListClientDto(string Id, string Name, string? WorkingDir, string DefaultCommitType);
+public sealed record UpdateListConfigClientDto(string ListId, string? Model, string? SystemPrompt, string? AgentPath);
+public sealed record UpdateTaskAgentSettingsClientDto(string TaskId, string? Model, string? SystemPrompt, string? AgentPath);
+public sealed record ListConfigClientDto(string? Model, string? SystemPrompt, string? AgentPath);
+```
+
+Use the existing file's naming convention instead of "ClientDto" if the file already has a convention (e.g., `AppSettingsDto` with no suffix — then follow suit and just name them `UpdateListDto`, `UpdateListConfigDto`, etc. in the UI namespace).
+
+- [ ] **Step 3: Add the four client methods**
+
+Inside the `WorkerClient` class, alongside `UpdateAppSettings`:
+
+```csharp
+public async Task UpdateListAsync(UpdateListClientDto dto, CancellationToken ct = default)
+{
+    await _hub.InvokeAsync("UpdateList", dto, ct);
+}
+
+public async Task UpdateListConfigAsync(UpdateListConfigClientDto dto, CancellationToken ct = default)
+{
+    await _hub.InvokeAsync("UpdateListConfig", dto, ct);
+}
+
+public async Task<ListConfigClientDto?> GetListConfigAsync(string listId, CancellationToken ct = default)
+{
+    return await _hub.InvokeAsync<ListConfigClientDto?>("GetListConfig", listId, ct);
+}
+
+public async Task UpdateTaskAgentSettingsAsync(UpdateTaskAgentSettingsClientDto dto, CancellationToken ct = default)
+{
+    await _hub.InvokeAsync("UpdateTaskAgentSettings", dto, ct);
+}
+```
+
+- [ ] **Step 4: Subscribe to `ListUpdated` event**
+
+Find where other hub events are subscribed (usually in `WorkerClient`'s `ConfigureHub` / `StartAsync` / constructor-equivalent setup). Add a line mirroring the pattern used for `TaskUpdated`:
+
+```csharp
+_hub.On<string>("ListUpdated", listId => ListUpdatedEvent?.Invoke(listId));
+```
+
+And declare the event alongside the other events (e.g. `TaskUpdatedEvent`):
+
+```csharp
+public event Action<string>? ListUpdatedEvent;
+```
+
+- [ ] **Step 5: Build UI**
+
+```
+dotnet build src/ClaudeDo.Ui/ClaudeDo.Ui.csproj
+```
+Expected: build succeeded, 0 errors.
+
+- [ ] **Step 6: Commit**
+
+```
+git add src/ClaudeDo.Ui/Services/WorkerClient.cs
+git commit -m "feat(ui): WorkerClient supports list/task agent settings + ListUpdated event"
+```
+
+---
+
+## Task 5: `ListSettingsModalViewModel`
+
+**Files:**
+- Create: `src/ClaudeDo.Ui/ViewModels/Modals/ListSettingsModalViewModel.cs`
+- Modify: `src/ClaudeDo.App/App.axaml.cs` (or wherever DI is registered — look for `AddTransient<WorktreeModalViewModel>` / `AddSingleton<MergeModalViewModel>` to find the registration block)
+
+- [ ] **Step 1: Create the ViewModel**
+
+Write `src/ClaudeDo.Ui/ViewModels/Modals/ListSettingsModalViewModel.cs`:
+
+```csharp
+using System.Collections.ObjectModel;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Ui.Services;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+
+namespace ClaudeDo.Ui.ViewModels.Modals;
+
+public sealed partial class ListSettingsModalViewModel : ViewModelBase
+{
+    private readonly WorkerClient _worker;
+
+    // Set by caller before Show
+    public string ListId { get; set; } = "";
+
+    [ObservableProperty] private string _name = "";
+    [ObservableProperty] private string _workingDir = "";
+    [ObservableProperty] private string _defaultCommitType = "chore";
+
+    [ObservableProperty] private string _selectedModel = "(default)";
+    [ObservableProperty] private string _systemPrompt = "";
+    [ObservableProperty] private AgentInfo? _selectedAgent;
+
+    public ObservableCollection<string> ModelOptions { get; } = new()
+    {
+        "(default)", "sonnet", "opus", "haiku",
+    };
+
+    public ObservableCollection<string> CommitTypeOptions { get; } = new()
+    {
+        "chore", "feat", "fix", "refactor", "docs", "test", "ci", "perf", "style", "build",
+    };
+
+    public ObservableCollection<AgentInfo> Agents { get; } = new();
+
+    public Action? CloseAction { get; set; }
+
+    public ListSettingsModalViewModel(WorkerClient worker)
+    {
+        _worker = worker;
+    }
+
+    public async Task LoadAsync(
+        string listId,
+        string name,
+        string? workingDir,
+        string defaultCommitType,
+        CancellationToken ct = default)
+    {
+        ListId = listId;
+        Name = name;
+        WorkingDir = workingDir ?? "";
+        DefaultCommitType = string.IsNullOrWhiteSpace(defaultCommitType) ? "chore" : defaultCommitType;
+
+        Agents.Clear();
+        Agents.Add(new AgentInfo("(none)", "", ""));
+        var agents = await _worker.GetAgentsAsync();
+        foreach (var a in agents) Agents.Add(a);
+
+        var config = await _worker.GetListConfigAsync(listId, ct);
+        SelectedModel = string.IsNullOrWhiteSpace(config?.Model) ? "(default)" : config!.Model!;
+        SystemPrompt = config?.SystemPrompt ?? "";
+        SelectedAgent = string.IsNullOrWhiteSpace(config?.AgentPath)
+            ? Agents[0]
+            : (Agents.FirstOrDefault(a => a.Path == config!.AgentPath) ?? Agents[0]);
+    }
+
+    [RelayCommand]
+    private async Task SaveAsync()
+    {
+        var model = SelectedModel == "(default)" ? null : SelectedModel;
+        var sp = string.IsNullOrWhiteSpace(SystemPrompt) ? null : SystemPrompt;
+        var ap = SelectedAgent is null || string.IsNullOrWhiteSpace(SelectedAgent.Path) ? null : SelectedAgent.Path;
+
+        await _worker.UpdateListAsync(new UpdateListClientDto(
+            ListId,
+            string.IsNullOrWhiteSpace(Name) ? "Untitled" : Name,
+            string.IsNullOrWhiteSpace(WorkingDir) ? null : WorkingDir,
+            DefaultCommitType));
+
+        await _worker.UpdateListConfigAsync(new UpdateListConfigClientDto(
+            ListId, model, sp, ap));
+
+        CloseAction?.Invoke();
+    }
+
+    [RelayCommand]
+    private void Cancel() => CloseAction?.Invoke();
+
+    [RelayCommand]
+    private void ResetAgentSettings()
+    {
+        SelectedModel = "(default)";
+        SystemPrompt = "";
+        SelectedAgent = Agents.Count > 0 ? Agents[0] : null;
+    }
+}
+```
+
+> Match the exact DTO record names used in `WorkerClient.cs` from Task 4. If you named them `UpdateListDto` (without `Client` suffix), update the `new UpdateListClientDto(...)` calls above to `new UpdateListDto(...)`.
+
+- [ ] **Step 2: Register in DI**
+
+Find the file that registers modal ViewModels (search the repo for `AddTransient<WorktreeModalViewModel>` or `AddSingleton<MergeModalViewModel>` — likely in `src/ClaudeDo.App/App.axaml.cs` or a DI extension). Add:
+
+```csharp
+services.AddTransient<ListSettingsModalViewModel>();
+```
+
+- [ ] **Step 3: Build UI**
+
+```
+dotnet build src/ClaudeDo.Ui/ClaudeDo.Ui.csproj
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj
+```
+Expected: both build succeeded, 0 errors.
+
+- [ ] **Step 4: Commit**
+
+```
+git add src/ClaudeDo.Ui/ViewModels/Modals/ListSettingsModalViewModel.cs src/ClaudeDo.App/App.axaml.cs
+git commit -m "feat(ui): add ListSettingsModalViewModel"
+```
+
+---
+
+## Task 6: `ListSettingsModalView`
+
+**Files:**
+- Create: `src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml`
+- Create: `src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml.cs`
+
+- [ ] **Step 1: Create the view XAML**
+
+Write `src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml`:
+
+```xml
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:vm="using:ClaudeDo.Ui.ViewModels.Modals"
+        x:Class="ClaudeDo.Ui.Views.Modals.ListSettingsModalView"
+        x:DataType="vm:ListSettingsModalViewModel"
+        Title="List settings"
+        Width="520" Height="600"
+        WindowStartupLocation="CenterOwner"
+        CanResize="False">
+    <DockPanel Margin="16">
+        <StackPanel DockPanel.Dock="Bottom" Orientation="Horizontal" HorizontalAlignment="Right" Spacing="8" Margin="0,16,0,0">
+            <Button Content="Cancel" Command="{Binding CancelCommand}" />
+            <Button Content="Save" Command="{Binding SaveCommand}" Classes="accent" />
+        </StackPanel>
+
+        <ScrollViewer>
+            <StackPanel Spacing="16">
+                <TextBlock Text="General" FontSize="16" FontWeight="SemiBold" />
+
+                <StackPanel Spacing="4">
+                    <TextBlock Text="Name" />
+                    <TextBox Text="{Binding Name}" />
+                </StackPanel>
+
+                <StackPanel Spacing="4">
+                    <TextBlock Text="Working directory" />
+                    <Grid ColumnDefinitions="*,Auto" >
+                        <TextBox Grid.Column="0" Text="{Binding WorkingDir}" Watermark="(none)" />
+                        <Button Grid.Column="1" Content="Browse…" Margin="8,0,0,0" Click="BrowseClicked" />
+                    </Grid>
+                </StackPanel>
+
+                <StackPanel Spacing="4">
+                    <TextBlock Text="Default commit type" />
+                    <ComboBox ItemsSource="{Binding CommitTypeOptions}"
+                              SelectedItem="{Binding DefaultCommitType, Mode=TwoWay}"
+                              HorizontalAlignment="Left" MinWidth="160" />
+                </StackPanel>
+
+                <Separator Margin="0,8,0,8" />
+
+                <Grid ColumnDefinitions="*,Auto">
+                    <TextBlock Grid.Column="0" Text="Agent" FontSize="16" FontWeight="SemiBold" />
+                    <Button Grid.Column="1" Content="Reset agent settings"
+                            Command="{Binding ResetAgentSettingsCommand}" />
+                </Grid>
+
+                <StackPanel Spacing="4">
+                    <TextBlock Text="Model" />
+                    <ComboBox ItemsSource="{Binding ModelOptions}"
+                              SelectedItem="{Binding SelectedModel, Mode=TwoWay}"
+                              HorizontalAlignment="Left" MinWidth="160" />
+                </StackPanel>
+
+                <StackPanel Spacing="4">
+                    <TextBlock Text="System prompt (appended)" />
+                    <TextBox Text="{Binding SystemPrompt, Mode=TwoWay}"
+                             AcceptsReturn="True" TextWrapping="Wrap"
+                             MinHeight="80" />
+                </StackPanel>
+
+                <StackPanel Spacing="4">
+                    <TextBlock Text="Agent file" />
+                    <ComboBox ItemsSource="{Binding Agents}"
+                              SelectedItem="{Binding SelectedAgent, Mode=TwoWay}"
+                              HorizontalAlignment="Left" MinWidth="240">
+                        <ComboBox.ItemTemplate>
+                            <DataTemplate>
+                                <StackPanel>
+                                    <TextBlock Text="{Binding Name}" />
+                                    <TextBlock Text="{Binding Description}" Opacity="0.6" FontSize="11" />
+                                </StackPanel>
+                            </DataTemplate>
+                        </ComboBox.ItemTemplate>
+                    </ComboBox>
+                </StackPanel>
+            </StackPanel>
+        </ScrollViewer>
+    </DockPanel>
+</Window>
+```
+
+- [ ] **Step 2: Create the code-behind**
+
+Write `src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml.cs`:
+
+```csharp
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Platform.Storage;
+using ClaudeDo.Ui.ViewModels.Modals;
+
+namespace ClaudeDo.Ui.Views.Modals;
+
+public partial class ListSettingsModalView : Window
+{
+    public ListSettingsModalView()
+    {
+        InitializeComponent();
+    }
+
+    private async void BrowseClicked(object? sender, RoutedEventArgs e)
+    {
+        if (DataContext is not ListSettingsModalViewModel vm) return;
+        var top = TopLevel.GetTopLevel(this);
+        if (top is null) return;
+
+        var folders = await top.StorageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
+        {
+            Title = "Choose working directory",
+            AllowMultiple = false,
+        });
+        if (folders.Count > 0)
+        {
+            vm.WorkingDir = folders[0].Path.LocalPath;
+        }
+    }
+}
+```
+
+- [ ] **Step 3: Build UI**
+
+```
+dotnet build src/ClaudeDo.Ui/ClaudeDo.Ui.csproj
+```
+Expected: build succeeded, 0 errors.
+
+- [ ] **Step 4: Commit**
+
+```
+git add src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml.cs
+git commit -m "feat(ui): add ListSettingsModalView"
+```
+
+---
+
+## Task 7: Wire context menu + gear button in `ListsIslandView`
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/Views/Islands/ListsIslandView.axaml`
+- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/ListsIslandViewModel.cs`
+- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/ListNavItemViewModel.cs` (expose fields needed by modal)
+
+- [ ] **Step 1: Ensure `ListNavItemViewModel` carries list fields**
+
+Read `src/ClaudeDo.Ui/ViewModels/Islands/ListNavItemViewModel.cs`. Confirm it has `Id`, `Name`. Add `WorkingDir` (string?) and `DefaultCommitType` (string) as `[ObservableProperty]` fields if missing. Also ensure the loader that populates `ListNavItemViewModel`s reads these from the DB.
+
+- [ ] **Step 2: Add `OpenSettingsAsync` command to `ListsIslandViewModel`**
+
+Read `src/ClaudeDo.Ui/ViewModels/Islands/ListsIslandViewModel.cs`. Add a field `ShowListSettingsModal` (view wires it) and a command:
+
+```csharp
+// Set by the view so the command can show the modal as a dialog.
+public Func<ListSettingsModalViewModel, System.Threading.Tasks.Task>? ShowListSettingsModal { get; set; }
+
+[RelayCommand]
+private async System.Threading.Tasks.Task OpenSettingsAsync(ListNavItemViewModel? row)
+{
+    if (row is null || ShowListSettingsModal is null) return;
+    var vm = _services.GetRequiredService<ListSettingsModalViewModel>();
+    await vm.LoadAsync(row.Id, row.Name, row.WorkingDir, row.DefaultCommitType);
+    await ShowListSettingsModal(vm);
+    // Refresh this row from DB in case name/working-dir changed
+    await RefreshRowAsync(row.Id);
+}
+```
+
+Add an `_services` constructor dependency (`IServiceProvider`) if not already present. Add `RefreshRowAsync(string listId)` that re-queries the list entity and updates the row's observable fields. Also subscribe to `_worker.ListUpdatedEvent += id => _ = RefreshRowAsync(id);` in the constructor (dispatch to UI thread if needed per existing pattern).
+
+- [ ] **Step 3: Update `ListsIslandView.axaml`**
+
+Open `src/ClaudeDo.Ui/Views/Islands/ListsIslandView.axaml` and find the DataTemplate for list rows. Add a context menu + a gear button. Example additions (adapt to the current `DataTemplate`/`ItemsControl` structure):
+
+```xml
+<Grid ColumnDefinitions="*,Auto">
+    <!-- existing name cell -->
+    <TextBlock Grid.Column="0" Text="{Binding Name}" VerticalAlignment="Center" />
+    <!-- NEW gear button, visible on hover via opacity trigger or always visible -->
+    <Button Grid.Column="1"
+            Content="⚙"
+            ToolTip.Tip="Settings…"
+            Command="{Binding $parent[UserControl].((vm:ListsIslandViewModel)DataContext).OpenSettingsCommand}"
+            CommandParameter="{Binding}" />
+    <Grid.ContextMenu>
+        <ContextMenu>
+            <MenuItem Header="Settings…"
+                      Command="{Binding $parent[UserControl].((vm:ListsIslandViewModel)DataContext).OpenSettingsCommand}"
+                      CommandParameter="{Binding}" />
+        </ContextMenu>
+    </Grid.ContextMenu>
+</Grid>
+```
+
+The exact ancestor navigation syntax depends on how other commands are bound in this view — match whatever pattern `ListsIslandView` already uses for its commands.
+
+Also wire `ShowListSettingsModal` in `ListsIslandView.axaml.cs` `OnDataContextChanged` (mirror how other islands set their modal-show callbacks):
+
+```csharp
+if (DataContext is ListsIslandViewModel vm)
+{
+    vm.ShowListSettingsModal = async modal =>
+    {
+        var window = new ListSettingsModalView { DataContext = modal };
+        modal.CloseAction = () => window.Close();
+        var top = TopLevel.GetTopLevel(this) as Window;
+        if (top is null) window.Show();
+        else await window.ShowDialog(top);
+    };
+}
+```
+
+- [ ] **Step 4: Build**
+
+```
+dotnet build src/ClaudeDo.Ui/ClaudeDo.Ui.csproj
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj
+```
+Expected: 0 errors.
+
+- [ ] **Step 5: Commit**
+
+```
+git add src/ClaudeDo.Ui/Views/Islands/ListsIslandView.axaml src/ClaudeDo.Ui/Views/Islands/ListsIslandView.axaml.cs src/ClaudeDo.Ui/ViewModels/Islands/ListsIslandViewModel.cs src/ClaudeDo.Ui/ViewModels/Islands/ListNavItemViewModel.cs
+git commit -m "feat(ui): open ListSettingsModal via context menu and gear button"
+```
+
+---
+
+## Task 8: Per-task agent settings in `DetailsIsland`
+
+**Files:**
+- Modify: `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs`
+- Modify: `src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml`
+
+Per-task overrides with inherit-fallback display. Auto-save on change (debounced 300ms).
+
+- [ ] **Step 1: Extend `DetailsIslandViewModel`**
+
+In `src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs`, add (alongside the existing `_model` field):
+
+```csharp
+[ObservableProperty] private string _taskModelSelection = "(inherit)";
+[ObservableProperty] private string _taskSystemPrompt = "";
+[ObservableProperty] private AgentInfo? _taskSelectedAgent;
+
+[ObservableProperty] private string _effectiveModelHint = "";
+[ObservableProperty] private string _effectiveSystemPromptHint = "";
+[ObservableProperty] private string _effectiveAgentHint = "";
+
+public ObservableCollection<string> TaskModelOptions { get; } = new()
+{
+    "(inherit)", "sonnet", "opus", "haiku",
+};
+
+public ObservableCollection<AgentInfo> TaskAgentOptions { get; } = new();
+
+private bool _suppressAgentSave;
+private CancellationTokenSource? _agentSaveCts;
+```
+
+Add an async helper `LoadAgentSettingsAsync(TaskEntity taskEntity)` called from `BindAsync` *after* the entity is loaded:
+
+```csharp
+private async Task LoadAgentSettingsAsync(TaskEntity entity, CancellationToken ct)
+{
+    _suppressAgentSave = true;
+    try
+    {
+        TaskAgentOptions.Clear();
+        TaskAgentOptions.Add(new AgentInfo("(inherit)", "", ""));
+        var agents = await _worker.GetAgentsAsync();
+        foreach (var a in agents) TaskAgentOptions.Add(a);
+
+        TaskModelSelection = string.IsNullOrWhiteSpace(entity.Model) ? "(inherit)" : entity.Model!;
+        TaskSystemPrompt = entity.SystemPrompt ?? "";
+        TaskSelectedAgent = string.IsNullOrWhiteSpace(entity.AgentPath)
+            ? TaskAgentOptions[0]
+            : (TaskAgentOptions.FirstOrDefault(a => a.Path == entity.AgentPath) ?? TaskAgentOptions[0]);
+
+        // Effective-value hints — load list's config for display
+        var listCfg = await _worker.GetListConfigAsync(entity.ListId, ct);
+        EffectiveModelHint = listCfg?.Model ?? "(global default)";
+        EffectiveSystemPromptHint = string.IsNullOrWhiteSpace(listCfg?.SystemPrompt) ? "(none)" : listCfg!.SystemPrompt!;
+        EffectiveAgentHint = string.IsNullOrWhiteSpace(listCfg?.AgentPath) ? "(none)" : System.IO.Path.GetFileName(listCfg!.AgentPath!);
+    }
+    finally
+    {
+        _suppressAgentSave = false;
+    }
+}
+```
+
+Add `partial void` handlers that trigger a debounced save:
+
+```csharp
+partial void OnTaskModelSelectionChanged(string value) => QueueAgentSave();
+partial void OnTaskSystemPromptChanged(string value) => QueueAgentSave();
+partial void OnTaskSelectedAgentChanged(AgentInfo? value) => QueueAgentSave();
+
+private void QueueAgentSave()
+{
+    if (_suppressAgentSave || Task is null) return;
+    _agentSaveCts?.Cancel();
+    _agentSaveCts = new CancellationTokenSource();
+    var ct = _agentSaveCts.Token;
+    _ = SaveAgentSettingsAsync(ct);
+}
+
+private async Task SaveAgentSettingsAsync(CancellationToken ct)
+{
+    try
+    {
+        await Task.Delay(300, ct);
+        if (Task is null) return;
+
+        var model = TaskModelSelection == "(inherit)" ? null : TaskModelSelection;
+        var sp = string.IsNullOrWhiteSpace(TaskSystemPrompt) ? null : TaskSystemPrompt;
+        var ap = TaskSelectedAgent is null || string.IsNullOrWhiteSpace(TaskSelectedAgent.Path)
+            ? null : TaskSelectedAgent.Path;
+
+        await _worker.UpdateTaskAgentSettingsAsync(
+            new UpdateTaskAgentSettingsClientDto(Task.Id, model, sp, ap), ct);
+    }
+    catch (OperationCanceledException) { /* a newer change superseded this one */ }
+    catch { /* best-effort; live log will surface worker errors */ }
+}
+```
+
+Also add a computed `bool IsAgentSectionEnabled => !IsRunning;` (already partial for `IsRunning`; raise property change when it flips by adding to the existing `OnAgentStatusLabelChanged` method):
+
+```csharp
+OnPropertyChanged(nameof(IsAgentSectionEnabled));
+```
+
+> Note: `System.Threading.Tasks.Task.Delay` — the file uses `Task` as an `[ObservableProperty]` name so `Task.Delay` resolves to the property, not the type. Fully qualify as `await System.Threading.Tasks.Task.Delay(300, ct);`.
+
+- [ ] **Step 2: Add the expander to `DetailsIslandView.axaml`**
+
+Open the view and add, somewhere inside the main scroll/stack layout (after the existing notes / before or after other sections — pick a natural location in the current layout):
+
+```xml
+<Expander Header="Agent settings (overrides)"
+          IsExpanded="False"
+          IsEnabled="{Binding IsAgentSectionEnabled}">
+    <StackPanel Spacing="8" Margin="0,8,0,0">
+
+        <StackPanel Spacing="2">
+            <TextBlock Text="Model" />
+            <ComboBox ItemsSource="{Binding TaskModelOptions}"
+                      SelectedItem="{Binding TaskModelSelection, Mode=TwoWay}"
+                      MinWidth="160" HorizontalAlignment="Left" />
+            <TextBlock Text="{Binding EffectiveModelHint, StringFormat='Effective if inherited: {0}'}"
+                       Opacity="0.6" FontSize="11" />
+        </StackPanel>
+
+        <StackPanel Spacing="2">
+            <TextBlock Text="System prompt (appended)" />
+            <TextBox Text="{Binding TaskSystemPrompt, Mode=TwoWay}"
+                     AcceptsReturn="True" TextWrapping="Wrap" MinHeight="60"
+                     Watermark="{Binding EffectiveSystemPromptHint}" />
+        </StackPanel>
+
+        <StackPanel Spacing="2">
+            <TextBlock Text="Agent file" />
+            <ComboBox ItemsSource="{Binding TaskAgentOptions}"
+                      SelectedItem="{Binding TaskSelectedAgent, Mode=TwoWay}"
+                      MinWidth="240" HorizontalAlignment="Left">
+                <ComboBox.ItemTemplate>
+                    <DataTemplate>
+                        <TextBlock Text="{Binding Name}" />
+                    </DataTemplate>
+                </ComboBox.ItemTemplate>
+            </ComboBox>
+            <TextBlock Text="{Binding EffectiveAgentHint, StringFormat='Effective if inherited: {0}'}"
+                       Opacity="0.6" FontSize="11" />
+        </StackPanel>
+
+    </StackPanel>
+</Expander>
+```
+
+- [ ] **Step 3: Call `LoadAgentSettingsAsync` from `BindAsync`**
+
+In `DetailsIslandViewModel.BindAsync`, after `AgentStatusLabel = entity.Status.ToString();`, add:
+
+```csharp
+await LoadAgentSettingsAsync(entity, ct);
+ct.ThrowIfCancellationRequested();
+```
+
+In `Bind(TaskRowViewModel? row)` — the `row == null` branch — reset the new fields:
+
+```csharp
+TaskModelSelection = "(inherit)";
+TaskSystemPrompt = "";
+TaskSelectedAgent = null;
+EffectiveModelHint = "";
+EffectiveSystemPromptHint = "";
+EffectiveAgentHint = "";
+```
+
+- [ ] **Step 4: Build**
+
+```
+dotnet build src/ClaudeDo.Ui/ClaudeDo.Ui.csproj
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj
+```
+Expected: 0 errors.
+
+- [ ] **Step 5: Commit**
+
+```
+git add src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml
+git commit -m "feat(ui): per-task agent settings in DetailsIsland"
+```
+
+---
+
+## Task 9: Documentation refresh
+
+**Files:**
+- Modify: `src/ClaudeDo.Data/CLAUDE.md`
+- Modify: `src/ClaudeDo.Worker/CLAUDE.md`
+- Modify: `src/ClaudeDo.Ui/CLAUDE.md`
+
+The project CLAUDE.md files are stale — `Data/CLAUDE.md` doesn't mention `ListConfigEntity`, `TaskRunEntity`, or the Model/SystemPrompt/AgentPath fields that already exist. Bring them up to date now that the full per-task/per-list path is wired end-to-end.
+
+- [ ] **Step 1: Update `ClaudeDo.Data/CLAUDE.md`**
+
+Add to the Models section:
+```
+- **ListConfigEntity** — ListId (PK, 1:1 with list), Model, SystemPrompt, AgentPath (all nullable)
+- **TaskRunEntity** — per-run record (session_id, tokens, turns, result, structured output, exit code, log path)
+- **SubtaskEntity**, **AgentInfo** — existing helpers
+- **TaskEntity** — add Model / SystemPrompt / AgentPath override fields (nullable), IsStarred, IsMyDay, Notes
+```
+
+Add to Repositories section:
+```
+- **ListRepository** — also manages `list_config` via `GetConfigAsync`, `SetConfigAsync` (upsert), `DeleteConfigAsync`
+- **TaskRepository** — also has `UpdateAgentSettingsAsync` (model/system-prompt/agent-path)
+- **TaskRunRepository**, **SubtaskRepository**, **AppSettingsRepository** — existing
+```
+
+Schema section: bump to 9+ tables including `list_config`, `task_runs`, `subtasks`, `app_settings`.
+
+- [ ] **Step 2: Update `ClaudeDo.Worker/CLAUDE.md`**
+
+In the SignalR Hub section, extend the method list:
+```
+**WorkerHub** methods: Ping, GetActive, RunNow, CancelTask, WakeQueue, ContinueTask, ResetTask, GetAgents, RefreshAgents,
+GetAppSettings, UpdateAppSettings, CleanupFinishedWorktrees, ResetAllWorktrees, MergeTask, GetMergeTargets,
+UpdateList, UpdateListConfig, GetListConfig, UpdateTaskAgentSettings
+```
+
+In events list, add `ListUpdated(listId)` alongside `TaskUpdated`.
+
+- [ ] **Step 3: Update `ClaudeDo.Ui/CLAUDE.md`**
+
+In the "Views" section, add:
+```
+- **ListSettingsModalView** — edits list name, working dir, default commit type, and per-list Model/SystemPrompt/AgentPath. Opened via context menu or gear button on a list row.
+- **DetailsIslandView** — now contains an "Agent settings (overrides)" expander with per-task Model/SystemPrompt/AgentPath, showing inherited effective values. Disabled while task is running.
+```
+
+In the "Services" section, extend WorkerClient method list to include `UpdateListAsync`, `UpdateListConfigAsync`, `GetListConfigAsync`, `UpdateTaskAgentSettingsAsync`. Events: add `ListUpdatedEvent`.
+
+- [ ] **Step 4: Commit**
+
+```
+git add src/ClaudeDo.Data/CLAUDE.md src/ClaudeDo.Worker/CLAUDE.md src/ClaudeDo.Ui/CLAUDE.md
+git commit -m "docs: refresh CLAUDE.md files for agent settings UI"
+```
+
+---
+
+## Task 10: Full build + test + manual smoke checklist
+
+- [ ] **Step 1: Full build of all non-installer projects**
+
+```
+dotnet build src/ClaudeDo.Data/ClaudeDo.Data.csproj
+dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj
+dotnet build src/ClaudeDo.Ui/ClaudeDo.Ui.csproj
+dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj
+```
+Expected: all four build with 0 errors.
+
+- [ ] **Step 2: Run full test suite**
+
+```
+dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj
+```
+Expected: all tests pass.
+
+- [ ] **Step 3: Record manual smoke-test checklist**
+
+This step is documentation only — the smoke test must be run by a human after merging (UI). Record the following in the PR description (or a file like `docs/smoke-tests/2026-04-22-agent-settings.md`):
+
+1. Open ClaudeDo.App.
+2. Right-click a list → **Settings…** opens modal.
+3. Enter a Name, choose a Model (e.g. `opus`), enter a system prompt, pick an agent → Save.
+4. Reopen modal → values persist.
+5. Select a task in that list → DetailsIsland shows "Agent settings (overrides)" expander, expand it, confirm fields show `(inherit)` and the hint line reflects the list's chosen Model.
+6. Set task Model to `haiku` → run the task → verify log shows `--model haiku` was passed.
+7. Click **Reset agent settings** in list modal → Save → DetailsIsland now shows `(global default)` hint.
+8. Start a task run → verify DetailsIsland agent expander is disabled while Running.
+
+- [ ] **Step 4: Final status check**
+
+```
+git status
+git log --oneline -15
+```
+Expected: working tree clean, 8 feature/test commits since the start + 1 doc commit + 1 spec commit.
+
+---
+
+## Notes for the implementing subagents
+
+- **Sonnet** only (project preference).
+- **Minimal diff**: do NOT refactor unrelated code. Only the files listed per task.
+- **No summaries, no comments** added to unchanged code — the user dislikes over-commenting.
+- If the project's file/naming pattern diverges from what's shown (e.g. DI registration file, hub broadcaster signature), match the existing pattern. The plan's code is illustrative but naming alignment with the codebase overrides it.
+- If a test file references helpers (`TempDatabase`) that don't exist, mirror the helper actually used in the project's other `*RepositoryTests`. Do not invent new test infrastructure.
+- Commit after each completed task (as listed in the plan).