dave-code 1.0.4 → 1.1.0

package/bin/toolRuntime.js

@@ -0,0 +1,1052 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import readline from 'readline';
+import { exec as execCommand } from 'child_process';
+
+export const SUPPORTED_TOOLS = new Set([
+  'LIST_DIR',
+  'READ_FILE',
+  'SEARCH_GREP',
+  'EDIT_FILE',
+  'WRITE_FILE',
+  'MAKE_DIR',
+  'MOVE_PATH',
+  'DELETE_PATH',
+  'RUN_COMMAND'
+]);
+export const MUTATING_TOOLS = new Set([
+  'EDIT_FILE', 'WRITE_FILE', 'MAKE_DIR', 'MOVE_PATH', 'DELETE_PATH', 'RUN_COMMAND'
+]);
+export const TOOL_DEFINITIONS = [
+  { name: 'LIST_DIR', description: 'List one directory inside the workspace.', inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'], additionalProperties: false } },
+  { name: 'READ_FILE', description: 'Read a UTF-8 text file or an inclusive line range.', inputSchema: { type: 'object', properties: { path: { type: 'string' }, startLine: { type: 'integer', minimum: 1 }, endLine: { type: 'integer', minimum: 1 } }, required: ['path'], additionalProperties: false } },
+  { name: 'SEARCH_GREP', description: 'Search for an exact text string in workspace text files.', inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'], additionalProperties: false } },
+  { name: 'EDIT_FILE', description: 'Replace exact, unique text in an existing file.', inputSchema: { type: 'object', properties: { path: { type: 'string' }, oldText: { type: 'string' }, newText: { type: 'string' }, replaceAll: { type: 'boolean' } }, required: ['path', 'oldText', 'newText'], additionalProperties: false } },
+  { name: 'WRITE_FILE', description: 'Create or completely replace a UTF-8 text file.', inputSchema: { type: 'object', properties: { path: { type: 'string' }, content: { type: 'string' } }, required: ['path', 'content'], additionalProperties: false } },
+  { name: 'MAKE_DIR', description: 'Create a directory inside the workspace.', inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'], additionalProperties: false } },
+  { name: 'MOVE_PATH', description: 'Move or rename a workspace path.', inputSchema: { type: 'object', properties: { source: { type: 'string' }, destination: { type: 'string' } }, required: ['source', 'destination'], additionalProperties: false } },
+  { name: 'DELETE_PATH', description: 'Delete a file or an empty directory inside the workspace.', inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'], additionalProperties: false } },
+  { name: 'RUN_COMMAND', description: 'Run a command from the workspace root after user confirmation.', inputSchema: { type: 'object', properties: { command: { type: 'string' } }, required: ['command'], additionalProperties: false } }
+];
+
+export function getToolDefinitions(mode = 'chat') {
+  return TOOL_DEFINITIONS.filter(tool => mode === 'code' || !MUTATING_TOOLS.has(tool.name));
+}
+const DEFAULT_TEXT_EXTS = new Set([
+  '.js', '.json', '.txt', '.md', '.html', '.css', '.yml', '.yaml',
+  '.sh', '.bat', '.cmd', '.py', '.cpp', '.h', '.c', '.go', '.rs',
+  '.java', '.ts', '.tsx', '.jsx'
+]);
+
+function decodeEntities(value) {
+  return String(value || '')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&amp;/g, '&');
+}
+
+function buildEditArgument(filePath, oldText, newText, replaceAll = false) {
+  return `${filePath}\n<<<SEARCH\n${oldText}\n===REPLACE\n${newText}\n>>>END${replaceAll ? '\nALL' : ''}`;
+}
+
+function parseDSMLToolCall(text) {
+  const trimmed = String(text || '').trim();
+  if (!/^<｜｜DSML｜｜tool_calls>[\s\S]*<\/｜｜DSML｜｜tool_calls>$/.test(trimmed)) return null;
+  const invokePattern = /<｜｜DSML｜｜invoke\s+name="([^"]+)">([\s\S]*?)<\/｜｜DSML｜｜invoke>/g;
+  const invokes = [...trimmed.matchAll(invokePattern)];
+  if (invokes.length === 0) return null;
+  if (invokes.length !== 1) {
+    return { error: 'Tool parse error: exactly one DSML invocation is allowed.' };
+  }
+
+  const invoke = invokes[0];
+  const sourceName = invoke[1];
+  const body = invoke[2];
+  const params = {};
+  const parameterPattern = /<｜｜DSML｜｜parameter\s+name="([^"]+)"[^>]*>([\s\S]*?)<\/｜｜DSML｜｜parameter>/g;
+  for (const match of body.matchAll(parameterPattern)) {
+    params[match[1]] = decodeEntities(match[2]);
+  }
+
+  const key = sourceName.toLowerCase();
+  const filePath = String(params.filePath || params.path || params.file_path || '').trim();
+  let toolName;
+  let toolArg;
+
+  if (key === 'read') {
+    toolName = 'READ_FILE';
+    const offset = Math.max(1, Number.parseInt(params.offset || '1', 10) || 1);
+    const limit = Math.max(1, Number.parseInt(params.limit || '0', 10) || 0);
+    toolArg = limit ? `${filePath}:${offset}-${offset + limit - 1}` : filePath;
+  } else if (key === 'write') {
+    toolName = 'WRITE_FILE';
+    toolArg = `${filePath}\n${params.content || params.text || ''}`;
+  } else if (key === 'edit' || key === 'strreplace') {
+    toolName = 'EDIT_FILE';
+    toolArg = buildEditArgument(
+      filePath,
+      params.oldString || params.old_string || params.oldText || '',
+      params.newString || params.new_string || params.newText || '',
+      String(params.replaceAll || params.replace_all || '').toLowerCase() === 'true'
+    );
+  } else if (key === 'bash' || key === 'shell' || key === 'runcommand') {
+    toolName = 'RUN_COMMAND';
+    toolArg = params.command || params.cmd || '';
+  } else if (key === 'grep' || key === 'search') {
+    toolName = 'SEARCH_GREP';
+    toolArg = params.pattern || params.query || params.text || '';
+  } else if (key === 'glob' || key === 'list' || key === 'listdir') {
+    toolName = 'LIST_DIR';
+    toolArg = params.path || params.directory || '.';
+  } else if (key === 'delete' || key === 'remove') {
+    toolName = 'DELETE_PATH';
+    toolArg = filePath;
+  } else if (key === 'move' || key === 'rename') {
+    toolName = 'MOVE_PATH';
+    toolArg = `${params.source || params.from || filePath}\n${params.destination || params.to || ''}`;
+  } else if (key === 'mkdir' || key === 'makedir') {
+    toolName = 'MAKE_DIR';
+    toolArg = filePath || params.directory || '';
+  } else {
+    return { error: `Tool parse error: unsupported DSML tool "${sourceName}".` };
+  }
+
+  return {
+    toolName,
+    toolArg,
+    match: invoke,
+    recovered: true,
+    sourceFormat: 'dsml',
+    remainingCalls: 0,
+    thoughtText: ''
+  };
+}
+
+export function createToolTagStreamFilter() {
+  let mode = 'pending';
+  let buffer = '';
+
+  function push(chunk) {
+    const text = String(chunk || '');
+    if (!text) return '';
+    if (mode === 'text') return text;
+    if (mode === 'reasoning') {
+      buffer += text;
+      const closeIndex = buffer.toLowerCase().indexOf('</think>');
+      if (closeIndex === -1) return '';
+      const remainder = buffer.slice(closeIndex + 8);
+      buffer = '';
+      mode = 'pending';
+      return push(remainder);
+    }
+    buffer += text;
+    const trimmed = buffer.trimStart();
+    const lower = trimmed.toLowerCase();
+    const upper = trimmed.toUpperCase();
+
+    if (!trimmed) return '';
+    if (lower.startsWith('<think>')) {
+      mode = 'reasoning';
+      const closeIndex = lower.indexOf('</think>');
+      if (closeIndex !== -1) {
+        const remainder = trimmed.slice(closeIndex + 8);
+        buffer = '';
+        mode = 'pending';
+        return push(remainder);
+      }
+      return '';
+    }
+    if ('<think>'.startsWith(lower) || 'reasoning_content:'.startsWith(lower)) return '';
+    if (lower.startsWith('reasoning_content:')) {
+      mode = 'reasoning';
+      return '';
+    }
+    const toolPrefixes = Array.from(SUPPORTED_TOOLS).map(tool => `<<${tool}:`);
+    if (toolPrefixes.some(prefix => prefix.startsWith(upper))) return '';
+    if (toolPrefixes.some(prefix => upper.startsWith(prefix))) {
+      mode = 'tool';
+      return '';
+    }
+    if (trimmed.startsWith('<<')) {
+      if (/^<<[A-Z_]+\s*:/.test(trimmed)) mode = 'tool';
+      return '';
+    }
+    if ('<<'.startsWith(trimmed)) return '';
+
+    mode = 'text';
+    const output = buffer;
+    buffer = '';
+    return output;
+  }
+
+  function finish() {
+    const trimmed = buffer.trimStart().toLowerCase();
+    if (mode === 'pending' && !trimmed.startsWith('<<') && !trimmed.startsWith('<think') && !trimmed.startsWith('reasoning_content:')) {
+      mode = 'text';
+      const output = buffer;
+      buffer = '';
+      return output;
+    }
+    return '';
+  }
+
+  return {
+    push,
+    finish,
+    isTool: () => mode === 'tool' || /^<<[A-Z_]+\s*:/.test(buffer.trimStart())
+  };
+}
+
+export function parseToolCall(reply = '') {
+  const text = String(reply).trim();
+  if (text.startsWith('<｜｜DSML｜｜tool_calls>')) {
+    const dsml = parseDSMLToolCall(text);
+    if (dsml) return dsml;
+  }
+
+  if (!text.startsWith('<<')) return null;
+  const match = text.match(/^<<([A-Z_]+):\s*([\s\S]*)>>$/);
+  if (!match) return { error: 'Tool parse error: legacy calls must occupy the complete message as <<TOOL_NAME: arguments>>.' };
+  if (/<<[A-Z_]+\s*:/.test(match[2])) {
+    return { error: 'Tool parse error: exactly one legacy tool call is allowed.' };
+  }
+
+  const toolName = match[1];
+  if (!SUPPORTED_TOOLS.has(toolName)) {
+    return {
+      error: `Tool parse error: unsupported tool "${toolName}". Supported tools: ${Array.from(SUPPORTED_TOOLS).join(', ')}.`
+    };
+  }
+
+  return {
+    toolName,
+    toolArg: match[2],
+    match,
+    recovered: false,
+    thoughtText: ''
+  };
+}
+
+export function isInsidePath(childPath, rootPath) {
+  const relative = path.relative(rootPath, childPath);
+  return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function canonicalExistingPath(targetPath) {
+  return fs.realpathSync.native(targetPath);
+}
+
+function canonicalRoot(workspaceRoot) {
+  const root = canonicalExistingPath(path.resolve(workspaceRoot));
+  return process.platform === 'win32' ? root.toLowerCase() : root;
+}
+
+function comparablePath(value) {
+  const normalized = path.resolve(value);
+  return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+
+function nearestExistingAncestor(targetPath) {
+  let current = path.resolve(targetPath);
+  while (!fs.existsSync(current)) {
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return current;
+}
+
+export function resolveWorkspacePath(rawPath, workspaceRoot) {
+  const trimmed = String(rawPath || '').trim();
+  if (!trimmed) {
+    throw new Error('Path is empty.');
+  }
+
+  const resolved = path.isAbsolute(trimmed)
+    ? path.resolve(trimmed)
+    : path.resolve(workspaceRoot, trimmed);
+  const root = path.resolve(workspaceRoot);
+
+  if (!isInsidePath(resolved, root)) {
+    throw new Error(`Access outside workspace is blocked: ${trimmed}`);
+  }
+
+  const realRoot = canonicalRoot(workspaceRoot);
+  const ancestor = nearestExistingAncestor(resolved);
+  const realAncestor = comparablePath(canonicalExistingPath(ancestor));
+  if (!isInsidePath(realAncestor, realRoot)) {
+    throw new Error(`Workspace path resolves through a link outside the workspace: ${trimmed}`);
+  }
+  if (fs.existsSync(resolved)) {
+    const realTarget = comparablePath(canonicalExistingPath(resolved));
+    if (!isInsidePath(realTarget, realRoot)) {
+      throw new Error(`Workspace path resolves outside the workspace: ${trimmed}`);
+    }
+    return resolved;
+  }
+  return resolved;
+}
+
+export function resolveExistingWorkspacePath(rawPath, workspaceRoot) {
+  const value = String(rawPath || '').trim();
+  let resolved;
+  let originalError;
+  try {
+    resolved = resolveWorkspacePath(value, workspaceRoot);
+    if (fs.existsSync(resolved)) return resolved;
+  } catch (error) {
+    originalError = error;
+  }
+  const fileName = value.replace(/\\/g, '/').split('/').filter(Boolean).at(-1);
+  const suggestions = [];
+  if (fileName && !['.', '..'].includes(fileName)) {
+    const visit = (directory, depth) => {
+      if (depth > 6 || suggestions.length >= 5) return;
+      let entries = [];
+      try {
+        entries = fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (suggestions.length >= 5) break;
+        if (['node_modules', '.git', '.gemini'].includes(entry.name)) continue;
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) visit(fullPath, depth + 1);
+        else if (entry.isFile() && entry.name === fileName) suggestions.push(path.relative(workspaceRoot, fullPath));
+      }
+    };
+    visit(workspaceRoot, 0);
+  }
+  const hint = suggestions.length
+    ? ` Candidate path${suggestions.length === 1 ? '' : 's'}: ${suggestions.join(', ')}. Retry with one exact workspace-relative path.`
+    : '';
+  if (originalError) throw new Error(`${originalError.message}${hint}`);
+  throw new Error(`Path does not exist inside workspace: ${value}.${hint}`);
+}
+
+export function isSensitivePath(filePath) {
+  const normalized = String(filePath || '').replace(/\\/g, '/').toLowerCase();
+  const base = path.posix.basename(normalized);
+  return base === '.env' || base.startsWith('.env.') ||
+    ['.npmrc', '.netrc'].includes(base) || base.startsWith('credentials') || base.startsWith('secrets') ||
+    /^(id_rsa|id_ed25519)(\.|$)/.test(base) ||
+    /\.(pem|key|p12|pfx|jks|keystore|crt|cer)$/.test(base) ||
+    normalized.split('/').includes('.git');
+}
+
+function contentHash(content) {
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+async function looksBinary(filePath) {
+  const handle = await fs.promises.open(filePath, 'r');
+  try {
+    const buffer = Buffer.alloc(8192);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, bytesRead).includes(0);
+  } finally {
+    await handle.close();
+  }
+}
+
+async function readLineRange(filePath, startLine, endLine) {
+  const input = fs.createReadStream(filePath, { encoding: 'utf8' });
+  const reader = readline.createInterface({ input, crlfDelay: Infinity });
+  const lines = [];
+  let current = 0;
+  try {
+    for await (const line of reader) {
+      current++;
+      if (current >= startLine && current <= endLine) lines.push(line);
+      if (current >= endLine) break;
+    }
+  } finally {
+    reader.close();
+    input.destroy();
+  }
+  return { content: lines.join('\n'), lineCount: lines.length };
+}
+
+export function truncateToolResult(text, maxChars = 12000) {
+  const clean = String(text || '');
+  if (clean.length <= maxChars) return clean;
+  return `${clean.slice(0, maxChars)}\n\n[Tool result truncated: ${clean.length - maxChars} characters omitted. Use narrower search terms or READ_FILE line ranges.]`;
+}
+
+function parseReadArgument(toolArg) {
+  if (toolArg && typeof toolArg === 'object') {
+    const startLine = Math.max(1, Number.parseInt(toolArg.startLine ?? toolArg.start_line ?? '1', 10) || 1);
+    const rawEnd = toolArg.endLine ?? toolArg.end_line;
+    const endLine = rawEnd === undefined || rawEnd === null ? null : Math.max(1, Number.parseInt(rawEnd, 10) || 1);
+    if (endLine !== null && endLine < startLine) {
+      throw new Error('Invalid line range: end line must be greater than or equal to start line.');
+    }
+    return {
+      filePath: String(toolArg.path ?? toolArg.filePath ?? ''),
+      startLine,
+      endLine,
+      hasRange: endLine !== null
+    };
+  }
+  let filePath = String(toolArg || '').trim();
+  let startLine = 1;
+  let endLine = null;
+  const rangeMatch = filePath.match(/:(\d+)-(\d+)$/);
+  if (rangeMatch) {
+    filePath = filePath.slice(0, -rangeMatch[0].length);
+    startLine = parseInt(rangeMatch[1], 10);
+    endLine = parseInt(rangeMatch[2], 10);
+  }
+  if (endLine !== null && endLine < startLine) {
+    throw new Error('Invalid line range: end line must be greater than or equal to start line.');
+  }
+  return { filePath, startLine, endLine, hasRange: !!rangeMatch };
+}
+
+function buildWritePreview(filePath, oldContent, newContent, existed) {
+  const relName = path.basename(filePath);
+  if (!existed) {
+    return [
+      `Create ${relName}`,
+      previewLines(newContent, '+')
+    ].join('\n');
+  }
+
+  if (oldContent === newContent) {
+    return `${relName}: no content changes.`;
+  }
+
+  const oldLines = oldContent.split('\n');
+  const newLines = newContent.split('\n');
+  let prefix = 0;
+  while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) {
+    prefix++;
+  }
+
+  let suffix = 0;
+  while (
+    suffix + prefix < oldLines.length &&
+    suffix + prefix < newLines.length &&
+    oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]
+  ) {
+    suffix++;
+  }
+
+  const oldChanged = oldLines.slice(prefix, oldLines.length - suffix);
+  const newChanged = newLines.slice(prefix, newLines.length - suffix);
+  const beforeLine = Math.max(1, prefix + 1);
+  const chunks = [
+    `Update ${relName}`,
+    `Changed around line ${beforeLine}:`
+  ];
+  chunks.push(previewLines(oldChanged.join('\n'), '-', 40));
+  chunks.push(previewLines(newChanged.join('\n'), '+', 40));
+  return chunks.filter(Boolean).join('\n');
+}
+
+function previewLines(text, marker, maxLines = 60) {
+  const lines = String(text || '').split('\n');
+  const shown = lines.slice(0, maxLines).map(line => `${marker} ${line}`).join('\n');
+  if (lines.length <= maxLines) return shown;
+  return `${shown}\n... ${lines.length - maxLines} more lines omitted`;
+}
+
+function parseEditArgument(toolArg) {
+  if (toolArg && typeof toolArg === 'object') {
+    return {
+      filePath: toolArg.path || toolArg.filePath || '',
+      oldText: toolArg.oldText ?? toolArg.oldString ?? '',
+      newText: toolArg.newText ?? toolArg.newString ?? '',
+      replaceAll: toolArg.replaceAll === true
+    };
+  }
+  const raw = String(toolArg || '');
+  if (raw.trimStart().startsWith('{')) {
+    const parsed = JSON.parse(raw);
+    return {
+      filePath: parsed.path || parsed.filePath || '',
+      oldText: parsed.oldText ?? parsed.oldString ?? '',
+      newText: parsed.newText ?? parsed.newString ?? '',
+      replaceAll: parsed.replaceAll === true
+    };
+  }
+
+  const normalized = raw.replace(/\r\n/g, '\n');
+  const firstNewline = normalized.indexOf('\n');
+  if (firstNewline === -1) throw new Error('EDIT_FILE requires a path and SEARCH/REPLACE blocks.');
+  const filePath = normalized.slice(0, firstNewline).trim();
+  const body = normalized.slice(firstNewline + 1);
+  const searchMarker = '<<<SEARCH\n';
+  const replaceMarker = '\n===REPLACE\n';
+  const endMarker = '\n>>>END';
+  if (!body.startsWith(searchMarker)) throw new Error('EDIT_FILE is missing <<<SEARCH.');
+  const replaceIndex = body.indexOf(replaceMarker, searchMarker.length);
+  const endIndex = body.lastIndexOf(endMarker);
+  if (replaceIndex === -1 || endIndex === -1 || endIndex < replaceIndex) {
+    throw new Error('EDIT_FILE requires ===REPLACE and >>>END markers.');
+  }
+  return {
+    filePath,
+    oldText: body.slice(searchMarker.length, replaceIndex),
+    newText: body.slice(replaceIndex + replaceMarker.length, endIndex),
+    replaceAll: /\nALL\s*$/.test(body.slice(endIndex + endMarker.length))
+  };
+}
+
+function countOccurrences(content, search) {
+  if (!search) return 0;
+  let count = 0;
+  let offset = 0;
+  while ((offset = content.indexOf(search, offset)) !== -1) {
+    count++;
+    offset += search.length;
+  }
+  return count;
+}
+
+function parseMoveArgument(toolArg) {
+  if (toolArg && typeof toolArg === 'object') {
+    return {
+      source: String(toolArg.source || toolArg.from || '').trim(),
+      destination: String(toolArg.destination || toolArg.to || '').trim()
+    };
+  }
+  const raw = String(toolArg || '').trim();
+  if (raw.startsWith('{')) {
+    const parsed = JSON.parse(raw);
+    return {
+      source: parsed.source || parsed.from || '',
+      destination: parsed.destination || parsed.to || ''
+    };
+  }
+  const [source = '', destination = ''] = raw.split(/\r?\n/, 2);
+  return { source: source.trim(), destination: destination.trim() };
+}
+
+function runWorkspaceCommand(command, cwd, signal) {
+  return new Promise(resolve => {
+    const child = execCommand(command, { cwd, timeout: 60000, maxBuffer: 1024 * 1024, windowsHide: true }, (error, stdout, stderr) => {
+      signal?.removeEventListener('abort', abort);
+      resolve({
+        exitCode: typeof error?.code === 'number' ? error.code : (error ? 1 : 0),
+        stdout: String(stdout || ''),
+        stderr: String(stderr || ''),
+        error
+      });
+    });
+    const abort = () => child.kill();
+    if (signal?.aborted) abort();
+    else signal?.addEventListener('abort', abort, { once: true });
+  });
+}
+
+export async function executeToolCall({
+  toolName,
+  toolArg,
+  workspaceRoot,
+  toolCallId = '',
+  emit = () => {},
+  requestPermission = async () => false,
+  lang = 'cn',
+  mode = 'chat',
+  signal,
+  getActiveEffort,
+  effortPresets,
+  runFileDigestionWorkflow
+}) {
+  const preset = effortPresets[getActiveEffort()] || effortPresets.high;
+  const maxToolChars = Math.max(8000, Math.min(30000, preset.maxReadLines * 35));
+  const cn = lang === 'cn';
+  const startedAt = Date.now();
+
+  function event(type, data = {}) {
+    emit(type, { tool: toolName, toolCallId, ...data });
+  }
+
+  function success(modelResult, displaySummary, data = {}) {
+    const durationMs = Date.now() - startedAt;
+    event('tool.completed', { displaySummary, durationMs, ...data });
+    return { ok: true, result: modelResult, modelResult, displaySummary, status: 'Done', data };
+  }
+
+  function failure(error) {
+    const modelResult = `Tool ${toolName} failed: ${error.message}`;
+    const displaySummary = cn ? `${toolName} 失败 · ${error.message}` : `${toolName} failed · ${error.message}`;
+    event('tool.failed', { displaySummary, error: error.message, durationMs: Date.now() - startedAt });
+    return { ok: false, result: modelResult, modelResult, displaySummary, status: 'Failed' };
+  }
+
+  try {
+    if (MUTATING_TOOLS.has(toolName) && mode !== 'code') {
+      throw new Error(`Workspace mutation is blocked in ${mode} mode. Use /code <request> to authorize one coding turn.`);
+    }
+
+    if (toolName === 'LIST_DIR') {
+      const rawPath = toolArg && typeof toolArg === 'object' ? toolArg.path : toolArg;
+      const resolvedPath = resolveExistingWorkspacePath(String(rawPath || '.').trim() || '.', workspaceRoot);
+      const relPath = path.relative(workspaceRoot, resolvedPath) || '.';
+      event('tool.started', { target: relPath, label: cn ? `正在查看 ${relPath}` : `Listing ${relPath}` });
+      const entries = await fs.promises.readdir(resolvedPath, { withFileTypes: true });
+      const rows = await Promise.all(entries.map(async entry => {
+        if (entry.isDirectory()) return `${entry.name} (Dir)`;
+        if (entry.isSymbolicLink()) return `${entry.name} (Symlink)`;
+        const stat = await fs.promises.stat(path.join(resolvedPath, entry.name));
+        return `${entry.name} (File, ${stat.size}B)`;
+      }));
+      const result = rows.join('\n') || '(Empty directory)';
+      return success(
+        truncateToolResult(result, maxToolChars),
+        cn ? `已查看 ${relPath} · ${entries.length} 项` : `Listed ${relPath} · ${entries.length} items`,
+        { target: relPath, itemCount: entries.length }
+      );
+    }
+
+    if (toolName === 'READ_FILE') {
+      const { filePath, startLine, endLine, hasRange } = parseReadArgument(toolArg);
+      const resolvedPath = resolveExistingWorkspacePath(filePath, workspaceRoot);
+      const relPath = path.relative(workspaceRoot, resolvedPath);
+      const rangeText = hasRange ? `:${startLine}-${endLine}` : '';
+      const target = `${relPath}${rangeText}`;
+      const realReadTarget = fs.realpathSync.native(resolvedPath);
+      if (isSensitivePath(relPath) || isSensitivePath(realReadTarget)) {
+        const displaySummary = cn ? `敏感文件读取确认 · ${relPath}` : `Sensitive file read · ${relPath}`;
+        event('permission.requested', { kind: 'sensitive-read', target: relPath, displaySummary });
+        const allowed = await requestPermission({
+          kind: 'sensitive-read',
+          prompt: cn
+            ? `读取 ${relPath} 会将内容发送给模型，是否允许？(y/n): `
+            : `Reading ${relPath} sends its content to the model. Allow? (y/n): `,
+          displaySummary
+        });
+        event('permission.resolved', { kind: 'sensitive-read', target: relPath, allowed, displaySummary });
+        if (!allowed) {
+          const modelResult = `Sensitive file read denied by user: ${relPath}`;
+          return { ok: true, cancelled: true, result: modelResult, modelResult, displaySummary, status: 'Cancelled' };
+        }
+      }
+      event('tool.started', { target, label: cn ? `正在读取 ${target}` : `Reading ${target}` });
+      const stat = await fs.promises.stat(resolvedPath);
+      if (!stat.isFile()) throw new Error(`READ_FILE target is not a file: ${relPath}`);
+      if (await looksBinary(resolvedPath)) throw new Error(`READ_FILE refuses binary content: ${relPath}`);
+
+      if (hasRange) {
+        if (endLine - startLine + 1 > preset.maxReadLines) {
+          throw new Error(`Requested range exceeds the ${preset.maxReadLines}-line limit.`);
+        }
+        const ranged = await readLineRange(resolvedPath, startLine, endLine);
+        return success(
+          truncateToolResult(ranged.content, maxToolChars),
+          cn ? `已读取 ${target} · ${ranged.lineCount} 行` : `Read ${target} · ${ranged.lineCount} lines`,
+          { target, lineCount: ranged.lineCount, totalLines: null }
+        );
+      }
+
+      if (stat.size > 2 * 1024 * 1024) {
+        throw new Error(`File is too large for a full read (${stat.size} bytes). Use READ_FILE with a targeted line range.`);
+      }
+      const content = await fs.promises.readFile(resolvedPath, 'utf8');
+      const lines = content.split('\n');
+
+      if (getActiveEffort() === 'ultracode' && lines.length > 1000) {
+        const totalChunks = Math.ceil(lines.length / 2000);
+        const displaySummary = cn
+          ? `消化 ${path.basename(resolvedPath)} · ${lines.length} 行 · ${totalChunks} 个分片`
+          : `Digest ${path.basename(resolvedPath)} · ${lines.length} lines · ${totalChunks} chunks`;
+        event('permission.requested', { kind: 'digest', target: relPath, displaySummary });
+        const proceed = await requestPermission({
+          kind: 'digest',
+          prompt: cn
+            ? `消化 "${path.basename(resolvedPath)}"（${lines.length} 行，约 ${totalChunks} 次 API 调用）？(y/n): `
+            : `Digest "${path.basename(resolvedPath)}" (${lines.length} lines, about ${totalChunks} API calls)? (y/n): `,
+          displaySummary
+        });
+        event('permission.resolved', {
+          kind: 'digest',
+          target: relPath,
+          allowed: proceed,
+          displaySummary: proceed
+            ? (cn ? '已允许大文件消化' : 'Large-file digestion allowed')
+            : (cn ? '已取消大文件消化' : 'Large-file digestion cancelled')
+        });
+        if (proceed) {
+          const report = await runFileDigestionWorkflow(resolvedPath, {
+            emit,
+            toolCallId,
+            toolName,
+            lang
+          });
+          return success(
+            truncateToolResult(report, maxToolChars),
+            cn ? `已消化 ${relPath} · ${totalChunks} 个分片` : `Digested ${relPath} · ${totalChunks} chunks`,
+            { target: relPath, lineCount: lines.length, chunks: totalChunks }
+          );
+        }
+        const modelResult = `[Read skipped by user. Use <<READ_FILE: ${relPath}:start-end>> for targeted ranges.]`;
+        return {
+          ok: true,
+          cancelled: true,
+          result: modelResult,
+          modelResult,
+          displaySummary: cn ? `已取消读取 ${relPath}` : `Cancelled reading ${relPath}`,
+          status: 'Cancelled'
+        };
+      }
+
+      if (lines.length > preset.maxReadLines) {
+        const truncated = lines.slice(0, preset.maxReadLines).join('\n');
+        const modelResult = truncateToolResult(`[File has ${lines.length} lines. Showing first ${preset.maxReadLines}. Use <<READ_FILE: ${relPath}:start-end>> for exact ranges.]\n\n${truncated}`, maxToolChars);
+        return success(
+          modelResult,
+          cn ? `已读取 ${relPath} · 前 ${preset.maxReadLines}/${lines.length} 行` : `Read ${relPath} · first ${preset.maxReadLines}/${lines.length} lines`,
+          { target: relPath, lineCount: preset.maxReadLines, totalLines: lines.length, truncated: true }
+        );
+      }
+
+      return success(
+        truncateToolResult(content, maxToolChars),
+        cn ? `已读取 ${relPath} · ${lines.length} 行` : `Read ${relPath} · ${lines.length} lines`,
+        { target: relPath, lineCount: lines.length, totalLines: lines.length }
+      );
+    }
+
+    if (toolName === 'EDIT_FILE') {
+      const { filePath, oldText, newText, replaceAll } = parseEditArgument(toolArg);
+      if (!filePath) throw new Error('EDIT_FILE path is empty.');
+      if (!oldText) throw new Error('EDIT_FILE search text is empty.');
+      const resolvedPath = resolveExistingWorkspacePath(filePath, workspaceRoot);
+      const relPath = path.relative(workspaceRoot, resolvedPath);
+      const oldContent = await fs.promises.readFile(resolvedPath, 'utf8');
+      const expectedHash = contentHash(oldContent);
+      const eol = oldContent.includes('\r\n') ? '\r\n' : '\n';
+      const normalizedContent = oldContent.replace(/\r\n/g, '\n');
+      const normalizedOld = String(oldText).replace(/\r\n/g, '\n');
+      const normalizedNew = String(newText).replace(/\r\n/g, '\n');
+      const matches = countOccurrences(normalizedContent, normalizedOld);
+      if (matches === 0) {
+        throw new Error(`EDIT_FILE search text was not found in ${relPath}. Read the exact current lines and retry.`);
+      }
+      if (matches > 1 && !replaceAll) {
+        throw new Error(`EDIT_FILE search text matched ${matches} locations in ${relPath}. Include more surrounding context or set replaceAll.`);
+      }
+
+      const updatedNormalized = replaceAll
+        ? normalizedContent.split(normalizedOld).join(normalizedNew)
+        : normalizedContent.replace(normalizedOld, normalizedNew);
+      const updatedContent = eol === '\r\n' ? updatedNormalized.replace(/\n/g, '\r\n') : updatedNormalized;
+      const preview = buildWritePreview(resolvedPath, oldContent, updatedContent, true);
+      const displaySummary = cn
+        ? `修改 ${relPath} · ${replaceAll ? matches : 1} 处`
+        : `Edit ${relPath} · ${replaceAll ? matches : 1} replacement${matches === 1 ? '' : 's'}`;
+      event('permission.requested', { kind: 'edit', target: relPath, displaySummary, preview });
+      const proceed = await requestPermission({
+        kind: 'edit',
+        prompt: cn ? '应用此局部修改？(y/n): ' : 'Apply this focused edit? (y/n): ',
+        displaySummary,
+        preview
+      });
+      event('permission.resolved', {
+        kind: 'edit',
+        target: relPath,
+        allowed: proceed,
+        displaySummary: proceed
+          ? (cn ? '已确认局部修改' : 'Focused edit approved')
+          : (cn ? `已取消修改 ${relPath}` : `Cancelled edit to ${relPath}`)
+      });
+      if (!proceed) {
+        const modelResult = `Edit cancelled by user: ${relPath}`;
+        return { ok: true, cancelled: true, result: modelResult, modelResult, displaySummary, status: 'Cancelled' };
+      }
+
+      event('tool.started', { target: relPath, label: cn ? `正在修改 ${relPath}` : `Editing ${relPath}` });
+      resolveExistingWorkspacePath(filePath, workspaceRoot);
+      const currentContent = await fs.promises.readFile(resolvedPath, 'utf8');
+      if (contentHash(currentContent) !== expectedHash) {
+        throw new Error(`${relPath} changed while awaiting confirmation. Read the file again before editing.`);
+      }
+      await fs.promises.writeFile(resolvedPath, updatedContent, 'utf8');
+      const modelResult = `Successfully edited ${relPath}: ${replaceAll ? matches : 1} replacement(s).`;
+      return success(modelResult, cn ? `已修改 ${relPath} · ${replaceAll ? matches : 1} 处` : `Edited ${relPath} · ${replaceAll ? matches : 1} replacement(s)`, {
+        target: relPath,
+        replacements: replaceAll ? matches : 1
+      });
+    }
+
+    if (toolName === 'WRITE_FILE') {
+      let filePathPart;
+      let fileContentPart;
+      if (toolArg && typeof toolArg === 'object') {
+        filePathPart = String(toolArg.path || toolArg.filePath || '');
+        fileContentPart = String(toolArg.content ?? '');
+      } else {
+        const rawArg = String(toolArg || '');
+        const firstNewline = rawArg.indexOf('\n');
+        filePathPart = firstNewline === -1 ? rawArg : rawArg.slice(0, firstNewline);
+        fileContentPart = firstNewline === -1 ? '' : rawArg.slice(firstNewline + 1);
+      }
+      const resolvedPath = resolveWorkspacePath(filePathPart.trim(), workspaceRoot);
+      const existed = fs.existsSync(resolvedPath);
+      const oldContent = existed ? await fs.promises.readFile(resolvedPath, 'utf8') : '';
+      const expectedHash = existed ? contentHash(oldContent) : null;
+      const relPath = path.relative(workspaceRoot, resolvedPath);
+      const preview = buildWritePreview(resolvedPath, oldContent, fileContentPart, existed);
+      const displaySummary = cn
+        ? `${existed ? '修改' : '创建'} ${relPath}`
+        : `${existed ? 'Update' : 'Create'} ${relPath}`;
+      event('permission.requested', { kind: 'write', target: relPath, displaySummary, preview });
+      const proceed = await requestPermission({
+        kind: 'write',
+        prompt: cn ? '应用此文件更改？(y/n): ' : 'Apply this file change? (y/n): ',
+        displaySummary,
+        preview
+      });
+      event('permission.resolved', {
+        kind: 'write',
+        target: relPath,
+        allowed: proceed,
+        displaySummary: proceed
+          ? (cn ? '已确认文件更改' : 'File change approved')
+          : (cn ? `已取消修改 ${relPath}` : `Cancelled change to ${relPath}`)
+      });
+      if (!proceed) {
+        const modelResult = `Write cancelled by user: ${relPath}`;
+        return { ok: true, cancelled: true, result: modelResult, modelResult, displaySummary, status: 'Cancelled' };
+      }
+
+      event('tool.started', { target: relPath, label: cn ? `正在写入 ${relPath}` : `Writing ${relPath}` });
+      resolveWorkspacePath(filePathPart.trim(), workspaceRoot);
+      if (existed) {
+        const currentContent = await fs.promises.readFile(resolvedPath, 'utf8');
+        if (contentHash(currentContent) !== expectedHash) {
+          throw new Error(`${relPath} changed while awaiting confirmation. Read the file again before writing.`);
+        }
+      } else if (fs.existsSync(resolvedPath)) {
+        throw new Error(`${relPath} was created while awaiting confirmation. Read it before writing.`);
+      }
+      await fs.promises.mkdir(path.dirname(resolvedPath), { recursive: true });
+      await fs.promises.writeFile(resolvedPath, fileContentPart, 'utf8');
+      const modelResult = `Successfully wrote file: ${relPath}`;
+      return success(
+        modelResult,
+        cn ? `已${existed ? '修改' : '创建'} ${relPath}` : `${existed ? 'Updated' : 'Created'} ${relPath}`,
+        { target: relPath, created: !existed, bytes: Buffer.byteLength(fileContentPart, 'utf8') }
+      );
+    }
+
+    if (toolName === 'MAKE_DIR') {
+      const rawPath = toolArg && typeof toolArg === 'object' ? toolArg.path : toolArg;
+      const resolvedPath = resolveWorkspacePath(String(rawPath || '').trim(), workspaceRoot);
+      const directoryExisted = fs.existsSync(resolvedPath);
+      const relPath = path.relative(workspaceRoot, resolvedPath);
+      const displaySummary = cn ? `创建目录 ${relPath}` : `Create directory ${relPath}`;
+      event('permission.requested', { kind: 'mkdir', target: relPath, displaySummary });
+      const proceed = await requestPermission({
+        kind: 'mkdir',
+        prompt: cn ? `创建目录 ${relPath}？(y/n): ` : `Create directory ${relPath}? (y/n): `,
+        displaySummary
+      });
+      event('permission.resolved', { kind: 'mkdir', target: relPath, allowed: proceed, displaySummary });
+      if (!proceed) {
+        const modelResult = `Directory creation cancelled by user: ${relPath}`;
+        return { ok: true, cancelled: true, result: modelResult, modelResult, displaySummary, status: 'Cancelled' };
+      }
+      event('tool.started', { target: relPath, label: cn ? `正在创建目录 ${relPath}` : `Creating directory ${relPath}` });
+      resolveWorkspacePath(String(rawPath || '').trim(), workspaceRoot);
+      if (!directoryExisted && fs.existsSync(resolvedPath)) {
+        throw new Error(`${relPath} appeared while awaiting confirmation. Inspect it before continuing.`);
+      }
+      await fs.promises.mkdir(resolvedPath, { recursive: true });
+      return success(
+        `Successfully created directory: ${relPath}`,
+        cn ? `已创建目录 ${relPath}` : `Created directory ${relPath}`,
+        { target: relPath }
+      );
+    }
+
+    if (toolName === 'MOVE_PATH') {
+      const { source, destination } = parseMoveArgument(toolArg);
+      if (!source || !destination) throw new Error('MOVE_PATH requires source and destination paths.');
+      const sourcePath = resolveExistingWorkspacePath(source, workspaceRoot);
+      const destinationPath = resolveWorkspacePath(destination, workspaceRoot);
+      const sourceIdentity = await fs.promises.lstat(sourcePath);
+      const sourceRel = path.relative(workspaceRoot, sourcePath);
+      const destinationRel = path.relative(workspaceRoot, destinationPath);
+      if (fs.existsSync(destinationPath)) throw new Error(`MOVE_PATH destination already exists: ${destinationRel}`);
+      const displaySummary = cn ? `移动 ${sourceRel} → ${destinationRel}` : `Move ${sourceRel} -> ${destinationRel}`;
+      event('permission.requested', { kind: 'move', target: sourceRel, displaySummary });
+      const proceed = await requestPermission({
+        kind: 'move',
+        prompt: cn ? `移动到 ${destinationRel}？(y/n): ` : `Move to ${destinationRel}? (y/n): `,
+        displaySummary
+      });
+      event('permission.resolved', { kind: 'move', target: sourceRel, allowed: proceed, displaySummary: proceed ? displaySummary : (cn ? '已取消移动' : 'Move cancelled') });
+      if (!proceed) {
+        const modelResult = `Move cancelled by user: ${sourceRel}`;
+        return { ok: true, cancelled: true, result: modelResult, modelResult, displaySummary, status: 'Cancelled' };
+      }
+      event('tool.started', { target: sourceRel, label: cn ? `正在移动 ${sourceRel}` : `Moving ${sourceRel}` });
+      resolveExistingWorkspacePath(source, workspaceRoot);
+      resolveWorkspacePath(destination, workspaceRoot);
+      if (fs.existsSync(destinationPath)) throw new Error(`${destinationRel} appeared while awaiting confirmation.`);
+      const currentSourceIdentity = await fs.promises.lstat(sourcePath);
+      if (currentSourceIdentity.dev !== sourceIdentity.dev || currentSourceIdentity.ino !== sourceIdentity.ino || currentSourceIdentity.mtimeMs !== sourceIdentity.mtimeMs || currentSourceIdentity.size !== sourceIdentity.size) {
+        throw new Error(`${sourceRel} changed while awaiting confirmation. Inspect it again before moving.`);
+      }
+      await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
+      await fs.promises.rename(sourcePath, destinationPath);
+      return success(`Successfully moved ${sourceRel} to ${destinationRel}`, displaySummary, { source: sourceRel, destination: destinationRel });
+    }
+
+    if (toolName === 'DELETE_PATH') {
+      const rawPath = toolArg && typeof toolArg === 'object' ? toolArg.path : toolArg;
+      const resolvedPath = resolveExistingWorkspacePath(String(rawPath || '').trim(), workspaceRoot);
+      const relPath = path.relative(workspaceRoot, resolvedPath);
+      if (!relPath) throw new Error('Deleting the workspace root is not allowed.');
+      const stat = await fs.promises.lstat(resolvedPath);
+      const deleteIdentity = { dev: stat.dev, ino: stat.ino, mtimeMs: stat.mtimeMs, size: stat.size };
+      if (stat.isDirectory()) {
+        const entries = await fs.promises.readdir(resolvedPath);
+        if (entries.length > 0) throw new Error('DELETE_PATH only removes files or empty directories.');
+      }
+      const displaySummary = cn ? `删除 ${relPath}` : `Delete ${relPath}`;
+      event('permission.requested', { kind: 'delete', target: relPath, displaySummary });
+      const proceed = await requestPermission({
+        kind: 'delete',
+        prompt: cn ? `确认删除 ${relPath}？(y/n): ` : `Delete ${relPath}? (y/n): `,
+        displaySummary
+      });
+      event('permission.resolved', { kind: 'delete', target: relPath, allowed: proceed, displaySummary: proceed ? displaySummary : (cn ? '已取消删除' : 'Delete cancelled') });
+      if (!proceed) {
+        const modelResult = `Delete cancelled by user: ${relPath}`;
+        return { ok: true, cancelled: true, result: modelResult, modelResult, displaySummary, status: 'Cancelled' };
+      }
+      event('tool.started', { target: relPath, label: cn ? `正在删除 ${relPath}` : `Deleting ${relPath}` });
+      resolveExistingWorkspacePath(String(rawPath || '').trim(), workspaceRoot);
+      const currentDeleteIdentity = await fs.promises.lstat(resolvedPath);
+      if (currentDeleteIdentity.dev !== deleteIdentity.dev || currentDeleteIdentity.ino !== deleteIdentity.ino || currentDeleteIdentity.mtimeMs !== deleteIdentity.mtimeMs || currentDeleteIdentity.size !== deleteIdentity.size) {
+        throw new Error(`${relPath} changed while awaiting confirmation. Inspect it again before deleting.`);
+      }
+      if (stat.isDirectory()) await fs.promises.rmdir(resolvedPath);
+      else await fs.promises.unlink(resolvedPath);
+      return success(`Successfully deleted: ${relPath}`, cn ? `已删除 ${relPath}` : `Deleted ${relPath}`, { target: relPath });
+    }
+
+    if (toolName === 'RUN_COMMAND') {
+      const rawCommand = toolArg && typeof toolArg === 'object' ? toolArg.command : toolArg;
+      const command = String(rawCommand || '').trim();
+      if (!command) throw new Error('RUN_COMMAND command is empty.');
+      const displaySummary = cn ? `运行命令: ${command}` : `Run command: ${command}`;
+      event('permission.requested', { kind: 'command', displaySummary, preview: `$ ${command}` });
+      const proceed = await requestPermission({
+        kind: 'command',
+        prompt: cn
+          ? '此命令不受沙箱限制，可能影响工作区外部。仍要运行？(y/n): '
+          : 'This command is not sandboxed and may affect paths outside the workspace. Run it? (y/n): ',
+        displaySummary,
+        preview: `$ ${command}`
+      });
+      event('permission.resolved', { kind: 'command', allowed: proceed, displaySummary: proceed ? (cn ? '已允许命令执行' : 'Command approved') : (cn ? '已取消命令' : 'Command cancelled') });
+      if (!proceed) {
+        const modelResult = `Command cancelled by user: ${command}`;
+        return { ok: true, cancelled: true, result: modelResult, modelResult, displaySummary, status: 'Cancelled' };
+      }
+      event('tool.started', { label: cn ? `正在运行 ${command}` : `Running ${command}` });
+      const commandResult = await runWorkspaceCommand(command, workspaceRoot, signal);
+      const combined = [
+        `Command: ${command}`,
+        `Exit code: ${commandResult.exitCode}`,
+        commandResult.stdout ? `stdout:\n${commandResult.stdout}` : '',
+        commandResult.stderr ? `stderr:\n${commandResult.stderr}` : ''
+      ].filter(Boolean).join('\n');
+      const modelResult = truncateToolResult(combined, maxToolChars);
+      if (commandResult.exitCode !== 0) {
+        const failedSummary = cn ? `命令失败 · 退出码 ${commandResult.exitCode}` : `Command failed · exit ${commandResult.exitCode}`;
+        event('tool.failed', { displaySummary: failedSummary, error: commandResult.stderr || commandResult.error?.message || failedSummary, durationMs: Date.now() - startedAt });
+        return { ok: false, result: modelResult, modelResult, displaySummary: failedSummary, status: 'Failed', data: { exitCode: commandResult.exitCode } };
+      }
+      return success(modelResult, cn ? '命令执行完成' : 'Command completed', { exitCode: 0 });
+    }
+
+    if (toolName === 'SEARCH_GREP') {
+      const rawQuery = toolArg && typeof toolArg === 'object' ? toolArg.query : toolArg;
+      const query = String(rawQuery || '').trim();
+      if (!query) throw new Error('Search query is empty.');
+      event('tool.started', { query, label: cn ? `正在搜索 “${query}”` : `Searching "${query}"` });
+      const results = [];
+      let totalMatches = 0;
+      let searchWasPartial = false;
+      const maxTotalMatches = 50;
+
+      async function searchGrep(dir, depth = 0) {
+        if (depth > 6) {
+          searchWasPartial = true;
+          return;
+        }
+        if (totalMatches >= maxTotalMatches) return;
+        const entries = (await fs.promises.readdir(dir, { withFileTypes: true }))
+          .sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+          if (totalMatches >= maxTotalMatches) break;
+          const file = entry.name;
+          if (file === 'node_modules' || file === '.git' || file === '.gemini' || file === 'package-lock.json') continue;
+          const fullPath = path.join(dir, file);
+          if (isSensitivePath(path.relative(workspaceRoot, fullPath))) continue;
+          try {
+            if (entry.isDirectory()) {
+              await searchGrep(fullPath, depth + 1);
+            } else if (entry.isFile()) {
+              const stat = await fs.promises.stat(fullPath);
+              const ext = path.extname(file).toLowerCase();
+              if (!DEFAULT_TEXT_EXTS.has(ext) && stat.size >= 100000) continue;
+              const content = await fs.promises.readFile(fullPath, 'utf8');
+              if (!content.includes(query)) continue;
+              const lines = content.split('\n');
+              const fileMatches = [];
+              for (let i = 0; i < lines.length; i++) {
+                if (lines[i].includes(query)) {
+                  const text = lines[i].trim();
+                  fileMatches.push({ lineNum: i + 1, text: text.length > 140 ? `${text.slice(0, 137)}...` : text });
+                  totalMatches++;
+                  if (totalMatches >= maxTotalMatches) break;
+                }
+              }
+              if (fileMatches.length > 0) {
+                results.push({ file: path.relative(workspaceRoot, fullPath), matches: fileMatches });
+              }
+            }
+          } catch (e) {
+            searchWasPartial = true;
+          }
+        }
+      }
+
+      await searchGrep(workspaceRoot);
+      if (results.length === 0) {
+        const modelResult = `No matches found for "${query}"${searchWasPartial ? '\n[Search was partial because some paths were too deep or unreadable.]' : ''}`;
+        return success(modelResult, cn ? `搜索 “${query}” · 无结果` : `Searched "${query}" · no matches`, { query, matchCount: 0, partial: searchWasPartial });
+      }
+      let output = 'Found matches:\n';
+      for (const result of results) {
+        output += `- ${result.file}:\n`;
+        for (const match of result.matches) {
+          output += `    Line ${match.lineNum}: ${match.text}\n`;
+        }
+      }
+      if (totalMatches >= maxTotalMatches) {
+        output += `[Search truncated at ${maxTotalMatches} matches. Use a narrower query if needed.]\n`;
+      }
+      if (searchWasPartial) output += '[Search was partial because some paths were too deep or unreadable.]\n';
+      return success(
+        truncateToolResult(output, maxToolChars),
+        cn ? `搜索 “${query}” · ${totalMatches} 处` : `Searched "${query}" · ${totalMatches} matches`,
+        { query, matchCount: totalMatches, truncated: totalMatches >= maxTotalMatches, partial: searchWasPartial }
+      );
+    }
+
+    return failure(new Error(`Unknown tool: ${toolName}`));
+  } catch (error) {
+    return failure(error);
+  }
+}