# Layer C — Inline Conflict Resolver 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:** Build the worker-side conflict plumbing (5 frozen hub methods + GitService reads) and a VSCode-style in-app inline conflict resolver UI for ClaudeDo's merge rework.

**Architecture:** The worker performs a real merge that leaves conflicts in the list's working tree (`leaveConflictsInTree:true`), exposes ours/theirs/base per conflicted file via `git show :2:/:3:/:1:`, accepts written resolutions, and finishes via the existing `ContinueMergeAsync`/`AbortMergeAsync`. The UI presents each conflicted file's hunk with Accept Current/Incoming/Both/Edit-manually controls plus a free-text merged box, then writes resolutions and continues.

**Tech Stack:** .NET 8, ASP.NET Core SignalR (WorkerHub), EF Core/SQLite, Avalonia MVVM (CommunityToolkit), xUnit + real git/SQLite fixtures.

**Frozen client contract (already shipped in foundation commit `2dfc455`, DO NOT edit):**
- `IWorkerClient` / `WorkerClient.cs` already call hub methods by name: `StartConflictMerge`, `GetMergeConflicts`, `WriteConflictResolution`, `ContinueMerge`, `AbortMerge`.
- Client DTOs already exist in `WorkerClient.cs`: `MergeConflictsDto(string TaskId, IReadOnlyList<ConflictFileDto> Files)`, `ConflictFileDto(string Path, IReadOnlyList<ConflictHunkDto> Hunks)`, `ConflictHunkDto(string Ours, string Theirs, string? Base)`, plus existing `MergeResultDto(string Status, IReadOnlyList<string> ConflictFiles, string? ErrorMessage)`.
- Worker-side DTOs must serialize identically (same record shape) and live in `WorkerHub.cs`.

**Do NOT touch:** `WorkerClient.cs`, `Interfaces/IWorkerClient.cs`, `WorkConsole.axaml`, `DetailsIslandViewModel.cs`, `WorktreesOverviewModalView/VM`, `WorktreeModalView`. Test fakes for `IWorkerClient` already implement the 5 methods as no-op stubs (`StubWorkerClient` is `virtual` in Ui.Tests) — subclass/override, never edit the interface.

**Build/test commands (.NET 8 — running Worker locks `Debug`, always `-c Release`):**
```bash
dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
dotnet test tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj -c Release
```

---

## File Structure

**Worker / Data (create + modify):**
- Modify `src/ClaudeDo.Data/Git/GitService.cs` — add `ShowStageAsync` (untrimmed blob read) + `AddPathAsync`; add `trimOutput` param to `RunGitAsync`.
- Modify `src/ClaudeDo.Worker/Lifecycle/TaskMergeService.cs` — add records `MergeConflicts`/`ConflictFileContent`; add `GetConflictsAsync` + `WriteResolutionAsync`.
- Modify `src/ClaudeDo.Worker/Hub/WorkerHub.cs` — add DTOs `MergeConflictsDto`/`ConflictFileDto`/`ConflictHunkDto` + 5 hub methods.

**UI (create new only):**
- Create `src/ClaudeDo.Ui/ViewModels/Conflicts/ConflictModels.cs` — `ConflictFile`, `ConflictHunk`.
- Create `src/ClaudeDo.Ui/ViewModels/Conflicts/ConflictResolverViewModel.cs`.
- Create `src/ClaudeDo.Ui/Views/Conflicts/ConflictResolverView.axaml` + `.axaml.cs`.

**Wiring (modify):**
- Modify `src/ClaudeDo.App/Program.cs` — register `ConflictResolverViewModel` + `Func<string, ConflictResolverViewModel>`.
- Modify `src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs` — additive seam (`ConflictResolverFactory`, `ShowConflictResolver`, `RequestConflictResolutionAsync`).
- Modify `src/ClaudeDo.Ui/Views/MainWindow.axaml.cs` — wire `ShowConflictResolver` dialog delegate.
- Modify `src/ClaudeDo.Localization/locales/en.json` + `de.json` — `conflictResolver.*` keys (parity enforced by Localization.Tests).

**Tests (create + modify):**
- Modify `tests/ClaudeDo.Worker.Tests/Services/TaskMergeServiceTests.cs` — conflict-read / write-resolution / round-trip tests.
- Create `tests/ClaudeDo.Ui.Tests/ViewModels/ConflictResolverViewModelTests.cs`.

---

## Task 1: GitService conflict-blob reads

**Files:**
- Modify: `src/ClaudeDo.Data/Git/GitService.cs`
- Test: `tests/ClaudeDo.Worker.Tests/Services/TaskMergeServiceTests.cs` (GitService exercised here via real repo; add focused tests in Task 2 round-trip)

- [ ] **Step 1: Add `trimOutput` param to `RunGitAsync`** so blob reads keep exact bytes.

In `RunGitAsync` signature add `bool trimOutput = true`, and change the return to:
```csharp
return (proc.ExitCode, trimOutput ? stdout.TrimEnd() : stdout, stderr.TrimEnd());
```
(All existing callers keep the default `true`.)

- [ ] **Step 2: Add `ShowStageAsync` + `AddPathAsync`** (place after `ListConflictedFilesAsync`):

```csharp
/// <summary>
/// Reads a conflicted file's blob at a merge stage: 1=base, 2=ours, 3=theirs.
/// Returns null when the stage doesn't exist (e.g. add/add conflict has no base).
/// Output is NOT trimmed so file content round-trips exactly.
/// </summary>
public async Task<string?> ShowStageAsync(string repoDir, int stage, string path, CancellationToken ct = default)
{
    var (exitCode, stdout, _) = await RunGitAsync(repoDir, ["show", $":{stage}:{path}"], ct, trimOutput: false);
    return exitCode == 0 ? stdout : null;
}

public async Task AddPathAsync(string repoDir, string path, CancellationToken ct = default)
{
    var (exitCode, _, stderr) = await RunGitAsync(repoDir, ["add", "--", path], ct);
    if (exitCode != 0)
        throw new InvalidOperationException($"git add '{path}' failed (exit {exitCode}): {stderr}");
}
```

- [ ] **Step 3: Build the Data + Worker projects to verify compilation.**

Run: `dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release`
Expected: Build succeeded, 0 errors.

- [ ] **Step 4: Commit**

```bash
git add src/ClaudeDo.Data/Git/GitService.cs
git commit -m "feat(git): add conflict-stage blob reads and single-path staging"
```

---

## Task 2: TaskMergeService conflict reads + resolution writes

**Files:**
- Modify: `src/ClaudeDo.Worker/Lifecycle/TaskMergeService.cs`
- Test: `tests/ClaudeDo.Worker.Tests/Services/TaskMergeServiceTests.cs`

- [ ] **Step 1: Write failing tests** (append inside `TaskMergeServiceTests`, before `#region Test doubles`). Reuse the existing helpers `SeedListAndTask`, `SeedWorktree`, `BuildService`, and the `GitRepoFixture` conflict setup pattern from `ContinueMergeAsync_AfterUserResolves...`.

```csharp
[Fact]
public async Task GetConflictsAsync_AfterConflictMerge_ReturnsOursAndTheirs()
{
    if (!GitRepoFixture.IsGitAvailable()) return;

    var db = NewDb();
    var repo = NewRepo();
    GitRepoFixture.RunGit(repo.RepoDir, "branch", "-m", "main");
    File.WriteAllText(Path.Combine(repo.RepoDir, "README.md"), "# main change\n");
    GitRepoFixture.RunGit(repo.RepoDir, "commit", "-am", "main change");

    var wtPath = Path.Combine(Path.GetTempPath(), $"wt_{Guid.NewGuid():N}");
    _wtCleanups.Add((repo.RepoDir, wtPath));
    GitRepoFixture.RunGit(repo.RepoDir, "worktree", "add", "-b", "claudedo/c1", wtPath, repo.BaseCommit);
    File.WriteAllText(Path.Combine(wtPath, "README.md"), "# branch change\n");
    GitRepoFixture.RunGit(wtPath, "commit", "-am", "branch change");

    var (_, task) = await SeedListAndTask(db, workingDir: repo.RepoDir, status: TaskStatus.WaitingForReview);
    await SeedWorktree(db, task.Id, wtPath, "claudedo/c1", repo.BaseCommit);

    var (svc, _) = BuildService(db);
    var start = await svc.MergeAsync(task.Id, "main", false, "msg", leaveConflictsInTree: true, CancellationToken.None);
    Assert.Equal(TaskMergeService.StatusConflict, start.Status);

    var conflicts = await svc.GetConflictsAsync(task.Id, CancellationToken.None);

    Assert.Equal(task.Id, conflicts.TaskId);
    var file = Assert.Single(conflicts.Files);
    Assert.Equal("README.md", file.Path);
    Assert.Contains("main change", file.Ours);     // ours = target (main) side after checkout
    Assert.Contains("branch change", file.Theirs);  // theirs = merged-in branch
    Assert.NotNull(file.Base);

    GitRepoFixture.RunGit(repo.RepoDir, "merge", "--abort");
}

[Fact]
public async Task WriteResolutionAsync_ThenContinue_CompletesMerge()
{
    if (!GitRepoFixture.IsGitAvailable()) return;

    var db = NewDb();
    var repo = NewRepo();
    GitRepoFixture.RunGit(repo.RepoDir, "branch", "-m", "main");
    File.WriteAllText(Path.Combine(repo.RepoDir, "README.md"), "# main change\n");
    GitRepoFixture.RunGit(repo.RepoDir, "commit", "-am", "main change");

    var wtPath = Path.Combine(Path.GetTempPath(), $"wt_{Guid.NewGuid():N}");
    _wtCleanups.Add((repo.RepoDir, wtPath));
    GitRepoFixture.RunGit(repo.RepoDir, "worktree", "add", "-b", "claudedo/c2", wtPath, repo.BaseCommit);
    File.WriteAllText(Path.Combine(wtPath, "README.md"), "# branch change\n");
    GitRepoFixture.RunGit(wtPath, "commit", "-am", "branch change");

    var (_, task) = await SeedListAndTask(db, workingDir: repo.RepoDir, status: TaskStatus.WaitingForReview);
    await SeedWorktree(db, task.Id, wtPath, "claudedo/c2", repo.BaseCommit);

    var (svc, _) = BuildService(db);
    await svc.MergeAsync(task.Id, "main", false, "msg", leaveConflictsInTree: true, CancellationToken.None);

    await svc.WriteResolutionAsync(task.Id, "README.md", "# resolved by user\n", CancellationToken.None);
    var result = await svc.ContinueMergeAsync(task.Id, CancellationToken.None);

    Assert.Equal(TaskMergeService.StatusMerged, result.Status);
    Assert.Equal("# resolved by user\n", File.ReadAllText(Path.Combine(repo.RepoDir, "README.md")));
    Assert.False(await new GitService().IsMidMergeAsync(repo.RepoDir));
}
```

- [ ] **Step 2: Run tests to verify they fail** (no such methods).

Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter "GetConflictsAsync_AfterConflictMerge_ReturnsOursAndTheirs|WriteResolutionAsync_ThenContinue_CompletesMerge"`
Expected: compile error / FAIL (methods don't exist).

- [ ] **Step 3: Add records + methods to `TaskMergeService.cs`.**

Add records beside `MergeResult` (top of file, after the existing record declarations):
```csharp
public sealed record MergeConflicts(
    string TaskId,
    IReadOnlyList<ConflictFileContent> Files);

public sealed record ConflictFileContent(
    string Path,
    string Ours,
    string Theirs,
    string? Base);
```

Add methods inside the class (after `AbortMergeAsync`):
```csharp
public async Task<MergeConflicts> GetConflictsAsync(string taskId, CancellationToken ct)
{
    var (_, list, _) = await LoadMergeContextAsync(taskId, ct);
    if (string.IsNullOrWhiteSpace(list.WorkingDir))
        throw new InvalidOperationException("list has no working directory");

    var files = await _git.ListConflictedFilesAsync(list.WorkingDir, ct);
    var result = new List<ConflictFileContent>(files.Count);
    foreach (var path in files)
    {
        var ours   = await _git.ShowStageAsync(list.WorkingDir, 2, path, ct) ?? "";
        var theirs = await _git.ShowStageAsync(list.WorkingDir, 3, path, ct) ?? "";
        var @base  = await _git.ShowStageAsync(list.WorkingDir, 1, path, ct);
        result.Add(new ConflictFileContent(path, ours, theirs, @base));
    }
    return new MergeConflicts(taskId, result);
}

public async Task WriteResolutionAsync(string taskId, string path, string content, CancellationToken ct)
{
    var (_, list, _) = await LoadMergeContextAsync(taskId, ct);
    if (string.IsNullOrWhiteSpace(list.WorkingDir))
        throw new InvalidOperationException("list has no working directory");

    var full = Path.Combine(list.WorkingDir, path.Replace('/', Path.DirectorySeparatorChar));
    await File.WriteAllTextAsync(full, content, ct);
    await _git.AddPathAsync(list.WorkingDir, path, ct);
}
```
(Note: `Path` is `System.IO.Path` — the file already uses it via other helpers; the record property `Path` does not shadow it inside these methods because it's accessed as a static type, not an instance member.)

- [ ] **Step 4: Run the tests to verify they pass.**

Run: `dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release --filter "GetConflictsAsync_AfterConflictMerge_ReturnsOursAndTheirs|WriteResolutionAsync_ThenContinue_CompletesMerge"`
Expected: PASS (2 tests). If git unavailable they no-op.

- [ ] **Step 5: Commit**

```bash
git add src/ClaudeDo.Worker/Lifecycle/TaskMergeService.cs tests/ClaudeDo.Worker.Tests/Services/TaskMergeServiceTests.cs
git commit -m "feat(merge): read conflict stages and write user resolutions"
```

---

## Task 3: WorkerHub conflict methods + DTOs

**Files:**
- Modify: `src/ClaudeDo.Worker/Hub/WorkerHub.cs`

- [ ] **Step 1: Add DTOs** beside the existing merge DTOs (after `public record MergeTargetsDto(...)`):

```csharp
public record MergeConflictsDto(string TaskId, IReadOnlyList<ConflictFileDto> Files);
public record ConflictFileDto(string Path, IReadOnlyList<ConflictHunkDto> Hunks);
public record ConflictHunkDto(string Ours, string Theirs, string? Base);
```

- [ ] **Step 2: Add the 5 hub methods** (after `PreviewMerge`). Names/params/returns MUST match the frozen client calls.

```csharp
public Task<MergeResultDto> StartConflictMerge(string taskId, string targetBranch)
    => HubGuard(async () =>
    {
        var r = await _mergeService.MergeAsync(
            taskId, targetBranch ?? "", removeWorktree: false, "Merge task",
            leaveConflictsInTree: true, CancellationToken.None);
        if (r.Status == TaskMergeService.StatusBlocked)
            throw new HubException(r.ErrorMessage ?? "merge blocked");
        return new MergeResultDto(r.Status, r.ConflictFiles, r.ErrorMessage);
    });

public Task<MergeConflictsDto> GetMergeConflicts(string taskId)
    => HubGuard(async () =>
    {
        var c = await _mergeService.GetConflictsAsync(taskId, CancellationToken.None);
        return new MergeConflictsDto(
            c.TaskId,
            c.Files.Select(f => new ConflictFileDto(
                f.Path,
                new[] { new ConflictHunkDto(f.Ours, f.Theirs, f.Base) })).ToList());
    });

public Task WriteConflictResolution(string taskId, string path, string resolvedContent)
    => HubGuard(() => _mergeService.WriteResolutionAsync(
        taskId, path, resolvedContent ?? "", CancellationToken.None));

public Task<MergeResultDto> ContinueMerge(string taskId)
    => HubGuard(async () =>
    {
        var r = await _mergeService.ContinueMergeAsync(taskId, CancellationToken.None);
        if (r.Status == TaskMergeService.StatusBlocked)
            throw new HubException(r.ErrorMessage ?? "continue failed");
        return new MergeResultDto(r.Status, r.ConflictFiles, r.ErrorMessage);
    });

public Task AbortMerge(string taskId)
    => HubGuard(async () =>
    {
        var r = await _mergeService.AbortMergeAsync(taskId, CancellationToken.None);
        if (r.Status == TaskMergeService.StatusBlocked)
            throw new HubException(r.ErrorMessage ?? "abort failed");
    });
```

- [ ] **Step 3: Build the Worker project to verify compilation.**

Run: `dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release`
Expected: Build succeeded, 0 errors.

- [ ] **Step 4: Commit**

```bash
git add src/ClaudeDo.Worker/Hub/WorkerHub.cs
git commit -m "feat(hub): expose conflict-resolution merge methods"
```

---

## Task 4: Conflict UI model

**Files:**
- Create: `src/ClaudeDo.Ui/ViewModels/Conflicts/ConflictModels.cs`
- Test: `tests/ClaudeDo.Ui.Tests/ViewModels/ConflictResolverViewModelTests.cs` (model tests added here in Task 5; this task is build-verified)

- [ ] **Step 1: Create the model file.** Shaped so a 3-way pane needs no model change (`Base` retained per hunk).

```csharp
using System.Collections.Generic;
using System.Linq;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

namespace ClaudeDo.Ui.ViewModels.Conflicts;

public sealed partial class ConflictHunk : ObservableObject
{
    public string Ours { get; }
    public string Theirs { get; }
    public string? Base { get; }

    [ObservableProperty] private string? _resolution;

    public bool IsResolved => Resolution is not null;

    public ConflictHunk(string ours, string theirs, string? @base)
    {
        Ours = ours;
        Theirs = theirs;
        Base = @base;
    }

    partial void OnResolutionChanged(string? value) => OnPropertyChanged(nameof(IsResolved));

    [RelayCommand] private void AcceptCurrent()  => Resolution = Ours;
    [RelayCommand] private void AcceptIncoming() => Resolution = Theirs;
    [RelayCommand] private void AcceptBoth()     => Resolution = Ours + Theirs;
    [RelayCommand] private void EditManually()   => Resolution ??= Ours;
}

public sealed class ConflictFile
{
    public string Path { get; }
    public IReadOnlyList<ConflictHunk> Hunks { get; }

    public ConflictFile(string path, IReadOnlyList<ConflictHunk> hunks)
    {
        Path = path;
        Hunks = hunks;
    }

    public bool AllHunksResolved => Hunks.Count > 0 && Hunks.All(h => h.IsResolved);

    /// <summary>The merged file content: concatenation of each hunk's resolution
    /// (single whole-file hunk today; concatenation keeps it correct for multi-hunk later).</summary>
    public string ComposeResolvedContent() => string.Concat(Hunks.Select(h => h.Resolution));
}
```

- [ ] **Step 2: Build the Ui project to verify compilation.**

Run: `dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release`
Expected: Build succeeded.

- [ ] **Step 3: Commit**

```bash
git add src/ClaudeDo.Ui/ViewModels/Conflicts/ConflictModels.cs
git commit -m "feat(ui): add inline conflict model (file/hunk with resolution)"
```

---

## Task 5: ConflictResolverViewModel

**Files:**
- Create: `src/ClaudeDo.Ui/ViewModels/Conflicts/ConflictResolverViewModel.cs`
- Test: `tests/ClaudeDo.Ui.Tests/ViewModels/ConflictResolverViewModelTests.cs`

- [ ] **Step 1: Write failing tests.** Subclass the existing `StubWorkerClient` (its conflict methods are `virtual`).

```csharp
using System.Collections.Generic;
using System.Threading.Tasks;
using ClaudeDo.Ui.Services;
using ClaudeDo.Ui.ViewModels.Conflicts;
using Xunit;

namespace ClaudeDo.Ui.Tests.ViewModels;

public class ConflictResolverViewModelTests
{
    private sealed class FakeWorker : StubWorkerClient
    {
        public string? WrittenPath;
        public string? WrittenContent;
        public bool Continued;
        public bool Aborted;
        public string ContinueStatus = "merged";

        public override Task<MergeResultDto> StartConflictMergeAsync(string taskId, string targetBranch)
            => Task.FromResult(new MergeResultDto("conflict", new[] { "README.md" }, null));

        public override Task<MergeConflictsDto> GetMergeConflictsAsync(string taskId)
            => Task.FromResult(new MergeConflictsDto(taskId, new[]
            {
                new ConflictFileDto("README.md", new[] { new ConflictHunkDto("ours\n", "theirs\n", "base\n") })
            }));

        public override Task WriteConflictResolutionAsync(string taskId, string path, string resolvedContent)
        {
            WrittenPath = path; WrittenContent = resolvedContent; return Task.CompletedTask;
        }

        public override Task<MergeResultDto> ContinueMergeAsync(string taskId)
        {
            Continued = true;
            return Task.FromResult(new MergeResultDto(ContinueStatus, System.Array.Empty<string>(), null));
        }

        public override Task AbortMergeAsync(string taskId) { Aborted = true; return Task.CompletedTask; }
    }

    [Fact]
    public async Task OpenAsync_LoadsConflicts_AndBlocksContinueUntilResolved()
    {
        var vm = new ConflictResolverViewModel(new FakeWorker(), "task-1");
        var hasConflicts = await vm.OpenAsync("main");

        Assert.True(hasConflicts);
        var file = Assert.Single(vm.Files);
        Assert.Equal("README.md", file.Path);
        Assert.False(vm.CanContinue);                 // nothing resolved yet

        file.Hunks[0].AcceptIncomingCommand.Execute(null);
        Assert.True(vm.CanContinue);                   // every hunk resolved
    }

    [Fact]
    public async Task Continue_WritesComposedResolution_AndClosesOnMerged()
    {
        var worker = new FakeWorker();
        var vm = new ConflictResolverViewModel(worker, "task-1");
        var closed = false;
        vm.CloseRequested = () => closed = true;

        await vm.OpenAsync("main");
        vm.Files[0].Hunks[0].AcceptCurrentCommand.Execute(null);   // resolution = "ours\n"
        await vm.ContinueCommand.ExecuteAsync(null);

        Assert.Equal("README.md", worker.WrittenPath);
        Assert.Equal("ours\n", worker.WrittenContent);
        Assert.True(worker.Continued);
        Assert.True(closed);
    }

    [Fact]
    public async Task Continue_StaysOpenAndReportsError_WhenStillConflicted()
    {
        var worker = new FakeWorker { ContinueStatus = "conflict" };
        var vm = new ConflictResolverViewModel(worker, "task-1");
        var closed = false;
        vm.CloseRequested = () => closed = true;

        await vm.OpenAsync("main");
        vm.Files[0].Hunks[0].AcceptBothCommand.Execute(null);
        await vm.ContinueCommand.ExecuteAsync(null);

        Assert.False(closed);
        Assert.NotNull(vm.Error);
    }

    [Fact]
    public async Task Abort_CallsWorkerAndCloses()
    {
        var worker = new FakeWorker();
        var vm = new ConflictResolverViewModel(worker, "task-1");
        var closed = false;
        vm.CloseRequested = () => closed = true;

        await vm.AbortCommand.ExecuteAsync(null);

        Assert.True(worker.Aborted);
        Assert.True(closed);
    }
}
```

- [ ] **Step 2: Run tests to verify they fail** (VM not defined).

Run: `dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release --filter "ConflictResolverViewModelTests"`
Expected: compile error / FAIL.

- [ ] **Step 3: Implement the ViewModel.**

```csharp
using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using ClaudeDo.Ui.Services;

namespace ClaudeDo.Ui.ViewModels.Conflicts;

public sealed partial class ConflictResolverViewModel : ObservableObject
{
    private readonly IWorkerClient _worker;
    private readonly string _taskId;

    public ObservableCollection<ConflictFile> Files { get; } = new();

    [ObservableProperty] private bool _isBusy;
    [ObservableProperty] private string? _error;
    [ObservableProperty] private bool _canContinue;

    public string TaskId => _taskId;
    public Action? CloseRequested { get; set; }

    public ConflictResolverViewModel(IWorkerClient worker, string taskId)
    {
        _worker = worker;
        _taskId = taskId;
    }

    /// <summary>Starts the conflict merge and loads ours/theirs/base per file.
    /// Returns true when there are conflicts to resolve (caller should show the dialog).</summary>
    public async Task<bool> OpenAsync(string targetBranch)
    {
        IsBusy = true;
        Error = null;
        try
        {
            var start = await _worker.StartConflictMergeAsync(_taskId, targetBranch);
            if (!string.Equals(start.Status, "conflict", StringComparison.Ordinal))
            {
                if (string.Equals(start.Status, "blocked", StringComparison.Ordinal))
                    Error = start.ErrorMessage;
                return false;
            }

            var conflicts = await _worker.GetMergeConflictsAsync(_taskId);
            Files.Clear();
            foreach (var f in conflicts.Files)
            {
                var hunks = f.Hunks.Select(h =>
                {
                    var hk = new ConflictHunk(h.Ours, h.Theirs, h.Base);
                    hk.PropertyChanged += OnHunkChanged;
                    return hk;
                }).ToList();
                Files.Add(new ConflictFile(f.Path, hunks));
            }
            RecomputeCanContinue();
            return Files.Count > 0;
        }
        catch (Exception ex)
        {
            Error = ex.Message;
            return false;
        }
        finally { IsBusy = false; }
    }

    private void OnHunkChanged(object? sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName is nameof(ConflictHunk.IsResolved) or nameof(ConflictHunk.Resolution))
            RecomputeCanContinue();
    }

    private void RecomputeCanContinue()
        => CanContinue = Files.Count > 0 && Files.All(f => f.AllHunksResolved);

    [RelayCommand]
    private async Task ContinueAsync()
    {
        if (!CanContinue) return;
        IsBusy = true;
        Error = null;
        try
        {
            foreach (var file in Files)
                await _worker.WriteConflictResolutionAsync(_taskId, file.Path, file.ComposeResolvedContent());

            var result = await _worker.ContinueMergeAsync(_taskId);
            if (string.Equals(result.Status, "merged", StringComparison.Ordinal))
                CloseRequested?.Invoke();
            else
                Error = result.ErrorMessage ?? "Conflicts not fully resolved — review and retry.";
        }
        catch (Exception ex)
        {
            Error = ex.Message;
        }
        finally { IsBusy = false; }
    }

    [RelayCommand]
    private async Task AbortAsync()
    {
        IsBusy = true;
        try { await _worker.AbortMergeAsync(_taskId); }
        catch (Exception ex) { Error = ex.Message; }
        finally
        {
            IsBusy = false;
            CloseRequested?.Invoke();
        }
    }
}
```

- [ ] **Step 4: Run tests to verify they pass.**

Run: `dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release --filter "ConflictResolverViewModelTests"`
Expected: PASS (4 tests).

- [ ] **Step 5: Commit**

```bash
git add src/ClaudeDo.Ui/ViewModels/Conflicts/ConflictResolverViewModel.cs tests/ClaudeDo.Ui.Tests/ViewModels/ConflictResolverViewModelTests.cs
git commit -m "feat(ui): add inline conflict resolver view-model"
```

---

## Task 6: ConflictResolverView + localization

**Files:**
- Create: `src/ClaudeDo.Ui/Views/Conflicts/ConflictResolverView.axaml`
- Create: `src/ClaudeDo.Ui/Views/Conflicts/ConflictResolverView.axaml.cs`
- Modify: `src/ClaudeDo.Localization/locales/en.json`
- Modify: `src/ClaudeDo.Localization/locales/de.json`

- [ ] **Step 1: Add localization keys** to `en.json` as a new top-level section (sibling of `"planning"`):

```json
  "conflictResolver": {
    "windowTitle": "Resolve merge conflicts",
    "modalTitle": "RESOLVE CONFLICTS",
    "loading": "Loading conflicts…",
    "current": "Current (ours)",
    "incoming": "Incoming (theirs)",
    "mergedResult": "Merged result",
    "acceptCurrent": "Accept Current",
    "acceptIncoming": "Accept Incoming",
    "acceptBoth": "Accept Both",
    "editManually": "Edit manually",
    "continue": "Resolve & continue",
    "abort": "Abort merge"
  },
```

- [ ] **Step 2: Add the SAME keys to `de.json`** (German values, identical key set — parity enforced by Localization.Tests):

```json
  "conflictResolver": {
    "windowTitle": "Merge-Konflikte lösen",
    "modalTitle": "KONFLIKTE LÖSEN",
    "loading": "Konflikte werden geladen…",
    "current": "Aktuell (unsere)",
    "incoming": "Eingehend (ihre)",
    "mergedResult": "Zusammengeführtes Ergebnis",
    "acceptCurrent": "Aktuelle übernehmen",
    "acceptIncoming": "Eingehende übernehmen",
    "acceptBoth": "Beide übernehmen",
    "editManually": "Manuell bearbeiten",
    "continue": "Lösen & fortfahren",
    "abort": "Merge abbrechen"
  },
```

- [ ] **Step 3: Create the View** (`ConflictResolverView.axaml`). A `Window` using `ModalShell`, mirroring `ConflictResolutionView.axaml`. Two stacked read-only boxes (ours/theirs), a button row, and a two-way merged-result box per hunk.

```xml
<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:vm="using:ClaudeDo.Ui.ViewModels.Conflicts"
        xmlns:ctl="using:ClaudeDo.Ui.Views.Controls"
        xmlns:loc="using:ClaudeDo.Ui.Localization"
        x:DataType="vm:ConflictResolverViewModel"
        x:Class="ClaudeDo.Ui.Views.Conflicts.ConflictResolverView"
        Title="{loc:Tr conflictResolver.windowTitle}"
        Width="760" Height="640" MinWidth="560" MinHeight="420"
        CanResize="True"
        WindowDecorations="BorderOnly"
        ExtendClientAreaToDecorationsHint="True"
        ExtendClientAreaTitleBarHeightHint="-1"
        WindowStartupLocation="CenterOwner"
        Background="{DynamicResource SurfaceBrush}">

  <Window.KeyBindings>
    <KeyBinding Gesture="Escape" Command="{Binding AbortCommand}"/>
  </Window.KeyBindings>

  <ctl:ModalShell Title="{loc:Tr conflictResolver.modalTitle}" CloseCommand="{Binding AbortCommand}">
    <ctl:ModalShell.Footer>
      <StackPanel Orientation="Horizontal" Spacing="8"
                  HorizontalAlignment="Right" VerticalAlignment="Center">
        <Button Classes="btn" Content="{loc:Tr conflictResolver.continue}"
                Command="{Binding ContinueCommand}" IsEnabled="{Binding CanContinue}"/>
        <Button Classes="btn" Content="{loc:Tr conflictResolver.abort}" Command="{Binding AbortCommand}"/>
      </StackPanel>
    </ctl:ModalShell.Footer>

    <Grid RowDefinitions="Auto,*" Margin="16,12">
      <TextBlock Grid.Row="0" Classes="meta" Margin="0,0,0,8"
                 Text="{loc:Tr conflictResolver.loading}"
                 IsVisible="{Binding IsBusy}"/>
      <TextBlock Grid.Row="0" Classes="meta" Foreground="{DynamicResource BloodBrush}"
                 Text="{Binding Error}" TextWrapping="Wrap"
                 IsVisible="{Binding Error, Converter={x:Static ObjectConverters.IsNotNull}}"/>

      <ScrollViewer Grid.Row="1">
        <ItemsControl ItemsSource="{Binding Files}">
          <ItemsControl.ItemTemplate>
            <DataTemplate x:DataType="vm:ConflictFile">
              <StackPanel Spacing="8" Margin="0,0,0,16">
                <TextBlock Classes="path-mono heading" Text="{Binding Path}"/>
                <ItemsControl ItemsSource="{Binding Hunks}">
                  <ItemsControl.ItemTemplate>
                    <DataTemplate x:DataType="vm:ConflictHunk">
                      <Border BorderBrush="{DynamicResource BorderBrush}" BorderThickness="1"
                              CornerRadius="6" Padding="10" Margin="0,0,0,8">
                        <StackPanel Spacing="6">
                          <TextBlock Classes="meta" Text="{loc:Tr conflictResolver.current}"/>
                          <TextBox Text="{Binding Ours, Mode=OneWay}" IsReadOnly="True"
                                   TextWrapping="NoWrap" AcceptsReturn="True" MaxHeight="120"
                                   FontFamily="{DynamicResource MonoFont}"/>
                          <TextBlock Classes="meta" Text="{loc:Tr conflictResolver.incoming}"/>
                          <TextBox Text="{Binding Theirs, Mode=OneWay}" IsReadOnly="True"
                                   TextWrapping="NoWrap" AcceptsReturn="True" MaxHeight="120"
                                   FontFamily="{DynamicResource MonoFont}"/>
                          <StackPanel Orientation="Horizontal" Spacing="6">
                            <Button Classes="btn" Content="{loc:Tr conflictResolver.acceptCurrent}"
                                    Command="{Binding AcceptCurrentCommand}"/>
                            <Button Classes="btn" Content="{loc:Tr conflictResolver.acceptIncoming}"
                                    Command="{Binding AcceptIncomingCommand}"/>
                            <Button Classes="btn" Content="{loc:Tr conflictResolver.acceptBoth}"
                                    Command="{Binding AcceptBothCommand}"/>
                            <Button Classes="btn" Content="{loc:Tr conflictResolver.editManually}"
                                    Command="{Binding EditManuallyCommand}"/>
                          </StackPanel>
                          <TextBlock Classes="meta" Text="{loc:Tr conflictResolver.mergedResult}"/>
                          <TextBox Text="{Binding Resolution, Mode=TwoWay}"
                                   TextWrapping="NoWrap" AcceptsReturn="True" MinHeight="80" MaxHeight="200"
                                   FontFamily="{DynamicResource MonoFont}"/>
                        </StackPanel>
                      </Border>
                    </DataTemplate>
                  </ItemsControl.ItemTemplate>
                </ItemsControl>
              </StackPanel>
            </DataTemplate>
          </ItemsControl.ItemTemplate>
        </ItemsControl>
      </ScrollViewer>
    </Grid>
  </ctl:ModalShell>
</Window>
```
**Note for the implementer:** if `MonoFont` / `path-mono` / `heading` / `meta` / `btn` resource keys or style classes don't resolve at build, drop the `FontFamily` attribute and unknown `Classes` (keep `btn`) — match whatever the existing `ConflictResolutionView.axaml` and app styles actually expose. Verify against `src/ClaudeDo.Ui/Views/Planning/ConflictResolutionView.axaml` and the app's style resources before finalizing.

- [ ] **Step 4: Create the code-behind** (`ConflictResolverView.axaml.cs`):

```csharp
using Avalonia.Controls;
using ClaudeDo.Ui.ViewModels.Conflicts;

namespace ClaudeDo.Ui.Views.Conflicts;

public partial class ConflictResolverView : Window
{
    public ConflictResolverView()
    {
        InitializeComponent();
    }

    protected override void OnDataContextChanged(System.EventArgs e)
    {
        base.OnDataContextChanged(e);
        if (DataContext is ConflictResolverViewModel vm)
            vm.CloseRequested = Close;
    }
}
```

- [ ] **Step 5: Build the App + run Localization tests.**

Run: `dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release && dotnet test tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj -c Release`
Expected: Build succeeded; localization parity tests PASS.

- [ ] **Step 6: Commit**

```bash
git add src/ClaudeDo.Ui/Views/Conflicts/ConflictResolverView.axaml src/ClaudeDo.Ui/Views/Conflicts/ConflictResolverView.axaml.cs src/ClaudeDo.Localization/locales/en.json src/ClaudeDo.Localization/locales/de.json
git commit -m "feat(ui): add inline conflict resolver view and localization"
```

---

## Task 7: Wire factory + dialog seam for the integrator

**Files:**
- Modify: `src/ClaudeDo.App/Program.cs`
- Modify: `src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs`
- Modify: `src/ClaudeDo.Ui/Views/MainWindow.axaml.cs`

These are additive seams only. The integrator connects Layer A/B's `RequestConflictResolution(taskId, target)` callback to `IslandsShellViewModel.RequestConflictResolutionAsync`.

- [ ] **Step 1: Register the factory in `Program.cs`** (in the ViewModels region, near the other `Func<>` factories). Only the `Func<>` factory is needed — the VM is never resolved directly:

```csharp
sc.AddSingleton<Func<string, ClaudeDo.Ui.ViewModels.Conflicts.ConflictResolverViewModel>>(sp =>
    taskId => new ClaudeDo.Ui.ViewModels.Conflicts.ConflictResolverViewModel(
        sp.GetRequiredService<WorkerClient>(), taskId));
```
Then, after `IslandsShellViewModel` is registered, set the factory on it once resolved. Replace the existing `sc.AddSingleton<IslandsShellViewModel>();` registration with a factory that injects the conflict-resolver factory:

```csharp
sc.AddSingleton<IslandsShellViewModel>(sp =>
{
    var shell = ActivatorUtilities.CreateInstance<IslandsShellViewModel>(sp);
    shell.ConflictResolverFactory =
        sp.GetRequiredService<Func<string, ClaudeDo.Ui.ViewModels.Conflicts.ConflictResolverViewModel>>();
    return shell;
});
```
(`ActivatorUtilities.CreateInstance` resolves the existing big constructor + its `Func<>` deps exactly as the default registration did.)

- [ ] **Step 2: Add the additive seam to `IslandsShellViewModel`** (near the other `Show*` delegate properties):

```csharp
// Layer C seam: composition root sets the factory; MainWindow sets the dialog opener.
// The integrator connects Layer A/B's RequestConflictResolution(taskId, target) to this method.
public Func<string, ClaudeDo.Ui.ViewModels.Conflicts.ConflictResolverViewModel>? ConflictResolverFactory { get; set; }
public Func<ClaudeDo.Ui.ViewModels.Conflicts.ConflictResolverViewModel, Task>? ShowConflictResolver { get; set; }

public async Task RequestConflictResolutionAsync(string taskId, string targetBranch)
{
    if (ConflictResolverFactory is null || ShowConflictResolver is null) return;
    var vm = ConflictResolverFactory(taskId);
    var hasConflicts = await vm.OpenAsync(targetBranch);
    if (hasConflicts)
        await ShowConflictResolver(vm);
}
```
(Add `using ClaudeDo.Ui.ViewModels.Conflicts;` or use fully-qualified names as above.)

- [ ] **Step 3: Wire the dialog opener in `MainWindow.axaml.cs`** inside `OnDataContextChanged`, alongside the other `vm.Show*` assignments:

```csharp
vm.ShowConflictResolver = async (resolverVm) =>
{
    var dlg = new ClaudeDo.Ui.Views.Conflicts.ConflictResolverView { DataContext = resolverVm };
    await dlg.ShowDialog(this);
};
```

- [ ] **Step 4: Build the App to verify compilation.**

Run: `dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release`
Expected: Build succeeded.

- [ ] **Step 5: Commit**

```bash
git add src/ClaudeDo.App/Program.cs src/ClaudeDo.Ui/ViewModels/IslandsShellViewModel.cs src/ClaudeDo.Ui/Views/MainWindow.axaml.cs
git commit -m "feat(ui): expose conflict-resolver factory and dialog seam for integrator"
```

---

## Task 8: Full verification

- [ ] **Step 1: Build both head projects.**

Run:
```bash
dotnet build src/ClaudeDo.Worker/ClaudeDo.Worker.csproj -c Release
dotnet build src/ClaudeDo.App/ClaudeDo.App.csproj -c Release
```
Expected: both Build succeeded, 0 errors/warnings.

- [ ] **Step 2: Run the full relevant test suites.**

Run:
```bash
dotnet test tests/ClaudeDo.Worker.Tests/ClaudeDo.Worker.Tests.csproj -c Release
dotnet test tests/ClaudeDo.Ui.Tests/ClaudeDo.Ui.Tests.csproj -c Release
dotnet test tests/ClaudeDo.Localization.Tests/ClaudeDo.Localization.Tests.csproj -c Release
```
Expected: all PASS.

- [ ] **Step 3: Flag visual verification.** The resolver dialog cannot be opened end-to-end until the integrator wires Layer A/B's `RequestConflictResolution(taskId, target)` → `IslandsShellViewModel.RequestConflictResolutionAsync`. Report this as a visual-verification gap for the user/integrator: open a real conflicting merge, confirm hunks render, Accept buttons populate the merged box, Resolve & continue closes on success, Abort restores the tree.

- [ ] **Step 4: Leave the branch for the orchestrator.** Do NOT push, do NOT merge to main.