npm - @yeaft/webchat-agent - Versions diffs - 1.0.266 → 1.0.268 - Mend

@yeaft/webchat-agent 1.0.266 → 1.0.268

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +62 -63
package/local-runtime/web/app.bundle.js.gz +0 -0
package/local-runtime/web/index.html +1 -1
package/package.json +1 -1
package/yeaft/engine.js +19 -21
package/yeaft/sub-agent/runner.js +3 -3
package/yeaft/tasks/manager.js +35 -6
package/yeaft/tasks/store.js +31 -2
package/yeaft/tools/agent.js +2 -0
package/yeaft/tools/bash.js +1 -8
package/yeaft/web-bridge.js +9 -7
package/yeaft/work-center/coordinator.js +117 -48
package/yeaft/work-center/plan-mutation.js +17 -3
package/yeaft/work-center/runner.js +15 -3
package/yeaft/work-center/service.js +1 -56
package/yeaft/work-center/workflow.js +12 -2

package/local-runtime/web/app.bundle.js.gz CHANGED Viewed

Binary file

package/local-runtime/web/index.html CHANGED Viewed

@@ -16,6 +16,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=616a4bf9"></script>
+  <script type="module" src="app.bundle.js?v=80038488"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.266",
+  "version": "1.0.268",
   "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 CHANGED Viewed

@@ -551,11 +551,12 @@ export class Engine {
   #externalUserWakePending = false;
   /**
-   * Tasks (background bash, sub-agent spawns) that were launched DURING
-   * the currently-running query() and have NOT terminated yet. The query
-   * loop refuses to finalize end_turn while this set is non-empty — instead
-   * it parks on `#asyncTaskWaiters` until a terminal event or a new user
-   * append wakes it up. Cleared at the top of each query() and again in
+   * Result-producing async tasks (currently sub-agent spawns) launched DURING
+   * the running query() and not yet terminated. Persistent shell tasks are
+   * deliberately status-only and never enter this set. The query loop refuses
+   * to finalize end_turn while this set is non-empty — instead it parks on
+   * `#asyncTaskWaiters` until a terminal event or a new user append wakes it.
+   * Cleared at the top of each query() and again in
    * the finally block so a stale set never leaks across turns.
    * @type {Set<string>}
    */
@@ -1272,12 +1273,10 @@ 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,
-      // Background-task ownership hook. Tools that produce a TaskManager
-      // task (bash background, agent spawn) call this with the new
-      // `task.id` so the engine keeps the current query parked at end_turn
-      // until the task terminates — its result is then spliced into the
-      // next adapter loop in the SAME turn. Tools that don't produce
-      // async tasks ignore it.
+      // 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
+      // shell tasks are status-only and intentionally do not call this hook.
       registerAsyncTask: (taskId, meta = {}) => {
         const current = typeof vpCtx?.currentToolCall === 'function' ? vpCtx.currentToolCall() : null;
         this.#registerAsyncTask(taskId, { ...(current || {}), ...(meta || {}) });
@@ -1305,11 +1304,9 @@ export class Engine {
         // to. Null when the parent has no stats wired (e.g. tests).
         toolStats: this.#toolStats || null,
         taskManager: this.#taskManager || null,
-        // Propagate the async-task coordinator so sub-agents launched
-        // from this engine register their background tasks against the
-        // SAME owner map the bridge uses. Without this, a sub-agent's
-        // background bash terminal event would not find its engine and
-        // would fall through to the legacy rescue path.
+        // Propagate the async-task coordinator so sub-agents launched from
+        // this engine register result-producing child tasks against the same
+        // owner map the bridge uses.
         asyncTaskCoordinator: this.#asyncTaskCoordinator || null,
       },
     };
@@ -3199,9 +3196,10 @@ export class Engine {
       }
       // If no tool calls, we're done — UNLESS we still own a pending
-      // async task. The user-facing semantic: a turn that launched a
-      // background bash / sub-agent stays "live" until those tasks
-      // terminate (or the user appends, or abort). The model already
+      // result-producing async task. Persistent shell tasks never register
+      // here; they remain visible in TaskManager without holding this turn.
+      // Registered tasks stay live until they terminate (or the user appends,
+      // or abort). The model already
       // said end_turn; we just defer finalization by parking on the
       // wait queue, then splice the synthetic task-result message in
       // and run one more adapter loop. This matches the contract the
@@ -4166,8 +4164,8 @@ export class Engine {
   }
   /**
-   * Register a background task as belonging to the current query. Called
-   * from tools (bash background, agent spawn) via `toolCtx.registerAsyncTask`.
+   * Register a result-producing async task as belonging to the current query.
+   * Called by tools such as SpawnAgent via `toolCtx.registerAsyncTask`.
    * @param {string} taskId
    * @param {{ id?: string, name?: string, threadId?: string, toolCallId?: string, toolName?: string }} [meta]
    * @returns {void}

package/yeaft/sub-agent/runner.js CHANGED Viewed

@@ -157,9 +157,9 @@ export function startSubAgent(agent, deps = {}) {
     toolStats: deps.toolStats || null,
     taskManager: deps.taskManager || null,
   });
-  // Same-turn async-task plumbing: inherit the parent's coordinator so a
-  // background bash launched FROM this sub-agent registers itself against
-  // the shared owner map and its terminal event reaches the sub-engine.
+  // 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);
   }

package/yeaft/tasks/manager.js CHANGED Viewed

@@ -6,7 +6,14 @@
  */
 import { randomUUID } from 'crypto';
-import { TaskStore, TASK_STATUS, isTerminalTaskStatus } from './store.js';
+import {
+  TaskStore,
+  TASK_RESULT_DELIVERY,
+  TASK_STATUS,
+  isTerminalTaskStatus,
+  normalizeTaskResultDelivery,
+  taskResultDeliveryFor,
+} from './store.js';
 import { startShellProcess } from './shell-runner.js';
 import { getRuntimePlatformInfo } from '../runtime-platform.js';
@@ -35,6 +42,7 @@ function publicSnapshot(task) {
     kind: task.kind,
     title: task.title,
     status: task.status,
+    resultDelivery: taskResultDeliveryFor(task),
     createdAt: task.createdAt,
     startedAt: task.startedAt,
     updatedAt: task.updatedAt,
@@ -63,20 +71,35 @@ export class TaskManager {
     this.active = new Map();
     this.processes = new Map();
     this.cancelEscalationTimers = new Map();
+    this.pendingStartupEvents = [];
     this.#loadPersistedRunningTasks();
   }
   setEventSink(onEvent) {
-    this.onEvent = typeof onEvent === 'function' ? onEvent : null;
+    const sink = typeof onEvent === 'function' ? onEvent : null;
+    this.onEvent = sink;
+    if (!sink || this.pendingStartupEvents.length === 0) return;
+    const pending = this.pendingStartupEvents;
+    this.pendingStartupEvents = [];
+    for (const event of pending) this.#deliverEvent(event, sink);
   }
   #key(sessionId, taskId) {
     return `${sessionId || 'default'}::${taskId}`;
   }
-  #emit(event, task, extra = {}) {
+  #deliverEvent(event, sink = this.onEvent) {
+    try { sink?.(event); } catch { /* event sinks must not break tasks */ }
+  }
+  #emit(event, task, extra = {}, { deferUntilSink = false } = {}) {
     const payload = { type: 'yeaft_task_event', event, task: publicSnapshot(task), ...extra };
-    try { this.onEvent?.(payload); } catch { /* event sinks must not break tasks */ }
+    if (!this.onEvent && deferUntilSink) {
+      this.pendingStartupEvents.push(payload);
+      return;
+    }
+    this.#deliverEvent(payload);
   }
   #loadPersistedRunningTasks() {
@@ -93,13 +116,17 @@ export class TaskManager {
       };
       this.store.writeTask(orphaned);
       this.store.appendEvent(orphaned.sessionId, { event: 'orphaned', taskId: orphaned.id });
-      this.#emit('completed', orphaned);
+      this.#emit('completed', orphaned, {}, { deferUntilSink: true });
     }
   }
-  startTask({ sessionId, ownerVpId = null, kind = 'tool', title = '', runtime = {}, source = {}, logPath = null } = {}) {
+  startTask({ sessionId, ownerVpId = null, kind = 'tool', title = '', runtime = {}, source = {}, logPath = null, resultDelivery = TASK_RESULT_DELIVERY.STATUS_ONLY } = {}) {
     const taskId = makeTaskId();
     const resolvedSessionId = sessionId || 'default';
+    const normalizedResultDelivery = normalizeTaskResultDelivery(resultDelivery);
+    if (normalizedResultDelivery !== resultDelivery) {
+      console.warn(`[Yeaft] Invalid task resultDelivery ${String(resultDelivery)}; using ${TASK_RESULT_DELIVERY.STATUS_ONLY}.`);
+    }
     const task = {
       id: taskId,
       sessionId: resolvedSessionId,
@@ -107,6 +134,7 @@ export class TaskManager {
       kind,
       title: title || kind,
       status: TASK_STATUS.RUNNING,
+      resultDelivery: normalizedResultDelivery,
       createdAt: nowIso(),
       startedAt: nowIso(),
       updatedAt: nowIso(),
@@ -140,6 +168,7 @@ export class TaskManager {
       kind: 'shell',
       title: title || command.slice(0, 120),
       status: TASK_STATUS.RUNNING,
+      resultDelivery: TASK_RESULT_DELIVERY.STATUS_ONLY,
       createdAt: nowIso(),
       startedAt: nowIso(),
       updatedAt: nowIso(),

package/yeaft/tasks/store.js CHANGED Viewed

@@ -27,6 +27,35 @@ export const TASK_STATUS = Object.freeze({
   ORPHANED: 'orphaned',
 });
+export const TASK_RESULT_DELIVERY = Object.freeze({
+  MODEL_REENTRY: 'model_reentry',
+  STATUS_ONLY: 'status_only',
+});
+export function normalizeTaskResultDelivery(value) {
+  if (value === TASK_RESULT_DELIVERY.MODEL_REENTRY || value === TASK_RESULT_DELIVERY.STATUS_ONLY) {
+    return value;
+  }
+  return TASK_RESULT_DELIVERY.STATUS_ONLY;
+}
+export function taskResultDeliveryFor(task) {
+  return normalizeTaskResultDelivery(task?.resultDelivery);
+}
+function normalizePersistedTask(task) {
+  if (!task || typeof task !== 'object') return task;
+  if (Object.prototype.hasOwnProperty.call(task, 'resultDelivery')) {
+    return { ...task, resultDelivery: normalizeTaskResultDelivery(task.resultDelivery) };
+  }
+  return {
+    ...task,
+    resultDelivery: task.kind === 'sub_agent'
+      ? TASK_RESULT_DELIVERY.MODEL_REENTRY
+      : TASK_RESULT_DELIVERY.STATUS_ONLY,
+  };
+}
 const TERMINAL = new Set([
   TASK_STATUS.SUCCEEDED,
   TASK_STATUS.FAILED,
@@ -133,7 +162,7 @@ export class TaskStore {
   readTask(sessionId, taskId) {
     const path = this.taskPath(sessionId, taskId);
     if (!existsSync(path)) return null;
-    return JSON.parse(readFileSync(path, 'utf8'));
+    return normalizePersistedTask(JSON.parse(readFileSync(path, 'utf8')));
   }
   loadActiveTasks() {
@@ -145,7 +174,7 @@ export class TaskStore {
       for (const entry of readdirSync(sessionDir, { withFileTypes: true })) {
         if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
         try {
-          const task = JSON.parse(readFileSync(join(sessionDir, entry.name), 'utf8'));
+          const task = normalizePersistedTask(JSON.parse(readFileSync(join(sessionDir, entry.name), 'utf8')));
           if (task && task.status === TASK_STATUS.RUNNING) out.push(task);
         } catch {
           // Ignore corrupt task metadata; one bad task must not block boot.

package/yeaft/tools/agent.js CHANGED Viewed

@@ -26,6 +26,7 @@ import { getPersona, listPersonaIds } from '../personas.js';
 import { startSubAgent } from '../sub-agent/runner.js';
 import { STATUS, isTerminalAgentStatus } from '../sub-agent/status.js';
 import { diagnoseAgentLiveness, makeLiveness } from '../sub-agent/liveness.js';
+import { TASK_RESULT_DELIVERY } from '../tasks/store.js';
 /** In-memory sub-agent registry. */
 const agents = new Map();
@@ -424,6 +425,7 @@ use it as the default workflow or call it repeatedly in a loop.`,
           ownerVpId: callerScope.parentVpId || ctx?.currentVpId || null,
           kind: 'sub_agent',
           title: spec.mission || spec.task || name,
+          resultDelivery: TASK_RESULT_DELIVERY.MODEL_REENTRY,
           runtime: { subAgentId: agentId, name, cwd: agent.cwd },
           source: { threadId: callerScope.parentThreadId || ctx?.threadId || 'main' },
         });

package/yeaft/tools/bash.js CHANGED Viewed

@@ -255,14 +255,7 @@ Guidelines:
             threadId: ctx.threadId || 'main',
           },
         });
-        // Same-turn parking: tell the engine "this turn has an async
-        // task in flight". The engine refuses to finalize end_turn
-        // while the set is non-empty and will splice the task result
-        // into the next adapter loop when it terminates. No-op when
-        // the engine didn't wire the hook (legacy callers / tests).
-        const currentToolCall = typeof ctx.currentToolCall === 'function' ? ctx.currentToolCall() : null;
-        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.`;
+        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.`;
       } catch (err) {
         throw new Error(err?.message || String(err));
       }

package/yeaft/web-bridge.js CHANGED Viewed

@@ -76,6 +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';
 const LEGACY_SKILL_COMMAND_PREFIX = 'skill:';
 const YEAFT_SKILL_COMMAND_PREFIX = 'yeaft-skills:';
@@ -1706,10 +1707,9 @@ function getOrCreateVpEngine(sessionId, vpId, threadId = 'main') {
     sessionId,
     vpId,
   });
-  // Install the async-task coordinator so background tasks launched
-  // from this engine register against the shared owner map and
-  // `scheduleTaskResultReentry` can deliver terminal events back into
-  // the same query() instead of opening a fresh turn.
+  // Install the async-task coordinator so result-producing child tasks
+  // register against the shared owner map. Persistent shell tasks are
+  // status-only and never enter this ownership path.
   try {
     if (typeof eng.setAsyncTaskCoordinator === 'function') {
       eng.setAsyncTaskCoordinator(buildAsyncTaskCoordinator());
@@ -1852,6 +1852,7 @@ function scheduleTaskResultRescue({ taskId, sessionId, vpId, threadId = 'main',
 function scheduleTaskResultReentry(event) {
   if (!event || event.event !== 'completed' || !event.task) return;
   const task = event.task;
+  if (taskResultDeliveryFor(task) !== TASK_RESULT_DELIVERY.MODEL_REENTRY) return;
   const sessionId = task.sessionId || event.sessionId || null;
   const vpId = task.ownerVpId || null;
   if (!sessionId || !vpId) return;
@@ -3990,9 +3991,10 @@ function handleEngineEvent(event, hctx) {
       }, envelope);
       break;
-    // Same-turn async-task wait. Engine parks at end_turn while a
-    // background bash / sub-agent is still running and re-enters the
-    // same turn when the terminal event arrives (see engine.js
+    // Same-turn result-producing task wait. Engine parks at end_turn while a
+    // registered child task is still running and re-enters the same turn when
+    // the terminal event arrives. Persistent shell tasks are status-only and
+    // never emit this wait edge (see engine.js
     // `#runQuery` wait block). Bridge forwards both edges so the debug
     // panel (and any other in-process subscriber) can render the park
     // window with the live list of pending taskIds. Wire types stay