ft-scout 6.0.4 → 6.0.8

package/bin/src/engine/agentEngine.js

@@ -186,6 +186,75 @@ export const AGENT_TOOLS = [
             required: ['pattern'],
         },
     },
+    {
+        name: 'tree_view',
+        description: 'Generate a visual ASCII/Unicode directory tree of a workspace path to visualize folder structures.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Relative path to directory (default "." for workspace root)' },
+                maxDepth: { type: 'number', description: 'Maximum depth limit for tree traversal (default 3)' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'file_info',
+        description: 'Get file statistics including file size, total line count, file extension, and last modification timestamp.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Relative path to the target file' },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'multi_edit_file',
+        description: 'Apply multiple code snippet replacements across a file in a single step to execute complex refactoring efficiently.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Relative path to the target file' },
+                edits: {
+                    type: 'array',
+                    description: 'Array of target and replacement pairs to apply sequentially',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            target: { type: 'string', description: 'Exact code snippet to replace' },
+                            replacement: { type: 'string', description: 'New code replacement snippet' },
+                        },
+                        required: ['target', 'replacement'],
+                    },
+                },
+                reason: { type: 'string', description: 'Explanation of why these multi-edits are being applied' },
+            },
+            required: ['path', 'edits'],
+        },
+    },
+    {
+        name: 'fetch_url',
+        description: 'Fetch content or documentation from an external HTTP/HTTPS URL for API docs, technical references, or specs.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'The absolute HTTP or HTTPS URL to fetch' },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'git_diff',
+        description: 'View current uncommitted git changes across the workspace or for a target file path.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Optional relative file path filter' },
+            },
+            required: [],
+        },
+    },
     {
         name: 'ask_user',
         description: 'ONLY use for missing API keys or secret credentials. DO NOT use to ask the user what code to write or to re-confirm their prompt—take immediate autonomous tool action instead.',
@@ -209,6 +278,51 @@ export const AGENT_TOOLS = [
         },
     },
 ];
+export function buildDirectoryTree(dirPath, prefix = '', currentDepth = 0, maxDepth = 3) {
+    if (currentDepth >= maxDepth)
+        return `${prefix}└── ... [depth limit reached]\n`;
+    if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory())
+        return '';
+    let result = '';
+    let entries = [];
+    try {
+        entries = fs.readdirSync(dirPath).filter((e) => !['.git', 'node_modules', '.ft', 'dist', 'bin/src/index.js'].includes(e));
+    }
+    catch {
+        return '';
+    }
+    entries.sort((a, b) => {
+        try {
+            const aIsDir = fs.statSync(path.join(dirPath, a)).isDirectory();
+            const bIsDir = fs.statSync(path.join(dirPath, b)).isDirectory();
+            if (aIsDir && !bIsDir)
+                return -1;
+            if (!aIsDir && bIsDir)
+                return 1;
+        }
+        catch { }
+        return a.localeCompare(b);
+    });
+    entries.forEach((entry, idx) => {
+        const isLast = idx === entries.length - 1;
+        const connector = isLast ? '└── ' : '├── ';
+        const childPath = path.join(dirPath, entry);
+        let isDir = false;
+        try {
+            isDir = fs.statSync(childPath).isDirectory();
+        }
+        catch { }
+        if (isDir) {
+            result += `${prefix}${connector}${entry}/\n`;
+            const childPrefix = prefix + (isLast ? '    ' : '│   ');
+            result += buildDirectoryTree(childPath, childPrefix, currentDepth + 1, maxDepth);
+        }
+        else {
+            result += `${prefix}${connector}${entry}\n`;
+        }
+    });
+    return result;
+}
 export class AgentExecutionLoop {
     cwd;
     historyMessages = [];
@@ -217,6 +331,9 @@ export class AgentExecutionLoop {
     autoApprove;
     maxSteps;
     projectName;
+    startTime = Date.now();
+    totalToolCalls = 0;
+    currentStep = 0;
     constructor(options) {
         this.cwd = process.cwd();
         this.autoApprove = Boolean(options?.autoApprove);
@@ -229,10 +346,21 @@ export class AgentExecutionLoop {
     getBackups() {
         return this.backups;
     }
+    getStats() {
+        return {
+            totalSteps: this.currentStep,
+            totalToolCalls: this.totalToolCalls,
+            modifiedFilesCount: this.modifiedFiles.size,
+            elapsedMs: Date.now() - this.startTime,
+        };
+    }
     resetContext() {
         this.historyMessages = [];
         this.modifiedFiles.clear();
         this.backups = [];
+        this.startTime = Date.now();
+        this.totalToolCalls = 0;
+        this.currentStep = 0;
     }
     systemPrompt() {
         const filesList = getDirectoryFiles(this.cwd).slice(0, 100);
@@ -248,29 +376,32 @@ Core Directives & Behavioral Guidelines:
 1. 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.
 2. 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. 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.
-5. 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.
-6. 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.
-7. 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.
-8. 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.
-9. 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.
-10. 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.
-11. 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.
-12. 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.
+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.
 
 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();
@@ -278,33 +409,61 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
     async executeGoal(userGoal) {
         this.resetContext();
         this.historyMessages.push({ role: 'system', content: this.systemPrompt() });
-        // Autonomous Target File Discovery: Find relevant workspace files matching terms in userGoal
+        // Robust Target File Discovery: Extract file paths/names directly from userGoal without destroying backslashes
         const filesList = getDirectoryFiles(this.cwd);
-        const stopWords = new Set([
-            'the', 'a', 'an', 'in', 'is', 'for', 'to', 'of', 'and', 'or', 'on', 'at', 'by', 'from',
-            'with', 'this', 'that', 'it', 'code', 'file', 'files', 'fix', 'add', 'make', 'create',
-            'update', 'change', 'modify', 'edit', 'write', 'implement', 'bro', 'please', 'scout',
-            'agent', 'bug', 'error', 'issue', 'help', 'app', 'project', 'script', 'function',
-            'folder', 'dir', 'directory', 'testing', 'inside', 'open', 'vs', 'vscode', 'py', 'python',
-            'new', 'build', 'run', 'test', 'suite'
-        ]);
-        const words = userGoal.split(/[\s,;:\/\\]+/).map((w) => w.replace(/["'(),;:!]/g, '').trim());
         const matchedFiles = [];
-        // 1. Check direct path or filename matches
-        for (const word of words) {
-            if (word && word.includes('.') && !word.startsWith('.')) {
-                const fullP = path.resolve(this.cwd, word);
-                if (fs.existsSync(fullP) && fs.statSync(fullP).isFile()) {
-                    const relP = path.relative(this.cwd, fullP).replace(/\\/g, '/');
-                    if (!matchedFiles.includes(relP))
-                        matchedFiles.push(relP);
+        const isIgnoredFile = (filePath) => {
+            const norm = filePath.replace(/\\/g, '/').toLowerCase();
+            const ext = path.extname(norm);
+            const ignoredExts = ['.pyc', '.pyo', '.png', '.jpg', '.jpeg', '.gif', '.ico', '.exe', '.bin', '.dll', '.so', '.dylib', '.zip', '.tar', '.gz'];
+            return (norm.includes('__pycache__/') ||
+                norm.includes('.git/') ||
+                norm.includes('node_modules/') ||
+                norm.includes('.ft/') ||
+                ignoredExts.includes(ext));
+        };
+        // Match potential paths (e.g. C:\path\to\file.py, pacman_game/game_map.py, game_map.py)
+        const pathMatches = userGoal.match(/(?:[a-zA-Z]:[\\/][^\s"':;,]+|\.?[\\/][^\s"':;,]+\.[a-zA-Z0-9]+|[a-zA-Z0-9_\-./\\]+\.[a-zA-Z0-9]+)/g) || [];
+        for (const rawPath of pathMatches) {
+            const cleanP = rawPath.replace(/^["'()]+|["'()]+$/g, '').trim();
+            if (!cleanP || cleanP.length < 3)
+                continue;
+            const fullP = path.isAbsolute(cleanP) ? cleanP : path.resolve(this.cwd, cleanP);
+            if (fs.existsSync(fullP) && fs.statSync(fullP).isFile()) {
+                const relP = path.relative(this.cwd, fullP).replace(/\\/g, '/');
+                if (!isIgnoredFile(relP) && !matchedFiles.includes(relP))
+                    matchedFiles.push(relP);
+            }
+            else {
+                // Check if any file in filesList matches or ends with the extracted relative path or filename
+                const normToken = cleanP.replace(/\\/g, '/').toLowerCase();
+                const baseName = path.basename(normToken);
+                for (const f of filesList) {
+                    if (isIgnoredFile(f))
+                        continue;
+                    const normF = f.replace(/\\/g, '/').toLowerCase();
+                    if (normF === normToken || normF.endsWith('/' + normToken) || (baseName.includes('.') && normF.endsWith('/' + baseName))) {
+                        if (!matchedFiles.includes(f))
+                            matchedFiles.push(f);
+                    }
                 }
             }
         }
-        // 2. If no direct path matched, search workspace file names for high-confidence keyword matches
+        // Keyword fallback if no direct path matched
         if (matchedFiles.length === 0) {
+            const stopWords = new Set([
+                'the', 'a', 'an', 'in', 'is', 'for', 'to', 'of', 'and', 'or', 'on', 'at', 'by', 'from',
+                'with', 'this', 'that', 'it', 'code', 'file', 'files', 'fix', 'add', 'make', 'create',
+                'update', 'change', 'modify', 'edit', 'write', 'implement', 'bro', 'please', 'scout',
+                'agent', 'bug', 'error', 'issue', 'help', 'app', 'project', 'script', 'function',
+                'folder', 'dir', 'directory', 'testing', 'inside', 'open', 'vs', 'vscode', 'py', 'python',
+                'new', 'build', 'run', 'test', 'suite'
+            ]);
+            const words = userGoal.split(/[\s,;:\/\\]+/).map((w) => w.replace(/["'(),;:!]/g, '').trim());
             const keywords = words.filter((w) => w.length >= 3 && !stopWords.has(w.toLowerCase()));
             for (const f of filesList) {
+                if (isIgnoredFile(f))
+                    continue;
                 if (matchedFiles.length >= 3)
                     break;
                 const normF = f.replace(/\\/g, '/').toLowerCase();
@@ -324,17 +483,17 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
             const fullP = path.resolve(this.cwd, file);
             if (fs.existsSync(fullP) && fs.statSync(fullP).isFile()) {
                 const analyzeSpin = spinner();
-                analyzeSpin.start(chalk.cyan(`🔍 Auto-discovered target file: ${file}. Analyzing...`));
+                analyzeSpin.start(chalk.cyan(` Auto-discovered target file: ${file}. Analyzing...`));
                 try {
                     const content = fs.readFileSync(fullP, 'utf-8');
                     const lines = content.split('\n');
-                    analyzeSpin.stop(chalk.green(`✓ Auto-discovered & analyzed ${file} (${lines.length} lines)`));
+                    analyzeSpin.stop(chalk.green(` Auto-discovered & analyzed ${file} (${lines.length} lines)`));
                     const previewSnippet = lines.length <= 250
                         ? lines.map((l, i) => `${i + 1} | ${l}`).join('\n')
                         : lines.slice(0, 100).map((l, i) => `${i + 1} | ${l}`).join('\n') + `\n... [truncated, file has ${lines.length} lines. Call read_file to view remaining lines]`;
                     this.historyMessages.push({
                         role: 'user',
-                        content: `[Reference Workspace Context - Auto-discovered file "${file}" (${lines.length} lines)]:\n\`\`\`\n${previewSnippet}\n\`\`\`\nNote: Use this complete file content as reference context for editing, debugging, or fulfilling the user goal.`,
+                        content: `[Reference Workspace Context - Pre-loaded target file "${file}" (${lines.length} lines)]:\n\`\`\`\n${previewSnippet}\n\`\`\`\nCRITICAL DIRECTIVE: The target file "${file}" is ALREADY fully pre-loaded into your reference context above. DO NOT call read_file or list_dir for this file again! Immediately begin calling write_file, edit_file, or run_command to satisfy the user goal.`,
                     });
                 }
                 catch {
@@ -350,12 +509,14 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
         }
         const estTotalSecs = Math.round(this.maxSteps * 12);
         const estTimeText = estTotalSecs >= 60 ? `~${(estTotalSecs / 60).toFixed(1)}m` : `~${estTotalSecs}s`;
-        console.log(chalk.gray(`⏱Estimated completion time: ${estTimeText} (Max ${this.maxSteps} steps)`));
+        console.log(chalk.gray(`Estimated completion time: ${estTimeText} (Max ${this.maxSteps} steps)`));
         let step = 0;
         let finalSummary = '';
+        let consecutiveReads = 0;
         const stepDurations = [];
         while (step < this.maxSteps) {
             step++;
+            this.currentStep = step;
             const stepStartTime = Date.now();
             const avgStepMs = stepDurations.length > 0
                 ? stepDurations.reduce((a, b) => a + b, 0) / stepDurations.length
@@ -400,6 +561,11 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 }
                 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).`));
@@ -417,16 +583,28 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                                 tool_call_id: tc.id,
                                 content: `Tool Execution Result (${fnName}):\n${toolResult.result}`,
                             });
+                            if (fnName === 'read_file' || fnName === 'list_dir' || fnName === 'glob_search' || fnName === 'grep_search') {
+                                consecutiveReads++;
+                                if (consecutiveReads >= 2) {
+                                    this.historyMessages.push({
+                                        role: 'user',
+                                        content: 'SYSTEM ACTION NUDGE: You have issued multiple read/exploration tool calls in a row. Stop reading files now and execute write_file, edit_file, or run_command immediately to satisfy the user goal.',
+                                    });
+                                }
+                            }
+                            else if (fnName === 'write_file' || fnName === 'edit_file' || fnName === 'run_command') {
+                                consecutiveReads = 0;
+                            }
                             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');
+                                        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');
+                                        safeNote(chalk.yellow(`️ Remaining verification issues:\n${healRes.remainingErrors.join('\n')}`), '️ Verification Warning');
                                     }
                                 }
                                 return { success: true, summary: finalSummary };
@@ -436,7 +614,6 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                     continue;
                 }
                 // Check text response or fallback JSON tool call
-                const textContent = msg.content || '';
                 stepSpinner.stop(chalk.blue(`Step ${step} thinking complete.`));
                 const parsedJsonTool = this.extractJsonToolCall(textContent);
                 if (parsedJsonTool) {
@@ -452,7 +629,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                     continue;
                 }
                 if (textContent.trim()) {
-                    safeNote(renderMarkdown(textContent), `🤖 Scout Agent Thought (Step ${step})`);
+                    safeNote(renderMarkdown(textContent), ` Scout Agent Thought (Step ${step})`);
                     const lowerText = textContent.toLowerCase();
                     const isExplicitCompletion = lowerText.includes('task is complete') ||
                         lowerText.includes('task complete') ||
@@ -483,14 +660,15 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
             catch (err) {
                 stepDurations.push(Date.now() - stepStartTime);
                 if (isQuotaExceededError(err)) {
-                    stepSpinner.stop(chalk.red(`❌ API Quota Exceeded (Step ${step}).`));
-                    safeNote(`${chalk.bold.red('❌ FrontTerrain API Quota Exceeded!')}\n\n` +
-                        `${chalk.yellow('You have reached the API usage limit or rate cap for FrontTerrain AI service.')}\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');
+                    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: 'FrontTerrain API Quota Exceeded. Please come back in a few hours.',
+                        summary: 'Something went wrong, please try again in a moment.',
                     };
                 }
                 stepSpinner.stop(chalk.red(`Step ${step} execution error: ${err?.message || String(err)}`));
@@ -520,7 +698,11 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
             }
             return { tool, args };
         }
-        const knownTools = ['read_file', 'write_file', 'edit_file', 'run_command', 'list_dir', 'grep_search', 'glob_search', 'ask_user', 'task_completed'];
+        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', 'ask_user', 'task_completed'
+        ];
         for (const toolName of knownTools) {
             const tagRegex = new RegExp(`<${toolName}>([\\s\\S]*?)<\\/${toolName}>`, 'i');
             const match = content.match(tagRegex);
@@ -549,13 +731,42 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
         return null;
     }
     async dispatchToolCall(name, args) {
+        this.totalToolCalls++;
+        let actionDesc = '';
+        if (name === 'read_file')
+            actionDesc = `Reading file: ${args.path || ''}`;
+        else if (name === 'write_file')
+            actionDesc = `Writing/Creating file: ${args.path || ''}`;
+        else if (name === 'edit_file')
+            actionDesc = `Editing file: ${args.path || ''}`;
+        else if (name === 'multi_edit_file')
+            actionDesc = `Multi-editing file: ${args.path || ''}`;
+        else if (name === 'run_command')
+            actionDesc = `Executing command: ${args.command || args.cmd || ''}`;
+        else if (name === 'list_dir')
+            actionDesc = `Listing directory: ${args.path || '.'}`;
+        else if (name === 'tree_view')
+            actionDesc = `Generating directory tree: ${args.path || '.'}`;
+        else if (name === 'file_info')
+            actionDesc = `Inspecting file stats: ${args.path || ''}`;
+        else if (name === 'grep_search')
+            actionDesc = `Searching pattern: "${args.query || args.pattern || ''}"`;
+        else if (name === 'glob_search')
+            actionDesc = `Finding files: "${args.pattern || ''}"`;
+        else if (name === 'fetch_url')
+            actionDesc = `Fetching URL: ${args.url || ''}`;
+        else if (name === 'git_diff')
+            actionDesc = `Retrieving workspace git diff`;
+        else if (name === 'task_completed')
+            actionDesc = `Task finished`;
         const badge = chalk.bgCyan.black.bold(` 🛠️ TOOL: ${name} `);
-        console.log(`\n${badge} ${chalk.dim(JSON.stringify(args))}`);
+        const descText = actionDesc ? chalk.yellow.bold(` → ${actionDesc}`) : '';
+        console.log(`\n${badge}${descText} ${chalk.dim(JSON.stringify(args))}`);
         switch (name) {
             case 'read_file': {
                 const targetPath = String(args.path || '').trim();
                 const readSpin = spinner();
-                readSpin.start(chalk.cyan(`🔍 Analyzing file ${targetPath}...`));
+                readSpin.start(chalk.cyan(` Analyzing file ${targetPath}...`));
                 const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(this.cwd, targetPath);
                 if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) {
                     readSpin.stop(chalk.red(`Failed to analyze file ${targetPath}: File not found.`));
@@ -565,7 +776,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 const lines = fileContent.split('\n');
                 const start = Math.max(1, Number(args.startLine) || 1);
                 const end = Math.min(lines.length, Number(args.endLine) || lines.length);
-                readSpin.stop(chalk.green(`✓ Analyzed file ${targetPath} (${lines.length} lines)`));
+                readSpin.stop(chalk.green(` Analyzed file ${targetPath} (${lines.length} lines)`));
                 const sliced = lines.slice(start - 1, end).map((l, i) => `${start + i} | ${l}`).join('\n');
                 let minifiedNotice = '';
                 if (lines.length <= 5 && fileContent.length > 500) {
@@ -584,7 +795,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 const fileExists = fs.existsSync(fullPath);
                 const actionText = fileExists ? 'Editing file' : 'Creating file';
                 const writeSpin = spinner();
-                writeSpin.start(chalk.yellow(`✏️ ${actionText} ${targetPath}...`));
+                writeSpin.start(chalk.yellow(`️ ${actionText} ${targetPath}...`));
                 if (!this.autoApprove && process.stdout.isTTY) {
                     writeSpin.stop();
                     const ok = await confirm({
@@ -594,7 +805,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                     if (isCancel(ok) || !ok) {
                         return { result: `User rejected write_file to "${targetPath}"` };
                     }
-                    writeSpin.start(chalk.yellow(`✏️ ${actionText} ${targetPath}...`));
+                    writeSpin.start(chalk.yellow(`️ ${actionText} ${targetPath}...`));
                 }
                 let origContent = '__FT_WAS_NEW__';
                 if (fileExists) {
@@ -610,20 +821,20 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 const oldLineCount = origContent !== '__FT_WAS_NEW__' ? origContent.split('\n').length : 0;
                 const newLineCount = content.split('\n').length;
                 const numberOfLinesChanged = origContent === '__FT_WAS_NEW__' ? newLineCount : Math.abs(newLineCount - oldLineCount) || newLineCount;
-                writeSpin.stop(chalk.green(`✓ ${actionText} ${targetPath}`));
+                writeSpin.stop(chalk.green(` ${actionText} ${targetPath}`));
                 safeNote(` • File: ${chalk.bold.cyan(targetPath)}\n` +
                     ` • Changed: ${chalk.bold.yellow(numberOfLinesChanged + ' line(s)')}\n` +
-                    ` • Why: ${reason}`, `📝 Changed ${numberOfLinesChanged} line(s) in ${targetPath}`);
+                    ` • Why: ${reason}`, ` Changed ${numberOfLinesChanged} line(s) in ${targetPath}`);
                 const checkSpin = spinner();
-                checkSpin.start(chalk.cyan(`🔍 Checking for error: edited ${targetPath}...`));
+                checkSpin.start(chalk.cyan(` Checking for error: edited ${targetPath}...`));
                 const syntaxCheck = await checkFileSyntax(targetPath, this.cwd);
                 if (!syntaxCheck.valid) {
-                    checkSpin.stop(chalk.red(`⚠️ Checking for error: edited ${targetPath} — Compiler/Syntax Error!`));
+                    checkSpin.stop(chalk.red(`️ Checking for error: edited ${targetPath} — Compiler/Syntax Error!`));
                     return {
-                        result: `Successfully wrote ${content.length} characters (${numberOfLinesChanged} lines changed) to "${targetPath}".\n\n⚠️ AUTOMATED SYNTAX / COMPILER ERROR DETECTED IN "${targetPath}":\n${syntaxCheck.errors.join('\n')}\n\nPLEASE IMMEDIATELY FIX THIS SYNTAX ERROR IN YOUR NEXT TOOL CALL.`
+                        result: `Successfully wrote ${content.length} characters (${numberOfLinesChanged} lines changed) to "${targetPath}".\n\n️ AUTOMATED SYNTAX / COMPILER ERROR DETECTED IN "${targetPath}":\n${syntaxCheck.errors.join('\n')}\n\nPLEASE IMMEDIATELY FIX THIS SYNTAX ERROR IN YOUR NEXT TOOL CALL.`
                     };
                 }
-                checkSpin.stop(chalk.green(`✓ Checking for error: edited ${targetPath} — Syntax & build clean.`));
+                checkSpin.stop(chalk.green(` Checking for error: edited ${targetPath} — Syntax & build clean.`));
                 return { result: `Successfully wrote ${content.length} characters (${numberOfLinesChanged} lines changed) to "${targetPath}". Rationale: ${reason}. Syntax check passed cleanly.` };
             }
             case 'edit_file': {
@@ -639,7 +850,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 }
                 const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(this.cwd, targetPath);
                 const editSpin = spinner();
-                editSpin.start(chalk.yellow(`✏️ Editing file ${targetPath}...`));
+                editSpin.start(chalk.yellow(`️ Editing file ${targetPath}...`));
                 if (!fs.existsSync(fullPath)) {
                     editSpin.stop(chalk.red(`Failed to edit file ${targetPath}: File does not exist.`));
                     return { result: `Error: File "${targetPath}" does not exist.` };
@@ -659,7 +870,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                     if (isCancel(ok) || !ok) {
                         return { result: `User rejected edit_file to "${targetPath}"` };
                     }
-                    editSpin.start(chalk.yellow(`✏️ Editing file ${targetPath}...`));
+                    editSpin.start(chalk.yellow(`️ Editing file ${targetPath}...`));
                 }
                 this.backups.push({ filePath: targetPath, originalContent: origContent });
                 fs.writeFileSync(fullPath, replaceRes.updatedContent, 'utf-8');
@@ -667,20 +878,20 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 const targetLines = target.split('\n').length;
                 const replacementLines = replacement.split('\n').length;
                 const numberOfLinesChanged = Math.max(targetLines, replacementLines);
-                editSpin.stop(chalk.green(`✓ Edited file ${targetPath}`));
+                editSpin.stop(chalk.green(` Edited file ${targetPath}`));
                 safeNote(` • File: ${chalk.bold.cyan(targetPath)}\n` +
                     ` • Changed: ${chalk.bold.yellow(numberOfLinesChanged + ' line(s)')}\n` +
-                    ` • Why: ${reason}`, `📝 Changed ${numberOfLinesChanged} line(s) in ${targetPath}`);
+                    ` • Why: ${reason}`, ` Changed ${numberOfLinesChanged} line(s) in ${targetPath}`);
                 const checkSpin = spinner();
-                checkSpin.start(chalk.cyan(`🔍 Checking for error: edited ${targetPath}...`));
+                checkSpin.start(chalk.cyan(` Checking for error: edited ${targetPath}...`));
                 const syntaxCheck = await checkFileSyntax(targetPath, this.cwd);
                 if (!syntaxCheck.valid) {
-                    checkSpin.stop(chalk.red(`⚠️ Checking for error: edited ${targetPath} — Compiler/Syntax Error!`));
+                    checkSpin.stop(chalk.red(`️ Checking for error: edited ${targetPath} — Compiler/Syntax Error!`));
                     return {
-                        result: `Successfully replaced snippet (${numberOfLinesChanged} lines changed) in "${targetPath}".\n\n⚠️ AUTOMATED SYNTAX / COMPILER ERROR DETECTED IN "${targetPath}":\n${syntaxCheck.errors.join('\n')}\n\nPLEASE IMMEDIATELY FIX THIS SYNTAX ERROR IN YOUR NEXT TOOL CALL.`
+                        result: `Successfully replaced snippet (${numberOfLinesChanged} lines changed) in "${targetPath}".\n\n️ AUTOMATED SYNTAX / COMPILER ERROR DETECTED IN "${targetPath}":\n${syntaxCheck.errors.join('\n')}\n\nPLEASE IMMEDIATELY FIX THIS SYNTAX ERROR IN YOUR NEXT TOOL CALL.`
                     };
                 }
-                checkSpin.stop(chalk.green(`✓ Checking for error: edited ${targetPath} — Syntax & build clean.`));
+                checkSpin.stop(chalk.green(` Checking for error: edited ${targetPath} — Syntax & build clean.`));
                 return { result: `Successfully replaced target snippet (${numberOfLinesChanged} lines changed) in "${targetPath}". Rationale: ${reason}. Syntax check passed cleanly.` };
             }
             case 'run_command': {
@@ -697,20 +908,20 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                     }
                 }
                 const runSpin = spinner();
-                runSpin.start(chalk.cyan(`⚡ ${actionLabel}...`));
+                runSpin.start(chalk.cyan(` ${actionLabel}...`));
                 const res = await executeSmartCommand(cmd, this.cwd, 3000);
                 if (res.isBackgroundServer) {
-                    runSpin.stop(chalk.green(`✓ ${actionLabel} started in background (PID ${res.pid}).`));
+                    runSpin.stop(chalk.green(` ${actionLabel} started in background (PID ${res.pid}).`));
                     return {
                         result: `Command started and running in background (PID ${res.pid || 'active'}). Output:\n${res.output.slice(0, 8000)}\n\n[Process is running as background server. Scout Agent can proceed directly to next step.]`
                     };
                 }
                 if (res.exitCode === 0) {
-                    runSpin.stop(chalk.green(`✓ ${actionLabel} executed successfully (Exit Code 0).`));
+                    runSpin.stop(chalk.green(` ${actionLabel} executed successfully (Exit Code 0).`));
                     return { result: `Command Exit Code 0 Output:\n${res.output.slice(0, 8000)}` };
                 }
                 else {
-                    runSpin.stop(chalk.red(`❌ ${actionLabel} failed with code ${res.exitCode}.`));
+                    runSpin.stop(chalk.red(` ${actionLabel} failed with code ${res.exitCode}.`));
                     return { result: `Command Exit Code ${res.exitCode} Error:\n${res.output.slice(0, 8000)}` };
                 }
             }
@@ -747,11 +958,137 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 const matched = allFiles.filter((f) => f.toLowerCase().includes(pattern) || path.basename(f).toLowerCase().endsWith(pattern.replace('*', '')));
                 return { result: `Glob search "${pattern}" matched ${matched.length} file(s):\n${matched.slice(0, 30).join('\n')}` };
             }
+            case 'tree_view': {
+                const relPath = String(args.path || '.').trim();
+                const maxDepth = Number(args.maxDepth) || 3;
+                const fullDir = path.resolve(this.cwd, relPath);
+                if (!fs.existsSync(fullDir) || !fs.statSync(fullDir).isDirectory()) {
+                    return { result: `Directory not found for tree_view: "${relPath}"` };
+                }
+                const treeStr = buildDirectoryTree(fullDir, '', 0, maxDepth);
+                return { result: `Directory Tree for "${relPath}":\n${relPath}/\n${treeStr}` };
+            }
+            case 'file_info': {
+                const targetPath = String(args.path || '').trim();
+                const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(this.cwd, targetPath);
+                if (!fs.existsSync(fullPath)) {
+                    return { result: `Error: Path "${targetPath}" does not exist.` };
+                }
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    const entries = fs.readdirSync(fullPath);
+                    return { result: `Directory Stats: "${targetPath}"\n • Total Entries: ${entries.length}\n • Created: ${stat.birthtime.toISOString()}\n • Modified: ${stat.mtime.toISOString()}` };
+                }
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                const lineCount = content.split('\n').length;
+                const ext = path.extname(targetPath) || 'none';
+                return {
+                    result: `File Info: "${targetPath}"\n` +
+                        ` • Size: ${(stat.size / 1024).toFixed(2)} KB (${stat.size} bytes)\n` +
+                        ` • Total Lines: ${lineCount}\n` +
+                        ` • Extension: ${ext}\n` +
+                        ` • Last Modified: ${stat.mtime.toISOString()}\n` +
+                        ` • Absolute Path: ${fullPath}`
+                };
+            }
+            case 'multi_edit_file': {
+                const targetPath = String(args.path || '').trim();
+                const edits = Array.isArray(args.edits) ? args.edits : [];
+                const reason = String(args.reason || args.description || 'Applied multiple code snippet edits.');
+                if (edits.length === 0) {
+                    return { result: `Error: No edits provided for multi_edit_file on "${targetPath}".` };
+                }
+                const fullPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(this.cwd, targetPath);
+                if (!fs.existsSync(fullPath)) {
+                    return { result: `Error: File "${targetPath}" does not exist.` };
+                }
+                let currentContent = fs.readFileSync(fullPath, 'utf-8');
+                const origContent = currentContent;
+                let appliedCount = 0;
+                const errors = [];
+                for (let i = 0; i < edits.length; i++) {
+                    const ed = edits[i];
+                    let target = String(ed.target || '');
+                    let replacement = String(ed.replacement || '');
+                    if (target.includes('\\n') && !target.includes('\n'))
+                        target = target.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+                    if (replacement.includes('\\n') && !replacement.includes('\n'))
+                        replacement = replacement.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+                    const replaceRes = robustSnippetReplace(currentContent, target, replacement);
+                    if (replaceRes.success) {
+                        currentContent = replaceRes.updatedContent;
+                        appliedCount++;
+                    }
+                    else {
+                        errors.push(`Edit #${i + 1} failed: ${replaceRes.error}`);
+                    }
+                }
+                if (appliedCount === 0) {
+                    return { result: `Error: All ${edits.length} multi-edits failed on "${targetPath}":\n${errors.join('\n')}` };
+                }
+                this.backups.push({ filePath: targetPath, originalContent: origContent });
+                fs.writeFileSync(fullPath, currentContent, 'utf-8');
+                this.modifiedFiles.add(targetPath);
+                safeNote(` • File: ${chalk.bold.cyan(targetPath)}\n` +
+                    ` • Multi-edits applied: ${chalk.bold.green(appliedCount + '/' + edits.length)}\n` +
+                    ` • Why: ${reason}`, ` Applied ${appliedCount} edits to ${targetPath}`);
+                const syntaxCheck = await checkFileSyntax(targetPath, this.cwd);
+                let syntaxNotice = syntaxCheck.valid ? 'Syntax check passed cleanly.' : `\n\n️ AUTOMATED SYNTAX ERROR DETECTED:\n${syntaxCheck.errors.join('\n')}`;
+                return {
+                    result: `Successfully applied ${appliedCount}/${edits.length} edit snippet(s) to "${targetPath}". Rationale: ${reason}.${errors.length > 0 ? ` Warnings: ${errors.join('; ')}` : ''} ${syntaxNotice}`
+                };
+            }
+            case 'fetch_url': {
+                const targetUrl = String(args.url || '').trim();
+                if (!targetUrl.startsWith('http://') && !targetUrl.startsWith('https://')) {
+                    return { result: `Error: Invalid URL scheme. URL must start with http:// or https://` };
+                }
+                const fetchSpin = spinner();
+                fetchSpin.start(chalk.cyan(` Fetching web URL ${targetUrl}...`));
+                try {
+                    const resp = await fetch(targetUrl, { headers: { 'User-Agent': 'Scout-CLI-Agent/6.0' } });
+                    if (!resp.ok) {
+                        fetchSpin.stop(chalk.red(`Failed to fetch URL: HTTP ${resp.status} ${resp.statusText}`));
+                        return { result: `HTTP Error ${resp.status}: ${resp.statusText}` };
+                    }
+                    let bodyText = await resp.text();
+                    fetchSpin.stop(chalk.green(` Fetched URL ${targetUrl} (${bodyText.length} chars)`));
+                    if (bodyText.includes('<html') || bodyText.includes('<body')) {
+                        bodyText = bodyText
+                            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+                            .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
+                            .replace(/<[^>]+>/g, ' ')
+                            .replace(/\s+/g, ' ')
+                            .trim();
+                    }
+                    const preview = bodyText.slice(0, 6000) + (bodyText.length > 6000 ? `\n... [truncated, ${bodyText.length} total chars]` : '');
+                    return { result: `Content fetched from ${targetUrl}:\n\n${preview}` };
+                }
+                catch (err) {
+                    fetchSpin.stop(chalk.red(`Fetch error for ${targetUrl}: ${err?.message || String(err)}`));
+                    return { result: `Fetch error: ${err?.message || String(err)}` };
+                }
+            }
+            case 'git_diff': {
+                const targetPath = args.path ? String(args.path).trim() : '';
+                try {
+                    const { execSync } = await import('child_process');
+                    const diffCmd = targetPath ? `git diff -- "${targetPath}"` : 'git diff';
+                    const diffOutput = execSync(diffCmd, { encoding: 'utf-8', cwd: this.cwd });
+                    if (!diffOutput || !diffOutput.trim()) {
+                        return { result: 'No uncommitted git changes found in workspace.' };
+                    }
+                    return { result: `Git Diff Output:\n${diffOutput.slice(0, 8000)}` };
+                }
+                catch (err) {
+                    return { result: `Could not retrieve git diff: ${err?.message || String(err)}` };
+                }
+            }
             case 'ask_user': {
                 const questionText = String(args.question || args.prompt || 'Please provide input:').trim();
                 const askSpin = spinner();
                 askSpin.stop();
-                safeNote(questionText, '❓ Scout Agent Question for User');
+                safeNote(questionText, ' Scout Agent Question for User');
                 const userInput = await text({
                     message: chalk.cyan.bold('Your response:'),
                     placeholder: 'Type your answer or instruction here...',