ft-scout 9.0.2 → 9.0.4

package/bin/src/engine/agentEngine.js

@@ -9,16 +9,17 @@ import { saveAgentSession, getRecentSessionsSummary } from '../utils/session.js'
 import { safeNote, renderMarkdown } from '../utils/markdown.js';
 import { openai, callOpenAIWithRetry, isQuotaExceededError, sanitizeMessage, sanitizeMessages } from './llm.js';
 import { checkFileSyntax, verifyAndSelfHealFiles, executeSmartCommand, extractErrorDiagnostics } from './verifier.js';
-import { openApp, executeInApp, cleanupScreenshots } from './appControl.js';
 import { speakText, listenSpeechToText } from './voiceEngine.js';
-import { startLiveScreenShare, stopLiveScreenShare, isLiveScreenShareActive } from './liveScreenEngine.js';
 import { TaskStateManager } from './agentState.js';
-import { OSComputerController } from './computer/index.js';
 import { SemanticBrowserController } from './browser/index.js';
 import { ActionVerifier } from './actionVerifier.js';
 import { ApprovalManager, RiskClassifier } from './safety.js';
 import { TaskPlanner } from './planner.js';
 import { UnifiedToolRegistry } from './toolRegistry.js';
+import { SystemComputerController, MockComputerController } from './computer/index.js';
+import { AgentWorkspace, inferExecutionIntent, resolveDesktopPath } from './workspace/index.js';
+import { AgentRuntime } from './runtime/index.js';
+export { AgentRuntime, AgentWorkspace, inferExecutionIntent, resolveDesktopPath, SystemComputerController, MockComputerController };
 const execAsync = promisify(exec);
 export function robustSnippetReplace(origContent, target, replacement) {
     if (!origContent || !target) {
@@ -277,54 +278,6 @@ export const AGENT_TOOLS = [
             required: ['question'],
         },
     },
-    {
-        name: 'open_app',
-        description: 'Open, launch, or focus an external application (browser, terminal, editor, VS Code, Notepad, or custom app) as requested by user prompt.',
-        parameters: {
-            type: 'object',
-            properties: {
-                app: { type: 'string', description: 'Application name or executable (e.g. "browser", "chrome", "edge", "terminal", "powershell", "code", "vscode", "notepad", or path)' },
-                target: { type: 'string', description: 'Optional target URL (for browser), file/folder path (for editor), or initial command (for terminal)' },
-                reason: { type: 'string', description: 'Explanation of why this app is being launched and taken over' },
-            },
-            required: ['app'],
-        },
-    },
-    {
-        name: 'app_action',
-        description: 'Execute interactive desktop/browser scratchpad automation actions, live screen sharing with model, UI element clicking, screen takeover, mouse cursor positioning & click takeover, mouse scrolling, window management, keyboard keystrokes, hotkeys, focus locks, or command sequences without shell commands (e.g. action: "live_screen_share", "start_screen_share", "stop_screen_share", "live_screen_stream", "see_screen", "analyze_screen", "capture_screen", "click_element", "click_app", "scroll", "list_windows", "focus_window", "takeover", "move_mouse", "type_text", "send_keys", "key_combo", "lock_app", "fetch_page", "navigate", "search", "send_dm", "exec_command", "open_file"). All screen frames are streamed in-memory directly to the model with zero temporary files.',
-        parameters: {
-            type: 'object',
-            properties: {
-                app: { type: 'string', description: 'Target application name, window title, screen, or category ("browser", "terminal", "editor", "notepad", "chrome", "desktop")' },
-                action: { type: 'string', description: 'Action type ("live_screen_share", "start_screen_share", "stop_screen_share", "live_screen_stream", "see_screen", "analyze_screen", "capture_screen", "click_element", "click_app", "scroll", "list_windows", "focus_window", "takeover", "send_mail", "type_text", "move_mouse", "send_keys", "key_combo", "lock_app", "fetch_page", "search", "send_dm", "exec_command", "open_file")' },
-                payload: { description: 'Action details/payload object or string (e.g. element name/description to click { element: "Search Google" }, coordinates { x: 100, y: 200 }, scroll { direction: "down", amount: 4 }, text string, { text: "...", enter: true }, { keyCombo: "ctrl+v" }, { duration: 3000 }, URL, search query, command, or file path)' },
-            },
-            required: ['app', 'action'],
-        },
-    },
-    {
-        name: 'agent_scratchpad',
-        description: 'Update, read, or clear the agent working memory scratchpad, step checklist, and working notes for multi-step goals.',
-        parameters: {
-            type: 'object',
-            properties: {
-                action: { type: 'string', description: 'Action type ("update", "read", "clear")' },
-                plan: {
-                    type: 'array',
-                    description: 'List of step items in the goal execution plan',
-                    items: { type: 'string' },
-                },
-                completedSteps: {
-                    type: 'array',
-                    description: 'Indices of steps that are completed (0-based numbers)',
-                    items: { type: 'number' },
-                },
-                notes: { type: 'string', description: 'Working memory notes, findings, or scratchpad text' },
-            },
-            required: ['action'],
-        },
-    },
     {
         name: 'speak_text',
         description: 'Speak a text phrase out loud using Text-to-Speech (TTS) voice synthesis for voice feedback or audio summaries.',
@@ -400,7 +353,6 @@ export class AgentExecutionLoop {
     backups = [];
     autoApprove;
     maxSteps;
-    projectName;
     startTime = Date.now();
     totalToolCalls = 0;
     currentStep = 0;
@@ -409,48 +361,32 @@ export class AgentExecutionLoop {
     consecutiveCommands = 0;
     consecutiveScreenChecks = 0;
     toolCallHistory = [];
-    scratchpadState = { plan: [], completedSteps: [], notes: '' };
     taskStateManager;
-    computerController;
     browserController;
+    computerController;
     actionVerifier;
     approvalManager;
     taskPlanner;
     toolRegistry;
     mockMode;
+    isCancelled = false;
+    cancelReason;
+    executionIntent;
     constructor(options) {
         this.cwd = process.cwd();
         this.autoApprove = Boolean(options?.autoApprove);
         this.maxSteps = options?.maxSteps || 30;
-        this.projectName = options?.projectName || path.basename(this.cwd);
         this.mockMode = Boolean(options?.mockMode);
         this.taskStateManager = new TaskStateManager(options?.taskId, '', this.cwd);
-        this.computerController = options?.computerController || new OSComputerController();
+        this.computerController = options?.computerController || (this.mockMode ? new MockComputerController() : new SystemComputerController(this.cwd));
         this.browserController = options?.browserController || new SemanticBrowserController(this.cwd);
         this.actionVerifier = new ActionVerifier(this.cwd);
         this.approvalManager = new ApprovalManager(this.autoApprove);
         this.taskPlanner = new TaskPlanner();
         this.toolRegistry = new UnifiedToolRegistry();
-        if (options?.screenShare) {
-            startLiveScreenShare().catch(() => { });
-        }
-        // Ensure temporary screenshot cleanup and screen share stop on early exit or interrupt
-        const onExitOrInterrupt = () => {
-            try {
-                cleanupScreenshots();
-            }
-            catch { }
-            try {
-                if (isLiveScreenShareActive())
-                    stopLiveScreenShare();
-            }
-            catch { }
-        };
-        process.once('exit', onExitOrInterrupt);
-        process.once('SIGINT', () => {
-            onExitOrInterrupt();
-            process.exit(0);
-        });
+    }
+    getExecutionIntent() {
+        return this.executionIntent;
     }
     getTaskStateManager() {
         return this.taskStateManager;
@@ -458,12 +394,12 @@ export class AgentExecutionLoop {
     getStateManager() {
         return this.taskStateManager;
     }
-    getComputerController() {
-        return this.computerController;
-    }
     getBrowserController() {
         return this.browserController;
     }
+    getComputerController() {
+        return this.computerController;
+    }
     getActionVerifier() {
         return this.actionVerifier;
     }
@@ -476,6 +412,15 @@ export class AgentExecutionLoop {
     getToolRegistry() {
         return this.toolRegistry;
     }
+    cancel(reason = 'User cancelled task') {
+        this.isCancelled = true;
+        this.cancelReason = reason;
+        this.taskStateManager.setStatus('failed');
+        this.taskStateManager.recordError(`Task execution cancelled: ${reason}`, 'runtime');
+    }
+    isTaskCancelled() {
+        return this.isCancelled;
+    }
     async resumeGoal(taskId) {
         const saved = TaskStateManager.loadTaskState(taskId, this.cwd);
         if (!saved) {
@@ -517,92 +462,7 @@ export class AgentExecutionLoop {
         this.consecutiveCommands = 0;
         this.consecutiveScreenChecks = 0;
         this.toolCallHistory = [];
-        this.scratchpadState = { plan: [], completedSteps: [], notes: '' };
-    }
-    updateScratchpad(plan, completedSteps, notes) {
-        if (plan !== undefined)
-            this.scratchpadState.plan = plan;
-        if (completedSteps !== undefined)
-            this.scratchpadState.completedSteps = completedSteps;
-        if (notes !== undefined)
-            this.scratchpadState.notes = notes;
-        try {
-            const ftDir = path.join(this.cwd, '.ft');
-            if (!fs.existsSync(ftDir)) {
-                fs.mkdirSync(ftDir, { recursive: true });
-            }
-            const scratchpadPath = path.join(ftDir, 'scratchpad.md');
-            let mdContent = `# Scout Agent Scratchpad\n\n`;
-            if (this.scratchpadState.plan.length > 0) {
-                mdContent += `## Plan Checklist\n`;
-                this.scratchpadState.plan.forEach((item, idx) => {
-                    const isDone = this.scratchpadState.completedSteps.includes(idx);
-                    mdContent += `- [${isDone ? 'x' : ' '}] Step ${idx + 1}: ${item}\n`;
-                });
-                mdContent += `\n`;
-            }
-            if (this.scratchpadState.notes) {
-                mdContent += `## Working Memory & Notes\n${this.scratchpadState.notes}\n`;
-            }
-            fs.writeFileSync(scratchpadPath, mdContent, 'utf-8');
-        }
-        catch {
-            // Ignore write errors to prevent breaking execution
-        }
-        let summary = 'Agent Scratchpad updated successfully.\n';
-        if (this.scratchpadState.plan.length > 0) {
-            summary += `Plan (${this.scratchpadState.plan.length} items):\n` +
-                this.scratchpadState.plan.map((item, idx) => `  ${this.scratchpadState.completedSteps.includes(idx) ? '[✓]' : '[ ]'} Step ${idx + 1}: ${item}`).join('\n') + '\n';
-        }
-        if (this.scratchpadState.notes) {
-            summary += `Notes: ${this.scratchpadState.notes}`;
-        }
-        return summary;
-    }
-    autoSyncScratchpadFromText(text) {
-        try {
-            const planLines = text.match(/[-*]\s*\[([ xX✓/])\]\s*(.*)/g);
-            if (planLines && planLines.length > 0) {
-                const plan = [];
-                const completed = [];
-                planLines.forEach((l, idx) => {
-                    const isDone = l.includes('[x]') || l.includes('[X]') || l.includes('[✓]');
-                    const cleanText = l.replace(/^[-*]\s*\[[ xX✓/]\]\s*/, '').trim();
-                    plan.push(cleanText);
-                    if (isDone)
-                        completed.push(idx);
-                });
-                this.scratchpadState.plan = plan;
-                this.scratchpadState.completedSteps = completed;
-            }
-            const obsMatch = text.match(/Observations?:\s*([^\n]+(?:\n[^\n]+)*)/i);
-            const thoughtMatch = text.match(/Thought:\s*([^\n]+(?:\n[^\n]+)*)/i);
-            const notes = [
-                thoughtMatch ? `Thought: ${thoughtMatch[1]?.trim()}` : '',
-                obsMatch ? `Observations: ${obsMatch[1]?.trim()}` : '',
-            ].filter(Boolean).join('\n\n');
-            if (notes) {
-                this.scratchpadState.notes = notes;
-            }
-            const ftDir = path.join(this.cwd, '.ft');
-            if (!fs.existsSync(ftDir))
-                fs.mkdirSync(ftDir, { recursive: true });
-            const scratchpadPath = path.join(ftDir, 'scratchpad.md');
-            let mdContent = `# Scout Agent Scratchpad & Working Memory\n\n`;
-            if (this.scratchpadState.plan.length > 0) {
-                mdContent += `## Plan Checklist\n`;
-                this.scratchpadState.plan.forEach((item, idx) => {
-                    const isDone = this.scratchpadState.completedSteps.includes(idx);
-                    mdContent += `- [${isDone ? 'x' : ' '}] Step ${idx + 1}: ${item}\n`;
-                });
-                mdContent += `\n`;
-            }
-            if (this.scratchpadState.notes) {
-                mdContent += `## Working Memory & Observations\n${this.scratchpadState.notes}\n`;
-            }
-            fs.writeFileSync(scratchpadPath, mdContent, 'utf-8');
-        }
-        catch { }
+        this.executionIntent = undefined;
     }
     handleToolConsecutiveTracking(fnName, args, step) {
         const argsKey = JSON.stringify(args || {});
@@ -661,9 +521,12 @@ export class AgentExecutionLoop {
             this.consecutiveReads++;
             this.consecutiveCommands = 0;
             if (this.consecutiveReads >= 2) {
+                const actionHint = this.executionIntent?.requiredInteraction === 'computer'
+                    ? `Take action in the requested application (${this.executionIntent.requiredApplications.join(', ') || 'Notepad'})! Use computer_type, computer_click, or computer_hotkey now.`
+                    : `You MUST execute write_file or edit_file on this step to write or modify code and satisfy the user goal.`;
                 this.historyMessages.push({
                     role: 'user',
-                    content: `URGENT ACTION MANDATE (Step ${step}): You have issued ${this.consecutiveReads} exploration tool calls in a row without making any code changes! STOP READING FILES NOW. You MUST execute write_file or edit_file on this step to write or modify code and satisfy the user goal.`,
+                    content: `URGENT ACTION MANDATE (Step ${step}): You have issued ${this.consecutiveReads} exploration tool calls in a row without making progress! ${actionHint}`,
                 });
             }
         }
@@ -671,9 +534,12 @@ export class AgentExecutionLoop {
             this.consecutiveReads = 0;
             this.consecutiveCommands++;
             if (this.consecutiveCommands >= 2) {
+                const actionHint = this.executionIntent?.requiredInteraction === 'computer'
+                    ? `Continue with computer interaction tools (computer_type, computer_hotkey) in the target application.`
+                    : `Call 'write_file' or 'edit_file' NOW to write the required source code and files directly to disk!`;
                 this.historyMessages.push({
                     role: 'user',
-                    content: `URGENT ACTION MANDATE (Step ${step}): You have executed ${this.consecutiveCommands} shell commands in a row without creating or editing any files! STOP running shell commands. Call 'write_file' or 'edit_file' NOW to write the required source code and files directly to disk!`,
+                    content: `URGENT ACTION MANDATE (Step ${step}): You have executed ${this.consecutiveCommands} shell commands in a row without progress! ${actionHint}`,
                 });
             }
         }
@@ -684,115 +550,65 @@ export class AgentExecutionLoop {
     }
     systemPrompt() {
         const filesList = getDirectoryFiles(this.cwd).slice(0, 100);
-        return `You are Scout Agent, an elite AI Principal Software Engineer & Autonomous Coding Assistant (built like Antigravity & Claude Code).
+        const intentInfo = this.executionIntent ? `
+Task Execution Intent & Constraints:
+• Required Applications: ${this.executionIntent.requiredApplications.length > 0 ? this.executionIntent.requiredApplications.join(', ') : 'None specified'}
+• Required Interaction Type: ${this.executionIntent.requiredInteraction}
+• Allow Alternative Tools (e.g. direct filesystem): ${this.executionIntent.allowAlternativeTools ? 'YES' : 'NO (STRICT)'}
+• Target Destination: ${this.executionIntent.targetDestination || 'Default'}
+• Target Artifact: ${this.executionIntent.targetArtifactName || 'None'}
+` : '';
+        return `You are Scout Agent, an elite AI Principal Software Engineer & Autonomous Computer-Use Operator (developed by FrontTerrain).
 
-Project Name: "${this.projectName}"
 Working Directory: "${this.cwd}"
 Host OS Platform: "${process.platform}"
 Current Date & Time: "${new Date().toISOString()}" (Current Year: ${new Date().getFullYear()})
-
+${intentInfo}
 Workspace Overview (first 100 files):
 ${filesList.join('\n')}
 
-Core Directives & Behavioral Guidelines:
-1. REAL-TIME DATE AWARENESS: You are aware of real-time date and time (${new Date().getFullYear()}). Always use the current year (${new Date().getFullYear()}) and date for web searches, documentation, commit messages, and references. NEVER hardcode obsolete past years like 2024.
-2. HIGH AGENCY & AUTONOMY: You act autonomously through step-by-step tool invocation to solve complex coding tasks, debug issues, build features, create projects from scratch, or answer architectural questions.
-3. MULTILINGUAL & INTENT COMPREHENSION: Understand user intent in any language (English, Hinglish like "likho", "bnao", "code karo", "fix karo", "samjha do", Hindi, Spanish, etc.).
-3. AUTONOMOUS TARGET FILE DISCOVERY: You have full autonomy to locate, inspect, and modify target workspace files. When given a goal without an explicit file path, use auto-discovered target files, \`grep_search\`, or \`glob_search\` to locate relevant code before editing.
-4. ACTION-FIRST & DIRECT EXECUTION PRIORITY: When given a goal to fix, edit, modify, or create files, TAKE CODE MODIFICATION ACTIONS (\`write_file\`, \`edit_file\`, or \`run_command\`) IMMEDIATELY within the first 1-3 steps! DO NOT waste multiple steps reading unrelated asset files, sound generators, raw text files, init files, or requirements files unless specifically requested by the user.
-5. PRE-LOADED CONTEXT RULE: If target files or auto-discovered files are already previewed in your context window history, DO NOT call \`read_file\` or \`list_dir\` on them again! Proceed directly to writing/editing code.
-6. COMPLETE FILE CREATION & EDITING: Whenever asked to write, edit, create, implement, or fix code, YOU MUST CREATE / MODIFY ALL NECESSARY FILES required to completely fulfill the prompt (e.g. main source files, component files, styles, configs, tests, documentation). CALL \`write_file\` or \`edit_file\` for EVERY necessary file to save changes directly to disk in the workspace! Always provide a clear \`reason\` argument for why the edit is made.
-7. RUN & VERIFY COMMANDS: Execute shell commands, tests, builds, and formatters using \`run_command\`. If a command or build fails, read the full error log, diagnose the root cause, and auto-fix the failing code immediately.
-8. NO CODE TRUNCATION OR PLACEHOLDERS: Maintain 100% code integrity. NEVER replace existing code or HTML tags with placeholder comments (e.g. \`<!-- remaining content -->\` or \`// TODO: rest of code\`) or stripped skeleton structures. Always output complete, functional code.
-9. REFORMATTING MINIFIED / LARGE FILES: When asked to format, beautify, or un-minify HTML, JS, CSS, or JSON files, DO NOT attempt to rewrite the file content manually using \`write_file\` or \`edit_file\` (which causes token truncation and content loss). ALWAYS use \`run_command\` to execute CLI formatters (e.g. \`npx prettier --write <file>\`, \`npx html-beautify -r <file>\`, \`npx js-beautify <file>\`, or run a quick Node script) to reformat files in-place on disk.
-10. FROM-SCRATCH PROJECT CREATION & AUTOMATED TESTING PROTOCOL: When asked to build/create a project from scratch:
- a. Scaffold Architecture: Create configuration/manifest files (\`package.json\`, \`tsconfig.json\`, \`pyproject.toml\`, etc.) and folder structure using \`write_file\` or \`run_command\`.
- b. Write Source Implementation: Create all necessary source files with fully functional, complete, production-ready code (no skeleton placeholders or TODOs).
- c. Write Automated Tests: Create comprehensive unit/integration test suite files (e.g. \`test/*.test.ts\`, \`tests/test_*.py\`, etc.).
- d. Execute Tests & Build Verification: Run test suites and builds via \`run_command\` (e.g. \`npm test\`, \`npx vitest run\`, \`pytest\`, \`cargo test\`, \`go test ./...\`).
- e. Self-Heal & Pass: If tests or builds fail, inspect output logs, edit files using \`edit_file\` or \`write_file\` to resolve errors, re-run tests until 100% passing, and only call \`task_completed\` when all checks pass cleanly.
-11. CRITICAL TERMINATION RULE: As soon as you have finished creating/modifying the necessary files, running verification checks, or answering the user request, YOU MUST CALL \`task_completed\` tool immediately with a clear summary of your work.
-12. PRODUCTION-GRADE CODE QUALITY: Every line of code you write or edit MUST be clean, elegant, modular, production-ready, highly readable, self-documenting, formatted, and strictly typed.
-13. HIGH AUTONOMY & NO DOUBLE PROMPTING: NEVER call \`ask_user\` to ask what code to write, what features to implement, or to re-confirm the prompt. Take immediate autonomous action using \`write_file\`, \`edit_file\`, \`run_command\`, \`read_file\`, or \`grep_search\` using best software engineering practices. ONLY call \`ask_user\` if a critical secret credential (API key/password) is strictly required.
-14. EDITING & DEBUGGING MASTERY PROTOCOL:
- a. Full Context Reading: When editing or fixing bugs in existing files, inspect full code context. For files under 250 lines, reference the complete file content before modifying.
- b. Guaranteed Edit Success: Use \`edit_file\` for precise snippet updates. If \`edit_file\` returns a target snippet mismatch error, IMMEDIATELY call \`write_file\` with the complete corrected file code so the edit is 100% applied without getting stuck!
- c. Automated Error Diagnostics: After editing, check compiler/syntax outputs and test runner logs. If an error is detected, auto-heal the code immediately before concluding.
-15. THOUGHT TRANSPARENCY PROTOCOL: In EVERY step before calling any tools or ending a turn, you MUST provide a clear 1-2 sentence explanation in your text response describing your current reasoning, what file/action you are taking, and why you are taking it.
-16. OS-COMPATIBLE SHELL COMMANDS: Always ensure shell commands passed to \`run_command\` are compatible with the host OS ("${process.platform}"). On Windows (\`win32\`), do NOT use Linux-only builtins like \`touch\`, \`rm -rf\`, \`cat\`, or \`ls -la\` directly. Use \`write_file\` to create files, standard \`npm\`/\`npx\`/\`node\`/\`git\`/\`python\` commands, or PowerShell syntax.
-17. STRICT USER INSTRUCTION & DIRECTIVE ALIGNMENT: You MUST strictly follow all exact user instructions, quantitative constraints, file paths, feature requirements, and architectural preferences specified in the user prompt. Execute the request step-by-step with zero deviation or hallucinated shortcuts, ensuring complete implementation within the allowed step limit.
-18. DIRECT FILE CREATION VIA write_file ONLY (NO SHELL COMMANDS): Do NOT use \`run_command\` with \`touch\`, \`mkdir\`, \`echo > file\`, \`cat > file\`, or shell scripts to create files or folders! ALWAYS call \`write_file\` or \`edit_file\` directly to write source code to disk. The \`write_file\` tool automatically creates all necessary parent directories in one step.
-19. EXTERNAL APP TAKEOVER & CONTROL PROTOCOL: When requested by user prompt to open, take over, or work inside external applications (browser, terminal, VS Code, Notepad, social apps like Instagram, WhatsApp, Twitter/X, Telegram, or custom apps):
- a. Launch App: Use \`open_app\` to launch or focus the target application with optional URL, file path, or initial script.
- b. Social DM & Messaging Automation: For Instagram, WhatsApp, Twitter/X, or Telegram messaging requests (e.g. "open instagram and send message to @user"), immediately invoke \`app_action\` with action "send_dm" or "open_dm" (or \`open_app\`) specifying the target username/phone and message text so the agent automatically opens the direct messaging link in the browser!
- c. Email & Gmail Automation: When requested to send or compose an email (e.g. "send mail to frontterrain@gmail.com saying...", "takeover mail.google.com and send mail"):
-    - Immediately invoke \`app_action\` with \`action: "send_mail"\` (or \`action: "send_dm"\`) specifying the target recipient email and body text. The agent automatically constructs the direct Gmail compose URL (\`https://mail.google.com/mail/?view=cm&fs=1&to=<recipient>&su=<subject>&body=<body>\`) which pre-populates the compose window and dispatches the email via Ctrl+Enter!
-    - Alternatively, navigate directly to \`https://mail.google.com/mail/?view=cm&fs=1&to=<recipient>&su=...&body=...\` and trigger hotkey \`app_action(action: "key_combo", payload: { keyCombo: "ctrl+enter" })\`. NEVER click blind coordinates like (20, 20) in a web browser!
- d. Work Inside App: Use \`app_action\` or \`run_command\` to execute actions inside the app context (e.g. fetching browser page content, running commands inside terminal, searching web, opening files in editor).
- e. Universal Gaming & External Application Protocol:
-     - Desktop Game/App Launch: To open or play ANY installed game or app on the PC (Steam games, Epic Games, Minecraft, Roblox, Discord, Spotify, etc.), call open_app("<game_name>"). The universal OS launcher automatically resolves installed Windows/macOS applications and store packages via system registry and launches them directly!
-     - Web Game Play: If the game is web-based (e.g. Chess.com, Slither.io, 2048, Poki) or not installed locally, NEVER guess speculative URL subpaths! Use app_action(app: "browser", action: "search", payload: { query: "<game_name> play online official" }) or navigate to the official domain homepage to find the verified play URL.
-     - Autonomous Gameplay Progression Loop:
-       1. Window Focus: Use app_action(action: "focus_window", payload: { app: "<game_name>" }) to bring the window front-and-center.
-       2. Screen Observation: Use app_action(action: "see_screen") to inspect the UI, loading screen, or active state.
-       3. Menu Traversal: Click menu buttons ("Play", "Start Game", "New Game", "Continue") using app_action(action: "click_element", payload: { element: "Play" }) .
-       4. Interactive Controls: Send gameplay controls using app_action(action: "send_keys" / "type_text" / "key_combo") with standard gaming keys (WASD, Arrow keys, Space, Enter, Escape, mouse clicks/drags).
-       5. Conclude task with task_completed when the requested gameplay actions or objectives are achieved.
-20. DESKTOP APP TAKEOVER & AUTOMATION PROTOCOL:
- a. STEP 1 SCREEN TAKEOVER: Whenever the user goal asks to take over the screen, control the desktop, or automate an external app (e.g. 'take over screen', 'open maps and click', 'take over desktop', 'open notepad'):
-    - Your VERY FIRST tool call in Step 1 MUST be \`app_action\` with \`action: "takeover"\` (e.g. \`app: "desktop"\` or the target app).
-    - Calling \`app_action\` with \`action: "takeover"\` immediately activates the full-screen sky-blue aura HUD, displays the warning banner "⚡ Scout is on the screen.", blocks external input interruptions, and takes over the mouse cursor!
-    - Then immediately proceed to launch/navigate with \`open_app\` or \`app_action\` (\`action: "click_element"\` / \`action: "click_app"\` / \`action: "type_text"\` / \`action: "send_keys"\`).
- b. LIVE SCREEN SHARE & VISION STREAM DIRECTIVE: You have direct real-time live screen sharing with the model! Instead of taking, saving, and sending static screenshot files, stream the screen live in real-time or inspect the live screen share stream using \`app_action\` with \`action: "live_screen_share"\`, \`"start_screen_share"\`, \`"live_screen_stream"\`, \`"see_screen"\`, or \`"analyze_screen"\`. Screen frames are streamed in-memory directly to the model (zero temporary files written to disk).
- c. VISUAL ELEMENT GROUNDING (click_element): Instead of guessing blind coordinates (x, y), click buttons, inputs, or menus by descriptive label using \`app_action(action: "click_element", payload: { element: "Search" })\`. Vision AI and native OS UI automation will locate the element and click it accurately.
- d. WINDOW & SCROLL CONTROLS: Use \`app_action(action: "scroll", payload: { direction: "down", amount: 4 })\` to scroll pages. Use \`app_action(action: "list_windows")\` to see all open windows, and \`app_action(action: "focus_window", payload: { app: "chrome" })\` to bring a window front-and-center.
- e. CLI Credential Input Prompt: If an application requires login credentials, passwords, 2FA codes, or secret tokens to proceed, call \`ask_user\` tool with a clear prompt. This presents a secure, interactive input bar directly in the user's running terminal CLI. Once the user enters the secret, take the received input, inject it into the target application window via \`app_action\` (\`action: "type_text"\`).
-21. MANDATORY TAKEOVER TOOL INVOCATION MANDATE: Whenever the user goal requests to open, launch, take over, click, type, or interact with an external app or desktop screen (e.g. 'take over browser and open website', 'open notepad and type', 'take over desktop', 'take over screen'):
- YOU MUST CALL \`app_action(action: "takeover")\` IN STEP 1. Then call \`open_app\` and \`app_action\` (\`click_element\`, \`click_app\`, \`type_text\`, \`send_keys\`). DO NOT call \`read_file\` or \`write_file\` for workspace code files when asked to take over external desktop apps! The takeover tool call is MANDATORY for executing the physical takeover.
-22. BROWSER DIRECT URL NAVIGATION MANDATE: When asked to open or navigate to a specific website or web app (e.g. Apple Maps, GitHub, YouTube, etc.), NEVER call Google Search or issue repeated \`app_action: search\` calls with text queries! IMMEDIATELY pass the exact URL (e.g. "https://maps.apple.com") to \`open_app(app: "browser", target: "https://maps.apple.com")\` or \`app_action(app: "browser", action: "navigate", payload: { url: "https://maps.apple.com" })\`. Direct URL navigation must always target the exact site URL directly without putting queries into Google Search!
-23. WORKING MEMORY & STRUCTURED SCRATCHPAD PROTOCOL:
- Like Antigravity and leading autonomous agents, maintain disciplined working memory. In EVERY step, start your response with a structured <scratchpad> reasoning block before returning tool calls:
- \`\`\`markdown
- <scratchpad>
- Thought: [1-2 sentences on what you are doing on this turn and why]
- Plan:
-   [x] 1. [Completed step]
-   [/] 2. [In-progress step]
-   [ ] 3. [Next upcoming step]
- Observations: [What you learned from the last tool result or screen capture]
- Next Action: [The exact tool you are invoking now]
- </scratchpad>
- \`\`\`
- This keeps your reasoning crystal-clear, ensures plan progression, and syncs automatically with .ft/scratchpad.md.
+CORE ARCHITECTURAL PRINCIPLES:
+1. USER INTENT > TOOL CONVENIENCE (CRITICAL MANDATE):
+   The easiest tool is NOT necessarily the correct tool. Scout optimizes for completing the user's ACTUAL REQUESTED WORKFLOW, not merely producing something that looks like the final artifact.
+   - Distinguish OUTCOME requirements (e.g. "Create a file containing X") from EXECUTION requirements (e.g. "Open Notepad, type X, save it as Y on Desktop").
+   - When the user explicitly specifies an application (e.g. Notepad, Excel, Chrome, VS Code) or computer interaction method, computer interaction tools (computer_open_app, computer_screenshot, computer_type, computer_hotkey, computer_switch_window, computer_click) MUST be used.
+   - NEVER silently substitute direct filesystem API calls (write_file) when computer/application interaction is required, unless the user explicitly permits alternative tools ("using any method you prefer").
+   - NEVER assume the repository root is the user's Desktop! If the user requests saving to Desktop, the file MUST be saved to the actual Desktop through the requested workflow.
 
-${this.getScratchpadPromptContext()}
+2. COMPUTER ACTION FAILURE RECOVERY:
+   When a computer action fails or encounters a problem:
+   DO NOT immediately switch to an unrelated tool (like write_file).
+   Instead, follow the bounded computer recovery loop:
+   ACTION FAILED ➔ OBSERVE SCREEN (computer_screenshot / computer_inspect_ui) ➔ UNDERSTAND FAILURE (check if application is active/focused) ➔ RETRY / ALTERNATIVE COMPUTER ACTION (switch window, click text area, send hotkey/keystrokes) ➔ OBSERVE ➔ CONTINUE.
+   Only after repeated bounded computer recovery attempts fail should you report the failure to the user.
+
+3. ACTIVE APPLICATION TRACKING:
+   Before sending keyboard or mouse input (computer_type, computer_click, computer_hotkey), ensure that the expected application (e.g. Notepad) is the active foreground window. If not, use computer_switch_window or computer_open_app to focus it first.
+
+4. REAL-TIME DATE AWARENESS: You are aware of real-time date and time (${new Date().getFullYear()}). Always use the current year (${new Date().getFullYear()}) and date for web searches, documentation, commit messages, and references. NEVER hardcode obsolete past years like 2024.
+5. HIGH AGENCY & AUTONOMY: You act autonomously through step-by-step tool invocation to solve complex coding tasks, debug issues, build features, create projects from scratch, or operate desktop applications.
+6. MULTILINGUAL & INTENT COMPREHENSION: Understand user intent in any language (English, Hinglish like "likho", "bnao", "code karo", "fix karo", "samjha do", Hindi, Spanish, etc.).
+7. FOR CODE & REPO TASKS: When the task is a coding, project refactoring, or repository maintenance task, use direct code modification tools (write_file, edit_file, run_command, read_file, grep_search).
+8. RUN & VERIFY COMMANDS: Execute shell commands, tests, builds, and formatters using run_command.
+9. CRITICAL TERMINATION RULE: As soon as you have finished creating/modifying the necessary files, running verification checks, or completing the desktop application workflow, YOU MUST CALL task_completed tool immediately with a clear summary of your work.
+10. THOUGHT TRANSPARENCY PROTOCOL: In EVERY step before calling any tools or ending a turn, you MUST provide a clear 1-2 sentence explanation in your text response describing your current reasoning, what file/action you are taking, and why you are taking it.
 
 When returning tool calls, use standard OpenAI function calling format or JSON tool call payload format:
 \`\`\`json
 {
- "tool": "tool_name",
- "args": { ... }
+  "tool": "tool_name",
+  "args": { ... }
 }
 \`\`\`
 `.trim();
     }
-    getScratchpadPromptContext() {
-        if (this.scratchpadState.plan.length === 0 && !this.scratchpadState.notes) {
-            return '';
-        }
-        let str = `ACTIVE SCRATCHPAD STATE (.ft/scratchpad.md):\n`;
-        if (this.scratchpadState.plan.length > 0) {
-            str += `Plan Checklist:\n` +
-                this.scratchpadState.plan.map((item, idx) => ` ${this.scratchpadState.completedSteps.includes(idx) ? '[✓]' : '[ ]'} Step ${idx + 1}: ${item}`).join('\n') + '\n';
-        }
-        if (this.scratchpadState.notes) {
-            str += `Working Notes: ${this.scratchpadState.notes}\n`;
-        }
-        return str;
-    }
     async executeGoal(userGoal) {
         this.resetContext();
+        this.executionIntent = inferExecutionIntent(userGoal);
         this.taskStateManager.setObjective(userGoal);
+        if (this.computerController.setExpectedApplication && this.executionIntent.requiredApplications.length > 0) {
+            this.computerController.setExpectedApplication(this.executionIntent.requiredApplications[0] ?? null);
+        }
         const structuredPlan = this.taskPlanner.createPlan(userGoal);
         this.taskStateManager.setPlan(structuredPlan.steps);
         this.taskStateManager.setAvailableTools(this.toolRegistry.getAllTools().map((t) => t.name));
@@ -922,233 +738,215 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
         let step = 0;
         let finalSummary = '';
         const stepDurations = [];
-        try {
-            while (step < this.maxSteps) {
-                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)`));
+        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;
                 try {
-                    let response;
-                    try {
+                    response = await callOpenAIWithRetry(async (model) => {
+                        return await openai.chat.completions.create({
+                            model,
+                            messages: sanitizeMessages(this.historyMessages),
+                            tools: this.toolRegistry.getAllTools().map((t) => ({ type: 'function', function: t })),
+                            tool_choice: 'auto',
+                            temperature: 0.1,
+                            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 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: 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.
+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(this.historyMessages),
-                                tools: this.toolRegistry.getAllTools().map((t) => ({ type: 'function', function: t })),
-                                tool_choice: 'auto',
+                                messages: sanitizeMessages(fallbackMessages),
                                 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 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: 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, open_app, app_action, agent_scratchpad, ask_user, speak_text, task_completed.
-For app takeover/control use: { "tool": "app_action", "args": { "app": "browser", "action": "takeover" } }
-For opening apps use: { "tool": "open_app", "args": { "app": "chrome", "target": "https://..." } }
-For clicking use: { "tool": "app_action", "args": { "app": "desktop", "action": "click_app", "payload": { "x": 500, "y": 300 } } }
-For typing text use: { "tool": "app_action", "args": { "app": "browser", "action": "type_text", "payload": { "text": "...", "enter": true } } }
-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;
-                        }
-                    }
-                    const choice = response.choices[0];
-                    if (!choice) {
-                        stepSpinner.stop(chalk.yellow('No response from Scout. Retrying step...'));
-                        continue;
+                    else {
+                        throw err;
                     }
-                    const msg = sanitizeMessage(choice.message);
-                    this.historyMessages.push(msg);
-                    // Render assistant's thought/scratchpad reasoning text if provided on this turn
-                    const textContent = msg.content || '';
-                    if (textContent.trim()) {
-                        const scratchMatch = textContent.match(/<scratchpad>([\s\S]*?)<\/scratchpad>/i);
-                        if (scratchMatch && scratchMatch[1]) {
-                            const scratchText = scratchMatch[1].trim();
-                            safeNote(renderMarkdown(scratchText), chalk.cyan.bold(`Scout Scratchpad & Working Memory (Step ${step})`));
-                            this.autoSyncScratchpadFromText(scratchText);
-                            const remainingText = textContent.replace(/<scratchpad>[\s\S]*?<\/scratchpad>/i, '').trim();
-                            if (remainingText) {
-                                safeNote(renderMarkdown(remainingText), `Scout Thought (Step ${step})`);
+                }
+                const choice = response.choices[0];
+                if (!choice) {
+                    stepSpinner.stop(chalk.yellow('No response from Scout. Retrying step...'));
+                    continue;
+                }
+                const msg = sanitizeMessage(choice.message);
+                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})`);
+                }
+                // 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 || '{}');
                             }
-                        }
-                        else {
-                            safeNote(renderMarkdown(textContent), `Scout Thought (Step ${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 {
-                                    args = JSON.parse(tc.function.arguments || '{}');
-                                }
-                                catch { }
-                                const toolResult = await this.dispatchToolCall(fnName, args);
-                                this.historyMessages.push({
-                                    role: 'user',
-                                    tool_call_id: tc.id,
-                                    content: `Tool Execution Result (${fnName}):\n${toolResult.result}`,
-                                });
-                                this.handleToolConsecutiveTracking(fnName, args, step);
-                                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, this.projectName, 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');
-                                        }
+                            catch { }
+                            const toolResult = await this.dispatchToolCall(fnName, args);
+                            this.historyMessages.push({
+                                role: 'user',
+                                tool_call_id: tc.id,
+                                content: `Tool Execution Result (${fnName}):\n${toolResult.result}`,
+                            });
+                            this.handleToolConsecutiveTracking(fnName, args, step);
+                            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');
                                     }
-                                    saveAgentSession({
-                                        goal: userGoal,
-                                        summary: finalSummary,
-                                        modifiedFiles: Array.from(this.modifiedFiles),
-                                    });
-                                    return { success: true, summary: finalSummary };
                                 }
+                                saveAgentSession({
+                                    goal: userGoal,
+                                    summary: finalSummary,
+                                    modifiedFiles: Array.from(this.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);
-                        this.historyMessages.push({
-                            role: 'user',
-                            content: `Tool Execution Result (${parsedJsonTool.tool}):\n${toolResult.result}`,
-                        });
-                        this.handleToolConsecutiveTracking(parsedJsonTool.tool, parsedJsonTool.args, step);
-                        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 };
-                        }
-                        continue;
                     }
-                    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();
-                        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('work is complete');
-                        // If explicit completion phrase found, OR files have already been modified and assistant returned a final summary without calling tools
-                        if (isExplicitCompletion || (this.modifiedFiles.size > 0 && !lowerText.includes('?') && textContent.length > 50)) {
-                            saveAgentSession({
-                                goal: userGoal,
-                                summary: textContent,
-                                modifiedFiles: Array.from(this.modifiedFiles),
-                            });
-                            return { success: true, summary: textContent };
-                        }
-                    }
-                    // If assistant responded with text without calling tools, prompt it to execute tools to complete the goal
+                    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);
                     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.',
+                        content: `Tool Execution Result (${parsedJsonTool.tool}):\n${toolResult.result}`,
                     });
-                    stepDurations.push(Date.now() - stepStartTime);
+                    this.handleToolConsecutiveTracking(parsedJsonTool.tool, parsedJsonTool.args, step);
+                    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 };
+                    }
+                    continue;
                 }
-                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.',
-                        };
+                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();
+                    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('work is complete');
+                    // If explicit completion phrase found, OR files have already been modified and assistant returned a final summary without calling tools
+                    if (isExplicitCompletion || (this.modifiedFiles.size > 0 && !lowerText.includes('?') && textContent.length > 50)) {
+                        saveAgentSession({
+                            goal: userGoal,
+                            summary: textContent,
+                            modifiedFiles: Array.from(this.modifiedFiles),
+                        });
+                        return { success: true, summary: textContent };
                     }
-                    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 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');
+                // 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.`,
+                });
             }
-            return {
-                success: false,
-                summary: `Reached max iteration steps limit (${this.maxSteps}). Modified files: ${Array.from(this.modifiedFiles).join(', ')}`,
-            };
-        }
-        finally {
-            cleanupScreenshots();
-            if (isLiveScreenShareActive()) {
-                stopLiveScreenShare();
+            // 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');
             }
         }
+        return {
+            success: false,
+            summary: `Reached max iteration steps limit (${this.maxSteps}). Modified files: ${Array.from(this.modifiedFiles).join(', ')}`,
+        };
     }
     extractJsonToolCall(content) {
         if (!content)
@@ -1168,10 +966,8 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
         const knownTools = [
             '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', 'open_app', 'app_action', 'agent_scratchpad',
+            'fetch_url', 'git_diff',
             'ask_user', 'speak_text', 'task_completed',
-            'desktop_action', 'type_text', 'click_app', 'send_keys', 'takeover',
-            'capture_screen', 'see_screen', 'analyze_screen', 'scratchpad',
         ];
         for (const toolName of knownTools) {
             const tagRegex = new RegExp(`<${toolName}>([\\s\\S]*?)<\\/${toolName}>`, 'i');
@@ -1227,10 +1023,6 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             actionDesc = `Fetching URL: ${args.url || ''}`;
         else if (name === 'git_diff')
             actionDesc = `Retrieving workspace git diff`;
-        else if (name === 'open_app')
-            actionDesc = `Launching app: ${args.app || ''} (${args.target || 'default'})`;
-        else if (name === 'app_action')
-            actionDesc = `Executing app action: ${args.app || ''} -> ${args.action || ''}`;
         else if (name === 'browser_navigate')
             actionDesc = `Navigating browser: ${args.url || ''}`;
         else if (name === 'browser_inspect')
@@ -1244,19 +1036,25 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
         else if (name === 'browser_content')
             actionDesc = `Extracting web page content`;
         else if (name === 'computer_screenshot')
-            actionDesc = `Capturing computer screenshot`;
+            actionDesc = `Observing computer screen`;
         else if (name === 'computer_click')
-            actionDesc = `Clicking coordinates (${args.x}, ${args.y})`;
+            actionDesc = `Clicking screen coordinate: (${args.x}, ${args.y})`;
+        else if (name === 'computer_double_click')
+            actionDesc = `Double clicking coordinate: (${args.x}, ${args.y})`;
         else if (name === 'computer_type')
-            actionDesc = `Typing text keystrokes`;
+            actionDesc = `Typing text: "${String(args.text || '').slice(0, 30)}"`;
+        else if (name === 'computer_key_press')
+            actionDesc = `Pressing key: ${args.key || ''}`;
         else if (name === 'computer_hotkey')
-            actionDesc = `Pressing hotkey: ${args.keys || ''}`;
+            actionDesc = `Executing hotkey: ${(args.keys || []).join('+')}`;
         else if (name === 'computer_open_app')
-            actionDesc = `Opening app: ${args.name || ''}`;
-        else if (name === 'computer_switch_app')
-            actionDesc = `Switching to app: ${args.name || ''}`;
-        else if (name === 'computer_scroll')
-            actionDesc = `Scrolling ${args.direction || 'down'}`;
+            actionDesc = `Launching application: ${args.appName || args.app || ''}`;
+        else if (name === 'computer_close_app')
+            actionDesc = `Closing application: ${args.appName || args.app || ''}`;
+        else if (name === 'computer_switch_window')
+            actionDesc = `Switching window: ${args.windowTitleOrApp || ''}`;
+        else if (name === 'computer_inspect_ui')
+            actionDesc = `Inspecting visible desktop UI`;
         else if (name === 'task_completed')
             actionDesc = `Task finished`;
         const badge = chalk.bgCyan.black.bold(` 🛠️ TOOL: ${name} `);
@@ -1280,6 +1078,27 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 return { result: `[ACTION REJECTED BY USER]: ${decision.reason || 'User did not approve executing this action.'}` };
             }
         }
+        // Validate against execution intent (USER INTENT > TOOL CONVENIENCE)
+        if (this.executionIntent && !this.executionIntent.allowAlternativeTools) {
+            if (this.executionIntent.requiredInteraction === 'computer') {
+                if (['write_file', 'edit_file', 'multi_edit_file'].includes(name)) {
+                    const reqApps = this.executionIntent.requiredApplications.join(', ') || 'the requested desktop application';
+                    const violationMsg = `[EXECUTION INTENT VIOLATION BLOCKED]: User explicitly required computer/application interaction using ${reqApps}. You cannot silently substitute direct filesystem API calls (${name}). You must use computer interaction tools (computer_open_app, computer_switch_window, computer_click, computer_type, computer_hotkey) to perform this task in ${reqApps}.`;
+                    console.log(chalk.red.bold(`\n⛔ ${violationMsg}`));
+                    this.taskStateManager.addObservation(name, violationMsg, false);
+                    return {
+                        result: JSON.stringify({
+                            success: false,
+                            action: name,
+                            error: 'ExecutionIntentViolation',
+                            message: violationMsg,
+                            recoverable: true,
+                            suggestedAction: `Use computer interaction tools with ${reqApps}. Focus the window, type text into the app, and save through the application UI.`
+                        }, null, 2)
+                    };
+                }
+            }
+        }
         switch (name) {
             case 'read_file': {
                 const targetPath = String(args.path || '').trim();
@@ -1314,12 +1133,16 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 return { result: `File: ${targetPath} (Lines ${start}-${end}/${lines.length}):\n${sliced}${minifiedNotice}` };
             }
             case 'write_file': {
-                const targetPath = String(args.path || '').trim();
+                let targetPath = String(args.path || '').trim();
                 let content = String(args.content || '');
                 const reason = String(args.reason || args.why || args.description || 'Created/updated file content to fulfill user prompt.');
                 if (content.includes('\\n') && !content.includes('\n')) {
                     content = content.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
                 }
+                if (this.executionIntent?.targetDestination === 'Desktop' || targetPath.toLowerCase().includes('desktop')) {
+                    const fileName = path.basename(targetPath);
+                    targetPath = resolveDesktopPath(fileName);
+                }
                 const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(this.cwd, targetPath);
                 const fileExists = fs.existsSync(fullPath);
                 const actionText = fileExists ? 'Editing file' : 'Creating file';
@@ -1659,49 +1482,6 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                     return { result: `Could not retrieve git diff: ${err?.message || String(err)}` };
                 }
             }
-            case 'agent_scratchpad': {
-                const action = String(args.action || 'update').toLowerCase();
-                if (action === 'clear') {
-                    this.scratchpadState = { plan: [], completedSteps: [], notes: '' };
-                    try {
-                        const scratchpadPath = path.join(this.cwd, '.ft', 'scratchpad.md');
-                        if (fs.existsSync(scratchpadPath))
-                            fs.unlinkSync(scratchpadPath);
-                    }
-                    catch { }
-                    return { result: 'Agent Scratchpad cleared.' };
-                }
-                else if (action === 'read') {
-                    const text = this.getScratchpadPromptContext() || 'Scratchpad is currently empty.';
-                    return { result: text };
-                }
-                else {
-                    const res = this.updateScratchpad(Array.isArray(args.plan) ? args.plan : undefined, Array.isArray(args.completedSteps) ? args.completedSteps : undefined, args.notes !== undefined ? String(args.notes) : undefined);
-                    return { result: res };
-                }
-            }
-            case 'open_app': {
-                const appName = String(args.app || '').trim();
-                const target = args.target ? String(args.target) : undefined;
-                const launchRes = await openApp(appName, target, args);
-                return { result: launchRes.output };
-            }
-            case 'scratchpad':
-            case 'desktop_action':
-            case 'type_text':
-            case 'click_app':
-            case 'send_keys':
-            case 'takeover':
-            case 'capture_screen':
-            case 'see_screen':
-            case 'analyze_screen':
-            case 'app_action': {
-                const appName = String(args.app || args.appName || 'desktop').trim();
-                const action = String(args.action || (name !== 'app_action' ? name : 'type_text')).trim();
-                const payload = args.payload !== undefined ? args.payload : (args.text || args.content || args.target || args.query || args.element || args.url || args.command || args);
-                const actionRes = await executeInApp(appName, action, payload);
-                return { result: actionRes.output };
-            }
             case 'ask_user': {
                 const questionText = String(args.question || args.prompt || 'Please provide input:').trim();
                 const askSpin = spinner();
@@ -1781,56 +1561,188 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             }
             case 'computer_screenshot': {
                 const res = await this.computerController.screenshot();
-                this.taskStateManager.addObservation('computer_screenshot', res.output, res.success);
-                return { result: res.output };
+                if (res.path) {
+                    this.taskStateManager.recordArtifact({
+                        filename: path.basename(res.path),
+                        path: res.path,
+                        type: 'image',
+                        description: `Screen observation (${res.width}x${res.height})`,
+                        application: res.activeWindow || 'Desktop',
+                    });
+                }
+                if (res.activeWindow) {
+                    this.taskStateManager.setActiveWindow(res.activeWindow);
+                }
+                const summary = `Screen captured (${res.width}x${res.height}), Active window: "${res.activeWindow || 'Desktop'}"${res.path ? `, Saved: ${res.path}` : ''}`;
+                this.taskStateManager.addObservation('computer_screenshot', summary, true);
+                return { result: summary };
             }
             case 'computer_click': {
-                const x = Number(args.x) || 0;
-                const y = Number(args.y) || 0;
-                const res = args.double
-                    ? await this.computerController.double_click(x, y)
-                    : await this.computerController.click(x, y, args.button || 'left');
+                const x = Number(args.x);
+                const y = Number(args.y);
+                const res = await this.computerController.click(x, y, { button: args.button });
                 this.taskStateManager.addObservation('computer_click', res.output, res.success, `(${x}, ${y})`);
-                return { result: res.output };
+                const structuredRes = {
+                    success: res.success,
+                    action: 'click',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    ...(res.activeWindow ? { activeWindow: res.activeWindow } : {}),
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_double_click': {
+                const x = Number(args.x);
+                const y = Number(args.y);
+                const res = await this.computerController.doubleClick(x, y);
+                this.taskStateManager.addObservation('computer_double_click', res.output, res.success, `(${x}, ${y})`);
+                const structuredRes = {
+                    success: res.success,
+                    action: 'double_click',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
             }
             case 'computer_type': {
-                const text = String(args.text || '');
-                const res = await this.computerController.type(text);
+                const textVal = String(args.text || '');
+                const res = await this.computerController.type(textVal);
                 this.taskStateManager.addObservation('computer_type', res.output, res.success);
-                return { result: res.output };
+                const structuredRes = {
+                    success: res.success,
+                    action: 'type',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    ...(res.activeWindow ? { activeWindow: res.activeWindow } : {}),
+                    ...(res.expectedWindow ? { expectedWindow: res.expectedWindow } : {}),
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_key_press': {
+                const key = String(args.key || '');
+                const res = await this.computerController.keyPress(key);
+                this.taskStateManager.addObservation('computer_key_press', res.output, res.success);
+                const structuredRes = {
+                    success: res.success,
+                    action: 'key_press',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
             }
             case 'computer_hotkey': {
-                const keys = String(args.keys || args.key || '');
+                const keys = Array.isArray(args.keys) ? args.keys.map(String) : [String(args.keys)];
                 const res = await this.computerController.hotkey(keys);
-                this.taskStateManager.addObservation('computer_hotkey', res.output, res.success, keys);
+                this.taskStateManager.addObservation('computer_hotkey', res.output, res.success);
+                const structuredRes = {
+                    success: res.success,
+                    action: 'hotkey',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    ...(res.activeWindow ? { activeWindow: res.activeWindow } : {}),
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_scroll': {
+                const deltaY = Number(args.deltaY || 0);
+                const deltaX = Number(args.deltaX || 0);
+                const res = await this.computerController.scroll(deltaX, deltaY);
+                this.taskStateManager.addObservation('computer_scroll', res.output, res.success);
                 return { result: res.output };
             }
-            case 'computer_open_app': {
-                const name = String(args.name || args.app || '').trim();
-                const target = args.target ? String(args.target) : undefined;
-                this.taskStateManager.setActiveApplication(name);
-                const res = await this.computerController.open_application(name, target);
-                this.taskStateManager.addObservation('computer_open_app', res.output, res.success, name);
+            case 'computer_mouse_move': {
+                const x = Number(args.x);
+                const y = Number(args.y);
+                const res = await this.computerController.mouseMove(x, y);
+                this.taskStateManager.addObservation('computer_mouse_move', res.output, res.success);
                 return { result: res.output };
             }
-            case 'computer_switch_app': {
-                const name = String(args.name || args.app || '').trim();
-                this.taskStateManager.setActiveApplication(name);
-                const res = await this.computerController.switch_application(name);
-                this.taskStateManager.addObservation('computer_switch_app', res.output, res.success, name);
+            case 'computer_drag': {
+                const res = await this.computerController.drag(Number(args.fromX), Number(args.fromY), Number(args.toX), Number(args.toY));
+                this.taskStateManager.addObservation('computer_drag', res.output, res.success);
                 return { result: res.output };
             }
-            case 'computer_scroll': {
-                const dir = (args.direction || 'down');
-                const amount = Number(args.amount) || 4;
-                const res = await this.computerController.scroll(dir, amount);
-                this.taskStateManager.addObservation('computer_scroll', res.output, res.success);
+            case 'computer_wait': {
+                const ms = Math.min(10000, Math.max(100, Number(args.ms) || 1000));
+                await this.computerController.wait(ms);
+                return { result: `Waited for ${ms}ms` };
+            }
+            case 'computer_open_app': {
+                const appName = String(args.appName || args.app || '');
+                const res = await this.computerController.openApplication(appName, args.args);
+                this.taskStateManager.setActiveApplication(appName);
+                this.taskStateManager.addObservation('computer_open_app', res.output, res.success);
+                const structuredRes = {
+                    success: res.success,
+                    action: 'open_app',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    activeWindow: res.activeWindow || appName,
+                    expectedWindow: res.expectedWindow || appName,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_close_app': {
+                const appName = String(args.appName || args.app || '');
+                const res = await this.computerController.closeApplication(appName);
+                this.taskStateManager.addObservation('computer_close_app', res.output, res.success);
                 return { result: res.output };
             }
+            case 'computer_switch_window': {
+                const targetWin = String(args.windowTitleOrApp || args.target || '');
+                const res = await this.computerController.switchWindow(targetWin);
+                if (res.success) {
+                    this.taskStateManager.setActiveWindow(targetWin);
+                }
+                this.taskStateManager.addObservation('computer_switch_window', res.output, res.success);
+                const structuredRes = {
+                    success: res.success,
+                    action: 'switch_window',
+                    output: res.output,
+                    ...(res.error ? { error: res.error } : {}),
+                    recoverable: res.recoverable ?? true,
+                    activeWindow: res.activeWindow || targetWin,
+                    expectedWindow: res.expectedWindow,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
+            case 'computer_inspect_ui': {
+                const ui = await this.computerController.inspectUI();
+                this.taskStateManager.setActiveWindow(ui.activeWindow);
+                const outStr = `Active Window: "${ui.activeWindow}"\nVisible Windows: ${ui.windows.map((w) => `"${w}"`).join(', ')}`;
+                this.taskStateManager.addObservation('computer_inspect_ui', outStr, true);
+                const structuredRes = {
+                    success: true,
+                    action: 'inspect_ui',
+                    activeWindow: ui.activeWindow,
+                    windows: ui.windows,
+                    output: outStr,
+                };
+                return { result: JSON.stringify(structuredRes, null, 2) };
+            }
             case 'task_completed': {
                 const summaryStr = String(args.summary || 'Task completed successfully.');
+                if (this.executionIntent?.targetDestination === 'Desktop' && this.executionIntent?.targetArtifactName) {
+                    const checkRes = await this.actionVerifier.verifyFileCreated(this.executionIntent.targetArtifactName, 1, 'Desktop');
+                    if (!checkRes.verified) {
+                        return {
+                            result: JSON.stringify({
+                                success: false,
+                                error: 'VerificationFailed',
+                                message: `Cannot conclude task as completed: ${checkRes.message}`,
+                                recoverable: true,
+                                suggestedAction: 'The file was not found on the Desktop (or was placed in a substitute path). Save the file to the user\'s Desktop via the application interface before completing.'
+                            }, null, 2)
+                        };
+                    }
+                }
                 speakText(summaryStr, { async: true });
-                cleanupScreenshots();
                 this.taskStateManager.setStatus('completed');
                 this.taskStateManager.completeStep(this.currentStep, summaryStr);
                 return { result: summaryStr };