@remnic/plugin-openclaw 9.69.60 → 9.69.63

package/dist/index.js

@@ -19,7 +19,7 @@ import OpenAI from "openai";
 import { createRequire } from "module";
 import { createHash as createHash3 } from "crypto";
 import { parseConfig } from "@remnic/core/config";
-import { initLogger, log as log8 } from "@remnic/core/logger";
+import { initLogger, log as log9 } from "@remnic/core/logger";
 import {
   detectSdkCapabilities
 } from "@remnic/core/sdk-compat";
@@ -450,7 +450,117 @@ function formatContinuityLoopSummary(loop) {
   if (loop.notes) lines.push(`Notes: ${loop.notes}`);
   return lines.join("\n");
 }
-function registerTools(api, orchestrator, hostRuntimeAgentId) {
+function buildLegacyMemorySearchTool(orchestrator) {
+  return {
+    name: "memory_search",
+    label: "Search Memory",
+    description: `Search local memory files using QMD's semantic index. Returns matching memories with snippets and relevance scores.
+
+Returns: Matching memory entries ranked by relevance
+Cost: Free (local index query)
+Speed: Fast
+
+Best for:
+- Finding previously learned facts about the user
+- Checking what you know about a topic
+- Locating past decisions or corrections`,
+    parameters: Type2.Object({
+      query: Type2.String({
+        description: "Search query \u2014 keywords, phrases, or natural language"
+      }),
+      namespace: Type2.Optional(
+        Type2.String({
+          description: "Optional namespace filter. When set, only returns results under memoryDir/namespaces/<namespace>/ (default namespace uses legacy root)."
+        })
+      ),
+      maxResults: Type2.Optional(
+        Type2.Number({
+          description: "Maximum results (default: 8)",
+          minimum: 1,
+          maximum: 50
+        })
+      ),
+      collection: Type2.Optional(
+        Type2.String({
+          description: "QMD collection to search. Omit for memory collection, use 'global' for all collections."
+        })
+      )
+    }),
+    async execute(_toolCallId, params) {
+      const { query, maxResults, collection, namespace } = params;
+      const namespaceFilter = namespace && namespace.length > 0 ? namespace : void 0;
+      const resultLimit = normalizeMemorySearchResultLimit(maxResults);
+      const searchCandidates = async (limit) => collection === "global" && !namespaceFilter ? await orchestrator.qmd.searchGlobal(query, limit) : await orchestrator.searchAcrossNamespaces({
+        query,
+        namespaces: namespaceFilter ? [namespaceFilter] : void 0,
+        maxResults: limit,
+        mode: "search"
+      });
+      let candidateLimit = resultLimit;
+      const privateVisibilityCache = /* @__PURE__ */ new Map();
+      let candidates = await searchCandidates(candidateLimit);
+      let filtered = await orchestrator.filterPrivateSearchResults(
+        candidates,
+        namespaceFilter ? [namespaceFilter] : [],
+        false,
+        privateVisibilityCache
+      );
+      while (filtered.length < resultLimit && candidates.length >= candidateLimit && candidateLimit < MEMORY_SEARCH_CANDIDATE_CAP) {
+        const nextCandidateLimit = Math.min(
+          MEMORY_SEARCH_CANDIDATE_CAP,
+          Math.max(candidateLimit + 16, candidateLimit * 2)
+        );
+        if (nextCandidateLimit === candidateLimit) break;
+        const nextCandidates = await searchCandidates(nextCandidateLimit);
+        if (nextCandidates.length <= candidates.length) break;
+        candidateLimit = nextCandidateLimit;
+        candidates = nextCandidates;
+        filtered = await orchestrator.filterPrivateSearchResults(
+          candidates,
+          namespaceFilter ? [namespaceFilter] : [],
+          false,
+          privateVisibilityCache
+        );
+      }
+      filtered = filtered.slice(0, resultLimit);
+      if (filtered.length === 0) {
+        return toolResult2(`No memories found matching: "${query}"`);
+      }
+      const formatted = filtered.map((r, i) => {
+        const snippet = r.snippet ? r.snippet.slice(0, 800) : "(no preview)";
+        return `### [${i + 1}] ${r.path}
+Score: ${r.score.toFixed(3)}
+
+\`\`\`
+${snippet}
+\`\`\``;
+      }).join("\n\n");
+      return toolResult2(
+        `## Memory Search: "${query}"
+
+${filtered.length} result(s)
+
+${formatted}`
+      );
+    }
+  };
+}
+function buildLegacyMemorySearchToolForPublicShape(orchestrator) {
+  const legacy = buildLegacyMemorySearchTool(orchestrator);
+  return {
+    ...legacy,
+    async execute(toolCallId, params) {
+      const filters = params.filters && typeof params.filters === "object" ? params.filters : void 0;
+      return legacy.execute(toolCallId, {
+        query: params.query,
+        ...typeof params.limit === "number" ? { maxResults: params.limit } : {},
+        ...typeof filters?.namespace === "string" ? { namespace: filters.namespace } : {},
+        ...typeof filters?.collection === "string" ? { collection: filters.collection } : {}
+      });
+    }
+  };
+}
+function registerTools(api, orchestrator, hostRuntimeAgentId, reservedToolNames = []) {
   const useDedicatedOpenClawMemoryTools = orchestrator.config.openclawToolsEnabled !== false;
   const actionTypes = [
     "store_episode",
@@ -551,103 +661,8 @@ Content: ${content}`
       }
     }
   }
-  if (!useDedicatedOpenClawMemoryTools) {
-    api.registerTool(
-      {
-        name: "memory_search",
-        label: "Search Memory",
-        description: `Search local memory files using QMD's semantic index. Returns matching memories with snippets and relevance scores.
-
-Returns: Matching memory entries ranked by relevance
-Cost: Free (local index query)
-Speed: Fast
-
-Best for:
-- Finding previously learned facts about the user
-- Checking what you know about a topic
-- Locating past decisions or corrections`,
-        parameters: Type2.Object({
-          query: Type2.String({
-            description: "Search query \u2014 keywords, phrases, or natural language"
-          }),
-          namespace: Type2.Optional(
-            Type2.String({
-              description: "Optional namespace filter. When set, only returns results under memoryDir/namespaces/<namespace>/ (default namespace uses legacy root)."
-            })
-          ),
-          maxResults: Type2.Optional(
-            Type2.Number({
-              description: "Maximum results (default: 8)",
-              minimum: 1,
-              maximum: 50
-            })
-          ),
-          collection: Type2.Optional(
-            Type2.String({
-              description: "QMD collection to search. Omit for memory collection, use 'global' for all collections."
-            })
-          )
-        }),
-        async execute(_toolCallId, params) {
-          const { query, maxResults, collection, namespace } = params;
-          const namespaceFilter = namespace && namespace.length > 0 ? namespace : void 0;
-          const resultLimit = normalizeMemorySearchResultLimit(maxResults);
-          const searchCandidates = async (limit) => collection === "global" && !namespaceFilter ? await orchestrator.qmd.searchGlobal(query, limit) : await orchestrator.searchAcrossNamespaces({
-            query,
-            namespaces: namespaceFilter ? [namespaceFilter] : void 0,
-            maxResults: limit,
-            mode: "search"
-          });
-          let candidateLimit = resultLimit;
-          const privateVisibilityCache = /* @__PURE__ */ new Map();
-          let candidates = await searchCandidates(candidateLimit);
-          let filtered = await orchestrator.filterPrivateSearchResults(
-            candidates,
-            namespaceFilter ? [namespaceFilter] : [],
-            false,
-            privateVisibilityCache
-          );
-          while (filtered.length < resultLimit && candidates.length >= candidateLimit && candidateLimit < MEMORY_SEARCH_CANDIDATE_CAP) {
-            const nextCandidateLimit = Math.min(
-              MEMORY_SEARCH_CANDIDATE_CAP,
-              Math.max(candidateLimit + 16, candidateLimit * 2)
-            );
-            if (nextCandidateLimit === candidateLimit) break;
-            const nextCandidates = await searchCandidates(nextCandidateLimit);
-            if (nextCandidates.length <= candidates.length) break;
-            candidateLimit = nextCandidateLimit;
-            candidates = nextCandidates;
-            filtered = await orchestrator.filterPrivateSearchResults(
-              candidates,
-              namespaceFilter ? [namespaceFilter] : [],
-              false,
-              privateVisibilityCache
-            );
-          }
-          filtered = filtered.slice(0, resultLimit);
-          if (filtered.length === 0) {
-            return toolResult2(`No memories found matching: "${query}"`);
-          }
-          const formatted = filtered.map((r, i) => {
-            const snippet = r.snippet ? r.snippet.slice(0, 800) : "(no preview)";
-            return `### [${i + 1}] ${r.path}
-Score: ${r.score.toFixed(3)}
-
-\`\`\`
-${snippet}
-\`\`\``;
-          }).join("\n\n");
-          return toolResult2(
-            `## Memory Search: "${query}"
-
-${filtered.length} result(s)
-
-${formatted}`
-          );
-        }
-      },
-      { name: "memory_search" }
-    );
+  if (!useDedicatedOpenClawMemoryTools && !reservedToolNames.includes("memory_search")) {
+    api.registerTool(buildLegacyMemorySearchTool(orchestrator), { name: "memory_search" });
   }
   api.registerTool(
     {
@@ -3026,8 +3041,8 @@ var EngramAccessService = class extends CoreEngramAccessService {
 
 // ../../src/index.ts
 import { EngramAccessHttpServer } from "@remnic/core/access-http";
-import path11 from "path";
-import os from "os";
+import path13 from "path";
+import os2 from "os";
 import { createOpikExporter } from "@remnic/core/opik-exporter";
 import { readEnvVar, resolveHomeDir as resolveHomeDir3 } from "@remnic/core/runtime/env";
 import { displayErrorDetail } from "@remnic/core/runtime/better-sqlite";
@@ -5232,11 +5247,11 @@ async function processOpenClawFlushPlanFile(params) {
 }
 
 // src/delegate-runtime.ts
-import path9 from "path";
+import path11 from "path";
 import {
   renderMemoryContextPrompt
 } from "@remnic/core";
-import { log as log7 } from "@remnic/core/logger";
+import { log as log8 } from "@remnic/core/logger";
 
 // src/delegate-authorization.ts
 import { log as log2 } from "@remnic/core/logger";
@@ -5244,10 +5259,62 @@ import { log as log2 } from "@remnic/core/logger";
 // src/bridge.ts
 import fs3 from "fs";
 import path6 from "path";
-import { isIPv6 } from "net";
+
+// src/bridge-daemon-host.ts
+import { isIP, isIPv6 } from "net";
+import os from "os";
+import { isLoopbackHost } from "@remnic/core/runtime/http-transport.js";
+var LOOPBACK_V4 = "127.0.0.1";
+function isLoopbackDaemonHost(host) {
+  const normalized = host.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
+  if (loopbackForSameHost(normalized) !== void 0) return true;
+  return isLoopbackHost(normalized);
+}
+function canonicalIPv6(value) {
+  if (!isIPv6(value)) return void 0;
+  try {
+    return new URL(`http://[${value}]`).hostname.replace(/^\[/, "").replace(/\]$/, "");
+  } catch {
+    return value;
+  }
+}
+function loopbackForSameHost(host) {
+  const normalized = host.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
+  if (normalized === "0.0.0.0") return LOOPBACK_V4;
+  const v6 = canonicalIPv6(normalized);
+  if (v6 === "::") return "::1";
+  const local = localInterfaceFamily(v6 ?? normalized);
+  if (local === void 0) return void 0;
+  return local === "IPv4" ? LOOPBACK_V4 : "::1";
+}
+function sameHostDialFallback(host) {
+  const normalized = host.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
+  return localInterfaceFamily(canonicalIPv6(normalized) ?? normalized) === void 0 ? void 0 : normalized;
+}
+function localInterfaceFamily(address) {
+  if (isIP(address) === 0) return void 0;
+  for (const entries of Object.values(os.networkInterfaces())) {
+    for (const entry of entries ?? []) {
+      if (entry.internal) continue;
+      if (entry.family === "IPv6") {
+        if (canonicalIPv6(entry.address.replace(/%.*$/, "")) === address) return "IPv6";
+        continue;
+      }
+      if (entry.address === address || canonicalIPv6(`::ffff:${entry.address}`) === address) {
+        return "IPv4";
+      }
+    }
+  }
+  return void 0;
+}
+function normalizeDaemonHost(value) {
+  const match = value.trim().match(/^\[(.+)\]$/);
+  return match ? match[1] : value.trim();
+}
+
+// src/bridge.ts
 import { Worker } from "worker_threads";
 import { configPathCandidates, readCompatEnv } from "@remnic/core";
-import { isLoopbackHost } from "@remnic/core/runtime/http-transport.js";
 
 // src/bridge-health-worker.ts
 function runHealthWorker(request, data) {
@@ -6047,29 +6114,6 @@ function isDaemonRunning() {
   }
   return false;
 }
-function isLoopbackDaemonHost(host) {
-  const normalized = host.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
-  if (loopbackForWildcardBind(normalized) !== void 0) return true;
-  return isLoopbackHost(normalized);
-}
-function canonicalIPv6(value) {
-  if (!isIPv6(value)) return void 0;
-  try {
-    return new URL(`http://[${value}]`).hostname.replace(/^\[/, "").replace(/\]$/, "");
-  } catch {
-    return value;
-  }
-}
-function loopbackForWildcardBind(host) {
-  const normalized = host.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
-  if (normalized === "0.0.0.0") return DEFAULT_HOST;
-  if (canonicalIPv6(normalized) === "::") return "::1";
-  return void 0;
-}
-function normalizeDaemonHost(value) {
-  const match = value.trim().match(/^\[(.+)\]$/);
-  return match ? match[1] : value.trim();
-}
 function coerceDaemonPort(value) {
   const parsed = typeof value === "string" && value.trim() !== "" ? Number(value.trim()) : value;
   return typeof parsed === "number" && Number.isInteger(parsed) && parsed > 0 && parsed <= 65535 ? parsed : void 0;
@@ -6158,7 +6202,7 @@ function shouldProbeDaemonHealth(host) {
 }
 function readDaemonHost() {
   const resolved = readConfiguredDaemonHost();
-  return loopbackForWildcardBind(resolved) ?? resolved;
+  return loopbackForSameHost(resolved) ?? resolved;
 }
 function readDaemonServerConfig() {
   for (const candidate of configPathCandidates()) {
@@ -6196,39 +6240,40 @@ function daemonEndpointCandidates(unitExists) {
     const resolvedHost = normalizeDaemonHost(
       envHost !== void 0 && envHost.trim() !== "" ? envHost : host ?? DEFAULT_HOST
     );
-    const dialHost = loopbackForWildcardBind(resolvedHost) ?? resolvedHost;
+    const dialHost = loopbackForSameHost(resolvedHost) ?? resolvedHost;
+    const dialFallback = sameHostDialFallback(resolvedHost);
     const dialPort = envPort ?? port ?? DEFAULT_PORT;
     const token = authTokenOverride ?? loadDaemonAuth(configPath).token;
     const configToken = configPath === void 0 ? void 0 : readServerBlock(configPath)?.authToken;
     const fallbackToken = configToken !== void 0 && configToken !== token ? configToken : void 0;
-    if (candidates.some(
-      (c) => c.host === dialHost && c.port === dialPort && c.token === token && // The BOUND credential is part of the identity too: when a gateway
-      // token wins for both, two configs on one endpoint resolve the same
-      // primary token but carry different fallbacks, and dropping the
-      // second would leave the daemon's real credential untried.
-      c.fallbackToken === fallbackToken && // So is the UNIT the credential is re-read from per request: two
-      // units can agree today and diverge on the next rotation.
-      c.authTokenUnit?.unitPath === authTokenUnit?.unitPath && // And so is the CONFIG, for the same reason: `daemonConfigPath` is
-      // re-read per request, so collapsing two configs that agree today
-      // would keep sending the retained one's token after the other
-      // rotates.
-      c.configPath === configPath
-    )) {
-      return;
+    for (const candidateHost of dialFallback === void 0 ? [dialHost] : [dialHost, dialFallback]) {
+      if (candidates.some(
+        (c) => c.host === candidateHost && c.port === dialPort && c.token === token && // The BOUND credential is part of the identity too: when a gateway
+        // token wins for both, two configs on one endpoint resolve the same
+        // primary token but carry different fallbacks, and dropping the
+        // second would leave the daemon's real credential untried.
+        c.fallbackToken === fallbackToken && // So is the UNIT the credential is re-read from per request: two
+        // units can agree today and diverge on the next rotation.
+        c.authTokenUnit?.unitPath === authTokenUnit?.unitPath && // And so is the CONFIG, for the same reason: `daemonConfigPath` is
+        // re-read per request, so collapsing two configs that agree today
+        // would keep sending the retained one's token after the other
+        // rotates.
+        c.configPath === configPath
+      )) {
+        continue;
+      }
+      candidates.push({
+        host: candidateHost,
+        port: dialPort,
+        configPath,
+        token,
+        aliasGroup: `${resolvedHost}\0${dialPort}\0${configPath ?? ""}\0${token}`,
+        ...authTokenOverride === void 0 ? {} : { authTokenOverride },
+        ...authTokenUnit === void 0 ? {} : { authTokenUnit },
+        ...fallbackToken === void 0 ? {} : { fallbackToken }
+      });
     }
-    candidates.push({
-      host: dialHost,
-      port: dialPort,
-      configPath,
-      token,
-      ...authTokenOverride === void 0 ? {} : { authTokenOverride },
-      ...authTokenUnit === void 0 ? {} : { authTokenUnit },
-      ...fallbackToken === void 0 ? {} : { fallbackToken }
-    });
   };
-  if (envHost !== void 0 && envHost.trim() !== "" || envPort !== void 0) {
-    add(void 0, void 0);
-  }
   const configOrder = configPathCandidates();
   const envConfigPath = readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH") ? configOrder[0] : void 0;
   const addConfigCandidate = (candidate) => {
@@ -6294,14 +6339,16 @@ function detectDaemonBridgeMode(options) {
     }
     probeable.push(candidate);
   }
-  let probed = 0;
+  const groupDeadlines = /* @__PURE__ */ new Map();
+  const totalGroups = new Set(probeable.map((candidate) => candidate.aliasGroup)).size;
   for (const {
     host: daemonHost,
     port: daemonPort,
     configPath,
     authTokenOverride,
     authTokenUnit,
-    fallbackToken
+    fallbackToken,
+    aliasGroup
   } of probeable) {
     const remainingMs = deadline - Date.now();
     if (remainingMs <= 0) {
@@ -6310,12 +6357,15 @@ function detectDaemonBridgeMode(options) {
       );
       break;
     }
-    const perCandidateMs = Math.max(
-      1,
-      Math.ceil(remainingMs / Math.max(1, probeable.length - probed))
-    );
-    probed += 1;
-    const candidateDeadline = Date.now() + Math.min(remainingMs, perCandidateMs);
+    const started = groupDeadlines.get(aliasGroup);
+    if (started === void 0) {
+      const perGroupMs = Math.max(
+        1,
+        Math.ceil(remainingMs / Math.max(1, totalGroups - groupDeadlines.size))
+      );
+      groupDeadlines.set(aliasGroup, Date.now() + Math.min(remainingMs, perGroupMs));
+    }
+    const candidateDeadline = groupDeadlines.get(aliasGroup) ?? Date.now();
     const firstAttemptMs = candidateDeadline - Date.now();
     if (firstAttemptMs <= 0) {
       options.onSkip?.(
@@ -6421,10 +6471,13 @@ function resolveBridgeMode(configBridgeMode, options = {}) {
     });
   }
   const selectedConfig = selectedDaemonConfigPath();
+  const configuredHost = readConfiguredDaemonHost();
+  const fallbackHost = sameHostDialFallback(configuredHost);
   return {
     mode: requested,
-    daemonHost: readDaemonHost(),
+    daemonHost: loopbackForSameHost(configuredHost) ?? configuredHost,
     daemonPort: readDaemonPort(),
+    ...fallbackHost === void 0 ? {} : { daemonHostFallback: fallbackHost },
     ...selectedConfig === void 0 ? {} : { daemonConfigPath: selectedConfig }
   };
 }
@@ -6603,114 +6656,234 @@ async function probeDelegateAuthorization(target, namespace = "", operations = D
   return { state: "unavailable", tokenSource: auth.source };
 }
 
-// src/delegate-runtime.ts
+// src/delegate-namespace-bindings.ts
+import path7 from "path";
+import { log as log3 } from "@remnic/core/logger";
 import {
   SESSION_NAMESPACE_BINDING_MAX_ENTRIES,
-  SESSION_NAMESPACE_BINDING_MAX_NAMESPACES as SESSION_NAMESPACE_BINDING_MAX_NAMESPACES2,
+  SESSION_NAMESPACE_BINDING_MAX_NAMESPACES,
   createFileSessionNamespaceBindingStore
 } from "@remnic/core/session-namespace-bindings";
-
-// src/delegate-namespaces.ts
-import {
-  SESSION_NAMESPACE_BINDING_MAX_NAMESPACE_LENGTH
-} from "@remnic/core/session-namespace-bindings";
-import { log as log3 } from "@remnic/core/logger";
-async function withNamespace(namespace, body, resolveScopedNamespace) {
-  const scoped = await resolveScopedNamespace(namespace || void 0);
-  return scoped === void 0 ? body : { ...body, namespace: scoped };
-}
-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) {
-    log3.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);
+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);
   }
-  if (remembered.length > 0) return remembered.map((namespace) => namespace || void 0);
-  return [fallback.trim() || void 0];
-}
-
-// src/delegate-daemon-target.ts
-function daemonTargetFor(bridge) {
-  const invalidatedCredentials = /* @__PURE__ */ new Set();
-  const invalidated = (token) => invalidatedCredentials.has(`daemon configuration\0${token}`);
-  return {
-    host: bridge.daemonHost,
-    port: bridge.daemonPort,
-    invalidateAuthToken: (auth) => {
-      invalidatedCredentials.add(`${auth.source}\0${auth.token}`);
-    },
-    resolveAuthToken: () => {
-      if (bridge.daemonAuthTokenOverride !== void 0 && !invalidated(bridge.daemonAuthTokenOverride)) {
-        const unit = bridge.daemonAuthUnit === void 0 ? void 0 : readUnitAuthToken(bridge.daemonAuthUnit);
-        if (unit?.readable === true && unit.token !== void 0 && !invalidated(unit.token)) {
-          return { token: unit.token, source: "daemon configuration" };
-        }
-        if ((unit === void 0 || unit.readable === false) && !invalidated(bridge.daemonAuthTokenOverride)) {
-          return { token: bridge.daemonAuthTokenOverride, source: "daemon configuration" };
-        }
-        if (bridge.daemonConfigPath !== void 0) {
-          const configToken = readDaemonConfigAuthToken(bridge.daemonConfigPath);
-          if (configToken !== void 0 && !invalidated(configToken)) {
-            return { token: configToken, source: "daemon configuration" };
-          }
-        }
-      }
-      if (bridge.daemonAuthPrefersConfig && bridge.daemonConfigPath !== void 0) {
-        const configToken = readDaemonConfigAuthToken(bridge.daemonConfigPath);
-        if (configToken !== void 0 && !invalidated(configToken)) {
-          return { token: configToken, source: "daemon configuration" };
-        }
+  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) => path7.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) {
+        log3.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) {
+        log3.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) {
+          log3.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);
+      });
+    }
+  };
+}
+
+// src/delegate-namespaces.ts
+import {
+  SESSION_NAMESPACE_BINDING_MAX_NAMESPACE_LENGTH
+} from "@remnic/core/session-namespace-bindings";
+import { log as log4 } from "@remnic/core/logger";
+async function withNamespace(namespace, body, resolveScopedNamespace) {
+  const scoped = await resolveScopedNamespace(namespace || void 0);
+  return scoped === void 0 ? body : { ...body, namespace: scoped };
+}
+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) {
+    log4.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];
+}
+
+// src/delegate-daemon-target.ts
+function daemonTargetFor(bridge) {
+  const invalidatedCredentials = /* @__PURE__ */ new Set();
+  const invalidated = (token) => invalidatedCredentials.has(`daemon configuration\0${token}`);
+  return {
+    host: bridge.daemonHost,
+    port: bridge.daemonPort,
+    invalidateAuthToken: (auth) => {
+      invalidatedCredentials.add(`${auth.source}\0${auth.token}`);
+    },
+    resolveAuthToken: () => {
+      if (bridge.daemonAuthTokenOverride !== void 0 && !invalidated(bridge.daemonAuthTokenOverride)) {
+        const unit = bridge.daemonAuthUnit === void 0 ? void 0 : readUnitAuthToken(bridge.daemonAuthUnit);
+        if (unit?.readable === true && unit.token !== void 0 && !invalidated(unit.token)) {
+          return { token: unit.token, source: "daemon configuration" };
+        }
+        if ((unit === void 0 || unit.readable === false) && !invalidated(bridge.daemonAuthTokenOverride)) {
+          return { token: bridge.daemonAuthTokenOverride, source: "daemon configuration" };
+        }
+        if (bridge.daemonConfigPath !== void 0) {
+          const configToken = readDaemonConfigAuthToken(bridge.daemonConfigPath);
+          if (configToken !== void 0 && !invalidated(configToken)) {
+            return { token: configToken, source: "daemon configuration" };
+          }
+        }
+      }
+      if (bridge.daemonAuthPrefersConfig && bridge.daemonConfigPath !== void 0) {
+        const configToken = readDaemonConfigAuthToken(bridge.daemonConfigPath);
+        if (configToken !== void 0 && !invalidated(configToken)) {
+          return { token: configToken, source: "daemon configuration" };
+        }
       }
       return loadDaemonAuth(bridge.daemonConfigPath, invalidatedCredentials);
     }
@@ -6720,14 +6893,14 @@ function daemonTargetFor(bridge) {
 // src/delegate-flush-plan-ingest.ts
 import { constants as constants2 } from "fs";
 import { lstat as lstat4, open as open2, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
-import path8 from "path";
-import { log as log4 } from "@remnic/core/logger";
+import path9 from "path";
+import { log as log5 } from "@remnic/core/logger";
 import { withHeldFileLock } from "@remnic/core/utils/serialize-mutations";
 
 // src/delegate-flush-plan-directory.ts
 import { constants } from "fs";
 import { lstat as lstat3, open, stat as stat2 } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 function buildSnapshotPaths(planPath) {
   return {
     plan: planPath,
@@ -6746,7 +6919,7 @@ function descriptorDirectoryRoot(platform = process.platform) {
 async function pinSnapshotDirectory(paths, options = {}) {
   const descriptorRoot = options.descriptorRoot ?? descriptorDirectoryRoot();
   if (descriptorRoot === void 0) return { kind: "unsupported" };
-  const directory = path7.dirname(paths.plan);
+  const directory = path8.dirname(paths.plan);
   let before;
   try {
     before = await lstat3(directory);
@@ -6767,7 +6940,7 @@ async function pinSnapshotDirectory(paths, options = {}) {
       await closeQuietly(handle);
       return { kind: "unstable" };
     }
-    const pinnedDirectory = path7.join(descriptorRoot, String(handle.fd));
+    const pinnedDirectory = path8.join(descriptorRoot, String(handle.fd));
     let anchored;
     try {
       anchored = await stat2(pinnedDirectory);
@@ -6796,7 +6969,7 @@ async function pinSnapshotDirectory(paths, options = {}) {
   }
 }
 function anchoredChild(pinnedDirectory, realPath) {
-  return path7.join(pinnedDirectory, path7.basename(realPath));
+  return path8.join(pinnedDirectory, path8.basename(realPath));
 }
 function isSameInode(left, right) {
   return left.dev === right.dev && left.ino === right.ino;
@@ -6890,14 +7063,14 @@ var MAX_RECLAIM_PASSES = 4;
 async function ingestFlushPlanNotes(options) {
   if (options.workspaceDir === void 0) return;
   const workspaceDir = options.workspaceDir;
-  const planPath = path8.join(
+  const planPath = path9.join(
     workspaceDir,
     ...buildMemoryFlushPlan({ serviceId: options.serviceId }).relativePath.split("/")
   );
   const paths = buildSnapshotPaths(planPath);
   for (const candidate of [paths.plan, paths.inflight, paths.rotating, paths.oversized]) {
     if (await isLinkFreeUnder(workspaceDir, candidate)) continue;
-    log4.warn(
+    log5.warn(
       `[${options.serviceId}] flush-plan ingestion skipped: ${candidate}, a parent, or the workspace root is a symlink`
     );
     return;
@@ -6908,21 +7081,21 @@ async function ingestFlushPlanNotes(options) {
     { staleMs: LOCK_STALE_MS, maxWaitMs: lockWaitMs },
     async (acquired, lock) => {
       if (!acquired) {
-        log4.warn(
+        log5.warn(
           `[${options.serviceId}] flush-plan ingestion skipped: another flush holds the lock; the notes drain on the next flush`
         );
         return;
       }
       for (const candidate of [paths.plan, paths.inflight, paths.rotating, paths.oversized]) {
         if (await isLinkFreeUnder(workspaceDir, candidate)) continue;
-        log4.warn(
+        log5.warn(
           `[${options.serviceId}] flush-plan ingestion skipped: ${candidate}, a parent, or the workspace root became a symlink`
         );
         return;
       }
       const pinned = await pinSnapshotDirectory(paths);
       if (pinned.kind === "unstable") {
-        log4.warn(
+        log5.warn(
           `[${options.serviceId}] flush-plan ingestion skipped: the snapshot directory changed identity while it was being opened`
         );
         return;
@@ -6941,7 +7114,7 @@ async function ingestUnderLock(options, paths, lock) {
     if (options.remainingTimeoutMs() <= 0) return;
     const claimed = await claimPendingNotes(paths, options.serviceId, lock);
     if (claimed === void 0) {
-      log4.warn(
+      log5.warn(
         `[${options.serviceId}] flush-plan lock was lost during recovery; its new owner drains the snapshot`
       );
       return;
@@ -6957,7 +7130,7 @@ async function ingestUnderLock(options, paths, lock) {
       while (pending.trim().length > 0) {
         const timeoutMs = options.remainingTimeoutMs();
         if (timeoutMs <= 0) {
-          log4.warn(
+          log5.warn(
             `[${options.serviceId}] flush-plan ingestion stopped: the caller's deadline is spent; the remainder drains on the next flush`
           );
           stop = true;
@@ -6980,7 +7153,7 @@ async function ingestUnderLock(options, paths, lock) {
           timeoutMs
         );
         if (isRefusal(response.status)) {
-          log4.warn(
+          log5.warn(
             `[${options.serviceId}] flush-plan notes were refused by the daemon (${response.status}); keeping them for the next flush`
           );
           stop = true;
@@ -6994,7 +7167,7 @@ async function ingestUnderLock(options, paths, lock) {
           pending = await quarantineOversizedLine(paths, pending, options.serviceId);
           chunkBytes = MAX_OBSERVE_CHUNK_BYTES;
           if (!await lock.refresh()) {
-            log4.warn(
+            log5.warn(
               `[${options.serviceId}] flush-plan lock was lost mid-flush; the snapshot is left to its new owner`
             );
             lockLost = true;
@@ -7010,7 +7183,7 @@ async function ingestUnderLock(options, paths, lock) {
         }
         pending = pending.slice(chunk.length);
         if (!await lock.refresh()) {
-          log4.warn(
+          log5.warn(
             `[${options.serviceId}] flush-plan lock was lost mid-flush; the snapshot is left to its new owner`
           );
           lockLost = true;
@@ -7023,7 +7196,7 @@ async function ingestUnderLock(options, paths, lock) {
       if (!lockLost && await lock.refresh()) {
         await releasePendingNotes(paths, pending, options.serviceId);
       } else if (!lockLost) {
-        log4.warn(
+        log5.warn(
           `[${options.serviceId}] flush-plan lock was lost before the snapshot could be updated; its new owner drains the remainder`
         );
       }
@@ -7043,7 +7216,7 @@ async function claimPendingNotes(paths, serviceId, lock) {
   const recovery = await mergeRotatedIntoInflight(paths, lock);
   if (recovery === "lock-lost") return void 0;
   if (recovery === "recovered") {
-    log4.warn(`[${serviceId}] recovered flush-plan notes left by an interrupted ingestion`);
+    log5.warn(`[${serviceId}] recovered flush-plan notes left by an interrupted ingestion`);
   }
   if (!await lock.refresh()) return void 0;
   try {
@@ -7082,7 +7255,7 @@ async function releasePendingNotes(paths, pending, serviceId) {
     }
     await atomicWrite(paths.inflight, pending);
   } catch (err) {
-    log4.warn(
+    log5.warn(
       `[${serviceId}] could not persist unsent flush-plan notes; the next ingestion recovers them: ${String(err)}`
     );
   }
@@ -7102,7 +7275,7 @@ async function quarantineOversizedLine(paths, pending, serviceId) {
   } finally {
     await handle.close();
   }
-  log4.warn(
+  log5.warn(
     `[${serviceId}] a flush-plan note exceeds the daemon's body limit; moved it to ${paths.oversizedLabel} so the remaining notes can drain`
   );
   return rest;
@@ -7151,16 +7324,16 @@ function chunkOnLineBoundaries(text, limit) {
   return chunks;
 }
 async function isLinkFreeUnder(root, target) {
-  const relative = path8.relative(root, target);
-  if (relative.startsWith("..") || path8.isAbsolute(relative)) return false;
+  const relative = path9.relative(root, target);
+  if (relative.startsWith("..") || path9.isAbsolute(relative)) return false;
   let current = root;
   try {
     if ((await lstat4(current)).isSymbolicLink()) return false;
   } catch {
     return true;
   }
-  for (const segment of relative.split(path8.sep)) {
-    current = path8.join(current, segment);
+  for (const segment of relative.split(path9.sep)) {
+    current = path9.join(current, segment);
     try {
       if ((await lstat4(current)).isSymbolicLink()) return false;
     } catch {
@@ -7196,7 +7369,7 @@ function extractTextContent(msg) {
 
 // src/delegate-capability.ts
 import { readFile as readFile2 } from "fs/promises";
-import { log as log5 } from "@remnic/core/logger";
+import { log as log6 } from "@remnic/core/logger";
 var HEALTH_CACHE_TTL_MS = 3e4;
 var SEARCH_CANDIDATE_CAP = 25e3;
 function searchCandidateCeiling(budget) {
@@ -7393,7 +7566,7 @@ function createDelegateMemoryCapability(options) {
         corpusShared = daemonIsLocal && health.memoryDir !== void 0 && daemonServesCorpus(options.memoryDir, health.memoryDir);
         if (!corpusShared && daemonIsLocal && !reportedCorpusMismatch) {
           reportedCorpusMismatch = true;
-          log5.error(
+          log6.error(
             `[${serviceId}] delegate capability: the daemon does not serve this plugin's memoryDir (daemon: ${health.memoryDir ?? "unreported"}, plugin: ${options.memoryDir}) \u2014 file-backed reads and public artifacts are disabled; search still runs through the daemon`
           );
         }
@@ -7411,7 +7584,7 @@ function createDelegateMemoryCapability(options) {
         const message = `[${serviceId}] delegate capability health probe failed: ${String(err)}`;
         if (message !== lastHealthFailure) {
           lastHealthFailure = message;
-          log5.warn(message);
+          log6.warn(message);
         }
       } finally {
         healthInFlight = void 0;
@@ -7638,7 +7811,7 @@ function createDelegateMemoryCapability(options) {
           agentIds: options.agentIds
         });
       } catch (err) {
-        log5.error(`[${serviceId}] delegate publicArtifacts.listArtifacts failed`, err);
+        log6.error(`[${serviceId}] delegate publicArtifacts.listArtifacts failed`, err);
         return [];
       }
     },
@@ -7651,7 +7824,7 @@ function registerDelegateMemoryCapability(api, options) {
   const hasRuntime = typeof api.registerMemoryRuntime === "function";
   const hasFlushPlan = typeof api.registerMemoryFlushPlan === "function";
   if (!hasUnified && !hasRuntime && !hasFlushPlan) {
-    log5.debug(
+    log6.debug(
       `[${options.serviceId}] delegate: host exposes no memory capability surface \u2014 nothing to register`
     );
     return built;
@@ -7668,7 +7841,7 @@ function registerDelegateMemoryCapability(api, options) {
   if (hasFlushPlan) api.registerMemoryFlushPlan?.(built.flushPlanResolver);
   const surface = hasUnified ? "memory capability with publicArtifacts provider" : "split memory runtime/flush-plan surfaces";
   const builder = options.allowPromptInjection ? " and promptBuilder" : " (promptBuilder omitted \u2014 injection disabled by policy)";
-  log5.info(`[${options.serviceId}] delegate: registered daemon-backed ${surface}${builder}`);
+  log6.info(`[${options.serviceId}] delegate: registered daemon-backed ${surface}${builder}`);
   return built;
 }
 
@@ -7680,7 +7853,7 @@ import {
   acceptsSupportPassportModelResponse,
   parseSupportPassportModelJob
 } from "@remnic/core";
-import { log as log6 } from "@remnic/core/logger";
+import { log as log7 } from "@remnic/core/logger";
 var MODEL_WORKER_COUNT = 4;
 var DEFAULT_REQUEST_TIMEOUT_MS = 25e3;
 var RESULT_REQUEST_TIMEOUT_MS = 5e3;
@@ -7753,7 +7926,7 @@ function createDelegateSupportPassportModelService(options) {
       ]);
     } catch (error) {
       if (!modelSignal.aborted) {
-        log6.warn(`delegate support passport model call failed: ${String(error)}`);
+        log7.warn(`delegate support passport model call failed: ${String(error)}`);
       }
       return null;
     } finally {
@@ -7898,14 +8071,14 @@ function createDelegateSupportPassportModelService(options) {
         }
         const job = parseSupportPassportModelJob(await response.json());
         if (!job) {
-          log6.warn("delegate support passport model bridge received an invalid job");
+          log7.warn("delegate support passport model bridge received an invalid job");
           await delayAfterFailure();
           continue;
         }
         consecutiveFailures = 0;
         const deadline = Date.now() + job.timeoutMs;
         if (!await acknowledge(job, signal, job.claimAckTimeoutMs ?? job.timeoutMs, true)) {
-          log6.warn("delegate support passport model bridge could not acknowledge a claimed job");
+          log7.warn("delegate support passport model bridge could not acknowledge a claimed job");
           await delayAfterFailure();
           continue;
         }
@@ -7931,7 +8104,7 @@ function createDelegateSupportPassportModelService(options) {
           });
           if (heartbeatError && !completionAccepted) throw heartbeatError;
         } catch (error) {
-          log6.warn(`delegate support passport model completion failed: ${String(error)}`);
+          log7.warn(`delegate support passport model completion failed: ${String(error)}`);
         } finally {
           heartbeatController.abort();
           workController.abort();
@@ -7939,7 +8112,7 @@ function createDelegateSupportPassportModelService(options) {
         }
       } catch (error) {
         if (signal.aborted) break;
-        log6.warn(`delegate support passport model bridge failed: ${String(error)}`);
+        log7.warn(`delegate support passport model bridge failed: ${String(error)}`);
         await delayAfterFailure();
       }
     }
@@ -7964,9 +8137,228 @@ function createDelegateSupportPassportModelService(options) {
   };
 }
 
-// src/delegate-runtime.ts
-var DELEGATE_BATCH_FLUSH_CACHE_TTL_MS = 3e4;
-var delegatePassportServiceApiServices = /* @__PURE__ */ new WeakMap();
+// src/delegate-tools.ts
+import path10 from "path";
+import {
+  collapseWhitespace,
+  truncateCodePointSafe
+} from "@remnic/core";
+import { isHandleToken } from "@remnic/core/recall-handles";
+var DEFAULT_SEARCH_RESULTS = 8;
+var DEFAULT_SNIPPET_MAX_CHARS = 600;
+var DAEMON_SEARCH_QUERY_MAX_CHARS = 2048;
+var DAEMON_MEMORY_GET_MAX_CHARS = 512;
+function clampLimit(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_SEARCH_RESULTS;
+  return Math.max(1, Math.min(50, Math.floor(value)));
+}
+function clampSnippetMaxChars(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_SNIPPET_MAX_CHARS;
+  return Math.max(1, Math.min(4e3, Math.floor(value)));
+}
+function sessionKeyFor(params, ctx) {
+  if (typeof ctx?.sessionKey === "string" && ctx.sessionKey.trim().length > 0) {
+    return ctx.sessionKey;
+  }
+  return typeof params.sessionKey === "string" && params.sessionKey.trim().length > 0 ? params.sessionKey : "default";
+}
+function activeMemoryGetOutputFrom(record) {
+  if (typeof record !== "object" || record === null) {
+    throw new Error("daemon memory route responded 2xx without a memory record");
+  }
+  const memory = record;
+  if (typeof memory.id !== "string" || typeof memory.content !== "string") {
+    throw new Error("daemon memory route returned a malformed memory record");
+  }
+  const frontmatter = typeof memory.frontmatter === "object" && memory.frontmatter !== null ? memory.frontmatter : {};
+  const metadata = {};
+  if (frontmatter.category === "fact" || frontmatter.category === "preference") {
+    metadata.type = frontmatter.category;
+  }
+  if (Array.isArray(frontmatter.tags) && typeof frontmatter.tags[0] === "string") {
+    metadata.topic = frontmatter.tags[0];
+  }
+  if (typeof frontmatter.updated === "string") metadata.updatedAt = frontmatter.updated;
+  if (typeof frontmatter.source === "string") metadata.sourceUri = frontmatter.source;
+  return {
+    id: memory.id,
+    text: collapseWhitespace(memory.content),
+    ...Object.keys(metadata).length > 0 ? { metadata } : {}
+  };
+}
+function buildDelegateMemorySearchTool(options) {
+  const spent = (deadline, signal, stage) => {
+    if (signal?.aborted) throw new Error(`memory_search aborted before ${stage}`);
+    if (deadline - Date.now() <= 0) throw new Error(`memory_search budget of ${options.timeoutMs}ms spent before ${stage}`);
+  };
+  return {
+    name: "memory_search",
+    description: "Search Remnic memories via the Remnic daemon (delegate).",
+    parameters: MemorySearchInputSchema,
+    inputSchema: MemorySearchInputSchema,
+    async execute(_toolCallId, params, signal, ctx) {
+      const query = typeof params.query === "string" ? params.query.trim() : "";
+      if (query.length === 0) throw new Error("memory_search requires a non-empty query");
+      const deadline = Date.now() + options.timeoutMs;
+      const { manager, error } = await options.runtime.getMemorySearchManager({
+        cfg: void 0,
+        agentId: ctx?.agentId ?? options.agentId
+      });
+      if (!manager) throw new Error(error ?? "delegate memory search manager unavailable");
+      spent(deadline, signal, "scope resolution");
+      const limit = clampLimit(params.limit);
+      const sessionKey = sessionKeyFor(params, ctx);
+      const filters = params.filters && typeof params.filters === "object" ? params.filters : void 0;
+      if (typeof filters?.namespace === "string" && filters.namespace.trim().length > 0) {
+        throw new Error(
+          `memory_search filters.namespace "${filters.namespace.trim()}" is not supported in delegate mode: the search is scoped to the session's own namespace`
+        );
+      }
+      spent(deadline, signal, "search");
+      const results = await manager.search(query.slice(0, DAEMON_SEARCH_QUERY_MAX_CHARS), {
+        maxResults: limit + 1,
+        sessionKey
+      });
+      const output = {
+        results: results.slice(0, limit).map((result) => ({
+          id: path10.basename(result.citation ?? result.path, ".md"),
+          score: result.score,
+          // Read per call: the owner's cap can change on an active takeover.
+          text: truncateCodePointSafe(collapseWhitespace(result.snippet), clampSnippetMaxChars(options.snippetMaxChars))
+        })),
+        truncated: results.length > limit
+      };
+      return toolJsonResult2(output);
+    }
+  };
+}
+function buildDelegateMemoryGetTool(options) {
+  return {
+    name: "memory_get",
+    description: "Fetch one Remnic memory via the Remnic daemon (delegate).",
+    parameters: MemoryGetInputSchema,
+    inputSchema: MemoryGetInputSchema,
+    async execute(_toolCallId, params, _signal, ctx) {
+      const id = typeof params.id === "string" ? params.id.trim() : "";
+      if (id.length === 0) throw new Error("memory_get requires an id");
+      if (id.length > DAEMON_MEMORY_GET_MAX_CHARS) {
+        return toolJsonResult2({ error: "not_found" });
+      }
+      const sessionKey = sessionKeyFor(params, ctx);
+      if (sessionKey.length > DAEMON_MEMORY_GET_MAX_CHARS) {
+        throw new Error(`memory_get sessionKey exceeds the daemon's ${DAEMON_MEMORY_GET_MAX_CHARS}-char cap`);
+      }
+      const deadline = Date.now() + options.timeoutMs;
+      const namespace = await options.resolveNamespace(sessionKey, Math.max(1, deadline - Date.now()));
+      const requested = typeof params.namespace === "string" && params.namespace.trim().length > 0 ? params.namespace.trim() : void 0;
+      if (requested !== void 0 && requested !== namespace) {
+        throw new Error(
+          `memory_get namespace "${requested}" does not match the session's memory scope${namespace === void 0 ? "" : ` "${namespace}"`}`
+        );
+      }
+      const search = new URLSearchParams({ sessionKey });
+      if (namespace !== void 0) search.set("namespace", namespace);
+      const pathname = `/engram/v1/memories/${encodeURIComponent(id)}?${search}`;
+      const response = await getJson(options.target, options.serviceId, pathname, Math.max(1, deadline - Date.now()));
+      if (response.status === 404) return toolJsonResult2({ error: "not_found" });
+      if (response.status === 400 && isHandleToken(id)) {
+        return toolJsonResult2({ error: "not_found" });
+      }
+      if (response.status < 200 || response.status > 299) {
+        throw new Error(`daemon ${pathname} responded ${response.status}`);
+      }
+      return toolJsonResult2(activeMemoryGetOutputFrom(response.body?.memory));
+    }
+  };
+}
+var SHARED_TOOL_SHAPES = {
+  memory_search: {
+    description: "Search Remnic memories for the OpenClaw active-memory surface.",
+    parameters: MemorySearchInputSchema
+  },
+  memory_get: {
+    description: "Fetch one Remnic memory for the OpenClaw active-memory surface.",
+    parameters: MemoryGetInputSchema
+  }
+};
+function installSharedTools(registerTool, owner, tools) {
+  for (const tool of tools) owner.serve[tool.name] = tool;
+  for (const tool of tools) {
+    if (owner.installed.has(tool.name)) continue;
+    owner.installed.add(tool.name);
+    const shape = SHARED_TOOL_SHAPES[tool.name];
+    registerTool(
+      {
+        ...tool,
+        ...shape === void 0 ? {} : { description: shape.description, parameters: shape.parameters, inputSchema: shape.parameters },
+        execute: async (...args) => {
+          const serving = owner.serve[tool.name] ?? tool;
+          if (!owner.enabled && tool.name !== "memory_search") {
+            throw new Error(`${tool.name} is disabled: the memory slot owner set openclawToolsEnabled: false`);
+          }
+          return serving.execute(...args);
+        }
+      },
+      { name: tool.name }
+    );
+  }
+}
+var delegateToolOwners = /* @__PURE__ */ new WeakMap();
+function registerDelegateTools(api, options) {
+  if (typeof api.registerTool !== "function") return;
+  const registerTool = api.registerTool.bind(api);
+  const existing = delegateToolOwners.get(api);
+  const owner = existing ?? {
+    enabled: options.enabled,
+    passive: options.passive,
+    installed: /* @__PURE__ */ new Set(),
+    serve: {}
+  };
+  if (existing === void 0) delegateToolOwners.set(api, owner);
+  else if (existing.passive && !options.passive) {
+    owner.enabled = options.enabled;
+    owner.passive = options.passive;
+  } else return;
+  const resolveNamespace = (operation) => async (sessionKey, timeoutMs) => {
+    const deadline = Date.now() + timeoutMs;
+    const bound = await options.resolveSearchNamespace(sessionKey);
+    return options.resolveScopedNamespace(bound, Math.max(1, deadline - Date.now()), [operation]);
+  };
+  const tools = [buildDelegateMemorySearchTool(options)];
+  if (owner.enabled) {
+    tools.push(
+      buildDelegateMemoryGetTool({
+        target: options.target,
+        serviceId: options.serviceId,
+        timeoutMs: options.timeoutMs,
+        resolveNamespace: resolveNamespace("memory_get")
+      })
+    );
+  }
+  installSharedTools(registerTool, owner, tools);
+}
+function registerEmbeddedTools(api, options) {
+  if (typeof api.registerTool !== "function") return [];
+  const registerTool = api.registerTool.bind(api);
+  const existing = delegateToolOwners.get(api);
+  const owner = existing ?? {
+    enabled: options.enabled,
+    passive: options.passive,
+    installed: /* @__PURE__ */ new Set(),
+    serve: {}
+  };
+  if (existing === void 0) delegateToolOwners.set(api, owner);
+  else if (options.passive && !existing.passive) return [...owner.installed];
+  else if (!options.passive) {
+    owner.enabled = options.enabled;
+    owner.passive = false;
+  }
+  installSharedTools(registerTool, owner, options.tools);
+  return [...owner.installed];
+}
+
+// src/delegate-hook-fields.ts
+var MAX_RECALL_QUERY_CHARS = 1500;
 function sessionKeyFrom(event, ctx) {
   const fromCtx = ctx?.sessionKey;
   if (typeof fromCtx === "string" && fromCtx.length > 0) return fromCtx;
@@ -7981,13 +8373,13 @@ function lifecycleSessionKeyFrom(event, ctx) {
   }
   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)) {
+function recallQueryFrom(event, cleanUserMessage) {
+  let prompt = typeof event.prompt === "string" ? cleanUserMessage(event.prompt).trim() : "";
+  if (prompt.length < 5 && Array.isArray(event.messages)) {
     const msgs = event.messages;
     for (let i = msgs.length - 1; i >= 0; i--) {
       if (msgs[i]?.role === "user") {
-        const text = extractTextContent(msgs[i]);
+        const text = extractTextContent(msgs[i]).trim();
         if (text.length >= 5) {
           prompt = text;
           break;
@@ -7995,7 +8387,7 @@ function recallQueryFrom(event) {
       }
     }
   }
-  return prompt ?? "";
+  return prompt.length > MAX_RECALL_QUERY_CHARS ? prompt.slice(-MAX_RECALL_QUERY_CHARS) : prompt;
 }
 function cwdFrom(event, ctx, fallback) {
   const runtime = ctx?.runtime;
@@ -8025,17 +8417,21 @@ function readContextComposition(response, fallbackContext) {
   if (degradation) composition.degradation = degradation;
   return composition;
 }
+
+// src/delegate-runtime.ts
+var DELEGATE_BATCH_FLUSH_CACHE_TTL_MS = 3e4;
+var delegatePassportServiceApiServices = /* @__PURE__ */ new WeakMap();
 function registerDelegateRuntime(api, options) {
   const { target, namespace, namespaceBindings } = options;
   const now = options.now ?? Date.now;
   if (options.supportPassportModelRoute) {
     const registeredServices = delegatePassportServiceApiServices.get(api);
     if (registeredServices?.has(options.serviceId)) {
-      log7.debug(
+      log8.debug(
         `delegate register: ${options.serviceId} already has its support passport model service on this api`
       );
     } else if (typeof api.registerService !== "function") {
-      log7.error(
+      log8.error(
         `[${options.serviceId}] delegate support passport gateway routing is unavailable: host exposes no service registration surface`
       );
     } else {
@@ -8053,32 +8449,22 @@ function registerDelegateRuntime(api, options) {
       }
     }
   }
-  if (options.passive) {
-    log7.info(
-      `[${options.serviceId}] bridge mode delegate: memory slot not owned \u2014 passive, no memory hooks registered`
-    );
-    return;
-  }
   const promptLinesBySession = /* @__PURE__ */ new Map();
   const promptInjectionEnabled = options.allowPromptInjection && options.recallBudgetChars !== 0;
   const useSectionBuilder = typeof api.registerMemoryPromptSection === "function";
   const cachePromptLines = useSectionBuilder;
-  const capability = registerDelegateMemoryCapability(api, {
+  const resolveSearchNamespace = async (sessionKey) => {
+    if (typeof sessionKey === "string" && sessionKey.trim().length > 0) {
+      const remembered = await rememberedNamespacesFor(sessionKey, namespaceBindings);
+      if (remembered.length > 0) return remembered.at(-1) || void 0;
+    }
+    return namespace.trim() || void 0;
+  };
+  const capabilityOptions = {
     serviceId: options.serviceId,
     target,
     namespace,
-    // Capability searches scope through the SAME per-session binding history
-    // the hooks use (the non-explicit branch of sessionNamespaceFrom): the
-    // host hands the runtime a sessionKey but no event/ctx to read an explicit
-    // namespace from, so the remembered binding — else the registration-wide
-    // fallback — is the correct scope.
-    resolveSearchNamespace: async (sessionKey) => {
-      if (typeof sessionKey === "string" && sessionKey.trim().length > 0) {
-        const remembered = await rememberedNamespacesFor(sessionKey, namespaceBindings);
-        if (remembered.length > 0) return remembered.at(-1) || void 0;
-      }
-      return namespace.trim() || void 0;
-    },
+    resolveSearchNamespace,
     // The daemon's own namespace-aware probe, so a substituted default is
     // proven usable before the first search rather than 403-ing on it.
     verifyNamespaceAuthorization: async (candidate, timeoutMs, operations) => {
@@ -8107,24 +8493,44 @@ function registerDelegateRuntime(api, options) {
     searchTimeoutMs: options.recallTimeoutMs,
     healthTimeoutMs: options.recallTimeoutMs,
     now: options.now
+  };
+  const capability = options.passive ? createDelegateMemoryCapability(capabilityOptions) : registerDelegateMemoryCapability(api, capabilityOptions);
+  registerDelegateTools(api, {
+    target,
+    serviceId: options.serviceId,
+    enabled: options.openclawToolsEnabled !== false,
+    passive: options.passive,
+    runtime: capability.runtime,
+    agentId: options.capability.agentIds[0] ?? "main",
+    snippetMaxChars: options.openclawToolSnippetMaxChars,
+    timeoutMs: options.recallTimeoutMs,
+    resolveSearchNamespace,
+    resolveScopedNamespace: capability.resolveScopedNamespace
   });
+  if (options.passive) {
+    log8.info(
+      `[${options.serviceId}] bridge mode delegate: memory slot not owned \u2014 passive, no memory hooks registered`
+    );
+    return;
+  }
+  const observeChains = /* @__PURE__ */ new Map();
+  const followUpFlushSessions = /* @__PURE__ */ new Map();
   if (promptInjectionEnabled) {
-    const recallHandler = async (event, ctx) => {
-      const query = recallQueryFrom(event);
+    const recallContext = async (query, event, ctx) => {
       const sessionKey = sessionKeyFrom(event, ctx);
       if (cachePromptLines) promptLinesBySession.delete(sessionKey);
-      if (query.trim().length < 5) return void 0;
+      if (query.length < 5) return void 0;
       const promptDeadline = Date.now() + Math.min(options.hookTimeoutMs, options.recallTimeoutMs);
       const promptRemaining = () => promptDeadline - Date.now();
       try {
         if (options.shouldSkipRecall(sessionKey)) {
-          log7.debug(`delegate recall skipped: cron policy excludes ${sessionKey}`);
+          log8.debug(`delegate recall skipped: cron policy excludes ${sessionKey}`);
           return void 0;
         }
         const runtimeAgent = ctx?.runtime?.agent;
         const agentId = (typeof ctx?.agentId === "string" ? ctx.agentId : void 0) ?? (typeof runtimeAgent?.id === "string" ? runtimeAgent.id : void 0) ?? "main";
         if (await options.resolveSessionDisabled(sessionKey, agentId)) {
-          log7.debug(`delegate recall skipped: session toggle disables memory for ${sessionKey}`);
+          log8.debug(`delegate recall skipped: session toggle disables memory for ${sessionKey}`);
           return void 0;
         }
         const cwd = cwdFrom(event, ctx, options.cwd);
@@ -8165,20 +8571,28 @@ function registerDelegateRuntime(api, options) {
           maxChars: options.recallBudgetChars
         });
         if (!rendered) return void 0;
-        const prompt = rendered.prompt;
-        if (cachePromptLines) {
-          promptLinesBySession.set(sessionKey, rendered.lines);
-          return void 0;
-        }
         return {
-          prependSystemContext: prompt,
+          prompt: rendered.prompt,
+          lines: rendered.lines,
           ...composition.degradation ? { degradation: composition.degradation } : {}
         };
       } catch (err) {
-        log7.warn(`delegate recall failed: ${String(err)}`);
+        log8.warn(`delegate recall failed: ${String(err)}`);
         return void 0;
       }
     };
+    const recallHandler = async (event, ctx) => {
+      const recalled = await recallContext(recallQueryFrom(event, options.cleanUserMessage), event, ctx);
+      if (!recalled) return void 0;
+      if (cachePromptLines) {
+        promptLinesBySession.set(sessionKeyFrom(event, ctx), recalled.lines);
+        return void 0;
+      }
+      return {
+        prependSystemContext: recalled.prompt,
+        ...recalled.degradation ? { degradation: recalled.degradation } : {}
+      };
+    };
     api.on(
       "before_prompt_build",
       (event, ctx) => recallHandler(event, ctx),
@@ -8197,7 +8611,7 @@ function registerDelegateRuntime(api, options) {
       api.registerMemoryPromptSection(memoryBuildFn);
     }
   } else {
-    log7.info(
+    log8.info(
       `[${options.serviceId}] bridge mode delegate: prompt injection disabled by hooks policy`
     );
   }
@@ -8215,36 +8629,49 @@ function registerDelegateRuntime(api, options) {
       (message) => (message.role === "user" || message.role === "assistant") && message.content.trim().length > 0
     );
     if (turn.length === 0) return;
+    const cwd = cwdFrom(event, ctx, options.cwd);
+    let scopedNamespace;
     try {
-      const observeDeadline = Date.now() + options.observeTimeoutMs;
-      const observeRemaining = () => observeDeadline - Date.now();
-      const cwd = cwdFrom(event, ctx, options.cwd);
-      const scopedNamespace = await sessionNamespaceFrom(
+      scopedNamespace = await sessionNamespaceFrom(
         sessionKey,
         event,
         ctx,
         namespace,
         namespaceBindings
       );
-      await postJson(
-        target,
-        options.serviceId,
-        "/engram/v1/observe",
-        await withNamespace(
-          scopedNamespace,
-          {
-            sessionKey,
-            messages: turn,
-            ...cwd ? { cwd } : {},
-            ...options.projectTag ? { projectTag: options.projectTag } : {}
-          },
-          (explicit) => capability.resolveScopedNamespace(explicit, observeRemaining(), ["observe"])
-        ),
-        Math.max(1, observeRemaining())
-      );
     } catch (err) {
-      log7.warn(`delegate observe failed: ${String(err)}`);
+      log8.warn(`delegate observe failed: ${String(err)}`);
+      return;
     }
+    const observe = async () => {
+      const observeDeadline = Date.now() + Math.min(options.observeTimeoutMs, options.flushTimeoutMs / 2);
+      const observeRemaining = () => observeDeadline - Date.now();
+      try {
+        await postJson(
+          target,
+          options.serviceId,
+          "/engram/v1/observe",
+          await withNamespace(
+            scopedNamespace,
+            {
+              sessionKey,
+              messages: turn,
+              ...cwd ? { cwd } : {},
+              ...options.projectTag ? { projectTag: options.projectTag } : {}
+            },
+            (explicit) => capability.resolveScopedNamespace(explicit, observeRemaining(), ["observe"])
+          ),
+          Math.max(1, observeRemaining())
+        );
+      } catch (err) {
+        log8.warn(`delegate observe failed: ${String(err)}`);
+      }
+    };
+    const chained = (observeChains.get(sessionKey) ?? Promise.resolve()).then(observe);
+    observeChains.set(sessionKey, chained);
+    void chained.then(() => {
+      if (observeChains.get(sessionKey) === chained) observeChains.delete(sessionKey);
+    });
   });
   let cachedBatchFlushSupport;
   let cachedBatchFlushSupportExpiresAt = 0;
@@ -8297,9 +8724,38 @@ function registerDelegateRuntime(api, options) {
       const remainingBudget = () => deadline - Date.now();
       const sessionKey = lifecycleSessionKeyFrom(event, ctx);
       if (sessionKey === void 0) {
-        log7.warn("delegate flush skipped: lifecycle event has malformed session key");
+        log8.warn("delegate flush skipped: lifecycle event has malformed session key");
         return false;
       }
+      const pendingObserve = observeChains.get(sessionKey);
+      if (pendingObserve !== void 0) {
+        const drainDeadline = Promise.withResolvers();
+        const timer = setTimeout(drainDeadline.resolve, Math.max(0, Math.min(remainingBudget(), options.flushTimeoutMs / 2)));
+        timer.unref?.();
+        const drained = await Promise.race([
+          pendingObserve.then(() => true),
+          drainDeadline.promise.then(() => false)
+        ]);
+        clearTimeout(timer);
+        if (!drained && !followUpFlushSessions.has(sessionKey)) {
+          const followUp = {};
+          followUpFlushSessions.set(sessionKey, followUp);
+          const releaseIfOwner = () => {
+            if (followUpFlushSessions.get(sessionKey) === followUp) {
+              followUpFlushSessions.delete(sessionKey);
+            }
+          };
+          void pendingObserve.then(async () => {
+            for (let round = 0; round < 8; round += 1) {
+              const queued = observeChains.get(sessionKey);
+              if (queued === void 0) break;
+              await queued;
+            }
+            releaseIfOwner();
+            return flushHandler({ sessionKey }, {});
+          }).catch((err) => log8.warn(`delegate follow-up flush failed: ${String(err)}`)).finally(releaseIfOwner);
+        }
+      }
       const namespaces = await lifecycleSessionNamespacesFrom(
         sessionKey,
         event,
@@ -8322,7 +8778,7 @@ function registerDelegateRuntime(api, options) {
           remainingTimeoutMs: remainingBudget
         });
       } catch (err) {
-        log7.warn(`delegate flush-plan ingestion failed: ${String(err)}`);
+        log8.warn(`delegate flush-plan ingestion failed: ${String(err)}`);
       }
       const flushNamespace = async (sessionNamespace) => postJson(
         target,
@@ -8347,7 +8803,7 @@ function registerDelegateRuntime(api, options) {
           (outcome) => outcome.status === "fulfilled" && outcome.value !== null && outcome.value.flushed === true
         );
       };
-      if (namespaces.length <= 1 || await supportsBatchFlush(remainingTimeout())) {
+      if (namespaces.length <= 1 || await supportsBatchFlush(Math.max(1, Math.floor(remainingBudget() / 2)))) {
         if (namespaces.length <= 1) {
           const response = await flushNamespace(namespaces[0]);
           return response !== null && response.flushed === true;
@@ -8365,7 +8821,11 @@ function registerDelegateRuntime(api, options) {
             options.serviceId,
             "/engram/v1/lcm/compaction/flush",
             { sessionKey, namespaces: requestNamespaces },
-            remainingTimeout()
+            // Half of what is left, like the support probe: the batch is an
+            // optimization whose failure path is `flushIndividually`, and one
+            // that stalled having spent everything would leave those singular
+            // flushes the 1ms floor and buffer the turns anyway.
+            Math.max(1, Math.floor(remainingBudget() / 2))
           );
           if (response === null) {
             invalidateCachedBatchFlushSupport();
@@ -8392,7 +8852,7 @@ function registerDelegateRuntime(api, options) {
       }
       return flushIndividually();
     } catch (err) {
-      log7.warn(`delegate flush failed: ${String(err)}`);
+      log8.warn(`delegate flush failed: ${String(err)}`);
       return false;
     }
   };
@@ -8402,135 +8862,13 @@ function registerDelegateRuntime(api, options) {
     api.on("before_reset", flushEndedSession);
     api.on("session_end", flushEndedSession);
   }
-  log7.info(
+  log8.info(
     `[${options.serviceId}] bridge mode delegate: memory loop backed by daemon at ${target.host}:${target.port} (embedded orchestrator skipped; tools/CLI stay daemon-side)`
   );
 }
 function activeDelegateAuthorizationOperations(options) {
   return options.allowPromptInjection && options.recallBudgetChars !== 0 ? DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS : DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS.filter((operation) => operation !== "recall");
 }
-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) => path9.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) {
-        log7.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_NAMESPACES2);
-  };
-  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) {
-        log7.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) {
-          log7.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();
@@ -8539,13 +8877,13 @@ var delegateAuthorizationPreflightServices = /* @__PURE__ */ new WeakMap();
 function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkDaemonHealthSync }) {
   const boundServices = delegateHookApiServices.get(api);
   if (boundServices?.has(options.serviceId)) {
-    log7.debug(
+    log8.debug(
       `delegate register: ${options.serviceId} already has hooks bound on this api \u2014 skipping duplicate registration`
     );
     return true;
   }
   if (delegateEmbeddedFallbackApis.has(api)) {
-    log7.debug(
+    log8.debug(
       `delegate register: ${options.serviceId} previously fell back to embedded on this api \u2014 staying embedded to avoid stacking memory paths`
     );
     return false;
@@ -8559,11 +8897,11 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     bridge = resolveBridgeMode(options.configBridgeMode, {
       memoryDir: options.memoryDir,
       timeoutMs: bridgeHealthTimeoutMs,
-      onSkip: (reason) => log7.info(`[${options.serviceId}] bridge mode auto: staying embedded \u2014 ${reason}`)
+      onSkip: (reason) => log8.info(`[${options.serviceId}] bridge mode auto: staying embedded \u2014 ${reason}`)
     });
   } catch (err) {
     const wantedDelegate = requestedDelegate(options.configBridgeMode);
-    log7.error(
+    log8.error(
       wantedDelegate ? `${String(err)} \u2014 falling back to the embedded runtime` : `${String(err)} \u2014 the deployment is embedded, so this only affects delegate mode`
     );
     if (!options.passive) delegateEmbeddedFallbackApis.add(api);
@@ -8571,7 +8909,7 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
   }
   if (bridge.mode !== "delegate") {
     if (delegateBoundApis.has(api)) {
-      log7.warn(
+      log8.warn(
         `[${options.serviceId}] bridge mode resolved embedded, but a sibling service already bound delegate hooks on this api \u2014 reusing them instead of stacking an embedded runtime`
       );
       return true;
@@ -8579,25 +8917,39 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     if (!options.passive) {
       delegateEmbeddedFallbackApis.add(api);
       if (resolveRequestedBridgeMode(options.configBridgeMode) === "auto") {
-        log7.info(
+        log8.info(
           `[${options.serviceId}] bridge mode auto: embedded hooks are bound on this api \u2014 a daemon that starts later is picked up on the next gateway restart`
         );
       }
     }
     return false;
   }
-  if (!bridge.healthVerified && !deps.checkHealth(bridge.daemonHost, bridge.daemonPort, bridgeHealthTimeoutMs)) {
-    if (delegateBoundApis.has(api)) {
-      log7.warn(
-        `[${options.serviceId}] no healthy daemon at ${bridge.daemonHost}:${bridge.daemonPort}, but a sibling service already bound delegate hooks on this api \u2014 reusing them instead of stacking an embedded runtime`
+  if (!bridge.healthVerified) {
+    const hosts = bridge.daemonHostFallback === void 0 ? [bridge.daemonHost] : [bridge.daemonHost, bridge.daemonHostFallback];
+    const preflightDeadline = Date.now() + bridgeHealthTimeoutMs;
+    const healthyHost = hosts.find((host, index) => {
+      const remaining = index === 0 ? bridgeHealthTimeoutMs : preflightDeadline - Date.now();
+      return remaining > 0 && deps.checkHealth(host, bridge.daemonPort, remaining);
+    });
+    if (healthyHost !== void 0 && healthyHost !== bridge.daemonHost) {
+      log8.info(
+        `[${options.serviceId}] bridge mode delegate: loopback refused, dialing the configured address ${healthyHost}`
       );
-      return true;
+      bridge = { ...bridge, daemonHost: healthyHost };
+    }
+    if (healthyHost === void 0) {
+      if (delegateBoundApis.has(api)) {
+        log8.warn(
+          `[${options.serviceId}] no healthy daemon at ${hosts.join("/")}:${bridge.daemonPort}, but a sibling service already bound delegate hooks on this api \u2014 reusing them instead of stacking an embedded runtime`
+        );
+        return true;
+      }
+      delegateEmbeddedFallbackApis.add(api);
+      log8.error(
+        `bridge mode delegate requested but no healthy daemon at ${hosts.join("/")}:${bridge.daemonPort} \u2014 falling back to the embedded runtime`
+      );
+      return false;
     }
-    delegateEmbeddedFallbackApis.add(api);
-    log7.error(
-      `bridge mode delegate requested but no healthy daemon at ${bridge.daemonHost}:${bridge.daemonPort} \u2014 falling back to the embedded runtime`
-    );
-    return false;
   }
   if (!options.passive) {
     (boundServices ?? delegateHookApiServices.set(api, /* @__PURE__ */ new Set()).get(api))?.add(
@@ -8607,9 +8959,9 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     delegateBoundApis.add(api);
   }
   const toggleStore = options.sessionTogglesEnabled ? createFileToggleStore(
-    path9.join(options.memoryDir, "state", "plugins", options.serviceId, "session-toggles.json"),
+    path11.join(options.memoryDir, "state", "plugins", options.serviceId, "session-toggles.json"),
     {
-      secondaryReadOnlyPath: options.respectBundledActiveMemoryToggle ? path9.join(options.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0
+      secondaryReadOnlyPath: options.respectBundledActiveMemoryToggle ? path11.join(options.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0
     }
   ) : null;
   const target = daemonTargetFor(bridge);
@@ -8633,6 +8985,8 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     cwd: options.cwd,
     projectTag: options.projectTag,
     flushOnResetEnabled: options.flushOnResetEnabled,
+    openclawToolsEnabled: options.openclawToolsEnabled,
+    openclawToolSnippetMaxChars: options.openclawToolSnippetMaxChars,
     capability: options.capability,
     recallTimeoutMs: 25e3,
     observeTimeoutMs: 12e4,
@@ -8652,16 +9006,16 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     void probe(target, "", operations).then((result) => {
       if (result.state === "authorized") return;
       if (result.state === "unauthorized") {
-        log7.warn(
+        log8.warn(
           `delegate authorization preflight rejected ${operationLabel} (${result.status}; token source: ${result.tokenSource}) \u2014 runtime remains active`
         );
         return;
       }
-      log7.warn(
+      log8.warn(
         `delegate authorization preflight could not verify ${operationLabel} (token source: ${result.tokenSource}) \u2014 runtime remains active`
       );
     }).catch(() => {
-      log7.warn("delegate authorization preflight could not complete \u2014 runtime remains active");
+      log8.warn("delegate authorization preflight could not complete \u2014 runtime remains active");
     });
   }
   return true;
@@ -8782,23 +9136,23 @@ __export(resolve_provider_secret_exports, {
   findGatewayRuntimeModules: () => findGatewayRuntimeModules
 });
 __reExport(resolve_provider_secret_exports, resolve_provider_secret_star);
-import path10 from "path";
+import path12 from "path";
 import * as resolve_provider_secret_star from "@remnic/core/resolve-provider-secret";
 async function findGatewayRuntimeModules(filePrefix) {
   const { existsSync, readFileSync, readdirSync, realpathSync: realpathSync2 } = await import("fs");
   const { createRequire: createRequire2 } = await import("module");
   const candidates = [];
   const isWithinRoot = (root, candidate) => {
-    const relative = path10.relative(root, candidate);
-    return relative.length === 0 || !relative.startsWith("..") && !path10.isAbsolute(relative);
+    const relative = path12.relative(root, candidate);
+    return relative.length === 0 || !relative.startsWith("..") && !path12.isAbsolute(relative);
   };
   let packageRoot;
   try {
     const req = createRequire2(import.meta.url);
     const openclawEntrypoint = realpathSync2(req.resolve("openclaw"));
-    let currentDir = path10.dirname(openclawEntrypoint);
+    let currentDir = path12.dirname(openclawEntrypoint);
     while (true) {
-      const packageJsonPath = path10.join(currentDir, "package.json");
+      const packageJsonPath = path12.join(currentDir, "package.json");
       if (existsSync(packageJsonPath)) {
         const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
         if (packageJson.name !== "openclaw") {
@@ -8807,7 +9161,7 @@ async function findGatewayRuntimeModules(filePrefix) {
         packageRoot = realpathSync2(currentDir);
         break;
       }
-      const parent = path10.dirname(currentDir);
+      const parent = path12.dirname(currentDir);
       if (parent === currentDir) {
         return [];
       }
@@ -8817,14 +9171,14 @@ async function findGatewayRuntimeModules(filePrefix) {
     return [];
   }
   try {
-    const distDir = realpathSync2(path10.join(packageRoot, "dist"));
+    const distDir = realpathSync2(path12.join(packageRoot, "dist"));
     if (!isWithinRoot(packageRoot, distDir)) {
       return [];
     }
     const files = readdirSync(distDir);
     for (const f of files) {
       if (f.startsWith(filePrefix) && f.endsWith(".js")) {
-        const candidate = realpathSync2(path10.join(distDir, f));
+        const candidate = realpathSync2(path12.join(distDir, f));
         if (isWithinRoot(packageRoot, candidate) && isWithinRoot(distDir, candidate)) {
           candidates.push(candidate);
         }
@@ -9080,7 +9434,7 @@ async function loadOpenClawProviderAuthRuntimeModule() {
         if (typeof mod.resolveApiKeyForProvider === "function" || typeof mod.getRuntimeAuthForModel === "function") {
           providerAuthRuntimeModule = mod;
           providerAuthRuntimeLoaded = true;
-          log8.debug("loaded OpenClaw provider auth runtime module");
+          log9.debug("loaded OpenClaw provider auth runtime module");
           return providerAuthRuntimeModule;
         }
       } catch {
@@ -9089,7 +9443,7 @@ async function loadOpenClawProviderAuthRuntimeModule() {
   } catch {
   }
   providerAuthRuntimeNextRetryAt = Date.now() + SECRET_REF_RESOLVER_RETRY_BACKOFF_MS;
-  log8.debug(
+  log9.debug(
     `OpenClaw provider auth runtime not available \u2014 will retry after ${SECRET_REF_RESOLVER_RETRY_BACKOFF_MS / 1e3}s`
   );
   return null;
@@ -9128,7 +9482,7 @@ async function loadOpenClawSecretRefResolver() {
             if (typeof fn === "function") {
               secretRefResolver = fn;
               secretRefResolverLoaded = true;
-              log8.debug(
+              log9.debug(
                 `loaded OpenClaw SecretRef resolver "${exportName}" from ${prefix}*.js`
               );
               return secretRefResolver;
@@ -9141,7 +9495,7 @@ async function loadOpenClawSecretRefResolver() {
   } catch {
   }
   secretRefResolverNextRetryAt = Date.now() + SECRET_REF_RESOLVER_RETRY_BACKOFF_MS;
-  log8.debug(
+  log9.debug(
     `OpenClaw SecretRef resolver not available \u2014 will retry after ${SECRET_REF_RESOLVER_RETRY_BACKOFF_MS / 1e3}s`
   );
   return null;
@@ -9167,7 +9521,7 @@ function resolveOpenClawConfigFilePath() {
   if (explicitConfigPath && explicitConfigPath.length > 0) {
     return expandTildePath3(explicitConfigPath);
   }
-  return path11.join(resolveHomeDir3(), ".openclaw", "openclaw.json");
+  return path13.join(resolveHomeDir3(), ".openclaw", "openclaw.json");
 }
 function coerceRawConfigBoolean(value) {
   if (typeof value === "boolean") return value;
@@ -9184,7 +9538,7 @@ function loadPluginEntryFromFile(pluginId) {
     const config = JSON.parse(content);
     return resolveRemnicPluginEntry(config, pluginId);
   } catch (err) {
-    log8.warn(`Failed to load config from file: ${err}`);
+    log9.warn(`Failed to load config from file: ${err}`);
     return void 0;
   }
 }
@@ -9202,7 +9556,7 @@ function loadRawConfigFromFile() {
     const config = JSON.parse(content);
     return config && typeof config === "object" ? config : void 0;
   } catch (err) {
-    log8.warn(`Failed to load raw OpenClaw config from file: ${err}`);
+    log9.warn(`Failed to load raw OpenClaw config from file: ${err}`);
     return void 0;
   }
 }
@@ -9214,10 +9568,10 @@ function readPluginHooksPolicy(apiConfig, pluginId) {
 }
 async function maybeRegisterLiveConnectorCron(orchestrator) {
   if (!hasEnabledLiveConnectorConfig(orchestrator.config.connectors)) return;
-  const jobsPath = path11.join(resolveHomeDir3(), ".openclaw", "cron", "jobs.json");
+  const jobsPath = path13.join(resolveHomeDir3(), ".openclaw", "cron", "jobs.json");
   try {
     if (!fileExistsNow(jobsPath)) {
-      log8.debug("live connectors cron: jobs.json not found, skipping auto-register");
+      log9.debug("live connectors cron: jobs.json not found, skipping auto-register");
       return;
     }
     const result = await ensureLiveConnectorCron(jobsPath, {
@@ -9225,12 +9579,12 @@ async function maybeRegisterLiveConnectorCron(orchestrator) {
       connectors: orchestrator.config.connectors
     });
     if (result.created || result.updated) {
-      log8.info(`live connectors cron ${result.created ? "auto-registered" : "reconciled"} (${result.jobId})`);
+      log9.info(`live connectors cron ${result.created ? "auto-registered" : "reconciled"} (${result.jobId})`);
     } else {
-      log8.debug("live connectors cron already exists, skipping auto-register");
+      log9.debug("live connectors cron already exists, skipping auto-register");
     }
   } catch (err) {
-    log8.debug(`live connectors cron auto-register error: ${err}`);
+    log9.debug(`live connectors cron auto-register error: ${err}`);
   }
 }
 function isBundledActiveMemoryEnabledForAgent(runtimeConfig, fileBackedRuntimeConfig, agentId) {
@@ -9399,13 +9753,13 @@ function registerOpenClawHostEmbeddingProvider(params) {
     }).then((result) => {
       providerInstance = result && typeof result === "object" ? result.provider ?? null : null;
       if (!providerInstance) {
-        log8.debug(
+        log9.debug(
           `OpenClaw host embedding provider ${selected.adapter.id} did not create a provider; using Remnic fallback embeddings`
         );
       }
       return providerInstance;
     }).catch((error) => {
-      log8.debug(
+      log9.debug(
         `OpenClaw host embedding provider ${selected.adapter.id} unavailable: ${error}`
       );
       return null;
@@ -9437,7 +9791,7 @@ function registerOpenClawHostEmbeddingProvider(params) {
     }
   };
   const unregister = registerHostEmbeddingProvider(cfg.memoryDir, hostProvider);
-  log8.info(
+  log9.info(
     `registered OpenClaw host embedding provider bridge (${selected.adapter.id}) for ${serviceId}`
   );
   return unregister;
@@ -9572,12 +9926,14 @@ async function embedBatchWithOpenClawProvider(kind, provider, texts, options) {
 }
 var sdkCaps;
 var NON_RUNTIME_REGISTRATION_MODES = /* @__PURE__ */ new Set([
-  "discovery",
-  "tool-discovery",
   "setup-only",
   "setup-runtime",
   "cli-metadata"
 ]);
+var DISCOVERY_REGISTRATION_MODES = /* @__PURE__ */ new Set([
+  "discovery",
+  "tool-discovery"
+]);
 function isNonRuntimeRegistrationMode(mode) {
   return typeof mode === "string" && NON_RUNTIME_REGISTRATION_MODES.has(mode);
 }
@@ -9592,22 +9948,23 @@ var pluginDefinition = {
     const keys = buildServiceKeys(serviceId);
     initLogger(api.logger, false);
     sdkCaps = detectSdkCapabilities(api);
-    log8.info(
+    log9.info(
       `SDK detection: version=${sdkCaps.sdkVersion}, beforePromptBuild=${sdkCaps.hasBeforePromptBuild}, memoryPromptSection=${sdkCaps.hasRegisterMemoryPromptSection}, memoryCapability=${sdkCaps.hasRegisterMemoryCapability}, typedHooks=${sdkCaps.hasTypedHooks}`
     );
     if (isNonRuntimeRegistrationMode(sdkCaps.registrationMode)) {
-      log8.info(
+      log9.info(
         `registrationMode=${sdkCaps.registrationMode} \u2014 skipping runtime initialization`
       );
       return;
     }
-    const disableRegisterMigration = readEnvVar("REMNIC_DISABLE_REGISTER_MIGRATION") === "1" || readEnvVar("OPENCLAW_ENGRAM_DISABLE_REGISTER_MIGRATION") === "1";
+    const discoveryPass = typeof sdkCaps.registrationMode === "string" && DISCOVERY_REGISTRATION_MODES.has(sdkCaps.registrationMode);
+    const disableRegisterMigration = readEnvVar("REMNIC_DISABLE_REGISTER_MIGRATION") === "1" || readEnvVar("OPENCLAW_ENGRAM_DISABLE_REGISTER_MIGRATION") === "1" || discoveryPass;
     if (!disableRegisterMigration) {
       const migrationPromise = globalThis[ENGRAM_MIGRATION_PROMISE] ??= migrateFromEngram({
         quiet: true,
-        logger: (message) => log8.info(message)
+        logger: (message) => log9.info(message)
       }).catch((error) => {
-        log8.warn(`register migration failed: ${error}`);
+        log9.warn(`register migration failed: ${error}`);
       });
       void migrationPromise;
     }
@@ -9641,10 +9998,10 @@ var pluginDefinition = {
     cfg.providerApiKeyResolver = resolveOpenClawProviderApiKey;
     cfg.runtimeAuthForModelResolver = getOpenClawRuntimeAuthForModel;
     initLogger(api.logger, cfg.debug);
-    log8.info(
+    log9.info(
       `initialized (debug=${cfg.debug}, qmdEnabled=${cfg.qmdEnabled}, transcriptEnabled=${cfg.transcriptEnabled}, hourlySummariesEnabled=${cfg.hourlySummariesEnabled})`
     );
-    log8.debug(
+    log9.debug(
       `init llm routing (modelSource=${cfg.modelSource}, localLlmEnabled=${cfg.localLlmEnabled}${cfg.localLlmFastEnabled ? `, fastLlm=${cfg.localLlmFastModel || "(primary)"}` : ""})`
     );
     const fileBackedRawRuntimeConfig = loadRawConfigFromFile();
@@ -9658,7 +10015,7 @@ var pluginDefinition = {
     });
     const passiveMode = slotValidationMode === "passive";
     if (passiveMode) {
-      log8.info(
+      log9.info(
         `[remnic] memory slot not assigned to ${serviceId}; running passively`
       );
     }
@@ -9689,6 +10046,8 @@ var pluginDefinition = {
       shouldSkipRecall: (sk) => shouldSkipRecallForSession(sk, cfg),
       cwd: getOpenClawRuntimeWorkspaceDir(api),
       flushOnResetEnabled: cfg.flushOnResetEnabled,
+      openclawToolsEnabled: cfg.openclawToolsEnabled,
+      openclawToolSnippetMaxChars: cfg.openclawToolSnippetMaxChars,
       supportPassportModelRoute: delegateSupportPassportGatewayRoute ?? void 0,
       // Memory-slot capability inputs. Mirrors the embedded derivation: the
       // registration-time runtime agent owns this memory, and QMD is the
@@ -9740,14 +10099,14 @@ var pluginDefinition = {
     }
     const hookApis = globalThis[keys.HOOK_APIS] ??= /* @__PURE__ */ new WeakSet();
     if (hookApis.has(api)) {
-      log8.debug(
+      log9.debug(
         "register: this api already has hooks bound \u2014 skipping duplicate hook registration"
       );
       return;
     }
     hookApis.add(api);
     if (!isFirstRegistration) {
-      log8.debug(
+      log9.debug(
         "register called again (new registry); re-registering hooks with shared orchestrator"
       );
     }
@@ -9783,9 +10142,9 @@ var pluginDefinition = {
       emitLegacyTools: cfg.emitLegacyTools
     });
     globalThis[keys.ACCESS_HTTP_SERVER] = accessHttpServer;
-    const pluginStateDir = path11.join(cfg.memoryDir, "state", "plugins", serviceId);
-    const togglePrimaryPath = path11.join(pluginStateDir, "session-toggles.json");
-    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path11.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
+    const pluginStateDir = path13.join(cfg.memoryDir, "state", "plugins", serviceId);
+    const togglePrimaryPath = path13.join(pluginStateDir, "session-toggles.json");
+    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path13.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
     const sessionToggleStore = createFileToggleStore2(togglePrimaryPath, {
       secondaryReadOnlyPath: toggleSecondaryPath
     });
@@ -9807,11 +10166,11 @@ var pluginDefinition = {
     }
     function resolveDreamJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path11.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path11.join(workspaceRoot, cfg.dreaming.journalPath);
+      return path13.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path13.join(workspaceRoot, cfg.dreaming.journalPath);
     }
     function resolveHeartbeatJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path11.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path11.join(workspaceRoot, cfg.heartbeat.journalPath);
+      return path13.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path13.join(workspaceRoot, cfg.heartbeat.journalPath);
     }
     const existingFlushPlanProcessingChains = globalThis[keys.FLUSH_PLAN_PROCESSING_CHAINS];
     const flushPlanProcessingChains = existingFlushPlanProcessingChains instanceof Map ? existingFlushPlanProcessingChains : /* @__PURE__ */ new Map();
@@ -9831,7 +10190,7 @@ var pluginDefinition = {
       }
       const remainingMs = Math.max(0, deadlineMs - Date.now());
       if (remainingMs === 0) {
-        log8.warn(
+        log9.warn(
           `OpenClaw flush-plan processing timed out before queue wait for ${reason}`
         );
         return Promise.resolve();
@@ -9841,7 +10200,7 @@ var pluginDefinition = {
         task,
         new Promise((resolve) => {
           timeout = setTimeout(() => {
-            log8.warn(
+            log9.warn(
               `OpenClaw flush-plan processing timed out while waiting for ${reason}; current drain remains fenced until it settles`
             );
             resolve();
@@ -9853,7 +10212,7 @@ var pluginDefinition = {
     }
     async function runOpenClawFlushPlanProcessing(reason, workspaceRoot, deadlineMs) {
       if (typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
-        log8.warn(
+        log9.warn(
           `OpenClaw flush-plan processing timed out before starting for ${reason}`
         );
         return;
@@ -9865,26 +10224,26 @@ var pluginDefinition = {
           serviceId,
           ingestor: orchestrator,
           logger: {
-            debug: (message) => log8.debug(message),
-            info: (message) => log8.info(message),
-            warn: (message) => log8.warn(message)
+            debug: (message) => log9.debug(message),
+            info: (message) => log9.info(message),
+            warn: (message) => log9.warn(message)
           },
           reason,
           deadlineMs,
           maxTurnChars: cfg.extractionMaxTurnChars
         });
         if (result.status === "processed" || result.status === "processed_preserved_tail" || result.status === "processed_marker_recovered" || result.status === "processed_marker_recovered_tail" || result.status === "processed_cleanup_deferred") {
-          log8.info(
+          log9.info(
             `OpenClaw flush-plan ${result.status}: ${result.bytesProcessed ?? 0} bytes` + (result.preservedBytes ? ` (${result.preservedBytes} bytes preserved)` : "")
           );
         } else if (result.status === "skipped") {
-          log8.warn(
+          log9.warn(
             `OpenClaw flush-plan processing skipped: ${result.reason ?? "unknown reason"}`
           );
         }
       } catch (error) {
         const detail = displayErrorDetail(error) || "unknown error";
-        log8.warn(`OpenClaw flush-plan processing failed: ${detail}`);
+        log9.warn(`OpenClaw flush-plan processing failed: ${detail}`);
       }
     }
     async function queueOpenClawFlushPlanProcessing(reason, runtimeWorkspaceDir, options = {}) {
@@ -9965,7 +10324,7 @@ var pluginDefinition = {
                 });
               },
               logger: {
-                debug: (message) => log8.debug(message)
+                debug: (message) => log9.debug(message)
               }
             });
           }
@@ -9977,7 +10336,7 @@ var pluginDefinition = {
       if (!cfg.dreaming.enabled) return;
       const route = resolveDreamNarrativeRoute(cfg, !!dreamNarrativeClient);
       if (route.kind === "skip") {
-        log8.debug(
+        log9.debug(
           "dreaming narrative skipped: no LLM available (set openaiApiKey or use modelSource=gateway)"
         );
         return;
@@ -10008,7 +10367,7 @@ Keep the reflection grounded in the evidence below.
             fallbackLlmRuntimeContextFromConfig2(cfg)
           );
           if (!route.hasExplicitModel && !llm.isAvailable(route.options)) {
-            log8.debug(
+            log9.debug(
               "dreaming narrative skipped: no gateway model configured (set dreaming.narrativeModel or taskModelChain)"
             );
             return;
@@ -10032,7 +10391,7 @@ Keep the reflection grounded in the evidence below.
           rawNarrative = typeof response.output_text === "string" ? response.output_text : JSON.stringify(response.output_text ?? "");
         }
       } catch (error) {
-        log8.warn(`dreaming narrative generation failed: ${String(error)}`);
+        log9.warn(`dreaming narrative generation failed: ${String(error)}`);
         return;
       }
       const parsed = parseDreamNarrativeResponse(
@@ -10048,12 +10407,11 @@ Keep the reflection grounded in the evidence below.
       });
       await queueDreamSurfaceSync();
     }
-    void pruneRecallAuditEntries(
-      recallAuditDir,
-      cfg.recallTranscriptRetentionDays
-    ).catch((error) => {
-      log8.debug(`recall audit prune failed: ${String(error)}`);
-    });
+    if (!discoveryPass) {
+      void pruneRecallAuditEntries(recallAuditDir, cfg.recallTranscriptRetentionDays).catch((error) => {
+        log9.debug(`recall audit prune failed: ${String(error)}`);
+      });
+    }
     const sessionCommandDescriptors = buildSessionCommandDescriptors(serviceId, {
       toggles: sessionToggleStore,
       getLastRecall: (sessionKey) => orchestrator.getLastRecall(sessionKey),
@@ -10088,7 +10446,7 @@ Keep the reflection grounded in the evidence below.
         timeoutMs: cfg.activeRecallTimeoutMs,
         cacheTtlMs: cfg.activeRecallCacheTtlMs,
         persistTranscripts: cfg.activeRecallPersistTranscripts,
-        transcriptDir: path11.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path11.join(pluginStateDir, cfg.activeRecallTranscriptDir),
+        transcriptDir: path13.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path13.join(pluginStateDir, cfg.activeRecallTranscriptDir),
         entityGraphDepth: cfg.activeRecallEntityGraphDepth,
         includeCausalTrajectories: cfg.activeRecallIncludeCausalTrajectories,
         includeDaySummary: cfg.activeRecallIncludeDaySummary,
@@ -10499,7 +10857,7 @@ Keep the reflection grounded in the evidence below.
           return;
         }
         if (typeof orchestrator.flushSession !== "function") {
-          log8.warn("codexCompat provider-switch flush unavailable; preserving binding");
+          log9.warn("codexCompat provider-switch flush unavailable; preserving binding");
           return;
         }
         try {
@@ -10509,7 +10867,7 @@ Keep the reflection grounded in the evidence below.
           });
           forgetCodexThread2(sessionKey, sessionIdentity.previousCodexThreadId);
         } catch (error) {
-          log8.warn(`codexCompat provider-switch flush failed: ${String(error)}`);
+          log9.warn(`codexCompat provider-switch flush failed: ${String(error)}`);
         }
       }
       async function flushAndForgetRememberedCodexThreadOnMetadataLoss(sessionKey, sessionIdentity) {
@@ -10527,7 +10885,7 @@ Keep the reflection grounded in the evidence below.
           return;
         }
         if (typeof orchestrator.flushSession !== "function") {
-          log8.warn("codexCompat metadata-loss flush unavailable; preserving binding");
+          log9.warn("codexCompat metadata-loss flush unavailable; preserving binding");
           return;
         }
         try {
@@ -10537,7 +10895,7 @@ Keep the reflection grounded in the evidence below.
           });
           forgetCodexThread2(sessionKey, rememberedThreadId);
         } catch (error) {
-          log8.warn(`codexCompat metadata-loss flush failed: ${String(error)}`);
+          log9.warn(`codexCompat metadata-loss flush failed: ${String(error)}`);
         }
       }
       async function resolveBeforeResetBufferKeys(sessionKey, sessionIdentity) {
@@ -10665,7 +11023,7 @@ Keep the reflection grounded in the evidence below.
         rememberCodexThread2(sessionKey, sessionIdentity.providerThreadId);
         if (sessionIdentity.isCodex && !codexCompactionModeLogged) {
           const mode = cfg.codexCompat.compactionFlushMode === "auto" ? "auto compaction flush mode (signal + heuristic)" : `${cfg.codexCompat.compactionFlushMode} compaction flush mode`;
-          log8.info(
+          log9.info(
             `codexCompat enabled: using ${mode} for bundled Codex sessions`
           );
           codexCompactionModeLogged = true;
@@ -10689,12 +11047,12 @@ Keep the reflection grounded in the evidence below.
               });
               clearCodexCompatCaches2(sessionKey, sessionIdentity.providerThreadId);
               rememberCodexThread2(sessionKey, sessionIdentity.providerThreadId);
-              log8.info(
+              log9.info(
                 `codexCompat heuristic flush: thread=${sessionIdentity.providerThreadId} messages ${previousCount} -> ${currentCount}`
               );
             } catch (error) {
               shouldPersistMessageCount = false;
-              log8.warn(`codexCompat heuristic flush failed: ${String(error)}`);
+              log9.warn(`codexCompat heuristic flush failed: ${String(error)}`);
             }
           }
           if (typeof currentCount === "number" && shouldPersistMessageCount && codexBaselineKey) {
@@ -10705,10 +11063,10 @@ Keep the reflection grounded in the evidence below.
         const runtimeAgent = ctx.runtime?.agent;
         const agentId = ctx?.agentId ?? runtimeAgent?.id ?? "main";
         const verboseRequested = cfg.verboseRecallVisibility !== false && isVerboseRecallRequested(event, ctx);
-        log8.debug(
+        log9.debug(
           `${hookLabel}: sessionKey=${sessionKey}, promptLen=${prompt.length}`
         );
-        log8.debug(
+        log9.debug(
           `${hookLabel}: cronRecallMode=${cfg.cronRecallMode}, allowlistCount=${cfg.cronRecallAllowlist.length}`
         );
         if (sessionKey.includes(":cron:") && cfg.cronRecallMode === "allowlist") {
@@ -10716,12 +11074,12 @@ Keep the reflection grounded in the evidence below.
             const re = wildcardToRegExp(pattern);
             return re.test(sessionKey);
           });
-          log8.debug(
+          log9.debug(
             `${hookLabel}: cron allowlist match=${matchedPattern ? "yes" : "no"} pattern=${matchedPattern ?? "none"}`
           );
         }
         if (shouldSkipRecallForSession(sessionKey, cfg)) {
-          log8.debug(
+          log9.debug(
             `${hookLabel}: skip recall for cron session ${sessionKey} (mode=${cfg.cronRecallMode})`
           );
           return;
@@ -10745,7 +11103,7 @@ Keep the reflection grounded in the evidence below.
               injectedChars: 0,
               toggleState: auditToggleState
             }).catch((error) => {
-              log8.debug(`recall audit append failed: ${String(error)}`);
+              log9.debug(`recall audit append failed: ${String(error)}`);
             });
           }
           if (!verboseRequested) return;
@@ -10799,7 +11157,7 @@ Keep the reflection grounded in the evidence below.
           const shouldWarnAndSuppressBundledActiveMemoryCollision = cfg.activeRecallEnabled && !cfg.activeRecallAllowChainedActiveMemory && bundledActiveMemoryEnabledForAgent;
           if (shouldWarnAndSuppressBundledActiveMemoryCollision && !warnedBundledActiveMemoryCollisionAgents.has(agentId)) {
             warnedBundledActiveMemoryCollisionAgents.add(agentId);
-            log8.warn(
+            log9.warn(
               `active recall suppressed because bundled active-memory plugin is enabled for agent "${agentId}" while activeRecallAllowChainedActiveMemory=false`
             );
           }
@@ -10813,7 +11171,7 @@ Keep the reflection grounded in the evidence below.
             ),
             currentMessage: prompt
           }).catch((error) => {
-            log8.debug(`active recall fallback failed: ${String(error)}`);
+            log9.debug(`active recall fallback failed: ${String(error)}`);
             return null;
           });
           const activeRecallLines = activeRecallResult?.summary && activeRecallResult.summary.length > 0 ? ["## Active Recall (Remnic)", "", activeRecallResult.summary, ""] : [];
@@ -10828,7 +11186,7 @@ Keep the reflection grounded in the evidence below.
             }
           });
           recallComposition ??= { context };
-          log8.debug(
+          log9.debug(
             `${hookLabel}: recall returned ${context?.length ?? 0} chars`
           );
           const lastRecall = orchestrator.getLastRecall(sessionKey);
@@ -10875,7 +11233,7 @@ Keep the reflection grounded in the evidence below.
                 requestedMode: lastRecall?.requestedMode,
                 fallbackUsed: lastRecall?.fallbackUsed
               }).catch((error) => {
-                log8.debug(`recall audit append failed: ${String(error)}`);
+                log9.debug(`recall audit append failed: ${String(error)}`);
               });
             }
             if (mergedLines.length === 0) return;
@@ -10902,7 +11260,7 @@ Keep the reflection grounded in the evidence below.
               requestedMode: lastRecall?.requestedMode,
               fallbackUsed: lastRecall?.fallbackUsed
             }).catch((error) => {
-              log8.debug(`recall audit append failed: ${String(error)}`);
+              log9.debug(`recall audit append failed: ${String(error)}`);
             });
           }
           const verboseLines = verboseRequested ? buildVerboseRecallHeader({
@@ -10922,12 +11280,12 @@ Keep the reflection grounded in the evidence below.
           const memorySectionLines = memoryContext.lines;
           const memoryLines = useMemoryPromptSection ? memorySectionLines : [...auxiliaryLines, ...memorySectionLines];
           const promptWithVerbose = useMemoryPromptSection ? auxiliaryLines.length > 0 ? auxiliaryLines.join("\n").replace(/\n$/, "") : void 0 : auxiliaryLines.length > 0 ? [...auxiliaryLines, ...memorySectionLines].join("\n").replace(/\n$/, "") : memoryContext.prompt;
-          log8.debug(
+          log9.debug(
             `${hookLabel}: returning memory context with ${trimmed.length} chars`
           );
           return promptWithVerbose ? { prependSystemContext: promptWithVerbose, memoryLines } : { memoryLines };
         } catch (err) {
-          log8.error("recall failed", err);
+          log9.error("recall failed", err);
           lastRecallSummaryBySession.set(sessionKey, null);
           clearCodexCompatCaches2(sessionKey, void 0, {
             preserveMessageCount: true,
@@ -10978,7 +11336,7 @@ Keep the reflection grounded in the evidence below.
       if (useMemoryPromptSection && api.registerMemoryPromptSection) {
         if (cfg.activeRecallEnabled && !globalThis[ACTIVE_RECALL_OVERLAP_WARNED]) {
           globalThis[ACTIVE_RECALL_OVERLAP_WARNED] = true;
-          log8.warn(
+          log9.warn(
             "activeRecallEnabled=true while memory-slot prompt injection is active (registerMemoryPromptSection). Prompt injection does NOT require active recall; this runs a second blocking retrieval per turn. Disable activeRecallEnabled unless the secondary pre-reply summary block is intentional (issue #1550)."
           );
         }
@@ -11189,7 +11547,7 @@ Keep the reflection grounded in the evidence below.
                   agentIds: capabilityAgentIds
                 });
               } catch (err) {
-                log8.error("publicArtifacts.listArtifacts failed", err);
+                log9.error("publicArtifacts.listArtifacts failed", err);
                 return [];
               }
             }
@@ -11206,14 +11564,14 @@ Keep the reflection grounded in the evidence below.
         }
         const builderDesc = !promptInjectionAllowed ? " (promptBuilder omitted \u2014 injection disabled by policy)" : memoryPromptBuilder ? " and promptBuilder (from registerMemoryPromptSection)" : " and promptBuilder (capability-only fallback)";
         const capabilityDesc = typeof api.registerMemoryCapability === "function" ? `memory capability with publicArtifacts provider${builderDesc}` : "split memory runtime/flush-plan surfaces";
-        log8.info(`registered ${capabilityDesc}`);
+        log9.info(`registered ${capabilityDesc}`);
       }
       if (cfg.openclawMessageReceivedCaptureEnabled) {
         api.on(
           "message_received",
           async (event, ctx) => {
             if (cfg.heartbeat.enabled && cfg.heartbeat.gateExtractionDuringHeartbeat && isHeartbeatTrigger2(event, ctx)) {
-              log8.debug(
+              log9.debug(
                 `message_received: skipping transcript capture during heartbeat run for ${ctx?.sessionKey ?? "default"}`
               );
               return;
@@ -11301,7 +11659,7 @@ Keep the reflection grounded in the evidence below.
                 rememberPendingSparseInboundContentFingerprint2(sparseInboundContentFingerprint);
               }
             } catch (err) {
-              log8.debug(`message_received transcript append failed: ${err}`);
+              log9.debug(`message_received transcript append failed: ${err}`);
             }
           }
         );
@@ -11312,7 +11670,7 @@ Keep the reflection grounded in the evidence below.
           if (!event.success || !Array.isArray(event.messages)) return;
           if (event.messages.length === 0) return;
           if (cfg.heartbeat.enabled && cfg.heartbeat.gateExtractionDuringHeartbeat && isHeartbeatTrigger2(event, ctx)) {
-            log8.debug(
+            log9.debug(
               `agent_end: skipping transcript/extraction buffering during heartbeat run for ${ctx?.sessionKey ?? "default"}`
             );
             return;
@@ -11375,7 +11733,7 @@ Keep the reflection grounded in the evidence below.
                 messages
               });
             } catch (error) {
-              log8.debug(
+              log9.debug(
                 `agent_end objective-state writer skipped due to error: ${error}`
               );
             }
@@ -11493,11 +11851,11 @@ Keep the reflection grounded in the evidence below.
                   );
                 }
               } catch (lcmErr) {
-                log8.debug(`LCM agent_end indexing error: ${lcmErr}`);
+                log9.debug(`LCM agent_end indexing error: ${lcmErr}`);
               }
             }
           } catch (err) {
-            log8.error("agent_end processing failed", err);
+            log9.error("agent_end processing failed", err);
           }
         }
       );
@@ -11523,7 +11881,7 @@ Keep the reflection grounded in the evidence below.
                 clearCodexCompatCaches2(sessionKey, signalThreadId);
                 rememberCodexThread2(sessionKey, signalThreadId);
               } catch (error) {
-                log8.warn(`codexCompat signal flush failed: ${String(error)}`);
+                log9.warn(`codexCompat signal flush failed: ${String(error)}`);
               }
             }
             if (orchestrator.lcmEngine?.enabled) {
@@ -11551,7 +11909,7 @@ Keep the reflection grounded in the evidence below.
                 );
                 await orchestrator.lcmEngine.preCompactionFlush(sessionKey);
               } catch (lcmErr) {
-                log8.debug(`LCM before_compaction error: ${lcmErr}`);
+                log9.debug(`LCM before_compaction error: ${lcmErr}`);
               }
             }
             if (!orchestrator.config.checkpointEnabled) {
@@ -11571,10 +11929,10 @@ Keep the reflection grounded in the evidence below.
                 turns: checkpointTurns,
                 ttl: new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString()
               });
-              log8.info(`saved checkpoint for ${sessionKey} before compaction`);
+              log9.info(`saved checkpoint for ${sessionKey} before compaction`);
             }
           } catch (err) {
-            log8.error("before_compaction hook failed", err);
+            log9.error("before_compaction hook failed", err);
           }
         }
       );
@@ -11614,28 +11972,28 @@ Keep the reflection grounded in the evidence below.
                 );
                 await orchestrator.lcmEngine.verifyPostCompaction(sessionKey);
               } catch (lcmErr) {
-                log8.debug(`LCM after_compaction error: ${lcmErr}`);
+                log9.debug(`LCM after_compaction error: ${lcmErr}`);
               }
             }
             void queueOpenClawFlushPlanProcessing("after_compaction", workspaceDir);
             if (!orchestrator.config.compactionResetEnabled) {
-              log8.debug(
+              log9.debug(
                 `compaction completed for ${sessionKey}, reset disabled \u2014 skipping`
               );
               return;
             }
-            log8.info(
+            log9.info(
               `compaction completed for ${sessionKey}, triggering session reset`
             );
             const apiAny = api;
             if (typeof apiAny.resetSession === "function") {
               const result = await apiAny.resetSession(sessionKey, "new");
               if (result?.ok === true) {
-                log8.info(
+                log9.info(
                   `session reset via API for ${sessionKey}, new sessionId=${result.sessionId}`
                 );
                 const safeSessionKey = sanitizeSessionKeyForFilename(sessionKey);
-                const signalPath = path11.join(
+                const signalPath = path13.join(
                   workspaceDir,
                   `.compaction-reset-signal-${safeSessionKey}`
                 );
@@ -11651,17 +12009,17 @@ Keep the reflection grounded in the evidence below.
                 const errorDetail = result && typeof result === "object" && "error" in result ? String(
                   result.error ?? "unknown error"
                 ) : `invalid result: ${JSON.stringify(result)}`;
-                log8.error(
+                log9.error(
                   `api.resetSession failed for ${sessionKey}: ${errorDetail}`
                 );
               }
             } else {
-              log8.error(
+              log9.error(
                 `api.resetSession not available \u2014 compaction reset requires OC fork with PR #29985. Session ${sessionKey} will continue without reset.`
               );
             }
           } catch (err) {
-            log8.error("after_compaction reset failed", err);
+            log9.error("after_compaction reset failed", err);
           }
         }
       );
@@ -11694,7 +12052,7 @@ Keep the reflection grounded in the evidence below.
                 ).catch((error) => {
                   if (!flushAbort.signal.aborted) {
                     flushFailed = true;
-                    log8.warn(
+                    log9.warn(
                       `before_reset flush failed for ${bufferKey}: ${String(error)}`
                     );
                   }
@@ -11727,7 +12085,7 @@ Keep the reflection grounded in the evidence below.
               );
             }
             if (flushTimedOut) {
-              log8.warn(
+              log9.warn(
                 `before_reset flush timed out after ${cfg.beforeResetTimeoutMs}ms`
               );
             }
@@ -11742,18 +12100,18 @@ Keep the reflection grounded in the evidence below.
           }
         );
       } catch (error) {
-        log8.debug(`before_reset hook unavailable on this runtime: ${String(error)}`);
+        log9.debug(`before_reset hook unavailable on this runtime: ${String(error)}`);
       }
       if (!passiveMode && sdkCaps.hasBeforePromptBuild) {
         api.on(
           "session_start",
           async (event, ctx) => {
             const sessionKey = event.sessionKey ?? "default";
-            log8.debug(`session_start: ${sessionKey}`);
+            log9.debug(`session_start: ${sessionKey}`);
             try {
               await orchestrator.maybeRunFileHygiene().catch(() => void 0);
             } catch (err) {
-              log8.debug(`session_start file hygiene failed: ${err}`);
+              log9.debug(`session_start file hygiene failed: ${err}`);
             }
             void queueOpenClawFlushPlanProcessing(
               "session_start",
@@ -11766,7 +12124,7 @@ Keep the reflection grounded in the evidence below.
           "session_end",
           async (event, ctx) => {
             const sessionKey = event.sessionKey ?? ctx.sessionKey ?? "default";
-            log8.debug(`session_end: ${sessionKey}`);
+            log9.debug(`session_end: ${sessionKey}`);
             const sessionIdentity = resolveSessionIdentity2(sessionKey, event, ctx);
             const rememberedThreadId = sessionIdentity.providerThreadId ?? resolveStoredCodexThreadId2(sessionKey);
             const bufferKeys = await resolveBeforeResetBufferKeys(sessionKey, {
@@ -11784,7 +12142,7 @@ Keep the reflection grounded in the evidence below.
                   });
                 } catch (error) {
                   flushFailed = true;
-                  log8.warn(
+                  log9.warn(
                     `session_end flush failed for ${bufferKey}: ${String(error)}`
                   );
                 }
@@ -11809,7 +12167,7 @@ Keep the reflection grounded in the evidence below.
           "before_tool_call",
           async (event, _ctx) => {
             if (event.toolName) {
-              log8.debug(`before_tool_call: ${event.toolName}`);
+              log9.debug(`before_tool_call: ${event.toolName}`);
             }
           }
         );
@@ -11817,7 +12175,7 @@ Keep the reflection grounded in the evidence below.
           "after_tool_call",
           async (event, _ctx) => {
             if (event.toolName) {
-              log8.debug(
+              log9.debug(
                 `after_tool_call: ${event.toolName} (${event.durationMs ?? "?"}ms)`
               );
             }
@@ -11828,7 +12186,7 @@ Keep the reflection grounded in the evidence below.
           async (event, ctx) => {
             const sessionKey = ctx?.sessionKey ?? "default";
             if (event.tokenUsage) {
-              log8.debug(
+              log9.debug(
                 `llm_output: model=${event.model ?? "?"}, tokens=${event.tokenUsage.input ?? 0}/${event.tokenUsage.output ?? 0}, ${event.durationMs ?? "?"}ms, session=${sessionKey}`
               );
             }
@@ -11837,7 +12195,7 @@ Keep the reflection grounded in the evidence below.
         api.on(
           "subagent_spawned",
           async (event, _ctx) => {
-            log8.debug(
+            log9.debug(
               `subagent_spawned: ${event.subagentId ?? "?"} purpose=${event.purpose ?? "?"} parent=${event.parentSessionKey ?? "?"}`
             );
           }
@@ -11845,7 +12203,7 @@ Keep the reflection grounded in the evidence below.
         api.on(
           "subagent_ended",
           async (event, _ctx) => {
-            log8.debug(
+            log9.debug(
               `subagent_ended: ${event.subagentId ?? "?"} success=${event.success ?? "?"} ${event.durationMs ?? "?"}ms`
             );
           }
@@ -11854,8 +12212,8 @@ Keep the reflection grounded in the evidence below.
     }
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path11.join(
-        os.homedir(),
+      const cronFilePath = path13.join(
+        os2.homedir(),
         ".openclaw",
         "cron",
         "jobs.json"
@@ -11863,7 +12221,7 @@ Keep the reflection grounded in the evidence below.
       try {
         const loadedJobs = await loadHourlySummaryCronJobsData(cronFilePath);
         if (loadedJobs.status === "invalid") {
-          log8.error(
+          log9.error(
             `hourly summary cron auto-registration skipped: existing jobs file is invalid at ${cronFilePath}`,
             loadedJobs.error
           );
@@ -11878,7 +12236,7 @@ Keep the reflection grounded in the evidence below.
             { nowMs: Date.now() }
           );
           if (!changed) {
-            log8.debug("hourly summary cron job already up to date");
+            log9.debug("hourly summary cron job already up to date");
             return;
           }
           jobsData.jobs[existingIndex] = job;
@@ -11886,7 +12244,7 @@ Keep the reflection grounded in the evidence below.
             cronFilePath,
             JSON.stringify(jobsData, null, 2)
           );
-          log8.info("reconciled hourly summary cron job routing to configured task model");
+          log9.info("reconciled hourly summary cron job routing to configured task model");
           return;
         }
         const randomMinute = Math.floor(Math.random() * 59) + 1;
@@ -11900,9 +12258,9 @@ Keep the reflection grounded in the evidence below.
           cronFilePath,
           JSON.stringify(jobsData, null, 2)
         );
-        log8.info("auto-registered hourly summary cron job");
+        log9.info("auto-registered hourly summary cron job");
       } catch (err) {
-        log8.error("failed to auto-register hourly summary cron job:", err);
+        log9.error("failed to auto-register hourly summary cron job:", err);
       }
     }
     if (typeof api.registerMemoryCorpusSupplement === "function") {
@@ -11913,32 +12271,32 @@ Keep the reflection grounded in the evidence below.
       };
       const normalizeCorpusPath = (value) => value.trim().replace(/\\/g, "/").replace(/^\.\//, "");
       const pathIsInside = (root, candidate) => {
-        const relative = path11.relative(root, candidate);
-        return relative === "" || !relative.startsWith("..") && !path11.isAbsolute(relative);
+        const relative = path13.relative(root, candidate);
+        return relative === "" || !relative.startsWith("..") && !path13.isAbsolute(relative);
       };
       const corpusPathCandidates = (rawPath, storageDir) => {
         const candidates = /* @__PURE__ */ new Set();
         const trimmed = rawPath.trim();
         if (!trimmed) return [];
         candidates.add(normalizeCorpusPath(trimmed));
-        if (path11.isAbsolute(trimmed)) {
-          const absolutePath = path11.resolve(trimmed);
-          const absoluteStorageDir = path11.resolve(storageDir);
+        if (path13.isAbsolute(trimmed)) {
+          const absolutePath = path13.resolve(trimmed);
+          const absoluteStorageDir = path13.resolve(storageDir);
           if (pathIsInside(absoluteStorageDir, absolutePath)) {
-            candidates.add(normalizeCorpusPath(path11.relative(absoluteStorageDir, absolutePath)));
+            candidates.add(normalizeCorpusPath(path13.relative(absoluteStorageDir, absolutePath)));
           }
         }
-        candidates.add(path11.basename(trimmed));
+        candidates.add(path13.basename(trimmed));
         return [...candidates].filter((candidate) => candidate.length > 0);
       };
       const displayCorpusPath = (rawPath, storageDir) => {
         const trimmed = rawPath.trim();
         if (!trimmed) return "";
-        if (path11.isAbsolute(trimmed)) {
-          const absolutePath = path11.resolve(trimmed);
-          const absoluteStorageDir = path11.resolve(storageDir);
+        if (path13.isAbsolute(trimmed)) {
+          const absolutePath = path13.resolve(trimmed);
+          const absoluteStorageDir = path13.resolve(storageDir);
           if (pathIsInside(absoluteStorageDir, absolutePath)) {
-            return normalizeCorpusPath(path11.relative(absoluteStorageDir, absolutePath));
+            return normalizeCorpusPath(path13.relative(absoluteStorageDir, absolutePath));
           }
         }
         return normalizeCorpusPath(trimmed);
@@ -12012,7 +12370,7 @@ Keep the reflection grounded in the evidence below.
               };
             });
           } catch (err) {
-            log8.warn(`memory corpus search failed: ${err}`);
+            log9.warn(`memory corpus search failed: ${err}`);
             throw corpusBackendError("search", err);
           }
         },
@@ -12048,30 +12406,31 @@ Keep the reflection grounded in the evidence below.
               updatedAt: memory.frontmatter.updated
             };
           } catch (err) {
-            log8.warn(`memory corpus get failed: ${err}`);
+            log9.warn(`memory corpus get failed: ${err}`);
             throw corpusBackendError("get", err);
           }
         }
       };
       api.registerMemoryCorpusSupplement(remnicCorpusSupplement);
     }
-    if (cfg.openclawToolsEnabled !== false && typeof api.registerTool === "function") {
-      api.registerTool(
-        buildMemorySearchTool(orchestrator, {
-          snippetMaxChars: cfg.openclawToolSnippetMaxChars
-        })
-      );
-      api.registerTool(buildMemoryGetTool(orchestrator));
-    }
+    const adaptersEnabled = cfg.openclawToolsEnabled !== false;
+    const ownedToolNames = registerEmbeddedTools(api, {
+      enabled: adaptersEnabled,
+      passive: passiveMode,
+      tools: adaptersEnabled ? [
+        buildMemorySearchTool(orchestrator, { snippetMaxChars: cfg.openclawToolSnippetMaxChars }),
+        buildMemoryGetTool(orchestrator)
+      ] : [buildLegacyMemorySearchToolForPublicShape(orchestrator)]
+    });
     const commandApi = api;
-    if (!passiveMode && cfg.commandsListEnabled && cfg.sessionTogglesEnabled !== false) {
+    if (!discoveryPass && !passiveMode && cfg.commandsListEnabled && cfg.sessionTogglesEnabled !== false) {
       if (typeof commandApi.registerCommand === "function" && !globalThis[SESSION_COMMANDS_REGISTERED_GUARD]) {
         globalThis[SESSION_COMMANDS_REGISTERED_GUARD] = true;
         for (const descriptor of sessionCommandDescriptors) {
           commandApi.registerCommand(descriptor);
         }
       } else if (typeof commandApi.registerCommand !== "function") {
-        log8.debug(
+        log9.debug(
           "registerCommand unavailable on this runtime; skipping Remnic session command descriptors because commands.list is a gateway RPC surface, not a typed plugin hook"
         );
       }
@@ -12080,7 +12439,9 @@ Keep the reflection grounded in the evidence below.
       api,
       orchestrator,
       // Host-native, model-inaccessible origin for shared-context tool writes.
-      getOpenClawRuntimeAgentId(api)
+      getOpenClawRuntimeAgentId(api),
+      // Names the shared ownership record already carries.
+      ownedToolNames
     );
     if (orchestrator.lcmEngine?.enabled) {
       registerLcmTools(
@@ -12088,7 +12449,7 @@ Keep the reflection grounded in the evidence below.
         orchestrator.lcmEngine
       );
     }
-    if (!globalThis[CLI_REGISTERED_GUARD]) {
+    if (!discoveryPass && !globalThis[CLI_REGISTERED_GUARD]) {
       globalThis[CLI_REGISTERED_GUARD] = true;
       registerCli(
         api,
@@ -12110,7 +12471,7 @@ Keep the reflection grounded in the evidence below.
             if (globalThis[keys.SERVICE_STARTED]) return;
           }
           if (globalThis[keys.SERVICE_STARTED]) {
-            log8.debug(
+            log9.debug(
               `${serviceId}: service.start() called again \u2014 skipping duplicate init`
             );
             return;
@@ -12123,10 +12484,10 @@ Keep the reflection grounded in the evidence below.
         globalThis[keys.ORCHESTRATOR] = orchestrator;
         const initPromise = (async () => {
           try {
-            log8.info("initializing engram memory system...");
+            log9.info("initializing engram memory system...");
             await orchestrator.initialize();
             if (!didCountStart) return;
-            activeOpikExporter = createOpikExporter({}, log8);
+            activeOpikExporter = createOpikExporter({}, log9);
             if (activeOpikExporter) activeOpikExporter.subscribe();
             if (orchestrator.config.transcriptEnabled) {
               await orchestrator.transcript.cleanup(
@@ -12138,7 +12499,7 @@ Keep the reflection grounded in the evidence below.
               await ensureHourlySummaryCron(api);
               if (!didCountStart) return;
             } else if (orchestrator.config.hourlySummariesEnabled) {
-              log8.info(
+              log9.info(
                 "hourly summaries enabled; cron auto-register is disabled. To schedule summaries, create an isolated/agentTurn cron job that calls `memory_summarize_hourly`."
               );
             }
@@ -12154,7 +12515,7 @@ Keep the reflection grounded in the evidence below.
                   resolveDreamJournalPath(),
                   () => {
                     void queueDreamSurfaceSync().catch((error) => {
-                      log8.debug(`dream surface watch sync failed: ${String(error)}`);
+                      log9.debug(`dream surface watch sync failed: ${String(error)}`);
                     });
                   }
                 );
@@ -12174,7 +12535,7 @@ Keep the reflection grounded in the evidence below.
                   resolveHeartbeatJournalPath(),
                   () => {
                     void queueHeartbeatSurfaceSync().catch((error) => {
-                      log8.debug(`heartbeat surface watch sync failed: ${String(error)}`);
+                      log9.debug(`heartbeat surface watch sync failed: ${String(error)}`);
                     });
                   }
                 );
@@ -12195,17 +12556,17 @@ Keep the reflection grounded in the evidence below.
               }
               try {
                 const status = await accessHttpServer.start();
-                log8.info(
+                log9.info(
                   `engram access HTTP ready at http://${status.host}:${status.port}`
                 );
               } catch (err) {
-                log8.error("failed to start engram access HTTP server", err);
+                log9.error("failed to start engram access HTTP server", err);
               }
             }
             if (!didCountStart) return;
             globalThis[keys.SERVICE_STARTED] = true;
-            log8.info("engram memory system ready");
-            log8.info(
+            log9.info("engram memory system ready");
+            log9.info(
               `gateway_start fired \u2014 Remnic memory plugin is active (id=${pluginDefinition.id}, memoryDir=${cfg.memoryDir})`
             );
             void queueOpenClawFlushPlanProcessing(
@@ -12279,7 +12640,7 @@ Keep the reflection grounded in the evidence below.
           try {
             activeOpikExporter?.unsubscribe();
           } catch (err) {
-            log8.debug(`engram opik exporter unsubscribe failed: ${err}`);
+            log9.debug(`engram opik exporter unsubscribe failed: ${err}`);
           }
           activeOpikExporter = null;
           const finishCodex = beginCodexSubscriptionShutdown(getCodexSubscriptionRunnerForOwner(cfg));
@@ -12287,7 +12648,7 @@ Keep the reflection grounded in the evidence below.
             try {
               await accessHttpServer.stop();
             } catch (err) {
-              log8.debug(`engram access HTTP stop failed: ${err}`);
+              log9.debug(`engram access HTTP stop failed: ${err}`);
             }
             stopDreamWatcher?.();
             stopDreamWatcher = null;
@@ -12298,7 +12659,7 @@ Keep the reflection grounded in the evidence below.
             try {
               await orchestrator.destroy();
             } catch (err) {
-              log8.debug(`engram orchestrator destroy on stop failed: ${err}`);
+              log9.debug(`engram orchestrator destroy on stop failed: ${err}`);
             }
           } finally {
             finishCodex();
@@ -12324,7 +12685,7 @@ Keep the reflection grounded in the evidence below.
         if (!secondaryTookOver) {
           globalThis[keys.SERVICE_STARTED] = false;
         }
-        log8.info("stopped");
+        log9.info("stopped");
       }
     });
   }
@@ -12460,9 +12821,9 @@ function truncateMetadataValue(value, maxChars) {
   return value.length <= maxChars ? value : value.slice(0, maxChars);
 }
 async function resolveFlushPlanProcessingChainKey(workspaceRoot) {
-  const lexicalRoot = path11.resolve(workspaceRoot);
+  const lexicalRoot = path13.resolve(workspaceRoot);
   try {
-    return path11.resolve(await realPathLater(lexicalRoot));
+    return path13.resolve(await realPathLater(lexicalRoot));
   } catch {
     return lexicalRoot;
   }