@yeaft/webchat-agent 0.1.554 → 0.1.556

package/connection/message-router.js

@@ -36,7 +36,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings } from '../unify/config-api.js';
-import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyArchiveGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyArchiveGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -360,6 +360,11 @@ export async function handleMessage(msg) {
       await handleUnifyChat(msg);
       break;
 
+    // task-338-F4: Unify group-chat dispatch via GroupCoordinator.
+    case 'unify_group_chat':
+      await handleUnifyGroupChat(msg);
+      break;
+
     case 'unify_load_history':
       await handleUnifyLoadHistory(msg);
       break;

package/package.json

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

package/unify/vp/vp-bridge.js

@@ -145,7 +145,7 @@ function _fanout(evt) {
 }
 
 function ensureLoader(registry = defaultRegistry) {
-  if (_loaderStarted) return _loader;
+  if (_loaderStarted) return { loader: _loader, fresh: false };
   _loaderStarted = true;
   try {
     _loader = new VpLoader({
@@ -158,7 +158,7 @@ function ensureLoader(registry = defaultRegistry) {
     // Hot-reload optional; subscribe still returns whatever scan loaded.
     _loader = null;
   }
-  return _loader;
+  return { loader: _loader, fresh: true };
 }
 
 /**
@@ -209,7 +209,19 @@ export function buildVpSnapshot(registry = defaultRegistry) {
  * @returns {() => void} unsubscribe fn
  */
 export function handleVpSubscribe(sendUnifyEvent, registry = defaultRegistry) {
-  ensureLoader(registry);
+  const { loader, fresh } = ensureLoader(registry);
+  // task-338-F2: replay semantics. The loader's own start() already scans
+  // on first creation, so on a `fresh` loader we skip the extra rescan (it
+  // would be redundant work and, more importantly, tests that seed the
+  // registry BEFORE subscribing would see their seeded entries wiped by
+  // a rescan against an unrelated DEFAULT_VP_LIB_DIR). On subsequent
+  // subscribes (page reload, reconnect, second web client), rescanNow()
+  // refreshes the registry so every client gets a snapshot that reflects
+  // current disk — catching the case where the FS watcher missed an
+  // event or VPs were added between the initial scan and this subscribe.
+  if (!fresh && loader && typeof loader.rescanNow === 'function') {
+    try { loader.rescanNow(); } catch { /* never crash subscribe on rescan */ }
+  }
   _subscribers.add(sendUnifyEvent);
   try {
     sendUnifyEvent(buildVpSnapshot(registry));

package/unify/web-bridge.js

@@ -940,6 +940,106 @@ function handleEngineEvent(event, threadId, hctx) {
   }
 }
 
+/**
+ * task-338-F4: Handle a unify_group_chat message from the web UI.
+ *
+ * Routes user text through the group coordinator's dispatch contract:
+ *   1. @-mentions → each mentioned vpId (intersected with group roster)
+ *   2. no mention → group.defaultVpId
+ *   3. no default VP → fallback to legacy single-agent handleUnifyChat
+ *
+ * Emits a `group_message` event tagged with `vpId` per dispatched target so
+ * frontend can render VP-scoped feedback. Does NOT itself run the engine —
+ * for each resolved target, it delegates into handleUnifyChat (which owns
+ * the Dispatcher + AbortController + timeout plumbing).
+ *
+ * Message shape: { type:'unify_group_chat', groupId, text, mentions? }
+ *
+ * @param {{groupId:string, text:string, mentions?:string[], agentId?:string, userId?:string, username?:string}} msg
+ */
+export async function handleUnifyGroupChat(msg) {
+  if (!msg || typeof msg !== 'object') return;
+  const { groupId, text } = msg;
+  if (!text?.trim()) return;
+  const mentions = Array.isArray(msg.mentions) ? msg.mentions : [];
+
+  // Resolve the group meta. If the group is missing / not found, fall back
+  // to legacy single-agent behavior so the send never silently drops.
+  let meta = null;
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    if (yeaftDir && groupId) {
+      const { openGroup, loadGroupMeta } = await import('./groups/group-store.js');
+      const { join } = await import('node:path');
+      const { existsSync } = await import('node:fs');
+      const root = join(yeaftDir, 'groups');
+      const dir = join(root, groupId);
+      if (existsSync(dir) && loadGroupMeta(dir)) {
+        const handle = openGroup(root, groupId);
+        meta = handle.getMeta();
+      }
+    }
+  } catch (err) {
+    console.warn('[Unify] unify_group_chat: group resolve failed', err?.message || err);
+  }
+
+  // Resolve target vpIds.
+  const roster = Array.isArray(meta?.roster) ? meta.roster : [];
+  let targets = [];
+  if (mentions.length > 0) {
+    // Intersect mentions with roster. Unknown mentions are ignored (not
+    // dispatched) — coordinator §6 "not_in_roster" semantics.
+    targets = mentions.filter((v) => roster.includes(v));
+  }
+  if (targets.length === 0 && meta?.defaultVpId && roster.includes(meta.defaultVpId)) {
+    targets = [meta.defaultVpId];
+  }
+
+  // Fallback: no target resolvable → behave as the legacy single-agent path
+  // so that the user's text still lands on the Engine.
+  if (targets.length === 0) {
+    await handleUnifyChat({
+      ...msg,
+      prompt: text,
+    });
+    return;
+  }
+
+  // Tag outbound events with vpId so the UI can attribute them per VP. One
+  // `group_message` event per target (mirrors coordinator.deliver() calls).
+  for (const vpId of targets) {
+    try {
+      sendUnifyEvent({
+        type: 'group_message',
+        groupId,
+        vpId,
+        text,
+        mentions,
+        trigger: mentions.includes(vpId) ? 'mention' : 'fallback',
+        ts: Date.now(),
+      });
+    } catch { /* never crash WS pipeline */ }
+  }
+
+  // For each target, dispatch into the engine via handleUnifyChat. We prepend
+  // an `@vp-<id>` tag on the prompt so the Dispatcher can route per-VP when
+  // VP-bound Engine wiring lands (task-338-F2/F5); today handleUnifyChat
+  // still runs a single shared Engine, which preserves legacy behaviour.
+  for (const vpId of targets) {
+    const scoped = `@vp-${vpId} ${text}`;
+    try {
+      await handleUnifyChat({
+        ...msg,
+        prompt: scoped,
+        groupId,
+        vpId,
+      });
+    } catch (err) {
+      console.warn('[Unify] unify_group_chat: per-vp dispatch failed', vpId, err?.message || err);
+    }
+  }
+}
+
 /**
  * Handle a unify_chat message from the web UI.
  *