@contextableai/openclaw-memory-rebac 0.1.5 → 0.3.0

package/dist/authorization.d.ts

@@ -22,6 +22,11 @@ export type FragmentRelationships = {
  * Returns group resource IDs from SpiceDB where the subject has the "access" permission.
  */
 export declare function lookupAuthorizedGroups(spicedb: SpiceDbClient, subject: Subject, zedToken?: string): Promise<string[]>;
+/**
+ * Look up the owner person ID for an agent.
+ * Returns undefined if no owner relationship exists.
+ */
+export declare function lookupAgentOwner(spicedb: SpiceDbClient, agentId: string, zedToken?: string): Promise<string | undefined>;
 /**
  * Look up all memory fragment IDs that a subject can view.
  * Used for fine-grained post-filtering when needed.

package/dist/authorization.js

@@ -28,6 +28,20 @@ export async function lookupAuthorizedGroups(spicedb, subject, zedToken) {
         consistency: tokenConsistency(zedToken),
     });
 }
+/**
+ * Look up the owner person ID for an agent.
+ * Returns undefined if no owner relationship exists.
+ */
+export async function lookupAgentOwner(spicedb, agentId, zedToken) {
+    const tuples = await spicedb.readRelationships({
+        resourceType: "agent",
+        resourceId: agentId,
+        relation: "owner",
+        consistency: tokenConsistency(zedToken),
+    });
+    const ownerTuple = tuples.find((t) => t.subjectType === "person");
+    return ownerTuple?.subjectId;
+}
 /**
  * Look up all memory fragment IDs that a subject can view.
  * Used for fine-grained post-filtering when needed.

package/dist/backend.d.ts

@@ -118,6 +118,12 @@ export interface MemoryBackend {
      * Returns true if deleted, false if the backend doesn't support it.
      */
     deleteFragment?(uuid: string, type?: string): Promise<boolean>;
+    /**
+     * Fetch fragment details by their IDs.
+     * Used for fragment-level recall (e.g., finding memories via `involves` permissions).
+     * Optional: not all backends support fetching individual fragments by ID.
+     */
+    getFragmentsByIds?(ids: string[]): Promise<SearchResult[]>;
     /**
      * Discover fragment (fact/edge) UUIDs that were extracted from a stored episode.
      * Called after store() resolves the episode ID to write per-fragment SpiceDB

package/dist/backends/graphiti.d.ts

@@ -63,6 +63,7 @@ export declare class GraphitiBackend implements MemoryBackend {
     listGroups(): Promise<BackendDataset[]>;
     deleteFragment(uuid: string, type?: string): Promise<boolean>;
     getEpisodes(groupId: string, lastN: number): Promise<GraphitiEpisode[]>;
+    getFragmentsByIds(ids: string[]): Promise<SearchResult[]>;
     discoverFragmentIds(episodeId: string): Promise<string[]>;
     getEntityEdge(uuid: string): Promise<FactResult>;
     registerCliCommands(cmd: Command): void;

package/dist/backends/graphiti.js

@@ -159,6 +159,26 @@ export class GraphitiBackend {
     async getEpisodes(groupId, lastN) {
         return this.restCall("GET", `/episodes/${encodeURIComponent(groupId)}?last_n=${lastN}`);
     }
+    async getFragmentsByIds(ids) {
+        const results = [];
+        for (const id of ids) {
+            try {
+                const fact = await this.getEntityEdge(id);
+                results.push({
+                    type: "fact",
+                    uuid: id,
+                    group_id: "unknown",
+                    summary: fact.fact,
+                    context: fact.name,
+                    created_at: fact.created_at,
+                });
+            }
+            catch {
+                // Fragment not found or unreachable — skip
+            }
+        }
+        return results;
+    }
     async discoverFragmentIds(episodeId) {
         const edges = await this.restCall("GET", `/episodes/${encodeURIComponent(episodeId)}/edges`);
         return edges.map((e) => e.uuid);

package/dist/config.d.ts

@@ -16,6 +16,8 @@ export type RebacMemoryConfig = {
     backendConfig: Record<string, unknown>;
     subjectType: "agent" | "person";
     subjectId: string;
+    /** Maps agent IDs to their owner person IDs (e.g., Slack user IDs). */
+    identities: Record<string, string>;
     autoCapture: boolean;
     autoRecall: boolean;
     maxCaptureMessages: number;

package/dist/config.js

@@ -41,7 +41,7 @@ export const rebacMemoryConfigSchema = {
         // Top-level allowed keys: shared keys + the backend name key
         assertAllowedKeys(cfg, [
             "backend", "spicedb",
-            "subjectType", "subjectId",
+            "subjectType", "subjectId", "identities",
             "autoCapture", "autoRecall", "maxCaptureMessages",
             backendName,
         ], "openclaw-memory-rebac config");
@@ -54,6 +54,16 @@ export const rebacMemoryConfigSchema = {
         const backendConfig = { ...entry.defaults, ...backendRaw };
         const subjectType = cfg.subjectType === "person" ? "person" : pluginDefaults.subjectType;
         const subjectId = typeof cfg.subjectId === "string" ? resolveEnvVars(cfg.subjectId) : pluginDefaults.subjectId;
+        // Parse identities: { "main": "U0123ABC", "work": "U0456DEF" }
+        const identitiesRaw = cfg.identities;
+        const identities = {};
+        if (identitiesRaw && typeof identitiesRaw === "object" && !Array.isArray(identitiesRaw)) {
+            for (const [agentId, personId] of Object.entries(identitiesRaw)) {
+                if (typeof personId === "string" && personId.trim()) {
+                    identities[agentId] = personId.trim();
+                }
+            }
+        }
         return {
             backend: backendName,
             spicedb: {
@@ -68,6 +78,7 @@ export const rebacMemoryConfigSchema = {
             backendConfig,
             subjectType,
             subjectId,
+            identities,
             autoCapture: cfg.autoCapture !== false,
             autoRecall: cfg.autoRecall !== false,
             maxCaptureMessages: typeof cfg.maxCaptureMessages === "number" && cfg.maxCaptureMessages > 0

package/dist/index.d.ts

@@ -10,6 +10,10 @@
  * Authorization is enforced at the data layer, not in prompts.
  *
  * Backend currently uses Graphiti for knowledge graph storage.
+ *
+ * Per-agent identity: tools and hooks derive the SpiceDB subject from
+ * the runtime agentId (OpenClawPluginToolContext / PluginHookAgentContext),
+ * falling back to config-level subjectType/subjectId when agentId is absent.
  */
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 declare const rebacMemoryPlugin: {

package/dist/index.js

@@ -10,6 +10,10 @@
  * Authorization is enforced at the data layer, not in prompts.
  *
  * Backend currently uses Graphiti for knowledge graph storage.
+ *
+ * Per-agent identity: tools and hooks derive the SpiceDB subject from
+ * the runtime agentId (OpenClawPluginToolContext / PluginHookAgentContext),
+ * falling back to config-level subjectType/subjectId when agentId is absent.
  */
 import { Type } from "@sinclair/typebox";
 import { readFileSync } from "node:fs";
@@ -17,7 +21,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { rebacMemoryConfigSchema, createBackend, defaultGroupId } from "./config.js";
 import { SpiceDbClient } from "./spicedb.js";
-import { lookupAuthorizedGroups, writeFragmentRelationships, deleteFragmentRelationships, canDeleteFragment, canWriteToGroup, ensureGroupMembership, } from "./authorization.js";
+import { lookupAuthorizedGroups, lookupViewableFragments, lookupAgentOwner, writeFragmentRelationships, deleteFragmentRelationships, canDeleteFragment, canWriteToGroup, ensureGroupMembership, } from "./authorization.js";
 import { searchAuthorizedMemories, formatDualResults, deduplicateSessionResults, } from "./search.js";
 import { registerCommands } from "./cli.js";
 // ============================================================================
@@ -64,14 +68,32 @@ const rebacMemoryPlugin = {
             process.removeListener("unhandledRejection", grpcRejectionHandler);
         }, 10_000);
         grpcGuardTimer.unref();
-        const currentSubject = { type: cfg.subjectType, id: cfg.subjectId };
-        let currentSessionId;
-        let lastWriteToken;
+        // Per-agent state: keyed by agentId (falls back to cfg.subjectId)
+        const agentStates = new Map();
+        function resolveSubject(agentId) {
+            if (agentId)
+                return { type: "agent", id: agentId };
+            return { type: cfg.subjectType, id: cfg.subjectId };
+        }
+        function getState(agentId) {
+            const key = agentId ?? cfg.subjectId;
+            let state = agentStates.get(key);
+            if (!state) {
+                state = {};
+                agentStates.set(key, state);
+            }
+            return state;
+        }
+        // Convenience: read state from the config-level default
+        // (used by service start and CLI where no agentId is available)
+        function getDefaultState() {
+            return getState(undefined);
+        }
         api.logger.info(`openclaw-memory-rebac: registered (backend: ${backend.name}, spicedb: ${cfg.spicedb.endpoint})`);
         // ========================================================================
-        // Tools
+        // Tools (registered as factories for per-agent identity)
         // ========================================================================
-        api.registerTool({
+        api.registerTool((ctx) => ({
             name: "memory_recall",
             label: "Memory Recall",
             description: "Search through memories using the knowledge graph. Returns results the current user is authorized to see. Supports session, long-term, or combined scope. REQUIRES a search query.",
@@ -82,20 +104,16 @@ const rebacMemoryPlugin = {
             }),
             async execute(_toolCallId, params) {
                 const { query, limit = 10, scope = "all" } = params;
-                const authorizedGroups = await lookupAuthorizedGroups(spicedb, currentSubject, lastWriteToken);
-                if (authorizedGroups.length === 0) {
-                    return {
-                        content: [{ type: "text", text: "No accessible memory groups found." }],
-                        details: { count: 0, authorizedGroups: [] },
-                    };
-                }
+                const subject = resolveSubject(ctx.agentId);
+                const state = getState(ctx.agentId);
+                const authorizedGroups = await lookupAuthorizedGroups(spicedb, subject, state.lastWriteToken);
                 let longTermGroups;
                 let sessionGroups;
                 if (scope === "session") {
                     longTermGroups = [];
                     sessionGroups = authorizedGroups.filter(isSessionGroup);
-                    if (currentSessionId) {
-                        const sg = sessionGroupId(currentSessionId);
+                    if (state.sessionId) {
+                        const sg = sessionGroupId(state.sessionId);
                         if (!sessionGroups.includes(sg))
                             sessionGroups.push(sg);
                     }
@@ -107,19 +125,20 @@ const rebacMemoryPlugin = {
                 else {
                     longTermGroups = authorizedGroups.filter((g) => !isSessionGroup(g));
                     sessionGroups = authorizedGroups.filter(isSessionGroup);
-                    if (currentSessionId) {
-                        const sg = sessionGroupId(currentSessionId);
+                    if (state.sessionId) {
+                        const sg = sessionGroupId(state.sessionId);
                         if (!sessionGroups.includes(sg))
                             sessionGroups.push(sg);
                     }
                 }
+                // Group-based search (existing path)
                 const [longTermResults, rawSessionResults] = await Promise.all([
                     longTermGroups.length > 0
                         ? searchAuthorizedMemories(backend, {
                             query,
                             groupIds: longTermGroups,
                             limit,
-                            sessionId: currentSessionId,
+                            sessionId: state.sessionId,
                         })
                         : Promise.resolve([]),
                     sessionGroups.length > 0
@@ -127,20 +146,45 @@ const rebacMemoryPlugin = {
                             query,
                             groupIds: sessionGroups,
                             limit,
-                            sessionId: currentSessionId,
+                            sessionId: state.sessionId,
                         })
                         : Promise.resolve([]),
                 ]);
                 const sessionResults = deduplicateSessionResults(longTermResults, rawSessionResults);
-                const totalCount = longTermResults.length + sessionResults.length;
+                const groupResults = [...longTermResults, ...sessionResults];
+                // Owner-aware fragment search: if the subject is an agent with an owner,
+                // also find fragments where the owner is in `involves`.
+                let ownerFragmentResults = [];
+                if (subject.type === "agent" && backend.getFragmentsByIds) {
+                    try {
+                        const ownerId = await lookupAgentOwner(spicedb, subject.id, state.lastWriteToken);
+                        if (ownerId) {
+                            const ownerSubject = { type: "person", id: ownerId };
+                            const viewableIds = await lookupViewableFragments(spicedb, ownerSubject, state.lastWriteToken);
+                            if (viewableIds.length > 0) {
+                                const groupResultIds = new Set(groupResults.map((r) => r.uuid));
+                                const newIds = viewableIds.filter((id) => !groupResultIds.has(id));
+                                if (newIds.length > 0) {
+                                    ownerFragmentResults = await backend.getFragmentsByIds(newIds);
+                                }
+                            }
+                        }
+                    }
+                    catch (err) {
+                        api.logger.warn(`openclaw-memory-rebac: owner-aware recall failed: ${String(err)}`);
+                    }
+                }
+                const allResults = [...groupResults, ...ownerFragmentResults];
+                const totalCount = allResults.length;
                 if (totalCount === 0) {
                     return {
                         content: [{ type: "text", text: "No relevant memories found." }],
                         details: { count: 0, authorizedGroups },
                     };
                 }
-                const text = formatDualResults(longTermResults, sessionResults);
-                const allResults = [...longTermResults, ...sessionResults];
+                const text = ownerFragmentResults.length > 0
+                    ? formatDualResults(groupResults, ownerFragmentResults)
+                    : formatDualResults(longTermResults, sessionResults);
                 const sanitized = allResults.map((r) => ({
                     type: r.type,
                     uuid: r.uuid,
@@ -156,11 +200,12 @@ const rebacMemoryPlugin = {
                         authorizedGroups,
                         longTermCount: longTermResults.length,
                         sessionCount: sessionResults.length,
+                        ownerFragmentCount: ownerFragmentResults.length,
                     },
                 };
             },
-        }, { name: "memory_recall" });
-        api.registerTool({
+        }), { name: "memory_recall" });
+        api.registerTool((ctx) => ({
             name: "memory_store",
             label: "Memory Store",
             description: "Save information to the knowledge graph with authorization tracking. Use longTerm=false to store session-scoped memories.",
@@ -173,6 +218,8 @@ const rebacMemoryPlugin = {
             }),
             async execute(_toolCallId, params) {
                 const { content, source_description = "conversation", involves = [], group_id, longTerm = true, } = params;
+                const subject = resolveSubject(ctx.agentId);
+                const state = getState(ctx.agentId);
                 const sanitizeGroupId = (id) => {
                     if (!id)
                         return undefined;
@@ -187,27 +234,27 @@ const rebacMemoryPlugin = {
                 if (sanitizedGroupId) {
                     targetGroupId = sanitizedGroupId;
                 }
-                else if (!longTerm && currentSessionId) {
-                    targetGroupId = sessionGroupId(currentSessionId);
+                else if (!longTerm && state.sessionId) {
+                    targetGroupId = sessionGroupId(state.sessionId);
                 }
                 else {
                     targetGroupId = backendDefaultGroupId;
                 }
                 const isOwnSession = isSessionGroup(targetGroupId) &&
-                    currentSessionId != null &&
-                    targetGroupId === sessionGroupId(currentSessionId);
+                    state.sessionId != null &&
+                    targetGroupId === sessionGroupId(state.sessionId);
                 if (isOwnSession) {
                     try {
-                        const token = await ensureGroupMembership(spicedb, targetGroupId, currentSubject);
+                        const token = await ensureGroupMembership(spicedb, targetGroupId, subject);
                         if (token)
-                            lastWriteToken = token;
+                            state.lastWriteToken = token;
                     }
                     catch {
                         api.logger.warn(`openclaw-memory-rebac: failed to ensure membership in ${targetGroupId}`);
                     }
                 }
                 else {
-                    const allowed = await canWriteToGroup(spicedb, currentSubject, targetGroupId, lastWriteToken);
+                    const allowed = await canWriteToGroup(spicedb, subject, targetGroupId, state.lastWriteToken);
                     if (!allowed) {
                         return {
                             content: [{ type: "text", text: `Permission denied: cannot write to group "${targetGroupId}"` }],
@@ -236,11 +283,11 @@ const rebacMemoryPlugin = {
                             const writeToken = await writeFragmentRelationships(spicedb, {
                                 fragmentId: factId,
                                 groupId: targetGroupId,
-                                sharedBy: currentSubject,
+                                sharedBy: subject,
                                 involves: involvedSubjects,
                             });
                             if (writeToken)
-                                lastWriteToken = writeToken;
+                                state.lastWriteToken = writeToken;
                         }
                         api.logger.info(`openclaw-memory-rebac: wrote SpiceDB relationships for ${factIds.length} fact(s) from episode ${episodeId}`);
                     }
@@ -249,11 +296,11 @@ const rebacMemoryPlugin = {
                         const writeToken = await writeFragmentRelationships(spicedb, {
                             fragmentId: episodeId,
                             groupId: targetGroupId,
-                            sharedBy: currentSubject,
+                            sharedBy: subject,
                             involves: involvedSubjects,
                         });
                         if (writeToken)
-                            lastWriteToken = writeToken;
+                            state.lastWriteToken = writeToken;
                     }
                 })
                     .catch((err) => {
@@ -270,8 +317,8 @@ const rebacMemoryPlugin = {
                     },
                 };
             },
-        }, { name: "memory_store" });
-        api.registerTool({
+        }), { name: "memory_store" });
+        api.registerTool((ctx) => ({
             name: "memory_forget",
             label: "Memory Forget",
             description: "Remove a memory fragment by ID. Use type-prefixed IDs from memory_recall (e.g. 'fact:UUID', 'chunk:UUID'). Always de-authorizes from SpiceDB; also deletes from storage if the backend supports individual deletion.",
@@ -280,6 +327,8 @@ const rebacMemoryPlugin = {
             }),
             async execute(_toolCallId, params) {
                 const { id } = params;
+                const subject = resolveSubject(ctx.agentId);
+                const state = getState(ctx.agentId);
                 // Parse optional type prefix — strip it to get the bare UUID
                 const colonIdx = id.indexOf(":");
                 let uuid;
@@ -303,11 +352,11 @@ const rebacMemoryPlugin = {
                 // Fragment-level relationships may be missing (episode UUID vs fact UUID mismatch),
                 // so fall back to group-level authorization: if the subject can contribute to any
                 // group they have access to, allow deletion.
-                let allowed = await canDeleteFragment(spicedb, currentSubject, uuid, lastWriteToken);
+                let allowed = await canDeleteFragment(spicedb, subject, uuid, state.lastWriteToken);
                 if (!allowed) {
-                    const groups = await lookupAuthorizedGroups(spicedb, currentSubject, lastWriteToken);
+                    const groups = await lookupAuthorizedGroups(spicedb, subject, state.lastWriteToken);
                     for (const g of groups) {
-                        if (await canWriteToGroup(spicedb, currentSubject, g, lastWriteToken)) {
+                        if (await canWriteToGroup(spicedb, subject, g, state.lastWriteToken)) {
                             allowed = true;
                             break;
                         }
@@ -335,19 +384,20 @@ const rebacMemoryPlugin = {
                 // Always de-authorize in SpiceDB
                 const writeToken = await deleteFragmentRelationships(spicedb, uuid);
                 if (writeToken)
-                    lastWriteToken = writeToken;
+                    state.lastWriteToken = writeToken;
                 return {
                     content: [{ type: "text", text: "Memory forgotten." }],
                     details: { action: "deleted", id, uuid },
                 };
             },
-        }, { name: "memory_forget" });
-        api.registerTool({
+        }), { name: "memory_forget" });
+        api.registerTool((ctx) => ({
             name: "memory_status",
             label: "Memory Status",
             description: "Check the health of the memory backend and SpiceDB.",
             parameters: Type.Object({}),
             async execute() {
+                const state = getState(ctx.agentId);
                 const backendStatus = await backend.getStatus();
                 let spicedbOk = false;
                 try {
@@ -361,22 +411,25 @@ const rebacMemoryPlugin = {
                     ...backendStatus,
                     spicedb: spicedbOk ? "connected" : "unreachable",
                     endpoint_spicedb: cfg.spicedb.endpoint,
-                    currentSessionId: currentSessionId ?? "none",
+                    currentSessionId: state.sessionId ?? "none",
+                    agentId: ctx.agentId ?? "default",
                 };
                 const statusText = [
                     `Backend (${backend.name}): ${backendStatus.healthy ? "connected" : "unreachable"}`,
                     `SpiceDB: ${spicedbOk ? "connected" : "unreachable"} (${cfg.spicedb.endpoint})`,
-                    `Session: ${currentSessionId ?? "none"}`,
+                    `Session: ${state.sessionId ?? "none"}`,
+                    `Agent: ${ctx.agentId ?? "default"}`,
                 ].join("\n");
                 return {
                     content: [{ type: "text", text: statusText }],
                     details: status,
                 };
             },
-        }, { name: "memory_status" });
+        }), { name: "memory_status" });
         // ========================================================================
         // CLI Commands
         // ========================================================================
+        const defaultSubject = { type: cfg.subjectType, id: cfg.subjectId };
         api.registerCli(({ program }) => {
             const mem = program
                 .command("rebac-mem")
@@ -385,8 +438,8 @@ const rebacMemoryPlugin = {
                 backend,
                 spicedb,
                 cfg,
-                currentSubject,
-                getLastWriteToken: () => lastWriteToken,
+                currentSubject: defaultSubject,
+                getLastWriteToken: () => getDefaultState().lastWriteToken,
             });
         }, { commands: ["rebac-mem"] });
         // ========================================================================
@@ -394,18 +447,18 @@ const rebacMemoryPlugin = {
         // ========================================================================
         if (cfg.autoRecall) {
             api.on("before_agent_start", async (event, ctx) => {
+                const subject = resolveSubject(ctx?.agentId);
+                const state = getState(ctx?.agentId);
                 if (ctx?.sessionKey)
-                    currentSessionId = ctx.sessionKey;
+                    state.sessionId = ctx.sessionKey;
                 if (!event.prompt || event.prompt.length < 5)
                     return;
                 try {
-                    const authorizedGroups = await lookupAuthorizedGroups(spicedb, currentSubject, lastWriteToken);
-                    if (authorizedGroups.length === 0)
-                        return;
+                    const authorizedGroups = await lookupAuthorizedGroups(spicedb, subject, state.lastWriteToken);
                     const longTermGroups = authorizedGroups.filter((g) => !isSessionGroup(g));
                     const sessionGroups = authorizedGroups.filter(isSessionGroup);
-                    if (currentSessionId) {
-                        const sg = sessionGroupId(currentSessionId);
+                    if (state.sessionId) {
+                        const sg = sessionGroupId(state.sessionId);
                         if (!sessionGroups.includes(sg))
                             sessionGroups.push(sg);
                     }
@@ -415,7 +468,7 @@ const rebacMemoryPlugin = {
                                 query: event.prompt,
                                 groupIds: longTermGroups,
                                 limit: 5,
-                                sessionId: currentSessionId,
+                                sessionId: state.sessionId,
                             })
                             : Promise.resolve([]),
                         sessionGroups.length > 0
@@ -423,7 +476,7 @@ const rebacMemoryPlugin = {
                                 query: event.prompt,
                                 groupIds: sessionGroups,
                                 limit: 3,
-                                sessionId: currentSessionId,
+                                sessionId: state.sessionId,
                             })
                             : Promise.resolve([]),
                     ]);
@@ -449,8 +502,10 @@ const rebacMemoryPlugin = {
         }
         if (cfg.autoCapture) {
             api.on("agent_end", async (event, ctx) => {
+                const subject = resolveSubject(ctx?.agentId);
+                const state = getState(ctx?.agentId);
                 if (ctx?.sessionKey)
-                    currentSessionId = ctx.sessionKey;
+                    state.sessionId = ctx.sessionKey;
                 if (!event.success || !event.messages || event.messages.length === 0)
                     return;
                 try {
@@ -495,24 +550,24 @@ const rebacMemoryPlugin = {
                     if (conversationLines.length === 0)
                         return;
                     const episodeBody = conversationLines.join("\n");
-                    const targetGroupId = currentSessionId
-                        ? sessionGroupId(currentSessionId)
+                    const targetGroupId = state.sessionId
+                        ? sessionGroupId(state.sessionId)
                         : backendDefaultGroupId;
                     const isOwnSession = isSessionGroup(targetGroupId) &&
-                        currentSessionId != null &&
-                        targetGroupId === sessionGroupId(currentSessionId);
+                        state.sessionId != null &&
+                        targetGroupId === sessionGroupId(state.sessionId);
                     if (isOwnSession) {
                         try {
-                            const token = await ensureGroupMembership(spicedb, targetGroupId, currentSubject);
+                            const token = await ensureGroupMembership(spicedb, targetGroupId, subject);
                             if (token)
-                                lastWriteToken = token;
+                                state.lastWriteToken = token;
                         }
                         catch {
                             // best-effort
                         }
                     }
                     else {
-                        const allowed = await canWriteToGroup(spicedb, currentSubject, targetGroupId, lastWriteToken);
+                        const allowed = await canWriteToGroup(spicedb, subject, targetGroupId, state.lastWriteToken);
                         if (!allowed) {
                             api.logger.warn(`openclaw-memory-rebac: auto-capture denied for group ${targetGroupId}`);
                             return;
@@ -535,27 +590,27 @@ const rebacMemoryPlugin = {
                                 const writeToken = await writeFragmentRelationships(spicedb, {
                                     fragmentId: factId,
                                     groupId: targetGroupId,
-                                    sharedBy: currentSubject,
+                                    sharedBy: subject,
                                 });
                                 if (writeToken)
-                                    lastWriteToken = writeToken;
+                                    state.lastWriteToken = writeToken;
                             }
                         }
                         else {
                             const writeToken = await writeFragmentRelationships(spicedb, {
                                 fragmentId: episodeId,
                                 groupId: targetGroupId,
-                                sharedBy: currentSubject,
+                                sharedBy: subject,
                             });
                             if (writeToken)
-                                lastWriteToken = writeToken;
+                                state.lastWriteToken = writeToken;
                         }
                     })
                         .catch((err) => {
                         api.logger.warn(`openclaw-memory-rebac: deferred SpiceDB write (auto-capture) failed: ${err}`);
                     });
                     // Backend-specific session enrichment (optional backend feature)
-                    if (backend.enrichSession && currentSessionId) {
+                    if (backend.enrichSession && state.sessionId) {
                         const lastUserMsg = [...event.messages]
                             .reverse()
                             .find((m) => m.role === "user");
@@ -581,7 +636,7 @@ const rebacMemoryPlugin = {
                         const assistantMsg = extractText(lastAssistMsg);
                         if (userMsg && assistantMsg) {
                             backend.enrichSession({
-                                sessionId: currentSessionId,
+                                sessionId: state.sessionId,
                                 groupId: targetGroupId,
                                 userMsg,
                                 assistantMsg,
@@ -601,6 +656,7 @@ const rebacMemoryPlugin = {
         api.registerService({
             id: "openclaw-memory-rebac",
             async start() {
+                const defaultState = getDefaultState();
                 const backendStatus = await backend.getStatus();
                 let spicedbOk = false;
                 try {
@@ -618,14 +674,33 @@ const rebacMemoryPlugin = {
                     // Will be retried on first use
                 }
                 if (spicedbOk) {
+                    // Ensure the config-level subject is a member of the default group
                     try {
-                        const token = await ensureGroupMembership(spicedb, backendDefaultGroupId, currentSubject);
+                        const token = await ensureGroupMembership(spicedb, backendDefaultGroupId, defaultSubject);
                         if (token)
-                            lastWriteToken = token;
+                            defaultState.lastWriteToken = token;
                     }
                     catch {
                         api.logger.warn("openclaw-memory-rebac: failed to ensure default group membership");
                     }
+                    // Write agent → owner relationships from identities config
+                    for (const [agentId, personId] of Object.entries(cfg.identities)) {
+                        try {
+                            const token = await spicedb.writeRelationships([{
+                                    resourceType: "agent",
+                                    resourceId: agentId,
+                                    relation: "owner",
+                                    subjectType: "person",
+                                    subjectId: personId,
+                                }]);
+                            if (token)
+                                defaultState.lastWriteToken = token;
+                            api.logger.info(`openclaw-memory-rebac: linked agent:${agentId} → person:${personId}`);
+                        }
+                        catch (err) {
+                            api.logger.warn(`openclaw-memory-rebac: failed to write owner for agent:${agentId}: ${err}`);
+                        }
+                    }
                 }
                 api.logger.info(`openclaw-memory-rebac: initialized (backend: ${backend.name} ${backendStatus.healthy ? "OK" : "UNREACHABLE"}, spicedb: ${spicedbOk ? "OK" : "UNREACHABLE"})`);
             },

package/docker/graphiti/docker-compose.yml

@@ -49,7 +49,7 @@ services:
       dockerfile: Dockerfile
     restart: unless-stopped
     ports:
-      - "8000:8000"
+      - "127.0.0.1:8000:8000"
     environment:
       # -- Graph database (Neo4j) --
       NEO4J_URI: bolt://neo4j:7687

package/docker/spicedb/docker-compose.yml

@@ -56,8 +56,8 @@ services:
     command: serve
     restart: unless-stopped
     ports:
-      - "${SPICEDB_GRPC_PORT:-50051}:50051"   # gRPC
-      - "${SPICEDB_HTTP_PORT:-8080}:8080"      # HTTP metrics / healthz
+      - "127.0.0.1:${SPICEDB_GRPC_PORT:-50051}:50051"   # gRPC
+      - "127.0.0.1:${SPICEDB_HTTP_PORT:-8080}:8080"      # HTTP metrics / healthz
     environment:
       SPICEDB_GRPC_PRESHARED_KEY: ${SPICEDB_PRESHARED_KEY:-dev_token}
       SPICEDB_DATASTORE_ENGINE: postgres

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextableai/openclaw-memory-rebac",
-  "version": "0.1.5",
+  "version": "0.3.0",
   "description": "OpenClaw two-layer memory plugin: SpiceDB ReBAC authorization + Graphiti knowledge graph",
   "type": "module",
   "license": "MIT",