@xagent-ai/cli 1.2.0 → 1.2.2

package/dist/tools.js

@@ -35,34 +35,34 @@ const execAsync = promisify(exec);
 //
 export class ReadTool {
     name = 'Read';
-    description = `Read the contents of a file. This is your PRIMARY tool for understanding existing code, configuration, and documentation.
-
-# When to Use
-- When you need to understand existing code before making changes
-- When user asks you to "read", "show", "view", or "check" a file
-- When debugging and need to inspect source files
-- When analyzing project structure by reading key files
-- When examining configuration files (package.json, tsconfig.json, etc.)
-- When checking documentation or README files
-
-# When NOT to Use
-- For files you've already read in the same conversation (use memory instead)
-- When you only need file metadata (use ListDirectory or Bash with ls instead)
-- For binary files that cannot be read as text
-
-# Parameters
-- \`filePath\`: Absolute path or path relative to project root
-- \`offset\`: (Optional) Line number to start reading from (0-based)
-- \`limit\`: (Optional) Maximum number of lines to read
-
-# Examples
-- Read specific file: Read(filePath="/path/to/file.ts")
-- Read with pagination: Read(filePath="src/app.ts", offset=0, limit=100)
-
-# Best Practices
-- Use absolute paths or paths relative to the project root
-- Use offset and limit for large files to avoid loading entire content
-- Combine with ListDirectory to explore project structure first
+    description = `Read the contents of a file. This is your PRIMARY tool for understanding existing code, configuration, and documentation.
+
+# When to Use
+- When you need to understand existing code before making changes
+- When user asks you to "read", "show", "view", or "check" a file
+- When debugging and need to inspect source files
+- When analyzing project structure by reading key files
+- When examining configuration files (package.json, tsconfig.json, etc.)
+- When checking documentation or README files
+
+# When NOT to Use
+- For files you've already read in the same conversation (use memory instead)
+- When you only need file metadata (use ListDirectory or Bash with ls instead)
+- For binary files that cannot be read as text
+
+# Parameters
+- \`filePath\`: Absolute path or path relative to project root
+- \`offset\`: (Optional) Line number to start reading from (0-based)
+- \`limit\`: (Optional) Maximum number of lines to read
+
+# Examples
+- Read specific file: Read(filePath="/path/to/file.ts")
+- Read with pagination: Read(filePath="src/app.ts", offset=0, limit=100)
+
+# Best Practices
+- Use absolute paths or paths relative to the project root
+- 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];
     async execute(params) {
@@ -104,32 +104,32 @@ export class ReadTool {
 }
 export class WriteTool {
     name = 'Write';
-    description = `Create a new file or completely overwrite an existing file with new content.
-
-# When to Use
-- Creating new files (source code, configuration, documentation)
-- Completely replacing file content (not partial edits)
-- Generating files from templates or scratch
-- When user explicitly asks to "create", "write", or "generate" a file
-
-# When NOT to Use
-- For making small edits to existing files (use Replace instead)
-- When you only need to append content (read file first, then write)
-- For creating directories (use CreateDirectory instead)
-
-# Parameters
-- \`filePath\`: Absolute path or path relative to project root
-- \`content\`: The complete content to write to the file
-
-# Examples
-- Create new file: Write(filePath="src/utils.ts", content="...")
-- Create config file: Write(filePath=".env.example", content="API_KEY=...")
-
-# Best Practices
-- Parent directories are created automatically
-- Use appropriate file extensions
-- Ensure content is complete and syntactically correct
-- For partial edits, use Replace tool instead`;
+    description = `Create a new file or completely overwrite an existing file with new content.
+
+# When to Use
+- Creating new files (source code, configuration, documentation)
+- Completely replacing file content (not partial edits)
+- Generating files from templates or scratch
+- When user explicitly asks to "create", "write", or "generate" a file
+
+# When NOT to Use
+- For making small edits to existing files (use edit instead)
+- When you only need to append content (read file first, then write)
+- For creating directories (use CreateDirectory instead)
+
+# Parameters
+- \`filePath\`: Absolute path or path relative to project root
+- \`content\`: The complete content to write to the file
+
+# Examples
+- Create new file: Write(filePath="src/utils.ts", content="...")
+- Create config file: Write(filePath=".env.example", content="API_KEY=...")
+
+# Best Practices
+- Parent directories are created automatically
+- Use appropriate file extensions
+- Ensure content is complete and syntactically correct
+- For partial edits, use Edit tool instead`;
     allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
     async execute(params) {
         const { filePath, content } = params;
@@ -138,9 +138,15 @@ export class WriteTool {
             const dir = path.dirname(absolutePath);
             await fs.mkdir(dir, { recursive: true });
             await fs.writeFile(absolutePath, content, 'utf-8');
+            const lineCount = content.split('\n').length;
+            const preview = content.split('\n').slice(0, 10).join('\n');
+            const isTruncated = lineCount > 10;
             return {
                 success: true,
-                message: `Successfully wrote to ${filePath}`
+                message: `Successfully wrote to ${filePath}`,
+                filePath,
+                lineCount,
+                preview: isTruncated ? preview + '\n...' : preview
             };
         }
         catch (error) {
@@ -150,39 +156,39 @@ 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.
-
-# When to Use
-- Finding specific function definitions or calls
-- Searching for variable usages or imports
-- Locating error messages or log statements
-- Finding all occurrences of a pattern across the codebase
-- When you need line-by-line results with context
-
-# When NOT to Use
-- When you only need to find files containing text (use SearchCodebase instead)
-- When searching by file pattern rather than content (use SearchCodebase)
-- For very large codebases where you only need file names (SearchCodebase is faster)
-
-# 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
-- \`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")
-
-# 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 context to see the surrounding code for each match
+    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.
+
+# When to Use
+- Finding specific function definitions or calls
+- Searching for variable usages or imports
+- Locating error messages or log statements
+- Finding all occurrences of a pattern across the codebase
+- When you need line-by-line results with context
+
+# When NOT to Use
+- When you only need to find files containing text (use SearchFiles instead)
+- When searching by file pattern rather than content (use SearchFiles)
+- For very large codebases where you only need file names (SearchFiles is faster)
+
+# 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
+- \`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")
+
+# 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 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];
     async execute(params) {
@@ -258,40 +264,40 @@ export class GrepTool {
 }
 export class BashTool {
     name = 'Bash';
-    description = `Execute shell commands in the terminal. This is your PRIMARY tool for running commands, scripts, and system operations.
-
-# When to Use
-- Running build commands (npm run build, tsc, etc.)
-- Installing dependencies (npm install, pip install, etc.)
-- Running tests (npm test, pytest, etc.)
-- Git operations (git commit, git push, etc.)
-- Running linters or formatters
-- Any command-line operations
-
-# When NOT to Use
-- For file operations (use Read/Write/Replace/CreateDirectory instead)
-- For searching file content (use Grep instead)
-- For finding files (use SearchCodebase or ListDirectory instead)
-- For commands that require user interaction (non-interactive only)
-- For dangerous commands without understanding the impact
-
-# Parameters
-- \`command\`: The shell command to execute
-- \`cwd\`: (Optional) Working directory for the command
-- \`description\`: (Optional) Description of what the command does
-- \`timeout\`: (Optional) Timeout in seconds, default: 120
-- \`run_in_bg\`: (Optional) Run in background, default: false
-
-# Examples
-- Install dependencies: Bash(command="npm install", description="Install npm dependencies")
-- Run tests: Bash(command="npm test", description="Run unit tests")
-- Build project: Bash(command="npm run build", description="Build the project")
-
-# Best Practices
-- 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
-- Check the command is safe before executing
+    description = `Execute shell commands in the terminal. This is your PRIMARY tool for running commands, scripts, and system operations.
+
+# When to Use
+- Running build commands (npm run build, tsc, etc.)
+- Installing dependencies (npm install, pip install, etc.)
+- Running tests (npm test, pytest, etc.)
+- Git operations (git commit, git push, etc.)
+- Running linters or formatters
+- Any command-line operations
+
+# When NOT to Use
+- For file operations (use Read/Write/Edit/CreateDirectory instead)
+- For searching file content (use Grep instead)
+- For finding files (use SearchFiles or ListDirectory instead)
+- For commands that require user interaction (non-interactive only)
+- For dangerous commands without understanding the impact
+
+# Parameters
+- \`command\`: The shell command to execute
+- \`cwd\`: (Optional) Working directory for the command
+- \`description\`: (Optional) Description of what the command does
+- \`timeout\`: (Optional) Timeout in seconds, default: 120
+- \`run_in_bg\`: (Optional) Run in background, default: false
+
+# Examples
+- Install dependencies: Bash(command="npm install", description="Install npm dependencies")
+- Run tests: Bash(command="npm test", description="Run unit tests")
+- Build project: Bash(command="npm run build", description="Build the project")
+
+# Best Practices
+- 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
+- Check the command is safe before executing
 - Use absolute paths or paths relative to project root`;
     allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
     async execute(params) {
@@ -382,33 +388,33 @@ export class BashTool {
 }
 export class ListDirectoryTool {
     name = 'ListDirectory';
-    description = `List files and directories in a path. This is your PRIMARY tool for exploring project structure.
-
-# When to Use
-- Exploring project structure and organization
-- Finding what files exist in a directory
-- Getting an overview of the codebase layout
-- When user asks to "list files" or "show directory contents"
-- Navigating through project directories
-
-# When NOT to Use
-- When you need to read file contents (use Read instead)
-- For recursive exploration of entire codebase (use recursive=true)
-- When you need to search for specific files (use SearchCodebase instead)
-
-# Parameters
-- \`path\`: (Optional) Directory path, default: "."
-- \`recursive\`: (Optional) List recursively, default: false
-
-# Examples
-- List current directory: ListDirectory(path=".")
-- List src directory: ListDirectory(path="src")
-- List all files recursively: ListDirectory(path=".", recursive=true)
-
-# Best Practices
-- Use recursive=true to see entire subtree
-- Results are absolute paths
-- Ignores node_modules and .git by default
+    description = `List files and directories in a path. This is your PRIMARY tool for exploring project structure.
+
+# When to Use
+- Exploring project structure and organization
+- Finding what files exist in a directory
+- Getting an overview of the codebase layout
+- When user asks to "list files" or "show directory contents"
+- Navigating through project directories
+
+# When NOT to Use
+- When you need to read file contents (use Read instead)
+- For recursive exploration of entire codebase (use recursive=true)
+- When you need to search for specific files (use SearchFiles instead)
+
+# Parameters
+- \`path\`: (Optional) Directory path, default: "."
+- \`recursive\`: (Optional) List recursively, default: false
+
+# Examples
+- List current directory: ListDirectory(path=".")
+- List src directory: ListDirectory(path="src")
+- List all files recursively: ListDirectory(path=".", recursive=true)
+
+# Best Practices
+- Use recursive=true to see entire subtree
+- 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];
     async execute(params) {
@@ -432,49 +438,59 @@ export class ListDirectoryTool {
         }
     }
 }
-export class SearchCodebaseTool {
-    name = 'SearchCodebase';
-    description = `Search for files matching a glob pattern. 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)
-- Locating files in specific directories or subdirectories
-- Finding configuration files, test files, or source files
-- When you need a list of file paths, not content
-
-# When NOT to Use
-- When you need to search file contents (use Grep instead)
-- When you need to find specific text within files (use Grep instead)
-- For searching non-file patterns (use Grep or Bash)
-
-# Parameters
-- \`pattern\`: Glob pattern (e.g., "**/*.ts", "src/**/*.test.ts")
-- \`path\`: (Optional) Directory to search in, default: "."
-
-# Examples
-- Find all TypeScript files: SearchCodebase(pattern="**/*.ts")
-- Find test files: SearchCodebase(pattern="**/*.test.ts")
-- Find config files: SearchCodebase(pattern="**/config.*")
-
-# Glob Patterns
-- \`*\` matches any characters except /
-- \`**\` matches any characters including /
-- \`?\` matches single character
-- Use brackets for character classes: [abc]
-
-# Best Practices
-- Use **/*.ts for recursive search in all directories
-- Combine with path parameter to search specific directories
+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.
+
+# When to Use
+- Finding all files of a certain type (*.ts, *.json, *.md)
+- Locating files in specific directories or subdirectories
+- Finding configuration files, test files, or source files
+- When you need a list of file paths, not content
+
+# When NOT to Use
+- When you need to search file contents (use Grep instead)
+- When you need to find specific text within files (use Grep instead)
+- For searching non-file patterns (use Grep or Bash)
+
+# Parameters
+- \`pattern\`: Glob pattern (e.g., "**/*.ts", "src/**/*.test.ts")
+- \`path\`: (Optional) Directory to search in, default: "."
+- \`limit\`: (Optional) Maximum number of results to return, default: 1000
+
+# Examples
+- Find all TypeScript files: SearchFiles(pattern="**/*.ts")
+- Find test files: SearchFiles(pattern="**/*.test.ts")
+- Find config files: SearchFiles(pattern="**/config.*")
+- Limit results: SearchFiles(pattern="**/*.ts", limit=100)
+
+# Glob Patterns
+- \`*\` matches any characters except /
+- \`**\` matches any characters including /
+- \`?\` matches single character
+- Use brackets for character classes: [abc]
+
+# Best Practices
+- Use **/*.ts for recursive search in all directories
+- 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];
     async execute(params) {
-        const { pattern, path: searchPath = '.' } = params;
+        const { pattern, path: searchPath = '.', limit = 1000 } = params;
         try {
             const files = await glob(pattern, {
                 cwd: searchPath,
                 ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**']
             });
-            return files;
+            const total = files.length;
+            const truncated = total > limit;
+            const result = truncated ? files.slice(0, limit) : files;
+            return {
+                files: result,
+                total,
+                truncated
+            };
         }
         catch (error) {
             throw new Error(`Search failed: ${error.message}`);
@@ -483,29 +499,29 @@ export class SearchCodebaseTool {
 }
 export class DeleteFileTool {
     name = 'DeleteFile';
-    description = `Delete a file from the filesystem.
-
-# When to Use
-- Removing temporary or debug files
-- Cleaning up generated files
-- Removing files as part of a refactoring task
-- When user explicitly requests file deletion
-
-# When NOT to Use
-- For removing directories (use Bash with rm -rf instead)
-- When uncertain if a file should be deleted (confirm with user first)
-- For removing important source files without explicit user request
-
-# Parameters
-- \`filePath\`: Absolute path to the file to delete
-
-# Examples
-- Delete temporary file: DeleteFile(filePath="debug.log")
-- Remove unused file: DeleteFile(filePath="src/old-component.tsx")
-
-# Best Practices
-- Ensure you have the correct file path
-- Consider if the file might be needed later
+    description = `Delete a file from the filesystem.
+
+# When to Use
+- Removing temporary or debug files
+- Cleaning up generated files
+- Removing files as part of a refactoring task
+- When user explicitly requests file deletion
+
+# When NOT to Use
+- For removing directories (use Bash with rm -rf instead)
+- When uncertain if a file should be deleted (confirm with user first)
+- For removing important source files without explicit user request
+
+# Parameters
+- \`filePath\`: Absolute path to the file to delete
+
+# Examples
+- Delete temporary file: DeleteFile(filePath="debug.log")
+- Remove unused file: DeleteFile(filePath="src/old-component.tsx")
+
+# Best Practices
+- Ensure you have the correct file path
+- Consider if the file might be needed later
 - This action is irreversible - be certain before executing`;
     allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
     async execute(params) {
@@ -515,7 +531,8 @@ export class DeleteFileTool {
             await fs.unlink(absolutePath);
             return {
                 success: true,
-                message: `Successfully deleted ${filePath}`
+                message: `Successfully deleted ${filePath}`,
+                filePath
             };
         }
         catch (error) {
@@ -525,29 +542,29 @@ export class DeleteFileTool {
 }
 export class CreateDirectoryTool {
     name = 'CreateDirectory';
-    description = `Create a new directory (folder) in the filesystem.
-
-# When to Use
-- Creating project structure (src/components, tests/unit, etc.)
-- Setting up directories for new features or modules
-- Organizing files into appropriate folders
-- When user requests to create a folder structure
-
-# When NOT to Use
-- For creating parent directories while writing files (Write tool does this automatically)
-- For creating multiple nested directories at once (create step by step or use Bash)
-
-# Parameters
-- \`dirPath\`: Path of the directory to create
-- \`recursive\`: (Optional, default: true) Create parent directories if they don't exist
-
-# Examples
-- Create single directory: CreateDirectory(dirPath="src/utils")
-- Create nested structure: CreateDirectory(dirPath="src/components/buttons", recursive=true)
-
-# Best Practices
-- recursive=true (default) creates all intermediate parent directories
-- Use appropriate naming conventions (kebab-case for directories)
+    description = `Create a new directory (folder) in the filesystem.
+
+# When to Use
+- Creating project structure (src/components, tests/unit, etc.)
+- Setting up directories for new features or modules
+- Organizing files into appropriate folders
+- When user requests to create a folder structure
+
+# When NOT to Use
+- For creating parent directories while writing files (Write tool does this automatically)
+- For creating multiple nested directories at once (create step by step or use Bash)
+
+# Parameters
+- \`dirPath\`: Path of the directory to create
+- \`recursive\`: (Optional, default: true) Create parent directories if they don't exist
+
+# Examples
+- Create single directory: CreateDirectory(dirPath="src/utils")
+- Create nested structure: CreateDirectory(dirPath="src/components/buttons", recursive=true)
+
+# Best Practices
+- recursive=true (default) creates all intermediate parent directories
+- Use appropriate naming conventions (kebab-case for directories)
 - Consider the overall project structure before creating`;
     allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
     async execute(params) {
@@ -565,103 +582,286 @@ export class CreateDirectoryTool {
         }
     }
 }
-export class ReplaceTool {
-    name = 'replace';
-    description = `Replace specific text within an existing file. This is your PRIMARY tool for making targeted edits to code.
-
-# When to Use
-- Modifying specific code sections without rewriting entire files
-- Changing function implementations, variable values, or configurations
-- Fixing bugs by editing specific lines
-- Updating imports, exports, or references
-
-# When NOT to Use
-- When you need to create a completely new file (use Write instead)
-- When you want to append content to a file (read first, then Write)
-- When making changes across multiple files (use Grep to find, then Replace individually)
-
-# Parameters
-- \`file_path\`: Path to the file to edit
-- \`instruction\`: Description of what to change (for your own tracking)
-- \`old_string\`: The exact text to find and replace (must match exactly)
-- \`new_string\`: The new text to replace with
-
-# Critical Requirements
-- \`old_string\` MUST be an EXACT match, including whitespace and indentation
-- Include at least 3 lines of context before and after the target text
-- Ensure unique matching to avoid unintended replacements
-
-# Examples
-replace(
-  file_path="src/app.ts",
-  instruction="Update API endpoint",
-  old_string="const API_URL = 'https://api.old.com';",
-  new_string="const API_URL = 'https://api.new.com';"
-)
-
-# Best Practices
-- Read the file first to understand the exact content
-- Include sufficient context in old_string to ensure unique match
-- Be careful with special regex characters in old_string (they're escaped automatically)
-- If multiple occurrences exist, all will be replaced`;
+// 编辑工具辅助函数
+function detectLineEnding(content) {
+    const crlfIdx = content.indexOf("\r\n");
+    const lfIdx = content.indexOf("\n");
+    if (lfIdx === -1)
+        return "\n";
+    if (crlfIdx === -1)
+        return "\n";
+    return crlfIdx < lfIdx ? "\r\n" : "\n";
+}
+function normalizeToLF(text) {
+    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;
+}
+function normalizeForFuzzyMatch(text) {
+    return (text
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .join("\n")
+        .replace(/['‘’""]/g, "'")
+        .replace(/["""]/g, '"')
+        .replace(/[—–‑−]/g, "-")
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " "));
+}
+function fuzzyFindText(content, oldText) {
+    const exactIndex = content.indexOf(oldText);
+    if (exactIndex !== -1) {
+        return {
+            found: true,
+            index: exactIndex,
+            matchLength: oldText.length,
+            usedFuzzyMatch: false,
+            contentForReplacement: content,
+        };
+    }
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+    const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+    if (fuzzyIndex === -1) {
+        return {
+            found: false,
+            index: -1,
+            matchLength: 0,
+            usedFuzzyMatch: false,
+            contentForReplacement: content,
+        };
+    }
+    return {
+        found: true,
+        index: fuzzyIndex,
+        matchLength: fuzzyOldText.length,
+        usedFuzzyMatch: true,
+        contentForReplacement: fuzzyContent,
+    };
+}
+function stripBom(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 parts = diffModule.diffLines(oldContent, newContent);
+    const output = [];
+    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;
+    let newLineNum = 1;
+    let lastWasChange = false;
+    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] === "") {
+            raw.pop();
+        }
+        if (part.added || part.removed) {
+            if (firstChangedLine === undefined) {
+                firstChangedLine = newLineNum;
+            }
+            for (const line of raw) {
+                if (part.added) {
+                    const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
+                    output.push(`+${lineNum} ${line}`);
+                    newLineNum++;
+                }
+                else {
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    output.push(`-${lineNum} ${line}`);
+                    oldLineNum++;
+                }
+            }
+            lastWasChange = true;
+        }
+        else {
+            const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+            if (lastWasChange || nextPartIsChange) {
+                let linesToShow = raw;
+                let skipStart = 0;
+                let skipEnd = 0;
+                if (!lastWasChange) {
+                    skipStart = Math.max(0, raw.length - contextLines);
+                    linesToShow = raw.slice(skipStart);
+                }
+                if (!nextPartIsChange && linesToShow.length > contextLines) {
+                    skipEnd = linesToShow.length - contextLines;
+                    linesToShow = linesToShow.slice(0, contextLines);
+                }
+                if (skipStart > 0) {
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    oldLineNum += skipStart;
+                    newLineNum += skipStart;
+                }
+                for (const line of linesToShow) {
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    output.push(` ${lineNum} ${line}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+                if (skipEnd > 0) {
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                }
+            }
+            else {
+                oldLineNum += raw.length;
+                newLineNum += raw.length;
+            }
+            lastWasChange = false;
+        }
+    }
+    return { diff: output.join("\n"), firstChangedLine };
+}
+export class EditTool {
+    name = 'Edit';
+    description = `Edit a file by replacing exact text. This is your PRIMARY tool for making targeted edits to code.
+
+# When to Use
+- Modifying specific code sections without rewriting entire files
+- Changing function implementations, variable values, or configurations
+- Fixing bugs by editing specific lines
+- Updating imports, exports, or references
+
+# When NOT to Use
+- When you need to create a completely new file (use Write instead)
+- When you want to append content to a file (read first, then Write)
+- When making changes across multiple files (use Grep to find, then edit individually)
+
+# Parameters
+- \`file_path\`: Path to the file to edit (relative or absolute)
+- \`instruction\`: Description of what to change (for your own tracking)
+- \`old_string\`: The exact text to find and replace (must match exactly)
+- \`new_string\`: The new text to replace with
+
+# Critical Requirements
+- \`old_string\` MUST be an EXACT match, including whitespace and indentation
+- Include sufficient context (at least 3 lines) before and after the target text to ensure unique matching
+- The file must exist before editing
+
+# Fuzzy Matching
+This tool supports fuzzy matching to handle minor formatting differences:
+- Trailing whitespace is ignored
+- Smart quotes (', ", , ) are normalized to ASCII
+- Unicode dashes/hyphens are normalized to ASCII hyphen
+- Special Unicode spaces are normalized to regular space
+
+# Examples
+edit(
+  file_path="src/app.ts",
+  instruction="Update API endpoint",
+  old_string="const API_URL = 'https://api.old.com'\\nconst PORT = 8080;",
+  new_string="const API_URL = 'https://api.new.com'\\nconst PORT = 3000;"
+)
+
+# Best Practices
+- Read the file first to understand the exact content
+- Include sufficient context in old_string to ensure unique match
+- If fuzzy matching is needed, the tool will automatically apply it
+- Check the diff output to verify the change is correct`;
     allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
     async execute(params) {
         const { file_path, instruction, old_string, new_string } = params;
         try {
             const absolutePath = path.resolve(file_path);
-            const content = await fs.readFile(absolutePath, 'utf-8');
-            const occurrences = (content.match(new RegExp(this.escapeRegExp(old_string), 'g')) || []).length;
-            if (occurrences === 0) {
+            // Check if file exists
+            try {
+                await fs.access(absolutePath);
+            }
+            catch {
+                return {
+                    success: false,
+                    message: `File not found: ${file_path}`,
+                };
+            }
+            // Read the file
+            const buffer = await fs.readFile(absolutePath);
+            const rawContent = buffer.toString("utf-8");
+            // Strip BOM before matching
+            const { bom, text: content } = stripBom(rawContent);
+            const originalEnding = detectLineEnding(content);
+            const normalizedContent = normalizeToLF(content);
+            const normalizedOldText = normalizeToLF(old_string);
+            const normalizedNewText = normalizeToLF(new_string);
+            // Find the old text using fuzzy matching
+            const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+            if (!matchResult.found) {
+                return {
+                    success: false,
+                    message: `Could not find the exact text in ${file_path}. The old text must match exactly including all whitespace and newlines.`,
+                };
+            }
+            // Count occurrences using fuzzy-normalized content
+            const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
+            const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
+            const occurrences = fuzzyContent.split(fuzzyOldText).length - 1;
+            if (occurrences > 1) {
+                return {
+                    success: false,
+                    message: `Found ${occurrences} occurrences of the text in ${file_path}. The text must be unique. Please provide more context to make it unique.`,
+                };
+            }
+            // Perform replacement
+            const baseContent = matchResult.contentForReplacement;
+            const newContent = baseContent.substring(0, matchResult.index) +
+                normalizedNewText +
+                baseContent.substring(matchResult.index + matchResult.matchLength);
+            // Verify the replacement actually changed something
+            if (baseContent === newContent) {
                 return {
                     success: false,
-                    message: `No occurrences found to replace in ${file_path}`,
-                    changes: 0
+                    message: `No changes made to ${file_path}. The replacement produced identical content.`,
                 };
             }
-            const newContent = content.replace(new RegExp(this.escapeRegExp(old_string), 'g'), new_string);
-            await fs.writeFile(absolutePath, newContent, 'utf-8');
+            const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+            await fs.writeFile(absolutePath, finalContent, "utf-8");
+            const diffResult = await generateDiffString(baseContent, newContent);
             return {
                 success: true,
-                message: `Successfully replaced ${occurrences} occurrence(s) in ${file_path}`,
-                changes: occurrences
+                message: `Successfully replaced text in ${file_path}.`,
+                diff: diffResult.diff,
+                firstChangedLine: diffResult.firstChangedLine,
             };
         }
         catch (error) {
-            throw new Error(`Failed to replace in file ${file_path}: ${error.message}`);
+            return {
+                success: false,
+                message: `Failed to edit file ${file_path}: ${error.message}`,
+            };
         }
     }
-    escapeRegExp(string) {
-        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    }
 }
 export class WebSearchTool {
     name = 'web_search';
-    description = `Search the web for information. This tool queries a search API to find relevant results.
-
-# When to Use
-- When you need current information not in your training data
-- Finding documentation, tutorials, or guides
-- Researching APIs, libraries, or tools
-- Getting up-to-date information on technical topics
-- When user asks for "latest", "recent", or "current" information
-
-# When NOT to Use
-- When information is likely in the codebase or project files
-- For information that doesn't change frequently (check docs first)
-- When you can use web_fetch with a known URL instead
-- For purely conversational queries
-
-# Parameters
-- \`query\`: Search query string
-
-# Examples
-- Find React documentation: web_search(query="React useEffect documentation")
-- Get latest Node.js version: web_search(query="Node.js latest LTS version 2024")
-
-# Best Practices
-- Be specific in your query for better results
-- Combine with web_fetch to get full content from relevant URLs
-- Use quotes for exact phrase matching
+    description = `Search the web for information. This tool queries a search API to find relevant results.
+
+# When to Use
+- When you need current information not in your training data
+- Finding documentation, tutorials, or guides
+- Researching APIs, libraries, or tools
+- Getting up-to-date information on technical topics
+- When user asks for "latest", "recent", or "current" information
+
+# When NOT to Use
+- When information is likely in the codebase or project files
+- For information that doesn't change frequently (check docs first)
+- When you can use web_fetch with a known URL instead
+- For purely conversational queries
+
+# Parameters
+- \`query\`: Search query string
+
+# Examples
+- Find React documentation: web_search(query="React useEffect documentation")
+- Get latest Node.js version: web_search(query="Node.js latest LTS version 2024")
+
+# Best Practices
+- Be specific in your query for better results
+- 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];
     async execute(params) {
@@ -694,51 +894,51 @@ export class WebSearchTool {
 }
 export class TodoWriteTool {
     name = 'todo_write';
-    description = `Create and manage structured task todo lists. Use this tool VERY frequently to track your progress and give users visibility into what needs to be done.
-
-# When to Use
-- Complex, multi-step tasks (3+ steps)
-- User explicitly requests a todo list
-- User provides multiple tasks to accomplish
-- Immediately when starting work on a new feature
-- After completing a task (update status immediately)
-- Breaking down large features into smaller steps
-- Tracking independent subtasks that can be worked on
-
-# When NOT to Use
-- Single, straightforward task
-- Trivial operations in less than 3 steps
-- Purely conversational or informational responses
-- When you already have an up-to-date todo list
-
-# Task States
-- **pending** - Not started, waiting to be worked on
-- **in_progress** - Currently working on (limit ONE at a time)
-- **completed** - Finished successfully
-- **failed** - Could not complete due to errors
-
-# Task Descriptions
-Each task needs:
-- \`id\`: Unique identifier
-- \`task\`: Clear, actionable description in imperative form (e.g., "Run tests")
-- \`status\`: Current state
-- \`priority\`: high/medium/low
-
-# Examples
-\`\`\`json
-{
-  "todos": [
-    { "id": "1", "task": "Run the build and check for errors", "status": "in_progress", "priority": "high" },
-    { "id": "2", "task": "Fix any type errors found", "status": "pending", "priority": "high" },
-    { "id": "3", "task": "Write unit tests for new feature", "status": "pending", "priority": "medium" }
-  ]
-}
-\`\`\`
-
-# Best Practices
-- Mark tasks as completed IMMEDIATELY after finishing
-- Don't batch multiple completions - update as you go
-- Keep task descriptions clear and actionable
+    description = `Create and manage structured task todo lists. Use this tool VERY frequently to track your progress and give users visibility into what needs to be done.
+
+# When to Use
+- Complex, multi-step tasks (3+ steps)
+- User explicitly requests a todo list
+- User provides multiple tasks to accomplish
+- Immediately when starting work on a new feature
+- After completing a task (update status immediately)
+- Breaking down large features into smaller steps
+- Tracking independent subtasks that can be worked on
+
+# When NOT to Use
+- Single, straightforward task
+- Trivial operations in less than 3 steps
+- Purely conversational or informational responses
+- When you already have an up-to-date todo list
+
+# Task States
+- **pending** - Not started, waiting to be worked on
+- **in_progress** - Currently working on (limit ONE at a time)
+- **completed** - Finished successfully
+- **failed** - Could not complete due to errors
+
+# Task Descriptions
+Each task needs:
+- \`id\`: Unique identifier
+- \`task\`: Clear, actionable description in imperative form (e.g., "Run tests")
+- \`status\`: Current state
+- \`priority\`: high/medium/low
+
+# Examples
+\`\`\`json
+{
+  "todos": [
+    { "id": "1", "task": "Run the build and check for errors", "status": "in_progress", "priority": "high" },
+    { "id": "2", "task": "Fix any type errors found", "status": "pending", "priority": "high" },
+    { "id": "3", "task": "Write unit tests for new feature", "status": "pending", "priority": "medium" }
+  ]
+}
+\`\`\`
+
+# Best Practices
+- Mark tasks as completed IMMEDIATELY after finishing
+- 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];
     todoList = [];
@@ -768,24 +968,24 @@ Each task needs:
 }
 export class TodoReadTool {
     name = 'todo_read';
-    description = `Read the current session's todo list and get a summary of all tasks. Use this to check what tasks remain and their current status.
-
-# When to Use
-- Before starting work to understand what needs to be done
-- After completing a task to verify the todo list is updated
-- When user asks about progress or remaining tasks
-- To get an overview of task distribution (pending, in_progress, completed)
-
-# What It Returns
-- Full list of all todos with their IDs, tasks, statuses, and priorities
-- Summary counts: total, pending, in_progress, completed, failed
-
-# Examples
-- User asks: "What are we working on right now?" → Use todo_read to show current state
-- After a task completes → Check todo_read to confirm the list is accurate
-
-# Best Practices
-- Use todo_write to modify the list, not todo_read
+    description = `Read the current session's todo list and get a summary of all tasks. Use this to check what tasks remain and their current status.
+
+# When to Use
+- Before starting work to understand what needs to be done
+- After completing a task to verify the todo list is updated
+- When user asks about progress or remaining tasks
+- To get an overview of task distribution (pending, in_progress, completed)
+
+# What It Returns
+- Full list of all todos with their IDs, tasks, statuses, and priorities
+- Summary counts: total, pending, in_progress, completed, failed
+
+# Examples
+- User asks: "What are we working on right now?" → Use todo_read to show current state
+- After a task completes → Check todo_read to confirm the list is accurate
+
+# 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];
     todoWriteTool;
@@ -814,42 +1014,42 @@ export class TodoReadTool {
 }
 export class TaskTool {
     name = 'task';
-    description = `Launch specialized AI subagents to handle complex, multi-step tasks. Subagents are expert agents designed for specific domains like planning, code exploration, frontend testing, and more.
-
-# When to Use
-- Complex tasks requiring specialized expertise (planning, analysis, testing)
-- Multi-step workflows that benefit from dedicated focus
-- When you need to delegate work to avoid context overload
-- Parallel execution of independent tasks across different domains
-- User explicitly requests a specific type of agent (e.g., "use the frontend tester")
-
-# Available SubAgents
-1. **plan-agent** - Task planning and breakdown, risk analysis, implementation roadmaps
-2. **explore-agent** - Codebase exploration, architecture analysis, finding specific code
-3. **frontend-tester** - Writing and running frontend tests, UI validation
-4. **code-reviewer** - Code review, security checks, bug detection
-5. **frontend-developer** - Frontend development (React, TypeScript, modern web)
-6. **backend-developer** - Backend development (Node.js, APIs, databases)
-7. **gui-subagent** - Browser automation, visual web interactions, desktop application automation
-
-# When NOT to Use
-- Simple, straightforward tasks you can handle directly
-- Tasks that don't require specialized expertise
-- Single-step operations (use other tools instead)
-
-# Examples
-- "Analyze the authentication module and create a security report" → explore-agent
-- "Create a detailed implementation plan for feature X" → plan-agent
-- "Write unit tests for this React component" → frontend-tester
-- "Review my changes for potential bugs" → code-reviewer
-- "Automatically fill out this form and navigate the website" → gui-subagent
-- "Test the login process on the desktop application" → gui-subagent
-- "send a message to the my mom on the desktop application wechat" → gui-subagent
-
-# Best Practices
-- Provide clear, specific prompts to subagents
-- Include relevant context (file paths, requirements, constraints)
-- Set appropriate executionMode if needed
+    description = `Launch specialized AI subagents to handle complex, multi-step tasks. Subagents are expert agents designed for specific domains like planning, code exploration, frontend testing, and more.
+
+# When to Use
+- Complex tasks requiring specialized expertise (planning, analysis, testing)
+- Multi-step workflows that benefit from dedicated focus
+- When you need to delegate work to avoid context overload
+- Parallel execution of independent tasks across different domains
+- User explicitly requests a specific type of agent (e.g., "use the frontend tester")
+
+# Available SubAgents
+1. **plan-agent** - Task planning and breakdown, risk analysis, implementation roadmaps
+2. **explore-agent** - Codebase exploration, architecture analysis, finding specific code
+3. **frontend-tester** - Writing and running frontend tests, UI validation
+4. **code-reviewer** - Code review, security checks, bug detection
+5. **frontend-developer** - Frontend development (React, TypeScript, modern web)
+6. **backend-developer** - Backend development (Node.js, APIs, databases)
+7. **gui-subagent** - Browser automation, visual web interactions, desktop application automation
+
+# When NOT to Use
+- Simple, straightforward tasks you can handle directly
+- Tasks that don't require specialized expertise
+- Single-step operations (use other tools instead)
+
+# Examples
+- "Analyze the authentication module and create a security report" → explore-agent
+- "Create a detailed implementation plan for feature X" → plan-agent
+- "Write unit tests for this React component" → frontend-tester
+- "Review my changes for potential bugs" → code-reviewer
+- "Automatically fill out this form and navigate the website" → gui-subagent
+- "Test the login process on the desktop application" → gui-subagent
+- "send a message to the my mom on the desktop application wechat" → gui-subagent
+
+# Best Practices
+- Provide clear, specific prompts to subagents
+- 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];
     async execute(params, _executionMode) {
@@ -870,10 +1070,21 @@ export class TaskTool {
             if (params.agents && params.agents.length > 0) {
                 return await this.executeParallelAgents(params.agents, params.description, mode, agentManager, toolRegistry, aiClient);
             }
-            if (!params.subagent_type || !params.prompt) {
-                throw new Error('Either subagent_type and prompt, or agents array must be provided');
-            }
-            const result = await this.executeSingleAgent(params.subagent_type, params.prompt, params.description, params.useContext ?? true, params.constraints || [], mode, agentManager, toolRegistry, aiClient, config);
+            if (!params.subagent_type) {
+                throw new Error('subagent_type is required for Task tool');
+            }
+            // 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
+                }));
+            }
+            const result = await this.executeSingleAgent(params.subagent_type, prompt, params.description, params.useContext ?? true, params.constraints || [], mode, agentManager, toolRegistry, aiClient, config);
             return result;
         }
         catch (error) {
@@ -1186,6 +1397,8 @@ export class TaskTool {
         const indent = '  '.repeat(indentLevel);
         const indentNext = '  '.repeat(indentLevel + 1);
         const agentName = agent.name || subagent_type;
+        // Track execution history for better reporting to main agent
+        const executionHistory = [];
         // Helper function to indent multi-line content
         const indentMultiline = (content, baseIndent) => {
             return content.split('\n').map(line => `${baseIndent}  ${line}`).join('\n');
@@ -1291,6 +1504,7 @@ export class TaskTool {
             }
             const choice = result.choices[0];
             const messageContent = choice.message?.content;
+            const reasoningContent = choice.message?.reasoning_content || '';
             const toolCalls = choice.message.tool_calls;
             let contentStr;
             let hasValidContent = false;
@@ -1319,6 +1533,13 @@ export class TaskTool {
             }
             // Add assistant message to conversation
             messages.push({ role: 'assistant', content: contentStr });
+            // 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 indentedReasoning = indentMultiline(truncatedReasoning, indent);
+                console.log(`${indentedReasoning}\n`);
+            }
             // Display assistant response (if there's any text content) with proper indentation
             if (contentStr) {
                 console.log(`\n${indent}${colors.primaryBright(agentName)}: ${description}`);
@@ -1342,11 +1563,92 @@ export class TaskTool {
                         // Check cancellation before tool execution
                         checkCancellation();
                         const toolResult = await cancellationManager.withCancellation(toolRegistry.execute(name, parsedParams, mode, indent), `subagent-${subagent_type}-${name}-${iteration}`);
-                        // Display tool result with proper indentation for multi-line content
+                        // Get showToolDetails config to control result display
+                        const showToolDetails = config.get('showToolDetails') || false;
+                        // Prepare result preview for history
                         const resultPreview = typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult, null, 2);
                         const truncatedPreview = resultPreview.length > 200 ? resultPreview.substring(0, 200) + '...' : resultPreview;
-                        const indentedPreview = indentMultiline(truncatedPreview, indent);
-                        console.log(`${indent}${colors.success(`${icons.check} Completed`)}\n${indentedPreview}\n`);
+                        // Special handling for different tools (consistent with session.ts display logic)
+                        const isTodoTool = name === 'todo_write' || name === 'todo_read';
+                        const isEditTool = name === 'Edit';
+                        const isWriteTool = name === 'Write';
+                        const isDeleteTool = name === 'DeleteFile';
+                        const hasDiff = isEditTool && toolResult?.diff;
+                        const hasFilePreview = isWriteTool && toolResult?.preview;
+                        const hasDeleteInfo = isDeleteTool && toolResult?.filePath;
+                        // Import render functions for consistent display
+                        const { renderDiff, renderLines } = await import('./theme.js');
+                        if (isTodoTool) {
+                            // Display todo list
+                            console.log(`${indent}${colors.success(`${icons.check} Todo List:`)}`);
+                            const todos = toolResult?.todos || [];
+                            if (todos.length === 0) {
+                                console.log(`${indent}  ${colors.textMuted('No tasks')}`);
+                            }
+                            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' }
+                                };
+                                for (const todo of todos) {
+                                    const status = statusConfig[todo.status] || statusConfig['pending'];
+                                    console.log(`${indent}  ${status.color(status.icon)} ${status.color(status.label)}: ${colors.text(todo.task)}`);
+                                }
+                            }
+                            if (toolResult?.message) {
+                                console.log(`${indent}${colors.textDim(toolResult.message)}`);
+                            }
+                            console.log('');
+                        }
+                        else if (hasDiff) {
+                            // Display edit result with diff
+                            console.log('');
+                            const diffOutput = renderDiff(toolResult.diff);
+                            const indentedDiff = diffOutput.split('\n').map(line => `${indent}  ${line}`).join('\n');
+                            console.log(`${indentedDiff}\n`);
+                        }
+                        else if (hasFilePreview) {
+                            // Display new file content in preview style
+                            console.log('');
+                            console.log(`${indent}${colors.success(`${icons.file} ${toolResult.filePath}`)}`);
+                            console.log(`${indent}${colors.textDim(`  ${toolResult.lineCount} lines`)}`);
+                            console.log('');
+                            console.log(renderLines(toolResult.preview, { maxLines: 10, indent: indent + '  ' }));
+                            console.log('');
+                        }
+                        else if (hasDeleteInfo) {
+                            // Display DeleteFile result
+                            console.log('');
+                            console.log(`${indent}${colors.success(`${icons.check} Deleted: ${toolResult.filePath}`)}`);
+                            console.log('');
+                        }
+                        else if (showToolDetails) {
+                            // Show full result details
+                            const indentedPreview = indentMultiline(resultPreview, indent);
+                            console.log(`${indent}${colors.success(`${icons.check} Tool Result:`)}\n${indentedPreview}\n`);
+                        }
+                        else if (toolResult && toolResult.success === false) {
+                            // Tool failed
+                            console.log(`${indent}${colors.error(`${icons.cross} ${toolResult.message || 'Failed'}`)}\n`);
+                        }
+                        else if (toolResult) {
+                            // Show brief preview by default
+                            const indentedPreview = indentMultiline(truncatedPreview, indent);
+                            console.log(`${indent}${colors.success(`${icons.check} Completed`)}\n${indentedPreview}\n`);
+                        }
+                        else {
+                            console.log(`${indent}${colors.textDim('(no result)')}\n`);
+                        }
+                        // Record successful tool execution in history (use truncated preview to save memory)
+                        executionHistory.push({
+                            tool: name,
+                            status: 'success',
+                            params: parsedParams,
+                            result: truncatedPreview,
+                            timestamp: new Date().toISOString()
+                        });
                         messages.push({
                             role: 'tool',
                             content: JSON.stringify(toolResult),
@@ -1358,13 +1660,32 @@ export class TaskTool {
                             console.log(`${indent}${colors.warning(`⚠️  Operation cancelled`)}\n`);
                             cancellationManager.off('cancelled', cancelHandler);
                             cleanupStdinPolling();
+                            const summaryPreview = contentStr.length > 300 ? contentStr.substring(0, 300) + '...' : contentStr;
                             return {
                                 success: false,
                                 message: `Task "${description}" cancelled by user`,
-                                result: contentStr
+                                result: {
+                                    summary: summaryPreview,
+                                    executionHistory: {
+                                        totalIterations: iteration,
+                                        toolsExecuted: executionHistory.length,
+                                        successfulTools: executionHistory.filter(t => t.status === 'success').length,
+                                        failedTools: executionHistory.filter(t => t.status === 'error').length,
+                                        history: executionHistory,
+                                        cancelled: true
+                                    }
+                                }
                             };
                         }
                         console.log(`${indent}${colors.error(`${icons.cross} Error:`)} ${error.message}\n`);
+                        // Record failed tool execution in history
+                        executionHistory.push({
+                            tool: name,
+                            status: 'error',
+                            params: parsedParams,
+                            error: error.message,
+                            timestamp: new Date().toISOString()
+                        });
                         messages.push({
                             role: 'tool',
                             content: JSON.stringify({ error: error.message }),
@@ -1375,25 +1696,48 @@ export class TaskTool {
                 console.log('');
                 continue; // Continue to next iteration to get final response
             }
-            // No more tool calls, return the result
+            // No more tool calls, return the result with execution history
             cancellationManager.off('cancelled', cancelHandler);
             cleanupStdinPolling();
+            const summaryPreview = contentStr.length > 300 ? contentStr.substring(0, 300) + '...' : contentStr;
             return {
                 success: true,
                 message: `Task "${description}" completed by ${subagent_type}`,
-                result: contentStr
+                result: {
+                    summary: summaryPreview,
+                    executionHistory: {
+                        totalIterations: iteration,
+                        toolsExecuted: executionHistory.length,
+                        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 lastContent = lastAssistantMsg?.content || '';
+        const lastContentStr = typeof lastAssistantMsg?.content === 'string'
+            ? lastAssistantMsg.content
+            : JSON.stringify(lastAssistantMsg?.content || '');
         cancellationManager.off('cancelled', cancelHandler);
         cleanupStdinPolling();
+        const summaryPreview = lastContentStr.length > 300 ? lastContentStr.substring(0, 300) + '...' : lastContentStr;
         return {
             success: true,
             message: `Task "${description}" completed (max iterations reached) by ${subagent_type}`,
-            result: lastContent
+            result: {
+                summary: summaryPreview,
+                executionHistory: {
+                    totalIterations: iteration,
+                    toolsExecuted: executionHistory.length,
+                    successfulTools: executionHistory.filter(t => t.status === 'success').length,
+                    failedTools: executionHistory.filter(t => t.status === 'error').length,
+                    history: executionHistory,
+                    maxIterationsReached: true
+                }
+            }
         };
     }
     async executeParallelAgents(agents, description, mode, agentManager, toolRegistry, aiClient, indentLevel = 1) {
@@ -1512,31 +1856,31 @@ export class TaskTool {
 }
 export class ReadBashOutputTool {
     name = 'ReadBashOutput';
-    description = `Retrieve output from a background task that was started with Bash(run_in_bg=true).
-
-# When to Use
-- Checking the output of a long-running background process
-- Monitoring progress of builds, tests, or servers
-- Retrieving logs from background tasks
-- When you started a task with run_in_bg=true and need results
-
-# When NOT to Use
-- For synchronous commands (they return output directly)
-- When the background task hasn't been started yet
-- For tasks that have already completed (use Bash directly)
-
-# Parameters
-- \`task_id\`: The ID returned from the background Bash command
-- \`poll_interval\`: (Optional) Seconds to wait before checking, default: 10
-
-# Examples
-- Check build output: ReadBashOutput(task_id="task_1234567890")
-- Wait and check: ReadBashOutput(task_id="task_123", poll_interval=5)
-
-# Best Practices
-- Save the task_id from Bash response for later use
-- Use appropriate poll_interval based on expected task duration
-- Check status to see if task is still running or completed
+    description = `Retrieve output from a background task that was started with Bash(run_in_bg=true).
+
+# When to Use
+- Checking the output of a long-running background process
+- Monitoring progress of builds, tests, or servers
+- Retrieving logs from background tasks
+- When you started a task with run_in_bg=true and need results
+
+# When NOT to Use
+- For synchronous commands (they return output directly)
+- When the background task hasn't been started yet
+- For tasks that have already completed (use Bash directly)
+
+# Parameters
+- \`task_id\`: The ID returned from the background Bash command
+- \`poll_interval\`: (Optional) Seconds to wait before checking, default: 10
+
+# Examples
+- Check build output: ReadBashOutput(task_id="task_1234567890")
+- Wait and check: ReadBashOutput(task_id="task_123", poll_interval=5)
+
+# Best Practices
+- Save the task_id from Bash response for later use
+- 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];
     async execute(params) {
@@ -1566,31 +1910,31 @@ export class ReadBashOutputTool {
 }
 export class WebFetchTool {
     name = 'web_fetch';
-    description = `Fetch and extract content from a specific URL. This tool retrieves the full content of a webpage.
-
-# When to Use
-- When you have a specific URL and need its content
-- Extracting documentation from web pages
-- Fetching API documentation or guides
-- Getting content from known URLs (not for searching)
-
-# When NOT to Use
-- When you need to search but don't have a specific URL (use web_search first)
-- For pages requiring authentication or login
-- For very large files or pages (may timeout)
-- When the URL format is unknown (use web_search first)
-
-# Parameters
-- \`prompt\`: A prompt containing the URL to fetch (e.g., "Summarize https://example.com/docs")
-
-# Examples
-- Fetch documentation: web_fetch(prompt="Extract key points from https://react.dev/docs")
-- Get API spec: web_fetch(prompt="Fetch the OpenAPI spec from https://api.example.com/openapi.json")
-
-# Best Practices
-- Ensure the URL is accessible and doesn't require authentication
-- Use specific prompts to extract relevant information
-- Check if the page is accessible if you get errors
+    description = `Fetch and extract content from a specific URL. This tool retrieves the full content of a webpage.
+
+# When to Use
+- When you have a specific URL and need its content
+- Extracting documentation from web pages
+- Fetching API documentation or guides
+- Getting content from known URLs (not for searching)
+
+# When NOT to Use
+- When you need to search but don't have a specific URL (use web_search first)
+- For pages requiring authentication or login
+- For very large files or pages (may timeout)
+- When the URL format is unknown (use web_search first)
+
+# Parameters
+- \`prompt\`: A prompt containing the URL to fetch (e.g., "Summarize https://example.com/docs")
+
+# Examples
+- Fetch documentation: web_fetch(prompt="Extract key points from https://react.dev/docs")
+- Get API spec: web_fetch(prompt="Fetch the OpenAPI spec from https://api.example.com/openapi.json")
+
+# Best Practices
+- Ensure the URL is accessible and doesn't require authentication
+- 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];
     async execute(params) {
@@ -1623,36 +1967,36 @@ export class WebFetchTool {
 }
 export class AskUserQuestionTool {
     name = 'ask_user_question';
-    description = `Ask the user questions during execution to gather input, preferences, or clarifications.
-
-# When to Use
-- When you need user input or preferences to proceed
-- When a task has multiple options and user should choose
-- When clarification is needed for ambiguous requests
-- When user explicitly asks to be prompted
-
-# When NOT to Use
-- When you can make reasonable assumptions
-- For simple confirmations (just proceed with reasonable default)
-- When the information is already available in context
-- For information you should know or can infer
-
-# Parameters
-- \`questions\`: Array of questions with:
-  - \`question\`: The question text
-  - \`header\`: (Optional) Short label for the question
-  - \`options\`: (Optional) Multiple choice options
-  - \`multiSelect\`: (Optional) Allow multiple selections
-
-# Examples
-- Simple input: Ask user their preferred name
-- Multiple choice: Ask which framework to use (React, Vue, Angular)
-- Multi-select: Ask which features to include (with checkboxes)
-
-# Best Practices
-- Limit to 1-4 questions at a time
-- Provide options when possible for faster response
-- Use multiSelect=true when multiple answers are valid
+    description = `Ask the user questions during execution to gather input, preferences, or clarifications.
+
+# When to Use
+- When you need user input or preferences to proceed
+- When a task has multiple options and user should choose
+- When clarification is needed for ambiguous requests
+- When user explicitly asks to be prompted
+
+# When NOT to Use
+- When you can make reasonable assumptions
+- For simple confirmations (just proceed with reasonable default)
+- When the information is already available in context
+- For information you should know or can infer
+
+# Parameters
+- \`questions\`: Array of questions with:
+  - \`question\`: The question text
+  - \`header\`: (Optional) Short label for the question
+  - \`options\`: (Optional) Multiple choice options
+  - \`multiSelect\`: (Optional) Allow multiple selections
+
+# Examples
+- Simple input: Ask user their preferred name
+- Multiple choice: Ask which framework to use (React, Vue, Angular)
+- Multi-select: Ask which features to include (with checkboxes)
+
+# Best Practices
+- Limit to 1-4 questions at a time
+- 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];
     async execute(params) {
@@ -1695,32 +2039,32 @@ export class AskUserQuestionTool {
 }
 export class SaveMemoryTool {
     name = 'save_memory';
-    description = `Save specific information to long-term memory for future sessions. Useful for remembering user preferences, project conventions, or important facts.
-
-# When to Use
-- User explicitly asks to "remember" something
-- User provides preferences or configuration details
-- Important project conventions or patterns to remember
-- Information that should persist across sessions
-
-# When NOT to Use
-- For temporary information only needed in current session
-- For information already in project files or configuration
-- For obvious or trivial facts
-- When user doesn't explicitly want information saved
-
-# Parameters
-- \`fact\`: The specific fact or information to remember
-
-# Examples
-- Remember user preference: save_memory(fact="User prefers TypeScript over JavaScript")
-- Remember project convention: save_memory(fact="Project uses kebab-case for component files")
-- Remember important context: save_memory(fact="API endpoint is https://api.example.com/v2")
-
-# Best Practices
-- Save only when user explicitly requests or provides clear preference
-- Keep facts concise and specific
-- Remember project-specific conventions for consistency
+    description = `Save specific information to long-term memory for future sessions. Useful for remembering user preferences, project conventions, or important facts.
+
+# When to Use
+- User explicitly asks to "remember" something
+- User provides preferences or configuration details
+- Important project conventions or patterns to remember
+- Information that should persist across sessions
+
+# When NOT to Use
+- For temporary information only needed in current session
+- For information already in project files or configuration
+- For obvious or trivial facts
+- When user doesn't explicitly want information saved
+
+# Parameters
+- \`fact\`: The specific fact or information to remember
+
+# Examples
+- Remember user preference: save_memory(fact="User prefers TypeScript over JavaScript")
+- Remember project convention: save_memory(fact="Project uses kebab-case for component files")
+- Remember important context: save_memory(fact="API endpoint is https://api.example.com/v2")
+
+# Best Practices
+- Save only when user explicitly requests or provides clear preference
+- 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];
     async execute(params) {
@@ -1741,31 +2085,31 @@ export class SaveMemoryTool {
 }
 export class ExitPlanModeTool {
     name = 'exit_plan_mode';
-    description = `Complete plan presentation in plan mode and transition to execution. This tool is used when you have finished planning and are ready to implement.
-
-# When to Use
-- When you have completed creating a plan or design document
-- When the plan is ready for review and execution
-- After presenting the full implementation plan to the user
-- When ready to transition from planning to coding
-
-# When NOT to Use
-- When still in the middle of planning (continue planning first)
-- When the plan needs revision based on feedback
-- When user hasn't reviewed the plan yet
-- In non-plan execution modes
-
-# Parameters
-- \`plan\`: The complete plan text to be saved and executed
-
-# Examples
-- Exit after creating implementation plan
-- Present final design and exit to implementation
-
-# Best Practices
-- Ensure the plan is complete and comprehensive
-- Include all necessary steps and considerations
-- The plan will be saved for reference during execution
+    description = `Complete plan presentation in plan mode and transition to execution. This tool is used when you have finished planning and are ready to implement.
+
+# When to Use
+- When you have completed creating a plan or design document
+- When the plan is ready for review and execution
+- After presenting the full implementation plan to the user
+- When ready to transition from planning to coding
+
+# When NOT to Use
+- When still in the middle of planning (continue planning first)
+- When the plan needs revision based on feedback
+- When user hasn't reviewed the plan yet
+- In non-plan execution modes
+
+# Parameters
+- \`plan\`: The complete plan text to be saved and executed
+
+# Examples
+- Exit after creating implementation plan
+- Present final design and exit to implementation
+
+# Best Practices
+- Ensure the plan is complete and comprehensive
+- 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];
     async execute(params) {
@@ -1784,28 +2128,28 @@ export class ExitPlanModeTool {
 }
 export class XmlEscapeTool {
     name = 'xml_escape';
-    description = `Automatically escape special characters in XML/HTML files to make them valid.
-
-# When to Use
-- When content contains special XML characters (<, >, &, ", ')
-- When generating XML/HTML from raw content
-- When fixing encoding issues in markup files
-
-# When NOT to Use
-- For files that should contain raw XML/HTML
-- For JavaScript, CSS, or other non-XML files
-- When escaping should be done manually
-
-# Parameters
-- \`file_path\`: Path to the file to escape
-- \`escape_all\`: (Optional) Also escape additional entities (©, ®, €)
-
-# Examples
-- Escape XML content in HTML file
-- Fix special characters in generated markup
-
-# Best Practices
-- Backup files before escaping if unsure
+    description = `Automatically escape special characters in XML/HTML files to make them valid.
+
+# When to Use
+- When content contains special XML characters (<, >, &, ", ')
+- When generating XML/HTML from raw content
+- When fixing encoding issues in markup files
+
+# When NOT to Use
+- For files that should contain raw XML/HTML
+- For JavaScript, CSS, or other non-XML files
+- When escaping should be done manually
+
+# Parameters
+- \`file_path\`: Path to the file to escape
+- \`escape_all\`: (Optional) Also escape additional entities (©, ®, €)
+
+# Examples
+- Escape XML content in HTML file
+- Fix special characters in generated markup
+
+# Best Practices
+- Backup files before escaping if unsure
 - escape_all=true adds common HTML entities`;
     allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
     async execute(params) {
@@ -1861,32 +2205,32 @@ export class XmlEscapeTool {
 }
 export class ImageReadTool {
     name = 'image_read';
-    description = `Read image files and generate detailed analysis using a vision-language model.
-
-# When to Use
-- Analyzing UI designs or mockups
-- Examining screenshots or diagrams
-- Extracting information from images
-- Validating visual content or assets
-
-# When NOT to Use
-- For text-based file analysis (use Read instead)
-- When the image is not relevant to the task
-- For very large images (may have size limits)
-
-# Parameters
-- \`image_input\`: Path to image or base64 data
-- \`prompt\`: Instructions for what to analyze
-- \`input_type\`: (Optional) 'file_path' or 'base64'
-- \`task_brief\`: (Optional) Brief task description
-
-# Examples
-- Analyze UI mockup: image_read(image_input="design.png", prompt="Describe the UI components")
-- Validate screenshot: image_read(image_input="screenshot.jpg", prompt="Check if login form is visible")
-
-# Best Practices
-- Provide clear prompts for what to look for
-- Use task_brief for context
+    description = `Read image files and generate detailed analysis using a vision-language model.
+
+# When to Use
+- Analyzing UI designs or mockups
+- Examining screenshots or diagrams
+- Extracting information from images
+- Validating visual content or assets
+
+# When NOT to Use
+- For text-based file analysis (use Read instead)
+- When the image is not relevant to the task
+- For very large images (may have size limits)
+
+# Parameters
+- \`image_input\`: Path to image or base64 data
+- \`prompt\`: Instructions for what to analyze
+- \`input_type\`: (Optional) 'file_path' or 'base64'
+- \`task_brief\`: (Optional) Brief task description
+
+# Examples
+- Analyze UI mockup: image_read(image_input="design.png", prompt="Describe the UI components")
+- Validate screenshot: image_read(image_input="screenshot.jpg", prompt="Check if login form is visible")
+
+# Best Practices
+- 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];
     async execute(params) {
@@ -1990,31 +2334,31 @@ export class ImageReadTool {
 // }
 export class InvokeSkillTool {
     name = 'InvokeSkill';
-    description = `Invoke a specialized skill to handle domain-specific tasks. Skills are AI-powered capabilities that understand complex requirements and generate high-quality outputs (see Available Skills section below for the list of skills).
-
-# When to Use
-- When user requests involve document processing (Word, PDF, PowerPoint)
-- When user wants to create frontend interfaces or web applications
-- When user needs visual design, posters, or generative art
-- When user asks for documentation or internal communications
-- When the task matches a specific skill domain
-
-# When NOT to Use
-- For simple file operations (use Read/Write instead)
-- For basic code changes (use Replace/Write instead)
-- When a regular tool can accomplish the task
-
-# Parameters
-- \`skillId\`: The skill identifier (see Available Skills section)
-- \`taskDescription\`: Detailed description of what to accomplish
-- \`inputFile\`: (Optional) Path to input file if applicable
-- \`outputFile\`: (Optional) Desired output file path
-- \`options\`: (Optional) Additional options for the skill
-
-# Best Practices
-- Provide detailed task descriptions for better results
-- Include relevant file paths when working with existing files
-- Match the skill to the domain (e.g., don't use frontend-design for Word docs)
+    description = `Invoke a specialized skill to handle domain-specific tasks. Skills are AI-powered capabilities that understand complex requirements and generate high-quality outputs (see Available Skills section below for the list of skills).
+
+# When to Use
+- When user requests involve document processing (Word, PDF, PowerPoint)
+- When user wants to create frontend interfaces or web applications
+- When user needs visual design, posters, or generative art
+- When user asks for documentation or internal communications
+- When the task matches a specific skill domain
+
+# When NOT to Use
+- For simple file operations (use Read/Write instead)
+- For basic code changes (use Edit/Write instead)
+- When a regular tool can accomplish the task
+
+# Parameters
+- \`skillId\`: The skill identifier (see Available Skills section)
+- \`taskDescription\`: Detailed description of what to accomplish
+- \`inputFile\`: (Optional) Path to input file if applicable
+- \`outputFile\`: (Optional) Desired output file path
+- \`options\`: (Optional) Additional options for the skill
+
+# Best Practices
+- Provide detailed task descriptions for better results
+- Include relevant file paths when working with existing files
+- Match the skill to the domain (e.g., don't use frontend-design for Word docs)
 - Skills will guide you through their specific workflows`;
     allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
     async execute(params, _executionMode) {
@@ -2161,10 +2505,10 @@ export class ToolRegistry {
         this.register(new GrepTool());
         this.register(new BashTool());
         this.register(new ListDirectoryTool());
-        this.register(new SearchCodebaseTool());
+        this.register(new SearchFilesTool());
         this.register(new DeleteFileTool());
         this.register(new CreateDirectoryTool());
-        this.register(new ReplaceTool());
+        this.register(new EditTool());
         this.register(new WebSearchTool());
         this.register(this.todoWriteTool);
         this.register(new TodoReadTool(this.todoWriteTool));
@@ -2393,7 +2737,7 @@ export class ToolRegistry {
                         required: []
                     };
                     break;
-                case 'SearchCodebase':
+                case 'SearchFiles':
                     parameters = {
                         type: 'object',
                         properties: {
@@ -2404,6 +2748,10 @@ export class ToolRegistry {
                             path: {
                                 type: 'string',
                                 description: 'Optional: The path to search in (default: current directory)'
+                            },
+                            limit: {
+                                type: 'integer',
+                                description: 'Optional: Maximum number of results to return (default: 1000)'
                             }
                         },
                         required: ['pattern']
@@ -2437,13 +2785,13 @@ export class ToolRegistry {
                         required: ['dirPath']
                     };
                     break;
-                case 'replace':
+                case 'Edit':
                     parameters = {
                         type: 'object',
                         properties: {
                             file_path: {
                                 type: 'string',
-                                description: 'The absolute path to the file'
+                                description: 'The absolute path to the file to edit'
                             },
                             instruction: {
                                 type: 'string',
@@ -2451,11 +2799,11 @@ export class ToolRegistry {
                             },
                             old_string: {
                                 type: 'string',
-                                description: 'The exact text to replace'
+                                description: 'The exact text to replace (supports fuzzy matching)'
                             },
                             new_string: {
                                 type: 'string',
-                                description: 'The exact text to replace with'
+                                description: 'The new text to replace with'
                             }
                         },
                         required: ['file_path', 'instruction', 'old_string', 'new_string']