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/PlanningSessionManager.cs

@@ -1,8 +1,10 @@
 using System.Security.Cryptography;
 using System.Text;
 using System.Text.Json;
+using ClaudeDo.Data;
 using ClaudeDo.Data.Models;
 using ClaudeDo.Data.Repositories;
+using Microsoft.EntityFrameworkCore;
 using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
 
 namespace ClaudeDo.Worker.Planning;
@@ -11,20 +13,40 @@ public sealed class PlanningSessionManager
 {
     private const string McpServerUrl = "http://127.0.0.1:47821/mcp";
 
-    private readonly TaskRepository _tasks;
-    private readonly ListRepository _lists;
+    private readonly IDbContextFactory<ClaudeDoDbContext>? _factory;
+    private readonly TaskRepository? _tasksOverride;
+    private readonly ListRepository? _listsOverride;
     private readonly string _rootDirectory;
 
+    // DI constructor — uses factory so this singleton can create scoped repos per call.
+    public PlanningSessionManager(IDbContextFactory<ClaudeDoDbContext> factory, string rootDirectory)
+    {
+        _factory = factory;
+        _rootDirectory = rootDirectory;
+    }
+
+    // Test constructor — accepts repos directly (single shared context, test-scoped).
     public PlanningSessionManager(TaskRepository tasks, ListRepository lists, string rootDirectory)
     {
-        _tasks = tasks;
-        _lists = lists;
+        _tasksOverride = tasks;
+        _listsOverride = lists;
         _rootDirectory = rootDirectory;
     }
 
+    private (TaskRepository tasks, ListRepository lists, ClaudeDoDbContext? ctx) CreateRepos()
+    {
+        if (_tasksOverride is not null)
+            return (_tasksOverride, _listsOverride!, null);
+        var ctx = _factory!.CreateDbContext();
+        return (new TaskRepository(ctx), new ListRepository(ctx), ctx);
+    }
+
     public async Task<PlanningSessionStartContext> StartAsync(string taskId, CancellationToken ct)
     {
-        var task = await _tasks.GetByIdAsync(taskId, ct)
+        var (tasks, lists, ctx) = CreateRepos();
+        await using var _ = ctx;
+
+        var task = await tasks.GetByIdAsync(taskId, ct)
             ?? throw new InvalidOperationException($"Task {taskId} not found.");
         if (task.ParentTaskId is not null)
             throw new InvalidOperationException("Cannot start a planning session on a child task.");
@@ -32,7 +54,7 @@ public sealed class PlanningSessionManager
             throw new InvalidOperationException($"Task is in status {task.Status}; only Manual can start planning.");
 
         var token = GenerateToken();
-        _ = await _tasks.SetPlanningStartedAsync(taskId, token, ct)
+        var started = await tasks.SetPlanningStartedAsync(taskId, token, ct)
             ?? throw new InvalidOperationException("Failed to transition task to Planning.");
 
         var sessionDir = Path.Combine(_rootDirectory, taskId);
@@ -48,23 +70,32 @@ public sealed class PlanningSessionManager
         await File.WriteAllTextAsync(files.SystemPromptPath, BuildSystemPrompt(), ct);
         await File.WriteAllTextAsync(files.InitialPromptPath, BuildInitialPrompt(task), ct);
 
-        var list = await _lists.GetByIdAsync(task.ListId, ct)
+        var list = await lists.GetByIdAsync(task.ListId, ct)
             ?? throw new InvalidOperationException($"List {task.ListId} not found.");
         return new PlanningSessionStartContext(taskId, list.WorkingDir, files);
     }
 
-    public Task<int> FinalizeAsync(string taskId, bool queueAgentTasks, CancellationToken ct)
-        => _tasks.FinalizePlanningAsync(taskId, queueAgentTasks, ct);
+    public async Task<int> FinalizeAsync(string taskId, bool queueAgentTasks, CancellationToken ct)
+    {
+        var (tasks, _, ctx) = CreateRepos();
+        await using var __ = ctx;
+        return await tasks.FinalizePlanningAsync(taskId, queueAgentTasks, ct);
+    }
 
     public async Task<int> GetPendingDraftCountAsync(string taskId, CancellationToken ct)
     {
-        var children = await _tasks.GetChildrenAsync(taskId, ct);
+        var (tasks, _, ctx) = CreateRepos();
+        await using var __ = ctx;
+        var children = await tasks.GetChildrenAsync(taskId, ct);
         return children.Count(c => c.Status == TaskStatus.Draft);
     }
 
     public async Task DiscardAsync(string taskId, CancellationToken ct)
     {
-        var ok = await _tasks.DiscardPlanningAsync(taskId, ct);
+        var (tasks, _, ctx) = CreateRepos();
+        await using var __ = ctx;
+
+        var ok = await tasks.DiscardPlanningAsync(taskId, ct);
         var sessionDir = Path.Combine(_rootDirectory, taskId);
         if (Directory.Exists(sessionDir))
         {
@@ -77,7 +108,10 @@ public sealed class PlanningSessionManager
 
     public async Task<PlanningSessionResumeContext> ResumeAsync(string taskId, CancellationToken ct)
     {
-        var task = await _tasks.GetByIdAsync(taskId, ct)
+        var (tasks, lists, ctx) = CreateRepos();
+        await using var _ = ctx;
+
+        var task = await tasks.GetByIdAsync(taskId, ct)
             ?? throw new InvalidOperationException($"Task {taskId} not found.");
         if (task.Status != TaskStatus.Planning)
             throw new InvalidOperationException($"Task is in status {task.Status}; resume requires Planning.");
@@ -89,7 +123,7 @@ public sealed class PlanningSessionManager
         if (!File.Exists(mcpConfigPath))
             throw new InvalidOperationException($"Session directory missing: {sessionDir}");
 
-        var list = await _lists.GetByIdAsync(task.ListId, ct)
+        var list = await lists.GetByIdAsync(task.ListId, ct)
             ?? throw new InvalidOperationException($"List {task.ListId} not found.");
         return new PlanningSessionResumeContext(taskId, list.WorkingDir, task.PlanningSessionId, mcpConfigPath);
     }