ft-scout 9.0.3 → 9.0.5

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

@@ -0,0 +1,1160 @@
+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';
+import { loadAuthConfig, isProOrHigher } from '../../utils/auth.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 = [];
+    screenshotCount = 0;
+    userTier;
+    static MAX_SCREENSHOTS_IN_HISTORY = 5;
+    static SCREENSHOT_MAX_DIMENSION = 1280;
+    constructor(options) {
+        this.cwd = options?.workspaceDir || process.cwd();
+        this.autoApprove = Boolean(options?.autoApprove);
+        this.mockMode = Boolean(options?.mockMode);
+        this.language = options?.language;
+        this.userTier = (options?.tier || (options?.mockMode ? 'pro' : 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';
+        const requestedSteps = options?.maxSteps || 30;
+        this.maxSteps = isPaid ? requestedSteps : Math.min(requestedSteps, 5);
+        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();
+    }
+    isProOrEnterprise() {
+        if (this.mockMode || (this.computerController && this.computerController.constructor.name === 'MockComputerController')) {
+            return true;
+        }
+        return isProOrHigher(this.userTier);
+    }
+    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();
+        const tierNotice = !this.isProOrEnterprise()
+            ? `\nTIER RESTRICTION (FREE DEVELOPER TIER):
+- You are operating under the Free Developer Tier.
+- Free developers have access to basic developer operations: code editing, creating new files and folders, reading files, and running terminal commands.
+- Scratchpad reasoning and autonomous computer/browser automation tools are locked to Pro & Enterprise plan users.
+- Do NOT attempt to use scratchpad, computer_* or browser_* tools. Complete coding and task requests using direct workspace tools (edit_file, write_file, read_file, run_command, list_dir, grep_search, etc.).`
+            : `\nTIER: PRO/ENTERPRISE (Full Autonomous Computer Control, Browser Automation & AI Scratchpad Unlocked).`;
+        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()}
+
+${tierNotice}
+
+${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;
+                const tierTools = this.toolRegistry.getToolsForTier(this.userTier);
+                try {
+                    response = await callOpenAIWithRetry(async (model) => {
+                        return await openai.chat.completions.create({
+                            model,
+                            messages: sanitizeMessages(this.historyMessages),
+                            tools: tierTools.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: ${tierTools.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);
+                    // Build the tool result message with correct role
+                    if (tc.id) {
+                        // Native tool call: use 'tool' role with matching tool_call_id
+                        this.historyMessages.push({
+                            role: 'tool',
+                            tool_call_id: tc.id,
+                            content: typeof toolResult.result === 'string' ? toolResult.result : JSON.stringify(toolResult.result),
+                        });
+                    }
+                    else {
+                        // JSON-extracted tool call (no tc.id): use 'user' role
+                        this.historyMessages.push({
+                            role: 'user',
+                            content: `Tool Execution Result (${tc.name}):\n${toolResult.result}`,
+                        });
+                    }
+                    // If the tool returned screenshot data, append a vision message so the model can see the screen
+                    if (toolResult.screenshotBase64) {
+                        this.pruneOldScreenshots();
+                        this.historyMessages.push({
+                            role: 'user',
+                            content: [
+                                { type: 'text', text: `[Screenshot after ${tc.name}]: ${toolResult.screenshotSummary || 'Current screen state.'}` },
+                                { type: 'image_url', image_url: { url: `data:image/png;base64,${toolResult.screenshotBase64}`, detail: 'low' } },
+                            ],
+                        });
+                    }
+                    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 executeTool(name, args) {
+        return await this.dispatchTool(name, args);
+    }
+    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_') || name === 'computer') {
+            if (!this.isProOrEnterprise()) {
+                const upgradeMsg = `[PLAN RESTRICTION]: Autonomous Computer Control tools (${name}) are exclusively available to Pro and Enterprise plan developers. Free tier developers can perform code editing, creating files/folders, and running terminal commands. Upgrade to Pro at https://tryscout.web.app to unlock autonomous computer & app control.`;
+                this.workspace.addObservation({
+                    tool: name,
+                    resultSummary: upgradeMsg,
+                    verified: false,
+                });
+                return { result: upgradeMsg };
+            }
+            return await this.dispatchComputerTool(name, args);
+        }
+        // 2. Browser Automation Tools
+        if (name.startsWith('browser_')) {
+            if (!this.isProOrEnterprise()) {
+                const upgradeMsg = `[PLAN RESTRICTION]: Autonomous Browser Control tools (${name}) are exclusively available to Pro and Enterprise plan developers. Free tier developers can perform code editing, creating files/folders, and running terminal commands. Upgrade to Pro at https://tryscout.web.app to unlock browser automation.`;
+                this.workspace.addObservation({
+                    tool: name,
+                    resultSummary: upgradeMsg,
+                    verified: false,
+                });
+                return { result: upgradeMsg };
+            }
+            return await this.dispatchBrowserTool(name, args);
+        }
+        // 3. Core Direct Workspace Tools
+        return await this.dispatchCoreTool(name, args);
+    }
+    async dispatchComputerTool(name, args) {
+        if (name === 'computer') {
+            const action = String(args.action || 'screenshot').toLowerCase().trim();
+            if (action === 'click' || action === 'left_click') {
+                name = 'computer_click';
+            }
+            else if (action === 'right_click') {
+                name = 'computer_right_click';
+            }
+            else if (action === 'double_click') {
+                name = 'computer_double_click';
+            }
+            else if (action === 'move' || action === 'mouse_move') {
+                name = 'computer_mouse_move';
+            }
+            else if (action === 'mouse_down') {
+                name = 'computer_mouse_down';
+            }
+            else if (action === 'mouse_up') {
+                name = 'computer_mouse_up';
+            }
+            else if (action === 'drag') {
+                name = 'computer_drag';
+                args.fromX = args.startX ?? args.fromX;
+                args.fromY = args.startY ?? args.fromY;
+                args.toX = args.endX ?? args.toX;
+                args.toY = args.endY ?? args.toY;
+            }
+            else if (action === 'scroll') {
+                name = 'computer_scroll';
+            }
+            else if (action === 'screenshot') {
+                name = 'computer_screenshot';
+            }
+            else if (action === 'type') {
+                name = 'computer_type';
+            }
+            else if (action === 'key_press' || action === 'key') {
+                name = 'computer_key_press';
+            }
+            else if (action === 'hotkey') {
+                name = 'computer_hotkey';
+            }
+            else if (action === 'open_app') {
+                name = 'computer_open_app';
+            }
+            else if (action === 'close_app') {
+                name = 'computer_close_app';
+            }
+            else if (action === 'switch_window') {
+                name = 'computer_switch_window';
+            }
+            else if (action === 'inspect_ui') {
+                name = 'computer_inspect_ui';
+            }
+            else if (action === 'diagnostic') {
+                name = 'computer_diagnostic';
+            }
+        }
+        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'}"`;
+                this.workspace.addObservation({ tool: name, resultSummary: summary, verified: true });
+                // Encode the screenshot as base64 for model vision
+                const base64Data = res.path ? this.readScreenshotAsBase64(res.path) : undefined;
+                this.screenshotCount++;
+                return {
+                    result: summary,
+                    screenshotBase64: base64Data,
+                    screenshotSummary: summary,
+                };
+            }
+            case 'computer_click': {
+                const x = Number(args.x);
+                const y = Number(args.y);
+                const btn = args.button || 'left';
+                const res = await this.computerController.click(x, y, { button: btn, clicks: 1 });
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'click',
+                    coordinates: res.coordinates || { x, y },
+                    button: btn,
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    ...(res.activeWindow ? { activeWindow: res.activeWindow } : {}),
+                };
+                // Auto-capture screenshot after click so model sees the result
+                const postSnap = await this.capturePostActionScreenshot('click');
+                return { result: JSON.stringify(structuredRes, null, 2), ...postSnap };
+            }
+            case 'computer_right_click': {
+                const x = Number(args.x);
+                const y = Number(args.y);
+                const res = await this.computerController.rightClick(x, y);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'right_click',
+                    coordinates: res.coordinates || { x, y },
+                    button: 'right',
+                    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',
+                    coordinates: res.coordinates || { x, y },
+                    button: 'left',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_mouse_down': {
+                const x = args.x !== undefined ? Number(args.x) : undefined;
+                const y = args.y !== undefined ? Number(args.y) : undefined;
+                const btn = args.button || 'left';
+                const res = await this.computerController.mouseDown(x, y, btn);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'mouse_down',
+                    coordinates: res.coordinates || (x !== undefined && y !== undefined ? { x, y } : undefined),
+                    button: btn,
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_mouse_up': {
+                const x = args.x !== undefined ? Number(args.x) : undefined;
+                const y = args.y !== undefined ? Number(args.y) : undefined;
+                const btn = args.button || 'left';
+                const res = await this.computerController.mouseUp(x, y, btn);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'mouse_up',
+                    coordinates: res.coordinates || (x !== undefined && y !== undefined ? { x, y } : undefined),
+                    button: btn,
+                    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 } : {}),
+                };
+                // Auto-capture screenshot after typing so model sees the result
+                const postSnap = await this.capturePostActionScreenshot('type');
+                return { result: JSON.stringify(structuredRes, null, 2), ...postSnap };
+            }
+            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 } : {}),
+                };
+                // Auto-capture screenshot after hotkey so model sees the result
+                const postSnap = await this.capturePostActionScreenshot('hotkey');
+                return { result: JSON.stringify(structuredRes, null, 2), ...postSnap };
+            }
+            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.move(x, y);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'move',
+                    coordinates: res.coordinates || { x, y },
+                    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_drag': {
+                const fromX = Number(args.fromX ?? args.startX ?? 0);
+                const fromY = Number(args.fromY ?? args.startY ?? 0);
+                const toX = Number(args.toX ?? args.endX ?? 0);
+                const toY = Number(args.toY ?? args.endY ?? 0);
+                const res = await this.computerController.drag(fromX, fromY, toX, toY);
+                this.workspace.addObservation({ tool: name, resultSummary: res.output, verified: res.success });
+                const structuredRes = {
+                    success: res.success,
+                    action: 'drag',
+                    from: { x: fromX, y: fromY },
+                    to: { x: toX, y: toY },
+                    coordinates: res.coordinates || { x: toX, y: toY },
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            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,
+                };
+                // Auto-capture screenshot after opening app so model sees the window
+                const postSnap = await this.capturePostActionScreenshot('open_app');
+                return { result: JSON.stringify(structuredRes, null, 2), ...postSnap };
+            }
+            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,
+                };
+                // Auto-capture screenshot after switching so model sees the new window
+                const postSnap = await this.capturePostActionScreenshot('switch_window');
+                return { result: JSON.stringify(structuredRes, null, 2), ...postSnap };
+            }
+            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) };
+            }
+            case 'computer_diagnostic': {
+                const diag = await this.computerController.runDiagnostic();
+                return { result: JSON.stringify(diag, null, 2) };
+            }
+            default:
+                return { result: `Unknown computer tool: "${name}"` };
+        }
+    }
+    /**
+     * Read a screenshot file from disk, resize it to save tokens, and return as base64.
+     * Returns undefined if the file cannot be read.
+     */
+    readScreenshotAsBase64(screenshotPath) {
+        try {
+            if (!fs.existsSync(screenshotPath))
+                return undefined;
+            const raw = fs.readFileSync(screenshotPath);
+            return raw.toString('base64');
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Capture a post-action screenshot automatically.
+     * This gives the model vision of what happened after a screen-modifying action.
+     * Includes a brief delay to let the UI settle.
+     */
+    async capturePostActionScreenshot(actionName) {
+        try {
+            // Brief delay to let the UI settle after the action
+            await this.computerController.wait(350);
+            const snap = await this.computerController.screenshot();
+            if (!snap.path)
+                return {};
+            const base64Data = this.readScreenshotAsBase64(snap.path);
+            if (!base64Data)
+                return {};
+            this.screenshotCount++;
+            const summary = `Post-action screenshot (after ${actionName}): ${snap.width}x${snap.height}, Active window: "${snap.activeWindow || 'Desktop'}"`;
+            return { screenshotBase64: base64Data, screenshotSummary: summary };
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Remove old screenshot vision messages from history to prevent context overflow.
+     * Keeps only the most recent MAX_SCREENSHOTS_IN_HISTORY screenshots.
+     */
+    pruneOldScreenshots() {
+        const maxKeep = AgentRuntime.MAX_SCREENSHOTS_IN_HISTORY;
+        // Find all vision messages (those with image_url content)
+        const visionIndices = [];
+        for (let i = 0; i < this.historyMessages.length; i++) {
+            const msg = this.historyMessages[i];
+            if (Array.isArray(msg.content)) {
+                const hasImage = msg.content.some((part) => part.type === 'image_url');
+                if (hasImage)
+                    visionIndices.push(i);
+            }
+        }
+        // If we have more than maxKeep, remove the oldest ones
+        if (visionIndices.length >= maxKeep) {
+            const toRemove = visionIndices.slice(0, visionIndices.length - maxKeep + 1);
+            // Remove in reverse order to preserve indices
+            for (let i = toRemove.length - 1; i >= 0; i--) {
+                const idx = toRemove[i];
+                if (idx !== undefined) {
+                    this.historyMessages.splice(idx, 1);
+                }
+            }
+        }
+    }
+    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 'scratchpad': {
+                if (!this.isProOrEnterprise()) {
+                    const upgradeMsg = `[PLAN RESTRICTION]: AI Scratchpad & Autonomous reasoning is an exclusive feature for Pro and Enterprise plan subscribers. Free tier developers can perform code editing, creating files/folders, and running commands. Upgrade to Pro at https://tryscout.web.app to unlock the AI Scratchpad.`;
+                    this.workspace.addObservation({
+                        tool: name,
+                        resultSummary: upgradeMsg,
+                        verified: false,
+                    });
+                    return { result: upgradeMsg };
+                }
+                const action = String(args.action || 'read').toLowerCase();
+                const scratchpadPath = path.resolve(this.cwd, '.ft', 'scratchpad.md');
+                fs.mkdirSync(path.dirname(scratchpadPath), { recursive: true });
+                if (action === 'write') {
+                    const content = String(args.content || '');
+                    fs.writeFileSync(scratchpadPath, content, 'utf-8');
+                    this.workspace.addObservation({ tool: name, resultSummary: `Scratchpad updated (${content.length} chars)`, verified: true });
+                    return { result: `Scratchpad updated successfully.` };
+                }
+                else if (action === 'append') {
+                    const content = String(args.content || '');
+                    fs.appendFileSync(scratchpadPath, `\n${content}`, 'utf-8');
+                    this.workspace.addObservation({ tool: name, resultSummary: `Appended to scratchpad`, verified: true });
+                    return { result: `Appended notes to scratchpad.` };
+                }
+                else if (action === 'clear') {
+                    fs.writeFileSync(scratchpadPath, '', 'utf-8');
+                    this.workspace.addObservation({ tool: name, resultSummary: `Cleared scratchpad`, verified: true });
+                    return { result: `Scratchpad cleared.` };
+                }
+                else {
+                    // read
+                    if (!fs.existsSync(scratchpadPath)) {
+                        return { result: `Scratchpad is currently empty.` };
+                    }
+                    const content = fs.readFileSync(scratchpadPath, 'utf-8');
+                    return { result: `Scratchpad content:\n${content || '(empty)'}` };
+                }
+            }
+            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