@yeaft/webchat-agent 1.0.325 → 1.0.326

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.325"}
+{"version":"1.0.326"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.325",
+  "version": "1.0.326",
   "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

@@ -365,7 +365,7 @@ export function shouldAllowGroupReflection({
  * @typedef {{ type: 'turn_start', turnNumber: number }} TurnStartEvent
  * @typedef {{ type: 'turn_end', turnNumber: number, stopReason: string, terminal?: boolean }} TurnEndEvent
  * @typedef {{ type: 'tool_start', id: string, name: string, input: object }} ToolStartEvent
- * @typedef {{ type: 'tool_end', id: string, name: string, output: string, isError: boolean }} ToolEndEvent
+ * @typedef {{ type: 'tool_end', id: string, name: string, output: string, isError: boolean, skipped?: boolean }} ToolEndEvent
  * @typedef {{ type: 'consolidate', archivedCount: number, extractedCount: number }} ConsolidateEvent
  * @typedef {{ type: 'recall', entryCount: number, cached: boolean }} RecallEvent
  * @typedef {{ type: 'fallback', from: string, to: string, reason: string }} FallbackEvent
@@ -1339,6 +1339,7 @@ export class Engine {
       // can mark "after this batch, end the turn — do NOT call adapter
       // again". Honored at the top of the tool-loop continuation.
       requestEndTurn: vpCtx?.requestEndTurn,
+      requestToolBatchBarrier: vpCtx?.requestToolBatchBarrier,
       // Result-producing async-task ownership hook. Tools such as SpawnAgent
       // call this with the new `task.id` so the engine keeps the current query
       // parked at end_turn until the result arrives. Persistent background
@@ -3636,6 +3637,8 @@ export class Engine {
       }
 
       // Execute tool calls and feed results back
+      /** @type {{ kind?: string, message?: string, sourceToolCallId?: string, sourceToolName?: string } | null} */
+      let toolBatchBarrier = null;
       let currentToolCallForAsyncTask = null;
       // task-707: requestEndTurn is a per-batch closure that lets a tool
       // signal "end this turn after the current batch — no adapter retry".
@@ -3667,6 +3670,17 @@ export class Engine {
             endTurnRequested = reason || { kind: 'tool_handoff' };
           }
         },
+        requestToolBatchBarrier: (reason) => {
+          if (toolBatchBarrier != null) return;
+          const detail = reason && typeof reason === 'object'
+            ? { ...reason }
+            : { message: String(reason || 'A preceding tool result invalidated the remaining batch.') };
+          toolBatchBarrier = {
+            ...detail,
+            sourceToolCallId: currentToolCallForAsyncTask?.id || null,
+            sourceToolName: currentToolCallForAsyncTask?.name || null,
+          };
+        },
       });
 
       // task-325a: track whether we aborted mid tool-loop so we can
@@ -3681,11 +3695,14 @@ export class Engine {
         // that's already running (the signal is passed in, tools decide
         // themselves whether to bail early), but we stop dispatching
         // any remaining tools the moment abort fires.
-        if (signal?.aborted) {
+        if (signal?.aborted && !toolBatchBarrier) {
           abortedDuringTools = true;
           break;
         }
+        if (signal?.aborted) abortedDuringTools = true;
 
+        const activeToolBatchBarrier = toolBatchBarrier;
+        const skipped = activeToolBatchBarrier != null;
         const toolStartTime = Date.now();
 
         // PR-L: duplicate-call detection. If this exact (toolName,
@@ -3696,25 +3713,27 @@ export class Engine {
         // assistant(tool_use) → user(tool_result, …) pairing demanded
         // by the Anthropic / OpenAI Responses APIs stays intact. We
         // don't block the call — the LLM still decides.
-        const dupHash = argsHashOf(tc.input);
-        // PR-L follow-up: lookback is by user-conversation turn
-        // (`queryNumber`), NOT by inner adapter loop iteration. Each call
-        // to query() bumps queryNumber once, so "last 2 turns" means the
-        // current user turn + the previous two user turns — the natural
-        // semantic for "the model is stuck in a loop across the
-        // conversation."
-        const dupInfo = this.#execLog.dupInfo({
-          toolName: tc.name,
-          argsHash: dupHash,
-          currentTurn: queryNumber,
-          lookbackTurns: 2,
-        });
-        if (dupInfo.count + 1 >= DUP_TOOL_THRESHOLD) {
-          pendingDupReminders.push(buildDuplicateReminder({
+        if (!skipped) {
+          const dupHash = argsHashOf(tc.input);
+          // PR-L follow-up: lookback is by user-conversation turn
+          // (`queryNumber`), NOT by inner adapter loop iteration. Each call
+          // to query() bumps queryNumber once, so "last 2 turns" means the
+          // current user turn + the previous two user turns — the natural
+          // semantic for "the model is stuck in a loop across the
+          // conversation."
+          const dupInfo = this.#execLog.dupInfo({
             toolName: tc.name,
-            count: dupInfo.count + 1,
-            lastResultBrief: dupInfo.lastResultBrief,
-          }));
+            argsHash: dupHash,
+            currentTurn: queryNumber,
+            lookbackTurns: 2,
+          });
+          if (dupInfo.count + 1 >= DUP_TOOL_THRESHOLD) {
+            pendingDupReminders.push(buildDuplicateReminder({
+              toolName: tc.name,
+              count: dupInfo.count + 1,
+              lastResultBrief: dupInfo.lastResultBrief,
+            }));
+          }
         }
 
         let output;
@@ -3722,18 +3741,40 @@ export class Engine {
         let isError = false;
         let toolErrorOutput = null;
         let fatalToolError = null;
-        currentToolCallForAsyncTask = {
-          id: tc.id,
-          name: tc.name,
-          threadId: runtimeThreadId,
-        };
+        currentToolCallForAsyncTask = skipped
+          ? null
+          : {
+              id: tc.id,
+              name: tc.name,
+              threadId: runtimeThreadId,
+            };
 
         // Resolve tool: prefer ToolRegistry, fallback to legacy #tools Map
         const hasTool = this.#toolRegistry
           ? this.#toolRegistry.isAllowed(tc.name, { collabToolPolicy: effectiveCollabToolPolicy })
           : this.#tools.has(tc.name);
 
-        if (!hasTool) {
+        if (skipped) {
+          const source = activeToolBatchBarrier.sourceToolName || 'a preceding tool';
+          const sourceId = activeToolBatchBarrier.sourceToolCallId
+            ? ` (${activeToolBatchBarrier.sourceToolCallId})`
+            : '';
+          output = [
+            `Skipped ${tc.name} because ${source}${sourceId} invalidated the remaining tool batch.`,
+            activeToolBatchBarrier.message || 'Review the preceding tool result before deciding whether to retry this call.',
+            'This tool was not executed. Submit it again only after reviewing the preceding result.',
+          ].join('\n');
+          isError = true;
+          yield {
+            type: 'tool_end',
+            id: tc.id,
+            name: tc.name,
+            output,
+            isError: true,
+            skipped: true,
+            threadId: this.currentThreadId,
+          };
+        } else if (!hasTool) {
           output = `Error: unknown tool "${tc.name}"`;
           isError = true;
           yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true, threadId: this.currentThreadId };
@@ -3816,13 +3857,14 @@ export class Engine {
           durationMs: toolDurationMs,
           isError,
           toolOutput: output,
+          ...(skipped ? { skipped: true } : {}),
           ...(displayImages.length > 0 ? { displayImageCount: displayImages.length } : {}),
         };
 
         // 2026-05-13: feed the per-tool counters. Stays best-effort — a
         // stats sink that throws shouldn't crash the engine. `record`
         // already swallows internal write errors.
-        if (this.#toolStats && typeof this.#toolStats.record === 'function') {
+        if (!skipped && this.#toolStats && typeof this.#toolStats.record === 'function') {
           try {
             this.#toolStats.record({
               name: tc.name,
@@ -3841,6 +3883,7 @@ export class Engine {
           toolOutput: output,
           durationMs: toolDurationMs,
           isError,
+          skipped,
         });
 
         // Append only the bounded copy to the model message history. Raw
@@ -3876,14 +3919,16 @@ export class Engine {
         // user-conversation turn), not the inner loop's turnNumber.
         // Aligns exec-log layout with dup detection lookback and the
         // T2 fallback-stub readTurn() call below.
-        this.#execLog.append(queryNumber, buildExecLogEntry({
-          loopIdx: queryToolCount,
-          toolName: tc.name,
-          args: tc.input,
-          output,
-          isError,
-        }));
-        queryToolCount += 1;
+        if (!skipped) {
+          this.#execLog.append(queryNumber, buildExecLogEntry({
+            loopIdx: queryToolCount,
+            toolName: tc.name,
+            args: tc.input,
+            output,
+            isError,
+          }));
+          queryToolCount += 1;
+        }
         if (fatalToolError) throw fatalToolError;
       }
 
@@ -3895,6 +3940,11 @@ export class Engine {
         conversationMessages.push({ role: 'user', content: reminder });
       }
 
+      // A batch barrier deliberately returns control to the provider. Any
+      // handoff requested by an earlier call belongs to the invalidated plan
+      // and must not leak into a later provider-generated batch.
+      if (toolBatchBarrier) endTurnRequested = null;
+
       // task-707: tool-callable end-turn signal. If a tool in this batch
       // called toolCtx.requestEndTurn(reason), break out of the outer
       // while-loop now — DON'T call adapter.stream() again. The
@@ -3907,7 +3957,7 @@ export class Engine {
       // collapse the arc into a summary that's only valuable across
       // multi-iteration tool loops) and BEFORE the abortedDuringTools
       // check (so a clean handoff doesn't get reported as 'aborted').
-      if (endTurnRequested) {
+      if (endTurnRequested && !toolBatchBarrier) {
         if (pendingSubAgentNotifs.length > 0) {
           acknowledgePendingNotifications(notifScope, pendingSubAgentNotifs.map(n => n.id));
         }
@@ -3945,7 +3995,8 @@ export class Engine {
       //     batch within the same query gets a distinct entry — without
       //     this the second batch would be silently skipped.
       const t1BatchDue = queryToolCount - lastT1AtToolCount >= TOOL_BATCH_SIZE;
-      if (groupReflectionAllowed && t1BatchDue && !abortedDuringTools && !signal?.aborted) {
+      if (groupReflectionAllowed && t1BatchDue && !toolBatchBarrier
+          && !abortedDuringTools && !signal?.aborted) {
         const t1DedupKey = `${queryNumber}:t1:${queryToolCount}`;
         if (this.#reflectedTurns.has(t1DedupKey)) {
           // Defensive: should never hit since t1BatchDue gates re-entry

package/yeaft/tools/bash.js

@@ -29,23 +29,18 @@ const DEFAULT_TIMEOUT_MS = 120_000;
 
 /** Max timeout in ms (10 minutes). */
 const MAX_TIMEOUT_MS = 600_000;
-/**
- * ToolRegistry must not preempt Bash's own process timeout. Bash terminates
- * the process tree and waits for close before returning exit 124; the grace
- * covers TERM/KILL escalation and the bounded close-confirmation window.
- */
-const REGISTRY_TIMEOUT_MS = MAX_TIMEOUT_MS + 15_000;
 const LINUX_NAMESPACE_HELPER = resolve(
   dirname(fileURLToPath(import.meta.url)),
   '..',
   'linux-process-namespace.js',
 );
+const RUN_PROCESS_OVERRIDE = Symbol('runProcessOverride');
 
 /**
  * Run a command in a child process.
- * @returns {Promise<{ stdout: string, stderr: string, exitCode: number, timedOut: boolean }>}
+ * @returns {Promise<{ stdout: string, stderr: string, exitCode: number, timedOut: boolean, terminationError: string | null }>}
  */
-function runCommand(command, { cwd, timeout, signal, runtimePlatform }) {
+function runCommand(command, { cwd, timeout, signal, runtimePlatform, runProcessImpl = runProcess }) {
   const platform = runtimePlatform || getRuntimePlatformInfo();
   const env = { ...process.env, TERM: 'dumb', FORCE_COLOR: '0' };
   const baseInvocation = buildShellInvocation(command, { runtimePlatform: platform });
@@ -76,7 +71,7 @@ function runCommand(command, { cwd, timeout, signal, runtimePlatform }) {
       systemdControl: null,
     };
   }
-  return runProcess(invocation.command, invocation.args, {
+  return runProcessImpl(invocation.command, invocation.args, {
     cwd,
     env,
     signal,
@@ -91,10 +86,11 @@ function runCommand(command, { cwd, timeout, signal, runtimePlatform }) {
     stderr: result.stderr,
     exitCode: result.code,
     timedOut: result.timedOut,
+    terminationError: result.terminationError || null,
   }));
 }
 
-export default defineTool({
+const bashTool = defineTool({
   name: 'Bash',
   description: {
     en: `Execute a shell command and return its output.
@@ -111,6 +107,7 @@ Guidelines:
 - 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
+- Foreground timeout and cleanup status is returned to you; decide whether to inspect, retry, stop, or use a background task
 - stderr is captured separately and included in the result`,
     zh: `执行 Shell 命令并返回输出。
 
@@ -123,6 +120,7 @@ Guidelines:
 - 尽量使用绝对路径
 - 避免交互式命令（不支持 stdin）
 - 长时间或需要跨 turn 持续存在的任务使用 background=true
+- 前台命令的超时和清理状态会返回给你；由你决定检查、重试、停止或改用后台任务
 - stderr 单独捕获并包含在结果中`
   },
   parameters: {
@@ -167,7 +165,10 @@ Guidelines:
     required: ['command'],
   },
   errorOutput: null,
-  timeoutMs: REGISTRY_TIMEOUT_MS,
+  // Foreground Bash owns a bounded timeout and process-tree cleanup state
+  // machine. A second ToolRegistry timer can preempt that cleanup and turn an
+  // owned exit 124 into a fatal orphan, so it must stay disabled for this tool.
+  timeoutMs: 0,
   isConcurrencySafe: () => false,
   isReadOnly: () => false,
   isDestructive: (input) => {
@@ -224,6 +225,7 @@ Guidelines:
         timeout,
         signal: ctx?.signal,
         runtimePlatform,
+        runProcessImpl: ctx?.[RUN_PROCESS_OVERRIDE] || runProcess,
       });
 
       // Format output similar to Claude Code
@@ -231,6 +233,24 @@ Guidelines:
       if (result.stdout) parts.push(result.stdout);
       if (result.stderr) parts.push(`STDERR:\n${result.stderr}`);
       if (result.timedOut) parts.push(`\n(Command timed out after ${timeout}ms)`);
+      if (result.terminationError) {
+        parts.push([
+          `WARNING: ${result.terminationError}`,
+          'The command timed out, but process-tree termination could not be confirmed. The command may still be running.',
+          'Decide whether to inspect or stop it, retry, or use background=true.',
+        ].join('\n'));
+      }
+      if (result.timedOut) {
+        ctx?.requestToolBatchBarrier?.({
+          kind: 'owned_timeout',
+          message: [
+            result.terminationError
+              ? 'The foreground Bash command timed out and process-tree termination could not be confirmed.'
+              : 'The foreground Bash command timed out.',
+            'Return this result to the model before executing another tool call from the same batch.',
+          ].join(' '),
+        });
+      }
 
       const output = parts.join('\n');
       if (result.exitCode !== 0) {
@@ -243,3 +263,14 @@ Guidelines:
     }
   },
 });
+
+export function createBashTool({ runProcessImpl = runProcess } = {}) {
+  return {
+    ...bashTool,
+    execute(input, ctx) {
+      return bashTool.execute(input, { ...ctx, [RUN_PROCESS_OVERRIDE]: runProcessImpl });
+    },
+  };
+}
+
+export default bashTool;

package/yeaft/tools/process-runner.js

@@ -102,6 +102,7 @@ function killProcessTree(proc, signalName, platform, spawnProcessSync, systemdSc
  * @param {string} command
  * @param {string[]} args
  * @param {{ cwd?: string, signal?: AbortSignal, timeoutMs?: number, maxBytes?: number, env?: NodeJS.ProcessEnv, preserveCarriageReturns?: boolean, killGraceMs?: number, forceSettleMs?: number, requireExitConfirmation?: 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 = {}) {
   if (options.signal?.aborted) {
@@ -188,21 +189,30 @@ export function runProcess(command, args, options = {}) {
       if (settled) return;
       settled = true;
       cleanup();
-      if (error) {
-        reject(error);
-        return;
-      }
-      if (aborted) {
-        reject(abortError(options.signal));
-        return;
-      }
-      resolve({
+      const result = {
         code: timedOut ? 124 : (code ?? 1),
         stdout: decode(stdout, stdoutTruncated, options.preserveCarriageReturns),
         stderr: decode(stderr, stderrTruncated),
         truncated,
         timedOut,
-      });
+      };
+      if (aborted) {
+        reject(abortError(options.signal));
+        return;
+      }
+      if (error) {
+        // A command timeout is an owned, bounded outcome. Failure to observe
+        // the final child close is important context for the caller, but it
+        // must not turn the timeout into an infrastructure exception that
+        // prevents the model from deciding what to do next.
+        if (timedOut && error instanceof ProcessTerminationError) {
+          resolve({ ...result, terminationError: error.message });
+          return;
+        }
+        reject(error);
+        return;
+      }
+      resolve(result);
     };
     const terminationConfirmed = () => {
       if (!options.requireExitConfirmation) return directClosed;
@@ -334,6 +344,10 @@ export function runProcess(command, args, options = {}) {
 
     if (Number.isFinite(options.timeoutMs) && options.timeoutMs > 0) {
       timer = setTimeout(() => {
+        // Preserve the first stop reason. Output overflow and Abort may have
+        // already started termination; a later deadline must not relabel that
+        // cleanup failure as a recoverable command timeout.
+        if (settled || stopRequested) return;
         timedOut = true;
         stop();
       }, options.timeoutMs);

package/yeaft/tools/types.js

@@ -45,6 +45,11 @@
  *   the supplied reason as `detail`. `reason` may be a structured object
  *   `{kind, ...}` so downstream observers (web-bridge) can render UI hints
  *   (e.g. "↪ 已转交给 @vp-b") without re-parsing strings.
+ * @property {(reason?: string|object) => void} [requestToolBatchBarrier]
+ *   — stop executing the remaining calls in the current assistant tool batch
+ *   while still pairing each call with an explicit skipped tool result. The
+ *   engine then returns those results to the provider before accepting another
+ *   plan. Used when a completed tool result invalidates the rest of the batch.
  * @property {string} [senderVpId] — id of the VP whose turn is currently
  *   running. Used by `route_forward` to stamp the forwarded message and
  *   by the loop guard to key per-sender throttling.