ft-scout 9.0.2 → 9.0.4

package/bin/src/engine/runtime/agentRuntime.js

@@ -0,0 +1,829 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { spinner, confirm, isCancel, text } from '@clack/prompts';
+import { safeNote, renderMarkdown } from '../../utils/markdown.js';
+import { openai, callOpenAIWithRetry, sanitizeMessage, sanitizeMessages } from '../llm.js';
+import { checkFileSyntax, verifyAndSelfHealFiles } from '../verifier.js';
+import { speakText } from '../voiceEngine.js';
+import { getDirectoryFiles, recordHistoryAction } from '../../utils/config.js';
+import { saveAgentSession, getRecentSessionsSummary } from '../../utils/session.js';
+import { AgentWorkspace, resolveDesktopPath } from '../workspace/agentWorkspace.js';
+import { SystemComputerController } from '../computer/computerController.js';
+import { MockComputerController } from '../computer/mockComputer.js';
+import { SemanticBrowserController } from '../browser/index.js';
+import { ActionVerifier } from '../actionVerifier.js';
+import { ApprovalManager, RiskClassifier } from '../safety.js';
+import { TaskPlanner } from '../planner.js';
+import { UnifiedToolRegistry } from '../toolRegistry.js';
+import { robustSnippetReplace, buildDirectoryTree } from '../agentEngine.js';
+export class AgentRuntime {
+    cwd;
+    autoApprove;
+    maxSteps;
+    mockMode;
+    language;
+    abortController = new AbortController();
+    isCancelled = false;
+    cancelReason;
+    workspace;
+    computerController;
+    browserController;
+    actionVerifier;
+    approvalManager;
+    planner;
+    toolRegistry;
+    historyMessages = [];
+    modifiedFiles = new Set();
+    backups = [];
+    totalToolCalls = 0;
+    currentStep = 0;
+    startTime = Date.now();
+    readFilesHistory = new Set();
+    toolCallHistory = [];
+    constructor(options) {
+        this.cwd = options?.workspaceDir || process.cwd();
+        this.autoApprove = Boolean(options?.autoApprove);
+        this.maxSteps = options?.maxSteps || 30;
+        this.mockMode = Boolean(options?.mockMode);
+        this.language = options?.language;
+        this.workspace = new AgentWorkspace(options?.taskId, '', this.cwd);
+        this.computerController = options?.computerController || (this.mockMode ? new MockComputerController() : new SystemComputerController(this.cwd));
+        this.browserController = options?.browserController || new SemanticBrowserController(this.cwd);
+        this.actionVerifier = new ActionVerifier(this.cwd);
+        this.approvalManager = new ApprovalManager(this.autoApprove);
+        this.planner = new TaskPlanner();
+        this.toolRegistry = new UnifiedToolRegistry();
+    }
+    getWorkspace() {
+        return this.workspace;
+    }
+    getComputerController() {
+        return this.computerController;
+    }
+    getBrowserController() {
+        return this.browserController;
+    }
+    getActionVerifier() {
+        return this.actionVerifier;
+    }
+    getApprovalManager() {
+        return this.approvalManager;
+    }
+    getPlanner() {
+        return this.planner;
+    }
+    getToolRegistry() {
+        return this.toolRegistry;
+    }
+    cancel(reason = 'User cancelled task') {
+        this.isCancelled = true;
+        this.cancelReason = reason;
+        this.abortController.abort();
+        this.workspace.setStatus('cancelled');
+        this.workspace.recordError(`Task execution cancelled: ${reason}`, 'runtime', undefined, false);
+    }
+    isTaskCancelled() {
+        return this.isCancelled;
+    }
+    getModifiedFiles() {
+        return Array.from(this.modifiedFiles);
+    }
+    getBackups() {
+        return this.backups;
+    }
+    getStats() {
+        return {
+            totalSteps: this.currentStep,
+            totalToolCalls: this.totalToolCalls,
+            modifiedFilesCount: this.modifiedFiles.size,
+            elapsedMs: Date.now() - this.startTime,
+            taskId: this.workspace.getData().taskId,
+            status: this.workspace.getData().status,
+        };
+    }
+    resetContext() {
+        this.historyMessages = [];
+        this.modifiedFiles.clear();
+        this.readFilesHistory.clear();
+        this.backups = [];
+        this.startTime = Date.now();
+        this.totalToolCalls = 0;
+        this.currentStep = 0;
+        this.toolCallHistory = [];
+        this.isCancelled = false;
+        this.cancelReason = undefined;
+        this.abortController = new AbortController();
+    }
+    buildSystemPrompt() {
+        const filesList = getDirectoryFiles(this.cwd).slice(0, 100);
+        const workspaceState = this.workspace.compactWorkspaceForPrompt();
+        return `You are Scout Agent, an elite AI Principal Software Engineer & Autonomous Computer-Use Operator (developed by FrontTerrain).
+You do not merely explain or output chat answers—you autonomously operate the computer, applications, browser, and workspace tools to fulfill the user's objective end-to-end.
+
+Execution Cycle:
+UNDERSTAND ➔ PLAN ➔ ACT ➔ OBSERVE ➔ UPDATE WORKSPACE ➔ REASON ABOUT STATE ➔ ACT AGAIN ➔ VERIFY ➔ COMPLETE
+
+Working Directory: "${this.cwd}"
+Host OS Platform: "${process.platform}"
+Current Year: ${new Date().getFullYear()}
+
+${workspaceState}
+
+Available Workspace Files (sample):
+${filesList.join('\n')}
+
+CORE ARCHITECTURAL PRINCIPLES:
+1. USER INTENT > TOOL CONVENIENCE (MANDATORY):
+   The easiest tool is NOT necessarily the correct tool. Scout optimizes for completing the user's ACTUAL REQUESTED WORKFLOW, not merely producing something that looks like the final artifact.
+   - Distinguish OUTCOME requirements (e.g. "Create a file containing X") from EXECUTION requirements (e.g. "Open Notepad, type X, save it as Y on Desktop").
+   - When the user explicitly specifies an application (e.g. Notepad, Excel, Chrome, VS Code) or computer interaction method, computer interaction tools (computer_open_app, computer_screenshot, computer_type, computer_hotkey, computer_switch_window, computer_click) MUST be used.
+   - NEVER silently substitute direct filesystem API calls (write_file) when computer/application interaction is required, unless the user explicitly permits alternative tools ("using any method you prefer").
+   - NEVER assume the repository root is the user's Desktop! If the user requests saving to Desktop, the file MUST be saved to the actual Desktop through the requested workflow.
+
+2. COMPUTER ACTION FAILURE RECOVERY:
+   When a computer action fails or encounters a problem:
+   DO NOT immediately switch to an unrelated tool (like write_file).
+   Instead, follow the bounded computer recovery loop:
+   ACTION FAILED ➔ OBSERVE SCREEN (computer_screenshot / computer_inspect_ui) ➔ UNDERSTAND FAILURE (check if application is active/focused) ➔ RETRY / ALTERNATIVE COMPUTER ACTION (switch window, click text area, send hotkey/keystrokes) ➔ OBSERVE ➔ CONTINUE.
+   Only after repeated bounded computer recovery attempts fail should you report the failure to the user.
+
+3. ACTIVE APPLICATION TRACKING:
+   Before sending keyboard or mouse input (computer_type, computer_click, computer_hotkey), ensure that the expected application (e.g. Notepad) is the active foreground window. If not, use computer_switch_window or computer_open_app to focus it first.
+
+Tool Selection Guidelines:
+- Level 1 - COMPUTER & DESKTOP APPS: When interacting with desktop GUI applications (VS Code, Notepad, File Explorer, Terminal), observing the screen, clicking desktop UI coordinates, or switching windows, use: computer_screenshot, computer_click, computer_type, computer_hotkey, computer_open_app, computer_switch_window, computer_inspect_ui.
+- Level 2 - BROWSER AUTOMATION: For web browsing, scraping, filling web forms, or downloading online files, use browser tools: browser_navigate, browser_click, browser_type, browser_download, browser_content.
+- Level 3 - DIRECT TOOLS: For file editing, creating, reading, searching, or shell commands in coding/repository tasks (when computer GUI is NOT required), use: write_file, edit_file, read_file, run_command, glob_search, grep_search.
+
+Action Rules:
+- Structured Tool Invocations: Return exactly one tool call per turn via native function calling or \`\`\`json { "tool": "tool_name", "args": { ... } } \`\`\`.
+- Screen Observations: Request \`computer_screenshot\` when you need to inspect desktop application UI or verify visible screen state.
+- Verification Mandate: Never assume an action succeeded. After creating files, verify them. After opening an app, verify its window appeared.
+- Termination: Call \`task_completed\` as soon as the objective has been achieved with a full summary.
+`.trim();
+    }
+    async executeGoal(userGoal) {
+        this.resetContext();
+        this.workspace.setObjective(userGoal);
+        const expectedApp = this.workspace.getData().environment.expectedApplication;
+        if (expectedApp && this.computerController.setExpectedApplication) {
+            this.computerController.setExpectedApplication(expectedApp);
+        }
+        const structuredPlan = this.planner.createPlan(userGoal);
+        this.workspace.setPlan(structuredPlan.steps);
+        const taskId = this.workspace.getData().taskId;
+        if (this.mockMode) {
+            for (let i = 1; i <= structuredPlan.steps.length; i++) {
+                this.workspace.startStep(i);
+                this.workspace.completeStep(i, `Completed step ${i} in mock mode`);
+            }
+            this.workspace.setStatus('completed');
+            return {
+                success: true,
+                summary: `Mock execution completed successfully for goal: "${userGoal}".`,
+                taskId,
+                stepsTaken: structuredPlan.steps.length,
+                modifiedFiles: [],
+                status: 'completed',
+            };
+        }
+        this.historyMessages.push({ role: 'system', content: this.buildSystemPrompt() });
+        // Memory persistence
+        const recentMemory = getRecentSessionsSummary(3);
+        if (recentMemory) {
+            this.historyMessages.push({ role: 'user', content: recentMemory });
+        }
+        // Add user goal
+        this.historyMessages.push({ role: 'user', content: userGoal });
+        let step = 0;
+        let finalSummary = '';
+        while (step < this.maxSteps) {
+            if (this.isCancelled) {
+                return {
+                    success: false,
+                    summary: `Task cancelled: ${this.cancelReason || 'User abort'}`,
+                    taskId,
+                    stepsTaken: step,
+                    modifiedFiles: Array.from(this.modifiedFiles),
+                    status: 'cancelled',
+                };
+            }
+            step++;
+            this.currentStep = step;
+            this.workspace.startStep(step);
+            // Context Compaction check: If history is long, compact middle turns using workspace state
+            if (this.historyMessages.length > 10) {
+                this.historyMessages = this.workspace.compactHistoryMessages(this.historyMessages, 6);
+            }
+            const stepSpinner = spinner();
+            stepSpinner.start(chalk.cyan(`Scout Operating (Step ${step}/${this.maxSteps})`));
+            try {
+                let response;
+                try {
+                    response = await callOpenAIWithRetry(async (model) => {
+                        return await openai.chat.completions.create({
+                            model,
+                            messages: sanitizeMessages(this.historyMessages),
+                            tools: this.toolRegistry.getAllTools().map((t) => ({ type: 'function', function: t })),
+                            tool_choice: 'auto',
+                            temperature: 0.1,
+                        });
+                    });
+                }
+                catch (err) {
+                    const errStr = String(err?.message || err || '').toLowerCase();
+                    if (errStr.includes('tool') || errStr.includes('400') || errStr.includes('not supported')) {
+                        const fallbackMsg = {
+                            role: 'user',
+                            content: `Format your tool call as a JSON code block:\n\`\`\`json\n{ "tool": "tool_name", "args": { ... } }\n\`\`\`\nAvailable tools: ${this.toolRegistry.getAllTools().map((t) => t.name).join(', ')}`,
+                        };
+                        response = await callOpenAIWithRetry(async (model) => {
+                            return await openai.chat.completions.create({
+                                model,
+                                messages: sanitizeMessages([...this.historyMessages, fallbackMsg]),
+                                temperature: 0.1,
+                            });
+                        });
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                const choice = response.choices[0];
+                if (!choice) {
+                    stepSpinner.stop(chalk.yellow('No response from model. Retrying step...'));
+                    continue;
+                }
+                const msg = sanitizeMessage(choice.message);
+                this.historyMessages.push(msg);
+                if (msg.content && msg.content.trim()) {
+                    safeNote(renderMarkdown(msg.content), `Scout Step ${step}`);
+                }
+                let toolCallsToExecute = [];
+                if (msg.tool_calls && msg.tool_calls.length > 0) {
+                    for (const tc of msg.tool_calls) {
+                        if (tc.type === 'function' && tc.function) {
+                            try {
+                                toolCallsToExecute.push({
+                                    name: tc.function.name,
+                                    args: JSON.parse(tc.function.arguments || '{}'),
+                                    id: tc.id,
+                                });
+                            }
+                            catch {
+                                toolCallsToExecute.push({ name: tc.function.name, args: {}, id: tc.id });
+                            }
+                        }
+                    }
+                }
+                else if (msg.content) {
+                    const parsed = this.extractJsonToolCall(msg.content);
+                    if (parsed) {
+                        toolCallsToExecute.push({ name: parsed.tool, args: parsed.args });
+                    }
+                }
+                stepSpinner.stop(chalk.green(`Step ${step}: Executing ${toolCallsToExecute.length} action(s).`));
+                for (const tc of toolCallsToExecute) {
+                    if (this.isCancelled)
+                        break;
+                    const toolResult = await this.dispatchTool(tc.name, tc.args);
+                    this.historyMessages.push({
+                        role: 'user',
+                        tool_call_id: tc.id,
+                        content: `Tool Execution Result (${tc.name}):\n${toolResult.result}`,
+                    });
+                    if (tc.name === 'task_completed') {
+                        finalSummary = tc.args.summary || toolResult.result;
+                        if (this.modifiedFiles.size > 0) {
+                            const filesList = getDirectoryFiles(this.cwd);
+                            await verifyAndSelfHealFiles(Array.from(this.modifiedFiles), this.cwd, path.basename(this.cwd), filesList, { maxRetries: 3 });
+                        }
+                        this.workspace.setStatus('completed');
+                        this.workspace.completeStep(step, finalSummary);
+                        saveAgentSession({
+                            goal: userGoal,
+                            summary: finalSummary,
+                            modifiedFiles: Array.from(this.modifiedFiles),
+                        });
+                        return {
+                            success: true,
+                            summary: finalSummary,
+                            taskId,
+                            stepsTaken: step,
+                            modifiedFiles: Array.from(this.modifiedFiles),
+                            status: 'completed',
+                        };
+                    }
+                }
+            }
+            catch (err) {
+                stepSpinner.stop(chalk.red(`Step ${step} error: ${err?.message || String(err)}`));
+                this.workspace.recordError(err?.message || String(err), 'runtime', undefined, false);
+                this.historyMessages.push({
+                    role: 'user',
+                    content: `System Error encountered on step ${step}: ${err?.message || String(err)}. Diagnose and adapt action.`,
+                });
+            }
+        }
+        this.workspace.setStatus('failed');
+        return {
+            success: false,
+            summary: `Reached max iteration steps limit (${this.maxSteps}). Modified files: ${Array.from(this.modifiedFiles).join(', ')}`,
+            taskId,
+            stepsTaken: step,
+            modifiedFiles: Array.from(this.modifiedFiles),
+            status: 'failed',
+        };
+    }
+    async dispatchTool(name, args) {
+        this.totalToolCalls++;
+        const risk = this.approvalManager.checkAction(name, args);
+        if (risk.requiresApproval && !this.autoApprove) {
+            this.workspace.setPendingApproval({
+                id: `act_${Date.now()}`,
+                tool: name,
+                args,
+                riskLevel: risk.level,
+                riskReason: risk.reason,
+                requestedAt: new Date().toISOString(),
+            });
+            const decision = await this.approvalManager.requestApproval(this.workspace.getData().taskId, name, args, risk);
+            this.workspace.setPendingApproval(null);
+            if (!decision.approved) {
+                this.workspace.addObservation({
+                    tool: name,
+                    resultSummary: `[ACTION BLOCKED: User rejected approval: ${decision.reason || 'Not approved'}]`,
+                    verified: false,
+                });
+                return { result: `[ACTION REJECTED BY USER]: ${decision.reason || 'User rejected this action.'}` };
+            }
+        }
+        // Validate against execution intent (USER INTENT > TOOL CONVENIENCE)
+        const validation = this.workspace.validateToolExecution(name, args);
+        if (!validation.allowed) {
+            const blockedSummary = `[EXECUTION INTENT VIOLATION BLOCKED]: ${validation.reason}`;
+            this.workspace.addObservation({
+                tool: name,
+                resultSummary: blockedSummary,
+                verified: false,
+            });
+            return {
+                result: JSON.stringify({
+                    success: false,
+                    action: name,
+                    error: 'ExecutionIntentViolation',
+                    message: validation.reason,
+                    recoverable: true,
+                    suggestedAction: 'Preserve the user\'s required execution method using computer interaction tools (computer_open_app, computer_switch_window, computer_click, computer_type, computer_hotkey). Do NOT substitute direct filesystem APIs.'
+                }, null, 2)
+            };
+        }
+        // 1. Computer Control Tools
+        if (name.startsWith('computer_')) {
+            return await this.dispatchComputerTool(name, args);
+        }
+        // 2. Browser Automation Tools
+        if (name.startsWith('browser_')) {
+            return await this.dispatchBrowserTool(name, args);
+        }
+        // 3. Core Direct Workspace Tools
+        return await this.dispatchCoreTool(name, args);
+    }
+    async dispatchComputerTool(name, args) {
+        switch (name) {
+            case 'computer_screenshot': {
+                const res = await this.computerController.screenshot();
+                if (res.path) {
+                    this.workspace.recordArtifact({
+                        filename: path.basename(res.path),
+                        path: res.path,
+                        type: 'image',
+                        description: `Screen observation (${res.width}x${res.height})`,
+                        application: res.activeWindow || 'Desktop',
+                    });
+                }
+                if (res.activeWindow) {
+                    this.workspace.setActiveWindow(res.activeWindow);
+                }
+                const summary = `Screen captured: ${res.width}x${res.height}, Active window: "${res.activeWindow || 'Desktop'}"${res.path ? `, Saved: ${res.path}` : ''}`;
+                this.workspace.addObservation({ tool: name, resultSummary: summary, verified: true });
+                return { result: summary };
+            }
+            case 'computer_click': {
+                const x = Number(args.x);
+                const y = Number(args.y);
+                const res = await this.computerController.click(x, y, { button: args.button, clicks: 1 });
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'click',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    ...(res.activeWindow ? { activeWindow: res.activeWindow } : {}),
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_double_click': {
+                const x = Number(args.x);
+                const y = Number(args.y);
+                const res = await this.computerController.doubleClick(x, y);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'double_click',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_type': {
+                const textVal = String(args.text || '');
+                const res = await this.computerController.type(textVal);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'type',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    ...(res.activeWindow ? { activeWindow: res.activeWindow } : {}),
+                    ...(res.expectedWindow ? { expectedWindow: res.expectedWindow } : {}),
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_key_press': {
+                const key = String(args.key || '');
+                const res = await this.computerController.keyPress(key);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'key_press',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_hotkey': {
+                const keys = Array.isArray(args.keys) ? args.keys.map(String) : [String(args.keys)];
+                const res = await this.computerController.hotkey(keys);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'hotkey',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    ...(res.activeWindow ? { activeWindow: res.activeWindow } : {}),
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_scroll': {
+                const deltaY = Number(args.deltaY || 0);
+                const deltaX = Number(args.deltaX || 0);
+                const res = await this.computerController.scroll(deltaX, deltaY);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                return { result: res.output };
+            }
+            case 'computer_mouse_move': {
+                const x = Number(args.x);
+                const y = Number(args.y);
+                const res = await this.computerController.mouseMove(x, y);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                return { result: res.output };
+            }
+            case 'computer_drag': {
+                const res = await this.computerController.drag(Number(args.fromX), Number(args.fromY), Number(args.toX), Number(args.toY));
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                return { result: res.output };
+            }
+            case 'computer_wait': {
+                const ms = Math.min(10000, Math.max(100, Number(args.ms) || 1000));
+                await this.computerController.wait(ms);
+                return { result: `Waited for ${ms}ms` };
+            }
+            case 'computer_open_app': {
+                const appName = String(args.appName || args.app || '');
+                const res = await this.computerController.openApplication(appName, args.args);
+                this.workspace.setActiveApplication(appName);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'open_app',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    activeWindow: res.activeWindow || appName,
+                    expectedWindow: res.expectedWindow || appName,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_close_app': {
+                const appName = String(args.appName || args.app || '');
+                const res = await this.computerController.closeApplication(appName);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                return { result: res.output };
+            }
+            case 'computer_switch_window': {
+                const targetWin = String(args.windowTitleOrApp || args.target || '');
+                const res = await this.computerController.switchWindow(targetWin);
+                if (res.success) {
+                    this.workspace.setActiveWindow(targetWin);
+                }
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'switch_window',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    activeWindow: res.activeWindow || targetWin,
+                    expectedWindow: res.expectedWindow,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_inspect_ui': {
+                const ui = await this.computerController.inspectUI();
+                this.workspace.setActiveWindow(ui.activeWindow);
+                const outStr = `Active Window: "${ui.activeWindow}"\nVisible Windows: ${ui.windows.map((w) => `"${w}"`).join(', ')}`;
+                this.workspace.addObservation({ tool: name, resultSummary: outStr, verified: true });
+                const structuredRes = {
+                    success: true,
+                    action: 'inspect_ui',
+                    activeWindow: ui.activeWindow,
+                    windows: ui.windows,
+                    output: outStr,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            default:
+                return { result: `Unknown computer tool: "${name}"` };
+        }
+    }
+    async dispatchBrowserTool(name, args) {
+        switch (name) {
+            case 'browser_navigate': {
+                const url = String(args.url || '');
+                this.workspace.setActiveUrl(url);
+                this.workspace.setActiveApplication('Browser');
+                const res = await this.browserController.navigate(url);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success, target: url });
+                return { result: res.output };
+            }
+            case 'browser_inspect': {
+                const res = await this.browserController.inspect_page();
+                this.workspace.addObservation({ tool: name, resultSummary: res.summary, verified: res.success, target: res.url });
+                return { result: res.summary };
+            }
+            case 'browser_click': {
+                const target = String(args.selectorOrText || args.target || '');
+                const res = await this.browserController.click(target);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success, target });
+                return { result: res.output };
+            }
+            case 'browser_type': {
+                const target = String(args.selectorOrText || args.target || '');
+                const textVal = String(args.text || '');
+                const res = await this.browserController.type(target, textVal);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success, target });
+                return { result: res.output };
+            }
+            case 'browser_download': {
+                const target = String(args.urlOrSelector || args.url || '');
+                const res = await this.browserController.download_file(target, args.destPath);
+                if (res.success && res.details?.path) {
+                    const vRes = await this.actionVerifier.verifyFileCreated(res.details.path);
+                    const artifact = this.workspace.recordArtifact({
+                        filename: res.details.filename || path.basename(res.details.path),
+                        path: res.details.path,
+                        application: 'Browser',
+                        verified: vRes.verified,
+                        sizeBytes: res.details.sizeBytes,
+                    });
+                    this.workspace.addObservation({ tool: name, resultSummary: `${res.output} (Verified on disk: ${vRes.verified})`, verified: vRes.verified });
+                    return { result: `${res.output}\nTracked Artifact: ${artifact.filename} (${artifact.path})` };
+                }
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: false });
+                return { result: res.output };
+            }
+            case 'browser_content': {
+                const res = await this.browserController.extract_content(args.selector);
+                this.workspace.addObservation({ tool: name, resultSummary: `Extracted content (${res.output.length} chars)`, verified: res.success });
+                return { result: res.output };
+            }
+            default:
+                return { result: `Unknown browser tool: "${name}"` };
+        }
+    }
+    async dispatchCoreTool(name, args) {
+        switch (name) {
+            case 'read_file': {
+                const targetPath = String(args.path || '').trim();
+                const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(this.cwd, targetPath);
+                if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) {
+                    return { result: `Error: File not found at path "${targetPath}"` };
+                }
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                const lines = content.split('\n');
+                const start = Math.max(1, Number(args.startLine) || 1);
+                const end = Math.min(lines.length, Number(args.endLine) || lines.length);
+                const sliced = lines.slice(start - 1, end).map((l, i) => `${start + i} | ${l}`).join('\n');
+                this.workspace.addObservation({ tool: name, resultSummary: `Read ${targetPath} (${lines.length} lines)`, verified: true, target: targetPath });
+                return { result: `File: ${targetPath} (Lines ${start}-${end}/${lines.length}):\n${sliced}` };
+            }
+            case 'write_file': {
+                let targetPath = String(args.path || '').trim();
+                const intent = this.workspace.getExecutionIntent();
+                if (intent.targetDestination === 'Desktop' || targetPath.toLowerCase().includes('desktop')) {
+                    const fileName = path.basename(targetPath);
+                    targetPath = resolveDesktopPath(fileName);
+                }
+                const content = String(args.content || '');
+                const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(this.cwd, targetPath);
+                fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+                fs.writeFileSync(fullPath, content, 'utf-8');
+                this.modifiedFiles.add(targetPath);
+                this.workspace.recordArtifact({
+                    filename: path.basename(targetPath),
+                    path: targetPath,
+                    type: 'file',
+                    verified: true,
+                    sizeBytes: Buffer.byteLength(content, 'utf-8'),
+                });
+                this.workspace.addObservation({ tool: name, resultSummary: `Wrote file ${targetPath} (${content.length} chars)`, verified: true, target: targetPath });
+                return { result: `Successfully wrote file "${targetPath}".` };
+            }
+            case 'edit_file': {
+                const targetPath = String(args.path || '').trim();
+                const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(this.cwd, targetPath);
+                if (!fs.existsSync(fullPath))
+                    return { result: `Error: File "${targetPath}" does not exist.` };
+                const currentContent = fs.readFileSync(fullPath, 'utf-8');
+                const replaceRes = robustSnippetReplace(currentContent, args.target, args.replacement);
+                if (!replaceRes.success) {
+                    return { result: `Error: ${replaceRes.error}` };
+                }
+                fs.writeFileSync(fullPath, replaceRes.updatedContent, 'utf-8');
+                this.modifiedFiles.add(targetPath);
+                this.workspace.addObservation({ tool: name, resultSummary: `Edited file ${targetPath}`, verified: true, target: targetPath });
+                return { result: `Successfully updated "${targetPath}".` };
+            }
+            case 'run_command': {
+                const cmd = String(args.command || args.cmd || '').trim();
+                try {
+                    const { execSync } = await import('child_process');
+                    const out = execSync(cmd, { cwd: this.cwd, encoding: 'utf-8', maxBuffer: 1024 * 1024 * 5 });
+                    const preview = out.slice(0, 5000);
+                    this.workspace.addObservation({ tool: name, resultSummary: `Ran command "${cmd}"`, verified: true, target: cmd });
+                    return { result: `Command Output:\n${preview}` };
+                }
+                catch (err) {
+                    const errOutput = (err?.stdout || '') + '\n' + (err?.stderr || err?.message || String(err));
+                    this.workspace.addObservation({ tool: name, resultSummary: `Command "${cmd}" failed`, verified: false, target: cmd });
+                    return { result: `Command Failed:\n${errOutput.slice(0, 5000)}` };
+                }
+            }
+            case 'list_dir': {
+                const relPath = String(args.path || '.').trim();
+                const fullPath = path.isAbsolute(relPath) ? relPath : path.resolve(this.cwd, relPath);
+                if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isDirectory()) {
+                    return { result: `Error: Directory not found "${relPath}"` };
+                }
+                const entries = fs.readdirSync(fullPath);
+                return { result: `Directory contents of "${relPath}":\n${entries.slice(0, 100).join('\n')}` };
+            }
+            case 'grep_search': {
+                const query = String(args.query || '').trim();
+                const files = getDirectoryFiles(this.cwd);
+                const matches = [];
+                for (const f of files.slice(0, 200)) {
+                    try {
+                        const c = fs.readFileSync(path.resolve(this.cwd, f), 'utf-8');
+                        if (c.includes(query))
+                            matches.push(f);
+                    }
+                    catch { }
+                }
+                return { result: `Files containing "${query}" (${matches.length}):\n${matches.slice(0, 30).join('\n')}` };
+            }
+            case 'glob_search': {
+                const pattern = String(args.pattern || '').trim().toLowerCase();
+                const files = getDirectoryFiles(this.cwd);
+                const matched = files.filter((f) => f.toLowerCase().includes(pattern.replace(/\*/g, '')));
+                return { result: `Matching files (${matched.length}):\n${matched.slice(0, 30).join('\n')}` };
+            }
+            case 'tree_view': {
+                const maxDepth = Number(args.maxDepth) || 3;
+                const tree = buildDirectoryTree(this.cwd, '', 0, maxDepth);
+                return { result: `Workspace Tree:\n${tree}` };
+            }
+            case 'file_info': {
+                const targetPath = String(args.path || '').trim();
+                const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(this.cwd, targetPath);
+                if (!fs.existsSync(fullPath))
+                    return { result: `Error: File not found "${targetPath}"` };
+                const st = fs.statSync(fullPath);
+                return {
+                    result: `File Info for "${targetPath}": Size: ${st.size} bytes, Modified: ${st.mtime.toISOString()}, IsDirectory: ${st.isDirectory()}`
+                };
+            }
+            case 'multi_edit_file': {
+                const targetPath = String(args.path || '').trim();
+                const edits = Array.isArray(args.edits) ? args.edits : [];
+                const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(this.cwd, targetPath);
+                if (!fs.existsSync(fullPath))
+                    return { result: `Error: File not found "${targetPath}"` };
+                let content = fs.readFileSync(fullPath, 'utf-8');
+                let count = 0;
+                for (const ed of edits) {
+                    const res = robustSnippetReplace(content, ed.target, ed.replacement);
+                    if (res.success) {
+                        content = res.updatedContent;
+                        count++;
+                    }
+                }
+                fs.writeFileSync(fullPath, content, 'utf-8');
+                this.modifiedFiles.add(targetPath);
+                return { result: `Applied ${count}/${edits.length} edits to "${targetPath}"` };
+            }
+            case 'fetch_url': {
+                const url = String(args.url || '').trim();
+                const resp = await fetch(url);
+                const textOut = await resp.text();
+                return { result: `Fetched ${url} (${textOut.length} chars):\n${textOut.slice(0, 4000)}` };
+            }
+            case 'git_diff': {
+                const { execSync } = await import('child_process');
+                try {
+                    const diff = execSync('git diff', { cwd: this.cwd, encoding: 'utf-8' });
+                    return { result: diff ? `Git diff:\n${diff.slice(0, 5000)}` : 'No git changes' };
+                }
+                catch {
+                    return { result: 'git diff not available' };
+                }
+            }
+            case 'ask_user': {
+                const q = String(args.question || 'Input required:');
+                safeNote(q, 'User Input Required');
+                const ans = await text({ message: chalk.cyan(q) });
+                const ansStr = typeof ans === 'symbol' ? 'cancelled' : String(ans);
+                return { result: `User answered: ${ansStr}` };
+            }
+            case 'speak_text': {
+                const txt = String(args.text || '');
+                speakText(txt, { async: true });
+                return { result: `Spoke: "${txt}"` };
+            }
+            case 'task_completed': {
+                const summary = String(args.summary || 'Completed');
+                const intent = this.workspace.getExecutionIntent();
+                if (intent.targetDestination === 'Desktop' && intent.targetArtifactName) {
+                    const checkRes = await this.actionVerifier.verifyFileCreated(intent.targetArtifactName, 1, 'Desktop');
+                    if (!checkRes.verified) {
+                        return {
+                            result: JSON.stringify({
+                                success: false,
+                                error: 'VerificationFailed',
+                                message: `Cannot conclude task as completed: ${checkRes.message}`,
+                                recoverable: true,
+                                suggestedAction: 'The file was not found on the Desktop (or was placed in a substitute path). Save the file to the user\'s Desktop via the application interface before completing.'
+                            }, null, 2)
+                        };
+                    }
+                }
+                speakText(summary, { async: true });
+                return { result: summary };
+            }
+            default:
+                return { result: `Unknown tool call: "${name}"` };
+        }
+    }
+    extractJsonToolCall(content) {
+        if (!content)
+            return null;
+        const funcMatch = content.match(/<function=([a-zA-Z0-9_]+)>([\s\S]*?)<\/function>/i);
+        if (funcMatch && funcMatch[1] && funcMatch[2]) {
+            try {
+                return { tool: funcMatch[1].trim(), args: JSON.parse(funcMatch[2].trim()) };
+            }
+            catch {
+                return { tool: funcMatch[1].trim(), args: { raw: funcMatch[2].trim() } };
+            }
+        }
+        const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) || content.match(/\{[\s\S]*"tool"[\s\S]*\}/);
+        if (jsonMatch) {
+            try {
+                const obj = JSON.parse(jsonMatch[1] || jsonMatch[0]);
+                if (obj && typeof obj.tool === 'string') {
+                    return { tool: obj.tool, args: obj.args || obj.parameters || {} };
+                }
+            }
+            catch { }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=agentRuntime.js.map