supipowers 1.2.5 → 1.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "Workflow extension for OMP coding agents.",
   "type": "module",
   "scripts": {

package/src/commands/commit.ts

@@ -5,8 +5,16 @@
 
 import type { Platform } from "../platform/types.js";
 import type { PlatformContext } from "../platform/types.js";
+import { modelRegistry } from "../config/model-registry-instance.js";
 import { analyzeAndCommit } from "../git/commit.js";
 
+modelRegistry.register({
+  id: "commit",
+  category: "command",
+  label: "Commit",
+  harnessRoleHint: "default",
+});
+
 /**
  * Register the command for autocomplete and /help listing.
  * Actual execution goes through handleCommit via the TUI dispatch.

package/src/commands/fix-pr.ts

@@ -1,7 +1,7 @@
 import type { Platform } from "../platform/types.js";
 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 { loadFixPrConfig, saveFixPrConfig } from "../fix-pr/config.js";
 import { buildFixPrOrchestratorPrompt } from "../fix-pr/prompt-builder.js";
 import type { FixPrConfig, CommentReplyPolicy } from "../fix-pr/types.js";
 import {
@@ -12,7 +12,7 @@ import {
 } from "../storage/fix-pr-sessions.js";
 import { notifyInfo, notifyError, notifyWarning } from "../notifications/renderer.js";
 import { modelRegistry } from "../config/model-registry-instance.js";
-import { resolveModelForAction, createModelBridge } from "../config/model-resolver.js";
+import { resolveModelForAction, createModelBridge, applyModelOverride } from "../config/model-resolver.js";
 import { loadModelConfig } from "../config/model-config.js";
 import { detectBotReviewers } from "../fix-pr/bot-detector.js";
 
@@ -23,6 +23,14 @@ modelRegistry.register({
   harnessRoleHint: "default",
 });
 
+modelRegistry.register({
+  id: "task",
+  category: "sub-agent",
+  parent: "fix-pr",
+  label: "Task (sub-agent)",
+  harnessRoleHint: "default",
+});
+
 function getScriptsDir(): string {
   return path.join(path.dirname(new URL(import.meta.url).pathname), "..", "fix-pr", "scripts");
 }
@@ -42,6 +50,12 @@ export function registerFixPrCommand(platform: Platform): void {
   platform.registerCommand("supi:fix-pr", {
     description: "Fix PR review comments with token-optimized agent orchestration",
     async handler(args: string | undefined, ctx: any): Promise<void> {
+      // Resolve and apply model override early — before any logic that might fail
+      const modelConfig = loadModelConfig(platform.paths, ctx.cwd);
+      const bridge = createModelBridge(platform);
+      const resolved = resolveModelForAction("fix-pr", modelRegistry, modelConfig, bridge);
+      await applyModelOverride(platform, ctx, "fix-pr", resolved);
+
       // ── Step 1: Detect PR ──────────────────────────────────────────
       let prNumber: number | null = null;
       let repo: string | null = null;
@@ -178,6 +192,9 @@ export function registerFixPrCommand(platform: Platform): void {
       }
 
       // ── Step 6: Build and send prompt ──────────────────────────────
+      // Resolve task model (sub-agents: planner, fixer). Falls back to fix-pr model.
+      const taskResolved = resolveModelForAction("task", modelRegistry, modelConfig, bridge);
+      const taskModel = taskResolved.model ?? resolved.model ?? "claude-sonnet-4-6";
       const prompt = buildFixPrOrchestratorPrompt({
         prNumber,
         repo,
@@ -187,15 +204,9 @@ export function registerFixPrCommand(platform: Platform): void {
         config,
         iteration: ledger.iteration,
         skillContent,
+        taskModel,
       });
 
-      // Resolve model for this action
-      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 && resolved.model) {
-        platform.setModel(resolved.model);
-      }
 
       platform.sendMessage(
         {
@@ -234,10 +245,6 @@ const ITERATION_OPTIONS = [
   "5",
 ];
 
-const MODEL_TIER_OPTIONS = [
-  "high — thorough reasoning, more tokens",
-  "low — fast execution, fewer tokens",
-];
 
 async function runSetupWizard(ctx: any): Promise<FixPrConfig | null> {
 
@@ -270,46 +277,10 @@ async function runSetupWizard(ctx: any): Promise<FixPrConfig | null> {
   if (!iterChoice) return null;
   const maxIterations = parseInt(iterChoice, 10);
 
-  // 4. Model preferences
-  const orchestratorTier = await ctx.ui.select(
-    "Orchestrator model tier (assessment & grouping)",
-    MODEL_TIER_OPTIONS,
-    { helpText: "Higher tier = more thorough analysis" },
-  );
-  if (!orchestratorTier) return null;
-
-  const plannerTier = await ctx.ui.select(
-    "Planner model tier (fix planning)",
-    MODEL_TIER_OPTIONS,
-    { helpText: "Higher tier = more detailed plans" },
-  );
-  if (!plannerTier) return null;
-
-  const fixerTier = await ctx.ui.select(
-    "Fixer model tier (code changes)",
-    MODEL_TIER_OPTIONS,
-    { helpText: "Lower tier usually sufficient for execution" },
-  );
-  if (!fixerTier) return null;
-
   const config: FixPrConfig = {
     reviewer: { type: "none", triggerMethod: null },
     commentPolicy,
     loop: { delaySeconds, maxIterations },
-    models: {
-      orchestrator: {
-        ...DEFAULT_FIX_PR_CONFIG.models.orchestrator,
-        tier: orchestratorTier.startsWith("high") ? "high" : "low",
-      },
-      planner: {
-        ...DEFAULT_FIX_PR_CONFIG.models.planner,
-        tier: plannerTier.startsWith("high") ? "high" : "low",
-      },
-      fixer: {
-        ...DEFAULT_FIX_PR_CONFIG.models.fixer,
-        tier: fixerTier.startsWith("high") ? "high" : "low",
-      },
-    },
   };
 
   return config;

package/src/commands/mcp.ts

@@ -8,6 +8,16 @@ import { generateReadme, writeReadme, writeToolsCache, generateSkill, writeSkill
 import { MCPC_EXIT } from "../mcp/types.js";
 import type { McpTool, ServerConfig, HostMcpServer } from "../mcp/types.js";
 import { lookupMcpServer, pickBestMatch } from "../mcp/registry.js";
+import { modelRegistry } from "../config/model-registry-instance.js";
+import { resolveModelForAction, createModelBridge, applyModelOverride } from "../config/model-resolver.js";
+import { loadModelConfig } from "../config/model-config.js";
+
+modelRegistry.register({
+  id: "mcp",
+  category: "command",
+  label: "MCP",
+  harnessRoleHint: "slow",
+});
 
 export interface ParsedMcpArgs {
   subcommand?: string;
@@ -789,6 +799,10 @@ export function registerMcpCommand(platform: Platform): void {
   platform.registerCommand("supi:mcp", {
     description: "Manage MCP servers — add, remove, enable, disable, refresh",
     async handler(args: string | undefined, ctx: any) {
+      const modelCfg = loadModelConfig(platform.paths, ctx.cwd);
+      const bridge = createModelBridge(platform);
+      const resolved = resolveModelForAction("mcp", modelRegistry, modelCfg, bridge);
+      await applyModelOverride(platform, ctx, "mcp", resolved);
       if (args) {
         // CLI mode — parse and dispatch
         await handleMcpCli(platform, ctx, parseCliArgs(args));

package/src/commands/model.ts

@@ -39,7 +39,7 @@ function buildDashboard(
   bridge: ModelPlatformBridge,
 ): string {
   const config = loadModelConfig(paths, cwd);
-  const lines: string[] = ["", "  Model Configuration", ""];
+  const lines: string[] = ["\n  Model Configuration\n", `  ${"action".padEnd(20)} ${"model".padEnd(24)} ${"thinking".padEnd(10)} source`];
 
   let lastCategory: "command" | "sub-agent" | null = null;
   let lastParent: string | undefined = undefined;
@@ -56,10 +56,11 @@ function buildDashboard(
     const modelDisplay = (resolved.source === "main" && source === "main"
       ? "—"
       : resolved.model) ?? "—";
+    const thinkingDisplay = resolved.thinkingLevel ?? "—";
     const sourceDisplay = formatSource(source);
 
     lines.push(
-      `  ${action.id.padEnd(20)} ${modelDisplay.padEnd(28)} ${sourceDisplay}`,
+      `  ${action.id.padEnd(20)} ${modelDisplay.padEnd(24)} ${thinkingDisplay.padEnd(10)} ${sourceDisplay}`,
     );
 
     lastCategory = action.category;

package/src/commands/plan.ts

@@ -12,7 +12,7 @@ import { buildPlanningPrompt, buildQuickPlanPrompt } from "../planning/prompt-bu
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { modelRegistry } from "../config/model-registry-instance.js";
-import { resolveModelForAction, createModelBridge } from "../config/model-resolver.js";
+import { resolveModelForAction, createModelBridge, applyModelOverride } from "../config/model-resolver.js";
 import { loadModelConfig } from "../config/model-config.js";
 import { startPlanTracking } from "../planning/approval-flow.js";
 
@@ -38,6 +38,12 @@ export function registerPlanCommand(platform: Platform): void {
   platform.registerCommand("supi:plan", {
     description: "Start collaborative planning for a feature or task",
     async handler(args: string | undefined, ctx: any) {
+      // Resolve and apply model override early — before any logic that might fail
+      const modelCfg = loadModelConfig(platform.paths, ctx.cwd);
+      const bridge = createModelBridge(platform);
+      const resolved = resolveModelForAction("plan", modelRegistry, modelCfg, bridge);
+      await applyModelOverride(platform, ctx, "plan", resolved);
+
       const skillPath = findSkillPath("planning");
       let skillContent = "";
       if (skillPath) {
@@ -133,13 +139,6 @@ export function registerPlanCommand(platform: Platform): void {
         prompt += "\n\n" + buildVisualInstructions(visualUrl, visualSessionDir);
       }
 
-      // Resolve model for this action
-      const modelConfig = loadModelConfig(platform.paths, ctx.cwd);
-      const bridge = createModelBridge(platform);
-      const resolved = resolveModelForAction("plan", modelRegistry, modelConfig, bridge);
-      if (resolved.source !== "main" && platform.setModel && resolved.model) {
-        platform.setModel(resolved.model);
-      }
 
       platform.sendMessage(
         {
@@ -151,7 +150,7 @@ export function registerPlanCommand(platform: Platform): void {
       );
 
       // Track planning state for the approval flow (agent_end hook)
-      startPlanTracking(ctx.cwd, platform.paths, ctx.newSession?.bind(ctx));
+      startPlanTracking(ctx.cwd, platform.paths, ctx.newSession?.bind(ctx), resolved);
 
       notifyInfo(ctx, "Planning started", args ? `Topic: ${args}` : "Describe what you want to build");
     },

package/src/commands/qa.ts

@@ -8,6 +8,16 @@ import { createNewE2eSession } from "../qa/session.js";
 import { buildE2eOrchestratorPrompt } from "../qa/prompt-builder.js";
 import { findActiveSession, getSessionDir } from "../storage/qa-sessions.js";
 import type { E2eQaConfig, AppType, E2eRegression } from "../qa/types.js";
+import { modelRegistry } from "../config/model-registry-instance.js";
+import { resolveModelForAction, createModelBridge, applyModelOverride } from "../config/model-resolver.js";
+import { loadModelConfig } from "../config/model-config.js";
+
+modelRegistry.register({
+  id: "qa",
+  category: "command",
+  label: "QA",
+  harnessRoleHint: "slow",
+});
 
 function getScriptsDir(): string {
   return path.join(path.dirname(new URL(import.meta.url).pathname), "..", "qa", "scripts");
@@ -104,6 +114,11 @@ export function registerQaCommand(platform: Platform): void {
   platform.registerCommand("supi:qa", {
     description: "Run autonomous E2E product testing pipeline with playwright",
     async handler(args: string | undefined, ctx: any) {
+      const modelCfg = loadModelConfig(platform.paths, ctx.cwd);
+      const bridge = createModelBridge(platform);
+      const resolved = resolveModelForAction("qa", modelRegistry, modelCfg, bridge);
+      await applyModelOverride(platform, ctx, "qa", resolved);
+
       const scriptsDir = getScriptsDir();
 
       // ── Step 1: Detect app type ─────────────────────────────────────

package/src/commands/release.ts

@@ -1,4 +1,7 @@
 import type { Platform } from "../platform/types.js";
+import { modelRegistry } from "../config/model-registry-instance.js";
+import { resolveModelForAction, createModelBridge, applyModelOverride } from "../config/model-resolver.js";
+import { loadModelConfig } from "../config/model-config.js";
 import type { ReleaseChannel, BumpType } from "../types.js";
 import { loadConfig, updateConfig } from "../config/loader.js";
 import { detectChannels } from "../release/detector.js";
@@ -10,6 +13,13 @@ import { notifyInfo, notifySuccess, notifyError } from "../notifications/rendere
 import { analyzeAndCommit } from "../git/commit.js";
 import { getWorkingTreeStatus } from "../git/status.js";
 
+modelRegistry.register({
+  id: "release",
+  category: "command",
+  label: "Release",
+  harnessRoleHint: "slow",
+});
+
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 const STATUS_KEY = "supi-release";
 const WIDGET_KEY = "supi-release";
@@ -185,7 +195,12 @@ export function registerReleaseCommand(platform: Platform): void {
  * TUI-only handler — called from the input event dispatcher in bootstrap.ts.
  * Runs the full release flow without triggering the outer LLM session.
  */
-export function handleRelease(platform: Platform, ctx: any, args?: string): void {
+export async function handleRelease(platform: Platform, ctx: any, args?: string): Promise<void> {
+  const modelCfg = loadModelConfig(platform.paths, ctx.cwd);
+  const bridge = createModelBridge(platform);
+  const resolved = resolveModelForAction("release", modelRegistry, modelCfg, bridge);
+  await applyModelOverride(platform, ctx, "release", resolved);
+
   if (!ctx.hasUI) {
     ctx.ui.notify("Release requires interactive mode", "warning");
     return;

package/src/commands/review.ts

@@ -5,7 +5,7 @@ import { buildReviewPrompt } from "../quality/gate-runner.js";
 import { isLspAvailable } from "../lsp/detector.js";
 import { notifyInfo, notifyWarning } from "../notifications/renderer.js";
 import { modelRegistry } from "../config/model-registry-instance.js";
-import { resolveModelForAction, createModelBridge } from "../config/model-resolver.js";
+import { resolveModelForAction, createModelBridge, applyModelOverride } from "../config/model-resolver.js";
 import { loadModelConfig } from "../config/model-config.js";
 
 modelRegistry.register({
@@ -19,6 +19,12 @@ export function registerReviewCommand(platform: Platform): void {
   platform.registerCommand("supi:review", {
     description: "Run quality gates at chosen depth (quick/thorough/full-regression)",
     async handler(args: string | undefined, ctx: any) {
+      // Resolve and apply model override early — before any logic that might fail
+      const modelCfg = loadModelConfig(platform.paths, ctx.cwd);
+      const bridge = createModelBridge(platform);
+      const resolved = resolveModelForAction("review", modelRegistry, modelCfg, bridge);
+      await applyModelOverride(platform, ctx, "review", resolved);
+
       const config = loadConfig(platform.paths, ctx.cwd);
 
       let profileOverride: string | undefined;
@@ -96,13 +102,6 @@ export function registerReviewCommand(platform: Platform): void {
 
       notifyInfo(ctx, `Review started`, `profile: ${profile.name}`);
 
-      // Resolve model for this action
-      const modelConfig = loadModelConfig(platform.paths, ctx.cwd);
-      const bridge = createModelBridge(platform);
-      const resolved = resolveModelForAction("review", modelRegistry, modelConfig, bridge);
-      if (resolved.source !== "main" && platform.setModel && resolved.model) {
-        platform.setModel(resolved.model);
-      }
 
       platform.sendMessage(
         {

package/src/config/model-resolver.ts

@@ -111,3 +111,90 @@ export function createModelBridge(platform: Platform): ModelPlatformBridge {
     },
   };
 }
+
+/**
+ * Apply a resolved model override to the current session.
+ *
+ * Resolves the string model ID to an OMP Model object via the context's
+ * modelRegistry, then calls platform.setModel() with it. Also applies
+ * thinking level if specified.
+ *
+ * @param platform - The platform adapter
+ * @param ctx - Command handler context (must have modelRegistry.getAvailable())
+ * @param actionId - The action being configured (e.g. "plan", "review") — used in notification
+ * @param resolved - The resolved model from resolveModelForAction()
+ * @returns true if model was applied, false if skipped or failed
+ */
+export async function applyModelOverride(
+  platform: Platform,
+  ctx: any,
+  actionId: string,
+  resolved: ResolvedModel,
+): Promise<boolean> {
+  // Skip if resolution fell through to the main session model (nothing to change)
+  if (resolved.source === "main") return false;
+
+  const modelId = resolved.model;
+  if (!modelId) return false;
+
+  // Apply thinking level (independent of model switch success)
+  if (resolved.thinkingLevel && platform.setThinkingLevel) {
+    platform.setThinkingLevel(resolved.thinkingLevel);
+  }
+
+  if (!platform.setModel) return false;
+
+  // Resolve string model ID to full OMP Model object via the context's model registry.
+  // OMP's setModel expects a Model object (with provider, id, api, etc.), not a string.
+  const available = ctx.modelRegistry?.getAvailable?.() as any[] | undefined;
+  if (!available) return false;
+
+  const modelObj = available.find((m: any) => {
+    if (!m?.id) return false;
+    if (modelId === m.id) return true;
+    if (modelId === `${m.provider}/${m.id}`) return true;
+    return modelId.includes("/") ? false : m.id === modelId;
+  });
+
+  if (!modelObj) return false;
+
+  // Save current model so we can restore after the agent turn completes.
+  // OMP's extension API setModel() persists to settings (calls session.setModel,
+  // not session.setModelTemporary). We must restore to avoid permanently
+  // overriding the user's default model.
+  const originalModel = ctx.model;
+
+  const applied = await platform.setModel(modelObj);
+  if (!applied) return false;
+
+  // Show persistent model override info in the footer status bar.
+  // ctx.ui.notify() is transient and gets immediately replaced by progress widgets;
+  // setStatus persists alongside them.
+  const STATUS_KEY = "supi-model";
+  const displayName = modelObj.name ?? modelObj.id ?? modelId;
+  const sourceLabel =
+    resolved.source === "action" ? `configured for ${actionId}` :
+    resolved.source === "default" ? "supipowers default" :
+    "harness role";
+  let detail = sourceLabel;
+  if (resolved.thinkingLevel) {
+    detail += ` \u00b7 ${resolved.thinkingLevel} thinking`;
+  }
+  ctx.ui?.setStatus?.(STATUS_KEY, `Model: ${displayName} (${detail})`);
+
+  // Register a one-shot agent_end hook to restore the original model
+  // and clear the status bar entry.
+  {
+    let restored = false;
+    platform.on("agent_end", async () => {
+      if (restored) return;
+      restored = true;
+      ctx.ui?.setStatus?.(STATUS_KEY, undefined);
+      if (originalModel) {
+        await platform.setModel!(originalModel);
+      }
+    });
+  }
+
+  return true;
+}

package/src/fix-pr/config.ts

@@ -13,11 +13,6 @@ export const DEFAULT_FIX_PR_CONFIG: FixPrConfig = {
   reviewer: { type: "none", triggerMethod: null },
   commentPolicy: "answer-selective",
   loop: { delaySeconds: 180, maxIterations: 3 },
-  models: {
-    orchestrator: { provider: "anthropic", model: "claude-opus-4-6", tier: "high" },
-    planner: { provider: "anthropic", model: "claude-opus-4-6", tier: "high" },
-    fixer: { provider: "anthropic", model: "claude-sonnet-4-6", tier: "low" },
-  },
 };
 
 export function loadFixPrConfig(paths: PlatformPaths, cwd: string): FixPrConfig | null {

package/src/fix-pr/prompt-builder.ts

@@ -10,6 +10,8 @@ export interface FixPrPromptOptions {
   config: FixPrConfig;
   iteration: number;
   skillContent: string;
+  /** Resolved model ID for sub-agent tasks (planner, fixer roles). */
+  taskModel: string;
 }
 
 function buildReplyInstructions(config: FixPrConfig): string {
@@ -47,8 +49,8 @@ function buildReplyInstructions(config: FixPrConfig): string {
 }
 
 export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): string {
-  const { prNumber, repo, comments, sessionDir, scriptsDir, config, iteration, skillContent } = options;
-  const { loop, models, reviewer } = config;
+  const { prNumber, repo, comments, sessionDir, scriptsDir, config, iteration, skillContent, taskModel } = options;
+  const { loop, reviewer } = config;
   const maxIter = loop.maxIterations;
   const delay = loop.delaySeconds;
 
@@ -190,11 +192,10 @@ export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): strin
   sections.push(
     "## Model Guidance",
     "",
-    `- **Orchestrator** (assessment, grouping): ${models.orchestrator.model} (${models.orchestrator.tier} tier) — thorough analysis`,
-    `- **Planner** (fix planning): ${models.planner.model} (${models.planner.tier} tier) — detailed planning`,
-    `- **Fixer** (code changes): ${models.fixer.model} (${models.fixer.tier} tier) — focused execution`,
+    `- **Orchestrator** (this session): handles assessment & grouping`,
+    `- **Planner & Fixer** (sub-agents): use model \`${taskModel}\``,
     "",
-    "These indicate the expected reasoning depth for each phase of work.",
+    "Sub-agents inherit the task model for planning and code changes.",
   );
 
   return sections.join("\n");

package/src/fix-pr/types.ts

@@ -4,12 +4,6 @@ export type ReviewerType = "coderabbit" | "copilot" | "gemini" | "none";
 /** How to handle comment replies */
 export type CommentReplyPolicy = "answer-all" | "answer-selective" | "no-answer";
 
-/** Model preference for a specific role */
-export interface ModelPref {
-  provider: string;
-  model: string;
-  tier: "low" | "high";
-}
 
 /** Per-repo fix-pr configuration */
 export interface FixPrConfig {
@@ -22,11 +16,6 @@ export interface FixPrConfig {
     delaySeconds: number;
     maxIterations: number;
   };
-  models: {
-    orchestrator: ModelPref;
-    planner: ModelPref;
-    fixer: ModelPref;
-  };
 }
 
 /** A PR review comment from GitHub API */

package/src/git/commit.ts

@@ -10,6 +10,9 @@ import { validateCommitMessage } from "./commit-msg.js";
 import { getWorkingTreeStatus } from "./status.js";
 import { discoverCommitConventions } from "./conventions.js";
 import { notifyInfo, notifyError, notifySuccess } from "../notifications/renderer.js";
+import { modelRegistry } from "../config/model-registry-instance.js";
+import { resolveModelForAction, createModelBridge } from "../config/model-resolver.js";
+import { loadModelConfig } from "../config/model-config.js";
 
 // ── Public types ───────────────────────────────────────────
 
@@ -213,6 +216,7 @@ function createProgress(ctx: any) {
     dispose() {
       stopTimer();
       ctx.ui.setStatus?.(STATUS_KEY, undefined);
+      ctx.ui.setStatus?.("supi-model", undefined);
       ctx.ui.setWidget?.(WIDGET_KEY, undefined);
     },
   };
@@ -292,8 +296,26 @@ export async function analyzeAndCommit(
 
     if (platform.capabilities.agentSessions) {
       progress.activate(4, `${fileList.length} file(s)`);
-      plan = await tryAgentPlan(platform, cwd, prompt);
+      // Resolve the commit sub-agent model from config (falls back to session default)
+      const modelCfg = loadModelConfig(platform.paths, cwd);
+      const bridge = createModelBridge(platform);
+      const commitModel = resolveModelForAction("commit", modelRegistry, modelCfg, bridge);
+
+      // Show model override in status bar if not using the main session model
+      if (commitModel.source !== "main" && commitModel.model) {
+        const sourceLabel =
+          commitModel.source === "action" ? "configured for commit" :
+          commitModel.source === "default" ? "supipowers default" :
+          "harness role";
+        let detail = sourceLabel;
+        if (commitModel.thinkingLevel) {
+          detail += ` \u00b7 ${commitModel.thinkingLevel} thinking`;
+        }
+        ctx.ui?.setStatus?.("supi-model", `Model: ${commitModel.model} (${detail})`);
+      }
+      plan = await tryAgentPlan(platform, cwd, prompt, commitModel.model);
       if (plan) {
+        plan = validatePlanFiles(plan, fileList);
         progress.complete(4, `${plan.commits.length} commit(s)`);
       } else {
         progress.skip(4, "unavailable");
@@ -332,7 +354,7 @@ export async function analyzeAndCommit(
 
     // 7. Execute commits
     progress.activate(6, `0/${plan.commits.length}`);
-    return executeCommitPlan(platform, ctx, cwd, plan, progress);
+    return executeCommitPlan(platform, ctx, cwd, plan, fileList, progress);
   } finally {
     // Always clean up, even on unexpected errors
     progress.dispose();
@@ -345,10 +367,11 @@ async function tryAgentPlan(
   platform: Platform,
   cwd: string,
   prompt: string,
+  model?: string,
 ): Promise<CommitPlan | null> {
   let session: Awaited<ReturnType<Platform["createAgentSession"]>> | null = null;
   try {
-    session = await platform.createAgentSession({ cwd, hasUI: false });
+    session = await platform.createAgentSession({ cwd, hasUI: false, ...(model ? { model } : {}) });
 
     const agentDone = new Promise<void>((resolve) => {
       session!.subscribe((event: any) => {
@@ -426,6 +449,26 @@ async function manualFallback(
   return { committed: 1, messages: [message] };
 }
 
+// ── Plan validation ────────────────────────────────────────
+
+/**
+ * Filter an AI-generated commit plan against the actual staged file list.
+ * Removes hallucinated paths that aren't staged, and drops empty groups.
+ * Falls back to the original plan if filtering would leave nothing.
+ */
+export function validatePlanFiles(plan: CommitPlan, stagedFiles: string[]): CommitPlan {
+  const stagedSet = new Set(stagedFiles);
+  const validCommits = plan.commits
+    .map((group) => ({
+      ...group,
+      files: group.files.filter((f) => stagedSet.has(f)),
+    }))
+    .filter((group) => group.files.length > 0);
+
+  return validCommits.length > 0 ? { commits: validCommits } : plan;
+}
+
+
 // ── Commit execution ───────────────────────────────────────
 
 async function executeCommitPlan(
@@ -433,38 +476,45 @@ async function executeCommitPlan(
   ctx: any,
   cwd: string,
   plan: CommitPlan,
+  stagedFiles: string[],
   progress: ReturnType<typeof createProgress>,
 ): Promise<CommitResult | null> {
   const exec = platform.exec.bind(platform);
   const committedMessages: string[] = [];
 
+  // Snapshot the full index as a tree object. This lets us restore the
+  // staging area for each commit group via `git read-tree` — which reads
+  // from git's object store and never consults .gitignore.
+  const writeTreeResult = await exec("git", ["write-tree"], { cwd });
+  if (writeTreeResult.code !== 0) {
+    progress.dispose();
+    notifyError(ctx, "Commit failed", "Could not snapshot index (git write-tree)");
+    return null;
+  }
+  const savedTree = writeTreeResult.stdout.trim();
+
   for (let i = 0; i < plan.commits.length; i++) {
     const group = plan.commits[i];
     const header = formatCommitMessage(group).split("\n")[0];
     progress.detail(`${i + 1}/${plan.commits.length}: ${header}`);
 
-    // Reset staging area
-    await exec("git", ["reset", "HEAD"], { cwd });
+    // Restore the full saved index (no gitignore involvement)
+    await exec("git", ["read-tree", savedTree], { cwd });
 
-    // Stage only this group's files
-    const addResult = await exec("git", ["add", ...group.files], { cwd });
-    if (addResult.code !== 0) {
-      progress.dispose();
-      const failedFiles = group.files.join(", ");
-      const reason = addResult.stderr?.trim() || "git add returned non-zero";
-      return reportPartialFailure(ctx, exec, cwd, committedMessages, {
-        step: `Commit ${i + 1}/${plan.commits.length}`,
-        error: `Could not stage files (${failedFiles}): ${reason}`,
-      });
+    // Unstage everything NOT in this group
+    const groupSet = new Set(group.files);
+    const filesToUnstage = stagedFiles.filter((f) => !groupSet.has(f));
+    if (filesToUnstage.length > 0) {
+      await exec("git", ["reset", "HEAD", "--", ...filesToUnstage], { cwd });
     }
 
-    // Build commit message
     const message = formatCommitMessage(group);
-
     const commitResult = await commitStaged(exec, cwd, message);
     if (!commitResult.success) {
       progress.dispose();
-      return reportPartialFailure(ctx, exec, cwd, committedMessages, {
+      // Restore full staging area so the user isn't left with a partial index
+      await exec("git", ["read-tree", savedTree], { cwd });
+      return reportPartialFailure(ctx, committedMessages, {
         step: `Commit ${i + 1}/${plan.commits.length}`,
         error: commitResult.error!,
       });
@@ -473,6 +523,10 @@ async function executeCommitPlan(
     committedMessages.push(message);
   }
 
+  // Restore the saved index so any staged files NOT in the plan remain staged.
+  // Files already committed now match HEAD, so they appear as not-staged.
+  await exec("git", ["read-tree", savedTree], { cwd });
+
   progress.complete(6, `${committedMessages.length} done`);
   progress.dispose();
   notifySuccess(
@@ -486,18 +540,12 @@ async function executeCommitPlan(
 
 /**
  * Report a mid-plan failure with context on what succeeded and what failed.
- * Re-stages remaining files so the user isn't left with a half-reset index.
  */
-async function reportPartialFailure(
+function reportPartialFailure(
   ctx: any,
-  exec: Platform["exec"],
-  cwd: string,
   committedMessages: string[],
   failure: { step: string; error: string },
-): Promise<CommitResult | null> {
-  // Re-stage everything so the user isn't stuck with a partial index
-  await exec("git", ["add", "-A"], { cwd });
-
+): CommitResult | null {
   const lines: string[] = [];
   lines.push(`Failed at ${failure.step}: ${failure.error}`);
 

package/src/planning/approval-flow.ts

@@ -1,4 +1,6 @@
 import type { Platform } from "../platform/types.js";
+import type { ResolvedModel } from "../types.js";
+import { applyModelOverride } from "../config/model-resolver.js";
 import { listPlans, readPlanFile } from "../storage/plans.js";
 
 /**
@@ -14,17 +16,21 @@ let plansBefore: string[] = [];
 let planCwd: string = "";
 /** newSession function captured from the command context at plan start. */
 let capturedNewSession: ((options?: any) => Promise<{ cancelled: boolean }>) | null = null;
+/** Resolved model for plan action — re-applied on execution handoff. */
+let capturedResolvedModel: ResolvedModel | null = null;
 
 /** Mark planning as started (called by plan command after sending steer). */
 export function startPlanTracking(
   cwd: string,
   paths: any,
   newSession?: (options?: any) => Promise<{ cancelled: boolean }>,
+  resolvedModel?: ResolvedModel,
 ): void {
   planningActive = true;
   planCwd = cwd;
   plansBefore = listPlans(paths, cwd);
   capturedNewSession = newSession ?? null;
+  capturedResolvedModel = resolvedModel ?? null;
 }
 
 /** Cancel plan tracking (e.g., session change). */
@@ -33,6 +39,7 @@ export function cancelPlanTracking(): void {
   plansBefore = [];
   planCwd = "";
   capturedNewSession = null;
+  capturedResolvedModel = null;
 }
 
 /** Whether a planning session is currently active. */
@@ -89,10 +96,16 @@ async function executeApproveFlow(
 ): Promise<void> {
   const prompt = buildExecutionPrompt(planContent, planPath);
 
+  // Re-apply the plan model override for the execution turn.
+  // The planning turn's restore hook already fired (model reverted to default).
+  // We must switch again so the execution LLM turn uses the configured model.
+  if (capturedResolvedModel) {
+    await applyModelOverride(platform, ctx, "plan", capturedResolvedModel);
+  }
+
   if (capturedNewSession) {
     const result = await capturedNewSession();
     if (result?.cancelled) {
-      // User dismissed the new-session prompt — keep plan state intact.
       ctx.ui.notify("Session start cancelled. Plan saved; run /supi:plan again to execute.");
       return;
     }

package/src/platform/omp.ts

@@ -17,8 +17,11 @@ export function createOmpAdapter(api: any): Platform {
     sendUserMessage: (text: string) => api.sendUserMessage(text),
     registerMessageRenderer: (type, fn) => api.registerMessageRenderer(type, fn),
 
-    setModel(model: string): void {
-      api.setModel(model);
+    async setModel(model: any): Promise<boolean> {
+      return api.setModel(model);
+    },
+    setThinkingLevel(level: string, persist?: boolean): void {
+      api.setThinkingLevel?.(level, persist);
     },
     getCurrentModel(): string {
       return api.getCurrentModel?.() ?? "unknown";

package/src/platform/types.ts

@@ -138,7 +138,8 @@ export interface Platform {
   registerMessageRenderer<T>(type: string, renderer: any): void;
 
   // Model access
-  setModel?(model: string): void;
+  setModel?(model: any): Promise<boolean>;
+  setThinkingLevel?(level: string, persist?: boolean): void;
   getCurrentModel?(): string;
   getModelForRole?(role: string): string | null;