supipowers 1.2.5 → 1.3.0

package/src/context-mode/snapshot-builder.ts

@@ -9,19 +9,255 @@ const CAPS = {
   git: 5,
 };
 
+/** Escape all 5 XML special characters in user data */
+function escapeXML(str: string): string {
+  return str
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+interface SnapshotOpts {
+  compactCount?: number;
+  searchTool?: string;
+  searchAvailable?: boolean;
+}
+
 /** Build a resume snapshot from tracked events for a session */
-export function buildResumeSnapshot(eventStore: EventStore, sessionId: string): string {
+export function buildResumeSnapshot(
+  eventStore: EventStore,
+  sessionId: string,
+  opts?: SnapshotOpts,
+): string {
   const counts = eventStore.getEventCounts(sessionId);
   const hasAnyEvents = Object.values(counts).some((c) => c > 0);
   if (!hasAnyEvents) return "";
 
+  if (opts?.searchAvailable) {
+    return buildReferenceSnapshot(eventStore, sessionId, opts);
+  }
+  return buildFallbackSnapshot(eventStore, sessionId);
+}
+
+// ---------------------------------------------------------------------------
+// Reference-based format (context-mode MCP available)
+// ---------------------------------------------------------------------------
+
+function buildReferenceSnapshot(eventStore: EventStore, sessionId: string, opts: SnapshotOpts): string {
+  const compactCount = opts.compactCount ?? 0;
+  const now = new Date().toISOString();
+  const sections: string[] = [
+    `<session_knowledge compact_count="${compactCount}" generated_at="${escapeXML(now)}">`,
+    "  <how_to_search>",
+    "  Each section below contains a summary of prior work.",
+    "  For FULL DETAILS, run the exact tool call shown under each section.",
+    "  Do NOT ask the user to re-explain prior work. Search first.",
+    "  </how_to_search>",
+  ];
+
+  let hasSections = false;
+
+  // --- rules ---
+  const ruleEvents = eventStore.getEvents(sessionId, { categories: ["rule"] });
+  if (ruleEvents.length > 0) {
+    const files = new Set<string>();
+    for (const r of ruleEvents) {
+      const data = safeParse(r.data);
+      const file = typeof data?.file === "string" ? data.file : typeof data?.path === "string" ? data.path : null;
+      if (file) files.add(file);
+    }
+    if (files.size > 0) {
+      const fileList = [...files];
+      sections.push("");
+      sections.push(`  <rules>`);
+      sections.push(`    Loaded ${fileList.length} project rule files: ${fileList.map(escapeXML).join(", ")}`);
+      sections.push(`    For full details:`);
+      sections.push(`    ctx_search(queries: [${fileList.map((f) => `"${escapeXML(f)}"`).join(", ")}], source: "session-events")`);
+      sections.push(`  </rules>`);
+      hasSections = true;
+    }
+  }
+
+  // --- files ---
+  const fileEvents = eventStore.getEvents(sessionId, { categories: ["file"], limit: 200 });
+  if (fileEvents.length > 0) {
+    const edited = new Set<string>();
+    const read = new Set<string>();
+    for (const f of fileEvents) {
+      const data = safeParse(f.data);
+      const p = typeof data?.path === "string" ? data.path : null;
+      if (!p) continue;
+      if (data?.op === "edit" || data?.op === "write") edited.add(p);
+      else if (data?.op === "read") read.add(p);
+    }
+    if (edited.size > 0 || read.size > 0) {
+      sections.push("");
+      sections.push(`  <files count="${edited.size + read.size}">`);
+      if (edited.size > 0) sections.push(`    Edited: ${[...edited].map(escapeXML).join(", ")}`);
+      if (read.size > 0) sections.push(`    Read: ${[...read].map(escapeXML).join(", ")}`);
+      const queryPaths = [...edited, ...read].slice(0, 5);
+      sections.push(`    For full details:`);
+      sections.push(`    ctx_search(queries: [${queryPaths.map((p) => `"${escapeXML(p)}"`).join(", ")}], source: "session-events")`);
+      sections.push(`  </files>`);
+      hasSections = true;
+    }
+  }
+
+  // --- tasks ---
+  const tasks = eventStore.getEvents(sessionId, { categories: ["task"], limit: CAPS.tasks });
+  if (tasks.length > 0) {
+    const summaries: string[] = [];
+    for (const t of tasks) {
+      const data = safeParse(t.data);
+      const content = extractTaskContent(data);
+      if (content) summaries.push(escapeXML(content.slice(0, 100)));
+    }
+    if (summaries.length > 0) {
+      sections.push("");
+      sections.push(`  <tasks>`);
+      for (const s of summaries) sections.push(`    ${s}`);
+      sections.push(`    For full details:`);
+      sections.push(`    ctx_search(queries: ["task", "todo"], source: "session-events")`);
+      sections.push(`  </tasks>`);
+      hasSections = true;
+    }
+  }
+
+  // --- decisions ---
+  const decisions = eventStore.getEvents(sessionId, { categories: ["decision"], limit: CAPS.decisions });
+  if (decisions.length > 0) {
+    const summaries: string[] = [];
+    for (const d of decisions) {
+      const data = safeParse(d.data);
+      const prompt = typeof data?.prompt === "string" ? data.prompt.slice(0, 100) : "";
+      if (prompt) summaries.push(escapeXML(prompt));
+    }
+    if (summaries.length > 0) {
+      sections.push("");
+      sections.push(`  <decisions>`);
+      for (const s of summaries) sections.push(`    ${s}`);
+      sections.push(`  </decisions>`);
+      hasSections = true;
+    }
+  }
+
+  // --- errors ---
+  const errors = eventStore.getEvents(sessionId, { categories: ["error"], limit: CAPS.errors });
+  if (errors.length > 0) {
+    const summaries: string[] = [];
+    for (const e of errors) {
+      const data = safeParse(e.data);
+      const summary = formatErrorSummary(data);
+      if (summary) summaries.push(escapeXML(summary.slice(0, 150)));
+    }
+    if (summaries.length > 0) {
+      sections.push("");
+      sections.push(`  <errors>`);
+      for (const s of summaries) sections.push(`    ${s}`);
+      sections.push(`  </errors>`);
+      hasSections = true;
+    }
+  }
+
+  // --- git ---
+  const gitEvents = eventStore.getEvents(sessionId, { categories: ["git"], limit: CAPS.git });
+  if (gitEvents.length > 0) {
+    const summaries: string[] = [];
+    for (const g of gitEvents) {
+      const data = safeParse(g.data);
+      const cmd = typeof data?.command === "string" ? data.command.slice(0, 100) : "";
+      if (cmd) summaries.push(escapeXML(cmd));
+    }
+    if (summaries.length > 0) {
+      sections.push("");
+      sections.push(`  <git>`);
+      for (const s of summaries) sections.push(`    ${s}`);
+      sections.push(`  </git>`);
+      hasSections = true;
+    }
+  }
+
+  // --- skills ---
+  const skillEvents = eventStore.getEvents(sessionId, { categories: ["skill"] });
+  if (skillEvents.length > 0) {
+    const names = new Set<string>();
+    for (const s of skillEvents) {
+      const data = safeParse(s.data);
+      const name = typeof data?.name === "string" ? data.name : typeof data?.skill === "string" ? data.skill : null;
+      if (name) names.add(name);
+    }
+    if (names.size > 0) {
+      sections.push("");
+      sections.push(`  <skills>`);
+      sections.push(`    Activated: ${[...names].map(escapeXML).join(", ")}`);
+      sections.push(`  </skills>`);
+      hasSections = true;
+    }
+  }
+
+  // --- intent ---
+  const intentEvents = eventStore.getEvents(sessionId, { categories: ["intent"], limit: 1 });
+  if (intentEvents.length > 0) {
+    const data = safeParse(intentEvents[0].data);
+    const mode = typeof data?.mode === "string" ? data.mode : typeof data?.intent === "string" ? data.intent : null;
+    if (mode) {
+      sections.push("");
+      sections.push(`  <intent>Session mode: ${escapeXML(mode)}</intent>`);
+      hasSections = true;
+    }
+  }
+
+  // --- env ---
+  const envEvents = eventStore.getEvents(sessionId, { categories: ["env"] });
+  if (envEvents.length > 0) {
+    const details: string[] = [];
+    for (const e of envEvents) {
+      const data = safeParse(e.data);
+      const detail = typeof data?.detail === "string" ? data.detail : typeof data?.env === "string" ? data.env : null;
+      if (detail) details.push(escapeXML(detail.slice(0, 100)));
+    }
+    if (details.length > 0) {
+      sections.push("");
+      sections.push(`  <env>`);
+      for (const d of details) sections.push(`    ${d}`);
+      sections.push(`  </env>`);
+      hasSections = true;
+    }
+  }
+
+  // --- cwd ---
+  const cwdEvents = eventStore.getEvents(sessionId, { categories: ["cwd"], limit: 1 });
+  if (cwdEvents.length > 0) {
+    const data = safeParse(cwdEvents[0].data);
+    const cwd = typeof data?.cwd === "string" ? data.cwd : typeof data?.path === "string" ? data.path : null;
+    if (cwd) {
+      sections.push("");
+      sections.push(`  <cwd>${escapeXML(cwd)}</cwd>`);
+      hasSections = true;
+    }
+  }
+
+  sections.push("</session_knowledge>");
+
+  if (!hasSections) return "";
+
+  return sections.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// Fallback inline-truncated format (no context-mode MCP)
+// ---------------------------------------------------------------------------
+
+function buildFallbackSnapshot(eventStore: EventStore, sessionId: string): string {
   const sections: string[] = ["<session_knowledge>"];
 
   // Last request
   const prompts = eventStore.getEvents(sessionId, { categories: ["prompt"], limit: 1 });
   if (prompts.length > 0) {
     const data = safeParse(prompts[0].data);
-    const prompt = typeof data?.prompt === "string" ? data.prompt.slice(0, 200) : "";
+    const prompt = typeof data?.prompt === "string" ? escapeXML(data.prompt.slice(0, 200)) : "";
     if (prompt) {
       sections.push(`  <last_request>${prompt}</last_request>`);
     }
@@ -34,7 +270,7 @@ export function buildResumeSnapshot(eventStore: EventStore, sessionId: string):
     for (const t of tasks) {
       const data = safeParse(t.data);
       const content = extractTaskContent(data);
-      if (content) sections.push(`    - ${content.slice(0, 100)}`);
+      if (content) sections.push(`    - ${escapeXML(content.slice(0, 100))}`);
     }
     sections.push("  </pending_tasks>");
   }
@@ -45,7 +281,7 @@ export function buildResumeSnapshot(eventStore: EventStore, sessionId: string):
     sections.push("  <key_decisions>");
     for (const d of decisions) {
       const data = safeParse(d.data);
-      const prompt = typeof data?.prompt === "string" ? data.prompt.slice(0, 100) : "";
+      const prompt = typeof data?.prompt === "string" ? escapeXML(data.prompt.slice(0, 100)) : "";
       if (prompt) sections.push(`    - ${prompt}`);
     }
     sections.push("  </key_decisions>");
@@ -63,7 +299,7 @@ export function buildResumeSnapshot(eventStore: EventStore, sessionId: string):
   if (modifiedPaths.size > 0) {
     sections.push("  <files_modified>");
     const paths = [...modifiedPaths].slice(0, CAPS.files);
-    for (const p of paths) sections.push(`    - ${p}`);
+    for (const p of paths) sections.push(`    - ${escapeXML(p)}`);
     sections.push("  </files_modified>");
   }
 
@@ -74,7 +310,7 @@ export function buildResumeSnapshot(eventStore: EventStore, sessionId: string):
     for (const e of errors) {
       const data = safeParse(e.data);
       const summary = formatErrorSummary(data);
-      if (summary) sections.push(`    - ${summary.slice(0, 150)}`);
+      if (summary) sections.push(`    - ${escapeXML(summary.slice(0, 150))}`);
     }
     sections.push("  </recent_errors>");
   }
@@ -85,7 +321,7 @@ export function buildResumeSnapshot(eventStore: EventStore, sessionId: string):
     sections.push("  <git_state>");
     for (const g of gitEvents) {
       const data = safeParse(g.data);
-      const cmd = typeof data?.command === "string" ? data.command.slice(0, 100) : "";
+      const cmd = typeof data?.command === "string" ? escapeXML(data.command.slice(0, 100)) : "";
       if (cmd) sections.push(`    - ${cmd}`);
     }
     sections.push("  </git_state>");

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;