minovative-mind-cli 2.11.0 → 2.11.3

package/README.md

@@ -122,6 +122,7 @@ Background tasks automatically route to dedicated auxiliary models with native `
 | Command         | What it does                                                                                                                                    |
 | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
 | `/config-key`   | Configure custom Google AI Studio API key (BYOK mode)                                                                                           |
+| `/profile`      | View, inspect, delete, or reset global adaptive persona memory and AI side-notes                                                                |
 | `/models`       | Hot-swap the active model                                                                                                                       |
 | `/plan`         | Toggle plan mode to review implementation strategies                                                                                            |
 | `/paste`        | Multi-line input mode (cancel with Ctrl+C)                                                                                                      |

package/dist/commands/chat.d.ts

@@ -9,7 +9,7 @@ import { Command } from '@oclif/core';
 export default class DefaultCommand extends Command {
     /**
      * The description displayed in the CLI help output.
-     * Details all supported slash commands (/config-key, /paste, /plan, /clear, /models,
+     * Details all supported slash commands (/config-key, /profile, /paste, /plan, /clear, /models,
      * /debug, /auto-approve, /sub-agents, /stats, /revert, /chats, /workspaces, /commit)
      * along with interactive chat controls.
      */

package/dist/commands/chat.js

@@ -17,7 +17,7 @@ import { updateWorkspaceStatus } from '../services/workspace.js';
 export default class DefaultCommand extends Command {
     /**
      * The description displayed in the CLI help output.
-     * Details all supported slash commands (/config-key, /paste, /plan, /clear, /models,
+     * Details all supported slash commands (/config-key, /profile, /paste, /plan, /clear, /models,
      * /debug, /auto-approve, /sub-agents, /stats, /revert, /chats, /workspaces, /commit)
      * along with interactive chat controls.
      */
@@ -25,6 +25,7 @@ export default class DefaultCommand extends Command {
 
 Inside the chat session, you can use the following commands in the slash menu:
   /config-key    - BYOK — Configure, clear, or view status of custom Google AI Studio API key
+  /profile       - View, inspect, delete, or reset global adaptive persona memory and AI side-notes
   /paste         - Enter multi-line paste mode for long code snippets and prompts
   /plan          - Toggle plan mode to review step-by-step implementation strategies
   /clear         - Clear conversation history, reset terminal screen, and display logo

package/dist/services/agent/slashCommands.js

@@ -17,12 +17,14 @@ import { checkByokSubscription } 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';
+import { loadUserProfile, deleteSideNote, clearUserProfile, getUserProfilePath, } from '../userProfileService.js';
 /**
  * @file slashCommands.ts
  * @description Interactive slash command handler module for Minovative Mind CLI.
  *
  * Supported slash commands:
  * - `/config-key`  : Configure, validate, toggle, or clear Bring Your Own Key (BYOK) Google AI Studio API credentials.
+ * - `/profile`     : View, inspect, delete, or reset global adaptive persona memory and AI side-notes.
  * - `/paste`       : Enter multi-line paste mode using EOF tracking (`Ctrl+D` submission).
  * - `/plan`        : Toggle AI step-by-step implementation planning mode.
  * - `/clear`       : Clear conversation history, wipe terminal screen, and reset CLI header.
@@ -1146,5 +1148,138 @@ Strict Formatting Rules:
         }
         return { shouldContinue: true };
     }
+    /**
+     * `/profile` - Displays and manages global adaptive user profile traits, persona memory, and AI side-notes.
+     */
+    if (lowerCommand === '/profile') {
+        const profile = await loadUserProfile();
+        const action = await p.select({
+            message: 'Adaptive User Profile & AI Memory Bank:',
+            options: [
+                {
+                    value: 'view',
+                    label: 'View Profile & Observations',
+                    hint: `${profile.agentNotes.length} side-note(s) recorded`,
+                },
+                {
+                    value: 'delete_note',
+                    label: 'Delete Specific Side-Note',
+                    hint: 'Select and remove an individual note',
+                },
+                {
+                    value: 'clear_all',
+                    label: 'Reset Profile & Clear Memory',
+                    hint: 'Wipe all persona traits and side-notes',
+                },
+                { value: 'cancel', label: 'Back to Chat', hint: 'Return to active session' },
+            ],
+        });
+        if (p.isCancel(action) || action === 'cancel') {
+            return { shouldContinue: true };
+        }
+        if (action === 'view') {
+            const hasStyle = profile.communicationStyle?.tonePreference ||
+                profile.communicationStyle?.verbosity ||
+                profile.communicationStyle?.formulationStyle;
+            const hasCognitive = profile.cognitiveTraits?.architecturalStyle ||
+                profile.cognitiveTraits?.decisionPreference ||
+                profile.cognitiveTraits?.riskTolerance ||
+                profile.cognitiveTraits?.delegationDepth ||
+                profile.cognitiveTraits?.debuggingStyle ||
+                profile.cognitiveTraits?.explanationFormat;
+            const hasStrengths = profile.technicalPreferences?.strengths && profile.technicalPreferences.strengths.length > 0;
+            const hasConventions = profile.technicalPreferences?.conventions && profile.technicalPreferences.conventions.length > 0;
+            const hasNotes = profile.agentNotes && profile.agentNotes.length > 0;
+            console.log(`\n${pc.bold(pc.cyan('🧠 Global Adaptive User Profile & Persona Memory'))}`);
+            console.log(`${pc.dim('Storage:')} ${pc.dim(getUserProfilePath())}\n`);
+            if (!hasStyle && !hasCognitive && !hasStrengths && !hasConventions && !hasNotes) {
+                p.log.info(pc.yellow('No personalized observations recorded yet. Mino will learn your communication style and preferences organically as you chat.'));
+            }
+            else {
+                if (hasStyle) {
+                    console.log(pc.bold('Communication Style:'));
+                    if (profile.communicationStyle?.tonePreference) {
+                        console.log(`  ${pc.dim('•')} Tone & Demeanor: ${pc.green(profile.communicationStyle.tonePreference)}`);
+                    }
+                    if (profile.communicationStyle?.verbosity) {
+                        console.log(`  ${pc.dim('•')} Output Formatting: ${pc.green(profile.communicationStyle.verbosity)}`);
+                    }
+                    if (profile.communicationStyle?.formulationStyle) {
+                        console.log(`  ${pc.dim('•')} Thought Formulation: ${pc.green(profile.communicationStyle.formulationStyle)}`);
+                    }
+                    console.log('');
+                }
+                if (hasCognitive) {
+                    console.log(pc.bold('Decision-Making & Cognitive Traits:'));
+                    if (profile.cognitiveTraits?.architecturalStyle) {
+                        console.log(`  ${pc.dim('•')} Architectural Orientation: ${pc.magenta(profile.cognitiveTraits.architecturalStyle)}`);
+                    }
+                    if (profile.cognitiveTraits?.decisionPreference) {
+                        console.log(`  ${pc.dim('•')} Decision Autonomy: ${pc.magenta(profile.cognitiveTraits.decisionPreference)}`);
+                    }
+                    if (profile.cognitiveTraits?.riskTolerance) {
+                        console.log(`  ${pc.dim('•')} Risk & Velocity: ${pc.magenta(profile.cognitiveTraits.riskTolerance)}`);
+                    }
+                    if (profile.cognitiveTraits?.delegationDepth) {
+                        console.log(`  ${pc.dim('•')} Delegation Depth: ${pc.magenta(profile.cognitiveTraits.delegationDepth)}`);
+                    }
+                    if (profile.cognitiveTraits?.debuggingStyle) {
+                        console.log(`  ${pc.dim('•')} Debugging Preference: ${pc.magenta(profile.cognitiveTraits.debuggingStyle)}`);
+                    }
+                    if (profile.cognitiveTraits?.explanationFormat) {
+                        console.log(`  ${pc.dim('•')} Explanation Preference: ${pc.magenta(profile.cognitiveTraits.explanationFormat)}`);
+                    }
+                    console.log('');
+                }
+                if (hasStrengths || hasConventions) {
+                    console.log(pc.bold('Technical Preferences:'));
+                    if (hasStrengths) {
+                        console.log(`  ${pc.dim('•')} Strengths: ${pc.cyan(profile.technicalPreferences.strengths.join(', '))}`);
+                    }
+                    if (hasConventions) {
+                        console.log(`  ${pc.dim('•')} Conventions: ${pc.cyan(profile.technicalPreferences.conventions.join(', '))}`);
+                    }
+                    console.log('');
+                }
+                if (hasNotes) {
+                    console.log(pc.bold(`AI Observations & Side-Notes (${profile.agentNotes.length}):`));
+                    profile.agentNotes.forEach((note, idx) => {
+                        console.log(`  ${pc.yellow(`[${idx + 1}]`)} ${note}`);
+                    });
+                    console.log('');
+                }
+            }
+        }
+        else if (action === 'delete_note') {
+            if (profile.agentNotes.length === 0) {
+                p.log.warn('No side-notes recorded yet to delete.');
+            }
+            else {
+                const noteChoices = profile.agentNotes.map((note, idx) => ({
+                    value: idx,
+                    label: `${idx + 1}. ${note.length > 70 ? note.slice(0, 67) + '...' : note}`,
+                }));
+                const selectedIndex = await p.select({
+                    message: 'Select a side-note to delete:',
+                    options: [...noteChoices, { value: -1, label: 'Cancel' }],
+                });
+                if (!p.isCancel(selectedIndex) && typeof selectedIndex === 'number' && selectedIndex >= 0) {
+                    await deleteSideNote(selectedIndex);
+                    p.log.success(`Deleted side-note [${selectedIndex + 1}].`);
+                }
+            }
+        }
+        else if (action === 'clear_all') {
+            const confirmClear = await p.confirm({
+                message: 'Are you sure you want to clear your global profile and all AI side-notes?',
+                initialValue: false,
+            });
+            if (confirmClear && !p.isCancel(confirmClear)) {
+                await clearUserProfile();
+                p.log.success('User profile memory and side-notes have been reset.');
+            }
+        }
+        return { shouldContinue: true };
+    }
     return { shouldContinue: true };
 }

package/dist/services/agent.js

@@ -35,6 +35,7 @@ import { verifyChangedFiles } from './verificationService.js';
 import { buildContextInjection } from '../utils/contextPrompts.js';
 import { registerContextFiles } from '../utils/fileReadGuard.js';
 import { historyText } from '../utils/historyPrompt.js';
+import { loadUserProfile, formatUserProfileForContext, extractAndSaveUserInsights, } from './userProfileService.js';
 // Submodule Imports
 import { AsyncInputHandler } from './agent/inputHandler.js';
 import { processResponse } from './agent/toolLoop.js';
@@ -207,6 +208,7 @@ export async function startAgentLoop(workspaceRoot, version) {
                         hint: 'Manage external workspaces for cross-project development',
                     },
                     { value: '/config-key', label: '/config-key', hint: 'BYOK — Use your own Google AI Studio API key' },
+                    { value: '/profile', label: '/profile', hint: 'View or manage AI observations and persona side-notes' },
                     { 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' },
@@ -451,6 +453,17 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     collector.recordCompressedContextSize(contextInjection.length);
                 dynamicSystemInstruction += '\n\n' + contextInjection;
             }
+            // Inject global adaptive user persona and learned preferences
+            try {
+                const userProfile = await loadUserProfile();
+                const profileInjection = formatUserProfileForContext(userProfile);
+                if (profileInjection) {
+                    dynamicSystemInstruction += '\n\n' + profileInjection;
+                }
+            }
+            catch (e) {
+                debugLog(`Failed to inject user profile context: ${e}`);
+            }
             // Apply the dynamic prompt updates and tool registrations to the active chat session
             chat.setAgentConfig(dynamicSystemInstruction, config.tools);
             if (getGlobalActiveModel() === GEMINI_MODELS.AUTO) {
@@ -549,6 +562,13 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                         // Print the summary text just like single-agent mode
                         console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim(`(Orchestrator)`)}\n`);
                         console.log(renderTerminalMarkdown(handledByOrchestrator));
+                        // Observe user interaction traits and update global user profile before next prompt
+                        try {
+                            await extractAndSaveUserInsights(userInput, handledByOrchestrator, ac.signal);
+                        }
+                        catch (err) {
+                            debugLog(`Background user profile insight extraction failed: ${err}`);
+                        }
                     }
                     // Print Usage Stats
                     const usage = getAndResetTurnUsage();
@@ -671,6 +691,13 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim(`(${chat.getModel()})`)}\n`);
                     console.log(renderTerminalMarkdown(cleanFinalText));
                     chat.appendFinalSummary(cleanFinalText);
+                    // Observe user interaction traits and update global user profile before next prompt
+                    try {
+                        await extractAndSaveUserInsights(userInput, cleanFinalText, ac.signal);
+                    }
+                    catch (err) {
+                        debugLog(`Background user profile insight extraction failed: ${err}`);
+                    }
                 }
             }
             if (usage) {

package/dist/services/ai.d.ts

@@ -114,9 +114,21 @@ export declare function createInvestigationSemanticSession(): any;
 export declare function createWebSearchAgentSession(): any;
 export declare function createHistorySummarizerSession(): any;
 /**
- * Summarizes an array of Content history entries using Gemini Flash Lite.
+ * Sanitizes and formats raw conversation history entries into a structured text transcript
+ * for safe consumption by the History Summarizer without requiring tool declarations or
+ * risking multi-turn schema rejections from the API.
+ */
+export declare function formatHistoryForSummarization(history: Content[]): string;
+/**
+ * Summarizes an array of Content history entries using Gemini Flash.
  */
 export declare function summarizeChatHistory(history: Content[], abortSignal?: AbortSignal): Promise<string>;
+export declare function createUserProfileExtractorSession(): any;
+/**
+ * Creates a Flash-Lite session with structured output to classify whether a user message
+ * is trivial/low-signal (greetings, confirmations, terminal commands) or contains substantive signal.
+ */
+export declare function createTrivialMessageClassifierSession(): any;
 /**
  * Generates a concise title for a chat session based on the user's first message.
  */

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, INVESTIGATION_SEMANTIC_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, USER_PROFILE_EXTRACTOR_SYSTEM_INSTRUCTION, TRIVIAL_MESSAGE_CLASSIFIER_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
 import { workspaceRegistry } from './workspaceRegistry.js';
 import { loadCredentials } from '../utils/credentialStore.js';
 import { ProxyClient } from './proxyClient.js';
@@ -836,7 +836,65 @@ export function createHistorySummarizerSession() {
     });
 }
 /**
- * Summarizes an array of Content history entries using Gemini Flash Lite.
+ * Sanitizes and formats raw conversation history entries into a structured text transcript
+ * for safe consumption by the History Summarizer without requiring tool declarations or
+ * risking multi-turn schema rejections from the API.
+ */
+export function formatHistoryForSummarization(history) {
+    if (!history || history.length === 0)
+        return '';
+    const lines = [];
+    for (const entry of history) {
+        if (!entry || !Array.isArray(entry.parts))
+            continue;
+        const roleLabel = entry.role === 'model' ? 'Assistant' : 'User';
+        const textPieces = [];
+        for (const part of entry.parts) {
+            if (!part)
+                continue;
+            if (typeof part.text === 'string' && part.text.trim()) {
+                textPieces.push(part.text.trim());
+            }
+            else if (part.functionCall) {
+                const name = part.functionCall.name || 'unknown_tool';
+                const argsStr = part.functionCall.args ? JSON.stringify(part.functionCall.args) : '';
+                const compactArgs = argsStr.length > 500 ? argsStr.substring(0, 500) + '...' : argsStr;
+                textPieces.push(`[Tool Invoked: ${name}(${compactArgs})]`);
+            }
+            else if (part.functionResponse) {
+                const name = part.functionResponse.name || 'unknown_tool';
+                const respObj = part.functionResponse.response;
+                let respStr = '';
+                if (respObj) {
+                    if (typeof respObj.output === 'string') {
+                        respStr = respObj.output;
+                    }
+                    else if (typeof respObj.result === 'string') {
+                        respStr = respObj.result;
+                    }
+                    else if (typeof respObj.error === 'string') {
+                        respStr = `Error: ${respObj.error}`;
+                    }
+                    else {
+                        respStr = JSON.stringify(respObj);
+                    }
+                }
+                const compactResp = respStr.length > 1000 ? respStr.substring(0, 1000) + '...' : respStr;
+                textPieces.push(`[Tool Output (${name})]: ${compactResp}`);
+            }
+            else if (part.inlineData) {
+                textPieces.push(`[Inline Data Attachment: ${part.inlineData.mimeType || 'unknown'}]`);
+            }
+        }
+        const turnText = textPieces.join('\n').trim();
+        if (turnText) {
+            lines.push(`[${roleLabel}]:\n${turnText}`);
+        }
+    }
+    return lines.join('\n\n');
+}
+/**
+ * Summarizes an array of Content history entries using Gemini Flash.
  */
 export async function summarizeChatHistory(history, abortSignal) {
     if (!history || history.length === 0) {
@@ -848,9 +906,13 @@ export async function summarizeChatHistory(history, abortSignal) {
         throw err;
     }
     try {
+        const formattedTranscript = formatHistoryForSummarization(history);
+        if (!formattedTranscript || !formattedTranscript.trim()) {
+            return '';
+        }
         const session = createHistorySummarizerSession();
-        session.loadRawHistory(JSON.parse(JSON.stringify(history)));
-        const result = await session.sendMessage('Summarize the preceding conversation history following your compression rules.', undefined, abortSignal);
+        const prompt = `Summarize the preceding conversation history following your compression rules:\n\n<conversation_history>\n${formattedTranscript}\n</conversation_history>`;
+        const result = await session.sendMessage(prompt, undefined, abortSignal);
         return result.response.text() || '';
     }
     catch (error) {
@@ -863,6 +925,150 @@ export async function summarizeChatHistory(history, abortSignal) {
         return '';
     }
 }
+// ─── User Profile Extractor Service ────────────────────────────────────
+export function createUserProfileExtractorSession() {
+    // Configured exclusively with FLASH_LITE for lightweight zero-latency profiling
+    const model = GEMINI_MODELS.FLASH_LITE;
+    return new ProxyChatSession(model, USER_PROFILE_EXTRACTOR_SYSTEM_INSTRUCTION, [], // no tools
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                tonePreference: {
+                    type: SchemaType.STRING,
+                    description: 'Observed tone and demeanor traits of the user',
+                },
+                verbosity: {
+                    type: SchemaType.STRING,
+                    description: 'Observed verbosity and output formatting preference',
+                },
+                formulationStyle: {
+                    type: SchemaType.STRING,
+                    description: 'Observed thought formulation and prompting style',
+                },
+                cognitiveTraits: {
+                    type: SchemaType.OBJECT,
+                    properties: {
+                        architecturalStyle: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "top-down-design", "bottom-up-code", "balanced"',
+                        },
+                        decisionPreference: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "direct-recommendation", "present-options"',
+                        },
+                        riskTolerance: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "defensive-rigor", "pragmatic-speed"',
+                        },
+                        delegationDepth: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "autonomous-delegation", "hands-on-stepwise"',
+                        },
+                        debuggingStyle: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "minimal-diff-fix", "root-cause-deep-dive"',
+                        },
+                        explanationFormat: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "code-first", "bullet-summaries", "conceptual-analogies"',
+                        },
+                    },
+                    description: 'Observed cognitive decision-making, collaboration, and problem-solving traits',
+                },
+                strengths: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'Observed technical strengths or technologies the user is actively familiar with',
+                },
+                removeStrengths: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'Outdated or abandoned technologies to remove when a pivot/contradiction occurs',
+                },
+                conventions: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'Observed architectural habits or coding conventions',
+                },
+                removeConventions: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'Outdated coding conventions to remove when a pivot/contradiction occurs',
+                },
+                addNotes: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.STRING,
+                    },
+                    description: 'New non-conflicting side-notes to add (empty if none)',
+                },
+                updateNotes: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.OBJECT,
+                        properties: {
+                            index: {
+                                type: SchemaType.INTEGER,
+                                description: '0-based index of the existing note to update',
+                            },
+                            updatedText: {
+                                type: SchemaType.STRING,
+                                description: 'Revised note text that supersedes the outdated observation',
+                            },
+                        },
+                        required: ['index', 'updatedText'],
+                    },
+                    description: 'Targeted updates to existing notes that evolved',
+                },
+                deleteNoteIndices: {
+                    type: SchemaType.ARRAY,
+                    items: {
+                        type: SchemaType.INTEGER,
+                    },
+                    description: '0-based indices of contradicted or obsolete notes to delete',
+                },
+            },
+            required: ['addNotes', 'updateNotes', 'deleteNoteIndices'],
+        },
+    });
+}
+/**
+ * Creates a Flash-Lite session with structured output to classify whether a user message
+ * is trivial/low-signal (greetings, confirmations, terminal commands) or contains substantive signal.
+ */
+export function createTrivialMessageClassifierSession() {
+    const model = GEMINI_MODELS.FLASH_LITE;
+    return new ProxyChatSession(model, TRIVIAL_MESSAGE_CLASSIFIER_SYSTEM_INSTRUCTION, [], // no tools
+    {
+        temperature: 0,
+        responseMimeType: 'application/json',
+        responseSchema: {
+            type: SchemaType.OBJECT,
+            properties: {
+                isTrivial: {
+                    type: SchemaType.BOOLEAN,
+                    description: 'True if the message is a low-signal greeting, confirmation, affirmation, or simple control command with zero technical/personal traits',
+                },
+                reason: {
+                    type: SchemaType.STRING,
+                    description: 'Brief reason for the classification decision',
+                },
+            },
+            required: ['isTrivial'],
+        },
+    });
+}
 /**
  * Generates a concise title for a chat session based on the user's first message.
  */

package/dist/services/contextAgent.js

@@ -322,24 +322,26 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
             onProgress(`⚡ Memory Bank HIT — loaded ${cacheHit.entry.relevantFiles.length} files from cache`);
         const cachedFiles = new Map();
         let cumulativeFileTokens = 0;
-        for (const filePath of cacheHit.entry.relevantFiles) {
-            if (abortSignal.aborted) {
-                const err = new Error('Operation aborted');
-                err.name = 'AbortError';
-                throw err;
-            }
-            if (cumulativeFileTokens >= MAX_TOTAL_FILE_TOKENS)
-                break;
+        const readResults = await Promise.all(cacheHit.entry.relevantFiles.map(async (filePath) => {
+            if (abortSignal.aborted)
+                return { filePath, error: 'aborted' };
             const readResult = await executeTool(workspaceRoot, 'read_file', { filePath });
-            if (!readResult.error) {
-                const boundedText = boundFileContent(filePath, readResult.output);
-                cachedFiles.set(filePath, { text: boundedText, inlineData: readResult.inlineData });
-                cumulativeFileTokens += estimateTokenCount(boundedText);
+            return { filePath, readResult };
+        }));
+        for (const item of readResults) {
+            if (item.readResult && !item.readResult.error) {
+                const boundedText = boundFileContent(item.filePath, item.readResult.output);
+                const tokens = estimateTokenCount(boundedText);
+                if (cumulativeFileTokens + tokens <= MAX_TOTAL_FILE_TOKENS) {
+                    cachedFiles.set(item.filePath, { text: boundedText, inlineData: item.readResult.inlineData });
+                    cumulativeFileTokens += tokens;
+                }
             }
         }
         const MAX_TOTAL_FILES = 30;
         try {
             const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
+            const depsToRead = [];
             const autoDiscovered = new Set();
             for (const filePath of cacheHit.entry.relevantFiles) {
                 if (abortSignal.aborted)
@@ -349,25 +351,34 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                     const graph = await buildDependencyGraph(resolved.workspaceRoot);
                     const reverseDeps = graph.getImportedBy(resolved.relativePath);
                     for (const dep of reverseDeps) {
-                        if (abortSignal.aborted)
-                            break;
                         if (cachedFiles.has(dep) || autoDiscovered.has(dep))
                             continue;
                         if (cachedFiles.size + autoDiscovered.size >= MAX_TOTAL_FILES)
                             break;
-                        if (cumulativeFileTokens >= MAX_TOTAL_FILE_TOKENS)
-                            break;
                         autoDiscovered.add(dep);
-                        const depReadRes = await executeTool(resolved.workspaceRoot, 'read_file', { filePath: dep });
-                        if (!depReadRes.error) {
-                            const boundedText = boundFileContent(dep, depReadRes.output);
-                            cachedFiles.set(dep, { text: boundedText, inlineData: depReadRes.inlineData });
-                            cumulativeFileTokens += estimateTokenCount(boundedText);
-                        }
+                        depsToRead.push({ dep, resolvedWorkspace: resolved.workspaceRoot });
                     }
                 }
                 catch (e) { }
             }
+            if (depsToRead.length > 0) {
+                const depResults = await Promise.all(depsToRead.map(async ({ dep, resolvedWorkspace }) => {
+                    if (abortSignal.aborted)
+                        return { dep, error: 'aborted' };
+                    const depReadRes = await executeTool(resolvedWorkspace, 'read_file', { filePath: dep });
+                    return { dep, depReadRes };
+                }));
+                for (const item of depResults) {
+                    if (item.depReadRes && !item.depReadRes.error) {
+                        const boundedText = boundFileContent(item.dep, item.depReadRes.output);
+                        const tokens = estimateTokenCount(boundedText);
+                        if (cumulativeFileTokens + tokens <= MAX_TOTAL_FILE_TOKENS) {
+                            cachedFiles.set(item.dep, { text: boundedText, inlineData: item.depReadRes.inlineData });
+                            cumulativeFileTokens += tokens;
+                        }
+                    }
+                }
+            }
         }
         catch (e) { }
         const { accumulateUsage } = await import('./metrics.js');

package/dist/services/orchestration/investigationAgent.js

@@ -135,7 +135,6 @@ export class InvestigationAgentRunner {
                     success = true;
                     break;
                 }
-                let isFinished = false;
                 if (onTool) {
                     for (const call of functionCalls) {
                         onTool(formatToolCall(call.name, (call.args || {})));

package/dist/services/proxyClient.js

@@ -359,11 +359,12 @@ export class ProxyClient {
                     // ignore parsing error
                 }
                 const errorMsg = errorData.error?.message || response.statusText;
-                if (response.status === 400 ||
-                    response.status === 401 ||
+                if (response.status === 401 ||
                     response.status === 403 ||
                     errorMsg.includes('API_KEY_INVALID') ||
+                    errorMsg.includes('API_KEY_EXPIRED') ||
                     errorMsg.includes('quota') ||
+                    errorMsg.includes('RESOURCE_EXHAUSTED') ||
                     errorMsg.includes('PERMISSION_DENIED')) {
                     throw new Error('AI_BYOK_ERROR: Your API key or quota is invalid. Please run /config-key to update your settings.');
                 }