lsd-pi 1.2.4 → 1.3.6

package/dist/resources/extensions/shared/interview-ui.js

@@ -29,9 +29,23 @@ import { makeUI, INDENT } from "./ui.js";
 // ─── Constants ────────────────────────────────────────────────────────────────
 const OTHER_OPTION_LABEL = "None of the above";
 const OTHER_OPTION_DESCRIPTION = "Select to type your own answer.";
+function matchesShowWhen(question, answers) {
+    if (!question.showWhen)
+        return true;
+    const controlling = answers[question.showWhen.questionId];
+    if (!controlling)
+        return false;
+    const selected = Array.isArray(controlling.selected)
+        ? controlling.selected
+        : [controlling.selected];
+    return selected.some((value) => question.showWhen?.selectedAnyOf.includes(value));
+}
 async function runSequentialInterviewFallback(questions, ctx) {
     const answers = {};
     for (const q of questions) {
+        if (!matchesShowWhen(q, answers)) {
+            continue;
+        }
         const options = q.options.map((o) => o.label);
         if (!q.allowMultiple) {
             options.push(OTHER_OPTION_LABEL);
@@ -147,7 +161,6 @@ export async function showInterviewRound(questions, opts, ctx) {
             notes: "",
             notesVisible: false,
         }));
-        const isMultiQuestion = questions.length > 1;
         let currentIdx = 0;
         let focusNotes = false;
         let showingReview = false;
@@ -181,13 +194,65 @@ export async function showInterviewRound(questions, opts, ctx) {
         function loadStateToEditor() {
             getEditor().setText(states[currentIdx].notes);
         }
+        function selectedLabelsForIndex(idx) {
+            if (isMultiSelect(idx)) {
+                return Array.from(states[idx].checkedIndices).sort((a, b) => a - b).map((optionIdx) => questions[idx].options[optionIdx]?.label).filter((v) => !!v);
+            }
+            const committed = states[idx].committedIndex;
+            if (committed === null)
+                return [];
+            if (committed < questions[idx].options.length)
+                return [questions[idx].options[committed]?.label].filter((v) => !!v);
+            if (committed === noneOrDoneIdx(idx))
+                return [OTHER_OPTION_LABEL];
+            return [];
+        }
+        function visibleQuestionIndices() {
+            const visible = [];
+            for (let i = 0; i < questions.length; i++) {
+                const q = questions[i];
+                if (!q.showWhen) {
+                    visible.push(i);
+                    continue;
+                }
+                const controllingIdx = questions.findIndex((candidate) => candidate.id === q.showWhen?.questionId);
+                if (controllingIdx < 0 || !visible.includes(controllingIdx))
+                    continue;
+                const selected = selectedLabelsForIndex(controllingIdx);
+                if (selected.some((label) => q.showWhen?.selectedAnyOf.includes(label))) {
+                    visible.push(i);
+                }
+            }
+            return visible;
+        }
         function isQuestionAnswered(idx) {
             if (isMultiSelect(idx))
                 return states[idx].checkedIndices.size > 0;
             return states[idx].committedIndex !== null;
         }
         function allAnswered() {
-            return questions.every((_, i) => isQuestionAnswered(i));
+            const visible = visibleQuestionIndices();
+            return visible.length > 0 && visible.every((i) => isQuestionAnswered(i));
+        }
+        function clearQuestionState(idx) {
+            states[idx].cursorIndex = 0;
+            states[idx].committedIndex = null;
+            states[idx].checkedIndices.clear();
+            states[idx].notes = "";
+            states[idx].notesVisible = false;
+        }
+        function reconcileVisibility() {
+            const visible = new Set(visibleQuestionIndices());
+            for (let i = 0; i < questions.length; i++) {
+                if (!visible.has(i))
+                    clearQuestionState(i);
+            }
+            if (!visible.has(currentIdx)) {
+                const fallback = visibleQuestionIndices()[0] ?? 0;
+                currentIdx = fallback;
+                loadStateToEditor();
+                focusNotes = false;
+            }
         }
         function switchQuestion(newIdx) {
             if (newIdx === currentIdx)
@@ -200,7 +265,10 @@ export async function showInterviewRound(questions, opts, ctx) {
         }
         function buildResult() {
             const answers = {};
+            const visible = new Set(visibleQuestionIndices());
             for (let i = 0; i < questions.length; i++) {
+                if (!visible.has(i))
+                    continue;
                 const q = questions[i];
                 const st = states[i];
                 const notes = st.notes.trim();
@@ -234,6 +302,7 @@ export async function showInterviewRound(questions, opts, ctx) {
             if (!isMultiSelect(currentIdx)) {
                 states[currentIdx].committedIndex = states[currentIdx].cursorIndex;
             }
+            reconcileVisibility();
             // Auto-open the notes field when "None of the above" is selected
             // so the user can immediately provide a free-text explanation
             // instead of being trapped in a re-asking loop (bug #2715).
@@ -245,10 +314,13 @@ export async function showInterviewRound(questions, opts, ctx) {
                 refresh();
                 return;
             }
-            if (isMultiQuestion && currentIdx < questions.length - 1) {
-                let next = currentIdx + 1;
-                for (let i = 0; i < questions.length; i++) {
-                    const candidate = (currentIdx + 1 + i) % questions.length;
+            const visible = visibleQuestionIndices();
+            const currentVisiblePos = visible.indexOf(currentIdx);
+            const isMultiQuestion = visible.length > 1;
+            if (isMultiQuestion && currentVisiblePos >= 0 && currentVisiblePos < visible.length - 1) {
+                let next = visible[currentVisiblePos + 1] ?? visible[0] ?? currentIdx;
+                for (let i = 0; i < visible.length; i++) {
+                    const candidate = visible[(currentVisiblePos + 1 + i) % visible.length] ?? currentIdx;
                     if (!isQuestionAnswered(candidate)) {
                         next = candidate;
                         break;
@@ -306,7 +378,8 @@ export async function showInterviewRound(questions, opts, ctx) {
             if (showingReview) {
                 if (matchesKey(data, Key.escape) || matchesKey(data, Key.left)) {
                     showingReview = false;
-                    switchQuestion(questions.length - 1);
+                    const visible = visibleQuestionIndices();
+                    switchQuestion(visible[visible.length - 1] ?? 0);
                     return;
                 }
                 if (matchesKey(data, Key.enter) || matchesKey(data, Key.right) || matchesKey(data, Key.space)) {
@@ -355,14 +428,19 @@ export async function showInterviewRound(questions, opts, ctx) {
                 return;
             }
             // ── Multi-question navigation ────────────────────────────────
+            const visible = visibleQuestionIndices();
+            const isMultiQuestion = visible.length > 1;
             if (isMultiQuestion) {
-                if (matchesKey(data, Key.left)) {
-                    switchQuestion((currentIdx - 1 + questions.length) % questions.length);
-                    return;
-                }
-                if (matchesKey(data, Key.right)) {
-                    switchQuestion((currentIdx + 1) % questions.length);
-                    return;
+                const visiblePos = visible.indexOf(currentIdx);
+                if (visiblePos >= 0) {
+                    if (matchesKey(data, Key.left)) {
+                        switchQuestion(visible[(visiblePos - 1 + visible.length) % visible.length] ?? currentIdx);
+                        return;
+                    }
+                    if (matchesKey(data, Key.right)) {
+                        switchQuestion(visible[(visiblePos + 1) % visible.length] ?? currentIdx);
+                        return;
+                    }
                 }
             }
             // ── Cursor navigation ────────────────────────────────────────
@@ -435,7 +513,8 @@ export async function showInterviewRound(questions, opts, ctx) {
             const push = (...rows) => { for (const r of rows)
                 lines.push(...r); };
             push(ui.bar(), ui.blank(), ui.header(`  ${opts.reviewHeadline ?? "Review your answers"}`), ui.blank());
-            for (let i = 0; i < questions.length; i++) {
+            const visible = visibleQuestionIndices();
+            for (const i of visible) {
                 const q = questions[i];
                 const st = states[i];
                 push(ui.subtitle(`  ${q.question}`));
@@ -501,19 +580,23 @@ export async function showInterviewRound(questions, opts, ctx) {
             const lines = [];
             const push = (...rows) => { for (const r of rows)
                 lines.push(...r); };
+            reconcileVisibility();
+            const visible = visibleQuestionIndices();
+            const isMultiQuestion = visible.length > 1;
+            const visiblePos = Math.max(visible.indexOf(currentIdx), 0);
             const q = questions[currentIdx];
             const st = states[currentIdx];
             const multiSel = isMultiSelect(currentIdx);
             push(ui.bar());
             // ── Progress header ────────────────────────────────────────────
             if (isMultiQuestion) {
-                const unanswered = questions.filter((_, i) => !isQuestionAnswered(i)).length;
-                const answeredSet = new Set(questions.map((_, i) => i).filter(i => isQuestionAnswered(i)));
-                push(ui.questionTabs(questions.map(q => q.header), currentIdx, answeredSet));
+                const unanswered = visible.filter((i) => !isQuestionAnswered(i)).length;
+                const answeredSet = new Set(visible.map((i, visibleIndex) => (isQuestionAnswered(i) ? visibleIndex : -1)).filter((i) => i >= 0));
+                push(ui.questionTabs(visible.map((i) => questions[i]?.header ?? ""), visiblePos, answeredSet));
                 push(ui.blank());
                 const progressParts = [
                     opts.progress,
-                    `Question ${currentIdx + 1}/${questions.length}`,
+                    `Question ${visiblePos + 1}/${visible.length}`,
                     unanswered > 0 ? `${unanswered} unanswered` : null,
                 ].filter(Boolean).join("  •  ");
                 if (progressParts)
@@ -582,7 +665,7 @@ export async function showInterviewRound(questions, opts, ctx) {
             }
             // ── Footer hints ───────────────────────────────────────────────
             push(ui.blank());
-            const isLast = !isMultiQuestion || currentIdx === questions.length - 1;
+            const isLast = !isMultiQuestion || visiblePos === visible.length - 1;
             const hints = [];
             if (focusNotes) {
                 hints.push("enter to confirm");

package/dist/resources/extensions/slash-commands/extension-manifest.json

@@ -2,11 +2,11 @@
 	"id": "slash-commands",
 	"name": "Slash Commands",
 	"version": "1.0.0",
-	"description": "Bundled slash commands for context inspection, planning, and lazy tool search",
+	"description": "Bundled slash commands for context inspection, planning, fast mode, and lazy tool search",
 	"tier": "bundled",
 	"requires": { "platform": ">=2.29.0" },
 	"provides": {
-		"commands": ["audit", "clear", "context", "plan", "execute", "cancel-plan", "tools"],
+		"commands": ["audit", "clear", "context", "fast", "plan", "execute", "cancel-plan", "tools"],
 		"tools": ["tool_search", "tool_enable"],
 		"flags": ["plan"]
 	}

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

@@ -0,0 +1,73 @@
+import { getAgentDir, SettingsManager } from "@gsd/pi-coding-agent";
+function parseFastCommandAction(args) {
+    const normalized = args.trim().toLowerCase();
+    if (!normalized)
+        return "toggle";
+    if (normalized === "on")
+        return "on";
+    if (normalized === "off")
+        return "off";
+    if (normalized === "status")
+        return "status";
+    return "invalid";
+}
+function supportsFastMode(model) {
+    if (!model)
+        return false;
+    if (model.api === "openai-codex-responses")
+        return true;
+    if (model.api !== "openai-responses")
+        return false;
+    if (model.provider !== "openai")
+        return false;
+    return model.capabilities?.supportsServiceTier === true;
+}
+function getModelLabel(model) {
+    if (!model)
+        return "no active model";
+    return `${model.provider}/${model.id}`;
+}
+function getSettingsManager() {
+    return SettingsManager.create(process.cwd(), getAgentDir());
+}
+export const __testing = {
+    parseFastCommandAction,
+    supportsFastMode,
+};
+export default function fastCommand(pi) {
+    pi.registerCommand("fast", {
+        description: "Toggle fast mode for OpenAI/Codex models (service_tier=priority)",
+        getArgumentCompletions(prefix) {
+            const options = [
+                { value: "on", label: "on", description: "Enable fast mode" },
+                { value: "off", label: "off", description: "Disable fast mode" },
+                { value: "status", label: "status", description: "Show current fast-mode status" },
+            ];
+            const query = prefix.trim().toLowerCase();
+            return options.filter((item) => item.value.startsWith(query));
+        },
+        async handler(args, ctx) {
+            const settings = getSettingsManager();
+            const current = settings.getFastMode();
+            const action = parseFastCommandAction(args);
+            const model = ctx.model;
+            const supported = supportsFastMode(model);
+            const modelLabel = getModelLabel(model);
+            if (action === "invalid") {
+                ctx.ui.notify("Usage: /fast [on|off|status]", "warning");
+                return;
+            }
+            if (action === "status") {
+                ctx.ui.notify(`Fast mode: ${current ? "ON" : "OFF"} · model ${modelLabel} is ${supported ? "supported" : "unsupported"}`, "info");
+                return;
+            }
+            const next = action === "toggle" ? !current : action === "on";
+            settings.setFastMode(next);
+            if (!supported) {
+                ctx.ui.notify(`Fast mode: ${next ? "ON" : "OFF"} (saved). Current model ${modelLabel} does not support fast mode.`, "warning");
+                return;
+            }
+            ctx.ui.notify(`Fast mode: ${next ? "ON" : "OFF"} (saved). ${next ? "Requests will include service_tier=priority." : "Requests will omit service_tier."}`, "info");
+        },
+    });
+}

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

@@ -1,6 +1,7 @@
 import auditCommand from "./audit.js";
 import clearCommand from "./clear.js";
 import contextCommand from "./context.js";
+import fastCommand from "./fast.js";
 import initCommand from "./init.js";
 import planCommand from "./plan.js";
 import toolSearchExtension from "./tools.js";
@@ -8,6 +9,7 @@ export default function slashCommands(pi) {
     auditCommand(pi);
     clearCommand(pi);
     contextCommand(pi);
+    fastCommand(pi);
     initCommand(pi);
     planCommand(pi);
     toolSearchExtension(pi);

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

@@ -28,9 +28,8 @@ const BLOCKED_TOOLS = new Set([
     "async_bash",
     "bg_shell",
     "browser_navigate",
-    "browser_go_back",
-    "browser_go_forward",
-    "browser_reload",
+    "browser_pages",
+    "browser_frames",
     "browser_click",
     "browser_drag",
     "browser_type",
@@ -41,18 +40,13 @@ const BLOCKED_TOOLS = new Set([
     "browser_select_option",
     "browser_set_checked",
     "browser_set_viewport",
-    "browser_click_ref",
-    "browser_hover_ref",
-    "browser_fill_ref",
+    "browser_ref",
     "browser_act",
     "browser_batch",
     "browser_fill_form",
-    "browser_mock_route",
-    "browser_block_urls",
-    "browser_clear_routes",
+    "browser_network",
     "browser_emulate_device",
-    "browser_save_state",
-    "browser_restore_state",
+    "browser_state",
     "browser_generate_test",
     "browser_verify",
     "write",
@@ -70,6 +64,7 @@ const REVISE_LABEL = "Revise plan";
 const CANCEL_LABEL = "Cancel";
 const DEFAULT_PLAN_REVIEW_AGENT = "generic";
 const DEFAULT_PLAN_CODING_AGENT = "worker";
+const MIN_PLAN_CONFIDENCE = 8;
 const INITIAL_STATE = {
     active: false,
     task: "",
@@ -366,6 +361,9 @@ function buildPlanModeSystemPrompt() {
         "You are currently in plan mode.",
         "Investigate, clarify scope, and produce a persisted execution plan before making source changes.",
         "If requirements are ambiguous or constraints are missing, ask concise clarifying questions before drafting or saving a plan.",
+        `Before writing or updating a plan artifact, make sure your confidence is at least ${MIN_PLAN_CONFIDENCE}/10. If confidence is lower, investigate more or ask clarifying questions first.`,
+        "Include an explicit confidence line in every saved plan, for example: \"Confidence: 8/10\" or higher.",
+        "When adjusting an existing saved plan, prefer the edit tool for targeted changes. Rewrite the whole file only when the structure changes substantially or an exact edit is impractical.",
         "Do not modify source files or run side-effect commands while plan mode is active.",
         "Persist plan artifacts under .lsd/plan/.",
     ];
@@ -395,25 +393,18 @@ function buildNewSessionOptionLabel() {
     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 [
-        "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}.`,
+        "Ask for plan approval now via exactly one ask_user_questions tool call.",
+        `Question 1 (single-select) id \"${PLAN_APPROVAL_ACTION_QUESTION_ID}\": ask what to do next with the plan. In the question text, tell the user that if they choose \"${REVISE_LABEL}\" they should type exact requested changes in the dialog notes field before submitting.`,
+        `Question 1 options: ${APPROVE_LABEL}, ${REVIEW_LABEL}, ${REVISE_LABEL}. Put "${APPROVE_LABEL}" first with a "(Recommended)" suffix in the description, not in the 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.`,
+        `Question 2 (single-select) id \"${PLAN_APPROVAL_PERMISSION_QUESTION_ID}\": ask which execution mode to use.`,
+        `Question 2 options: ${APPROVE_AUTO_LABEL} (Recommended), ${APPROVE_BYPASS_LABEL}, ${APPROVE_AUTO_SUBAGENT_LABEL}, ${APPROVE_BYPASS_SUBAGENT_LABEL}${showNewSessionOption ? `, ${newSessionLabel}` : ""}.`,
+        `Set question 2 showWhen.questionId to \"${PLAN_APPROVAL_ACTION_QUESTION_ID}\" and showWhen.selectedAnyOf to [\"${APPROVE_LABEL}\"] so it appears only when the user selects Approve plan.`,
+        "Do not restate the plan in a normal assistant response. Just call ask_user_questions.",
     ].join(" ");
 }
 // Keep for external callers that reference the combined form (headless path)
@@ -461,6 +452,23 @@ function buildReviewSteeringMessage(planPath, planMarkdown) {
     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 buildRevisionSteeringMessage(planPath, requestedChanges) {
+    const details = [
+        `The user selected \"${REVISE_LABEL}\" for ${planPath}.`,
+        "Revise the existing saved plan instead of drafting a fresh replacement unless a full rewrite is genuinely necessary.",
+        "Prefer the edit tool for targeted adjustments to the current plan artifact. Use write only if the structure changes substantially or an exact edit is impractical.",
+        `Before saving the revised plan, make sure confidence is at least ${MIN_PLAN_CONFIDENCE}/10. If lower, investigate more or ask clarifying questions first.`,
+        "Keep an explicit confidence line in the plan, for example: \"Confidence: 8/10\" or higher.",
+    ];
+    if (requestedChanges) {
+        details.push(`User-requested changes: ${requestedChanges}`);
+    }
+    else {
+        details.push("No concrete revision note was provided yet. Ask one concise clarifying question about what should change before editing the plan.");
+    }
+    details.push("After revising the saved plan artifact, ask for approval again.");
+    return details.join("\n\n");
+}
 function approvalSelectionToExecutionMode(selected) {
     if (!selected)
         return undefined;
@@ -489,6 +497,12 @@ function getAnswerValues(answer) {
     }
     return values;
 }
+function getAnswerNote(answer) {
+    if (typeof answer?.notes !== "string")
+        return undefined;
+    const note = answer.notes.trim();
+    return note.length > 0 ? note : undefined;
+}
 function selectionRequestsCancel(selected) {
     return selected.some((value) => {
         if (typeof value !== "string")
@@ -513,6 +527,8 @@ export const __testing = {
     buildApprovalSteeringMessage,
     buildPlanPreviewMessage,
     buildReviewSteeringMessage,
+    buildRevisionSteeringMessage,
+    buildPlanModeSystemPrompt,
     buildAutoSuggestPlanModeSystemPrompt,
     readAutoSuggestPlanModeSetting,
     PLAN_SUGGEST_QUESTION_ID,
@@ -679,8 +695,16 @@ export default function planCommand(pi) {
         if (!actionSelection)
             return;
         if (actionSelection.includes(APPROVE_LABEL)) {
-            // Steer the second question — handle in the next tool_result cycle
-            pi.sendUserMessage(buildApprovalModeInstructions(), { deliverAs: "steer" });
+            const executionMode = approvalSelectionToExecutionMode(permissionValues[0]) ?? {
+                permissionMode: DEFAULT_APPROVAL_PERMISSION_MODE,
+                executeWithSubagent: false,
+            };
+            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");
+            }
+            await approvePlan(pi, ctx, executionMode.permissionMode, executionMode.executeWithSubagent);
             return;
         }
         if (actionSelection.includes(REVIEW_LABEL)) {
@@ -695,9 +719,11 @@ export default function planCommand(pi) {
             return;
         }
         if (actionSelection.includes(REVISE_LABEL)) {
+            const requestedChanges = getAnswerNote(actionAnswer);
             enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
                 approvalStatus: "revising",
             });
+            pi.sendUserMessage(buildRevisionSteeringMessage(state.latestPlanPath ?? "the latest plan", requestedChanges), { deliverAs: "steer" });
         }
     });
     pi.registerCommand("plan", {

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

@@ -37,6 +37,30 @@ function getBalancedToolNames(activeToolNames) {
             "ask_user_questions",
         ];
 }
+const STANDARD_TOOLS = [
+    // Core
+    "read", "bash", "edit", "write", "lsp", "grep", "find", "ls",
+    // Background
+    "bg_shell",
+    // Search
+    "web_search", "fetch_page",
+    // Docs
+    "resolve_library", "get_library_docs",
+    // Agent
+    "subagent", "await_subagent", "Skill",
+    // User interaction
+    "ask_user_questions", "secure_env_collect",
+    // Browser (essential)
+    "browser_navigate", "browser_click", "browser_type", "browser_screenshot",
+    "browser_scroll", "browser_key_press", "browser_evaluate",
+    "browser_find", "browser_wait_for", "browser_close",
+    "browser_assert", "browser_batch",
+    // Tool management
+    "tool_search", "tool_enable",
+];
+function getStandardToolNames() {
+    return [...STANDARD_TOOLS];
+}
 function getFullToolNames(pi) {
     return pi.getAllTools().map((tool) => tool.name).filter((name) => Boolean(name));
 }
@@ -168,7 +192,8 @@ export default function toolSearchExtension(pi) {
                         currentActive.length > 0 ? currentActive.join(", ") : "(none)",
                         "",
                         "Usage:",
-                        "  /tools balanced   Switch to the balanced tool profile",
+                        "  /tools balanced   Switch to the balanced tool profile (12 tools)",
+                        "  /tools standard   Switch to the standard tool profile (~32 tools)",
                         "  /tools full       Switch to the full tool profile (all available tools)",
                         "  /tools on         Alias for /tools full",
                         "  /tools off        Alias for /tools balanced",
@@ -183,7 +208,18 @@ export default function toolSearchExtension(pi) {
                 pi.setActiveTools(nextActive);
                 pi.sendMessage({
                     customType: "tools:mode",
-                    content: `Balanced tool profile active: ${pi.getActiveTools().join(", ")}`,
+                    content: `Balanced tool profile active (${pi.getActiveTools().length} tools): ${pi.getActiveTools().join(", ")}`,
+                    display: true,
+                });
+                return;
+            }
+            if (input === "standard") {
+                settings.setToolProfile("standard");
+                const nextActive = getStandardToolNames();
+                pi.setActiveTools(nextActive);
+                pi.sendMessage({
+                    customType: "tools:mode",
+                    content: `Standard tool profile active (${pi.getActiveTools().length} tools): ${pi.getActiveTools().join(", ")}`,
                     display: true,
                 });
                 return;
@@ -194,14 +230,14 @@ export default function toolSearchExtension(pi) {
                 pi.setActiveTools(nextActive);
                 pi.sendMessage({
                     customType: "tools:mode",
-                    content: `Full tool profile active: ${pi.getActiveTools().join(", ")}`,
+                    content: `Full tool profile active (${pi.getActiveTools().length} tools): ${pi.getActiveTools().join(", ")}`,
                     display: true,
                 });
                 return;
             }
             pi.sendMessage({
                 customType: "tools:help",
-                content: `Unknown /tools subcommand: ${input}\n\nTry /tools, /tools balanced, /tools full, /tools on, or /tools off.`,
+                content: `Unknown /tools subcommand: ${input}\n\nTry /tools, /tools balanced, /tools standard, /tools full, /tools on, or /tools off.`,
                 display: true,
             });
         },