@yeaft/webchat-agent 0.1.530 → 0.1.531

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 } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -420,6 +420,22 @@ export async function handleMessage(msg) {
       handleUnifyVpRead(msg);
       break;
 
+    // task-334h (R6 §Δ28 / §Δ31.6): task-scoped direct message echo.
+    // Replaces the withdrawn R3 `unify_task_private_chat`. Agent validates,
+    // stamps msgId + ts, and broadcasts the `task_message` mirror back.
+    case 'unify_task_message':
+      handleUnifyTaskMessage(msg);
+      break;
+
+    // task-334h (R6 §Δ29): user-memory skeleton. Payload schema + event
+    // names are wire-frozen here; real ingestion lands in task-334l.
+    case 'unify_user_memory_write':
+      handleUnifyUserMemoryWrite(msg);
+      break;
+    case 'unify_user_memory_remove':
+      handleUnifyUserMemoryRemove(msg);
+      break;
+
     // Expert roles definition (for ExpertPanel detail view)
     case 'get_expert_roles': {
       const { getExpertRolesDefinition } = await import('../expert-roles.js');

package/package.json

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

package/unify/task-message.js

@@ -0,0 +1,144 @@
+/**
+ * task-message.js — R6 §Δ28 / §Δ31.6 task-scoped direct messaging.
+ *
+ * Replaces the withdrawn R3 `unify_task_private_chat` event with a simple
+ * echo-able `task_message` pair:
+ *
+ *   inbound  (web → agent):  `unify_task_message`
+ *     { type, groupId, taskId, vpId, text, mentions?, replyTo?, requestId? }
+ *   outbound (agent → web):  `task_message`
+ *     { type, groupId, taskId, vpId, msgId, text, mentions, replyTo,
+ *       ts, requestId? }
+ *
+ * This module owns only the *wire adapter* — the payload is validated,
+ * stamped with msgId + ts, and broadcast back so the sender's UI and any
+ * other connected views converge on the same record. Persistence + task
+ * ACL enforcement are deliberately deferred to task-334l (per PM dispatch:
+ * "user_memory_* 实际 ingestion 归 334l"); the parallel task-private
+ * storage hook follows the same phasing.
+ *
+ * Invariants:
+ *   • Never throws on the WS hot path — bad payloads reply with a
+ *     `task_message_rejected` event carrying a stable `code` string for
+ *     UI i18n (mirrors the vp_crud_result contract from 334-ui-g).
+ *   • The outbound event field order and keys are considered wire-frozen
+ *     per R6 §Δ31.6 table; additive fields only in future slices.
+ */
+
+import { nextMsgId, isValidVpId } from './groups/ids.js';
+
+/** Known `reject` codes — kept stable so 334-ui-* can key i18n on them. */
+export const TASK_MESSAGE_REJECT_CODES = Object.freeze({
+  MISSING_GROUP_ID: 'missing_group_id',
+  MISSING_TASK_ID: 'missing_task_id',
+  MISSING_VP_ID: 'missing_vp_id',
+  INVALID_VP_ID: 'invalid_vp_id',
+  EMPTY_TEXT: 'empty_text',
+  TEXT_TOO_LONG: 'text_too_long',
+});
+
+/** Soft body cap — matches the shard-entry cap used elsewhere in R6 (§Δ26.3). */
+export const MAX_TEXT_LENGTH = 16_384;
+
+/**
+ * Pure validator. Returns `{ ok: true, payload }` or `{ ok: false, code }`.
+ * No IO, no clock reads — safe to unit-test in isolation.
+ *
+ * @param {any} msg — raw WS message from the web client
+ */
+export function validateTaskMessage(msg) {
+  if (!msg || typeof msg !== 'object') {
+    return { ok: false, code: TASK_MESSAGE_REJECT_CODES.MISSING_GROUP_ID };
+  }
+  const { groupId, taskId, vpId, text } = msg;
+  if (!groupId || typeof groupId !== 'string') {
+    return { ok: false, code: TASK_MESSAGE_REJECT_CODES.MISSING_GROUP_ID };
+  }
+  if (!taskId || typeof taskId !== 'string') {
+    return { ok: false, code: TASK_MESSAGE_REJECT_CODES.MISSING_TASK_ID };
+  }
+  if (!vpId || typeof vpId !== 'string') {
+    return { ok: false, code: TASK_MESSAGE_REJECT_CODES.MISSING_VP_ID };
+  }
+  // Allow the reserved `user` sentinel as a speaker here — tasks can have
+  // human-user messages alongside VP messages. Any other vpId must pass
+  // the full shape check (rejects `all`, `system`, pure digits, etc.).
+  if (vpId !== 'user' && !isValidVpId(vpId)) {
+    return { ok: false, code: TASK_MESSAGE_REJECT_CODES.INVALID_VP_ID };
+  }
+  if (typeof text !== 'string' || text.length === 0) {
+    return { ok: false, code: TASK_MESSAGE_REJECT_CODES.EMPTY_TEXT };
+  }
+  if (text.length > MAX_TEXT_LENGTH) {
+    return { ok: false, code: TASK_MESSAGE_REJECT_CODES.TEXT_TOO_LONG };
+  }
+
+  const mentions = Array.isArray(msg.mentions)
+    ? msg.mentions.filter(m => typeof m === 'string' && m.length > 0).slice(0, 32)
+    : [];
+  const replyTo = typeof msg.replyTo === 'string' && msg.replyTo.length > 0
+    ? msg.replyTo
+    : null;
+
+  return {
+    ok: true,
+    payload: { groupId, taskId, vpId, text, mentions, replyTo },
+  };
+}
+
+/**
+ * Build the outbound `task_message` event from a validated payload.
+ * Exposed separately so tests can snapshot the wire shape without
+ * needing a live send fn.
+ *
+ * @param {{groupId:string,taskId:string,vpId:string,text:string,mentions:string[],replyTo:?string}} payload
+ * @param {{now?:()=>number, msgId?:()=>string, requestId?:string}} [opts]
+ */
+export function buildTaskMessageEvent(payload, opts = {}) {
+  const now = typeof opts.now === 'function' ? opts.now : Date.now;
+  const mkId = typeof opts.msgId === 'function' ? opts.msgId : nextMsgId;
+  const evt = {
+    type: 'task_message',
+    groupId: payload.groupId,
+    taskId: payload.taskId,
+    vpId: payload.vpId,
+    msgId: mkId(),
+    text: payload.text,
+    mentions: payload.mentions,
+    replyTo: payload.replyTo,
+    ts: now(),
+  };
+  if (opts.requestId) evt.requestId = opts.requestId;
+  return evt;
+}
+
+/**
+ * Build the outbound `task_message_rejected` event.
+ * @param {string} code — one of TASK_MESSAGE_REJECT_CODES
+ * @param {any} msg — original inbound msg (for requestId echo)
+ */
+export function buildTaskMessageRejected(code, msg) {
+  const evt = { type: 'task_message_rejected', code };
+  if (msg && typeof msg.requestId === 'string') evt.requestId = msg.requestId;
+  if (msg && typeof msg.groupId === 'string') evt.groupId = msg.groupId;
+  if (msg && typeof msg.taskId === 'string') evt.taskId = msg.taskId;
+  return evt;
+}
+
+/**
+ * WS handler entry point. Validates, echoes, never throws.
+ *
+ * @param {any} msg
+ * @param {(event:object)=>void} sendUnifyEvent
+ * @param {{now?:()=>number, msgId?:()=>string}} [opts] — test seams
+ */
+export function handleUnifyTaskMessage(msg, sendUnifyEvent, opts = {}) {
+  const result = validateTaskMessage(msg);
+  if (!result.ok) {
+    try { sendUnifyEvent(buildTaskMessageRejected(result.code, msg)); } catch { /* best-effort */ }
+    return;
+  }
+  const requestId = msg && typeof msg.requestId === 'string' ? msg.requestId : undefined;
+  const evt = buildTaskMessageEvent(result.payload, { ...opts, requestId });
+  try { sendUnifyEvent(evt); } catch { /* never crash WS pipeline */ }
+}

package/unify/user-memory.js

@@ -0,0 +1,104 @@
+/**
+ * user-memory.js — R6 §Δ29 user-memory WS event skeleton.
+ *
+ * PLACEHOLDER ONLY. Actual ingestion / shard write / cross-task recall
+ * is owned by task-334l. This file reserves three event names on the
+ * wire + acknowledges the request so the web client can ship its
+ * emitter code without a dependency-cycle on 334l's storage layer.
+ *
+ * Wire shapes (frozen by R6 §Δ31.6 table; additive fields only):
+ *
+ *   inbound  (web → agent):  `unify_user_memory_write`
+ *     { type, text, tags?, sourceRef?, requestId? }
+ *
+ *   outbound (agent → web):  `user_memory_updated`
+ *     { type, entryId?, reason: 'accepted'|'deferred'|'noop',
+ *       requestId?, pending?: boolean }
+ *
+ *   outbound (agent → web):  `user_memory_removed`
+ *     { type, entryId, requestId? }
+ *
+ * Current behaviour: every write is replied with `user_memory_updated`
+ * carrying `reason: 'deferred'` and `pending: true` — the frontend
+ * treats this as "queued but not yet persisted" and keeps the toast in
+ * a muted state. 334l will flip the reason to `'accepted'` with a
+ * concrete `entryId` once the ingestion pipeline lands.
+ *
+ * No removal path is offered yet (would require the storage layer to
+ * have produced entryIds first); the handler is exported as a named
+ * stub so the router can wire it without a second edit when 334l ships.
+ */
+
+/** @type {(event:object)=>void | null} */
+let _sendUnifyEvent = null;
+
+/**
+ * Install a send fn. Called once during session init from web-bridge.js.
+ * Exposed so tests can swap in a collector without spinning up a session.
+ */
+export function setUserMemorySender(fn) {
+  _sendUnifyEvent = (typeof fn === 'function') ? fn : null;
+}
+
+/**
+ * WS handler: `unify_user_memory_write`.
+ *
+ * Validates the minimum shape (non-empty string `text`) and replies with
+ * a `user_memory_updated` ack carrying `pending: true`. Never throws.
+ *
+ * @param {any} msg
+ * @param {(event:object)=>void} [sendUnifyEvent] — optional override
+ *   (falls back to the module-level sender installed via setUserMemorySender)
+ */
+export function handleUnifyUserMemoryWrite(msg, sendUnifyEvent) {
+  const send = sendUnifyEvent || _sendUnifyEvent;
+  if (!send) return;
+
+  const requestId = msg && typeof msg.requestId === 'string' ? msg.requestId : undefined;
+  const text = msg && typeof msg.text === 'string' ? msg.text : '';
+
+  if (!text || text.length === 0) {
+    try {
+      send({
+        type: 'user_memory_updated',
+        reason: 'noop',
+        pending: false,
+        ...(requestId ? { requestId } : {}),
+      });
+    } catch { /* best-effort */ }
+    return;
+  }
+
+  // Placeholder — 334l replaces this with real ingestion.
+  try {
+    send({
+      type: 'user_memory_updated',
+      reason: 'deferred',
+      pending: true,
+      ...(requestId ? { requestId } : {}),
+    });
+  } catch { /* best-effort */ }
+}
+
+/**
+ * WS handler: `unify_user_memory_remove` (skeleton).
+ *
+ * Until 334l lands we have no entries to remove; reply with a noop
+ * `user_memory_updated` so the UI can clear its toast.
+ */
+export function handleUnifyUserMemoryRemove(msg, sendUnifyEvent) {
+  const send = sendUnifyEvent || _sendUnifyEvent;
+  if (!send) return;
+
+  const requestId = msg && typeof msg.requestId === 'string' ? msg.requestId : undefined;
+  const entryId = msg && typeof msg.entryId === 'string' ? msg.entryId : null;
+
+  try {
+    send({
+      type: 'user_memory_removed',
+      entryId,
+      pending: true, // 334l will flip once real removal lands
+      ...(requestId ? { requestId } : {}),
+    });
+  } catch { /* best-effort */ }
+}

package/unify/web-bridge.js

@@ -28,6 +28,11 @@ import ctx from '../context.js';
 import { getThreadStore, MAIN_THREAD_ID } from './threads/store.js';
 import { handleVpSubscribe } from './vp/vp-bridge.js';
 import { createVp, updateVp, deleteVp, readVp, VpCrudError } from './vp/vp-crud.js';
+import { handleUnifyTaskMessage as _handleUnifyTaskMessage } from './task-message.js';
+import {
+  handleUnifyUserMemoryWrite as _handleUnifyUserMemoryWrite,
+  handleUnifyUserMemoryRemove as _handleUnifyUserMemoryRemove,
+} from './user-memory.js';
 
 /** @type {import('./session.js').Session | null} */
 let session = null;
@@ -198,6 +203,40 @@ export function handleUnifyVpDelete(msg) {
   }
 }
 
+/**
+ * task-334h (R6 §Δ28 / §Δ31.6): task-scoped direct message echo.
+ *
+ * Replaces the withdrawn R3 `unify_task_private_chat`. The agent acts as a
+ * relay: validate → stamp msgId + ts → broadcast `task_message`. Real
+ * persistence + task ACL lands in 334l.
+ *
+ * @param {any} msg
+ */
+export function handleUnifyTaskMessage(msg) {
+  _handleUnifyTaskMessage(msg, sendUnifyEvent);
+}
+
+/**
+ * task-334h (R6 §Δ29): user-memory write skeleton. Replies with a
+ * `user_memory_updated` ack carrying `pending: true`; 334l replaces the
+ * stub with real ingestion + entryId.
+ *
+ * @param {any} msg
+ */
+export function handleUnifyUserMemoryWrite(msg) {
+  _handleUnifyUserMemoryWrite(msg, sendUnifyEvent);
+}
+
+/**
+ * task-334h (R6 §Δ29): user-memory remove skeleton. Replies with
+ * `user_memory_removed` ack; 334l replaces the stub.
+ *
+ * @param {any} msg
+ */
+export function handleUnifyUserMemoryRemove(msg) {
+  _handleUnifyUserMemoryRemove(msg, sendUnifyEvent);
+}
+
 export function handleUnifyVpRead(msg) {
   const requestId = msg && msg.requestId;
   const vpId = msg && msg.vpId;