minovative-mind-cli 2.14.1 → 2.14.3

package/dist/services/agent.js

@@ -26,13 +26,13 @@ const execAsync = promisify(exec);
 import { debugLog, isDebugOn } from '../utils/logger.js';
 import { ensureProjectStorage, ensureIgnored, readCache, writeCache, invalidateCacheForDependents, } from '../utils/projectStorage.js';
 import { GEMINI_MODELS, TPM_COOLING_DELAYS } from '../utils/config.js';
-import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, compressTextUsingFlashLite, generateChatTitle, getGlobalActiveModel, getModelThinkingLevel, summarizeChatHistory, } from './ai.js';
+import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, getResearchConfig, compressTextUsingFlashLite, generateChatTitle, getGlobalActiveModel, getModelThinkingLevel, summarizeChatHistory, } from './ai.js';
 import { getAndResetTurnUsage } from './proxyClient.js';
 import { changeLogger } from './changeLogger.js';
 import { chatHistoryService } from './chatHistoryService.js';
 import { gatherContext, routeIntent, evaluateExecutionComplexity } from './contextAgent.js';
 import { verifyChangedFiles } from './verificationService.js';
-import { buildContextInjection } from '../utils/contextPrompts.js';
+import { buildTieredContextInjection, CONTEXT_BUDGET_CONFIG } from '../utils/contextPrompts.js';
 import { registerContextFiles } from '../utils/fileReadGuard.js';
 import { historyText } from '../utils/historyPrompt.js';
 import { loadUserProfile, formatUserProfileForContext, extractAndSaveUserInsights } from './userProfileService.js';
@@ -43,6 +43,8 @@ import { handleSlashCommand } from './agent/slashCommands.js';
 import { getMetricCollector } from './metrics.js';
 import { Orchestrator } from './orchestration/orchestrator.js';
 import { isSubAgentsEnabled, getApprovalMode } from './agent-tools.js';
+import { resetSessionSettingsToDefault } from './sessionSettings.js';
+import { clearFileReadCache } from '../utils/fileReadCache.js';
 import { runWithAgentId } from '../utils/asyncContext.js';
 // Export submodules for potential external uses if required
 export { AsyncInputHandler } from './agent/inputHandler.js';
@@ -117,6 +119,8 @@ export async function startAgentLoop(workspaceRoot, version) {
     changeLogger.init(workspaceRoot);
     chatHistoryService.init(workspaceRoot);
     const chat = createSharedChatSession();
+    resetSessionSettingsToDefault(chat);
+    clearFileReadCache();
     const inputHandler = new AsyncInputHandler();
     const chatSessionState = {
         id: crypto.randomUUID(),
@@ -160,6 +164,7 @@ export async function startAgentLoop(workspaceRoot, version) {
             chatSessionState.modelUsageCounts = {};
             chatSessionState.latestUsageMetadata = undefined;
             chatSessionState.previousUsageMetadata = undefined;
+            resetSessionSettingsToDefault(chat);
             chat.setSessionInfo(chatSessionState.id, workspaceRoot);
         }
         inputHandler.stop();
@@ -359,21 +364,22 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             if (gatherRes.chainedMessages.length > 0) {
                 const chainedContent = gatherRes.chainedMessages.join('\n');
                 const newIntent = await routeIntent(chainedContent, '', ac.signal);
-                if (gatherRes.contextResult !== null) {
-                    // If the model previously needed search context, determine if followups change the mode
-                    effectiveTargetAgent = newIntent.targetAgent;
+                if (gatherRes.targetAgent === 'EXECUTE') {
+                    // EXECUTE permission sets are immutable during follow-ups to prevent downgrades
+                    effectiveTargetAgent = 'EXECUTE';
+                }
+                else if (gatherRes.targetAgent === 'RESEARCH') {
+                    // RESEARCH sessions stay in RESEARCH mode during chained requests
+                    // Chained requests are incorporated into the research context for comprehensive investigation
+                    effectiveTargetAgent = 'RESEARCH';
                 }
                 else {
-                    // If not in a context-search flow
-                    if (gatherRes.targetAgent === 'EXECUTE') {
-                        // EXECUTE permission sets are immutable during follow-ups to prevent downgrades
+                    // If in CHAT mode, escalate if chained instructions dictate
+                    if (newIntent.targetAgent === 'EXECUTE') {
                         effectiveTargetAgent = 'EXECUTE';
                     }
-                    else {
-                        // Conversational prompts can escalate to EXECUTE if chained instructions dictate
-                        if (newIntent.targetAgent === 'EXECUTE' || newIntent.needsContext) {
-                            effectiveTargetAgent = 'EXECUTE';
-                        }
+                    else if (newIntent.targetAgent === 'RESEARCH') {
+                        effectiveTargetAgent = 'RESEARCH';
                     }
                 }
                 finalInput += `\n\n[USER FOLLOW-UP INSTRUCTIONS SENT DURING INVESTIGATION]:\n${chainedContent}\n\nPlease incorporate these instructions into your work. Address them appropriately, but ensure you do not lose track of the original request's primary objective.`;
@@ -383,16 +389,23 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 process.stdout.write('\x1b[2K\r');
                 return;
             }
-            // Hot-swap the underlying LLM system instruction context depending on intent (conversational vs execution)
+            // Hot-swap the underlying LLM system instruction context depending on intent (conversational vs research vs execution)
             debugLog(`Intent Router output: original targetAgent = ${gatherRes.targetAgent}, effective = ${effectiveTargetAgent}`);
-            const config = effectiveTargetAgent === 'CHAT' ? getGeneralChatConfig() : getPlanExecutionConfig();
+            const config = effectiveTargetAgent === 'CHAT'
+                ? getGeneralChatConfig()
+                : effectiveTargetAgent === 'RESEARCH'
+                    ? getResearchConfig()
+                    : getPlanExecutionConfig();
             let dynamicSystemInstruction = config.systemInstruction;
             // Inject gathered workspace directories, dependency configurations, and matching search patterns
             if (gatherRes.contextResult) {
                 // Compress each relevant file individually using helper to avoid nested loop warning
                 gatherRes.contextResult.relevantFiles = await compressContextFiles(workspaceRoot, gatherRes.contextResult, ac.signal);
-                // Assemble the final context injection string
-                const contextInjection = buildContextInjection(gatherRes.contextResult);
+                // Assemble the final context injection string using 3-tier IR/graph context ranking
+                const contextInjection = buildTieredContextInjection(gatherRes.contextResult, {
+                    prompt: userInput,
+                    maxChars: CONTEXT_BUDGET_CONFIG.DEFAULT_CONTEXT_MAX_CHARS,
+                });
                 debugLog(`Final compressed context injection size: ${contextInjection.length} chars`);
                 // Pre-register all injected files with the read-guard so the execution
                 // agent is allowed to modify them without calling read_file first.
@@ -492,6 +505,9 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 if (effectiveTargetAgent === 'CHAT') {
                     selectedModel = GEMINI_MODELS.FLASH_LITE;
                 }
+                else if (effectiveTargetAgent === 'RESEARCH') {
+                    selectedModel = GEMINI_MODELS.FLASH;
+                }
                 else {
                     spinner.stop(); // MUST clear the investigation spinner first to prevent leaking the setInterval
                     spinner.start(pc.blue('🧠 Evaluating execution complexity...'));
@@ -658,6 +674,8 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                             creditsRemaining: usage.remainingBalance,
                             lastTurnDuration: turnDuration,
                             modelName: chat.getModel(),
+                            thinkingLevel: (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+                                getModelThinkingLevel(chat.getModel()),
                             totalTokens: chatSessionState.totalTokens,
                             totalInputTokens: chatSessionState.totalInputTokens,
                             totalOutputTokens: chatSessionState.totalOutputTokens,
@@ -665,6 +683,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                             gitBranch: gitBranch || undefined,
                             autoApprove: getApprovalMode() === 'skip-all',
                             subAgents: isSubAgentsEnabled(),
+                            debugMode: isDebugOn(),
                             latestUsageMetadata: chatSessionState.latestUsageMetadata,
                             previousUsageMetadata: chatSessionState.previousUsageMetadata,
                             modelUsageCounts: chatSessionState.modelUsageCounts,
@@ -822,6 +841,8 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                             creditsRemaining: latestUsage?.remainingBalance,
                             lastTurnDuration: turnDuration,
                             modelName: chat.getModel(),
+                            thinkingLevel: (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+                                getModelThinkingLevel(chat.getModel()),
                             totalTokens: chatSessionState.totalTokens,
                             totalInputTokens: chatSessionState.totalInputTokens,
                             totalOutputTokens: chatSessionState.totalOutputTokens,
@@ -829,6 +850,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                             gitBranch: gitBranch || undefined,
                             autoApprove: getApprovalMode() === 'skip-all',
                             subAgents: isSubAgentsEnabled(),
+                            debugMode: isDebugOn(),
                             latestUsageMetadata: chatSessionState.latestUsageMetadata,
                             previousUsageMetadata: chatSessionState.previousUsageMetadata,
                             modelUsageCounts: chatSessionState.modelUsageCounts,
@@ -847,6 +869,8 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     creditsRemaining: latestUsage?.remainingBalance,
                     lastTurnDuration: turnDuration,
                     modelName: chat.getModel(),
+                    thinkingLevel: (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+                        getModelThinkingLevel(chat.getModel()),
                     totalTokens: chatSessionState.totalTokens,
                     totalInputTokens: chatSessionState.totalInputTokens,
                     totalOutputTokens: chatSessionState.totalOutputTokens,
@@ -854,6 +878,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     gitBranch: gitBranch || undefined,
                     autoApprove: getApprovalMode() === 'skip-all',
                     subAgents: isSubAgentsEnabled(),
+                    debugMode: isDebugOn(),
                     latestUsageMetadata: chatSessionState.latestUsageMetadata,
                     previousUsageMetadata: chatSessionState.previousUsageMetadata,
                     modelUsageCounts: chatSessionState.modelUsageCounts,
@@ -1201,7 +1226,7 @@ If you are not done, please continue working using your other tools.`;
             .join('\n\n');
         debugLog(`Verification failed on attempt ${correctionAttempts}/${MAX_CORRECTIONS}. Issues:\n${combinedIssuesForAI}`);
         // Compile compilation and syntax diagnostic warnings into an auto-correction prompt
-        const correctionPrompt = `AUTOMATED SYSTEM CHECK: Your previous changes resulted in the following issues:\n\n${combinedIssuesForAI}\n\nPlease analyze these issues and use your file modification tools to fix them.`;
+        const correctionPrompt = `AUTOMATED SYSTEM CHECK: Your previous changes resulted in the following issues:\n\n${combinedIssuesForAI}\n\nCRITICAL ANTI-CHEATING RULE: You MUST fix these issues head-on in the application source code. You are STRICTLY FORBIDDEN from modifying build configurations (e.g. next.config.*, tsconfig.json, vite.config.*, .eslintrc*, package.json scripts) to ignore, disable, or bypass build, compile, type, or lint errors (such as ignoreBuildErrors, ignoreDuringBuilds, or turning off checks). You are also forbidden from adding blanket suppressions like @ts-ignore, @ts-nocheck, or eslint-disable to silence errors. Fix the underlying root cause in the actual code.`;
         // Cooling-off delay before initiating the self-correction turn
         await new Promise((resolve) => setTimeout(resolve, TPM_COOLING_DELAYS.CORRECTION_TURN_MS));
         if (signal.aborted)

package/dist/services/ai.d.ts

@@ -18,6 +18,9 @@ export declare function setModelThinkingLevel(model: string, level: ThinkingLeve
  * Resets user-configured thinking levels back to default model presets.
  */
 export declare function resetModelThinkingLevels(): void;
+export declare const HISTORICAL_TOOL_OUTPUT_THRESHOLD = 1500;
+export declare const COLLAPSED_TOOL_OUTPUT_MARKER = "\n... [Historical tool output collapsed to save context]";
+export declare function collapseHistoricalOutput(val: string, threshold?: number): string;
 export declare class ProxyChatSession {
     private history;
     private fullHistory;
@@ -114,6 +117,12 @@ export declare function getPlanExecutionConfig(): {
         functionDeclarations: import("@google/generative-ai").FunctionDeclaration[];
     }[];
 };
+export declare function getResearchConfig(): {
+    systemInstruction: string;
+    tools: {
+        functionDeclarations: import("@google/generative-ai").FunctionDeclaration[];
+    }[];
+};
 /**
  * Compresses a large string of text using Gemini Flash.
  * Used for shrinking context payloads to prevent OOM/choking.

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, 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 { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, RESEARCH_AGENT_SYSTEM_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';
@@ -100,9 +100,9 @@ const MAX_HISTORY_ENTRIES = 500;
  * payload stays within sane memory bounds.
  */
 const MAX_PART_TEXT_LENGTH = 60_000;
-const HISTORICAL_TOOL_OUTPUT_THRESHOLD = 1500;
-const COLLAPSED_TOOL_OUTPUT_MARKER = '\n... [Historical tool output collapsed to save context]';
-function collapseHistoricalOutput(val, threshold = HISTORICAL_TOOL_OUTPUT_THRESHOLD) {
+export const HISTORICAL_TOOL_OUTPUT_THRESHOLD = 1500;
+export const COLLAPSED_TOOL_OUTPUT_MARKER = '\n... [Historical tool output collapsed to save context]';
+export function collapseHistoricalOutput(val, threshold = HISTORICAL_TOOL_OUTPUT_THRESHOLD) {
     if (typeof val !== 'string')
         return String(val ?? '');
     if (val.length <= threshold || val.includes('[Historical tool output collapsed')) {
@@ -354,20 +354,10 @@ export class ProxyChatSession {
                         const funcResp = part.functionResponse;
                         if (funcResp.response && typeof funcResp.response === 'object') {
                             const respObj = funcResp.response;
-                            if (typeof respObj.output === 'string') {
-                                respObj.output = collapseHistoricalOutput(respObj.output, threshold);
-                            }
-                            if (typeof respObj.error === 'string') {
-                                respObj.error = collapseHistoricalOutput(respObj.error, threshold);
-                            }
-                            if (typeof respObj.result === 'string') {
-                                respObj.result = collapseHistoricalOutput(respObj.result, threshold);
-                            }
-                            if (typeof respObj.stdout === 'string') {
-                                respObj.stdout = collapseHistoricalOutput(respObj.stdout, threshold);
-                            }
-                            if (typeof respObj.stderr === 'string') {
-                                respObj.stderr = collapseHistoricalOutput(respObj.stderr, threshold);
+                            for (const key of Object.keys(respObj)) {
+                                if (typeof respObj[key] === 'string') {
+                                    respObj[key] = collapseHistoricalOutput(respObj[key], threshold);
+                                }
                             }
                         }
                     }
@@ -544,6 +534,12 @@ export function getPlanExecutionConfig() {
         tools: [{ functionDeclarations: getToolDeclarations({ isExecutionAgent: true }) }],
     };
 }
+export function getResearchConfig() {
+    return {
+        systemInstruction: RESEARCH_AGENT_SYSTEM_INSTRUCTION.replace('{{MULTI_WORKSPACE_BLOCK}}', getMultiWorkspaceBlock()),
+        tools: [{ functionDeclarations: getToolDeclarations({ isResearchAgent: true }) }],
+    };
+}
 /**
  * Compresses a large string of text using Gemini Flash.
  * Used for shrinking context payloads to prevent OOM/choking.
@@ -701,7 +697,17 @@ export function getContextToolDeclarations() {
                 },
                 {
                     name: 'run_analysis_script',
-                    description: 'Write and execute a disposable analysis script to structurally map code in the workspace. Use this to get exact line ranges for functions, classes, and variables by leveraging the language\'s native AST parser (e.g., TypeScript compiler API, Python ast module, go/parser). You can also use this to probe the development environment — detecting available runtimes (e.g., node --version, python3 --version), checking if ports are in use, identifying project type (monorepo, package manager), or diagnosing system-level issues (disk space, memory) that may affect execution. For complex investigation tasks, you can write lightweight ML scripts (e.g., TF-IDF cosine similarity to rank file relevance, Z-score outlier detection for anomalous log lines, K-Means clustering, or Naive Bayes classification). Default to "node" for generic math/analysis as a safe baseline, but act like a native inhabitant of the host environment — if Python, Go, Rust, or specialized libraries are available in the project context, leverage the host\'s native runtimes and standard libraries for maximum efficiency. The script is executed from a temporary directory and automatically cleaned up after execution. Output should be structured JSON to stdout. Use the results to make precise read_file calls with exact startLine/endLine instead of guessing. CRITICAL: Do not use this tool on binary, document, or non-code files (e.g. PDF, image, audio, docx).',
+                    description: 'Write and execute a disposable analysis script to structurally map code in the workspace. ' +
+                        'Sandbox Features: ' +
+                        '(1) Preloaded Helpers: "emitResult(data)" / "__emitResult(data)" sends structured JSON payloads directly to structuredResult without manual stdout parsing; "inspectSymbols(target)" / "inspectObject(target)" inspects functions, classes, and properties. ' +
+                        '(2) Module & Path Resolution: Automatically inherits tsconfig.json path aliases (@/*), NODE_PATH, and workspace virtualenvs (.venv, venv) for Python. ' +
+                        '(3) Diagnostics Middleware: Provides actionable [SANDBOX DIAGNOSTIC] advisories for missing imports, ESM/CJS interop, and compiler errors. ' +
+                        'Use this to get exact line ranges for functions, classes, and variables by leveraging the language\'s native AST parser (e.g., TypeScript compiler API, Python ast module, go/parser). ' +
+                        'You can also use this to probe the development environment — detecting available runtimes (e.g., node --version, python3 --version), checking if ports are in use, identifying project type (monorepo, package manager), or diagnosing system-level issues (disk space, memory) that may affect execution. ' +
+                        'For complex investigation tasks, you can write lightweight ML scripts (e.g., TF-IDF cosine similarity to rank file relevance, Z-score outlier detection for anomalous log lines, K-Means clustering, or Naive Bayes classification). ' +
+                        'Default to "node" for generic math/analysis as a safe baseline, but act like a native inhabitant of the host environment — if Python, Go, Rust, or specialized libraries are available in the project context, leverage the host\'s native runtimes and standard libraries for maximum efficiency. ' +
+                        'The script is executed from a temporary directory and automatically cleaned up after execution. ' +
+                        'Use the results to make precise read_file calls with exact startLine/endLine instead of guessing. CRITICAL: Do not use this tool on binary, document, or non-code files (e.g. PDF, image, audio, docx).',
                     parameters: {
                         type: SchemaType.OBJECT,
                         properties: {
@@ -711,7 +717,7 @@ export function getContextToolDeclarations() {
                             },
                             code: {
                                 type: SchemaType.STRING,
-                                description: 'The analysis script code. Should output structured JSON to stdout with structural information (name, type, startLine, endLine for each code element).',
+                                description: 'The analysis script code. Should output structured JSON to stdout or use emitResult(data) with structural information (name, type, startLine, endLine for each code element).',
                             },
                             targetFile: {
                                 type: SchemaType.STRING,
@@ -794,7 +800,7 @@ export function createIntentRouterSession() {
                 },
                 agent: {
                     type: SchemaType.STRING,
-                    enum: ['CHAT', 'EXECUTE'],
+                    enum: ['CHAT', 'RESEARCH', 'EXECUTE'],
                     description: 'Target agent to route the request to',
                 },
             },
@@ -1109,6 +1115,50 @@ export function createUserProfileExtractorSession() {
                     },
                     description: 'Observed cognitive decision-making, collaboration, and problem-solving traits',
                 },
+                conversationalPersona: {
+                    type: SchemaType.OBJECT,
+                    properties: {
+                        relationshipModel: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "collaborative-peer", "command-operator", "rubber-duck", "socratic-explorer"',
+                        },
+                        banterAffinity: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "witty-banter", "dry-professional", "warm-encouraging"',
+                        },
+                        formalityLevel: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "casual-slang", "telegraphic-concise", "polite-cordial"',
+                        },
+                        apologyTolerance: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "zero-apologies", "tolerant-empathetic"',
+                        },
+                        stressCadence: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "urgent-surgical", "calm-exploratory"',
+                        },
+                        promptingHabit: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "code-dump-deducer", "bulleted-architect", "stream-of-consciousness", "rapid-breadcrumbs"',
+                        },
+                        conversationalQuirks: {
+                            type: SchemaType.ARRAY,
+                            items: {
+                                type: SchemaType.STRING,
+                            },
+                            description: 'Observed recurring catchphrases, quirks, or unique conversational habits',
+                        },
+                        removeQuirks: {
+                            type: SchemaType.ARRAY,
+                            items: {
+                                type: SchemaType.STRING,
+                            },
+                            description: 'Outdated or superseded conversational quirks to prune',
+                        },
+                    },
+                    description: 'Observed interpersonal, psychological, and conversational pairing dynamics',
+                },
                 strengths: {
                     type: SchemaType.ARRAY,
                     items: {

package/dist/services/chatHistoryService.d.ts

@@ -1,4 +1,5 @@
 import type { Content } from '@google/generative-ai';
+import type { ThinkingLevel } from '../utils/config.js';
 /**
  * Options for configuring dynamic history pruning.
  */
@@ -32,6 +33,8 @@ export interface ChatSessionData {
     lastTurnDuration?: string;
     /** Optional name of the AI model used during this session (e.g., "gemini-1.5-pro"). */
     modelName?: string;
+    /** Optional thinking reasoning level used during this session (e.g., "LOW", "MEDIUM", "HIGH"). */
+    thinkingLevel?: ThinkingLevel;
     /** Optional total cumulative tokens consumed during the session. */
     totalTokens?: number;
     /** Optional total cumulative input tokens (prompt + cached) consumed during the session. */
@@ -46,6 +49,8 @@ export interface ChatSessionData {
     autoApprove?: boolean;
     /** Optional flag indicating whether sub-agents were enabled or active during this session. */
     subAgents?: boolean;
+    /** Optional flag indicating whether debug diagnostic logging was enabled in this session. */
+    debugMode?: boolean;
     /** Optional metadata about the token usage from the very last turn. */
     latestUsageMetadata?: any;
     /** Optional metadata about the token usage from the turn prior to the last turn. */

package/dist/services/contextAgent.d.ts

@@ -1,19 +1,27 @@
+import type { TierPartitionResult } from '../utils/contextRanker.js';
+export interface ContextFileEntry {
+    text: string;
+    inlineData?: any;
+    scoped?: boolean;
+    tier?: 1 | 2 | 3;
+    outline?: string;
+}
 export interface ContextAgentResult {
     projectTree: string;
     projectType: string;
-    relevantFiles: Map<string, {
-        text: string;
-        inlineData?: any;
-    }>;
+    relevantFiles: Map<string, ContextFileEntry>;
     summary: string;
     webSearchSummary?: string;
     fromMemoryBank?: boolean;
     isParallel?: boolean;
+    tierPartition?: TierPartitionResult;
 }
 export declare function detectProjectType(workspaceRoot: string): Promise<string>;
+import type { TargetAgent } from './agent/types.js';
+export type { TargetAgent } from './agent/types.js';
 export interface IntentRoute {
     needsContext: boolean;
-    targetAgent: 'CHAT' | 'EXECUTE';
+    targetAgent: TargetAgent;
 }
 export declare function routeIntent(userRequest: string, chatHistory?: string, abortSignal?: AbortSignal): Promise<IntentRoute>;
 export declare function evaluateExecutionComplexity(userRequest: string, investigationSummary: string | undefined, numRelevantFiles: number, chatHistory?: string, abortSignal?: AbortSignal): Promise<'EASY' | 'HARD'>;
@@ -22,6 +30,6 @@ export declare function gatherContext(workspaceRoot: string, userRequest: string
     waitForPrompt: () => Promise<void>;
 }, abortSignal: AbortSignal, onProgress?: (msg: string) => void, onToolCall?: (msg: string, label: string) => void): Promise<{
     contextResult: ContextAgentResult | null;
-    targetAgent: 'CHAT' | 'EXECUTE';
+    targetAgent: TargetAgent;
     chainedMessages: string[];
 }>;

package/dist/services/contextAgent.js

@@ -219,9 +219,11 @@ export async function routeIntent(userRequest, chatHistory = '', abortSignal) {
         const text = result.response.text()?.trim() || '{}';
         const parsed = JSON.parse(text);
         debugLog(`Intent Router Parsed: ${JSON.stringify(parsed)}`);
+        const rawAgent = parsed.agent?.toUpperCase?.() || parsed.agent;
+        const validAgent = rawAgent === 'CHAT' ? 'CHAT' : rawAgent === 'RESEARCH' ? 'RESEARCH' : 'EXECUTE';
         return {
             needsContext: parsed.context === 'SEARCH',
-            targetAgent: parsed.agent === 'CHAT' ? 'CHAT' : 'EXECUTE',
+            targetAgent: validAgent,
         };
     }
     catch (e) {
@@ -557,8 +559,8 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
             else if (call.name === 'find_recent_changes') {
                 logMsg = `  [Context Agent] Looking for recently modified files`;
             }
-            else if (call.name === 'run_analysis_script') {
-                logMsg = `  [Context Agent] Running analysis script (${args.language})`;
+            else if (call.name === 'run_analysis_script' || call.name === 'run_debug_script') {
+                logMsg = `  [Context Agent] Running analysis script (${args.language || 'auto'})`;
             }
             if (onProgress) {
                 onProgress(logMsg.trim());
@@ -745,18 +747,42 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                     },
                 };
             }
-            else if (call.name === 'run_analysis_script') {
-                const analysisResult = await runEphemeralScript(workspaceRoot, args.language, args.code, {
+            else if (call.name === 'run_analysis_script' || call.name === 'run_debug_script') {
+                const analysisResult = await runEphemeralScript(workspaceRoot, args.language || 'auto', args.code, {
                     abortSignal,
                 });
-                const rawOutput = analysisResult.exitCode === 0
-                    ? analysisResult.stdout || '(script produced no output)'
-                    : `Script failed (exit ${analysisResult.exitCode}):\n${analysisResult.stderr}`;
-                const output = boundToolOutput(rawOutput);
+                let rawOutput = '';
+                if (analysisResult.exitCode !== 0) {
+                    rawOutput += `Script failed with exit code ${analysisResult.exitCode}.\n`;
+                }
+                if (analysisResult.structuredResult !== undefined) {
+                    const formattedStructured = typeof analysisResult.structuredResult === 'string'
+                        ? analysisResult.structuredResult
+                        : JSON.stringify(analysisResult.structuredResult, null, 2);
+                    rawOutput += `[STRUCTURED RESULT]\n${formattedStructured}\n`;
+                }
+                if (analysisResult.stdout) {
+                    rawOutput += `[STDOUT]\n${analysisResult.stdout}\n`;
+                }
+                if (analysisResult.stderr) {
+                    rawOutput += `[STDERR]\n${analysisResult.stderr}\n`;
+                }
+                if (!rawOutput.trim()) {
+                    rawOutput = '(script produced no output)';
+                }
+                const output = boundToolOutput(rawOutput.trim());
                 return {
                     functionResponse: {
                         name: call.name,
-                        response: { output },
+                        response: {
+                            output,
+                            ...(analysisResult.structuredResult !== undefined
+                                ? { structuredResult: analysisResult.structuredResult }
+                                : {}),
+                            ...(analysisResult.exitCode !== 0
+                                ? { error: `Script failed (exit ${analysisResult.exitCode}):\n${analysisResult.stderr}` }
+                                : {}),
+                        },
                     },
                 };
             }

package/dist/services/orchestration/investigationAgent.js

@@ -329,19 +329,43 @@ export class InvestigationAgentRunner {
                             },
                         };
                     }
-                    else if (call.name === 'run_analysis_script') {
+                    else if (call.name === 'run_analysis_script' || call.name === 'run_debug_script') {
                         if (onProgress)
-                            onProgress(`${logPrefix} Running analysis script`);
-                        const analysisResult = await runEphemeralScript(this.workspaceRoot, args.language, args.code, {
+                            onProgress(`${logPrefix} Running analysis script (${args.language || 'auto'})`);
+                        const analysisResult = await runEphemeralScript(this.workspaceRoot, args.language || 'auto', args.code, {
                             abortSignal,
                         });
-                        const output = analysisResult.exitCode === 0
-                            ? analysisResult.stdout || '(script produced no output)'
-                            : `Script failed (exit ${analysisResult.exitCode}):\n${analysisResult.stderr}`;
+                        let rawOutput = '';
+                        if (analysisResult.exitCode !== 0) {
+                            rawOutput += `Script failed with exit code ${analysisResult.exitCode}.\n`;
+                        }
+                        if (analysisResult.structuredResult !== undefined) {
+                            const formattedStructured = typeof analysisResult.structuredResult === 'string'
+                                ? analysisResult.structuredResult
+                                : JSON.stringify(analysisResult.structuredResult, null, 2);
+                            rawOutput += `[STRUCTURED RESULT]\n${formattedStructured}\n`;
+                        }
+                        if (analysisResult.stdout) {
+                            rawOutput += `[STDOUT]\n${analysisResult.stdout}\n`;
+                        }
+                        if (analysisResult.stderr) {
+                            rawOutput += `[STDERR]\n${analysisResult.stderr}\n`;
+                        }
+                        if (!rawOutput.trim()) {
+                            rawOutput = '(script produced no output)';
+                        }
                         return {
                             functionResponse: {
                                 name: call.name,
-                                response: { output },
+                                response: {
+                                    output: rawOutput.trim(),
+                                    ...(analysisResult.structuredResult !== undefined
+                                        ? { structuredResult: analysisResult.structuredResult }
+                                        : {}),
+                                    ...(analysisResult.exitCode !== 0
+                                        ? { error: `Script failed (exit ${analysisResult.exitCode}):\n${analysisResult.stderr}` }
+                                        : {}),
+                                },
                             },
                         };
                     }

package/dist/services/orchestration/investigationCache.js

@@ -332,20 +332,21 @@ function tokenJaccardSimilarity(a, b) {
 export async function generateWorkspaceFingerprint(workspaceRoot, relevantFiles) {
     const fileStats = [];
     for (const file of relevantFiles) {
+        const normFile = file.replace(/\\/g, '/').toLowerCase();
         try {
-            const fullPath = path.join(workspaceRoot, file);
+            const fullPath = path.isAbsolute(file) ? file : path.join(workspaceRoot, file);
             const stat = await fs.stat(fullPath);
-            fileStats.push(`${file}:${stat.mtimeMs}:${stat.size}`);
+            fileStats.push(`${normFile}:${stat.mtimeMs}:${stat.size}`);
         }
         catch (e) {
             if (e.code === 'ENOENT') {
-                fileStats.push(`${file}:deleted`);
+                fileStats.push(`${normFile}:deleted`);
             }
             else if (e.code === 'EACCES' || e.code === 'EPERM') {
-                fileStats.push(`${file}:inaccessible`);
+                fileStats.push(`${normFile}:inaccessible`);
             }
             else {
-                fileStats.push(`${file}:error`);
+                fileStats.push(`${normFile}:error`);
             }
         }
     }
@@ -356,15 +357,17 @@ export async function generateWorkspaceFingerprint(workspaceRoot, relevantFiles)
  * Enforces LRU eviction to keep cache store below MAX_CACHE_SIZE_BYTES (5MB).
  */
 export function pruneCacheStore(store) {
+    if (!store || !store.entries)
+        return;
     let storeJson = JSON.stringify(store);
     while (Buffer.byteLength(storeJson, 'utf8') > MAX_CACHE_SIZE_BYTES) {
         const keys = Object.keys(store.entries);
         if (keys.length === 0)
             break;
         let oldestKey = keys[0];
-        let oldestTime = store.entries[oldestKey].lastAccessedAt || store.entries[oldestKey].createdAt;
+        let oldestTime = store.entries[oldestKey].lastAccessedAt || store.entries[oldestKey].createdAt || 0;
         for (let i = 1; i < keys.length; i++) {
-            const entryTime = store.entries[keys[i]].lastAccessedAt || store.entries[keys[i]].createdAt;
+            const entryTime = store.entries[keys[i]].lastAccessedAt || store.entries[keys[i]].createdAt || 0;
             if (entryTime < oldestTime) {
                 oldestKey = keys[i];
                 oldestTime = entryTime;
@@ -612,7 +615,14 @@ export async function invalidateFilesFromInvestigationCache(workspaceRoot, chang
         const entry = store.entries[hash];
         const dependsOnChange = entry.relevantFiles.some((f) => {
             const normF = f.replace(/\\/g, '/').toLowerCase();
-            return normalizedChanged.some((c) => normF === c || normF.endsWith('/' + c) || c.endsWith('/' + normF));
+            const baseF = path.basename(normF);
+            return normalizedChanged.some((c) => {
+                const baseC = path.basename(c);
+                return (normF === c ||
+                    normF.endsWith('/' + c) ||
+                    c.endsWith('/' + normF) ||
+                    (baseF === baseC && (normF.includes(c) || c.includes(normF))));
+            });
         });
         if (dependsOnChange) {
             delete store.entries[hash];
@@ -620,7 +630,7 @@ export async function invalidateFilesFromInvestigationCache(workspaceRoot, chang
         }
     }
     if (invalidated > 0) {
-        writeCache(workspaceRoot, CACHE_FILE, store);
+        await writeCache(workspaceRoot, CACHE_FILE, store);
         debugLog(`[DEBUG] Investigation cache: invalidated ${invalidated} entries referencing changed files`);
     }
 }

package/dist/services/orchestration/readCache.d.ts

@@ -73,6 +73,7 @@ export declare class ReadCache {
     /**
      * Invalidates and evicts all cache entries associated with a file path,
      * including full-file reads and any ranged or targeted sub-reads.
+     * Uses case-insensitive and normalized path comparison.
      *
      * @param filePath - The file path that was modified or deleted.
      */