minovative-mind-cli 1.5.1 → 2.1.0

package/dist/services/agent/slashCommands.js

@@ -4,13 +4,14 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
-import { toggleDebugMode } from '../../utils/logger.js';
+import crypto from 'node:crypto';
+import { toggleDebugMode, isDebugOn } from '../../utils/logger.js';
 import { changeLogger } from '../changeLogger.js';
 import { chatHistoryService } from '../chatHistoryService.js';
 import { printLogo, brandBg, brandFg } from '../../utils/logo.js';
 import { readPaste } from '../../utils/paste.js';
-import { setApprovalMode, getApprovalMode } from '../agent-tools.js';
-import { ProxyChatSession } from '../ai.js';
+import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled, isSemanticSearchEnabled, setSemanticSearchEnabled, } from '../agent-tools.js';
+import { ProxyChatSession, setGlobalActiveModel, getGlobalActiveModel, getGlobalLatestUsageMetadata } from '../ai.js';
 const execAsync = promisify(exec);
 /**
  * Handles all slash command operations (/paste, /clear, /models, /debug, /auto-approve, /revert, /commit).
@@ -39,6 +40,16 @@ export async function handleSlashCommand(command, context) {
             return { shouldContinue: true, isRawPasteMode: false };
         }
     }
+    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 };
+    }
     if (lowerCommand === '/clear') {
         chat.clearHistory();
         process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
@@ -71,10 +82,16 @@ export async function handleSlashCommand(command, context) {
                     label: 'Gemini 3.1 Flash-Lite',
                     hint: 'Ultra-fast and cost-effective',
                 },
+                {
+                    value: 'auto',
+                    label: 'Auto (Flash-Lite / Flash 3.5)',
+                    hint: 'Dynamically routes between Flash-Lite and Flash 3.5 based on prompt complexity',
+                },
             ],
         });
         if (!p.isCancel(selectedModel)) {
             chat.setModel(selectedModel);
+            setGlobalActiveModel(selectedModel);
             p.log.success(`Model successfully switched to ${pc.cyan(selectedModel)}`);
         }
         return { shouldContinue: true };
@@ -100,41 +117,149 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
+    if (lowerCommand === '/sub-agents') {
+        if (isSubAgentsEnabled()) {
+            setSubAgentsEnabled(false);
+            p.log.success('MMAAK Engine disabled. Single-agent mode active.');
+        }
+        else {
+            setSubAgentsEnabled(true);
+            p.log.success('MMAAK Engine enabled. The system will now use parallel investigation and thread agents.');
+        }
+        return { shouldContinue: true };
+    }
+    if (lowerCommand === '/semantic-search') {
+        if (isSemanticSearchEnabled()) {
+            setSemanticSearchEnabled(false);
+            p.log.success('Semantic search disabled. The vector indexing layer is now turned off.');
+        }
+        else {
+            setSemanticSearchEnabled(true);
+            p.log.success('Semantic search enabled. The AST-aware vector index is active.');
+        }
+        return { shouldContinue: true };
+    }
+    if (lowerCommand === '/stats') {
+        const latestUsage = getGlobalLatestUsageMetadata();
+        const currentModel = chat.getModel();
+        const globalModel = getGlobalActiveModel();
+        const displayModel = globalModel === 'auto' ? `Auto (Last turn: ${currentModel})` : currentModel;
+        const autoApprove = getApprovalMode() === 'skip-all' ? 'Enabled' : 'Disabled';
+        const subAgents = isSubAgentsEnabled() ? 'Enabled' : 'Disabled';
+        const semanticSearch = isSemanticSearchEnabled() ? 'Enabled' : 'Disabled';
+        const planMode = context.isPlanMode ? '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('Semantic Search:')}  ${semanticSearch === 'Enabled' ? pc.green(semanticSearch) : pc.yellow(semanticSearch)}`);
+        console.log(`${pc.bold('Plan Mode:')}        ${planMode === 'Enabled' ? pc.green(planMode) : pc.yellow(planMode)}`);
+        const debugMode = isDebugOn() ? 'Enabled' : 'Disabled';
+        console.log(`${pc.bold('Debug Log:')}        ${debugMode === 'Enabled' ? pc.green(debugMode) : pc.yellow(debugMode)}`);
+        if (latestUsage) {
+            if (latestUsage.remainingBalance !== undefined) {
+                let diffStr = '';
+                if (latestUsage.creditsUsed !== undefined) {
+                    const before = latestUsage.remainingBalance + latestUsage.creditsUsed;
+                    console.log(`${pc.bold('Credits Before:')}   ${pc.cyan(before.toLocaleString())}`);
+                    const diff = -latestUsage.creditsUsed;
+                    if (diff < 0) {
+                        diffStr = ` ${pc.red(`(${diff})`)}`;
+                    }
+                    else if (diff > 0) {
+                        diffStr = ` ${pc.green(`(+${diff})`)}`;
+                    }
+                    else {
+                        diffStr = ` ${pc.dim(`(0)`)}`;
+                    }
+                }
+                console.log(`${pc.bold('Credits Left:')}     ${pc.cyan(latestUsage.remainingBalance.toLocaleString())}${diffStr}`);
+            }
+            const totalInputTokens = (latestUsage.promptTokens || 0) + (latestUsage.cachedTokens || 0);
+            if (totalInputTokens > 0) {
+                console.log(`${pc.bold('Last Turn Input:')}  ${totalInputTokens.toLocaleString()} tokens`);
+            }
+            if (latestUsage.candidatesTokens) {
+                console.log(`${pc.bold('Last Turn Output:')} ${latestUsage.candidatesTokens.toLocaleString()} tokens`);
+            }
+        }
+        else {
+            console.log(`${pc.bold('Token Usage:')}      No data available yet.`);
+        }
+        console.log(pc.dim('----------------------------------------\n'));
+        return { shouldContinue: true };
+    }
     if (lowerCommand === '/revert') {
+        const isEnabled = changeLogger.getIsEnabled();
         const history = changeLogger.getHistory();
-        if (!history || history.length === 0) {
-            p.log.warn('No changes to revert.');
-            return { shouldContinue: true };
-        }
-        const lastChangeSet = history[history.length - 1];
         const truncate = (str, max) => {
             const singleLine = str.replace(/\s+/g, ' ').trim();
             return singleLine.length > max ? singleLine.substring(0, max - 3) + '...' : singleLine;
         };
+        let lastChangeSet = null;
+        const options = [];
+        if (isEnabled && history && history.length > 0) {
+            lastChangeSet = history[history.length - 1];
+            options.push({
+                value: 'revert_last',
+                label: `Revert last change (${truncate(lastChangeSet.description, 50)})${lastChangeSet.status === 'partial' ? ' [Partial]' : ''}`,
+            });
+            options.push({ value: 'view_history', label: 'View history' });
+        }
+        if (isEnabled) {
+            options.push({ value: 'disable_revert', label: 'Disable' });
+        }
+        else {
+            options.push({ value: 'enable_revert', label: 'Enable' });
+        }
+        options.push({ value: 'cancel', label: 'Cancel' });
         const revertMenu = await p['select']({
-            message: 'Revert Menu',
-            options: [
-                {
-                    value: 'revert_last',
-                    label: `Revert last change (${truncate(lastChangeSet.description, 50)})${lastChangeSet.status === 'partial' ? ' [Partial]' : ''}`,
-                },
-                { value: 'view_history', label: 'View history' },
-                { value: 'cancel', label: 'Cancel' },
-            ],
+            message: isEnabled && history.length === 0 ? 'Revert Menu (No changes to revert)' : 'Revert Menu',
+            options,
         });
         if (p.isCancel(revertMenu) || revertMenu === 'cancel') {
             return { shouldContinue: true };
         }
-        let targetTimestamp = lastChangeSet.timestamp;
+        if (revertMenu === 'disable_revert') {
+            changeLogger.setIsEnabled(false);
+            p.log.success('Revert command has been disabled. File modifications will no longer be tracked.');
+            return { shouldContinue: true };
+        }
+        if (revertMenu === 'enable_revert') {
+            changeLogger.setIsEnabled(true);
+            p.log.success('Revert command has been enabled. Future file modifications will be tracked.');
+            return { shouldContinue: true };
+        }
+        let targetTimestamp = lastChangeSet ? lastChangeSet.timestamp : null;
         if (revertMenu === 'view_history') {
+            const { workspaceRegistry } = await import('../workspaceRegistry.js');
             const historyOptions = history
                 .slice()
                 .reverse()
-                .map((cs, i) => ({
-                value: cs.timestamp,
-                label: `[${i === 0 ? 'Latest' : `-${i}`}] ${truncate(cs.description, 50)} (${new Date(cs.timestamp).toLocaleTimeString()})${cs.status === 'partial' ? ' [Partial]' : ''}`,
-                hint: `Reverts this and all ${i} changes after it`,
-            }));
+                .map((cs, i) => {
+                const externalWorkspaces = new Set();
+                for (const change of cs.changes) {
+                    if (change.filePath.startsWith('@')) {
+                        const slashIndex = change.filePath.indexOf('/');
+                        const aliasStr = slashIndex === -1 ? change.filePath.substring(1) : change.filePath.substring(1, slashIndex);
+                        const ws = workspaceRegistry.get(aliasStr);
+                        if (ws) {
+                            const rootName = path.basename(ws.absolutePath);
+                            externalWorkspaces.add(rootName);
+                        }
+                        else {
+                            externalWorkspaces.add(`@${aliasStr}`);
+                        }
+                    }
+                }
+                const tags = externalWorkspaces.size > 0 ? pc.blue(` [${Array.from(externalWorkspaces).join(', ')}]`) : '';
+                return {
+                    value: cs.timestamp,
+                    label: `[${i === 0 ? 'Latest' : `-${i}`}] ${truncate(cs.description, 50)}${tags} (${new Date(cs.timestamp).toLocaleTimeString()})${cs.status === 'partial' ? ' [Partial]' : ''}`,
+                    hint: `Reverts this and all ${i} changes after it`,
+                };
+            });
             const selectedHistory = await p['select']({
                 message: 'Select the point in history to revert back to:',
                 options: [...historyOptions, { value: -1, label: 'Cancel' }],
@@ -149,13 +274,14 @@ export async function handleSlashCommand(command, context) {
         try {
             const changesToRevert = changeLogger.popUntil(targetTimestamp);
             const flatChanges = changesToRevert.flatMap((cs) => cs.changes);
+            const { resolveAndValidateMultiWorkspacePath } = await import('../../utils/pathSecurity.js');
             for (const change of flatChanges) {
-                const absPath = path.resolve(workspaceRoot, change.filePath);
+                const { absolutePath } = resolveAndValidateMultiWorkspacePath(workspaceRoot, change.filePath);
                 if (change.action === 'create') {
-                    await fs.rm(absPath, { force: true });
+                    await fs.rm(absolutePath, { force: true });
                 }
                 else if (change.originalContent !== null) {
-                    await fs.writeFile(absPath, change.originalContent, 'utf-8');
+                    await fs.writeFile(absolutePath, change.originalContent, 'utf-8');
                 }
             }
             spinner.stop('Reverted successfully.');
@@ -168,33 +294,75 @@ export async function handleSlashCommand(command, context) {
         return { shouldContinue: true };
     }
     if (lowerCommand === '/chats') {
-        const sessions = chatHistoryService.getSessions();
-        if (!sessions || sessions.length === 0) {
-            p.log.warn('No chat history found.');
-            return { shouldContinue: true };
+        const sessions = chatHistoryService.getSessions() || [];
+        const hasSessions = sessions.length > 0;
+        const options = [{ value: 'new', label: 'New Chat' }];
+        if (hasSessions) {
+            options.push({ value: 'resume', label: 'View Chats' });
+            options.push({ value: 'delete', label: 'Delete Chat' });
         }
+        options.push({ value: 'cancel', label: 'Cancel' });
         const truncate = (str, max) => {
             const singleLine = str.replace(/\s+/g, ' ').trim();
             return singleLine.length > max ? singleLine.substring(0, max - 3) + '...' : singleLine;
         };
         const chatsMenu = await p['select']({
             message: 'Chat Sessions',
-            options: [
-                { value: 'resume', label: 'Resume another chat' },
-                { value: 'delete', label: 'Delete a past chat' },
-                { value: 'cancel', label: 'Cancel' },
-            ],
+            options,
         });
         if (p.isCancel(chatsMenu) || chatsMenu === 'cancel') {
             return { shouldContinue: true };
         }
+        if (chatsMenu === 'new') {
+            chat.clearHistory();
+            if (chatSessionState) {
+                chatSessionState.id = crypto.randomUUID();
+                chatSessionState.title = '';
+            }
+            process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
+            printLogo();
+            p.intro(`${brandBg(' Minovative Mind CLI ')} ${pc.dim('v' + version)}`);
+            p.log.info(`${pc.dim('Workspace:')} ${brandFg(workspaceRoot)}`);
+            p.log.info(`${pc.dim('Commands:')} Type ${pc.yellow('/')} to open the command menu and "${pc.yellow('stop')}" to stop the ai generation. Type ${pc.yellow('exit')} to leave.`);
+            p.log.success('Started a new chat session.');
+            console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
+            return { shouldContinue: true };
+        }
+        const { workspaceRegistry } = await import('../workspaceRegistry.js');
         const sessionOptions = sessions
             .slice()
             .reverse()
-            .map((s) => ({
-            value: s.id,
-            label: `${truncate(s.title, 50)} (${new Date(s.timestamp).toLocaleString()})`,
-        }));
+            .map((s) => {
+            const externalWorkspaces = new Set();
+            if (s.history) {
+                for (const item of s.history) {
+                    if (item.role === 'user' || !item.parts)
+                        continue;
+                    for (const part of item.parts) {
+                        if (part.functionCall && part.functionCall.args && part.functionCall.args.filePath) {
+                            const p = part.functionCall.args.filePath;
+                            if (typeof p === 'string' && p.startsWith('@')) {
+                                const slashIndex = p.indexOf('/');
+                                const aliasStr = slashIndex === -1 ? p.substring(1) : p.substring(1, slashIndex);
+                                const ws = workspaceRegistry.get(aliasStr);
+                                if (ws) {
+                                    const rootName = path.basename(ws.absolutePath);
+                                    externalWorkspaces.add(rootName);
+                                }
+                                else {
+                                    externalWorkspaces.add(`@${aliasStr}`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            const tags = externalWorkspaces.size > 0 ? pc.blue(` [${Array.from(externalWorkspaces).join(', ')}]`) : '';
+            return {
+                value: s.id,
+                label: `${truncate(s.title, 50)}${tags} (${new Date(s.timestamp).toLocaleString()})`,
+            };
+        });
         if (chatsMenu === 'resume') {
             const selectedSessionId = await p['select']({
                 message: 'Select a session to resume:',
@@ -219,13 +387,19 @@ export async function handleSlashCommand(command, context) {
                 // Print the loaded history so the user can see past context
                 for (const item of session.history) {
                     if (item.role === 'user') {
-                        const text = item.parts.map((p) => p.text).filter(Boolean).join('\n');
+                        const text = item.parts
+                            .map((p) => p.text)
+                            .filter(Boolean)
+                            .join('');
                         if (text) {
-                            p.log.step(pc.cyan(text));
+                            p.log.step(pc.bgBlue(pc.white(` ${text} `)));
                         }
                     }
                     else if (item.role === 'model') {
-                        const text = item.parts.map((p) => p.text).filter(Boolean).join('\n');
+                        const text = item.parts
+                            .map((p) => p.text)
+                            .filter(Boolean)
+                            .join('');
                         if (text) {
                             console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim('(Resumed)')}\n`);
                             const { marked } = await import('marked');
@@ -260,6 +434,159 @@ export async function handleSlashCommand(command, context) {
         }
         return { shouldContinue: true };
     }
+    if (lowerCommand === '/workspaces') {
+        const { workspaceRegistry } = await import('../workspaceRegistry.js');
+        while (true) {
+            const allRoots = workspaceRegistry.getAllRoots(workspaceRoot);
+            const options = [];
+            options.push({ value: 'add', label: 'Add Workspace' });
+            const externalRoots = allRoots.filter(r => r.alias);
+            if (externalRoots.length > 0) {
+                options.push({ value: 'edit', label: 'Edit Workspace' });
+                options.push({ value: 'remove', label: 'Remove Workspace' });
+                options.push({ value: 'list', label: 'List Workspaces' });
+            }
+            options.push({ value: 'cancel', label: 'Exit Menu' });
+            const action = await p['select']({
+                message: 'Manage External Workspaces',
+                options,
+            });
+            if (p.isCancel(action) || action === 'cancel') {
+                break;
+            }
+            if (action === 'add') {
+                const aliasStr = await p['text']({
+                    message: 'Enter a short alias (e.g. backend, ui):',
+                    validate: (val) => {
+                        if (!val)
+                            return 'Alias is required';
+                        if (!/^[a-zA-Z0-9_-]+$/.test(val))
+                            return 'Only letters, numbers, hyphens, and underscores';
+                        if (workspaceRegistry.getAllRoots(workspaceRoot).some(r => r.alias === val))
+                            return 'Alias already in use';
+                    }
+                });
+                if (p.isCancel(aliasStr))
+                    continue;
+                const rootPathStr = await p['text']({
+                    message: 'Enter the absolute path to the workspace root (e.g. /Users/name/Projects/app):',
+                    validate: (val) => {
+                        if (!val)
+                            return 'Path is required';
+                    }
+                });
+                if (p.isCancel(rootPathStr))
+                    continue;
+                let cleanRootPathStr = rootPathStr.trim();
+                if ((cleanRootPathStr.startsWith("'") && cleanRootPathStr.endsWith("'")) ||
+                    (cleanRootPathStr.startsWith('"') && cleanRootPathStr.endsWith('"'))) {
+                    cleanRootPathStr = cleanRootPathStr.slice(1, -1);
+                }
+                try {
+                    const stats = await fs.stat(cleanRootPathStr);
+                    if (!stats.isDirectory()) {
+                        p.log.error('Path is not a directory.');
+                        continue;
+                    }
+                    workspaceRegistry.register(aliasStr, cleanRootPathStr);
+                    p.log.success(`Added @${aliasStr} -> ${cleanRootPathStr}`);
+                }
+                catch (e) {
+                    p.log.error(`Invalid path or directory does not exist: ${cleanRootPathStr}`);
+                }
+            }
+            else if (action === 'edit') {
+                const editOptions = externalRoots.map(r => ({
+                    value: r.alias,
+                    label: `@${r.alias} -> ${r.root}`
+                }));
+                editOptions.push({ value: 'cancel', label: 'Cancel' });
+                const aliasToEdit = await p['select']({
+                    message: 'Select workspace to edit:',
+                    options: editOptions
+                });
+                if (p.isCancel(aliasToEdit) || aliasToEdit === 'cancel')
+                    continue;
+                const ws = workspaceRegistry.get(aliasToEdit);
+                if (!ws)
+                    continue;
+                const newAliasStr = await p['text']({
+                    message: `Enter new alias (current: ${ws.alias}):`,
+                    initialValue: ws.alias,
+                    validate: (val) => {
+                        if (!val)
+                            return 'Alias is required';
+                        if (!/^[a-zA-Z0-9_-]+$/.test(val))
+                            return 'Only letters, numbers, hyphens, and underscores';
+                        if (val !== ws.alias && workspaceRegistry.getAllRoots(workspaceRoot).some(r => r.alias === val))
+                            return 'Alias already in use';
+                    }
+                });
+                if (p.isCancel(newAliasStr))
+                    continue;
+                const newRootPathStr = await p['text']({
+                    message: `Enter absolute path to workspace root (e.g. /Users/name/Projects/app):`,
+                    initialValue: ws.absolutePath,
+                    validate: (val) => {
+                        if (!val)
+                            return 'Path is required';
+                    }
+                });
+                if (p.isCancel(newRootPathStr))
+                    continue;
+                let cleanNewRootPathStr = newRootPathStr.trim();
+                if ((cleanNewRootPathStr.startsWith("'") && cleanNewRootPathStr.endsWith("'")) ||
+                    (cleanNewRootPathStr.startsWith('"') && cleanNewRootPathStr.endsWith('"'))) {
+                    cleanNewRootPathStr = cleanNewRootPathStr.slice(1, -1);
+                }
+                try {
+                    const stats = await fs.stat(cleanNewRootPathStr);
+                    if (!stats.isDirectory()) {
+                        p.log.error('Path is not a directory.');
+                        continue;
+                    }
+                    // Remove old alias first to avoid duplicate alias error, or to clean up
+                    workspaceRegistry.unregister(ws.alias);
+                    workspaceRegistry.register(newAliasStr, cleanNewRootPathStr);
+                    p.log.success(`Updated @${newAliasStr} -> ${cleanNewRootPathStr}`);
+                }
+                catch (e) {
+                    // If register failed, try to rollback
+                    p.log.error(`Failed to update workspace: ${e instanceof Error ? e.message : String(e)}`);
+                    try {
+                        workspaceRegistry.register(ws.alias, ws.absolutePath);
+                    }
+                    catch { }
+                }
+            }
+            else if (action === 'remove') {
+                const removeOptions = externalRoots.map(r => ({
+                    value: r.alias,
+                    label: `@${r.alias} -> ${r.root}`
+                }));
+                removeOptions.push({ value: 'cancel', label: 'Cancel' });
+                const aliasToRemove = await p['select']({
+                    message: 'Select workspace to remove:',
+                    options: removeOptions
+                });
+                if (p.isCancel(aliasToRemove) || aliasToRemove === 'cancel')
+                    continue;
+                workspaceRegistry.unregister(aliasToRemove);
+                p.log.success(`Removed @${aliasToRemove}`);
+            }
+            else if (action === 'list') {
+                for (const { alias, root } of allRoots) {
+                    if (alias) {
+                        p.log.step(`${pc.blue(`@${alias}`)} -> ${pc.dim(root)}`);
+                    }
+                    else {
+                        p.log.step(`${pc.cyan('(primary)')} -> ${pc.dim(root)}`);
+                    }
+                }
+            }
+        }
+        return { shouldContinue: true };
+    }
     if (lowerCommand === '/commit') {
         const commitSpinner = p.spinner();
         commitSpinner.start('Staging changes and analyzing diff...');

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

@@ -25,7 +25,7 @@ export declare function formatToolCall(name: string, args: Record<string, unknow
  * 6. **Submit Loop Frame**: Feeds execution outcomes back to the Gemini session and recursively repeats this sequence until the LLM produces a final text answer without further tool requests.
  *
  * ### Limits & Recovery Guardrails:
- * - **Turn-Limiting**: Capped at `MAX_TURNS` (100) to prevent infinite loops, API token drain, or excessive billing if the AI gets stuck in a repetitive loop.
+ * - **Turn-Limiting**: Capped at `MAX_TURNS` (Infinity) to prevent infinite loops, API token drain, or excessive billing if the AI gets stuck in a repetitive loop.
  * - **Empty-Response Healing**: If the API returns an empty text response with no tools, the system initiates up to `MAX_EMPTY_RETRIES` (3) system-driven wake-up prompts to re-engage the model.
  *
  * @param chat - The current active proxy chat session.

package/dist/services/agent/toolLoop.js

@@ -5,6 +5,7 @@ import { executeTool } from '../agent-tools.js';
 import { getPlanExecutionConfig } from '../ai.js';
 import { routeIntent } from '../contextAgent.js';
 import { requestCommandApproval } from './commandApproval.js';
+import { getMetricCollector } from '../metrics.js';
 // ─── Constants ───────────────────────────────────────────────────────
 /**
  * Mapping of tool identifiers to user-friendly terminal emojis.
@@ -92,7 +93,7 @@ export function formatToolCall(name, args) {
  * 6. **Submit Loop Frame**: Feeds execution outcomes back to the Gemini session and recursively repeats this sequence until the LLM produces a final text answer without further tool requests.
  *
  * ### Limits & Recovery Guardrails:
- * - **Turn-Limiting**: Capped at `MAX_TURNS` (100) to prevent infinite loops, API token drain, or excessive billing if the AI gets stuck in a repetitive loop.
+ * - **Turn-Limiting**: Capped at `MAX_TURNS` (Infinity) to prevent infinite loops, API token drain, or excessive billing if the AI gets stuck in a repetitive loop.
  * - **Empty-Response Healing**: If the API returns an empty text response with no tools, the system initiates up to `MAX_EMPTY_RETRIES` (3) system-driven wake-up prompts to re-engage the model.
  *
  * @param chat - The current active proxy chat session.
@@ -107,7 +108,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
     let response = result.response;
     // Upper limit on autonomous sequential tool executions to prevent out-of-control loops
     let turnCount = 0;
-    const MAX_TURNS = 100;
+    const MAX_TURNS = Infinity;
     // Recovery thresholds for handling unexpected empty API payloads
     let emptyRetryCount = 0;
     const MAX_EMPTY_RETRIES = 3;
@@ -170,6 +171,9 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
             return finalOutput;
         }
         // Process each tool call requested by the model (using helper to avoid nested loop warning)
+        const collector = getMetricCollector();
+        if (collector)
+            collector.recordToolTurn();
         const execRes = await executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal);
         if (execRes.aborted) {
             return '[Generation stopped by user]';
@@ -263,6 +267,7 @@ async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abor
                 response: {
                     output: toolResult.output,
                     ...(toolResult.error ? { error: toolResult.error } : {}),
+                    ...(toolResult.inlineData ? { inlineData: toolResult.inlineData } : {}),
                 },
             },
         });

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

@@ -9,6 +9,7 @@ export interface SlashCommandContext {
     workspaceRoot: string;
     version: string;
     isRawPasteMode: boolean;
+    isPlanMode: boolean;
     chatSessionState: {
         id: string;
         title: string;
@@ -18,4 +19,5 @@ export interface SlashCommandResult {
     shouldContinue: boolean;
     userInputOverride?: string;
     isRawPasteMode?: boolean;
+    isPlanModeOverride?: boolean;
 }

package/dist/services/agent-tools.d.ts

@@ -2,7 +2,14 @@ import { type FunctionDeclaration } from '@google/generative-ai';
 export interface ToolResult {
     error?: string;
     output: string;
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
 }
+export declare function isSemanticSearchEnabled(): boolean;
+export declare function setSemanticSearchEnabled(val: boolean): void;
+export declare function getToolDeclarations(): FunctionDeclaration[];
 /**
  * FunctionDeclaration-compatible schema objects that describe
  * every tool the agent can invoke. Passed to the model at init.
@@ -11,6 +18,8 @@ export declare const toolDeclarations: FunctionDeclaration[];
 export type ApprovalMode = 'ask' | 'skip-once' | 'skip-all';
 export declare function getApprovalMode(): ApprovalMode;
 export declare function setApprovalMode(mode: ApprovalMode): void;
+export declare function isSubAgentsEnabled(): boolean;
+export declare function setSubAgentsEnabled(enabled: boolean): void;
 /**
  * If set to 'skip-once', reverts to 'ask' after a single command is run.
  */
@@ -29,8 +38,4 @@ export declare function grepSearch(workspaceRoot: string, pattern: string, fileG
 export declare function traceDependencies(workspaceRoot: string, filePath: string, direction?: string, maxDepth?: number): Promise<ToolResult>;
 export declare function findRecentChanges(workspaceRoot: string, dirPath?: string, minutes?: number, maxDepth?: number): Promise<ToolResult>;
 export declare function runDebugScript(workspaceRoot: string, language: string, code: string, abortSignal?: AbortSignal): Promise<ToolResult>;
-/**
- * Dispatches a function call from the model to the appropriate local tool.
- * Returns the tool result as a string to feed back to the model.
- */
 export declare function executeTool(workspaceRoot: string, toolName: string, args: Record<string, unknown>, abortSignal?: AbortSignal): Promise<ToolResult>;