@yeaft/webchat-agent 0.1.716 → 0.1.718

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.716",
+  "version": "0.1.718",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/engine.js

@@ -219,6 +219,27 @@ export class Engine {
   /** @type {((agentId: string, evt: object) => void) | null} */
   #subAgentEventSink = null;
 
+  /**
+   * PR-4 — current-featureId accessor.
+   *
+   * The feature arc lives in the per-VP web-bridge (`runVpTurn` creates
+   * one per turn) so the engine itself does NOT own the featureId. To
+   * let sub-agents inherit their parent's featureId without coupling the
+   * engine to FeatureArc, the bridge plugs in a thin accessor right
+   * after creating the arc — `engine.setCurrentFeatureIdAccessor(() =>
+   * arc.getFeatureId() || null)`. The engine surfaces the result via
+   * `parentEngineDeps.getCurrentFeatureId` (read lazily at sub-agent
+   * event-emit time, so a feature that opens mid-turn still tags the
+   * sub-agent's later events).
+   *
+   * The accessor is cleared (set to null) by the bridge in the same
+   * `finally` block that clears the per-turn AbortController, so a
+   * stale arc reference can't leak into the next turn.
+   *
+   * @type {(() => (string|null)) | null}
+   */
+  #currentFeatureIdAccessor = null;
+
   /**
    * task-325a — abort state.
    *
@@ -716,6 +737,13 @@ export class Engine {
         parentVpPersona: vpCtx?.vpPersona || null,
         onEvent: this.#subAgentEventSink || null,
         language: this.#config?.language || 'en',
+        // PR-4: lazy accessor so the sub-agent runner can stamp the
+        // parent's active featureId on every forwarded event. Read at
+        // emit-time (NOT at spawn-time) so a feature that opens AFTER
+        // the sub-agent starts still tags later events.
+        getCurrentFeatureId: () => {
+          try { return this.#currentFeatureIdAccessor?.() || null; } catch { return null; }
+        },
       },
     };
   }
@@ -732,6 +760,36 @@ export class Engine {
     this.#subAgentEventSink = typeof sink === 'function' ? sink : null;
   }
 
+  /**
+   * PR-4 — install / clear the per-turn current-featureId accessor.
+   *
+   * Called by `runVpTurn` in web-bridge.js: right after `arc =
+   * createFeatureArc(...)` it passes `() => arc.getFeatureId() || null`,
+   * and clears it (passes null) in the `finally` so a stale arc
+   * reference can't leak into the next turn. The engine reads it
+   * lazily via `parentEngineDeps.getCurrentFeatureId` so sub-agents
+   * inherit whatever featureId is live at the moment they emit.
+   *
+   * Concurrency note: callers are expected to serialize per-VP turns
+   * (web-bridge does — `runVpTurn` runs one turn at a time per VP and
+   * its `finally` clears the accessor before the next turn lands).
+   * If two installs collide (which today would be a bug, not by
+   * design), we warn so it's visible in logs.
+   *
+   * @param {(() => (string|null)) | null} fn
+   */
+  setCurrentFeatureIdAccessor(fn) {
+    const next = typeof fn === 'function' ? fn : null;
+    if (next && this.#currentFeatureIdAccessor) {
+      // Canary: a prior accessor is still installed when we're about
+      // to overwrite it. Today's lifecycle (per-turn install + finally
+      // clear) means this should never fire; if it does, two turns
+      // are racing on the same engine.
+      console.warn('[Engine] setCurrentFeatureIdAccessor: overwriting non-null accessor — concurrent turns on the same VP engine?');
+    }
+    this.#currentFeatureIdAccessor = next;
+  }
+
   /**
    * Perform memory recall for a given prompt.
    *

package/unify/sub-agent/runner.js

@@ -181,6 +181,25 @@ export function startSubAgent(agent, deps = {}) {
  */
 async function driveSubAgent(agent, subEngine, vpPersona, deps) {
   const onEvent = typeof deps.onEvent === 'function' ? deps.onEvent : null;
+  // PR-4: lazy parent-feature lookup. The parent's web-bridge installs
+  // an accessor on its engine right after creating the per-turn arc;
+  // that accessor flows here as `deps.getCurrentFeatureId`. We read it
+  // at every emit (NOT once at spawn-time) so a feature that opens AFTER
+  // the sub-agent starts still tags later events. Returns null when the
+  // parent is not in a feature run, in which case we leave `featureId`
+  // unset on the forwarded event (NOT explicitly null) so the frontend
+  // sub-agent card renders in its anchor-based fallback position.
+  const getParentFeatureId = (typeof deps.getCurrentFeatureId === 'function')
+    ? deps.getCurrentFeatureId
+    : null;
+  const wrapEvt = (evt) => {
+    const base = { ...evt, agentId: agent.id, agentName: agent.name };
+    if (!getParentFeatureId) return base;
+    let fid = null;
+    try { fid = getParentFeatureId(); } catch { fid = null; }
+    if (fid && !base.featureId) base.featureId = fid;
+    return base;
+  };
 
   // Helper: append a user message and either start or resume.
   const dequeueNextUserPrompt = () => {
@@ -197,7 +216,7 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
 
   agent.status = 'running';
   if (onEvent) {
-    try { onEvent(agent.id, { type: 'sub_agent_status', agentId: agent.id, agentName: agent.name, status: 'running' }); } catch { /* ignore */ }
+    try { onEvent(agent.id, wrapEvt({ type: 'sub_agent_status', status: 'running' })); } catch { /* ignore */ }
   }
 
   while (agent.status !== 'closed' && agent.status !== 'completed' && agent.status !== 'failed') {
@@ -206,7 +225,7 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
       // Nothing to do — go idle and wait for SendMessage / CloseAgent.
       agent.status = 'idle';
       if (onEvent) {
-        try { onEvent(agent.id, { type: 'sub_agent_status', agentId: agent.id, status: 'idle' }); } catch { /* ignore */ }
+        try { onEvent(agent.id, wrapEvt({ type: 'sub_agent_status', status: 'idle' })); } catch { /* ignore */ }
       }
       await waitUntilResumed(agent);
       // Either we have a new prompt now (back to running) or status is closed.
@@ -231,7 +250,7 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
         // the agent identity attached. Frontend renders these inside
         // the sub-agent's collapsed card.
         if (onEvent) {
-          try { onEvent(agent.id, { ...evt, agentId: agent.id, agentName: agent.name }); } catch { /* ignore listener errors */ }
+          try { onEvent(agent.id, wrapEvt(evt)); } catch { /* ignore listener errors */ }
         }
         if (evt && evt.type === 'text_delta' && typeof evt.text === 'string') {
           assistantText += evt.text;
@@ -250,7 +269,7 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
       agent.error = err && err.message ? err.message : String(err);
       agent.diagnostics.push({ type: 'query_error', error: agent.error, at: Date.now() });
       if (onEvent) {
-        try { onEvent(agent.id, { type: 'sub_agent_status', agentId: agent.id, status: 'failed', error: agent.error }); } catch { /* ignore */ }
+        try { onEvent(agent.id, wrapEvt({ type: 'sub_agent_status', status: 'failed', error: agent.error })); } catch { /* ignore */ }
       }
       return;
     }
@@ -262,7 +281,7 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
       agent.error = streamError;
       agent.diagnostics.push({ type: 'stream_error', error: streamError, at: Date.now() });
       if (onEvent) {
-        try { onEvent(agent.id, { type: 'sub_agent_status', agentId: agent.id, status: 'failed', error: streamError }); } catch { /* ignore */ }
+        try { onEvent(agent.id, wrapEvt({ type: 'sub_agent_status', status: 'failed', error: streamError })); } catch { /* ignore */ }
       }
       return;
     }
@@ -281,7 +300,7 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
       agent.status = 'failed';
       agent.error = agent.error || 'sub-agent stream ended without end_turn';
       if (onEvent) {
-        try { onEvent(agent.id, { type: 'sub_agent_status', agentId: agent.id, status: 'failed', error: agent.error }); } catch { /* ignore */ }
+        try { onEvent(agent.id, wrapEvt({ type: 'sub_agent_status', status: 'failed', error: agent.error })); } catch { /* ignore */ }
       }
       return;
     }
@@ -291,7 +310,7 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
     // by SendMessage, run the next; else go idle.
     agent.result = assistantText;
     if (onEvent) {
-      try { onEvent(agent.id, { type: 'sub_agent_turn_end', agentId: agent.id, agentName: agent.name, content: assistantText }); } catch { /* ignore */ }
+      try { onEvent(agent.id, wrapEvt({ type: 'sub_agent_turn_end', content: assistantText })); } catch { /* ignore */ }
     }
   }
 }

package/unify/web-bridge.js

@@ -1615,6 +1615,13 @@ async function runVpTurn({ prompt, groupId, vpId, turnId, envelope: inboundEnvel
       const assistantTextParts = [];
       const toolCallsAccum = [];
       const toolResultsAccum = [];
+      // PR-4 (review fix): hoist `vpEngine` so the `finally` can clear
+      // the per-turn featureId accessor on the SAME engine instance
+      // we installed it on — even if the VP was kicked or its group
+      // deleted mid-turn (both code paths call `vpEngines.delete(...)`).
+      // Calling `getOrCreateVpEngine` again from `finally` would
+      // resurrect a zombie engine for a VP that no longer exists.
+      let vpEngine = null;
 
       // task-707: per-VP engine + persistent group coord. The coord is
       // created in handleUnifyGroupChat via getOrCreateGroupContext and
@@ -1686,6 +1693,19 @@ async function runVpTurn({ prompt, groupId, vpId, turnId, envelope: inboundEnvel
       // ready; the main engine loop must not be held back waiting for it.
       arc.startTrackA();
 
+      // PR-4: let sub-agents spawned during this turn inherit the
+      // parent's active featureId. Read lazily inside the engine's
+      // parentEngineDeps so a feature that opens AFTER a sub-agent
+      // spawns still tags the sub-agent's later events. Cleared in the
+      // `finally` below so a stale `arc` reference doesn't leak into
+      // the next turn.
+      vpEngine = getOrCreateVpEngine(groupId, vpId);
+      if (typeof vpEngine.setCurrentFeatureIdAccessor === 'function') {
+        vpEngine.setCurrentFeatureIdAccessor(() => {
+          try { return arc?.getFeatureId?.() || null; } catch { return null; }
+        });
+      }
+
       const handlerCtx = {
         assistantTextParts,
         toolCallsAccum,
@@ -1705,7 +1725,6 @@ async function runVpTurn({ prompt, groupId, vpId, turnId, envelope: inboundEnvel
       const trimmedMessages = trimSnapshotForBudget(baseSnapshot, {
         messageTokenBudget: session?.config?.messageTokenBudget,
       });
-      const vpEngine = getOrCreateVpEngine(groupId, vpId);
       for await (const event of vpEngine.query({
         prompt,
         messages: trimmedMessages,
@@ -1743,6 +1762,18 @@ async function runVpTurn({ prompt, groupId, vpId, turnId, envelope: inboundEnvel
       }, envelope);
     } finally {
       if (queryTimer) clearTimeout(queryTimer);
+      // PR-4 (review fix): clear the accessor on the SAME engine
+      // instance we installed it on. Reusing the captured reference
+      // (instead of calling getOrCreateVpEngine again) avoids
+      // resurrecting a zombie engine if the VP/group was torn down
+      // mid-turn. `vpEngine` is null only when the install path threw
+      // before the engine lookup (very early failure) — in that case
+      // there's nothing to clear.
+      try {
+        if (vpEngine && typeof vpEngine.setCurrentFeatureIdAccessor === 'function') {
+          vpEngine.setCurrentFeatureIdAccessor(null);
+        }
+      } catch { /* best-effort */ }
     }
   } catch (err) {
     const isAbort = err && (err.name === 'AbortError' || err.name === 'LLMAbortError');