ft-scout 9.4.6 → 9.4.8

package/bin/src/engine/agentEngine.js

@@ -23,6 +23,10 @@ import { loadAuthConfig, isProOrHigher } from '../utils/auth.js';
 import { getMCPManager } from '../mcp/index.js';
 import { writeTelemetry } from '../utils/qrBridge.js';
 import { compress, LEVEL_FAST } from 'codrop';
+import { CheckpointManager } from './checkpoints/checkpointManager.js';
+import { renderStepHeader, renderThoughtBox, renderToolCall, renderToolResult, renderTaskCompletedCard, } from '../utils/claudeUI.js';
+import { loadWorkspaceRules } from '../utils/rules.js';
+import { InterruptManager } from '../utils/interruptHandler.js';
 export { AgentRuntime, AgentWorkspace, inferExecutionIntent, resolveDesktopPath, SystemComputerController, MockComputerController };
 const execAsync = promisify(exec);
 export function robustSnippetReplace(origContent, target, replacement) {
@@ -293,6 +297,29 @@ export const AGENT_TOOLS = [
             required: ['text'],
         },
     },
+    {
+        name: 'delegate_subtask',
+        description: 'Delegate a specialized subtask to an autonomous specialist subagent (architect, coder, tester, reviewer, general). Useful for delegating code reviews, test generation, architectural breakdowns, or isolated module implementations to an autonomous worker agent.',
+        parameters: {
+            type: 'object',
+            properties: {
+                role: {
+                    type: 'string',
+                    enum: ['architect', 'coder', 'tester', 'reviewer', 'general'],
+                    description: 'Specialist role for the subagent (architect, coder, tester, reviewer, general)',
+                },
+                task: {
+                    type: 'string',
+                    description: 'The specific subtask instruction or goal for the subagent to complete',
+                },
+                context: {
+                    type: 'string',
+                    description: 'Relevant file paths, error messages, or architectural context to provide to the subagent',
+                },
+            },
+            required: ['role', 'task'],
+        },
+    },
     {
         name: 'task_completed',
         description: 'Signal that the user goal has been fully completed with the full answer, results, and summary.',
@@ -383,6 +410,7 @@ export class AgentExecutionLoop {
     userTier;
     currentGoal = '';
     isAudioMode = false;
+    agentWorkspace;
     syncTelemetry(status, lastLog) {
         try {
             writeTelemetry({
@@ -403,11 +431,12 @@ export class AgentExecutionLoop {
         this.mockMode = Boolean(options?.mockMode);
         this.isAudioMode = Boolean(options?.isAudioMode);
         this.userTier = (options?.tier || loadAuthConfig().currentTier || 'free').toLowerCase();
-        // Free tier is bounded to basic direct actions (max 5 steps). Full autonomous multi-step loops require Pro/Enterprise.
-        const isPaid = this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
-        const requestedSteps = options?.maxSteps || 30;
-        this.maxSteps = isPaid ? requestedSteps : Math.min(requestedSteps, 5);
-        this.taskStateManager = new TaskStateManager(options?.taskId, '', this.cwd);
+        // 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 || isProOrHigher(this.userTier);
+        const requestedSteps = options?.maxSteps;
+        this.maxSteps = isPaid ? (requestedSteps || Infinity) : Math.min(requestedSteps || 5, 5);
+        this.agentWorkspace = new AgentWorkspace(options?.taskId, '', this.cwd);
+        this.taskStateManager = this.agentWorkspace.getStateManager();
         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);
@@ -418,6 +447,9 @@ export class AgentExecutionLoop {
     getUserTier() {
         return this.userTier;
     }
+    isPaidTier() {
+        return this.mockMode || isProOrHigher(this.userTier);
+    }
     getExecutionIntent() {
         return this.executionIntent;
     }
@@ -591,9 +623,10 @@ Task Execution Intent & Constraints:
 • Target Destination: ${this.executionIntent.targetDestination || 'Default'}
 • Target Artifact: ${this.executionIntent.targetArtifactName || 'None'}
 ` : '';
-        const isPaid = this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
+        const isPaid = this.isPaidTier();
         const tierDirective = isPaid ? `
 PLAN TIER & CAPABILITIES: ${this.userTier.toUpperCase()} (FULL ACCESS UNLOCKED)
+• Unlimited autonomous multi-step loops with no step limits.
 • Autonomous Computer-Use, Browser Automation, and AI Scratchpad Reasoning are fully ENABLED.
 • Use the 'scratchpad' tool to organize multi-step reasoning, break down complex goals, draft hypotheses, and track working memory across turns.
 ` : `
@@ -610,6 +643,8 @@ PLAN TIER & CAPABILITIES: DEVELOPER FREE (BASIC DEVELOPER OPS ONLY)
         const mcpCapabilitiesSection = mcpRouting.capabilitiesSummary ? `\n${mcpRouting.capabilitiesSummary}\n` : '';
         const recentSessionsMemory = getRecentSessionsSummary(1);
         const sessionHistorySection = recentSessionsMemory ? `\n${recentSessionsMemory}\n` : '';
+        const workspaceRules = loadWorkspaceRules(this.cwd);
+        const rulesSection = workspaceRules.found ? `\n${workspaceRules.formattedPrompt}\n` : '';
         return `You are Scout Agent, an elite AI Principal Software Engineer & Autonomous Computer-Use Operator (developed by FrontTerrain).
 
 Working Directory: "${this.cwd}"
@@ -619,6 +654,7 @@ ${tierDirective}
 ${intentInfo}
 ${mcpCapabilitiesSection}
 ${sessionHistorySection}
+${rulesSection}
 Workspace Overview (first 100 files):
 ${filesList.join('\n')}
 
@@ -710,6 +746,10 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
             };
         }
         this.historyMessages.push({ role: 'system', content: this.systemPrompt() });
+        const workspaceRules = loadWorkspaceRules(this.cwd);
+        if (workspaceRules.found) {
+            console.log(chalk.cyan(`📋 Loaded workspace rules from ${workspaceRules.fileName}`));
+        }
         // Robust Target File Discovery: Only run file discovery if the goal has explicit code editing/modification intent
         const simpleAppCheck = checkSimpleAppAction(userGoal);
         const lowerGoal = userGoal.toLowerCase().trim();
@@ -821,371 +861,448 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 content: promptContent,
             });
         }
-        const estTotalSecs = Math.round(this.maxSteps * 12);
-        const estTimeText = estTotalSecs >= 60 ? `~${(estTotalSecs / 60).toFixed(1)}m` : `~${estTotalSecs}s`;
-        console.log(chalk.gray(`Estimated completion time: ${estTimeText} (Max ${this.maxSteps} steps)`));
+        const isPaid = this.mockMode || isProOrHigher(this.userTier);
+        if (!isPaid && Number.isFinite(this.maxSteps)) {
+            const estTotalSecs = Math.round(this.maxSteps * 12);
+            const estTimeText = estTotalSecs >= 60 ? `~${(estTotalSecs / 60).toFixed(1)}m` : `~${estTotalSecs}s`;
+            console.log(chalk.gray(`Estimated completion time: ${estTimeText} (Free Tier Max ${this.maxSteps} steps)`));
+        }
+        else {
+            console.log(chalk.gray(`⚡ Autonomous execution loop: Unlimited steps active (${this.userTier.toUpperCase()} plan)`));
+        }
         let step = 0;
         let finalSummary = '';
         const stepDurations = [];
-        while (step < this.maxSteps) {
-            if (this.isCancelled) {
-                return {
-                    success: false,
-                    summary: `Task cancelled: ${this.cancelReason || 'User abort'}`,
-                };
-            }
-            step++;
-            this.currentStep = step;
-            this.taskStateManager.startStep(step);
-            const stepStartTime = Date.now();
-            const avgStepMs = stepDurations.length > 0
-                ? stepDurations.reduce((a, b) => a + b, 0) / stepDurations.length
-                : 12000;
-            const remainingSteps = (this.maxSteps - step + 1);
-            const estSecsLeft = Math.max(5, Math.round((remainingSteps * avgStepMs) / 1000));
-            const estLeftStr = estSecsLeft >= 60
-                ? `${Math.floor(estSecsLeft / 60)}m ${estSecsLeft % 60}s`
-                : `${estSecsLeft}s`;
-            const stepSpinner = spinner();
-            stepSpinner.start(chalk.cyan(`Scout is Working (Step ${step}/${this.maxSteps} • Est. completion: ~${estLeftStr} left)`));
-            try {
-                let response;
-                const mcpRouting = getMCPManager().routeTools(userGoal);
-                const mcpToolDefs = mcpRouting.tools.map((mt) => {
-                    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: this.currentGoal,
+                modifiedFilesCount: this.modifiedFiles.size,
+            }),
+            onPause: () => {
+                this.syncTelemetry('paused', `scout: execution paused by user at step ${this.currentStep}`);
+            },
+            onResume: () => {
+                this.syncTelemetry('running', `scout: execution resumed at step ${this.currentStep}`);
+            },
+            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 > 160 ? desc.slice(0, 157) + '...' : 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'}`,
                     };
+                }
+                step++;
+                this.currentStep = step;
+                this.taskStateManager.startStep(step);
+                // Context Compaction check: If history is long, compact middle turns using workspace state (including scratchpad working memory)
+                if (this.historyMessages.length > 10) {
+                    this.historyMessages = this.agentWorkspace.compactHistoryMessages(this.historyMessages, 6);
+                }
+                const stepStartTime = Date.now();
+                renderStepHeader({
+                    step,
+                    maxSteps: this.maxSteps,
+                    startTimeMs: this.startTime,
+                    tokensConsumed: this.totalTokensConsumed,
+                    userTier: this.userTier,
                 });
-                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));
+                const stepSpinner = spinner();
+                if (isPaid && !Number.isFinite(this.maxSteps)) {
+                    stepSpinner.start(chalk.cyan(`Scout is Working (Step ${step})`));
                 }
-                else if (!needsBrowser) {
-                    baseTools = baseTools.filter((t) => !t.name.startsWith('browser_'));
+                else {
+                    const avgStepMs = stepDurations.length > 0
+                        ? stepDurations.reduce((a, b) => a + b, 0) / stepDurations.length
+                        : 12000;
+                    const remainingSteps = (this.maxSteps - step + 1);
+                    const estSecsLeft = Math.max(5, Math.round((remainingSteps * avgStepMs) / 1000));
+                    const estLeftStr = estSecsLeft >= 60
+                        ? `${Math.floor(estSecsLeft / 60)}m ${estSecsLeft % 60}s`
+                        : `${estSecsLeft}s`;
+                    stepSpinner.start(chalk.cyan(`Scout is Working (Step ${step}/${this.maxSteps} • Est. completion: ~${estLeftStr} left)`));
                 }
-                const activeLoopTools = [...baseTools, ...mcpToolDefs];
                 try {
-                    response = await callOpenAIWithRetry(async (model) => {
-                        return await openai.chat.completions.create({
-                            model,
-                            messages: sanitizeMessages(this.historyMessages),
-                            tools: activeLoopTools.map((t) => ({ type: 'function', function: t })),
-                            tool_choice: 'auto',
-                            temperature: 0.1,
-                            presence_penalty: 0.1,
-                            frequency_penalty: 0.1,
-                        });
-                    });
-                }
-                catch (err) {
-                    const errStr = String(err?.message || err?.error || err || '').toLowerCase();
-                    if (errStr.includes('tool') || errStr.includes('400') || errStr.includes('not supported') || errStr.includes('reasoning')) {
-                        // Model doesn't support native function calling  inject tool-call formatting hint
-                        // so extractJsonToolCall can parse the response as a structured tool invocation
-                        const availableToolNames = activeLoopTools.map((t) => t.name).join(', ');
-                        const toolHintMsg = {
-                            role: 'user',
-                            content: `IMPORTANT: This model does not support native function/tool calling. You MUST format your tool invocations as a JSON code block in your response like this:
-\`\`\`json
-{ "tool": "tool_name", "args": { ... } }
-\`\`\`
-Available tools: ${availableToolNames}
-You MUST output exactly ONE JSON code block per tool call. Do NOT describe what you would do in plain text — output the JSON tool call directly!`,
+                    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 > 160 ? desc.slice(0, 157) + '...' : desc}`,
+                            parameters: {
+                                type: 'object',
+                                properties: mt.inputSchema.properties || {},
+                                required: mt.inputSchema.required || [],
+                            },
+                            source: 'mcp',
+                            mcpServerId: mt.serverId,
+                            mcpServerName: mt.serverName,
                         };
-                        const fallbackMessages = [...this.historyMessages, toolHintMsg];
+                    });
+                    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 activeLoopTools = [...baseTools, ...mcpToolDefs];
+                    try {
                         response = await callOpenAIWithRetry(async (model) => {
                             return await openai.chat.completions.create({
                                 model,
-                                messages: sanitizeMessages(fallbackMessages),
+                                messages: sanitizeMessages(this.historyMessages),
+                                tools: activeLoopTools.map((t) => ({ type: 'function', function: t })),
+                                tool_choice: 'auto',
                                 temperature: 0.1,
                                 presence_penalty: 0.1,
                                 frequency_penalty: 0.1,
                             });
                         });
                     }
-                    else {
-                        throw err;
-                    }
-                }
-                const choice = response.choices[0];
-                if (!choice) {
-                    stepSpinner.stop(chalk.yellow('No response from Scout. Retrying step...'));
-                    continue;
-                }
-                const msg = sanitizeMessage(choice.message);
-                const tokensThisTurn = response?.usage?.total_tokens || 0;
-                this.totalTokensConsumed += tokensThisTurn;
-                this.syncTelemetry('running', `scout: [step ${step}] generated reasoning (${tokensThisTurn} tokens)`);
-                this.historyMessages.push(msg);
-                // Render assistant's thought reasoning text if provided on this turn
-                const textContent = msg.content || '';
-                if (textContent.trim()) {
-                    safeNote(renderMarkdown(textContent), `Scout Thought (Step ${step})`);
-                    if (this.isAudioMode) {
-                        const speechText = cleanTextForSpeech(textContent);
-                        if (speechText) {
-                            speakText(speechText.length > 200 ? speechText.slice(0, 200) + '...' : speechText, { async: true });
+                    catch (err) {
+                        const errStr = String(err?.message || err?.error || err || '').toLowerCase();
+                        if (errStr.includes('tool') || errStr.includes('400') || errStr.includes('not supported') || errStr.includes('reasoning')) {
+                            // Model doesn't support native function calling  inject tool-call formatting hint
+                            // so extractJsonToolCall can parse the response as a structured tool invocation
+                            const availableToolNames = activeLoopTools.map((t) => t.name).join(', ');
+                            const toolHintMsg = {
+                                role: 'user',
+                                content: `IMPORTANT: This model does not support native function/tool calling. You MUST format your tool invocations as a JSON code block in your response like this:
+\`\`\`json
+{ "tool": "tool_name", "args": { ... } }
+\`\`\`
+Available tools: ${availableToolNames}
+You MUST output exactly ONE JSON code block per tool call. Do NOT describe what you would do in plain text — output the JSON tool call directly!`,
+                            };
+                            const fallbackMessages = [...this.historyMessages, toolHintMsg];
+                            response = await callOpenAIWithRetry(async (model) => {
+                                return await openai.chat.completions.create({
+                                    model,
+                                    messages: sanitizeMessages(fallbackMessages),
+                                    temperature: 0.1,
+                                    presence_penalty: 0.1,
+                                    frequency_penalty: 0.1,
+                                });
+                            });
+                        }
+                        else {
+                            throw err;
                         }
                     }
-                }
-                // Check native tool calls
-                if (msg.tool_calls && msg.tool_calls.length > 0) {
-                    stepSpinner.stop(chalk.green(`Step ${step}: Scout issued ${msg.tool_calls.length} tool call(s).`));
-                    for (const tc of msg.tool_calls) {
-                        if (tc.type === 'function' && tc.function) {
-                            const fnName = tc.function.name;
-                            let args = {};
-                            try {
-                                args = JSON.parse(tc.function.arguments || '{}');
-                            }
-                            catch { }
-                            if (this.isAudioMode && fnName !== 'task_completed') {
-                                let actionPhrase = '';
-                                if (fnName === 'run_command')
-                                    actionPhrase = `Running command ${args.command ? args.command.slice(0, 40) : ''}`;
-                                else if (fnName === 'read_file')
-                                    actionPhrase = `Reading ${path.basename(args.filePath || '')}`;
-                                else if (fnName === 'write_file')
-                                    actionPhrase = `Creating ${path.basename(args.filePath || '')}`;
-                                else if (fnName === 'edit_file')
-                                    actionPhrase = `Editing ${path.basename(args.filePath || '')}`;
-                                else if (fnName.startsWith('mcp_') || fnName.includes('github'))
-                                    actionPhrase = `Querying ${fnName}`;
-                                if (actionPhrase)
-                                    speakText(actionPhrase, { async: true });
-                            }
-                            const toolResult = await this.dispatchToolCall(fnName, args);
-                            this.totalToolCalls++;
-                            this.syncTelemetry('running', `scout: [step ${step}] executed tool ${fnName}`);
-                            const toolResStr = String(toolResult.result || '');
-                            let cappedResult = toolResStr;
-                            if (toolResStr.length > 800) {
+                    const choice = response.choices[0];
+                    if (!choice) {
+                        stepSpinner.stop(chalk.yellow('No response from Scout. Retrying step...'));
+                        continue;
+                    }
+                    const msg = sanitizeMessage(choice.message);
+                    const tokensThisTurn = response?.usage?.total_tokens || 0;
+                    this.totalTokensConsumed += tokensThisTurn;
+                    this.syncTelemetry('running', `scout: [step ${step}] generated reasoning (${tokensThisTurn} tokens)`);
+                    this.historyMessages.push(msg);
+                    // Render assistant's thought reasoning text if provided on this turn
+                    const textContent = msg.content || '';
+                    if (textContent.trim()) {
+                        renderThoughtBox(textContent, step);
+                    }
+                    // Check native tool calls
+                    if (msg.tool_calls && msg.tool_calls.length > 0) {
+                        stepSpinner.stop(chalk.green(`Step ${step}: Scout issued ${msg.tool_calls.length} tool call(s).`));
+                        for (const tc of msg.tool_calls) {
+                            if (tc.type === 'function' && tc.function) {
+                                const fnName = tc.function.name;
+                                let args = {};
                                 try {
-                                    const origBytes = Buffer.byteLength(toolResStr, 'utf-8');
-                                    const cdp = compress(Buffer.from(toolResStr, 'utf-8'), LEVEL_FAST);
-                                    const ratio = (origBytes / Math.max(1, cdp.length)).toFixed(1);
-                                    cappedResult = toolResStr.slice(0, 800) + `\n... [Codrop: ${origBytes}B compressed to ${cdp.length}B (${ratio}x ratio) for LLM context]`;
-                                    this.syncTelemetry('running', `scout: [codrop] compressed ${fnName} output (${ratio}x ratio)`);
+                                    args = JSON.parse(tc.function.arguments || '{}');
                                 }
-                                catch {
-                                    cappedResult = toolResStr.slice(0, 800) + '\n... [output truncated for token efficiency]';
-                                }
-                            }
-                            this.historyMessages.push({
-                                role: 'user',
-                                tool_call_id: tc.id,
-                                content: `Tool Execution Result (${fnName}):\n${cappedResult}`,
-                            });
-                            this.handleToolConsecutiveTracking(fnName, args, step);
-                            // Automatic immediate completion for simple app actions (open/close/switch window)
-                            if (simpleAppCheck.isSimple && (fnName === 'computer_open_app' || fnName === 'computer_close_app' || fnName === 'computer_switch_window')) {
-                                let callSucceeded = false;
-                                try {
-                                    const parsed = JSON.parse(toolResult.result);
-                                    callSucceeded = parsed.success !== false;
+                                catch { }
+                                const toolStartTime = Date.now();
+                                const toolResult = await this.dispatchToolCall(fnName, args);
+                                const durationMs = Date.now() - toolStartTime;
+                                renderToolResult({
+                                    name: fnName,
+                                    args,
+                                    result: toolResult.result,
+                                    durationMs,
+                                    success: !String(toolResult.result).startsWith('[PLAN RESTRICTION') && !String(toolResult.result).startsWith('[ACTION BLOCKED'),
+                                });
+                                this.totalToolCalls++;
+                                this.syncTelemetry('running', `scout: [step ${step}] executed tool ${fnName}`);
+                                const toolResStr = String(toolResult.result || '');
+                                let cappedResult = toolResStr;
+                                if (toolResStr.length > 800) {
+                                    try {
+                                        const origBytes = Buffer.byteLength(toolResStr, 'utf-8');
+                                        const cdp = compress(Buffer.from(toolResStr, 'utf-8'), LEVEL_FAST);
+                                        const ratio = (origBytes / Math.max(1, cdp.length)).toFixed(1);
+                                        cappedResult = toolResStr.slice(0, 800) + `\n... [Codrop: ${origBytes}B compressed to ${cdp.length}B (${ratio}x ratio) for LLM context]`;
+                                        this.syncTelemetry('running', `scout: [codrop] compressed ${fnName} output (${ratio}x ratio)`);
+                                    }
+                                    catch {
+                                        cappedResult = toolResStr.slice(0, 800) + '\n... [output truncated for token efficiency]';
+                                    }
                                 }
-                                catch {
-                                    callSucceeded = !toolResult.result.toLowerCase().includes('failed') && !toolResult.result.toLowerCase().includes('error');
+                                this.historyMessages.push({
+                                    role: 'user',
+                                    tool_call_id: tc.id,
+                                    content: `Tool Execution Result (${fnName}):\n${cappedResult}`,
+                                });
+                                this.handleToolConsecutiveTracking(fnName, args, step);
+                                // Automatic immediate completion for simple app actions (open/close/switch window)
+                                if (simpleAppCheck.isSimple && (fnName === 'computer_open_app' || fnName === 'computer_close_app' || fnName === 'computer_switch_window')) {
+                                    let callSucceeded = false;
+                                    try {
+                                        const parsed = JSON.parse(toolResult.result);
+                                        callSucceeded = parsed.success !== false;
+                                    }
+                                    catch {
+                                        callSucceeded = !toolResult.result.toLowerCase().includes('failed') && !toolResult.result.toLowerCase().includes('error');
+                                    }
+                                    if (callSucceeded) {
+                                        const appName = simpleAppCheck.appName || 'application';
+                                        const actionVerb = simpleAppCheck.action === 'close' ? 'closed' : (simpleAppCheck.action === 'switch' ? 'focused' : 'launched');
+                                        finalSummary = `I've ${actionVerb} ${appName} for you. It's ready on your screen!`;
+                                        renderTaskCompletedCard({
+                                            objective: userGoal,
+                                            summary: finalSummary,
+                                            modifiedFiles: [],
+                                            steps: step,
+                                            maxSteps: this.maxSteps,
+                                            totalTokens: this.totalTokensConsumed,
+                                            totalToolCalls: this.totalToolCalls,
+                                            elapsedSecs: Math.round((Date.now() - this.startTime) / 1000),
+                                            userTier: this.userTier,
+                                        });
+                                        saveAgentSession({
+                                            goal: userGoal,
+                                            summary: finalSummary,
+                                            modifiedFiles: [],
+                                        });
+                                        this.syncTelemetry('idle', `scout: completed task successfully (${this.modifiedFiles.size} files modified)`);
+                                        return { success: true, summary: finalSummary };
+                                    }
                                 }
-                                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');
+                                if (fnName === 'task_completed') {
+                                    finalSummary = args.summary || toolResult.result;
+                                    if (this.modifiedFiles.size > 0) {
+                                        const filesList = getDirectoryFiles(this.cwd);
+                                        const healRes = await verifyAndSelfHealFiles(Array.from(this.modifiedFiles), this.cwd, path.basename(this.cwd), filesList, { maxRetries: 3 });
+                                        if (healRes.verifiedFiles.length > 0) {
+                                            safeNote(chalk.green(` Self-Healing Verification Confirmed: ${healRes.verifiedFiles.length} file(s) syntax & build clean!`), ' Code Verification Clean');
+                                        }
+                                        if (healRes.remainingErrors.length > 0) {
+                                            safeNote(chalk.yellow(`️ Remaining verification issues:\n${healRes.remainingErrors.join('\n')}`), '️ Verification Warning');
+                                        }
+                                    }
+                                    renderTaskCompletedCard({
+                                        objective: userGoal,
+                                        summary: finalSummary,
+                                        modifiedFiles: Array.from(this.modifiedFiles),
+                                        steps: step,
+                                        maxSteps: this.maxSteps,
+                                        totalTokens: this.totalTokensConsumed,
+                                        totalToolCalls: this.totalToolCalls,
+                                        elapsedSecs: Math.round((Date.now() - this.startTime) / 1000),
+                                        userTier: this.userTier,
+                                    });
                                     saveAgentSession({
                                         goal: userGoal,
                                         summary: finalSummary,
-                                        modifiedFiles: [],
+                                        modifiedFiles: Array.from(this.modifiedFiles),
                                     });
-                                    this.syncTelemetry('idle', `scout: completed task successfully (${this.modifiedFiles.size} files modified)`);
                                     return { success: true, summary: finalSummary };
                                 }
                             }
-                            if (fnName === 'task_completed') {
-                                finalSummary = args.summary || toolResult.result;
-                                if (this.modifiedFiles.size > 0) {
-                                    const filesList = getDirectoryFiles(this.cwd);
-                                    const healRes = await verifyAndSelfHealFiles(Array.from(this.modifiedFiles), this.cwd, path.basename(this.cwd), filesList, { maxRetries: 3 });
-                                    if (healRes.verifiedFiles.length > 0) {
-                                        safeNote(chalk.green(` Self-Healing Verification Confirmed: ${healRes.verifiedFiles.length} file(s) syntax & build clean!`), ' Code Verification Clean');
-                                    }
-                                    if (healRes.remainingErrors.length > 0) {
-                                        safeNote(chalk.yellow(`️ Remaining verification issues:\n${healRes.remainingErrors.join('\n')}`), '️ Verification Warning');
-                                    }
-                                }
+                        }
+                        continue;
+                    }
+                    // Check text response or fallback JSON tool call
+                    stepSpinner.stop(chalk.blue(`Step ${step} thinking complete.`));
+                    const parsedJsonTool = this.extractJsonToolCall(textContent);
+                    if (parsedJsonTool) {
+                        const toolStartTime = Date.now();
+                        const toolResult = await this.dispatchToolCall(parsedJsonTool.tool, parsedJsonTool.args);
+                        const durationMs = Date.now() - toolStartTime;
+                        renderToolResult({
+                            name: parsedJsonTool.tool,
+                            args: parsedJsonTool.args,
+                            result: toolResult.result,
+                            durationMs,
+                            success: !String(toolResult.result).startsWith('[PLAN RESTRICTION') && !String(toolResult.result).startsWith('[ACTION BLOCKED'),
+                        });
+                        const jsonResStr = String(toolResult.result || '');
+                        let cappedJsonResult = jsonResStr;
+                        if (jsonResStr.length > 800) {
+                            try {
+                                const origBytes = Buffer.byteLength(jsonResStr, 'utf-8');
+                                const cdp = compress(Buffer.from(jsonResStr, 'utf-8'), LEVEL_FAST);
+                                const ratio = (origBytes / Math.max(1, cdp.length)).toFixed(1);
+                                cappedJsonResult = jsonResStr.slice(0, 800) + `\n... [Codrop: ${origBytes}B compressed to ${cdp.length}B (${ratio}x ratio) for LLM context]`;
+                            }
+                            catch {
+                                cappedJsonResult = jsonResStr.slice(0, 800) + '\n... [output truncated for token efficiency]';
+                            }
+                        }
+                        this.historyMessages.push({
+                            role: 'user',
+                            content: `Tool Execution Result (${parsedJsonTool.tool}):\n${cappedJsonResult}`,
+                        });
+                        this.handleToolConsecutiveTracking(parsedJsonTool.tool, parsedJsonTool.args, step);
+                        // Automatic immediate completion for simple app actions (open/close/switch window)
+                        if (simpleAppCheck.isSimple && (parsedJsonTool.tool === 'computer_open_app' || parsedJsonTool.tool === 'computer_close_app' || parsedJsonTool.tool === 'computer_switch_window')) {
+                            let callSucceeded = false;
+                            try {
+                                const parsed = JSON.parse(toolResult.result);
+                                callSucceeded = parsed.success !== false;
+                            }
+                            catch {
+                                callSucceeded = !toolResult.result.toLowerCase().includes('failed') && !toolResult.result.toLowerCase().includes('error');
+                            }
+                            if (callSucceeded) {
+                                const appName = simpleAppCheck.appName || 'application';
+                                const actionVerb = simpleAppCheck.action === 'close' ? 'closed' : (simpleAppCheck.action === 'switch' ? 'focused' : 'launched');
+                                finalSummary = `I've ${actionVerb} ${appName} for you. It's ready on your screen!`;
+                                safeNote(chalk.green(` ${finalSummary}`), 'Task Completed');
                                 saveAgentSession({
                                     goal: userGoal,
                                     summary: finalSummary,
-                                    modifiedFiles: Array.from(this.modifiedFiles),
+                                    modifiedFiles: [],
                                 });
                                 return { success: true, summary: finalSummary };
                             }
                         }
-                    }
-                    continue;
-                }
-                // Check text response or fallback JSON tool call
-                stepSpinner.stop(chalk.blue(`Step ${step} thinking complete.`));
-                const parsedJsonTool = this.extractJsonToolCall(textContent);
-                if (parsedJsonTool) {
-                    const toolResult = await this.dispatchToolCall(parsedJsonTool.tool, parsedJsonTool.args);
-                    const jsonResStr = String(toolResult.result || '');
-                    let cappedJsonResult = jsonResStr;
-                    if (jsonResStr.length > 800) {
-                        try {
-                            const origBytes = Buffer.byteLength(jsonResStr, 'utf-8');
-                            const cdp = compress(Buffer.from(jsonResStr, 'utf-8'), LEVEL_FAST);
-                            const ratio = (origBytes / Math.max(1, cdp.length)).toFixed(1);
-                            cappedJsonResult = jsonResStr.slice(0, 800) + `\n... [Codrop: ${origBytes}B compressed to ${cdp.length}B (${ratio}x ratio) for LLM context]`;
-                        }
-                        catch {
-                            cappedJsonResult = jsonResStr.slice(0, 800) + '\n... [output truncated for token efficiency]';
-                        }
-                    }
-                    this.historyMessages.push({
-                        role: 'user',
-                        content: `Tool Execution Result (${parsedJsonTool.tool}):\n${cappedJsonResult}`,
-                    });
-                    this.handleToolConsecutiveTracking(parsedJsonTool.tool, parsedJsonTool.args, step);
-                    // Automatic immediate completion for simple app actions (open/close/switch window)
-                    if (simpleAppCheck.isSimple && (parsedJsonTool.tool === 'computer_open_app' || parsedJsonTool.tool === 'computer_close_app' || parsedJsonTool.tool === 'computer_switch_window')) {
-                        let callSucceeded = false;
-                        try {
-                            const parsed = JSON.parse(toolResult.result);
-                            callSucceeded = parsed.success !== false;
-                        }
-                        catch {
-                            callSucceeded = !toolResult.result.toLowerCase().includes('failed') && !toolResult.result.toLowerCase().includes('error');
-                        }
-                        if (callSucceeded) {
-                            const appName = simpleAppCheck.appName || 'application';
-                            const actionVerb = simpleAppCheck.action === 'close' ? 'closed' : (simpleAppCheck.action === 'switch' ? 'focused' : 'launched');
-                            finalSummary = `I've ${actionVerb} ${appName} for you. It's ready on your screen!`;
-                            safeNote(chalk.green(` ${finalSummary}`), 'Task Completed');
+                        if (parsedJsonTool.tool === 'task_completed') {
+                            finalSummary = parsedJsonTool.args?.summary || toolResult.result;
                             saveAgentSession({
                                 goal: userGoal,
                                 summary: finalSummary,
-                                modifiedFiles: [],
+                                modifiedFiles: Array.from(this.modifiedFiles),
                             });
                             return { success: true, summary: finalSummary };
                         }
+                        continue;
                     }
-                    if (parsedJsonTool.tool === 'task_completed') {
-                        finalSummary = parsedJsonTool.args?.summary || toolResult.result;
-                        saveAgentSession({
-                            goal: userGoal,
-                            summary: finalSummary,
-                            modifiedFiles: Array.from(this.modifiedFiles),
-                        });
-                        return { success: true, summary: finalSummary };
+                    if (textContent.trim()) {
+                        let cleanedThought = textContent
+                            .replace(/[\u0600-\u06FF\u0750-\u077F\uAC00-\uD7AF\u3040-\u30FF\u4E00-\u9FFF\u0D80-\u0DFF]+/g, '')
+                            .trim();
+                        if (!cleanedThought || cleanedThought.length < 5) {
+                            cleanedThought = 'Analyzing codebase files and executing next tool operation...';
+                        }
+                        safeNote(renderMarkdown(cleanedThought), ` Scout Agent Thought (Step ${step})`);
+                        const lowerText = textContent.toLowerCase().trim();
+                        const isExplicitCompletion = lowerText.includes('task is complete') ||
+                            lowerText.includes('task complete') ||
+                            lowerText.includes('goal completed') ||
+                            lowerText.includes('goal is completed') ||
+                            lowerText.includes('all tasks completed') ||
+                            lowerText.includes('i have completed') ||
+                            lowerText.includes('no further changes needed') ||
+                            lowerText.includes('the fix is complete') ||
+                            lowerText.includes('has been created') ||
+                            lowerText.includes('successfully created') ||
+                            lowerText.includes('created the file') ||
+                            lowerText.includes('file created') ||
+                            lowerText.includes('implementation complete') ||
+                            lowerText.includes('setup is complete') ||
+                            lowerText.includes('setup complete') ||
+                            lowerText.includes('instructions have been executed') ||
+                            lowerText.includes('work is complete');
+                        const isIntermediateThought = /^(?:the\s+user\s+wants|i\s+will|i'll|let\s+me|i\s+need\s+to|i\s+am\s+going\s+to|first|starting|next|looking\s+at|checking|we\s+need\s+to|we\s+will)\b/i.test(lowerText);
+                        const hasActionDirective = /\b(execute|run|setup|set\s+up|install|configure|create|make|write|edit|modify|fix|update|refactor|build|delete|remove|patch|implement|apply|download|save|deploy)\b/i.test(userGoal);
+                        const isInformationalGoal = !hasActionDirective && (/^(?:lookup|look\s*up|check|find|who|what|why|where|how|tell|show|explain|display|list|search|query|status|info|describe)\b/i.test(userGoal.trim()) ||
+                            !/\b(create|make|write|edit|modify|fix|update|refactor|build|delete|remove|patch|implement|execute|run|setup|set\s+up|install)\b/i.test(userGoal.trim()));
+                        const isAnsweringInformational = !isIntermediateThought && isInformationalGoal && textContent.trim().length > 20 && !lowerText.includes('error occurred') && !lowerText.includes('cannot complete');
+                        const isSummaryAfterModifications = !isIntermediateThought && this.modifiedFiles.size > 0 && !lowerText.includes('?') && textContent.trim().length > 30;
+                        if (isExplicitCompletion || isAnsweringInformational || isSummaryAfterModifications) {
+                            saveAgentSession({
+                                goal: userGoal,
+                                summary: textContent,
+                                modifiedFiles: Array.from(this.modifiedFiles),
+                            });
+                            return { success: true, summary: textContent };
+                        }
                     }
-                    continue;
+                    // If assistant responded with text without calling tools, prompt it to execute tools to complete the goal
+                    this.historyMessages.push({
+                        role: 'user',
+                        content: 'You provided a text response but have not called any tools (write_file, edit_file, run_command, task_completed). Please execute necessary tool calls to complete the user goal, or invoke task_completed if finished.',
+                    });
+                    stepDurations.push(Date.now() - stepStartTime);
                 }
-                if (textContent.trim()) {
-                    let cleanedThought = textContent
-                        .replace(/[\u0600-\u06FF\u0750-\u077F\uAC00-\uD7AF\u3040-\u30FF\u4E00-\u9FFF\u0D80-\u0DFF]+/g, '')
-                        .trim();
-                    if (!cleanedThought || cleanedThought.length < 5) {
-                        cleanedThought = 'Analyzing codebase files and executing next tool operation...';
-                    }
-                    safeNote(renderMarkdown(cleanedThought), ` Scout Agent Thought (Step ${step})`);
-                    const lowerText = textContent.toLowerCase().trim();
-                    const isExplicitCompletion = lowerText.includes('task is complete') ||
-                        lowerText.includes('task complete') ||
-                        lowerText.includes('goal completed') ||
-                        lowerText.includes('goal is completed') ||
-                        lowerText.includes('all tasks completed') ||
-                        lowerText.includes('i have completed') ||
-                        lowerText.includes('no further changes needed') ||
-                        lowerText.includes('the fix is complete') ||
-                        lowerText.includes('has been created') ||
-                        lowerText.includes('successfully created') ||
-                        lowerText.includes('created the file') ||
-                        lowerText.includes('file created') ||
-                        lowerText.includes('implementation complete') ||
-                        lowerText.includes('setup is complete') ||
-                        lowerText.includes('setup complete') ||
-                        lowerText.includes('instructions have been executed') ||
-                        lowerText.includes('work is complete');
-                    const isIntermediateThought = /^(?:the\s+user\s+wants|i\s+will|i'll|let\s+me|i\s+need\s+to|i\s+am\s+going\s+to|first|starting|next|looking\s+at|checking|we\s+need\s+to|we\s+will)\b/i.test(lowerText);
-                    const hasActionDirective = /\b(execute|run|setup|set\s+up|install|configure|create|make|write|edit|modify|fix|update|refactor|build|delete|remove|patch|implement|apply|download|save|deploy)\b/i.test(userGoal);
-                    const isInformationalGoal = !hasActionDirective && (/^(?:lookup|look\s*up|check|find|who|what|why|where|how|tell|show|explain|display|list|search|query|status|info|describe)\b/i.test(userGoal.trim()) ||
-                        !/\b(create|make|write|edit|modify|fix|update|refactor|build|delete|remove|patch|implement|execute|run|setup|set\s+up|install)\b/i.test(userGoal.trim()));
-                    const isAnsweringInformational = !isIntermediateThought && isInformationalGoal && textContent.trim().length > 20 && !lowerText.includes('error occurred') && !lowerText.includes('cannot complete');
-                    const isSummaryAfterModifications = !isIntermediateThought && this.modifiedFiles.size > 0 && !lowerText.includes('?') && textContent.trim().length > 30;
-                    if (isExplicitCompletion || isAnsweringInformational || isSummaryAfterModifications) {
-                        saveAgentSession({
-                            goal: userGoal,
-                            summary: textContent,
-                            modifiedFiles: Array.from(this.modifiedFiles),
-                        });
-                        return { success: true, summary: textContent };
+                catch (err) {
+                    stepDurations.push(Date.now() - stepStartTime);
+                    if (isQuotaExceededError(err)) {
+                        stepSpinner.stop(chalk.red(`Oops! it\'s not you, it\'s us`));
+                        safeNote(`${chalk.bold.red(`Something went wrong in (Step ${step}), please try again in a moment`)}\n\n` +
+                            `${chalk.yellow('The configured AI provider has reached its API usage limit or rate cap.')}\n` +
+                            `${chalk.dim('This is separate from your Scout credit balance shown by `scout quota`.')}\n\n` +
+                            `${chalk.bold.cyan(' Please come back and try again in a few hours (or check back later today).')}\n\n` +
+                            `${chalk.dim('Scout Agent session has ended gracefully to protect remaining workflow.')}`, '️ API Quota Limit Reached');
+                        return {
+                            success: false,
+                            summary: 'Something went wrong, please try again in a moment.',
+                        };
                     }
+                    stepSpinner.stop(chalk.red(`Step ${step} execution error: ${err?.message || String(err)}`));
+                    this.historyMessages.push({
+                        role: 'user',
+                        content: `Error in previous turn: ${err?.message || String(err)}. Please try alternative steps or call tools.`,
+                    });
                 }
-                // If assistant responded with text without calling tools, prompt it to execute tools to complete the goal
-                this.historyMessages.push({
-                    role: 'user',
-                    content: 'You provided a text response but have not called any tools (write_file, edit_file, run_command, task_completed). Please execute necessary tool calls to complete the user goal, or invoke task_completed if finished.',
-                });
-                stepDurations.push(Date.now() - stepStartTime);
-            }
-            catch (err) {
-                stepDurations.push(Date.now() - stepStartTime);
-                if (isQuotaExceededError(err)) {
-                    stepSpinner.stop(chalk.red(`Oops! it\'s not you, it\'s us`));
-                    safeNote(`${chalk.bold.red(`Something went wrong in (Step ${step}), please try again in a moment`)}\n\n` +
-                        `${chalk.yellow('The configured AI provider has reached its API usage limit or rate cap.')}\n` +
-                        `${chalk.dim('This is separate from your Scout credit balance shown by `scout quota`.')}\n\n` +
-                        `${chalk.bold.cyan(' Please come back and try again in a few hours (or check back later today).')}\n\n` +
-                        `${chalk.dim('Scout Agent session has ended gracefully to protect remaining workflow.')}`, '️ API Quota Limit Reached');
-                    return {
-                        success: false,
-                        summary: 'Something went wrong, please try again in a moment.',
-                    };
-                }
-                stepSpinner.stop(chalk.red(`Step ${step} execution error: ${err?.message || String(err)}`));
-                this.historyMessages.push({
-                    role: 'user',
-                    content: `Error in previous turn: ${err?.message || String(err)}. Please try alternative steps or call tools.`,
-                });
-            }
-            // Step limit check: Auto-extend by +15 steps ONLY for Pro & Enterprise (up to 60 max threshold)
-            const isPaid = this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
-            if (step >= this.maxSteps) {
-                if (isPaid && this.maxSteps < 60) {
-                    this.maxSteps += 15;
-                    safeNote(chalk.bold.yellow(`⚡ Step limit reached while task is in progress. Automatically extending execution by +15 extra steps (New Max Limit: ${this.maxSteps})...`), ' Auto Extra Steps Extension');
-                }
-                else if (!isPaid) {
+                // Step limit check: Free tier only. Pro and Enterprise have unlimited steps.
+                if (!isPaid && step >= this.maxSteps) {
                     safeNote(chalk.bold.yellow(`⚡ Free Tier limit reached (${this.maxSteps} steps).\nFree developers can perform basic code editing, creating files/folders, and running commands.\nTo unlock unlimited autonomous multi-step loops and scratchpad reasoning, upgrade to Pro at https://scout.frontterrain.com/plans or run 'scout dashboard'.`), ' Free Tier Step Limit');
                     break;
                 }
             }
+            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(', ')}`,
+            };
+        }
+        finally {
+            interruptManager.detach();
         }
-        return {
-            success: false,
-            summary: `Reached max iteration steps limit (${this.maxSteps}). Modified files: ${Array.from(this.modifiedFiles).join(', ')}`,
-        };
     }
     extractJsonToolCall(content) {
         if (!content)
@@ -1206,7 +1323,7 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             'read_file', 'write_file', 'edit_file', 'run_command', 'list_dir',
             'grep_search', 'glob_search', 'tree_view', 'file_info', 'multi_edit_file',
             'fetch_url', 'git_diff',
-            'ask_user', 'speak_text', 'task_completed', 'scratchpad',
+            'ask_user', 'speak_text', 'delegate_subtask', 'task_completed', 'scratchpad',
         ];
         for (const toolName of knownTools) {
             const tagRegex = new RegExp(`<${toolName}>([\\s\\S]*?)<\\/${toolName}>`, 'i');
@@ -1306,16 +1423,16 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             actionDesc = `Inspecting visible desktop UI`;
         else if (name === 'computer_diagnostic')
             actionDesc = `Running computer control diagnostics`;
+        else if (name === 'delegate_subtask')
+            actionDesc = `Delegating subtask to [${args.role || 'subagent'}]: ${String(args.task || '').slice(0, 40)}`;
         else if (name === 'computer')
             actionDesc = `Computer action: ${args.action || 'action'}`;
         else if (name === 'scratchpad')
             actionDesc = `Scratchpad (${args.action || 'read'})`;
         else if (name === 'task_completed')
             actionDesc = `Task finished`;
-        const badge = chalk.bgCyan.black.bold(` 🛠️ TOOL: ${name} `);
-        const descText = actionDesc ? chalk.yellow.bold(` → ${actionDesc}`) : '';
-        console.log(`\n${badge}${descText} ${chalk.dim(JSON.stringify(args))}`);
-        const isPaid = this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
+        renderToolCall({ name, args, step: this.currentStep });
+        const isPaid = this.mockMode || isProOrHigher(this.userTier);
         // 1. Scratchpad Feature Gating (Pro & Enterprise only)
         if (name === 'scratchpad') {
             if (!isPaid) {
@@ -1326,41 +1443,25 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             }
             const action = String(args.action || 'read').toLowerCase().trim();
             const content = String(args.content || '');
-            const ftDir = path.join(this.cwd, '.ft');
-            const scratchPath = path.join(ftDir, 'scratchpad.md');
-            fs.mkdirSync(ftDir, { recursive: true });
-            let currentScratch = '';
-            if (fs.existsSync(scratchPath)) {
-                try {
-                    currentScratch = fs.readFileSync(scratchPath, 'utf-8');
-                }
-                catch { }
-            }
             if (action === 'write') {
-                fs.writeFileSync(scratchPath, content, 'utf-8');
-                try {
-                    fs.writeFileSync(path.join(ftDir, 'scratchpad.cdp'), compress(Buffer.from(content, 'utf-8'), LEVEL_FAST));
-                }
-                catch { }
+                this.agentWorkspace.setScratchpad(content);
                 this.taskStateManager.addObservation(name, `Scratchpad updated (${content.length} chars, Codrop .cdp archived)`, true);
                 return { result: `Scratchpad updated successfully:\n${content}` };
             }
             else if (action === 'append') {
+                const currentScratch = this.agentWorkspace.getScratchpad();
                 const updated = currentScratch ? `${currentScratch}\n\n---\n<!-- ${new Date().toISOString()} -->\n${content}` : content;
-                fs.writeFileSync(scratchPath, updated, 'utf-8');
-                try {
-                    fs.writeFileSync(path.join(ftDir, 'scratchpad.cdp'), compress(Buffer.from(updated, 'utf-8'), LEVEL_FAST));
-                }
-                catch { }
+                this.agentWorkspace.setScratchpad(updated);
                 this.taskStateManager.addObservation(name, `Appended to scratchpad (${content.length} chars, Codrop .cdp archived)`, true);
                 return { result: `Appended to scratchpad. Current contents:\n${updated}` };
             }
             else if (action === 'clear') {
-                fs.writeFileSync(scratchPath, '', 'utf-8');
+                this.agentWorkspace.clearScratchpad();
                 this.taskStateManager.addObservation(name, `Cleared scratchpad`, true);
                 return { result: `Scratchpad cleared.` };
             }
             else {
+                const currentScratch = this.agentWorkspace.getScratchpad();
                 this.taskStateManager.addObservation(name, `Read scratchpad (${currentScratch.length} chars)`, true);
                 return { result: currentScratch ? `Scratchpad Contents:\n${currentScratch}` : `Scratchpad is currently empty.` };
             }
@@ -1486,6 +1587,9 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             else if (action === 'diagnostic') {
                 name = 'computer_diagnostic';
             }
+            else if (action === 'wait') {
+                name = 'computer_wait';
+            }
         }
         // Tier Gating Enforcement
         if (!isPaid) {
@@ -1504,6 +1608,11 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 this.taskStateManager.addObservation(name, upgradeMsg, false);
                 return { result: upgradeMsg };
             }
+            if (name === 'delegate_subtask') {
+                const upgradeMsg = `[PLAN RESTRICTION]: Autonomous Multi-Agent Swarm Delegation is exclusively available to Pro and Enterprise plan subscribers. Free tier developers can perform code editing, creating files/folders, and running commands. Upgrade to Pro at https://scout.frontterrain.com to unlock autonomous subagents.`;
+                this.taskStateManager.addObservation(name, upgradeMsg, false);
+                return { result: upgradeMsg };
+            }
         }
         switch (name) {
             case 'read_file': {
@@ -1563,6 +1672,10 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                     this.backups.push({ filePath: targetPath, originalContent: '__FT_WAS_NEW__' });
                     fs.mkdirSync(path.dirname(fullPath), { recursive: true });
                 }
+                try {
+                    CheckpointManager.getInstance(this.cwd).createCheckpoint(`Step ${this.currentStep}: write_file ${targetPath}`, [targetPath], this.currentStep, this.taskStateManager.getCurrentState().taskId);
+                }
+                catch { }
                 fs.writeFileSync(fullPath, content, 'utf-8');
                 this.modifiedFiles.add(targetPath);
                 const oldLineCount = origContent !== '__FT_WAS_NEW__' ? origContent.split('\n').length : 0;
@@ -1618,6 +1731,10 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                     return { result: `Error editing "${targetPath}": ${replaceRes.error}` };
                 }
                 this.backups.push({ filePath: targetPath, originalContent: origContent });
+                try {
+                    CheckpointManager.getInstance(this.cwd).createCheckpoint(`Step ${this.currentStep}: edit_file ${targetPath}`, [targetPath], this.currentStep, this.taskStateManager.getCurrentState().taskId);
+                }
+                catch { }
                 fs.writeFileSync(fullPath, replaceRes.updatedContent, 'utf-8');
                 this.modifiedFiles.add(targetPath);
                 const targetLines = target.split('\n').length;
@@ -1877,11 +1994,7 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             }
             case 'speak_text': {
                 const phrase = String(args.text || args.phrase || '').trim();
-                if (phrase) {
-                    await speakText(phrase, { async: true });
-                    return { result: `Spoke text out loud: "${phrase}"` };
-                }
-                return { result: 'No text provided to speak.' };
+                return { result: `[TTS DISABLED]: Text-to-speech audio synthesis has been disabled. Text displayed: "${phrase}"` };
             }
             case 'browser_navigate': {
                 const targetUrl = String(args.url || '').trim();
@@ -1953,35 +2066,6 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 this.taskStateManager.addObservation('browser_scroll', res.output, res.success);
                 return { result: res.output };
             }
-            case 'scratchpad': {
-                const action = String(args.action || 'read').toLowerCase().trim();
-                const scratchpadPath = path.resolve(this.cwd, '.ft', 'scratchpad.md');
-                fs.mkdirSync(path.dirname(scratchpadPath), { recursive: true });
-                if (action === 'read') {
-                    const content = fs.existsSync(scratchpadPath) ? fs.readFileSync(scratchpadPath, 'utf-8') : '(Scratchpad is empty)';
-                    this.taskStateManager.addObservation('scratchpad', 'Read scratchpad content', true);
-                    return { result: `Scratchpad Content:\n${content || '(empty)'}` };
-                }
-                else if (action === 'write') {
-                    const newContent = String(args.content || '');
-                    fs.writeFileSync(scratchpadPath, newContent, 'utf-8');
-                    this.taskStateManager.addObservation('scratchpad', `Wrote scratchpad (${newContent.length} chars)`, true);
-                    return { result: `Scratchpad updated (${newContent.length} chars).` };
-                }
-                else if (action === 'append') {
-                    const appendContent = String(args.content || '');
-                    fs.appendFileSync(scratchpadPath, `\n${appendContent}`, 'utf-8');
-                    this.taskStateManager.addObservation('scratchpad', `Appended to scratchpad (${appendContent.length} chars)`, true);
-                    return { result: `Appended to scratchpad (${appendContent.length} chars).` };
-                }
-                else if (action === 'clear') {
-                    if (fs.existsSync(scratchpadPath))
-                        fs.unlinkSync(scratchpadPath);
-                    this.taskStateManager.addObservation('scratchpad', 'Cleared scratchpad', true);
-                    return { result: 'Scratchpad cleared.' };
-                }
-                return { result: `Unknown scratchpad action: "${action}". Supported: read, write, append, clear.` };
-            }
             case 'computer_screenshot': {
                 const res = await this.computerController.screenshot();
                 if (res.path) {
@@ -2244,6 +2328,39 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 };
                 return { result: JSON.stringify(structuredRes, 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)
+                };
+            }
+            case 'delegate_subtask': {
+                const role = (args.role || 'general');
+                const task = String(args.task || '').trim();
+                const context = args.context ? String(args.context) : undefined;
+                if (!task) {
+                    return { result: JSON.stringify({ success: false, error: 'No task specified for subagent delegation.' }) };
+                }
+                const { SubagentManager } = await import('./subagents/subagentManager.js');
+                const subagentMgr = SubagentManager.getInstance();
+                const subRes = await subagentMgr.delegate({
+                    role,
+                    task,
+                    context,
+                    cwd: this.cwd,
+                    tier: this.userTier,
+                });
+                if (subRes.modifiedFiles && subRes.modifiedFiles.length > 0) {
+                    for (const f of subRes.modifiedFiles) {
+                        this.modifiedFiles.add(f);
+                    }
+                }
+                this.taskStateManager.addObservation('delegate_subtask', `[Subagent ${role.toUpperCase()} Result]: ${subRes.summary}`, subRes.success);
+                return { result: JSON.stringify(subRes, null, 2) };
+            }
             case 'task_completed': {
                 const summaryStr = String(args.summary || 'Task completed successfully.');
                 if (this.executionIntent?.targetDestination === 'Desktop' && this.executionIntent?.targetArtifactName) {