@xagent-ai/cli 1.2.2 → 1.3.0

package/dist/tools.js

@@ -1,18 +1,21 @@
 import fs from 'fs/promises';
+import { select, text } from '@clack/prompts';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import readline from 'readline';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
+import { spawn } from 'child_process';
 import { glob } from 'glob';
 import axios from 'axios';
-import inquirer from 'inquirer';
 import { ExecutionMode, AuthType } from './types.js';
 import { colors, icons } from './theme.js';
 import { getLogger } from './logger.js';
 import { getCancellationManager } from './cancellation.js';
 import { SystemPromptGenerator } from './system-prompt-generator.js';
-const execAsync = promisify(exec);
+import { getSingletonSession } from './session.js';
+import { ripgrep, fdFind } from './ripgrep.js';
+import { getShellConfig, killProcessTree, quoteShellCommand } from './shell.js';
+import { truncateTail, buildTruncationNotice } from './truncate.js';
+import { createAIClient } from './ai-client-factory.js';
 //
 // Tool Description Pattern
 //
@@ -64,8 +67,16 @@ export class ReadTool {
 - Use offset and limit for large files to avoid loading entire content
 - Combine with ListDirectory to explore project structure first
 - Don't re-read files unnecessarily`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
+        if (!params || typeof params.filePath !== 'string') {
+            throw new Error('filePath is required and must be a string');
+        }
         const { filePath, offset = 0, limit } = params;
         try {
             // Handle ~ (user home directory) in file paths
@@ -82,10 +93,18 @@ export class ReadTool {
             const absolutePath = path.resolve(resolvedPath);
             const content = await fs.readFile(absolutePath, 'utf-8');
             const lines = content.split('\n');
+            const totalLines = lines.length;
             const startLine = Math.max(0, offset);
-            const endLine = limit !== undefined ? Math.min(lines.length, startLine + limit) : lines.length;
+            const endLine = limit !== undefined ? Math.min(totalLines, startLine + limit) : totalLines;
             const selectedLines = lines.slice(startLine, endLine);
-            return selectedLines.join('\n');
+            const result = selectedLines.join('\n');
+            // Add truncation notice if content is limited
+            if (limit !== undefined && endLine < totalLines) {
+                const remaining = totalLines - endLine;
+                const nextOffset = endLine;
+                return (result + `\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue]`);
+            }
+            return result;
         }
         catch (error) {
             // Show user-friendly path in error message
@@ -146,7 +165,7 @@ export class WriteTool {
                 message: `Successfully wrote to ${filePath}`,
                 filePath,
                 lineCount,
-                preview: isTruncated ? preview + '\n...' : preview
+                preview: isTruncated ? preview + '\n...' : preview,
             };
         }
         catch (error) {
@@ -156,7 +175,7 @@ export class WriteTool {
 }
 export class GrepTool {
     name = 'Grep';
-    description = `Search for text patterns within files using regex or literal string matching. This is your PRIMARY tool for finding specific code, functions, or content.
+    description = `Search for text patterns within files using ripgrep. This is your PRIMARY tool for finding specific code, functions, or content.
 
 # When to Use
 - Finding specific function definitions or calls
@@ -173,89 +192,41 @@ export class GrepTool {
 # Parameters
 - \`pattern\`: Regex or literal string to search for
 - \`path\`: (Optional) Directory to search in, default: "."
-- \`include\`: (Optional) File glob pattern to include
-- \`exclude\`: (Optional) File glob pattern to exclude
-- \`case_sensitive\`: (Optional) Case-sensitive search, default: false
-- \`fixed_strings\`: (Optional) Treat pattern as literal string, default: false
+- \`glob\`: (Optional) File glob pattern to include (e.g., "*.ts", "**/*.js")
+- \`ignoreCase\`: (Optional) Case-insensitive search, default: false
+- \`literal\`: (Optional) Treat pattern as literal string, default: false
 - \`context\`: (Optional) Lines of context before/after matches
-- \`no_ignore\`: (Optional) Don't ignore node_modules/.git, default: false
 
 # Examples
 - Find function: Grep(pattern="function myFunction")
 - Find with context: Grep(pattern="TODO", context=3)
-- TypeScript only: Grep(pattern="interface", include="*.ts")
+- TypeScript only: Grep(pattern="interface", glob="*.ts")
+- Case-insensitive: Grep(pattern="error", ignoreCase=true)
 
 # Best Practices
-- Use case_sensitive=true for short patterns to reduce false positives
-- Use fixed_strings=true if your pattern has special regex characters
+- Use ignoreCase=true for short patterns to reduce false positives
+- Use literal=true if your pattern has special regex characters
 - Use context to see the surrounding code for each match
-- Combine with include/exclude to narrow down file types`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+- Combine with glob to narrow down file types`;
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
-        const { pattern, path: searchPath = '.', include, exclude, case_sensitive = false, fixed_strings = false, context, after, before, no_ignore = false } = params;
+        const { pattern, path: searchPath = '.', glob: includeGlob, ignoreCase = false, literal = false, context, limit, } = params;
         try {
-            const ignorePatterns = no_ignore ? [] : ['node_modules/**', '.git/**', 'dist/**', 'build/**'];
-            if (exclude) {
-                ignorePatterns.push(exclude);
-            }
-            const absolutePath = path.resolve(searchPath);
-            const files = await glob('**/*', {
-                cwd: absolutePath,
-                nodir: true,
-                ignore: ignorePatterns
+            const result = await ripgrep({
+                pattern,
+                path: searchPath,
+                glob: includeGlob,
+                ignoreCase,
+                literal,
+                context,
+                limit,
             });
-            const results = [];
-            for (const file of files) {
-                const fullPath = path.join(absolutePath, file);
-                if (include && !file.match(include)) {
-                    continue;
-                }
-                try {
-                    const content = await fs.readFile(fullPath, 'utf-8');
-                    const lines = content.split('\n');
-                    lines.forEach((line, index) => {
-                        let matches = false;
-                        if (fixed_strings) {
-                            matches = case_sensitive
-                                ? line.includes(pattern)
-                                : line.toLowerCase().includes(pattern.toLowerCase());
-                        }
-                        else {
-                            try {
-                                const flags = case_sensitive ? 'g' : 'gi';
-                                const regex = new RegExp(pattern, flags);
-                                matches = regex.test(line);
-                            }
-                            catch (e) {
-                                matches = case_sensitive
-                                    ? line.includes(pattern)
-                                    : line.toLowerCase().includes(pattern.toLowerCase());
-                            }
-                        }
-                        if (matches) {
-                            const contextLines = [];
-                            if (before || context) {
-                                const beforeCount = before || context || 0;
-                                for (let i = Math.max(0, index - beforeCount); i < index; i++) {
-                                    contextLines.push(`${fullPath}:${i + 1}:${lines[i].trim()}`);
-                                }
-                            }
-                            contextLines.push(`${fullPath}:${index + 1}:${line.trim()}`);
-                            if (after || context) {
-                                const afterCount = after || context || 0;
-                                for (let i = index + 1; i < Math.min(lines.length, index + 1 + afterCount); i++) {
-                                    contextLines.push(`${fullPath}:${i + 1}:${lines[i].trim()}`);
-                                }
-                            }
-                            results.push(...contextLines);
-                        }
-                    });
-                }
-                catch (error) {
-                    continue;
-                }
-            }
-            return results;
+            return result.split('\n').filter((line) => line.trim());
         }
         catch (error) {
             throw new Error(`Grep failed: ${error.message}`);
@@ -287,13 +258,23 @@ export class BashTool {
 - \`description\`: (Optional) Description of what the command does
 - \`timeout\`: (Optional) Timeout in seconds, default: 120
 - \`run_in_bg\`: (Optional) Run in background, default: false
+- \`skillPath\`: (Optional) Skill directory path - when provided, NODE_PATH will include the skill's node_modules for dependency resolution
 
 # Examples
 - Install dependencies: Bash(command="npm install", description="Install npm dependencies")
+- Run in skill directory with local deps: Bash(command="npm install docx", skillPath="~/.xagent/skills/docx")
+
+# NODE_PATH Resolution
+When \`skillPath\` is provided, the command will have access to:
+- \`<skillPath>/node_modules\` (skill's local dependencies)
+- xAgent's global node_modules
+
+This is useful when working with skills that have local dependencies.
 - Run tests: Bash(command="npm test", description="Run unit tests")
 - Build project: Bash(command="npm run build", description="Build the project")
 
 # Best Practices
+- To install npm packages that persist across sessions, use: \`XAGENT_USER_NPM=1 npm install <package>\`
 - Always provide a description for context
 - Set appropriate timeout for long-running commands
 - Use run_in_bg=true for commands that take a long time
@@ -301,7 +282,7 @@ export class BashTool {
 - Use absolute paths or paths relative to project root`;
     allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
     async execute(params) {
-        const { command, cwd, description, timeout = 120, run_in_bg = false } = params;
+        const { command, cwd, description, timeout = 120, run_in_bg = false, skillPath } = params;
         // Determine effective working directory
         // Only use cwd if the command doesn't contain 'cd' (let LLM control directory)
         let effectiveCwd;
@@ -318,26 +299,104 @@ export class BashTool {
             // No cwd provided, use default
             effectiveCwd = undefined;
         }
-        // Set up environment with NODE_PATH only for node commands
-        const nodeModulesPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'node_modules');
+        // Resolve actual working directory
+        const actualCwd = effectiveCwd || process.cwd();
+        // Set up environment with NODE_PATH for node commands
+        const builtinNodeModulesPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'node_modules');
+        // Get user skills path from config (unified path: ~/.xagent/skills)
+        const { getConfigManager } = await import('./config.js');
+        const configManager = getConfigManager();
+        const userSkillsPath = configManager.getUserSkillsPath();
+        // Skill deps path: ~/.xagent/skills/{skillName}/node_modules
+        const builtinDepsPath = userSkillsPath ? path.join(userSkillsPath, 'builtin-deps') : null;
+        // Determine which node_modules to use
+        let skillNodeModulesPath = null;
+        // Priority 1: skillPath parameter (workspace scenario - LLM works in workspace, not skill dir)
+        if (skillPath) {
+            if (skillPath.includes('/builtin-deps/')) {
+                // Skill with deps in builtin-deps directory
+                const match = skillPath.match(/\/builtin-deps\/([^/]+)/);
+                if (match) {
+                    skillNodeModulesPath = path.join(builtinDepsPath, match[1], 'node_modules');
+                }
+            }
+            else {
+                // Regular skill
+                skillNodeModulesPath = path.join(skillPath, 'node_modules');
+            }
+        }
+        // Priority 2: Check if we're inside a skill directory
+        else if (userSkillsPath && userSkillsPath.trim() && actualCwd.startsWith(userSkillsPath)) {
+            const relativePath = actualCwd.substring(userSkillsPath.length);
+            const pathParts = relativePath.split(path.sep).filter(Boolean);
+            if (pathParts.length > 0) {
+                if (pathParts[0] === 'builtin-deps' && pathParts.length > 1) {
+                    // Skill with local deps in builtin-deps
+                    const skillName = pathParts[1];
+                    skillNodeModulesPath = path.join(builtinDepsPath, skillName, 'node_modules');
+                }
+                else {
+                    // Regular skill
+                    const skillName = pathParts[0];
+                    const skillRoot = path.join(userSkillsPath, skillName);
+                    try {
+                        const skillMdPath = path.join(skillRoot, 'SKILL.md');
+                        await fs.access(skillMdPath);
+                        skillNodeModulesPath = path.join(skillRoot, 'node_modules');
+                    }
+                    catch {
+                        // Not a skill directory, skip
+                    }
+                }
+            }
+        }
+        // Build NODE_PATH - skill's node_modules takes precedence (last-wins)
+        let nodePath;
+        if (skillNodeModulesPath) {
+            nodePath = `${skillNodeModulesPath}${path.delimiter}${builtinNodeModulesPath}`;
+        }
+        else {
+            nodePath = builtinNodeModulesPath;
+        }
         const env = {
             ...process.env,
-            NODE_PATH: nodeModulesPath
+            NODE_PATH: nodePath
         };
-        // Only add NODE_PATH prefix for node commands
-        const isNodeCommand = /\bnode\b/.test(command);
-        const finalCommand = isNodeCommand
-            ? `set NODE_PATH=${nodeModulesPath} && ${command}`
-            : command;
+        // Handle npm install commands
+        const isNpmInstall = /\bnpm\s+install\b/i.test(command);
+        let finalCommand = command;
+        if (isNpmInstall && skillNodeModulesPath) {
+            // Install to skill's own node_modules
+            await fs.mkdir(skillNodeModulesPath, { recursive: true }).catch(() => { });
+            finalCommand = command.replace(/\bnpm\s+install\b/i, `npm install --prefix "${skillNodeModulesPath}"`);
+        }
+        // Get shell configuration (Windows Git Bash detection, etc.)
+        const { shell, args } = getShellConfig();
+        // Set up cross-platform encoding environment for command execution
+        if (process.platform === 'win32') {
+            // Windows: set code page to UTF-8 and ensure console output encoding
+            // chcp 65001 sets the console code page to UTF-8
+            // Use *>$null to suppress output (PowerShell-style, not CMD-style)
+            finalCommand = `chcp 65001 *>$null; [Console]::OutputEncoding = [System.Text.Encoding]::UTF8; [System.Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ${finalCommand}`;
+        }
+        else {
+            // Unix/macOS: set locale to UTF-8 for proper encoding handling
+            finalCommand = `export LC_ALL=C.UTF-8; export LANG=C.UTF-8; export PYTHONIOENCODING=utf-8; ${finalCommand}`;
+        }
+        const shellArgs = [...args, quoteShellCommand(finalCommand)];
         try {
             if (run_in_bg) {
                 const taskId = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-                const childProcess = spawn(finalCommand, {
+                const spawnOptions = {
                     cwd: effectiveCwd || process.cwd(),
-                    shell: true,
-                    detached: true,
-                    env
-                });
+                    env,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                };
+                // On Windows, don't use detached mode for PowerShell as it breaks output piping
+                if (process.platform !== 'win32') {
+                    spawnOptions.detached = true;
+                }
+                const childProcess = spawn(shell, shellArgs, spawnOptions);
                 const output = [];
                 childProcess.stdout?.on('data', (data) => {
                     const text = data.toString();
@@ -348,43 +407,127 @@ export class BashTool {
                     output.push(text);
                 });
                 childProcess.on('close', (code) => {
-                    console.log(`Background task ${taskId} exited with code ${code}`);
+                    // Silent cleanup - don't log to avoid noise during normal operation
+                    // Note: On Windows with PowerShell, the shell process exits after
+                    // the command completes
                 });
                 const toolRegistry = getToolRegistry();
                 toolRegistry.addBackgroundTask(taskId, {
                     process: childProcess,
                     startTime: Date.now(),
-                    output
+                    output,
                 });
                 return {
                     stdout: '',
                     stderr: '',
                     exitCode: 0,
-                    taskId
+                    taskId,
                 };
             }
             else {
-                const { stdout, stderr } = await execAsync(finalCommand, {
+                // Execute command with spawn for better control
+                const result = await this.spawnWithTimeout(shell, shellArgs, {
                     cwd: effectiveCwd || process.cwd(),
-                    maxBuffer: 1024 * 1024 * 10,
-                    timeout: timeout * 1000,
-                    env
+                    env,
+                    timeout,
                 });
+                // Apply truncation to stdout and stderr separately
+                const stdoutResult = truncateTail(result.stdout);
+                const stderrResult = truncateTail(result.stderr);
+                let stdout = stdoutResult.content;
+                let stderr = stderrResult.content;
+                let truncationNotice = '';
+                if (stdoutResult.truncated) {
+                    truncationNotice += buildTruncationNotice(stdoutResult) + '\n';
+                }
+                if (stderrResult.truncated) {
+                    truncationNotice += buildTruncationNotice(stderrResult) + '\n';
+                }
                 return {
                     stdout,
                     stderr,
-                    exitCode: 0
+                    exitCode: result.exitCode,
+                    truncated: stdoutResult.truncated || stderrResult.truncated,
+                    truncationNotice: truncationNotice || undefined,
                 };
             }
         }
         catch (error) {
+            // Check if this was a timeout
+            if (error.message === 'timeout') {
+                return {
+                    stdout: '',
+                    stderr: 'Command timed out',
+                    exitCode: -1,
+                    truncated: false,
+                };
+            }
             return {
                 stdout: error.stdout || '',
                 stderr: error.stderr || error.message,
-                exitCode: error.code || 1
+                exitCode: error.code || 1,
             };
         }
     }
+    /**
+     * Execute a command with timeout support and proper process termination.
+     */
+    spawnWithTimeout(shell, args, options) {
+        return new Promise((resolve, reject) => {
+            const { cwd, env, timeout } = options;
+            let timedOut = false;
+            let timeoutHandle;
+            const spawnOptions = {
+                cwd,
+                env,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            };
+            // On Windows, don't use detached mode for PowerShell as it breaks output piping
+            if (process.platform !== 'win32') {
+                spawnOptions.detached = true;
+            }
+            const child = spawn(shell, args, spawnOptions);
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            // Set timeout if provided
+            if (timeout > 0) {
+                timeoutHandle = setTimeout(() => {
+                    timedOut = true;
+                    if (child.pid) {
+                        killProcessTree(child.pid);
+                    }
+                }, timeout * 1000);
+            }
+            // Stream stdout
+            child.stdout?.on('data', (data) => {
+                stdoutChunks.push(data);
+            });
+            // Stream stderr
+            child.stderr?.on('data', (data) => {
+                stderrChunks.push(data);
+            });
+            // Handle process exit
+            child.on('close', (code) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (timedOut) {
+                    reject(new Error('timeout'));
+                    return;
+                }
+                resolve({
+                    stdout: Buffer.concat(stdoutChunks).toString('utf-8'),
+                    stderr: Buffer.concat(stderrChunks).toString('utf-8'),
+                    exitCode: code ?? -1,
+                });
+            });
+            // Handle spawn errors
+            child.on('error', (err) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                reject(err);
+            });
+        });
+    }
 }
 export class ListDirectoryTool {
     name = 'ListDirectory';
@@ -416,7 +559,12 @@ export class ListDirectoryTool {
 - Results are absolute paths
 - Ignores node_modules and .git by default
 - Combine with Read to examine file contents`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
         const { path: dirPath = '.', recursive = false } = params;
         try {
@@ -429,9 +577,9 @@ export class ListDirectoryTool {
             const files = await glob(pattern, {
                 cwd: absolutePath,
                 nodir: false,
-                ignore: ['node_modules/**', '.git/**']
+                ignore: ['node_modules/**', '.git/**'],
             });
-            return files.map(file => path.join(absolutePath, file));
+            return files.map((file) => path.join(absolutePath, file));
         }
         catch (error) {
             throw new Error(`Failed to list directory: ${error.message}`);
@@ -440,7 +588,7 @@ export class ListDirectoryTool {
 }
 export class SearchFilesTool {
     name = 'SearchFiles';
-    description = `Search for files matching a glob pattern. This is your PRIMARY tool for finding files by name or extension.
+    description = `Search for files matching a glob pattern using fd. This is your PRIMARY tool for finding files by name or extension.
 
 # When to Use
 - Finding all files of a certain type (*.ts, *.json, *.md)
@@ -475,21 +623,35 @@ export class SearchFilesTool {
 - Combine with path parameter to search specific directories
 - Use limit parameter to avoid huge result sets
 - Results are file paths, not content (use Grep on results if needed)`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
         const { pattern, path: searchPath = '.', limit = 1000 } = params;
         try {
-            const files = await glob(pattern, {
-                cwd: searchPath,
-                ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**']
+            const output = await fdFind({
+                pattern,
+                path: searchPath,
+                limit,
             });
+            if (output === 'No files found') {
+                return {
+                    files: [],
+                    total: 0,
+                    truncated: false,
+                };
+            }
+            const files = output.split('\n').filter((line) => line.trim());
             const total = files.length;
             const truncated = total > limit;
             const result = truncated ? files.slice(0, limit) : files;
             return {
                 files: result,
                 total,
-                truncated
+                truncated,
             };
         }
         catch (error) {
@@ -532,7 +694,7 @@ export class DeleteFileTool {
             return {
                 success: true,
                 message: `Successfully deleted ${filePath}`,
-                filePath
+                filePath,
             };
         }
         catch (error) {
@@ -574,7 +736,7 @@ export class CreateDirectoryTool {
             await fs.mkdir(absolutePath, { recursive });
             return {
                 success: true,
-                message: `Successfully created directory ${dirPath}`
+                message: `Successfully created directory ${dirPath}`,
             };
         }
         catch (error) {
@@ -584,29 +746,29 @@ export class CreateDirectoryTool {
 }
 // 编辑工具辅助函数
 function detectLineEnding(content) {
-    const crlfIdx = content.indexOf("\r\n");
-    const lfIdx = content.indexOf("\n");
+    const crlfIdx = content.indexOf('\r\n');
+    const lfIdx = content.indexOf('\n');
     if (lfIdx === -1)
-        return "\n";
+        return '\n';
     if (crlfIdx === -1)
-        return "\n";
-    return crlfIdx < lfIdx ? "\r\n" : "\n";
+        return '\n';
+    return crlfIdx < lfIdx ? '\r\n' : '\n';
 }
 function normalizeToLF(text) {
-    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
 }
 function restoreLineEndings(text, ending) {
-    return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+    return ending === '\r\n' ? text.replace(/\n/g, '\r\n') : text;
 }
 function normalizeForFuzzyMatch(text) {
-    return (text
-        .split("\n")
+    return text
+        .split('\n')
         .map((line) => line.trimEnd())
-        .join("\n")
+        .join('\n')
         .replace(/['‘’""]/g, "'")
         .replace(/["""]/g, '"')
-        .replace(/[—–‑−]/g, "-")
-        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " "));
+        .replace(/[—–‑−]/g, '-')
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, ' ');
 }
 function fuzzyFindText(content, oldText) {
     const exactIndex = content.indexOf(oldText);
@@ -640,14 +802,16 @@ function fuzzyFindText(content, oldText) {
     };
 }
 function stripBom(content) {
-    return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+    return content.startsWith('\uFEFF')
+        ? { bom: '\uFEFF', text: content.slice(1) }
+        : { bom: '', text: content };
 }
 async function generateDiffString(oldContent, newContent, contextLines = 4) {
-    const diffModule = await import("diff");
+    const diffModule = await import('diff');
     const parts = diffModule.diffLines(oldContent, newContent);
     const output = [];
-    const oldLines = oldContent.split("\n");
-    const newLines = newContent.split("\n");
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
     const maxLineNum = Math.max(oldLines.length, newLines.length);
     const lineNumWidth = String(maxLineNum).length;
     let oldLineNum = 1;
@@ -656,8 +820,8 @@ async function generateDiffString(oldContent, newContent, contextLines = 4) {
     let firstChangedLine;
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
-        const raw = part.value.split("\n");
-        if (raw[raw.length - 1] === "") {
+        const raw = part.value.split('\n');
+        if (raw[raw.length - 1] === '') {
             raw.pop();
         }
         if (part.added || part.removed) {
@@ -666,12 +830,12 @@ async function generateDiffString(oldContent, newContent, contextLines = 4) {
             }
             for (const line of raw) {
                 if (part.added) {
-                    const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
+                    const lineNum = String(newLineNum).padStart(lineNumWidth, ' ');
                     output.push(`+${lineNum} ${line}`);
                     newLineNum++;
                 }
                 else {
-                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, ' ');
                     output.push(`-${lineNum} ${line}`);
                     oldLineNum++;
                 }
@@ -693,18 +857,18 @@ async function generateDiffString(oldContent, newContent, contextLines = 4) {
                     linesToShow = linesToShow.slice(0, contextLines);
                 }
                 if (skipStart > 0) {
-                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    output.push(` ${''.padStart(lineNumWidth, ' ')} ...`);
                     oldLineNum += skipStart;
                     newLineNum += skipStart;
                 }
                 for (const line of linesToShow) {
-                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, ' ');
                     output.push(` ${lineNum} ${line}`);
                     oldLineNum++;
                     newLineNum++;
                 }
                 if (skipEnd > 0) {
-                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    output.push(` ${''.padStart(lineNumWidth, ' ')} ...`);
                 }
             }
             else {
@@ -714,7 +878,7 @@ async function generateDiffString(oldContent, newContent, contextLines = 4) {
             lastWasChange = false;
         }
     }
-    return { diff: output.join("\n"), firstChangedLine };
+    return { diff: output.join('\n'), firstChangedLine };
 }
 export class EditTool {
     name = 'Edit';
@@ -779,7 +943,7 @@ edit(
             }
             // Read the file
             const buffer = await fs.readFile(absolutePath);
-            const rawContent = buffer.toString("utf-8");
+            const rawContent = buffer.toString('utf-8');
             // Strip BOM before matching
             const { bom, text: content } = stripBom(rawContent);
             const originalEnding = detectLineEnding(content);
@@ -817,7 +981,7 @@ edit(
                 };
             }
             const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-            await fs.writeFile(absolutePath, finalContent, "utf-8");
+            await fs.writeFile(absolutePath, finalContent, 'utf-8');
             const diffResult = await generateDiffString(baseContent, newContent);
             return {
                 success: true,
@@ -863,7 +1027,12 @@ export class WebSearchTool {
 - Combine with web_fetch to get full content from relevant URLs
 - Use quotes for exact phrase matching
 - Consider adding context like year or version in query`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
         const { query } = params;
         try {
@@ -877,14 +1046,14 @@ export class WebSearchTool {
             }
             const response = await axios.post(`${baseUrl}/search`, { query }, {
                 headers: {
-                    'Authorization': `Bearer ${searchApiKey}`,
-                    'Content-Type': 'application/json'
+                    Authorization: `Bearer ${searchApiKey}`,
+                    'Content-Type': 'application/json',
                 },
-                timeout: 30000
+                timeout: 30000,
             });
             return {
                 results: response.data.results || [],
-                message: `Found ${response.data.results?.length || 0} results for "${query}"`
+                message: `Found ${response.data.results?.length || 0} results for "${query}"`,
             };
         }
         catch (error) {
@@ -940,22 +1109,27 @@ Each task needs:
 - Don't batch multiple completions - update as you go
 - Keep task descriptions clear and actionable
 - Use appropriate priority levels to indicate urgency`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     todoList = [];
     async execute(params) {
         const { todos } = params;
         try {
             this.todoList = todos;
             const summary = {
-                pending: todos.filter(t => t.status === 'pending').length,
-                in_progress: todos.filter(t => t.status === 'in_progress').length,
-                completed: todos.filter(t => t.status === 'completed').length,
-                failed: todos.filter(t => t.status === 'failed').length
+                pending: todos.filter((t) => t.status === 'pending').length,
+                in_progress: todos.filter((t) => t.status === 'in_progress').length,
+                completed: todos.filter((t) => t.status === 'completed').length,
+                failed: todos.filter((t) => t.status === 'failed').length,
             };
             return {
                 success: true,
                 message: `Updated todo list: ${summary.pending} pending, ${summary.in_progress} in progress, ${summary.completed} completed, ${summary.failed} failed`,
-                todos: this.todoList
+                todos: this.todoList,
             };
         }
         catch (error) {
@@ -987,7 +1161,12 @@ export class TodoReadTool {
 # Best Practices
 - Use todo_write to modify the list, not todo_read
 - Check todo_read after todo_write to verify updates`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     todoWriteTool;
     constructor(todoWriteTool) {
         this.todoWriteTool = todoWriteTool;
@@ -997,14 +1176,14 @@ export class TodoReadTool {
             const todos = this.todoWriteTool.getTodos();
             const summary = {
                 total: todos.length,
-                pending: todos.filter(t => t.status === 'pending').length,
-                in_progress: todos.filter(t => t.status === 'in_progress').length,
-                completed: todos.filter(t => t.status === 'completed').length,
-                failed: todos.filter(t => t.status === 'failed').length
+                pending: todos.filter((t) => t.status === 'pending').length,
+                in_progress: todos.filter((t) => t.status === 'in_progress').length,
+                completed: todos.filter((t) => t.status === 'completed').length,
+                failed: todos.filter((t) => t.status === 'failed').length,
             };
             return {
                 todos,
-                summary
+                summary,
             };
         }
         catch (error) {
@@ -1051,7 +1230,12 @@ export class TaskTool {
 - Include relevant context (file paths, requirements, constraints)
 - Set appropriate executionMode if needed
 - For parallel execution, ensure tasks are truly independent`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params, _executionMode) {
         const mode = params.executionMode || _executionMode || ExecutionMode.YOLO;
         try {
@@ -1059,13 +1243,8 @@ export class TaskTool {
             const agentManager = getAgentManager(process.cwd());
             const { getConfigManager } = await import('./config.js');
             const config = getConfigManager();
-            const { AIClient } = await import('./ai-client.js');
-            const aiClient = new AIClient({
-                type: AuthType.OPENAI_COMPATIBLE,
-                apiKey: config.get('apiKey'),
-                baseUrl: config.get('baseUrl'),
-                modelName: config.get('modelName') || 'Qwen3-Coder'
-            });
+            const authConfig = config.getAuthConfig();
+            const aiClient = createAIClient(authConfig);
             const toolRegistry = getToolRegistry();
             if (params.agents && params.agents.length > 0) {
                 return await this.executeParallelAgents(params.agents, params.description, mode, agentManager, toolRegistry, aiClient);
@@ -1076,13 +1255,14 @@ export class TaskTool {
             // Support both 'prompt' and 'query' parameter names (tool definition uses 'query')
             const prompt = params.prompt || params.query;
             if (!prompt) {
-                throw new Error('Task query/prompt is required. Received params: ' + JSON.stringify({
-                    subagent_type: params.subagent_type,
-                    prompt: params.prompt,
-                    query: params.query,
-                    description: params.description,
-                    agents: params.agents?.length
-                }));
+                throw new Error('Task query/prompt is required. Received params: ' +
+                    JSON.stringify({
+                        subagent_type: params.subagent_type,
+                        prompt: params.prompt,
+                        query: params.query,
+                        description: params.description,
+                        agents: params.agents?.length,
+                    }));
             }
             const result = await this.executeSingleAgent(params.subagent_type, prompt, params.description, params.useContext ?? true, params.constraints || [], mode, agentManager, toolRegistry, aiClient, config);
             return result;
@@ -1095,11 +1275,16 @@ export class TaskTool {
      * Create unified VLM caller
      * Uses remote VLM if remoteAIClient is provided, otherwise uses local VLM
      * Both modes receive full messages array for consistent behavior
+     * @param remoteAIClient - Remote AI client for VLM calls
+     * @param taskId - Task identifier for backend tracking
+     * @param localConfig - Local VLM configuration
+     * @param isFirstVlmCallRef - Reference to boolean tracking if this is the first VLM call
+     * @param signal - Abort signal for cancellation
      */
-    createRemoteVlmCaller(remoteAIClient, taskId, localConfig, signal) {
+    createRemoteVlmCaller(remoteAIClient, taskId, localConfig, isFirstVlmCallRef, signal) {
         // Remote mode: use RemoteAIClient
         if (remoteAIClient) {
-            return this.createRemoteVLMCaller(remoteAIClient, taskId, signal);
+            return this.createRemoteVLMCaller(remoteAIClient, taskId, isFirstVlmCallRef, signal);
         }
         // Local mode: use local API
         return this.createLocalVLMCaller(localConfig, signal);
@@ -1107,11 +1292,24 @@ export class TaskTool {
     /**
      * Create remote VLM caller using RemoteAIClient
      * Now receives full messages array for consistent behavior with local mode
+     * @param remoteAIClient - Remote AI client
+     * @param taskId - Task identifier for backend tracking
+     * @param isFirstVlmCallRef - Reference to boolean tracking if this is the first VLM call
+     * @param signal - Abort signal for cancellation
      */
-    createRemoteVLMCaller(remoteAIClient, taskId, signal) {
-        return async (messages, systemPrompt) => {
+    createRemoteVLMCaller(remoteAIClient, taskId, isFirstVlmCallRef, signal) {
+        return async (messages, systemPrompt, _taskId, _isFirstVlmCallRef) => {
             try {
-                return await remoteAIClient.invokeVLM(messages, systemPrompt, { signal, taskId });
+                // Use the ref to track first call status for the backend
+                const status = isFirstVlmCallRef.current ? 'begin' : 'continue';
+                const result = await remoteAIClient.invokeVLM(messages, systemPrompt, {
+                    signal,
+                    taskId,
+                    status,
+                });
+                // Update ref after call so subsequent calls use 'continue'
+                isFirstVlmCallRef.current = false;
+                return result;
             }
             catch (error) {
                 throw new Error(`Remote VLM call failed: ${error.message}`);
@@ -1141,7 +1339,7 @@ export class TaskTool {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${apiKey}`,
+                    Authorization: `Bearer ${apiKey}`,
                 },
                 body: JSON.stringify(requestBody),
                 signal: abortSignal,
@@ -1150,7 +1348,7 @@ export class TaskTool {
                 const errorText = await response.text();
                 throw new Error(`VLM API error: ${errorText}`);
             }
-            const result = await response.json();
+            const result = (await response.json());
             return result.choices?.[0]?.message?.content || '';
         };
     }
@@ -1163,10 +1361,11 @@ export class TaskTool {
         console.log(`${indent}${colors.primaryBright(`${icons.robot} GUI Agent`)}: ${description}`);
         console.log(`${indent}${colors.border(icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length))}`);
         console.log('');
-        // Get VLM configuration (used for local mode fallback)
-        const baseUrl = config.get('guiSubagentBaseUrl') || config.get('baseUrl') || '';
-        const apiKey = config.get('guiSubagentApiKey') || config.get('apiKey') || '';
-        const modelName = config.get('guiSubagentModel') || config.get('modelName') || '';
+        // Get VLM configuration for local mode
+        // NOTE: guiSubagentBaseUrl must be explicitly configured, NOT fallback to baseUrl
+        const baseUrl = config.get('guiSubagentBaseUrl') || '';
+        const apiKey = config.get('guiSubagentApiKey') || '';
+        const modelName = config.get('guiSubagentModel') || '';
         // Determine mode: remote if remoteAIClient exists, otherwise local
         const isRemoteMode = !!remoteAIClient;
         // Log mode information
@@ -1175,11 +1374,11 @@ export class TaskTool {
         }
         else {
             console.log(`${indent}${colors.info(`${icons.brain} Using local VLM configuration`)}`);
-            // Local mode requires configuration check
-            if (!baseUrl) {
+            // Local mode requires explicit VLM configuration
+            if (!baseUrl || !apiKey || !modelName) {
                 return {
                     success: false,
-                    message: `GUI task "${description}" failed: No valid API URL configured`
+                    message: `GUI task "${description}" failed: VLM not configured. Please run /model to configure Vision-Language Model first.`,
                 };
             }
             console.log(`${indent}${colors.textMuted(`  Model: ${modelName}`)}`);
@@ -1198,23 +1397,27 @@ export class TaskTool {
                 taskId = null;
             }
         }
+        // Track first VLM call for proper status management
+        const isFirstVlmCallRef = { current: true };
         // Create remoteVlmCaller using the unified method (handles both local and remote modes)
-        const remoteVlmCaller = this.createRemoteVlmCaller(remoteAIClient, taskId, { baseUrl, apiKey, modelName });
+        const remoteVlmCaller = this.createRemoteVlmCaller(remoteAIClient, taskId, { baseUrl, apiKey, modelName }, isFirstVlmCallRef);
         // Set up stdin polling for ESC cancellation
         let rawModeEnabled = false;
         let stdinPollingInterval = null;
         const cancellationManager = getCancellationManager();
         const logger = getLogger();
         const setupStdinPolling = () => {
+            logger.debug(`[GUIAgent ESC] setupStdinPolling called, process.stdin.isTTY: ${process.stdin.isTTY}`);
             if (process.stdin.isTTY) {
                 try {
                     process.stdin.setRawMode(true);
                     rawModeEnabled = true;
                     process.stdin.resume();
                     readline.emitKeypressEvents(process.stdin);
+                    logger.debug(`[GUIAgent ESC] Raw mode enabled successfully`);
                 }
                 catch (e) {
-                    logger.debug(`[GUIAgent] Could not set raw mode: ${e}`);
+                    logger.debug(`[GUIAgent ESC] Could not set raw mode: ${e.message}`);
                 }
                 stdinPollingInterval = setInterval(() => {
                     try {
@@ -1222,14 +1425,23 @@ export class TaskTool {
                             const chunk = process.stdin.read(1);
                             if (chunk && chunk.length > 0) {
                                 const code = chunk[0];
-                                if (code === 0x1B) { // ESC
-                                    logger.debug('[GUIAgent] ESC detected!');
+                                if (code === 0x1b) {
+                                    // ESC
+                                    logger.debug('[GUIAgent ESC Polling] ESC detected! Code: 0x1b');
                                     cancellationManager.cancel();
                                 }
+                                else {
+                                    // Log other key codes for debugging
+                                    logger.debug(`[GUIAgent ESC Polling] Key code: 0x${code.toString(16)}`);
+                                }
                             }
                         }
+                        else {
+                            logger.debug('[GUIAgent ESC Polling] rawModeEnabled is false');
+                        }
                     }
                     catch (e) {
+                        logger.debug(`[GUIAgent ESC Polling] Error: ${e.message}`);
                         // Ignore polling errors
                     }
                 }, 10);
@@ -1248,7 +1460,9 @@ export class TaskTool {
         };
         cancellationManager.on('cancelled', cancelHandler);
         // Start polling for ESC
+        logger.debug(`[GUIAgent ESC] About to call setupStdinPolling`);
         setupStdinPolling();
+        logger.debug(`[GUIAgent ESC] setupStdinPolling called`);
         try {
             // Import and create GUIAgent
             const { createGUISubAgent } = await import('./gui-subagent/index.js');
@@ -1256,11 +1470,14 @@ export class TaskTool {
                 model: !isRemoteMode ? modelName : undefined,
                 modelBaseUrl: !isRemoteMode ? baseUrl : undefined,
                 modelApiKey: !isRemoteMode ? apiKey : undefined,
+                taskId: taskId || undefined,
+                isFirstVlmCallRef,
                 remoteVlmCaller,
                 isLocalMode: !isRemoteMode,
-                maxLoopCount: 30,
+                maxLoopCount: 100,
                 loopIntervalInMs: 500,
                 showAIDebugInfo: config.get('showAIDebugInfo') || false,
+                indentLevel: indentLevel,
             });
             // Add constraints to prompt if any
             const fullPrompt = prompt;
@@ -1278,7 +1495,7 @@ export class TaskTool {
                     success: true,
                     cancelled: true, // Mark as cancelled so main agent won't continue
                     message: `GUI task "${description}" cancelled by user`,
-                    result: 'Task cancelled'
+                    result: 'Task cancelled',
                 };
             }
             cleanupStdinPolling();
@@ -1286,20 +1503,58 @@ export class TaskTool {
             // Flush stdout to ensure all output is displayed before returning
             process.stdout.write('\n');
             // Return result based on GUIAgent status
+            // Always return all info except screenshots (base64) to avoid huge payload
+            const conversationsWithoutScreenshots = result.conversations.map((conv) => ({
+                ...conv,
+                screenshotBase64: undefined, // Remove screenshots to avoid huge payload
+            }));
             if (result.status === 'end') {
-                const iterations = result.conversations.filter(c => c.from === 'human' && c.screenshotBase64).length;
+                const iterations = conversationsWithoutScreenshots.filter((c) => c.from === 'human' && c.screenshotContext).length;
                 console.log(`${indent}${colors.success(`${icons.check} GUI task completed in ${iterations} iterations`)}`);
                 return {
                     success: true,
                     message: `GUI task "${description}" completed`,
-                    result: `Completed in ${iterations} iterations`
+                    result: {
+                        status: result.status,
+                        iterations,
+                        actions: conversationsWithoutScreenshots
+                            .filter((c) => c.from === 'assistant' && c.actionType)
+                            .map((c) => c.actionType),
+                        conversations: conversationsWithoutScreenshots,
+                        error: result.error,
+                    },
+                };
+            }
+            else if (result.status === 'call_llm') {
+                // Empty action or needs LLM decision - return to main agent with full context
+                console.log(`${indent}${colors.warning(`${icons.warning} GUI agent returned to main agent for LLM decision`)}`);
+                return {
+                    success: true,
+                    message: `GUI task "${description}" returned for LLM decision`,
+                    result: {
+                        status: result.status,
+                        iterations: conversationsWithoutScreenshots.filter((c) => c.from === 'human' && c.screenshotContext).length,
+                        actions: conversationsWithoutScreenshots
+                            .filter((c) => c.from === 'assistant' && c.actionType)
+                            .map((c) => c.actionType),
+                        conversations: conversationsWithoutScreenshots,
+                        error: result.error,
+                    },
                 };
             }
             else if (result.status === 'user_stopped') {
                 return {
                     success: true,
                     message: `GUI task "${description}" stopped by user`,
-                    result: 'User stopped'
+                    result: {
+                        status: result.status,
+                        iterations: conversationsWithoutScreenshots.filter((c) => c.from === 'human' && c.screenshotContext).length,
+                        actions: conversationsWithoutScreenshots
+                            .filter((c) => c.from === 'assistant' && c.actionType)
+                            .map((c) => c.actionType),
+                        conversations: conversationsWithoutScreenshots,
+                        stopped: true,
+                    },
                 };
             }
             else {
@@ -1307,7 +1562,16 @@ export class TaskTool {
                 const errorMsg = result.error || 'Unknown error';
                 return {
                     success: false,
-                    message: `GUI task "${description}" failed: ${errorMsg}`
+                    message: `GUI task "${description}" failed: ${errorMsg}`,
+                    result: {
+                        status: result.status,
+                        iterations: conversationsWithoutScreenshots.filter((c) => c.from === 'human' && c.screenshotContext).length,
+                        actions: conversationsWithoutScreenshots
+                            .filter((c) => c.from === 'assistant' && c.actionType)
+                            .map((c) => c.actionType),
+                        conversations: conversationsWithoutScreenshots,
+                        error: result.error,
+                    },
                 };
             }
         }
@@ -1323,20 +1587,20 @@ export class TaskTool {
                     success: true,
                     cancelled: true, // Mark as cancelled so main agent won't continue
                     message: `GUI task "${description}" cancelled by user`,
-                    result: 'Task cancelled'
+                    result: 'Task cancelled',
                 };
             }
             if (error.message === 'Operation cancelled by user') {
                 return {
                     success: true,
                     message: `GUI task "${description}" cancelled by user`,
-                    result: 'Task cancelled'
+                    result: 'Task cancelled',
                 };
             }
             // Return failure without throwing - let the main agent handle it
             return {
                 success: false,
-                message: `GUI task "${description}" failed: ${error.message}`
+                message: `GUI task "${description}" failed: ${error.message}`,
             };
         }
     }
@@ -1385,15 +1649,37 @@ export class TaskTool {
                 modelName = agent.model;
             }
         }
-        // Create a new AIClient for this subagent with its specific model
-        const { AIClient: SubAgentAIClient } = await import('./ai-client.js');
-        const subAgentClient = new SubAgentAIClient({
-            type: AuthType.OPENAI_COMPATIBLE,
-            apiKey: apiKey,
-            baseUrl: baseUrl,
-            modelName: modelName,
-            showAIDebugInfo: config.get('showAIDebugInfo') || false
-        });
+        // Create AI client for this subagent
+        let subAgentClient;
+        let isRemoteMode = false;
+        let mainTaskId = null;
+        const authConfig = config.getAuthConfig();
+        if (authConfig.type === AuthType.OAUTH_XAGENT) {
+            // Remote mode: try to reuse session's RemoteAIClient first
+            const session = getSingletonSession();
+            const existingClient = session?.getRemoteAIClient();
+            if (existingClient) {
+                subAgentClient = existingClient;
+                isRemoteMode = true;
+                // Get the main taskId from session - subagent shares the same taskId as the parent task
+                mainTaskId = session?.getTaskId() || null;
+            }
+            else {
+                subAgentClient = createAIClient(authConfig);
+            }
+        }
+        else {
+            // Local mode: create client with subagent-specific model config
+            const subAuthConfig = {
+                ...authConfig,
+                type: AuthType.OPENAI_COMPATIBLE,
+                apiKey: apiKey,
+                baseUrl: baseUrl,
+                modelName: modelName,
+                showAIDebugInfo: config.get('showAIDebugInfo') || false,
+            };
+            subAgentClient = createAIClient(subAuthConfig);
+        }
         const indent = '  '.repeat(indentLevel);
         const indentNext = '  '.repeat(indentLevel + 1);
         const agentName = agent.name || subagent_type;
@@ -1401,12 +1687,15 @@ export class TaskTool {
         const executionHistory = [];
         // Helper function to indent multi-line content
         const indentMultiline = (content, baseIndent) => {
-            return content.split('\n').map(line => `${baseIndent}  ${line}`).join('\n');
+            return content
+                .split('\n')
+                .map((line) => `${baseIndent}  ${line}`)
+                .join('\n');
         };
         const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, mode, agent);
         const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(agent.systemPrompt);
         const fullPrompt = constraints.length > 0
-            ? `${prompt}\n\nConstraints:\n${constraints.map(c => `- ${c}`).join('\n')}`
+            ? `${prompt}\n\nConstraints:\n${constraints.map((c) => `- ${c}`).join('\n')}`
             : prompt;
         // Set up raw mode and stdin polling for ESC detection
         const cancellationManager = getCancellationManager();
@@ -1432,7 +1721,8 @@ export class TaskTool {
                             const chunk = process.stdin.read(1);
                             if (chunk && chunk.length > 0) {
                                 const code = chunk[0];
-                                if (code === 0x1B) { // ESC
+                                if (code === 0x1b) {
+                                    // ESC
                                     logger.debug('[TaskTool] ESC detected via polling!');
                                     cancellationManager.cancel();
                                 }
@@ -1468,7 +1758,7 @@ export class TaskTool {
         };
         let messages = [
             { role: 'system', content: enhancedSystemPrompt },
-            { role: 'user', content: fullPrompt }
+            { role: 'user', content: fullPrompt },
         ];
         const availableTools = agentManager.getAvailableToolsForAgent(agent, mode);
         const allToolDefinitions = toolRegistry.getToolDefinitions();
@@ -1482,8 +1772,8 @@ export class TaskTool {
                 function: {
                     name: toolName,
                     description: `Tool: ${toolName}`,
-                    parameters: { type: 'object', properties: {}, required: [] }
-                }
+                    parameters: { type: 'object', properties: {}, required: [] },
+                },
             };
         });
         let iteration = 0;
@@ -1492,11 +1782,22 @@ export class TaskTool {
             iteration++;
             // Check for cancellation before each iteration
             checkCancellation();
-            // Use withCancellation to make API call cancellable
-            const result = await cancellationManager.withCancellation(subAgentClient.chatCompletion(messages, {
+            // Prepare chat options with taskId and model names for remote mode
+            const chatOptions = {
                 tools: toolDefinitions,
-                temperature: 0.7
-            }), `api-${subagent_type}-${iteration}`);
+                temperature: 0.7,
+            };
+            // Pass taskId, status, and model names for remote mode subagent calls
+            // Subagent shares the same taskId as the main task
+            if (isRemoteMode && mainTaskId) {
+                chatOptions.taskId = mainTaskId;
+                chatOptions.status = iteration === 1 ? 'begin' : 'continue';
+                // Pass model names to ensure subagent uses the same models as main task
+                chatOptions.llmModelName = config.get('remote_llmModelName');
+                chatOptions.vlmModelName = config.get('remote_vlmModelName');
+            }
+            // Use withCancellation to make API call cancellable
+            const result = (await cancellationManager.withCancellation(subAgentClient.chatCompletion(messages, chatOptions), `api-${subagent_type}-${iteration}`));
             // Check for cancellation after API call
             checkCancellation();
             if (!result || !result.choices || result.choices.length === 0) {
@@ -1514,8 +1815,8 @@ export class TaskTool {
             }
             else if (Array.isArray(messageContent)) {
                 const textParts = messageContent
-                    .filter(item => typeof item?.text === 'string' && item.text.trim() !== '')
-                    .map(item => item.text);
+                    .filter((item) => typeof item?.text === 'string' && item.text.trim() !== '')
+                    .map((item) => item.text);
                 contentStr = textParts.join('');
                 hasValidContent = textParts.length > 0;
             }
@@ -1531,12 +1832,21 @@ export class TaskTool {
             if (choice.finish_reason === 'length') {
                 throw new Error(`Sub-agent ${subagent_type} response truncated due to length limits`);
             }
-            // Add assistant message to conversation
-            messages.push({ role: 'assistant', content: contentStr });
+            // Add assistant message to conversation (必须包含 tool_calls，否则 tool_result 无法匹配)
+            const assistantMessage = { role: 'assistant', content: contentStr };
+            if (toolCalls && toolCalls.length > 0) {
+                assistantMessage.tool_calls = toolCalls;
+            }
+            if (reasoningContent) {
+                assistantMessage.reasoning_content = reasoningContent;
+            }
+            messages.push(assistantMessage);
             // Display reasoning content if present
             if (reasoningContent) {
                 console.log(`\n${indent}${colors.textDim(`${icons.brain} Thinking Process:`)}`);
-                const truncatedReasoning = reasoningContent.length > 500 ? reasoningContent.substring(0, 500) + '...' : reasoningContent;
+                const truncatedReasoning = reasoningContent.length > 500
+                    ? reasoningContent.substring(0, 500) + '...'
+                    : reasoningContent;
                 const indentedReasoning = indentMultiline(truncatedReasoning, indent);
                 console.log(`${indentedReasoning}\n`);
             }
@@ -1587,10 +1897,10 @@ export class TaskTool {
                             }
                             else {
                                 const statusConfig = {
-                                    'pending': { icon: icons.circle, color: colors.textMuted, label: 'Pending' },
-                                    'in_progress': { icon: icons.loading, color: colors.warning, label: 'In Progress' },
-                                    'completed': { icon: icons.success, color: colors.success, label: 'Completed' },
-                                    'failed': { icon: icons.error, color: colors.error, label: 'Failed' }
+                                    pending: { icon: icons.circle, color: colors.textMuted, label: 'Pending' },
+                                    in_progress: { icon: icons.loading, color: colors.warning, label: 'In Progress' },
+                                    completed: { icon: icons.success, color: colors.success, label: 'Completed' },
+                                    failed: { icon: icons.error, color: colors.error, label: 'Failed' },
                                 };
                                 for (const todo of todos) {
                                     const status = statusConfig[todo.status] || statusConfig['pending'];
@@ -1606,7 +1916,10 @@ export class TaskTool {
                             // Display edit result with diff
                             console.log('');
                             const diffOutput = renderDiff(toolResult.diff);
-                            const indentedDiff = diffOutput.split('\n').map(line => `${indent}  ${line}`).join('\n');
+                            const indentedDiff = diffOutput
+                                .split('\n')
+                                .map((line) => `${indent}  ${line}`)
+                                .join('\n');
                             console.log(`${indentedDiff}\n`);
                         }
                         else if (hasFilePreview) {
@@ -1647,12 +1960,12 @@ export class TaskTool {
                             status: 'success',
                             params: parsedParams,
                             result: truncatedPreview,
-                            timestamp: new Date().toISOString()
+                            timestamp: new Date().toISOString(),
                         });
                         messages.push({
                             role: 'tool',
                             content: JSON.stringify(toolResult),
-                            tool_call_id: toolCall.id
+                            tool_call_id: toolCall.id,
                         });
                     }
                     catch (error) {
@@ -1669,12 +1982,12 @@ export class TaskTool {
                                     executionHistory: {
                                         totalIterations: iteration,
                                         toolsExecuted: executionHistory.length,
-                                        successfulTools: executionHistory.filter(t => t.status === 'success').length,
-                                        failedTools: executionHistory.filter(t => t.status === 'error').length,
+                                        successfulTools: executionHistory.filter((t) => t.status === 'success').length,
+                                        failedTools: executionHistory.filter((t) => t.status === 'error').length,
                                         history: executionHistory,
-                                        cancelled: true
-                                    }
-                                }
+                                        cancelled: true,
+                                    },
+                                },
                             };
                         }
                         console.log(`${indent}${colors.error(`${icons.cross} Error:`)} ${error.message}\n`);
@@ -1684,12 +1997,12 @@ export class TaskTool {
                             status: 'error',
                             params: parsedParams,
                             error: error.message,
-                            timestamp: new Date().toISOString()
+                            timestamp: new Date().toISOString(),
                         });
                         messages.push({
                             role: 'tool',
                             content: JSON.stringify({ error: error.message }),
-                            tool_call_id: toolCall.id
+                            tool_call_id: toolCall.id,
                         });
                     }
                 }
@@ -1708,16 +2021,16 @@ export class TaskTool {
                     executionHistory: {
                         totalIterations: iteration,
                         toolsExecuted: executionHistory.length,
-                        successfulTools: executionHistory.filter(t => t.status === 'success').length,
-                        failedTools: executionHistory.filter(t => t.status === 'error').length,
-                        history: executionHistory
-                    }
-                }
+                        successfulTools: executionHistory.filter((t) => t.status === 'success').length,
+                        failedTools: executionHistory.filter((t) => t.status === 'error').length,
+                        history: executionHistory,
+                    },
+                },
             };
         }
         // Max iterations reached - return accumulated results instead of throwing error
         // Get the last assistant message content
-        const lastAssistantMsg = messages.filter(m => m.role === 'assistant').pop();
+        const lastAssistantMsg = messages.filter((m) => m.role === 'assistant').pop();
         const lastContentStr = typeof lastAssistantMsg?.content === 'string'
             ? lastAssistantMsg.content
             : JSON.stringify(lastAssistantMsg?.content || '');
@@ -1732,12 +2045,12 @@ export class TaskTool {
                 executionHistory: {
                     totalIterations: iteration,
                     toolsExecuted: executionHistory.length,
-                    successfulTools: executionHistory.filter(t => t.status === 'success').length,
-                    failedTools: executionHistory.filter(t => t.status === 'error').length,
+                    successfulTools: executionHistory.filter((t) => t.status === 'success').length,
+                    failedTools: executionHistory.filter((t) => t.status === 'error').length,
                     history: executionHistory,
-                    maxIterationsReached: true
-                }
-            }
+                    maxIterationsReached: true,
+                },
+            },
         };
     }
     async executeParallelAgents(agents, description, mode, agentManager, toolRegistry, aiClient, indentLevel = 1) {
@@ -1765,7 +2078,8 @@ export class TaskTool {
                             const chunk = process.stdin.read(1);
                             if (chunk && chunk.length > 0) {
                                 const code = chunk[0];
-                                if (code === 0x1B) { // ESC
+                                if (code === 0x1b) {
+                                    // ESC
                                     logger.debug('[ParallelAgents] ESC detected via polling!');
                                     cancellationManager.cancel();
                                 }
@@ -1801,7 +2115,7 @@ export class TaskTool {
                     success: false,
                     agent: agentTask.subagent_type,
                     description: agentTask.description,
-                    error: 'Operation cancelled by user'
+                    error: 'Operation cancelled by user',
                 };
             }
             try {
@@ -1810,7 +2124,7 @@ export class TaskTool {
                     success: true,
                     agent: agentTask.subagent_type,
                     description: agentTask.description,
-                    result: result.result
+                    result: result.result,
                 };
             }
             catch (error) {
@@ -1818,14 +2132,14 @@ export class TaskTool {
                     success: false,
                     agent: agentTask.subagent_type,
                     description: agentTask.description,
-                    error: error.message
+                    error: error.message,
                 };
             }
         });
         const results = await Promise.all(agentPromises);
         const duration = Date.now() - startTime;
-        const successfulAgents = results.filter(r => r.success);
-        const failedAgents = results.filter(r => !r.success);
+        const successfulAgents = results.filter((r) => r.success);
+        const failedAgents = results.filter((r) => !r.success);
         console.log(`${indent}${colors.success('✔')} Parallel task completed in ${colors.textMuted(duration + 'ms')}`);
         console.log(`${indent}${colors.info('ℹ')} Success: ${successfulAgents.length}/${agents.length} agents\n`);
         if (failedAgents.length > 0) {
@@ -1841,16 +2155,16 @@ export class TaskTool {
         return {
             success: failedAgents.length === 0,
             message: `Parallel task "${description}" completed: ${successfulAgents.length}/${agents.length} successful`,
-            results: successfulAgents.map(r => ({
+            results: successfulAgents.map((r) => ({
                 agent: r.agent,
                 description: r.description,
-                result: r.result
+                result: r.result,
             })),
-            errors: failedAgents.map(r => ({
+            errors: failedAgents.map((r) => ({
                 agent: r.agent,
                 description: r.description,
-                error: r.error
-            }))
+                error: r.error,
+            })),
         };
     }
 }
@@ -1882,7 +2196,12 @@ export class ReadBashOutputTool {
 - Use appropriate poll_interval based on expected task duration
 - Check status to see if task is still running or completed
 - Combine with todo_write to track background task progress`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
         const { task_id, poll_interval = 10 } = params;
         try {
@@ -1892,7 +2211,7 @@ export class ReadBashOutputTool {
                 throw new Error(`Task ${task_id} not found`);
             }
             const interval = Math.min(Math.max(poll_interval, 1), 120);
-            await new Promise(resolve => setTimeout(resolve, interval * 1000));
+            await new Promise((resolve) => setTimeout(resolve, interval * 1000));
             const duration = Date.now() - task.startTime;
             const output = task.output.join('');
             const status = task.process.exitCode === null ? 'running' : 'completed';
@@ -1900,7 +2219,7 @@ export class ReadBashOutputTool {
                 taskId: task_id,
                 output,
                 status,
-                duration: Math.floor(duration / 1000)
+                duration: Math.floor(duration / 1000),
             };
         }
         catch (error) {
@@ -1936,7 +2255,12 @@ export class WebFetchTool {
 - Use specific prompts to extract relevant information
 - Check if the page is accessible if you get errors
 - Large pages may be truncated due to size limits`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
         const { prompt } = params;
         try {
@@ -1948,7 +2272,7 @@ export class WebFetchTool {
             const response = await axios.get(url, {
                 timeout: 30000,
                 maxContentLength: 10 * 1024 * 1024,
-                validateStatus: () => true
+                validateStatus: () => true,
             });
             let content = response.data;
             if (typeof content === 'object') {
@@ -1957,7 +2281,7 @@ export class WebFetchTool {
             return {
                 content,
                 url,
-                status: response.status
+                status: response.status,
             };
         }
         catch (error) {
@@ -1998,7 +2322,12 @@ export class AskUserQuestionTool {
 - Provide options when possible for faster response
 - Use multiSelect=true when multiple answers are valid
 - Be clear and concise in question wording`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
         const { questions } = params;
         try {
@@ -2008,26 +2337,18 @@ export class AskUserQuestionTool {
             const answers = [];
             for (const q of questions) {
                 if (q.options && q.options.length > 0) {
-                    const result = await inquirer.prompt([
-                        {
-                            type: q.multiSelect ? 'checkbox' : 'list',
-                            name: 'answer',
-                            message: q.question,
-                            choices: q.options,
-                            default: q.multiSelect ? [] : q.options[0]
-                        }
-                    ]);
-                    answers.push(Array.isArray(result.answer) ? result.answer.join(', ') : result.answer);
+                    const options = q.options.map((opt) => ({ value: opt, label: opt }));
+                    const result = await select({
+                        message: q.question,
+                        options,
+                    });
+                    answers.push(result);
                 }
                 else {
-                    const result = await inquirer.prompt([
-                        {
-                            type: 'input',
-                            name: 'answer',
-                            message: q.question
-                        }
-                    ]);
-                    answers.push(result.answer);
+                    const result = (await text({
+                        message: q.question,
+                    }));
+                    answers.push(result);
                 }
             }
             return { answers };
@@ -2066,7 +2387,12 @@ export class SaveMemoryTool {
 - Keep facts concise and specific
 - Remember project-specific conventions for consistency
 - This persists across sessions (global memory)`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
         const { fact } = params;
         try {
@@ -2075,7 +2401,7 @@ export class SaveMemoryTool {
             await memoryManager.saveMemory(fact, 'global');
             return {
                 success: true,
-                message: `Successfully saved fact to memory`
+                message: `Successfully saved fact to memory`,
             };
         }
         catch (error) {
@@ -2111,14 +2437,19 @@ export class ExitPlanModeTool {
 - Include all necessary steps and considerations
 - The plan will be saved for reference during execution
 - Use this only when truly ready to start coding`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
         const { plan } = params;
         try {
             return {
                 success: true,
                 message: 'Plan completed and ready for execution',
-                plan
+                plan,
             };
         }
         catch (error) {
@@ -2162,7 +2493,7 @@ export class XmlEscapeTool {
                 { char: '<', replacement: '&lt;' },
                 { char: '>', replacement: '&gt;' },
                 { char: '"', replacement: '&quot;' },
-                { char: "'", replacement: '&apos;' }
+                { char: "'", replacement: '&apos;' },
             ];
             let changes = 0;
             for (const { char, replacement } of specialChars) {
@@ -2177,7 +2508,7 @@ export class XmlEscapeTool {
                 const additionalChars = [
                     { char: '©', replacement: '&copy;' },
                     { char: '®', replacement: '&reg;' },
-                    { char: '€', replacement: '&euro;' }
+                    { char: '€', replacement: '&euro;' },
                 ];
                 for (const { char, replacement } of additionalChars) {
                     const regex = new RegExp(this.escapeRegExp(char), 'g');
@@ -2192,7 +2523,7 @@ export class XmlEscapeTool {
             return {
                 success: true,
                 message: `Successfully escaped ${changes} character(s) in ${file_path}`,
-                changes
+                changes,
             };
         }
         catch (error) {
@@ -2232,7 +2563,12 @@ export class ImageReadTool {
 - Provide clear prompts for what to look for
 - Use task_brief for context
 - Supports PNG, JPG, GIF, WEBP, SVG, BMP`;
-    allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params) {
         const { image_input, prompt, task_brief, input_type = 'file_path', mime_type } = params;
         try {
@@ -2245,16 +2581,11 @@ export class ImageReadTool {
             else {
                 imageData = image_input;
             }
-            const { AIClient } = await import('./ai-client.js');
             const configManager = await import('./config.js');
             const { getConfigManager } = configManager;
             const config = getConfigManager();
-            const aiClient = new AIClient({
-                type: AuthType.OPENAI_COMPATIBLE,
-                apiKey: config.get('apiKey'),
-                baseUrl: config.get('baseUrl'),
-                modelName: config.get('modelName') || 'Qwen3-Coder'
-            });
+            const authConfig = config.getAuthConfig();
+            const aiClient = createAIClient(authConfig);
             const textContent = task_brief ? `${task_brief}\n\n${prompt}` : prompt;
             const messages = [
                 {
@@ -2262,19 +2593,19 @@ export class ImageReadTool {
                     content: [
                         {
                             type: 'text',
-                            text: textContent
+                            text: textContent,
                         },
                         {
                             type: 'image_url',
                             image_url: {
-                                url: `data:${mime_type || 'image/jpeg'};base64,${imageData}`
-                            }
-                        }
-                    ]
-                }
+                                url: `data:${mime_type || 'image/jpeg'};base64,${imageData}`,
+                            },
+                        },
+                    ],
+                },
             ];
             const result = await aiClient.chatCompletion(messages, {
-                temperature: 0.7
+                temperature: 0.7,
             });
             const messageContent = result.choices[0]?.message?.content;
             const analysis = typeof messageContent === 'string' ? messageContent : '';
@@ -2283,8 +2614,8 @@ export class ImageReadTool {
                 image_info: {
                     input_type,
                     prompt,
-                    task_brief
-                }
+                    task_brief,
+                },
             };
         }
         catch (error) {
@@ -2365,7 +2696,7 @@ export class InvokeSkillTool {
         const { skillId, taskDescription, inputFile, outputFile, options } = params;
         try {
             const { getSkillInvoker } = await import('./skill-invoker.js');
-            const { SkillExecutionParams } = await import('./skill-invoker.js');
+            const { SkillExecutionParams } = (await import('./skill-invoker.js'));
             const skillInvoker = getSkillInvoker();
             await skillInvoker.initialize();
             // Verify skill exists
@@ -2380,7 +2711,7 @@ export class InvokeSkillTool {
                         taskDescription,
                         inputFile,
                         outputFile,
-                        options
+                        options,
                     });
                     if (result.success) {
                         return {
@@ -2390,7 +2721,7 @@ export class InvokeSkillTool {
                             task: taskDescription,
                             result: result.output,
                             files: result.files,
-                            nextSteps: result.nextSteps
+                            nextSteps: result.nextSteps,
                         };
                     }
                     else {
@@ -2404,7 +2735,7 @@ export class InvokeSkillTool {
                 taskDescription,
                 inputFile,
                 outputFile,
-                options
+                options,
             });
             if (result.success) {
                 return {
@@ -2414,7 +2745,8 @@ export class InvokeSkillTool {
                     task: taskDescription,
                     result: result.output,
                     files: result.files,
-                    nextSteps: result.nextSteps
+                    nextSteps: result.nextSteps,
+                    skillPath: result.skillPath
                 };
             }
             else {
@@ -2542,7 +2874,8 @@ export class ToolRegistry {
         let registeredCount = 0;
         for (const [fullName, tool] of mcpTools) {
             const firstUnderscoreIndex = fullName.indexOf('__');
-            if (firstUnderscoreIndex === -1 || firstUnderscoreIndex === 0 ||
+            if (firstUnderscoreIndex === -1 ||
+                firstUnderscoreIndex === 0 ||
                 firstUnderscoreIndex === fullName.length - 2)
                 continue;
             const serverName = fullName.substring(0, firstUnderscoreIndex);
@@ -2577,7 +2910,7 @@ export class ToolRegistry {
                         const { getMCPManager } = await import('./mcp.js');
                         const mcpManager = getMCPManager();
                         return await mcpManager.callTool(fullName, params);
-                    }
+                    },
                 };
                 this.tools.set(toolName, mcpTool);
                 registeredCount++;
@@ -2621,11 +2954,11 @@ export class ToolRegistry {
         this.backgroundTasks.delete(taskId);
     }
     getToolDefinitions() {
-        return Array.from(this.tools.values()).map(tool => {
+        return Array.from(this.tools.values()).map((tool) => {
             let parameters = {
                 type: 'object',
                 properties: {},
-                required: []
+                required: [],
             };
             // Define specific parameters for each tool
             switch (tool.name) {
@@ -2635,18 +2968,18 @@ export class ToolRegistry {
                         properties: {
                             filePath: {
                                 type: 'string',
-                                description: 'The absolute path to the file to read'
+                                description: 'The absolute path to the file to read',
                             },
                             offset: {
                                 type: 'number',
-                                description: 'Optional: Line number to start reading from (0-based)'
+                                description: 'Optional: Line number to start reading from (0-based)',
                             },
                             limit: {
                                 type: 'number',
-                                description: 'Optional: Maximum number of lines to read'
-                            }
+                                description: 'Optional: Maximum number of lines to read',
+                            },
                         },
-                        required: ['filePath']
+                        required: ['filePath'],
                     };
                     break;
                 case 'Write':
@@ -2655,14 +2988,14 @@ export class ToolRegistry {
                         properties: {
                             filePath: {
                                 type: 'string',
-                                description: 'The absolute path to the file to write'
+                                description: 'The absolute path to the file to write',
                             },
                             content: {
                                 type: 'string',
-                                description: 'The content to write to the file'
-                            }
+                                description: 'The content to write to the file',
+                            },
                         },
-                        required: ['filePath', 'content']
+                        required: ['filePath', 'content'],
                     };
                     break;
                 case 'Grep':
@@ -2671,26 +3004,34 @@ export class ToolRegistry {
                         properties: {
                             pattern: {
                                 type: 'string',
-                                description: 'The regex pattern to search for'
+                                description: 'The regex pattern or literal string to search for',
                             },
                             path: {
                                 type: 'string',
-                                description: 'Optional: The path to search in (default: current directory)'
+                                description: 'Optional: The path to search in (default: current directory)',
                             },
-                            include: {
+                            glob: {
                                 type: 'string',
-                                description: 'Optional: Glob pattern to filter files'
+                                description: 'Optional: Glob pattern to filter files (e.g., "*.ts", "**/*.js")',
                             },
-                            case_sensitive: {
+                            ignoreCase: {
                                 type: 'boolean',
-                                description: 'Optional: Case-sensitive search (default: false)'
+                                description: 'Optional: Case-insensitive search (default: false)',
+                            },
+                            literal: {
+                                type: 'boolean',
+                                description: 'Optional: Treat pattern as literal string (default: false)',
                             },
                             context: {
                                 type: 'number',
-                                description: 'Optional: Number of context lines to show'
-                            }
+                                description: 'Optional: Number of context lines to show before and after',
+                            },
+                            limit: {
+                                type: 'number',
+                                description: 'Optional: Maximum number of matches to return',
+                            },
                         },
-                        required: ['pattern']
+                        required: ['pattern'],
                     };
                     break;
                 case 'Bash':
@@ -2699,26 +3040,26 @@ export class ToolRegistry {
                         properties: {
                             command: {
                                 type: 'string',
-                                description: 'The shell command to execute'
+                                description: 'The shell command to execute',
                             },
                             cwd: {
                                 type: 'string',
-                                description: 'Optional: Working directory'
+                                description: 'Optional: Working directory',
                             },
                             description: {
                                 type: 'string',
-                                description: 'Optional: Brief description of the command'
+                                description: 'Optional: Brief description of the command',
                             },
                             timeout: {
                                 type: 'number',
-                                description: 'Optional: Timeout in seconds (default: 120)'
+                                description: 'Optional: Timeout in seconds (default: 120)',
                             },
                             run_in_bg: {
                                 type: 'boolean',
-                                description: 'Optional: Run in background (default: false)'
-                            }
+                                description: 'Optional: Run in background (default: false)',
+                            },
                         },
-                        required: ['command']
+                        required: ['command'],
                     };
                     break;
                 case 'ListDirectory':
@@ -2727,14 +3068,14 @@ export class ToolRegistry {
                         properties: {
                             path: {
                                 type: 'string',
-                                description: 'Optional: The directory path to list (default: current directory)'
+                                description: 'Optional: The directory path to list (default: current directory)',
                             },
                             recursive: {
                                 type: 'boolean',
-                                description: 'Optional: List recursively (default: false)'
-                            }
+                                description: 'Optional: List recursively (default: false)',
+                            },
                         },
-                        required: []
+                        required: [],
                     };
                     break;
                 case 'SearchFiles':
@@ -2743,18 +3084,18 @@ export class ToolRegistry {
                         properties: {
                             pattern: {
                                 type: 'string',
-                                description: 'The glob pattern to match files'
+                                description: 'The glob pattern to match files',
                             },
                             path: {
                                 type: 'string',
-                                description: 'Optional: The path to search in (default: current directory)'
+                                description: 'Optional: The path to search in (default: current directory)',
                             },
                             limit: {
                                 type: 'integer',
-                                description: 'Optional: Maximum number of results to return (default: 1000)'
-                            }
+                                description: 'Optional: Maximum number of results to return (default: 1000)',
+                            },
                         },
-                        required: ['pattern']
+                        required: ['pattern'],
                     };
                     break;
                 case 'DeleteFile':
@@ -2763,10 +3104,10 @@ export class ToolRegistry {
                         properties: {
                             filePath: {
                                 type: 'string',
-                                description: 'The path to the file to delete'
-                            }
+                                description: 'The path to the file to delete',
+                            },
                         },
-                        required: ['filePath']
+                        required: ['filePath'],
                     };
                     break;
                 case 'CreateDirectory':
@@ -2775,14 +3116,14 @@ export class ToolRegistry {
                         properties: {
                             dirPath: {
                                 type: 'string',
-                                description: 'The directory path to create'
+                                description: 'The directory path to create',
                             },
                             recursive: {
                                 type: 'boolean',
-                                description: 'Optional: Create parent directories (default: true)'
-                            }
+                                description: 'Optional: Create parent directories (default: true)',
+                            },
                         },
-                        required: ['dirPath']
+                        required: ['dirPath'],
                     };
                     break;
                 case 'Edit':
@@ -2791,22 +3132,22 @@ export class ToolRegistry {
                         properties: {
                             file_path: {
                                 type: 'string',
-                                description: 'The absolute path to the file to edit'
+                                description: 'The absolute path to the file to edit',
                             },
                             instruction: {
                                 type: 'string',
-                                description: 'Description of what needs to be changed'
+                                description: 'Description of what needs to be changed',
                             },
                             old_string: {
                                 type: 'string',
-                                description: 'The exact text to replace (supports fuzzy matching)'
+                                description: 'The exact text to replace (supports fuzzy matching)',
                             },
                             new_string: {
                                 type: 'string',
-                                description: 'The new text to replace with'
-                            }
+                                description: 'The new text to replace with',
+                            },
                         },
-                        required: ['file_path', 'instruction', 'old_string', 'new_string']
+                        required: ['file_path', 'instruction', 'old_string', 'new_string'],
                     };
                     break;
                 case 'web_search':
@@ -2815,10 +3156,10 @@ export class ToolRegistry {
                         properties: {
                             query: {
                                 type: 'string',
-                                description: 'The search query'
-                            }
+                                description: 'The search query',
+                            },
                         },
-                        required: ['query']
+                        required: ['query'],
                     };
                     break;
                 case 'todo_write':
@@ -2833,21 +3174,24 @@ export class ToolRegistry {
                                     properties: {
                                         id: { type: 'string' },
                                         task: { type: 'string' },
-                                        status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'failed'] },
-                                        priority: { type: 'string', enum: ['high', 'medium', 'low'] }
+                                        status: {
+                                            type: 'string',
+                                            enum: ['pending', 'in_progress', 'completed', 'failed'],
+                                        },
+                                        priority: { type: 'string', enum: ['high', 'medium', 'low'] },
                                     },
-                                    required: ['id', 'task', 'status']
-                                }
-                            }
+                                    required: ['id', 'task', 'status'],
+                                },
+                            },
                         },
-                        required: ['todos']
+                        required: ['todos'],
                     };
                     break;
                 case 'todo_read':
                     parameters = {
                         type: 'object',
                         properties: {},
-                        required: []
+                        required: [],
                     };
                     break;
                 case 'task':
@@ -2856,7 +3200,7 @@ export class ToolRegistry {
                         properties: {
                             description: {
                                 type: 'string',
-                                description: 'Brief description of the task (3-5 words)'
+                                description: 'Brief description of the task (3-5 words)',
                             },
                             agents: {
                                 type: 'array',
@@ -2866,50 +3210,66 @@ export class ToolRegistry {
                                     properties: {
                                         description: {
                                             type: 'string',
-                                            description: 'Brief description of the sub-agent task'
+                                            description: 'Brief description of the sub-agent task',
                                         },
                                         prompt: {
                                             type: 'string',
-                                            description: 'The task for the sub-agent to perform'
+                                            description: 'The task for the sub-agent to perform',
                                         },
                                         subagent_type: {
                                             type: 'string',
-                                            enum: ['general-purpose', 'plan-agent', 'explore-agent', 'frontend-tester', 'code-reviewer', 'frontend-developer', 'backend-developer'],
-                                            description: 'The type of specialized agent'
+                                            enum: [
+                                                'general-purpose',
+                                                'plan-agent',
+                                                'explore-agent',
+                                                'frontend-tester',
+                                                'code-reviewer',
+                                                'frontend-developer',
+                                                'backend-developer',
+                                            ],
+                                            description: 'The type of specialized agent',
                                         },
                                         constraints: {
                                             type: 'array',
                                             items: { type: 'string' },
-                                            description: 'Optional: Constraints or limitations'
-                                        }
+                                            description: 'Optional: Constraints or limitations',
+                                        },
                                     },
-                                    required: ['description', 'prompt', 'subagent_type']
-                                }
+                                    required: ['description', 'prompt', 'subagent_type'],
+                                },
                             },
                             prompt: {
                                 type: 'string',
-                                description: 'Optional: The task for the agent to perform (use agents for parallel execution)'
+                                description: 'Optional: The task for the agent to perform (use agents for parallel execution)',
                             },
                             subagent_type: {
                                 type: 'string',
-                                enum: ['general-purpose', 'plan-agent', 'explore-agent', 'frontend-tester', 'code-reviewer', 'frontend-developer', 'backend-developer'],
-                                description: 'Optional: The type of specialized agent (use agents for parallel execution)'
+                                enum: [
+                                    'general-purpose',
+                                    'plan-agent',
+                                    'explore-agent',
+                                    'frontend-tester',
+                                    'code-reviewer',
+                                    'frontend-developer',
+                                    'backend-developer',
+                                ],
+                                description: 'Optional: The type of specialized agent (use agents for parallel execution)',
                             },
                             useContext: {
                                 type: 'boolean',
-                                description: 'Optional: Include main agent context'
+                                description: 'Optional: Include main agent context',
                             },
                             outputFormat: {
                                 type: 'string',
-                                description: 'Optional: Output format template'
+                                description: 'Optional: Output format template',
                             },
                             constraints: {
                                 type: 'array',
                                 items: { type: 'string' },
-                                description: 'Optional: Constraints or limitations'
-                            }
+                                description: 'Optional: Constraints or limitations',
+                            },
                         },
-                        required: ['description']
+                        required: ['description'],
                     };
                     break;
                 case 'ReadBashOutput':
@@ -2918,14 +3278,14 @@ export class ToolRegistry {
                         properties: {
                             task_id: {
                                 type: 'string',
-                                description: 'The ID of the task'
+                                description: 'The ID of the task',
                             },
                             poll_interval: {
                                 type: 'number',
-                                description: 'Optional: Polling interval in seconds (default: 10)'
-                            }
+                                description: 'Optional: Polling interval in seconds (default: 10)',
+                            },
                         },
-                        required: ['task_id']
+                        required: ['task_id'],
                     };
                     break;
                 case 'web_fetch':
@@ -2934,10 +3294,10 @@ export class ToolRegistry {
                         properties: {
                             prompt: {
                                 type: 'string',
-                                description: 'Prompt containing URL(s) and processing instructions'
-                            }
+                                description: 'Prompt containing URL(s) and processing instructions',
+                            },
                         },
-                        required: ['prompt']
+                        required: ['prompt'],
                     };
                     break;
                 case 'ask_user_question':
@@ -2955,15 +3315,15 @@ export class ToolRegistry {
                                         options: {
                                             type: 'array',
                                             items: { type: 'string' },
-                                            description: 'Available choices (2-4 options)'
+                                            description: 'Available choices (2-4 options)',
                                         },
-                                        multiSelect: { type: 'boolean' }
+                                        multiSelect: { type: 'boolean' },
                                     },
-                                    required: ['question', 'header', 'options', 'multiSelect']
-                                }
-                            }
+                                    required: ['question', 'header', 'options', 'multiSelect'],
+                                },
+                            },
                         },
-                        required: ['questions']
+                        required: ['questions'],
                     };
                     break;
                 case 'save_memory':
@@ -2972,10 +3332,10 @@ export class ToolRegistry {
                         properties: {
                             fact: {
                                 type: 'string',
-                                description: 'The specific fact to remember'
-                            }
+                                description: 'The specific fact to remember',
+                            },
                         },
-                        required: ['fact']
+                        required: ['fact'],
                     };
                     break;
                 case 'exit_plan_mode':
@@ -2984,10 +3344,10 @@ export class ToolRegistry {
                         properties: {
                             plan: {
                                 type: 'string',
-                                description: 'The plan to present'
-                            }
+                                description: 'The plan to present',
+                            },
                         },
-                        required: ['plan']
+                        required: ['plan'],
                     };
                     break;
                 case 'xml_escape':
@@ -2996,14 +3356,14 @@ export class ToolRegistry {
                         properties: {
                             file_path: {
                                 type: 'string',
-                                description: 'The absolute path to the XML/HTML file'
+                                description: 'The absolute path to the XML/HTML file',
                             },
                             escape_all: {
                                 type: 'boolean',
-                                description: 'Optional: Escape all special characters (default: false)'
-                            }
+                                description: 'Optional: Escape all special characters (default: false)',
+                            },
                         },
-                        required: ['file_path']
+                        required: ['file_path'],
                     };
                     break;
                 case 'image_read':
@@ -3012,27 +3372,27 @@ export class ToolRegistry {
                         properties: {
                             image_input: {
                                 type: 'string',
-                                description: 'Image file path or base64 data'
+                                description: 'Image file path or base64 data',
                             },
                             prompt: {
                                 type: 'string',
-                                description: 'Comprehensive VLM instruction'
+                                description: 'Comprehensive VLM instruction',
                             },
                             task_brief: {
                                 type: 'string',
-                                description: 'Brief task description (max 15 words)'
+                                description: 'Brief task description (max 15 words)',
                             },
                             input_type: {
                                 type: 'string',
                                 enum: ['file_path', 'base64'],
-                                description: 'Input type (default: file_path)'
+                                description: 'Input type (default: file_path)',
                             },
                             mime_type: {
                                 type: 'string',
-                                description: 'Optional: MIME type for base64 input'
-                            }
+                                description: 'Optional: MIME type for base64 input',
+                            },
                         },
-                        required: ['image_input', 'prompt']
+                        required: ['image_input', 'prompt'],
                     };
                     break;
                 case 'Skill':
@@ -3041,17 +3401,17 @@ export class ToolRegistry {
                         properties: {
                             skill: {
                                 type: 'string',
-                                description: 'The skill name to execute'
-                            }
+                                description: 'The skill name to execute',
+                            },
                         },
-                        required: ['skill']
+                        required: ['skill'],
                     };
                     break;
                 case 'ListSkills':
                     parameters = {
                         type: 'object',
                         properties: {},
-                        required: []
+                        required: [],
                     };
                     break;
                 case 'GetSkillDetails':
@@ -3060,10 +3420,10 @@ export class ToolRegistry {
                         properties: {
                             skill: {
                                 type: 'string',
-                                description: 'The skill name/id to get details for'
-                            }
+                                description: 'The skill name/id to get details for',
+                            },
                         },
-                        required: ['skill']
+                        required: ['skill'],
                     };
                     break;
                 default:
@@ -3074,13 +3434,13 @@ export class ToolRegistry {
                         parameters = {
                             type: 'object',
                             properties: {},
-                            required: []
+                            required: [],
                         };
                         if (mcpTool.inputSchema.properties) {
                             for (const [paramName, paramDef] of Object.entries(mcpTool.inputSchema.properties)) {
                                 parameters.properties[paramName] = {
                                     type: paramDef.type || 'string',
-                                    description: paramDef.description || ''
+                                    description: paramDef.description || '',
                                 };
                             }
                         }
@@ -3092,7 +3452,7 @@ export class ToolRegistry {
                         parameters = {
                             type: 'object',
                             properties: {},
-                            required: []
+                            required: [],
                         };
                     }
             }
@@ -3101,8 +3461,8 @@ export class ToolRegistry {
                 function: {
                     name: tool.name,
                     description: tool.description,
-                    parameters
-                }
+                    parameters,
+                },
             };
         });
     }
@@ -3128,7 +3488,7 @@ export class ToolRegistry {
                 continue;
             const [serverName, actualToolName] = [
                 fullName.substring(0, firstUnderscoreIndex),
-                fullName.substring(firstUnderscoreIndex + 2)
+                fullName.substring(firstUnderscoreIndex + 2),
             ];
             if (actualToolName === toolName) {
                 return await this.executeMCPTool(fullName, params, executionMode, indent);
@@ -3179,7 +3539,7 @@ export class ToolRegistry {
             const result = await approvalEngine.evaluate({
                 toolName,
                 params,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             });
             // Decide whether to execute based on approval result
             if (result.decision === 'approved') {
@@ -3254,7 +3614,7 @@ export class ToolRegistry {
                 const result = await approvalEngine.evaluate({
                     toolName: `MCP[${serverName}]::${actualToolName}`,
                     params,
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 });
                 if (result.decision === 'approved') {
                     console.log(`${indent}${colors.success(`✅ [Smart Mode] MCP tool '${serverName}::${actualToolName}' passed approval`)}`);