feat(worker): map MCP HTTP endpoint and broadcast TaskUpdated

- Add PlanningMcpContextAccessor (Option A) to read PlanningMcpContext
  from HttpContext.Items set by PlanningTokenAuthMiddleware
- Annotate PlanningMcpService with [McpServerToolType]/[McpServerTool]
  and remove PlanningMcpContext ctx parameter from all tool methods
- Broadcast TaskUpdated(parentTaskId) via HubBroadcaster after every
  mutation in PlanningMcpService
- Refactor PlanningSessionManager to accept IDbContextFactory for
  singleton-safe use in DI; keep direct-repo ctor for tests
- Register PlanningSessionManager (singleton), IPlanningTerminalLauncher,
  PlanningMcpContextAccessor, PlanningMcpService, and MCP server in
  Program.cs; wire PlanningTokenAuthMiddleware and MapMcp("/mcp")
- Update PlanningMcpServiceTests with fake HttpContext accessor and
  no-op HubBroadcaster (avoids Moq dependency)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/ClaudeDo.Worker/Planning/PlanningMcpService.cs

@@ -1,5 +1,8 @@
+using System.ComponentModel;
 using ClaudeDo.Data.Models;
 using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Hub;
+using ModelContextProtocol.Server;
 using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
 
 namespace ClaudeDo.Worker.Planning;
@@ -7,28 +10,45 @@ namespace ClaudeDo.Worker.Planning;
 public sealed record ChildTaskDto(string TaskId, string Title, string? Description, string Status, IReadOnlyList<string> Tags);
 public sealed record CreatedChildDto(string TaskId, string Status);
 
+[McpServerToolType]
 public sealed class PlanningMcpService
 {
     private readonly TaskRepository _tasks;
+    private readonly PlanningMcpContextAccessor _contextAccessor;
+    private readonly HubBroadcaster _broadcaster;
 
-    public PlanningMcpService(TaskRepository tasks) => _tasks = tasks;
+    public PlanningMcpService(
+        TaskRepository tasks,
+        PlanningMcpContextAccessor contextAccessor,
+        HubBroadcaster broadcaster)
+    {
+        _tasks = tasks;
+        _contextAccessor = contextAccessor;
+        _broadcaster = broadcaster;
+    }
 
+    private Task BroadcastTaskUpdatedAsync(string taskId, CancellationToken ct)
+        => _broadcaster.TaskUpdated(taskId);
+
+    [McpServerTool, Description("Create a new draft child task under the current planning session's parent task.")]
     public async Task<CreatedChildDto> CreateChildTask(
-        PlanningMcpContext ctx,
         string title,
         string? description,
         IReadOnlyList<string>? tags,
         string? commitType,
         CancellationToken cancellationToken)
     {
+        var ctx = _contextAccessor.Current;
         var child = await _tasks.CreateChildAsync(ctx.ParentTaskId, title, description, tags, commitType, cancellationToken);
+        await BroadcastTaskUpdatedAsync(ctx.ParentTaskId, cancellationToken);
         return new CreatedChildDto(child.Id, "Draft");
     }
 
+    [McpServerTool, Description("List all child tasks under the current planning session's parent task.")]
     public async Task<IReadOnlyList<ChildTaskDto>> ListChildTasks(
-        PlanningMcpContext ctx,
         CancellationToken cancellationToken)
     {
+        var ctx = _contextAccessor.Current;
         var children = await _tasks.GetChildrenAsync(ctx.ParentTaskId, cancellationToken);
         var list = new List<ChildTaskDto>(children.Count);
         foreach (var c in children)
@@ -39,8 +59,8 @@ public sealed class PlanningMcpService
         return list;
     }
 
+    [McpServerTool, Description("Update an existing draft child task. Only Draft tasks may be modified.")]
     public async Task<ChildTaskDto> UpdateChildTask(
-        PlanningMcpContext ctx,
         string taskId,
         string? title,
         string? description,
@@ -48,6 +68,7 @@ public sealed class PlanningMcpService
         string? commitType,
         CancellationToken cancellationToken)
     {
+        var ctx = _contextAccessor.Current;
         var child = await _tasks.GetByIdAsync(taskId, cancellationToken)
             ?? throw new InvalidOperationException($"Task {taskId} not found.");
         if (child.ParentTaskId != ctx.ParentTaskId)
@@ -60,19 +81,18 @@ public sealed class PlanningMcpService
         if (commitType is not null) child.CommitType = commitType;
         await _tasks.UpdateAsync(child, cancellationToken);
 
-        // Tag handling omitted for v1 simplicity — tags set at create time.
-        // If Claude asks to update tags, it can delete and re-create.
-
         var reload = (await _tasks.GetByIdAsync(taskId, cancellationToken))!;
         var tagList = await _tasks.GetTagsAsync(reload.Id, cancellationToken);
+        await BroadcastTaskUpdatedAsync(ctx.ParentTaskId, cancellationToken);
         return new ChildTaskDto(reload.Id, reload.Title, reload.Description, reload.Status.ToString(), tagList.Select(t => t.Name).ToList());
     }
 
+    [McpServerTool, Description("Delete a draft child task. Only Draft tasks may be deleted.")]
     public async Task DeleteChildTask(
-        PlanningMcpContext ctx,
         string taskId,
         CancellationToken cancellationToken)
     {
+        var ctx = _contextAccessor.Current;
         var child = await _tasks.GetByIdAsync(taskId, cancellationToken)
             ?? throw new InvalidOperationException($"Task {taskId} not found.");
         if (child.ParentTaskId != ctx.ParentTaskId)
@@ -81,20 +101,28 @@ public sealed class PlanningMcpService
             throw new InvalidOperationException("Cannot delete a finalized task.");
 
         await _tasks.DeleteAsync(taskId, cancellationToken);
+        await BroadcastTaskUpdatedAsync(ctx.ParentTaskId, cancellationToken);
     }
 
+    [McpServerTool, Description("Update the title and/or description of the parent planning task itself.")]
     public async Task UpdatePlanningTask(
-        PlanningMcpContext ctx,
         string? title,
         string? description,
         CancellationToken cancellationToken)
     {
+        var ctx = _contextAccessor.Current;
         await _tasks.UpdatePlanningTaskAsync(ctx.ParentTaskId, title, description, cancellationToken);
+        await BroadcastTaskUpdatedAsync(ctx.ParentTaskId, cancellationToken);
     }
 
-    public Task<int> Finalize(
-        PlanningMcpContext ctx,
+    [McpServerTool, Description("Finalize the planning session, promoting all draft child tasks to queued or manual status.")]
+    public async Task<int> Finalize(
         bool queueAgentTasks,
         CancellationToken cancellationToken)
-        => _tasks.FinalizePlanningAsync(ctx.ParentTaskId, queueAgentTasks, cancellationToken);
+    {
+        var ctx = _contextAccessor.Current;
+        var count = await _tasks.FinalizePlanningAsync(ctx.ParentTaskId, queueAgentTasks, cancellationToken);
+        await BroadcastTaskUpdatedAsync(ctx.ParentTaskId, cancellationToken);
+        return count;
+    }
 }