ft-scout 9.0.4 → 9.0.6

package/bin/src/engine/agentEngine.js

@@ -19,6 +19,7 @@ import { UnifiedToolRegistry } from './toolRegistry.js';
 import { SystemComputerController, MockComputerController } from './computer/index.js';
 import { AgentWorkspace, inferExecutionIntent, resolveDesktopPath } from './workspace/index.js';
 import { AgentRuntime } from './runtime/index.js';
+import { loadAuthConfig, isProOrHigher } from '../utils/auth.js';
 export { AgentRuntime, AgentWorkspace, inferExecutionIntent, resolveDesktopPath, SystemComputerController, MockComputerController };
 const execAsync = promisify(exec);
 export function robustSnippetReplace(origContent, target, replacement) {
@@ -372,11 +373,16 @@ export class AgentExecutionLoop {
     isCancelled = false;
     cancelReason;
     executionIntent;
+    userTier;
     constructor(options) {
         this.cwd = process.cwd();
         this.autoApprove = Boolean(options?.autoApprove);
-        this.maxSteps = options?.maxSteps || 30;
         this.mockMode = Boolean(options?.mockMode);
+        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);
         this.computerController = options?.computerController || (this.mockMode ? new MockComputerController() : new SystemComputerController(this.cwd));
         this.browserController = options?.browserController || new SemanticBrowserController(this.cwd);
@@ -385,6 +391,9 @@ export class AgentExecutionLoop {
         this.taskPlanner = new TaskPlanner();
         this.toolRegistry = new UnifiedToolRegistry();
     }
+    getUserTier() {
+        return this.userTier;
+    }
     getExecutionIntent() {
         return this.executionIntent;
     }
@@ -558,11 +567,27 @@ 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 tierDirective = isPaid ? `
+PLAN TIER & CAPABILITIES: ${this.userTier.toUpperCase()} (FULL ACCESS UNLOCKED)
+• 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.
+` : `
+PLAN TIER & CAPABILITIES: DEVELOPER FREE (BASIC DEVELOPER OPS ONLY)
+• Scratchpadding and Autonomous Multi-Step Desktop/Browser Control are RESTRICTED to Pro & Enterprise plans.
+• As a Free Tier developer assistant, you ONLY perform basic developer operations:
+  1. Code editing: use edit_file or multi_edit_file to modify existing code.
+  2. Creating new files & folders: use write_file to create new files and parent directories.
+  3. Running commands: use run_command to execute terminal commands, builds, or tests.
+  4. Reading & exploring: use read_file, list_dir, grep_search to inspect files.
+• Do NOT attempt to use scratchpad, computer, or browser tools. Execute the requested file edit, file creation, or command directly and call task_completed immediately.
+`;
         return `You are Scout Agent, an elite AI Principal Software Engineer & Autonomous Computer-Use Operator (developed by FrontTerrain).
 
 Working Directory: "${this.cwd}"
 Host OS Platform: "${process.platform}"
 Current Date & Time: "${new Date().toISOString()}" (Current Year: ${new Date().getFullYear()})
+${tierDirective}
 ${intentInfo}
 Workspace Overview (first 100 files):
 ${filesList.join('\n')}
@@ -611,7 +636,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
         }
         const structuredPlan = this.taskPlanner.createPlan(userGoal);
         this.taskStateManager.setPlan(structuredPlan.steps);
-        this.taskStateManager.setAvailableTools(this.toolRegistry.getAllTools().map((t) => t.name));
+        this.taskStateManager.setAvailableTools(this.toolRegistry.getToolsForTier(this.userTier).map((t) => t.name));
         if (this.mockMode) {
             for (let i = 1; i <= structuredPlan.steps.length; i++) {
                 this.taskStateManager.startStep(i);
@@ -766,7 +791,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                         return await openai.chat.completions.create({
                             model,
                             messages: sanitizeMessages(this.historyMessages),
-                            tools: this.toolRegistry.getAllTools().map((t) => ({ type: 'function', function: t })),
+                            tools: this.toolRegistry.getToolsForTier(this.userTier).map((t) => ({ type: 'function', function: t })),
                             tool_choice: 'auto',
                             temperature: 0.1,
                             presence_penalty: 0.1,
@@ -937,10 +962,17 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                     content: `Error in previous turn: ${err?.message || String(err)}. Please try alternative steps or call tools.`,
                 });
             }
-            // If current max steps limit is reached while task is still in progress, auto-extend by +15 extra steps (up to 60 max threshold)
-            if (step >= this.maxSteps && 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');
+            // 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) {
+                    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 {
@@ -967,7 +999,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',
+            'ask_user', 'speak_text', 'task_completed', 'scratchpad',
         ];
         for (const toolName of knownTools) {
             const tagRegex = new RegExp(`<${toolName}>([\\s\\S]*?)<\\/${toolName}>`, 'i');
@@ -1039,8 +1071,18 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             actionDesc = `Observing computer screen`;
         else if (name === 'computer_click')
             actionDesc = `Clicking screen coordinate: (${args.x}, ${args.y})`;
+        else if (name === 'computer_right_click')
+            actionDesc = `Right clicking coordinate: (${args.x}, ${args.y})`;
         else if (name === 'computer_double_click')
             actionDesc = `Double clicking coordinate: (${args.x}, ${args.y})`;
+        else if (name === 'computer_mouse_down')
+            actionDesc = `Mouse down (${args.button || 'left'})`;
+        else if (name === 'computer_mouse_up')
+            actionDesc = `Mouse up (${args.button || 'left'})`;
+        else if (name === 'computer_mouse_move')
+            actionDesc = `Moving mouse to: (${args.x}, ${args.y})`;
+        else if (name === 'computer_drag')
+            actionDesc = `Dragging from (${args.fromX ?? args.startX}, ${args.fromY ?? args.startY}) to (${args.toX ?? args.endX}, ${args.toY ?? args.endY})`;
         else if (name === 'computer_type')
             actionDesc = `Typing text: "${String(args.text || '').slice(0, 30)}"`;
         else if (name === 'computer_key_press')
@@ -1055,11 +1097,68 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             actionDesc = `Switching window: ${args.windowTitleOrApp || ''}`;
         else if (name === 'computer_inspect_ui')
             actionDesc = `Inspecting visible desktop UI`;
+        else if (name === 'computer_diagnostic')
+            actionDesc = `Running computer control diagnostics`;
+        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';
+        // 1. Scratchpad Feature Gating (Pro & Enterprise only)
+        if (name === 'scratchpad') {
+            if (!isPaid) {
+                const blockedMsg = `[PLAN RESTRICTION: PRO / ENTERPRISE ONLY] The Scratchpad reasoning memory is exclusive to Pro and Enterprise tiers. Free tier developers can perform basic code editing (edit_file), creating files and folders (write_file), and running commands (run_command). To unlock the AI scratchpad, upgrade at https://scout.frontterrain.com/plans or run 'scout dashboard'.`;
+                console.log(chalk.red.bold(`\n⛔ ${blockedMsg}`));
+                this.taskStateManager.addObservation(name, blockedMsg, false);
+                return { result: blockedMsg };
+            }
+            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');
+                this.taskStateManager.addObservation(name, `Scratchpad updated (${content.length} chars)`, true);
+                return { result: `Scratchpad updated successfully:\n${content}` };
+            }
+            else if (action === 'append') {
+                const updated = currentScratch ? `${currentScratch}\n\n---\n<!-- ${new Date().toISOString()} -->\n${content}` : content;
+                fs.writeFileSync(scratchPath, updated, 'utf-8');
+                this.taskStateManager.addObservation(name, `Appended to scratchpad (${content.length} chars)`, true);
+                return { result: `Appended to scratchpad. Current contents:\n${updated}` };
+            }
+            else if (action === 'clear') {
+                fs.writeFileSync(scratchPath, '', 'utf-8');
+                this.taskStateManager.addObservation(name, `Cleared scratchpad`, true);
+                return { result: `Scratchpad cleared.` };
+            }
+            else {
+                this.taskStateManager.addObservation(name, `Read scratchpad (${currentScratch.length} chars)`, true);
+                return { result: currentScratch ? `Scratchpad Contents:\n${currentScratch}` : `Scratchpad is currently empty.` };
+            }
+        }
+        // 2. Autonomous Computer & Browser Automation Gating (Pro & Enterprise only)
+        if (name === 'computer' || name.startsWith('computer_') || name.startsWith('browser_')) {
+            if (!isPaid) {
+                const blockedMsg = `[PLAN RESTRICTION: PRO / ENTERPRISE ONLY] Autonomous Computer-Use & Browser Automation features are exclusive to Pro and Enterprise tiers. Free tier developers can perform basic code editing (edit_file), creating files and folders (write_file), and running commands (run_command) in the workspace. Upgrade to Pro at https://scout.frontterrain.com/plans or run 'scout dashboard'.`;
+                console.log(chalk.red.bold(`\n⛔ ${blockedMsg}`));
+                this.taskStateManager.addObservation(name, blockedMsg, false);
+                return { result: blockedMsg };
+            }
+        }
         // Safety and human approval classification layer
         const risk = this.approvalManager.checkAction(name, args);
         if (risk.requiresApproval && !this.autoApprove) {
@@ -1099,6 +1198,82 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 }
             }
         }
+        if (name === 'computer') {
+            const action = String(args.action || 'screenshot').toLowerCase().trim();
+            if (action === 'click' || action === 'left_click') {
+                name = 'computer_click';
+            }
+            else if (action === 'right_click') {
+                name = 'computer_right_click';
+            }
+            else if (action === 'double_click') {
+                name = 'computer_double_click';
+            }
+            else if (action === 'move' || action === 'mouse_move') {
+                name = 'computer_mouse_move';
+            }
+            else if (action === 'mouse_down') {
+                name = 'computer_mouse_down';
+            }
+            else if (action === 'mouse_up') {
+                name = 'computer_mouse_up';
+            }
+            else if (action === 'drag') {
+                name = 'computer_drag';
+                args.fromX = args.startX ?? args.fromX;
+                args.fromY = args.startY ?? args.fromY;
+                args.toX = args.endX ?? args.toX;
+                args.toY = args.endY ?? args.toY;
+            }
+            else if (action === 'scroll') {
+                name = 'computer_scroll';
+            }
+            else if (action === 'screenshot') {
+                name = 'computer_screenshot';
+            }
+            else if (action === 'type') {
+                name = 'computer_type';
+            }
+            else if (action === 'key_press' || action === 'key') {
+                name = 'computer_key_press';
+            }
+            else if (action === 'hotkey') {
+                name = 'computer_hotkey';
+            }
+            else if (action === 'open_app') {
+                name = 'computer_open_app';
+            }
+            else if (action === 'close_app') {
+                name = 'computer_close_app';
+            }
+            else if (action === 'switch_window') {
+                name = 'computer_switch_window';
+            }
+            else if (action === 'inspect_ui') {
+                name = 'computer_inspect_ui';
+            }
+            else if (action === 'diagnostic') {
+                name = 'computer_diagnostic';
+            }
+        }
+        // Tier Gating Enforcement
+        if (!isPaid) {
+            if (name.startsWith('computer_') || name === 'computer') {
+                const upgradeMsg = `[PLAN RESTRICTION]: Autonomous Computer Control tools (${name}) are exclusively available to Pro and Enterprise plan developers. Free tier developers can perform code editing, creating files/folders, and running terminal commands. Upgrade to Pro at https://scout.frontterrain.com to unlock autonomous computer & app control.`;
+                this.taskStateManager.addObservation(name, upgradeMsg, false);
+                return { result: upgradeMsg };
+            }
+            if (name.startsWith('browser_')) {
+                const upgradeMsg = `[PLAN RESTRICTION]: Autonomous Browser Control tools (${name}) are exclusively available to Pro and Enterprise plan developers. Free tier developers can perform code editing, creating files/folders, and running terminal commands. Upgrade to Pro at https://scout.frontterrain.com to unlock browser automation.`;
+                this.taskStateManager.addObservation(name, upgradeMsg, false);
+                return { result: upgradeMsg };
+            }
+            if (name === 'scratchpad') {
+                const upgradeMsg = `[PLAN RESTRICTION]: AI Scratchpad & Autonomous reasoning is an exclusive feature for Pro and Enterprise plan subscribers. Free tier developers can perform code editing, creating files/folders, and running commands. Upgrade to Pro at https://scout.frontterrain.com to unlock the AI Scratchpad.`;
+                this.taskStateManager.addObservation(name, upgradeMsg, false);
+                return { result: upgradeMsg };
+            }
+        }
         switch (name) {
             case 'read_file': {
                 const targetPath = String(args.path || '').trim();
@@ -1559,6 +1734,54 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 this.taskStateManager.addObservation('browser_content', `Extracted content (${res.output.length} chars)`, res.success);
                 return { result: res.output };
             }
+            case 'browser_screenshot': {
+                const res = await this.browserController.screenshot();
+                this.taskStateManager.addObservation('browser_screenshot', res.output, res.success, res.url);
+                return { result: res.output };
+            }
+            case 'browser_select': {
+                const selector = String(args.selector || args.target || '');
+                const val = String(args.value || args.val || '');
+                const res = await this.browserController.select(selector, val);
+                this.taskStateManager.addObservation('browser_select', res.output, res.success, selector);
+                return { result: res.output };
+            }
+            case 'browser_scroll': {
+                const direction = (args.direction || 'down');
+                const amount = Number(args.amount) || 4;
+                const res = await this.browserController.scroll(direction, amount);
+                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) {
@@ -1580,11 +1803,31 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             case 'computer_click': {
                 const x = Number(args.x);
                 const y = Number(args.y);
-                const res = await this.computerController.click(x, y, { button: args.button });
+                const btn = args.button || 'left';
+                const res = await this.computerController.click(x, y, { button: btn, clicks: 1 });
                 this.taskStateManager.addObservation('computer_click', res.output, res.success, `(${x}, ${y})`);
                 const structuredRes = {
                     success: res.success,
                     action: 'click',
+                    coordinates: res.coordinates || { x, y },
+                    button: btn,
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    ...(res.activeWindow ? { activeWindow: res.activeWindow } : {}),
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_right_click': {
+                const x = Number(args.x);
+                const y = Number(args.y);
+                const res = await this.computerController.rightClick(x, y);
+                this.taskStateManager.addObservation('computer_right_click', res.output, res.success, `(${x}, ${y})`);
+                const structuredRes = {
+                    success: res.success,
+                    action: 'right_click',
+                    coordinates: res.coordinates || { x, y },
+                    button: 'right',
                     output: res.output,
                     ...(res.error ? { error: res.error } : {}),
                     recoverable: res.recoverable ?? true,
@@ -1600,6 +1843,42 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 const structuredRes = {
                     success: res.success,
                     action: 'double_click',
+                    coordinates: res.coordinates || { x, y },
+                    button: 'left',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_mouse_down': {
+                const x = args.x !== undefined ? Number(args.x) : undefined;
+                const y = args.y !== undefined ? Number(args.y) : undefined;
+                const btn = args.button || 'left';
+                const res = await this.computerController.mouseDown(x, y, btn);
+                this.taskStateManager.addObservation('computer_mouse_down', res.output, res.success);
+                const structuredRes = {
+                    success: res.success,
+                    action: 'mouse_down',
+                    coordinates: res.coordinates || (x !== undefined && y !== undefined ? { x, y } : undefined),
+                    button: btn,
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_mouse_up': {
+                const x = args.x !== undefined ? Number(args.x) : undefined;
+                const y = args.y !== undefined ? Number(args.y) : undefined;
+                const btn = args.button || 'left';
+                const res = await this.computerController.mouseUp(x, y, btn);
+                this.taskStateManager.addObservation('computer_mouse_up', res.output, res.success);
+                const structuredRes = {
+                    success: res.success,
+                    action: 'mouse_up',
+                    coordinates: res.coordinates || (x !== undefined && y !== undefined ? { x, y } : undefined),
+                    button: btn,
                     output: res.output,
                     ...(res.error ? { error: res.error } : {}),
                     recoverable: res.recoverable ?? true,
@@ -1658,14 +1937,41 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             case 'computer_mouse_move': {
                 const x = Number(args.x);
                 const y = Number(args.y);
-                const res = await this.computerController.mouseMove(x, y);
+                const res = await this.computerController.move(x, y);
                 this.taskStateManager.addObservation('computer_mouse_move', res.output, res.success);
-                return { result: res.output };
+                const structuredRes = {
+                    success: res.success,
+                    action: 'move',
+                    coordinates: res.coordinates || { x, y },
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    ...(res.activeWindow ? { activeWindow: res.activeWindow } : {}),
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
             }
             case 'computer_drag': {
-                const res = await this.computerController.drag(Number(args.fromX), Number(args.fromY), Number(args.toX), Number(args.toY));
+                const fromX = Number(args.fromX ?? args.startX ?? 0);
+                const fromY = Number(args.fromY ?? args.startY ?? 0);
+                const toX = Number(args.toX ?? args.endX ?? 0);
+                const toY = Number(args.toY ?? args.endY ?? 0);
+                const res = await this.computerController.drag(fromX, fromY, toX, toY);
                 this.taskStateManager.addObservation('computer_drag', res.output, res.success);
-                return { result: res.output };
+                const structuredRes = {
+                    success: res.success,
+                    action: 'drag',
+                    from: { x: fromX, y: fromY },
+                    to: { x: toX, y: toY },
+                    coordinates: res.coordinates || { x: toX, y: toY },
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_diagnostic': {
+                const diag = await this.computerController.runDiagnostic();
+                return { result: JSON.stringify(diag, null, 2) };
             }
             case 'computer_wait': {
                 const ms = Math.min(10000, Math.max(100, Number(args.ms) || 1000));