supipowers 1.2.4 → 1.2.6

package/bin/install.mjs

@@ -5,7 +5,11 @@ import { dirname, join } from "node:path";
 
 const isWindows = process.platform === "win32";
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const result = spawnSync("bun", [join(__dirname, "install.ts"), ...process.argv.slice(2)], {
+// When invoked via bunx/npx, always force a full install to guarantee
+// node_modules/ and a consistent extension directory. The --force flag
+// bypasses the "already up to date" version check.
+const args = [join(__dirname, "install.ts"), "--force", ...process.argv.slice(2)];
+const result = spawnSync("bun", args, {
   stdio: "inherit",
   env: process.env,
   shell: isWindows,

package/bin/install.ts

@@ -14,6 +14,7 @@ import { spawnSync } from "node:child_process";
 import {
   readFileSync,
   writeFileSync,
+  appendFileSync,
   existsSync,
   mkdirSync,
   cpSync,
@@ -123,10 +124,37 @@ async function exec(cmd: string, args: string[]): Promise<ExecResult> {
   return { stdout: r.stdout ?? "", stderr: r.stderr ?? "", code: r.status ?? 1 };
 }
 
-// ── CLI Flags ────────────────────────────────────────────────
+// ── CLI Flags ────────────────────────────────────────────────────
 
 const cliArgs = process.argv.slice(2);
 const skipDeps = cliArgs.includes("--skip-deps");
+const FORCE = cliArgs.includes("--force");
+const DEBUG = cliArgs.includes("--debug");
+
+// ── Debug logging ────────────────────────────────────────────────
+
+const LOG_FILE = resolve(process.cwd(), "supipowers-install.log");
+
+function log(msg: string): void {
+  if (!DEBUG) return;
+  const line = `[${new Date().toISOString()}] ${msg}\n`;
+  appendFileSync(LOG_FILE, line);
+}
+
+if (DEBUG) {
+  // Start fresh log
+  writeFileSync(LOG_FILE, `supipowers installer debug log\n`);
+  log(`platform: ${process.platform}`);
+  log(`arch: ${process.arch}`);
+  log(`bun: ${process.versions?.bun ?? "N/A"}`);
+  log(`node: ${process.version}`);
+  log(`cwd: ${process.cwd()}`);
+  log(`homedir: ${homedir()}`);
+  log(`argv: ${JSON.stringify(process.argv)}`);
+  log(`__dirname: ${__dirname}`);
+  log(`packageRoot will be: ${resolve(__dirname, "..")}`);
+  log(`isWindows: ${isWindows}`);
+}
 
 // ── Install to platform ──────────────────────────────────────
 
@@ -143,18 +171,29 @@ function installToPlatform(platformDir: string, packageRoot: string): string {
   const extDir = join(agentDir, "extensions", "supipowers");
   const installedPkgPath = join(extDir, "package.json");
 
+  log(`installToPlatform(platformDir=${platformDir}, packageRoot=${packageRoot})`);
+  log(`  agentDir: ${agentDir}`);
+  log(`  extDir:   ${extDir}`);
+
   // Check for existing installation
   let installedVersion: string | null = null;
   if (existsSync(installedPkgPath)) {
     try {
       const installed = JSON.parse(readFileSync(installedPkgPath, "utf8"));
       installedVersion = installed.version;
+      log(`  existing version: ${installedVersion}`);
     } catch {
-      // corrupted package.json — treat as not installed
+      log(`  existing package.json corrupted, treating as fresh install`);
     }
+  } else {
+    log(`  no existing installation found`);
   }
 
-  if (installedVersion === VERSION) {
+  const hasNodeModules = existsSync(join(extDir, "node_modules"));
+  log(`  node_modules present: ${hasNodeModules}`);
+
+  if (installedVersion === VERSION && hasNodeModules && !FORCE) {
+    log(`  already up to date with deps, skipping`);
     note(
       `supipowers v${VERSION} is already installed and up to date.`,
       `Up to date (${platformDir})`,
@@ -162,9 +201,16 @@ function installToPlatform(platformDir: string, packageRoot: string): string {
     return extDir;
   }
 
+  if (installedVersion === VERSION && !hasNodeModules) {
+    log(`  same version but node_modules missing — reinstalling deps`);
+  }
+  if (FORCE) {
+    log(`  --force flag set, reinstalling`);
+  }
+
   const action = installedVersion ? "Updating" : "Installing";
   if (installedVersion) {
-    note(`v${installedVersion} → v${VERSION}`, `Updating supipowers (${platformDir})`);
+    note(`v${installedVersion} \u2192 v${VERSION}`, `Updating supipowers (${platformDir})`);
   }
 
   const s = spinner();
@@ -173,14 +219,40 @@ function installToPlatform(platformDir: string, packageRoot: string): string {
   try {
     // Clean previous installation to remove stale files
     if (existsSync(extDir)) {
+      log(`  removing old extDir`);
       rmSync(extDir, { recursive: true });
     }
 
-    // Copy extension (src/ + bin/ + package.json) → ~/<platform>/agent/extensions/supipowers/
+    // Copy extension (src/ + bin/ + package.json) \u2192 ~/<platform>/agent/extensions/supipowers/
+    log(`  creating extDir and copying files`);
     mkdirSync(extDir, { recursive: true });
     cpSync(join(packageRoot, "src"), join(extDir, "src"), { recursive: true });
     cpSync(join(packageRoot, "bin"), join(extDir, "bin"), { recursive: true });
     cpSync(join(packageRoot, "package.json"), join(extDir, "package.json"));
+    log(`  files copied to ${extDir}`);
+
+    // Rewrite package.json for the installed extension.
+    // The npm-published package.json has bin, scripts, prepare, devDeps —
+    // all of which cause problems during `bun install` in the extension dir.
+    // We keep only what OMP needs (omp.extensions) and the runtime dependencies.
+    const sourcePkg = JSON.parse(readFileSync(join(extDir, "package.json"), "utf8"));
+    const runtimePkg = {
+      name: sourcePkg.name,
+      version: sourcePkg.version,
+      type: sourcePkg.type,
+      omp: sourcePkg.omp,
+      dependencies: {
+        // Only packages imported at runtime by src/ code:
+        // - config/schema.ts → @sinclair/typebox
+        // - commands/model.ts, model-picker.ts → @oh-my-pi/pi-ai
+        // - commands/model-picker.ts → @oh-my-pi/pi-tui
+        "@sinclair/typebox": "*",
+        "@oh-my-pi/pi-ai": "*",
+        "@oh-my-pi/pi-tui": "*",
+      },
+    };
+    writeFileSync(join(extDir, "package.json"), JSON.stringify(runtimePkg, null, 2));
+    log(`  rewrote package.json: ${JSON.stringify(runtimePkg, null, 2)}`);
 
     // Copy skills → ~/<platform>/agent/skills/<skillname>/SKILL.md
     const skillsSource = join(packageRoot, "skills");
@@ -196,17 +268,19 @@ function installToPlatform(platformDir: string, packageRoot: string): string {
       }
     }
 
-    // Install dependencies so the extension's runtime imports resolve.
-    // Bun installs peer deps by default, which provides @sinclair/typebox
-    // and @oh-my-pi/* packages that the extension needs at import time.
-    // Without this, the extension fails to load on systems where these
-    // packages aren't in Bun's global install (e.g. OMP installed via npm).
+    // Install runtime dependencies so the extension's imports resolve.
+    // Without node_modules/, external imports (@sinclair/typebox, @oh-my-pi/*)
+    // fail on systems where these packages aren't in Bun's global install.
+    log(`  running: bun install (cwd=${extDir})`);
     s.message("Installing extension dependencies...");
-    const install = run("bun", ["install", "--frozen-lockfile=false"], { cwd: extDir });
+    const install = run("bun", ["install"], { cwd: extDir });
+    log(`  bun install exit code: ${install.status}`);
+    log(`  bun install stdout: ${install.stdout ?? "(null)"}`);
+    log(`  bun install stderr: ${install.stderr ?? "(null)"}`);
+    if (install.error) log(`  bun install error: ${install.error.message}`);
     if (install.status !== 0) {
-      // Non-fatal: the extension may still work if OMP provides the deps.
-      // Log a warning but don't bail — the user might be offline or the
-      // registry might be temporarily unreachable.
+      // Non-fatal: the extension may still work if OMP provides the deps
+      // via its own module resolution (e.g. Bun global install on macOS).
       note(
         "Could not install extension dependencies.\n" +
           "If /supi commands don't appear in OMP, run:\n" +
@@ -215,12 +289,23 @@ function installToPlatform(platformDir: string, packageRoot: string): string {
       );
     }
 
+    // Verify node_modules was created
+    const nmExists = existsSync(join(extDir, "node_modules"));
+    log(`  node_modules exists after install: ${nmExists}`);
+    if (nmExists) {
+      try {
+        const nmContents = readdirSync(join(extDir, "node_modules"));
+        log(`  node_modules top-level: ${nmContents.join(", ")}`);
+      } catch { /* ignore */ }
+    }
+
     s.stop(
       installedVersion
         ? `supipowers updated to v${VERSION} (${platformDir})`
         : `supipowers v${VERSION} installed (${platformDir})`,
     );
   } catch (err: unknown) {
+    log(`  installToPlatform FAILED: ${err instanceof Error ? err.stack : String(err)}`);
     s.stop(`${action} failed (${platformDir})`);
     const message = err instanceof Error ? err.message : `Failed to copy files to ~/${platformDir}/agent/`;
     bail(message);
@@ -377,9 +462,14 @@ async function main(): Promise<void> {
   const piBin = findPiBinary();
   const ompBin = findOmpBinary();
 
+  log(`findPiBinary() => ${piBin ?? "null"}`);
+  log(`findOmpBinary() => ${ompBin ?? "null"}`);
+
   const piVer = piBin ? run(piBin, ["--version"]).stdout?.trim() || "unknown" : null;
   const ompVer = ompBin ? run(ompBin, ["--version"]).stdout?.trim() || "unknown" : null;
 
+  log(`piVer: ${piVer ?? "N/A"}, ompVer: ${ompVer ?? "N/A"}`);
+
   const detected: string[] = [];
   if (piBin) detected.push(`Pi ${piVer}`);
   if (ompBin) detected.push(`OMP ${ompVer}`);
@@ -448,6 +538,8 @@ async function main(): Promise<void> {
   // ── Step 3: Install supipowers to each chosen target ──────
 
   const packageRoot = resolve(__dirname, "..");
+  log(`packageRoot: ${packageRoot}`);
+  log(`targets: ${JSON.stringify(targets)}`);
 
   for (const target of targets) {
     installToPlatform(target.dir, packageRoot);
@@ -456,6 +548,10 @@ async function main(): Promise<void> {
     await installContextMode(target.dir);
   }
 
+  if (DEBUG) {
+    note(`Debug log written to:\n${LOG_FILE}`, "Debug");
+  }
+
   // ── Step 4: Unified dependency check (--skip-deps to skip) ──
 
   if (skipDeps) {

package/bin/local-install.sh

@@ -2,38 +2,42 @@
 # Install supipowers locally from the current working tree.
 # Usage:  ./bin/local-install.sh
 #
-# This creates a global symlink so both the `supipowers` CLI and
-# the Pi/OMP extension resolve to your local source — no publish needed.
-# Re-run after pulling new changes; the symlink stays valid.
+# Creates a global symlink so `supipowers` CLI works, then runs the
+# installer with --debug to deploy the extension and write a log file.
+# Re-run after pulling new changes.
 
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
 
-echo "→ Installing supipowers locally from $PROJECT_DIR"
+echo "-> Installing supipowers locally from $PROJECT_DIR"
 
 # 1. Install dependencies (fast no-op when lock is current)
-echo "→ Installing dependencies…"
+echo "-> Installing dependencies..."
 cd "$PROJECT_DIR"
 bun install --frozen-lockfile 2>/dev/null || bun install
 
 # 2. Create a global symlink via bun link
-#    This registers the package globally so `supipowers` CLI works
-#    and Pi/OMP can resolve it by name.
-echo "→ Linking supipowers globally…"
+echo "-> Linking supipowers globally..."
 bun link
 
 # 3. Verify the link
 if command -v supipowers &>/dev/null; then
-  echo "✓ 'supipowers' CLI is available at $(which supipowers)"
+  echo "[OK] 'supipowers' CLI is available at $(which supipowers)"
 else
-  echo "⚠ CLI not on PATH — you may need to add bun's global bin to \$PATH:"
+  echo "[WARN] CLI not on PATH -- you may need to add bun's global bin to \$PATH:"
   echo "  export PATH=\"\$HOME/.bun/bin:\$PATH\""
 fi
 
-# 4. Show version
+# 4. Run the installer with --debug to deploy extension + write log
+echo "-> Running installer (--debug mode)..."
+bun run "$PROJECT_DIR/bin/install.ts" --debug --force
+
+# 5. Show version and log location
 VERSION=$(node -e "console.log(require('$PROJECT_DIR/package.json').version)")
 echo ""
-echo "✓ supipowers v${VERSION} installed locally (linked to $PROJECT_DIR)"
-echo "  Any edits to src/ or skills/ take effect immediately — no rebuild needed."
+echo "[OK] supipowers v${VERSION} installed locally"
+if [ -f "$PROJECT_DIR/supipowers-install.log" ]; then
+  echo "  Debug log: $PROJECT_DIR/supipowers-install.log"
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "1.2.4",
+  "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/deps/registry.ts

@@ -34,10 +34,10 @@ export async function checkBinary(
   exec: ExecFn,
   binary: string,
 ): Promise<{ installed: boolean; version?: string }> {
-  // `which` is Unix-only; Windows uses `where` to locate executables
-  const whichCmd = process.platform === "win32" ? "where" : "which";
-  const which = await exec(whichCmd, [binary]);
-  if (which.code !== 0) return { installed: false };
+  // Bun.which() is cross-platform (handles .cmd/.exe/.bat on Windows)
+  // and doesn't require shelling out to `which` (Unix) or `where` (Windows).
+  const found = Bun.which(binary);
+  if (!found) return { installed: false };
 
   const ver = await exec(binary, ["--version"]);
   const version = ver.code === 0 ? ver.stdout.trim().split("\n")[0] : undefined;

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;