# 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).