ft-scout 9.4.7 → 9.4.8

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

@@ -20,6 +20,9 @@ import { robustSnippetReplace, buildDirectoryTree } from '../agentEngine.js';
 import { loadAuthConfig, isProOrHigher } from '../../utils/auth.js';
 import { getMCPManager } from '../../mcp/index.js';
 import { compress, LEVEL_FAST } from 'codrop';
+import { renderStepHeader, renderThoughtBox, renderToolCall, renderToolResult, renderTaskCompletedCard, } from '../../utils/claudeUI.js';
+import { loadWorkspaceRules } from '../../utils/rules.js';
+import { InterruptManager } from '../../utils/interruptHandler.js';
 export class AgentRuntime {
     cwd;
     autoApprove;
@@ -55,7 +58,7 @@ export class AgentRuntime {
         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 (unlimited steps).
-        const isPaid = this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
+        const isPaid = this.mockMode || isProOrHigher(this.userTier);
         const requestedSteps = options?.maxSteps;
         this.maxSteps = isPaid ? (requestedSteps || Infinity) : Math.min(requestedSteps || 5, 5);
         this.workspace = new AgentWorkspace(options?.taskId, '', this.cwd);
@@ -136,6 +139,8 @@ export class AgentRuntime {
     buildSystemPrompt() {
         const filesList = getDirectoryFiles(this.cwd).slice(0, 100);
         const workspaceState = this.workspace.compactWorkspaceForPrompt();
+        const workspaceRules = loadWorkspaceRules(this.cwd);
+        const rulesSection = workspaceRules.found ? `\n${workspaceRules.formattedPrompt}\n` : '';
         const tierNotice = !this.isProOrEnterprise()
             ? `\nTIER RESTRICTION (FREE DEVELOPER TIER):
 - You are operating under the Free Developer Tier.
@@ -156,7 +161,7 @@ Current Year: ${new Date().getFullYear()}
 ${tierNotice}
 
 ${workspaceState}
-
+${rulesSection}
 Available Workspace Files (sample):
 ${filesList.join('\n')}
 
@@ -227,253 +232,333 @@ Action Rules:
         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 isPaid = this.isProOrEnterprise();
-            const stepSpinner = spinner();
-            const stepText = isPaid && !Number.isFinite(this.maxSteps)
-                ? `Scout Operating (Step ${step})`
-                : `Scout Operating (Step ${step}/${this.maxSteps})`;
-            stepSpinner.start(chalk.cyan(stepText));
-            try {
-                let response;
-                const mcpRouting = getMCPManager().routeTools(userGoal);
-                const mcpToolDefs = mcpRouting.tools.map((mt) => {
-                    let desc = mt.description;
-                    if (mt.originalName === 'execute_blender_code') {
-                        desc = 'Execute Python (bpy) code inside Blender. Use this to procedurally create, model, texture, color, and render 3D meshes, anime/game characters, clothing, hair, materials, cel-shading, lights, cameras, and scenes directly.';
-                    }
-                    else if (mt.originalName === 'generate_3d') {
-                        desc = 'Cloud AI text-to-3d generator (requires external API key). If keys are not set, use execute_blender_code to model directly.';
+        const interruptManager = new InterruptManager({
+            getStepInfo: () => ({
+                step: this.currentStep || 1,
+                maxSteps: this.maxSteps,
+                goal: userGoal,
+                modifiedFilesCount: this.modifiedFiles.size,
+            }),
+            onPause: () => {
+                this.workspace.setStatus('paused');
+            },
+            onResume: () => {
+                this.workspace.setStatus('running');
+            },
+            onFeedback: (feedback) => {
+                this.historyMessages.push({
+                    role: 'user',
+                    content: `[USER STEERING FEEDBACK (INTERRUPTED AT STEP ${this.currentStep})]:\n"${feedback}"\n\nPlease adapt your execution plan accordingly and follow these user steering instructions immediately.`,
+                });
+            },
+            onRevert: () => {
+                if (this.backups.length === 0)
+                    return false;
+                for (const b of this.backups) {
+                    try {
+                        fs.writeFileSync(b.filePath, b.originalContent, 'utf-8');
                     }
+                    catch { }
+                }
+                this.modifiedFiles.clear();
+                return true;
+            },
+            onAbort: (reason) => {
+                this.isCancelled = true;
+                this.cancelReason = reason;
+            },
+        });
+        interruptManager.attach();
+        try {
+            while (step < this.maxSteps) {
+                if (this.isCancelled) {
                     return {
-                        name: mt.originalName,
-                        description: `[MCP: ${mt.serverName}] ${desc.length > 250 ? desc.slice(0, 247) + '...' : desc}`,
-                        parameters: {
-                            type: 'object',
-                            properties: mt.inputSchema.properties || {},
-                            required: mt.inputSchema.required || [],
-                        },
-                        source: 'mcp',
-                        mcpServerId: mt.serverId,
-                        mcpServerName: mt.serverName,
+                        success: false,
+                        summary: `Task cancelled: ${this.cancelReason || 'User abort'}`,
+                        taskId,
+                        stepsTaken: step,
+                        modifiedFiles: Array.from(this.modifiedFiles),
+                        status: 'cancelled',
                     };
-                });
-                const goalLower = (userGoal || '').toLowerCase();
-                const needsBrowser = goalLower.includes('browser') || goalLower.includes('website') || goalLower.includes('webpage') || goalLower.includes('http') || goalLower.includes('url') || goalLower.includes('scrape') || goalLower.includes('chrome');
-                const needsComputer = goalLower.includes('computer') || goalLower.includes('desktop') || goalLower.includes('mouse') || goalLower.includes('coordinate') || goalLower.includes('drag') || goalLower.includes('double click');
-                let baseTools = this.toolRegistry.getToolsForTier(this.userTier);
-                if (mcpToolDefs.length > 0 && !needsBrowser && !needsComputer) {
-                    const ESSENTIAL_BASE_TOOLS = new Set(['read_file', 'write_file', 'edit_file', 'run_command', 'list_dir', 'grep_search', 'task_completed', 'ask_user', 'speak_text', 'scratchpad', 'computer_open_app']);
-                    baseTools = baseTools.filter((t) => ESSENTIAL_BASE_TOOLS.has(t.name));
                 }
-                else if (!needsBrowser) {
-                    baseTools = baseTools.filter((t) => !t.name.startsWith('browser_'));
+                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 tierTools = [...baseTools, ...mcpToolDefs];
+                const isPaid = this.isProOrEnterprise();
+                renderStepHeader({
+                    step,
+                    maxSteps: this.maxSteps,
+                    startTimeMs: this.workspace.getData().createdAt ? new Date(this.workspace.getData().createdAt).getTime() : Date.now(),
+                    tokensConsumed: 0,
+                    userTier: this.userTier,
+                });
+                const stepSpinner = spinner();
+                const stepText = isPaid && !Number.isFinite(this.maxSteps)
+                    ? `Scout Operating (Step ${step})`
+                    : `Scout Operating (Step ${step}/${this.maxSteps})`;
+                stepSpinner.start(chalk.cyan(stepText));
                 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(', ')}`,
+                    let response;
+                    const mcpRouting = getMCPManager().routeTools(userGoal);
+                    const mcpToolDefs = mcpRouting.tools.map((mt) => {
+                        let desc = mt.description;
+                        if (mt.originalName === 'execute_blender_code') {
+                            desc = 'Execute Python (bpy) code inside Blender. Use this to procedurally create, model, texture, color, and render 3D meshes, anime/game characters, clothing, hair, materials, cel-shading, lights, cameras, and scenes directly.';
+                        }
+                        else if (mt.originalName === 'generate_3d') {
+                            desc = 'Cloud AI text-to-3d generator (requires external API key). If keys are not set, use execute_blender_code to model directly.';
+                        }
+                        return {
+                            name: mt.originalName,
+                            description: `[MCP: ${mt.serverName}] ${desc.length > 250 ? desc.slice(0, 247) + '...' : desc}`,
+                            parameters: {
+                                type: 'object',
+                                properties: mt.inputSchema.properties || {},
+                                required: mt.inputSchema.required || [],
+                            },
+                            source: 'mcp',
+                            mcpServerId: mt.serverId,
+                            mcpServerName: mt.serverName,
                         };
+                    });
+                    const goalLower = (userGoal || '').toLowerCase();
+                    const needsBrowser = goalLower.includes('browser') || goalLower.includes('website') || goalLower.includes('webpage') || goalLower.includes('http') || goalLower.includes('url') || goalLower.includes('scrape') || goalLower.includes('chrome');
+                    const needsComputer = goalLower.includes('computer') || goalLower.includes('desktop') || goalLower.includes('mouse') || goalLower.includes('coordinate') || goalLower.includes('drag') || goalLower.includes('double click');
+                    let baseTools = this.toolRegistry.getToolsForTier(this.userTier);
+                    if (mcpToolDefs.length > 0 && !needsBrowser && !needsComputer) {
+                        const ESSENTIAL_BASE_TOOLS = new Set(['read_file', 'write_file', 'edit_file', 'run_command', 'list_dir', 'grep_search', 'task_completed', 'ask_user', 'speak_text', 'scratchpad', 'computer_open_app']);
+                        baseTools = baseTools.filter((t) => ESSENTIAL_BASE_TOOLS.has(t.name));
+                    }
+                    else if (!needsBrowser) {
+                        baseTools = baseTools.filter((t) => !t.name.startsWith('browser_'));
+                    }
+                    const tierTools = [...baseTools, ...mcpToolDefs];
+                    try {
                         response = await callOpenAIWithRetry(async (model) => {
                             return await openai.chat.completions.create({
                                 model,
-                                messages: sanitizeMessages([...this.historyMessages, fallbackMsg]),
+                                messages: sanitizeMessages(this.historyMessages),
+                                tools: tierTools.map((t) => ({ type: 'function', function: t })),
+                                tool_choice: 'auto',
                                 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 (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,
                                 });
-                            }
-                            catch {
-                                toolCallsToExecute.push({ name: tc.function.name, args: {}, id: tc.id });
-                            }
+                            });
+                        }
+                        else {
+                            throw err;
                         }
                     }
-                }
-                else if (msg.content) {
-                    const parsed = this.extractJsonToolCall(msg.content);
-                    if (parsed) {
-                        toolCallsToExecute.push({ name: parsed.tool, args: parsed.args });
+                    const choice = response.choices[0];
+                    if (!choice) {
+                        stepSpinner.stop(chalk.yellow('No response from model. Retrying step...'));
+                        continue;
                     }
-                }
-                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
-                    const rawContent = typeof toolResult.result === 'string' ? toolResult.result : JSON.stringify(toolResult.result);
-                    let cappedContent = rawContent;
-                    if (rawContent.length > 800) {
-                        try {
-                            const origBytes = Buffer.byteLength(rawContent, 'utf-8');
-                            const cdp = compress(Buffer.from(rawContent, 'utf-8'), LEVEL_FAST);
-                            const ratio = (origBytes / Math.max(1, cdp.length)).toFixed(1);
-                            cappedContent = rawContent.slice(0, 800) + `\n... [Codrop: ${origBytes}B compressed to ${cdp.length}B (${ratio}x ratio) for LLM context]`;
-                        }
-                        catch {
-                            cappedContent = rawContent.slice(0, 800) + '\n... [output truncated for token efficiency]';
-                        }
+                    const msg = sanitizeMessage(choice.message);
+                    this.historyMessages.push(msg);
+                    if (msg.content && msg.content.trim()) {
+                        renderThoughtBox(msg.content, step);
                     }
-                    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: cappedContent,
-                        });
+                    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 {
-                        // JSON-extracted tool call (no tc.id): use 'user' role
-                        this.historyMessages.push({
-                            role: 'user',
-                            content: `Tool Execution Result (${tc.name}):\n${cappedContent}`,
-                        });
+                    else if (msg.content) {
+                        const parsed = this.extractJsonToolCall(msg.content);
+                        if (parsed) {
+                            toolCallsToExecute.push({ name: parsed.tool, args: parsed.args });
+                        }
                     }
-                    // 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' } },
-                            ],
+                    stepSpinner.stop(chalk.green(`Step ${step}: Executing ${toolCallsToExecute.length} action(s).`));
+                    for (const tc of toolCallsToExecute) {
+                        if (this.isCancelled)
+                            break;
+                        renderToolCall({ name: tc.name, args: tc.args, step });
+                        const toolStartTime = Date.now();
+                        const toolResult = await this.dispatchTool(tc.name, tc.args);
+                        const durationMs = Date.now() - toolStartTime;
+                        renderToolResult({
+                            name: tc.name,
+                            args: tc.args,
+                            result: typeof toolResult.result === 'string' ? toolResult.result : JSON.stringify(toolResult.result),
+                            durationMs,
+                            success: !String(toolResult.result).includes('[PLAN RESTRICTION') && !String(toolResult.result).includes('[ACTION BLOCKED'),
                         });
-                    }
-                    // Automatic immediate completion for simple app actions (open/close/switch window)
-                    const simpleAppCheck = checkSimpleAppAction(userGoal);
-                    if (simpleAppCheck.isSimple && (tc.name === 'computer_open_app' || tc.name === 'computer_close_app' || tc.name === 'computer_switch_window')) {
-                        let callSucceeded = false;
-                        try {
-                            const parsed = typeof toolResult.result === 'string' ? JSON.parse(toolResult.result) : toolResult.result;
-                            callSucceeded = parsed?.success !== false;
+                        // Build the tool result message with correct role
+                        const rawContent = typeof toolResult.result === 'string' ? toolResult.result : JSON.stringify(toolResult.result);
+                        let cappedContent = rawContent;
+                        if (rawContent.length > 800) {
+                            try {
+                                const origBytes = Buffer.byteLength(rawContent, 'utf-8');
+                                const cdp = compress(Buffer.from(rawContent, 'utf-8'), LEVEL_FAST);
+                                const ratio = (origBytes / Math.max(1, cdp.length)).toFixed(1);
+                                cappedContent = rawContent.slice(0, 800) + `\n... [Codrop: ${origBytes}B compressed to ${cdp.length}B (${ratio}x ratio) for LLM context]`;
+                            }
+                            catch {
+                                cappedContent = rawContent.slice(0, 800) + '\n... [output truncated for token efficiency]';
+                            }
+                        }
+                        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: cappedContent,
+                            });
                         }
-                        catch {
-                            const str = String(toolResult.result || '').toLowerCase();
-                            callSucceeded = !str.includes('failed') && !str.includes('error');
+                        else {
+                            // JSON-extracted tool call (no tc.id): use 'user' role
+                            this.historyMessages.push({
+                                role: 'user',
+                                content: `Tool Execution Result (${tc.name}):\n${cappedContent}`,
+                            });
+                        }
+                        // 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 (callSucceeded) {
-                            const appName = simpleAppCheck.appName || 'application';
-                            const actionVerb = simpleAppCheck.action === 'close' ? 'closed' : (simpleAppCheck.action === 'switch' ? 'focused' : 'launched');
-                            finalSummary = `I've ${actionVerb} ${appName} for you. It's ready on your screen!`;
-                            safeNote(chalk.green(` ${finalSummary}`), 'Task Completed');
+                        // Automatic immediate completion for simple app actions (open/close/switch window)
+                        const simpleAppCheck = checkSimpleAppAction(userGoal);
+                        if (simpleAppCheck.isSimple && (tc.name === 'computer_open_app' || tc.name === 'computer_close_app' || tc.name === 'computer_switch_window')) {
+                            let callSucceeded = false;
+                            try {
+                                const parsed = typeof toolResult.result === 'string' ? JSON.parse(toolResult.result) : toolResult.result;
+                                callSucceeded = parsed?.success !== false;
+                            }
+                            catch {
+                                const str = String(toolResult.result || '').toLowerCase();
+                                callSucceeded = !str.includes('failed') && !str.includes('error');
+                            }
+                            if (callSucceeded) {
+                                const appName = simpleAppCheck.appName || 'application';
+                                const actionVerb = simpleAppCheck.action === 'close' ? 'closed' : (simpleAppCheck.action === 'switch' ? 'focused' : 'launched');
+                                finalSummary = `I've ${actionVerb} ${appName} for you. It's ready on your screen!`;
+                                renderTaskCompletedCard({
+                                    objective: userGoal,
+                                    summary: finalSummary,
+                                    modifiedFiles: [],
+                                    steps: step,
+                                    maxSteps: this.maxSteps,
+                                    totalTokens: 0,
+                                    totalToolCalls: step,
+                                    elapsedSecs: Math.round((Date.now() - (this.workspace.getData().createdAt ? new Date(this.workspace.getData().createdAt).getTime() : Date.now())) / 1000),
+                                    userTier: this.userTier,
+                                });
+                                this.workspace.setStatus('completed');
+                                this.workspace.completeStep(step, finalSummary);
+                                saveAgentSession({
+                                    goal: userGoal,
+                                    summary: finalSummary,
+                                    modifiedFiles: [],
+                                });
+                                return {
+                                    success: true,
+                                    summary: finalSummary,
+                                    taskId,
+                                    stepsTaken: step,
+                                    modifiedFiles: [],
+                                    status: 'completed',
+                                };
+                            }
+                        }
+                        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 });
+                            }
+                            renderTaskCompletedCard({
+                                objective: userGoal,
+                                summary: finalSummary,
+                                modifiedFiles: Array.from(this.modifiedFiles),
+                                steps: step,
+                                maxSteps: this.maxSteps,
+                                totalTokens: 0,
+                                totalToolCalls: step,
+                                elapsedSecs: Math.round((Date.now() - (this.workspace.getData().createdAt ? new Date(this.workspace.getData().createdAt).getTime() : Date.now())) / 1000),
+                                userTier: this.userTier,
+                            });
                             this.workspace.setStatus('completed');
                             this.workspace.completeStep(step, finalSummary);
                             saveAgentSession({
                                 goal: userGoal,
                                 summary: finalSummary,
-                                modifiedFiles: [],
+                                modifiedFiles: Array.from(this.modifiedFiles),
                             });
                             return {
                                 success: true,
                                 summary: finalSummary,
                                 taskId,
                                 stepsTaken: step,
-                                modifiedFiles: [],
+                                modifiedFiles: Array.from(this.modifiedFiles),
                                 status: 'completed',
                             };
                         }
                     }
-                    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.`,
+                    });
                 }
             }
-            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');
+            const isPaid = this.isProOrEnterprise();
+            return {
+                success: false,
+                summary: isPaid
+                    ? `Task ended after ${step} iteration steps. Modified files: ${Array.from(this.modifiedFiles).join(', ')}`
+                    : `Reached max iteration steps limit (${this.maxSteps}). Modified files: ${Array.from(this.modifiedFiles).join(', ')}`,
+                taskId,
+                stepsTaken: step,
+                modifiedFiles: Array.from(this.modifiedFiles),
+                status: 'failed',
+            };
+        }
+        finally {
+            interruptManager.detach();
         }
-        this.workspace.setStatus('failed');
-        const isPaid = this.isProOrEnterprise();
-        return {
-            success: false,
-            summary: isPaid
-                ? `Task ended after ${step} iteration steps. Modified files: ${Array.from(this.modifiedFiles).join(', ')}`
-                : `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);
@@ -608,6 +693,9 @@ Action Rules:
             else if (action === 'diagnostic') {
                 name = 'computer_diagnostic';
             }
+            else if (action === 'wait') {
+                name = 'computer_wait';
+            }
         }
         switch (name) {
             case 'computer_screenshot': {
@@ -879,6 +967,15 @@ Action Rules:
                 const diag = await this.computerController.runDiagnostic();
                 return { result: JSON.stringify(diag, null, 2) };
             }
+            case 'computer': {
+                return {
+                    result: JSON.stringify({
+                        success: false,
+                        error: 'InvalidComputerAction',
+                        message: `Unknown computer action: "${args?.action}". Supported actions: click, right_click, double_click, move, mouse_down, mouse_up, drag, scroll, screenshot, type, key_press, hotkey, open_app, close_app, switch_window, inspect_ui, diagnostic, wait.`
+                    }, null, 2)
+                };
+            }
             default:
                 return { result: `Unknown computer tool: "${name}"` };
         }
@@ -1234,8 +1331,7 @@ Action Rules:
             }
             case 'speak_text': {
                 const txt = String(args.text || '');
-                speakText(txt, { async: true });
-                return { result: `Spoke: "${txt}"` };
+                return { result: `[TTS DISABLED]: Text-to-speech audio synthesis has been disabled. Text displayed: "${txt}"` };
             }
             case 'task_completed': {
                 const summary = String(args.summary || 'Completed');
@@ -1254,7 +1350,6 @@ Action Rules:
                         };
                     }
                 }
-                speakText(summary, { async: true });
                 return { result: summary };
             }
             default: {