706 lines
23 KiB
Markdown
706 lines
23 KiB
Markdown
# Logic Bug Fixes Implementation Plan
|
||
|
||
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
|
||
|
||
**Goal:** Fix confirmed logic bugs across Worker, App/Ui, and Installer found in the 2026-04-17 three-agent review.
|
||
|
||
**Architecture:** Each bug is an isolated change to one or two files. Group by priority (Critical → High → Medium → Info). TDD where the bug is observable via xUnit integration test (Worker, Data); for UI/Installer bugs without test harness, do a focused manual repro and guard with a regression comment referencing the commit.
|
||
|
||
**Tech Stack:** .NET 8, Avalonia 12, CommunityToolkit.Mvvm, EF Core + SQLite, SignalR, xUnit (Worker tests only).
|
||
|
||
---
|
||
|
||
## File Map
|
||
|
||
**Worker:**
|
||
- Modify: `src/ClaudeDo.Worker/Hub/WorkerHub.cs` — remove premature `RunCreated` broadcast
|
||
- Modify: `src/ClaudeDo.Worker/Runner/TaskRunner.cs` — emit `RunCreated` after run row insert
|
||
- Modify: `src/ClaudeDo.Worker/Services/QueueService.cs` — add slot-collision guard on `RunNow`/`ContinueTask`
|
||
- Modify: `src/ClaudeDo.Worker/Runner/ClaudeArgsBuilder.cs` — extend quoting to cover whitespace/newline
|
||
- Test: `tests/ClaudeDo.Worker.Tests/ClaudeArgsBuilderTests.cs` — regression for newline in system prompt
|
||
- Test: `tests/ClaudeDo.Worker.Tests/QueueServiceSlotGuardTests.cs` — regression for RunNow-while-queued
|
||
|
||
**Ui:**
|
||
- Modify: `src/ClaudeDo.Ui/ViewModels/TaskListViewModel.cs` — guard nullability in `AddTask`, harden `OnTaskUpdated`
|
||
- Modify: `src/ClaudeDo.Ui/ViewModels/TaskDetailViewModel.cs` — defer `_taskId` assignment until after cancel check
|
||
- Modify: `src/ClaudeDo.Ui/ViewModels/TaskEditorViewModel.cs` — init TCS before dialog shown
|
||
|
||
**Installer:**
|
||
- Modify: `src/ClaudeDo.Installer/Steps/RegisterServiceStep.cs` — remove inline start; reject CurrentUser without password
|
||
- Modify: `src/ClaudeDo.Installer/Steps/DownloadAndExtractStep.cs` — rename-before-extract rollback
|
||
- Modify: `src/ClaudeDo.Installer/Core/UninstallRunner.cs` — add `removeAppData` parameter
|
||
- Modify: `src/ClaudeDo.Installer/Steps/WriteConfigStep.cs` — expand `~` in `UiDbPath`
|
||
- Verify: `src/ClaudeDo.Installer/App.xaml.cs` — confirm Avalonia vs WPF usings
|
||
|
||
---
|
||
|
||
## Critical
|
||
|
||
### Task 1: Worker — fix `RunCreated` broadcast ordering (W1)
|
||
|
||
Bug: `WorkerHub.RunNow` fires `RunCreated` before the run row is inserted by `RunOnceAsync`. UI can receive an event for a row that does not yet exist.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Worker/Hub/WorkerHub.cs:35-50`
|
||
- Modify: `src/ClaudeDo.Worker/Runner/TaskRunner.cs:234-256` (`RunOnceAsync`)
|
||
|
||
- [ ] **Step 1: Remove premature broadcast from WorkerHub**
|
||
|
||
In `src/ClaudeDo.Worker/Hub/WorkerHub.cs`, replace the body of `RunNow`:
|
||
|
||
```csharp
|
||
public async Task RunNow(string taskId)
|
||
{
|
||
try
|
||
{
|
||
await _queue.RunNow(taskId);
|
||
}
|
||
catch (InvalidOperationException)
|
||
{
|
||
throw new HubException("override slot busy");
|
||
}
|
||
catch (KeyNotFoundException)
|
||
{
|
||
throw new HubException("task not found");
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Emit `RunCreated` inside `RunOnceAsync` after row insert**
|
||
|
||
In `src/ClaudeDo.Worker/Runner/TaskRunner.cs`, find `RunOnceAsync`. After the `runRepo.AddAsync(run, ct);` block (~line 256), add:
|
||
|
||
```csharp
|
||
await _broadcaster.RunCreated(taskId, runNumber, isRetry);
|
||
```
|
||
|
||
Then remove the existing `await _broadcaster.RunCreated(task.Id, 2, true);` on line 128 (inside the auto-retry block in `RunAsync`) and the `await _broadcaster.RunCreated(taskId, nextRunNumber, false);` on line 219 (in `ContinueAsync`), since `RunOnceAsync` now broadcasts unconditionally.
|
||
|
||
- [ ] **Step 3: Build and run Worker tests**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx && dotnet test tests/ClaudeDo.Worker.Tests`
|
||
Expected: all existing tests pass.
|
||
|
||
- [ ] **Step 4: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Worker/Hub/WorkerHub.cs src/ClaudeDo.Worker/Runner/TaskRunner.cs
|
||
git commit -m "fix(worker): emit RunCreated after run row exists"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 2: Ui — harden `OnTaskUpdated` against async void crash (U2)
|
||
|
||
Bug: `TaskListViewModel.OnTaskUpdated` is `async void` with no try/catch. A DB error escapes to `TaskScheduler.UnobservedTaskException` and can crash the process.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Ui/ViewModels/TaskListViewModel.cs:328-332`
|
||
|
||
- [ ] **Step 1: Wrap handler body in try/catch**
|
||
|
||
Replace the existing method with:
|
||
|
||
```csharp
|
||
private async void OnTaskUpdated(string taskId)
|
||
{
|
||
if (CurrentListId is null) return;
|
||
try
|
||
{
|
||
await RefreshSingleAsync(taskId);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
System.Diagnostics.Debug.WriteLine($"[TaskListViewModel] OnTaskUpdated failed for {taskId}: {ex}");
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Build**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx`
|
||
Expected: build succeeds.
|
||
|
||
- [ ] **Step 3: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Ui/ViewModels/TaskListViewModel.cs
|
||
git commit -m "fix(ui): swallow DB errors in TaskListViewModel.OnTaskUpdated"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 3: Installer — reject CurrentUser service registration without password (I1)
|
||
|
||
Bug: `RegisterServiceStep` passes `obj=.\<user>` to `sc.exe create` with no `password=`. SCM rejects it with exit 5 / 1069 and the user gets an opaque error.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Installer/Steps/RegisterServiceStep.cs`
|
||
|
||
- [ ] **Step 1: Read the current file**
|
||
|
||
Read `src/ClaudeDo.Installer/Steps/RegisterServiceStep.cs` to confirm the exact shape of the `obj=` branch and the outer `StepResult` return.
|
||
|
||
- [ ] **Step 2: Replace CurrentUser branch with early failure**
|
||
|
||
Where the step builds `obj=".\\<username>"` for the `CurrentUser` account option, replace it with:
|
||
|
||
```csharp
|
||
if (ctx.ServiceAccount == ServiceAccountType.CurrentUser)
|
||
{
|
||
return StepResult.Fail(
|
||
"Service cannot run as Current User without a password. " +
|
||
"Select 'Local System' or extend ServicePage to capture a password.");
|
||
}
|
||
```
|
||
|
||
Keep the `LocalSystem` branch (which passes `obj= LocalSystem` with no password requirement) unchanged.
|
||
|
||
- [ ] **Step 3: Build**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx`
|
||
Expected: build succeeds.
|
||
|
||
- [ ] **Step 4: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Installer/Steps/RegisterServiceStep.cs
|
||
git commit -m "fix(installer): reject CurrentUser service account without password"
|
||
```
|
||
|
||
---
|
||
|
||
## High
|
||
|
||
### Task 4: Worker — guard slot collision on `RunNow` and `ContinueTask` (W2)
|
||
|
||
Bug: Queue slot and override slot have no guard against operating on the same `taskId`. `TaskRunner.MarkRunningAsync` can overwrite `started_at`.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Worker/Services/QueueService.cs:59-115`
|
||
- Test: `tests/ClaudeDo.Worker.Tests/QueueServiceSlotGuardTests.cs` (new)
|
||
|
||
- [ ] **Step 1: Write failing test**
|
||
|
||
Create `tests/ClaudeDo.Worker.Tests/QueueServiceSlotGuardTests.cs`:
|
||
|
||
```csharp
|
||
using ClaudeDo.Data.Models;
|
||
using ClaudeDo.Worker.Services;
|
||
using Xunit;
|
||
|
||
namespace ClaudeDo.Worker.Tests;
|
||
|
||
public class QueueServiceSlotGuardTests : WorkerTestBase
|
||
{
|
||
[Fact]
|
||
public async Task RunNow_rejects_task_already_active_in_queue_slot()
|
||
{
|
||
var queue = ServiceProvider.GetRequiredService<QueueService>();
|
||
var task = await SeedAgentTaskAsync(listId: await SeedListAsync(), title: "blocker");
|
||
|
||
// Prime queue slot by wake signal.
|
||
queue.WakeQueue();
|
||
await WaitForActiveSlotAsync("queue", task.Id);
|
||
|
||
// RunNow on the same id must throw InvalidOperationException.
|
||
await Assert.ThrowsAsync<InvalidOperationException>(() => queue.RunNow(task.Id));
|
||
}
|
||
}
|
||
```
|
||
|
||
(Helpers `WorkerTestBase`, `SeedAgentTaskAsync`, `SeedListAsync`, `WaitForActiveSlotAsync` exist in the test project — follow the pattern from existing tests.)
|
||
|
||
- [ ] **Step 2: Run test to verify it fails**
|
||
|
||
Run: `dotnet test tests/ClaudeDo.Worker.Tests --filter "FullyQualifiedName~QueueServiceSlotGuardTests"`
|
||
Expected: FAIL — currently `RunNow` succeeds and creates a duplicate slot.
|
||
|
||
- [ ] **Step 3: Add guard in `RunNow`**
|
||
|
||
In `src/ClaudeDo.Worker/Services/QueueService.cs`, inside the `lock (_lock)` block in `RunNow` (~line 69), add before the existing override check:
|
||
|
||
```csharp
|
||
if (_queueSlot?.TaskId == taskId)
|
||
throw new InvalidOperationException("task is already running in queue slot");
|
||
```
|
||
|
||
- [ ] **Step 4: Add same guard in `ContinueTask`**
|
||
|
||
In the `lock (_lock)` block in `ContinueTask` (~line 97), add:
|
||
|
||
```csharp
|
||
if (_queueSlot?.TaskId == taskId)
|
||
throw new InvalidOperationException("task is already running in queue slot");
|
||
```
|
||
|
||
- [ ] **Step 5: Run tests**
|
||
|
||
Run: `dotnet test tests/ClaudeDo.Worker.Tests`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 6: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Worker/Services/QueueService.cs tests/ClaudeDo.Worker.Tests/QueueServiceSlotGuardTests.cs
|
||
git commit -m "fix(worker): guard against same task in queue and override slot"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 5: Worker — quote CLI args with tab/newline/carriage-return (W3)
|
||
|
||
Bug: `ClaudeArgsBuilder.Escape` only quotes on space/quote. System prompts with newlines pass through unquoted and corrupt the argument list.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Worker/Runner/ClaudeArgsBuilder.cs:56-64`
|
||
- Test: `tests/ClaudeDo.Worker.Tests/ClaudeArgsBuilderTests.cs` (new or existing)
|
||
|
||
- [ ] **Step 1: Write failing test**
|
||
|
||
If `ClaudeArgsBuilderTests.cs` does not exist, create it:
|
||
|
||
```csharp
|
||
using ClaudeDo.Worker.Runner;
|
||
using Xunit;
|
||
|
||
namespace ClaudeDo.Worker.Tests;
|
||
|
||
public class ClaudeArgsBuilderTests
|
||
{
|
||
[Fact]
|
||
public void Build_quotes_system_prompt_with_newline()
|
||
{
|
||
var builder = new ClaudeArgsBuilder();
|
||
var args = builder.Build(new ClaudeRunConfig(
|
||
Model: null,
|
||
SystemPrompt: "line1\nline2",
|
||
AgentPath: null,
|
||
ResumeSessionId: null));
|
||
|
||
Assert.Contains("--append-system-prompt \"line1\\nline2\"", args);
|
||
}
|
||
|
||
[Fact]
|
||
public void Build_quotes_system_prompt_with_tab()
|
||
{
|
||
var builder = new ClaudeArgsBuilder();
|
||
var args = builder.Build(new ClaudeRunConfig(
|
||
Model: null,
|
||
SystemPrompt: "col1\tcol2",
|
||
AgentPath: null,
|
||
ResumeSessionId: null));
|
||
|
||
Assert.Contains("\"col1", args);
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Run test to verify it fails**
|
||
|
||
Run: `dotnet test tests/ClaudeDo.Worker.Tests --filter "FullyQualifiedName~ClaudeArgsBuilderTests"`
|
||
Expected: FAIL — newline is passed through unquoted.
|
||
|
||
- [ ] **Step 3: Extend `Escape` condition and escape newline/tab**
|
||
|
||
In `src/ClaudeDo.Worker/Runner/ClaudeArgsBuilder.cs`, replace `Escape`:
|
||
|
||
```csharp
|
||
private static string Escape(string value)
|
||
{
|
||
if (value.Contains(' ') || value.Contains('"') || value.Contains('\'')
|
||
|| value.Contains('\t') || value.Contains('\n') || value.Contains('\r'))
|
||
{
|
||
var escaped = value
|
||
.Replace("\\", "\\\\")
|
||
.Replace("\"", "\\\"")
|
||
.Replace("\n", "\\n")
|
||
.Replace("\r", "\\r")
|
||
.Replace("\t", "\\t");
|
||
return $"\"{escaped}\"";
|
||
}
|
||
return value;
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 4: Run tests**
|
||
|
||
Run: `dotnet test tests/ClaudeDo.Worker.Tests --filter "FullyQualifiedName~ClaudeArgsBuilderTests"`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Worker/Runner/ClaudeArgsBuilder.cs tests/ClaudeDo.Worker.Tests/ClaudeArgsBuilderTests.cs
|
||
git commit -m "fix(worker): escape newline/tab in CLI args"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 6: Installer — remove inline service start from `RegisterServiceStep` (I2)
|
||
|
||
Bug: `RegisterServiceStep` calls `sc.exe start` inline. `StartServiceStep` exists separately. If the update path ever wires both, the service is started twice.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Installer/Steps/RegisterServiceStep.cs`
|
||
- Modify: `src/ClaudeDo.Installer/App.xaml.cs` (pipeline) — ensure `StartServiceStep` is in the fresh-install pipeline
|
||
|
||
- [ ] **Step 1: Read current pipeline wiring in App.xaml.cs**
|
||
|
||
Read `src/ClaudeDo.Installer/App.xaml.cs` around line 112 to confirm the list of steps passed into `InstallerService`.
|
||
|
||
- [ ] **Step 2: Remove inline `sc.exe start` from RegisterServiceStep**
|
||
|
||
Delete the block (~lines 72-77) that runs `sc.exe start <service>` when `ctx.AutoStart == true`.
|
||
|
||
- [ ] **Step 3: Add `StartServiceStep` to the fresh-install pipeline if missing**
|
||
|
||
In `App.xaml.cs`, append `new StartServiceStep(...)` after `RegisterServiceStep` in the step list. Gate its execution internally on `ctx.AutoStart` (it already handles exit code 1056).
|
||
|
||
- [ ] **Step 4: Build**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx`
|
||
Expected: build succeeds.
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Installer/Steps/RegisterServiceStep.cs src/ClaudeDo.Installer/App.xaml.cs
|
||
git commit -m "fix(installer): move service start out of RegisterServiceStep"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 7: Installer — rollback-safe extract in `DownloadAndExtractStep` (I3)
|
||
|
||
Bug: Old `app/` and `worker/` are deleted before extraction. If extraction throws, user is left with no binaries and no recovery path.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Installer/Steps/DownloadAndExtractStep.cs:70-95`
|
||
|
||
- [ ] **Step 1: Read the current delete/extract sequence**
|
||
|
||
Read `src/ClaudeDo.Installer/Steps/DownloadAndExtractStep.cs` around lines 70-95 to identify the exact `Directory.Delete` and `ZipFile.ExtractToDirectory` calls and which `ctx` paths they reference.
|
||
|
||
- [ ] **Step 2: Replace delete-before-extract with rename-then-commit**
|
||
|
||
Wrap the delete+extract block:
|
||
|
||
```csharp
|
||
var appDir = Path.Combine(ctx.InstallRoot, "app");
|
||
var workDir = Path.Combine(ctx.InstallRoot, "worker");
|
||
var appBak = appDir + ".bak";
|
||
var workBak = workDir + ".bak";
|
||
|
||
// Stash existing dirs.
|
||
if (Directory.Exists(appBak)) Directory.Delete(appBak, recursive: true);
|
||
if (Directory.Exists(workBak)) Directory.Delete(workBak, recursive: true);
|
||
if (Directory.Exists(appDir)) Directory.Move(appDir, appBak);
|
||
if (Directory.Exists(workDir)) Directory.Move(workDir, workBak);
|
||
|
||
try
|
||
{
|
||
ZipFile.ExtractToDirectory(zipPath, ctx.InstallRoot, overwriteFiles: true);
|
||
}
|
||
catch
|
||
{
|
||
// Roll back to previous binaries.
|
||
if (Directory.Exists(appDir)) Directory.Delete(appDir, recursive: true);
|
||
if (Directory.Exists(workDir)) Directory.Delete(workDir, recursive: true);
|
||
if (Directory.Exists(appBak)) Directory.Move(appBak, appDir);
|
||
if (Directory.Exists(workBak)) Directory.Move(workBak, workDir);
|
||
throw;
|
||
}
|
||
|
||
// Success — drop stash.
|
||
if (Directory.Exists(appBak)) Directory.Delete(appBak, recursive: true);
|
||
if (Directory.Exists(workBak)) Directory.Delete(workBak, recursive: true);
|
||
```
|
||
|
||
- [ ] **Step 3: Build**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx`
|
||
Expected: build succeeds.
|
||
|
||
- [ ] **Step 4: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Installer/Steps/DownloadAndExtractStep.cs
|
||
git commit -m "fix(installer): rollback-safe extract with .bak stash"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 8: Installer — gate `~/.todo-app` deletion behind explicit consent (I4)
|
||
|
||
Bug: Uninstaller always deletes user data (db, logs, configs). Reinstalling a different version silently destroys all tasks.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Installer/Core/UninstallRunner.cs:60-80`
|
||
- Modify: `src/ClaudeDo.Installer/Views/UninstallPage.xaml(.cs)` (or equivalent) — add a checkbox
|
||
|
||
- [ ] **Step 1: Read `UninstallRunner.RunAsync` signature**
|
||
|
||
Read `src/ClaudeDo.Installer/Core/UninstallRunner.cs` around lines 1-90 to get current signature.
|
||
|
||
- [ ] **Step 2: Add `removeAppData` parameter to `RunAsync`**
|
||
|
||
Change signature to:
|
||
|
||
```csharp
|
||
public async Task<UninstallResult> RunAsync(bool removeAppData, CancellationToken ct = default)
|
||
```
|
||
|
||
Guard the deletion:
|
||
|
||
```csharp
|
||
if (removeAppData)
|
||
{
|
||
var appData = Paths.Expand("~/.todo-app");
|
||
if (Directory.Exists(appData))
|
||
Directory.Delete(appData, recursive: true);
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 3: Wire a "Remove user data" checkbox on the uninstall page**
|
||
|
||
In the uninstall view/VM, add `[ObservableProperty] private bool _removeAppData;` (default `false`) and pass it into `RunAsync(RemoveAppData)`.
|
||
|
||
- [ ] **Step 4: Build**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx`
|
||
Expected: build succeeds.
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Installer/Core/UninstallRunner.cs src/ClaudeDo.Installer/Views/UninstallPage.xaml src/ClaudeDo.Installer/Views/UninstallPage.xaml.cs
|
||
git commit -m "fix(installer): make user-data deletion on uninstall opt-in"
|
||
```
|
||
|
||
---
|
||
|
||
## Medium
|
||
|
||
### Task 9: Ui — guard `AddTask` against null `CurrentListId` after await (U1)
|
||
|
||
Bug: `AddTask` awaits `editor.LoadAgentsAsync`. Between `CanAddTask` and `listRepo.GetByIdAsync(CurrentListId)` on line 164, a concurrent `LoadAsync(null)` could null the id. Compiler warns CS8604.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Ui/ViewModels/TaskListViewModel.cs:157-170`
|
||
|
||
- [ ] **Step 1: Capture `CurrentListId` before the first `await`**
|
||
|
||
Replace the start of `AddTask`:
|
||
|
||
```csharp
|
||
[RelayCommand(CanExecute = nameof(CanAddTask))]
|
||
private async Task AddTask()
|
||
{
|
||
var listId = CurrentListId;
|
||
if (listId is null) return;
|
||
|
||
string defaultCommitType;
|
||
using (var context = _dbFactory.CreateDbContext())
|
||
{
|
||
var listRepo = new ListRepository(context);
|
||
var list = await listRepo.GetByIdAsync(listId);
|
||
defaultCommitType = list?.DefaultCommitType ?? "chore";
|
||
}
|
||
|
||
var editor = _editorFactory();
|
||
await editor.LoadAgentsAsync(_worker);
|
||
editor.InitForCreate(listId, defaultCommitType);
|
||
// …rest unchanged, but use `listId` consistently where CurrentListId was read
|
||
```
|
||
|
||
Audit the rest of the method: replace every subsequent read of `CurrentListId` with `listId`.
|
||
|
||
- [ ] **Step 2: Build**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx`
|
||
Expected: build succeeds with no CS8604 on this method.
|
||
|
||
- [ ] **Step 3: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Ui/ViewModels/TaskListViewModel.cs
|
||
git commit -m "fix(ui): capture CurrentListId before await in AddTask"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 10: Ui — defer `_taskId` assignment in `TaskDetailViewModel.LoadAsync` (U3)
|
||
|
||
Bug: `_taskId = taskId` is set at line 87, before the previous `_loadCts` is cancelled. If load is cancelled, `_taskId` has been clobbered but `HasWorktree` / `CanWorktreeAction` still reflect the previous task.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Ui/ViewModels/TaskDetailViewModel.cs:76-90`
|
||
|
||
- [ ] **Step 1: Reset stale worktree state when starting a new load**
|
||
|
||
Replace the start of `LoadAsync`:
|
||
|
||
```csharp
|
||
public async Task LoadAsync(string taskId)
|
||
{
|
||
var oldCts = _loadCts;
|
||
var cts = new CancellationTokenSource();
|
||
_loadCts = cts;
|
||
oldCts?.Cancel();
|
||
oldCts?.Dispose();
|
||
var ct = cts.Token;
|
||
|
||
_taskId = taskId;
|
||
|
||
// Clear stale worktree state so buttons don't act on the previous task.
|
||
HasWorktree = false;
|
||
WorktreeState = "";
|
||
BranchName = null;
|
||
DiffStat = null;
|
||
WorktreePath = null;
|
||
OnPropertyChanged(nameof(CanWorktreeAction));
|
||
|
||
LiveText = "";
|
||
_formatter = new StreamLineFormatter();
|
||
// …rest unchanged
|
||
```
|
||
|
||
- [ ] **Step 2: Build**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx`
|
||
Expected: build succeeds.
|
||
|
||
- [ ] **Step 3: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Ui/ViewModels/TaskDetailViewModel.cs
|
||
git commit -m "fix(ui): reset stale worktree state on TaskDetail reload"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 11: Ui — initialize TCS before dialog shown in `TaskEditorViewModel` (U4)
|
||
|
||
Bug: `ShowAndWaitAsync` creates a fresh `_tcs` only when called. If `Save` fires before `ShowAndWaitAsync` (possible if `ShowDialogAsync` is ever awaited), the result is dropped.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Ui/ViewModels/TaskEditorViewModel.cs:72-80, 260-264`
|
||
- Modify: `src/ClaudeDo.Ui/ViewModels/ListEditorViewModel.cs` (same pattern — apply identically)
|
||
|
||
- [ ] **Step 1: Reset `_tcs` at the start of `InitForCreate` and `InitForEditAsync`**
|
||
|
||
In `TaskEditorViewModel.cs`, at the top of `InitForCreate`:
|
||
|
||
```csharp
|
||
public void InitForCreate(string listId, string defaultCommitType = "chore")
|
||
{
|
||
_tcs = new TaskCompletionSource<TaskEntity?>();
|
||
_editId = null;
|
||
// …rest unchanged
|
||
```
|
||
|
||
Same first line at the top of `InitForEditAsync` and `InitForEdit`.
|
||
|
||
- [ ] **Step 2: Remove re-assignment in `ShowAndWaitAsync`**
|
||
|
||
```csharp
|
||
public Task<TaskEntity?> ShowAndWaitAsync() => _tcs.Task;
|
||
```
|
||
|
||
- [ ] **Step 3: Apply the same pattern to `ListEditorViewModel`**
|
||
|
||
Mirror the same three edits in `src/ClaudeDo.Ui/ViewModels/ListEditorViewModel.cs` (reset TCS in its `InitForCreate` / `InitForEdit`, strip the creation in `ShowAndWaitAsync`).
|
||
|
||
- [ ] **Step 4: Build**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx`
|
||
Expected: build succeeds.
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Ui/ViewModels/TaskEditorViewModel.cs src/ClaudeDo.Ui/ViewModels/ListEditorViewModel.cs
|
||
git commit -m "fix(ui): init editor TCS before dialog can complete"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 12: Installer — expand `~` in `UiDbPath` (I5)
|
||
|
||
Bug: `workerCfg.DbPath = Paths.Expand(ctx.DbPath)` but `uiCfg.DbPath = ctx.UiDbPath` is stored as-is. If UI cannot expand `~` at runtime on Windows, DB path is unresolvable.
|
||
|
||
**Files:**
|
||
- Modify: `src/ClaudeDo.Installer/Steps/WriteConfigStep.cs:31-34`
|
||
|
||
- [ ] **Step 1: Expand UiDbPath symmetrically**
|
||
|
||
Change the assignment:
|
||
|
||
```csharp
|
||
uiCfg.DbPath = Paths.Expand(ctx.UiDbPath);
|
||
```
|
||
|
||
- [ ] **Step 2: Build**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx`
|
||
Expected: build succeeds.
|
||
|
||
- [ ] **Step 3: Commit**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Installer/Steps/WriteConfigStep.cs
|
||
git commit -m "fix(installer): expand ~ in UiDbPath"
|
||
```
|
||
|
||
---
|
||
|
||
## Info
|
||
|
||
### Task 13: Installer — verify App.xaml.cs WPF-vs-Avalonia usings (I6)
|
||
|
||
Suspected bug: `src/ClaudeDo.Installer/App.xaml.cs` uses `System.Windows` (WPF). If the project is Avalonia, wrong base class is inherited.
|
||
|
||
**Files:**
|
||
- Read: `src/ClaudeDo.Installer/App.xaml.cs`
|
||
- Read: `src/ClaudeDo.Installer/ClaudeDo.Installer.csproj`
|
||
|
||
- [ ] **Step 1: Inspect the csproj for the UI framework SDK**
|
||
|
||
Read `src/ClaudeDo.Installer/ClaudeDo.Installer.csproj` and look for `<UseWPF>` or `<PackageReference Include="Avalonia" ... />`.
|
||
|
||
- [ ] **Step 2: Decision fork**
|
||
|
||
- If WPF (`<UseWPF>true</UseWPF>`): `System.Windows` is correct. Stop. No fix needed.
|
||
- If Avalonia: replace `using System.Windows;` with `using Avalonia;` and change `Application` / `StartupEventArgs` / `ExitEventArgs` to Avalonia equivalents (`Avalonia.Application`, lifetime `OnFrameworkInitializationCompleted`).
|
||
|
||
- [ ] **Step 3: Build**
|
||
|
||
Run: `dotnet build ClaudeDo.slnx`
|
||
Expected: build succeeds.
|
||
|
||
- [ ] **Step 4: Commit only if changed**
|
||
|
||
```bash
|
||
git add src/ClaudeDo.Installer/App.xaml.cs
|
||
git commit -m "fix(installer): use Avalonia application base class"
|
||
```
|
||
|
||
---
|
||
|
||
## Out of Scope
|
||
|
||
Deferred / not fixed in this plan:
|
||
- `TryScheduleTrampolineDelete` PID-less delay (I6 in review, low severity) — `ping -n 3` is flaky but rarely hit
|
||
- `AvailableAgents` being `List<T>` instead of `ObservableCollection<T>` (U5/info) — current `OnPropertyChanged` pattern works; revisit only if a bug manifests
|
||
|
||
---
|
||
|
||
## Self-Review Notes
|
||
|
||
- Every Worker bug (W1–W3) has a regression test or tested path.
|
||
- Every UI fix names the exact file:line and shows the replacement snippet.
|
||
- Installer Task 3 (I1) does not guess a password-capture UI — it deliberately returns `StepResult.Fail`, leaving the UX change for a later plan.
|
||
- Task 13 (I6) is a conditional task with a decision fork; no speculative rewrite.
|
||
- Types are consistent: `RunCreated(taskId, runNumber, isRetry)` in Task 1 matches the existing `HubBroadcaster.RunCreated` signature used at `TaskRunner.cs:128,219`.
|