minovative-mind-cli 2.9.0 → 2.10.0

package/README.md

@@ -89,7 +89,7 @@ Hot-swap during a session using `/models`:
 | Model                     | Best for                                            |
 | ------------------------- | --------------------------------------------------- |
 | **Auto** (default)        | Automatically selects (3.7 Flash or 3.5 Flash Lite) |
-| **Gemini 3.7 Flash**      | Next-gen performance, reasoning & fast execution   |
+| **Gemini 3.7 Flash**      | Next-gen performance, reasoning & fast execution    |
 | **Gemini 3.6 Flash**      | Everyday coding — fast and accurate                 |
 | **Gemini 3.1 Pro**        | Complex architectural changes                       |
 | **Gemini 3.5 Flash Lite** | Best for speed and cost efficiency                  |
@@ -101,11 +101,19 @@ If you prefer to use your own API key instead of credits, you can configure it v
 - **Configuration:** Use `/config-key` in the chat session to set and manage your API key.
 - **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](https://aistudio.google.com).
 
-> Background tasks (routing, history summarization, context compression, commits) always use lightweight
-> models automatically. You pay for those lightweight model
-> background ai models and for your selected model
-> during chat and code execution.
-> Use `/debug` to see exactly what's running.
+### Auxiliary Model Routing Defaults
+
+Background tasks automatically route to dedicated auxiliary models with native `responseSchema` constraints for optimal latency, cost efficiency, and structured output reliability:
+
+- **Intent Router (`routeIntent`)**: `Gemini 3.7 Flash` (Temp 0, native `responseSchema`) — zero-temperature classification of `SEARCH` vs `SKIP` and `CHAT` vs `EXECUTE`.
+- **Complexity Evaluators**: `Gemini 3.7 Flash` (Temp 0, native `responseSchema`) — domain partitioning and parallel execution wave feasibility.
+- **Context Compressor**: `Gemini 3.7 Flash` (Temp 0.2) — surgical code distillation for files exceeding 2,000 characters.
+- **Session Titling**: `Gemini 3.7 Flash` (Temp 0.7, native `responseSchema`) — automated concise chat session titling.
+- **Semantic Cache Classifier**: `Gemini 3.5 Flash Lite` (Temp 0, native `responseSchema`) — intent and topic classification for cache hits.
+- **History Summarizer**: `Gemini 3.7 Flash` (Temp 0.2) — 3-part structured conversation compression preserving recent history.
+- **Commit Generator**: `Gemini 3.5 Flash Lite` — conventional commit message synthesis.
+
+> You pay for auxiliary model background AI operations and for your selected model during chat and code execution. Use `/debug` to inspect real-time routing diagnostics.
 
 ---
 

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

@@ -31,6 +31,8 @@ export declare class AsyncInputHandler {
     private stopped;
     /** Reference to the AbortController controlling the active AI request to trigger cancellations */
     private ac;
+    /** Timeout reference for reattaching listener after prompting to avoid race conditions */
+    private reattachTimeout;
     /**
      * Registers the active AbortController for the current AI request.
      * This is triggered when the user commands a process cancel (e.g., typing "stop").
@@ -45,6 +47,14 @@ export declare class AsyncInputHandler {
      * @returns True if a text prompt is currently displayed, false otherwise.
      */
     isCurrentlyPrompting(): boolean;
+    /**
+     * Checks if there are any queued user messages pending.
+     */
+    hasQueuedMessages(): boolean;
+    /**
+     * Returns a copy of currently queued messages without clearing them.
+     */
+    peek(): string[];
     /**
      * Blocks and waits until any active prompting action is completed.
      * Guarantees terminal stdout is clean before resuming logs.
@@ -63,16 +73,21 @@ export declare class AsyncInputHandler {
     private onData;
     /**
      * Starts intercepting keystrokes and enables raw terminal processing.
-     * Saves the original raw mode configuration to ensure a clean restoration later.
+     * Clears any stale queued messages and saves the original raw mode configuration.
      *
      * @param spinner - The current active Clack spinner UI reference, if any.
      */
     start(spinner?: ReturnType<typeof p.spinner>): void;
     /**
-     * Disables raw mode, stops intercepting keystrokes, and restores
-     * the terminal stdin stream to its original raw/cooked state.
+     * Disables raw mode, stops intercepting keystrokes, restores
+     * the terminal stdin stream to its original raw/cooked state, and
+     * completely clears the queued messages.
      */
     stop(): void;
+    /**
+     * Clears all pending queued messages without modifying stream state.
+     */
+    clear(): void;
     /**
      * Clears the spinner reference without stopping the input handler.
      */

package/dist/services/agent/inputHandler.js

@@ -1,6 +1,12 @@
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { truncateForTerminal } from '../../utils/terminal.js';
+if (process.stdin.setMaxListeners) {
+    process.stdin.setMaxListeners(50);
+}
+if (process.stdout.setMaxListeners) {
+    process.stdout.setMaxListeners(50);
+}
 /**
  * Asynchronous Input Handler (AsyncInputHandler)
  *
@@ -33,6 +39,8 @@ export class AsyncInputHandler {
     stopped = true;
     /** Reference to the AbortController controlling the active AI request to trigger cancellations */
     ac = null;
+    /** Timeout reference for reattaching listener after prompting to avoid race conditions */
+    reattachTimeout = null;
     /**
      * Registers the active AbortController for the current AI request.
      * This is triggered when the user commands a process cancel (e.g., typing "stop").
@@ -51,6 +59,18 @@ export class AsyncInputHandler {
     isCurrentlyPrompting() {
         return this.isPrompting;
     }
+    /**
+     * Checks if there are any queued user messages pending.
+     */
+    hasQueuedMessages() {
+        return this.queue.length > 0;
+    }
+    /**
+     * Returns a copy of currently queued messages without clearing them.
+     */
+    peek() {
+        return [...this.queue];
+    }
     /**
      * Blocks and waits until any active prompting action is completed.
      * Guarantees terminal stdout is clean before resuming logs.
@@ -72,7 +92,7 @@ export class AsyncInputHandler {
      */
     onData = async (chunk) => {
         try {
-            if (this.isPrompting)
+            if (this.stopped || this.isPrompting)
                 return;
             const char = chunk.toString();
             // Handle Ctrl+C (End of Text ASCII 0x03) immediately
@@ -99,6 +119,9 @@ export class AsyncInputHandler {
                 placeholder: '(Leave blank and press Enter to cancel)',
                 initialValue: char,
             });
+            if (this.stopped) {
+                return;
+            }
             let wasAborted = false;
             if (!p.isCancel(userInput) && userInput.trim()) {
                 const text = userInput.trim();
@@ -114,7 +137,7 @@ export class AsyncInputHandler {
                     p.log.info(pc.cyan(`📥 Queued message: "${text}"`));
                 }
             }
-            if (this.spinner && !wasAborted) {
+            if (this.spinner && !wasAborted && !this.stopped) {
                 const resumeMsg = this.spinner._lastMessage || 'Resuming execution...';
                 this.spinner.start(resumeMsg);
             }
@@ -128,9 +151,14 @@ export class AsyncInputHandler {
                     process.stdin.setRawMode(true);
                 }
                 process.stdin.resume();
+                if (this.reattachTimeout) {
+                    clearTimeout(this.reattachTimeout);
+                }
                 // Small delay before reattaching listener to avoid capturing duplicate keypress frames
-                setTimeout(() => {
+                this.reattachTimeout = setTimeout(() => {
+                    this.reattachTimeout = null;
                     if (!this.stopped) {
+                        process.stdin.removeListener('data', this.onData);
                         process.stdin.on('data', this.onData);
                     }
                     this.isPrompting = false;
@@ -143,56 +171,53 @@ export class AsyncInputHandler {
     };
     /**
      * Starts intercepting keystrokes and enables raw terminal processing.
-     * Saves the original raw mode configuration to ensure a clean restoration later.
+     * Clears any stale queued messages and saves the original raw mode configuration.
      *
      * @param spinner - The current active Clack spinner UI reference, if any.
      */
     start(spinner) {
+        if (this.reattachTimeout) {
+            clearTimeout(this.reattachTimeout);
+            this.reattachTimeout = null;
+        }
         this.stopped = false;
+        this.queue = [];
         if (spinner) {
-            this.spinner = spinner;
-            // Monkey-patch to track the latest message for un-pausing
-            if (!spinner._isPatched) {
-                ;
-                spinner._isPatched = true;
-                spinner._lastMessage = 'Executing...';
-                const originalMessage = spinner.message.bind(spinner);
-                spinner.message = (msg) => {
-                    if (msg) {
-                        ;
-                        spinner._lastMessage = msg;
-                    }
-                    originalMessage(msg ? truncateForTerminal(msg) : msg);
-                };
-                const originalStart = spinner.start.bind(spinner);
-                spinner.start = (msg) => {
-                    if (msg) {
-                        ;
-                        spinner._lastMessage = msg;
-                    }
-                    originalStart(msg ? truncateForTerminal(msg) : msg);
-                };
-            }
+            this.setSpinner(spinner);
         }
         if (process.stdin.isTTY) {
             this.originalRawMode = process.stdin.isRaw;
             process.stdin.setRawMode(true);
         }
         process.stdin.resume();
+        process.stdin.removeListener('data', this.onData);
         process.stdin.on('data', this.onData);
     }
     /**
-     * Disables raw mode, stops intercepting keystrokes, and restores
-     * the terminal stdin stream to its original raw/cooked state.
+     * Disables raw mode, stops intercepting keystrokes, restores
+     * the terminal stdin stream to its original raw/cooked state, and
+     * completely clears the queued messages.
      */
     stop() {
         this.stopped = true;
+        this.isPrompting = false;
+        if (this.reattachTimeout) {
+            clearTimeout(this.reattachTimeout);
+            this.reattachTimeout = null;
+        }
         process.stdin.removeListener('data', this.onData);
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(this.originalRawMode);
         }
         process.stdin.resume();
         this.spinner = null;
+        this.queue = [];
+    }
+    /**
+     * Clears all pending queued messages without modifying stream state.
+     */
+    clear() {
+        this.queue = [];
     }
     /**
      * Clears the spinner reference without stopping the input handler.

package/dist/services/agent/slashCommands.js

@@ -715,7 +715,7 @@ export async function handleSlashCommand(command, context) {
         }
         else if (chatsMenu === 'bulk-delete') {
             const selectedIds = await p['multiselect']({
-                message: 'Select chat sessions to delete:',
+                message: `Select chat sessions to delete: ${pc.dim('(Press Esc to go back / cancel)')}`,
                 options: sessions
                     .slice()
                     .sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))
@@ -723,7 +723,7 @@ export async function handleSlashCommand(command, context) {
                     value: s.id,
                     label: `${truncate(s.title, 50)} (${new Date(s.timestamp).toLocaleString()})`,
                 })),
-                required: true,
+                required: false,
             });
             if (p.isCancel(selectedIds) || !Array.isArray(selectedIds) || selectedIds.length === 0) {
                 p.log.warn('Bulk delete canceled.');
@@ -735,6 +735,16 @@ export async function handleSlashCommand(command, context) {
             if (confirm) {
                 await chatHistoryService.bulkDeleteSessions(selectedIds);
                 p.log.success(`Successfully deleted ${selectedIds.length} session(s).`);
+                if (chatSessionState && selectedIds.includes(chatSessionState.id)) {
+                    chat.clearHistory();
+                    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.warn('Active session was deleted. Chat history cleared.');
+                    console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
+                }
             }
             else {
                 p.log.warn('Bulk delete canceled.');

package/dist/services/agent.js

@@ -504,6 +504,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 const orchestrator = new Orchestrator(workspaceRoot, chatSessionState.id, inputHandler);
                 const handledByOrchestrator = await orchestrator.runOrchestration(finalInput, dynamicSystemInstruction, ac.signal);
                 if (typeof handledByOrchestrator === 'string') {
+                    inputHandler.stop();
                     const isStopped = handledByOrchestrator.includes('Generation stopped') ||
                         handledByOrchestrator.includes('[Generation stopped');
                     if (isStopped) {
@@ -654,6 +655,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             // Stage 2: Recursive Tool Loops and Automated Self-Correction (delegated to a helper function to avoid nested loop warning)
             const correctionRes = await executeSelfCorrectionLoop(chat, result, workspaceRoot, inputHandler, effectiveTargetAgent, ac.signal, spinner, userInput, isPlanMode);
             const finalText = correctionRes.finalText;
+            inputHandler.stop();
             // Update latest usage metadata to reflect all completed turns
             const usage = getAndResetTurnUsage();
             const postExecutionChanges = changeLogger.getCurrentChangeSet()?.changes || [];
@@ -890,6 +892,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             p.log.error(`${pc.red('Error:')} ${message}`);
         }
         finally {
+            inputHandler.stop();
             spinner.stop();
             process.stdout.write('\x1b[2K\r');
             // Persist any verified or partial changes into our session change ledger.

package/dist/services/ai.d.ts

@@ -77,7 +77,7 @@ export declare function getPlanModeConfig(): {
     tools: never[];
 };
 /**
- * Compresses a large string of text using gemini-3.5-flash-lite.
+ * Compresses a large string of text using Gemini Flash.
  * Used for shrinking context payloads to prevent OOM/choking.
  */
 export declare function compressTextUsingFlashLite(text: string, instruction?: string, inlineData?: any, force?: boolean, abortSignal?: AbortSignal): Promise<string>;
@@ -91,6 +91,7 @@ export declare function createContextAgentSession(): any;
 export declare function createIntentRouterSession(): any;
 export declare function createExecutionComplexitySession(): any;
 export declare function createInvestigationComplexitySession(): any;
+export declare function createInvestigationSemanticSession(): any;
 export declare function createWebSearchAgentSession(): any;
 export declare function createHistorySummarizerSession(): any;
 /**

package/dist/services/ai.js

@@ -5,7 +5,7 @@ import { getMetricCollector } from './metrics.js';
 import { getAuthorizedIdToken, checkByokSubscription } from './auth.js';
 import { debugLog } from '../utils/logger.js';
 import { readCache, writeCache } from '../utils/projectStorage.js';
-import { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, PLAN_MODE_INSTRUCTION, CONTEXT_SYSTEM_INSTRUCTION, INTENT_ROUTER_SYSTEM_INSTRUCTION, WEB_SEARCH_SYSTEM_INSTRUCTION, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
+import { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, PLAN_MODE_INSTRUCTION, CONTEXT_SYSTEM_INSTRUCTION, INTENT_ROUTER_SYSTEM_INSTRUCTION, WEB_SEARCH_SYSTEM_INSTRUCTION, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, INVESTIGATION_SEMANTIC_SYSTEM_INSTRUCTION, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
 import { workspaceRegistry } from './workspaceRegistry.js';
 import { loadCredentials } from '../utils/credentialStore.js';
 import { ProxyClient } from './proxyClient.js';
@@ -345,7 +345,7 @@ export function getPlanModeConfig() {
     };
 }
 /**
- * Compresses a large string of text using gemini-3.5-flash-lite.
+ * Compresses a large string of text using Gemini Flash.
  * Used for shrinking context payloads to prevent OOM/choking.
  */
 export async function compressTextUsingFlashLite(text, instruction = "<directives>\nSummarize the following text concisely. Preserve the most critical technical details, function names, and architecture logic. Make sure it's understandable without the fluff.\n</directives>", inlineData, force = false, abortSignal) {
@@ -357,7 +357,7 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
         const idToken = await getAuthorizedIdToken();
         if (!idToken)
             return text;
-        let model = GEMINI_MODELS.FLASH_LITE;
+        let model = GEMINI_MODELS.FLASH;
         const parts = [{ text }];
         if (inlineData) {
             parts.push({ inlineData });
@@ -397,7 +397,7 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
         if (abortSignal?.aborted || error?.name === 'AbortError' || error?.message?.includes('abort')) {
             return text;
         }
-        debugLog(`Failed to compress text using flash-lite: ${error}`);
+        debugLog(`Failed to compress text using flash: ${error}`);
         if (error?.status === 401 ||
             error?.status === 403 ||
             error?.message?.includes('API_KEY_INVALID') ||
@@ -568,25 +568,143 @@ export function createContextAgentSession() {
 export function createIntentRouterSession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, INTENT_ROUTER_SYSTEM_INSTRUCTION, [], // no tools
-    { temperature: 0, responseMimeType: 'application/json' });
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                context: {
+                    type: SchemaType.STRING,
+                    enum: ['SEARCH', 'SKIP'],
+                    description: 'Whether workspace context search is required',
+                },
+                agent: {
+                    type: SchemaType.STRING,
+                    enum: ['CHAT', 'EXECUTE'],
+                    description: 'Target agent to route the request to',
+                },
+            },
+            required: ['context', 'agent'],
+        },
+    });
 }
 // ─── Execution Complexity Router Service ──────────────────────────────
 export function createExecutionComplexitySession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, [], // no tools
-    { temperature: 0, responseMimeType: 'application/json' });
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                complexity: {
+                    type: SchemaType.STRING,
+                    enum: ['EASY', 'HARD'],
+                    description: 'Execution task complexity rating',
+                },
+            },
+            required: ['complexity'],
+        },
+    });
 }
 // ─── Investigation Complexity Router Service ─────────────────────────
 export function createInvestigationComplexitySession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, [], // no tools
-    { temperature: 0, responseMimeType: 'application/json' });
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                strategy: {
+                    type: SchemaType.STRING,
+                    enum: ['SINGLE', 'PARALLEL'],
+                    description: 'Investigation strategy (SINGLE or PARALLEL)',
+                },
+                domains: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'All identified investigation domains',
+                },
+                agentAssignments: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.OBJECT,
+                        properties: {
+                            agentLabel: {
+                                type: SchemaType.STRING,
+                                description: 'Label of the sub-agent',
+                            },
+                            domains: {
+                                type: SchemaType.ARRAY,
+                                items: {
+                                    type: SchemaType.STRING,
+                                },
+                                description: 'Domains assigned to this sub-agent',
+                            },
+                        },
+                        required: ['agentLabel', 'domains'],
+                    },
+                    description: 'Sub-agent domain group assignments',
+                },
+                reasoning: {
+                    type: SchemaType.STRING,
+                    description: 'Brief justification for the chosen strategy and grouping',
+                },
+            },
+            required: ['strategy', 'domains', 'agentAssignments', 'reasoning'],
+        },
+    });
+}
+// ─── Investigation Semantic Router Service ───────────────────────────
+export function createInvestigationSemanticSession() {
+    let model = getGlobalActiveModel();
+    if (model === 'auto' || model.includes('claude'))
+        model = GEMINI_MODELS.FLASH_LITE;
+    return new ProxyChatSession(model, INVESTIGATION_SEMANTIC_SYSTEM_INSTRUCTION, [], // no tools
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                topics: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'Technical topic or domain identifiers',
+                },
+                components: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'Target component, file, function, or endpoint names',
+                },
+                intent: {
+                    type: SchemaType.STRING,
+                    description: 'Primary intent category (e.g. bug_fix, feature_addition, explanation, refactoring)',
+                },
+                reasoning: {
+                    type: SchemaType.STRING,
+                    description: 'Brief justification for the extracted metadata',
+                },
+            },
+            required: ['topics', 'components', 'intent'],
+        },
+    });
 }
 // ─── Web Search Agent Service ───────────────────────────────────────────
 export function createWebSearchAgentSession() {
@@ -604,7 +722,7 @@ export function createWebSearchAgentSession() {
 export function createHistorySummarizerSession() {
     let model = getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
-        model = GEMINI_MODELS.FLASH_LITE;
+        model = GEMINI_MODELS.FLASH;
     return new ProxyChatSession(model, HISTORY_SUMMARIZER_SYSTEM_INSTRUCTION, [], {
         temperature: 0.2,
         maxOutputTokens: MAX_OUTPUT_TOKENS,
@@ -655,7 +773,7 @@ export async function generateChatTitle(firstMessage, abortSignal) {
         const contents = [{ role: 'user', parts: [{ text: firstMessage.substring(0, 500) }] }];
         let model = getGlobalActiveModel();
         if (model === 'auto' || model.includes('claude'))
-            model = GEMINI_MODELS.FLASH_LITE;
+            model = GEMINI_MODELS.FLASH;
         const byokEnabled = await isByokEnabled();
         let result;
         if (byokEnabled) {

package/dist/services/contextAgent.js

@@ -246,7 +246,31 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     }
     const projectType = primaryProjectType;
     const { lookupInvestigation, saveInvestigation } = await import('./orchestration/investigationCache.js');
-    const cacheHit = await lookupInvestigation(workspaceRoot, userRequest);
+    const collector = getMetricCollector();
+    const lookupStart = Date.now();
+    let cacheHit = null;
+    try {
+        cacheHit = await lookupInvestigation(workspaceRoot, userRequest, {
+            abortSignal,
+            onProgress,
+            allowSemanticFallback: true,
+        });
+        if (collector) {
+            collector.recordCachePerformance('investigation', Date.now() - lookupStart);
+            if (cacheHit) {
+                collector.recordCacheHit('investigation');
+            }
+            else {
+                collector.recordCacheMiss('investigation');
+            }
+        }
+    }
+    catch (err) {
+        if (err?.name === 'AbortError' || abortSignal?.aborted) {
+            throw err;
+        }
+        debugLog(`Investigation cache lookup error: ${err?.message || err}`);
+    }
     if (cacheHit) {
         if (onProgress)
             onProgress(`⚡ Memory Bank HIT — loaded ${cacheHit.entry.relevantFiles.length} files from cache`);
@@ -596,7 +620,6 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
         // Prepare next turn
         currentMessage = functionResponses;
     }
-    const collector = getMetricCollector();
     if (collector) {
         collector.recordContextSelectedFiles(Array.from(relevantFiles.keys()));
         if (!isInvestigationFinished || relevantFiles.size === 0) {
@@ -604,8 +627,16 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
         }
     }
     if (isInvestigationFinished && relevantFiles.size > 0) {
-        const { saveInvestigation } = await import('./orchestration/investigationCache.js');
-        await saveInvestigation(workspaceRoot, userRequest, Array.from(relevantFiles.keys()), summary);
+        try {
+            const { saveInvestigation } = await import('./orchestration/investigationCache.js');
+            await saveInvestigation(workspaceRoot, userRequest, Array.from(relevantFiles.keys()), summary, undefined, abortSignal);
+        }
+        catch (err) {
+            if (err?.name === 'AbortError' || abortSignal?.aborted) {
+                throw err;
+            }
+            debugLog(`Failed to save investigation to cache: ${err?.message || err}`);
+        }
     }
     return {
         contextResult: { projectTree, projectType, relevantFiles, summary, webSearchSummary, isParallel: false },

package/dist/services/investigationComplexity.d.ts

@@ -31,7 +31,7 @@ export interface InvestigationComplexityResult {
 /**
  * Evaluates whether the investigation phase should be parallelized.
  *
- * Uses `gemini-3.5-flash-lite` (under auto mode) at temperature 0 to classify the prompt's
+ * Uses `gemini-3.7-flash` (under auto mode) at temperature 0 to classify the prompt's
  * investigation complexity. The PM dynamically identifies domains and groups
  * them into agent assignments. Agent count = `agentAssignments.length`, which
  * may be fewer than `domains.length` when related domains are batched together.

package/dist/services/investigationComplexity.js

@@ -16,7 +16,7 @@ import { debugLog } from '../utils/logger.js';
 /**
  * Evaluates whether the investigation phase should be parallelized.
  *
- * Uses `gemini-3.5-flash-lite` (under auto mode) at temperature 0 to classify the prompt's
+ * Uses `gemini-3.7-flash` (under auto mode) at temperature 0 to classify the prompt's
  * investigation complexity. The PM dynamically identifies domains and groups
  * them into agent assignments. Agent count = `agentAssignments.length`, which
  * may be fewer than `domains.length` when related domains are batched together.