minovative-mind-cli 2.13.4 → 2.14.0

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, getModelThinkingLevel, summarizeChatHistory, } from './ai.js';
 import { getAndResetTurnUsage } from './proxyClient.js';
 import { changeLogger } from './changeLogger.js';
 import { chatHistoryService } from './chatHistoryService.js';
@@ -35,7 +35,7 @@ import { verifyChangedFiles } from './verificationService.js';
 import { buildContextInjection } from '../utils/contextPrompts.js';
 import { registerContextFiles } from '../utils/fileReadGuard.js';
 import { historyText } from '../utils/historyPrompt.js';
-import { loadUserProfile, formatUserProfileForContext, extractAndSaveUserInsights, } from './userProfileService.js';
+import { loadUserProfile, formatUserProfileForContext, extractAndSaveUserInsights } from './userProfileService.js';
 // Submodule Imports
 import { AsyncInputHandler } from './agent/inputHandler.js';
 import { processResponse } from './agent/toolLoop.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, workspaceRoot);
         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`);
@@ -453,6 +402,78 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     collector.recordCompressedContextSize(contextInjection.length);
                 dynamicSystemInstruction += '\n\n' + contextInjection;
             }
+            // Resolve and inject explicit @ Context Mentions (files, symbols, git diffs, diagnostics, external workspaces)
+            try {
+                const { mentionEngine } = await import('./mentionEngine.js');
+                const resolvedMentions = await mentionEngine.resolveMentions(userInput, workspaceRoot);
+                if (resolvedMentions.hasMentions) {
+                    const isPrompting = inputHandler.isCurrentlyPrompting();
+                    if (!isPrompting) {
+                        spinner.stop();
+                    }
+                    for (const item of resolvedMentions.mentions) {
+                        if (item.resolved) {
+                            const label = item.statusLabel ? ` ${pc.dim(`(${item.statusLabel})`)}` : '';
+                            p.log.step(`${pc.green('✔')} Context ${pc.cyan(item.mention.raw)}${label}`);
+                        }
+                        else {
+                            const reason = item.error ? ` ${pc.dim(`(${item.error})`)}` : '';
+                            p.log.warn(`${pc.red('✖')} Context ${pc.yellow(item.mention.raw)}${reason}`);
+                        }
+                    }
+                    if (!isPrompting) {
+                        spinner.start('Preparing agent configuration...');
+                    }
+                    if (resolvedMentions.formattedContext) {
+                        debugLog(`Resolved ${resolvedMentions.mentions.length} context mention(s) (${resolvedMentions.totalTokens} tokens estimated)`);
+                        dynamicSystemInstruction += '\n\n' + resolvedMentions.formattedContext;
+                        // Pre-register all resolved file mention paths with the read-guard
+                        const mentionedFiles = resolvedMentions.mentions
+                            .filter((m) => m.mention.type === 'file' && m.resolved)
+                            .map((m) => m.mention.target);
+                        if (mentionedFiles.length > 0) {
+                            registerContextFiles(mentionedFiles);
+                        }
+                    }
+                }
+                // Also resolve mentions from any chained follow-up instructions received during investigation
+                if (gatherRes.chainedMessages.length > 0) {
+                    const chainedContent = gatherRes.chainedMessages.join('\n');
+                    const chainedMentions = await mentionEngine.resolveMentions(chainedContent, workspaceRoot);
+                    if (chainedMentions.hasMentions) {
+                        const isPrompting = inputHandler.isCurrentlyPrompting();
+                        if (!isPrompting) {
+                            spinner.stop();
+                        }
+                        for (const item of chainedMentions.mentions) {
+                            if (item.resolved) {
+                                const label = item.statusLabel ? ` ${pc.dim(`(${item.statusLabel})`)}` : '';
+                                p.log.step(`${pc.green('✔')} Chained Context ${pc.cyan(item.mention.raw)}${label}`);
+                            }
+                            else {
+                                const reason = item.error ? ` ${pc.dim(`(${item.error})`)}` : '';
+                                p.log.warn(`${pc.red('✖')} Chained Context ${pc.yellow(item.mention.raw)}${reason}`);
+                            }
+                        }
+                        if (!isPrompting) {
+                            spinner.start('Preparing agent configuration...');
+                        }
+                        if (chainedMentions.formattedContext) {
+                            debugLog(`Resolved ${chainedMentions.mentions.length} chained context mention(s) (${chainedMentions.totalTokens} tokens estimated)`);
+                            dynamicSystemInstruction += '\n\n' + chainedMentions.formattedContext;
+                            const chainedFiles = chainedMentions.mentions
+                                .filter((m) => m.mention.type === 'file' && m.resolved)
+                                .map((m) => m.mention.target);
+                            if (chainedFiles.length > 0) {
+                                registerContextFiles(chainedFiles);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (mentionErr) {
+                debugLog(`Context mention resolution encountered an error: ${mentionErr?.message || mentionErr}`);
+            }
             // Inject global adaptive user persona and learned preferences
             try {
                 const userProfile = await loadUserProfile();
@@ -480,10 +501,20 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     selectedModel = complexity === 'EASY' ? GEMINI_MODELS.FLASH_LITE : GEMINI_MODELS.FLASH;
                 }
                 chat.setModel(selectedModel);
-                debugLog(`Auto-routing to model ${selectedModel} based on intent ${effectiveTargetAgent}`);
+                const thinkingLevel = getModelThinkingLevel(selectedModel);
+                if (typeof chat.setThinkingLevel === 'function') {
+                    chat.setThinkingLevel(thinkingLevel);
+                }
+                debugLog(`Auto-routing to model ${selectedModel} (thinking: ${thinkingLevel}) based on intent ${effectiveTargetAgent}`);
             }
             else {
-                chat.setModel(getGlobalActiveModel());
+                const activeModel = getGlobalActiveModel();
+                chat.setModel(activeModel);
+                const thinkingLevel = getModelThinkingLevel(activeModel);
+                if (typeof chat.setThinkingLevel === 'function') {
+                    chat.setThinkingLevel(thinkingLevel);
+                }
+                debugLog(`Active model set to ${activeModel} (thinking: ${thinkingLevel})`);
             }
             if (ac.signal.aborted) {
                 spinner.stop();
@@ -510,7 +541,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');
@@ -650,6 +681,10 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             // Send the formulated prompt payload to the generative model
             let result;
             try {
+                const activeModel = chat.getModel();
+                const currentThinking = (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+                    getModelThinkingLevel(activeModel);
+                debugLog(`Dispatching turn to model ${activeModel} (thinking: ${currentThinking})`);
                 result = await chat.sendMessage(finalInput, undefined, ac.signal);
             }
             catch (e) {
@@ -673,7 +708,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 +720,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 +860,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,14 +880,40 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
         }
     });
 }
-async function collectUserInput(history, isPlanMode) {
+async function collectUserInput(history, workspaceRoot = process.cwd()) {
     let lines = [];
     let isMultiLine = false;
     while (true) {
         const userInputRaw = await historyText({
-            message: isMultiLine ? '  ' : isPlanMode ? pc.cyan('(Plan Mode) ❯') : pc.magenta('❯'),
-            placeholder: isMultiLine ? '' : 'Use ' + String.fromCharCode(92) + ' for new lines',
+            message: isMultiLine ? '  ' : pc.magenta('❯'),
+            placeholder: isMultiLine
+                ? ''
+                : 'Use ' + String.fromCharCode(92) + ' for new lines or @ to mention file paths and more',
             history,
+            autocomplete: {
+                workspaceRoot,
+                getSuggestions: async (query) => {
+                    try {
+                        const { mentionEngine } = await import('./mentionEngine.js');
+                        const suggestions = await mentionEngine.getSuggestionsForQuery(query, { workspaceRoot });
+                        return suggestions.map((s) => ({
+                            value: s.value,
+                            label: s.label,
+                            category: s.category,
+                            description: s.description,
+                            metadata: {
+                                filePath: s.filePath,
+                                symbol: s.label,
+                                helperLabel: s.helperLabel,
+                                symbolKind: s.symbolKind,
+                            },
+                        }));
+                    }
+                    catch {
+                        return [];
+                    }
+                },
+            },
         });
         if (p.isCancel(userInputRaw)) {
             if (isMultiLine) {
@@ -1075,7 +1050,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 +1116,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,9 +1,23 @@
 import { type Content, type FunctionCall } from '@google/generative-ai';
+import { type ThinkingLevel } from '../utils/config.js';
 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;
 export declare function getGlobalActiveModel(): string;
+/**
+ * Gets the thinking reasoning level configured for a specific model or active model.
+ * Falls back to default model thinking levels or 'MEDIUM' if not explicitly configured.
+ */
+export declare function getModelThinkingLevel(model?: string): ThinkingLevel;
+/**
+ * Sets the user-configured thinking reasoning level for a specific model.
+ */
+export declare function setModelThinkingLevel(model: string, level: ThinkingLevel): void;
+/**
+ * Resets user-configured thinking levels back to default model presets.
+ */
+export declare function resetModelThinkingLevels(): void;
 export declare class ProxyChatSession {
     private history;
     private fullHistory;
@@ -12,6 +26,7 @@ export declare class ProxyChatSession {
     private tools;
     private toolConfig?;
     private generationConfig;
+    private configuredThinkingLevel?;
     private latestUsageMetadata;
     constructor(modelName: string, systemInstruction: string, tools: any[], generationConfig: any, toolConfig?: any);
     getLatestUsageMetadata(): any;
@@ -20,6 +35,10 @@ export declare class ProxyChatSession {
     getToolConfig(): any;
     setModel(modelName: string): void;
     getModel(): string;
+    setThinkingLevel(level: ThinkingLevel): void;
+    getThinkingLevel(): ThinkingLevel | undefined;
+    setGenerationConfig(generationConfig: any): void;
+    getGenerationConfig(): any;
     clearHistory(): void;
     getRawHistory(): Content[];
     getFullHistory(): Content[];
@@ -95,10 +114,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.