@yeaft/webchat-agent 1.0.527 → 1.0.528

package/yeaft/tools/bash.js

@@ -77,6 +77,7 @@ function runCommand(command, { cwd, timeout, signal, runtimePlatform, runProcess
     signal,
     timeoutMs: timeout,
     maxBytes: MAX_OUTPUT,
+    outputLimitAction: 'head-tail',
     requireExitConfirmation: true,
     systemdScope: invocation.systemdControl,
     onSettled: invocation.cleanup || null,
@@ -86,6 +87,7 @@ function runCommand(command, { cwd, timeout, signal, runtimePlatform, runProcess
     stderr: result.stderr,
     exitCode: result.code,
     timedOut: result.timedOut,
+    truncated: result.truncated,
     terminationError: result.terminationError || null,
   }));
 }
@@ -103,7 +105,7 @@ Guidelines:
 - Commands run in the working directory (cwd from context)
 - Match command syntax to the Agent OS shown in the runtime_platform prompt
 - Timeout defaults to 2 minutes (max 10 minutes)
-- Large outputs are truncated at 256KB
+- Large outputs retain a bounded head/tail (256KB per stream); capture limits do not stop the command. Use background tasks for persistent full logs
 - Use absolute paths when possible
 - Avoid interactive commands (no stdin support)
 - Use background=true for long-running or persistent tasks that should survive across turns
@@ -116,7 +118,7 @@ Guidelines:
 使用指南：
 - 命令在工作目录中执行（上下文中的 cwd）
 - 默认超时 2 分钟（最大 10 分钟）
-- 大输出在 256KB 处截断
+- 大输出有界保留首尾（每个流 256KB），不因输出上限终止命令；需要持久完整日志时使用后台任务
 - 尽量使用绝对路径
 - 避免交互式命令（不支持 stdin）
 - 长时间或需要跨 turn 持续存在的任务使用 background=true
@@ -136,8 +138,8 @@ Guidelines:
       cwd: {
         type: 'string',
         description: {
-          en: 'Working directory for the command (default: engine cwd)',
-          zh: '命令的工作目录（默认为引擎当前目录）',
+          en: 'Working directory; relative paths resolve against engine cwd',
+          zh: '命令工作目录；相对路径以引擎当前目录为基准',
         },
       },
       timeout_ms: {
@@ -189,9 +191,7 @@ Guidelines:
     if (!command) throw new Error('command is required');
 
     // Resolve working directory
-    const cwd = inputCwd
-      ? resolve(inputCwd)
-      : (ctx?.cwd || process.cwd());
+    const cwd = resolve(ctx?.cwd || process.cwd(), inputCwd || '.');
 
     if (!existsSync(cwd)) {
       throw new Error(`Working directory does not exist: ${cwd}`);
@@ -217,7 +217,7 @@ Guidelines:
             threadId: ctx.threadId || 'main',
           },
         });
-        return `Started background task ${task.id}.\nStatus: ${task.status}\nLog: ${task.log?.path || ''}\nThe task is detached from this turn. Use ListTasks, ReadTaskLog, or CancelTask to inspect or control it.`;
+        return `Started background task ${task.id}.\nWorking directory: ${cwd}\nStatus: ${task.status}\nLog: ${task.log?.path || ''}\nThe task is detached from this turn. Use ListTasks, ReadTaskLog, or CancelTask to inspect or control it.`;
       } catch (err) {
         throw new Error(err?.message || String(err));
       }
@@ -236,6 +236,7 @@ Guidelines:
       const parts = [];
       if (result.stdout) parts.push(result.stdout);
       if (result.stderr) parts.push(`STDERR:\n${result.stderr}`);
+      if (result.truncated) parts.push('[Captured output truncated; command exit/timeout status is reported separately. Use a background task for a durable log.]');
       if (result.timedOut) parts.push(`\n(Command timed out after ${timeout}ms)`);
       if (result.terminationError) {
         parts.push([
@@ -258,10 +259,11 @@ Guidelines:
 
       const output = parts.join('\n');
       if (result.exitCode !== 0) {
-        return `Exit code: ${result.exitCode}\n${output}`;
+        return `Exit code: ${result.exitCode}\nWorking directory: ${cwd}\n${output}`;
       }
       return output || '(no output)';
     } catch (err) {
+      err.message = `${err.message} (working directory: ${cwd})`;
       if (err?.name === 'ProcessTerminationError') err.fatalToolTimeout = true;
       throw err;
     }

package/yeaft/tools/exit-worktree.js

@@ -67,7 +67,7 @@ unless discard_changes is set to true.`,
   },
   isDestructive: (input) => input?.action === 'remove',
   async execute(input, ctx) {
-    const worktreePath = resolve(input.path);
+    const worktreePath = resolve(ctx?.cwd || process.cwd(), input.path);
     const mainCwd = ctx?.cwd || process.cwd();
 
     if (!existsSync(worktreePath)) {

package/yeaft/tools/file-read.js

@@ -8,6 +8,7 @@
  * Modeled after Claude Code's Read tool.
  */
 
+import { createHash } from 'node:crypto';
 import { defineTool } from './types.js';
 import { readFile, stat } from 'fs/promises';
 import { existsSync } from 'fs';
@@ -77,6 +78,34 @@ function formatLinesWithinBudget(allLines, startLine, endLine, startColumn = 0,
   return { text: parts.join(''), nextLine, nextColumn };
 }
 
+// Query-local observations are hints only: always read the current file and
+// never suppress ranges. Hashing observed bytes handles same-size/mtime edits.
+function describeRead(ctx, path, content, start, end, startColumn, nextColumn) {
+  const version = createHash('sha256').update(content).digest('hex').slice(0, 16);
+  const observations = ctx?.fileReadObservations;
+  const previous = observations?.get(path);
+  const ranges = previous?.version === version ? previous.ranges : [];
+  const overlaps = ranges.filter(([from, to]) => from < end && to > start)
+    .map(([from, to]) => `${Math.max(from, start) + 1}-${Math.min(to, end)}`);
+  // Partial Unicode lines are not considered fully observed.
+  const from = start + (startColumn > 0 ? 1 : 0);
+  const to = end - (nextColumn > 0 ? 1 : 0);
+  if (observations && to > from) {
+    const merged = [...ranges, [from, to]].sort((a, b) => a[0] - b[0]).reduce((out, range) => {
+      const last = out.at(-1);
+      if (last && range[0] <= last[1]) last[1] = Math.max(last[1], range[1]);
+      else out.push([...range]);
+      return out;
+    }, []);
+    observations.delete(path);
+    observations.set(path, { version, ranges: merged.slice(-16) });
+    if (observations.size > 64) observations.delete(observations.keys().next().value);
+  }
+  const hint = overlaps.length
+    ? ` Previously returned unchanged lines in this query: ${overlaps.slice(0, 4).join(', ')}. Read other ranges only if needed.` : '';
+  return `\n[File: ${path}; observed version: ${version}.${hint}]`;
+}
+
 export default defineTool({
   name: 'FileRead',
   description: {
@@ -140,7 +169,9 @@ Guidelines:
   },
   isConcurrencySafe: () => true,
   isReadOnly: () => true,
-  cacheWithinQuery: true,
+  // The workspace may change outside this Engine (editor, process, peer).
+  // Observation hints must describe a fresh read, never a cached snapshot.
+  cacheWithinQuery: false,
   async execute(input, ctx) {
     const { file_path, offset = 0, column_offset = 0, limit = DEFAULT_LIMIT } = input;
     if (!file_path) return JSON.stringify({ error: 'file_path is required' });
@@ -201,6 +232,8 @@ Guidelines:
       const startColumn = column_offset;
       const { text: numbered, nextLine, nextColumn } = formatLinesWithinBudget(allLines, startLine, endLine, startColumn);
 
+      const shownEnd = nextColumn > 0 ? nextLine + 1 : nextLine;
+      const observation = describeRead(ctx, absPath, content, startLine, shownEnd, startColumn, nextColumn);
       const hasMoreContent = nextColumn > 0 || nextLine < totalLines;
       if (startLine > 0 || startColumn > 0 || hasMoreContent) {
         const continuation = hasMoreContent
@@ -208,11 +241,10 @@ Guidelines:
             ? ` 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}\n\n[Showing lines ${startLine + 1}-${shownEnd} of ${totalLines} total.${continuation}]${observation}`;
       }
 
-      return numbered;
+      return numbered + observation;
     } catch (err) {
       return JSON.stringify({ error: `Failed to read file: ${err.message}` });
     }

package/yeaft/tools/git-read.js

@@ -46,8 +46,27 @@ async function filterOverrides(run, options) {
   });
 }
 
-function errorOutput(message) {
-  return JSON.stringify({ error: message });
+function errorOutput(message, operation) {
+  return JSON.stringify({
+    error: message, errorEffect: 'none', code: 'invalid_arguments',
+    hint: `Use only fields for the chosen operation. Minimal example: ${JSON.stringify({ operation: ['status', 'diff', 'show', 'log'].includes(operation) ? operation : 'status' })}`,
+  });
+}
+
+// Some strict-schema providers require every property. Treat their empty
+// placeholders as omitted, without accepting unknown keys or non-default
+// arguments belonging to another operation.
+function normalizeInput(input) {
+  const result = { ...input };
+  for (const key of ['base', 'head', 'revision', 'paths', 'limit']) {
+    if (result[key] === null || result[key] === undefined
+        || (['base', 'head', 'revision'].includes(key) && result[key] === '')
+        || (key === 'paths' && Array.isArray(result[key]) && result[key].length === 0)
+        || (key === 'limit' && result.operation !== 'log' && result[key] === DEFAULT_LOG_LIMIT)) {
+      delete result[key];
+    }
+  }
+  return result;
 }
 
 function validateValue(value, name) {
@@ -80,6 +99,7 @@ export function buildGitReadArgs(input) {
     return { error: 'input must be an object' };
   }
 
+  input = normalizeInput(input);
   const { operation } = input;
   if (!['status', 'diff', 'show', 'log'].includes(operation)) {
     return { error: 'operation must be one of: status, diff, show, log' };
@@ -202,16 +222,16 @@ GitRead 不 fetch、不写 Git 状态、不创建 worktree。它禁用 pager、e
     additionalProperties: false,
     properties: {
       operation: { type: 'string', enum: ['status', 'diff', 'show', 'log'] },
-      base: { type: 'string', maxLength: MAX_VALUE_LENGTH, description: 'Diff base revision; omitted for working-tree changes against HEAD' },
-      head: { type: 'string', maxLength: MAX_VALUE_LENGTH, description: 'Diff head revision; requires base and defaults to HEAD' },
-      revision: { type: 'string', maxLength: MAX_VALUE_LENGTH, description: 'Revision for show or log (default: HEAD)' },
+      base: { type: 'string', maxLength: MAX_VALUE_LENGTH, description: 'diff only; empty/omitted means working-tree changes against HEAD' },
+      head: { type: 'string', maxLength: MAX_VALUE_LENGTH, description: 'diff only; requires base, empty/omitted defaults to HEAD' },
+      revision: { type: 'string', maxLength: MAX_VALUE_LENGTH, description: 'show/log only; empty/omitted defaults to HEAD' },
       paths: {
         type: 'array',
         maxItems: MAX_PATHS,
         items: { type: 'string', minLength: 1, maxLength: MAX_VALUE_LENGTH },
-        description: 'Optional repository-relative paths for diff or show',
+        description: 'diff/show only; empty/omitted means all paths',
       },
-      limit: { type: 'integer', minimum: 1, maximum: MAX_LOG_LIMIT, description: 'Maximum log entries' },
+      limit: { type: 'integer', minimum: 1, maximum: MAX_LOG_LIMIT, description: 'log only; default 20. Empty optional fields are ignored; omit fields for other operations.' },
     },
     required: ['operation'],
   },
@@ -220,7 +240,7 @@ GitRead 不 fetch、不写 Git 状态、不创建 worktree。它禁用 pager、e
   isReadOnly: () => true,
   async execute(input, ctx) {
     const built = buildGitReadArgs(input);
-    if (built.error) return errorOutput(built.error);
+    if (built.error) return errorOutput(built.error, input?.operation);
     const cwd = resolve(ctx?.cwd || process.cwd());
     try {
       const run = ctx?.[RUN_PROCESS_OVERRIDE] || runProcess;
@@ -248,7 +268,7 @@ GitRead 不 fetch、不写 Git 状态、不创建 worktree。它禁用 pager、e
       return formatGitReadResult(input.operation, result);
     } catch (error) {
       if (error?.name === 'AbortError') throw error;
-      return errorOutput(`GitRead failed: ${error?.message || String(error)}`);
+      return JSON.stringify({ error: `GitRead failed: ${error?.message || String(error)}`, resolvedCwd: cwd });
     }
   },
 });

package/yeaft/tools/list-agents.js

@@ -1,40 +1,36 @@
-/**
- * list-agents.js — List all active (and optionally terminal) sub-agents.
- *
- * Returns: { agents: [{ id, name, status, task, outputFile, liveness,
- * lastEventAt, msSinceLastEvent, error, hasResult, createdAt }, …] }.
- *
- * The default filter drops `closed` agents to stay tidy; pass
- * include_closed=true (or include_terminal=true) to see them all. The
- * include_closed alias is kept for backward-compat with the old shape.
- */
+/** Compact, caller-scoped status projection for sub-agent orchestration. */
 
 import { defineTool } from './types.js';
 import { agentBelongsToCaller, getAgentRegistry } from './agent.js';
-import { isTerminalAgentStatus } from '../sub-agent/status.js';
+import { isTerminalAgentStatus, STATUS } from '../sub-agent/status.js';
 import { diagnoseAgentLiveness } from '../sub-agent/liveness.js';
 
+function nextStepFor(agent, liveness) {
+  if (isTerminalAgentStatus(agent.status)) {
+    return 'Use WaitAgent to collect the final result, or read outputFile for the full timeline.';
+  }
+  if (agent.status === STATUS.IDLE) {
+    return 'Use WaitAgent to collect the reply; PromptAgent only if follow-up guidance is needed.';
+  }
+  if (liveness.stale) {
+    return 'Diagnostic only: inspect outputFile before deciding whether to CloseAgent; do not assume the work is dead.';
+  }
+  return 'Continue parent work; completion arrives by notification. Read outputFile only when detailed progress is needed.';
+}
+
 export default defineTool({
   name: 'ListAgents',
   description: {
-    en: `List all sub-agents and their current status.
+    en: `List caller-owned sub-agents as compact status references.
 
-Returns id, name, status, mission/task summary, durable outputFile path,
-liveness counters (toolUseCount, tokenCount, msSinceLastEvent, recentTools),
-stale/stalled diagnostics, result tail, and message count for each agent. Use
-this as the primary non-blocking monitor for async sub-agent work, and Read
-\`outputFile\` for any single agent if you need its full timeline.
+Returns identity, status, bounded mission summary, durable outputFile, actual tool/LLM/token usage, recent activity, diagnostic staleness, and an actionable next step. It does not copy result text or the full log; use WaitAgent for a reply and Read outputFile for the timeline.
 
-By default only non-closed agents are returned. Pass include_closed=true
-to also list closed/failed/abandoned/completed agents.`,
-    zh: `列出所有子 Agent 及其当前状态。
+By default terminal agents are omitted. Pass include_closed=true to include them.`,
+    zh: `以紧凑状态引用列出调用方拥有的子 Agent。
 
-返回每个 Agent 的 id、name、status、mission/task 摘要、持久化 outputFile 路径、
-liveness 计数器（toolUseCount、tokenCount、msSinceLastEvent、recentTools）、
-stale/stalled 诊断、result 尾部和消息数量。将此作为异步子 Agent 工作的主要非阻塞监控工具；
-如需查看某个 Agent 的完整时间线，可 Read 其 outputFile。
+返回身份、状态、有界任务摘要、持久化 outputFile、真实工具/LLM/token 用量、最近活动、诊断性 stale 状态和有效下一步。不复制结果文本或完整日志；回复用 WaitAgent 获取，时间线用 Read outputFile 查看。
 
-默认只返回未关闭的 Agent。传 include_closed=true 可同时列出 closed/failed/abandoned/completed 的 Agent。`
+默认省略终止 Agent；传 include_closed=true 可包含。`,
   },
   parameters: {
     type: 'object',
@@ -42,15 +38,15 @@ stale/stalled 诊断、result 尾部和消息数量。将此作为异步子 Agen
       include_closed: {
         type: 'boolean',
         description: {
-          en: 'Include closed/failed/abandoned/completed agents in the list (default: false)',
-          zh: '在列表中包含已关闭/失败/放弃/完成的 Agent（默认 false）',
+          en: 'Include terminal agents (default: false)',
+          zh: '包含终止 Agent（默认 false）',
         },
       },
       include_terminal: {
         type: 'boolean',
         description: {
-          en: 'Alias for include_closed — include all terminal-status agents in the list',
-          zh: 'include_closed 的别名 — 列出所有已终止状态的 Agent',
+          en: 'Backward-compatible alias for include_closed',
+          zh: 'include_closed 的兼容别名',
         },
       },
     },
@@ -61,51 +57,57 @@ stale/stalled 诊断、result 尾部和消息数量。将此作为异步子 Agen
   duplicateCallPolicy: () => 'allow',
   async execute(input, ctx) {
     const includeTerminal = Boolean(input?.include_closed || input?.include_terminal);
-    const agents = getAgentRegistry();
     const now = Date.now();
+    const agents = [];
 
-    const agentList = [];
-    for (const [id, agent] of agents) {
+    for (const [id, agent] of getAgentRegistry()) {
       if (!agentBelongsToCaller(agent, ctx)) continue;
       if (!includeTerminal && isTerminalAgentStatus(agent.status)) continue;
-      const liveness = diagnoseAgentLiveness(agent, { now });
-      const resultText = (typeof agent.result === 'string' && agent.result)
-        ? agent.result
-        : (agent.lastResult || '');
-      agentList.push({
+      const live = diagnoseAgentLiveness(agent, { now });
+      const execution = live.execution;
+      agents.push({
         id,
         name: agent.name,
         status: agent.status,
         task: typeof agent.task === 'string' ? agent.task.slice(0, 200) : null,
         outputFile: agent.outputFile || null,
-        liveness,
-        lastEventAt: liveness.lastEventAt,
-        msSinceLastEvent: liveness.msSinceLastEvent,
-        lastEventType: liveness.lastEventType,
-        stale: liveness.stale,
-        stalled: liveness.stalled,
-        diagnostic: liveness.diagnostic,
+        activity: {
+          lastEventAt: live.lastEventAt,
+          msSinceLastEvent: live.msSinceLastEvent,
+          lastEventType: live.lastEventType,
+          recentTools: live.recentTools,
+          outputChars: live.outputChars,
+        },
+        usage: {
+          toolExecutions: execution?.toolCalls || 0,
+          llmRequests: execution?.llmCalls || agent.usage?.llmCalls || 0,
+          providerTokens: live.usageTokens,
+          turns: agent.usage?.turns || 0,
+        },
+        control: {
+          limits: execution?.limits || { ...agent.budget },
+          remainingToolCalls: execution?.remainingToolCalls ?? null,
+          remainingLlmCalls: execution?.remainingLlmCalls ?? null,
+          remainingWallTimeMs: execution?.remainingWallTimeMs ?? null,
+          reportingLlmCalls: execution?.reportingLlmCalls || 0,
+          allowTools: execution?.allowTools || [...(agent.allowTools || [])],
+          controlRevision: execution?.controlRevision || 0,
+        },
+        stale: live.stale,
+        diagnostic: live.diagnostic,
         error: agent.error || null,
         hasResult: Boolean(agent.result || agent.lastResult),
-        resultTail: resultText ? resultText.slice(-1000) : '',
-        messages: Array.isArray(agent.messages) ? agent.messages.length : 0,
-        turns: agent.usage?.turns || 0,
-        createdAt: agent.createdAt,
+        next_step: nextStepFor(agent, live),
       });
     }
 
-    if (agentList.length === 0) {
-      return JSON.stringify({
-        agents: [],
+    return JSON.stringify({
+      agents,
+      ...(agents.length === 0 ? {
         message: includeTerminal
           ? 'No sub-agents in the registry'
           : 'No active sub-agents (pass include_closed=true to see terminal ones)',
-      });
-    }
-
-    return JSON.stringify({
-      agents: agentList,
-      totalCount: agentList.length,
-    }, null, 2);
+      } : {}),
+    });
   },
 });

package/yeaft/tools/list-tasks.js

@@ -4,11 +4,31 @@
 
 import { defineTool } from './types.js';
 
+/** Model-facing projection only; TaskManager snapshots remain the UI/API source. */
+export function compactTaskSnapshot(task) {
+  if (!task || typeof task !== 'object') return null;
+  const runtime = task.runtime && typeof task.runtime === 'object' ? task.runtime : {};
+  const log = task.log && typeof task.log === 'object' ? task.log : {};
+  return {
+    id: task.id,
+    kind: task.kind,
+    title: typeof task.title === 'string' ? task.title.slice(0, 200) : task.title,
+    status: task.status,
+    resultDelivery: task.resultDelivery,
+    updatedAt: task.updatedAt,
+    ...(runtime.subAgentId ? { agentId: runtime.subAgentId } : {}),
+    ...(log.path ? { logPath: log.path } : {}),
+    ...(runtime.cancelRequestedAt ? { cancelPending: true } : {}),
+    ...(runtime.cancelEscalatedAt ? { cancelEscalated: true } : {}),
+    ...(runtime.cancelEscalationFailed ? { cancelEscalationFailed: true } : {}),
+  };
+}
+
 export default defineTool({
   name: 'ListTasks',
   description: {
-    en: 'List currently running Session background tasks.',
-    zh: '列出当前正在运行的 Session 后台任务。',
+    en: 'List currently running Session background tasks as compact status references. Use ReadTaskLog for task output.',
+    zh: '以紧凑状态引用列出当前运行的 Session 后台任务；任务输出请用 ReadTaskLog。',
   },
   parameters: {
     type: 'object',
@@ -25,6 +45,14 @@ export default defineTool({
   async execute(input = {}, ctx = {}) {
     if (!ctx.taskManager) return JSON.stringify({ error: 'task manager unavailable' });
     const sessionId = input.sessionId || ctx.sessionId || null;
-    return JSON.stringify({ tasks: ctx.taskManager.listActiveTasks(sessionId) }, null, 2);
+    const tasks = ctx.taskManager.listActiveTasks(sessionId)
+      .map(compactTaskSnapshot)
+      .filter(Boolean);
+    return JSON.stringify({
+      tasks,
+      next_steps: tasks.length > 0
+        ? 'ReadTaskLog reads output by task id. For sub_agent tasks use WaitAgent/CloseAgent with agentId to collect/cancel; for shell tasks use CancelTask only when cancellation is intended. cancelPending is not proof the process has stopped.'
+        : 'No active tasks require follow-up.',
+    });
   },
 });

package/yeaft/tools/process-runner.js

@@ -119,7 +119,7 @@ function processGroupIsInactive(pid) {
  *
  * @param {string} command
  * @param {string[]} args
- * @param {{ cwd?: string, signal?: AbortSignal, timeoutMs?: number, maxBytes?: number, env?: NodeJS.ProcessEnv, preserveCarriageReturns?: boolean, killGraceMs?: number, gracefulTerminationDeadline?: number, terminationDeadline?: number, forceSettleMs?: number, treeKillTimeoutMs?: number, requireExitConfirmation?: boolean, requireProcessGroupExit?: boolean, systemdScope?: { unit: string, systemctlPath: string, env?: NodeJS.ProcessEnv } | null, onSettled?: (() => void) | null, platform?: NodeJS.Platform, spawnProcess?: typeof spawn, spawnProcessSync?: typeof spawnSync }} [options]
+ * @param {{ cwd?: string, signal?: AbortSignal, timeoutMs?: number, maxBytes?: number, outputLimitAction?: 'stop'|'head-tail', env?: NodeJS.ProcessEnv, preserveCarriageReturns?: boolean, killGraceMs?: number, gracefulTerminationDeadline?: number, terminationDeadline?: number, forceSettleMs?: number, treeKillTimeoutMs?: number, requireExitConfirmation?: boolean, requireProcessGroupExit?: boolean, systemdScope?: { unit: string, systemctlPath: string, env?: NodeJS.ProcessEnv } | null, onSettled?: (() => void) | null, platform?: NodeJS.Platform, spawnProcess?: typeof spawn, spawnProcessSync?: typeof spawnSync }} [options]
  * @returns {Promise<{ code: number, stdout: string, stderr: string, truncated: boolean, timedOut: boolean, terminationError?: string }>}
  */
 export function runProcess(command, args, options = {}) {
@@ -135,6 +135,7 @@ export function runProcess(command, args, options = {}) {
     const maxBytes = Number.isFinite(options.maxBytes)
       ? Math.max(0, options.maxBytes)
       : DEFAULT_MAX_BYTES;
+    const keepOutputTail = options.outputLimitAction === 'head-tail';
     const killGraceMs = Number.isFinite(options.killGraceMs)
       ? Math.max(0, options.killGraceMs)
       : DEFAULT_KILL_GRACE_MS;
@@ -212,6 +213,18 @@ export function runProcess(command, args, options = {}) {
     };
     const decode = (chunks, wasTruncated, preserveCarriageReturns = false) => {
       const decoder = new StringDecoder('utf8');
+      if (wasTruncated && keepOutputTail) {
+        const buffer = Buffer.concat(chunks);
+        const marker = '\n[Process output middle omitted]\n';
+        const budget = Math.max(0, maxBytes - Buffer.byteLength(marker));
+        const headEnd = Math.floor(budget / 2);
+        let tailStart = buffer.length - (budget - headEnd);
+        while (tailStart < buffer.length && (buffer[tailStart] & 0xc0) === 0x80) tailStart += 1;
+        const head = decoder.write(buffer.subarray(0, headEnd));
+        const tail = new StringDecoder('utf8').write(buffer.subarray(tailStart));
+        const value = head + marker.slice(0, maxBytes) + tail;
+        return preserveCarriageReturns ? value : value.replace(/\r/g, '');
+      }
       let value = decoder.write(Buffer.concat(chunks));
       if (!wasTruncated) value += decoder.end();
       return preserveCarriageReturns ? value : value.replace(/\r/g, '');
@@ -357,6 +370,21 @@ export function runProcess(command, args, options = {}) {
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
       const current = isStdout ? stdoutBytes : stderrBytes;
       const remaining = maxBytes - current;
+      if (keepOutputTail && (buffer.length > remaining || (isStdout ? stdoutTruncated : stderrTruncated))) {
+        const prior = Buffer.concat(target);
+        const headSize = Math.floor(maxBytes / 2);
+        const tailSize = maxBytes - headSize;
+        const head = prior.length >= headSize ? prior.subarray(0, headSize)
+          : Buffer.concat([prior, buffer.subarray(0, headSize - prior.length)]);
+        const tail = buffer.length >= tailSize ? buffer.subarray(buffer.length - tailSize)
+          : Buffer.concat([prior.subarray(Math.max(0, prior.length - (tailSize - buffer.length))), buffer]);
+        // Copy slices so a tiny retained tail cannot retain an unbounded chunk.
+        target.splice(0, target.length, Buffer.from(head), Buffer.from(tail));
+        truncated = true;
+        if (isStdout) { stdoutTruncated = true; stdoutBytes = maxBytes; }
+        else { stderrTruncated = true; stderrBytes = maxBytes; }
+        return;
+      }
       if (remaining <= 0) {
         truncated = true;
         if (isStdout) stdoutTruncated = true;

package/yeaft/tools/registry.js

@@ -216,6 +216,14 @@ export function isToolErrorOutput(output) {
   return parseToolErrorOutput(output) !== null;
 }
 
+// Only an explicit, side-effect-free validation envelope qualifies. Runtime
+// failures (network, tests, IO) must never be guessed to be invalid arguments.
+export function toolValidationError(output) {
+  const parsed = parseToolErrorOutput(output);
+  return parsed?.code === 'invalid_arguments' && parsed.errorEffect === 'none'
+    ? parsed.error : null;
+}
+
 export function toolErrorEffect(output) {
   return parseToolErrorOutput(output)?.errorEffect === 'none' ? 'none' : 'unknown';
 }
@@ -245,6 +253,16 @@ export function truncateToolResultIfNeeded(output, { toolName, language } = {})
   }
   marker = truncateUtf8(marker, TOOL_RESULT_MAX_BYTES);
   const contentBudget = Math.max(0, TOOL_RESULT_MAX_BYTES - Buffer.byteLength(marker, 'utf8'));
+  if (toolName === 'Bash' && contentBudget > 256) {
+    const omission = normalizeLanguage(language) === 'zh'
+      ? '\n[中间输出省略；以下为末尾]\n' : '\n[Middle omitted; output tail follows]\n';
+    const budget = contentBudget - Buffer.byteLength(omission, 'utf8');
+    const headBudget = Math.floor(budget / 2);
+    const buffer = Buffer.from(text, 'utf8');
+    let start = buffer.length - (budget - headBudget);
+    while (start < buffer.length && (buffer[start] & 0xc0) === 0x80) start += 1;
+    return truncateUtf8(text, headBudget) + omission + buffer.subarray(start).toString('utf8') + marker;
+  }
   return truncateUtf8(text, contentBudget) + marker;
 }
 

package/yeaft/tools/update-agent.js

@@ -59,7 +59,8 @@ export default defineTool({
     agent.budget = { ...agent.budget, ...input.budget };
     if (grants) agent.allowTools = grants.tools;
     agent.controlRevision = (agent.controlRevision || 0) + 1;
-    if (agent.execution && agent.execution.toolCalls < agent.budget.max_tool_calls * 0.75) agent.execution.warning = null;
+    if (agent.execution && (agent.budget.max_tool_calls === undefined
+        || agent.execution.toolCalls < agent.budget.max_tool_calls * 0.75)) agent.execution.warning = null;
     if (!agent.budgetReportStarted) {
       agent.toolBudgetReason = null;
       agent.executionBudgetReason = null;