ft-scout 9.0.7 → 9.0.9

package/bin/src/engine/agentEngine.js

@@ -9,7 +9,7 @@ import { saveAgentSession, getRecentSessionsSummary } from '../utils/session.js'
 import { safeNote, renderMarkdown } from '../utils/markdown.js';
 import { openai, callOpenAIWithRetry, isQuotaExceededError, sanitizeMessage, sanitizeMessages } from './llm.js';
 import { checkFileSyntax, verifyAndSelfHealFiles, executeSmartCommand, extractErrorDiagnostics } from './verifier.js';
-import { speakText, listenSpeechToText } from './voiceEngine.js';
+import { speakText, listenSpeechToText, cleanTextForSpeech } from './voiceEngine.js';
 import { TaskStateManager } from './agentState.js';
 import { SemanticBrowserController } from './browser/index.js';
 import { ActionVerifier } from './actionVerifier.js';
@@ -20,6 +20,7 @@ import { SystemComputerController, MockComputerController } from './computer/ind
 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: {
@@ -292,11 +293,14 @@ export const AGENT_TOOLS = [
     },
     {
         name: 'task_completed',
-        description: 'Signal that the user goal has been fully completed with a final teardown summary.',
+        description: 'Signal that the user goal has been fully completed with the full answer, results, and summary.',
         parameters: {
             type: 'object',
             properties: {
-                summary: { type: 'string', description: 'Comprehensive teardown report of completed changes' },
+                summary: {
+                    type: 'string',
+                    description: 'The complete answer, findings, and results delivered directly to the user. For lookups or questions, this MUST include all retrieved details, accounts, URLs, or data.',
+                },
             },
             required: ['summary'],
         },
@@ -374,10 +378,13 @@ export class AgentExecutionLoop {
     cancelReason;
     executionIntent;
     userTier;
+    currentGoal = '';
+    isAudioMode = false;
     constructor(options) {
         this.cwd = process.cwd();
         this.autoApprove = Boolean(options?.autoApprove);
         this.mockMode = Boolean(options?.mockMode);
+        this.isAudioMode = Boolean(options?.isAudioMode);
         this.userTier = (options?.tier || loadAuthConfig().currentTier || 'free').toLowerCase();
         // Free tier is bounded to basic direct actions (max 5 steps). Full autonomous multi-step loops require Pro/Enterprise.
         const isPaid = this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
@@ -582,6 +589,10 @@ 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` : '';
+        const recentSessionsMemory = getRecentSessionsSummary(3);
+        const sessionHistorySection = recentSessionsMemory ? `\n${recentSessionsMemory}\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 +600,8 @@ Host OS Platform: "${process.platform}"
 Current Date & Time: "${new Date().toISOString()}" (Current Year: ${new Date().getFullYear()})
 ${tierDirective}
 ${intentInfo}
+${mcpCapabilitiesSection}
+${sessionHistorySection}
 Workspace Overview (first 100 files):
 ${filesList.join('\n')}
 
@@ -615,10 +628,18 @@ 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 & 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!
+9. CRITICAL TERMINATION, RESULTS DELIVERY & CONVERSATIONAL VOICE RULE:
+   - For ANY lookup, question, status check, external data retrieval, or inquiry (e.g. "Lookup up my github account", "What is X", "Check my PRs"):
+     Your 'summary' argument in task_completed (or your direct response) MUST contain the COMPLETE, ACCURATE, AND DETAILED ANSWER with all specific data found (usernames, repository names, statistics, URLs, findings, or explanations).
+     NEVER output a vacuous meta-summary like "Task completed" or "Looked up account" without providing the actual information the user asked for!
+   - For coding/modification tasks: Detail what was changed, created, and tested.
+   - 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. "Here are your GitHub account details: your username is ..."). 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!
+12. STRICT ACTIVE GOAL ISOLATION & ACCURACY:
+   - You must strictly execute ONLY the current active goal provided in the user prompt.
+   - Historical workspace sessions are provided for background context ONLY. NEVER re-run, repeat, or resume past session tasks unless the user explicitly requests it in the current prompt.
+   - For lookups, questions, status checks, or external service queries (e.g. GitHub account, MCP tools, web): deliver the concrete results directly and do NOT attempt to edit or rewrite unrelated workspace files.
 
 When returning tool calls, use standard OpenAI function calling format or JSON tool call payload format:
 \`\`\`json
@@ -631,6 +652,8 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
     }
     async executeGoal(userGoal) {
         this.resetContext();
+        this.currentGoal = userGoal;
+        this.taskStateManager.createTaskState(userGoal);
         this.executionIntent = inferExecutionIntent(userGoal);
         this.taskStateManager.setObjective(userGoal);
         if (this.computerController.setExpectedApplication && this.executionIntent.requiredApplications.length > 0) {
@@ -638,7 +661,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);
@@ -651,19 +676,14 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
             };
         }
         this.historyMessages.push({ role: 'system', content: this.systemPrompt() });
-        // Load persistent session history memory (minimum 3 sessions Context)
-        const recentSessionsMemory = getRecentSessionsSummary(3);
-        if (recentSessionsMemory) {
-            this.historyMessages.push({
-                role: 'user',
-                content: recentSessionsMemory,
-            });
-        }
-        // Robust Target File Discovery: Only run file discovery if the goal is NOT a simple desktop application launch/action
+        // Robust Target File Discovery: Only run file discovery if the goal has explicit code editing/modification intent
         const simpleAppCheck = checkSimpleAppAction(userGoal);
+        const lowerGoal = userGoal.toLowerCase().trim();
+        const hasCodeEditIntent = /\b(edit|modify|fix|update|change|refactor|write|create|implement|patch|delete|remove|add\s+code|add\s+function|debug)\b/i.test(lowerGoal) &&
+            !/\b(lookup|look\s*up|who|what|why|where|how|explain|describe|tell|status|check|github|mcp)\b/i.test(lowerGoal);
         const filesList = getDirectoryFiles(this.cwd);
         const matchedFiles = [];
-        if (!simpleAppCheck.isSimple) {
+        if (hasCodeEditIntent && !simpleAppCheck.isSimple) {
             const isIgnoredFile = (filePath) => {
                 const norm = filePath.replace(/\\/g, '/').toLowerCase();
                 const ext = path.extname(norm);
@@ -701,7 +721,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                     }
                 }
             }
-            // Keyword fallback if no direct path matched
+            // Keyword fallback only if explicit path wasn't matched and code edit intent exists
             if (matchedFiles.length === 0) {
                 const stopWords = new Set([
                     'the', 'a', 'an', 'in', 'is', 'for', 'to', 'of', 'and', 'or', 'on', 'at', 'by', 'from',
@@ -747,7 +767,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                         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.`,
+                            content: `[Reference Workspace Context - Pre-loaded target file "${file}" (${lines.length} lines)]:\n\`\`\`\n${previewSnippet}\n\`\`\`\n(Note: "${file}" is pre-loaded above for your reference. Use this context if relevant to completing the user goal.)`,
                         });
                     }
                     catch {
@@ -759,7 +779,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
         if (userGoal && userGoal.trim()) {
             this.historyMessages.push({
                 role: 'user',
-                content: userGoal,
+                content: `USER GOAL: "${userGoal.trim()}"\n\nPlease execute the necessary steps and tools to fulfill this exact goal now.`,
             });
         }
         const estTotalSecs = Math.round(this.maxSteps * 12);
@@ -791,12 +811,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,
@@ -807,7 +841,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',
@@ -816,7 +850,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) => {
@@ -844,6 +878,12 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 const textContent = msg.content || '';
                 if (textContent.trim()) {
                     safeNote(renderMarkdown(textContent), `Scout Thought (Step ${step})`);
+                    if (this.isAudioMode) {
+                        const speechText = cleanTextForSpeech(textContent);
+                        if (speechText) {
+                            speakText(speechText.length > 200 ? speechText.slice(0, 200) + '...' : speechText, { async: true });
+                        }
+                    }
                 }
                 // Check native tool calls
                 if (msg.tool_calls && msg.tool_calls.length > 0) {
@@ -856,6 +896,21 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                                 args = JSON.parse(tc.function.arguments || '{}');
                             }
                             catch { }
+                            if (this.isAudioMode && fnName !== 'task_completed') {
+                                let actionPhrase = '';
+                                if (fnName === 'run_command')
+                                    actionPhrase = `Running command ${args.command ? args.command.slice(0, 40) : ''}`;
+                                else if (fnName === 'read_file')
+                                    actionPhrase = `Reading ${path.basename(args.filePath || '')}`;
+                                else if (fnName === 'write_file')
+                                    actionPhrase = `Creating ${path.basename(args.filePath || '')}`;
+                                else if (fnName === 'edit_file')
+                                    actionPhrase = `Editing ${path.basename(args.filePath || '')}`;
+                                else if (fnName.startsWith('mcp_') || fnName.includes('github'))
+                                    actionPhrase = `Querying ${fnName}`;
+                                if (actionPhrase)
+                                    speakText(actionPhrase, { async: true });
+                            }
                             const toolResult = await this.dispatchToolCall(fnName, args);
                             this.historyMessages.push({
                                 role: 'user',
@@ -976,8 +1031,13 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                         lowerText.includes('file created') ||
                         lowerText.includes('implementation complete') ||
                         lowerText.includes('work is complete');
-                    // If explicit completion phrase found, OR files have already been modified and assistant returned a final summary without calling tools
-                    if (isExplicitCompletion || (this.modifiedFiles.size > 0 && !lowerText.includes('?') && textContent.length > 50)) {
+                    const isInformationalGoal = /^(?:lookup|look\s*up|check|find|who|what|why|where|how|tell|show|explain|display|list|search|query|status|info|get|fetch|describe)\b/i.test(userGoal.trim()) ||
+                        !/\b(create|make|write|edit|modify|fix|update|refactor|build|delete|remove|patch|implement)\b/i.test(userGoal.trim());
+                    const isAnsweringInformational = isInformationalGoal && textContent.trim().length > 20 && !lowerText.includes('error occurred') && !lowerText.includes('cannot complete');
+                    const isSummaryAfterModifications = this.modifiedFiles.size > 0 && !lowerText.includes('?') && textContent.trim().length > 30;
+                    const isSummaryAfterToolExecution = this.totalToolCalls > 0 && textContent.trim().length > 30 && !lowerText.includes('calling tool') && !lowerText.includes('next step');
+                    // If explicit completion phrase found, OR informational answer provided, OR files were modified, OR tools were executed and assistant is delivering the summary
+                    if (isExplicitCompletion || isAnsweringInformational || isSummaryAfterModifications || isSummaryAfterToolExecution) {
                         saveAgentSession({
                             goal: userGoal,
                             summary: textContent,
@@ -1423,13 +1483,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,
@@ -1489,12 +1549,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': {
@@ -2127,13 +2187,32 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                         };
                     }
                 }
-                speakText(summaryStr, { async: true });
                 this.taskStateManager.setStatus('completed');
                 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}"` };
+            }
         }
     }
 }