supipowers 1.1.0 → 1.2.2

package/src/bootstrap.ts

@@ -7,29 +7,28 @@ import { registerConfigCommand, handleConfig } from "./commands/config.js";
 import { registerStatusCommand, handleStatus } from "./commands/status.js";
 import { registerPlanCommand, getActiveVisualSessionDir, setActiveVisualSessionDir } from "./commands/plan.js";
 import { getScriptsDir } from "./visual/companion.js";
-import { registerRunCommand } from "./commands/run.js";
 import { registerReviewCommand } from "./commands/review.js";
 import { registerQaCommand } from "./commands/qa.js";
-import { registerReleaseCommand } from "./commands/release.js";
+import { registerReleaseCommand, handleRelease } from "./commands/release.js";
 import { registerUpdateCommand, handleUpdate } from "./commands/update.js";
 import { registerDoctorCommand, handleDoctor } from "./commands/doctor.js";
 import { registerMcpCommand, handleMcp, handleMcpCli, parseCliArgs } from "./commands/mcp.js";
 import { registerModelCommand, handleModel } from "./commands/model.js";
 import { executeManagerAction } from "./mcp/manager-tool.js";
 import { registerFixPrCommand } from "./commands/fix-pr.js";
+import { registerContextCommand, handleContext } from "./commands/context.js";
+import { registerCommitCommand, handleCommit } from "./commands/commit.js";
 import { loadConfig } from "./config/loader.js";
-import { migrateModelPreference } from "./config/model-config.js";
 import { registerContextModeHooks } from "./context-mode/hooks.js";
-import { registerProgressRenderer } from "./orchestrator/progress-renderer.js";
-import { activeRuns } from "./orchestrator/run-progress.js";
 import { loadMcpRegistry } from "./mcp/config.js";
 import { McpcClient } from "./mcp/mcpc.js";
 import { parseTags, computeActiveServers } from "./mcp/activation.js";
 import { initializeMcpServers, shutdownMcpServers } from "./mcp/lifecycle.js";
+import { registerPlanApprovalHook } from "./planning/approval-flow.js";
 
 // TUI-only commands — intercepted at the input level to prevent
 // message submission and "Working..." indicator
-const TUI_COMMANDS: Record<string, (platform: Platform, ctx: any) => void> = {
+const TUI_COMMANDS: Record<string, (platform: Platform, ctx: any, args?: string) => void> = {
   "supi": (platform, ctx) => handleSupi(platform, ctx),
   "supi:config": (platform, ctx) => handleConfig(platform, ctx),
   "supi:status": (platform, ctx) => handleStatus(platform, ctx),
@@ -37,6 +36,9 @@ const TUI_COMMANDS: Record<string, (platform: Platform, ctx: any) => void> = {
   "supi:doctor": (platform, ctx) => handleDoctor(platform, ctx),
   "supi:mcp": (platform, ctx) => handleMcp(platform, ctx),
   "supi:model": (platform, ctx) => handleModel(platform, ctx),
+  "supi:context": (platform, ctx) => handleContext(platform, ctx),
+  "supi:commit": (platform, ctx, args) => handleCommit(platform, ctx, args),
+  "supi:release": (platform, ctx, args) => handleRelease(platform, ctx, args),
 };
 
 let pendingTags: string[] = [];
@@ -57,7 +59,6 @@ export function bootstrap(platform: Platform): void {
   registerConfigCommand(platform);
   registerStatusCommand(platform);
   registerPlanCommand(platform);
-  registerRunCommand(platform);
   registerReviewCommand(platform);
   registerQaCommand(platform);
   registerReleaseCommand(platform);
@@ -66,30 +67,13 @@ export function bootstrap(platform: Platform): void {
   registerDoctorCommand(platform);
   registerMcpCommand(platform);
   registerModelCommand(platform);
+  registerContextCommand(platform);
+  registerCommitCommand(platform);
+
+
+  // Register plan approval flow (agent_end hook for plan approval UI)
+  registerPlanApprovalHook(platform);
 
-  // Register custom message renderers
-  registerProgressRenderer(platform);
-
-  // Wire ESC key to abort active runs via raw terminal input
-  // The handleInput on InlineProgressComponent is not called by OMP's TUI
-  // (custom message renderers are not the focused component), so we use
-  // onTerminalInput which hooks into the TUI's input listener pipeline.
-  platform.on("session_start", (_event: any, ctx: any) => {
-    if (!ctx?.ui?.onTerminalInput) return;
-    ctx.ui.onTerminalInput((data: string) => {
-      // ESC key: \x1b not followed by [ (which would be an ANSI sequence)
-      if (data !== "\x1b" && data !== "\x1b\x1b") return;
-      // Find any active run and abort it
-      for (const state of activeRuns.values()) {
-        if (!state.aborted) {
-          state.abort();
-          ctx.ui.notify("Run interrupted — press ESC again to abort the agent turn", "warning");
-          return { consume: true };
-        }
-      }
-      return;
-    });
-  });
 
   // Intercept TUI-only commands at the input level — this runs BEFORE
   // message submission, so no chat message appears and no "Working..." indicator
@@ -114,7 +98,8 @@ export function bootstrap(platform: Platform): void {
     const handler = TUI_COMMANDS[commandName];
     if (!handler) return;
 
-    handler(platform, ctx);
+    const args = spaceIndex === -1 ? undefined : text.slice(spaceIndex + 1);
+    handler(platform, ctx, args);
     return { action: "handled" };
   });
 
@@ -122,8 +107,6 @@ export function bootstrap(platform: Platform): void {
   const config = loadConfig(platform.paths, process.cwd());
   registerContextModeHooks(platform, config);
 
-  // Migrate old modelPreference to model.json
-  migrateModelPreference(platform.paths, process.cwd());
 
   // MCP per-turn activation
   platform.on("before_agent_start", async (event, ctx) => {

package/src/commands/commit.ts

@@ -0,0 +1,44 @@
+// src/commands/commit.ts — /supi:commit slash command
+//
+// TUI-only command — intercepted at the input level to prevent
+// the "Working..." spinner. It never triggers the outer LLM session.
+
+import type { Platform } from "../platform/types.js";
+import type { PlatformContext } from "../platform/types.js";
+import { analyzeAndCommit } from "../git/commit.js";
+
+/**
+ * Register the command for autocomplete and /help listing.
+ * Actual execution goes through handleCommit via the TUI dispatch.
+ */
+export function registerCommitCommand(platform: Platform): void {
+  platform.registerCommand("supi:commit", {
+    description: "AI-powered commit — analyzes changes and generates conventional commit messages",
+    async handler() {
+      // No-op: execution is handled by the TUI input interceptor.
+      // This registration exists only for autocomplete and /help.
+    },
+  });
+}
+
+/**
+ * TUI-only handler — called from the input event dispatcher in bootstrap.ts.
+ * Runs the full commit flow (git ops, agent analysis, UI approval, execution)
+ * without ever triggering the outer LLM session.
+ */
+export function handleCommit(platform: Platform, ctx: PlatformContext, args?: string): void {
+  if (!ctx.hasUI) {
+    ctx.ui.notify("Commit requires interactive mode", "warning");
+    return;
+  }
+
+  void (async () => {
+    try {
+      await analyzeAndCommit(platform, ctx, {
+        userContext: args?.trim() || undefined,
+      });
+    } catch (err) {
+      ctx.ui.notify(`Commit error: ${(err as Error).message}`, "error");
+    }
+  })();
+}

package/src/commands/config.ts

@@ -44,33 +44,6 @@ function buildSettings(platform: Platform, cwd: string): SettingDef[] {
       get: (c) => c.defaultProfile,
       set: (d, v) => updateConfig(paths, d, { defaultProfile: v }),
     },
-    {
-      label: "Max parallel agents",
-      key: "orchestration.maxParallelAgents",
-      helpText: "Sub-agents running concurrently in each /supi:run batch",
-      type: "select",
-      options: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
-      get: (c) => String(c.orchestration.maxParallelAgents),
-      set: (d, v) => updateConfig(paths, d, { orchestration: { maxParallelAgents: Number(v) } }),
-    },
-    {
-      label: "Max fix retries",
-      key: "orchestration.maxFixRetries",
-      helpText: "Times a failed task is retried before marking it blocked",
-      type: "select",
-      options: ["0", "1", "2", "3", "4", "5"],
-      get: (c) => String(c.orchestration.maxFixRetries),
-      set: (d, v) => updateConfig(paths, d, { orchestration: { maxFixRetries: Number(v) } }),
-    },
-    {
-      label: "Max nesting depth",
-      key: "orchestration.maxNestingDepth",
-      helpText: "How deep sub-agents can spawn other sub-agents",
-      type: "select",
-      options: ["0", "1", "2", "3", "4", "5"],
-      get: (c) => String(c.orchestration.maxNestingDepth),
-      set: (d, v) => updateConfig(paths, d, { orchestration: { maxNestingDepth: Number(v) } }),
-    },
     {
       label: "LSP setup guide",
       key: "lsp.setupGuide",

package/src/commands/context.ts

@@ -0,0 +1,117 @@
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { Platform, PlatformContext } from "../platform/types.js";
+import {
+  parseSystemPrompt,
+  buildBreakdownItems,
+  formatSectionReport,
+  formatToolsReport,
+} from "../context/analyzer.js";
+import type { ContextUsage } from "../context/analyzer.js";
+
+const REPORT_FILE = ".omp-context-breakdown.md";
+
+export function handleContext(platform: Platform, ctx: PlatformContext): void {
+  void (async () => {
+    if (!ctx.hasUI) return;
+
+    // Gather data from OMP runtime
+    let usage: ContextUsage | null = null;
+    try {
+      const raw = (ctx as any).getContextUsage?.();
+      if (raw && typeof raw === "object") {
+        usage = {
+          tokens: typeof raw.tokens === "number" ? raw.tokens : null,
+          contextWindow: typeof raw.contextWindow === "number" ? raw.contextWindow : null,
+          percent: typeof raw.percent === "number" ? raw.percent : null,
+        };
+      }
+    } catch {
+      // getContextUsage not available — continue without
+    }
+
+    let systemPrompt = "";
+    try {
+      systemPrompt = (ctx as any).getSystemPrompt?.() ?? "";
+    } catch {
+      // getSystemPrompt not available — continue without
+    }
+
+    // If we have nothing to show, notify and bail
+    if (!usage && !systemPrompt) {
+      ctx.ui.notify("Context data unavailable", "warning");
+      return;
+    }
+
+    // Parse system prompt (may be empty)
+    const sections = systemPrompt ? parseSystemPrompt(systemPrompt) : [];
+    const activeTools = platform.getActiveTools();
+    const items = buildBreakdownItems(usage, sections, activeTools, !systemPrompt);
+    const lines = items.map(i => i.line);
+
+    while (true) {
+      const choice = await ctx.ui.select("Context Breakdown", lines, {
+        helpText: "Select to inspect, Esc to close",
+      });
+      if (!choice || choice.trim() === "Close") break;
+
+      const item = items.find(i => i.line === choice);
+      if (!item || (!item.section && !item.toolNames)) continue;
+
+      let report: string | null = null;
+      if (item.section) {
+        report = formatSectionReport(item.section);
+      } else if (item.toolNames) {
+        report = formatToolsReport(item.toolNames);
+      }
+
+      if (report) {
+        const filePath = writeReport(ctx.cwd, report);
+        await openInEditor(platform, filePath);
+        ctx.ui.notify(`Wrote ${REPORT_FILE}`, "info");
+      }
+    }
+  })().catch((err) => {
+    ctx.ui.notify(`Context error: ${(err as Error).message}`, "error");
+  });
+}
+
+export function registerContextCommand(platform: Platform): void {
+  platform.registerCommand("supi:context", {
+    description: "Show context window breakdown — what's consuming tokens",
+    async handler(_args: string | undefined, ctx: any) {
+      handleContext(platform, ctx);
+    },
+  });
+}
+
+
+/** Write report to project root, falling back to tmpdir on failure */
+function writeReport(cwd: string, content: string): string {
+  const primary = join(cwd, REPORT_FILE);
+  try {
+    writeFileSync(primary, content, "utf-8");
+    return primary;
+  } catch {
+    const fallback = join(tmpdir(), REPORT_FILE);
+    writeFileSync(fallback, content, "utf-8");
+    return fallback;
+  }
+}
+
+/** Open a file in the user's preferred editor */
+async function openInEditor(platform: Platform, filePath: string): Promise<void> {
+  const editor = process.env.VISUAL || process.env.EDITOR;
+  try {
+    if (editor) {
+      await platform.exec(editor, [filePath]);
+    } else {
+      const cmd = process.platform === "darwin" ? "open"
+        : process.platform === "win32" ? "start" : "xdg-open";
+      await platform.exec(cmd, [filePath]);
+    }
+  } catch {
+    // Editor open failed — non-fatal, file was still written
+  }
+}

package/src/commands/doctor.ts

@@ -323,8 +323,7 @@ export function registerDoctorCommand(platform: Platform): void {
   });
 }
 
-const CAPABILITY_LABELS: Record<keyof PlatformCapabilities, string> = {
-  agentSessions: "Sub-agent orchestration (/supi:run)",
+const CAPABILITY_LABELS: Partial<Record<keyof PlatformCapabilities, string>> = {
   compactionHooks: "Context compression",
   customWidgets: "Progress widgets",
   registerTool: "Custom tool registration",

package/src/commands/fix-pr.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadFixPrConfig, saveFixPrConfig, DEFAULT_FIX_PR_CONFIG } from "../fix-pr/config.js";
 import { buildFixPrOrchestratorPrompt } from "../fix-pr/prompt-builder.js";
-import type { FixPrConfig, ReviewerType, CommentReplyPolicy } from "../fix-pr/types.js";
+import type { FixPrConfig, CommentReplyPolicy } from "../fix-pr/types.js";
 import {
   generateFixPrSessionId,
   createFixPrSession,
@@ -14,6 +14,7 @@ import { notifyInfo, notifyError, notifyWarning } from "../notifications/rendere
 import { modelRegistry } from "../config/model-registry-instance.js";
 import { resolveModelForAction, createModelBridge } from "../config/model-resolver.js";
 import { loadModelConfig } from "../config/model-config.js";
+import { detectBotReviewers } from "../fix-pr/bot-detector.js";
 
 modelRegistry.register({
   id: "fix-pr",
@@ -155,6 +156,18 @@ export function registerFixPrCommand(platform: Platform): void {
 
       const commentCount = comments.split("\n").length;
 
+      // Auto-detect bot reviewers from comment data
+      const detectedBots = detectBotReviewers(comments);
+      if (detectedBots.length > 0) {
+        config = {
+          ...config,
+          reviewer: {
+            type: detectedBots[0].type,
+            triggerMethod: detectedBots[0].triggerMethod,
+          },
+        };
+      }
+
       // ── Step 5: Load skill ─────────────────────────────────────────
       let skillContent = "";
       const skillPath = findSkillPath("fix-pr");
@@ -180,7 +193,7 @@ export function registerFixPrCommand(platform: Platform): void {
       const modelConfig = loadModelConfig(platform.paths, ctx.cwd);
       const bridge = createModelBridge(platform);
       const resolved = resolveModelForAction("fix-pr", modelRegistry, modelConfig, bridge);
-      if (resolved.source !== "main" && platform.setModel) {
+      if (resolved.source !== "main" && platform.setModel && resolved.model) {
         platform.setModel(resolved.model);
       }
 
@@ -200,18 +213,6 @@ export function registerFixPrCommand(platform: Platform): void {
 
 // ── Setup Wizard ───────────────────────────────────────────────────────
 
-const REVIEWER_OPTIONS = [
-  "CodeRabbit",
-  "GitHub Copilot",
-  "Gemini Code Review",
-  "None",
-];
-
-const REVIEWER_DEFAULTS: Record<string, string> = {
-  "CodeRabbit": "/review",
-  "GitHub Copilot": "@copilot review",
-  "Gemini Code Review": "/gemini review",
-};
 
 const POLICY_OPTIONS = [
   "Answer all comments",
@@ -239,33 +240,6 @@ const MODEL_TIER_OPTIONS = [
 ];
 
 async function runSetupWizard(ctx: any): Promise<FixPrConfig | null> {
-  // 1. Automated reviewer
-  const reviewerChoice = await ctx.ui.select(
-    "Automated PR reviewer",
-    REVIEWER_OPTIONS,
-    { helpText: "Select your automated reviewer, if any" },
-  );
-  if (!reviewerChoice) return null;
-
-  let reviewerType: ReviewerType = "none";
-  let triggerMethod: string | null = null;
-
-  if (reviewerChoice !== "None") {
-    reviewerType = reviewerChoice.toLowerCase().replace(/ /g, "").replace("github", "") as ReviewerType;
-    // Normalize to our type names
-    if (reviewerChoice === "CodeRabbit") reviewerType = "coderabbit";
-    else if (reviewerChoice === "GitHub Copilot") reviewerType = "copilot";
-    else if (reviewerChoice === "Gemini Code Review") reviewerType = "gemini";
-
-    const defaultTrigger = REVIEWER_DEFAULTS[reviewerChoice] || "";
-    triggerMethod = await ctx.ui.input(
-      "How to trigger re-review?",
-      defaultTrigger,
-      { helpText: `Default for ${reviewerChoice}: ${defaultTrigger}` },
-    );
-    if (triggerMethod === undefined) return null;
-    if (!triggerMethod) triggerMethod = defaultTrigger;
-  }
 
   // 2. Comment reply policy
   const policyChoice = await ctx.ui.select(
@@ -319,7 +293,7 @@ async function runSetupWizard(ctx: any): Promise<FixPrConfig | null> {
   if (!fixerTier) return null;
 
   const config: FixPrConfig = {
-    reviewer: { type: reviewerType, triggerMethod },
+    reviewer: { type: "none", triggerMethod: null },
     commentPolicy,
     loop: { delaySeconds, maxIterations },
     models: {

package/src/commands/mcp.ts

@@ -1,12 +1,12 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { Platform, PlatformContext } from "../platform/types.js";
-import { loadMcpRegistry, addServer, removeServer, updateServer, getServerConfig, acquireLock } from "../mcp/config.js";
+import { loadMcpRegistry, addServer, removeServer, updateServer, getServerConfig, acquireLock, discoverHostMcpServers } from "../mcp/config.js";
 import { McpcClient } from "../mcp/mcpc.js";
 import { generateTriggers } from "../mcp/triggers.js";
 import { generateReadme, writeReadme, writeToolsCache, generateSkill, writeSkill, updateAgentsMd } from "../mcp/docs.js";
 import { MCPC_EXIT } from "../mcp/types.js";
-import type { McpTool, ServerConfig } from "../mcp/types.js";
+import type { McpTool, ServerConfig, HostMcpServer } from "../mcp/types.js";
 import { lookupMcpServer, pickBestMatch } from "../mcp/registry.js";
 
 export interface ParsedMcpArgs {
@@ -507,14 +507,125 @@ export async function handleMcpCli(
       break;
     }
 
+    // ── MIGRATE ──────────────────────────────────────────
+    case "migrate": {
+      await handleMcpMigrate(platform, ctx);
+      break;
+    }
+
     default:
       ctx.ui.notify(
-        `Unknown subcommand "${parsed.subcommand}". Available: add, remove, enable, disable, refresh, login, logout, activation, tag, list, info`,
+        `Unknown subcommand "${parsed.subcommand}". Available: add, remove, enable, disable, refresh, login, logout, activation, tag, list, info, migrate`,
         "warning",
       );
   }
 }
 
+// ── Migrate Handler ───────────────────────────────────────────
+
+/**
+ * Discover MCP servers from the host config that are not yet in supi's
+ * managed registry, present a checkbox multi-select UI, and migrate selected
+ * servers via the existing "add" flow.
+ */
+export async function handleMcpMigrate(
+  platform: Platform,
+  ctx: PlatformContext,
+): Promise<void> {
+  // 1. Discover host servers
+  const hostServers = discoverHostMcpServers(platform.paths, ctx.cwd);
+
+  // 2. Load supi registry to find already-managed names
+  const registry = loadMcpRegistry(platform.paths, ctx.cwd);
+  const managedNames = new Set(Object.keys(registry.servers));
+
+  // 3. Filter to servers not yet managed
+  const candidates: HostMcpServer[] = hostServers.filter((s) => !managedNames.has(s.name));
+
+  if (candidates.length === 0) {
+    ctx.ui.notify("All host MCP servers are already in the supipowers registry.", "info");
+    return;
+  }
+
+  // 4. Checkbox-toggle multi-select UI
+  const selected = new Set<number>();
+
+  while (true) {
+    const checkboxOptions = candidates.map((s, i) => {
+      const tick = selected.has(i) ? "✓" : "✗";
+      // Treat sse as http for display
+      const t = s.transport === "sse" ? "http" : s.transport;
+      const auth = s.hasAuth ? " 🔒" : "";
+      return `${tick} ${s.name} — ${t} (${s.scope})${auth}`;
+    });
+
+    const selectedCount = selected.size;
+    const doneLabel = `[Done — migrate ${selectedCount} selected]`;
+
+    checkboxOptions.push("[Select All]");
+    checkboxOptions.push(doneLabel);
+    checkboxOptions.push("[Cancel]");
+
+    const pick = await ctx.ui.select(
+      "Migrate MCP servers from host config",
+      checkboxOptions,
+      { helpText: "Select servers to migrate · Esc to cancel" },
+    );
+
+    if (pick === undefined || pick === null || pick === "[Cancel]") return;
+
+    if (pick === "[Select All]") {
+      if (selected.size === candidates.length) {
+        // All selected — deselect all
+        selected.clear();
+      } else {
+        candidates.forEach((_, i) => selected.add(i));
+      }
+      continue;
+    }
+
+    if (pick === doneLabel) break;
+
+    // Toggle the clicked candidate
+    const idx = checkboxOptions.indexOf(pick);
+    if (idx >= 0 && idx < candidates.length) {
+      if (selected.has(idx)) {
+        selected.delete(idx);
+      } else {
+        selected.add(idx);
+      }
+    }
+  }
+
+  if (selected.size === 0) {
+    ctx.ui.notify("No servers selected. Migration cancelled.", "info");
+    return;
+  }
+
+  // 5. Migrate selected servers via the existing add flow
+  const toMigrate = [...selected].map((i) => candidates[i]);
+  let migratedCount = 0;
+
+  for (const server of toMigrate) {
+    // Map host transport to supi's transport (sse → http, treat as HTTP URL-based)
+    const transport: "http" | "stdio" = server.transport === "stdio" ? "stdio" : "http";
+
+    await handleMcpCli(platform, ctx, {
+      subcommand: "add",
+      name: server.name,
+      url: transport === "http" ? server.url : undefined,
+      command: transport === "stdio" ? server.command : undefined,
+      commandArgs: server.args,
+      transport,
+    });
+
+    migratedCount++;
+  }
+
+  ctx.ui.notify(`Migration complete. Processed ${migratedCount} server(s).`, "info");
+}
+
+
 export function handleMcp(platform: Platform, ctx: PlatformContext): void {
   if (!ctx.hasUI) {
     ctx.ui.notify("MCP UI requires interactive mode", "warning");
@@ -536,6 +647,7 @@ export function handleMcp(platform: Platform, ctx: PlatformContext): void {
       });
       options.push("[Add server]");
       options.push("[Refresh all]");
+      options.push("[Migrate from host]");
       options.push("[Done]");
 
       const choice = await ctx.ui.select(
@@ -572,6 +684,12 @@ export function handleMcp(platform: Platform, ctx: PlatformContext): void {
       }
 
       // ── Refresh all ───────────────────────────────────────
+      // ── Migrate from host flow ───────────────────────────
+      if (choice === "[Migrate from host]") {
+        await handleMcpMigrate(platform, ctx);
+        continue;
+      }
+
       if (choice === "[Refresh all]") {
         await handleMcpCli(platform, ctx, { subcommand: "refresh" });
         continue;

package/src/commands/plan.ts

@@ -14,6 +14,7 @@ import * as path from "node:path";
 import { modelRegistry } from "../config/model-registry-instance.js";
 import { resolveModelForAction, createModelBridge } from "../config/model-resolver.js";
 import { loadModelConfig } from "../config/model-config.js";
+import { startPlanTracking } from "../planning/approval-flow.js";
 
 modelRegistry.register({
   id: "plan",
@@ -136,7 +137,7 @@ export function registerPlanCommand(platform: Platform): void {
       const modelConfig = loadModelConfig(platform.paths, ctx.cwd);
       const bridge = createModelBridge(platform);
       const resolved = resolveModelForAction("plan", modelRegistry, modelConfig, bridge);
-      if (resolved.source !== "main" && platform.setModel) {
+      if (resolved.source !== "main" && platform.setModel && resolved.model) {
         platform.setModel(resolved.model);
       }
 
@@ -149,6 +150,9 @@ export function registerPlanCommand(platform: Platform): void {
         { deliverAs: "steer", triggerTurn: true }
       );
 
+      // Track planning state for the approval flow (agent_end hook)
+      startPlanTracking(ctx.cwd, platform.paths, ctx.newSession?.bind(ctx));
+
       notifyInfo(ctx, "Planning started", args ? `Topic: ${args}` : "Describe what you want to build");
     },
   });