ft-scout 9.0.6 → 9.0.8

package/bin/src/engine/agentEngine.js

@@ -14,12 +14,13 @@ import { TaskStateManager } from './agentState.js';
 import { SemanticBrowserController } from './browser/index.js';
 import { ActionVerifier } from './actionVerifier.js';
 import { ApprovalManager, RiskClassifier } from './safety.js';
-import { TaskPlanner } from './planner.js';
+import { TaskPlanner, checkSimpleAppAction } from './planner.js';
 import { UnifiedToolRegistry } from './toolRegistry.js';
 import { SystemComputerController, MockComputerController } from './computer/index.js';
 import { AgentWorkspace, inferExecutionIntent, resolveDesktopPath } from './workspace/index.js';
 import { AgentRuntime } from './runtime/index.js';
 import { loadAuthConfig, isProOrHigher } from '../utils/auth.js';
+import { getMCPManager } from '../mcp/index.js';
 export { AgentRuntime, AgentWorkspace, inferExecutionIntent, resolveDesktopPath, SystemComputerController, MockComputerController };
 const execAsync = promisify(exec);
 export function robustSnippetReplace(origContent, target, replacement) {
@@ -157,7 +158,7 @@ export const AGENT_TOOLS = [
     },
     {
         name: 'run_command',
-        description: 'Execute a terminal/shell command in the workspace (e.g. npm test, npm run build, git status). WARNING: Do NOT use run_command to create files or folders (e.g. mkdir, touch, echo >)—call write_file directly instead!',
+        description: 'Execute a terminal/shell command in the workspace (e.g. npm test, npm run build, git status). WARNING: Do NOT use run_command to create files or folders (e.g. mkdir, touch, echo >)call write_file directly instead!',
         parameters: {
             type: 'object',
             properties: {
@@ -270,7 +271,7 @@ export const AGENT_TOOLS = [
     },
     {
         name: 'ask_user',
-        description: 'ONLY use for missing API keys or secret credentials. DO NOT use to ask the user what code to write or to re-confirm their prompt—take immediate autonomous tool action instead.',
+        description: 'ONLY use for missing API keys or secret credentials. DO NOT use to ask the user what code to write or to re-confirm their prompttake immediate autonomous tool action instead.',
         parameters: {
             type: 'object',
             properties: {
@@ -374,6 +375,7 @@ export class AgentExecutionLoop {
     cancelReason;
     executionIntent;
     userTier;
+    currentGoal = '';
     constructor(options) {
         this.cwd = process.cwd();
         this.autoApprove = Boolean(options?.autoApprove);
@@ -582,6 +584,8 @@ PLAN TIER & CAPABILITIES: DEVELOPER FREE (BASIC DEVELOPER OPS ONLY)
   4. Reading & exploring: use read_file, list_dir, grep_search to inspect files.
 • Do NOT attempt to use scratchpad, computer, or browser tools. Execute the requested file edit, file creation, or command directly and call task_completed immediately.
 `;
+        const mcpRouting = getMCPManager().routeTools(this.currentGoal);
+        const mcpCapabilitiesSection = mcpRouting.capabilitiesSummary ? `\n${mcpRouting.capabilitiesSummary}\n` : '';
         return `You are Scout Agent, an elite AI Principal Software Engineer & Autonomous Computer-Use Operator (developed by FrontTerrain).
 
 Working Directory: "${this.cwd}"
@@ -589,6 +593,7 @@ Host OS Platform: "${process.platform}"
 Current Date & Time: "${new Date().toISOString()}" (Current Year: ${new Date().getFullYear()})
 ${tierDirective}
 ${intentInfo}
+${mcpCapabilitiesSection}
 Workspace Overview (first 100 files):
 ${filesList.join('\n')}
 
@@ -615,8 +620,10 @@ CORE ARCHITECTURAL PRINCIPLES:
 6. MULTILINGUAL & INTENT COMPREHENSION: Understand user intent in any language (English, Hinglish like "likho", "bnao", "code karo", "fix karo", "samjha do", Hindi, Spanish, etc.).
 7. FOR CODE & REPO TASKS: When the task is a coding, project refactoring, or repository maintenance task, use direct code modification tools (write_file, edit_file, run_command, read_file, grep_search).
 8. RUN & VERIFY COMMANDS: Execute shell commands, tests, builds, and formatters using run_command.
-9. CRITICAL TERMINATION RULE: As soon as you have finished creating/modifying the necessary files, running verification checks, or completing the desktop application workflow, YOU MUST CALL task_completed tool immediately with a clear summary of your work.
+9. CRITICAL TERMINATION & CONVERSATIONAL VOICE RULE: As soon as you have finished creating/modifying the necessary files, running verification checks, or completing the desktop application workflow, YOU MUST CALL task_completed tool immediately.
+   - CONVERSATIONAL CO-PILOT TONE: In your 'summary' parameter for task_completed, speak directly and warmly to the developer like an elite human co-pilot (e.g. "I've launched Chrome for you and it's active on your screen. What should we tackle next?" or "I've created the authentication controller and all unit tests pass with zero regressions!"). Never output dry mechanical robot logs or third-person phrases like "Objective achieved with 1 tool call". Talk directly to the user!
 10. THOUGHT TRANSPARENCY PROTOCOL: In EVERY step before calling any tools or ending a turn, you MUST provide a clear 1-2 sentence explanation in your text response describing your current reasoning, what file/action you are taking, and why you are taking it.
+11. APPLICATION LAUNCH & SIMPLE ACTION TERMINATION: When the user's objective is simply to open, launch, close, or focus an application (e.g. "Open Chrome", "Launch Notepad", "Open Calculator"): Immediately after calling computer_open_app or computer_close_app, your goal is 100% complete! You MUST call task_completed on the very next step with your friendly conversational summary. NEVER explore the repository or call list_dir, read_file, grep_search, or edit_file for app launching tasks!
 
 When returning tool calls, use standard OpenAI function calling format or JSON tool call payload format:
 \`\`\`json
@@ -629,6 +636,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
     }
     async executeGoal(userGoal) {
         this.resetContext();
+        this.currentGoal = userGoal;
         this.executionIntent = inferExecutionIntent(userGoal);
         this.taskStateManager.setObjective(userGoal);
         if (this.computerController.setExpectedApplication && this.executionIntent.requiredApplications.length > 0) {
@@ -636,7 +644,9 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
         }
         const structuredPlan = this.taskPlanner.createPlan(userGoal);
         this.taskStateManager.setPlan(structuredPlan.steps);
-        this.taskStateManager.setAvailableTools(this.toolRegistry.getToolsForTier(this.userTier).map((t) => t.name));
+        const mcpRouted = getMCPManager().routeTools(userGoal);
+        const mcpNames = mcpRouted.tools.map((t) => t.originalName);
+        this.taskStateManager.setAvailableTools([...this.toolRegistry.getToolsForTier(this.userTier).map((t) => t.name), ...mcpNames]);
         if (this.mockMode) {
             for (let i = 1; i <= structuredPlan.steps.length; i++) {
                 this.taskStateManager.startStep(i);
@@ -657,97 +667,100 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 content: recentSessionsMemory,
             });
         }
-        // Robust Target File Discovery: Extract file paths/names directly from userGoal without destroying backslashes
+        // Robust Target File Discovery: Only run file discovery if the goal is NOT a simple desktop application launch/action
+        const simpleAppCheck = checkSimpleAppAction(userGoal);
         const filesList = getDirectoryFiles(this.cwd);
         const matchedFiles = [];
-        const isIgnoredFile = (filePath) => {
-            const norm = filePath.replace(/\\/g, '/').toLowerCase();
-            const ext = path.extname(norm);
-            const ignoredExts = ['.pyc', '.pyo', '.png', '.jpg', '.jpeg', '.gif', '.ico', '.exe', '.bin', '.dll', '.so', '.dylib', '.zip', '.tar', '.gz'];
-            return (norm.includes('__pycache__/') ||
-                norm.includes('.git/') ||
-                norm.includes('node_modules/') ||
-                norm.includes('.ft/') ||
-                ignoredExts.includes(ext));
-        };
-        // Match potential paths
-        const pathMatches = userGoal.match(/(?:[a-zA-Z]:[\\/][^\s"':;,]+|\.?[\\/][^\s"':;,]+\.[a-zA-Z0-9]+|[a-zA-Z0-9_\-./\\]+\.[a-zA-Z0-9]+)/g) || [];
-        for (const rawPath of pathMatches) {
-            const cleanP = rawPath.replace(/^["'()]+|["'()]+$/g, '').trim();
-            if (!cleanP || cleanP.length < 3)
-                continue;
-            const fullP = path.isAbsolute(cleanP) ? cleanP : path.resolve(this.cwd, cleanP);
-            if (fs.existsSync(fullP) && fs.statSync(fullP).isFile()) {
-                const relP = path.relative(this.cwd, fullP).replace(/\\/g, '/');
-                if (!isIgnoredFile(relP) && !matchedFiles.includes(relP))
-                    matchedFiles.push(relP);
+        if (!simpleAppCheck.isSimple) {
+            const isIgnoredFile = (filePath) => {
+                const norm = filePath.replace(/\\/g, '/').toLowerCase();
+                const ext = path.extname(norm);
+                const ignoredExts = ['.pyc', '.pyo', '.png', '.jpg', '.jpeg', '.gif', '.ico', '.exe', '.bin', '.dll', '.so', '.dylib', '.zip', '.tar', '.gz'];
+                return (norm.includes('__pycache__/') ||
+                    norm.includes('.git/') ||
+                    norm.includes('node_modules/') ||
+                    norm.includes('.ft/') ||
+                    ignoredExts.includes(ext));
+            };
+            // Match potential paths
+            const pathMatches = userGoal.match(/(?:[a-zA-Z]:[\\/][^\s"':;,]+|\.?[\\/][^\s"':;,]+\.[a-zA-Z0-9]+|[a-zA-Z0-9_\-./\\]+\.[a-zA-Z0-9]+)/g) || [];
+            for (const rawPath of pathMatches) {
+                const cleanP = rawPath.replace(/^["'()]+|["'()]+$/g, '').trim();
+                if (!cleanP || cleanP.length < 3)
+                    continue;
+                const fullP = path.isAbsolute(cleanP) ? cleanP : path.resolve(this.cwd, cleanP);
+                if (fs.existsSync(fullP) && fs.statSync(fullP).isFile()) {
+                    const relP = path.relative(this.cwd, fullP).replace(/\\/g, '/');
+                    if (!isIgnoredFile(relP) && !matchedFiles.includes(relP))
+                        matchedFiles.push(relP);
+                }
+                else {
+                    // Check if any file in filesList matches or ends with the extracted relative path or filename
+                    const normToken = cleanP.replace(/\\/g, '/').toLowerCase();
+                    const baseName = path.basename(normToken);
+                    for (const f of filesList) {
+                        if (isIgnoredFile(f))
+                            continue;
+                        const normF = f.replace(/\\/g, '/').toLowerCase();
+                        if (normF === normToken || normF.endsWith('/' + normToken) || (baseName.includes('.') && normF.endsWith('/' + baseName))) {
+                            if (!matchedFiles.includes(f))
+                                matchedFiles.push(f);
+                        }
+                    }
+                }
             }
-            else {
-                // Check if any file in filesList matches or ends with the extracted relative path or filename
-                const normToken = cleanP.replace(/\\/g, '/').toLowerCase();
-                const baseName = path.basename(normToken);
+            // Keyword fallback if no direct path matched
+            if (matchedFiles.length === 0) {
+                const stopWords = new Set([
+                    'the', 'a', 'an', 'in', 'is', 'for', 'to', 'of', 'and', 'or', 'on', 'at', 'by', 'from',
+                    'with', 'this', 'that', 'it', 'code', 'file', 'files', 'fix', 'add', 'make', 'create',
+                    'update', 'change', 'modify', 'edit', 'write', 'implement', 'bro', 'please', 'scout',
+                    'agent', 'bug', 'error', 'issue', 'help', 'app', 'project', 'script', 'function',
+                    'folder', 'dir', 'directory', 'testing', 'inside', 'open', 'vs', 'vscode', 'py', 'python',
+                    'new', 'build', 'run', 'test', 'suite'
+                ]);
+                const words = userGoal.split(/[\s,;:\/\\]+/).map((w) => w.replace(/["'(),;:!]/g, '').trim());
+                const keywords = words.filter((w) => w.length >= 3 && !stopWords.has(w.toLowerCase()));
                 for (const f of filesList) {
                     if (isIgnoredFile(f))
                         continue;
+                    if (matchedFiles.length >= 3)
+                        break;
                     const normF = f.replace(/\\/g, '/').toLowerCase();
-                    if (normF === normToken || normF.endsWith('/' + normToken) || (baseName.includes('.') && normF.endsWith('/' + baseName))) {
-                        if (!matchedFiles.includes(f))
-                            matchedFiles.push(f);
+                    const baseName = path.basename(normF, path.extname(normF));
+                    for (const kw of keywords) {
+                        const kwLower = kw.toLowerCase();
+                        if (baseName === kwLower || normF.endsWith('/' + kwLower + path.extname(normF))) {
+                            if (!matchedFiles.includes(f))
+                                matchedFiles.push(f);
+                            break;
+                        }
                     }
                 }
             }
-        }
-        // Keyword fallback if no direct path matched
-        if (matchedFiles.length === 0) {
-            const stopWords = new Set([
-                'the', 'a', 'an', 'in', 'is', 'for', 'to', 'of', 'and', 'or', 'on', 'at', 'by', 'from',
-                'with', 'this', 'that', 'it', 'code', 'file', 'files', 'fix', 'add', 'make', 'create',
-                'update', 'change', 'modify', 'edit', 'write', 'implement', 'bro', 'please', 'scout',
-                'agent', 'bug', 'error', 'issue', 'help', 'app', 'project', 'script', 'function',
-                'folder', 'dir', 'directory', 'testing', 'inside', 'open', 'vs', 'vscode', 'py', 'python',
-                'new', 'build', 'run', 'test', 'suite'
-            ]);
-            const words = userGoal.split(/[\s,;:\/\\]+/).map((w) => w.replace(/["'(),;:!]/g, '').trim());
-            const keywords = words.filter((w) => w.length >= 3 && !stopWords.has(w.toLowerCase()));
-            for (const f of filesList) {
-                if (isIgnoredFile(f))
-                    continue;
-                if (matchedFiles.length >= 3)
-                    break;
-                const normF = f.replace(/\\/g, '/').toLowerCase();
-                const baseName = path.basename(normF, path.extname(normF));
-                for (const kw of keywords) {
-                    const kwLower = kw.toLowerCase();
-                    if (baseName === kwLower || normF.endsWith('/' + kwLower + path.extname(normF))) {
-                        if (!matchedFiles.includes(f))
-                            matchedFiles.push(f);
-                        break;
+            // Safely inject high-confidence existing file previews without prompt-hijacking
+            for (const file of matchedFiles.slice(0, 3)) {
+                const fullP = path.resolve(this.cwd, file);
+                if (fs.existsSync(fullP) && fs.statSync(fullP).isFile()) {
+                    const analyzeSpin = spinner();
+                    analyzeSpin.start(chalk.cyan(` Auto-discovered target file: ${file}. Analyzing...`));
+                    try {
+                        const content = fs.readFileSync(fullP, 'utf-8');
+                        const lines = content.split('\n');
+                        analyzeSpin.stop(chalk.green(` Auto-discovered & analyzed ${file} (${lines.length} lines)`));
+                        const previewSnippet = lines.length <= 250
+                            ? lines.map((l, i) => `${i + 1} | ${l}`).join('\n')
+                            : lines.slice(0, 100).map((l, i) => `${i + 1} | ${l}`).join('\n') + `\n... [truncated, file has ${lines.length} lines. Call read_file to view remaining lines]`;
+                        this.readFilesHistory.add(file);
+                        this.readFilesHistory.add(file.replace(/\\/g, '/').toLowerCase());
+                        this.historyMessages.push({
+                            role: 'user',
+                            content: `[Reference Workspace Context - Pre-loaded target file "${file}" (${lines.length} lines)]:\n\`\`\`\n${previewSnippet}\n\`\`\`\nCRITICAL DIRECTIVE: The target file "${file}" is ALREADY fully pre-loaded into your reference context above. DO NOT call read_file or list_dir for this file again! Immediately begin calling write_file, edit_file, or run_command to satisfy the user goal.`,
+                        });
+                    }
+                    catch {
+                        analyzeSpin.stop(chalk.yellow(`Could not read file ${file}`));
                     }
-                }
-            }
-        }
-        // Safely inject high-confidence existing file previews without prompt-hijacking
-        for (const file of matchedFiles.slice(0, 3)) {
-            const fullP = path.resolve(this.cwd, file);
-            if (fs.existsSync(fullP) && fs.statSync(fullP).isFile()) {
-                const analyzeSpin = spinner();
-                analyzeSpin.start(chalk.cyan(` Auto-discovered target file: ${file}. Analyzing...`));
-                try {
-                    const content = fs.readFileSync(fullP, 'utf-8');
-                    const lines = content.split('\n');
-                    analyzeSpin.stop(chalk.green(` Auto-discovered & analyzed ${file} (${lines.length} lines)`));
-                    const previewSnippet = lines.length <= 250
-                        ? lines.map((l, i) => `${i + 1} | ${l}`).join('\n')
-                        : lines.slice(0, 100).map((l, i) => `${i + 1} | ${l}`).join('\n') + `\n... [truncated, file has ${lines.length} lines. Call read_file to view remaining lines]`;
-                    this.readFilesHistory.add(file);
-                    this.readFilesHistory.add(file.replace(/\\/g, '/').toLowerCase());
-                    this.historyMessages.push({
-                        role: 'user',
-                        content: `[Reference Workspace Context - Pre-loaded target file "${file}" (${lines.length} lines)]:\n\`\`\`\n${previewSnippet}\n\`\`\`\nCRITICAL DIRECTIVE: The target file "${file}" is ALREADY fully pre-loaded into your reference context above. DO NOT call read_file or list_dir for this file again! Immediately begin calling write_file, edit_file, or run_command to satisfy the user goal.`,
-                    });
-                }
-                catch {
-                    analyzeSpin.stop(chalk.yellow(`Could not read file ${file}`));
                 }
             }
         }
@@ -786,12 +799,26 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
             stepSpinner.start(chalk.cyan(`Scout is Working (Step ${step}/${this.maxSteps} • Est. completion: ~${estLeftStr} left)`));
             try {
                 let response;
+                const mcpRouting = getMCPManager().routeTools(userGoal);
+                const mcpToolDefs = mcpRouting.tools.map((mt) => ({
+                    name: mt.originalName,
+                    description: `[MCP: ${mt.serverName}] ${mt.description}`,
+                    parameters: {
+                        type: 'object',
+                        properties: mt.inputSchema.properties || {},
+                        required: mt.inputSchema.required || [],
+                    },
+                    source: 'mcp',
+                    mcpServerId: mt.serverId,
+                    mcpServerName: mt.serverName,
+                }));
+                const activeLoopTools = [...this.toolRegistry.getToolsForTier(this.userTier), ...mcpToolDefs];
                 try {
                     response = await callOpenAIWithRetry(async (model) => {
                         return await openai.chat.completions.create({
                             model,
                             messages: sanitizeMessages(this.historyMessages),
-                            tools: this.toolRegistry.getToolsForTier(this.userTier).map((t) => ({ type: 'function', function: t })),
+                            tools: activeLoopTools.map((t) => ({ type: 'function', function: t })),
                             tool_choice: 'auto',
                             temperature: 0.1,
                             presence_penalty: 0.1,
@@ -802,7 +829,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 catch (err) {
                     const errStr = String(err?.message || err?.error || err || '').toLowerCase();
                     if (errStr.includes('tool') || errStr.includes('400') || errStr.includes('not supported') || errStr.includes('reasoning')) {
-                        // Model doesn't support native function calling — inject tool-call formatting hint
+                        // Model doesn't support native function calling  inject tool-call formatting hint
                         // so extractJsonToolCall can parse the response as a structured tool invocation
                         const toolHintMsg = {
                             role: 'user',
@@ -811,7 +838,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
 { "tool": "tool_name", "args": { ... } }
 \`\`\`
 Available tools: read_file, write_file, edit_file, run_command, list_dir, grep_search, glob_search, tree_view, file_info, multi_edit_file, fetch_url, git_diff, ask_user, speak_text, task_completed.
-You MUST output exactly ONE JSON code block per tool call. Do NOT describe what you would do in plain text—output the JSON tool call directly!`,
+You MUST output exactly ONE JSON code block per tool call. Do NOT describe what you would do in plain textoutput the JSON tool call directly!`,
                         };
                         const fallbackMessages = [...this.historyMessages, toolHintMsg];
                         response = await callOpenAIWithRetry(async (model) => {
@@ -858,6 +885,29 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                                 content: `Tool Execution Result (${fnName}):\n${toolResult.result}`,
                             });
                             this.handleToolConsecutiveTracking(fnName, args, step);
+                            // Automatic immediate completion for simple app actions (open/close/switch window)
+                            if (simpleAppCheck.isSimple && (fnName === 'computer_open_app' || fnName === 'computer_close_app' || fnName === 'computer_switch_window')) {
+                                let callSucceeded = false;
+                                try {
+                                    const parsed = JSON.parse(toolResult.result);
+                                    callSucceeded = parsed.success !== false;
+                                }
+                                catch {
+                                    callSucceeded = !toolResult.result.toLowerCase().includes('failed') && !toolResult.result.toLowerCase().includes('error');
+                                }
+                                if (callSucceeded) {
+                                    const appName = simpleAppCheck.appName || 'application';
+                                    const actionVerb = simpleAppCheck.action === 'close' ? 'closed' : (simpleAppCheck.action === 'switch' ? 'focused' : 'launched');
+                                    finalSummary = `I've ${actionVerb} ${appName} for you. It's ready on your screen!`;
+                                    safeNote(chalk.green(` ${finalSummary}`), 'Task Completed');
+                                    saveAgentSession({
+                                        goal: userGoal,
+                                        summary: finalSummary,
+                                        modifiedFiles: [],
+                                    });
+                                    return { success: true, summary: finalSummary };
+                                }
+                            }
                             if (fnName === 'task_completed') {
                                 finalSummary = args.summary || toolResult.result;
                                 if (this.modifiedFiles.size > 0) {
@@ -891,6 +941,29 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                         content: `Tool Execution Result (${parsedJsonTool.tool}):\n${toolResult.result}`,
                     });
                     this.handleToolConsecutiveTracking(parsedJsonTool.tool, parsedJsonTool.args, step);
+                    // Automatic immediate completion for simple app actions (open/close/switch window)
+                    if (simpleAppCheck.isSimple && (parsedJsonTool.tool === 'computer_open_app' || parsedJsonTool.tool === 'computer_close_app' || parsedJsonTool.tool === 'computer_switch_window')) {
+                        let callSucceeded = false;
+                        try {
+                            const parsed = JSON.parse(toolResult.result);
+                            callSucceeded = parsed.success !== false;
+                        }
+                        catch {
+                            callSucceeded = !toolResult.result.toLowerCase().includes('failed') && !toolResult.result.toLowerCase().includes('error');
+                        }
+                        if (callSucceeded) {
+                            const appName = simpleAppCheck.appName || 'application';
+                            const actionVerb = simpleAppCheck.action === 'close' ? 'closed' : (simpleAppCheck.action === 'switch' ? 'focused' : 'launched');
+                            finalSummary = `I've ${actionVerb} ${appName} for you. It's ready on your screen!`;
+                            safeNote(chalk.green(` ${finalSummary}`), 'Task Completed');
+                            saveAgentSession({
+                                goal: userGoal,
+                                summary: finalSummary,
+                                modifiedFiles: [],
+                            });
+                            return { success: true, summary: finalSummary };
+                        }
+                    }
                     if (parsedJsonTool.tool === 'task_completed') {
                         finalSummary = parsedJsonTool.args?.summary || toolResult.result;
                         saveAgentSession({
@@ -1178,6 +1251,22 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             }
         }
         // Validate against execution intent (USER INTENT > TOOL CONVENIENCE)
+        const simpleCheckInDispatch = checkSimpleAppAction(this.taskStateManager.getState()?.objective || '');
+        if (simpleCheckInDispatch.isSimple) {
+            if (['list_dir', 'read_file', 'grep_search', 'glob_search', 'file_info', 'tree_view', 'write_file', 'edit_file', 'multi_edit_file'].includes(name)) {
+                const blockedExplorationMsg = `[UNNECESSARY WORKSPACE EXPLORATION BLOCKED]: The user only requested to ${simpleCheckInDispatch.action || 'launch'} ${simpleCheckInDispatch.appName || 'the application'}. Reading repository code or listing files (${name}) is forbidden for this task. You must call task_completed immediately.`;
+                this.taskStateManager.addObservation(name, blockedExplorationMsg, false);
+                return {
+                    result: JSON.stringify({
+                        success: false,
+                        action: name,
+                        error: 'UnnecessaryWorkspaceExplorationBlocked',
+                        message: blockedExplorationMsg,
+                        directive: "Call 'task_completed' NOW with your completion summary."
+                    }, null, 2)
+                };
+            }
+        }
         if (this.executionIntent && !this.executionIntent.allowAlternativeTools) {
             if (this.executionIntent.requiredInteraction === 'computer') {
                 if (['write_file', 'edit_file', 'multi_edit_file'].includes(name)) {
@@ -1356,13 +1445,13 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 checkSpin.start(chalk.cyan(` Checking for error: edited ${targetPath}...`));
                 const syntaxCheck = await checkFileSyntax(targetPath, this.cwd);
                 if (!syntaxCheck.valid) {
-                    checkSpin.stop(chalk.red(`️ Checking for error: edited ${targetPath} — Compiler/Syntax Error!`));
+                    checkSpin.stop(chalk.red(`️ Checking for error: edited ${targetPath}  Compiler/Syntax Error!`));
                     this.taskStateManager.recordError(`Syntax error in "${targetPath}": ${syntaxCheck.errors.join('; ')}`, 'write_file');
                     return {
                         result: `Successfully wrote ${content.length} characters (${numberOfLinesChanged} lines changed) to "${targetPath}".\n\n️ AUTOMATED SYNTAX / COMPILER ERROR DETECTED IN "${targetPath}":\n${syntaxCheck.errors.join('\n')}\n\nPLEASE IMMEDIATELY FIX THIS SYNTAX ERROR IN YOUR NEXT TOOL CALL.`
                     };
                 }
-                checkSpin.stop(chalk.green(` Checking for error: edited ${targetPath} — Syntax & build clean.`));
+                checkSpin.stop(chalk.green(` Checking for error: edited ${targetPath}  Syntax & build clean.`));
                 this.taskStateManager.recordArtifact({
                     filename: path.basename(targetPath),
                     path: targetPath,
@@ -1422,12 +1511,12 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 checkSpin.start(chalk.cyan(` Checking for error: edited ${targetPath}...`));
                 const syntaxCheck = await checkFileSyntax(targetPath, this.cwd);
                 if (!syntaxCheck.valid) {
-                    checkSpin.stop(chalk.red(`️ Checking for error: edited ${targetPath} — Compiler/Syntax Error!`));
+                    checkSpin.stop(chalk.red(`️ Checking for error: edited ${targetPath}  Compiler/Syntax Error!`));
                     return {
                         result: `Successfully replaced snippet (${numberOfLinesChanged} lines changed) in "${targetPath}".\n\n️ AUTOMATED SYNTAX / COMPILER ERROR DETECTED IN "${targetPath}":\n${syntaxCheck.errors.join('\n')}\n\nPLEASE IMMEDIATELY FIX THIS SYNTAX ERROR IN YOUR NEXT TOOL CALL.`
                     };
                 }
-                checkSpin.stop(chalk.green(` Checking for error: edited ${targetPath} — Syntax & build clean.`));
+                checkSpin.stop(chalk.green(` Checking for error: edited ${targetPath}  Syntax & build clean.`));
                 return { result: `Successfully replaced target snippet (${numberOfLinesChanged} lines changed) in "${targetPath}". Rationale: ${reason}. Syntax check passed cleanly.` };
             }
             case 'run_command': {
@@ -1983,6 +2072,9 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 const res = await this.computerController.openApplication(appName, args.args);
                 this.taskStateManager.setActiveApplication(appName);
                 this.taskStateManager.addObservation('computer_open_app', res.output, res.success);
+                const currentObj = this.taskStateManager.getState()?.objective || '';
+                const simpleCheck = checkSimpleAppAction(currentObj);
+                const isOnlyOpening = simpleCheck.isSimple && simpleCheck.action !== 'close';
                 const structuredRes = {
                     success: res.success,
                     action: 'open_app',
@@ -1991,6 +2083,9 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                     recoverable: res.recoverable ?? true,
                     activeWindow: res.activeWindow || appName,
                     expectedWindow: res.expectedWindow || appName,
+                    ...(isOnlyOpening && res.success ? {
+                        directive: "CRITICAL: The requested application is now opened. Your objective is 100% satisfied. You MUST call 'task_completed' immediately on your next turn. DO NOT call list_dir, read_file, or explore the repository."
+                    } : {}),
                 };
                 return { result: JSON.stringify(structuredRes, null, 2) };
             }
@@ -1998,6 +2093,12 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 const appName = String(args.appName || args.app || '');
                 const res = await this.computerController.closeApplication(appName);
                 this.taskStateManager.addObservation('computer_close_app', res.output, res.success);
+                const currentObj = this.taskStateManager.getState()?.objective || '';
+                const simpleCheck = checkSimpleAppAction(currentObj);
+                const isOnlyClosing = simpleCheck.isSimple && simpleCheck.action === 'close';
+                if (isOnlyClosing && res.success) {
+                    return { result: `${res.output}\nCRITICAL: Application closed. Objective complete. Call task_completed now.` };
+                }
                 return { result: res.output };
             }
             case 'computer_switch_window': {
@@ -2053,8 +2154,28 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 this.taskStateManager.completeStep(this.currentStep, summaryStr);
                 return { result: summaryStr };
             }
-            default:
+            default: {
+                // Check if this tool is provided by a connected MCP server
+                const mcpManager = getMCPManager();
+                const mcpTarget = mcpManager.findTool(name);
+                if (mcpTarget) {
+                    const mcpRes = await mcpManager.executeTool(name, args);
+                    const isSuccess = mcpRes.status === 'success';
+                    const outputStr = typeof mcpRes.result === 'string'
+                        ? mcpRes.result
+                        : (mcpRes.result?.text ? String(mcpRes.result.text) : JSON.stringify(mcpRes.result ?? { status: mcpRes.status, error: mcpRes.error }));
+                    this.taskStateManager.addObservation(name, mcpRes.outputSummary || outputStr, isSuccess);
+                    // Check if MCP result generated or referenced local files/artifacts
+                    if (isSuccess && typeof mcpRes.result === 'object' && mcpRes.result !== null) {
+                        const possiblePath = mcpRes.result.path || mcpRes.result.filePath || mcpRes.result.file || args.destPath || args.path || args.outputPath;
+                        if (typeof possiblePath === 'string' && fs.existsSync(path.resolve(this.cwd, possiblePath))) {
+                            this.modifiedFiles.add(path.relative(this.cwd, path.resolve(this.cwd, possiblePath)).replace(/\\/g, '/'));
+                        }
+                    }
+                    return { result: outputStr };
+                }
                 return { result: `Unknown tool call name: "${name}"` };
+            }
         }
     }
 }