@orion-agents/orion-code 0.1.9 → 0.2.2

package/dist/tools/index.js

@@ -1,2268 +0,0 @@
-"use strict";
-/**
- * orion code - 工具集
- *
- * 定义 Agent 可用的工具（Tool System v2）：
- *   - read_file: 读取文件内容
- *   - write_file: 写入文件
- *   - list_files: 列出目录
- *   - exec_command: 执行 shell 命令
- *
- * 使用 buildTool() 工厂模式。
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findDestructiveRmTarget = exports.assessCommandSecurity = exports.isPotentiallyDestructive = exports.checkDangerousCommand = exports.isReadOnlyCommand = exports.POTENTIALLY_DESTRUCTIVE_PATTERNS = exports.DANGEROUS_PATTERNS = exports.READ_ONLY_COMMANDS = exports.TOOLS = exports.BATCH_READ_MAX_STEPS = exports.BATCH_READ_ALLOWED_TOOLS = void 0;
-exports.getRuntimeTools = getRuntimeTools;
-exports.validateRegexPattern = validateRegexPattern;
-exports.executeTool = executeTool;
-exports.getToolNames = getToolNames;
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const readline_1 = require("readline");
-const tool_1 = require("../framework/tool");
-const tool_scheduler_1 = require("../framework/tool-scheduler");
-const external_assertion_1 = require("../framework/external-assertion");
-const tool_state_1 = require("../framework/tool-state");
-const tool_artifacts_1 = require("../core/tool-artifacts");
-const environment_1 = require("../product/environment");
-const storage_1 = require("../memory/storage");
-const semantic_config_1 = require("../memory/semantic-config");
-const session_storage_1 = require("../services/session-storage");
-const workspace_containment_1 = require("../services/workspace-containment");
-const web_1 = require("./web");
-const mcp_1 = require("./mcp");
-const todo_1 = require("./todo");
-const plan_1 = require("./plan");
-const git_1 = require("./git");
-const lsp_1 = require("./lsp");
-const tools_1 = require("../runtime/goals/tools");
-const bash_security_1 = require("./bash_security");
-const debug_log_1 = require("../utils/debug-log");
-const errors_1 = require("../utils/errors");
-const sandbox_1 = require("./sandbox");
-exports.BATCH_READ_ALLOWED_TOOLS = new Set([
-    'git_status',
-    'list_files',
-    'glob',
-    'grep',
-    'read_file',
-]);
-exports.BATCH_READ_MAX_STEPS = 8;
-const BATCH_READ_STEP_OUTPUT_MAX_BYTES = 1600;
-const LIST_FILES_MAX_DEPTH = 8;
-const EXEC_COMMAND_MIN_TIMEOUT_MS = 1;
-const EXEC_COMMAND_MAX_TIMEOUT_MS = 600000;
-const EXEC_COMMAND_MIN_OUTPUT_BYTES = 1024;
-const EXEC_COMMAND_MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
-function validateOptionalSafeInteger(args, toolName, field, minimum, maximum) {
-    const value = args[field];
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== 'number' ||
-        !Number.isFinite(value) ||
-        !Number.isSafeInteger(value) ||
-        value < minimum ||
-        value > maximum) {
-        return `${toolName} ${field} must be a safe integer between ${minimum} and ${maximum}`;
-    }
-    return undefined;
-}
-function compactOneLine(text, maxLength) {
-    const compact = text.replace(/\s+/g, ' ').trim();
-    if (compact.length <= maxLength)
-        return compact;
-    if (maxLength <= 3)
-        return compact.slice(0, maxLength);
-    const headLength = Math.ceil((maxLength - 3) * 0.55);
-    const tailLength = Math.floor((maxLength - 3) * 0.45);
-    return `${compact.slice(0, headLength)}...${compact.slice(-tailLength)}`;
-}
-function summarizeFailedToolResult(result) {
-    const details = [];
-    if (result.error) {
-        details.push(compactOneLine(result.error, 80));
-    }
-    const output = result.output ? compactOneLine(result.output, 120) : '';
-    if (output && output !== result.error) {
-        details.push(`output: ${output}`);
-    }
-    return details.join('; ');
-}
-// ============================================================================
-// 工具集
-// ============================================================================
-exports.TOOLS = [
-    // Web tools (P0)
-    ...web_1.WEB_TOOLS,
-    // MCP tools (P0)
-    ...mcp_1.MCP_TOOLS,
-    // Git tools (P0 - Issue #18/#23)
-    ...git_1.GIT_TOOLS,
-    // LSP tools (P0 - Phase 6)
-    ...lsp_1.lspTools,
-    // Todo tools (P1)
-    ...todo_1.TODO_TOOLS,
-    // Plan mode tools (P1)
-    ...plan_1.PLAN_TOOLS,
-    // Goal tools (P0 - v0.2.24)
-    ...tools_1.GOAL_TOOLS,
-    // File tools
-    (0, tool_1.buildTool)({
-        name: 'read_file',
-        description: '读取文件内容，支持从指定行开始分页。返回文件内容字符串。',
-        parameters: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: '文件路径（绝对路径或相对路径）',
-                },
-                maxLines: {
-                    type: 'number',
-                    description: '最大读取行数（可选，默认 500 行）',
-                },
-                offset: {
-                    type: 'number',
-                    description: '开始读取的行号（可选，1-based，默认第 1 行）',
-                },
-            },
-            required: ['path'],
-        },
-        execute: async (args, context) => {
-            // Ensure path is a valid string
-            const path = args.path;
-            if (!path || typeof path !== 'string') {
-                return { success: false, output: '', error: 'read_file requires a path parameter' };
-            }
-            const maxLines = readPositiveInteger(args.maxLines, 'maxLines', 500);
-            if (typeof maxLines === 'string') {
-                return { success: false, output: '', error: maxLines };
-            }
-            const offset = readPositiveInteger(args.offset, 'offset', 1);
-            if (typeof offset === 'string') {
-                return { success: false, output: '', error: offset };
-            }
-            return readFileSync_(path, maxLines, offset, context.cwd);
-        },
-        isReadOnly: () => true,
-        isConcurrencySafe: () => true,
-        userFacingName: args => `Read ${args.path}`,
-        getSummary: (args, result) => {
-            const path = args.path;
-            if (!result.success)
-                return `📄 read ${path} → error`;
-            const lines = result.output.split('\n').length;
-            const bytes = Buffer.byteLength(result.output, 'utf8');
-            return `📄 read ${path} (${lines}L, ${bytes}B)`;
-        },
-    }),
-    (0, tool_1.buildTool)({
-        name: 'write_file',
-        description: '将内容写入文件。如果文件不存在则创建，存在则覆盖。',
-        parameters: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: '文件路径（绝对路径或相对路径）',
-                },
-                content: {
-                    type: 'string',
-                    description: '要写入的文件内容',
-                },
-            },
-            required: ['path', 'content'],
-        },
-        execute: async (args, context) => {
-            // Ensure path and content are valid strings
-            const path = args.path;
-            const content = args.content;
-            if (!path || typeof path !== 'string') {
-                return { success: false, output: '', error: 'write_file requires a path parameter' };
-            }
-            if (typeof content !== 'string') {
-                return { success: false, output: '', error: 'write_file requires a content parameter' };
-            }
-            return writeFileSync_(path, content, context.cwd);
-        },
-        isDestructive: () => true,
-        isFileEdit: () => true,
-        checkPermissions: (_args, _context) => {
-            return { behavior: 'ask', reason: 'Write operation may modify existing files' };
-        },
-        userFacingName: args => `Write ${args.path}`,
-        getSummary: (args, result) => {
-            const path = args.path;
-            if (!result.success)
-                return `💾 write ${path} → error`;
-            const bytes = Buffer.byteLength(args.content || '', 'utf8');
-            return `💾 write ${path} (${bytes}B)`;
-        },
-    }),
-    (0, tool_1.buildTool)({
-        name: 'list_files',
-        description: '列出指定目录中的文件和子目录。支持控制递归深度。',
-        parameters: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: '目录路径（绝对路径或相对路径）',
-                },
-                maxDepth: {
-                    type: 'number',
-                    description: '最大递归深度（可选，默认 2，范围 0-8）',
-                    minimum: 0,
-                    maximum: LIST_FILES_MAX_DEPTH,
-                },
-            },
-            required: ['path'],
-        },
-        execute: async (args, context) => {
-            // Ensure path is a valid string
-            const path = args.path;
-            if (!path || typeof path !== 'string') {
-                return { success: false, output: '', error: 'list_files requires a path parameter' };
-            }
-            return listFiles_(path, args.maxDepth, context.cwd);
-        },
-        validateInput: args => validateOptionalSafeInteger(args, 'list_files', 'maxDepth', 0, LIST_FILES_MAX_DEPTH),
-        isReadOnly: () => true,
-        isConcurrencySafe: () => true,
-        userFacingName: args => `List ${args.path}`,
-        getSummary: (args, result) => {
-            const path = args.path;
-            if (!result.success)
-                return `📁 list ${path} → error`;
-            const count = result.output.split('\n').filter(Boolean).length;
-            return `📁 list ${path} (${count} entries)`;
-        },
-    }),
-    (0, tool_1.buildTool)({
-        name: 'exec_command',
-        description: '执行一个 shell 命令。返回 stdout 和 stderr。输出超过 maxOutput 会自动截断。',
-        parameters: {
-            type: 'object',
-            properties: {
-                command: {
-                    type: 'string',
-                    description: '要执行的 shell 命令',
-                },
-                cwd: {
-                    type: 'string',
-                    description: '工作目录（可选，默认当前目录）',
-                },
-                timeout: {
-                    type: 'number',
-                    description: '超时时间 ms（可选，默认 30000，范围 1-600000）',
-                    minimum: EXEC_COMMAND_MIN_TIMEOUT_MS,
-                    maximum: EXEC_COMMAND_MAX_TIMEOUT_MS,
-                },
-                maxOutput: {
-                    type: 'number',
-                    description: '最大输出字节数（可选，默认 51200，范围 1024-10485760，超出截断）',
-                    minimum: EXEC_COMMAND_MIN_OUTPUT_BYTES,
-                    maximum: EXEC_COMMAND_MAX_OUTPUT_BYTES,
-                },
-            },
-            required: ['command'],
-        },
-        execute: async (args, context) => {
-            // Ensure command is a valid string
-            const command = args.command;
-            if (!command || typeof command !== 'string') {
-                return { success: false, output: '', error: 'exec_command requires a command parameter' };
-            }
-            // Issue #32 #3.2: 传递 abortSignal
-            return execCommand_(command, args.cwd, args.timeout, args.maxOutput, context.abortSignal, context.cwd);
-        },
-        validateInput: args => validateOptionalSafeInteger(args, 'exec_command', 'timeout', EXEC_COMMAND_MIN_TIMEOUT_MS, EXEC_COMMAND_MAX_TIMEOUT_MS) ??
-            validateOptionalSafeInteger(args, 'exec_command', 'maxOutput', EXEC_COMMAND_MIN_OUTPUT_BYTES, EXEC_COMMAND_MAX_OUTPUT_BYTES),
-        isDestructive: args => {
-            const cmd = args.command || '';
-            return (0, bash_security_1.containsRecursiveRm)(cmd) || /(?:^|[;&|]\s*)(?:[^\s]+\/)?(?:mkfs|dd)(?:\s|$)/.test(cmd);
-        },
-        checkPermissions: (args, context) => {
-            const cmd = args.command || '';
-            // Use the bash_security module for comprehensive checks
-            const security = (0, bash_security_1.assessCommandSecurity)(cmd);
-            if (security.level === 'blocked') {
-                return {
-                    behavior: 'deny',
-                    reason: security.reason || `Command blocked by safety policy: ${cmd.slice(0, 50)}`,
-                };
-            }
-            // v0.1.3-2 §1.2: a configured-but-unusable sandbox is a hard deny, decided
-            // here so the user sees the reason instead of an opaque execution failure.
-            let paths;
-            try {
-                paths = resolveExecCommandPaths(args.cwd, context?.cwd);
-            }
-            catch (error) {
-                return {
-                    behavior: 'deny',
-                    reason: error instanceof Error ? error.message : 'exec_command cwd is outside workspace',
-                };
-            }
-            const { workdir, projectRoot } = paths;
-            const sandboxSettings = (0, sandbox_1.resolveSandboxSettings)(projectRoot);
-            let sandboxNote = '';
-            if ((sandboxSettings.profile ?? 'none') !== 'none') {
-                const plan = (0, sandbox_1.planSandboxedCommand)(cmd, {
-                    cwd: workdir,
-                    projectRoot,
-                    settings: sandboxSettings,
-                });
-                if (!plan.ok) {
-                    return {
-                        behavior: 'deny',
-                        reason: `sandbox profile "${plan.profile}" is configured but cannot be applied — ${plan.reason}`,
-                    };
-                }
-                sandboxNote = ` [${(0, sandbox_1.describeSandboxPlan)(plan)}]`;
-            }
-            if (security.level === 'safe' && security.isReadOnly) {
-                return { behavior: 'allow' };
-            }
-            if (security.level === 'caution') {
-                return {
-                    behavior: 'ask',
-                    reason: (security.reason || 'Command requires confirmation') + sandboxNote,
-                };
-            }
-            // Default: ask for confirmation
-            return { behavior: 'ask', reason: 'Command requires confirmation' + sandboxNote };
-        },
-        isReadOnly: args => {
-            const cmd = args.command || '';
-            return (0, bash_security_1.isReadOnlyCommand)(cmd);
-        },
-        isConcurrencySafe: args => {
-            const cmd = args.command || '';
-            return (0, bash_security_1.isReadOnlyCommand)(cmd);
-        },
-        userFacingName: args => `Exec ${compactOneLine(args.command || '', 80)}`,
-        getSummary: (args, result) => {
-            const command = args.command || '';
-            const commandSummary = command ? `\n  $ ${compactOneLine(command, 160)}` : '';
-            if (!result.success) {
-                const detail = summarizeFailedToolResult(result);
-                return `🔧 exec → error${detail ? ` (${detail})` : ''}${commandSummary}`;
-            }
-            const bytes = Buffer.byteLength(result.output, 'utf8');
-            return `🔧 exec (${bytes}B output)${commandSummary}`;
-        },
-    }),
-    (0, tool_1.buildTool)({
-        name: 'edit_file',
-        description: '对文件进行精确字符串替换。old_string 必须在文件中唯一匹配，否则拒绝执行。使用 replace_all 可替换所有精确匹配；只有显式 fuzzy_match=true 时才尝试宽松空白匹配。',
-        parameters: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description: '文件路径（绝对路径或相对路径）',
-                },
-                old_string: {
-                    type: 'string',
-                    description: '要替换的字符串（必须精确匹配）',
-                },
-                new_string: {
-                    type: 'string',
-                    description: '替换后的字符串',
-                },
-                replace_all: {
-                    type: 'boolean',
-                    description: '是否替换所有匹配（可选，默认 false）',
-                },
-                fuzzy_match: {
-                    type: 'boolean',
-                    description: '精确匹配失败时是否允许宽松空白匹配（可选，默认 false；多候选时总是拒绝）',
-                },
-                preview: {
-                    type: 'boolean',
-                    description: '预览匹配结果而不写入文件（可选，默认 false）',
-                },
-            },
-            required: ['path', 'old_string', 'new_string'],
-        },
-        execute: async (args, context) => {
-            // Ensure required parameters are valid strings
-            const path = args.path;
-            const old_string = args.old_string;
-            const new_string = args.new_string;
-            if (!path || typeof path !== 'string') {
-                return { success: false, output: '', error: 'edit_file requires a path parameter' };
-            }
-            if (!old_string || typeof old_string !== 'string') {
-                return { success: false, output: '', error: 'edit_file requires an old_string parameter' };
-            }
-            if (typeof new_string !== 'string') {
-                return { success: false, output: '', error: 'edit_file requires a new_string parameter' };
-            }
-            const lastEditFileArgs = { path, old_string, new_string, updatedAt: Date.now() };
-            if (typeof args.replace_all === 'boolean')
-                lastEditFileArgs.replace_all = args.replace_all;
-            if (typeof args.fuzzy_match === 'boolean')
-                lastEditFileArgs.fuzzy_match = args.fuzzy_match;
-            if (context?.sessionId)
-                lastEditFileArgs.sessionId = context.sessionId;
-            if (context?.turnId)
-                lastEditFileArgs.turnId = context.turnId;
-            lastEditFileArgs.updatedAt = Date.now();
-            (0, tool_state_1.setToolState)({ lastEditFileArgs });
-            return editFile_(path, old_string, new_string, args.replace_all, args.fuzzy_match, args.preview, context.cwd);
-        },
-        isDestructive: () => true,
-        isFileEdit: () => true,
-        checkPermissions: (_args, _context) => {
-            return { behavior: 'ask', reason: 'Edit operation modifies file contents' };
-        },
-        userFacingName: args => `Edit ${args.path}`,
-        getSummary: (args, result) => {
-            const path = args.path;
-            if (!result.success)
-                return `✏️ edit ${path} → error`;
-            const replaceAll = args.replace_all ? ' (all)' : '';
-            return `✏️ edit ${path}${replaceAll}`;
-        },
-    }),
-    (0, tool_1.buildTool)({
-        name: 'glob',
-        description: '使用 glob 模式搜索文件。支持 **（递归）、*（任意字符）、?（单个字符）等通配符。',
-        parameters: {
-            type: 'object',
-            properties: {
-                pattern: {
-                    type: 'string',
-                    description: 'Glob 模式（如 **/*.ts, src/**/*.js）',
-                },
-                path: {
-                    type: 'string',
-                    description: '搜索起始目录（可选，默认当前目录）',
-                },
-            },
-            required: ['pattern'],
-        },
-        execute: async (args, context) => {
-            // Ensure pattern is a valid string
-            const pattern = args.pattern;
-            if (!pattern || typeof pattern !== 'string') {
-                return { success: false, output: '', error: 'glob requires a pattern parameter' };
-            }
-            return glob_(pattern, args.path, context.cwd);
-        },
-        isReadOnly: () => true,
-        isConcurrencySafe: () => true,
-        userFacingName: args => `Glob ${args.pattern}`,
-        getSummary: (args, result) => {
-            const pattern = args.pattern;
-            if (!result.success)
-                return `🔍 glob ${pattern} → error`;
-            const count = result.output.split('\n').filter(Boolean).length;
-            return `🔍 glob ${pattern} → ${count} matches`;
-        },
-    }),
-    (0, tool_1.buildTool)({
-        name: 'grep',
-        description: '在文件中搜索正则表达式模式。返回匹配的文件路径和行内容。',
-        parameters: {
-            type: 'object',
-            properties: {
-                pattern: {
-                    type: 'string',
-                    description: '正则表达式模式',
-                },
-                path: {
-                    type: 'string',
-                    description: '搜索路径（可选，默认当前目录）',
-                },
-                glob: {
-                    type: 'string',
-                    description: '文件过滤模式（可选，如 *.ts）',
-                },
-                context: {
-                    type: 'number',
-                    description: '上下文行数（可选，默认 0）',
-                },
-            },
-            required: ['pattern'],
-        },
-        execute: async (args, context) => {
-            // Ensure pattern is a valid string
-            const pattern = args.pattern;
-            if (!pattern || typeof pattern !== 'string') {
-                return { success: false, output: '', error: 'grep requires a pattern parameter' };
-            }
-            return grep_(pattern, args.path, args.glob, args.context, context.cwd);
-        },
-        isReadOnly: () => true,
-        isConcurrencySafe: () => true,
-        userFacingName: args => `Grep ${args.pattern}`,
-        getSummary: (args, result) => {
-            const pattern = args.pattern;
-            if (!result.success)
-                return `🔎 grep /${pattern}/ → error`;
-            const count = result.output.split('\n').filter(l => l && !l.startsWith('--')).length;
-            return `🔎 grep /${pattern}/ → ${count} matches`;
-        },
-    }),
-    (0, tool_1.buildTool)({
-        name: 'batch_read',
-        description: 'Run up to 8 read-only exploration tool calls in one ordered batch. Allowed tools: git_status, list_files, glob, grep, read_file.',
-        parameters: {
-            type: 'object',
-            properties: {
-                steps: {
-                    type: 'array',
-                    description: 'Array of steps: [{ "tool": "read_file", "args": { "path": "package.json" } }]. Max 8 steps.',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            tool: { type: 'string', description: 'Allowed read-only tool name' },
-                            args: { type: 'object', description: 'Arguments for the tool' },
-                        },
-                        required: ['tool', 'args'],
-                    },
-                    maxItems: exports.BATCH_READ_MAX_STEPS,
-                },
-                reason: {
-                    type: 'string',
-                    description: 'Optional reason for this read-only batch.',
-                },
-            },
-            required: ['steps'],
-        },
-        execute: async (args, context) => executeBatchRead(args, context),
-        isReadOnly: () => true,
-        isConcurrencySafe: () => true,
-        userFacingName: args => {
-            const count = Array.isArray(args.steps) ? args.steps.length : 0;
-            return `Batch read ${count} steps`;
-        },
-        getSummary: (args, result) => {
-            if (!result.success)
-                return '📚 batch_read → error';
-            const count = Array.isArray(args.steps) ? args.steps.length : 0;
-            return `📚 batch_read → ${count} steps`;
-        },
-    }),
-    // Memory tools
-    (0, tool_1.buildTool)({
-        name: 'memory_save',
-        description: 'Save a memory entry to the persistent memory system. Memories help tailor behavior to user preferences.',
-        parameters: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Memory name (kebab-case, e.g., "user-role", "feedback-style")',
-                },
-                type: {
-                    type: 'string',
-                    enum: ['user', 'feedback', 'project', 'reference'],
-                    description: 'Memory type',
-                },
-                description: {
-                    type: 'string',
-                    description: 'One-line description for memory index',
-                },
-                content: {
-                    type: 'string',
-                    description: 'Memory content. For feedback/project: use rule + Why + How to apply structure',
-                },
-            },
-            required: ['name', 'type', 'content'],
-        },
-        execute: async (args, context) => {
-            const name = args.name;
-            const type = args.type;
-            const content = args.content;
-            if (!name || typeof name !== 'string') {
-                return { success: false, output: '', error: 'memory_save requires a name parameter' };
-            }
-            if (!type || !['user', 'feedback', 'project', 'reference'].includes(type)) {
-                return {
-                    success: false,
-                    output: '',
-                    error: 'memory_save requires a valid type: user, feedback, project, or reference',
-                };
-            }
-            if (!content || typeof content !== 'string') {
-                return { success: false, output: '', error: 'memory_save requires a content parameter' };
-            }
-            const description = args.description || content.slice(0, 80);
-            try {
-                const projectPath = context?.cwd || process.cwd();
-                const entry = {
-                    name,
-                    type,
-                    description,
-                    content,
-                    createdAt: Date.now(),
-                    updatedAt: Date.now(),
-                };
-                if ((0, semantic_config_1.isSemanticEnabled)()) {
-                    // saveAndIndex internally calls saveMemory + vectorStore.upsert
-                    const { getSemanticSearchService } = await Promise.resolve().then(() => __importStar(require('../memory/semantic-search')));
-                    await getSemanticSearchService().saveAndIndex(entry, projectPath);
-                }
-                else {
-                    (0, storage_1.saveMemory)(entry, projectPath);
-                }
-                return { success: true, output: `Saved memory: ${name} (${type})` };
-            }
-            catch (err) {
-                return { success: false, output: '', error: (0, errors_1.errorMessage)(err) };
-            }
-        },
-        isReadOnly: () => false,
-        userFacingName: args => `Memory save ${args.name}`,
-        getSummary: (args, result) => {
-            const name = args.name;
-            const type = args.type;
-            if (!result.success)
-                return `🧠 save ${name} → error`;
-            return `🧠 save ${name} (${type})`;
-        },
-    }),
-    (0, tool_1.buildTool)({
-        name: 'memory_recall',
-        description: 'Recall memories from the memory system. Returns matching memories or all if no query.',
-        parameters: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Search query (optional, returns all if empty)',
-                },
-                type: {
-                    type: 'string',
-                    enum: ['user', 'feedback', 'project', 'reference'],
-                    description: 'Filter by memory type (optional)',
-                },
-            },
-            required: [],
-        },
-        execute: async (args, context) => {
-            try {
-                const projectPath = context?.cwd || process.cwd();
-                const query = args.query || '';
-                const type = args.type;
-                let memories;
-                if (query && (0, semantic_config_1.isSemanticEnabled)()) {
-                    // Semantic path: ask the vector store, then fall back to keywords if it
-                    // returns nothing (e.g. embedding provider unreachable, empty index)
-                    try {
-                        const { getSemanticSearchService } = await Promise.resolve().then(() => __importStar(require('../memory/semantic-search')));
-                        const result = await getSemanticSearchService().search({
-                            query,
-                            projectPath,
-                            type,
-                        });
-                        memories = result.memories.map(m => ({
-                            name: m.name,
-                            type: m.type,
-                            description: m.description,
-                            content: m.content,
-                            createdAt: m.createdAt,
-                            updatedAt: m.createdAt,
-                        }));
-                        if (memories.length === 0) {
-                            memories = (0, storage_1.searchMemories)(query, projectPath);
-                            if (type)
-                                memories = memories.filter(m => m.type === type);
-                        }
-                    }
-                    catch (error) {
-                        (0, debug_log_1.debugError)('tools.memory.semanticSearch', error, query);
-                        memories = (0, storage_1.searchMemories)(query, projectPath);
-                        if (type)
-                            memories = memories.filter(m => m.type === type);
-                    }
-                }
-                else if (type) {
-                    memories = (0, storage_1.loadAllMemories)(projectPath).filter(m => m.type === type);
-                }
-                else if (query) {
-                    memories = (0, storage_1.searchMemories)(query, projectPath);
-                }
-                else {
-                    memories = (0, storage_1.loadAllMemories)(projectPath);
-                }
-                if (memories.length === 0) {
-                    return { success: true, output: 'No memories found' };
-                }
-                const lines = [];
-                for (const mem of memories) {
-                    lines.push(`## ${mem.name} (${mem.type})`);
-                    lines.push(mem.description);
-                    lines.push(mem.content);
-                    lines.push('');
-                }
-                return { success: true, output: lines.join('\n') };
-            }
-            catch (err) {
-                return { success: false, output: '', error: (0, errors_1.errorMessage)(err) };
-            }
-        },
-        isReadOnly: () => true,
-        userFacingName: args => `Memory recall ${args.query || 'all'}`,
-        getSummary: (args, result) => {
-            const query = args.query || 'all';
-            if (!result.success)
-                return `🧠 recall "${query}" → error`;
-            if (result.output === 'No memories found')
-                return `🧠 recall "${query}" → 0 found`;
-            const count = result.output.split(/^## /m).length - 1;
-            return `🧠 recall "${query}" → ${count} memories`;
-        },
-    }),
-    (0, tool_1.buildTool)({
-        name: 'memory_forget',
-        description: 'Delete a memory entry from the memory system.',
-        parameters: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Memory name to delete',
-                },
-            },
-            required: ['name'],
-        },
-        execute: async (args, context) => {
-            const name = args.name;
-            if (!name || typeof name !== 'string') {
-                return { success: false, output: '', error: 'memory_forget requires a name parameter' };
-            }
-            try {
-                const projectPath = context?.cwd || process.cwd();
-                const existing = (0, storage_1.loadMemory)(name, projectPath);
-                if (!existing) {
-                    return { success: false, output: '', error: `Memory not found: ${name}` };
-                }
-                (0, storage_1.deleteMemory)(name, projectPath);
-                if ((0, semantic_config_1.isSemanticEnabled)()) {
-                    try {
-                        const { getVectorStore } = require('../memory/vector-store');
-                        getVectorStore().delete(name, projectPath);
-                    }
-                    catch (error) {
-                        // Vector store cleanup is best-effort, but a failure leaves an
-                        // orphaned embedding that keeps surfacing a deleted memory.
-                        (0, debug_log_1.debugError)('tools.memory.vectorDelete', error, name);
-                    }
-                }
-                return { success: true, output: `Deleted memory: ${name}` };
-            }
-            catch (err) {
-                return { success: false, output: '', error: (0, errors_1.errorMessage)(err) };
-            }
-        },
-        isReadOnly: () => false,
-        userFacingName: args => `Memory forget ${args.name}`,
-        getSummary: (args, result) => {
-            const name = args.name;
-            if (!result.success)
-                return `🧠 forget ${name} → error`;
-            return `🧠 forget ${name}`;
-        },
-    }),
-    // History search tool
-    (0, tool_1.buildTool)({
-        name: 'history_search',
-        description: 'Search previous tool operations in current or past sessions. Helps find what was done before.',
-        parameters: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Search query (tool name, file path, keyword)',
-                },
-                sessionId: {
-                    type: 'string',
-                    description: 'Session ID to search (optional, defaults to searching recent sessions)',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Max results (optional, default 10)',
-                },
-            },
-            required: ['query'],
-        },
-        execute: async (args) => {
-            const query = args.query;
-            if (!query || typeof query !== 'string') {
-                return { success: false, output: '', error: 'history_search requires a query parameter' };
-            }
-            try {
-                const limit = args.limit || 10;
-                const sessionId = args.sessionId;
-                // If sessionId provided, search that session; otherwise search all recent sessions
-                const sessions = sessionId
-                    ? [(0, session_storage_1.loadSessionMeta)(sessionId)].filter(Boolean)
-                    : (0, session_storage_1.listSessions)(5);
-                const results = [];
-                for (const session of sessions) {
-                    if (!session)
-                        continue;
-                    const messages = (0, session_storage_1.readSessionMessages)(session.id);
-                    // Search through messages for tool calls matching query
-                    for (let i = 0; i < messages.length; i++) {
-                        const msg = messages[i];
-                        if (msg.role === 'assistant' && msg.tool_calls) {
-                            for (const tc of msg.tool_calls) {
-                                // Match tool name or arguments content
-                                const matchesQuery = tc.function.name.toLowerCase().includes(query.toLowerCase()) ||
-                                    tc.function.arguments.toLowerCase().includes(query.toLowerCase());
-                                if (matchesQuery) {
-                                    // Find corresponding tool result
-                                    const nextMsg = messages[i + 1];
-                                    const resultPreview = nextMsg?.role === 'tool' && nextMsg.toolCallId === tc.id
-                                        ? nextMsg.content.slice(0, 200)
-                                        : '(no result)';
-                                    results.push({
-                                        sessionId: session.id.slice(0, 8),
-                                        tool: tc.function.name,
-                                        args: tc.function.arguments.slice(0, 100),
-                                        resultPreview,
-                                        timestamp: msg.timestamp,
-                                    });
-                                }
-                            }
-                        }
-                    }
-                }
-                // Sort by timestamp (newest first) and limit
-                results.sort((a, b) => b.timestamp - a.timestamp);
-                const limited = results.slice(0, limit);
-                if (limited.length === 0) {
-                    return { success: true, output: 'No matching tool operations found' };
-                }
-                const lines = [];
-                lines.push(`Found ${limited.length} matching operations:`);
-                lines.push('');
-                for (const r of limited) {
-                    lines.push(`Session ${r.sessionId}: ${r.tool}`);
-                    lines.push(`  Args: ${r.args}`);
-                    lines.push(`  Result: ${r.resultPreview.slice(0, 100)}...`);
-                    lines.push('');
-                }
-                return { success: true, output: lines.join('\n') };
-            }
-            catch (err) {
-                return { success: false, output: '', error: (0, errors_1.errorMessage)(err) };
-            }
-        },
-        isReadOnly: () => true,
-        userFacingName: args => `History search ${args.query}`,
-        getSummary: (args, result) => {
-            const query = args.query;
-            if (!result.success)
-                return `📜 history "${query}" → error`;
-            if (result.output.startsWith('No matching'))
-                return `📜 history "${query}" → 0 found`;
-            const match = result.output.match(/Found (\d+) matching/);
-            const count = match ? match[1] : '?';
-            return `📜 history "${query}" → ${count} found`;
-        },
-    }),
-];
-/**
- * Runtime tool pool.
- *
- * Static Orion Code tools are always present. Connected MCP server tools are
- * exposed as first-class tools named mcp__<server>__<tool>, matching the
- * convention used by Claude Code, Codex, and OpenClaude.
- */
-function getRuntimeTools() {
-    return [...exports.TOOLS, ...mcp_1.mcpManager.getOrionCodeTools()];
-}
-// ============================================================================
-// 工具实现
-// ============================================================================
-/** Normalize model/tool path strings before resolving them on disk. */
-function normalizeToolPath(input) {
-    let value = input.trim();
-    const markdownLink = value.match(/^!?\[[^\]]*\]\(([\s\S]+)\)$/u);
-    if (markdownLink) {
-        value = markdownLink[1].trim();
-        if (value.startsWith('<')) {
-            const end = value.indexOf('>');
-            if (end >= 0) {
-                value = value.slice(1, end);
-            }
-        }
-        else {
-            value = value.replace(/\s+["'][\s\S]*["']$/u, '');
-        }
-    }
-    if ((value.startsWith('`') && value.endsWith('`')) ||
-        (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))) {
-        value = value.slice(1, -1);
-    }
-    if (value.startsWith('file://')) {
-        try {
-            return decodeURIComponent(new URL(value).pathname);
-        }
-        catch (error) {
-            // Malformed URL or bad percent-encoding: strip the scheme so the path
-            // still reaches the caller's own validation instead of vanishing.
-            return value.replace(/^file:\/\//u, '');
-        }
-    }
-    // Plain filesystem paths are not URLs: do NOT percent-decode them, or a
-    // literal filename like "lit%41.txt" is silently rewritten to "litA.txt".
-    return value;
-}
-/** Safely stat a path, returning null for dangling symlinks or missing files
- *  instead of throwing ENOENT. Uses lstatSync to avoid following symlinks
- *  when checking existence. */
-function safeStatSync(resolved) {
-    try {
-        // lstatSync does NOT follow symlinks — safe for dangling ones.
-        const lst = (0, fs_1.lstatSync)(resolved);
-        if (lst.isSymbolicLink()) {
-            // For symlinks, use statSync (follows the link) inside try/catch.
-            // If the target doesn't exist, statSync throws ENOENT — catch and return null.
-            try {
-                return (0, fs_1.statSync)(resolved);
-            }
-            catch {
-                return null; // dangling symlink
-            }
-        }
-        return (0, fs_1.statSync)(resolved);
-    }
-    catch {
-        return null; // path doesn't exist at all
-    }
-}
-/** Read a file safely, returning null for dangling symlinks or unreadable files. */
-function safeReadFileSync(resolved) {
-    try {
-        // Check if it's a dangling symlink before attempting read.
-        const st = safeStatSync(resolved);
-        if (!st || st.isDirectory())
-            return null;
-        return (0, fs_1.readFileSync)(resolved, 'utf-8');
-    }
-    catch (error) {
-        // Permission denied or a binary that is not valid UTF-8; callers treat null
-        // as "no content", which otherwise hides a real read failure.
-        (0, debug_log_1.debugError)('tools.safeReadFile', error, resolved);
-        return null;
-    }
-}
-/** Resolve tool path parameters relative to the current tool cwd. */
-function safePath(input, cwd = process.cwd()) {
-    return (0, path_1.resolve)(cwd, normalizeToolPath(input));
-}
-/**
- * Return true when `p` resolves (after following symlinks) to a location at or
- * under `rootReal`. Used to enforce that a realpath is still inside the
- * workspace even when directories along the path are themselves symlinks.
- */
-function isWithinWorkspace(resolved, cwd) {
-    return (0, workspace_containment_1.isWorkspacePath)(cwd, resolved);
-}
-function isExecCwdWithinWorkspace(workdir, projectRoot) {
-    const root = (0, path_1.resolve)(projectRoot);
-    const rel = (0, path_1.relative)(root, workdir);
-    if (!(rel === '' || (!rel.startsWith('..') && !(0, path_1.isAbsolute)(rel))))
-        return false;
-    // A missing synthetic root can only fail at spawn time; lexical containment
-    // still prevents it from selecting an external directory. Real workspaces
-    // take the shared symlink-aware boundary check.
-    return (0, fs_1.existsSync)(root) ? (0, workspace_containment_1.isWorkspacePath)(root, workdir) : true;
-}
-/**
- * Truncate text to at most maxBytes UTF-8 bytes, cutting on a character
- * boundary (never inside a multi-byte sequence or surrogate pair). Returns the
- * truncated text and the byte length it was cut at. String.slice counts UTF-16
- * code units, not bytes, so it is wrong for enforcing a byte budget on CJK or
- * emoji content and can split a surrogate pair.
- */
-function truncateToBytes(text, maxBytes) {
-    const buf = Buffer.from(text, 'utf-8');
-    if (buf.length <= maxBytes)
-        return { text, bytes: buf.length };
-    let cut = maxBytes;
-    // Walk back past UTF-8 continuation bytes (0x80-0xBF) to a lead-byte boundary.
-    while (cut > 0 && (buf[cut] & 0xc0) === 0x80)
-        cut--;
-    return { text: buf.subarray(0, cut).toString('utf-8'), bytes: cut };
-}
-function readPositiveInteger(value, name, defaultValue) {
-    if (value === undefined)
-        return defaultValue;
-    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1) {
-        return `read_file ${name} must be a positive integer`;
-    }
-    return value;
-}
-async function readFileSync_(path, maxLines, offset, cwd) {
-    try {
-        const normalizedPath = normalizeToolPath(path);
-        const resolved = safePath(path, cwd);
-        const workspaceRoot = cwd ?? process.cwd();
-        if (!isWithinWorkspace(resolved, workspaceRoot)) {
-            return {
-                success: false,
-                output: '',
-                error: `Refusing to read outside the workspace: ${normalizedPath}`,
-            };
-        }
-        if (!(0, fs_1.existsSync)(resolved)) {
-            return { success: false, output: '', error: `File not found: ${normalizedPath}` };
-        }
-        const st = safeStatSync(resolved);
-        if (!st) {
-            return {
-                success: false,
-                output: '',
-                error: `Cannot access file: ${normalizedPath} (may be a dangling symlink or missing)`,
-            };
-        }
-        if (st.isDirectory()) {
-            return {
-                success: false,
-                output: '',
-                error: `Path is a directory, not a file: ${normalizedPath}`,
-            };
-        }
-        const content = safeReadFileSync(resolved);
-        if (content === null) {
-            return {
-                success: false,
-                output: '',
-                error: `Cannot read file: ${normalizedPath}`,
-            };
-        }
-        const lines = content.split('\n');
-        const maxBytes = 51200; // 50KB byte limit
-        if (offset > lines.length) {
-            return {
-                success: false,
-                output: '',
-                error: `read_file offset ${offset} is beyond the file (${lines.length} lines)`,
-            };
-        }
-        const startIndex = offset - 1;
-        const selectedLines = lines.slice(startIndex, startIndex + maxLines);
-        const selected = selectedLines.join('\n');
-        const remainingLines = Math.max(0, lines.length - startIndex - selectedLines.length);
-        if (remainingLines > 0) {
-            const byteLen = Buffer.byteLength(selected, 'utf8');
-            const notice = `\n\n[... truncated, ${remainingLines} more lines; showing lines ${offset}-${offset + selectedLines.length - 1} of ${lines.length}]`;
-            if (byteLen > maxBytes) {
-                const cut = truncateToBytes(selected, maxBytes);
-                return {
-                    success: true,
-                    output: cut.text + `\n\n[... truncated at ${cut.bytes}B]`,
-                };
-            }
-            return { success: true, output: selected + notice };
-        }
-        // Also apply byte limit to the selected page.
-        const byteLen = Buffer.byteLength(selected, 'utf8');
-        if (byteLen > maxBytes) {
-            const cut = truncateToBytes(selected, maxBytes);
-            return {
-                success: true,
-                output: cut.text + `\n\n[... truncated at ${cut.bytes}B of ${byteLen}B]`,
-            };
-        }
-        return { success: true, output: selected };
-    }
-    catch (err) {
-        return { success: false, output: '', error: (0, errors_1.errorMessage)(err) };
-    }
-}
-async function writeFileSync_(path, content, cwd) {
-    try {
-        const normalizedPath = normalizeToolPath(path);
-        const resolved = safePath(path, cwd);
-        const workspaceRoot = cwd ?? process.cwd();
-        if (!isWithinWorkspace(resolved, workspaceRoot)) {
-            return {
-                success: false,
-                output: '',
-                error: `Refusing to write outside the workspace: ${normalizedPath}`,
-            };
-        }
-        (0, fs_1.mkdirSync)((0, path_1.dirname)(resolved), { recursive: true });
-        (0, fs_1.writeFileSync)(resolved, content, 'utf-8');
-        return {
-            success: true,
-            output: `Wrote ${content.split('\n').length} lines to ${normalizedPath}`,
-        };
-    }
-    catch (err) {
-        return { success: false, output: '', error: (0, errors_1.errorMessage)(err) };
-    }
-}
-async function listFiles_(path, maxDepth, cwd) {
-    const normalizedPath = normalizeToolPath(path);
-    const resolved = safePath(path, cwd);
-    const workspaceRoot = cwd ?? process.cwd();
-    if (!isWithinWorkspace(resolved, workspaceRoot)) {
-        return {
-            success: false,
-            output: '',
-            error: `Refusing to list outside the workspace: ${normalizedPath}`,
-        };
-    }
-    if (!(0, fs_1.existsSync)(resolved)) {
-        return { success: false, output: '', error: `Path not found: ${normalizedPath}` };
-    }
-    if (!(0, fs_1.statSync)(resolved).isDirectory()) {
-        return { success: true, output: normalizedPath };
-    }
-    const depth = maxDepth ?? 2;
-    const results = [];
-    function walk(dir, currentDepth, prefix) {
-        if (currentDepth > depth)
-            return;
-        try {
-            const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.name.startsWith('.') && entry.name !== '.')
-                    continue;
-                const fullPath = (0, path_1.join)(dir, entry.name);
-                const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-                if (entry.isDirectory()) {
-                    results.push(`${relPath}/`);
-                    walk(fullPath, currentDepth + 1, relPath);
-                }
-                else {
-                    results.push(relPath);
-                }
-            }
-        }
-        catch {
-            // skip unreadable directories
-        }
-    }
-    walk(resolved, 1, '');
-    // Limit output to 500 entries
-    const maxEntries = 500;
-    const output = results.length > maxEntries
-        ? results.slice(0, maxEntries).join('\n') +
-            `\n\n[... truncated, ${results.length - maxEntries} more entries]`
-        : results.join('\n');
-    return { success: true, output };
-}
-// Issue #32 #3.2: execCommand_ 支持 abortSignal
-function resolveExecCommandPaths(cwd, baseCwd) {
-    const projectRoot = (0, path_1.resolve)(baseCwd ?? process.cwd());
-    if (!cwd)
-        return { workdir: projectRoot, projectRoot };
-    const normalizedCwd = normalizeToolPath(cwd);
-    if ((0, path_1.isAbsolute)(normalizedCwd)) {
-        throw new Error('exec_command cwd must be a workspace-relative path');
-    }
-    const workdir = safePath(normalizedCwd, projectRoot);
-    if (!isExecCwdWithinWorkspace(workdir, projectRoot)) {
-        throw new Error('exec_command cwd must stay within the workspace');
-    }
-    return {
-        workdir,
-        projectRoot,
-    };
-}
-async function execCommand_(command, cwd, timeout, maxOutput, abortSignal, baseCwd, sandbox) {
-    let paths;
-    try {
-        paths = resolveExecCommandPaths(cwd, baseCwd);
-    }
-    catch (error) {
-        return {
-            success: false,
-            output: '',
-            error: error instanceof Error ? error.message : 'exec_command cwd is outside workspace',
-        };
-    }
-    const { workdir, projectRoot } = paths;
-    // v0.1.3-2 §1.2: plan the (possibly sandboxed) argv before spawning. A
-    // configured sandbox that cannot be honoured must refuse the command rather
-    // than silently degrade into an unsandboxed run.
-    const plan = (0, sandbox_1.planSandboxedCommand)(command, {
-        cwd: workdir,
-        projectRoot,
-        settings: sandbox ?? (0, sandbox_1.resolveSandboxSettings)(projectRoot),
-    });
-    if (!plan.ok) {
-        return {
-            success: false,
-            output: '',
-            error: `Refusing to run: sandbox profile "${plan.profile}" is configured but cannot be applied — ${plan.reason}. ` +
-                'Set sandbox.profile to "none" to run without isolation.',
-        };
-    }
-    return new Promise(resolve => {
-        const timeoutMs = timeout ?? 30000;
-        const maxBytes = maxOutput ?? 51200; // Default 50KB, Issue #28 fix
-        // The docker backend bind-mounts `workdir` into the container; the host
-        // directory must exist at container-creation time or the mount fails with a
-        // confusing "nonexistent directory" error. Create it deterministically
-        // rather than relying on docker to materialise it.
-        if (plan.backend === 'docker') {
-            try {
-                (0, fs_1.mkdirSync)(workdir, { recursive: true });
-            }
-            catch {
-                // If it cannot be created we let the spawn fail with a clear error.
-            }
-        }
-        // Use spawn for streaming output with truncation support. The user command
-        // is a single argv element, so no intermediate shell re-parses it.
-        const useProcessGroup = process.platform !== 'win32';
-        const child = (0, child_process_1.spawn)(plan.file, plan.args, {
-            cwd: workdir,
-            detached: useProcessGroup,
-        });
-        // Issue #53: exec_command runs a complete command as a single argv element
-        // and never pipes input into it. If stdin stays open, stdin-reading commands
-        // (cat, sort, grep, `python3 -`, ...) block waiting for EOF until the timeout.
-        // Close it immediately so the child receives EOF and can proceed.
-        child.stdin?.end();
-        let stdoutData = '';
-        let stderrData = '';
-        let stdoutTruncated = false;
-        let stderrTruncated = false;
-        // Issue #32 修复：使用独立计数器
-        let stdoutBytes = 0;
-        let stderrBytes = 0;
-        let interrupted = null;
-        // Issue #32 #3.2: AbortSignal 处理
-        // Declared uninitialized on purpose: `finish()` below closes over it before the
-        // `timeoutId = setTimeout(...)` assignment. `const` without an initializer is a
-        // compile error (TS1155), and inlining the assignment would put it in the closure's TDZ.
-        // eslint-disable-next-line prefer-const
-        let timeoutId;
-        let killTimerId;
-        let settled = false;
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timeoutId)
-                clearTimeout(timeoutId);
-            if (killTimerId)
-                clearTimeout(killTimerId);
-            if (abortSignal) {
-                abortSignal.removeEventListener('abort', abortHandler);
-            }
-            resolve(result);
-        };
-        const terminateChild = () => {
-            if (!child.pid || child.killed)
-                return;
-            try {
-                if (useProcessGroup) {
-                    process.kill(-child.pid, 'SIGTERM');
-                }
-                else {
-                    child.kill('SIGTERM');
-                }
-            }
-            catch {
-                child.kill('SIGTERM');
-            }
-            killTimerId = setTimeout(() => {
-                if (!child.pid || child.killed || settled)
-                    return;
-                try {
-                    if (useProcessGroup) {
-                        process.kill(-child.pid, 'SIGKILL');
-                    }
-                    else {
-                        child.kill('SIGKILL');
-                    }
-                }
-                catch {
-                    child.kill('SIGKILL');
-                }
-            }, 500);
-            killTimerId.unref?.();
-        };
-        const abortHandler = () => {
-            interrupted = 'aborted';
-            terminateChild();
-        };
-        if (abortSignal) {
-            abortSignal.addEventListener('abort', abortHandler);
-            if (abortSignal.aborted) {
-                abortHandler();
-            }
-        }
-        // Timeout handling
-        timeoutId = setTimeout(() => {
-            if (!interrupted) {
-                interrupted = 'timeout';
-                terminateChild();
-            }
-        }, timeoutMs);
-        // Stream stdout with truncation
-        child.stdout.on('data', (data) => {
-            if (!stdoutTruncated) {
-                const chunk = data.toString();
-                // Issue #30: count UTF-8 bytes, not UTF-16 code units, so CJK/emoji
-                // output is bounded by `maxBytes` (a UTF-16 count could exceed it ~2x).
-                const chunkBytes = Buffer.byteLength(chunk, 'utf8');
-                if (stdoutBytes + chunkBytes > maxBytes) {
-                    stdoutTruncated = true;
-                    const room = Math.max(0, maxBytes - stdoutBytes);
-                    // Byte-accurate truncation that respects multi-byte character boundaries.
-                    stdoutData += truncateToBytes(chunk, room).text;
-                    stdoutBytes = maxBytes;
-                }
-                else {
-                    stdoutData += chunk;
-                    stdoutBytes += chunkBytes;
-                }
-            }
-        });
-        // Stream stderr with truncation (Issue #32 修复：使用独立计数器)
-        child.stderr.on('data', (data) => {
-            if (!stderrTruncated) {
-                const chunk = data.toString();
-                // Issue #30: count UTF-8 bytes, not UTF-16 code units.
-                const chunkBytes = Buffer.byteLength(chunk, 'utf8');
-                if (stderrBytes + chunkBytes > maxBytes) {
-                    stderrTruncated = true;
-                    const room = Math.max(0, maxBytes - stderrBytes);
-                    stderrData += truncateToBytes(chunk, room).text;
-                    stderrBytes = maxBytes;
-                }
-                else {
-                    stderrData += chunk;
-                    stderrBytes += chunkBytes;
-                }
-            }
-        });
-        child.on('close', code => {
-            if (interrupted === 'aborted') {
-                finish({
-                    success: false,
-                    output: truncateToBytes(stdoutData, maxBytes).text,
-                    error: 'Command aborted by user',
-                });
-                return;
-            }
-            if (interrupted === 'timeout') {
-                finish({
-                    success: false,
-                    output: truncateToBytes(stdoutData, maxBytes).text,
-                    error: `Command timed out after ${timeoutMs}ms`,
-                });
-                return;
-            }
-            const output = stdoutData.trim();
-            const errOutput = stderrData.trim();
-            // Add truncation notice if output was truncated
-            let finalOutput = output;
-            if (stdoutTruncated) {
-                finalOutput += '\n\n[... output truncated, exceeded 50KB limit]';
-            }
-            if (code !== 0) {
-                finish({
-                    success: false,
-                    output: finalOutput || errOutput,
-                    error: `Command exited with code ${code}`,
-                });
-            }
-            else {
-                finish({
-                    success: true,
-                    output: finalOutput || '(no output)',
-                    error: stderrTruncated
-                        ? errOutput + '\n\n[... stderr truncated]'
-                        : errOutput || undefined,
-                });
-            }
-        });
-        child.on('error', err => {
-            finish({
-                success: false,
-                output: '',
-                error: err.message,
-            });
-        });
-    });
-}
-function lineNumberForIndex(content, index) {
-    return content.slice(0, Math.max(0, index)).split('\n').length;
-}
-function findAllMatchIndexes(content, needle, limit = 20) {
-    const indexes = [];
-    let cursor = 0;
-    while (indexes.length < limit) {
-        const index = content.indexOf(needle, cursor);
-        if (index < 0)
-            break;
-        indexes.push(index);
-        cursor = index + Math.max(needle.length, 1);
-    }
-    return indexes;
-}
-function previewLine(text) {
-    return text.replace(/\s+/g, ' ').trim().slice(0, 120);
-}
-function buildEditCandidates(params) {
-    const cursorByMatch = new Map();
-    return params.matches.slice(0, 20).map((match, index) => {
-        const cursor = cursorByMatch.get(match) ?? 0;
-        const matchIndex = params.content.indexOf(match, cursor);
-        cursorByMatch.set(match, matchIndex >= 0 ? matchIndex + Math.max(match.length, 1) : cursor);
-        const lineNum = matchIndex >= 0 ? lineNumberForIndex(params.content, matchIndex) : 0;
-        // Get context lines (3 before, 3 after)
-        const allLines = params.content.split('\n');
-        const contextBefore = allLines.slice(Math.max(0, lineNum - 4), lineNum).join('\n');
-        const contextAfter = allLines.slice(lineNum + 1, lineNum + 4).join('\n');
-        return {
-            index,
-            line: lineNum,
-            match,
-            contextBefore,
-            contextAfter,
-            isReplaceAll: (params.count ?? 1) > 1,
-        };
-    });
-}
-function formatEditPreview(params) {
-    const cursorByMatch = new Map();
-    const lines = [
-        `Preview: ${params.kind === 'fuzzy' ? `Fuzzy ${params.strategy ?? 'match'}` : 'Exact match'} candidates (${params.matches.length})`,
-    ];
-    params.matches.slice(0, 20).forEach((match, index) => {
-        const cursor = cursorByMatch.get(match) ?? 0;
-        const matchIndex = params.content.indexOf(match, cursor);
-        cursorByMatch.set(match, matchIndex >= 0 ? matchIndex + Math.max(match.length, 1) : cursor);
-        const lineNum = matchIndex >= 0 ? lineNumberForIndex(params.content, matchIndex) : '?';
-        lines.push(`${index + 1}. line ${lineNum}: "${previewLine(match)}"`);
-    });
-    if (params.matches.length > 20) {
-        lines.push(`... ${params.matches.length - 20} more candidates omitted`);
-    }
-    lines.push(`Would replace with: "${previewLine(params.newString)}"`);
-    return lines.join('\n');
-}
-/**
- * Attempt to find old_string in content using fuzzy matching strategies.
- * Returns null if no match found, or the matched strings.
- */
-function fuzzyMatch(content, oldString) {
-    // Strategy 1: Line-by-line matching (allow different indentation)
-    const oldLines = oldString
-        .split('\n')
-        .map(l => l.trim())
-        .filter(Boolean);
-    const contentLines = content.split('\n');
-    const lineMatches = [];
-    for (let i = 0; i <= contentLines.length - oldLines.length; i++) {
-        let allMatch = true;
-        for (let j = 0; j < oldLines.length; j++) {
-            if (contentLines[i + j].trim() !== oldLines[j]) {
-                allMatch = false;
-                break;
-            }
-        }
-        if (allMatch) {
-            const matchedStr = contentLines.slice(i, i + oldLines.length).join('\n');
-            lineMatches.push(matchedStr);
-        }
-    }
-    if (lineMatches.length > 0) {
-        return { matches: lineMatches, strategy: 'line' };
-    }
-    // Strategy 2: Whitespace-tolerant token match. This preserves the actual
-    // matched span without consuming unrelated leading/trailing blank lines.
-    const tokens = oldString.trim().split(/\s+/).filter(Boolean);
-    if (tokens.length === 0)
-        return null;
-    const pattern = tokens.map(escapeRegExp).join('\\s+');
-    const regex = new RegExp(pattern, 'g');
-    const wsMatches = [];
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-        if (match[0]) {
-            wsMatches.push(match[0]);
-        }
-        if (wsMatches.length > 5)
-            break; // Safety limit
-        if (match.index === regex.lastIndex)
-            regex.lastIndex++;
-    }
-    if (wsMatches.length > 0) {
-        return { matches: wsMatches, strategy: 'whitespace' };
-    }
-    return null;
-}
-async function editFile_(path, old_string, new_string, replace_all, fuzzy_match, preview, cwd) {
-    try {
-        const normalizedPath = normalizeToolPath(path);
-        const resolved = safePath(path, cwd);
-        const workspaceRoot = cwd ?? process.cwd();
-        if (!isWithinWorkspace(resolved, workspaceRoot)) {
-            return {
-                success: false,
-                output: '',
-                error: `Refusing to edit outside the workspace: ${normalizedPath}`,
-            };
-        }
-        if (!(0, fs_1.existsSync)(resolved)) {
-            return { success: false, output: '', error: `File not found: ${normalizedPath}` };
-        }
-        const fileStat = safeStatSync(resolved);
-        if (!fileStat) {
-            return {
-                success: false,
-                output: '',
-                error: `Cannot access file: ${normalizedPath} (may be a dangling symlink)`,
-            };
-        }
-        if (fileStat.isDirectory()) {
-            return {
-                success: false,
-                output: '',
-                error: `Path is a directory, not a file: ${normalizedPath}`,
-            };
-        }
-        const content = safeReadFileSync(resolved);
-        if (content === null) {
-            return { success: false, output: '', error: `Cannot read file: ${normalizedPath}` };
-        }
-        // Check if old_string exists exactly
-        const count = (content.match(new RegExp(escapeRegExp(old_string), 'g')) || []).length;
-        if (count > 0 && preview) {
-            const matchIndexes = findAllMatchIndexes(content, old_string);
-            const matches = matchIndexes.map(() => old_string);
-            return {
-                success: true,
-                output: formatEditPreview({
-                    kind: 'exact',
-                    content,
-                    matches,
-                    newString: new_string,
-                }),
-                metadata: {
-                    candidates: buildEditCandidates({
-                        kind: 'exact',
-                        content,
-                        matches,
-                        newString: new_string,
-                        count,
-                    }),
-                },
-            };
-        }
-        if (count === 0) {
-            if (!fuzzy_match) {
-                return {
-                    success: false,
-                    output: '',
-                    error: `old_string not found in file: ${old_string.slice(0, 100)}...`,
-                };
-            }
-            // Try fuzzy match strategies
-            const fuzzyResult = fuzzyMatch(content, old_string);
-            if (fuzzyResult === null) {
-                return {
-                    success: false,
-                    output: '',
-                    error: `old_string not found in file: ${old_string.slice(0, 100)}...`,
-                };
-            }
-            if (preview) {
-                return {
-                    success: true,
-                    output: formatEditPreview({
-                        kind: 'fuzzy',
-                        content,
-                        matches: fuzzyResult.matches,
-                        newString: new_string,
-                        strategy: fuzzyResult.strategy,
-                    }),
-                    metadata: {
-                        candidates: buildEditCandidates({
-                            kind: 'fuzzy',
-                            content,
-                            matches: fuzzyResult.matches,
-                            newString: new_string,
-                            strategy: fuzzyResult.strategy,
-                        }),
-                    },
-                };
-            }
-            if (fuzzyResult.matches.length > 1) {
-                return {
-                    success: false,
-                    output: '',
-                    error: `Fuzzy match found ${fuzzyResult.matches.length} candidates. Provide a more specific string. First 3 candidates:\n${fuzzyResult.matches
-                        .slice(0, 3)
-                        .map((m, i) => `  ${i + 1}: "${m.slice(0, 80)}..."`)
-                        .join('\n')}`,
-                };
-            }
-            // Use the single fuzzy match only.
-            const match = fuzzyResult.matches[0];
-            const idx = content.indexOf(match);
-            const newContent = content.slice(0, idx) + new_string + content.slice(idx + match.length);
-            (0, fs_1.writeFileSync)(resolved, newContent, 'utf-8');
-            return {
-                success: true,
-                output: `Fuzzy edited ${normalizedPath} (matched by ${fuzzyResult.strategy}, "${match.slice(0, 50)}...")`,
-            };
-        }
-        // If not replace_all, require unique match
-        if (!replace_all && count > 1) {
-            return {
-                success: false,
-                output: '',
-                error: `old_string found ${count} times in file. Use replace_all=true to replace all occurrences, or provide a more specific string that matches exactly once.`,
-            };
-        }
-        // Perform replacement
-        let newContent;
-        if (replace_all) {
-            newContent = content.split(old_string).join(new_string);
-        }
-        else {
-            // Replace first occurrence only
-            const idx = content.indexOf(old_string);
-            newContent = content.slice(0, idx) + new_string + content.slice(idx + old_string.length);
-        }
-        (0, fs_1.writeFileSync)(resolved, newContent, 'utf-8');
-        return {
-            success: true,
-            output: `Replaced ${count} occurrence(s) of old_string with new_string in ${normalizedPath}`,
-        };
-    }
-    catch (err) {
-        return { success: false, output: '', error: (0, errors_1.errorMessage)(err) };
-    }
-}
-/** Escape special regex characters for literal matching */
-function escapeRegExp(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Validate a caller-supplied regular expression pattern before compiling it.
- *
- * Issue #79: `grep_` compiles user/model-supplied patterns with `new RegExp`
- * directly. A pathological pattern with a quantified group that itself contains
- * a quantifier (e.g. `(a+)+`, `(\d+)*`) triggers catastrophic backtracking
- * (ReDoS) and can hang the process on adversarial input (prompt injection).
- * Reject empty/oversized patterns and the classic nested-quantifier shapes.
- */
-function validateRegexPattern(pattern) {
-    if (!pattern)
-        return 'pattern must not be empty';
-    if (pattern.length > 2000)
-        return 'pattern is too long (max 2000 characters)';
-    // A group containing an internal quantifier, then quantified again: the
-    // canonical exponential-backtracking construction. Quantifier families
-    // include braces; treating only `*+?` as quantifiers lets `(a{1,})+` hang
-    // the event loop on a long near miss.
-    const quantifier = String.raw `(?:[*+?]|\{\d+(?:,\d*)?\})`;
-    if (new RegExp(String.raw `\([^()]*${quantifier}[^()]*\)\s*${quantifier}`).test(pattern)) {
-        return 'pattern contains a quantified group with an internal quantifier — this risks catastrophic backtracking (ReDoS)';
-    }
-    // Reject the common overlapping-alternative form `(a|aa)+`: either branch
-    // can consume the same prefix, creating exponentially many partitions.
-    const quantifiedGroup = new RegExp(String.raw `\(([^()]*)\)\s*${quantifier}`, 'gu');
-    for (const match of pattern.matchAll(quantifiedGroup)) {
-        const alternatives = match[1].split('|');
-        if (alternatives.length > 1 &&
-            alternatives.some((left, index) => alternatives.some((right, otherIndex) => index !== otherIndex && left.length > 0 && right.length > 0 && right.startsWith(left)))) {
-            return 'pattern contains overlapping alternatives inside a quantified group — this risks catastrophic backtracking (ReDoS)';
-        }
-    }
-    try {
-        new RegExp(pattern);
-    }
-    catch {
-        return 'pattern is not a valid regular expression';
-    }
-    return null;
-}
-// ============================================================================
-// Glob/Grep 工具实现
-// ============================================================================
-/**
- * Glob 模式匹配 - 简化版实现
- * 支持: **（递归目录）、*（任意字符）、?（单个字符）
- */
-async function glob_(pattern, basePath, cwd) {
-    try {
-        const normalizedBasePath = basePath ? normalizeToolPath(basePath) : (cwd ?? process.cwd());
-        const base = basePath ? safePath(basePath, cwd) : (cwd ?? process.cwd());
-        const workspaceRoot = cwd ?? process.cwd();
-        if (!isWithinWorkspace(base, workspaceRoot)) {
-            return {
-                success: false,
-                output: '',
-                error: `Refusing to search outside the workspace: ${normalizedBasePath}`,
-            };
-        }
-        if (!(0, fs_1.existsSync)(base)) {
-            return { success: false, output: '', error: `Path not found: ${normalizedBasePath}` };
-        }
-        if (!(0, fs_1.statSync)(base).isDirectory()) {
-            return {
-                success: false,
-                output: '',
-                error: `Path is not a directory: ${normalizedBasePath}`,
-            };
-        }
-        const results = [];
-        // Convert glob pattern to regex.
-        // Escape ALL regex metacharacters first, then translate glob wildcards.
-        // Escaping only `.` (the old behavior) left parens/brackets/+/^/$/| as
-        // regex syntax: a literal "(group)" became a capture group (so the real
-        // file stopped matching) and an unbalanced "[" made new RegExp throw.
-        function globToRegex(pat) {
-            // Use placeholders for glob wildcards so escaping does not touch them.
-            let regex = pat;
-            // **/ at start - matches optional path (including empty)
-            regex = regex.replace(/^\*\*\//, '<<STARSTAR_SLASH_START>>');
-            // **/ in middle - matches any number of path segments
-            regex = regex.replace(/\*\*\//g, '<<STARSTAR_SLASH>>');
-            // standalone ** - matches anything
-            regex = regex.replace(/\*\*/g, '<<STARSTAR>>');
-            // Escape every regex metacharacter in the remaining literal text.
-            // NOTE: * and ? are glob wildcards, handled below - do not escape them.
-            regex = regex.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-            // * matches anything except /
-            regex = regex.replace(/\*/g, '[^/]*');
-            // ? matches single char except /
-            regex = regex.replace(/\?/g, '[^/]');
-            // Now restore ** placeholders
-            regex = regex.replace(/<<STARSTAR_SLASH_START>>/g, '(.*\\/)?');
-            regex = regex.replace(/<<STARSTAR_SLASH>>/g, '([^/]+\\/)*');
-            regex = regex.replace(/<<STARSTAR>>/g, '.*');
-            return new RegExp(`^${regex}$`);
-        }
-        const regex = globToRegex(pattern);
-        // Recursive walk with a depth cap so a pathological tree (or symlink loop)
-        // cannot hang or OOM the tool.
-        const MAX_DEPTH = 16;
-        function walk(dir, prefix, depth) {
-            if (depth > MAX_DEPTH)
-                return;
-            try {
-                const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.name.startsWith('.'))
-                        continue;
-                    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-                    if (entry.isDirectory()) {
-                        walk((0, path_1.join)(dir, entry.name), relPath, depth + 1);
-                    }
-                    else {
-                        if (regex.test(relPath)) {
-                            results.push(relPath);
-                        }
-                    }
-                }
-            }
-            catch {
-                // skip unreadable directories
-            }
-        }
-        walk(base, '', 0);
-        if (results.length === 0) {
-            return { success: true, output: 'No files found matching pattern' };
-        }
-        // Limit output to 200 matches
-        const maxMatches = 200;
-        const sorted = results.sort();
-        const output = sorted.length > maxMatches
-            ? sorted.slice(0, maxMatches).join('\n') +
-                `\n\n[... truncated, ${sorted.length - maxMatches} more matches]`
-            : sorted.join('\n');
-        return { success: true, output };
-    }
-    catch (err) {
-        return { success: false, output: '', error: (0, errors_1.errorMessage)(err) };
-    }
-}
-/**
- * Grep 搜索 - 在文件中搜索正则表达式
- */
-async function grep_(pattern, basePath, globPattern, contextLines, cwd) {
-    try {
-        const normalizedBasePath = basePath ? normalizeToolPath(basePath) : (cwd ?? process.cwd());
-        const base = basePath ? safePath(basePath, cwd) : (cwd ?? process.cwd());
-        const workspaceRoot = cwd ?? process.cwd();
-        if (!isWithinWorkspace(base, workspaceRoot)) {
-            return {
-                success: false,
-                output: '',
-                error: `Refusing to search outside the workspace: ${normalizedBasePath}`,
-            };
-        }
-        if (!(0, fs_1.existsSync)(base)) {
-            return { success: false, output: '', error: `Path not found: ${normalizedBasePath}` };
-        }
-        const patternError = validateRegexPattern(pattern);
-        if (patternError) {
-            return { success: false, output: '', error: `Invalid grep pattern: ${patternError}` };
-        }
-        const regex = new RegExp(pattern);
-        const context = contextLines ?? 0;
-        const results = [];
-        const maxResults = 100;
-        // Get list of files to search
-        const files = [];
-        const skippedDangling = [];
-        function collectFiles(dir) {
-            try {
-                const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.name.startsWith('.'))
-                        continue;
-                    const fullPath = (0, path_1.join)(dir, entry.name);
-                    if (entry.isDirectory()) {
-                        collectFiles(fullPath);
-                    }
-                    else {
-                        // Check glob filter if provided
-                        if (globPattern) {
-                            if (!matchGlobSimple(entry.name, globPattern))
-                                continue;
-                        }
-                        // Skip dangling symlinks — collect their paths for a warning.
-                        if (entry.isSymbolicLink()) {
-                            try {
-                                (0, fs_1.statSync)(fullPath);
-                            }
-                            catch {
-                                skippedDangling.push(fullPath);
-                                continue;
-                            }
-                        }
-                        files.push(fullPath);
-                    }
-                }
-            }
-            catch {
-                // skip unreadable
-            }
-        }
-        function matchGlobSimple(name, pat) {
-            const escaped = pat.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-            const regex = escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
-            return new RegExp(`^${regex}$`).test(name);
-        }
-        const baseStat = safeStatSync(base);
-        if (!baseStat) {
-            return {
-                success: false,
-                output: '',
-                error: `Cannot access path: ${base} (may be a dangling symlink or missing)`,
-            };
-        }
-        if (baseStat.isDirectory()) {
-            collectFiles(base);
-        }
-        else {
-            // Skip dangling symlinks / unreadable single files early.
-            const fileStat = safeStatSync(base);
-            if (fileStat && fileStat.isFile()) {
-                files.push(base);
-            }
-        }
-        // Search each file
-        for (const file of files) {
-            if (results.length >= maxResults)
-                break;
-            try {
-                // Skip dangling symlinks and unreadable files before creating the stream.
-                const fileStat = safeStatSync(file);
-                if (!fileStat || !fileStat.isFile())
-                    continue;
-                const stream = (0, fs_1.createReadStream)(file, { encoding: 'utf-8' });
-                const rl = (0, readline_1.createInterface)({
-                    input: stream,
-                    crlfDelay: Infinity,
-                });
-                const lines = [];
-                const relPath = (0, path_1.relative)(base, file);
-                rl.on('line', line => {
-                    lines.push(line);
-                });
-                // Guard against stream errors (dangling symlinks, permission denied, etc.)
-                await new Promise((resolve, reject) => {
-                    stream.on('error', reject);
-                    rl.on('close', resolve);
-                });
-                // Search for matches
-                for (let i = 0; i < lines.length && results.length < maxResults; i++) {
-                    if (regex.test(lines[i])) {
-                        // Format: file:line:content
-                        const start = Math.max(0, i - context);
-                        const end = Math.min(lines.length - 1, i + context);
-                        if (context > 0) {
-                            results.push(`${relPath}:${i + 1}:`);
-                            for (let j = start; j <= end; j++) {
-                                const prefix = j === i ? '>' : ' ';
-                                results.push(`  ${prefix}${j + 1}: ${lines[j]}`);
-                            }
-                            results.push('');
-                        }
-                        else {
-                            results.push(`${relPath}:${i + 1}: ${lines[i]}`);
-                        }
-                    }
-                }
-            }
-            catch {
-                // skip unreadable files
-            }
-        }
-        const symlinkWarning = skippedDangling.length > 0
-            ? `\n⚠️  Skipped ${skippedDangling.length} dangling symlink(s): ${skippedDangling.slice(0, 3).join(', ')}${skippedDangling.length > 3 ? '...' : ''}\n`
-            : '';
-        if (results.length === 0) {
-            return { success: true, output: 'No matches found' + symlinkWarning };
-        }
-        return { success: true, output: results.slice(0, maxResults).join('\n') + symlinkWarning };
-    }
-    catch (err) {
-        return { success: false, output: '', error: (0, errors_1.errorMessage)(err) };
-    }
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function parseBatchReadSteps(rawSteps) {
-    let value = rawSteps;
-    if (typeof value === 'string') {
-        try {
-            value = JSON.parse(value);
-        }
-        catch {
-            return { error: 'batch_read steps must be an array or a valid JSON array string' };
-        }
-    }
-    if (!Array.isArray(value)) {
-        return { error: 'batch_read requires steps to be an array' };
-    }
-    if (value.length === 0) {
-        return { error: 'batch_read requires at least one step' };
-    }
-    if (value.length > exports.BATCH_READ_MAX_STEPS) {
-        return { error: `batch_read supports at most ${exports.BATCH_READ_MAX_STEPS} steps` };
-    }
-    const steps = [];
-    for (let i = 0; i < value.length; i++) {
-        const step = value[i];
-        if (!isRecord(step)) {
-            return { error: `batch_read step ${i + 1} must be an object` };
-        }
-        if (typeof step.tool !== 'string' || !step.tool) {
-            return { error: `batch_read step ${i + 1} requires a tool string` };
-        }
-        let stepArgs = step.args;
-        if (typeof stepArgs === 'string') {
-            try {
-                stepArgs = JSON.parse(stepArgs);
-            }
-            catch {
-                return {
-                    error: `batch_read step ${i + 1} args must be an object or valid JSON object string`,
-                };
-            }
-        }
-        if (!isRecord(stepArgs)) {
-            return { error: `batch_read step ${i + 1} requires args to be an object` };
-        }
-        steps.push({ tool: step.tool, args: stepArgs });
-    }
-    return { steps };
-}
-function buildBatchReadPayload(success, summary, steps, error) {
-    const payload = {
-        success,
-        output: steps
-            .map(step => `${step.index}. ${step.tool}: ${step.summary || (step.success ? 'ok' : step.error || 'error')}`)
-            .join('\n'),
-        summary,
-        steps,
-    };
-    if (error) {
-        payload.error = error;
-    }
-    return {
-        success,
-        output: JSON.stringify(payload, null, 2),
-        summary,
-        error,
-    };
-}
-async function executeBatchRead(args, context) {
-    const parsed = parseBatchReadSteps(args.steps);
-    if (parsed.error || !parsed.steps) {
-        return buildBatchReadPayload(false, parsed.error || 'Invalid batch_read request', [], parsed.error);
-    }
-    const runtimeTools = getRuntimeTools();
-    for (let i = 0; i < parsed.steps.length; i++) {
-        const step = parsed.steps[i];
-        const tool = runtimeTools.find(t => t.name === step.tool);
-        if (!exports.BATCH_READ_ALLOWED_TOOLS.has(step.tool)) {
-            const error = `Tool ${step.tool} is not allowed in batch_read`;
-            return buildBatchReadPayload(false, error, [
-                {
-                    index: i + 1,
-                    tool: step.tool,
-                    args: step.args,
-                    success: false,
-                    error,
-                    output: '',
-                },
-            ], error);
-        }
-        if (!tool || tool.isReadOnly?.(step.args) !== true) {
-            const error = `Tool ${step.tool} is unavailable or not read-only`;
-            return buildBatchReadPayload(false, error, [
-                {
-                    index: i + 1,
-                    tool: step.tool,
-                    args: step.args,
-                    success: false,
-                    error,
-                    output: '',
-                },
-            ], error);
-        }
-        // The scheduler resolved permissions for `batch_read` itself, not for the
-        // tools it fans out to. Without re-running the gate here, a project
-        // `deny: read_file(*.env)` rule applies to the flat call and must also apply
-        // to the batched one, otherwise the model could read a denied path simply
-        // by wrapping it in `batch_read`.
-        const stepPermission = (0, tool_1.getToolMetadataPresence)(tool).hasPermissionCheck && tool.checkPermissions
-            ? tool.checkPermissions(step.args, context)
-            : undefined;
-        const effective = (0, tool_scheduler_1.resolveEffectivePermission)({
-            toolName: step.tool,
-            tool,
-            args: step.args,
-            permission: stepPermission,
-            permissionMode: context.permissionMode,
-            allowlist: context.toolAllowlist?.(step.tool, step.args),
-        });
-        if (effective.outcome === 'deny') {
-            const error = effective.reason || `Tool ${step.tool} is not permitted (${effective.source ?? 'policy'})`;
-            return buildBatchReadPayload(false, error, [
-                {
-                    index: i + 1,
-                    tool: step.tool,
-                    args: step.args,
-                    success: false,
-                    error,
-                    output: '',
-                },
-            ], error);
-        }
-        if (effective.outcome === 'confirm') {
-            const confirmation = context.toolConfirmation ?? 'ask';
-            if (confirmation === 'deny' || !context.confirmToolUse) {
-                const error = confirmation === 'deny'
-                    ? `Tool ${step.tool} requires confirmation and was denied by toolConfirmation=deny.`
-                    : effective.reason || `Tool ${step.tool} requires user confirmation.`;
-                return buildBatchReadPayload(false, error, [
-                    {
-                        index: i + 1,
-                        tool: step.tool,
-                        args: step.args,
-                        success: false,
-                        error,
-                        output: '',
-                    },
-                ], error);
-            }
-            const approved = await context.confirmToolUse({
-                name: step.tool,
-                args: step.args,
-                reason: effective.reason,
-                abortSignal: context.abortSignal,
-            });
-            if (!approved) {
-                const error = `Tool ${step.tool} requires user confirmation and was denied by user.`;
-                return buildBatchReadPayload(false, error, [
-                    {
-                        index: i + 1,
-                        tool: step.tool,
-                        args: step.args,
-                        success: false,
-                        error,
-                        output: '',
-                    },
-                ], error);
-            }
-        }
-    }
-    const stepResults = [];
-    for (let i = 0; i < parsed.steps.length; i++) {
-        const step = parsed.steps[i];
-        try {
-            const rawResult = await executeTool(step.tool, step.args, context.abortSignal, context);
-            const envelope = JSON.parse(rawResult);
-            const output = typeof envelope.output === 'string'
-                ? envelope.output
-                : JSON.stringify(envelope.output ?? '');
-            stepResults.push({
-                index: i + 1,
-                tool: step.tool,
-                args: step.args,
-                success: envelope.success === true,
-                summary: typeof envelope.summary === 'string' ? envelope.summary : undefined,
-                error: typeof envelope.error === 'string' ? envelope.error : undefined,
-                output: (0, tool_artifacts_1.truncateForContext)(output, BATCH_READ_STEP_OUTPUT_MAX_BYTES),
-            });
-        }
-        catch (err) {
-            stepResults.push({
-                index: i + 1,
-                tool: step.tool,
-                args: step.args,
-                success: false,
-                error: (0, errors_1.errorMessage)(err),
-                output: '',
-            });
-        }
-    }
-    const okCount = stepResults.filter(step => step.success).length;
-    const success = okCount === stepResults.length;
-    const summary = `batch_read completed ${okCount}/${stepResults.length} steps`;
-    return buildBatchReadPayload(success, summary, stepResults, success ? undefined : summary);
-}
-// ============================================================================
-// 统一执行入口
-// ============================================================================
-/**
- * 执行一个工具调用，返回结构化结果字符串
- * Issue #32 #3.2: 支持 abortSignal
- */
-async function executeTool(name, args, abortSignal, toolContext) {
-    const runtimeTools = getRuntimeTools();
-    const tool = runtimeTools.find(t => t.name === name);
-    if (!tool) {
-        return JSON.stringify({
-            success: false,
-            error: `Unknown tool: ${name}. Available tools: ${runtimeTools.map(t => t.name).join(', ')}`,
-        });
-    }
-    const context = {
-        cwd: toolContext?.cwd || process.cwd(),
-        config: toolContext?.config || {
-            name: process.env[environment_1.ENV.NAME] || 'orion-code',
-            mode: process.env[environment_1.ENV.MODE] || 'development',
-        },
-        abortSignal, // Issue #32 #3.2: 透传 abortSignal
-        sessionId: toolContext?.sessionId,
-        turnId: toolContext?.turnId,
-        // Must survive the rebuild: batch_read re-runs the permission gate on its
-        // sub-steps and reads both of these off the context.
-        permissionMode: toolContext?.permissionMode,
-        toolAllowlist: toolContext?.toolAllowlist,
-        toolConfirmation: toolContext?.toolConfirmation,
-        confirmToolUse: toolContext?.confirmToolUse,
-        onPlanModeChange: toolContext?.onPlanModeChange,
-    };
-    const result = await tool.execute(args, context);
-    // Assertions are generated by the runtime allowlist, never accepted from a
-    // tool's display summary or arbitrary custom ToolResult payload.
-    const externalAssertion = (0, external_assertion_1.deriveToolExternalAssertion)({ name, args, result });
-    const summary = summarizeToolResult(tool, args, result);
-    const outputBytes = Buffer.byteLength(result.output || '', 'utf8');
-    let output = result.output || '';
-    let artifactRef;
-    if (outputBytes > tool_artifacts_1.ARTIFACT_THRESHOLD) {
-        const artifact = (0, tool_artifacts_1.storeArtifact)(context.cwd, name, output, outputBytes);
-        if (artifact) {
-            artifactRef = { id: artifact.id, outputBytes: artifact.outputBytes };
-            output = (0, tool_artifacts_1.truncateForContext)(output);
-        }
-    }
-    const payload = {
-        success: result.success,
-        output,
-        summary,
-        outputBytes,
-        externalAssertion,
-    };
-    if (!result.success) {
-        payload.error = result.error;
-    }
-    if (artifactRef) {
-        payload.artifactRef = artifactRef;
-    }
-    return JSON.stringify(payload);
-}
-function summarizeToolResult(tool, args, result) {
-    try {
-        return tool.getSummary?.(args, result);
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * 获取可用工具名称列表
- */
-function getToolNames() {
-    return getRuntimeTools()
-        .map(t => t.name)
-        .join(', ');
-}
-// Re-export bash_security module
-var bash_security_2 = require("./bash_security");
-Object.defineProperty(exports, "READ_ONLY_COMMANDS", { enumerable: true, get: function () { return bash_security_2.READ_ONLY_COMMANDS; } });
-Object.defineProperty(exports, "DANGEROUS_PATTERNS", { enumerable: true, get: function () { return bash_security_2.DANGEROUS_PATTERNS; } });
-Object.defineProperty(exports, "POTENTIALLY_DESTRUCTIVE_PATTERNS", { enumerable: true, get: function () { return bash_security_2.POTENTIALLY_DESTRUCTIVE_PATTERNS; } });
-Object.defineProperty(exports, "isReadOnlyCommand", { enumerable: true, get: function () { return bash_security_2.isReadOnlyCommand; } });
-Object.defineProperty(exports, "checkDangerousCommand", { enumerable: true, get: function () { return bash_security_2.checkDangerousCommand; } });
-Object.defineProperty(exports, "isPotentiallyDestructive", { enumerable: true, get: function () { return bash_security_2.isPotentiallyDestructive; } });
-Object.defineProperty(exports, "assessCommandSecurity", { enumerable: true, get: function () { return bash_security_2.assessCommandSecurity; } });
-Object.defineProperty(exports, "findDestructiveRmTarget", { enumerable: true, get: function () { return bash_security_2.findDestructiveRmTarget; } });
-//# sourceMappingURL=index.js.map