@contextableai/openclaw-memory-rebac 0.2.0 → 0.3.1

package/README.md

@@ -213,6 +213,41 @@ Session groups (`session-<id>`) provide per-conversation memory isolation:
 - Other agents cannot read or write to foreign session groups without explicit membership
 - Session memories are searchable within the session scope and are deduplicated against long-term memories
 
+### Per-Agent Identity
+
+When multiple agents share a single OpenClaw gateway, each agent gets its own SpiceDB identity. Tools and lifecycle hooks derive the subject from the runtime `agentId` — so `agent:stenographer` and `agent:main` write memories with distinct `shared_by` relationships, even though they run through the same plugin instance.
+
+If `agentId` is not available in the runtime context (e.g., older OpenClaw versions or standalone CLI use), the plugin falls back to the config-level `subjectType`/`subjectId`.
+
+Session state (session IDs and SpiceDB consistency tokens) is also tracked per agent, so agents don't interfere with each other's sessions.
+
+### Identity Linking
+
+The `identities` config field connects agents to the people they represent. This is essential for **cross-agent recall** — finding memories stored by one agent that involve a person represented by a different agent.
+
+```json
+{
+  "identities": {
+    "main": "U0123ABC",
+    "work": "U0456DEF"
+  }
+}
+```
+
+Each entry maps an agent ID to a person ID (typically a Slack user ID or other external identifier). At plugin startup, the plugin writes `agent:<agentId> #owner person:<personId>` relationships to SpiceDB.
+
+**How cross-agent recall works:**
+
+1. Agent A stores a memory with `involves: ["U0123ABC"]`
+2. Later, agent B (configured as `"main": "U0123ABC"`) calls `memory_recall`
+3. The plugin resolves `agent:main` → `person:U0123ABC` via SpiceDB
+4. It discovers the memory because `person:U0123ABC` is in `involves`
+5. The memory is returned alongside group-based results
+
+This means a user's personal agent can discover memories stored by service agents (like a meeting recorder or Slack observer), as long as the user was a participant. The service agent retains `shared_by` ownership (and exclusive delete permission), while involved people get view access through their own agents.
+
+Agents without an `identities` entry (like service agents) are not linked to any person and cannot be resolved through identity chains. This is intentional — a service agent acts on its own behalf, not on behalf of a human.
+
 ## Configuration Reference
 
 | Key | Type | Default | Description |
@@ -227,7 +262,8 @@ Session groups (`session-<id>`) provide per-conversation memory isolation:
 | `graphiti.uuidPollMaxAttempts` | integer | `60` | Max polling attempts (total timeout = interval x attempts) |
 | `graphiti.requestTimeoutMs` | integer | `30000` | HTTP request timeout for Graphiti REST calls (ms) |
 | `subjectType` | string | `agent` | SpiceDB subject type (`agent` or `person`) |
-| `subjectId` | string | `default` | SpiceDB subject ID (supports `${ENV_VAR}`) |
+| `subjectId` | string | `default` | Fallback SpiceDB subject ID when agentId is unavailable (supports `${ENV_VAR}`) |
+| `identities` | object | `{}` | Maps agent IDs to owner person IDs for cross-agent recall (see [Identity Linking](#identity-linking)) |
 | `autoCapture` | boolean | `true` | Auto-capture conversations |
 | `autoRecall` | boolean | `true` | Auto-inject relevant memories |
 | `customInstructions` | string | *(see below)* | Custom extraction instructions |
@@ -267,13 +303,18 @@ All commands are under `rebac-mem`:
 
 | Command | Description |
 |---------|-------------|
-| `rebac-mem search <query>` | Search memories with authorization. Options: `--limit`, `--scope` |
-| `rebac-mem status` | Check SpiceDB + backend connectivity |
+| `rebac-mem search <query>` | Search memories with authorization (includes owner-aware recall). Options: `--limit`, `--as` |
+| `rebac-mem status` | Check SpiceDB + backend connectivity, show subject and identity links |
 | `rebac-mem schema-write` | Write/update the SpiceDB authorization schema |
-| `rebac-mem groups` | List authorized groups for the current subject |
+| `rebac-mem groups` | List authorized groups for a subject. Options: `--as` |
 | `rebac-mem add-member <group-id> <subject-id>` | Add a subject to a group. Options: `--type` |
+| `rebac-mem identities` | List configured identity links and verify them in SpiceDB |
+| `rebac-mem link-identity <agent-id> <person-id>` | Write an agent→owner relationship to SpiceDB |
+| `rebac-mem unlink-identity <agent-id>` | Remove an agent→owner relationship from SpiceDB |
 | `rebac-mem import` | Import workspace markdown files. Options: `--workspace`, `--include-sessions`, `--group`, `--dry-run` |
 
+The `--as` flag accepts `"type:id"` (e.g., `"agent:main"`, `"person:U0123ABC"`) or a bare `"id"` (defaults to agent type). Use it to query as a different subject without changing config.
+
 Backend-specific commands (Graphiti):
 
 | Command | Description |
@@ -340,6 +381,9 @@ OpenClaw has an exclusive `memory` slot — only one memory plugin is active at
           },
           "subjectType": "agent",
           "subjectId": "my-agent",
+          "identities": {
+            "my-agent": "U0123ABC"
+          },
           "autoCapture": true,
           "autoRecall": true
         }

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/cli.d.ts

@@ -13,6 +13,11 @@ import type { MemoryBackend } from "./backend.js";
 import type { SpiceDbClient } from "./spicedb.js";
 import type { RebacMemoryConfig } from "./config.js";
 import { type Subject } from "./authorization.js";
+/**
+ * Parse an --as flag value into a Subject.
+ * Accepts "type:id" (e.g., "agent:main", "person:U0123ABC") or bare "id" (defaults to agent type).
+ */
+export declare function parseSubjectOverride(value: string): Subject;
 export type CliContext = {
     backend: MemoryBackend;
     spicedb: SpiceDbClient;

package/dist/cli.js

@@ -14,7 +14,7 @@ import { join, dirname, basename, resolve } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { defaultGroupId } from "./config.js";
-import { lookupAuthorizedGroups, ensureGroupMembership, } from "./authorization.js";
+import { lookupAuthorizedGroups, lookupAgentOwner, lookupViewableFragments, ensureGroupMembership, } from "./authorization.js";
 import { searchAuthorizedMemories } from "./search.js";
 // ============================================================================
 // Session helper (mirrors index.ts — no shared module to avoid circular import)
@@ -24,6 +24,25 @@ function sessionGroupId(sessionId) {
     return `session-${sanitized}`;
 }
 // ============================================================================
+// Subject parsing helper
+// ============================================================================
+/**
+ * Parse an --as flag value into a Subject.
+ * Accepts "type:id" (e.g., "agent:main", "person:U0123ABC") or bare "id" (defaults to agent type).
+ */
+export function parseSubjectOverride(value) {
+    const colonIdx = value.indexOf(":");
+    if (colonIdx !== -1) {
+        const type = value.slice(0, colonIdx);
+        const id = value.slice(colonIdx + 1);
+        if (type !== "agent" && type !== "person") {
+            throw new Error(`Invalid subject type "${type}" — must be "agent" or "person"`);
+        }
+        return { type, id };
+    }
+    return { type: "agent", id: value };
+}
+// ============================================================================
 // Command Registration
 // ============================================================================
 export function registerCommands(cmd, ctx) {
@@ -34,26 +53,54 @@ export function registerCommands(cmd, ctx) {
     // --------------------------------------------------------------------------
     cmd
         .command("search")
-        .description("Search memories with authorization")
+        .description("Search memories with authorization (includes owner-aware recall for agents)")
         .argument("<query>", "Search query")
         .option("--limit <n>", "Max results", "10")
+        .option("--as <subject>", "Override subject (e.g., \"main\", \"agent:main\", \"person:U0123ABC\")")
         .action(async (query, opts) => {
-        const authorizedGroups = await lookupAuthorizedGroups(spicedb, currentSubject, getLastWriteToken());
-        if (authorizedGroups.length === 0) {
-            console.log("No accessible memory groups.");
-            return;
+        const subject = opts.as ? parseSubjectOverride(opts.as) : currentSubject;
+        const token = getLastWriteToken();
+        // Group-based search
+        const authorizedGroups = await lookupAuthorizedGroups(spicedb, subject, token);
+        console.log(`Searching as ${subject.type}:${subject.id}...`);
+        const groupResults = authorizedGroups.length > 0
+            ? await searchAuthorizedMemories(backend, {
+                query,
+                groupIds: authorizedGroups,
+                limit: parseInt(opts.limit),
+            })
+            : [];
+        // Owner-aware recall: if agent, resolve owner and find involves fragments
+        let ownerResults = [];
+        if (subject.type === "agent" && backend.getFragmentsByIds) {
+            try {
+                const ownerId = await lookupAgentOwner(spicedb, subject.id, token);
+                if (ownerId) {
+                    const ownerSubject = { type: "person", id: ownerId };
+                    const viewableIds = await lookupViewableFragments(spicedb, ownerSubject, token);
+                    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) {
+                            ownerResults = await backend.getFragmentsByIds(newIds);
+                        }
+                    }
+                    if (ownerResults.length > 0) {
+                        console.log(`  + ${ownerResults.length} result(s) via owner identity (person:${ownerId})`);
+                    }
+                }
+            }
+            catch {
+                // Owner lookup failed — proceed with group results only
+            }
         }
-        console.log(`Searching ${authorizedGroups.length} authorized groups...`);
-        const results = await searchAuthorizedMemories(backend, {
-            query,
-            groupIds: authorizedGroups,
-            limit: parseInt(opts.limit),
-        });
-        if (results.length === 0) {
+        const allResults = [...groupResults, ...ownerResults];
+        if (allResults.length === 0) {
             console.log("No results found.");
             return;
         }
-        console.log(JSON.stringify(results, null, 2));
+        console.log(`Found ${allResults.length} result(s) across ${authorizedGroups.length} group(s).`);
+        console.log(JSON.stringify(allResults, null, 2));
     });
     // --------------------------------------------------------------------------
     // status
@@ -77,6 +124,14 @@ export function registerCommands(cmd, ctx) {
                 console.log(`  ${k}: ${v}`);
         }
         console.log(`SpiceDB: ${spicedbOk ? "OK" : "UNREACHABLE"} (${cfg.spicedb.endpoint})`);
+        console.log(`Subject: ${currentSubject.type}:${currentSubject.id}`);
+        const identityEntries = Object.entries(cfg.identities);
+        if (identityEntries.length > 0) {
+            console.log(`Identities: ${identityEntries.length} configured`);
+            for (const [agentId, personId] of identityEntries) {
+                console.log(`  agent:${agentId} → person:${personId}`);
+            }
+        }
     });
     // --------------------------------------------------------------------------
     // schema-write
@@ -95,14 +150,16 @@ export function registerCommands(cmd, ctx) {
     // --------------------------------------------------------------------------
     cmd
         .command("groups")
-        .description("List authorized groups for current subject")
-        .action(async () => {
-        const groups = await lookupAuthorizedGroups(spicedb, currentSubject, getLastWriteToken());
+        .description("List authorized groups for a subject")
+        .option("--as <subject>", "Override subject (e.g., \"main\", \"agent:stenographer\")")
+        .action(async (opts) => {
+        const subject = opts.as ? parseSubjectOverride(opts.as) : currentSubject;
+        const groups = await lookupAuthorizedGroups(spicedb, subject, getLastWriteToken());
         if (groups.length === 0) {
-            console.log("No authorized groups.");
+            console.log(`No authorized groups for ${subject.type}:${subject.id}.`);
             return;
         }
-        console.log(`Authorized groups for ${currentSubject.type}:${currentSubject.id}:`);
+        console.log(`Authorized groups for ${subject.type}:${subject.id}:`);
         for (const g of groups)
             console.log(`  - ${g}`);
     });
@@ -449,6 +506,93 @@ export function registerCommands(cmd, ctx) {
         });
     }
     // --------------------------------------------------------------------------
+    // identities — list and verify agent→owner identity links
+    // --------------------------------------------------------------------------
+    cmd
+        .command("identities")
+        .description("List configured identity links and verify them in SpiceDB")
+        .action(async () => {
+        const identities = cfg.identities;
+        const entries = Object.entries(identities);
+        if (entries.length === 0) {
+            console.log("No identities configured.");
+            console.log("Add an \"identities\" field to your config to link agents to their owners:");
+            console.log('  { "identities": { "main": "U0123ABC" } }');
+            return;
+        }
+        console.log("Configured identity links:\n");
+        for (const [agentId, personId] of entries) {
+            let spicedbStatus;
+            try {
+                const ownerId = await lookupAgentOwner(spicedb, agentId, getLastWriteToken());
+                if (ownerId === personId) {
+                    spicedbStatus = "verified";
+                }
+                else if (ownerId) {
+                    spicedbStatus = `mismatch (SpiceDB has person:${ownerId})`;
+                }
+                else {
+                    spicedbStatus = "not found in SpiceDB";
+                }
+            }
+            catch {
+                spicedbStatus = "SpiceDB unreachable";
+            }
+            console.log(`  agent:${agentId} → person:${personId}  [${spicedbStatus}]`);
+        }
+        console.log("\nTo write missing links, restart the gateway or use: rebac-mem link-identity <agent-id> <person-id>");
+    });
+    // --------------------------------------------------------------------------
+    // link-identity — write an agent→owner relationship to SpiceDB
+    // --------------------------------------------------------------------------
+    cmd
+        .command("link-identity")
+        .description("Write an agent→owner relationship to SpiceDB")
+        .argument("<agent-id>", "Agent ID")
+        .argument("<person-id>", "Owner person ID")
+        .action(async (agentId, personId) => {
+        try {
+            await spicedb.writeRelationships([{
+                    resourceType: "agent",
+                    resourceId: agentId,
+                    relation: "owner",
+                    subjectType: "person",
+                    subjectId: personId,
+                }]);
+            console.log(`Linked agent:${agentId} → person:${personId}`);
+        }
+        catch (err) {
+            console.error(`Failed to write identity link: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    // --------------------------------------------------------------------------
+    // unlink-identity — remove an agent→owner relationship from SpiceDB
+    // --------------------------------------------------------------------------
+    cmd
+        .command("unlink-identity")
+        .description("Remove an agent→owner relationship from SpiceDB")
+        .argument("<agent-id>", "Agent ID")
+        .action(async (agentId) => {
+        try {
+            const ownerId = await lookupAgentOwner(spicedb, agentId, getLastWriteToken());
+            if (!ownerId) {
+                console.log(`No owner link found for agent:${agentId}`);
+                return;
+            }
+            await spicedb.deleteRelationships([{
+                    resourceType: "agent",
+                    resourceId: agentId,
+                    relation: "owner",
+                    subjectType: "person",
+                    subjectId: ownerId,
+                }]);
+            console.log(`Unlinked agent:${agentId} (was → person:${ownerId})`);
+        }
+        catch (err) {
+            console.error(`Failed to remove identity link: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    // --------------------------------------------------------------------------
     // Backend-specific extension point
     // --------------------------------------------------------------------------
     backend.registerCliCommands?.(cmd);

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/package.json

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