@yeaft/webchat-agent 1.0.286 → 1.0.287

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.286"}
+{"version":"1.0.287"}

package/package.json

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

@@ -81,6 +81,9 @@ const MAX_CONTINUE_TURNS = 3;
 /** Bound the best-effort post-turn AMS LLM call independently of the user turn. */
 const AMS_ADJUST_TIMEOUT_MS = 30_000;
 
+/** Maximum silence while a visible turn waits for a result-producing task. */
+const DEFAULT_ASYNC_TASK_WAIT_TIMEOUT_MS = 120_000;
+
 // ─── LLM retry policy defaults ──────────────────────────────────
 // Hard-coded floor / ceiling for retry behaviour. The engine reads the
 // effective policy from `config.llmRetry` so users can dial these via
@@ -629,6 +632,7 @@ export class Engine {
    *   onUnregister?: (taskId:string, engine:Engine) => void,
    *   onConsumed?: (taskId:string, engine:Engine) => void,
    *   onUndelivered?: (taskId:string, delivery:object, engine:Engine) => void,
+   *   onDeferred?: (taskId:string, engine:Engine) => void,
    * } | null}
    */
   #asyncTaskCoordinator = null;
@@ -3209,14 +3213,17 @@ export class Engine {
       if ((stopReason !== 'tool_use' || toolCalls.length === 0)
           && this.#pendingAsyncTaskIds.size > 0
           && !signal?.aborted) {
+        const asyncTaskWaitTimeoutMs = this.#asyncTaskWaitTimeoutMs();
+        const deferredTaskIds = [];
         // Drop into a wait loop. The loop wakes on (a) any task
         // terminal event delivered via `notifyAsyncTaskCompleted`, (b)
         // a fresh user append (which is honored as a higher priority
         // user input), or (c) abort. On wake we re-check: if either
         // queue has content, drain + splice + continue the outer loop.
         // If both queues are empty AND we still have pending tasks AND
-        // we're not aborted, we just keep waiting. This is the only
-        // place query() can block on something other than the LLM stream.
+        // we're not aborted, wait only until the oldest tracked task has
+        // been silent for the bounded window. Stale ownership is then
+        // released so a later terminal event uses the rescue-turn path.
         yield {
           type: 'async_task_wait_start',
           turnId: queryTurnId,
@@ -3237,7 +3244,10 @@ export class Engine {
                && this.#pendingUserMessages.length === 0
                && !this.#externalUserWakePending) {
           if (this.#pendingAsyncTaskIds.size === 0) break;
-          await this.#waitForAsyncWake(signal);
+          const waitMs = this.#nextAsyncTaskWaitMs(asyncTaskWaitTimeoutMs);
+          if (await this.#waitForAsyncWake(signal, waitMs) === 'timeout') {
+            deferredTaskIds.push(...this.#deferExpiredAsyncTasks(asyncTaskWaitTimeoutMs));
+          }
         }
         yield {
           type: 'async_task_wait_end',
@@ -3246,6 +3256,8 @@ export class Engine {
           threadId,
           aborted: Boolean(signal?.aborted),
           remainingTaskIds: Array.from(this.#pendingAsyncTaskIds),
+          timedOut: deferredTaskIds.length > 0,
+          deferredTaskIds,
         };
         if (signal?.aborted) {
           yield { type: 'aborted', reason: this.#abortReason || 'external', turnNumber, threadId };
@@ -4186,6 +4198,69 @@ export class Engine {
     try { this.#asyncTaskCoordinator?.onRegister?.(taskId, this); } catch { /* coord must not throw into tools */ }
   }
 
+  #asyncTaskWaitTimeoutMs() {
+    const configured = Number(this.#config?.asyncTaskWaitTimeoutMs);
+    if (!Number.isFinite(configured)) return DEFAULT_ASYNC_TASK_WAIT_TIMEOUT_MS;
+    return Math.max(1, Math.min(60 * 60_000, Math.floor(configured)));
+  }
+
+  #asyncTaskLastActivityAt(taskId) {
+    if (!this.#taskManager || typeof this.#taskManager.getTask !== 'function') return null;
+    const sessionId = this.#sessionId || 'default';
+    let task = null;
+    try { task = this.#taskManager.getTask(sessionId, taskId); } catch { return null; }
+    if (!task || task.status !== 'running') return 0;
+    const updatedAt = Date.parse(task.updatedAt || task.startedAt || task.createdAt || '');
+    return Number.isFinite(updatedAt) ? updatedAt : 0;
+  }
+
+  #nextAsyncTaskWaitMs(timeoutMs) {
+    const now = Date.now();
+    let next = timeoutMs;
+    for (const taskId of this.#pendingAsyncTaskIds) {
+      const lastActivityAt = this.#asyncTaskLastActivityAt(taskId);
+      if (lastActivityAt === null) continue;
+      next = Math.min(next, Math.max(1, lastActivityAt + timeoutMs - now));
+    }
+    return Math.max(1, next);
+  }
+
+  /**
+   * Release stale same-turn ownership without stopping the underlying tasks.
+   * Active sub-agents refresh TaskManager.updatedAt from their event stream, so
+   * the timeout measures silence rather than total runtime. A later terminal
+   * event misses the owner map and uses the bridge rescue path.
+   * @param {number} timeoutMs
+   * @returns {string[]}
+   */
+  #deferExpiredAsyncTasks(timeoutMs) {
+    if (this.#pendingAsyncTaskIds.size === 0) return [];
+    const now = Date.now();
+    const taskIds = Array.from(this.#pendingAsyncTaskIds).filter((taskId) => {
+      const lastActivityAt = this.#asyncTaskLastActivityAt(taskId);
+      return lastActivityAt === null || now - lastActivityAt >= timeoutMs;
+    });
+    for (const taskId of taskIds) {
+      // Keep ownership visible while the coordinator decides whether this is a
+      // real defer. If a terminal event already won and removed the task, the
+      // coordinator can reject a stale timeout callback instead of scheduling
+      // a duplicate rescue.
+      try {
+        if (typeof this.#asyncTaskCoordinator?.onDeferred === 'function') {
+          this.#asyncTaskCoordinator.onDeferred(taskId, this);
+        } else {
+          this.#asyncTaskCoordinator?.onUnregister?.(taskId, this);
+        }
+      } catch { /* best-effort */ }
+      this.#pendingAsyncTaskIds.delete(taskId);
+      this.#asyncTaskToolMeta.delete(taskId);
+    }
+    if (taskIds.length > 0) {
+      console.warn(`[Engine] async task wait silent for ${timeoutMs}ms; deferring ${taskIds.join(', ')}`);
+    }
+    return taskIds;
+  }
+
   #wakeAsyncTaskWaiters() {
     if (this.#asyncTaskWaiters.length === 0) return;
     const waiters = this.#asyncTaskWaiters.splice(0);
@@ -4196,30 +4271,42 @@ export class Engine {
 
   /**
    * Wait for *any* of: an async task terminal event, a fresh user append,
-   * or signal abort. Resolves immediately if any of those is already
-   * pending. The loop re-evaluates conditions on wake — multiple
-   * concurrent tasks all wake the same waiter once, then the loop drains
-   * everything in one iteration and decides whether to keep waiting.
+   * signal abort, or the current silence budget. The loop re-evaluates all
+   * queues and task activity on every wake.
    * @param {AbortSignal|null|undefined} signal
-   * @returns {Promise<void>}
+   * @param {number} timeoutMs
+   * @returns {Promise<'wake'|'timeout'>}
    */
-  #waitForAsyncWake(signal) {
+  #waitForAsyncWake(signal, timeoutMs) {
     return new Promise((resolve) => {
+      let settled = false;
+      let timer = null;
+      let onAbort = null;
       // Fast paths — anything already pending releases instantly. This is
       // the common case when a task finished between adapter loops.
-      if (this.#pendingTaskResultMessages.length > 0) return resolve();
-      if (this.#pendingTaskResultUpdates.length > 0) return resolve();
-      if (this.#pendingUserMessages.length > 0) return resolve();
-      if (this.#externalUserWakePending) return resolve();
-      if (signal?.aborted) return resolve();
-      this.#asyncTaskWaiters.push(resolve);
+      if (this.#pendingTaskResultMessages.length > 0) return resolve('wake');
+      if (this.#pendingTaskResultUpdates.length > 0) return resolve('wake');
+      if (this.#pendingUserMessages.length > 0) return resolve('wake');
+      if (this.#externalUserWakePending) return resolve('wake');
+      if (signal?.aborted) return resolve('wake');
+      const finish = (reason) => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        if (signal && onAbort) {
+          try { signal.removeEventListener('abort', onAbort); } catch { /* ignore */ }
+        }
+        const idx = this.#asyncTaskWaiters.indexOf(wake);
+        if (idx >= 0) this.#asyncTaskWaiters.splice(idx, 1);
+        resolve(reason);
+      };
+      const wake = () => finish('wake');
+      this.#asyncTaskWaiters.push(wake);
+      timer = setTimeout(() => finish('timeout'), Math.max(1, Number(timeoutMs) || 1));
+      timer.unref?.();
       if (signal && typeof signal.addEventListener === 'function') {
-        // Best-effort abort wakeup; the loop re-checks signal.aborted.
-        const onAbort = () => {
-          // Splice the resolver out of the wait queue so it can't double-fire.
-          const idx = this.#asyncTaskWaiters.indexOf(resolve);
-          if (idx >= 0) this.#asyncTaskWaiters.splice(idx, 1);
-          try { resolve(); } catch { /* ignore */ }
+        onAbort = () => {
+          try { finish('wake'); } catch { /* ignore */ }
         };
         try { signal.addEventListener('abort', onAbort, { once: true }); } catch { /* old runtimes */ }
       }

package/yeaft/sub-agent/runner.js

@@ -137,88 +137,105 @@ export function startSubAgent(agent, deps = {}) {
   if (agent.__driverStarted) return; // idempotent
   agent.__driverStarted = true;
 
-  // Build sub-engine wired to the parent's adapter/stores/config but with
-  // a restricted toolset. We DO NOT pass a conversationStore: sub-agent
-  // turns must not pollute the user-facing conversation history. The
-  // memory stores are shared so memory recall still works for the
-  // sub-agent (matches parent VP persona memory).
-  const childRegistry = buildChildToolRegistry(deps.parentToolRegistry);
-  const subEngine = new Engine({
-    adapter: deps.adapter,
-    trace: deps.trace,
-    config: { ...deps.config, _readOnly: true },
-    conversationStore: null,
-    memoryStore: deps.memoryStore || null,
-    memoryShardStore: deps.memoryShardStore || null,
-    toolRegistry: childRegistry,
-    skillManager: deps.skillManager || null,
-    mcpManager: deps.mcpManager || null,
-    yeaftDir: deps.yeaftDir || null,
-    toolStats: deps.toolStats || null,
-    taskManager: deps.taskManager || null,
-  });
-  // Same-turn result plumbing: inherit the parent's coordinator so any
-  // result-producing child task launched from this sub-agent uses the shared
-  // owner map. Persistent shell tasks remain status-only and do not register.
-  if (deps.asyncTaskCoordinator && typeof subEngine.setAsyncTaskCoordinator === 'function') {
-    subEngine.setAsyncTaskCoordinator(deps.asyncTaskCoordinator);
-  }
-
-  agent.subEngine = subEngine;
-  agent.engineMessages = agent.engineMessages || [];
-  agent.liveness = agent.liveness || makeLiveness();
-  agent.parentVpId = deps.parentVpId || null;
-  agent.parentSessionId = deps.parentSessionId || null;
-  agent.parentThreadId = deps.parentThreadId || 'main';
-  agent.outputLog = createOutputLog(agent.id, deps.subAgentLogDir);
-  agent.outputFile = agent.outputLog.path;
-  if (agent.taskId && deps.taskManager && agent.parentSessionId) {
-    try { deps.taskManager.setTaskLogPath(agent.parentSessionId, agent.taskId, agent.outputFile); } catch { /* ignore */ }
-  }
-  agent.outputLog.write({ type: 'sub_agent_spawned', agentId: agent.id, agentName: agent.name, mission: agent.mission || agent.task || '' });
-
-  // Compose the system-prompt-overlay we want injected.
-  const preamble = buildSpawnedPreamble({
-    parentName: deps.parentName || 'parent',
-    parentVpId: deps.parentVpId || null,
-    agentName: agent.name,
-    mission: agent.mission || agent.task || '',
-    language: deps.language || deps.config?.language || 'en',
-  });
+  let subEngine = null;
+  let outputLog = null;
+  try {
+    // Build sub-engine wired to the parent's adapter/stores/config but with
+    // a restricted toolset. We DO NOT pass a conversationStore: sub-agent
+    // turns must not pollute the user-facing conversation history. The
+    // memory stores are shared so memory recall still works for the
+    // sub-agent (matches parent VP persona memory).
+    const childRegistry = buildChildToolRegistry(deps.parentToolRegistry);
+    subEngine = new Engine({
+      adapter: deps.adapter,
+      trace: deps.trace,
+      config: { ...deps.config, _readOnly: true },
+      conversationStore: null,
+      memoryStore: deps.memoryStore || null,
+      memoryShardStore: deps.memoryShardStore || null,
+      toolRegistry: childRegistry,
+      skillManager: deps.skillManager || null,
+      mcpManager: deps.mcpManager || null,
+      yeaftDir: deps.yeaftDir || null,
+      toolStats: deps.toolStats || null,
+      taskManager: deps.taskManager || null,
+    });
+    // Same-turn result plumbing: inherit the parent's coordinator so any
+    // result-producing child task launched from this sub-agent uses the shared
+    // owner map. Persistent shell tasks remain status-only and do not register.
+    if (deps.asyncTaskCoordinator && typeof subEngine.setAsyncTaskCoordinator === 'function') {
+      subEngine.setAsyncTaskCoordinator(deps.asyncTaskCoordinator);
+    }
 
-  const baseVpPersona =
-    deps.parentVpPersona && typeof deps.parentVpPersona === 'object'
-      ? { ...deps.parentVpPersona }
-      : {};
-  baseVpPersona.persona =
-    [(baseVpPersona.persona || '').trim(), preamble.trim()]
-      .filter(Boolean)
-      .join('\n\n');
-  if (!baseVpPersona.displayName || !String(baseVpPersona.displayName).trim()) {
-    baseVpPersona.displayName = `${deps.parentName || 'Parent'}/${agent.name || 'sub-agent'}`;
-  }
-  baseVpPersona.subAgent = {
-    parentVpId: deps.parentVpId || null,
-    agentId: agent.id,
-    agentName: agent.name,
-  };
+    agent.subEngine = subEngine;
+    agent.engineMessages = agent.engineMessages || [];
+    agent.liveness = agent.liveness || makeLiveness();
+    agent.parentVpId = deps.parentVpId || null;
+    agent.parentSessionId = deps.parentSessionId || null;
+    agent.parentThreadId = deps.parentThreadId || 'main';
+    outputLog = createOutputLog(agent.id, deps.subAgentLogDir);
+    agent.outputLog = outputLog;
+    agent.outputFile = outputLog.path;
+    if (agent.taskId && deps.taskManager && agent.parentSessionId) {
+      try { deps.taskManager.setTaskLogPath(agent.parentSessionId, agent.taskId, agent.outputFile); } catch { /* ignore */ }
+    }
+    outputLog.write({ type: 'sub_agent_spawned', agentId: agent.id, agentName: agent.name, mission: agent.mission || agent.task || '' });
+
+    // Compose the system-prompt-overlay we want injected.
+    const preamble = buildSpawnedPreamble({
+      parentName: deps.parentName || 'parent',
+      parentVpId: deps.parentVpId || null,
+      agentName: agent.name,
+      mission: agent.mission || agent.task || '',
+      language: deps.language ?? deps.config?.language ?? 'en',
+    });
 
-  agent.subVpPersona = baseVpPersona;
+    const baseVpPersona =
+      deps.parentVpPersona && typeof deps.parentVpPersona === 'object'
+        ? { ...deps.parentVpPersona }
+        : {};
+    baseVpPersona.persona =
+      [(baseVpPersona.persona || '').trim(), preamble.trim()]
+        .filter(Boolean)
+        .join('\n\n');
+    if (!baseVpPersona.displayName || !String(baseVpPersona.displayName).trim()) {
+      baseVpPersona.displayName = `${deps.parentName || 'Parent'}/${agent.name || 'sub-agent'}`;
+    }
+    baseVpPersona.subAgent = {
+      parentVpId: deps.parentVpId || null,
+      agentId: agent.id,
+      agentName: agent.name,
+    };
 
-  // Background driver — pumps queued user messages through engine.query
-  // turn by turn until the agent reaches a terminal state.
-  driveSubAgent(agent, subEngine, baseVpPersona, deps).catch((err) => {
-    // The driver normally handles its own failures (stream try/catch +
-    // terminal transition). This .catch covers genuinely unexpected
-    // throws between turns (e.g. inside dequeueNextUserPrompt) so we
-    // never leave a zombie record without a terminal status.
-    if (isTerminalAgentStatus(agent.status)) return;
-    transitionTerminal(agent, STATUS.FAILED, {
-      error: err && err.message ? err.message : String(err),
-      diagnostic: 'driver_error',
-      deps,
+    agent.subVpPersona = baseVpPersona;
+
+    // Background driver — pumps queued user messages through engine.query
+    // turn by turn until the agent reaches a terminal state.
+    driveSubAgent(agent, subEngine, baseVpPersona, deps).catch((err) => {
+      // The driver normally handles its own failures (stream try/catch +
+      // terminal transition). This .catch covers genuinely unexpected
+      // throws between turns (e.g. inside dequeueNextUserPrompt) so we
+      // never leave a zombie record without a terminal status.
+      if (isTerminalAgentStatus(agent.status)) return;
+      transitionTerminal(agent, STATUS.FAILED, {
+        error: err && err.message ? err.message : String(err),
+        diagnostic: 'driver_error',
+        deps,
+      });
     });
-  });
+  } catch (err) {
+    // Startup is transactional. Nothing owns these resources until the driver
+    // promise has been scheduled; a synchronous failure must leave the record
+    // restartable and release every partially-created handle.
+    try { outputLog?.close(); } catch { /* best-effort rollback */ }
+    try { subEngine?.retireAsyncTasks?.('sub_agent_startup_failed', { rescue: false }); } catch { /* best-effort rollback */ }
+    agent.outputLog = null;
+    agent.outputFile = null;
+    agent.subEngine = null;
+    agent.subVpPersona = null;
+    agent.__driverStarted = false;
+    throw err;
+  }
 }
 
 /**

package/yeaft/tools/agent.js

@@ -440,6 +440,14 @@ use it as the default workflow or call it repeatedly in a loop.`,
         }
         startSubAgent(agent, deps);
       } catch (err) {
+        if (agent.taskId && ctx?.taskManager?.completeTask) {
+          try {
+            ctx.taskManager.completeTask(callerScope.sessionId || ctx?.sessionId || 'default', agent.taskId, {
+              status: 'failed',
+              error: err && err.message ? err.message : String(err),
+            });
+          } catch { /* task terminal delivery is best-effort */ }
+        }
         agent.status = STATUS.FAILED;
         agent.error = err && err.message ? err.message : String(err);
         agent.diagnostics.push({ type: 'spawn_error', error: agent.error, at: Date.now() });

package/yeaft/web-bridge.js

@@ -76,7 +76,7 @@ import { getAgentRegistry, agentBelongsToScope } from './tools/agent.js';
 import { isPromptableAgentStatus } from './sub-agent/status.js';
 import { perfNowMs, recordAgentPerfTrace } from './perf-trace.js';
 import { recordAgentSessionCreated, recordAgentTurn } from '../metrics.js';
-import { TASK_RESULT_DELIVERY, taskResultDeliveryFor } from './tasks/store.js';
+import { TASK_RESULT_DELIVERY, isTerminalTaskStatus, taskResultDeliveryFor } from './tasks/store.js';
 
 const LEGACY_SKILL_COMMAND_PREFIX = 'skill:';
 const YEAFT_SKILL_COMMAND_PREFIX = 'yeaft-skills:';
@@ -487,6 +487,7 @@ function retireCachedVpEngine(key, {
  *   onUnregister: (taskId: string, engine: import('./engine.js').Engine) => void,
  *   onConsumed: (taskId: string, engine: import('./engine.js').Engine) => void,
  *   onUndelivered: (taskId: string, delivery: object, engine: import('./engine.js').Engine) => void,
+ *   onDeferred: (taskId: string, engine: import('./engine.js').Engine) => void,
  * }}
  */
 function buildAsyncTaskCoordinator() {
@@ -519,6 +520,22 @@ function buildAsyncTaskCoordinator() {
         taskStatus: delivery?.taskStatus,
       });
     },
+    onDeferred(taskId, engine) {
+      if (!engine?.ownsPendingAsyncTask?.(taskId)) return;
+      if (!deleteOwnerIfMatch(taskId, engine)) return;
+      const sessionId = engine?.sessionId || null;
+      const task = sessionId && session?.taskManager?.getTask?.(sessionId, taskId);
+      if (!task || !isTerminalTaskStatus(task.status)) return;
+      scheduleTaskResultRescue({
+        taskId,
+        sessionId: task.sessionId || sessionId,
+        vpId: task.ownerVpId || engine?.vpId || null,
+        threadId: task.source?.threadId || task.runtime?.threadId || engine?.currentThreadId || 'main',
+        content: formatTaskResultForVp(task),
+        taskKind: task.kind,
+        taskStatus: task.status,
+      });
+    },
   };
 }
 /**
@@ -4024,6 +4041,12 @@ function handleEngineEvent(event, hctx) {
       break;
 
     case 'async_task_wait_end':
+      if (event.timedOut) {
+        console.warn(
+          '[Yeaft] same-turn async task wait timed out; continuing the VP turn and deferring task results:',
+          Array.isArray(event.deferredTaskIds) ? event.deferredTaskIds : [],
+        );
+      }
       if (!event.aborted && typeof hctx.resetQueryTimer === 'function') hctx.resetQueryTimer();
       sendSessionEvent({
         type: 'vp_async_task_wait_end',
@@ -4032,6 +4055,8 @@ function handleEngineEvent(event, hctx) {
         loopNumber: event.loopNumber,
         aborted: Boolean(event.aborted),
         remainingTaskIds: Array.isArray(event.remainingTaskIds) ? event.remainingTaskIds : [],
+        timedOut: Boolean(event.timedOut),
+        deferredTaskIds: Array.isArray(event.deferredTaskIds) ? event.deferredTaskIds : [],
         ts: Date.now(),
       }, envelope);
       break;
@@ -7303,4 +7328,10 @@ export const __testHooks = {
   queuedTurnIds() {
     return Array.from(vpInboxes.values()).flatMap((inbox) => Array.isArray(inbox) ? inbox.map((entry) => entry.turnId) : []);
   },
+  asyncTaskCoordinatorForTest() {
+    return buildAsyncTaskCoordinator();
+  },
+  asyncTaskOwnerForTest(taskId) {
+    return asyncTaskOwners.get(taskId) || null;
+  },
 };