supipowers 1.2.5 → 1.3.0

package/package.json

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

package/skills/context-mode/SKILL.md

@@ -33,10 +33,6 @@ Instead use:
 - `ctx_execute(language: "shell", code: "find ...")` to run in sandbox
 - `ctx_batch_execute(commands, queries)` for multiple searches
 
-### Read (full-file, no limit) — BLOCKED
-Reading an entire file without a `limit` parameter is blocked.
-- If you need to **Edit** the file → re-call Read with `limit` parameter (e.g., `limit: 200`)
-- If you need to **analyze or explore** → use `ctx_execute_file(path, language, code)` instead. Only your printed summary enters context.
 
 ## REDIRECTED tools — use sandbox equivalents
 
@@ -46,9 +42,9 @@ For everything else, use:
 - `ctx_batch_execute(commands, queries)` — run multiple commands + search in ONE call
 - `ctx_execute(language: "shell", code: "...")` — run in sandbox, only stdout enters context
 
-### Read (for analysis)
-If you are reading a file to **Edit** it → Read with `limit` is correct (Edit needs content in context).
-If you are reading to **analyze, explore, or summarize** → use `ctx_execute_file(path, language, code)` instead. Only your printed summary enters context. The raw file content stays in the sandbox.
+### Read (large files)
+Reads are never blocked — they always go through OMP's native read tool so hashline anchors (`N#XX`) are preserved for the edit contract. Large file reads (>110 lines) are automatically compressed to head (80 lines) + tail (30 lines) with a `sel` hint for the omitted section.
+For analysis-only reads where hashlines aren't needed, `ctx_execute_file(path, language, code)` remains more efficient — only your printed summary enters context.
 
 ## Tool selection hierarchy
 

package/src/bootstrap.ts

@@ -17,6 +17,7 @@ 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 { registerOptimizeContextCommand, handleOptimizeContext } from "./commands/optimize-context.js";
 import { registerCommitCommand, handleCommit } from "./commands/commit.js";
 import { loadConfig } from "./config/loader.js";
 import { registerContextModeHooks } from "./context-mode/hooks.js";
@@ -37,6 +38,7 @@ const TUI_COMMANDS: Record<string, (platform: Platform, ctx: any, args?: string)
   "supi:mcp": (platform, ctx) => handleMcp(platform, ctx),
   "supi:model": (platform, ctx) => handleModel(platform, ctx),
   "supi:context": (platform, ctx) => handleContext(platform, ctx),
+  "supi:optimize-context": (platform, ctx) => handleOptimizeContext(platform, ctx),
   "supi:commit": (platform, ctx, args) => handleCommit(platform, ctx, args),
   "supi:release": (platform, ctx, args) => handleRelease(platform, ctx, args),
 };
@@ -68,6 +70,7 @@ export function bootstrap(platform: Platform): void {
   registerMcpCommand(platform);
   registerModelCommand(platform);
   registerContextCommand(platform);
+  registerOptimizeContextCommand(platform);
   registerCommitCommand(platform);
 
 

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/optimize-context.ts

@@ -0,0 +1,202 @@
+import type { Platform, PlatformContext } from "../platform/types.js";
+import {
+  parseSystemPrompt,
+  parseIndividualSkills,
+} from "../context/analyzer.js";
+import {
+  detectTechStack,
+  buildContextReport,
+} from "../context/optimizer.js";
+import type { ContextReport } from "../context/optimizer.js";
+
+function formatTokens(n: number): string {
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n);
+}
+
+export function handleOptimizeContext(platform: Platform, ctx: PlatformContext): void {
+  void (async () => {
+    if (!ctx.hasUI) return;
+
+    // 1. Detect tech stack
+    const techStack = await detectTechStack(platform, ctx.cwd);
+
+    // 2. Get system prompt
+    let systemPrompt = "";
+    try {
+      systemPrompt = (ctx as any).getSystemPrompt?.() ?? "";
+    } catch {
+      // getSystemPrompt not available
+    }
+
+    if (!systemPrompt) {
+      ctx.ui.notify("System prompt unavailable", "warning");
+      return;
+    }
+
+    // 3. Parse
+    const sections = parseSystemPrompt(systemPrompt);
+    const skills = parseIndividualSkills(systemPrompt);
+
+    // 4. Build raw report
+    const report = buildContextReport(sections, skills, techStack);
+
+    // 5. Show TUI
+    await showReport(platform, ctx, report);
+  })().catch((err) => {
+    ctx.ui.notify(`Optimize error: ${(err as Error).message}`, "error");
+  });
+}
+
+export function registerOptimizeContextCommand(platform: Platform): void {
+  platform.registerCommand("supi:optimize-context", {
+    description: "Analyze context usage and suggest token optimizations",
+    async handler(_args: string | undefined, ctx: any) {
+      handleOptimizeContext(platform, ctx);
+    },
+  });
+}
+
+// ── Internal ──────────────────────────────────────────────
+
+async function showReport(
+  platform: Platform,
+  ctx: PlatformContext,
+  report: ContextReport,
+): Promise<void> {
+  const techList = [
+    ...report.techStack.languages,
+    ...(report.techStack.runtime ? [report.techStack.runtime] : []),
+    ...report.techStack.frameworks,
+    ...report.techStack.tools,
+  ].join(", ");
+
+  const lines: string[] = [
+    `Tech: ${techList || "unknown"}`,
+    `Current: ~${formatTokens(report.totalTokens)} tokens  |  Target: ~8.0K tokens`,
+    "",
+  ];
+
+  // Skills breakdown
+  if (report.skills.length === 0) {
+    lines.push("No skills detected in system prompt.");
+  } else {
+    const totalSkillTokens = report.skills.reduce((sum, s) => sum + s.tokens, 0);
+    lines.push(`Skills (${report.skills.length} loaded, ~${formatTokens(totalSkillTokens)} tok total):`);
+    lines.push("");
+
+    const sorted = [...report.skills].sort((a, b) => b.tokens - a.tokens);
+    for (const s of sorted) {
+      lines.push(`  ${s.name.padEnd(32)} ~${formatTokens(s.tokens)} tok`);
+    }
+  }
+
+  // Non-skill sections
+  if (report.sections.length > 0) {
+    lines.push("");
+    lines.push("Other sections:");
+    lines.push("");
+
+    for (const sec of report.sections) {
+      const tok = formatTokens(sec.tokens);
+      const note = sec.note ? `  (${sec.note})` : "";
+      lines.push(`  ${sec.label.padEnd(28)} ~${tok} tok${note}`);
+    }
+  }
+
+  const message = lines.join("\n");
+
+  // confirm() may not be available on all platforms
+  const shouldOptimize = ctx.ui.confirm
+    ? await ctx.ui.confirm("Context Optimization", message)
+    : (await ctx.ui.select("Context Optimization", [message, "▶ Optimize with AI", "Close"]))?.includes("Optimize");
+
+  if (!shouldOptimize) return;
+
+  platform.sendMessage(
+    {
+      customType: "optimize-context",
+      content: [{ type: "text", text: buildOptimizationPrompt(report) }],
+      display: "none",
+    },
+    { deliverAs: "steer", triggerTurn: true },
+  );
+}
+
+function buildOptimizationPrompt(report: ContextReport): string {
+  const lines: string[] = [];
+
+  const techList = [
+    ...report.techStack.languages,
+    ...(report.techStack.runtime ? [report.techStack.runtime] : []),
+    ...report.techStack.frameworks,
+    ...report.techStack.tools,
+  ].join(", ");
+
+  lines.push("# Context Optimization Request");
+  lines.push("");
+  lines.push(`Current system prompt is **~${formatTokens(report.totalTokens)} tokens**. Target is **< 8K tokens**.`);
+  lines.push(`Project tech stack: **${techList || "unknown"}**`);
+  lines.push("");
+
+  // Skill inventory
+  if (report.skills.length > 0) {
+    lines.push("## Skills currently loaded");
+    lines.push("");
+    lines.push("| Skill | Tokens |");
+    lines.push("|-------|--------|");
+    const sorted = [...report.skills].sort((a, b) => b.tokens - a.tokens);
+    for (const s of sorted) {
+      lines.push(`| ${s.name} | ~${formatTokens(s.tokens)} |`);
+    }
+    lines.push("");
+  }
+
+  // Section inventory
+  if (report.sections.length > 0) {
+    lines.push("## Other prompt sections");
+    lines.push("");
+    for (const sec of report.sections) {
+      const note = sec.note ? ` — ${sec.note}` : "";
+      lines.push(`- **${sec.label}**: ~${formatTokens(sec.tokens)} tok${note}`);
+    }
+    lines.push("");
+  }
+
+  lines.push("## Your task");
+  lines.push("");
+  lines.push("Classify each loaded skill into one of these actions:");
+  lines.push("");
+  lines.push("| Action | Prompt cost | When to use |");
+  lines.push("|--------|-------------|-------------|");
+  lines.push("| **Keep as skill** | Full content every turn | Essential for this project, needed constantly |");
+  lines.push("| **Convert to rulebook rule** | Name + description only | Relevant but only needed on-demand (load via `rule://`) |");
+  lines.push("| **Convert to TTSR rule** | Zero | Behavioral enforcement — triggered by regex pattern in output stream |");
+  lines.push("| **Convert to slash command** | Zero | Interactive workflow the user invokes explicitly |");
+  lines.push("| **Disable** | Zero | Irrelevant to this project's tech stack |");
+  lines.push("");
+  lines.push("For each skill, consider:");
+  lines.push("1. Is it relevant to the detected tech stack? If not → **disable**.");
+  lines.push("2. Does it enforce a behavior pattern (debugging, TDD, verification)? → **TTSR** with a condition regex.");
+  lines.push("3. Is it reference material loaded for occasional lookups? → **rulebook** with a short description.");
+  lines.push("4. Is it an interactive workflow the user triggers explicitly? → **slash command**.");
+  lines.push("5. Is it essential context needed on every turn for this project? → **keep**.");
+  lines.push("");
+  lines.push("## Implementation");
+  lines.push("");
+  lines.push("After classifying, implement the changes:");
+  lines.push("");
+  lines.push("- **Rulebook**: Create `.omp/rules/<skill-name>.md` with YAML frontmatter `description: \"...\"` and condensed key content");
+  lines.push("- **TTSR**: Create `.omp/rules/<skill-name>.md` with YAML frontmatter `condition: \"regex_pattern\"`");
+  lines.push("- **Disable**: Note which skills to remove from the session configuration");
+  lines.push("- **Command**: Note which skills could become slash commands (but don't create them now)");
+  lines.push("");
+  lines.push("## Warnings");
+  lines.push("");
+  lines.push("- Do **NOT** delete files from `~/.omp/skills/` — only create project-local `.omp/rules/` files");
+  lines.push("- Rulebook and TTSR files go in `.omp/rules/` at the project root");
+  lines.push("- Preserve the original skill content's intent when condensing for rulebook rules");
+  lines.push("");
+  lines.push("Present your classification table and implementation plan first, then ask before executing.");
+
+  return lines.join("\n");
+}

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/commands/supi.ts

@@ -20,6 +20,7 @@ export function handleSupi(platform: Platform, ctx: PlatformContext): void {
       "/supi:doctor   — Run health checks",
       "/supi:update   — Update to latest version",
       "/supi:context  — Show context breakdown",
+      "/supi:optimize-context — Optimize context to save tokens",
     ];
 
     const status = [