@compilr-dev/agents 0.3.16 → 0.3.18

package/dist/context/result-compactor.js

@@ -0,0 +1,165 @@
+/**
+ * Compact Tool Result Formatting — Phase 2 of Advanced Token Optimization
+ *
+ * Replaces JSON.stringify for tool results in the LLM messages array.
+ * Per-tool formatters strip JSON overhead (escaped newlines, metadata fields)
+ * and produce a text format the LLM can parse just as well.
+ *
+ * Only affects what the LLM reads in its message history.
+ * CLI formatters, events, and hooks still receive the raw ToolExecutionResult.
+ */
+// ============================================================
+// Helpers
+// ============================================================
+/** Safely extract a string field from an unknown record. */
+function str(value, fallback = '') {
+    return typeof value === 'string' ? value : fallback;
+}
+/** Safely extract a number field from an unknown record. */
+function num(value, fallback = 0) {
+    return typeof value === 'number' ? value : fallback;
+}
+// ============================================================
+// Public API
+// ============================================================
+/**
+ * Format a tool result as compact text for LLM context.
+ * Falls back to JSON.stringify for unknown tools or non-object results.
+ */
+export function compactToolResult(toolName, result, input) {
+    // String results — already compact
+    if (typeof result === 'string')
+        return result;
+    if (result === null || result === undefined)
+        return '';
+    // Per-tool formatters
+    const formatter = TOOL_FORMATTERS.get(toolName);
+    if (formatter)
+        return formatter(result, input);
+    // Fallback: JSON.stringify (current behavior)
+    return JSON.stringify(result);
+}
+const TOOL_FORMATTERS = new Map([
+    ['read_file', formatReadFile],
+    ['bash', formatBash],
+    ['bash_output', formatBash],
+    ['grep', formatGrep],
+    ['glob', formatGlob],
+    ['edit', formatEdit],
+    ['write_file', formatWriteFile],
+]);
+/**
+ * read_file → [path 200L] + content
+ */
+function formatReadFile(r) {
+    const path = str(r.path);
+    const content = str(r.content);
+    const totalLines = typeof r.totalLines === 'number' ? r.totalLines : undefined;
+    const linesReturned = typeof r.linesReturned === 'number' ? r.linesReturned : undefined;
+    const truncated = r.truncated === true;
+    // Header: [path NL] or [path M/NL] if truncated
+    let header;
+    if (truncated && linesReturned !== undefined && totalLines !== undefined) {
+        header = `[${path} ${String(linesReturned)}/${String(totalLines)}L]`;
+    }
+    else if (totalLines !== undefined) {
+        header = `[${path} ${String(totalLines)}L]`;
+    }
+    else {
+        header = `[${path}]`;
+    }
+    return `${header}\n${content}`;
+}
+/**
+ * bash → $ command\nstdout\n[stderr]\nstderr
+ * Non-zero exit: [exit:N] $ command\n...
+ * Background: shell_id message
+ */
+function formatBash(r, input) {
+    // Background execution has different shape
+    if (r.shell_id) {
+        return `[bg:${str(r.shell_id)}] ${str(r.message)}`;
+    }
+    const stdout = str(r.stdout);
+    const stderr = str(r.stderr);
+    const exitCode = num(r.exitCode);
+    const command = input ? str(input.command) : '';
+    const parts = [];
+    // Command line
+    if (command) {
+        const prefix = exitCode !== 0 ? `[exit:${String(exitCode)}] ` : '';
+        parts.push(`${prefix}$ ${command}`);
+    }
+    else if (exitCode !== 0) {
+        parts.push(`[exit:${String(exitCode)}]`);
+    }
+    // stdout
+    if (stdout) {
+        parts.push(stdout);
+    }
+    // stderr (only if non-empty)
+    if (stderr) {
+        parts.push('[stderr]');
+        parts.push(stderr);
+    }
+    return parts.join('\n');
+}
+/**
+ * grep → N matches in M files:\n...matches
+ * Files-only mode → N files matching:\n...files
+ */
+function formatGrep(r) {
+    const count = num(r.count);
+    // Files-only mode (has `files` array)
+    if (Array.isArray(r.files)) {
+        const files = r.files;
+        if (files.length === 0)
+            return '0 files matching';
+        return `${String(count)} files matching:\n${files.join('\n')}`;
+    }
+    // Matches mode
+    const matches = Array.isArray(r.matches) ? r.matches : undefined;
+    const filesSearched = typeof r.filesSearched === 'number' ? r.filesSearched : undefined;
+    if (!matches || matches.length === 0) {
+        return filesSearched ? `0 matches in ${String(filesSearched)} files` : '0 matches';
+    }
+    const summary = filesSearched
+        ? `${String(count)} matches in ${String(filesSearched)} files:`
+        : `${String(count)} matches:`;
+    return `${summary}\n${matches.join('\n')}`;
+}
+/**
+ * glob → N files:\n...files
+ */
+function formatGlob(r) {
+    const files = Array.isArray(r.files) ? r.files : undefined;
+    const count = num(r.count);
+    if (!files || files.length === 0)
+        return '0 files';
+    return `${String(count)} files:\n${files.join('\n')}`;
+}
+/**
+ * edit → OK path (N replacements)
+ */
+function formatEdit(r) {
+    const filePath = str(r.filePath);
+    const replacements = num(r.replacements);
+    const created = r.created === true;
+    if (created) {
+        return `OK created ${filePath}`;
+    }
+    return `OK ${filePath} (${String(replacements)} replacement${replacements !== 1 ? 's' : ''})`;
+}
+/**
+ * write_file → OK wrote path (NB)
+ */
+function formatWriteFile(r) {
+    const path = str(r.path);
+    const bytesWritten = typeof r.bytesWritten === 'number' ? r.bytesWritten : undefined;
+    const mode = str(r.mode);
+    const action = mode === 'appended' ? 'appended' : 'wrote';
+    if (bytesWritten !== undefined) {
+        return `OK ${action} ${path} (${String(bytesWritten)}B)`;
+    }
+    return `OK ${action} ${path}`;
+}

package/dist/index.d.ts

@@ -39,8 +39,8 @@ export type { ToolPairingValidation } from './messages/index.js';
 export { generateId, sleep, retry, truncate, withRetryGenerator, calculateBackoffDelay, DEFAULT_RETRY_CONFIG, countTokens, countMessageTokens, } from './utils/index.js';
 export type { RetryConfig as LLMRetryConfig, WithRetryOptions } from './utils/index.js';
 export { AgentError, ProviderError, ToolError, ToolTimeoutError, ToolLoopError, ValidationError, MaxIterationsError, AbortError, ContextOverflowError, isAgentError, isProviderError, isToolError, isToolTimeoutError, isToolLoopError, isContextOverflowError, wrapError, } from './errors.js';
-export { ContextManager, DEFAULT_CONTEXT_CONFIG, FileAccessTracker, createFileTrackingHook, TRACKED_TOOLS, DelegatedResultStore, ToolResultDelegator, DELEGATION_SYSTEM_PROMPT, DEFAULT_DELEGATION_CONFIG, } from './context/index.js';
-export type { ContextManagerOptions, ContextCategory, BudgetAllocation, CategoryBudgetInfo, PreflightResult, VerbosityLevel, VerbosityConfig, ContextConfig, FilteringConfig, CompactionConfig, SummarizationConfig, CompactionResult, SummarizationResult, FilteringResult, ContextEvent, ContextEventHandler, ContextStats, FileAccessType, FileAccess, FileAccessTrackerOptions, FormatHintsOptions, FileAccessStats, RestorationHintMessage, DelegatedResultStoreStats, ToolResultDelegatorOptions, DelegationConfig, StoredResult, DelegationEvent, } from './context/index.js';
+export { ContextManager, DEFAULT_CONTEXT_CONFIG, FileAccessTracker, createFileTrackingHook, TRACKED_TOOLS, DelegatedResultStore, ToolResultDelegator, DELEGATION_SYSTEM_PROMPT, DEFAULT_DELEGATION_CONFIG, compactToolResult, ObservationMasker, DEFAULT_MASK_CONFIG, extractInputSummary, buildMaskText, isMasked, } from './context/index.js';
+export type { ContextManagerOptions, ContextCategory, BudgetAllocation, CategoryBudgetInfo, PreflightResult, VerbosityLevel, VerbosityConfig, ContextConfig, FilteringConfig, CompactionConfig, SummarizationConfig, CompactionResult, SummarizationResult, FilteringResult, ContextEvent, ContextEventHandler, ContextStats, FileAccessType, FileAccess, FileAccessTrackerOptions, FormatHintsOptions, FileAccessStats, RestorationHintMessage, DelegatedResultStoreStats, ToolResultDelegatorOptions, DelegationConfig, StoredResult, DelegationEvent, ObservationMaskConfig, MaskResult, ObservationMaskStats, } from './context/index.js';
 export { SkillRegistry, defineSkill, createSkillRegistry, builtinSkills, getDefaultSkillRegistry, resetDefaultSkillRegistry, } from './skills/index.js';
 export type { Skill, SkillInvocationResult, SkillInvokeOptions } from './skills/index.js';
 export { JsonSerializer, CompactJsonSerializer, defaultSerializer, MemoryCheckpointer, FileCheckpointer, StateError, StateErrorCode, CURRENT_STATE_VERSION, } from './state/index.js';

package/dist/index.js

@@ -47,7 +47,11 @@ export { AgentError, ProviderError, ToolError, ToolTimeoutError, ToolLoopError,
 // Context management
 export { ContextManager, DEFAULT_CONTEXT_CONFIG, FileAccessTracker, createFileTrackingHook, TRACKED_TOOLS, 
 // Tool result delegation
-DelegatedResultStore, ToolResultDelegator, DELEGATION_SYSTEM_PROMPT, DEFAULT_DELEGATION_CONFIG, } from './context/index.js';
+DelegatedResultStore, ToolResultDelegator, DELEGATION_SYSTEM_PROMPT, DEFAULT_DELEGATION_CONFIG, 
+// Compact tool result formatting (Phase 2 Token Optimization)
+compactToolResult, 
+// Observation masking (Phase 1 Token Optimization)
+ObservationMasker, DEFAULT_MASK_CONFIG, extractInputSummary, buildMaskText, isMasked, } from './context/index.js';
 // Skills system
 export { SkillRegistry, defineSkill, createSkillRegistry, builtinSkills, getDefaultSkillRegistry, resetDefaultSkillRegistry, } from './skills/index.js';
 // State management

package/dist/tools/builtin/ask-user-simple.js

@@ -75,10 +75,8 @@ async function askSimpleWithReadline(question, options, defaultValue) {
  */
 export const askUserSimpleTool = defineTool({
     name: 'ask_user_simple',
-    description: 'Ask a single simple question with string options. ' +
-        'Use this instead of ask_user when you only need one question. ' +
-        'Provide 2-4 clear, concise options. ' +
-        'The user can select by number or by typing the option text.',
+    // Original: 'Ask a single simple question with string options. Use this instead of ask_user when you only need one question. Provide 2-4 clear, concise options. The user can select by number or by typing the option text.'
+    description: 'Ask a single question with 2-4 string options.',
     inputSchema: {
         type: 'object',
         properties: {

package/dist/tools/builtin/ask-user.js

@@ -90,10 +90,8 @@ async function askWithReadline(questions) {
  */
 export const askUserTool = defineTool({
     name: 'ask_user',
-    description: 'Ask the user one or more questions with predefined options. ' +
-        'Use this to gather preferences, make decisions, or get user input during workflows. ' +
-        'Each question should have 2-4 clear options. ' +
-        'Prefer ask_user_simple for single simple questions.',
+    // Original: 'Ask the user one or more questions with predefined options. Use this to gather preferences, make decisions, or get user input during workflows. Each question should have 2-4 clear options. Prefer ask_user_simple for single simple questions.'
+    description: 'Ask 1-4 questions with predefined options. Prefer ask_user_simple for single questions.',
     inputSchema: {
         type: 'object',
         properties: {

package/dist/tools/builtin/backlog.js

@@ -86,9 +86,8 @@ function generateItemId(type, items) {
  */
 export const backlogReadTool = defineTool({
     name: 'backlog_read',
-    description: 'Read backlog items from the project. ' +
-        'Use filters to narrow results. Use id parameter to get a specific item. ' +
-        'Returns items sorted by priority (critical first) then by creation date.',
+    // Original: 'Read backlog items from the project. Use filters to narrow results. Use id parameter to get a specific item. Returns items sorted by priority (critical first) then by creation date.'
+    description: 'Read backlog items, sorted by priority then creation date.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -189,9 +188,8 @@ export const backlogReadTool = defineTool({
  */
 export const backlogWriteTool = defineTool({
     name: 'backlog_write',
-    description: 'Create, update, or delete backlog items. ' +
-        'Actions: add (new item), update (modify existing), delete (remove), replace (full list). ' +
-        'IDs are auto-generated for new items based on type (e.g., FEAT-001, BUG-002).',
+    // Original: 'Create, update, or delete backlog items. Actions: add (new item), update (modify existing), delete (remove), replace (full list). IDs are auto-generated for new items based on type (e.g., FEAT-001, BUG-002).'
+    description: 'Create, update, or delete backlog items.',
     inputSchema: {
         type: 'object',
         properties: {

package/dist/tools/builtin/bash-output.js

@@ -8,9 +8,8 @@ import { getDefaultShellManager } from './shell-manager.js';
  */
 export const bashOutputTool = defineTool({
     name: 'bash_output',
-    description: 'Retrieve output from a running or completed background bash shell. ' +
-        'Returns only new output since the last check. ' +
-        'Use this to monitor long-running commands started with run_in_background.',
+    // Original: 'Retrieve output from a running or completed background bash shell. Returns only new output since the last check. Use this to monitor long-running commands started with run_in_background.'
+    description: 'Retrieve output from a background bash shell.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -67,24 +66,8 @@ export function createBashOutputTool(options) {
     const manager = options?.shellManager ?? getDefaultShellManager();
     return defineTool({
         name: 'bash_output',
-        description: 'Retrieve output from a running or completed background bash shell. ' +
-            'Returns only new output since the last check. ' +
-            'Use this to monitor long-running commands started with run_in_background.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                bash_id: {
-                    type: 'string',
-                    description: 'The ID of the background shell to retrieve output from',
-                },
-                filter: {
-                    type: 'string',
-                    description: 'Optional regular expression to filter output lines. ' +
-                        'Only lines matching this regex will be included.',
-                },
-            },
-            required: ['bash_id'],
-        },
+        description: bashOutputTool.definition.description,
+        inputSchema: bashOutputTool.definition.inputSchema,
         execute: (input) => Promise.resolve(executeBashOutput(input, manager)),
     });
 }

package/dist/tools/builtin/bash.js

@@ -78,9 +78,9 @@ function truncateOutput(output, maxSize) {
  */
 export const bashTool = defineTool({
     name: 'bash',
-    description: 'Execute a shell command and return its output. ' +
-        'Commands run in bash shell. Use for system operations, git commands, npm, etc. ' +
-        'Set run_in_background=true for long-running commands, then use bash_output to monitor.',
+    // Original: 'Execute a shell command and return its output. Commands run in bash shell. Use for system operations, git commands, npm, etc. Set run_in_background=true for long-running commands, then use bash_output to monitor.'
+    description: 'Execute a shell command. ' +
+        'For long-running commands, set run_in_background and poll with bash_output.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -94,7 +94,8 @@ export const bashTool = defineTool({
             },
             timeout: {
                 type: 'number',
-                description: 'Timeout in milliseconds (default: 60000). Ignored for background commands.',
+                description: 'Timeout in milliseconds. Ignored for background commands.',
+                default: 60000,
             },
             env: {
                 type: 'object',
@@ -479,39 +480,8 @@ function isExecError(error) {
 export function createBashTool(options) {
     return defineTool({
         name: 'bash',
-        description: 'Execute a shell command and return its output. ' +
-            'Commands run in bash shell. Use for system operations, git commands, npm, etc. ' +
-            'Set run_in_background=true for long-running commands, then use bash_output to monitor.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                command: {
-                    type: 'string',
-                    description: 'The shell command to execute',
-                },
-                cwd: {
-                    type: 'string',
-                    description: 'Working directory for the command',
-                },
-                timeout: {
-                    type: 'number',
-                    description: 'Timeout in milliseconds (default: 60000). Ignored for background commands.',
-                },
-                env: {
-                    type: 'object',
-                    description: 'Additional environment variables',
-                },
-                run_in_background: {
-                    type: 'boolean',
-                    description: 'Run command in background and return shell ID. Use bash_output to get results.',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Brief description of what this command does',
-                },
-            },
-            required: ['command'],
-        },
+        description: bashTool.definition.description,
+        inputSchema: bashTool.definition.inputSchema,
         execute: async (input, context) => {
             const { cwd: defaultCwd, timeout: defaultTimeout = DEFAULT_TIMEOUT, maxOutputSize = DEFAULT_MAX_OUTPUT_SIZE, blockedCommands = [], restrictToAllowed = false, allowedCommands = [], shell = '/bin/bash', shellManager, fifoMode = 'warn', } = options ?? {};
             const command = input.command.trim();

package/dist/tools/builtin/edit.js

@@ -157,35 +157,8 @@ function truncate(str, maxLength) {
 export function createEditTool(options) {
     return defineTool({
         name: 'edit',
-        description: 'Perform exact string replacements in files. ' +
-            'By default, the old_string must be unique in the file. ' +
-            'Use replaceAll to replace all occurrences.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filePath: {
-                    type: 'string',
-                    description: 'Path to the file to edit',
-                },
-                oldString: {
-                    type: 'string',
-                    description: 'The text to search for and replace',
-                },
-                newString: {
-                    type: 'string',
-                    description: 'The replacement text',
-                },
-                replaceAll: {
-                    type: 'boolean',
-                    description: 'Replace all occurrences instead of requiring uniqueness',
-                },
-                createIfMissing: {
-                    type: 'boolean',
-                    description: 'Create the file with newString content if it does not exist',
-                },
-            },
-            required: ['filePath', 'oldString', 'newString'],
-        },
+        description: editTool.definition.description,
+        inputSchema: editTool.definition.inputSchema,
         execute: async (input) => {
             let targetPath = input.filePath;
             // Resolve relative paths

package/dist/tools/builtin/glob.js

@@ -34,9 +34,8 @@ const DEFAULT_EXCLUDE_DIRS = [
 export const globTool = defineTool({
     name: 'glob',
     readonly: true,
-    description: 'Find files matching glob patterns. ' +
-        'Supports common patterns like **/*.ts for recursive matching. ' +
-        'Returns a list of matching file paths.',
+    // Original: 'Find files matching glob patterns. Supports common patterns like **/*.ts for recursive matching. Returns a list of matching file paths.'
+    description: 'Find files matching glob patterns.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -50,7 +49,7 @@ export const globTool = defineTool({
             },
             includeHidden: {
                 type: 'boolean',
-                description: 'Include hidden files/directories (default: false)',
+                description: 'Include hidden files/directories',
             },
             onlyDirectories: {
                 type: 'boolean',
@@ -58,7 +57,8 @@ export const globTool = defineTool({
             },
             onlyFiles: {
                 type: 'boolean',
-                description: 'Only match files (default: true)',
+                description: 'Only match files',
+                default: true,
             },
             maxDepth: {
                 type: 'number',
@@ -66,7 +66,8 @@ export const globTool = defineTool({
             },
             maxResults: {
                 type: 'number',
-                description: 'Maximum number of results (default: 1000)',
+                description: 'Maximum number of results',
+                default: 1000,
             },
             absolute: {
                 type: 'boolean',
@@ -224,52 +225,8 @@ export function createGlobTool(options) {
     return defineTool({
         name: 'glob',
         readonly: true,
-        description: 'Find files matching glob patterns. ' +
-            'Supports common patterns like **/*.ts for recursive matching. ' +
-            'Returns a list of matching file paths.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                pattern: {
-                    type: 'string',
-                    description: 'Glob pattern (e.g., "**/*.ts", "src/**/*.js", "*.md")',
-                },
-                path: {
-                    type: 'string',
-                    description: 'Base directory to search in (default: current directory)',
-                },
-                includeHidden: {
-                    type: 'boolean',
-                    description: 'Include hidden files/directories (default: false)',
-                },
-                onlyDirectories: {
-                    type: 'boolean',
-                    description: 'Only match directories',
-                },
-                onlyFiles: {
-                    type: 'boolean',
-                    description: 'Only match files (default: true)',
-                },
-                maxDepth: {
-                    type: 'number',
-                    description: 'Maximum directory depth to traverse',
-                },
-                maxResults: {
-                    type: 'number',
-                    description: 'Maximum number of results (default: 1000)',
-                },
-                absolute: {
-                    type: 'boolean',
-                    description: 'Return absolute paths instead of relative',
-                },
-                excludeDirs: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Directory names to exclude (default: node_modules, .git, dist, build, etc.)',
-                },
-            },
-            required: ['pattern'],
-        },
+        description: globTool.definition.description,
+        inputSchema: globTool.definition.inputSchema,
         execute: async (input) => {
             let searchPath = input.path ?? '.';
             // Resolve relative paths

package/dist/tools/builtin/grep.js

@@ -35,9 +35,8 @@ const DEFAULT_EXCLUDE_DIRS = [
 export const grepTool = defineTool({
     name: 'grep',
     readonly: true,
-    description: 'Search for patterns in files using regular expressions. ' +
-        'Can search a single file or recursively through directories. ' +
-        'Returns matching lines with optional context.',
+    // Original: 'Search for patterns in files using regular expressions. Can search a single file or recursively through directories. Returns matching lines with optional context.'
+    description: 'Search for regex patterns in files or directories.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -51,11 +50,13 @@ export const grepTool = defineTool({
             },
             ignoreCase: {
                 type: 'boolean',
-                description: 'Case insensitive search (default: false)',
+                description: 'Case insensitive search',
+                default: false,
             },
             lineNumbers: {
                 type: 'boolean',
-                description: 'Include line numbers in output (default: true)',
+                description: 'Include line numbers in output',
+                default: true,
             },
             before: {
                 type: 'number',
@@ -80,11 +81,13 @@ export const grepTool = defineTool({
             },
             maxMatches: {
                 type: 'number',
-                description: 'Maximum number of matches to return (default: 100)',
+                description: 'Maximum number of matches to return',
+                default: 100,
             },
             recursive: {
                 type: 'boolean',
-                description: 'Search recursively in directories (default: true)',
+                description: 'Search recursively in directories',
+                default: true,
             },
         },
         required: ['pattern', 'path'],
@@ -321,65 +324,8 @@ export function createGrepTool(options) {
     return defineTool({
         name: 'grep',
         readonly: true,
-        description: 'Search for patterns in files using regular expressions. ' +
-            'Can search a single file or recursively through directories. ' +
-            'Returns matching lines with optional context.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                pattern: {
-                    type: 'string',
-                    description: 'Regular expression pattern to search for',
-                },
-                path: {
-                    type: 'string',
-                    description: 'Path to file or directory to search in',
-                },
-                ignoreCase: {
-                    type: 'boolean',
-                    description: 'Case insensitive search (default: false)',
-                },
-                lineNumbers: {
-                    type: 'boolean',
-                    description: 'Include line numbers in output (default: true)',
-                },
-                before: {
-                    type: 'number',
-                    description: 'Number of context lines before match',
-                },
-                after: {
-                    type: 'number',
-                    description: 'Number of context lines after match',
-                },
-                filesOnly: {
-                    type: 'boolean',
-                    description: 'Only return filenames with matches',
-                },
-                includeHidden: {
-                    type: 'boolean',
-                    description: 'Include hidden files/directories',
-                },
-                extensions: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'File extensions to include (e.g., [".ts", ".js"])',
-                },
-                maxMatches: {
-                    type: 'number',
-                    description: 'Maximum number of matches to return (default: 100)',
-                },
-                recursive: {
-                    type: 'boolean',
-                    description: 'Search recursively in directories (default: true)',
-                },
-                excludeDirs: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Directory names to exclude (default: node_modules, .git, dist, build, etc.)',
-                },
-            },
-            required: ['pattern', 'path'],
-        },
+        description: grepTool.definition.description,
+        inputSchema: grepTool.definition.inputSchema,
         execute: async (input) => {
             let searchPath = input.path;
             // Resolve relative paths

package/dist/tools/builtin/kill-shell.js

@@ -8,8 +8,8 @@ import { getDefaultShellManager } from './shell-manager.js';
  */
 export const killShellTool = defineTool({
     name: 'kill_shell',
-    description: 'Kill a running background bash shell by its ID. ' +
-        'Use this to terminate long-running commands that are no longer needed.',
+    // Original: 'Kill a running background bash shell by its ID. Use this to terminate long-running commands that are no longer needed.'
+    description: 'Terminate a background bash shell by ID.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -63,18 +63,8 @@ export function createKillShellTool(options) {
     const manager = options?.shellManager ?? getDefaultShellManager();
     return defineTool({
         name: 'kill_shell',
-        description: 'Kill a running background bash shell by its ID. ' +
-            'Use this to terminate long-running commands that are no longer needed.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                shell_id: {
-                    type: 'string',
-                    description: 'The ID of the background shell to kill',
-                },
-            },
-            required: ['shell_id'],
-        },
+        description: killShellTool.definition.description,
+        inputSchema: killShellTool.definition.inputSchema,
         execute: (input) => Promise.resolve(executeKillShell(input, manager)),
     });
 }