lsd-pi 1.1.10 → 1.2.1

package/dist/onboarding.js

@@ -296,7 +296,7 @@ export async function runOnboarding(authStorage, settingsManager) {
         summaryLines.push(`${pc.green('✓')} Budget subagent model: ${budgetModel}`);
     }
     else {
-        summaryLines.push(`${pc.dim('↷')} Budget subagent model: app default/current model`);
+        summaryLines.push(`${pc.dim('↷')} Budget subagent model: app default/current model — set one to keep scout reconnaissance cheap`);
     }
     if (lspInstalled === null) {
         summaryLines.push(`${pc.dim('↷')} Language servers: skipped — run /setup to install later`);
@@ -345,9 +345,9 @@ async function runBudgetModelStep(p, pc, settingsManager) {
     if (existing) {
         options.push({ value: 'keep', label: `Keep current (${existing})`, hint: 'already configured' });
     }
-    options.push({ value: 'default', label: 'Use current/default model', hint: 'scout falls back when no budget model is set' }, ...BUDGET_MODEL_OPTIONS, { value: 'skip', label: 'Skip for now', hint: 'change later in /settings' });
+    options.push({ value: 'default', label: 'Use current/default model', hint: 'works, but setting a cheap scout model keeps reconnaissance predictable' }, ...BUDGET_MODEL_OPTIONS, { value: 'skip', label: 'Skip for now', hint: 'change later in /settings' });
     const choice = await p.select({
-        message: 'Choose a budget model for cheap subagents like scout',
+        message: 'Choose a budget model for cheap scout / recon subagents',
         options,
     });
     if (p.isCancel(choice) || choice === 'skip') {

package/dist/resources/agents/scout.md

@@ -9,6 +9,12 @@ You are a scout. Quickly investigate a codebase and return structured findings t
 
 Your output will be passed to an agent who has NOT seen the files you explored.
 
+Scope boundary:
+- Scout is for reconnaissance and mapping only.
+- Do **not** perform full code review, security audit, bug triage, ranking of issues, or final recommendations as if you were the reviewer.
+- If the task asks for review/audit findings, narrow your work to reconnaissance support: identify likely hotspots, relevant files, and questions/risks for a later reviewer.
+- Do not present "top issues" as final judgments; present them as areas worth deeper review.
+
 Thoroughness (infer from task, default medium):
 
 - Quick: Targeted lookups, key files only

package/dist/resources/extensions/slash-commands/index.js

@@ -1,12 +1,14 @@
 import auditCommand from "./audit.js";
 import clearCommand from "./clear.js";
 import contextCommand from "./context.js";
+import initCommand from "./init.js";
 import planCommand from "./plan.js";
 import toolSearchExtension from "./tools.js";
 export default function slashCommands(pi) {
     auditCommand(pi);
     clearCommand(pi);
     contextCommand(pi);
+    initCommand(pi);
     planCommand(pi);
     toolSearchExtension(pi);
 }

package/dist/resources/extensions/slash-commands/init.js

@@ -0,0 +1,47 @@
+import { getAgentDir } from "@gsd/pi-coding-agent";
+import { existsSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+const STARTER_CONTENT = `# Project Context
+
+## Overview
+- Add a short description of this project and its purpose.
+
+## Commands
+- Build:
+- Test:
+- Lint:
+
+## Conventions
+- Add coding conventions, architecture notes, and review expectations.
+`;
+function ensureFile(filePath) {
+    if (existsSync(filePath)) {
+        return "exists";
+    }
+    writeFileSync(filePath, STARTER_CONTENT, "utf-8");
+    return "created";
+}
+export default function initCommand(pi) {
+    pi.registerCommand("init", {
+        description: "Initialize global and project LSD.md files if they do not exist",
+        async handler(_args, ctx) {
+            const globalPath = resolve(getAgentDir(), "..", "LSD.md");
+            const projectPath = join(ctx.cwd, "LSD.md");
+            const globalStatus = ensureFile(globalPath);
+            const projectStatus = ensureFile(projectPath);
+            await ctx.reload();
+            const lines = ["Initialized LSD.md files", ""];
+            lines.push(`Global:  ${globalStatus === "created" ? "created" : "exists"}  ${globalPath}`);
+            lines.push(`Project: ${projectStatus === "created" ? "created" : "exists"}  ${projectPath}`);
+            if (globalStatus === "exists" && projectStatus === "exists") {
+                lines.push("");
+                lines.push("Nothing changed.");
+            }
+            pi.sendMessage({
+                customType: "init:report",
+                content: lines.join("\n"),
+                display: true,
+            });
+        },
+    });
+}

package/dist/resources/extensions/slash-commands/plan.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 const PLAN_ENTRY_TYPE = "plan-mode-state";
 const PLAN_APPROVAL_ACTION_QUESTION_ID = "plan_mode_approval_action";
 const PLAN_APPROVAL_PERMISSION_QUESTION_ID = "plan_mode_approval_permission";
+const PLAN_SUGGEST_QUESTION_ID = "plan_mode_suggest_switch";
 const PLAN_DIR_RE = /(^|[/\\])\.(?:lsd|gsd)[/\\]plan([/\\]|$)/;
 const BASH_READ_ONLY_RE = /^\s*(cat|head|tail|less|more|wc|file|stat|du|df|which|type|echo|printf|ls|find|grep|rg|awk|sed\b(?!.*-i)|sort|uniq|diff|comm|tr|cut|tee\s+-a\s+\/dev\/null|git\s+(log|show|diff|status|branch|tag|remote|rev-parse|ls-files|blame|shortlog|describe|stash\s+list|config\s+--get|cat-file)|gh\s+(issue|pr|api|repo|release)\s+(view|list|diff|status|checks)|mkdir\s+-p\s+\.(?:lsd|gsd)(?:[\\/]+plan)?|rtk\s)/;
 const SAFE_TOOLS = new Set([
@@ -63,10 +64,12 @@ const APPROVE_AUTO_LABEL = "Auto mode";
 const APPROVE_BYPASS_LABEL = "Bypass mode";
 const APPROVE_AUTO_SUBAGENT_LABEL = "Execute with subagent in auto mode";
 const APPROVE_BYPASS_SUBAGENT_LABEL = "Execute with subagent in bypass mode";
+const APPROVE_NEW_SESSION_LABEL = "New session with coding model"; // shown in second question when autoSwitchPlanModel is on
 const REVIEW_LABEL = "Let other agent review";
 const REVISE_LABEL = "Revise plan";
 const CANCEL_LABEL = "Cancel";
 const DEFAULT_PLAN_REVIEW_AGENT = "generic";
+const DEFAULT_PLAN_CODING_AGENT = "worker";
 const INITIAL_STATE = {
     active: false,
     task: "",
@@ -78,6 +81,7 @@ const INITIAL_STATE = {
 };
 let state = { ...INITIAL_STATE };
 let startedFromFlag = false;
+let reasoningModelSwitchDone = false;
 function isPlanModeActive() {
     return getPermissionMode() === "plan";
 }
@@ -95,6 +99,12 @@ function parseQualifiedModelRef(value) {
         return undefined;
     return { provider, id };
 }
+function parseSubagentName(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
 function readPlanModeSettings() {
     try {
         const settingsPath = join(getAgentDir(), "settings.json");
@@ -105,10 +115,13 @@ function readPlanModeSettings() {
         const reasoningModel = parseQualifiedModelRef(parsed.planModeReasoningModel);
         const reviewModel = parseQualifiedModelRef(parsed.planModeReviewModel);
         const codingModel = parseQualifiedModelRef(parsed.planModeCodingModel);
+        const codingSubagent = parseSubagentName(parsed.planModeCodingSubagent)
+            ?? parseSubagentName(parsed.planModeCodingAgent);
         return {
             reasoningModel: reasoningModel ? `${reasoningModel.provider}/${reasoningModel.id}` : undefined,
             reviewModel: reviewModel ? `${reviewModel.provider}/${reviewModel.id}` : undefined,
             codingModel: codingModel ? `${codingModel.provider}/${codingModel.id}` : undefined,
+            codingSubagent,
         };
     }
     catch {
@@ -124,6 +137,42 @@ export function readPlanModeReviewModel() {
 export function readPlanModeCodingModel() {
     return readPlanModeSettings().codingModel;
 }
+export function readPlanModeCodingSubagent() {
+    return readPlanModeSettings().codingSubagent;
+}
+function readAutoSuggestPlanModeSetting() {
+    try {
+        const settingsPath = join(getAgentDir(), "settings.json");
+        if (!existsSync(settingsPath))
+            return false;
+        const raw = readFileSync(settingsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed.autoSuggestPlanMode === true;
+    }
+    catch {
+        return false;
+    }
+}
+function readAutoSwitchPlanModelSetting() {
+    try {
+        const settingsPath = join(getAgentDir(), "settings.json");
+        if (!existsSync(settingsPath))
+            return false;
+        const raw = readFileSync(settingsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed.autoSwitchPlanModel === true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildAutoSuggestPlanModeSystemPrompt() {
+    return [
+        `Plan-mode suggestion: if the user's latest request describes a large, multi-step, or ambiguous task — e.g. a refactor, multi-file change, new feature, migration, or anything that benefits from upfront investigation — proactively ask whether to switch to plan mode before making any edits.`,
+        `How to suggest: call ask_user_questions with a single question. Set the question id to exactly "${PLAN_SUGGEST_QUESTION_ID}". Ask: "This looks like a complex task. Would you like to switch to plan mode first?". Provide exactly two options: "Yes, switch to plan mode" (recommended) and "No, proceed directly". Do NOT call /plan yourself — wait for the user answer and the system will handle switching automatically.`,
+        "Do not suggest plan mode for simple, single-file, or read-only tasks. Do not suggest it if the user is already in plan mode or in the middle of an implementation. Only suggest it once per distinct task.",
+    ].join(" ");
+}
 function sameModel(left, right) {
     return !!left && !!right && left.provider === right.provider && left.id === right.id;
 }
@@ -175,6 +224,16 @@ function restoreStateFromSession(ctx) {
         // Best-effort restore only.
     }
 }
+async function enablePlanModeWithModelSwitch(pi, ctx, currentModel, next = {}) {
+    enablePlanMode(pi, currentModel, next);
+    // Signal that before_agent_start should switch to the reasoning model on next turn
+    reasoningModelSwitchDone = false;
+    if (!readAutoSwitchPlanModelSetting())
+        return;
+    if (!readPlanModeReasoningModel()) {
+        ctx.ui?.notify?.("OpusPlan: set a Plan reasoning model in /settings to auto-switch on entry", "info");
+    }
+}
 function enablePlanMode(pi, currentModel, next = {}) {
     const currentMode = getPermissionMode();
     const enteringPlanMode = currentMode !== "plan";
@@ -193,6 +252,7 @@ function enablePlanMode(pi, currentModel, next = {}) {
     });
 }
 function leavePlanMode(pi, approvalStatus, nextPermissionMode, clearTask = false) {
+    reasoningModelSwitchDone = false;
     setPermissionModeAndEnv(nextPermissionMode);
     setState(pi, {
         active: false,
@@ -230,9 +290,10 @@ function buildExecutionKickoffMessage(options) {
         return details.join(" ");
     }
     const codingModel = readPlanModeCodingModel();
+    const codingSubagent = readPlanModeCodingSubagent() ?? DEFAULT_PLAN_CODING_AGENT;
     const agentInvocationInstruction = codingModel
-        ? `Invoke the subagent tool with agent "worker" and model="${codingModel}" to implement the plan end-to-end.`
-        : `Invoke the subagent tool with agent "worker" to implement the plan end-to-end.`;
+        ? `Invoke the subagent tool with exact parameters agent "${codingSubagent}" and model="${codingModel}" to implement the plan end-to-end.`
+        : `Invoke the subagent tool with exact parameter agent "${codingSubagent}" to implement the plan end-to-end.`;
     const details = [
         "Plan approved. Exit plan mode and execute the approved plan with a subagent now.",
         agentInvocationInstruction,
@@ -242,9 +303,34 @@ function buildExecutionKickoffMessage(options) {
         details.push(`Original task: ${task}`);
     if (state.latestPlanPath)
         details.push(`Primary plan artifact: ${state.latestPlanPath}`);
-    details.push("After subagent completion, summarize the result and any remaining follow-ups.");
+    details.push("Important: if the plan is large and you estimate it would exceed a single subagent's context window (~200k tokens), " +
+        "split execution across multiple sequential subagents instead of one. " +
+        "Use the subagent tool's chain mode: pass a \"chain\" array where each entry covers one self-contained phase or group of steps from the plan. " +
+        "Each chain entry should include the agent name, a focused task description for that phase, and may reference {previous} to receive the prior phase's output as handoff context. " +
+        "Only split when genuinely needed — prefer a single subagent for plans that fit comfortably.");
+    details.push("After all subagents complete: (1) do a quick review of the implementation — check that the plan steps were actually carried out, spot obvious issues or missed pieces, and verify the code compiles/passes lint if applicable. " +
+        "(2) Then summarize what was done, what (if anything) needs follow-up, and flag any concerns found during review.");
     return details.join(" ");
 }
+let pendingNewSession = null;
+function scheduleNewSession(pi, ctx) {
+    const codingModelRef = parseQualifiedModelRef(readPlanModeCodingModel());
+    const codingSubagent = readPlanModeCodingSubagent() ?? DEFAULT_PLAN_CODING_AGENT;
+    const planPath = state.latestPlanPath;
+    const planContent = planPath ? readPlanArtifact(planPath) : undefined;
+    pendingNewSession = {
+        codingModelRef,
+        codingSubagent,
+        planPath,
+        planContent,
+        task: state.task,
+    };
+    leavePlanMode(pi, "approved", "auto");
+    ctx.ui?.notify?.("Plan approved. Starting new session…", "info");
+    // Trigger the internal command which has ExtensionCommandContext (ctx.newSession available).
+    // Must use the /prefix so tryExecuteExtensionCommand parses the name correctly.
+    pi.executeSlashCommand("/plan-execute-new-session");
+}
 async function approvePlan(pi, ctx, permissionMode, executeWithSubagent = false) {
     const reasoningModel = parseQualifiedModelRef(readPlanModeReasoningModel());
     if (reasoningModel) {
@@ -255,7 +341,13 @@ async function approvePlan(pi, ctx, permissionMode, executeWithSubagent = false)
         targetPermissionMode: permissionMode,
     };
     leavePlanMode(pi, "approved", permissionMode);
-    await pi.sendUserMessage(buildExecutionKickoffMessage({ permissionMode, executeWithSubagent }), { deliverAs: "followUp" });
+    // Deliver the kickoff as a steering message so it is injected BEFORE the LLM
+    // produces its next assistant turn. Using "followUp" would defer delivery
+    // until the agent has no more tool calls, which lets the LLM call the
+    // subagent tool with the default session model BEFORE it ever sees the
+    // explicit model="<planModeCodingModel>" instruction. Steering ensures the
+    // configured plan-mode coding model reaches the subagent invocation.
+    await pi.sendUserMessage(buildExecutionKickoffMessage({ permissionMode, executeWithSubagent }), { deliverAs: "steer" });
 }
 async function cancelPlan(pi, ctx, clearTask = true) {
     const restoreMode = state.previousMode ?? "accept-on-edit";
@@ -288,33 +380,46 @@ function readPlanArtifact(planPath) {
         return undefined;
     }
 }
-function buildApprovalDialogInstructions() {
+function buildNewSessionOptionLabel() {
+    const codingModel = readPlanModeCodingModel();
+    const codingSubagent = readPlanModeCodingSubagent() ?? DEFAULT_PLAN_CODING_AGENT;
+    const modelSuffix = codingModel ? codingModel.split("/")[1] ?? codingModel : null;
+    // e.g. "Approve plan — new session (worker · claude-sonnet-4-6)"
+    //      "Approve plan — new session (worker)"
+    const suffix = modelSuffix ? `${codingSubagent} · ${modelSuffix}` : codingSubagent;
+    return `${APPROVE_LABEL} — ${APPROVE_NEW_SESSION_LABEL} (${suffix})`;
+}
+function buildApprovalActionInstructions() {
     return [
-        "Present approval options now using ask_user_questions with exactly two single-select questions.",
-        `First question id: \"${PLAN_APPROVAL_ACTION_QUESTION_ID}\". Ask what to do next with the plan.`,
-        "Use exactly these 3 options for the first question:",
-        `1. ${APPROVE_LABEL} (Recommended)`,
-        `2. ${REVIEW_LABEL}`,
-        `3. ${REVISE_LABEL}`,
-        `Second question id: \"${PLAN_APPROVAL_PERMISSION_QUESTION_ID}\". Ask which execution mode to use if the plan is approved.`,
-        "Use exactly these 4 options for the second question:",
-        `1. ${APPROVE_AUTO_LABEL} (Recommended)`,
-        `2. ${APPROVE_BYPASS_LABEL}`,
-        `3. ${APPROVE_AUTO_SUBAGENT_LABEL}`,
-        `4. ${APPROVE_BYPASS_SUBAGENT_LABEL}`,
-        `Do not include \"${CANCEL_LABEL}\" as an explicit option. If the user wants to cancel, they should choose \"None of the above\" on the first question and type \"${CANCEL_LABEL}\" in the free-text note.`,
-        `If the user selects \"${REVIEW_LABEL}\" or \"${REVISE_LABEL}\", ignore the second answer for now.`,
-        "If the dialog is dismissed or the user gives no answer, continue planning.",
+        "Ask for plan approval now using ask_user_questions.",
+        `One single-select question with id \"${PLAN_APPROVAL_ACTION_QUESTION_ID}\". Ask what to do next with the plan.`,
+        `Options: ${APPROVE_LABEL}, ${REVIEW_LABEL}, ${REVISE_LABEL}.`,
+        `Do not include \"${CANCEL_LABEL}\" as an explicit option — if the user wants to cancel they should choose \"None of the above\" and type \"${CANCEL_LABEL}\" in the note.`,
+        "Do not restate the plan. Just show the question.",
     ].join(" ");
 }
+function buildApprovalModeInstructions() {
+    const autoSwitchEnabled = readAutoSwitchPlanModelSetting();
+    const showNewSessionOption = autoSwitchEnabled;
+    const newSessionLabel = buildNewSessionOptionLabel();
+    const options = showNewSessionOption
+        ? `${APPROVE_AUTO_LABEL}, ${APPROVE_BYPASS_LABEL}, ${APPROVE_AUTO_SUBAGENT_LABEL}, ${APPROVE_BYPASS_SUBAGENT_LABEL}, ${newSessionLabel}`
+        : `${APPROVE_AUTO_LABEL}, ${APPROVE_BYPASS_LABEL}, ${APPROVE_AUTO_SUBAGENT_LABEL}, ${APPROVE_BYPASS_SUBAGENT_LABEL}`;
+    return [
+        "Plan approved. Now ask which execution mode to use via ask_user_questions.",
+        `One single-select question with id \"${PLAN_APPROVAL_PERMISSION_QUESTION_ID}\".`,
+        `Options: ${options}.`,
+    ].join(" ");
+}
+// Keep for external callers that reference the combined form (headless path)
+function buildApprovalDialogInstructions() {
+    return buildApprovalActionInstructions();
+}
 function buildApprovalSteeringMessage(planPath) {
-    const details = [
+    return [
         `Plan artifact saved at ${planPath}.`,
-        "Do not restate the plan in a normal assistant response.",
-        "Ask for approval now via ask_user_questions.",
-        buildApprovalDialogInstructions(),
-    ];
-    return details.join("\n\n");
+        buildApprovalActionInstructions(),
+    ].join("\n\n");
 }
 function buildPlanPreviewMessage(planPath, planMarkdown) {
     const details = [
@@ -348,7 +453,7 @@ function buildReviewSteeringMessage(planPath, planMarkdown) {
     else {
         details.push(`Have the subagent read ${planPath} before reviewing it.`);
     }
-    details.push("After the subagent responds, summarize its feedback for the user, present the current plan again, and then ask for approval again.", buildApprovalDialogInstructions());
+    details.push("After the subagent responds, summarize its feedback for the user, present the current plan again, and then ask for approval again.", buildApprovalActionInstructions());
     return details.join("\n\n");
 }
 function approvalSelectionToExecutionMode(selected) {
@@ -403,6 +508,9 @@ export const __testing = {
     buildApprovalSteeringMessage,
     buildPlanPreviewMessage,
     buildReviewSteeringMessage,
+    buildAutoSuggestPlanModeSystemPrompt,
+    readAutoSuggestPlanModeSetting,
+    PLAN_SUGGEST_QUESTION_ID,
 };
 export default function planCommand(pi) {
     pi.registerFlag("plan", {
@@ -412,16 +520,27 @@ export default function planCommand(pi) {
     pi.on("session_start", async (_event, ctx) => {
         restoreStateFromSession(ctx);
         startedFromFlag = false;
+        reasoningModelSwitchDone = false;
         if (state.active) {
             setPermissionModeAndEnv("plan");
         }
     });
-    pi.on("before_agent_start", async () => {
-        if (!isPlanModeActive())
-            return;
-        return {
-            systemPrompt: buildPlanModeSystemPrompt(),
-        };
+    pi.on("before_agent_start", async (_event, ctx) => {
+        if (isPlanModeActive()) {
+            // Switch to reasoning model once per plan mode activation
+            if (!reasoningModelSwitchDone && readAutoSwitchPlanModelSetting()) {
+                const reasoningModel = parseQualifiedModelRef(readPlanModeReasoningModel());
+                if (reasoningModel) {
+                    reasoningModelSwitchDone = true;
+                    await setModelIfNeeded(pi, ctx, reasoningModel);
+                }
+            }
+            return { systemPrompt: buildPlanModeSystemPrompt() };
+        }
+        if (readAutoSuggestPlanModeSetting()) {
+            return { systemPrompt: buildAutoSuggestPlanModeSystemPrompt() };
+        }
+        return;
     });
     pi.on("input", async (event, ctx) => {
         const planFlag = pi.getFlag("plan");
@@ -430,7 +549,7 @@ export default function planCommand(pi) {
         }
         startedFromFlag = true;
         ensurePlanDir();
-        enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
+        await enablePlanModeWithModelSwitch(pi, ctx, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
             task: event.text.trim(),
             approvalStatus: "pending",
             latestPlanPath: undefined,
@@ -492,6 +611,28 @@ export default function planCommand(pi) {
             }
             return;
         }
+        if (event.toolName === "ask_user_questions" && !isPlanModeActive()) {
+            const details = event.details;
+            if (!details?.cancelled && details?.response?.answers) {
+                const suggestAnswer = details.response.answers[PLAN_SUGGEST_QUESTION_ID];
+                if (suggestAnswer) {
+                    const selected = Array.isArray(suggestAnswer.selected) ? suggestAnswer.selected[0] : suggestAnswer.selected;
+                    if (typeof selected === "string" && selected.toLowerCase().includes("yes")) {
+                        ensurePlanDir();
+                        await enablePlanModeWithModelSwitch(pi, ctx, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
+                            task: state.task,
+                            latestPlanPath: undefined,
+                            approvalStatus: "pending",
+                            targetPermissionMode: undefined,
+                        });
+                        ctx.ui?.notify?.("Plan mode enabled. Investigate and produce a plan before making changes.", "info");
+                        pi.sendUserMessage("The user confirmed switching to plan mode. You are now in plan mode. Investigate the task and produce a persisted execution plan under .lsd/plan/ before making any source changes.", { deliverAs: "steer" });
+                    }
+                    return;
+                }
+            }
+            return;
+        }
         if (!isPlanModeActive() || event.toolName !== "ask_user_questions")
             return;
         const details = event.details;
@@ -501,24 +642,21 @@ export default function planCommand(pi) {
         const permissionAnswer = details.response.answers[PLAN_APPROVAL_PERMISSION_QUESTION_ID];
         const actionValues = getAnswerValues(actionAnswer);
         const permissionValues = getAnswerValues(permissionAnswer);
-        if (actionValues.length === 0 && permissionValues.length === 0)
-            return;
-        if (selectionRequestsCancel([...actionValues, ...permissionValues])) {
-            await cancelPlan(pi, ctx, true);
-            return;
-        }
-        const actionSelection = actionValues[0];
-        if (!actionSelection)
-            return;
-        if (actionSelection.includes(APPROVE_LABEL)) {
+        // ── Second question answered (execution mode) ─────────────────────────
+        if (permissionValues.length > 0) {
+            if (selectionRequestsCancel(permissionValues)) {
+                await cancelPlan(pi, ctx, true);
+                return;
+            }
+            if (permissionValues[0]?.includes(APPROVE_NEW_SESSION_LABEL)) {
+                scheduleNewSession(pi, ctx);
+                return;
+            }
             const executionMode = approvalSelectionToExecutionMode(permissionValues[0]) ?? {
                 permissionMode: DEFAULT_APPROVAL_PERMISSION_MODE,
                 executeWithSubagent: false,
             };
-            state = {
-                ...state,
-                targetPermissionMode: executionMode.permissionMode,
-            };
+            state = { ...state, targetPermissionMode: executionMode.permissionMode };
             if (executionMode.executeWithSubagent) {
                 const modeLabel = executionMode.permissionMode === "danger-full-access" ? "bypass" : "auto";
                 ctx.ui?.notify?.(`Plan approved: subagent(${modeLabel})`, "info");
@@ -526,6 +664,21 @@ export default function planCommand(pi) {
             await approvePlan(pi, ctx, executionMode.permissionMode, executionMode.executeWithSubagent);
             return;
         }
+        // ── First question answered (action) ──────────────────────────────────
+        if (actionValues.length === 0)
+            return;
+        if (selectionRequestsCancel(actionValues)) {
+            await cancelPlan(pi, ctx, true);
+            return;
+        }
+        const actionSelection = actionValues[0];
+        if (!actionSelection)
+            return;
+        if (actionSelection.includes(APPROVE_LABEL)) {
+            // Steer the second question — handle in the next tool_result cycle
+            pi.sendUserMessage(buildApprovalModeInstructions(), { deliverAs: "steer" });
+            return;
+        }
         if (actionSelection.includes(REVIEW_LABEL)) {
             setState(pi, {
                 ...state,
@@ -563,15 +716,16 @@ export default function planCommand(pi) {
             }
             ensurePlanDir();
             const task = args.trim();
-            enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
+            await enablePlanModeWithModelSwitch(pi, ctx, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
                 task,
                 latestPlanPath: undefined,
                 approvalStatus: "pending",
                 targetPermissionMode: undefined,
             });
+            const reasoningModel = readAutoSwitchPlanModelSetting() ? readPlanModeReasoningModel() : undefined;
             ctx.ui.notify(task
-                ? `Plan mode enabled. Current task: ${task}`
-                : "Plan mode enabled. Investigation is allowed; source changes stay blocked until you exit plan mode.", "info");
+                ? `Plan mode enabled${reasoningModel ? ` · ${reasoningModel.split("/")[1] ?? reasoningModel}` : ""}. Current task: ${task}`
+                : `Plan mode enabled${reasoningModel ? ` · ${reasoningModel.split("/")[1] ?? reasoningModel}` : ""}. Investigation is allowed; source changes stay blocked until you exit plan mode.`, "info");
         },
     });
     pi.registerCommand("execute", {
@@ -597,4 +751,37 @@ export default function planCommand(pi) {
             ctx.ui.notify("Plan mode cancelled.", "info");
         },
     });
+    // Internal command — called by scheduleNewSession() via pi.executeSlashCommand().
+    // Runs in ExtensionCommandContext so ctx.newSession() is available.
+    pi.registerCommand("plan-execute-new-session", {
+        description: "Internal: execute approved plan in a new session with the coding model",
+        async handler(_args, ctx) {
+            const payload = pendingNewSession;
+            pendingNewSession = null;
+            if (!payload)
+                return;
+            // Switch to coding model first
+            if (payload.codingModelRef) {
+                await setModelIfNeeded(pi, ctx, payload.codingModelRef);
+            }
+            const result = await ctx.newSession();
+            if (result.cancelled)
+                return;
+            // Inject plan into the new session as a steer message
+            const parts = [
+                `Plan approved. You are acting as the ${payload.codingSubagent} agent. Implement the following plan now without re-investigating or re-planning.`,
+            ];
+            if (payload.task)
+                parts.push(`Original task: ${payload.task}`);
+            if (payload.planPath)
+                parts.push(`Plan artifact: ${payload.planPath}`);
+            if (payload.planContent) {
+                parts.push(`Full plan:\n\`\`\`markdown\n${payload.planContent}\n\`\`\``);
+            }
+            else if (payload.planPath) {
+                parts.push(`Read the plan from ${payload.planPath} before starting.`);
+            }
+            pi.sendUserMessage(parts.join("\n\n"), { deliverAs: "steer" });
+        },
+    });
 }