Merge claudedo/ccd650a8d2b04a7092e81ed07c16dbe0

src/ClaudeDo.Worker/External/HandoffMcpTools.cs

@@ -0,0 +1,44 @@
+using System.ComponentModel;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Hub;
+using ModelContextProtocol.Server;
+
+namespace ClaudeDo.Worker.External;
+
+public sealed record HandoffListHandlerResult(bool Requested, string TaskId, int SurvivingCount);
+
+[McpServerToolType]
+public sealed class HandoffMcpTools
+{
+    private readonly TaskRepository _tasks;
+    private readonly HubBroadcaster _broadcaster;
+
+    public HandoffMcpTools(TaskRepository tasks, HubBroadcaster broadcaster)
+    {
+        _tasks = tasks;
+        _broadcaster = broadcaster;
+    }
+
+    [McpServerTool, Description(
+        "End of Phase 2 for the list handler (\"Let Claude handle it\"): hand this run off to a fresh " +
+        "ConPTY session that carries out Phases 3-5, without dragging along this session's dedupe/rewrite " +
+        "context. taskId is this session's own handler task id; survivingTaskIds are the tasks that made " +
+        "it past dedupe, in the order to run them. Reuses the SAME handler task -- no new task is created, " +
+        "and HandlerBaseCommit is untouched. The current tile stays open; end your own turn after calling this.")]
+    public async Task<HandoffListHandlerResult> HandoffListHandler(
+        string taskId, IReadOnlyList<string> survivingTaskIds, CancellationToken cancellationToken)
+    {
+        if (survivingTaskIds.Count == 0)
+            throw new InvalidOperationException("survivingTaskIds must contain at least one task id.");
+
+        _ = await _tasks.GetByIdAsync(taskId, cancellationToken)
+            ?? throw new InvalidOperationException($"Task {taskId} not found.");
+
+        foreach (var id in survivingTaskIds)
+            _ = await _tasks.GetByIdAsync(id, cancellationToken)
+                ?? throw new InvalidOperationException($"Task {id} not found.");
+
+        await _broadcaster.HandoffRequested(taskId, survivingTaskIds);
+        return new HandoffListHandlerResult(true, taskId, survivingTaskIds.Count);
+    }
+}

src/ClaudeDo.Worker/Hub/HubBroadcaster.cs

@@ -32,6 +32,11 @@ public sealed class HubBroadcaster : IPrimeBroadcaster, IRefineBroadcaster
     public Task TaskQuestionResolved(string taskId, string questionId) =>
         _hub.Clients.All.SendAsync("TaskQuestionResolved", taskId, questionId);
 
+    // A running list-handler session called handoff_list_handler at the end of Phase 2 -- the UI
+    // opens a second ConPTY tile for the same handler task id to carry out Phases 3-5.
+    public Task HandoffRequested(string taskId, IReadOnlyList<string> survivingTaskIds) =>
+        _hub.Clients.All.SendAsync("HandoffRequested", taskId, survivingTaskIds);
+
     public Task ListUpdated(string listId) =>
         _hub.Clients.All.SendAsync("ListUpdated", listId);
 

src/ClaudeDo.Worker/Hub/WorkerHub.cs

@@ -751,6 +751,16 @@ public sealed class WorkerHub : Microsoft.AspNetCore.SignalR.Hub
         return taskId;
     });
 
+    // Builds the launch spec for the fresh ConPTY session a merge-helper run hands off to once
+    // Phase 2 (enhance) is done -- reuses the SAME handler task id (no new task created), only a
+    // new session dir + handoff kickoff naming the surviving tasks.
+    public Task<LaunchSpec> GetMergeHelperHandoffLaunchSpec(string taskId, string[] survivingTaskIds) => HubGuard(() =>
+    {
+        if (_interactiveLaunchSpec is null)
+            throw new InvalidOperationException("Interactive launch spec service is not configured.");
+        return _interactiveLaunchSpec.BuildForMergeHelperHandoffAsync(taskId, survivingTaskIds, Context.ConnectionAborted);
+    });
+
     // Starts a planning session (worktree + prompt files + token, task -> Planning) and returns
     // the launch spec for an embedded ConPTY planning terminal -- the ConPTY replacement for
     // StartPlanningSessionAsync's external wt window. On any spec-build failure the just-started

src/ClaudeDo.Worker/Program.cs

@@ -302,6 +302,7 @@ if (cfg.ExternalMcpPort > 0)
     externalBuilder.Services.AddScoped<RunHistoryMcpTools>();
     externalBuilder.Services.AddScoped<AgentMcpTools>();
     externalBuilder.Services.AddScoped<LifecycleMcpTools>();
+    externalBuilder.Services.AddScoped<HandoffMcpTools>();
     externalBuilder.Services.AddScoped<AppSettingsMcpTools>();
     externalBuilder.Services.AddScoped<TaskWaitMcpTools>();
     externalBuilder.Services.AddScoped<QueueStateMcpTools>();
@@ -318,6 +319,7 @@ if (cfg.ExternalMcpPort > 0)
         .WithTools<RunHistoryMcpTools>()
         .WithTools<AgentMcpTools>()
         .WithTools<LifecycleMcpTools>()
+        .WithTools<HandoffMcpTools>()
         .WithTools<AppSettingsMcpTools>()
         .WithTools<TaskWaitMcpTools>()
         .WithTools<QueueStateMcpTools>()

src/ClaudeDo.Worker/Runner/InteractiveLaunchSpecService.cs

@@ -253,6 +253,79 @@ public sealed class InteractiveLaunchSpecService : IInteractiveLaunchSpecService
         return new LaunchSpec(repoDir, resolvedClaude, args, env);
     }
 
+    // Builds the LaunchSpec for the fresh session a merge-helper run hands off to once Phase 2
+    // (enhance) is done -- SAME handler task id as the run that called handoff_list_handler, so
+    // HandlerBaseCommit/HandlerHeadCommit and the review range stay untouched; this never creates
+    // a task. Reuses the merge-helper system prompt unchanged (the phase 3-5 instructions already
+    // live there) and only writes a fresh handoff kickoff file, in a NEW session dir -- the old
+    // ConPTY tile keeps running against its own session-dir files untouched.
+    public async Task<LaunchSpec> BuildForMergeHelperHandoffAsync(
+        string taskId, IReadOnlyList<string> survivingTaskIds, CancellationToken ct)
+    {
+        if (survivingTaskIds.Count == 0)
+            throw new InvalidOperationException("No surviving tasks to hand off.");
+
+        await using var ctx = await _dbFactory.CreateDbContextAsync(ct);
+        var taskRepo = new TaskRepository(ctx);
+        var listRepo = new ListRepository(ctx);
+
+        var handlerTask = await taskRepo.GetByIdAsync(taskId, ct)
+            ?? throw new KeyNotFoundException($"Task not found: {taskId}");
+        var list = await listRepo.GetByIdAsync(handlerTask.ListId, ct)
+            ?? throw new KeyNotFoundException($"List not found: {handlerTask.ListId}");
+
+        var repoDir = list.WorkingDir;
+        if (string.IsNullOrEmpty(repoDir) || !Directory.Exists(repoDir))
+            throw new InvalidOperationException($"list '{list.Name}' has no existing working directory");
+
+        var briefLines = new List<string>();
+        foreach (var id in survivingTaskIds)
+        {
+            var task = await taskRepo.GetByIdAsync(id, ct)
+                ?? throw new KeyNotFoundException($"Task not found: {id}");
+            briefLines.Add($"- [{task.Status}] {task.Title} (id: {task.Id})");
+        }
+
+        var sessionDir = Path.Combine(Paths.AppDataRoot(), "merge-helper-sessions", Guid.NewGuid().ToString());
+        Directory.CreateDirectory(sessionDir);
+
+        var systemPromptPath = Path.Combine(sessionDir, "system-prompt.md");
+        await File.WriteAllTextAsync(systemPromptPath, PromptFiles.ReadOrDefault(PromptKind.MergeHelper), ct);
+
+        var briefPath = Path.Combine(sessionDir, "handoff.md");
+        await File.WriteAllTextAsync(briefPath, PromptFiles.Render(PromptKind.MergeHelperHandoff,
+            new Dictionary<string, string>
+            {
+                ["scope"] = $"List: {list.Name}",
+                ["repo"] = repoDir,
+                ["tasks"] = string.Join("\n", briefLines),
+            }), ct);
+
+        var resolvedClaude = WindowsTerminalLauncher.Resolve(_claudePath)
+            ?? throw new InvalidOperationException($"claude executable not found: {_claudePath}");
+
+        var listConfig = await listRepo.GetConfigAsync(handlerTask.ListId, ct);
+        var settings = await new AppSettingsRepository(ctx).GetAsync(ct);
+
+        var args = new List<string>
+        {
+            "--effort", EffortFor(settings, listConfig?.Model),
+            "--permission-mode", "auto",
+            "--allowedTools", MergeHelperAllowedTools,
+            "--add-dir", sessionDir, repoDir,
+            "--append-system-prompt-file", systemPromptPath,
+            $"Read the file {briefPath} first. It lists the surviving tasks and their status. " +
+            "After reading it, begin at phase 3 as your instructions describe.",
+        };
+
+        var env = new Dictionary<string, string>
+        {
+            ["MCP_TOOL_TIMEOUT"] = "200000",
+        };
+
+        return new LaunchSpec(repoDir, resolvedClaude, args, env);
+    }
+
     // Renders one task as a brief list item. A description can itself be arbitrary Markdown
     // (headings, lists, fenced code) — those must not merge into the brief's own task list, so
     // the description is placed in a fenced code block indented to the list item's continuation

src/ClaudeDo.Worker/Runner/Interfaces/IInteractiveLaunchSpecService.cs

@@ -42,4 +42,12 @@ public interface IInteractiveLaunchSpecService
     /// is empty or the list has no existing working directory.</summary>
     Task<string> CreateMergeHelperTaskAsync(
         IReadOnlyList<string> taskIds, string listId, string title, string descriptionHeader, CancellationToken ct);
+
+    /// <summary>Builds a LaunchSpec for the fresh ConPTY session a merge-helper run hands off to
+    /// once Phase 2 (enhance) is done -- reuses the SAME handler task id (no new task, HandlerBaseCommit
+    /// untouched) and the unmodified merge-helper system prompt, writing only a fresh handoff kickoff
+    /// naming the surviving tasks. Throws KeyNotFoundException if the task/list doesn't exist;
+    /// InvalidOperationException if survivingTaskIds is empty or the list has no working directory.</summary>
+    Task<LaunchSpec> BuildForMergeHelperHandoffAsync(
+        string taskId, IReadOnlyList<string> survivingTaskIds, CancellationToken ct);
 }