@yeaft/webchat-agent 0.1.555 → 0.1.557

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.555",
+  "version": "0.1.557",
   "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,132 @@ 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 : [];
+
+  // Fallback path #1 (PM red-line): no groupId on payload → skip group
+  // resolution entirely and hand the text to the legacy single-agent
+  // dispatcher. Ensures backward-compat with old clients that never learned
+  // about groups.
+  if (!groupId) {
+    await handleUnifyChat({ ...msg, prompt: text });
+    return;
+  }
+
+  // Open the group handle (meta + jsonl log). Unresolvable groups take the
+  // legacy fallback — never silently drop the send.
+  let groupHandle = null;
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    if (yeaftDir) {
+      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)) {
+        groupHandle = openGroup(root, groupId);
+      }
+    }
+  } catch (err) {
+    console.warn('[Unify] unify_group_chat: group open failed', err?.message || err);
+  }
+
+  if (!groupHandle) {
+    await handleUnifyChat({ ...msg, prompt: text });
+    return;
+  }
+
+  // Adapter layer (PM red-line: do NOT modify coordinator to fit this
+  // consumer). We drive `createCoordinator()` with a capturing `deliver`
+  // callback, collect its dispatched/fallback report, then translate each
+  // target into (a) a per-VP `group_message` event for the UI and (b) a
+  // per-VP prompt dispatched through the legacy `handleUnifyChat` path.
+  //
+  // Source of truth for mentions is the PAYLOAD (ChatInput parsed them
+  // once). We pass them through the coordinator's `input.meta` so the
+  // appended log carries the authoritative set — the coordinator will also
+  // run its own parse over `text` for routing, which matches the payload by
+  // construction (ChatInput's `parseMentions` is the same regex).
+  const { createCoordinator } = await import('./groups/coordinator.js');
+  const captured = [];
+  const coord = createCoordinator(groupHandle, {
+    deliver: (vpId, envelope) => { captured.push({ vpId, envelope }); },
+  });
+
+  let report;
+  try {
+    report = coord.ingest({
+      from: 'user',
+      role: 'user',
+      text,
+      meta: { mentions },
+    });
+  } catch (err) {
+    console.warn('[Unify] unify_group_chat: coord.ingest failed', err?.message || err);
+    await handleUnifyChat({ ...msg, prompt: text });
+    return;
+  }
+
+  // Fallback path #2: coordinator resolved no targets and no default VP.
+  // Hand off to the legacy single-agent path so the text still runs.
+  const dispatchedIds = Array.isArray(report?.dispatched) ? report.dispatched : [];
+  if (dispatchedIds.length === 0 && !report?.fallback) {
+    await handleUnifyChat({ ...msg, prompt: text });
+    return;
+  }
+
+  // Per target: emit `group_message` tagged with `speakerVpId` (the VP
+  // being addressed — F3's GroupSelector binding consumes this) + dispatch
+  // through the Engine via handleUnifyChat with an `@vp-<id>` prompt prefix.
+  for (const { vpId, envelope } of captured) {
+    try {
+      sendUnifyEvent({
+        type: 'group_message',
+        groupId,
+        vpId,
+        speakerVpId: vpId,
+        text,
+        mentions,
+        trigger: envelope?.trigger || 'fallback',
+        ts: Date.now(),
+      });
+    } catch { /* never crash WS pipeline */ }
+
+    try {
+      await handleUnifyChat({
+        ...msg,
+        prompt: `@vp-${vpId} ${text}`,
+        groupId,
+        vpId,
+        speakerVpId: 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.
  *