lsd-pi 1.1.9 → 1.2.0

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

@@ -48,19 +48,23 @@ export default function contextCommand(pi) {
                 const descLen = t.description?.length ?? 0;
                 const schemaLen = JSON.stringify(t.parameters ?? {}).length;
                 const totalChars = nameLen + descLen + schemaLen;
+                const isActive = activeToolNames.has(t.name ?? "");
                 const tokens = Math.ceil(totalChars / 4);
                 return {
                     name: t.name ?? "(unnamed)",
+                    totalChars,
                     tokens,
                     descTokens: Math.ceil(descLen / 4),
                     schemaTokens: Math.ceil((nameLen + schemaLen) / 4),
-                    isActive: activeToolNames.has(t.name ?? ""),
+                    isActive,
                 };
             });
-            const totalSchemaBytes = allTools.reduce((sum, t) => {
-                return sum + (t.name?.length ?? 0) + (t.description?.length ?? 0) + JSON.stringify(t.parameters ?? {}).length;
-            }, 0);
-            const toolsTokens = Math.ceil(totalSchemaBytes / 4);
+            const activeSchemaBytes = toolSizes
+                .filter((t) => t.isActive)
+                .reduce((sum, t) => sum + t.totalChars, 0);
+            const registeredSchemaBytes = toolSizes.reduce((sum, t) => sum + t.totalChars, 0);
+            const activeToolsTokens = Math.ceil(activeSchemaBytes / 4);
+            const registeredToolsTokens = Math.ceil(registeredSchemaBytes / 4);
             const largestActiveTools = toolSizes
                 .filter((t) => t.isActive)
                 .sort((a, b) => b.tokens - a.tokens)
@@ -84,7 +88,7 @@ export default function contextCommand(pi) {
             const windowSize = model?.contextWindow ?? null;
             const usedTokens = contextUsage?.tokens ?? null;
             const percentUsed = contextUsage?.percent ?? null;
-            const fallbackUsedTokens = systemPromptTokens + toolsTokens + historyTokens;
+            const fallbackUsedTokens = systemPromptTokens + activeToolsTokens + historyTokens;
             const effectiveUsedTokens = usedTokens ?? fallbackUsedTokens;
             const estimatedLabel = usedTokens === null ? " (estimated)" : "";
             const freeTokens = windowSize !== null ? windowSize - effectiveUsedTokens : null;
@@ -129,8 +133,11 @@ export default function contextCommand(pi) {
             }
             lines.push("");
             lines.push(`Tools                    ${activeToolsCount} active / ${totalToolsCount} registered`);
-            lines.push(`  Total schema bytes:    ${totalSchemaBytes.toLocaleString()}`);
-            lines.push(`  Est. tokens:           ~${toolsTokens.toLocaleString()}`);
+            lines.push(`  Active schema bytes:   ${activeSchemaBytes.toLocaleString()}`);
+            lines.push(`  Est. tokens:           ~${activeToolsTokens.toLocaleString()}`);
+            if (activeToolsCount !== totalToolsCount) {
+                lines.push(`  Registered total:      ${registeredSchemaBytes.toLocaleString()} bytes · ~${registeredToolsTokens.toLocaleString()} tok`);
+            }
             if (largestActiveTools.length > 0) {
                 lines.push("  Largest active tools:");
                 for (const tool of largestActiveTools) {

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

@@ -1,9 +1,10 @@
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
-import { getAgentDir, getPermissionMode, isToolCallEventType, setPermissionMode, } from "@gsd/pi-coding-agent";
+import { getAgentDir, getPermissionMode, isToolCallEventType, setPermissionMode, SettingsManager, } from "@gsd/pi-coding-agent";
 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;
 }
@@ -133,6 +182,13 @@ function resolveModelFromContext(ctx, modelRef) {
 }
 function setPermissionModeAndEnv(mode) {
     setPermissionMode(mode);
+    try {
+        const settingsManager = SettingsManager.create();
+        settingsManager.setPermissionMode(mode);
+    }
+    catch {
+        // Best-effort persistence; if settings manager is unavailable, proceed with in-memory only
+    }
     process.env.LUCENT_CODE_PERMISSION_MODE = mode;
 }
 function saveState(pi) {
@@ -168,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";
@@ -186,6 +252,7 @@ function enablePlanMode(pi, currentModel, next = {}) {
     });
 }
 function leavePlanMode(pi, approvalStatus, nextPermissionMode, clearTask = false) {
+    reasoningModelSwitchDone = false;
     setPermissionModeAndEnv(nextPermissionMode);
     setState(pi, {
         active: false,
@@ -223,13 +290,13 @@ function buildExecutionKickoffMessage(options) {
         return details.join(" ");
     }
     const codingModel = readPlanModeCodingModel();
-    const modelInstruction = codingModel
-        ? `Set model to \"${codingModel}\" for that subagent.`
-        : "Do not pass a model override for that subagent unless needed.";
+    const codingSubagent = readPlanModeCodingSubagent() ?? DEFAULT_PLAN_CODING_AGENT;
+    const agentInvocationInstruction = codingModel
+        ? `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.",
-        "Invoke the subagent tool with agent \"generic\" to implement the plan end-to-end.",
-        modelInstruction,
+        agentInvocationInstruction,
         `Execution permission mode is now \"${permissionMode}\".`,
     ];
     if (task)
@@ -239,6 +306,25 @@ function buildExecutionKickoffMessage(options) {
     details.push("After subagent completion, summarize the result and any remaining follow-ups.");
     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) {
@@ -249,7 +335,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";
@@ -282,33 +374,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 [
+        "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 [
-        "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.",
+        "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 = [
@@ -342,7 +447,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) {
@@ -397,6 +502,9 @@ export const __testing = {
     buildApprovalSteeringMessage,
     buildPlanPreviewMessage,
     buildReviewSteeringMessage,
+    buildAutoSuggestPlanModeSystemPrompt,
+    readAutoSuggestPlanModeSetting,
+    PLAN_SUGGEST_QUESTION_ID,
 };
 export default function planCommand(pi) {
     pi.registerFlag("plan", {
@@ -406,16 +514,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");
@@ -424,7 +543,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,
@@ -486,6 +605,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;
@@ -495,24 +636,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");
@@ -520,6 +658,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,
@@ -557,15 +710,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", {
@@ -591,4 +745,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" });
+        },
+    });
 }