@vainplex/openclaw-membrane 0.3.5 → 0.3.7

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.3.7] — 2026-03-04
+
+### Fixed
+- **Full agent memory isolation (client-side filtering).** Server-side scope filters in `membraned` are not enforced, so v0.3.6's retrieval scoping alone was insufficient. Now:
+  - **Ingest:** Events tagged with `source: openclaw-{agentId}` (was always `openclaw`).
+  - **Retrieve:** Client-side filter in `parseMembraneRecords()` drops records from other agents. Legacy records (source=`openclaw`) pass through for backwards compatibility.
+  - Agents can no longer see each other's conversation history in Membrane context injection.
+
+## [0.3.6] — 2026-03-04
+
+### Fixed
+- **Agent-scoped memory retrieval.** Membrane now passes `agentId` from hook context to retrieval queries. Each agent only retrieves its own memories instead of seeing all agents' conversations. Prevents cross-agent memory injection in multi-agent setups. `actor_id` is set to `openclaw-{agentId}` and `scopes` filters by agent.
+
 ## [0.3.5] — 2026-03-04
 
 ### Fixed

package/dist/index.js

@@ -41,14 +41,14 @@ export function validateConfig(raw) {
     return result;
 }
 // --- Retrieve helper ---
-async function retrieveMemories(client, query, config, fetchLimit) {
+async function retrieveMemories(client, query, config, fetchLimit, agentId = 'main') {
     const request = {
         task_descriptor: query.substring(0, 500),
         trust: {
             max_sensitivity: config.retrieve_max_sensitivity,
             authenticated: true,
-            actor_id: 'openclaw-main',
-            scopes: [],
+            actor_id: `openclaw-${agentId}`,
+            scopes: [agentId],
         },
         memory_types: [],
         min_salience: config.retrieve_min_salience,
@@ -90,15 +90,15 @@ async function handleSearch(client, config, logger, params) {
     }
 }
 // --- Context hook handler ---
-async function handleContextInjection(client, config, logger, prompt) {
+async function handleContextInjection(client, config, logger, prompt, agentId = 'main') {
     if (!prompt || prompt.length < 5)
         return undefined;
     try {
         const fetchLimit = Math.max(config.retrieve_limit * 10, 50);
-        const result = await retrieveMemories(client, prompt, config, fetchLimit);
+        const result = await retrieveMemories(client, prompt, config, fetchLimit, agentId);
         if (!result?.records?.length)
             return undefined;
-        const parsed = parseMembraneRecords(result.records, logger);
+        const parsed = parseMembraneRecords(result.records, logger, agentId);
         const memories = selectMemories(parsed, config.retrieve_limit);
         if (memories.length === 0)
             return undefined;
@@ -119,16 +119,16 @@ async function handleContextInjection(client, config, logger, prompt) {
     }
 }
 // --- Event handler ---
-function handleEvent(event, config, reliability, logger) {
+function handleEvent(event, config, reliability, logger, agentId = 'main') {
     const normalizedEvent = {
         type: event.type,
         payload: (event.payload || event.data || {}),
         context: event.context,
     };
     const sensitivity = mapSensitivity(normalizedEvent, config.default_sensitivity);
-    const mapped = mapEvent(normalizedEvent, sensitivity);
+    const mapped = mapEvent(normalizedEvent, sensitivity, agentId);
     if (mapped) {
-        logger.info(`[membrane] Received event: ${event.type}`);
+        logger.info(`[membrane] Received event: ${event.type} (agent=${agentId})`);
         reliability.enqueue(mapped.method, mapped.payload);
     }
 }
@@ -163,7 +163,9 @@ const plugin = {
         const hookHandler = (type) => (event, ctx) => {
             const e = event;
             const c = ctx;
-            handleEvent({ type, payload: e, context: c }, config, reliability, logger);
+            const hookCtx = ctx;
+            const agentId = hookCtx?.agentId || 'main';
+            handleEvent({ type, payload: e, context: c }, config, reliability, logger, agentId);
         };
         api.on('message_received', hookHandler('message_received'));
         api.on('message_sent', hookHandler('message_sent'));
@@ -192,7 +194,9 @@ const plugin = {
                         : '';
                 if (!content || content.length < 10)
                     break;
-                handleEvent({ type: 'message_sent', payload: { content }, context: ctx }, config, reliability, logger);
+                const endCtx = ctx;
+                const endAgentId = endCtx?.agentId || 'main';
+                handleEvent({ type: 'message_sent', payload: { content }, context: ctx }, config, reliability, logger, endAgentId);
                 break; // Only the last one
             }
         });
@@ -209,9 +213,11 @@ const plugin = {
         });
         // Context hook: auto-inject Membrane memories before agent starts
         if (config.retrieve_enabled) {
-            api.on('before_agent_start', (event) => {
+            api.on('before_agent_start', (event, ctx) => {
                 const e = event;
-                return handleContextInjection(client, config, logger, e.prompt || e.message || '');
+                const hookCtx = ctx;
+                const agentId = hookCtx?.agentId || 'main';
+                return handleContextInjection(client, config, logger, e.prompt || e.message || '', agentId);
             });
         }
         // Shutdown: flush buffer, close client

package/dist/mapping.js

@@ -106,23 +106,35 @@ function mapTaskCompleted(payload, timestamp) {
     };
 }
 // --- Main dispatcher ---
-export function mapEvent(event, sensitivity) {
+export function mapEvent(event, sensitivity, agentId = 'main') {
     const timestamp = new Date().toISOString();
+    const source = `openclaw-${agentId}`;
+    let mapped;
     switch (event.type) {
         case 'message_received':
-            return mapMessageReceived(event.payload, timestamp, sensitivity);
+            mapped = mapMessageReceived(event.payload, timestamp, sensitivity);
+            break;
         case 'message_sent':
         case 'message_sending':
-            return mapMessageSent(event.payload, timestamp, sensitivity);
+            mapped = mapMessageSent(event.payload, timestamp, sensitivity);
+            break;
         case 'session_start':
-            return mapSessionStart(timestamp, sensitivity);
+            mapped = mapSessionStart(timestamp, sensitivity);
+            break;
         case 'after_tool_call':
-            return mapToolCall(event.payload, timestamp, sensitivity);
+            mapped = mapToolCall(event.payload, timestamp, sensitivity);
+            break;
         case 'fact_extracted':
-            return mapFactExtracted(event.payload, timestamp, sensitivity);
+            mapped = mapFactExtracted(event.payload, timestamp, sensitivity);
+            break;
         case 'task_completed':
-            return mapTaskCompleted(event.payload, timestamp);
+            mapped = mapTaskCompleted(event.payload, timestamp);
+            break;
         default:
             return null;
     }
+    if (mapped) {
+        mapped.payload.source = source;
+    }
+    return mapped;
 }

package/dist/parser.js

@@ -10,13 +10,22 @@ const MIN_TOOL_SUMMARY_LENGTH = 30;
 const MAX_SUMMARY_LENGTH = 500;
 /**
  * Parse raw Membrane Retrieve records into categorized, formatted memory strings.
+ * When agentId is provided, filters records to only include those from the same agent.
+ * Records without a source tag (legacy) are included for backwards compatibility.
  */
-export function parseMembraneRecords(rawRecords, logger) {
+export function parseMembraneRecords(rawRecords, logger, agentId) {
     const conversational = [];
     const tool = [];
+    const expectedSource = agentId ? `openclaw-${agentId}` : undefined;
+    let filtered = 0;
     for (const raw of rawRecords) {
         try {
             const record = JSON.parse(Buffer.from(raw).toString());
+            // Client-side agent isolation: skip records from other agents
+            if (expectedSource && record.source && record.source !== expectedSource && record.source !== 'openclaw') {
+                filtered++;
+                continue;
+            }
             const tsShort = formatTimestamp(record.created_at);
             parsePayload(record, tsShort, conversational, tool);
         }
@@ -24,6 +33,9 @@ export function parseMembraneRecords(rawRecords, logger) {
             logger?.debug(`[membrane] Failed to parse record: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    if (filtered > 0) {
+        logger?.debug(`[membrane] Filtered ${filtered} records from other agents (keeping source=${expectedSource})`);
+    }
     return { conversational, tool };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vainplex/openclaw-membrane",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "type": "module",
   "description": "Membrane gRPC bridge for OpenClaw — episodic memory ingestion, search tool, and auto-context injection via Membrane sidecar",
   "main": "dist/index.js",