@remnic/plugin-openclaw 9.25.7 → 9.27.0

package/dist/index.js

@@ -5275,6 +5275,7 @@ function resolveRemnicOpenClawPluginEntry(raw, preferredId) {
 import path4 from "path";
 import { renderMemoryContextPrompt } from "@remnic/core";
 import { log as log2 } from "@remnic/core/logger";
+import { SESSION_NAMESPACE_BINDING_MAX_ENTRIES, SESSION_NAMESPACE_BINDING_MAX_NAMESPACES, SESSION_NAMESPACE_BINDING_MAX_NAMESPACE_LENGTH, createFileSessionNamespaceBindingStore } from "@remnic/core/session-namespace-bindings";
 import { createFileToggleStore } from "@remnic/core/session-toggles";
 
 // src/bridge.ts
@@ -5605,6 +5606,7 @@ function extractTextContent(msg) {
 }
 
 // src/delegate-runtime.ts
+var DELEGATE_BATCH_FLUSH_CACHE_TTL_MS = 3e4;
 var DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS = [
   "recall",
   "observe",
@@ -5668,6 +5670,30 @@ async function postJson(target, serviceId, pathname, body, timeoutMs) {
   const parsed = await res.json().catch(() => null);
   return typeof parsed === "object" && parsed !== null ? parsed : null;
 }
+async function getJson(target, serviceId, pathname, timeoutMs) {
+  const headers = {};
+  const auth = target.resolveAuthToken();
+  if (auth.token) headers.Authorization = `Bearer ${auth.token}`;
+  const res = await fetch(daemonUrl(target, pathname), {
+    headers,
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) {
+    if (res.status === 401 || res.status === 403) {
+      const status = res.status === 401 ? 401 : 403;
+      await res.body?.cancel();
+      reportDaemonAuthorizationFailure(serviceId, pathname, status, auth.source);
+      return { status: res.status, body: null };
+    }
+    await res.body?.cancel();
+    return { status: res.status, body: null };
+  }
+  const parsed = await res.json().catch(() => null);
+  return {
+    status: res.status,
+    body: typeof parsed === "object" && parsed !== null ? parsed : null
+  };
+}
 function sessionKeyFrom(event, ctx) {
   const fromCtx = ctx?.sessionKey;
   if (typeof fromCtx === "string" && fromCtx.length > 0) return fromCtx;
@@ -5675,6 +5701,13 @@ function sessionKeyFrom(event, ctx) {
   if (typeof fromEvent === "string" && fromEvent.length > 0) return fromEvent;
   return "default";
 }
+function lifecycleSessionKeyFrom(event, ctx) {
+  const fromEvent = event?.sessionKey;
+  if (fromEvent !== void 0) {
+    return typeof fromEvent === "string" && fromEvent.length > 0 ? fromEvent : void 0;
+  }
+  return sessionKeyFrom(event, ctx);
+}
 function recallQueryFrom(event) {
   let prompt = typeof event.prompt === "string" ? event.prompt : void 0;
   if ((!prompt || prompt.length < 5) && Array.isArray(event.messages)) {
@@ -5699,7 +5732,67 @@ function cwdFrom(event, ctx, fallback) {
   return fallback;
 }
 function withNamespace(namespace, body) {
-  return namespace.length > 0 ? { ...body, namespace } : body;
+  return namespace ? { ...body, namespace } : body;
+}
+function explicitSessionNamespaceFrom(sessionKey, event, ctx) {
+  const eventSessionKey = typeof event.sessionKey === "string" ? event.sessionKey : void 0;
+  const ctxSessionKey = typeof ctx.sessionKey === "string" ? ctx.sessionKey : void 0;
+  const sources = eventSessionKey === sessionKey ? [event, ctx] : ctxSessionKey === sessionKey ? [ctx, event] : [ctx, event];
+  for (const source of sources) {
+    const sourceSessionKey = typeof source.sessionKey === "string" ? source.sessionKey : void 0;
+    if (sourceSessionKey !== sessionKey) continue;
+    const runtime = source.runtime;
+    if (typeof runtime !== "object" || runtime === null) continue;
+    const agent = runtime.agent;
+    if (typeof agent !== "object" || agent === null) continue;
+    const session = agent.session;
+    if (typeof session !== "object" || session === null) continue;
+    const namespace = session.namespace;
+    if (namespace !== void 0 && typeof namespace !== "string") {
+      throw new Error("delegate session namespace metadata must be a string");
+    }
+    return { namespace: typeof namespace === "string" ? namespace.trim() || void 0 : void 0 };
+  }
+  return void 0;
+}
+async function rememberedNamespacesFor(sessionKey, namespaceBindings) {
+  return namespaceBindings.namespacesFor(sessionKey);
+}
+async function rememberNamespace(sessionKey, namespace, namespaceBindings) {
+  if (namespace.length > SESSION_NAMESPACE_BINDING_MAX_NAMESPACE_LENGTH) {
+    throw new Error(
+      `delegate session namespace exceeds the daemon limit of ${SESSION_NAMESPACE_BINDING_MAX_NAMESPACE_LENGTH} characters`
+    );
+  }
+  try {
+    await namespaceBindings.remember(sessionKey, namespace);
+  } catch (err) {
+    log2.warn(`delegate namespace binding persistence failed: ${String(err)}`);
+    throw err;
+  }
+}
+async function sessionNamespaceFrom(sessionKey, event, ctx, fallback, namespaceBindings) {
+  const explicit = explicitSessionNamespaceFrom(sessionKey, event, ctx);
+  if (explicit !== void 0) {
+    await rememberNamespace(sessionKey, explicit.namespace ?? "", namespaceBindings);
+    return explicit.namespace;
+  }
+  const remembered = await rememberedNamespacesFor(sessionKey, namespaceBindings);
+  return remembered.length > 0 ? remembered.at(-1) || void 0 : fallback.trim() || void 0;
+}
+async function lifecycleSessionNamespacesFrom(sessionKey, event, ctx, fallback, namespaceBindings) {
+  const explicit = explicitSessionNamespaceFrom(sessionKey, event, ctx);
+  if (explicit !== void 0) {
+    await rememberNamespace(sessionKey, explicit.namespace ?? "", namespaceBindings);
+  }
+  const remembered = await rememberedNamespacesFor(sessionKey, namespaceBindings);
+  if (explicit !== void 0) {
+    const explicitNamespace = explicit.namespace ?? "";
+    const namespaces = remembered.includes(explicitNamespace) ? remembered : [...remembered, explicitNamespace];
+    return namespaces.map((namespace) => namespace || void 0);
+  }
+  if (remembered.length > 0) return remembered.map((namespace) => namespace || void 0);
+  return [fallback.trim() || void 0];
 }
 function readContextComposition(response, fallbackContext) {
   const candidate = response.contextComposition;
@@ -5712,7 +5805,8 @@ function readContextComposition(response, fallbackContext) {
   return { context: candidate.context };
 }
 function registerDelegateRuntime(api, options) {
-  const { target, namespace } = options;
+  const { target, namespace, namespaceBindings } = options;
+  const now = options.now ?? Date.now;
   if (options.passive) {
     log2.info(
       `[${options.serviceId}] bridge mode delegate: memory slot not owned \u2014 passive, no hooks registered`
@@ -5739,11 +5833,18 @@ function registerDelegateRuntime(api, options) {
           return void 0;
         }
         const cwd = cwdFrom(event, ctx, options.cwd);
+        const scopedNamespace = await sessionNamespaceFrom(
+          sessionKey,
+          event,
+          ctx,
+          namespace,
+          namespaceBindings
+        );
         const response = await postJson(
           target,
           options.serviceId,
           "/engram/v1/recall",
-          withNamespace(namespace, {
+          withNamespace(scopedNamespace, {
             query,
             sessionKey,
             mode: "auto",
@@ -5815,11 +5916,18 @@ function registerDelegateRuntime(api, options) {
     if (turn.length === 0) return;
     try {
       const cwd = cwdFrom(event, ctx, options.cwd);
+      const scopedNamespace = await sessionNamespaceFrom(
+        sessionKey,
+        event,
+        ctx,
+        namespace,
+        namespaceBindings
+      );
       await postJson(
         target,
         options.serviceId,
         "/engram/v1/observe",
-        withNamespace(namespace, {
+        withNamespace(scopedNamespace, {
           sessionKey,
           messages: turn,
           ...cwd ? { cwd } : {},
@@ -5831,25 +5939,129 @@ function registerDelegateRuntime(api, options) {
       log2.warn(`delegate observe failed: ${String(err)}`);
     }
   });
+  let cachedBatchFlushSupport;
+  let cachedBatchFlushSupportExpiresAt = 0;
+  let supportsBatchFlushPromise;
+  const invalidateCachedBatchFlushSupport = () => {
+    cachedBatchFlushSupport = void 0;
+    cachedBatchFlushSupportExpiresAt = 0;
+  };
+  const cacheBatchFlushSupport = (supported) => {
+    cachedBatchFlushSupport = supported;
+    cachedBatchFlushSupportExpiresAt = now() + DELEGATE_BATCH_FLUSH_CACHE_TTL_MS;
+  };
+  const supportsBatchFlush = (timeoutMs) => {
+    if (cachedBatchFlushSupport !== void 0) {
+      if (now() < cachedBatchFlushSupportExpiresAt) {
+        return Promise.resolve(cachedBatchFlushSupport);
+      }
+      invalidateCachedBatchFlushSupport();
+    }
+    if (supportsBatchFlushPromise !== void 0) return supportsBatchFlushPromise;
+    const probe = getJson(
+      target,
+      options.serviceId,
+      "/engram/v1/capabilities",
+      timeoutMs
+    ).then((response) => {
+      const isSuccessfulResponse = response.status >= 200 && response.status < 300;
+      if (isSuccessfulResponse && response.body !== null) {
+        const batchFlushSupport = response.body.lcmCompactionFlushBatch;
+        if (typeof batchFlushSupport === "boolean") {
+          cacheBatchFlushSupport(batchFlushSupport);
+          return batchFlushSupport;
+        }
+        return false;
+      }
+      if (response.status === 204 || response.status === 404 || response.status === 405 || response.status === 501) {
+        cacheBatchFlushSupport(false);
+      }
+      return false;
+    }).catch(() => false);
+    supportsBatchFlushPromise = probe.finally(() => {
+      supportsBatchFlushPromise = void 0;
+    });
+    return supportsBatchFlushPromise;
+  };
   const flushHandler = async (event, ctx) => {
-    const fromEvent = event?.sessionKey;
-    const sessionKey = typeof fromEvent === "string" && fromEvent.length > 0 ? fromEvent : sessionKeyFrom(event, ctx);
     try {
-      await postJson(
+      const deadline = Date.now() + options.flushTimeoutMs;
+      const remainingTimeout = () => Math.max(1, deadline - Date.now());
+      const sessionKey = lifecycleSessionKeyFrom(event, ctx);
+      if (sessionKey === void 0) {
+        log2.warn("delegate flush skipped: lifecycle event has malformed session key");
+        return false;
+      }
+      const namespaces = await lifecycleSessionNamespacesFrom(
+        sessionKey,
+        event,
+        ctx,
+        namespace,
+        namespaceBindings
+      );
+      const flushNamespace = (sessionNamespace) => postJson(
         target,
         options.serviceId,
         "/engram/v1/lcm/compaction/flush",
-        withNamespace(namespace, { sessionKey }),
-        options.flushTimeoutMs
+        withNamespace(sessionNamespace, { sessionKey }),
+        remainingTimeout()
       );
+      const flushIndividually = async () => {
+        const outcomes = await Promise.allSettled(namespaces.map(flushNamespace));
+        return outcomes.every(
+          (outcome) => outcome.status === "fulfilled" && outcome.value !== null && outcome.value.flushed === true
+        );
+      };
+      if (namespaces.length <= 1 || await supportsBatchFlush(remainingTimeout())) {
+        if (namespaces.length <= 1) {
+          const response = await flushNamespace(namespaces[0]);
+          return response !== null && response.flushed === true;
+        }
+        try {
+          const response = await postJson(
+            target,
+            options.serviceId,
+            "/engram/v1/lcm/compaction/flush",
+            {
+              sessionKey,
+              namespaces: namespaces.map((sessionNamespace) => sessionNamespace ?? "")
+            },
+            remainingTimeout()
+          );
+          if (response === null) {
+            invalidateCachedBatchFlushSupport();
+            return flushIndividually();
+          }
+          const responseNamespaces = response.namespaces;
+          const responseResults = response.results;
+          const isBatchResponse = Array.isArray(responseNamespaces) && Array.isArray(responseResults) && responseNamespaces.length === namespaces.length && responseNamespaces.every(
+            (responseNamespace, index) => responseNamespace === (namespaces[index] ?? "")
+          ) && responseResults.length === namespaces.length;
+          if (!isBatchResponse) {
+            invalidateCachedBatchFlushSupport();
+            return flushIndividually();
+          }
+          if (response.flushed !== true) {
+            invalidateCachedBatchFlushSupport();
+            return false;
+          }
+          return true;
+        } catch {
+          invalidateCachedBatchFlushSupport();
+          return flushIndividually();
+        }
+      }
+      return flushIndividually();
     } catch (err) {
       log2.warn(`delegate flush failed: ${String(err)}`);
+      return false;
     }
   };
   api.on("before_compaction", flushHandler);
   if (options.flushOnResetEnabled) {
-    api.on("before_reset", flushHandler);
-    api.on("session_end", flushHandler);
+    const flushEndedSession = async (event, ctx) => flushHandler(event, ctx);
+    api.on("before_reset", flushEndedSession);
+    api.on("session_end", flushEndedSession);
   }
   log2.info(
     `[${options.serviceId}] bridge mode delegate: memory loop backed by daemon at ${target.host}:${target.port} (embedded orchestrator skipped; tools/CLI/surfaces stay daemon-side)`
@@ -5858,7 +6070,130 @@ function registerDelegateRuntime(api, options) {
 function activeDelegateAuthorizationOperations(options) {
   return options.allowPromptInjection && options.recallBudgetChars !== 0 ? DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS : DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS.slice(1);
 }
+var delegateNamespaceMigrationChains = /* @__PURE__ */ new Map();
+var queueDelegateNamespaceMigration = (bindingPath, sessionKey, operation) => {
+  let sessionChains = delegateNamespaceMigrationChains.get(bindingPath);
+  if (sessionChains === void 0) {
+    sessionChains = /* @__PURE__ */ new Map();
+    delegateNamespaceMigrationChains.set(bindingPath, sessionChains);
+  }
+  const prior = sessionChains.get(sessionKey) ?? Promise.resolve();
+  const run = prior.catch(() => void 0).then(operation);
+  const settled = run.then(
+    () => void 0,
+    () => void 0
+  );
+  sessionChains.set(sessionKey, settled);
+  void settled.then(() => {
+    if (sessionChains?.get(sessionKey) !== settled) return;
+    sessionChains.delete(sessionKey);
+    if (sessionChains.size === 0 && delegateNamespaceMigrationChains.get(bindingPath) === sessionChains) {
+      delegateNamespaceMigrationChains.delete(bindingPath);
+    }
+  });
+  return run;
+};
+function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapterActive) {
+  const bindingPath = (pluginId) => path4.join(memoryDir, "state", "plugins", pluginId, "session-namespace-bindings.json");
+  const primaryPath = bindingPath(serviceId);
+  const primary = createFileSessionNamespaceBindingStore(primaryPath);
+  if (serviceId !== REMNIC_OPENCLAW_PLUGIN_ID) return primary;
+  const legacy = createFileSessionNamespaceBindingStore(
+    bindingPath(REMNIC_OPENCLAW_LEGACY_PLUGIN_ID)
+  );
+  const migratedLegacySessions = /* @__PURE__ */ new Set();
+  const rememberMigratedLegacySession = (sessionKey) => {
+    if (migratedLegacySessions.has(sessionKey)) return;
+    migratedLegacySessions.add(sessionKey);
+    while (migratedLegacySessions.size > SESSION_NAMESPACE_BINDING_MAX_ENTRIES) {
+      const oldest = migratedLegacySessions.values().next().value;
+      if (oldest === void 0) return;
+      migratedLegacySessions.delete(oldest);
+    }
+  };
+  const queueSessionMigration = (sessionKey, operation) => queueDelegateNamespaceMigration(primaryPath, sessionKey, operation);
+  const readLegacyNamespaces = async (sessionKey, current) => {
+    if (!isLegacyAdapterActive() && migratedLegacySessions.has(sessionKey)) return [];
+    try {
+      const previous = await legacy.namespacesFor(sessionKey);
+      if (previous.length === 0) rememberMigratedLegacySession(sessionKey);
+      return previous;
+    } catch (err) {
+      if (current.length > 0) {
+        log2.warn(
+          `[${serviceId}] delegate legacy namespace read failed; using canonical bindings: ${String(err)}`
+        );
+        return [];
+      }
+      throw err;
+    }
+  };
+  const mergeNamespaceHistory = (current, previous) => {
+    const merged = [];
+    for (const remembered of [...previous, ...current]) {
+      const existing = merged.indexOf(remembered);
+      if (existing >= 0) merged.splice(existing, 1);
+      merged.push(remembered);
+    }
+    return merged.slice(-SESSION_NAMESPACE_BINDING_MAX_NAMESPACES);
+  };
+  const persistNamespaceHistory = async (store, sessionKey, namespaces) => {
+    if (store.replace !== void 0) {
+      await store.replace(sessionKey, namespaces);
+      return;
+    }
+    for (const namespace of namespaces) {
+      await store.remember(sessionKey, namespace);
+    }
+  };
+  const completeLegacyMigration = async (sessionKey) => {
+    if (!isLegacyAdapterActive()) {
+      try {
+        await legacy.replace?.(sessionKey, []);
+      } catch (err) {
+        log2.warn(`[${serviceId}] delegate legacy namespace cleanup failed: ${String(err)}`);
+      }
+    }
+    rememberMigratedLegacySession(sessionKey);
+  };
+  return {
+    async namespacesFor(sessionKey) {
+      return queueSessionMigration(sessionKey, async () => {
+        const current = await primary.namespacesFor(sessionKey);
+        const previous = await readLegacyNamespaces(sessionKey, current);
+        if (previous.length === 0) return current;
+        const merged = mergeNamespaceHistory(current, previous);
+        const hasMissingLegacy = previous.some((remembered) => !current.includes(remembered));
+        if (!hasMissingLegacy) {
+          await completeLegacyMigration(sessionKey);
+          return current;
+        }
+        try {
+          await persistNamespaceHistory(primary, sessionKey, merged);
+          await completeLegacyMigration(sessionKey);
+        } catch (err) {
+          log2.warn(`[${serviceId}] delegate namespace migration failed: ${String(err)}`);
+        }
+        return merged;
+      });
+    },
+    async remember(sessionKey, namespace) {
+      return queueSessionMigration(sessionKey, async () => {
+        const current = await primary.namespacesFor(sessionKey);
+        const previous = await readLegacyNamespaces(sessionKey, current);
+        if (previous.length === 0) {
+          await primary.remember(sessionKey, namespace);
+          return;
+        }
+        const merged = mergeNamespaceHistory([...current, namespace], previous);
+        await persistNamespaceHistory(primary, sessionKey, merged);
+        await completeLegacyMigration(sessionKey);
+      });
+    }
+  };
+}
 var delegateHookApiServices = /* @__PURE__ */ new WeakMap();
+var delegateActiveServiceIds = /* @__PURE__ */ new Set();
 var delegateEmbeddedFallbackApis = /* @__PURE__ */ new WeakSet();
 var delegateAuthorizationPreflightServices = /* @__PURE__ */ new WeakMap();
 function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkDaemonHealthSync }) {
@@ -5898,6 +6233,7 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     (boundServices ?? delegateHookApiServices.set(api, /* @__PURE__ */ new Set()).get(api))?.add(
       options.serviceId
     );
+    delegateActiveServiceIds.add(options.serviceId);
   }
   const toggleStore = options.sessionTogglesEnabled ? createFileToggleStore(
     path4.join(options.memoryDir, "state", "plugins", options.serviceId, "session-toggles.json"),
@@ -5914,6 +6250,11 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     serviceId: options.serviceId,
     target,
     namespace: "",
+    namespaceBindings: createDelegateNamespaceBindingStore(
+      options.memoryDir,
+      options.serviceId,
+      () => delegateActiveServiceIds.has(REMNIC_OPENCLAW_LEGACY_PLUGIN_ID)
+    ),
     allowPromptInjection: options.allowPromptInjection,
     passive: options.passive,
     gateHeartbeatTurns: options.gateHeartbeatTurns,