openclaw-memory-atmem 2.2.5 → 2.2.6-beta.1

package/README.md

@@ -5,11 +5,18 @@ This npm package is the host bridge for AtMem. It is not a standalone memory eng
 Use the Python-owned installer:
 
 ```bash
-python -m pip install --upgrade atmem==2.2.5
+python -m pip install --pre --upgrade atmem==2.2.6b1
 atmem openclaw install
 ```
 
-The installer pins `openclaw-memory-atmem@2.2.5`, binds the exact `atmem` executable, copies existing OpenClaw memory, configures shadow mode, restarts the gateway and verifies the loaded plugin. Direct npm installation cannot perform or prove those steps.
+The installer pins the matching OpenClaw bridge, binds the exact `atmem` executable, copies existing OpenClaw memory, configures shadow mode, restarts the gateway and verifies the loaded plugin. Direct npm installation cannot perform or prove those steps.
+
+The bridge also supports AtMem's optional delegated context-provider mode. It
+supplies authenticated owner/workspace bindings, contributes a verified result
+as exactly one `prependContext` segment, confirms that segment at `llm_input`,
+and suppresses native AtMem recall for the turn. Delegation is enabled only by
+an AtMem registration; the bridge's `delegatedContext.userId` is an identity
+mapping, not an activation switch.
 
 Existing AtMem 2.1 users run `atmem openclaw upgrade` after upgrading the Python
 package. This preserves the current memory mode and migration, verifies the new

package/dist/index.js

@@ -61,6 +61,10 @@ function parseConfig(raw) {
         statePath: expandHome(String(cfg.controlPlane?.statePath ?? "~/.atmem/control-plane.json")),
         blackboxEnabled: cfg.controlPlane?.enabled === true || cfg.controlPlane?.blackboxEnabled === true,
     };
+    const delegatedContext = {
+        userId: String(cfg.delegatedContext?.userId ?? "").trim(),
+        requireOwner: cfg.delegatedContext?.requireOwner !== false,
+    };
     return {
         command: String(cfg.command ?? "atmem"),
         commandArgs: controlPlane.enabled
@@ -98,6 +102,7 @@ function parseConfig(raw) {
         },
         tools: { enabled: cfg.tools?.enabled !== false },
         controlPlane,
+        delegatedContext,
     };
 }
 const FILE_TOOL_HINTS = [
@@ -347,6 +352,17 @@ function register(api) {
         }
         return cfg.subject;
     };
+    const workspaceIdFor = (ctx) => {
+        const workspace = cfg.agentWorkspaces[agentIdFor(ctx)];
+        return workspace ? `ws_${digestText(workspace).slice(0, 16)}` : undefined;
+    };
+    const delegatedUserIdFor = (ctx) => {
+        if (!cfg.delegatedContext.userId)
+            return undefined;
+        if (cfg.delegatedContext.requireOwner && ctx.senderIsOwner !== true)
+            return undefined;
+        return cfg.delegatedContext.userId;
+    };
     const scopedKey = (value, ctx) => `${agentIdFor(ctx)}:${value}`;
     const contextIds = (ctx) => [...new Set([ctx.runId, ctx.sessionKey, ctx.sessionId].filter((value) => Boolean(value)).map((value) => scopedKey(value, ctx)))];
     const callFor = (ctx, name, args, timeoutMs = cfg.recall.timeoutMs) => {
@@ -389,6 +405,7 @@ function register(api) {
                 event_type: eventType,
                 run_id: flightRunId(eventRunId, ctx),
                 agent_id: agentIdFor(ctx),
+                workspace_id: workspaceIdFor(ctx),
                 subject_id: Object.keys(cfg.agentSubjects).length ? subjectFor(ctx) : undefined,
                 session_id: ctx.sessionId ?? ctx.sessionKey,
                 tool_call_id: toolCallId,
@@ -548,6 +565,37 @@ function register(api) {
         await observeTurnInput(event.prompt, ctx, "before_model_resolve", Array.isArray(event.attachments) ? event.attachments.length : 0);
     });
     api.on("llm_input", async (event, ctx) => {
+        const sessionKey = scopedKey(ctx.sessionKey ?? ctx.sessionId ?? event.sessionId ?? "default-session", ctx);
+        const pending = pendingPrompts.get(sessionKey);
+        if (pending?.delegatedContext !== undefined) {
+            const exact = pending.delegatedContext;
+            const promptOccurrences = exact ? event.prompt.split(exact).length - 1 : 0;
+            const systemOccurrences = exact
+                ? (event.systemPrompt ?? "").split(exact).length - 1
+                : 0;
+            const occurrences = promptOccurrences + systemOccurrences;
+            const deliveredLocation = promptOccurrences === 1
+                ? "prompt"
+                : systemOccurrences === 1
+                    ? "systemPrompt"
+                    : "none";
+            const delivered = occurrences === 1 && digestText(exact) === pending.delegatedContextSha256;
+            await recordBlackbox("context.injected", event.runId, ctx, {
+                disposition: delivered ? "injected" : "recall_failed",
+                provider: pending.delegatedAuthority,
+                result_sha256: pending.delegatedResultSha256,
+                context_sha256: pending.delegatedContextSha256,
+                context_chars: exact.length,
+                context_byte_length: Buffer.byteLength(exact, "utf8"),
+                context_location: deliveredLocation,
+                success: delivered,
+                reason: delivered ? undefined : `expected one exact delegated segment; observed ${occurrences}`,
+            }, undefined, { contextReceiptId: pending.contextReceiptId });
+            if (delivered && pending.exposureId) {
+                await callFor(ctx, "control_exposure_shown", { exposure_id: pending.exposureId }, cfg.recall.timeoutMs);
+            }
+            pendingPrompts.set(sessionKey, { ...pending, delegatedContext: undefined });
+        }
         await recordBlackbox("model.input", event.runId, ctx, {
             provider: event.provider,
             model: event.model,
@@ -690,13 +738,47 @@ function register(api) {
         sweep();
         if (cfg.controlPlane.enabled) {
             try {
-                const prepared = (await callFor(ctx, "control_prepare", { query: userText, session_id: sessionKey, agent_id: agentIdFor(ctx) }, cfg.recall.timeoutMs));
+                const prepared = (await callFor(ctx, "control_prepare", {
+                    query: userText,
+                    session_id: sessionKey,
+                    host_run_id: ctx.runId,
+                    turn_id: ctx.runId,
+                    agent_id: agentIdFor(ctx),
+                    user_id: delegatedUserIdFor(ctx),
+                    workspace_id: workspaceIdFor(ctx),
+                }, cfg.recall.timeoutMs));
                 pendingPrompts.set(sessionKey, {
                     text: userText,
                     ts: Date.now(),
                     exposureId: prepared.exposure_id,
                     contextReceiptId: prepared.context_receipt_id,
+                    delegatedContext: prepared.authority === "delegated" && prepared.inject
+                        ? prepared.context ?? ""
+                        : undefined,
+                    delegatedContextSha256: prepared.authority === "delegated" ? prepared.context_sha256 : undefined,
+                    delegatedAuthority: prepared.authority,
+                    delegatedResultSha256: prepared.result_sha256,
                 });
+                if (prepared.authority === "delegated" &&
+                    prepared.inject &&
+                    (!prepared.context ||
+                        !prepared.context_sha256 ||
+                        digestText(prepared.context) !== prepared.context_sha256)) {
+                    throw new Error("delegated context failed exact handoff digest validation");
+                }
+                if (prepared.authority === "delegated" || prepared.authority === "atmem_fallback") {
+                    await recordBlackbox("context.provider_authorization", undefined, ctx, {
+                        disposition: prepared.decision ?? "provider_failure",
+                        provider: prepared.provider?.id,
+                        mode: prepared.authority,
+                        result_sha256: prepared.result_sha256,
+                        context_sha256: prepared.context_sha256,
+                        context_byte_length: Buffer.byteLength(prepared.context ?? "", "utf8"),
+                        context_receipt_sha256: prepared.receipt?.sha256,
+                        context_chars: (prepared.context ?? "").length,
+                        success: prepared.decision === "inject" || prepared.decision === "withhold",
+                    }, undefined, { contextReceiptId: prepared.context_receipt_id });
+                }
                 await recordBlackbox("context.disposition", undefined, ctx, {
                     disposition: prepared.inject && prepared.context
                         ? "injected"
@@ -705,20 +787,26 @@ function register(api) {
                             : "no_relevant_memory",
                     context_sha256: digestText(prepared.context ?? ""),
                     context_block_sha256: digestText(prepared.context ?? ""),
-                    context_envelope_sha256: digestJson({ appendContext: prepared.context ?? "" }),
+                    context_envelope_sha256: digestJson(prepared.authority === "delegated"
+                        ? { prependContext: prepared.context ?? "" }
+                        : { appendContext: prepared.context ?? "" }),
                     context_receipt_sha256: prepared.manifest_sha256,
                     digest_profile: "atmem-context-envelope-canonical-json-v1",
                     context_chars: (prepared.context ?? "").length,
                     candidate_ids: prepared.candidate_ids ?? [],
                     exposure_id: prepared.exposure_id,
                     mode: prepared.mode,
-                    context_location: prepared.inject ? "appendContext" : "none",
+                    context_location: prepared.inject
+                        ? prepared.authority === "delegated" ? "prependContext" : "appendContext"
+                        : "none",
                 }, undefined, {
                     contextReceiptId: prepared.context_receipt_id,
                 });
                 if (prepared.inject && prepared.context) {
                     api.logger.info(`${TAG} memory control plane ${prepared.mode ?? "active"} context exposed`);
-                    return { appendContext: prepared.context };
+                    return prepared.authority === "delegated"
+                        ? { prependContext: prepared.context }
+                        : { appendContext: prepared.context };
                 }
                 return;
             }

package/dist/src/rpc-client.js

@@ -128,7 +128,7 @@ export class AtmemClient {
             capabilities: {},
             clientInfo: {
                 name: "openclaw-memory-atmem",
-                version: "2.2.5",
+                version: "2.2.6-beta.1",
             },
         });
         this.notify("notifications/initialized", {});

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "memory-atmem",
   "name": "Memory (atmem)",
   "description": "OpenClaw bridge installed and managed by the AtMem memory control plane.",
-  "version": "2.2.5",
+  "version": "2.2.6-beta.1",
   "commandAliases": ["memory-atmem"],
   "activation": {
     "onStartup": true,
@@ -135,6 +135,22 @@
             "description": "Record content-minimizing agent flights through the private control protocol. Managed automatically by the AtMem installer."
           }
         }
+      },
+      "delegatedContext": {
+        "type": "object",
+        "description": "Identity mapping used only when AtMem has an explicitly enabled delegated context-provider registration. This does not enable delegation.",
+        "properties": {
+          "userId": {
+            "type": "string",
+            "default": "",
+            "description": "Opaque authenticated user ID registered with AtMem. Leave empty unless delegated authority is configured."
+          },
+          "requireOwner": {
+            "type": "boolean",
+            "default": true,
+            "description": "Send the mapped user ID only when OpenClaw marks the sender as owner."
+          }
+        }
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-memory-atmem",
-  "version": "2.2.5",
+  "version": "2.2.6-beta.1",
   "description": "OpenClaw Agent Black Box and memory control-plane bridge for AtMem",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,7 +40,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "node test/setup.mjs && node test/hooks.mjs",
+    "test": "node test/setup.mjs && node test/hooks.mjs && node test/delegated-context-contract.mjs",
     "smoke": "node test/smoke.mjs",
     "prepack": "npm run build && npm run typecheck && npm test && npm run smoke"
   },