@yeaft/webchat-agent 0.1.530 → 0.1.532

package/unify/tools/open-source-message.js

@@ -0,0 +1,49 @@
+/**
+ * open-source-message.js — task-334f R6 §Δ24.4.
+ *
+ * Low-level random access: given a (groupId, msgId), fetch the raw message
+ * from the group's jsonl log. Used when a VP has an exact pointer but does
+ * not want to run the memory_trace wrapper (5% case: audit / debug).
+ */
+
+import { defineTool } from './types.js';
+
+export default defineTool({
+  name: 'open_source_message',
+  description: `Open a single source message by (groupId, msgId).
+
+This is the low-level random-access primitive. Prefer memory_trace if you are
+starting from a memory entry. Returns JSON: { message } or { error }.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      groupId: { type: 'string', description: 'Group id' },
+      msgId:   { type: 'string', description: 'Message id' },
+    },
+    required: ['groupId', 'msgId'],
+  },
+  isConcurrencySafe: () => true,
+  isReadOnly: () => true,
+  async execute(input, ctx) {
+    const { groupId, msgId } = input || {};
+    if (!groupId || !msgId) {
+      return JSON.stringify({ error: 'groupId and msgId required' });
+    }
+    const coordinator = ctx?.coordinator;
+    if (!coordinator || typeof coordinator.openGroup !== 'function') {
+      return JSON.stringify({ error: 'group coordinator not available' });
+    }
+    const group = coordinator.openGroup(groupId);
+    if (!group) return JSON.stringify({ error: `group not found: ${groupId}` });
+
+    const iter = typeof group.readMessageRange === 'function'
+      ? group.readMessageRange(msgId, msgId)
+      : group.streamMessages();
+    for (const msg of iter) {
+      if (msg.id === msgId) {
+        return JSON.stringify({ message: msg });
+      }
+    }
+    return JSON.stringify({ error: `message not found: ${msgId} in ${groupId}` });
+  },
+});

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;