@yeaft/webchat-agent 1.0.209 → 1.0.210

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.209"}
+{"version":"1.0.210"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.209",
+  "version": "1.0.210",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/engine.js

@@ -46,7 +46,7 @@ import { countTurns } from './turn-utils.js';
 import { attachRouterPlan, extractPriorPlan, stripMetaForWire } from './router/continuity.js';
 import { resolveThinking } from './router/thinking.js';
 import { approxTokens } from './memory/budget.js';
-import { COLLAB_TOOL_POLICY, normalizeToolOutput, truncateToolResultIfNeeded } from './tools/registry.js';
+import { COLLAB_TOOL_POLICY, isToolErrorOutput, normalizeToolOutput, truncateToolResultIfNeeded } from './tools/registry.js';
 import { extractDisplayImages, stripDisplayImageData } from './image-assets.js';
 import { acknowledgePendingNotifications, formatNotificationsForPrompt, peekPendingNotifications } from './sub-agent/notifications.js';
 import {
@@ -3344,6 +3344,7 @@ export class Engine {
         let output;
         let displayImages = [];
         let isError = false;
+        let toolErrorOutput = null;
         currentToolCallForAsyncTask = {
           id: tc.id,
           name: tc.name,
@@ -3363,9 +3364,11 @@ export class Engine {
           try {
             yield { type: 'tool_start', id: tc.id, name: tc.name, input: tc.input, threadId: this.currentThreadId };
             if (this.#toolRegistry) {
+              toolErrorOutput = this.#toolRegistry.get(tc.name)?.errorOutput || null;
               output = await this.#toolRegistry.execute(tc.name, tc.input, toolCtx);
             } else {
               const tool = this.#tools.get(tc.name);
+              toolErrorOutput = tool.errorOutput || null;
               // Pass the full toolCtx (cwd, workDir, signal, …) — not just
               // `{ signal }`. Legacy registerTool() callers historically got
               // a 1-field ctx, but that means tools like bash/file-read run
@@ -3380,7 +3383,8 @@ export class Engine {
             if (displayImages.length > 0) {
               output = stripDisplayImageData(output, displayImages);
             }
-            yield { type: 'tool_end', id: tc.id, name: tc.name, output, displayImages, isError: false, threadId: this.currentThreadId };
+            isError = toolErrorOutput === 'json-error-envelope' && isToolErrorOutput(output);
+            yield { type: 'tool_end', id: tc.id, name: tc.name, output, displayImages, isError, threadId: this.currentThreadId };
             if (displayImages.some(image => image.deliveryQueued === true)) hasDisplayImageAnchor = true;
           } catch (err) {
             output = `Error: ${err.message}`;

package/yeaft/tools/bash.js

@@ -210,6 +210,7 @@ Guidelines:
     },
     required: ['command'],
   },
+  errorOutput: null,
   isConcurrencySafe: () => false,
   isReadOnly: () => false,
   isDestructive: (input) => {
@@ -223,7 +224,7 @@ Guidelines:
   },
   async execute(input, ctx) {
     const { command, cwd: inputCwd, timeout_ms, background = false, taskTitle } = input;
-    if (!command) return JSON.stringify({ error: 'command is required' });
+    if (!command) throw new Error('command is required');
 
     // Resolve working directory
     const cwd = inputCwd
@@ -231,7 +232,7 @@ Guidelines:
       : (ctx?.cwd || process.cwd());
 
     if (!existsSync(cwd)) {
-      return JSON.stringify({ error: `Working directory does not exist: ${cwd}` });
+      throw new Error(`Working directory does not exist: ${cwd}`);
     }
 
     // Clamp timeout
@@ -240,7 +241,7 @@ Guidelines:
 
     if (background) {
       if (!ctx?.taskManager) {
-        return JSON.stringify({ error: 'background tasks are unavailable in this runtime' });
+        throw new Error('background tasks are unavailable in this runtime');
       }
       try {
         const task = ctx.taskManager.startShellTask({
@@ -263,7 +264,7 @@ Guidelines:
         try { ctx.registerAsyncTask?.(task.id, currentToolCall || {}); } catch { /* never block tool return on coord errors */ }
         return `Started background task ${task.id}.\nStatus: ${task.status}\nLog: ${task.log?.path || ''}\nUse ListTasks, ReadTaskLog, or CancelTask to inspect or control it.`;
       } catch (err) {
-        return JSON.stringify({ error: err?.message || String(err) });
+        throw new Error(err?.message || String(err));
       }
     }
 
@@ -287,7 +288,7 @@ Guidelines:
       }
       return output || '(no output)';
     } catch (err) {
-      return JSON.stringify({ error: err.message });
+      throw new Error(err.message);
     }
   },
 });

package/yeaft/tools/file-read.js

@@ -34,6 +34,50 @@ const MAX_FILE_SIZE = 10 * 1024 * 1024;
  *  round-trip this tool's prompt guidance promises to avoid). */
 const DEFAULT_LIMIT = 3000;
 
+/** Keep raw output close to the model-facing 32 KiB budget while leaving
+ * room for line metadata and the Registry's localized truncation marker. */
+const DEFAULT_OUTPUT_BYTES = 30 * 1024;
+
+function takeUtf8(text, maxBytes) {
+  const chars = [];
+  let bytes = 0;
+  for (const char of text) {
+    const size = Buffer.byteLength(char, 'utf8');
+    if (bytes + size > maxBytes) break;
+    chars.push(char);
+    bytes += size;
+  }
+  return { text: chars.join(''), charCount: chars.length, bytes };
+}
+
+function formatLinesWithinBudget(allLines, startLine, endLine, startColumn = 0, maxBytes = DEFAULT_OUTPUT_BYTES) {
+  const parts = [];
+  let usedBytes = 0;
+  let nextLine = startLine;
+  let nextColumn = startColumn;
+  for (let i = startLine; i < endLine; i += 1) {
+    const prefix = parts.length > 0 ? '\n' : '';
+    const lineChars = Array.from(allLines[i]);
+    const column = i === startLine ? Math.min(startColumn, lineChars.length) : 0;
+    const linePrefix = `${i + 1}\t${column > 0 ? `[column ${column}] ` : ''}`;
+    const formatted = linePrefix + lineChars.slice(column).join('');
+    const remaining = maxBytes - usedBytes - Buffer.byteLength(prefix, 'utf8');
+    if (remaining <= 0) break;
+    const bounded = takeUtf8(formatted, remaining);
+    if (!bounded.text) break;
+    parts.push(prefix + bounded.text);
+    usedBytes += Buffer.byteLength(prefix, 'utf8') + bounded.bytes;
+    if (bounded.text !== formatted) {
+      nextLine = i;
+      nextColumn = column + Math.max(0, bounded.charCount - Array.from(linePrefix).length);
+      break;
+    }
+    nextLine = i + 1;
+    nextColumn = 0;
+  }
+  return { text: parts.join(''), nextLine, nextColumn };
+}
+
 export default defineTool({
   name: 'FileRead',
   description: {
@@ -70,14 +114,21 @@ Guidelines:
         },
       },
       offset: {
-        type: 'number',
+        type: 'integer',
+        minimum: 0,
         description: {
           en: 'Line number to start reading from (0-based, default: 0)',
           zh: '起始行号（从 0 开始计数，默认 0）',
         },
       },
+      column_offset: {
+        type: 'integer',
+        minimum: 0,
+        description: { en: 'Unicode character offset within the first requested line (0-based, default: 0)', zh: '首个待读行内的 Unicode 字符偏移量（从 0 开始，默认 0）' },
+      },
       limit: {
-        type: 'number',
+        type: 'integer',
+        minimum: 1,
         description: {
           en: `Maximum number of lines to read (default: ${DEFAULT_LIMIT})`,
           zh: `最多读取行数（默认 ${DEFAULT_LIMIT} 行）`,
@@ -89,8 +140,17 @@ Guidelines:
   isConcurrencySafe: () => true,
   isReadOnly: () => true,
   async execute(input, ctx) {
-    const { file_path, offset = 0, limit = DEFAULT_LIMIT } = input;
+    const { file_path, offset = 0, column_offset = 0, limit = DEFAULT_LIMIT } = input;
     if (!file_path) return JSON.stringify({ error: 'file_path is required' });
+    if (!Number.isInteger(offset) || offset < 0) {
+      return JSON.stringify({ error: 'offset must be a non-negative integer' });
+    }
+    if (!Number.isInteger(column_offset) || column_offset < 0) {
+      return JSON.stringify({ error: 'column_offset must be a non-negative integer' });
+    }
+    if (!Number.isInteger(limit) || limit < 1) {
+      return JSON.stringify({ error: 'limit must be a positive integer' });
+    }
 
     const cwd = ctx?.cwd || process.cwd();
     const absPath = resolve(cwd, file_path);
@@ -126,20 +186,28 @@ Guidelines:
       const allLines = content.split('\n');
       const totalLines = allLines.length;
 
+      if (offset > totalLines) {
+        return JSON.stringify({ error: `offset ${offset} exceeds file length (${totalLines} lines)` });
+      }
+      if (offset === totalLines) {
+        return `[Offset ${offset} is at end of file (${totalLines} lines total).]`;
+      }
+
       // Apply offset and limit
-      const startLine = Math.max(0, Math.min(offset, totalLines));
+      const startLine = offset;
       const endLine = Math.min(startLine + limit, totalLines);
-      const lines = allLines.slice(startLine, endLine);
-
-      // Format with line numbers (1-based like cat -n)
-      const numbered = lines.map((line, i) => {
-        const lineNum = startLine + i + 1;
-        return `${lineNum}\t${line}`;
-      }).join('\n');
-
-      // Add metadata if partial
-      if (startLine > 0 || endLine < totalLines) {
-        return `${numbered}\n\n[Showing lines ${startLine + 1}-${endLine} of ${totalLines} total]`;
+      const startColumn = column_offset;
+      const { text: numbered, nextLine, nextColumn } = formatLinesWithinBudget(allLines, startLine, endLine, startColumn);
+
+      const hasMoreContent = nextColumn > 0 || nextLine < totalLines;
+      if (startLine > 0 || startColumn > 0 || hasMoreContent) {
+        const continuation = hasMoreContent
+          ? nextColumn > 0
+            ? ` Continue with offset=${nextLine}, column_offset=${nextColumn}.`
+            : ` Continue with offset=${nextLine}.`
+          : '';
+        const shownEnd = nextColumn > 0 ? nextLine + 1 : nextLine;
+        return `${numbered}\n\n[Showing lines ${startLine + 1}-${shownEnd} of ${totalLines} total.${continuation}]`;
       }
 
       return numbered;

package/yeaft/tools/glob.js

@@ -10,6 +10,13 @@ import { readdir, stat } from 'fs/promises';
 import { existsSync } from 'fs';
 import { resolve, join, relative } from 'path';
 
+const STAT_CONCURRENCY = 32;
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', '__pycache__', '.next', '.nuxt',
+  'dist', 'build', '.cache', '.venv', 'venv', '.tox',
+  'vendor', 'target', '.gradle', '.idea', '.vscode',
+]);
+
 /**
  * Simple glob pattern matcher (supports * and **).
  * @param {string} pattern
@@ -44,19 +51,13 @@ async function* walkDir(dir, baseDir, maxDepth = 10, depth = 0) {
     return;
   }
 
-  // Skip common large/irrelevant directories
-  const SKIP = new Set([
-    'node_modules', '.git', '__pycache__', '.next', '.nuxt',
-    'dist', 'build', '.cache', '.venv', 'venv', '.tox',
-    'vendor', 'target', '.gradle', '.idea', '.vscode',
-  ]);
-
   for (const entry of entries) {
     const fullPath = join(dir, entry.name);
     const relPath = relative(baseDir, fullPath);
 
     if (entry.isDirectory()) {
-      if (SKIP.has(entry.name)) continue;
+      const normalized = relPath.replace(/\\/g, '/');
+      if (SKIP_DIRS.has(entry.name) || normalized === '.yeaft/worktrees' || normalized.startsWith('.yeaft/worktrees/')) continue;
       yield { path: relPath, isDir: true };
       yield* walkDir(fullPath, baseDir, maxDepth, depth + 1);
     } else {
@@ -106,7 +107,8 @@ Guidelines:
         },
       },
       limit: {
-        type: 'number',
+        type: 'integer',
+        minimum: 1,
         description: {
           en: 'Maximum number of results (default: 500)',
           zh: '最多返回结果数（默认 500）',
@@ -120,6 +122,9 @@ Guidelines:
   async execute(input, ctx) {
     const { pattern, path: searchPath, limit = 500 } = input;
     if (!pattern) return JSON.stringify({ error: 'pattern is required' });
+    if (!Number.isInteger(limit) || limit < 1) {
+      return JSON.stringify({ error: 'limit must be a positive integer' });
+    }
 
     const cwd = ctx?.cwd || process.cwd();
     const baseDir = searchPath ? resolve(cwd, searchPath) : cwd;
@@ -129,29 +134,25 @@ Guidelines:
     }
 
     try {
-      const matches = [];
-
+      const paths = [];
       for await (const entry of walkDir(baseDir, baseDir)) {
-        if (matches.length >= limit * 2) break; // over-fetch for sorting
+        if (!entry.isDir && matchGlob(pattern, entry.path)) paths.push(entry.path);
+      }
 
-        if (!entry.isDir && matchGlob(pattern, entry.path)) {
-          // Get mtime for sorting
+      // Exact newest-first semantics require every matching mtime. Batch the
+      // metadata reads instead of serializing one syscall per path.
+      const matches = [];
+      for (let i = 0; i < paths.length; i += STAT_CONCURRENCY) {
+        matches.push(...await Promise.all(paths.slice(i, i + STAT_CONCURRENCY).map(async (path) => {
           try {
-            const fileStat = await stat(join(baseDir, entry.path));
-            matches.push({
-              path: entry.path,
-              mtime: fileStat.mtimeMs,
-            });
+            const fileStat = await stat(join(baseDir, path));
+            return { path, mtime: fileStat.mtimeMs };
           } catch {
-            matches.push({ path: entry.path, mtime: 0 });
+            return { path, mtime: 0 };
           }
-        }
+        })));
       }
-
-      // Sort by mtime (newest first)
       matches.sort((a, b) => b.mtime - a.mtime);
-
-      // Trim to limit
       const trimmed = matches.slice(0, limit);
 
       return trimmed.map(m => m.path).join('\n') || '(no matches)';

package/yeaft/tools/grep.js

@@ -17,11 +17,15 @@ const MAX_LINES = 250;
 
 /** Hard cap before Grep output reaches history, debug events, or WebSocket. */
 const MAX_OUTPUT_BYTES = 512 * 1024;
+const SEARCH_RESULT_BYTES = 32 * 1024;
 const OUTPUT_TRUNCATED_MARKER = '\n\n[Output truncated]';
 const MAX_CAPTURE_BYTES = MAX_OUTPUT_BYTES - Buffer.byteLength(OUTPUT_TRUNCATED_MARKER, 'utf8');
 
 /** Keep one pathological source line from consuming the whole output budget. */
 const MAX_LINE_BYTES = 16 * 1024;
+const FALLBACK_CONCURRENCY = 8;
+const SKIP_DIRS = new Set(['node_modules', '.git', '__pycache__', '.next', 'dist', 'build', '.cache']);
+let ripgrepAvailability;
 
 /** Binary extensions to skip. */
 const BINARY_EXTS = new Set([
@@ -108,12 +112,22 @@ function createOutputCollector(maxBytes = MAX_OUTPUT_BYTES) {
 /**
  * Check if ripgrep is available.
  */
+export function setRipgrepAvailabilityForTests(value) {
+  ripgrepAvailability = value;
+}
+
 function hasRipgrep() {
-  return new Promise((resolve) => {
+  if (typeof ripgrepAvailability === 'boolean') return Promise.resolve(ripgrepAvailability);
+  if (ripgrepAvailability) return ripgrepAvailability;
+  ripgrepAvailability = new Promise((resolve) => {
     const proc = spawn('rg', ['--version'], { stdio: 'pipe', windowsHide: true });
     proc.on('close', (code) => resolve(code === 0));
     proc.on('error', () => resolve(false));
+  }).then((available) => {
+    ripgrepAvailability = available;
+    return available;
   });
+  return ripgrepAvailability;
 }
 
 /**
@@ -121,15 +135,9 @@ function hasRipgrep() {
  */
 export function runRipgrep(pattern, searchPath, options, spawnProcess = spawn) {
   return new Promise((resolve, reject) => {
-    const args = [
-      pattern,
-      searchPath,
-      '--no-heading',
-      '--line-number',
-      '--color', 'never',
-    ];
-
+    const args = [pattern, searchPath, '--no-heading', '--line-number', '--color', 'never'];
     if (options.caseInsensitive) args.push('-i');
+    if (options.fixedStrings) args.push('-F');
     if (options.glob) args.push('--glob', options.glob);
     if (options.type) args.push('--type', options.type);
     if (options.filesOnly) args.push('-l');
@@ -138,52 +146,92 @@ export function runRipgrep(pattern, searchPath, options, spawnProcess = spawn) {
     if (options.before) args.push('-B', String(options.before));
     if (options.after) args.push('-A', String(options.after));
     if (options.multiline) args.push('-U', '--multiline-dotall');
-    args.push('--max-count', String(options.maxResults || 500));
 
     const proc = spawnProcess('rg', args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    const requestedBudget = Number(options.byteBudget);
+    const stdoutBudget = Number.isFinite(requestedBudget) && requestedBudget >= 0
+      ? Math.min(requestedBudget, MAX_OUTPUT_BYTES)
+      : MAX_OUTPUT_BYTES;
+    const stdoutMarker = truncateUtf8(OUTPUT_TRUNCATED_MARKER, stdoutBudget);
     const stdoutChunks = [];
     const stderrChunks = [];
-    let capturedBytes = 0;
-    let truncatedStream = null;
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    let stdoutLines = 0;
+    let stoppedForLimit = false;
+    let stopRequested = false;
     let settled = false;
 
-    function capture(streamName, chunk, chunks) {
-      if (truncatedStream) return;
+    function stop() {
+      if (stopRequested) return;
+      stopRequested = true;
+      try { proc.kill(); } catch {}
+    }
+
+    function captureStdout(chunk) {
+      if (stdoutTruncated || stoppedForLimit) return;
+      let buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      const maxResults = Math.max(1, options.maxResults || 500);
+      let cursor = 0;
+      while (stdoutLines < maxResults) {
+        const newline = buffer.indexOf(0x0a, cursor);
+        if (newline === -1) break;
+        stdoutLines += 1;
+        cursor = newline + 1;
+      }
+      if (stdoutLines >= maxResults) {
+        buffer = buffer.subarray(0, cursor);
+        stoppedForLimit = true;
+      }
+
+      const remaining = stdoutBudget - stdoutBytes;
+      if (buffer.length > remaining) {
+        if (remaining > 0) stdoutChunks.push(buffer.subarray(0, remaining));
+        stdoutBytes = stdoutBudget;
+        stdoutTruncated = true;
+      } else {
+        stdoutChunks.push(buffer);
+        stdoutBytes += buffer.length;
+      }
+      if (stdoutTruncated || stoppedForLimit) stop();
+    }
+
+    function captureStderr(chunk) {
+      if (stderrTruncated) return;
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      const remaining = MAX_CAPTURE_BYTES - capturedBytes;
+      const remaining = MAX_OUTPUT_BYTES - stderrBytes;
       if (buffer.length > remaining) {
-        if (remaining > 0) chunks.push(buffer.subarray(0, remaining));
-        capturedBytes = MAX_CAPTURE_BYTES;
-        truncatedStream = streamName;
-        try { proc.kill(); } catch {}
+        if (remaining > 0) stderrChunks.push(buffer.subarray(0, remaining));
+        stderrBytes = MAX_OUTPUT_BYTES;
+        stderrTruncated = true;
+        stop();
         return;
       }
-      chunks.push(buffer);
-      capturedBytes += buffer.length;
+      stderrChunks.push(buffer);
+      stderrBytes += buffer.length;
     }
 
-    function decodeCaptured(chunks, wasTruncated) {
-      // Buffer decoding normally expands each invalid byte to the three-byte
-      // U+FFFD replacement character. Use a one-byte replacement, then enforce
-      // the final encoded-byte boundary as a last line of defense.
-      const marker = wasTruncated ? OUTPUT_TRUNCATED_MARKER : '';
-      const maxTextBytes = MAX_OUTPUT_BYTES - Buffer.byteLength(marker, 'utf8');
+    function decodeCaptured(chunks, maxBytes, wasTruncated, marker = OUTPUT_TRUNCATED_MARKER) {
+      const boundedMarker = wasTruncated ? truncateUtf8(marker, maxBytes) : '';
+      const maxTextBytes = Math.max(0, maxBytes - Buffer.byteLength(boundedMarker, 'utf8'));
       const decoded = Buffer.concat(chunks).toString('utf8').replaceAll('\ufffd', '?').replace(/\r/g, '');
-      return truncateUtf8(decoded, maxTextBytes) + marker;
+      return truncateUtf8(decoded, maxTextBytes) + boundedMarker;
     }
 
-    proc.stdout.on('data', (chunk) => capture('stdout', chunk, stdoutChunks));
-    proc.stderr.on('data', (chunk) => capture('stderr', chunk, stderrChunks));
+    proc.stdout.on('data', captureStdout);
+    proc.stderr.on('data', captureStderr);
     proc.on('close', (code) => {
       if (settled) return;
       settled = true;
-      const stdout = decodeCaptured(stdoutChunks, truncatedStream === 'stdout');
-      const stderr = decodeCaptured(stderrChunks, truncatedStream === 'stderr');
-      if (code === 0 || code === 1 || truncatedStream === 'stdout') resolve(stdout);
+      const stdout = decodeCaptured(stdoutChunks, stdoutBudget, stdoutTruncated, stdoutMarker);
+      const stderr = decodeCaptured(stderrChunks, MAX_OUTPUT_BYTES, stderrTruncated);
+      if (code === 0 || code === 1 || stoppedForLimit || stdoutTruncated) resolve(stdout);
       else reject(new Error(stderr || `rg exited with code ${code}`));
     });
     proc.on('error', (err) => {
-      if (settled) return;
+      if (settled || stopRequested) return;
       settled = true;
       reject(err);
     });
@@ -194,67 +242,94 @@ export function runRipgrep(pattern, searchPath, options, spawnProcess = spawn) {
  * Fallback: Node.js grep implementation.
  */
 export async function nodeGrep(pattern, searchPath, options) {
-  const regex = new RegExp(pattern, options.caseInsensitive ? 'gi' : 'g');
-  const output = createOutputCollector();
+  const regexSource = options.fixedStrings
+    ? pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    : pattern;
+  const regex = new RegExp(regexSource, options.caseInsensitive ? 'gi' : 'g');
+  const output = createOutputCollector(options.byteBudget || SEARCH_RESULT_BYTES);
+  const maxResults = Math.max(1, options.maxResults || 500);
   let resultCount = 0;
-  const SKIP = new Set(['node_modules', '.git', '__pycache__', '.next', 'dist', 'build', '.cache']);
+  let stopped = false;
+
+  function compileGlob(glob) {
+    const escaped = glob.replace(/\\/g, '/')
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*\*/g, '\0').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]')
+      .replace(/\0/g, '.*');
+    return new RegExp(`^${escaped}$`);
+  }
+  const globMatcher = options.glob ? compileGlob(options.glob) : null;
+  const typeExtensions = {
+    js: ['.js', '.jsx', '.mjs', '.cjs'], ts: ['.ts', '.tsx', '.mts', '.cts'],
+    py: ['.py'], rust: ['.rs'], go: ['.go'], java: ['.java'],
+    json: ['.json'], yaml: ['.yaml', '.yml'], markdown: ['.md', '.markdown'],
+    html: ['.html', '.htm'], css: ['.css'], shell: ['.sh', '.bash', '.zsh'],
+  };
+
+  function matchesFilters(fullPath) {
+    const relPath = relative(searchPath, fullPath).replace(/\\/g, '/');
+    if (globMatcher && !globMatcher.test(relPath) && !globMatcher.test(relPath.split('/').pop())) return false;
+    if (!options.type) return true;
+    const extensions = typeExtensions[options.type];
+    return Boolean(extensions?.includes(extname(fullPath).toLowerCase()));
+  }
+
+  function addResult(value) {
+    resultCount += 1;
+    if (!output.add(value) || resultCount >= maxResults) stopped = true;
+  }
+
+  async function searchFile(fullPath) {
+    if (stopped || !matchesFilters(fullPath) || BINARY_EXTS.has(extname(fullPath).toLowerCase())) return;
+    try {
+      const fileStat = await stat(fullPath);
+      if (fileStat.size > 1024 * 1024 || stopped) return;
+      const content = decodeTextFile(await readFile(fullPath));
+      if (content == null) return;
+      const relPath = relative(searchPath, fullPath);
+      regex.lastIndex = 0;
+      if (options.filesOnly) {
+        if (regex.test(content)) addResult(relPath);
+      } else if (options.count) {
+        const matches = content.match(regex);
+        if (matches) addResult(`${relPath}:${matches.length}`);
+      } else {
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length && !stopped; i += 1) {
+          regex.lastIndex = 0;
+          if (regex.test(lines[i])) addResult(`${relPath}:${i + 1}:${lines[i]}`);
+        }
+      }
+    } catch {
+      // Skip unreadable files.
+    }
+  }
 
   async function searchDir(dir) {
-    if (resultCount >= (options.maxResults || 500)) return;
+    if (stopped) return;
     let entries;
     try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
-
+    const files = [];
+    const directories = [];
     for (const entry of entries) {
-      if (resultCount >= (options.maxResults || 500)) return;
       const fullPath = join(dir, entry.name);
-
       if (entry.isDirectory()) {
-        if (SKIP.has(entry.name)) continue;
-        await searchDir(fullPath);
-      } else {
-        const ext = extname(entry.name).toLowerCase();
-        if (BINARY_EXTS.has(ext)) continue;
-
-        try {
-          const fileStat = await stat(fullPath);
-          if (fileStat.size > 1024 * 1024) continue; // skip files > 1MB
-
-          const buffer = await readFile(fullPath);
-          const content = decodeTextFile(buffer);
-          if (content == null) continue;
-          const relPath = relative(searchPath, fullPath);
-
-          if (options.filesOnly) {
-            if (regex.test(content)) {
-              resultCount += 1;
-              if (!output.add(relPath)) return;
-            }
-            regex.lastIndex = 0;
-          } else if (options.count) {
-            const matches = content.match(regex);
-            if (matches) {
-              resultCount += 1;
-              if (!output.add(`${relPath}:${matches.length}`)) return;
-            }
-          } else {
-            const lines = content.split('\n');
-            for (let i = 0; i < lines.length; i++) {
-              if (regex.test(lines[i])) {
-                resultCount += 1;
-                if (!output.add(`${relPath}:${i + 1}:${lines[i]}`)) return;
-              }
-              regex.lastIndex = 0;
-              if (resultCount >= (options.maxResults || 500)) return;
-            }
-          }
-        } catch {
-          // Skip unreadable files
-        }
-      }
+        const relPath = relative(searchPath, fullPath).replace(/\\/g, '/');
+        if (!SKIP_DIRS.has(entry.name) && relPath !== '.yeaft/worktrees' && !relPath.startsWith('.yeaft/worktrees/')) directories.push(fullPath);
+      } else files.push(fullPath);
+    }
+    for (let i = 0; i < files.length && !stopped; i += FALLBACK_CONCURRENCY) {
+      await Promise.all(files.slice(i, i + FALLBACK_CONCURRENCY).map(searchFile));
+    }
+    for (const child of directories) {
+      if (stopped) break;
+      await searchDir(child);
     }
   }
 
-  await searchDir(searchPath);
+  const rootStat = await stat(searchPath);
+  if (rootStat.isDirectory()) await searchDir(searchPath);
+  else await searchFile(searchPath);
   return output.toString();
 }
 
@@ -336,6 +411,13 @@ Guidelines:
           zh: '不区分大小写搜索（默认 false）',
         },
       },
+      fixed_strings: {
+        type: 'boolean',
+        description: {
+          en: 'Treat the pattern as a literal string (default: false)',
+          zh: '将模式视为普通字符串而非正则表达式（默认 false）',
+        },
+      },
       context: {
         type: 'number',
         description: {
@@ -365,7 +447,8 @@ Guidelines:
         },
       },
       head_limit: {
-        type: 'number',
+        type: 'integer',
+        minimum: 1,
         description: {
           en: 'Limit output to first N results (default: 250)',
           zh: '限制输出前 N 条结果（默认 250）',
@@ -379,12 +462,16 @@ Guidelines:
   async execute(input, ctx) {
     const {
       pattern, path: searchPath, output_mode = 'files_with_matches',
-      glob: globFilter, type, case_insensitive = false,
+      glob: globFilter, type, case_insensitive = false, fixed_strings = false,
       context, before, after, multiline = false,
       head_limit = MAX_LINES,
     } = input;
 
     if (!pattern) return JSON.stringify({ error: 'pattern is required' });
+    if (!Number.isInteger(head_limit) || head_limit < 1) {
+      return JSON.stringify({ error: 'head_limit must be a positive integer' });
+    }
+    const headLimit = Math.min(head_limit, 10000);
 
     const cwd = ctx?.cwd || process.cwd();
     const absPath = searchPath ? resolve(cwd, searchPath) : cwd;
@@ -397,13 +484,15 @@ Guidelines:
       caseInsensitive: case_insensitive,
       glob: globFilter,
       type,
+      fixedStrings: fixed_strings,
       filesOnly: output_mode === 'files_with_matches',
       count: output_mode === 'count',
       context,
       before,
       after,
       multiline,
-      maxResults: head_limit * 2,
+      maxResults: headLimit,
+      byteBudget: SEARCH_RESULT_BYTES,
     };
 
     try {
@@ -423,9 +512,9 @@ Guidelines:
       // Limit output lines, then enforce the byte budget at the actual tool
       // boundary so prefixes, JSON escaping, and result markers are included.
       const lines = result.trim().split('\n');
-      if (lines.length > head_limit) {
+      if (lines.length > headLimit) {
         return boundToolOutput(
-          lines.slice(0, head_limit).join('\n') + `\n\n... (${lines.length - head_limit} more results)`,
+          lines.slice(0, headLimit).join('\n') + `\n\n... (${lines.length - headLimit} more results)`,
         );
       }
 

package/yeaft/tools/mcp-tools.js

@@ -111,6 +111,7 @@ export function buildMcpFlattenedTools(mcpManager) {
         t.description || `MCP tool ${fullName.split('__').slice(1).join('__')} from server ${t.server}`
       ),
       parameters: t.inputSchema || { type: 'object', properties: {} },
+      errorOutput: null,
       async execute(input = {}, _ctx) {
         // Look up the manager fresh on each call. We deliberately don't
         // close over a server reference — hot-reload may have replaced
@@ -125,7 +126,11 @@ export function buildMcpFlattenedTools(mcpManager) {
           throw new Error(`MCP manager not available for ${flattenedName}`);
         }
         const result = await mcpManager.callTool(fullName, input || {});
-        return formatMcpResult(result);
+        const output = formatMcpResult(result);
+        if (result && typeof result === 'object' && result.isError === true) {
+          throw new Error(output || `MCP tool ${fullName} failed`);
+        }
+        return output;
       },
     });
   });
@@ -262,7 +267,11 @@ Usage guidelines:
 
     try {
       const result = await mcpManager.callTool(tool_name, args, timeout_ms || 30000);
-      return formatMcpResult(result);
+      const output = formatMcpResult(result);
+      if (result && typeof result === 'object' && result.isError === true) {
+        throw new Error(output || `MCP tool ${tool_name} failed`);
+      }
+      return output;
     } catch (err) {
       return JSON.stringify({
         error: err.message,

package/yeaft/tools/read-task-log.js

@@ -7,8 +7,8 @@ import { defineTool } from './types.js';
 export default defineTool({
   name: 'ReadTaskLog',
   description: {
-    en: 'Read a background task log by taskId. Supports tail reads and byte offsets.',
-    zh: '按 taskId 读取后台任务日志。支持 tail 和字节 offset。',
+    en: 'Read a background task log by taskId. The first read defaults to the tail. For later reads, pass the previous nextOffset as offset to receive only new bytes; an explicit offset defaults tail to false.',
+    zh: '按 taskId 读取后台任务日志。首次读取默认返回末尾；后续把上次返回的 nextOffset 作为 offset 传入即可只读取新增字节，显式传 offset 时 tail 默认 false。',
   },
   parameters: {
     type: 'object',
@@ -28,10 +28,11 @@ export default defineTool({
     const taskId = input.taskId;
     if (!taskId) return JSON.stringify({ error: 'taskId is required' });
     const sessionId = input.sessionId || ctx.sessionId || 'default';
+    const hasOffset = Number.isFinite(input.offset);
     const result = ctx.taskManager.readTaskLog(sessionId, taskId, {
       offset: input.offset,
       maxBytes: input.maxBytes,
-      tail: input.tail !== false,
+      tail: typeof input.tail === 'boolean' ? input.tail : !hasOffset,
     });
     return JSON.stringify(result, null, 2);
   },

package/yeaft/tools/registry.js

@@ -37,7 +37,7 @@ export const FORWARD_TOOL_NAMES = Object.freeze(['RouteForward']);
  * persisted transcripts need the raw result. The engine/history replay path
  * applies this only when building messages for the model.
  */
-export const TOOL_RESULT_MAX_BYTES = 10 * 1024;
+export const TOOL_RESULT_MAX_BYTES = 32 * 1024;
 
 function normalizeLanguage(language) {
   return String(language || '').toLowerCase().startsWith('zh') ? 'zh' : 'en';
@@ -194,24 +194,49 @@ export function normalizeToolOutput(output) {
   return text;
 }
 
+export function isToolErrorOutput(output) {
+  const text = normalizeToolOutput(output).trim();
+  if (!text.startsWith('{')) return false;
+  try {
+    const parsed = JSON.parse(text);
+    return Boolean(
+      parsed
+      && typeof parsed === 'object'
+      && !Array.isArray(parsed)
+      && typeof parsed.error === 'string'
+      && parsed.error.trim(),
+    );
+  } catch {
+    return false;
+  }
+}
+
+function truncateUtf8(text, maxBytes) {
+  if (maxBytes <= 0) return '';
+  const buffer = Buffer.from(String(text), 'utf8');
+  if (buffer.length <= maxBytes) return String(text);
+  let end = maxBytes;
+  while (end > 0 && (buffer[end] & 0xc0) === 0x80) end -= 1;
+  return buffer.subarray(0, end).toString('utf8');
+}
+
 export function truncateToolResultIfNeeded(output, { toolName, language } = {}) {
   const text = normalizeToolOutput(output);
   const originalBytes = Buffer.byteLength(text, 'utf8');
   if (originalBytes <= TOOL_RESULT_MAX_BYTES) return text;
 
-  const chunks = [];
-  let used = 0;
-  for (const ch of text) {
-    const n = Buffer.byteLength(ch, 'utf8');
-    if (used + n > TOOL_RESULT_MAX_BYTES) break;
-    chunks.push(ch);
-    used += n;
+  const markerFor = name => normalizeLanguage(language) === 'zh'
+    ? `\n\n[已截断：${name} 返回 ${formatSize(originalBytes)}，上限为 ${formatSize(TOOL_RESULT_MAX_BYTES)}；原因：单个 tool result 超过 ${formatSize(TOOL_RESULT_MAX_BYTES)}，模型消息历史不会看到剩余内容]`
+    : `\n\n[truncated: ${name} returned ${formatSize(originalBytes)}, capped at ${formatSize(TOOL_RESULT_MAX_BYTES)}; reason: single tool result exceeded ${formatSize(TOOL_RESULT_MAX_BYTES)}, the model message history will not see the rest]`;
+  let marker = markerFor(String(toolName || 'tool'));
+  if (Buffer.byteLength(marker, 'utf8') > TOOL_RESULT_MAX_BYTES) {
+    const fixedMarker = markerFor('');
+    const nameBudget = Math.max(0, TOOL_RESULT_MAX_BYTES - Buffer.byteLength(fixedMarker, 'utf8'));
+    marker = markerFor(truncateUtf8(String(toolName || 'tool'), nameBudget));
   }
-  const head = chunks.join('');
-  const marker = normalizeLanguage(language) === 'zh'
-    ? `\n\n[已截断：${toolName} 返回 ${formatSize(originalBytes)}，上限为 ${formatSize(TOOL_RESULT_MAX_BYTES)}；原因：单个 tool result 超过 ${formatSize(TOOL_RESULT_MAX_BYTES)}，模型消息历史不会看到剩余内容]`
-    : `\n\n[truncated: ${toolName} returned ${formatSize(originalBytes)}, capped at ${formatSize(TOOL_RESULT_MAX_BYTES)}; reason: single tool result exceeded ${formatSize(TOOL_RESULT_MAX_BYTES)}, the model message history will not see the rest]`;
-  return head + marker;
+  marker = truncateUtf8(marker, TOOL_RESULT_MAX_BYTES);
+  const contentBudget = Math.max(0, TOOL_RESULT_MAX_BYTES - Buffer.byteLength(marker, 'utf8'));
+  return truncateUtf8(text, contentBudget) + marker;
 }
 
 /**

package/yeaft/tools/types.js

@@ -62,6 +62,7 @@
  * @property {(input?: object) => boolean} [isConcurrencySafe] — can run in parallel?
  * @property {(input?: object) => boolean} [isReadOnly] — read-only operation?
  * @property {(input?: object) => boolean} [isDestructive] — destructive operation?
+ * @property {'json-error-envelope' | null} [errorOutput] — explicit returned-output error contract; null means only thrown errors fail
  */
 
 /**
@@ -75,6 +76,7 @@
  *   isConcurrencySafe?: (input?: object) => boolean,
  *   isReadOnly?: (input?: object) => boolean,
  *   isDestructive?: (input?: object) => boolean,
+ *   errorOutput?: 'json-error-envelope' | null,
  *   timeoutMs?: number,
  * }} def
  * @returns {ToolDef}
@@ -88,6 +90,7 @@ export function defineTool({
   isConcurrencySafe = () => false,
   isReadOnly = () => false,
   isDestructive = () => false,
+  errorOutput = 'json-error-envelope',
   timeoutMs,
 }) {
   if (!name) throw new Error('Tool must have a name');
@@ -101,6 +104,7 @@ export function defineTool({
     isConcurrencySafe,
     isReadOnly,
     isDestructive,
+    errorOutput,
   };
   // Legacy tool-name aliases. Registered as extra lookup keys so old
   // jsonl tool_calls (e.g. `SendMessage` → `PromptAgent`) keep resolving,