@cognee/cognee-openclaw 2026.4.13 → 2026.6.11

package/dist/src/plugin.js

@@ -1,12 +1,29 @@
-import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// SyncResult is used as the return type of the per-agent sync helpers below.
 import { MEMORY_SCOPES } from "./types.js";
 import { CogneeHttpClient } from "./client.js";
 import { resolveConfig } from "./config.js";
 import { collectMemoryFiles } from "./files.js";
 import { buildMemoryFlushPlan } from "./flush-plan.js";
-import { loadDatasetState, loadScopedSyncIndexes, loadSyncIndex, saveDatasetState, saveScopedSyncIndexes, saveSyncIndex, migrateLegacyIndex, SYNC_INDEX_PATH, } from "./persistence.js";
-import { datasetNameForScope, fallbackDatasetIdForScope, isMultiScopeEnabled, routeFileToScope } from "./scope.js";
+import { loadDatasetState, loadScopedSyncIndexes, loadSyncIndex, loadAgentSyncIndexes, saveDatasetState, saveScopedSyncIndexes, saveSyncIndex, saveAgentSyncIndexes, migrateLegacyIndex, migrateAgentScopeToPerAgent, SYNC_INDEX_PATH, } from "./persistence.js";
+import { datasetNameForScope, isMultiScopeEnabled, normalizeAgentId, routeFileToScope } from "./scope.js";
 import { syncFiles, syncFilesScoped } from "./sync.js";
+/** Expand a leading `~` in a workspace path to the user's home directory. */
+function expandHome(p) {
+    if (!p)
+        return p;
+    if (p === "~")
+        return homedir();
+    if (p.startsWith("~/"))
+        return join(homedir(), p.slice(2));
+    return p;
+}
+// Module-scope dedupe so a duplicate register() (e.g. plugin loaded twice via
+// different module specifiers) doesn't run startup auto-sync twice for the
+// same workspace. The in-closure autoSyncStarted flag inside register() can't
+// catch this because each register() call gets its own closure.
+const autoSyncedWorkspaces = new Set();
 const memoryCogneePlugin = {
     id: "cognee-openclaw",
     name: "Memory (Cognee)",
@@ -14,6 +31,23 @@ const memoryCogneePlugin = {
     kind: "memory",
     register(api) {
         const cfg = resolveConfig(api.pluginConfig);
+        // Auto-enable per-agent memory when the gateway hosts more than one agent,
+        // unless the plugin config set `perAgentMemory` explicitly. This keeps
+        // single-agent installs (the common case) on the legacy shared behavior so
+        // the upgrade is non-breaking; multi-agent gateways get per-agent isolation.
+        const perAgentExplicit = typeof api.pluginConfig?.perAgentMemory === "boolean";
+        if (!perAgentExplicit) {
+            try {
+                const agentList = api.runtime?.config?.loadConfig?.()?.agents?.list;
+                if (Array.isArray(agentList) && agentList.length > 1) {
+                    cfg.perAgentMemory = true;
+                    api.logger.info?.(`cognee-openclaw: per-agent memory auto-enabled (${agentList.length} agents configured)`);
+                }
+            }
+            catch (error) {
+                api.logger.debug?.(`cognee-openclaw: could not read agents.list for perAgentMemory auto-enable: ${String(error)}`);
+            }
+        }
         const client = new CogneeHttpClient(cfg.baseUrl, cfg.apiKey, cfg.username, cfg.password, cfg.requestTimeoutMs, cfg.ingestionTimeoutMs, cfg.mode);
         const multiScope = isMultiScopeEnabled(cfg);
         api.registerMemoryFlushPlan?.(buildMemoryFlushPlan);
@@ -21,14 +55,46 @@ const memoryCogneePlugin = {
         // Legacy single-scope state
         let datasetId;
         let syncIndex = { entries: {} };
-        // Multi-scope state
+        // Multi-scope state (company/user shared; agent scope lives in agentIndexes
+        // when perAgentMemory is on).
         let scopedIndexes = {};
+        // Per-agent agent-scope state (perAgentMemory mode), keyed by normalized agentId.
+        let agentIndexes = {};
+        const perAgentMemory = multiScope && cfg.perAgentMemory;
+        // Serialize sync work per agent so concurrent turns of the SAME agent don't
+        // double-run. Keyed by normalized agentId.
+        const agentLocks = new Map();
+        function withAgentLock(agentId, fn) {
+            const prev = agentLocks.get(agentId) ?? Promise.resolve();
+            const next = prev.catch(() => { }).then(fn);
+            agentLocks.set(agentId, next.catch(() => { }));
+            return next;
+        }
+        // Global lock around the read-modify-write of agent-sync-indexes.json.
+        // DIFFERENT agents are NOT serialized by agentLocks, so without this their
+        // concurrent load→mutate→save would clobber each other's bucket (they share
+        // one file). This makes the reload+set+save atomic so distinct buckets merge.
+        let indexSaveChain = Promise.resolve();
+        function withIndexSaveLock(fn) {
+            const next = indexSaveChain.catch(() => { }).then(fn);
+            indexSaveChain = next.catch(() => { });
+            return next;
+        }
         // Session state
         let sessionId;
+        // Cached as a fallback for paths that may lack ctx.
+        let lastAgentId;
+        let lastWorkspaceDir;
+        // Per-agent workspace cache (normalized agentId -> workspaceDir), populated
+        // on agent_end. session_end's ctx carries agentId but NOT workspaceDir, so
+        // this lets the final sweep find the right agent's workspace without falling
+        // back to a single global (which mis-attributes when >1 agent is active).
+        const agentWorkspaces = new Map();
         let resolvedWorkspaceDir;
         let resolveServiceReady;
         const serviceReady = new Promise((r) => { resolveServiceReady = r; });
-        // Load persisted state on startup
+        // Hoisted so CLI processes can suppress the gateway's auto-sync timer.
+        let autoSyncStarted = false;
         const stateReady = Promise.all([
             loadDatasetState()
                 .then((state) => {
@@ -52,6 +118,18 @@ const memoryCogneePlugin = {
                         }
                     }
                     scopedIndexes = indexes;
+                })
+                    .then(async () => {
+                    if (!perAgentMemory)
+                        return;
+                    // Move any legacy shared `agent` scope entry into the per-agent map.
+                    const migrated = await migrateAgentScopeToPerAgent(normalizeAgentId(undefined, cfg));
+                    if (migrated) {
+                        api.logger.info?.("cognee-openclaw: migrated shared agent scope index to per-agent");
+                        // Reload shared indexes (migration removed the agent entry from them).
+                        scopedIndexes = await loadScopedSyncIndexes();
+                    }
+                    agentIndexes = await loadAgentSyncIndexes();
                 })
                     .catch((error) => {
                     api.logger.warn?.(`cognee-openclaw: failed to load scoped sync indexes: ${String(error)}`);
@@ -67,6 +145,15 @@ const memoryCogneePlugin = {
                     api.logger.warn?.(`cognee-openclaw: failed to load sync index: ${String(error)}`);
                 }),
         ]);
+        // Resolve the locally-cached fallback dataset id for a scope. For the agent
+        // scope under perAgentMemory, that's the per-agent index; otherwise the
+        // shared scoped index.
+        function scopeFallbackDatasetId(scope, runtimeAgentId) {
+            if (scope === "agent" && perAgentMemory) {
+                return agentIndexes[normalizeAgentId(runtimeAgentId, cfg)]?.datasetId;
+            }
+            return scopedIndexes[scope]?.datasetId;
+        }
         // Fix #8: Log when scopes have no dataset ID during recall
         async function getRecallDatasetIds(runtimeAgentId) {
             const state = await loadDatasetState();
@@ -75,7 +162,7 @@ const memoryCogneePlugin = {
             if (multiScope) {
                 for (const scope of cfg.recallScopes) {
                     const dsName = datasetNameForScope(scope, cfg, runtimeAgentId);
-                    const dsId = state[dsName] ?? fallbackDatasetIdForScope(scope, dsName, scopedIndexes[scope], runtimeAgentId);
+                    const dsId = state[dsName] ?? scopeFallbackDatasetId(scope, runtimeAgentId);
                     if (dsId) {
                         ids.push(dsId);
                     }
@@ -90,8 +177,79 @@ const memoryCogneePlugin = {
             }
             return { ids, missingScopes };
         }
-        // Helper: run sync
-        async function runSync(workspaceDir, logger) {
+        // Sync ONE agent's `agent`-scope files from its own workspace into its own
+        // dataset + per-agent index. Serialized per agentId. Used by per-agent mode.
+        async function syncAgentScope(workspaceDir, rawAgentId, logger) {
+            await stateReady;
+            const agentId = normalizeAgentId(rawAgentId, cfg);
+            return withAgentLock(agentId, async () => {
+                const allFiles = await collectMemoryFiles(workspaceDir);
+                const agentFiles = allFiles.filter((f) => routeFileToScope(f.path, cfg.scopeRouting, cfg.defaultWriteScope) === "agent");
+                // Start from this agent's latest persisted bucket.
+                const idx = (await loadAgentSyncIndexes())[agentId] ?? { entries: {} };
+                const dsName = datasetNameForScope("agent", cfg, agentId);
+                // syncFiles mutates `idx` in place (entries/dataIds) but does not persist
+                // it (persistIndex=false); we own persistence below.
+                const result = await syncFiles(client, agentFiles, agentFiles, idx, cfg, logger, dsName, false);
+                // Atomic merge-save: reload the latest on-disk map (may include other
+                // agents' buckets written meanwhile), set just our bucket, save.
+                await withIndexSaveLock(async () => {
+                    const latest = await loadAgentSyncIndexes();
+                    latest[agentId] = idx;
+                    await saveAgentSyncIndexes(latest);
+                    agentIndexes = latest;
+                });
+                return result;
+            });
+        }
+        // Sync ONLY the shared scopes (company/user) from a workspace. Never run
+        // from a per-agent workspace (it lacks company/user files and would forget
+        // them); only from the default/gateway workspace at startup.
+        async function syncSharedScopes(workspaceDir, logger) {
+            await stateReady;
+            const files = await collectMemoryFiles(workspaceDir);
+            return syncFilesScoped(client, files, files, scopedIndexes, cfg, logger, undefined, ["company", "user"]);
+        }
+        // Seed every configured agent's files from its own workspace (startup/CLI).
+        async function seedAllAgents(defaultWorkspace, logger) {
+            const config = api.runtime?.config?.loadConfig?.();
+            const list = config?.agents?.list;
+            const defWs = expandHome(config?.agents?.defaults?.workspace) || defaultWorkspace;
+            const agents = Array.isArray(list) && list.length > 0
+                ? list
+                : [{ id: cfg.agentId, workspace: defWs }];
+            for (const a of agents) {
+                const ws = expandHome(a.workspace) || defWs;
+                if (!ws)
+                    continue;
+                try {
+                    const r = await syncAgentScope(ws, a.id, logger);
+                    logger.info?.(`cognee-openclaw: seeded agent "${normalizeAgentId(a.id, cfg)}": ${r.added} added, ${r.updated} updated, ${r.deleted} deleted, ${r.skipped} unchanged`);
+                }
+                catch (e) {
+                    logger.warn?.(`cognee-openclaw: failed to seed agent "${a.id}": ${String(e)}`);
+                }
+            }
+        }
+        // Resolve an agent's workspace from OpenClaw config (agents.list[].workspace
+        // by agentId), with sensible fallbacks. Used by the per-agent file paths so
+        // startup seeding and the agent_end/session_end sweeps always read the SAME
+        // directory — otherwise a runtime ctx.workspaceDir that differs from the
+        // seed workspace makes the sweep see the seeded file as "missing" and forget
+        // it. Resolving from config (the single source of truth) avoids that.
+        function resolveAgentWorkspace(rawAgentId) {
+            const target = normalizeAgentId(rawAgentId, cfg);
+            try {
+                const config = api.runtime?.config?.loadConfig?.();
+                const list = config?.agents?.list;
+                const match = list?.find((a) => normalizeAgentId(a.id, cfg) === target);
+                return expandHome(match?.workspace) || expandHome(config?.agents?.defaults?.workspace) || resolvedWorkspaceDir;
+            }
+            catch {
+                return resolvedWorkspaceDir;
+            }
+        }
+        async function runSync(workspaceDir, logger, runtimeAgentId) {
             await stateReady;
             const files = await collectMemoryFiles(workspaceDir);
             if (files.length === 0) {
@@ -99,8 +257,14 @@ const memoryCogneePlugin = {
                 return { added: 0, updated: 0, skipped: 0, errors: 0, deleted: 0 };
             }
             logger.info?.(`cognee-openclaw: found ${files.length} memory file(s), syncing...`);
-            if (multiScope) {
-                return syncFilesScoped(client, files, files, scopedIndexes, cfg, logger);
+            if (perAgentMemory) {
+                // Per-agent mode: this path syncs only the shared scopes (company/user)
+                // from the given workspace; the `agent` scope is handled per agent via
+                // syncAgentScope/seedAllAgents (each from its own workspace).
+                return syncFilesScoped(client, files, files, scopedIndexes, cfg, logger, runtimeAgentId, ["company", "user"]);
+            }
+            else if (multiScope) {
+                return syncFilesScoped(client, files, files, scopedIndexes, cfg, logger, runtimeAgentId);
             }
             else {
                 const result = await syncFiles(client, files, files, syncIndex, cfg, logger);
@@ -113,10 +277,12 @@ const memoryCogneePlugin = {
             datasetId = undefined;
             syncIndex = { entries: {} };
             scopedIndexes = {};
+            agentIndexes = {};
             await Promise.all([
                 saveDatasetState({}),
                 saveSyncIndex({ entries: {} }),
                 saveScopedSyncIndexes({}),
+                saveAgentSyncIndexes({}),
             ]);
         }
         async function clearLocalStateForDataset(datasetName) {
@@ -135,6 +301,8 @@ const memoryCogneePlugin = {
             if (multiScope) {
                 let changed = false;
                 for (const scope of MEMORY_SCOPES) {
+                    if (scope === "agent" && perAgentMemory)
+                        continue; // handled per-agent below
                     const expectedName = datasetNameForScope(scope, cfg);
                     const idx = scopedIndexes[scope];
                     const actualName = idx?.datasetName ?? expectedName;
@@ -147,6 +315,20 @@ const memoryCogneePlugin = {
                     await saveScopedSyncIndexes(scopedIndexes);
                 }
             }
+            if (perAgentMemory) {
+                agentIndexes = await loadAgentSyncIndexes();
+                let agentChanged = false;
+                for (const [agentId, idx] of Object.entries(agentIndexes)) {
+                    const expectedName = datasetNameForScope("agent", cfg, agentId);
+                    const actualName = idx.datasetName ?? expectedName;
+                    if (actualName === datasetName || expectedName === datasetName) {
+                        delete agentIndexes[agentId];
+                        agentChanged = true;
+                    }
+                }
+                if (agentChanged)
+                    await saveAgentSyncIndexes(agentIndexes);
+            }
         }
         // ------------------------------------------------------------------
         // CLI commands
@@ -154,10 +336,28 @@ const memoryCogneePlugin = {
         api.registerCli((ctx) => {
             const cognee = ctx.program.command("cognee").description("Cognee memory management");
             const cliWorkspaceDir = ctx.workspaceDir || process.cwd();
+            autoSyncStarted = true;
             cognee
                 .command("index")
                 .description("Sync memory files to Cognee (add new, update changed, skip unchanged)")
-                .action(async () => {
+                .option("--agent <id>", "Per-agent mode: sync only this agent's workspace")
+                .action(async (opts) => {
+                if (perAgentMemory) {
+                    if (opts.agent) {
+                        // Resolve this agent's workspace from config; fall back to cwd.
+                        const config = api.runtime?.config?.loadConfig?.();
+                        const list = config?.agents?.list;
+                        const match = list?.find((a) => normalizeAgentId(a.id, cfg) === normalizeAgentId(opts.agent, cfg));
+                        const ws = expandHome(match?.workspace) || cliWorkspaceDir;
+                        const r = await syncAgentScope(ws, opts.agent, ctx.logger);
+                        console.log(`Sync complete [agent=${normalizeAgentId(opts.agent, cfg)}]: ${r.added} added, ${r.updated} updated, ${r.deleted} deleted, ${r.skipped} unchanged, ${r.errors} errors`);
+                        process.exit(0);
+                    }
+                    const shared = await runSync(cliWorkspaceDir, ctx.logger); // company/user
+                    await seedAllAgents(cliWorkspaceDir, ctx.logger); // each agent's own files
+                    console.log(`Shared sync complete: ${shared.added} added, ${shared.updated} updated, ${shared.deleted} deleted, ${shared.skipped} unchanged. Per-agent files seeded (see log).`);
+                    process.exit(0);
+                }
                 const result = await runSync(cliWorkspaceDir, ctx.logger);
                 const summary = `Sync complete: ${result.added} added, ${result.updated} updated, ${result.deleted} deleted, ${result.skipped} unchanged, ${result.errors} errors`;
                 ctx.logger.info?.(summary);
@@ -172,7 +372,10 @@ const memoryCogneePlugin = {
                 const files = await collectMemoryFiles(cliWorkspaceDir);
                 if (multiScope) {
                     const state = await loadDatasetState();
-                    for (const scope of MEMORY_SCOPES) {
+                    // Shared scopes (company/user). In per-agent mode the agent scope is
+                    // reported per-agent below instead of here.
+                    const scopesToShow = perAgentMemory ? ["company", "user"] : MEMORY_SCOPES;
+                    for (const scope of scopesToShow) {
                         const dsName = datasetNameForScope(scope, cfg);
                         const scopeIndex = scopedIndexes[scope] ?? { entries: {} };
                         const entryCount = Object.keys(scopeIndex.entries).length;
@@ -192,6 +395,23 @@ const memoryCogneePlugin = {
                         console.log(`  New (unindexed): ${newCount}`);
                         console.log(`  Changed (dirty): ${dirty}`);
                     }
+                    if (perAgentMemory) {
+                        agentIndexes = await loadAgentSyncIndexes();
+                        const config = api.runtime?.config?.loadConfig?.();
+                        const list = config?.agents?.list;
+                        const agentKeys = new Set(Object.keys(agentIndexes));
+                        for (const a of list ?? [])
+                            agentKeys.add(normalizeAgentId(a.id, cfg));
+                        if (agentKeys.size === 0)
+                            agentKeys.add(normalizeAgentId(undefined, cfg));
+                        for (const agentId of agentKeys) {
+                            const idx = agentIndexes[agentId] ?? { entries: {} };
+                            const dsName = datasetNameForScope("agent", cfg, agentId);
+                            console.log(`\n[AGENT:${agentId}] Dataset: ${dsName}`);
+                            console.log(`  Dataset ID: ${state[dsName] ?? idx.datasetId ?? "(not set)"}`);
+                            console.log(`  Indexed files: ${Object.keys(idx.entries).length}`);
+                        }
+                    }
                 }
                 else {
                     const entryCount = Object.keys(syncIndex.entries).length;
@@ -366,12 +586,31 @@ const memoryCogneePlugin = {
                 console.log(`Forget failed: ${result.error ?? "unknown error"}`);
                 process.exit(1);
             });
+            cognee
+                .command("improve")
+                .description("Bridge session-cache QAs (and any feedback) into the permanent graph. With --session-id, scopes to that session; otherwise improves the dataset in general.")
+                .option("--session-id <id>", "Session to bridge")
+                .option("--dataset <name>", "Dataset name (default: configured datasetName)")
+                .action(async (opts) => {
+                const dsName = opts.dataset ?? (multiScope ? datasetNameForScope("agent", cfg) : cfg.datasetName);
+                try {
+                    const result = await client.improve({
+                        datasetName: dsName,
+                        ...(opts.sessionId ? { sessionIds: [opts.sessionId] } : {}),
+                    });
+                    console.log(`Improve dispatched for dataset "${dsName}"${opts.sessionId ? ` (sessionId=${opts.sessionId})` : ""} — status=${result.status ?? "?"}`);
+                    process.exit(0);
+                }
+                catch (error) {
+                    console.log(`Improve failed: ${error instanceof Error ? error.message : String(error)}`);
+                    process.exit(1);
+                }
+            });
         }, { commands: ["cognee"] });
         // ------------------------------------------------------------------
         // Auto-sync on startup (with health check)
         // ------------------------------------------------------------------
         if (cfg.autoIndex) {
-            let autoSyncStarted = false;
             const runAutoSync = async (workspaceDir) => {
                 if (autoSyncStarted)
                     return;
@@ -379,6 +618,12 @@ const memoryCogneePlugin = {
                 resolvedWorkspaceDir = workspaceDir || process.cwd();
                 resolveServiceReady?.();
                 const logger = api.logger;
+                // Dedupe across duplicate register() calls in the same process.
+                if (autoSyncedWorkspaces.has(resolvedWorkspaceDir)) {
+                    logger.debug?.(`cognee-openclaw: auto-sync already ran for ${resolvedWorkspaceDir} in this process, skipping`);
+                    return;
+                }
+                autoSyncedWorkspaces.add(resolvedWorkspaceDir);
                 try {
                     await client.health();
                 }
@@ -386,13 +631,14 @@ const memoryCogneePlugin = {
                     logger.warn?.(`cognee-openclaw: Cognee API unreachable at ${cfg.baseUrl} — auto-sync disabled for this session. Error: ${String(error)}`);
                     return;
                 }
-                if (cfg.enableSessions && !sessionId) {
-                    sessionId = `openclaw-${randomUUID()}`;
-                    logger.info?.(`cognee-openclaw: session ${sessionId}`);
-                }
                 try {
                     const result = await runSync(resolvedWorkspaceDir, logger);
                     logger.info?.(`cognee-openclaw: auto-sync complete: ${result.added} added, ${result.updated} updated, ${result.deleted} deleted, ${result.skipped} unchanged`);
+                    // Per-agent mode: seed each configured agent's files from its OWN
+                    // workspace (runSync above only handled the shared company/user scopes).
+                    if (perAgentMemory) {
+                        await seedAllAgents(resolvedWorkspaceDir, logger);
+                    }
                 }
                 catch (error) {
                     logger.warn?.(`cognee-openclaw: auto-sync failed: ${String(error)}`);
@@ -427,6 +673,9 @@ const memoryCogneePlugin = {
         if (cfg.autoRecall) {
             api.on("before_prompt_build", async (event, ctx) => {
                 await stateReady;
+                // session_start isn't fired in every openclaw flow; sync from ctx on every hook.
+                if (cfg.enableSessions && ctx.sessionId)
+                    sessionId = ctx.sessionId;
                 if (!event.prompt || event.prompt.length < 5) {
                     api.logger.debug?.("cognee-openclaw: skipping recall (prompt too short)");
                     return;
@@ -446,7 +695,7 @@ const memoryCogneePlugin = {
                         const state = await loadDatasetState();
                         const searchPromises = cfg.recallScopes.map(async (scope) => {
                             const dsName = datasetNameForScope(scope, cfg, ctx.agentId);
-                            const dsId = state[dsName] ?? fallbackDatasetIdForScope(scope, dsName, scopedIndexes[scope], ctx.agentId);
+                            const dsId = state[dsName] ?? scopeFallbackDatasetId(scope, ctx.agentId);
                             if (!dsId)
                                 return null;
                             const results = await client.recall({
@@ -527,50 +776,31 @@ const memoryCogneePlugin = {
                 if (!event.success)
                     return;
                 await Promise.all([stateReady, serviceReady]);
-                const workspaceDir = resolvedWorkspaceDir;
-                // Fix #4: Actually persist the session into the knowledge graph
-                if (cfg.enableSessions && cfg.persistSessionsAfterEnd && sessionId) {
-                    try {
-                        // Determine target dataset for session persistence
-                        const targetDatasetIds = [];
-                        if (multiScope) {
-                            const state = await loadDatasetState();
-                            const agentDsName = datasetNameForScope("agent", cfg, ctx.agentId);
-                            const agentDsId = state[agentDsName] ?? fallbackDatasetIdForScope("agent", agentDsName, scopedIndexes.agent, ctx.agentId);
-                            if (agentDsId)
-                                targetDatasetIds.push(agentDsId);
-                        }
-                        else if (datasetId) {
-                            targetDatasetIds.push(datasetId);
-                        }
-                        if (targetDatasetIds.length > 0) {
-                            // Call Cognee's session persistence endpoint via the generic fetchJson
-                            await client.fetchAPI("/api/v1/sessions/persist", {
-                                method: "POST",
-                                headers: { "Content-Type": "application/json" },
-                                body: JSON.stringify({
-                                    session_ids: [sessionId],
-                                    dataset_ids: targetDatasetIds,
-                                }),
-                            }).catch(() => {
-                                // Session persistence endpoint may not exist on all Cognee versions.
-                                // Fail silently — this is an enhancement, not critical path.
-                                api.logger.debug?.("cognee-openclaw: session persistence endpoint not available");
-                            });
+                lastAgentId = ctx.agentId;
+                lastWorkspaceDir = ctx.workspaceDir || resolvedWorkspaceDir;
+                if (cfg.enableSessions && ctx.sessionId)
+                    sessionId = ctx.sessionId;
+                const workspaceDir = ctx.workspaceDir || resolvedWorkspaceDir;
+                // Remember this agent's workspace so session_end can sweep the right one.
+                if (workspaceDir)
+                    agentWorkspaces.set(normalizeAgentId(ctx.agentId, cfg), workspaceDir);
+                try {
+                    if (perAgentMemory) {
+                        // Sync ONLY this agent's agent-scope files from its OWN workspace
+                        // into its own dataset + per-agent index. Resolve the workspace from
+                        // config (not ctx.workspaceDir) so it matches the startup seed and a
+                        // mismatched runtime cwd can't make the sweep "forget" the seed file.
+                        const agentWs = resolveAgentWorkspace(ctx.agentId) || workspaceDir;
+                        const result = await syncAgentScope(agentWs, ctx.agentId, api.logger);
+                        if (result.added || result.updated || result.deleted) {
+                            api.logger.info?.(`cognee-openclaw: post-agent sync [agent=${normalizeAgentId(ctx.agentId, cfg)}]: ${result.added} added, ${result.updated} updated, ${result.deleted} deleted`);
                         }
                     }
-                    catch (error) {
-                        api.logger.warn?.(`cognee-openclaw: session persistence failed: ${String(error)}`);
-                    }
-                }
-                // Sync file changes
-                try {
-                    if (multiScope) {
+                    else if (multiScope) {
                         try {
-                            const freshIndexes = await loadScopedSyncIndexes();
-                            scopedIndexes = freshIndexes;
+                            scopedIndexes = await loadScopedSyncIndexes();
                         }
-                        catch { /* fall through */ }
+                        catch { /* keep cached scopedIndexes */ }
                         const files = await collectMemoryFiles(workspaceDir);
                         let hasChanges = false;
                         for (const file of files) {
@@ -610,7 +840,7 @@ const memoryCogneePlugin = {
                             if (freshIndex.datasetName)
                                 syncIndex.datasetName = freshIndex.datasetName;
                         }
-                        catch { /* fall through */ }
+                        catch { /* keep cached syncIndex */ }
                         const files = await collectMemoryFiles(workspaceDir);
                         const changedFiles = files.filter((f) => {
                             const existing = syncIndex.entries[f.path];
@@ -631,20 +861,59 @@ const memoryCogneePlugin = {
                     api.logger.warn?.(`cognee-openclaw: post-agent sync failed: ${String(error)}`);
                 }
             });
+            api.on("session_start", async (event) => {
+                if (cfg.enableSessions)
+                    sessionId = event.sessionId;
+            });
             // Final sweep when the openclaw session closes. Catches memory file
-            // edits that happened outside an agent_end (failed runs, manual
-            // edits between turns, tool writes outside the agent loop).
-            api.on("session_end", async () => {
+            // edits that happened outside an agent_end.
+            //
+            // CRITICAL: resolve the agent + session from THIS event's ctx, not the
+            // global lastAgentId. With >1 agent active, lastAgentId is whichever agent
+            // ran most recently, so using it would bridge one agent's session into
+            // another agent's dataset.
+            // PluginHookSessionContext carries agentId + sessionId, so prefer those.
+            api.on("session_end", async (event, ctx) => {
                 await Promise.all([stateReady, serviceReady]);
-                if (!resolvedWorkspaceDir)
-                    return;
-                try {
-                    const result = await runSync(resolvedWorkspaceDir, api.logger);
-                    api.logger.info?.(`cognee-openclaw: session-end sync: ${result.added} added, ${result.updated} updated, ${result.deleted} deleted`);
+                const endAgentId = ctx?.agentId ?? lastAgentId;
+                const endSessionId = ctx?.sessionId ?? event.sessionId;
+                if (!ctx?.agentId) {
+                    api.logger.debug?.(`cognee-openclaw: session_end without ctx.agentId; falling back to lastAgentId="${endAgentId ?? "(none)"}"`);
+                }
+                // Per-agent: resolve from config (matches the startup seed). Otherwise
+                // fall back to the cached workspace for this agent.
+                const sweepWorkspace = perAgentMemory
+                    ? (resolveAgentWorkspace(endAgentId) || lastWorkspaceDir || resolvedWorkspaceDir)
+                    : (agentWorkspaces.get(normalizeAgentId(endAgentId, cfg)) || lastWorkspaceDir || resolvedWorkspaceDir);
+                if (sweepWorkspace) {
+                    try {
+                        if (perAgentMemory) {
+                            // Final sweep for THIS session's agent, from its own workspace.
+                            const result = await syncAgentScope(sweepWorkspace, endAgentId, api.logger);
+                            api.logger.info?.(`cognee-openclaw: session-end sync [agent=${normalizeAgentId(endAgentId, cfg)}]: ${result.added} added, ${result.updated} updated, ${result.deleted} deleted`);
+                        }
+                        else {
+                            const result = await runSync(sweepWorkspace, api.logger, endAgentId);
+                            api.logger.info?.(`cognee-openclaw: session-end sync: ${result.added} added, ${result.updated} updated, ${result.deleted} deleted`);
+                        }
+                    }
+                    catch (error) {
+                        api.logger.warn?.(`cognee-openclaw: session-end sync failed: ${String(error)}`);
+                    }
                 }
-                catch (error) {
-                    api.logger.warn?.(`cognee-openclaw: session-end sync failed: ${String(error)}`);
+                // Bridge session-cache QAs (including any auto-captured feedback) into
+                // THIS session's agent dataset — keyed by endAgentId + endSessionId.
+                if (cfg.improveOnSessionEnd && endSessionId) {
+                    const dsName = multiScope ? datasetNameForScope("agent", cfg, endAgentId) : cfg.datasetName;
+                    try {
+                        const result = await client.improve({ datasetName: dsName, sessionIds: [endSessionId] });
+                        api.logger.info?.(`cognee-openclaw: session-end improve dispatched for session ${endSessionId} -> dataset "${dsName}" (status=${result.status ?? "?"})`);
+                    }
+                    catch (error) {
+                        api.logger.warn?.(`cognee-openclaw: session-end improve failed: ${error instanceof Error ? error.message : String(error)}`);
+                    }
                 }
+                sessionId = undefined;
             });
         }
     },