minovative-mind-cli 2.14.2 → 2.14.3

package/dist/services/agent.js

@@ -26,7 +26,7 @@ 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';
@@ -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,9 +389,13 @@ 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) {
@@ -495,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...'));
@@ -661,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,
@@ -668,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,
@@ -825,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,
@@ -832,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,
@@ -850,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,
@@ -857,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,
@@ -1204,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

@@ -117,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';
@@ -534,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.
@@ -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',
                 },
             },

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

@@ -17,9 +17,11 @@ export interface ContextAgentResult {
     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'>;
@@ -28,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) {

package/dist/services/sessionSettings.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @file sessionSettings.ts
+ * @description Manages session-scoped slash command settings and operational toggles.
+ *
+ * Operational toggles scoped to an individual chat session include:
+ * - `autoApprove`  : Whether automatic confirmation is enabled for shell execution commands (/auto-approve)
+ * - `subAgents`    : Whether the MMAAK parallel multi-agent orchestration engine is enabled (/sub-agents)
+ * - `debugMode`    : Whether internal diagnostic telemetry logging is visible (/debug)
+ * - `modelName`    : The generative AI model selected for this session (/models)
+ * - `thinkingLevel`: The reasoning budget allocation level for the active model (/models)
+ *
+ * Safe Lifecycle:
+ * - On new chat sessions or CLI boot, settings automatically reset to safe defaults.
+ * - On resuming a saved session, previous settings are restored and verified.
+ */
+import { type ThinkingLevel } from '../utils/config.js';
+import { type ProxyChatSession } from './ai.js';
+import { type ChatSessionData } from './chatHistoryService.js';
+/**
+ * Session-scoped operational settings container.
+ */
+export interface SessionSettings {
+    /** Whether auto-approval mode is enabled for command execution ('skip-all' vs 'ask'). */
+    autoApprove: boolean;
+    /** Whether MMAAK parallel sub-agent orchestration is enabled. */
+    subAgents: boolean;
+    /** Whether internal telemetry and diagnostic logging is enabled. */
+    debugMode: boolean;
+    /** Active generative AI model identifier for the session. */
+    modelName: string;
+    /** Active thinking/reasoning level for the model. */
+    thinkingLevel: ThinkingLevel;
+}
+/**
+ * Default safe settings used when creating a new chat session or resetting state.
+ */
+export declare const DEFAULT_SESSION_SETTINGS: Readonly<SessionSettings>;
+/**
+ * Applies saved or specified settings to the active environment and chat session.
+ *
+ * @param session - A partial session object or settings container.
+ * @param chat - Optional active ProxyChatSession instance to update.
+ * @returns The resulting applied SessionSettings.
+ */
+export declare function applySessionSettings(session: Partial<ChatSessionData> | Partial<SessionSettings>, chat?: ProxyChatSession): SessionSettings;
+/**
+ * Resets all session operational toggles back to default safe values.
+ *
+ * @param chat - Optional active ProxyChatSession instance to reset.
+ * @returns The default SessionSettings.
+ */
+export declare function resetSessionSettingsToDefault(chat?: ProxyChatSession): SessionSettings;
+/**
+ * Inspects and retrieves the current operational settings across modules.
+ *
+ * @param chat - Optional active ProxyChatSession instance.
+ * @returns The current active SessionSettings.
+ */
+export declare function getCurrentSessionSettings(chat?: ProxyChatSession): SessionSettings;
+/**
+ * Persists current operational settings to the saved session cache if the session exists on disk.
+ *
+ * @param sessionId - The unique identifier of the chat session to update.
+ * @param chat - Optional active ProxyChatSession instance.
+ */
+export declare function syncActiveSessionSettings(sessionId?: string, chat?: ProxyChatSession): Promise<void>;

package/dist/services/sessionSettings.js

@@ -0,0 +1,126 @@
+/**
+ * @file sessionSettings.ts
+ * @description Manages session-scoped slash command settings and operational toggles.
+ *
+ * Operational toggles scoped to an individual chat session include:
+ * - `autoApprove`  : Whether automatic confirmation is enabled for shell execution commands (/auto-approve)
+ * - `subAgents`    : Whether the MMAAK parallel multi-agent orchestration engine is enabled (/sub-agents)
+ * - `debugMode`    : Whether internal diagnostic telemetry logging is visible (/debug)
+ * - `modelName`    : The generative AI model selected for this session (/models)
+ * - `thinkingLevel`: The reasoning budget allocation level for the active model (/models)
+ *
+ * Safe Lifecycle:
+ * - On new chat sessions or CLI boot, settings automatically reset to safe defaults.
+ * - On resuming a saved session, previous settings are restored and verified.
+ */
+import { setApprovalMode, getApprovalMode, isSubAgentsEnabled, setSubAgentsEnabled } from './agent-tools.js';
+import { isDebugOn, setDebugMode } from '../utils/logger.js';
+import { DEFAULT_MODEL, DEFAULT_MODEL_THINKING_LEVELS, } from '../utils/config.js';
+import { getGlobalActiveModel, setGlobalActiveModel, getModelThinkingLevel, setModelThinkingLevel, } from './ai.js';
+import { chatHistoryService } from './chatHistoryService.js';
+/**
+ * Default safe settings used when creating a new chat session or resetting state.
+ */
+export const DEFAULT_SESSION_SETTINGS = Object.freeze({
+    autoApprove: false,
+    subAgents: true,
+    debugMode: false,
+    modelName: DEFAULT_MODEL,
+    thinkingLevel: (DEFAULT_MODEL_THINKING_LEVELS[DEFAULT_MODEL] || 'MEDIUM'),
+});
+/**
+ * Applies saved or specified settings to the active environment and chat session.
+ *
+ * @param session - A partial session object or settings container.
+ * @param chat - Optional active ProxyChatSession instance to update.
+ * @returns The resulting applied SessionSettings.
+ */
+export function applySessionSettings(session, chat) {
+    // 1. Auto-approve mode
+    const autoApprove = session.autoApprove ?? DEFAULT_SESSION_SETTINGS.autoApprove;
+    setApprovalMode(autoApprove ? 'skip-all' : 'ask');
+    // 2. MMAAK sub-agents
+    const subAgents = session.subAgents ?? DEFAULT_SESSION_SETTINGS.subAgents;
+    setSubAgentsEnabled(subAgents);
+    // 3. Debug logging
+    const debugMode = session.debugMode ?? DEFAULT_SESSION_SETTINGS.debugMode;
+    setDebugMode(debugMode);
+    // 4. Model selection
+    const modelName = session.modelName ?? DEFAULT_SESSION_SETTINGS.modelName;
+    setGlobalActiveModel(modelName);
+    if (chat && typeof chat.setModel === 'function') {
+        chat.setModel(modelName);
+    }
+    // 5. Thinking level
+    const targetThinking = session.thinkingLevel ??
+        getModelThinkingLevel(modelName) ??
+        DEFAULT_MODEL_THINKING_LEVELS[modelName] ??
+        DEFAULT_SESSION_SETTINGS.thinkingLevel;
+    setModelThinkingLevel(modelName, targetThinking);
+    if (chat && typeof chat.setThinkingLevel === 'function') {
+        chat.setThinkingLevel(targetThinking);
+    }
+    return {
+        autoApprove,
+        subAgents,
+        debugMode,
+        modelName,
+        thinkingLevel: targetThinking,
+    };
+}
+/**
+ * Resets all session operational toggles back to default safe values.
+ *
+ * @param chat - Optional active ProxyChatSession instance to reset.
+ * @returns The default SessionSettings.
+ */
+export function resetSessionSettingsToDefault(chat) {
+    return applySessionSettings(DEFAULT_SESSION_SETTINGS, chat);
+}
+/**
+ * Inspects and retrieves the current operational settings across modules.
+ *
+ * @param chat - Optional active ProxyChatSession instance.
+ * @returns The current active SessionSettings.
+ */
+export function getCurrentSessionSettings(chat) {
+    const autoApprove = getApprovalMode() === 'skip-all';
+    const subAgents = isSubAgentsEnabled();
+    const debugMode = isDebugOn();
+    const modelName = (chat && typeof chat.getModel === 'function' ? chat.getModel() : undefined) || getGlobalActiveModel();
+    const thinkingLevel = (chat && typeof chat.getThinkingLevel === 'function' ? chat.getThinkingLevel() : undefined) ||
+        getModelThinkingLevel(modelName) ||
+        'MEDIUM';
+    return {
+        autoApprove,
+        subAgents,
+        debugMode,
+        modelName,
+        thinkingLevel,
+    };
+}
+/**
+ * Persists current operational settings to the saved session cache if the session exists on disk.
+ *
+ * @param sessionId - The unique identifier of the chat session to update.
+ * @param chat - Optional active ProxyChatSession instance.
+ */
+export async function syncActiveSessionSettings(sessionId, chat) {
+    if (!sessionId)
+        return;
+    try {
+        const session = chatHistoryService.getSession(sessionId);
+        if (!session)
+            return;
+        const current = getCurrentSessionSettings(chat);
+        session.autoApprove = current.autoApprove;
+        session.subAgents = current.subAgents;
+        session.debugMode = current.debugMode;
+        session.modelName = current.modelName;
+        session.thinkingLevel = current.thinkingLevel;
+        await chatHistoryService.saveSession(session);
+    }
+    catch {
+        // Non-blocking sync failure ignored
+    }
+}

package/dist/services/verificationService.js

@@ -149,8 +149,13 @@ export async function runVerification(workspaceRoot, abortSignal) {
     const MAX_VERIFY_OUTPUT = 50_000; // 50KB cap on verification output
     debugLog(`Running project-level verification command: ${command}`);
     try {
+        const cleanEnv = { ...process.env };
+        delete cleanEnv.NEXT_DISABLE_ESLINT;
+        delete cleanEnv.TSC_COMPILE_ON_ERROR;
+        delete cleanEnv.ESLINT_NO_DEV_ERRORS;
         const { stdout, stderr } = await execAsync(command, {
             cwd: workspaceRoot,
+            env: cleanEnv,
             timeout: 120_000, // 120s (2 mins) - builds can take a while (e.g., Next.js, Gradle)
             maxBuffer: 1024 * 1024, // 1 MB buffer
             signal: abortSignal,
@@ -235,6 +240,7 @@ ${result.errors.join('\n')}
 Please fix these errors using the modify_file tool.`;
 }
 import { auditFilePerformance, formatAuditForModel, formatAuditForTerminal, isAuditableFile, } from '../utils/performanceAuditor.js';
+import { detectAntiCheatingViolations } from '../utils/antiCheatingGuard.js';
 export async function verifyChangedFiles(workspaceRoot, filePaths, abortSignal) {
     if (process.env.MMCLI_SKIP_VERIFICATION === 'true' || process.env.SKIP_VERIFICATION === '1') {
         return { errors: null, warnings: null };
@@ -267,10 +273,26 @@ export async function verifyChangedFiles(workspaceRoot, filePaths, abortSignal)
         if (buildResult.aborted) {
             return '[Verification Aborted]';
         }
-        const buildErrorMsg = `[Build Error: ${buildResult.command}]\n${buildResult.errors.join('\n').substring(0, 5000)}`;
+        const buildErrorMsg = `[Build Error: ${buildResult.command}]\n${buildResult.errors.join('\n').substring(0, 5000)}\n\nCRITICAL DIRECTIVE: Do NOT modify configuration files (such as next.config.*, tsconfig.json, or package.json) to disable, ignore, or bypass these errors (e.g. ignoreBuildErrors, ignoreDuringBuilds). You MUST fix these errors directly in the source code.`;
         errors.push(buildErrorMsg);
     }
-    // 2. Performance Audit
+    // 2. Anti-Cheating Invariant Scan: Ensure no modified files introduced bypass flags
+    for (const file of filePaths) {
+        if (abortSignal?.aborted)
+            return '[Verification Aborted]';
+        try {
+            const absolutePath = path.resolve(workspaceRoot, file);
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            const antiCheatViolation = detectAntiCheatingViolations(file, content);
+            if (antiCheatViolation) {
+                errors.push(`[Verification Rejected - Anti-Cheating Violation in "${file}"]\n${antiCheatViolation}`);
+            }
+        }
+        catch {
+            // File might have been deleted or inaccessible
+        }
+    }
+    // 3. Performance Audit
     // We run this even if the build failed, so the model gets all feedback at once
     for (const file of filePaths) {
         if (abortSignal?.aborted)

package/dist/utils/antiCheatingGuard.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Determines whether a given file path represents a critical project configuration
+ * file or root manifest that should never be deleted or renamed by the agent.
+ *
+ * @param filePath - Relative or absolute path to check
+ * @returns True if the file is a protected critical config file
+ */
+export declare function isCriticalConfigFile(filePath: string): boolean;
+/**
+ * Evaluates whether a proposed file modification or write introduces anti-cheating violations
+ * by attempting to silence, ignore, or bypass build, compiler, type, or lint errors.
+ *
+ * This function is strictly diff-aware: if the existing file already had an error-ignoring flag,
+ * modifying unrelated sections of the file will not trigger a false positive.
+ *
+ * @param filePath - Path to the file being created or modified
+ * @param newContent - The proposed new content of the file
+ * @param existingContent - The previous content of the file (if it already existed on disk)
+ * @returns An error message string if an anti-cheating violation is detected, or null if clean.
+ */
+export declare function detectAntiCheatingViolations(filePath: string, newContent: string, existingContent?: string): string | null;