lsd-pi 1.1.10 → 1.2.0

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,
@@ -245,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) {
@@ -255,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";
@@ -288,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 [
-        "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 +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) {
@@ -403,6 +502,9 @@ export const __testing = {
     buildApprovalSteeringMessage,
     buildPlanPreviewMessage,
     buildReviewSteeringMessage,
+    buildAutoSuggestPlanModeSystemPrompt,
+    readAutoSuggestPlanModeSetting,
+    PLAN_SUGGEST_QUESTION_ID,
 };
 export default function planCommand(pi) {
     pi.registerFlag("plan", {
@@ -412,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");
@@ -430,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,
@@ -492,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;
@@ -501,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");
@@ -526,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,
@@ -563,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", {
@@ -597,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" });
+        },
+    });
 }

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

@@ -6,11 +6,6 @@ function getSettingsManager() {
 function isHashlineMode(activeToolNames) {
     return activeToolNames.includes("hashline_read") || activeToolNames.includes("hashline_edit");
 }
-function getCoreToolNames(activeToolNames) {
-    return isHashlineMode(activeToolNames)
-        ? ["hashline_read", "bash", "lsp", "tool_search", "tool_enable"]
-        : ["read", "bash", "lsp", "tool_search", "tool_enable"];
-}
 function getBalancedToolNames(activeToolNames) {
     return isHashlineMode(activeToolNames)
         ? [
@@ -25,6 +20,7 @@ function getBalancedToolNames(activeToolNames) {
             "Skill",
             "subagent",
             "await_subagent",
+            "ask_user_questions",
         ]
         : [
             "read",
@@ -38,8 +34,12 @@ function getBalancedToolNames(activeToolNames) {
             "Skill",
             "subagent",
             "await_subagent",
+            "ask_user_questions",
         ];
 }
+function getFullToolNames(pi) {
+    return pi.getAllTools().map((tool) => tool.name).filter((name) => Boolean(name));
+}
 function scoreTool(query, tool) {
     const name = (tool.name ?? "").toLowerCase();
     const description = (tool.description ?? "").toLowerCase();
@@ -153,43 +153,30 @@ export default function toolSearchExtension(pi) {
         },
     });
     pi.registerCommand("tools", {
-        description: "Toggle lazy tool-search mode",
+        description: "Manage default tool profiles",
         handler: async (args, _ctx) => {
             const input = args.trim();
             const settings = getSettingsManager();
             const currentActive = pi.getActiveTools();
             const toolProfile = settings.getToolProfile();
-            const toolSearchEnabled = toolProfile === "minimal";
             if (!input) {
                 pi.sendMessage({
                     customType: "tools:status",
                     content: [
                         `Tool profile: ${toolProfile}`,
-                        `Tool search mode: ${toolSearchEnabled ? "on" : "off"}`,
                         `Active tools: ${currentActive.length}`,
                         currentActive.length > 0 ? currentActive.join(", ") : "(none)",
                         "",
                         "Usage:",
-                        "  /tools on         Enable lazy tool-search mode and switch to a small core tool set",
-                        "  /tools off        Disable lazy tool-search mode and restore the balanced tool profile",
                         "  /tools balanced   Switch to the balanced tool profile",
-                        "  /tools minimal    Switch to the minimal core tool profile",
+                        "  /tools full       Switch to the full tool profile (all available tools)",
+                        "  /tools on         Alias for /tools full",
+                        "  /tools off        Alias for /tools balanced",
                     ].join("\n"),
                     display: true,
                 });
                 return;
             }
-            if (["on", "enable", "mode on"].includes(input)) {
-                settings.setToolProfile("minimal");
-                const nextActive = getCoreToolNames(currentActive);
-                pi.setActiveTools(nextActive);
-                pi.sendMessage({
-                    customType: "tools:mode",
-                    content: `Tool search mode enabled. Active tools reduced to: ${pi.getActiveTools().join(", ")}`,
-                    display: true,
-                });
-                return;
-            }
             if (["off", "disable", "mode off", "balanced", "default"].includes(input)) {
                 settings.setToolProfile("balanced");
                 const nextActive = getBalancedToolNames(currentActive);
@@ -201,20 +188,20 @@ export default function toolSearchExtension(pi) {
                 });
                 return;
             }
-            if (["minimal", "core"].includes(input)) {
-                settings.setToolProfile("minimal");
-                const nextActive = getCoreToolNames(currentActive);
+            if (["on", "enable", "mode on", "full", "all"].includes(input)) {
+                settings.setToolProfile("full");
+                const nextActive = getFullToolNames(pi);
                 pi.setActiveTools(nextActive);
                 pi.sendMessage({
                     customType: "tools:mode",
-                    content: `Minimal tool profile active: ${pi.getActiveTools().join(", ")}`,
+                    content: `Full tool profile active: ${pi.getActiveTools().join(", ")}`,
                     display: true,
                 });
                 return;
             }
             pi.sendMessage({
                 customType: "tools:help",
-                content: `Unknown /tools subcommand: ${input}\n\nTry /tools, /tools on, /tools off, /tools balanced, or /tools minimal.`,
+                content: `Unknown /tools subcommand: ${input}\n\nTry /tools, /tools balanced, /tools full, /tools on, or /tools off.`,
                 display: true,
             });
         },