minovative-mind-cli 2.14.2 → 2.14.3

package/README.md

@@ -156,14 +156,14 @@ Minovative Mind CLI continuously adapts to your unique developer personality and
 | `/profile`      | View, inspect, delete, or reset global adaptive persona memory, pairing dynamics, and AI side-notes                                             |
 | `/models`       | Hot-swap the active model or configure its native reasoning thinking level (`Low`, `Medium`, `High`)                                            |
 | `/paste`        | Multi-line input mode (cancel with Ctrl+C)                                                                                                      |
-| `/clear`        | Clear conversation history                                                                                                                      |
-| `/debug`        | Expose internal agent diagnostics                                                                                                               |
-| `/auto-approve` | Toggle skipping confirmation prompts for commands                                                                                               |
-| `/sub-agents`   | Toggle the MMAAK Engine for parallel investigation and execution (concurrency limited to 2)                                                     |
+| `/clear`        | Clear conversation history and reset session settings to safe defaults                                                                          |
+| `/debug`        | Toggle internal agent telemetry and diagnostic logging (saved per session)                                                                      |
+| `/auto-approve` | Toggle skipping confirmation prompts for commands (saved per session, automatically resets to 'ask' on new sessions)                            |
+| `/sub-agents`   | Toggle the MMAAK Engine for parallel investigation and execution (saved per session, concurrency limited to 2)                                  |
 | `/stats`        | View session and all-time statistics, token telemetry, active model settings, and live thinking level runtime telemetry                         |
 | `/commit`       | Generate a conventional commit message from your diff                                                                                           |
 | `/revert`       | Undo changes from the last turn, or toggle the revert logger                                                                                    |
-| `/chats`        | View, resume, rename, or delete previous chat sessions (with centralized token telemetry, Git branch, auto-approve status, and sub-agent state) |
+| `/chats`        | View, resume, rename, or delete previous chat sessions (with session settings restoration, Git branch, auto-approve status, and sub-agent state) |
 | `/workspaces`   | Manage active workspaces and linked cross-repo aliases                                                                                          |
 | `stop`          | Abort generation immediately                                                                                                                    |
 

package/dist/services/agent/slashCommands.js

@@ -19,6 +19,10 @@ import { GEMINI_MODELS, isByokEnabled, DEFAULT_MODEL_THINKING_LEVELS } from '../
 import { loadCredentials, updateCredentialField } from '../../utils/credentialStore.js';
 import { getGlobalActiveModel, setGlobalActiveModel, getModelThinkingLevel, setModelThinkingLevel, ProxyChatSession } from '../ai.js';
 import { loadUserProfile, deleteSideNote, clearUserProfile, getUserProfilePath } from '../userProfileService.js';
+import { applySessionSettings, resetSessionSettingsToDefault, syncActiveSessionSettings, } from '../sessionSettings.js';
+import { clearFileReadCache } from '../../utils/fileReadCache.js';
+import { invalidateDependencyGraph } from '../../utils/dependencyTracer.js';
+import { clearSymbolExtractorCache } from '../../utils/symbolExtractor.js';
 /**
  * @file slashCommands.ts
  * @description Interactive slash command handler module for Minovative Mind CLI.
@@ -79,12 +83,22 @@ export async function handleSlashCommand(command, context) {
      */
     if (lowerCommand === '/clear') {
         chat.clearHistory();
+        resetSessionSettingsToDefault(chat);
+        if (chatSessionState) {
+            chatSessionState.autoApprove = false;
+            chatSessionState.subAgents = true;
+            chatSessionState.debugMode = false;
+            chatSessionState.modelName = chat.getModel();
+            chatSessionState.thinkingLevel =
+                (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+                    getModelThinkingLevel(chat.getModel());
+        }
         process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
         printLogo();
         p.intro(`${brandBg(' Minovative Mind CLI ')} ${pc.dim('v' + version)}`);
         p.log.info(`${pc.dim('Workspace:')} ${brandFg(workspaceRoot)}`);
         p.log.info(`${pc.dim('Commands:')} Type ${pc.yellow('/')} to open the command menu and "${pc.yellow('stop')}" to stop the ai generation. Type ${pc.yellow('exit')} to leave.`);
-        p.log.success('Chat history cleared.');
+        p.log.success('Chat history cleared (session settings reset to defaults).');
         console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
         return { shouldContinue: true };
     }
@@ -139,11 +153,17 @@ export async function handleSlashCommand(command, context) {
         if (!p.isCancel(selectedModel)) {
             chat.setModel(selectedModel);
             setGlobalActiveModel(selectedModel);
+            if (chatSessionState) {
+                chatSessionState.modelName = selectedModel;
+            }
             if (selectedModel === 'auto') {
                 const defaultAutoThinking = DEFAULT_MODEL_THINKING_LEVELS[GEMINI_MODELS.AUTO] || 'MEDIUM';
                 if (typeof chat.setThinkingLevel === 'function') {
                     chat.setThinkingLevel(defaultAutoThinking);
                 }
+                if (chatSessionState) {
+                    chatSessionState.thinkingLevel = defaultAutoThinking;
+                }
                 p.log.success(`Model successfully switched to ${pc.cyan('Auto (Smart Routing & Reasoning)')}`);
             }
             else {
@@ -174,15 +194,22 @@ export async function handleSlashCommand(command, context) {
                     if (typeof chat.setThinkingLevel === 'function') {
                         chat.setThinkingLevel(selectedThinking);
                     }
+                    if (chatSessionState) {
+                        chatSessionState.thinkingLevel = selectedThinking;
+                    }
                     p.log.success(`Model successfully switched to ${pc.cyan(selectedModel)} with thinking level ${pc.cyan(selectedThinking)}`);
                 }
                 else {
                     if (typeof chat.setThinkingLevel === 'function') {
                         chat.setThinkingLevel(activeModelThinking);
                     }
+                    if (chatSessionState) {
+                        chatSessionState.thinkingLevel = activeModelThinking;
+                    }
                     p.log.success(`Model successfully switched to ${pc.cyan(selectedModel)}`);
                 }
             }
+            await syncActiveSessionSettings(chatSessionState?.id, chat);
         }
         return { shouldContinue: true };
     }
@@ -191,6 +218,10 @@ export async function handleSlashCommand(command, context) {
      */
     if (lowerCommand === '/debug') {
         const debugMode = toggleDebugMode();
+        if (chatSessionState) {
+            chatSessionState.debugMode = debugMode;
+        }
+        await syncActiveSessionSettings(chatSessionState?.id, chat);
         if (debugMode) {
             const currentModel = chat.getModel();
             const currentThinkingLevel = (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
@@ -208,10 +239,18 @@ export async function handleSlashCommand(command, context) {
     if (lowerCommand === '/auto-approve') {
         if (getApprovalMode() === 'skip-all') {
             setApprovalMode('ask');
+            if (chatSessionState) {
+                chatSessionState.autoApprove = false;
+            }
+            await syncActiveSessionSettings(chatSessionState?.id, chat);
             p.log.success('Auto-approve disabled. You will be prompted before commands run.');
         }
         else {
             setApprovalMode('skip-all');
+            if (chatSessionState) {
+                chatSessionState.autoApprove = true;
+            }
+            await syncActiveSessionSettings(chatSessionState?.id, chat);
             p.log.success('Auto-approve enabled for all future commands in this session.');
         }
         return { shouldContinue: true };
@@ -222,10 +261,18 @@ export async function handleSlashCommand(command, context) {
     if (lowerCommand === '/sub-agents') {
         if (isSubAgentsEnabled()) {
             setSubAgentsEnabled(false);
+            if (chatSessionState) {
+                chatSessionState.subAgents = false;
+            }
+            await syncActiveSessionSettings(chatSessionState?.id, chat);
             p.log.success('MMAAK Engine disabled. Single-agent mode active.');
         }
         else {
             setSubAgentsEnabled(true);
+            if (chatSessionState) {
+                chatSessionState.subAgents = true;
+            }
+            await syncActiveSessionSettings(chatSessionState?.id, chat);
             p.log.success('MMAAK Engine enabled. The system will now use parallel investigation and thread agents.');
         }
         return { shouldContinue: true };
@@ -478,6 +525,9 @@ export async function handleSlashCommand(command, context) {
                     await fs.writeFile(absolutePath, change.originalContent, 'utf-8');
                 }
             }
+            clearFileReadCache();
+            invalidateDependencyGraph(workspaceRoot);
+            clearSymbolExtractorCache();
             spinner.stop('Reverted successfully.');
             p.log.success(`Reverted ${changesToRevert.length} changeset(s) successfully.`);
         }
@@ -514,6 +564,7 @@ export async function handleSlashCommand(command, context) {
         }
         if (chatsMenu === 'new') {
             chat.clearHistory();
+            resetSessionSettingsToDefault(chat);
             if (chatSessionState) {
                 chatSessionState.id = crypto.randomUUID();
                 chatSessionState.title = '';
@@ -521,6 +572,13 @@ export async function handleSlashCommand(command, context) {
                 chatSessionState.totalInputTokens = 0;
                 chatSessionState.totalOutputTokens = 0;
                 chatSessionState.totalCreditsUsed = 0;
+                chatSessionState.autoApprove = false;
+                chatSessionState.subAgents = true;
+                chatSessionState.debugMode = false;
+                chatSessionState.modelName = chat.getModel();
+                chatSessionState.thinkingLevel =
+                    (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+                        getModelThinkingLevel(chat.getModel());
                 chat.setSessionInfo(chatSessionState.id, workspaceRoot);
             }
             process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
@@ -528,7 +586,7 @@ export async function handleSlashCommand(command, context) {
             p.intro(`${brandBg(' Minovative Mind CLI ')} ${pc.dim('v' + version)}`);
             p.log.info(`${pc.dim('Workspace:')} ${brandFg(workspaceRoot)}`);
             p.log.info(`${pc.dim('Commands:')} Type ${pc.yellow('/')} to open the command menu and "${pc.yellow('stop')}" to stop the ai generation. Type ${pc.yellow('exit')} to leave.`);
-            p.log.success('Started a new chat session.');
+            p.log.success('Started a new chat session (settings reset to defaults).');
             console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
             return { shouldContinue: true };
         }
@@ -577,6 +635,8 @@ export async function handleSlashCommand(command, context) {
             }
             const session = sessions.find((s) => s.id === selectedSessionId);
             if (session) {
+                // Restore session-scoped operational settings
+                const applied = applySessionSettings(session, chat);
                 // Update timestamp so it becomes the most recently used session
                 session.timestamp = Date.now();
                 await chatHistoryService.saveSession(session);
@@ -591,6 +651,11 @@ export async function handleSlashCommand(command, context) {
                     chatSessionState.latestUsageMetadata = session.latestUsageMetadata;
                     chatSessionState.previousUsageMetadata = session.previousUsageMetadata;
                     chatSessionState.modelUsageCounts = session.modelUsageCounts || {};
+                    chatSessionState.autoApprove = applied.autoApprove;
+                    chatSessionState.subAgents = applied.subAgents;
+                    chatSessionState.debugMode = applied.debugMode;
+                    chatSessionState.modelName = applied.modelName;
+                    chatSessionState.thinkingLevel = applied.thinkingLevel;
                     chat.setSessionInfo(session.id, workspaceRoot);
                 }
                 process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
@@ -599,6 +664,16 @@ export async function handleSlashCommand(command, context) {
                 p.log.info(`${pc.dim('Workspace:')} ${brandFg(workspaceRoot)}`);
                 p.log.info(`${pc.dim('Commands:')} Type ${pc.yellow('/')} to open the command menu and "${pc.yellow('stop')}" to stop the ai generation. Type ${pc.yellow('exit')} to leave.`);
                 p.log.success(`Resumed session: ${session.title}`);
+                // Display session settings restoration status badge
+                const autoApproveBadge = applied.autoApprove ? pc.green('ON') : pc.dim('OFF');
+                const subAgentsBadge = applied.subAgents ? pc.green('ON') : pc.red('OFF');
+                const debugBadge = applied.debugMode ? pc.green('ON') : pc.dim('OFF');
+                const modelBadge = pc.cyan(applied.modelName);
+                const thinkingBadge = pc.cyan(applied.thinkingLevel);
+                p.log.info(`${pc.dim('Session Settings:')} Model: ${modelBadge} (thinking: ${thinkingBadge}) | Auto-Approve: ${autoApproveBadge} | Sub-Agents: ${subAgentsBadge} | Debug: ${debugBadge}`);
+                if (applied.autoApprove) {
+                    p.log.warn(pc.yellow('Notice: Auto-approve is ENABLED for this resumed session.'));
+                }
                 // Print the loaded history cleanly: only user and AI conversational messages,
                 // with a clean indicator label if the turn involved tool/code changes.
                 let turnHadModifications = false;
@@ -689,9 +764,6 @@ export async function handleSlashCommand(command, context) {
                 if (session.lastTurnDuration !== undefined) {
                     p.log.info(`${pc.dim('Generated in')} ${pc.cyan(session.lastTurnDuration + 's')}`);
                 }
-                if (session.modelName) {
-                    p.log.info(`${pc.dim('Model:')} ${pc.cyan(session.modelName)}`);
-                }
                 if (session.totalTokens !== undefined) {
                     const inputStr = session.totalInputTokens
                         ? ` (Input: ${session.totalInputTokens.toLocaleString()}, Output: ${(session.totalOutputTokens || 0).toLocaleString()})`
@@ -704,11 +776,6 @@ export async function handleSlashCommand(command, context) {
                 if (session.gitBranch) {
                     p.log.info(`${pc.dim('Last Active Branch:')} ${pc.cyan(session.gitBranch)}`);
                 }
-                if (session.autoApprove !== undefined || session.subAgents !== undefined) {
-                    const aa = session.autoApprove ? pc.green('Enabled') : pc.yellow('Disabled');
-                    const sa = session.subAgents ? pc.green('Enabled') : pc.yellow('Disabled');
-                    p.log.info(`${pc.dim('Sub-Agents:')} ${sa} | ${pc.dim('Auto-Approve:')} ${aa}`);
-                }
                 console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
             }
         }
@@ -754,12 +821,27 @@ export async function handleSlashCommand(command, context) {
             p.log.success('Session deleted successfully.');
             if (chatSessionState && chatSessionState.id === selectedSessionId) {
                 chat.clearHistory();
+                resetSessionSettingsToDefault(chat);
+                chatSessionState.id = crypto.randomUUID();
+                chatSessionState.title = '';
+                chatSessionState.totalTokens = 0;
+                chatSessionState.totalInputTokens = 0;
+                chatSessionState.totalOutputTokens = 0;
+                chatSessionState.totalCreditsUsed = 0;
+                chatSessionState.autoApprove = false;
+                chatSessionState.subAgents = true;
+                chatSessionState.debugMode = false;
+                chatSessionState.modelName = chat.getModel();
+                chatSessionState.thinkingLevel =
+                    (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+                        getModelThinkingLevel(chat.getModel());
+                chat.setSessionInfo(chatSessionState.id, workspaceRoot);
                 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.');
+                p.log.warn('Active session was deleted. Chat history and settings reset to defaults.');
                 console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
             }
         }
@@ -787,12 +869,27 @@ export async function handleSlashCommand(command, context) {
                 p.log.success(`Successfully deleted ${selectedIds.length} session(s).`);
                 if (chatSessionState && selectedIds.includes(chatSessionState.id)) {
                     chat.clearHistory();
+                    resetSessionSettingsToDefault(chat);
+                    chatSessionState.id = crypto.randomUUID();
+                    chatSessionState.title = '';
+                    chatSessionState.totalTokens = 0;
+                    chatSessionState.totalInputTokens = 0;
+                    chatSessionState.totalOutputTokens = 0;
+                    chatSessionState.totalCreditsUsed = 0;
+                    chatSessionState.autoApprove = false;
+                    chatSessionState.subAgents = true;
+                    chatSessionState.debugMode = false;
+                    chatSessionState.modelName = chat.getModel();
+                    chatSessionState.thinkingLevel =
+                        (typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+                            getModelThinkingLevel(chat.getModel());
+                    chat.setSessionInfo(chatSessionState.id, workspaceRoot);
                     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.');
+                    p.log.warn('Active session was deleted. Chat history and settings reset to defaults.');
                     console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
                 }
             }

package/dist/services/agent/toolLoop.js

@@ -3,7 +3,7 @@ import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { debugLog } from '../../utils/logger.js';
 import { executeTool } from '../agent-tools.js';
-import { getPlanExecutionConfig, HISTORICAL_TOOL_OUTPUT_THRESHOLD } from '../ai.js';
+import { getPlanExecutionConfig, getResearchConfig, HISTORICAL_TOOL_OUTPUT_THRESHOLD } from '../ai.js';
 import { routeIntent } from '../contextAgent.js';
 import { requestCommandApproval } from './commandApproval.js';
 import { getMetricCollector, recordRecoveryCircuitBreakerTrip } from '../metrics.js';
@@ -265,7 +265,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
         if (queuedMsg) {
             additionalText = `[USER INTERRUPTION] The user sent the following message during your execution:\n"${queuedMsg}"\n\nPlease incorporate this feedback into your ongoing work. Address the user's message, but DO NOT lose track of your original overall plan or focus. After addressing this interruption, continue with your broader objective.`;
             p.log.info(pc.cyan(`Sending queued message to AI...`));
-            // Dynamically upgrade agent permissions/intent to EXECUTE mode if the interrupted instruction requires system modifications
+            // Dynamically upgrade agent permissions/intent if the interrupted instruction requires system modifications
             const newIntent = await routeIntent(queuedMsg, '', abortSignal);
             if (agentState.targetAgent === 'CHAT') {
                 if (newIntent.targetAgent === 'EXECUTE' || newIntent.needsContext) {
@@ -274,7 +274,14 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
                     chat.setAgentConfig(config.systemInstruction, config.tools);
                     p.log.info(pc.yellow(`Upgraded session intent to EXECUTE based on chained message.`));
                 }
+                else if (newIntent.targetAgent === 'RESEARCH') {
+                    agentState.targetAgent = 'RESEARCH';
+                    const config = getResearchConfig();
+                    chat.setAgentConfig(config.systemInstruction, config.tools);
+                    p.log.info(pc.cyan(`Upgraded session intent to RESEARCH based on chained message.`));
+                }
             }
+            // If agentState.targetAgent === 'RESEARCH', keep RESEARCH mode and incorporate into ongoing research
         }
         // Apply in-place history pruning to collapse oversized tool responses older than 1 turn
         chat.pruneToolOutputHistory(HISTORICAL_TOOL_OUTPUT_THRESHOLD, 1);

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

@@ -1,12 +1,14 @@
 import type { ProxyChatSession } from '../ai.js';
 import type { AsyncInputHandler } from './inputHandler.js';
+export type TargetAgent = 'CHAT' | 'RESEARCH' | 'EXECUTE';
 /**
  * State tracking container for the active agent operational mode.
  */
 export interface AgentState {
-    /** The target agent mode: 'CHAT' for conversational interactions or 'EXECUTE' for tool/command execution. */
-    targetAgent: 'CHAT' | 'EXECUTE';
+    /** The target agent mode: 'CHAT' for conversational interactions, 'RESEARCH' for active diagnostics/benchmarks, or 'EXECUTE' for tool/command execution. */
+    targetAgent: TargetAgent;
 }
+import type { ThinkingLevel } from '../../utils/config.js';
 /**
  * Context object provided to slash command handlers containing session handles, terminal state, and metadata.
  */
@@ -32,6 +34,11 @@ export interface SlashCommandContext {
         latestUsageMetadata?: any;
         previousUsageMetadata?: any;
         modelUsageCounts?: Record<string, number>;
+        autoApprove?: boolean;
+        subAgents?: boolean;
+        debugMode?: boolean;
+        modelName?: string;
+        thinkingLevel?: ThinkingLevel;
     };
 }
 /**

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

@@ -31,11 +31,12 @@ export interface ToolResult {
 /**
  * Returns the list of available function declarations for Gemini function calling.
  *
- * @param options - Configuration options such as `isExecutionAgent`.
+ * @param options - Configuration options such as `isExecutionAgent` or `isResearchAgent`.
  * @returns An array of Google Generative AI `FunctionDeclaration` objects.
  */
 export declare function getToolDeclarations(options?: {
     isExecutionAgent?: boolean;
+    isResearchAgent?: boolean;
 }): FunctionDeclaration[];
 /**
  * FunctionDeclaration-compatible schema objects that describe

package/dist/services/agent-tools.js

@@ -23,13 +23,15 @@ import { findBestMatch, applyMatch } from '../utils/fuzzyMatch.js';
 import { localValidate } from '../utils/localSyntaxValidator.js';
 import { validateAndFixSyntax, aiFuzzyMatch } from './agent/syntaxAgent.js';
 import { sanitizeForCDATA } from '../utils/contextPrompts.js';
-import { findDependencies, formatDependencyResult } from '../utils/dependencyTracer.js';
+import { findDependencies, formatDependencyResult, invalidateDependencyGraph } from '../utils/dependencyTracer.js';
 import { atomicWriteFile } from '../utils/atomicWrite.js';
 import { EXCLUDED_EXTENSIONS } from '../utils/excludedExtensions.js';
 import { extractSymbols } from '../utils/symbolExtractor.js';
 import { getMetricCollector, recordRecoveryPrunedLogVolume } from './metrics.js';
 import { getCurrentAgentId } from '../utils/asyncContext.js';
 import { recordFileRead, hasAgentReadFile } from '../utils/fileReadGuard.js';
+import { getCachedFileContent, invalidateFileReadCache, clearFileReadCache } from '../utils/fileReadCache.js';
+import { detectAntiCheatingViolations, isCriticalConfigFile } from '../utils/antiCheatingGuard.js';
 import { runFuzzProbe, checkHeapDelta as runCheckHeapDelta, checkBehavioralDrift as runCheckBehavioralDrift, runEphemeralScript, } from '../utils/analysisRunner.js';
 import ignore from 'ignore';
 const execAsync = promisify(exec);
@@ -37,13 +39,24 @@ const execAsync = promisify(exec);
 /**
  * Returns the list of available function declarations for Gemini function calling.
  *
- * @param options - Configuration options such as `isExecutionAgent`.
+ * @param options - Configuration options such as `isExecutionAgent` or `isResearchAgent`.
  * @returns An array of Google Generative AI `FunctionDeclaration` objects.
  */
 export function getToolDeclarations(options) {
     if (options?.isExecutionAgent) {
         return toolDeclarations;
     }
+    if (options?.isResearchAgent) {
+        const excludedForResearch = new Set([
+            'modify_file',
+            'write_file',
+            'delete_file',
+            'rename_file',
+            'create_todo_list',
+            'update_todo_status',
+        ]);
+        return toolDeclarations.filter((tool) => !excludedForResearch.has(tool.name));
+    }
     return toolDeclarations.filter((tool) => tool.name !== 'create_todo_list' && tool.name !== 'update_todo_status' && tool.name !== 'finish_task');
 }
 /**
@@ -626,7 +639,7 @@ export async function readFile(workspaceRoot, filePath, startLine, endLine, targ
                 };
             }
         }
-        let content = await fs.readFile(absPath, 'utf-8');
+        let content = await getCachedFileContent(absPath);
         // Handle Jupyter Notebooks natively
         if (filePath.toLowerCase().endsWith('.ipynb')) {
             try {
@@ -829,9 +842,15 @@ export async function writeFile(workspaceRoot, filePath, content) {
                 };
             }
         }
+        const antiCheatError = detectAntiCheatingViolations(filePath, finalContent, existingContent ?? undefined);
+        if (antiCheatError) {
+            return { output: '', error: antiCheatError };
+        }
         await fs.mkdir(path.dirname(absPath), { recursive: true });
         changeLogger.logChange(filePath, existingContent, existingContent !== null ? 'modify' : 'create');
         await atomicWriteFile(absPath, finalContent, 'utf-8');
+        invalidateFileReadCache(absPath);
+        invalidateDependencyGraph(workspaceRoot);
         return { output: `Successfully wrote to "${filePath}".` };
     }
     catch (err) {
@@ -854,6 +873,12 @@ export async function writeFile(workspaceRoot, filePath, content) {
  */
 export async function deleteFile(workspaceRoot, filePath) {
     try {
+        if (isCriticalConfigFile(filePath)) {
+            return {
+                output: '',
+                error: `Anti-cheating violation: Deleting critical configuration file "${filePath}" is strictly prohibited. You must fix all build, compiler, type, and lint errors head-on in the source code.`,
+            };
+        }
         const absPath = resolveAndValidatePath(workspaceRoot, filePath);
         let existingContent = null;
         try {
@@ -864,6 +889,8 @@ export async function deleteFile(workspaceRoot, filePath) {
         }
         changeLogger.logChange(filePath, existingContent, 'delete');
         await fs.rm(absPath, { force: true });
+        invalidateFileReadCache(absPath);
+        invalidateDependencyGraph(workspaceRoot);
         return { output: `Successfully deleted "${filePath}".` };
     }
     catch (err) {
@@ -881,6 +908,12 @@ export async function deleteFile(workspaceRoot, filePath) {
  */
 export async function renameFile(workspaceRoot, sourcePath, targetPath) {
     try {
+        if (isCriticalConfigFile(sourcePath)) {
+            return {
+                output: '',
+                error: `Anti-cheating violation: Moving or renaming critical configuration file "${sourcePath}" is strictly prohibited. You must fix all build, compiler, type, and lint errors head-on in the source code.`,
+            };
+        }
         const absSource = resolveAndValidatePath(workspaceRoot, sourcePath);
         const absTarget = resolveAndValidatePath(workspaceRoot, targetPath);
         let existingContent = null;
@@ -896,6 +929,9 @@ export async function renameFile(workspaceRoot, sourcePath, targetPath) {
         changeLogger.logChange(targetPath, null, 'create');
         await fs.mkdir(path.dirname(absTarget), { recursive: true });
         await fs.rename(absSource, absTarget);
+        invalidateFileReadCache(absSource);
+        invalidateFileReadCache(absTarget);
+        invalidateDependencyGraph(workspaceRoot);
         return { output: `Successfully moved/renamed "${sourcePath}" to "${targetPath}".` };
     }
     catch (err) {
@@ -1018,10 +1054,16 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                     };
                 }
             }
+            const antiCheatError = detectAntiCheatingViolations(filePath, finalModified, existing);
+            if (antiCheatError) {
+                return { output: '', error: antiCheatError };
+            }
             changeLogger.logChange(filePath, existing, 'modify');
             await atomicWriteFile(absPath, finalModified, 'utf-8');
+            invalidateFileReadCache(absPath);
+            invalidateDependencyGraph(workspaceRoot);
             return {
-                output: `Successfully applied ${edits.length} edit(s) to "${filePath}".\\nStrategies used:\\n${strategies.join('\\n')}`,
+                output: `Successfully applied ${edits.length} edit(s) to "${filePath}".\nStrategies used:\n${strategies.join('\n')}`,
             };
         }
         catch (err) {
@@ -1385,6 +1427,9 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
             maxBuffer: 1024 * 1024 * 2, // 2 MB buffer
             signal: abortSignal,
         });
+        // Invalidate caches as shell command may have modified the workspace filesystem
+        clearFileReadCache();
+        invalidateDependencyGraph(workspaceRoot);
         const output = [stdout, stderr].filter(Boolean).join('\n');
         // Bounded head/tail window truncation with structured metadata receipt
         const windowedOutput = truncateWithHeadTailWindow(output, {
@@ -1395,6 +1440,9 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
         return { output: windowedOutput || '(command produced no output)' };
     }
     catch (err) {
+        // Also invalidate in case of partial command execution or errors that wrote files
+        clearFileReadCache();
+        invalidateDependencyGraph(workspaceRoot);
         const message = err instanceof Error ? err.message : String(err);
         // Condense error output with high-signal extraction and dynamic tail sizing
         const condensedError = extractHighSignalError(message);