minovative-mind-cli 2.13.3 → 2.13.5

package/README.md

@@ -137,7 +137,6 @@ Background tasks automatically route to dedicated auxiliary models with native `
 | `/config-key`   | Configure custom Google AI Studio API key (BYOK mode)                                                                                           |
 | `/profile`      | View, inspect, delete, or reset global adaptive persona memory and AI side-notes                                                                |
 | `/models`       | Hot-swap the active model                                                                                                                       |
-| `/plan`         | Toggle plan mode to review implementation strategies                                                                                            |
 | `/paste`        | Multi-line input mode (cancel with Ctrl+C)                                                                                                      |
 | `/clear`        | Clear conversation history                                                                                                                      |
 | `/debug`        | Expose internal agent diagnostics                                                                                                               |
@@ -165,7 +164,7 @@ Minovative Mind CLI doesn't restrict you to a single repository. You can logical
 
 ## 🌐 Supported Languages
 
-Minovative Mind CLI fundamentally supports **ALL programming languages** for chat, code generation, planning, and execution, as it relies on Gemini's vast training data.
+Minovative Mind CLI fundamentally supports **ALL programming languages** for chat, code generation, and execution, as it relies on Gemini's vast training data.
 
 However, the PCV engine features deep, context-aware analysis across **12 major programming language families**. Our core advanced engines—**Smart Dependency Tracing**, **Property-Based & Mutation Verification**, **Performance Auditing** (across 9 language families), and **Ephemeral Analysis Scripts**—provide tailored support depending on the language's syntax and runtime model:
 

package/dist/commands/chat.d.ts

@@ -9,7 +9,7 @@ import { Command } from '@oclif/core';
 export default class DefaultCommand extends Command {
     /**
      * The description displayed in the CLI help output.
-     * Details all supported slash commands (/config-key, /profile, /paste, /plan, /clear, /models,
+     * Details all supported slash commands (/config-key, /profile, /paste, /clear, /models,
      * /debug, /auto-approve, /sub-agents, /stats, /revert, /chats, /workspaces, /commit)
      * along with interactive chat controls.
      */

package/dist/commands/chat.js

@@ -18,7 +18,7 @@ import { optimizeWorkspaceIDESettings } from '../services/ideOptimization.js';
 export default class DefaultCommand extends Command {
     /**
      * The description displayed in the CLI help output.
-     * Details all supported slash commands (/config-key, /profile, /paste, /plan, /clear, /models,
+     * Details all supported slash commands (/config-key, /profile, /paste, /clear, /models,
      * /debug, /auto-approve, /sub-agents, /stats, /revert, /chats, /workspaces, /commit)
      * along with interactive chat controls.
      */
@@ -28,7 +28,6 @@ Inside the chat session, you can use the following commands in the slash menu:
   /config-key    - BYOK — Configure, clear, or view status of custom Google AI Studio API key
   /profile       - View, inspect, delete, or reset global adaptive persona memory and AI side-notes
   /paste         - Enter multi-line paste mode for long code snippets and prompts
-  /plan          - Toggle plan mode to review step-by-step implementation strategies
   /clear         - Clear conversation history, reset terminal screen, and display logo
   /models        - Select or hot-swap the active Gemini model for the session
   /debug         - Toggle internal agent telemetry, diagnostic logging, and execution state

package/dist/services/agent/slashCommands.js

@@ -27,7 +27,6 @@ import { loadUserProfile, deleteSideNote, clearUserProfile, getUserProfilePath,
  * - `/config-key`  : Configure, validate, toggle, or clear Bring Your Own Key (BYOK) Google AI Studio API credentials.
  * - `/profile`     : View, inspect, delete, or reset global adaptive persona memory and AI side-notes.
  * - `/paste`       : Enter multi-line paste mode using EOF tracking (`Ctrl+D` submission).
- * - `/plan`        : Toggle AI step-by-step implementation planning mode.
  * - `/clear`       : Clear conversation history, wipe terminal screen, and reset CLI header.
  * - `/models`      : Hot-swap the active generative AI model (Gemini 3.1 Pro, Gemini 3.7 Flash, Gemini 3.6 Flash, Gemini 3.5 Flash-Lite, Auto routing).
  * - `/debug`       : Toggle internal agent telemetry and diagnostic logging.
@@ -75,19 +74,6 @@ export async function handleSlashCommand(command, context) {
             return { shouldContinue: true, isRawPasteMode: false };
         }
     }
-    /**
-     * `/plan` - Toggles step-by-step AI implementation planning mode.
-     */
-    if (lowerCommand === '/plan') {
-        const newPlanMode = !context.isPlanMode;
-        if (newPlanMode) {
-            p.log.info(pc.cyan('Plan mode enabled. The AI will formulate a step-by-step plan instead of executing code. Type /plan again to exit.'));
-        }
-        else {
-            p.log.info(pc.cyan('Plan mode disabled. Returning to normal execution.'));
-        }
-        return { shouldContinue: true, isPlanModeOverride: newPlanMode };
-    }
     /**
      * `/clear` - Resets chat conversation history, clears the terminal screen, and reprints CLI header.
      */
@@ -226,14 +212,12 @@ export async function handleSlashCommand(command, context) {
         }
         const autoApprove = getApprovalMode() === 'skip-all' ? 'Enabled' : 'Disabled';
         const subAgents = isSubAgentsEnabled() ? 'Enabled' : 'Disabled';
-        const planMode = context.isPlanMode ? 'Enabled' : 'Disabled';
         const byokEnabled = (await isByokEnabled()) ? 'Enabled' : 'Disabled';
         p.log.step(pc.magenta('📊 Session Statistics & Status'));
         console.log(pc.dim('----------------------------------------'));
         console.log(`${pc.bold('AI Model:')}         ${pc.cyan(displayModel)}`);
         console.log(`${pc.bold('Auto-Approve:')}     ${autoApprove === 'Enabled' ? pc.green(autoApprove) : pc.yellow(autoApprove)}`);
         console.log(`${pc.bold('Sub-Agents:')}       ${subAgents === 'Enabled' ? pc.green(subAgents) : pc.yellow(subAgents)}`);
-        console.log(`${pc.bold('Plan Mode:')}        ${planMode === 'Enabled' ? pc.green(planMode) : pc.yellow(planMode)}`);
         console.log(`${pc.bold('BYOK:')}             ${byokEnabled === 'Enabled' ? pc.green(byokEnabled) : pc.yellow(byokEnabled)}`);
         const debugMode = isDebugOn() ? 'Enabled' : 'Disabled';
         console.log(`${pc.bold('Debug Log:')}        ${debugMode === 'Enabled' ? pc.green(debugMode) : pc.yellow(debugMode)}`);

package/dist/services/agent/types.d.ts

@@ -21,8 +21,6 @@ export interface SlashCommandContext {
     version: string;
     /** Flag indicating whether raw paste mode is currently enabled. */
     isRawPasteMode: boolean;
-    /** Flag indicating whether step-by-step implementation planning mode is currently active. */
-    isPlanMode: boolean;
     /** Session state tracking tokens, credits, usage metadata, and model turn counts. */
     chatSessionState: {
         id: string;
@@ -46,6 +44,4 @@ export interface SlashCommandResult {
     userInputOverride?: string;
     /** Optional override flag to enable or disable raw paste mode. */
     isRawPasteMode?: boolean;
-    /** Optional override flag to enable or disable implementation planning mode. */
-    isPlanModeOverride?: boolean;
 }

package/dist/services/agent.d.ts

@@ -92,9 +92,6 @@ export declare function startAgentLoop(workspaceRoot: string, version: string):
  * @param chat - The active ProxyChatSession instance maintaining message history.
  * @param inputHandler - The AsyncInputHandler instance for managing keyboard interrupts and queueing.
  * @param chatSessionState - Object tracking session statistics, token counts, credit usage, and model metrics.
- * @param isPlanMode - Flag indicating whether plan mode (read-only architecture planning) is active.
- * @param cachedContextResult - Optional pre-gathered context result to bypass duplicate investigation turns.
- * @returns An object containing optional plan mode actions or context results, or void.
  */
 export declare function executeSingleTurn(workspaceRoot: string, userInput: string, chat: any, inputHandler: AsyncInputHandler, chatSessionState: {
     id: string;
@@ -106,10 +103,7 @@ export declare function executeSingleTurn(workspaceRoot: string, userInput: stri
     latestUsageMetadata?: any;
     previousUsageMetadata?: any;
     modelUsageCounts?: Record<string, number>;
-}, isPlanMode: boolean, cachedContextResult?: any): Promise<{
-    planModeReturn?: string;
-    contextResult?: any;
-} | void>;
+}): Promise<void>;
 /**
  * Raw chat history entry count threshold to trigger chat history summarization.
  * 2 entries = 1 complete conversational user/model turn.

package/dist/services/agent.js

@@ -25,8 +25,8 @@ import { renderTerminalMarkdown } from '../utils/terminal.js';
 const execAsync = promisify(exec);
 import { debugLog, isDebugOn } from '../utils/logger.js';
 import { ensureProjectStorage, ensureIgnored, readCache, writeCache, invalidateCacheForDependents, } from '../utils/projectStorage.js';
-import { GEMINI_MODELS, isByokEnabled, TPM_COOLING_DELAYS } from '../utils/config.js';
-import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, compressTextUsingFlashLite, generateChatTitle, getGlobalActiveModel, setGlobalActiveModel, summarizeChatHistory, } from './ai.js';
+import { GEMINI_MODELS, TPM_COOLING_DELAYS } from '../utils/config.js';
+import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, compressTextUsingFlashLite, generateChatTitle, getGlobalActiveModel, summarizeChatHistory, } from './ai.js';
 import { getAndResetTurnUsage } from './proxyClient.js';
 import { changeLogger } from './changeLogger.js';
 import { chatHistoryService } from './chatHistoryService.js';
@@ -130,7 +130,6 @@ export async function startAgentLoop(workspaceRoot, version) {
     chat.setSessionInfo(chatSessionState.id, workspaceRoot);
     const sessionInputHistory = [];
     let isRawPasteMode = false;
-    let isPlanMode = false;
     // Hook process.stdin.emit to intercept fast stream inputs.
     // When large buffers containing newlines arrive rapidly, we interpret them as a clipboard paste,
     // sanitizing and collapsing them to prevent premature command line submission.
@@ -165,7 +164,7 @@ export async function startAgentLoop(workspaceRoot, version) {
         }
         inputHandler.stop();
         // Input collection (delegated to a helper function to avoid nested loop warning)
-        const { userInput: rawInput, canceled } = await collectUserInput(sessionInputHistory, isPlanMode);
+        const { userInput: rawInput, canceled } = await collectUserInput(sessionInputHistory);
         if (canceled) {
             p.outro(pc.green('Goodbye! Happy coding. 🚀'));
             return;
@@ -180,11 +179,6 @@ export async function startAgentLoop(workspaceRoot, version) {
                 message: 'Command Menu',
                 options: [
                     { value: '/models', label: '/models', hint: 'Change the active AI model' },
-                    {
-                        value: '/plan',
-                        label: '/plan',
-                        hint: `Toggle plan mode (build a plan without executing) ${isPlanMode ? pc.green('(ON)') : pc.red('(OFF)')}`,
-                    },
                     { value: '/paste', label: '/paste', hint: 'Paste large text directly into the CLI (Press Ctrl+D to submit)' },
                     { value: '/clear', label: '/clear', hint: 'Clear chat session history' },
                     {
@@ -244,16 +238,12 @@ export async function startAgentLoop(workspaceRoot, version) {
                 workspaceRoot,
                 version,
                 isRawPasteMode,
-                isPlanMode,
                 chatSessionState,
             };
             const slashResult = await handleSlashCommand(userInput, slashCtx);
             if (slashResult.isRawPasteMode !== undefined) {
                 isRawPasteMode = slashResult.isRawPasteMode;
             }
-            if (slashResult.isPlanModeOverride !== undefined) {
-                isPlanMode = slashResult.isPlanModeOverride;
-            }
             if (slashResult.userInputOverride !== undefined) {
                 userInput = slashResult.userInputOverride;
             }
@@ -262,32 +252,7 @@ export async function startAgentLoop(workspaceRoot, version) {
             }
         }
         // ─── Main Execution Cycle ────────────────────────────────────────
-        let currentInput = userInput;
-        let cachedContextResult = null;
-        while (true) {
-            const execResult = await executeSingleTurn(workspaceRoot, currentInput, chat, inputHandler, chatSessionState, isPlanMode, cachedContextResult);
-            const planModeReturn = execResult?.planModeReturn;
-            const contextResult = execResult?.contextResult;
-            if (isPlanMode && planModeReturn) {
-                if (planModeReturn === 'proceed') {
-                    isPlanMode = false;
-                    currentInput = 'Please execute the plan we just finalized.';
-                    cachedContextResult = contextResult;
-                    p.log.info(pc.cyan('Proceeding with execution...'));
-                    continue;
-                }
-                else if (planModeReturn === 'edit') {
-                    p.log.info(pc.cyan('Please provide additional instructions to revise the plan.'));
-                    break;
-                }
-                else if (planModeReturn === 'exit') {
-                    isPlanMode = false;
-                    p.log.info(pc.cyan('Exited plan mode. Returning to normal chat.'));
-                    break;
-                }
-            }
-            break;
-        }
+        await executeSingleTurn(workspaceRoot, userInput, chat, inputHandler, chatSessionState);
     }
 }
 /**
@@ -301,11 +266,8 @@ export async function startAgentLoop(workspaceRoot, version) {
  * @param chat - The active ProxyChatSession instance maintaining message history.
  * @param inputHandler - The AsyncInputHandler instance for managing keyboard interrupts and queueing.
  * @param chatSessionState - Object tracking session statistics, token counts, credit usage, and model metrics.
- * @param isPlanMode - Flag indicating whether plan mode (read-only architecture planning) is active.
- * @param cachedContextResult - Optional pre-gathered context result to bypass duplicate investigation turns.
- * @returns An object containing optional plan mode actions or context results, or void.
  */
-export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHandler, chatSessionState, isPlanMode, cachedContextResult) {
+export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHandler, chatSessionState) {
     return runWithAgentId('main', async () => {
         const { resetTurnAccumulator } = await import('./metrics.js');
         resetTurnAccumulator();
@@ -324,71 +286,67 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             if (ac.signal.aborted)
                 return;
             // Stage 0: Summarize chat history if length threshold is met
-            if (!cachedContextResult) {
-                const isDebug = isDebugOn();
-                if (!inputHandler.isCurrentlyPrompting() && !isDebug) {
-                    spinner.start('Checking conversation history...');
-                }
-                const historySummarized = await summarizeHistoryIfNeeded(chat, ac.signal);
-                if (historySummarized) {
-                    debugLog('Chat history was summarized and compressed prior to context investigation.');
-                }
-                if (!inputHandler.isCurrentlyPrompting() && !isDebug) {
-                    spinner.stop();
-                }
+            const isDebug = isDebugOn();
+            if (!inputHandler.isCurrentlyPrompting() && !isDebug) {
+                spinner.start('Checking conversation history...');
+            }
+            const historySummarized = await summarizeHistoryIfNeeded(chat, ac.signal);
+            if (historySummarized) {
+                debugLog('Chat history was summarized and compressed prior to context investigation.');
+            }
+            if (!inputHandler.isCurrentlyPrompting() && !isDebug) {
+                spinner.stop();
             }
             if (ac.signal.aborted)
                 return;
             // Stage 1: Gather Workspace Context and route intentions
             spinner.start('🔍 Investigating workspace...');
-            let gatherRes = { targetAgent: 'EXECUTE', chainedMessages: [], contextResult: cachedContextResult || null };
-            if (!cachedContextResult) {
-                const collector = getMetricCollector();
-                if (collector)
-                    collector.startTimer('contextGather');
-                const chatHistory = chat.getRecentHistory(3);
-                const toolLogs = [];
-                try {
-                    gatherRes = await gatherContext(workspaceRoot, userInput, chatHistory, inputHandler, ac.signal, (msg) => {
-                        if (!inputHandler.isCurrentlyPrompting()) {
-                            spinner.message(`🔍 Investigating workspace... ${pc.dim(msg)}`);
-                        }
-                    }, (toolMsg, label) => {
-                        const formattedLog = `${pc.dim(`[${label}]`)} ${toolMsg}`;
-                        toolLogs.push(formattedLog);
-                        if (!inputHandler.isCurrentlyPrompting()) {
-                            spinner.message(`🔍 Investigating workspace... ${formattedLog}`);
-                        }
-                    });
-                }
-                catch (gatherErr) {
-                    spinner.stop();
-                    process.stdout.write('\x1b[2K\r');
-                    if (ac.signal.aborted || gatherErr?.name === 'AbortError' || gatherErr?.message?.includes('abort')) {
-                        return;
+            let gatherRes = { targetAgent: 'EXECUTE', chainedMessages: [] };
+            const collector = getMetricCollector();
+            if (collector)
+                collector.startTimer('contextGather');
+            const chatHistory = chat.getRecentHistory(3);
+            const toolLogs = [];
+            try {
+                gatherRes = await gatherContext(workspaceRoot, userInput, chatHistory, inputHandler, ac.signal, (msg) => {
+                    if (!inputHandler.isCurrentlyPrompting()) {
+                        spinner.message(`🔍 Investigating workspace... ${pc.dim(msg)}`);
                     }
-                    throw gatherErr;
-                }
-                if (collector)
-                    collector.stopTimer('contextGather');
-                if (ac.signal.aborted) {
-                    spinner.stop();
-                    process.stdout.write('\x1b[2K\r');
-                    return;
-                }
-                // Print all collected logs at once to prevent flickering, while spinner is stopped
-                if (toolLogs.length > 0) {
-                    spinner.stop();
-                    toolLogs.forEach((log) => p.log.step(log));
-                    spinner.start(`🔍 Context gathered successfully.`);
-                }
-                // Post-investigation cooling-off delay to allow API Tokens-Per-Minute (TPM) sliding window to settle
-                await new Promise((resolve) => setTimeout(resolve, TPM_COOLING_DELAYS.POST_INVESTIGATION_MS));
-                if (ac.signal.aborted) {
-                    spinner.stop();
-                    process.stdout.write('\x1b[2K\r');
+                }, (toolMsg, label) => {
+                    const formattedLog = `${pc.dim(`[${label}]`)} ${toolMsg}`;
+                    toolLogs.push(formattedLog);
+                    if (!inputHandler.isCurrentlyPrompting()) {
+                        spinner.message(`🔍 Investigating workspace... ${formattedLog}`);
+                    }
+                });
+            }
+            catch (gatherErr) {
+                spinner.stop();
+                process.stdout.write('\x1b[2K\r');
+                if (ac.signal.aborted || gatherErr?.name === 'AbortError' || gatherErr?.message?.includes('abort')) {
                     return;
                 }
+                throw gatherErr;
+            }
+            if (collector)
+                collector.stopTimer('contextGather');
+            if (ac.signal.aborted) {
+                spinner.stop();
+                process.stdout.write('\x1b[2K\r');
+                return;
+            }
+            // Print all collected logs at once to prevent flickering, while spinner is stopped
+            if (toolLogs.length > 0) {
+                spinner.stop();
+                toolLogs.forEach((log) => p.log.step(log));
+                spinner.start(`🔍 Context gathered successfully.`);
+            }
+            // Post-investigation cooling-off delay to allow API Tokens-Per-Minute (TPM) sliding window to settle
+            await new Promise((resolve) => setTimeout(resolve, TPM_COOLING_DELAYS.POST_INVESTIGATION_MS));
+            if (ac.signal.aborted) {
+                spinner.stop();
+                process.stdout.write('\x1b[2K\r');
+                return;
             }
             let latestUsage = undefined;
             // Collect any inputs that were queued while the Context Agent was investigating
@@ -427,21 +385,12 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             }
             // Hot-swap the underlying LLM system instruction context depending on intent (conversational vs execution)
             debugLog(`Intent Router output: original targetAgent = ${gatherRes.targetAgent}, effective = ${effectiveTargetAgent}`);
-            let config;
-            if (isPlanMode) {
-                const { getPlanModeConfig } = await import('./ai.js');
-                config = getPlanModeConfig();
-            }
-            else {
-                config = effectiveTargetAgent === 'CHAT' ? getGeneralChatConfig() : getPlanExecutionConfig();
-            }
+            const config = effectiveTargetAgent === 'CHAT' ? getGeneralChatConfig() : getPlanExecutionConfig();
             let dynamicSystemInstruction = config.systemInstruction;
             // Inject gathered workspace directories, dependency configurations, and matching search patterns
             if (gatherRes.contextResult) {
                 // Compress each relevant file individually using helper to avoid nested loop warning
-                if (!cachedContextResult) {
-                    gatherRes.contextResult.relevantFiles = await compressContextFiles(workspaceRoot, gatherRes.contextResult, ac.signal);
-                }
+                gatherRes.contextResult.relevantFiles = await compressContextFiles(workspaceRoot, gatherRes.contextResult, ac.signal);
                 // Assemble the final context injection string
                 const contextInjection = buildContextInjection(gatherRes.contextResult);
                 debugLog(`Final compressed context injection size: ${contextInjection.length} chars`);
@@ -510,7 +459,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 gitBranch = stdout.trim();
             }
             catch { }
-            if (!isPlanMode && effectiveTargetAgent === 'EXECUTE' && isSubAgentsEnabled()) {
+            if (effectiveTargetAgent === 'EXECUTE' && isSubAgentsEnabled()) {
                 spinner.stop(); // Clear the spinner before delegating
                 inputHandler.clearSpinner(); // Prevent prompt from reviving the old spinner
                 process.stdout.write('\x1b[2K\r');
@@ -673,7 +622,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             const calls = result.response.functionCalls();
             debugLog(`Initial functionCalls: ${calls && calls.length > 0 ? JSON.stringify(calls) : 'None'}`);
             // Stage 2: Recursive Tool Loops and Automated Self-Correction (delegated to a helper function to avoid nested loop warning)
-            const correctionRes = await executeSelfCorrectionLoop(chat, result, workspaceRoot, inputHandler, effectiveTargetAgent, ac.signal, spinner, userInput, isPlanMode);
+            const correctionRes = await executeSelfCorrectionLoop(chat, result, workspaceRoot, inputHandler, effectiveTargetAgent, ac.signal, spinner, userInput);
             const finalText = correctionRes.finalText;
             inputHandler.stop();
             // Update latest usage metadata to reflect all completed turns
@@ -685,8 +634,9 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             if (modifiedFiles.length > 0) {
                 await invalidateCacheForDependents(workspaceRoot, modifiedFiles);
             }
+            let cleanFinalText = '';
             if (finalText) {
-                const cleanFinalText = finalText.replace(/\[TASK_FINISHED\]/g, '').trim();
+                cleanFinalText = finalText.replace(/\[TASK_FINISHED\]/g, '').trim();
                 if (cleanFinalText) {
                     console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim(`(${chat.getModel()})`)}\n`);
                     console.log(renderTerminalMarkdown(cleanFinalText));
@@ -824,93 +774,6 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 })
                     .catch((e) => debugLog('Failed to auto-save session: ' + e));
             }
-            let planModeReturn = undefined;
-            if (isPlanMode && finalText && finalText !== '[Generation stopped.]') {
-                inputHandler.stop(); // MUST stop the async input handler before showing an interactive prompt, or it will intercept stdin and freeze/duplicate
-                // Ensure the terminal has fully scrolled and there is a clean line break
-                console.log('\n');
-                // Small delay to allow stdout to flush and terminal to finish scrolling from the markdown output
-                // This prevents @clack/prompts from miscalculating the cursor position and duplicating the prompt on arrow keys
-                await new Promise((resolve) => setTimeout(resolve, 200));
-                while (true) {
-                    const currentModel = getGlobalActiveModel();
-                    const planAction = await p['select']({
-                        message: 'Plan generated. What would you like to do?',
-                        options: [
-                            { value: 'proceed', label: 'Proceed with plan', hint: 'Executes the generated plan immediately' },
-                            { value: 'edit', label: 'Edit plan', hint: 'Provide additional feedback to revise the plan' },
-                            {
-                                value: 'choose_model',
-                                label: 'Choose AI model',
-                                hint: `Change the active AI model (Current: ${currentModel})`,
-                            },
-                            { value: 'exit', label: 'Exit plan mode', hint: 'Return to normal chat without executing' },
-                        ],
-                    });
-                    if (planAction === 'choose_model') {
-                        const byokEnabled = await isByokEnabled();
-                        const options = [
-                            // {
-                            //   value: 'claude-opus-5',
-                            //   label: 'Claude 5 Opus',
-                            //   hint: 'For hardcore & complex problems',
-                            // },
-                            {
-                                value: 'gemini-3.1-pro-preview',
-                                label: 'Gemini 3.1 Pro',
-                                hint: 'For hardcore & complex problems',
-                            },
-                            // {
-                            //   value: 'claude-sonnet-5',
-                            //   label: 'Claude 5 Sonnet',
-                            //   hint: 'Best for raw speed and cost efficiency',
-                            // },
-                            {
-                                value: 'gemini-3.7-flash',
-                                label: 'Gemini 3.7 Flash',
-                                hint: 'Next-gen reasoning, speed & balanced performance',
-                            },
-                            {
-                                value: 'gemini-3.6-flash',
-                                label: 'Gemini 3.6 Flash',
-                                hint: 'Everyday coding — fast and accurate',
-                            },
-                            {
-                                value: 'gemini-3.5-flash-lite',
-                                label: 'Gemini 3.5 Flash-Lite',
-                                hint: 'Best for raw speed and cost efficiency',
-                            },
-                            {
-                                value: 'auto',
-                                label: 'Auto (Flash-Lite / Flash)',
-                                hint: 'Dynamically routes between Gemini 3.5 Flash-Lite and Gemini 3.7 Flash based on prompt complexity',
-                            },
-                        ].filter((o) => !(byokEnabled && o.value.includes('claude')));
-                        const selectedModel = await p['select']({
-                            message: `Select AI Model (Current: ${pc.cyan(currentModel)})`,
-                            initialValue: currentModel,
-                            options: options,
-                        });
-                        if (!p.isCancel(selectedModel)) {
-                            chat.setModel(selectedModel);
-                            setGlobalActiveModel(selectedModel);
-                            p.log.success(`Model successfully switched to ${pc.cyan(selectedModel)}`);
-                        }
-                        continue;
-                    }
-                    if (p.isCancel(planAction) || planAction === 'exit') {
-                        planModeReturn = 'exit';
-                    }
-                    else if (planAction === 'edit') {
-                        planModeReturn = 'edit';
-                    }
-                    else if (planAction === 'proceed') {
-                        planModeReturn = 'proceed';
-                    }
-                    break;
-                }
-            }
-            return { planModeReturn, contextResult: gatherRes.contextResult };
         }
         catch (err) {
             if (ac.signal.aborted || err?.name === 'AbortError' || err?.message?.includes('abort')) {
@@ -931,12 +794,12 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
         }
     });
 }
-async function collectUserInput(history, isPlanMode) {
+async function collectUserInput(history) {
     let lines = [];
     let isMultiLine = false;
     while (true) {
         const userInputRaw = await historyText({
-            message: isMultiLine ? '  ' : isPlanMode ? pc.cyan('(Plan Mode) ❯') : pc.magenta('❯'),
+            message: isMultiLine ? '  ' : pc.magenta('❯'),
             placeholder: isMultiLine ? '' : 'Use ' + String.fromCharCode(92) + ' for new lines',
             history,
         });
@@ -1075,7 +938,7 @@ export async function summarizeHistoryIfNeeded(chat, abortSignal) {
     }
     return false;
 }
-async function executeSelfCorrectionLoop(chat, initialResult, workspaceRoot, inputHandler, effectiveTargetAgent, signal, spinner, originalUserInput, isPlanMode) {
+async function executeSelfCorrectionLoop(chat, initialResult, workspaceRoot, inputHandler, effectiveTargetAgent, signal, spinner, originalUserInput) {
     let correctionAttempts = 0;
     const MAX_CORRECTIONS = 5;
     let result = initialResult;
@@ -1141,7 +1004,7 @@ async function executeSelfCorrectionLoop(chat, initialResult, workspaceRoot, inp
         }
         previousChangeCount = currentChanges.length;
         // ─── Tool-Based Intent Verification ─────────────────────────────────
-        if (effectiveTargetAgent === 'EXECUTE' && !intentVerified && !isPlanMode) {
+        if (effectiveTargetAgent === 'EXECUTE' && !intentVerified) {
             if (!currentText.includes('[TASK_FINISHED]')) {
                 p.log.warn(pc.yellow('AI paused execution without calling finish_task. Prompting to continue or finish...'));
                 const finishReminder = `SYSTEM CHECK: You stopped without calling the \`finish_task\` tool. 

package/dist/services/ai.d.ts

@@ -1,4 +1,5 @@
 import { type Content, type FunctionCall } from '@google/generative-ai';
+export declare function getMultiWorkspaceBlock(): string;
 export declare function setModelOverride(agent: 'context' | 'execution', overrideStr: string): void;
 export declare function clearModelOverrides(): void;
 export declare function setGlobalActiveModel(model: string): void;
@@ -9,11 +10,14 @@ export declare class ProxyChatSession {
     private modelName;
     private systemInstruction;
     private tools;
+    private toolConfig?;
     private generationConfig;
     private latestUsageMetadata;
-    constructor(modelName: string, systemInstruction: string, tools: any[], generationConfig: any);
+    constructor(modelName: string, systemInstruction: string, tools: any[], generationConfig: any, toolConfig?: any);
     getLatestUsageMetadata(): any;
-    setAgentConfig(systemInstruction: string, tools: any[]): void;
+    setAgentConfig(systemInstruction: string, tools: any[], toolConfig?: any): void;
+    setToolConfig(toolConfig?: any): void;
+    getToolConfig(): any;
     setModel(modelName: string): void;
     getModel(): string;
     clearHistory(): void;
@@ -91,10 +95,6 @@ export declare function getPlanExecutionConfig(): {
         functionDeclarations: import("@google/generative-ai").FunctionDeclaration[];
     }[];
 };
-export declare function getPlanModeConfig(): {
-    systemInstruction: string;
-    tools: never[];
-};
 /**
  * Compresses a large string of text using Gemini Flash.
  * Used for shrinking context payloads to prevent OOM/choking.