@yeaft/webchat-agent 0.1.529 → 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.529",
+  "version": "0.1.531",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/prompts.js

@@ -18,12 +18,37 @@
  *   - Legacy `memory={profile,entries}` param still supported for callers
  *     (tests, CLI) that have not migrated.
  *
+ * task-334e additions (R6 §Δ24.5 / §Δ27.3 / §Δ31.4 / §Δ29.3):
+ *   - `taskCtx` param → renders a `## task_ctx` block with:
+ *       * task-memory top-5 bodies with semantic shard prefix `[shard]`
+ *         (no sourceRef — memory_trace opens the trail on demand)
+ *       * `### related tasks` sub-section — `relatedTaskIds` top-3 (sorted
+ *         by updatedAt desc) + per-task top-2 memory; ACL-gated by
+ *         `target.members` ∋ currentVpId (§Δ31.4)
+ *       * `### summary reminder` soft nudge — condition (§Δ27.3):
+ *           non-summary msgs ≥ 3 AND since-lastSummary > 15min AND
+ *           currentVpId == task.initiatorVpId → emits a DYNAMIC hint
+ *   - `userProfile` param → renders a `## user_profile` block. Stub
+ *     implementation: when not passed explicitly, we fall back to reading
+ *     `~/.yeaft/user/profile.json` ({ "content": "…string…" }) if present
+ *     (§Δ29.3 placeholder until 334l wires real user-memory recall).
+ *   - `coreMemory` param → renders a `## core_memory` block with recall
+ *     top-7 memory bodies (no sourceRef) and a trailing meta line pointing
+ *     at `memory_trace` as the way to open the original message.
+ *
+ * Hard constraints (task-334e contract):
+ *   - Does NOT modify engine.js turn loop.
+ *   - Does NOT implement memory_trace / open_source_message (task-334f).
+ *   - Does NOT implement task_summary_post (task-334n).
+ *   - Changes limited to prompts.js + templates/.
+ *
  * Reference: yeaft-unify-system-prompt-budget.md — Static + Dynamic + Context layers
  */
 
 import { readFileSync, existsSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { homedir } from 'os';
 
 // ─── Template Loading (one-time at startup) ──────────────────────
 
@@ -159,6 +184,14 @@ const PROMPTS = {
     profileHeader: '### User Profile',
     recalledHeader: '### Recalled Memories',
     compactHeader: '## Conversation History Summary',
+    // task-334e — new section headers
+    taskCtxHeader: '## task_ctx',
+    taskCtxRelatedHeader: '### related tasks',
+    taskCtxSummaryReminder: (min, count) =>
+      `💡 ${min}min since last summary (+${count} new messages). Consider calling \`task_summary_post\`.`,
+    userProfileHeader: '## user_profile',
+    coreMemoryHeader: '## core_memory',
+    coreMemoryMeta: 'To open the original message behind any entry above, call `memory_trace`.',
   },
   zh: {
     identity: '你是 Yeaft，一个有用的 AI 助手。',
@@ -169,6 +202,14 @@ const PROMPTS = {
     profileHeader: '### 用户画像',
     recalledHeader: '### 相关记忆',
     compactHeader: '## 对话历史摘要',
+    // task-334e — new section headers
+    taskCtxHeader: '## task_ctx',
+    taskCtxRelatedHeader: '### 相关任务',
+    taskCtxSummaryReminder: (min, count) =>
+      `💡 距上次 summary 已过 ${min}min，新增 ${count} 条消息，建议调用 \`task_summary_post\`。`,
+    userProfileHeader: '## user_profile',
+    coreMemoryHeader: '## core_memory',
+    coreMemoryMeta: '如需原始 message，调 `memory_trace`。',
   },
 };
 
@@ -191,6 +232,35 @@ export const SUPPORTED_LANGUAGES = Object.keys(PROMPTS);
  *   5. Skills section
  *   6. Memory section
  *   7. Compact summary section
+ *   8. Task context section (task-334e §Δ24.5 + §Δ27.3 + §Δ31.4)
+ *   9. User profile section (task-334e §Δ29.3 stub)
+ *  10. Core memory section (task-334e §Δ24.5)
+ *
+ * task-334e params:
+ *   @param {object} [taskCtx] — per-task context
+ *   @param {string} [taskCtx.taskId]
+ *   @param {string} [taskCtx.currentVpId] — used for ACL + initiator check
+ *   @param {string} [taskCtx.initiatorVpId] — task initiator VP id
+ *   @param {Array<{body:string, shard?:string}>} [taskCtx.memories] — task-memory top-5
+ *   @param {Array<{id:string, title?:string, members?:string[], updatedAt?:number,
+ *                  memories?:Array<{body:string, shard?:string}>}>} [taskCtx.relatedTasks]
+ *          — related tasks; we take top-3 by updatedAt desc, top-2 mem each,
+ *            ACL-gated (members must include currentVpId)
+ *   @param {object} [taskCtx.summaryReminder]
+ *   @param {number} [taskCtx.summaryReminder.nonSummaryCount] — msgs since last summary
+ *   @param {number} [taskCtx.summaryReminder.lastSummaryAt] — epoch ms (0/missing = never)
+ *   @param {number} [taskCtx.summaryReminder.now] — override clock (tests), default Date.now()
+ *
+ *   @param {string} [userProfile] — explicit profile content (334l path);
+ *     when omitted we read `~/.yeaft/user/profile.json` `{ content }` as stub.
+ *   @param {{ entries?: Array<{body:string, shard?:string}>, max?: number }} [coreMemory]
+ *     — recalled memory entries; we render top-7 bodies + meta line.
+ *
+ *   @param {boolean} [memoryTraceAvailable=false] — feature flag gating the
+ *     "call memory_trace" meta line in the core_memory block. Defaults to
+ *     false so we don't point VPs at an unimplemented tool (prev-3 Nit-2 /
+ *     PM-approved Option A). 334f will flip this to `true` from session.js
+ *     once `memory_trace` ships; this slice stays decoupled from session.js.
  *
  * @param {{
  *   language?: string,
@@ -200,6 +270,10 @@ export const SUPPORTED_LANGUAGES = Object.keys(PROMPTS);
  *   memoryInjection?: string,
  *   compactSummary?: string,
  *   skillContent?: string,
+ *   taskCtx?: object,
+ *   userProfile?: string,
+ *   coreMemory?: object,
+ *   memoryTraceAvailable?: boolean,
  * }} params
  * @returns {string}
  */
@@ -211,6 +285,10 @@ export function buildSystemPrompt({
   memoryInjection,
   compactSummary,
   skillContent,
+  taskCtx,
+  userProfile,
+  coreMemory,
+  memoryTraceAvailable = false,
 } = {}) {
   // Fallback to English for unknown languages
   const lang = PROMPTS[language] || PROMPTS.en;
@@ -287,5 +365,206 @@ export function buildSystemPrompt({
     parts.push(`${lang.compactHeader}\n${compactSummary}`);
   }
 
+  // ─── 8. Task Context Section (task-334e §Δ24.5 / §Δ27.3 / §Δ31.4) ─
+  const taskCtxBlock = renderTaskCtx(taskCtx, lang);
+  if (taskCtxBlock) parts.push(taskCtxBlock);
+
+  // ─── 9. User Profile Section (task-334e §Δ29.3 stub) ───
+  const profileBlock = renderUserProfile(userProfile, lang);
+  if (profileBlock) parts.push(profileBlock);
+
+  // ─── 10. Core Memory Section (task-334e §Δ24.5) ────────
+  const coreMemBlock = renderCoreMemory(coreMemory, lang, memoryTraceAvailable);
+  if (coreMemBlock) parts.push(coreMemBlock);
+
   return parts.join('\n\n');
 }
+
+// ─── task-334e helpers ───────────────────────────────────────────
+
+const DEFAULT_TASK_MEMORY_TOP = 5;
+const DEFAULT_RELATED_TASK_TOP = 3;
+const DEFAULT_RELATED_TASK_MEMORY_TOP = 2;
+const DEFAULT_CORE_MEMORY_TOP = 7;
+const SUMMARY_REMINDER_MIN_MESSAGES = 3;
+const SUMMARY_REMINDER_MIN_AGE_MS = 15 * 60 * 1000; // 15 minutes
+
+/**
+ * Render `## task_ctx` block. Never throws on malformed input — missing
+ * fields degrade to omission. The block is only emitted when at least one
+ * of { memories, relatedTasks (post-ACL), summaryReminder } has content.
+ */
+function renderTaskCtx(taskCtx, lang) {
+  if (!taskCtx || typeof taskCtx !== 'object') return '';
+
+  const memLines = renderTaskMemories(taskCtx.memories);
+  const relatedLines = renderRelatedTasks(
+    taskCtx.relatedTasks,
+    taskCtx.currentVpId,
+    lang,
+  );
+  const reminderLine = renderSummaryReminder(taskCtx, lang);
+
+  if (!memLines && !relatedLines && !reminderLine) return '';
+
+  const out = [lang.taskCtxHeader];
+  if (taskCtx.taskId) out.push(`taskId: ${taskCtx.taskId}`);
+  if (memLines) out.push(memLines);
+  if (relatedLines) out.push(relatedLines);
+  if (reminderLine) out.push(reminderLine);
+  return out.join('\n');
+}
+
+/** Render task-memory top-N bodies with `[shard]` prefix, no sourceRef. */
+function renderTaskMemories(memories) {
+  if (!Array.isArray(memories) || memories.length === 0) return '';
+  const lines = [];
+  for (const m of memories.slice(0, DEFAULT_TASK_MEMORY_TOP)) {
+    const body = typeof m?.body === 'string' ? m.body.trim() : '';
+    if (!body) continue;
+    const shard = typeof m?.shard === 'string' && m.shard.trim() ? m.shard.trim() : 'general';
+    lines.push(`- [${shard}] ${body}`);
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Render `### related tasks` sub-block. §Δ31.4 ACL: a related task is only
+ * included if `task.members` contains `currentVpId`. Missing `members` is
+ * treated as private (excluded) — fail-closed.
+ *
+ * Ordering: by `updatedAt` desc (undefined treated as 0). Top-3 tasks, top-2
+ * memory each.
+ */
+function renderRelatedTasks(relatedTasks, currentVpId, lang) {
+  if (!Array.isArray(relatedTasks) || relatedTasks.length === 0) return '';
+  if (!currentVpId) return ''; // no ACL subject → fail-closed
+
+  const allowed = relatedTasks.filter((t) => {
+    if (!t || typeof t !== 'object') return false;
+    const members = Array.isArray(t.members) ? t.members : null;
+    if (!members) return false; // fail-closed on missing ACL
+    return members.includes(currentVpId);
+  });
+  if (allowed.length === 0) return '';
+
+  // Sort by updatedAt desc; undefined coerces to 0 (i.e. pushed to the end).
+  const sorted = allowed
+    .slice()
+    .sort((a, b) => (Number(b.updatedAt) || 0) - (Number(a.updatedAt) || 0));
+
+  const out = [lang.taskCtxRelatedHeader];
+  for (const t of sorted.slice(0, DEFAULT_RELATED_TASK_TOP)) {
+    const title = typeof t.title === 'string' && t.title.trim() ? t.title.trim() : t.id;
+    out.push(`- **${t.id}** · ${title}`);
+    const mems = Array.isArray(t.memories) ? t.memories : [];
+    for (const m of mems.slice(0, DEFAULT_RELATED_TASK_MEMORY_TOP)) {
+      const body = typeof m?.body === 'string' ? m.body.trim() : '';
+      if (!body) continue;
+      const shard = typeof m?.shard === 'string' && m.shard.trim() ? m.shard.trim() : 'general';
+      out.push(`  - [${shard}] ${body}`);
+    }
+  }
+  // If every allowed task had zero usable memory, we still keep the header +
+  // task list — the related-task identifiers themselves are useful context.
+  return out.join('\n');
+}
+
+/**
+ * Render the summary-reminder line (§Δ27.3).
+ *
+ * Conditions (ALL must hold):
+ *   (a) currentVpId === task.initiatorVpId
+ *   (b) summaryReminder.nonSummaryCount ≥ 3
+ *   (c) (now - lastSummaryAt) > 15 minutes
+ *       (lastSummaryAt == 0 / missing is treated as "never summarized":
+ *        only triggers if nonSummaryCount ≥ 3)
+ */
+function renderSummaryReminder(taskCtx, lang) {
+  const r = taskCtx && taskCtx.summaryReminder;
+  if (!r || typeof r !== 'object') return '';
+  if (!taskCtx.currentVpId || !taskCtx.initiatorVpId) return '';
+  if (taskCtx.currentVpId !== taskCtx.initiatorVpId) return '';
+
+  const count = Number(r.nonSummaryCount) || 0;
+  if (count < SUMMARY_REMINDER_MIN_MESSAGES) return '';
+
+  const now = Number(r.now) || Date.now();
+  const lastAt = Number(r.lastSummaryAt) || 0;
+  const ageMs = lastAt > 0 ? now - lastAt : Number.POSITIVE_INFINITY;
+  if (lastAt > 0 && ageMs <= SUMMARY_REMINDER_MIN_AGE_MS) return '';
+
+  // For "never summarized" (lastAt==0) we report age as nonSummaryCount's
+  // session-coarse proxy: we print a dash so the prompt does not lie about
+  // an exact minute count. The hint still carries the count of new msgs.
+  const minStr = lastAt > 0 ? String(Math.round(ageMs / 60000)) : '—';
+  return lang.taskCtxSummaryReminder(minStr, count);
+}
+
+/**
+ * Render `## user_profile` block. If the caller passed an explicit string,
+ * we use it verbatim (that's the 334l path). Otherwise we stub-read from
+ * `~/.yeaft/user/profile.json` (`{ content: "..." }`) per §Δ29.3. Any IO
+ * error is swallowed — this is best-effort context, not critical path.
+ */
+function renderUserProfile(userProfile, lang) {
+  let content = '';
+  if (typeof userProfile === 'string' && userProfile.trim()) {
+    content = userProfile.trim();
+  } else if (userProfile == null) {
+    content = readUserProfileStub();
+  }
+  if (!content) return '';
+  return `${lang.userProfileHeader}\n${content}`;
+}
+
+function readUserProfileStub() {
+  try {
+    const path = join(homedir(), '.yeaft', 'user', 'profile.json');
+    if (!existsSync(path)) return '';
+    const raw = readFileSync(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.content === 'string') return parsed.content.trim();
+    return '';
+  } catch {
+    // File missing, unreadable, malformed JSON, or non-string content.
+    // Stub is best-effort — fall through silently.
+    return '';
+  }
+}
+
+/**
+ * Render `## core_memory` block with recall top-7 bodies + (optional) meta line.
+ *
+ * Accepts `{ entries: [{body,shard}], max?: number }`. Never renders
+ * `sourceRef`. The "call memory_trace" meta line is gated by
+ * `memoryTraceAvailable` (prev-3 Nit-2 / PM-approved Option A): when the
+ * `memory_trace` tool is not yet implemented (334f), we omit the meta line
+ * entirely so the LLM does not try to call a non-existent tool. 334f will
+ * flip the flag to `true` when it wires session.js.
+ */
+function renderCoreMemory(coreMemory, lang, memoryTraceAvailable) {
+  if (!coreMemory || typeof coreMemory !== 'object') return '';
+  const entries = Array.isArray(coreMemory.entries) ? coreMemory.entries : [];
+  if (entries.length === 0) return '';
+  const max = Number.isFinite(coreMemory.max) && coreMemory.max > 0
+    ? Math.floor(coreMemory.max)
+    : DEFAULT_CORE_MEMORY_TOP;
+
+  const lines = [lang.coreMemoryHeader];
+  let shown = 0;
+  for (const e of entries) {
+    if (shown >= max) break;
+    const body = typeof e?.body === 'string' ? e.body.trim() : '';
+    if (!body) continue;
+    const shard = typeof e?.shard === 'string' && e.shard.trim() ? e.shard.trim() : 'general';
+    lines.push(`- [${shard}] ${body}`);
+    shown += 1;
+  }
+  if (shown === 0) return '';
+  if (memoryTraceAvailable) {
+    lines.push('');
+    lines.push(lang.coreMemoryMeta);
+  }
+  return lines.join('\n');
+}

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;