feat(planning): run interactive planning sessions via embedded ConPTY

Planning start/resume opened an external Windows Terminal (wt) window.
Route them through the embedded ConPTY Command Center pane instead, matching
the existing interactive-session UX (no external window).

- Extract bare planning arg builders (BuildPlanningStartArgs/ResumeArgs) from
  WindowsTerminalLauncher; the wt path still uses them (kept, not removed).
- InteractiveLaunchSpecService.BuildPlanningStart/Resume map a planning
  context into a LaunchSpec (planning args + env: MAX_THINKING_TOKENS,
  CLAUDEDO_PLANNING_TOKEN). Hub GetPlanningStart/ResumeLaunchSpec run
  StartAsync/ResumeAsync then return the spec.
- UI: OpenPlanningSession + the resume branch raise OpenPlanningConPtyRequested;
  the shell opens Mission Control and hosts a planning ConPTY pane.

Env is process-global by design (sequential human-paced sessions). wt planning
code retained. Tests added for the arg/env mapping.

src/ClaudeDo.Worker/Hub/WorkerHub.cs

@@ -673,6 +673,38 @@ public sealed class WorkerHub : Microsoft.AspNetCore.SignalR.Hub
         return _interactiveLaunchSpec.BuildForDirectoryAsync(directory, 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
+    // session is discarded (no children exist yet), mirroring StartPlanningSessionAsync.
+    public Task<LaunchSpec> GetPlanningStartLaunchSpec(string taskId) => HubGuard(async () =>
+    {
+        if (_interactiveLaunchSpec is null)
+            throw new InvalidOperationException("Interactive launch spec service is not configured.");
+        var ctx = await _planning.StartAsync(taskId, Context.ConnectionAborted);
+        try
+        {
+            var spec = _interactiveLaunchSpec.BuildPlanningStart(ctx);
+            await Clients.All.SendAsync("TaskUpdated", taskId);
+            return spec;
+        }
+        catch
+        {
+            await _planning.DiscardAsync(taskId, dequeueQueuedChildren: true, Context.ConnectionAborted);
+            throw;
+        }
+    });
+
+    // Resumes a planning session and returns the ConPTY launch spec (--permission-mode plan
+    // --resume). ConPTY replacement for ResumePlanningSessionAsync's external wt window.
+    public Task<LaunchSpec> GetPlanningResumeLaunchSpec(string taskId) => HubGuard(async () =>
+    {
+        if (_interactiveLaunchSpec is null)
+            throw new InvalidOperationException("Interactive launch spec service is not configured.");
+        var ctx = await _planning.ResumeAsync(taskId, Context.ConnectionAborted);
+        return _interactiveLaunchSpec.BuildPlanningResume(ctx);
+    });
+
     public async Task<DiscardPlanningOutcome> DiscardPlanningSessionAsync(string taskId, bool dequeueQueuedChildren = false)
     {
         var outcome = await _planning.DiscardAsync(taskId, dequeueQueuedChildren, Context.ConnectionAborted);

src/ClaudeDo.Worker/Planning/WindowsTerminalLauncher.cs

@@ -74,11 +74,7 @@ public sealed class WindowsTerminalLauncher : ITerminalLauncher
         var resolvedWt = ResolveWtOrThrow();
         var resolvedClaude = ResolveClaudeOrThrow();
 
-        var command = BuildPwshCommand(resolvedClaude, new[]
-        {
-            "--permission-mode", "plan",
-            "--resume", ctx.ClaudeSessionId,
-        });
+        var command = BuildPwshCommand(resolvedClaude, BuildPlanningResumeArgs(ctx.ClaudeSessionId));
 
         StartInWindowsTerminal(resolvedWt, ctx.WorkingDir, command, env =>
         {
@@ -117,13 +113,21 @@ public sealed class WindowsTerminalLauncher : ITerminalLauncher
     // Arg order matters: variadic flags (--allowedTools, --add-dir) come first; the
     // single-line kickoff prompt is positional, so it must follow a single-value flag
     // (--append-system-prompt-file) or a variadic flag would swallow it.
-    internal static string BuildPlanningStartCommand(string claudePath, PlanningSessionStartContext ctx)
+    internal static string BuildPlanningStartCommand(string claudePath, PlanningSessionStartContext ctx) =>
+        BuildPwshCommand(claudePath, BuildPlanningStartArgs(ctx));
+
+    // The raw claude CLI args for an interactive planning START, shared with the embedded-ConPTY
+    // planning path (InteractiveLaunchSpecService), which needs the bare Exe/Args pair rather than
+    // a pwsh-wrapped command line. Arg order matters: variadic flags (--allowedTools, --add-dir)
+    // come first; the single-line kickoff prompt is positional, so it must follow a single-value
+    // flag (--append-system-prompt-file) or a variadic flag would swallow it.
+    internal static IReadOnlyList<string> BuildPlanningStartArgs(PlanningSessionStartContext ctx)
     {
         var kickoff =
             $"Read the file {ctx.Files.InitialPromptPath} first. It contains the task you must plan. " +
             "After reading it, begin the planning session as your instructions describe.";
 
-        return BuildPwshCommand(claudePath, new[]
+        return new[]
         {
             "--model", Model,
             "--permission-mode", "plan",
@@ -131,9 +135,14 @@ public sealed class WindowsTerminalLauncher : ITerminalLauncher
             "--add-dir", ctx.Files.SessionDirectory,
             "--append-system-prompt-file", ctx.Files.SystemPromptPath,
             kickoff,
-        });
+        };
     }
 
+    // The raw claude CLI args for an interactive planning RESUME, shared with the embedded-ConPTY
+    // planning path. Pins --permission-mode plan (unlike a plain --resume pickup).
+    internal static IReadOnlyList<string> BuildPlanningResumeArgs(string claudeSessionId) =>
+        new[] { "--permission-mode", "plan", "--resume", claudeSessionId };
+
     private string ResolveWtOrThrow() =>
         Resolve(_wtPath) ?? throw new TerminalLaunchException($"Windows Terminal not found: {_wtPath}");
 

src/ClaudeDo.Worker/Runner/InteractiveLaunchSpecService.cs

@@ -107,6 +107,40 @@ public sealed class InteractiveLaunchSpecService : IInteractiveLaunchSpecService
         return new LaunchSpec(worktree.Path, resolvedClaude, args, env);
     }
 
+    public LaunchSpec BuildPlanningStart(PlanningSessionStartContext ctx)
+    {
+        var resolvedClaude = WindowsTerminalLauncher.Resolve(_claudePath)
+            ?? throw new InvalidOperationException($"claude executable not found: {_claudePath}");
+
+        // Mirrors the env the wt planning launcher set (MAX_THINKING_TOKENS + the per-session
+        // planning token); MCP_TOOL_TIMEOUT matches the other embedded-ConPTY specs. Applied to
+        // the UI process env at spawn time (see PtyTerminalSession) — process-global by design.
+        var env = new Dictionary<string, string>
+        {
+            ["MAX_THINKING_TOKENS"] = "20000",
+            ["CLAUDEDO_PLANNING_TOKEN"] = ctx.Token,
+            ["MCP_TOOL_TIMEOUT"] = "200000",
+        };
+
+        return new LaunchSpec(
+            ctx.WorkingDir, resolvedClaude, WindowsTerminalLauncher.BuildPlanningStartArgs(ctx), env);
+    }
+
+    public LaunchSpec BuildPlanningResume(PlanningSessionResumeContext ctx)
+    {
+        var resolvedClaude = WindowsTerminalLauncher.Resolve(_claudePath)
+            ?? throw new InvalidOperationException($"claude executable not found: {_claudePath}");
+
+        var env = new Dictionary<string, string>
+        {
+            ["CLAUDEDO_PLANNING_TOKEN"] = ctx.Token,
+            ["MCP_TOOL_TIMEOUT"] = "200000",
+        };
+
+        return new LaunchSpec(
+            ctx.WorkingDir, resolvedClaude, WindowsTerminalLauncher.BuildPlanningResumeArgs(ctx.ClaudeSessionId), env);
+    }
+
     public Task<LaunchSpec> BuildForDirectoryAsync(string directory, CancellationToken ct)
     {
         if (!Directory.Exists(directory))

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

@@ -1,7 +1,18 @@
+using ClaudeDo.Worker.Planning;
+
 namespace ClaudeDo.Worker.Runner;
 
 public interface IInteractiveLaunchSpecService
 {
+    /// <summary>Maps an already-prepared planning START context (worktree + prompt files + token,
+    /// produced by PlanningSessionManager.StartAsync) into a LaunchSpec for an embedded ConPTY
+    /// planning session — same planning CLI args as the wt launcher, planning env carried in Env.</summary>
+    LaunchSpec BuildPlanningStart(PlanningSessionStartContext ctx);
+
+    /// <summary>Maps a planning RESUME context (from PlanningSessionManager.ResumeAsync) into a
+    /// LaunchSpec for an embedded ConPTY planning session (--permission-mode plan --resume).</summary>
+    LaunchSpec BuildPlanningResume(PlanningSessionResumeContext ctx);
+
     /// <summary>Builds a LaunchSpec for opening an interactive session in a task's worktree.
     /// Throws KeyNotFoundException if the task doesn't exist, InvalidOperationException
     /// if it's Running/Queued. If the task has no usable worktree yet, one is created on