minovative-mind-cli 2.3.3 → 2.5.0

package/README.md

@@ -93,6 +93,11 @@ Hot-swap during a session using `/models`:
 | **Gemini 3.1 Pro**        | Complex architectural changes                       |
 | **Gemini 3.5 Flash Lite** | Best for speed and cost efficiency                  |
 
+### BYOK (Bring Your Own Key)
+If you prefer to use your own Gemini API key, you can configure it via the settings.
+*   **Configuration:** Set `useByok: true` and `geminiApiKey: "YOUR_KEY"` in your credentials storage.
+*   **Error Handling:** If your key is invalid, expired, or you hit rate limits, the CLI will report a `BYOK AI Error`. Please check your API key status in the Google AI Studio dashboard.
+
 > Background tasks (routing, compression, commits) always use lightweight
 > models automatically. You pay for those lightweight model
 > background ai models and for your selected model

package/dist/commands/chat.js

@@ -30,10 +30,11 @@ Inside the chat session, you can use the following commands in the slash menu:
   /auto-approve  - Toggle automatic approval of tool/command runs
   /sub-agents    - Toggle the MMAAK Engine for parallel investigation and execution
   /workspaces    - Manage external workspaces for cross-project development
+  /config-key    - BYOK (Bring Your Own Key) Configuration
   /stats         - View current session statistics and configuration
   /commit        - Commit current workspace changes to Git
   /revert        - Revert the last file modification made by the agent
-  /chats         - View, resume, or delete previous chat sessions
+  /chats         - View, resume, or delete previous chat sessions (includes bulk delete)
  
 Chat Controls:
   - Multi-line Input: End a line with \\ to continue on the next line

package/dist/services/agent/slashCommands.js

@@ -11,8 +11,11 @@ import { chatHistoryService } from '../chatHistoryService.js';
 import { printLogo, brandBg, brandFg } from '../../utils/logo.js';
 import { readPaste } from '../../utils/paste.js';
 import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled } from '../agent-tools.js';
-import { ProxyChatSession, setGlobalActiveModel, getGlobalActiveModel } from '../ai.js';
-import { GEMINI_MODELS } from '../../utils/config.js';
+import { ProxyClient, getAndResetTurnUsage } from '../proxyClient.js';
+import { getAuthorizedIdToken } from '../auth.js';
+import { GEMINI_MODELS, isByokEnabled } from '../../utils/config.js';
+import { loadCredentials, updateCredentialField } from '../../utils/credentialStore.js';
+import { getGlobalActiveModel, setGlobalActiveModel, ProxyChatSession } from '../ai.js';
 const execAsync = promisify(exec);
 /**
  * Handles all slash command operations (/paste, /clear, /models, /debug, /auto-approve, /revert, /commit).
@@ -21,6 +24,44 @@ const execAsync = promisify(exec);
 export async function handleSlashCommand(command, context) {
     const { chat, inputHandler, workspaceRoot, version, chatSessionState } = context;
     const lowerCommand = command.toLowerCase();
+    if (lowerCommand === '/config-key') {
+        const creds = await loadCredentials();
+        const action = await p['select']({
+            message: 'BYOK (Bring Your Own Key) Configuration',
+            options: [
+                { value: 'status', label: 'Status' },
+                { value: 'toggle', label: creds.useByok ? 'Disable BYOK' : 'Enable BYOK' },
+                { value: 'set', label: 'Set API Key' },
+                { value: 'clear', label: 'Clear API Key' },
+                { value: 'cancel', label: 'Cancel' },
+            ],
+        });
+        if (action === 'status') {
+            const enabled = await isByokEnabled();
+            p.log.info(`BYOK Status: ${enabled ? pc.green('Enabled') : pc.red('Disabled')}\n` +
+                `API Key: ${creds.geminiApiKey ? pc.green('Set') : pc.red('Not Set')}`);
+        }
+        else if (action === 'toggle') {
+            await updateCredentialField('useByok', !creds.useByok);
+            p.log.success(`BYOK ${!creds.useByok ? 'enabled' : 'disabled'}.`);
+        }
+        else if (action === 'set') {
+            const key = await p['text']({
+                message: 'Enter your Gemini API Key:',
+                validate: (value) => (value ? undefined : 'API Key is required'),
+            });
+            if (key && typeof key === 'string') {
+                await updateCredentialField('geminiApiKey', key);
+                p.log.success('API Key updated.');
+            }
+        }
+        else if (action === 'clear') {
+            await updateCredentialField('geminiApiKey', '');
+            await updateCredentialField('useByok', false);
+            p.log.success('API Key cleared and BYOK disabled.');
+        }
+        return { shouldContinue: true };
+    }
     if (lowerCommand === '/paste') {
         p.log.info(pc.cyan('Paste mode activated. Paste your text below, then press Ctrl+D on an empty line to submit. (Ctrl+C to cancel)'));
         try {
@@ -155,14 +196,37 @@ export async function handleSlashCommand(command, context) {
         const autoApprove = getApprovalMode() === 'skip-all' ? 'Enabled' : 'Disabled';
         const subAgents = isSubAgentsEnabled() ? 'Enabled' : 'Disabled';
         const planMode = context.isPlanMode ? 'Enabled' : 'Disabled';
+        const byokEnabled = await isByokEnabled() ? 'Enabled' : 'Disabled';
         p.log.step(pc.magenta('📊 Session Statistics & Status'));
         console.log(pc.dim('----------------------------------------'));
         console.log(`${pc.bold('AI Model:')}         ${pc.cyan(displayModel)}`);
         console.log(`${pc.bold('Auto-Approve:')}     ${autoApprove === 'Enabled' ? pc.green(autoApprove) : pc.yellow(autoApprove)}`);
         console.log(`${pc.bold('Sub-Agents:')}       ${subAgents === 'Enabled' ? pc.green(subAgents) : pc.yellow(subAgents)}`);
         console.log(`${pc.bold('Plan Mode:')}        ${planMode === 'Enabled' ? pc.green(planMode) : pc.yellow(planMode)}`);
+        console.log(`${pc.bold('BYOK:')}             ${byokEnabled === 'Enabled' ? pc.green(byokEnabled) : pc.yellow(byokEnabled)}`);
         const debugMode = isDebugOn() ? 'Enabled' : 'Disabled';
         console.log(`${pc.bold('Debug Log:')}        ${debugMode === 'Enabled' ? pc.green(debugMode) : pc.yellow(debugMode)}`);
+        try {
+            const { getInvestigationCacheStats } = await import('../orchestration/investigationCache.js');
+            const invStats = getInvestigationCacheStats(workspaceRoot);
+            const memBankSizeKB = (invStats.sizeBytes / 1024).toFixed(1);
+            console.log(`${pc.bold('Memory Bank:')}      ${pc.cyan(`${invStats.entries} cached investigations (${memBankSizeKB} KB / 5 MB)`)}`);
+            const { readCache } = await import('../../utils/projectStorage.js');
+            const contextCache = readCache(workspaceRoot, 'context_cache.json');
+            const contextEntries = contextCache ? Object.keys(contextCache).length : 0;
+            let contextSizeKB = '0.0';
+            try {
+                const fs = await import('node:fs');
+                const path = await import('node:path');
+                const stat = fs.statSync(path.join(workspaceRoot, '.minovativemind', 'context_cache.json'));
+                contextSizeKB = (stat.size / 1024).toFixed(1);
+            }
+            catch (e) { }
+            console.log(`${pc.bold('Context Cache:')}    ${pc.cyan(`${contextEntries} file summaries (${contextSizeKB} KB / 5 MB)`)}`);
+        }
+        catch (e) {
+            // Ignored if cache stats fail
+        }
         if (latestUsage) {
             if (latestUsage.remainingBalance !== undefined) {
                 let diffStr = '';
@@ -336,6 +400,7 @@ export async function handleSlashCommand(command, context) {
         if (hasSessions) {
             options.push({ value: 'resume', label: 'View Chats' });
             options.push({ value: 'delete', label: 'Delete Chat' });
+            options.push({ value: 'bulk-delete', label: 'Bulk Delete Chats' });
         }
         options.push({ value: 'cancel', label: 'Cancel' });
         const truncate = (str, max) => {
@@ -550,6 +615,30 @@ export async function handleSlashCommand(command, context) {
                 console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
             }
         }
+        else if (chatsMenu === 'bulk-delete') {
+            const selectedIds = await p['multiselect']({
+                message: 'Select chat sessions to delete:',
+                options: sessions.map((s) => ({
+                    value: s.id,
+                    label: `${truncate(s.title, 50)} (${new Date(s.timestamp).toLocaleString()})`,
+                })),
+                required: true,
+            });
+            if (p.isCancel(selectedIds) || !Array.isArray(selectedIds) || selectedIds.length === 0) {
+                p.log.warn('Bulk delete canceled.');
+                return { shouldContinue: true };
+            }
+            const confirm = await p['confirm']({
+                message: `Are you sure you want to delete ${selectedIds.length} session(s)?`,
+            });
+            if (confirm) {
+                await chatHistoryService.bulkDeleteSessions(selectedIds);
+                p.log.success(`Successfully deleted ${selectedIds.length} session(s).`);
+            }
+            else {
+                p.log.warn('Bulk delete canceled.');
+            }
+        }
         return { shouldContinue: true };
     }
     if (lowerCommand === '/workspaces') {
@@ -789,5 +878,66 @@ ${diffOut}
         }
         return { shouldContinue: true };
     }
+    if (lowerCommand === '/config-key') {
+        const creds = await loadCredentials();
+        const byokEnabled = !!(creds.useByok && creds.geminiApiKey);
+        const action = await p['select']({
+            message: `API Key Configuration (Current Mode: ${byokEnabled ? pc.green('BYOK') : pc.yellow('Credits')})`,
+            options: [
+                { value: 'toggle', label: byokEnabled ? 'Disable BYOK (Use Credits)' : 'Enable BYOK (Use API Key)' },
+                { value: 'set', label: 'Set/Update API Key' },
+                { value: 'clear', label: 'Clear API Key' },
+                { value: 'status', label: 'Check Status' },
+                { value: 'cancel', label: 'Cancel' },
+            ],
+        });
+        if (p.isCancel(action) || action === 'cancel')
+            return { shouldContinue: true };
+        if (action === 'toggle') {
+            if (!byokEnabled && !creds.geminiApiKey) {
+                p.log.error('You must set an API key before enabling BYOK mode.');
+            }
+            else {
+                await updateCredentialField('useByok', !byokEnabled);
+                p.log.success(`BYOK mode is now ${!byokEnabled ? pc.green('Enabled') : pc.yellow('Disabled')}`);
+            }
+        }
+        else if (action === 'set') {
+            const key = await p['password']({
+                message: 'Enter your Google AI Studio API Key:',
+                validate: (v) => (!v ? 'API key is required' : undefined),
+            });
+            if (p.isCancel(key))
+                return { shouldContinue: true };
+            const spinner = p.spinner();
+            spinner.start('Validating API Key...');
+            try {
+                // Test call to verify key
+                const client = new ProxyClient();
+                const idToken = (await getAuthorizedIdToken()) || '';
+                // We use a simple prompt to test the key
+                await client.generateFunctionCallViaProxy(idToken, 'gemini-3.5-flash-lite', [{ role: 'user', parts: [{ text: 'ping' }] }], undefined, undefined, 'You are a validator. Respond with "pong".', { maxOutputTokens: 10 });
+                // Reset metrics after validation
+                getAndResetTurnUsage();
+                await updateCredentialField('geminiApiKey', key);
+                spinner.stop('API Key validated and updated.');
+                p.log.success('API key saved.');
+            }
+            catch (err) {
+                spinner.stop('Validation failed.');
+                p.log.error(`Invalid API Key: ${err.message}`);
+            }
+        }
+        else if (action === 'clear') {
+            await updateCredentialField('geminiApiKey', undefined);
+            await updateCredentialField('useByok', false);
+            p.log.success('API key cleared and BYOK mode disabled.');
+        }
+        else if (action === 'status') {
+            p.log.info(`Mode: ${byokEnabled ? pc.green('BYOK') : pc.yellow('Credits')}\n` +
+                `Key Set: ${creds.geminiApiKey ? pc.green('Yes') : pc.red('No')}`);
+        }
+        return { shouldContinue: true };
+    }
     return { shouldContinue: true };
 }

package/dist/services/agent/toolLoop.js

@@ -115,8 +115,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
     const MAX_TURNS = Infinity;
     // Recovery thresholds for handling unexpected empty API payloads
     let emptyRetryCount = 0;
-    const MAX_EMPTY_RETRIES = 3;
-    const visitedToolCalls = new Set();
+    const MAX_EMPTY_RETRIES = 5;
     // Loop while the model keeps requesting tool calls
     while (true) {
         turnCount++;
@@ -179,7 +178,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
         const collector = getMetricCollector();
         if (collector)
             collector.recordToolTurn();
-        const execRes = await executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal, visitedToolCalls);
+        const execRes = await executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal);
         if (execRes.aborted) {
             return '[Generation stopped by user]';
         }
@@ -222,7 +221,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
         response = followUp.response;
     }
 }
-async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal, visitedToolCalls) {
+async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal) {
     const toolResponses = [];
     for (const fc of functionCalls) {
         await inputHandler.waitForPrompt();
@@ -232,19 +231,6 @@ async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abor
         }
         const toolName = fc.name;
         const toolArgs = (fc.args ?? {});
-        const callSignature = `${toolName}:${JSON.stringify(toolArgs)}`;
-        if (visitedToolCalls.has(callSignature)) {
-            toolResponses.push({
-                functionResponse: {
-                    name: toolName,
-                    response: {
-                        error: 'You have already made this exact tool call previously. Please review your context history or try a different action.'
-                    }
-                }
-            });
-            continue;
-        }
-        visitedToolCalls.add(callSignature);
         // Log the ongoing tool action to the console
         p.log.step(formatToolCall(toolName, toolArgs));
         // If executing a CLI/shell command, wait for approval
@@ -281,6 +267,8 @@ async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abor
                 p.log.warn(`${pc.red('Tool error:')} [${displayError}]`);
             }
         }
+        if (!toolResult.error && (toolName === 'write_file' || toolName === 'modify_file' || toolName === 'delete_file')) {
+        }
         toolResponses.push({
             functionResponse: {
                 name: toolName,

package/dist/services/agent-tools.js

@@ -330,8 +330,20 @@ const DEFAULT_IGNORED_DIRS = new Set([
     '.cache',
     'coverage',
     '.turbo',
+    '.tmp',
+    'temp',
+    'tmp',
+    '.minovativemind',
+]);
+const DEFAULT_IGNORED_FILES = new Set([
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    '.DS_Store',
+    '.minovative-scratch.js',
+    'testExtractor.ts',
+    'testExtractor.js',
 ]);
-const DEFAULT_IGNORED_FILES = new Set(['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', '.DS_Store']);
 /**
  * Parses .gitignore and .minovativemindignore to supplement the default ignore lists.
  */
@@ -339,7 +351,7 @@ async function getIgnoredPaths(workspaceRoot) {
     const ignoredDirs = new Set(DEFAULT_IGNORED_DIRS);
     const ignoredFiles = new Set(DEFAULT_IGNORED_FILES);
     const ig = ignore();
-    ig.add(Array.from(DEFAULT_IGNORED_DIRS).map(d => d + '/'));
+    ig.add(Array.from(DEFAULT_IGNORED_DIRS).map((d) => d + '/'));
     ig.add(Array.from(DEFAULT_IGNORED_FILES));
     const filesToRead = ['.gitignore', '.minovativemindignore'];
     for (const ignoreFile of filesToRead) {
@@ -582,7 +594,7 @@ export async function writeFile(workspaceRoot, filePath, content) {
         if (!validation.valid) {
             return {
                 output: '',
-                error: `Syntax validation failed for "${filePath}":\\n- ${validation.errors.join('\\n- ')}\\n\\nPlease fix the syntax and try again.`,
+                error: `Syntax validation failed for "${filePath}":\n- ${validation.errors.join('\n- ')}\n\nPlease fix the syntax and try again.`,
             };
         }
         await fs.mkdir(path.dirname(absPath), { recursive: true });
@@ -594,7 +606,7 @@ export async function writeFile(workspaceRoot, filePath, content) {
         const message = err instanceof Error ? err.message : String(err);
         const collector = getMetricCollector();
         if (collector)
-            collector.recordWriteFailure();
+            collector.recordWriteFailure?.();
         return {
             output: '',
             error: `Failed to write file "${filePath}": ${message}`,
@@ -645,7 +657,7 @@ export async function renameFile(workspaceRoot, sourcePath, targetPath) {
     }
 }
 export async function modifyFile(workspaceRoot, filePath, edits) {
-    const MAX_MODIFY_RETRIES = 2;
+    const MAX_MODIFY_RETRIES = 4;
     const absPath = resolveAndValidatePath(workspaceRoot, filePath);
     for (let attempt = 1; attempt <= MAX_MODIFY_RETRIES; attempt++) {
         try {
@@ -658,17 +670,17 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                 if (!match) {
                     const collector = getMetricCollector();
                     if (collector)
-                        collector.recordModifyFailure();
+                        collector.recordModifyFailure?.();
                     if (attempt < MAX_MODIFY_RETRIES) {
                         // Break out of inner loop, triggering a retry in outer loop
                         modified = existing; // reset
                         break;
                     }
                     // Provide a preview of the file to help the AI self-correct
-                    const preview = modified.split('\\n').slice(0, 20).join('\\n');
+                    const preview = modified.split('\n').slice(0, 30).join('\n');
                     return {
                         output: '',
-                        error: `Edit #${i + 1} failed: Search content not found in "${filePath}".\\nFile start preview:\\n${preview}\\n...`,
+                        error: `Edit #${i + 1} failed: Search content not found in "${filePath}". Please call 'read_file' to check the exact lines of code before retrying modify_file.\n\nFile start preview:\n${preview}\n...`,
                     };
                 }
                 modified = applyMatch(modified, match, edit.replaceContent);
@@ -776,27 +788,27 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
     try {
         const { stdout, stderr } = await execAsync(command, {
             cwd: workspaceRoot,
-            timeout: 60_000, // 60 second timeout
+            timeout: 120_000, // 120 second timeout
             maxBuffer: 1024 * 1024 * 2, // 2 MB buffer
             signal: abortSignal,
         });
         let output = [stdout, stderr].filter(Boolean).join('\n');
         // Truncate command output to prevent memory blowout from massive build logs
-        const MAX_CMD_OUTPUT = 15_000;
+        const MAX_CMD_OUTPUT = 30_000;
         if (output.length > MAX_CMD_OUTPUT) {
             output =
                 output.substring(0, MAX_CMD_OUTPUT) +
-                    `\n\n... (Output truncated: ${output.length} bytes exceeded 15KB limit. To view the rest, pipe the command to a file and read it in chunks, or use grep.)`;
+                    `\n\n... (Output truncated: ${output.length} bytes exceeded 30KB limit. To view the rest, pipe the command to a file and read it in chunks, or use grep.)`;
         }
         return { output: output || '(command produced no output)' };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         // Also truncate error output
-        const MAX_ERR_OUTPUT = 15_000;
+        const MAX_ERR_OUTPUT = 30_000;
         const truncatedMsg = message.length > MAX_ERR_OUTPUT
             ? message.substring(0, MAX_ERR_OUTPUT) +
-                `\n\n... (Error output truncated: ${message.length} bytes exceeded 15KB limit. Pipe to a file if you need full logs.)`
+                `\n\n... (Error output truncated: ${message.length} bytes exceeded 30KB limit. Pipe to a file if you need full logs.)`
             : message;
         return { output: '', error: `Command failed: ${truncatedMsg}` };
     }
@@ -1281,7 +1293,7 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
     if (result.error) {
         const collector = getMetricCollector();
         if (collector)
-            collector.recordToolFailure(toolName);
+            collector.recordToolFailure?.(toolName);
     }
     return result;
 }

package/dist/services/agent.js

@@ -86,7 +86,14 @@ export async function startAgentLoop(workspaceRoot, version) {
     chatHistoryService.init(workspaceRoot);
     const chat = createSharedChatSession();
     const inputHandler = new AsyncInputHandler();
-    const chatSessionState = { id: crypto.randomUUID(), title: '', totalTokens: 0, totalInputTokens: 0, totalOutputTokens: 0, modelUsageCounts: {} };
+    const chatSessionState = {
+        id: crypto.randomUUID(),
+        title: '',
+        totalTokens: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        modelUsageCounts: {},
+    };
     chat.setSessionInfo(chatSessionState.id, workspaceRoot);
     const sessionInputHistory = [];
     let isRawPasteMode = false;
@@ -137,11 +144,23 @@ 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: '/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' },
-                    { value: '/debug', label: '/debug', hint: `Toggle internal debug logs ${isDebugOn() ? pc.green('(ON)') : pc.red('(OFF)')}` },
-                    { value: '/auto-approve', label: '/auto-approve', hint: `Approve all future terminal commands ${getApprovalMode() === 'skip-all' ? pc.green('(ON)') : pc.red('(OFF)')}` },
+                    {
+                        value: '/debug',
+                        label: '/debug',
+                        hint: `Toggle internal debug logs ${isDebugOn() ? pc.green('(ON)') : pc.red('(OFF)')}`,
+                    },
+                    {
+                        value: '/auto-approve',
+                        label: '/auto-approve',
+                        hint: `Approve all future terminal commands ${getApprovalMode() === 'skip-all' ? pc.green('(ON)') : pc.red('(OFF)')}`,
+                    },
                     {
                         value: '/sub-agents',
                         label: '/sub-agents',
@@ -152,6 +171,7 @@ export async function startAgentLoop(workspaceRoot, version) {
                         label: '/workspaces',
                         hint: 'Manage external workspaces for cross-project development',
                     },
+                    { value: '/config-key', label: '/config-key', hint: 'BYOK (Bring Your Own Key) Configuration' },
                     { 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' },
@@ -235,6 +255,8 @@ export async function startAgentLoop(workspaceRoot, version) {
 }
 export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHandler, chatSessionState, isPlanMode, cachedContextResult) {
     return runWithAgentId('main', async () => {
+        const { resetTurnAccumulator } = await import('./metrics.js');
+        resetTurnAccumulator();
         const turnStartTime = Date.now();
         const spinner = p.spinner();
         const ac = new AbortController();
@@ -505,8 +527,13 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     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)`)}`);
                 }
-                const inputTokens = (usage.promptTokens || 0) + (usage.cachedTokens || 0);
-                const outputTokens = usage.candidatesTokens || 0;
+                const { getTurnTotals } = await import('./metrics.js');
+                const totals = getTurnTotals();
+                if (gatherRes && gatherRes.contextResult && gatherRes.contextResult.fromMemoryBank) {
+                    p.log.info(`${pc.green('⚡')} ${pc.green('Memory Bank:')}       Investigation skipped ${pc.dim(`(saved ~5 context agent turns)`)}`);
+                }
+                const inputTokens = (totals.promptTokens || usage.promptTokens || 0) + (totals.cachedTokens || usage.cachedTokens || 0);
+                const outputTokens = totals.outputTokens || usage.candidatesTokens || 0;
                 const totalTokens = inputTokens + outputTokens;
                 p.log.info(`${pc.dim('Tokens Used:')} ${pc.cyan(totalTokens.toLocaleString())} ${pc.dim(`(Input: ${inputTokens.toLocaleString()}, Output: ${outputTokens.toLocaleString()})`)}`);
                 if (usage.remainingBalance !== undefined) {
@@ -740,13 +767,16 @@ async function compressContextFiles(workspaceRoot, contextResult) {
         }
     }
     if (cacheUpdated) {
-        // Keep cache size manageable by restricting to recent 500 file entries
-        const keys = Object.keys(cachedContext);
-        if (keys.length > 500) {
-            const toDelete = keys.length - 500;
-            for (let i = 0; i < toDelete; i++) {
-                delete cachedContext[keys[i]];
-            }
+        // Keep cache size manageable by restricting to 5MB total size
+        const MAX_CACHE_SIZE_BYTES = 5 * 1024 * 1024; // 5MB
+        let cacheJson = JSON.stringify(cachedContext);
+        while (Buffer.byteLength(cacheJson, 'utf8') > MAX_CACHE_SIZE_BYTES) {
+            const keys = Object.keys(cachedContext);
+            if (keys.length === 0)
+                break;
+            // Remove oldest entries (assuming keys are inserted chronologically)
+            delete cachedContext[keys[0]];
+            cacheJson = JSON.stringify(cachedContext);
         }
         writeCache(workspaceRoot, 'context_cache.json', cachedContext);
     }

package/dist/services/ai.d.ts

@@ -1,4 +1,4 @@
-import type { Content, FunctionCall } from '@google/generative-ai';
+import { type Content, type 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;
@@ -76,7 +76,7 @@ export declare function getPlanModeConfig(): {
  * Compresses a large string of text using gemini-3.5-flash-lite.
  * Used for shrinking context payloads to prevent OOM/choking.
  */
-export declare function compressTextUsingFlashLite(text: string, instruction?: string, inlineData?: any): Promise<string>;
+export declare function compressTextUsingFlashLite(text: string, instruction?: string, inlineData?: any, force?: boolean): Promise<string>;
 /**
  * Returns the tool declarations for the read-only Context Agent.
  * Extracted as a reusable function so investigation sub-agents can import