minovative-mind-cli 1.5.1 → 2.0.0

package/dist/services/agent.js

@@ -23,17 +23,23 @@ import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import { debugLog, isDebugOn } from '../utils/logger.js';
 import { ensureProjectStorage, ensureIgnored, readCache, writeCache, invalidateCacheForDependents, } from '../utils/projectStorage.js';
-import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, compressTextUsingFlashLite, generateChatTitle, } from './ai.js';
+import { GEMINI_MODELS } from '../utils/config.js';
+import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, compressTextUsingFlashLite, generateChatTitle, getGlobalActiveModel, getGlobalLatestUsageMetadata, } from './ai.js';
 import { changeLogger } from './changeLogger.js';
 import { chatHistoryService } from './chatHistoryService.js';
-import { gatherContext, routeIntent } from './contextAgent.js';
+import { gatherContext, routeIntent, evaluateExecutionComplexity } from './contextAgent.js';
 import { verifyChangedFiles } from './verificationService.js';
 import { buildContextInjection } from '../utils/contextPrompts.js';
+import { historyText } from '../utils/historyPrompt.js';
 // Submodule Imports
 import { AsyncInputHandler } from './agent/inputHandler.js';
 import { processResponse } from './agent/toolLoop.js';
 import { handleSlashCommand } from './agent/slashCommands.js';
-marked.use(markedTerminal());
+import { getMetricCollector } from './metrics.js';
+import { Orchestrator } from './orchestration/orchestrator.js';
+import { isSubAgentsEnabled } from './agent-tools.js';
+import { runWithAgentId } from '../utils/asyncContext.js';
+marked.use(markedTerminal({ reflowText: false }));
 // Export submodules for potential external uses if required
 export { AsyncInputHandler } from './agent/inputHandler.js';
 /**
@@ -77,7 +83,9 @@ export async function startAgentLoop(workspaceRoot, version) {
     const chat = createSharedChatSession();
     const inputHandler = new AsyncInputHandler();
     const chatSessionState = { id: crypto.randomUUID(), title: '' };
+    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.
@@ -102,7 +110,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();
+        const { userInput: rawInput, canceled } = await collectUserInput(sessionInputHistory, isPlanMode);
         if (canceled) {
             p.outro(pc.green('Goodbye! Happy coding. 🚀'));
             return;
@@ -111,16 +119,28 @@ export async function startAgentLoop(workspaceRoot, version) {
         if (!userInput) {
             continue;
         }
+        // Push non-empty input to history if it's not the same as the last item
+        if (sessionInputHistory[sessionInputHistory.length - 1] !== userInput) {
+            sessionInputHistory.push(userInput);
+        }
         // Capture standalone forward slash triggers to open the selection console
         if (userInput === '/') {
             const commandMenu = await p['select']({
                 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)' },
                     { 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' },
                     { value: '/debug', label: '/debug', hint: 'Toggle internal debug logs' },
                     { value: '/auto-approve', label: '/auto-approve', hint: 'Approve all future terminal commands' },
+                    { value: '/sub-agents', label: '/sub-agents', hint: 'Toggle the MMAAK Engine for parallel investigation and execution' },
+                    {
+                        value: '/semantic-search',
+                        label: '/semantic-search',
+                        hint: 'Toggle local vector index capabilities for better search',
+                    },
+                    { value: '/stats', label: '/stats', hint: 'View current session statistics and configuration' },
                     { value: '/commit', label: '/commit', hint: 'Auto-commit changes with AI message' },
                     { value: '/revert', label: '/revert', hint: 'Undo last change' },
                     { value: '/chats', label: '/chats', hint: 'View or resume past chat sessions' },
@@ -151,12 +171,16 @@ 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;
             }
@@ -165,6 +189,36 @@ 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;
+        }
+    }
+}
+export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHandler, chatSessionState, isPlanMode, cachedContextResult) {
+    return runWithAgentId('main', async () => {
         const turnStartTime = Date.now();
         const spinner = p.spinner();
         const ac = new AbortController();
@@ -175,12 +229,20 @@ export async function startAgentLoop(workspaceRoot, version) {
             let finalInput = userInput;
             // Stage 1: Gather Workspace Context and route intentions
             spinner.start('🔍 Investigating workspace...');
-            const chatHistory = chat.getRecentHistory(3);
-            const gatherRes = await gatherContext(workspaceRoot, userInput, chatHistory, inputHandler, ac.signal, (msg) => {
-                if (!inputHandler.isCurrentlyPrompting()) {
-                    spinner.message(`🔍 Investigating workspace... ${pc.dim(msg)}`);
-                }
-            });
+            let gatherRes = { targetAgent: 'EXECUTE', chainedMessages: [], contextResult: cachedContextResult || null };
+            if (!cachedContextResult) {
+                const collector = getMetricCollector();
+                if (collector)
+                    collector.startTimer('contextGather');
+                const chatHistory = chat.getRecentHistory(3);
+                gatherRes = await gatherContext(workspaceRoot, userInput, chatHistory, inputHandler, ac.signal, (msg) => {
+                    if (!inputHandler.isCurrentlyPrompting()) {
+                        spinner.message(`🔍 Investigating workspace... ${pc.dim(msg)}`);
+                    }
+                });
+                if (collector)
+                    collector.stopTimer('contextGather');
+            }
             let latestUsage = undefined;
             // Collect any inputs that were queued while the Context Agent was investigating
             const leftoverMsg = inputHandler.getAndClear();
@@ -213,26 +275,64 @@ export async function startAgentLoop(workspaceRoot, version) {
             }
             // Hot-swap the underlying LLM system instruction context depending on intent (conversational vs execution)
             debugLog(`Intent Router output: original targetAgent = ${gatherRes.targetAgent}, effective = ${effectiveTargetAgent}`);
-            const config = effectiveTargetAgent === 'CHAT' ? getGeneralChatConfig() : getPlanExecutionConfig();
+            let config;
+            if (isPlanMode) {
+                const { getPlanModeConfig } = await import('./ai.js');
+                config = getPlanModeConfig();
+            }
+            else {
+                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
-                gatherRes.contextResult.relevantFiles = await compressContextFiles(workspaceRoot, gatherRes.contextResult);
+                if (!cachedContextResult) {
+                    gatherRes.contextResult.relevantFiles = await compressContextFiles(workspaceRoot, gatherRes.contextResult);
+                }
                 // Assemble the final context injection string
                 const contextInjection = buildContextInjection(gatherRes.contextResult);
                 debugLog(`Final compressed context injection size: ${contextInjection.length} chars`);
+                const collector = getMetricCollector();
+                if (collector)
+                    collector.recordCompressedContextSize(contextInjection.length);
                 dynamicSystemInstruction += '\n\n' + contextInjection;
             }
             // Apply the dynamic prompt updates and tool registrations to the active chat session
             chat.setAgentConfig(dynamicSystemInstruction, config.tools);
+            if (getGlobalActiveModel() === GEMINI_MODELS.AUTO) {
+                let selectedModel = GEMINI_MODELS.FLASH_3_5;
+                if (effectiveTargetAgent === 'CHAT') {
+                    selectedModel = GEMINI_MODELS.FLASH_LITE_3_1;
+                }
+                else {
+                    spinner.start(pc.blue('🧠 Evaluating execution complexity...'));
+                    const complexity = await evaluateExecutionComplexity(finalInput, gatherRes.contextResult?.summary, gatherRes.contextResult?.relevantFiles?.size || 0);
+                    spinner.stop();
+                    process.stdout.write('\x1b[2K\r');
+                    selectedModel = complexity === 'EASY' ? GEMINI_MODELS.FLASH_LITE_3_1 : GEMINI_MODELS.FLASH_3_5;
+                }
+                chat.setModel(selectedModel);
+                debugLog(`Auto-routing to model ${selectedModel} based on intent ${effectiveTargetAgent}`);
+            }
+            else {
+                chat.setModel(getGlobalActiveModel());
+            }
             if (gatherRes.contextResult) {
-                if (!inputHandler.isCurrentlyPrompting()) {
-                    spinner.stop(pc.green('🔍 Investigation completed.'));
-                    spinner.start('Thinking...');
+                if (!gatherRes.contextResult.isParallel) {
+                    if (!inputHandler.isCurrentlyPrompting()) {
+                        spinner.stop(pc.green('🔍 Investigation completed.'));
+                        spinner.start('Thinking...');
+                    }
+                    else {
+                        p.log.success(pc.green('🔍 Investigation completed.'));
+                    }
                 }
                 else {
-                    p.log.success(pc.green('🔍 Investigation completed.'));
+                    // Parallel investigation already printed its own detailed summary log
+                    if (!inputHandler.isCurrentlyPrompting()) {
+                        spinner.start('Thinking...');
+                    }
                 }
             }
             else {
@@ -240,27 +340,106 @@ export async function startAgentLoop(workspaceRoot, version) {
                     spinner.message('Thinking...');
                 }
             }
+            if (effectiveTargetAgent === 'EXECUTE' && isSubAgentsEnabled()) {
+                spinner.stop(); // Clear the spinner before delegating
+                process.stdout.write('\x1b[2K\r');
+                const orchestrator = new Orchestrator(workspaceRoot, chatSessionState.id, inputHandler);
+                const handledByOrchestrator = await orchestrator.runOrchestration(finalInput, dynamicSystemInstruction, ac.signal);
+                if (typeof handledByOrchestrator === 'string') {
+                    // The orchestrator successfully decomposed and ran the task.
+                    // Inject the task context into the main proxy chat session so the agent remembers what happened
+                    // and so the history state gets saved properly on disk.
+                    chat.getRawHistory().push({
+                        role: 'user',
+                        parts: [{ text: userInput }],
+                    });
+                    chat.getRawHistory().push({
+                        role: 'model',
+                        parts: [{ text: handledByOrchestrator }],
+                    });
+                    // Print the summary text just like single-agent mode
+                    if (handledByOrchestrator !== '[Generation stopped.]') {
+                        console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim(`(Orchestrator)`)}\n`);
+                        const cleanText = handledByOrchestrator.replace(/\n([ \t]*\n){2,}/g, '\n\n');
+                        console.log(marked.parse(cleanText));
+                    }
+                    // Print Usage Stats
+                    const usage = getGlobalLatestUsageMetadata();
+                    if (usage) {
+                        if (usage.cachedTokens > 0) {
+                            const totalInputTokens = (usage.promptTokens || 0) + usage.cachedTokens;
+                            const percentSaved = totalInputTokens > 0 ? Math.round((usage.cachedTokens / totalInputTokens) * 100) : 0;
+                            p.log.info(`${pc.green('⚡')} ${pc.green('Context Cache Hit:')} ${pc.bold(usage.cachedTokens.toLocaleString())} tokens cached ${pc.dim(`(Saved ~${percentSaved}% of input cost)`)}`);
+                        }
+                        if (usage.remainingBalance !== undefined) {
+                            p.log.info(`${pc.dim('Credits Remaining:')} ${pc.cyan(usage.remainingBalance.toLocaleString())}`);
+                        }
+                    }
+                    // Post-execution steps for the UI (saving history, invalidate cache)
+                    const postExecutionChanges = changeLogger.getCurrentChangeSet()?.changes || [];
+                    const modifiedFiles = postExecutionChanges
+                        .filter((c) => c.action === 'modify' || c.action === 'create' || c.action === 'delete')
+                        .map((c) => path.relative(workspaceRoot, c.filePath));
+                    if (modifiedFiles.length > 0) {
+                        await invalidateCacheForDependents(workspaceRoot, modifiedFiles);
+                    }
+                    const turnEndTime = Date.now();
+                    const turnDuration = ((turnEndTime - turnStartTime) / 1000).toFixed(1);
+                    p.log.info(`${pc.dim('Orchestration finished in')} ${pc.cyan(turnDuration + 's')}`);
+                    changeLogger.markComplete();
+                    changeLogger.commitChangeSet();
+                    // Auto-save chat history for the orchestrator turn
+                    const history = chat.getRawHistory();
+                    if (history.length > 0) {
+                        if (!chatSessionState.title) {
+                            chatSessionState.title = 'Generating title...';
+                            try {
+                                const title = await generateChatTitle(userInput);
+                                chatSessionState.title = title;
+                            }
+                            catch (e) {
+                                debugLog('Failed to save session with title: ' + e);
+                            }
+                        }
+                        chatHistoryService
+                            .saveSession({
+                            id: chatSessionState.id,
+                            title: chatSessionState.title,
+                            timestamp: Date.now(),
+                            history,
+                        })
+                            .catch((e) => debugLog('Failed to auto-save session: ' + e));
+                    }
+                    return;
+                }
+                // If it returned false, the graph was too simple (1 task) or failed, so we fall through to the single-agent loop.
+                if (!inputHandler.isCurrentlyPrompting()) {
+                    spinner.start('Thinking (Single-Agent)...');
+                }
+            }
             // Send the formulated prompt payload to the generative model
             let result;
             try {
                 result = await chat.sendMessage(finalInput, undefined, ac.signal);
             }
             catch (e) {
-                spinner.stop('');
+                spinner.stop();
+                process.stdout.write('\x1b[2K\r');
                 if (e.name === 'AbortError' || e.message?.includes('abort')) {
                     p.log.warn(pc.yellow('Generation aborted by user.'));
                 }
                 else {
                     p.log.error(pc.red(`Error communicating with AI: ${e.message || String(e)}`));
                 }
-                continue;
+                return;
             }
             latestUsage = result.response.usageMetadata?.();
             const grounding = result.response.groundingMetadata?.();
             if (grounding?.webSearchQueries && grounding.webSearchQueries.length > 0) {
                 p.log.info(`${pc.blue('🌐')} ${pc.dim('Google Search Queries:')} ${grounding.webSearchQueries.map((q) => pc.cyan(`"${q}"`)).join(', ')}`);
             }
-            spinner.stop('');
+            spinner.stop();
+            process.stdout.write('\x1b[2K\r');
             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)
@@ -303,44 +482,95 @@ export async function startAgentLoop(workspaceRoot, version) {
             if (history.length > 0) {
                 if (!chatSessionState.title) {
                     chatSessionState.title = 'Generating title...';
-                    generateChatTitle(userInput).then(title => {
+                    try {
+                        const title = await generateChatTitle(userInput);
                         chatSessionState.title = title;
-                        chatHistoryService.saveSession({
+                        await chatHistoryService.saveSession({
                             id: chatSessionState.id,
                             title: chatSessionState.title,
                             timestamp: Date.now(),
-                            history: chat.getRawHistory()
-                        }).catch(e => debugLog('Failed to save session with title: ' + e));
-                    });
+                            history: chat.getRawHistory(),
+                        });
+                    }
+                    catch (e) {
+                        debugLog('Failed to save session with title: ' + e);
+                    }
                 }
-                chatHistoryService.saveSession({
+                chatHistoryService
+                    .saveSession({
                     id: chatSessionState.id,
                     title: chatSessionState.title,
                     timestamp: Date.now(),
-                    history
-                }).catch(e => debugLog('Failed to auto-save session: ' + e));
+                    history,
+                })
+                    .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));
+                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: 'exit', label: 'Exit plan mode', hint: 'Return to normal chat without executing' },
+                    ],
+                });
+                if (p.isCancel(planAction) || planAction === 'exit') {
+                    planModeReturn = 'exit';
+                }
+                else if (planAction === 'edit') {
+                    planModeReturn = 'edit';
+                }
+                else if (planAction === 'proceed') {
+                    planModeReturn = 'proceed';
+                }
             }
+            return { planModeReturn, contextResult: gatherRes.contextResult };
         }
         catch (err) {
-            spinner.stop('');
             const message = err instanceof Error ? err.message : String(err);
             p.log.error(`${pc.red('Error:')} ${message}`);
         }
         finally {
+            spinner.stop();
+            process.stdout.write('\x1b[2K\r');
             // Persist any verified or partial changes into our session change ledger.
             // This ensures that if the process crashes, errors out, or is aborted mid-generation,
             // the user can still use /revert to undo the partial file mutations.
+            const changedFiles = changeLogger.getChangedFiles();
             changeLogger.commitChangeSet();
+            // Delta-update the embedding index if there were changes
+            if (changedFiles.length > 0) {
+                try {
+                    const { getEmbeddingIndex } = await import('./embeddingIndex.js');
+                    const index = getEmbeddingIndex();
+                    // Only update if it's already loaded in memory
+                    if (index.isReady()) {
+                        await index.updateIndex(workspaceRoot, changedFiles);
+                        await index.save(workspaceRoot);
+                    }
+                }
+                catch (e) {
+                    debugLog(`Failed to delta-update embedding index: ${e.message}`);
+                }
+            }
         }
-    }
+    });
 }
-async function collectUserInput() {
+async function collectUserInput(history, isPlanMode) {
     let lines = [];
     let isMultiLine = false;
     while (true) {
-        const userInputRaw = await p.text({
-            message: isMultiLine ? '  ' : pc.magenta('❯'),
+        const userInputRaw = await historyText({
+            message: isMultiLine ? '  ' : isPlanMode ? pc.cyan('(Plan Mode) ❯') : pc.magenta('❯'),
             placeholder: isMultiLine ? '' : 'Use "\\" for new lines',
+            history,
         });
         if (p.isCancel(userInputRaw)) {
             if (isMultiLine) {
@@ -376,10 +606,12 @@ async function compressContextFiles(workspaceRoot, contextResult) {
     const cachedContext = readCache(workspaceRoot, 'context_cache.json') || {};
     let cacheUpdated = false;
     const compressedFiles = new Map();
-    for (const [filePath, content] of contextResult.relevantFiles.entries()) {
-        if (content.length < 2000) {
+    for (const [filePath, contentObj] of contextResult.relevantFiles.entries()) {
+        const content = contentObj.text;
+        const inlineData = contentObj.inlineData;
+        if (content.length < 2000 && !inlineData) {
             debugLog(`Bypassing cache and compression for ${filePath} (length ${content.length} < 2000)`);
-            compressedFiles.set(filePath, content);
+            compressedFiles.set(filePath, contentObj);
             continue;
         }
         const fileHash = crypto
@@ -388,13 +620,13 @@ async function compressContextFiles(workspaceRoot, contextResult) {
             .digest('hex');
         if (cachedContext[fileHash]) {
             debugLog(`Context cache HIT for file ${filePath} (hash ${fileHash.substring(0, 8)})`);
-            compressedFiles.set(filePath, cachedContext[fileHash]);
+            compressedFiles.set(filePath, { text: cachedContext[fileHash] });
         }
         else {
             debugLog(`Context cache MISS for file ${filePath} (hash ${fileHash.substring(0, 8)})`);
             const compressPrompt = `Summarize the following file contents concisely. Preserve all exports, functions, classes, variables, and architectural purpose. Keep it under 2000 characters if possible. File: ${filePath}`;
-            const summary = await compressTextUsingFlashLite(content, compressPrompt);
-            compressedFiles.set(filePath, summary);
+            const summary = await compressTextUsingFlashLite(content, compressPrompt, inlineData);
+            compressedFiles.set(filePath, { text: summary });
             cachedContext[fileHash] = summary;
             cacheUpdated = true;
         }
@@ -441,8 +673,12 @@ async function executeSelfCorrectionLoop(chat, initialResult, workspaceRoot, inp
             const forcePrompt = `AUTOMATED SYSTEM CHECK: You did not modify any files. You MUST use your file modification tools to apply a fix for the previously mentioned errors. Do not just explain the issue.`;
             spinner.start('Thinking (Correction)...');
             result = await chat.sendMessage(forcePrompt);
-            spinner.stop('');
+            spinner.stop();
+            process.stdout.write('\x1b[2K\r');
             correctionAttempts++;
+            const collector = getMetricCollector();
+            if (collector)
+                collector.recordSelfCorrection();
             continue;
         }
         previousChangeCount = currentChanges.length;
@@ -466,9 +702,17 @@ async function executeSelfCorrectionLoop(chat, initialResult, workspaceRoot, inp
         }
         if (!hasErrors) {
             p.log.success('Verification passed.');
+            const collector = getMetricCollector();
+            if (collector && correctionAttempts === 0)
+                collector.recordVerificationResult(true);
             break;
         }
+        const collector = getMetricCollector();
+        if (collector && correctionAttempts === 0)
+            collector.recordVerificationResult(false);
         correctionAttempts++;
+        if (collector)
+            collector.recordSelfCorrection();
         if (correctionAttempts > MAX_CORRECTIONS) {
             p.log.warn('Max self-correction attempts reached. Leaving remaining issues for manual review.');
             break;
@@ -496,7 +740,8 @@ async function executeSelfCorrectionLoop(chat, initialResult, workspaceRoot, inp
         const correctionPrompt = `AUTOMATED SYSTEM CHECK: Your previous changes resulted in the following issues:\n\n${combinedIssuesForAI}\n\nPlease analyze these issues and use your file modification tools to fix them.`;
         spinner.start('Thinking (Correction)...');
         result = await chat.sendMessage(correctionPrompt);
-        spinner.stop('');
+        spinner.stop();
+        process.stdout.write('\x1b[2K\r');
     }
     return { finalText };
 }

package/dist/services/ai.d.ts

@@ -1,4 +1,9 @@
 import type { Content, FunctionCall } from '@google/generative-ai';
+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;
+export declare function getGlobalLatestUsageMetadata(): any;
 export declare class ProxyChatSession {
     private history;
     private modelName;
@@ -31,7 +36,7 @@ export declare class ProxyChatSession {
             name: string;
             response: any;
         };
-    }>, additionalText?: string, abortSignal?: AbortSignal): Promise<{
+    }>, additionalText?: string, abortSignal?: AbortSignal, onChunk?: (chunk: string) => void): Promise<{
         response: {
             text: () => string;
             functionCalls: () => FunctionCall[] | undefined;
@@ -56,16 +61,25 @@ 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-3.1-flash-lite.
  * Used for shrinking context payloads to prevent OOM/choking.
  */
-export declare function compressTextUsingFlashLite(text: string, instruction?: string): Promise<string>;
-export declare const CONTEXT_AGENT_MODEL: "gemini-3.5-flash";
+export declare function compressTextUsingFlashLite(text: string, instruction?: string, inlineData?: any): Promise<string>;
+/**
+ * Returns the tool declarations for the read-only Context Agent.
+ * Extracted as a reusable function so investigation sub-agents can import
+ * the same schema without duplicating the declarations.
+ */
+export declare function getContextToolDeclarations(): any[];
 export declare function createContextAgentSession(): any;
-export declare const INTENT_ROUTER_MODEL: "gemini-3.1-flash-lite";
 export declare function createIntentRouterSession(): any;
-export declare const WEB_SEARCH_AGENT_MODEL: "gemini-3.1-flash-lite";
+export declare function createExecutionComplexitySession(): any;
+export declare function createInvestigationComplexitySession(): any;
 export declare function createWebSearchAgentSession(): any;
 /**
  * Generates a concise title for a chat session based on the user's first message.