@yeaft/webchat-agent 0.1.754 → 0.1.756

package/package.json

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

package/unify/conversation/persist.js

@@ -102,6 +102,11 @@ function serializeMessage(msg) {
   // in the default group and switching back to the originating group
   // shows an empty pane.
   if (msg.groupId) fm.push(`groupId: ${msg.groupId}`);
+  // Group-chat attribution: when a VP authors an assistant turn (either
+  // its own reply or a route_forward injection from another VP), stamp
+  // the speaker so the UI can render the message on the correct VP track.
+  // For real user messages this is unset.
+  if (msg.speakerVpId) fm.push(`speakerVpId: ${msg.speakerVpId}`);
 
   // Token estimate
   const content = msg.content || '';
@@ -173,6 +178,7 @@ export function parseMessage(raw) {
       case 'threadId': msg.threadId = value; break;
       case 'sourceThreadId': msg.sourceThreadId = value; break;
       case 'groupId': msg.groupId = value; break;
+      case 'speakerVpId': msg.speakerVpId = value; break;
       // toolCalls are multi-line YAML — handled separately below
     }
   }

package/unify/groups/coordinator.js

@@ -64,7 +64,20 @@ export function createCoordinator(group, options = {}) {
     const meta = group.getMeta();
     if (!meta) throw new Error('group not initialised (call createGroup first)');
 
-    const fromUser = input.from === 'user' || input.role === 'user';
+    // `fromUser` drives `selectRespondingVps` — when true, the @-mention
+    // matrix runs (mention/broadcast/fallback). When false, VPs cannot
+    // text-@-route (VP-authored free text is surface noise per arch §6).
+    //
+    // route_forward injection is a special case: the message is VP-authored
+    // (role='assistant') but it MUST trigger dispatch (target VP needs to
+    // run). We detect it via `meta.injectedBy === 'route_forward'` and
+    // treat it as "user-like" for dispatch purposes only. Persistence still
+    // honours the caller's `role` field so the on-disk record correctly
+    // attributes the turn to the sending VP, not to the user.
+    const isRouteForwardInjection = input?.meta?.injectedBy === 'route_forward';
+    const fromUser = input.from === 'user'
+      || input.role === 'user'
+      || isRouteForwardInjection;
     const mentions = parseMentions(input.text);
 
     // Persist first — audit log / replay works even if dispatch has bugs.

package/unify/routing/router.js

@@ -125,17 +125,12 @@ export function createRouter(deps = {}) {
     }
 
     // Synthesize an injection message — coordinator's `ingest` expects the
-    // {from, role, text} shape. We set role='user' ONLY because that's the
-    // code path that triggers @-routing; semantically it is a VP-initiated
-    // injection. The `from` field preserves the real sender vpId, and we
-    // stamp meta.synthetic + meta.injectedBy so downstream auditors can
-    // tell it apart from real user input.
-    //
-    // Why not add a third role to Coordinator? Scope discipline: Coordinator
-    // (334b) owns user vs VP branching. A third branch would force edits
-    // across both 334b and 334d for one hop. Setting role='user' with
-    // synthetic meta keeps the Coordinator API frozen — and `from` still
-    // reflects the real author, which is what the guard keys on anyway.
+    // {from, role, text} shape. The forwarded message is semantically the
+    // SENDER VP speaking (just delivered to a different VP's inbox), so it
+    // persists as role='assistant' attributed to `from`. The `meta.injectedBy`
+    // stamp + `synthetic` marker let Coordinator's `selectRespondingVps`
+    // still treat this like a routed turn (target VPs need to respond) even
+    // though role is now 'assistant'.
     const injectText = to === 'all'
       ? `@all ${text}`
       : `@${to} ${text}`;
@@ -143,7 +138,7 @@ export function createRouter(deps = {}) {
     const report = coordinator.ingest(
       {
         from,                  // real VP id — preserved for provenance
-        role: 'user',          // triggers coordinator dispatch path
+        role: 'assistant',     // VP-authored — persists as assistant turn
         text: injectText,
         taskId: args.taskId ?? null,
         meta: {

package/unify/web-bridge.js

@@ -617,10 +617,22 @@ function ensureDriverRunning(groupId, vpId) {
       try {
         const envMsgId = envelope?.msg?.id;
         if (envMsgId && text) {
-          persistUserMessageOnceByMsgId({
+          // route_forward injection: the envelope text was authored by the
+          // sending VP, not the user. Persist as an assistant row attributed
+          // to the sender so history replay puts it on the VP track, not on
+          // the human "user" track. Non-forward envelopes (real user input)
+          // persist as the user row exactly like before.
+          const meta = envelope?.msg?.meta || {};
+          const isForward = meta.injectedBy === 'route_forward';
+          const senderVpId = isForward
+            ? (meta.senderVpId || envelope?.msg?.from || null)
+            : null;
+          persistInboundMessageOnceByMsgId({
             msgId: envMsgId,
             text,
             groupId,
+            role: isForward ? 'assistant' : 'user',
+            speakerVpId: senderVpId,
           });
         }
       } catch { /* never crash WS pipeline */ }
@@ -1685,7 +1697,7 @@ export async function handleUnifyGroupChat(msg) {
   try {
     const persistedMsgId = report?.message?.id;
     if (persistedMsgId) {
-      persistUserMessageOnceByMsgId({
+      persistInboundMessageOnceByMsgId({
         msgId: persistedMsgId,
         text,
         groupId,
@@ -1693,7 +1705,7 @@ export async function handleUnifyGroupChat(msg) {
     }
   } catch (err) {
     console.warn(
-      '[Unify] unify_group_chat: persistUserMessageOnceByMsgId failed',
+      '[Unify] unify_group_chat: persistInboundMessageOnceByMsgId failed',
       err?.message || err,
     );
   }
@@ -2210,11 +2222,13 @@ function appendTurnToGroupHistory(groupId, prompt, assistantTextParts, toolCalls
 }
 
 /**
- * Persist the user row to disk EXACTLY ONCE per coordinator-ingest call,
- * keyed by the coordinator-assigned `msgId`. Both `handleUnifyGroupChat`
- * (real user input) and `enqueueForVp`'s driver loop (route_forward
- * synthetic injections) call this — the Set guard makes either path
- * the writer, whichever runs first, while the other becomes a no-op.
+ * Persist an inbound message row to disk EXACTLY ONCE per
+ * coordinator-ingest call, keyed by the coordinator-assigned `msgId`.
+ * Both `handleUnifyGroupChat` (real user input, persists as
+ * role='user') and `enqueueForVp`'s driver loop (route_forward
+ * synthetic injections, persists as role='assistant' attributed via
+ * `speakerVpId`) call this — the Set guard makes either path the
+ * writer, whichever runs first, while the other becomes a no-op.
  *
  * Without this dedup, a 2-VP group prompt produces TWO `m{NNNN}.md`
  * user rows (one per engine) — `handleUnifyLoadHistory` then replays
@@ -2232,11 +2246,11 @@ function appendTurnToGroupHistory(groupId, prompt, assistantTextParts, toolCalls
  * schema today (the engine never wrote them either) — they live on the
  * coordinator's jsonl-log under group meta.
  *
- * @param {{ msgId:string, text:string, groupId:string }} args
+ * @param {{ msgId:string, text:string, groupId:string, role?:string, speakerVpId?:string|null }} args
  * @returns {boolean} true if this call wrote the row, false if a prior
  *   call already wrote it (dedup hit).
  */
-function persistUserMessageOnceByMsgId({ msgId, text, groupId }) {
+function persistInboundMessageOnceByMsgId({ msgId, text, groupId, role, speakerVpId }) {
   if (!session?.conversationStore) return false;
   // No msgId means no dedup key — caller is responsible for guarding.
   // Both call sites already do (`if (envMsgId && text)` and
@@ -2267,17 +2281,30 @@ function persistUserMessageOnceByMsgId({ msgId, text, groupId }) {
     }
   }
   try {
+    // role defaults to 'user' for back-compat: handleUnifyGroupChat's
+    // real-user call site passes no role and gets a user row. The driver
+    // loop passes role='assistant' + speakerVpId for route_forward
+    // injections so the on-disk record correctly attributes the text to
+    // the sending VP.
+    const persistRole = role === 'assistant' ? 'assistant' : 'user';
     const record = {
-      role: 'user',
+      role: persistRole,
       content: text,
       threadId: 'main',
     };
     if (groupId) record.groupId = groupId;
+    // Stamp speakerVpId so the UI's loadHistory replay can route the row
+    // to the correct VP block. Only meaningful when role='assistant'; for
+    // a real user message we leave it unset (the UI's user track is
+    // unattributed).
+    if (persistRole === 'assistant' && speakerVpId && typeof speakerVpId === 'string') {
+      record.speakerVpId = speakerVpId;
+    }
     session.conversationStore.append(record);
     return true;
   } catch (err) {
     console.warn(
-      '[Unify] persistUserMessageOnceByMsgId failed (non-fatal):',
+      '[Unify] persistInboundMessageOnceByMsgId failed (non-fatal):',
       err?.message || err,
     );
     return false;
@@ -2731,11 +2758,19 @@ export async function handleUnifyLoadHistory(msg) {
     if (m.role === 'user') {
       sendUnifyOutput({ type: 'user', message: { content: m.content } }, { groupId: m.groupId || null });
     } else if (m.role === 'assistant') {
+      // speakerVpId rides on the envelope so the frontend can route this
+      // replayed assistant text to the correct VP track. Without it, the
+      // history replay would merge replies from different VPs onto one
+      // anonymous assistant turn.
+      const envelopeOpts = {
+        groupId: m.groupId || null,
+      };
+      if (m.speakerVpId) envelopeOpts.vpId = m.speakerVpId;
       sendUnifyOutput({
         type: 'assistant',
         message: { content: [{ type: 'text', text: m.content }] },
-      }, { groupId: m.groupId || null });
-      sendUnifyOutput({ type: 'result', result_text: '' }, { groupId: m.groupId || null });
+      }, envelopeOpts);
+      sendUnifyOutput({ type: 'result', result_text: '' }, envelopeOpts);
     }
   }