@remnic/plugin-openclaw 9.46.0 → 9.46.2

package/dist/index.js

@@ -3114,14 +3114,14 @@ __reExport(access_http_exports, access_http_star);
 import * as access_http_star from "@remnic/core/access-http";
 
 // ../../src/index.ts
-import path6 from "path";
+import path10 from "path";
 import os from "os";
 
 // ../../src/opik-exporter.ts
 import { createOpikExporter, OpikExporter } from "@remnic/core/opik-exporter";
 
 // ../../src/index.ts
-import { readEnvVar, resolveHomeDir as resolveHomeDir2 } from "@remnic/core/runtime/env";
+import { readEnvVar, resolveHomeDir as resolveHomeDir3 } from "@remnic/core/runtime/env";
 import { displayErrorDetail as displayErrorDetail2 } from "@remnic/core/runtime/better-sqlite";
 
 // ../../src/migrate/from-engram.ts
@@ -5332,51 +5332,31 @@ function resolveRemnicOpenClawPluginEntry(raw, preferredId) {
 }
 
 // src/delegate-runtime.ts
-import path4 from "path";
+import path8 from "path";
 import {
   renderMemoryContextPrompt
 } from "@remnic/core";
+import { log as log6 } from "@remnic/core/logger";
+
+// src/delegate-authorization.ts
 import { log as log2 } from "@remnic/core/logger";
-import {
-  SESSION_NAMESPACE_BINDING_MAX_ENTRIES,
-  SESSION_NAMESPACE_BINDING_MAX_NAMESPACES,
-  SESSION_NAMESPACE_BINDING_MAX_NAMESPACE_LENGTH,
-  createFileSessionNamespaceBindingStore
-} from "@remnic/core/session-namespace-bindings";
-import { createFileToggleStore } from "@remnic/core/session-toggles";
 
 // src/bridge.ts
-import fs from "fs";
-import path3 from "path";
+import fs3 from "fs";
+import path6 from "path";
+import { isIPv4, isIPv6 } from "net";
 import { Worker } from "worker_threads";
-import { expandTildePath } from "@remnic/core";
-var DEFAULT_HOST = "127.0.0.1";
-var DEFAULT_PORT = 4318;
-var LIVENESS_PATH = "/engram/v1/live";
-var LEGACY_HEALTH_PATH = "/engram/v1/health";
-var DEFAULT_DAEMON_HEALTH_TIMEOUT_MS = 1e4;
-function parseBridgeHealthTimeoutMs(value) {
-  if (value === void 0) return DEFAULT_DAEMON_HEALTH_TIMEOUT_MS;
-  const parsed = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
-  if (typeof parsed !== "number" || !Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 1 || parsed > 12e4) {
-    throw new Error(
-      `bridgeHealthTimeoutMs must be an integer in [1, 120000]; got ${String(value)}`
-    );
-  }
-  return parsed;
-}
-function parseOpenClawBridgeConfig(config) {
-  return {
-    healthTimeoutMs: parseBridgeHealthTimeoutMs(config.bridgeHealthTimeoutMs)
-  };
-}
+import { expandTildePath as expandTildePath3 } from "@remnic/core";
+
+// src/bridge-health-worker.ts
 function runHealthWorker(request, data) {
+  const READINESS_RETRY_MS = 250;
   const view = new Int32Array(data.state);
   let completed = false;
-  function finish(ok) {
+  function finish(ok, rejectedAuth = false) {
     if (completed) return;
     completed = true;
-    Atomics.store(view, 0, ok ? 1 : 2);
+    Atomics.store(view, 0, ok ? 1 : rejectedAuth ? 3 : 2);
     Atomics.notify(view, 0);
   }
   function probe(pathname, fallbackPath) {
@@ -5385,7 +5365,7 @@ function runHealthWorker(request, data) {
       finish(false);
       return;
     }
-    let responseReceived = false;
+    let settled = false;
     try {
       const headers = {};
       if (data.token) headers.Authorization = `Bearer ${data.token}`;
@@ -5399,24 +5379,58 @@ function runHealthWorker(request, data) {
           headers
         },
         (res) => {
-          responseReceived = true;
           const statusCode = res.statusCode;
+          if (statusCode === 200 && data.capture && data.captureField && res.on) {
+            let body = "";
+            res.setEncoding?.("utf8");
+            res.on("data", (chunk) => {
+              if (body.length < 65536) body += chunk ?? "";
+            });
+            res.on("end", () => {
+              try {
+                const parsed = JSON.parse(body);
+                const value = typeof parsed === "object" && parsed !== null ? parsed[data.captureField] : void 0;
+                if (typeof value === "string") {
+                  const bytes = new TextEncoder().encode(value);
+                  const capture = new Uint8Array(data.capture);
+                  new DataView(data.capture).setUint32(0, bytes.length);
+                  if (bytes.length <= capture.length - 4) capture.set(bytes, 4);
+                }
+              } catch {
+              }
+              settled = true;
+              finish(true);
+            });
+            res.on("error", () => {
+              if (!settled) finish(false);
+            });
+            return;
+          }
           res.resume();
+          settled = true;
           if (statusCode === 200) {
             finish(true);
           } else if (statusCode === 404 && fallbackPath) {
             probe(fallbackPath, null);
+          } else if (statusCode === 503) {
+            if (Date.now() + READINESS_RETRY_MS >= data.deadline) {
+              finish(false);
+              return;
+            }
+            setTimeout(() => probe(pathname, fallbackPath), READINESS_RETRY_MS);
+          } else if (statusCode === 401 || statusCode === 403) {
+            finish(false, true);
           } else {
             finish(false);
           }
         }
       );
       req.on("error", () => {
-        if (!responseReceived) finish(false);
+        if (!settled) finish(false);
       });
       req.on("timeout", () => {
         req.destroy();
-        if (!responseReceived) finish(false);
+        if (!settled) finish(false);
       });
       req.end();
     } catch {
@@ -5431,20 +5445,684 @@ import { workerData } from "node:worker_threads";
 const __name = (target) => target;
 (${runHealthWorker.toString()})(request, workerData);
 `;
+
+// src/bridge-unit-discovery.ts
+import fs2 from "fs";
+import path4 from "path";
+import { expandTildePath } from "@remnic/core";
+
+// src/bridge-service-units.ts
+import fs from "fs";
+import path3 from "path";
+function coercePort(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;
+}
+function foldContinuationLines(unit, joiner = " ") {
+  const logical = [];
+  let pending;
+  for (const raw of unit.split("\n")) {
+    const line = raw.replace(/\r$/, "");
+    const trailing = /(\\*)$/.exec(line)?.[1]?.length ?? 0;
+    const continues = trailing % 2 === 1;
+    const body = continues ? line.slice(0, -1) : line;
+    pending = pending === void 0 ? body : `${pending}${joiner}${joiner === "" ? body : body.trim()}`;
+    if (continues) continue;
+    logical.push(pending);
+    pending = void 0;
+  }
+  if (pending !== void 0) logical.push(pending);
+  return logical;
+}
+function readEffectiveDirectives(unit) {
+  const env = /* @__PURE__ */ new Map();
+  const envFiles = [];
+  const unsetEnv = [];
+  const execStart = [];
+  let workingDirectory;
+  for (const line of foldContinuationLines(unit)) {
+    const directive = /^\s*(Environment|EnvironmentFile|UnsetEnvironment|ExecStart|WorkingDirectory)=(.*)$/.exec(
+      line
+    );
+    if (directive === null) continue;
+    const [, name, rawValue = ""] = directive;
+    const value = rawValue.trim();
+    if (name === "Environment") {
+      if (value === "") {
+        env.clear();
+        continue;
+      }
+      for (const rawToken of value.match(/"[^"]*"|'[^']*'|\S+/g) ?? []) {
+        const token = /^(["']).*\1$/.test(rawToken) ? rawToken.slice(1, -1) : rawToken;
+        const split = token.indexOf("=");
+        if (split <= 0) continue;
+        env.set(token.slice(0, split), token.slice(split + 1));
+      }
+      continue;
+    }
+    if (name === "EnvironmentFile") {
+      if (value === "") {
+        envFiles.length = 0;
+        continue;
+      }
+      for (const rawToken of value.match(/"[^"]*"|'[^']*'|\S+/g) ?? []) {
+        const token = /^(["']).*\1$/.test(rawToken) ? rawToken.slice(1, -1) : rawToken;
+        envFiles.push(token.startsWith("-") ? token.slice(1) : token);
+      }
+      continue;
+    }
+    if (name === "UnsetEnvironment") {
+      if (value === "") {
+        unsetEnv.length = 0;
+        continue;
+      }
+      for (const rawToken of value.match(/"[^"]*"|'[^']*'|\S+/g) ?? []) {
+        unsetEnv.push(/^(["']).*\1$/.test(rawToken) ? rawToken.slice(1, -1) : rawToken);
+      }
+      continue;
+    }
+    if (name === "ExecStart") {
+      if (value === "") {
+        execStart.length = 0;
+        continue;
+      }
+      execStart.push(value);
+      continue;
+    }
+    workingDirectory = value === "" ? void 0 : value;
+  }
+  return { env, envFiles, unsetEnv, execStart, workingDirectory };
+}
+function parseEnvironmentFile(body) {
+  const parsed = /* @__PURE__ */ new Map();
+  for (const line of foldContinuationLines(body, "")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#") || trimmed.startsWith(";")) continue;
+    const split = trimmed.indexOf("=");
+    if (split <= 0) continue;
+    const key = trimmed.slice(0, split).trim();
+    const raw = trimmed.slice(split + 1).trim();
+    parsed.set(key, /^(["']).*\1$/.test(raw) ? raw.slice(1, -1) : raw);
+  }
+  return parsed;
+}
+function readUnitEnvironment(unit, scope, readFile4, listDir) {
+  const directives = readEffectiveDirectives(unit);
+  const merged = new Map(directives.env);
+  for (const candidate of directives.envFiles) {
+    const expandedFile = expandAccountRelative(candidate, scope);
+    if (!scope.userScoped && (expandedFile.includes("%") || expandedFile.startsWith("~"))) continue;
+    const resolved = settleUnitValue(expandedFile);
+    if (!path3.isAbsolute(resolved)) continue;
+    for (const match of expandEnvironmentFilePattern(resolved, listDir)) {
+      const body = readFile4(match);
+      if (body === void 0) continue;
+      for (const [key, value] of parseEnvironmentFile(body)) merged.set(key, value);
+    }
+  }
+  for (const name of directives.unsetEnv) {
+    const split = name.indexOf("=");
+    if (split <= 0) {
+      merged.delete(name);
+      continue;
+    }
+    const key = name.slice(0, split);
+    if (merged.get(key) === name.slice(split + 1)) merged.delete(key);
+  }
+  return merged;
+}
+function expandEnvironmentFilePattern(candidate, listDir) {
+  if (!/[*?[]/.test(candidate)) return [candidate];
+  const directory = path3.dirname(candidate);
+  const pattern = path3.basename(candidate);
+  if (/[*?[]/.test(directory)) return [];
+  const matcher = new RegExp(
+    `^${pattern.replace(/[.+^${}()|\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")}$`
+  );
+  return listDir(directory).filter((entry) => matcher.test(entry)).sort().map((entry) => path3.join(directory, entry));
+}
+function defaultUnitDirLister(directory) {
+  try {
+    return fs.readdirSync(directory);
+  } catch {
+    return [];
+  }
+}
+function defaultUnitFileReader(candidate) {
+  try {
+    return fs.readFileSync(candidate, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function readUnitEnv(unit, name, scope, readFile4 = defaultUnitFileReader, listDir = defaultUnitDirLister) {
+  const systemdValue = readUnitEnvironment(unit, scope, readFile4, listDir).get(name);
+  const systemd = systemdValue === void 0 ? null : [void 0, systemdValue];
+  const launchdRaw = new RegExp(`<key>${name}</key>\\s*<string>([^<]*)</string>`).exec(unit);
+  const launchd = launchdRaw === null ? null : [void 0, decodePlistString(launchdRaw[1] ?? "")];
+  const raw = (systemd?.[1] ?? launchd?.[1])?.trim();
+  if (raw === void 0) return void 0;
+  if (raw === "") return "";
+  const expanded = expandAccountRelative(raw, scope);
+  if (!scope.userScoped && (expanded.includes("%") || expanded.startsWith("~"))) return void 0;
+  return settleUnitValue(expanded);
+}
+function expandAccountRelative(value, scope) {
+  const withSpecifier = expandUnitSpecifiers(value, scope);
+  if (!scope.userScoped) return withSpecifier;
+  if (withSpecifier === "~") return scope.homeDir;
+  if (withSpecifier.startsWith("~/")) return path3.join(scope.homeDir, withSpecifier.slice(2));
+  return withSpecifier;
+}
+var ESCAPED_PERCENT = "\0remnic-escaped-percent\0";
+function userRuntimeDir() {
+  const getuid = globalThis.process?.getuid;
+  const uid = typeof getuid === "function" ? getuid.call(globalThis.process) : void 0;
+  return uid === void 0 ? "/run/user" : `/run/user/${uid}`;
+}
+function settleUnitValue(value) {
+  return value.replaceAll(ESCAPED_PERCENT, "%");
+}
+function expandUnitSpecifiers(value, scope) {
+  const home = scope.homeDir;
+  const env = globalThis.process?.["env"];
+  const xdg = (name, fallback) => {
+    const configured = scope.userScoped ? env?.[name] : void 0;
+    return configured !== void 0 && configured.trim() !== "" ? configured : fallback;
+  };
+  const directories = scope.userScoped ? {
+    E: xdg("XDG_CONFIG_HOME", path3.join(home, ".config")),
+    S: xdg("XDG_STATE_HOME", path3.join(home, ".local", "state")),
+    C: xdg("XDG_CACHE_HOME", path3.join(home, ".cache")),
+    L: path3.join(xdg("XDG_STATE_HOME", path3.join(home, ".local", "state")), "log"),
+    t: xdg("XDG_RUNTIME_DIR", userRuntimeDir())
+  } : { E: "/etc", S: "/var/lib", C: "/var/cache", L: "/var/log", t: "/run" };
+  return value.replace(/%(.)/g, (match, specifier) => {
+    if (specifier === "%") return ESCAPED_PERCENT;
+    if (specifier === "h") return scope.userScoped ? home : match;
+    return directories[specifier] ?? match;
+  });
+}
+function decodePlistString(value) {
+  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function readUnitWorkingDirectory(unit) {
+  const systemd = readEffectiveDirectives(unit).workingDirectory;
+  const launchdRaw = /<key>WorkingDirectory<\/key>\s*<string>([^<]*)<\/string>/.exec(unit)?.[1];
+  const launchd = launchdRaw === void 0 ? void 0 : decodePlistString(launchdRaw).trim();
+  const raw = systemd ?? launchd;
+  if (raw === void 0 || raw === "") return void 0;
+  return /^(["']).*\1$/.test(raw) ? raw.slice(1, -1) : raw;
+}
+function readUnitCliOverrides(unit, scope, readFile4, listDir) {
+  const tokens = [];
+  const environment = readUnitEnvironment(unit, scope, readFile4, listDir);
+  const substituteBraced = (token) => token.replace(
+    /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g,
+    (match, name) => environment.get(name) ?? match
+  );
+  const expandToken = (token) => {
+    const braced = substituteBraced(token);
+    const bare = /^\$([A-Za-z_][A-Za-z0-9_]*)$/.exec(braced);
+    const name = bare?.[1];
+    if (name === void 0) return [braced];
+    const value = environment.get(name);
+    if (value === void 0) return [braced];
+    return value.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  };
+  for (const command of readEffectiveDirectives(unit).execStart) {
+    for (const token of command.match(/"[^"]*"|'[^']*'|\S+/g) ?? []) {
+      tokens.push(...expandToken(token));
+    }
+  }
+  const programArgs = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(unit);
+  if (programArgs?.[1]) {
+    for (const entry of programArgs[1].matchAll(/<string>([^<]*)<\/string>/g)) {
+      tokens.push(decodePlistString(entry[1] ?? ""));
+    }
+  }
+  const unquote = (value) => /^(["']).*\1$/.test(value) ? value.slice(1, -1) : value;
+  const readFlag = (flag) => {
+    let found;
+    for (const [index, rawToken] of tokens.entries()) {
+      const token = unquote(rawToken);
+      if (token === flag) {
+        const next = tokens[index + 1];
+        if (next === void 0) continue;
+        const value = unquote(next);
+        if (value.startsWith("-")) continue;
+        found = value;
+        continue;
+      }
+      if (token.startsWith(`${flag}=`)) found = unquote(token.slice(flag.length + 1));
+    }
+    return found;
+  };
+  const expand = (value) => {
+    if (value === void 0) return void 0;
+    const expanded = expandAccountRelative(value, scope);
+    if (!scope.userScoped && (expanded.includes("%") || expanded.startsWith("~"))) return void 0;
+    return settleUnitValue(expanded);
+  };
+  const configPath = expand(readFlag("--config"));
+  const resolvedConfig = configPath === void 0 ? void 0 : resolveAgainstWorkingDirectory(
+    configPath,
+    readUnitWorkingDirectory(unit),
+    scope
+  );
+  const host = expand(readFlag("--host"));
+  const authToken = expand(readFlag("--auth-token"));
+  return {
+    ...resolvedConfig !== void 0 && path3.isAbsolute(resolvedConfig) ? { configPath: resolvedConfig } : {},
+    ...host === void 0 ? {} : { host },
+    ...coercePort(expand(readFlag("--port"))) === void 0 ? {} : { port: coercePort(expand(readFlag("--port"))) },
+    ...authToken === void 0 ? {} : { authToken }
+  };
+}
+function resolveUnitEndpoint(unit, scope, readFile4 = defaultUnitFileReader, listDir = defaultUnitDirLister) {
+  const cli = readUnitCliOverrides(unit, scope, readFile4, listDir);
+  const envOverride = (primary, legacy) => {
+    const value = readUnitEnv(unit, primary, scope, readFile4, listDir);
+    if (value !== void 0) return value === "" ? void 0 : value;
+    const legacyValue = readUnitEnv(unit, legacy, scope, readFile4, listDir);
+    return legacyValue === "" ? void 0 : legacyValue;
+  };
+  const host = cli.host ?? envOverride("REMNIC_HOST", "ENGRAM_HOST");
+  const port = cli.port ?? coercePort(envOverride("REMNIC_PORT", "ENGRAM_PORT"));
+  const authToken = cli.authToken ?? envOverride("REMNIC_AUTH_TOKEN", "ENGRAM_AUTH_TOKEN");
+  const configFromCli = cli.configPath === void 0 ? {} : { configPath: cli.configPath };
+  return {
+    ...resolveUnitConfigPathInner(unit, scope, readFile4, listDir),
+    ...configFromCli,
+    ...host === void 0 ? {} : { host },
+    ...port === void 0 ? {} : { port },
+    ...authToken === void 0 ? {} : { authToken }
+  };
+}
+function resolveUnitConfigPathInner(unit, scope, readFile4, listDir) {
+  const workingDirectory = readUnitWorkingDirectory(unit);
+  for (const name of ["REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH"]) {
+    const raw = readUnitEnv(unit, name, scope, readFile4, listDir);
+    if (raw === "") return {};
+    if (raw === void 0) continue;
+    const resolved = resolveAgainstWorkingDirectory(raw, workingDirectory, scope);
+    if (resolved === void 0) continue;
+    return { configPath: resolved };
+  }
+  if (workingDirectory !== void 0) {
+    for (const name of ["remnic.config.json", "engram.config.json"]) {
+      const candidate = resolveAgainstWorkingDirectory(name, workingDirectory, scope);
+      if (candidate !== void 0 && readFile4(candidate) !== void 0) {
+        return { configPath: candidate };
+      }
+    }
+  }
+  return {};
+}
+function resolveAgainstWorkingDirectory(candidate, workingDirectory, scope) {
+  if (path3.isAbsolute(candidate)) return candidate;
+  if (workingDirectory === void 0) return void 0;
+  if (!scope.userScoped && (workingDirectory.includes("%") || workingDirectory.startsWith("~"))) {
+    return void 0;
+  }
+  const expanded = settleUnitValue(expandAccountRelative(workingDirectory, scope));
+  if (!path3.isAbsolute(expanded)) return void 0;
+  return path3.resolve(expanded, candidate);
+}
+function resolveSystemUnitSources(unitDirs, unitNames, exists = (candidate) => fs.existsSync(candidate)) {
+  const sources = [];
+  for (const name of unitNames) {
+    const unitPath = [...unitDirs].reverse().map((dir) => path3.join(dir, name)).find((candidate) => exists(candidate));
+    if (unitPath === void 0) continue;
+    sources.push({ unitPath, dropInDirs: unitDirs.map((dir) => path3.join(dir, `${name}.d`)) });
+  }
+  return sources;
+}
+
+// src/bridge-unit-discovery.ts
+function resolveHomeDir() {
+  const env = globalThis.process?.["env"];
+  const home = env?.["HOME"] ?? env?.["USERPROFILE"];
+  return home !== void 0 && home.trim() !== "" ? expandTildePath(home) : "";
+}
+function fileExists(filePath) {
+  try {
+    return fs2.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
 var LAUNCHD_SERVICE_PATHS = [
   ["Library", "LaunchAgents", "ai.remnic.daemon.plist"],
   ["Library", "LaunchAgents", "ai.remnic.server.plist"],
   ["Library", "LaunchAgents", "ai.engram.daemon.plist"]
 ];
-var SYSTEMD_SERVICE_PATHS = [
-  [".config", "systemd", "user", "remnic.service"],
-  [".config", "systemd", "user", "engram.service"]
+var SYSTEMD_UNIT_NAMES = ["remnic.service", "engram.service"];
+function dedupe(entries) {
+  return [...new Set(entries)];
+}
+function systemdUserUnitDirs(homeDir) {
+  const env = globalThis.process?.["env"];
+  const xdgConfig = env?.["XDG_CONFIG_HOME"];
+  const xdgData = env?.["XDG_DATA_HOME"];
+  const underHome = (...segments) => path4.join(homeDir, ...segments);
+  const xdgConfigDirs = env?.["XDG_CONFIG_DIRS"];
+  const systemConfigDirs = xdgConfigDirs !== void 0 && xdgConfigDirs.trim() !== "" ? xdgConfigDirs.split(":").filter((entry) => entry.trim() !== "").map((entry) => path4.join(expandTildePath(entry), "systemd", "user")) : ["/etc/xdg/systemd/user"];
+  return [
+    // Distribution `share` locations rank below their `lib` counterparts.
+    "/usr/share/systemd/user",
+    "/usr/lib/systemd/user",
+    "/usr/local/share/systemd/user",
+    "/usr/local/lib/systemd/user",
+    // BOTH the XDG-configured directory and the default, when they differ.
+    // These variables come from the GATEWAY's environment; the daemon's user
+    // manager may have been started with different ones, or none. Scanning only
+    // ours would miss a unit sitting in the other location — the daemon's real
+    // one. Extra directories cost a `statSync` that misses.
+    ...dedupe([
+      underHome(".local", "share", "systemd", "user"),
+      ...xdgData !== void 0 && xdgData.trim() !== "" ? [path4.join(expandTildePath(xdgData), "systemd", "user")] : []
+    ]),
+    "/run/systemd/user",
+    "/etc/systemd/user",
+    // `XDG_CONFIG_DIRS` (default `/etc/xdg`) outranks `/etc/systemd/user` and
+    // is outranked only by the user's own config directory. Listed in
+    // ASCENDING precedence, so a later entry of the colon list ranks lower —
+    // the reverse of how XDG reads it.
+    ...systemConfigDirs.reverse(),
+    ...dedupe([
+      underHome(".config", "systemd", "user"),
+      ...xdgConfig !== void 0 && xdgConfig.trim() !== "" ? [path4.join(expandTildePath(xdgConfig), "systemd", "user")] : []
+    ])
+  ];
+}
+var SYSTEMD_SYSTEM_UNIT_DIRS = [
+  "/usr/lib/systemd/system",
+  "/lib/systemd/system",
+  "/usr/local/lib/systemd/system",
+  "/run/systemd/system",
+  "/etc/systemd/system"
 ];
+var SYSTEMD_SYSTEM_UNIT_NAMES = SYSTEMD_UNIT_NAMES;
+function readUnitDropIns(dropInDirs) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const dropInDir of dropInDirs) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dropInDir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries.filter((name) => name.endsWith(".conf"))) {
+      try {
+        byName.set(entry, fs2.readFileSync(path4.join(dropInDir, entry), "utf8"));
+      } catch {
+      }
+    }
+  }
+  return [...byName.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, body]) => body);
+}
+function readUnitText(source) {
+  if (!fileExists(source.unitPath)) return void 0;
+  let unit;
+  try {
+    unit = fs2.readFileSync(source.unitPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  return [unit, ...readUnitDropIns(source.dropInDirs)].join("\n");
+}
+function readUnitAuthToken(source) {
+  const unit = readUnitText(source);
+  if (unit === void 0) return { readable: false };
+  return {
+    readable: true,
+    token: resolveUnitEndpoint(unit, {
+      userScoped: source.userScoped,
+      homeDir: resolveHomeDir()
+    }).authToken
+  };
+}
+function readServiceEndpoints() {
+  const homeDir = resolveHomeDir();
+  const unitPaths = [
+    ...LAUNCHD_SERVICE_PATHS.map((segments) => {
+      const unitPath = path4.join(homeDir, ...segments);
+      return { unitPath, dropInDirs: [`${unitPath}.d`], userScoped: true };
+    }),
+    // User units follow the same load-path rules as system ones: highest
+    // precedence file wins, drop-ins collected from every directory.
+    ...resolveSystemUnitSources(
+      systemdUserUnitDirs(homeDir),
+      SYSTEMD_UNIT_NAMES,
+      fileExists
+    ).map((source) => ({ ...source, userScoped: true })),
+    // For a SYSTEM unit the base file and its overrides can live in different
+    // load-path directories: a packaged unit under `/usr/lib` customized by
+    // `systemctl edit`, which writes `/etc/systemd/system/<unit>.d/*.conf`.
+    ...resolveSystemUnitSources(SYSTEMD_SYSTEM_UNIT_DIRS, SYSTEMD_SYSTEM_UNIT_NAMES, fileExists).map(
+      (source) => ({ ...source, userScoped: false })
+    )
+  ];
+  const endpoints = [];
+  for (const source of unitPaths) {
+    const { userScoped } = source;
+    const unit = readUnitText(source);
+    if (unit === void 0) continue;
+    const resolved = resolveUnitEndpoint(unit, { userScoped, homeDir });
+    if (resolved.configPath === void 0 && resolved.host === void 0 && resolved.port === void 0 && resolved.authToken === void 0) {
+      continue;
+    }
+    const seen = endpoints.some(
+      (entry) => entry.configPath === resolved.configPath && entry.host === resolved.host && entry.port === resolved.port && entry.authToken === resolved.authToken && // The UNIT is part of the identity now that credentials are re-read
+      // from it per request. Canonical and legacy units can start out
+      // identical while either is the active service; dropping the second
+      // would pin refresh to a unit that may never change again while the
+      // active one rotates its token.
+      entry.authTokenUnit?.unitPath === source.unitPath
+    );
+    if (!seen) {
+      endpoints.push({
+        ...resolved,
+        authTokenUnit: { ...source, dropInDirs: [...source.dropInDirs] }
+      });
+    }
+  }
+  return endpoints;
+}
+function isDaemonServiceConfigured() {
+  const homeDir = resolveHomeDir();
+  for (const segments of LAUNCHD_SERVICE_PATHS) {
+    if (fileExists(path4.join(homeDir, ...segments))) return true;
+  }
+  return [...systemdUserUnitDirs(homeDir), ...SYSTEMD_SYSTEM_UNIT_DIRS].some(
+    (dir) => SYSTEMD_UNIT_NAMES.some((name) => fileExists(path4.join(dir, name)))
+  );
+}
+
+// src/memory-read-scope.ts
+import { lstatSync, realpathSync } from "fs";
+import { realpath as fsRealpath } from "fs/promises";
+import path5 from "path";
+import { expandTildePath as expandTildePath2 } from "@remnic/core";
+function trimTrailingSeparators(value) {
+  const floor = Math.max(1, path5.parse(value).root.length);
+  let end = value.length;
+  while (end > floor && (value[end - 1] === "/" || value[end - 1] === "\\")) end -= 1;
+  return value.slice(0, end);
+}
+function defaultIsSymlink(target) {
+  try {
+    return lstatSync(target).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+var NAMESPACE_STORAGE_SEGMENT = "namespaces";
+function daemonServesCorpus(corpusRoot, daemonMemoryDir, realpath3 = realpathSync, isSymlink = defaultIsSymlink) {
+  if (!corpusRoot?.trim() || !daemonMemoryDir?.trim()) return false;
+  const expandedRoot = expandTildePath2(corpusRoot.trim());
+  const expandedDaemon = expandTildePath2(daemonMemoryDir.trim());
+  if (!path5.isAbsolute(expandedRoot) || !path5.isAbsolute(expandedDaemon)) return false;
+  if (isSymlink(path5.resolve(expandedRoot)) || isSymlink(path5.resolve(expandedDaemon))) {
+    return false;
+  }
+  let canonicalRoot;
+  let canonicalDaemon;
+  try {
+    canonicalRoot = trimTrailingSeparators(path5.normalize(realpath3(path5.resolve(expandedRoot))));
+    canonicalDaemon = trimTrailingSeparators(path5.normalize(realpath3(path5.resolve(expandedDaemon))));
+  } catch {
+    return false;
+  }
+  if (canonicalRoot === canonicalDaemon) return true;
+  const relative = path5.relative(canonicalRoot, canonicalDaemon);
+  if (relative.startsWith("..") || path5.isAbsolute(relative)) return false;
+  const segments = relative.split(path5.sep).filter((segment) => segment.length > 0);
+  return segments.length === 2 && segments[0] === NAMESPACE_STORAGE_SEGMENT;
+}
+function isSessionsMemoryPath(relativePath) {
+  return /(?:^|[\\/])sessions[\\/]/i.test(relativePath);
+}
+function isMemoryArtifactPath(candidate) {
+  return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(candidate);
+}
+function isContained(root, candidate) {
+  const relative = path5.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+function createMemoryReadScope(options) {
+  const { memoryDir, workspaceDir } = options;
+  const realpath3 = options.realpath ?? fsRealpath;
+  const allowedRoots = [
+    memoryDir,
+    // Delegate mode drops this: the daemon reports only its `memoryDir`, so a
+    // gateway-local workspace it never searched or authorized must not be a
+    // readable root just because the two processes share a corpus.
+    workspaceDir && options.includeWorkspaceRoot !== false ? path5.join(workspaceDir, "memory") : void 0,
+    ...options.additionalRoots ?? []
+  ].filter((root) => typeof root === "string" && root.length > 0);
+  const canonicalRootsPromise = Promise.all(
+    allowedRoots.map(async (root) => {
+      const resolved = path5.resolve(root);
+      try {
+        return path5.normalize(await realpath3(resolved));
+      } catch {
+        return path5.normalize(resolved);
+      }
+    })
+  );
+  const canonicalizeForRead = async (rawPath) => path5.normalize(await realpath3(path5.resolve(rawPath)));
+  const normalizeWorkspacePath = (rawPath) => {
+    if (!rawPath || typeof rawPath !== "string") return "memory";
+    const resolved = path5.isAbsolute(rawPath) ? path5.resolve(rawPath) : path5.resolve(workspaceDir, rawPath);
+    const relative = path5.relative(workspaceDir, resolved);
+    return relative && !relative.startsWith("..") && !path5.isAbsolute(relative) ? relative : rawPath;
+  };
+  const absolutize = (rawPath) => {
+    if (path5.isAbsolute(rawPath)) return path5.resolve(rawPath);
+    for (const root of allowedRoots) {
+      const candidate = path5.resolve(root, rawPath);
+      if (isContained(root, candidate)) return candidate;
+    }
+    return path5.resolve(workspaceDir, rawPath);
+  };
+  return {
+    allowedRoots,
+    absolutize,
+    normalizeWorkspacePath,
+    relativizeToMemoryRoot(rawPath) {
+      if (!rawPath || typeof rawPath !== "string") return "memory";
+      const resolved = path5.isAbsolute(rawPath) ? path5.resolve(rawPath) : path5.resolve(workspaceDir, rawPath);
+      for (const root of allowedRoots) {
+        const relative = path5.relative(root, resolved);
+        if (relative !== "" && !relative.startsWith("..") && !path5.isAbsolute(relative)) {
+          return relative;
+        }
+      }
+      return normalizeWorkspacePath(rawPath);
+    },
+    async resolveReadablePath(requestedPath) {
+      if (typeof requestedPath !== "string" || requestedPath.length === 0) {
+        throw new Error("memory read rejected (missing path)");
+      }
+      const candidates = path5.isAbsolute(requestedPath) ? [path5.resolve(requestedPath)] : allowedRoots.map((root) => path5.resolve(root, requestedPath));
+      let canonicalPath;
+      for (const candidate of candidates) {
+        try {
+          canonicalPath = await canonicalizeForRead(candidate);
+          break;
+        } catch {
+        }
+      }
+      if (canonicalPath === void 0) {
+        throw new Error(`memory read rejected (path unresolvable): ${requestedPath}`);
+      }
+      const canonicalRoots = await canonicalRootsPromise;
+      const containingRoot = canonicalRoots.find((root) => isContained(root, canonicalPath));
+      if (containingRoot === void 0) {
+        throw new Error(`memory read outside allowed roots: ${requestedPath}`);
+      }
+      if (!canonicalPath.toLowerCase().endsWith(".md")) {
+        throw new Error(`memory read restricted to .md files: ${requestedPath}`);
+      }
+      const rootRelative = path5.relative(containingRoot, canonicalPath);
+      if (rootRelative.startsWith("..") || path5.isAbsolute(rootRelative)) {
+        throw new Error(`memory read outside allowed roots: ${requestedPath}`);
+      }
+      const rawIsArtifact = !path5.isAbsolute(requestedPath) && isMemoryArtifactPath(requestedPath);
+      if (isMemoryArtifactPath(rootRelative) || rawIsArtifact) {
+        throw new Error(`memory read excluded (artifact path): ${requestedPath}`);
+      }
+      return canonicalPath;
+    }
+  };
+}
+
+// src/bridge.ts
+function daemonUrl(target, pathname) {
+  const host = target.host.includes(":") && !target.host.startsWith("[") ? `[${target.host}]` : target.host;
+  return `http://${host}:${target.port}${pathname}`;
+}
+function daemonAuthHeaders(target) {
+  const auth = target.resolveAuthToken();
+  return auth.token ? { Authorization: `Bearer ${auth.token}` } : {};
+}
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 4318;
+var LIVENESS_PATH = "/engram/v1/live";
+var LEGACY_HEALTH_PATH = "/engram/v1/health";
+var DEFAULT_DAEMON_HEALTH_TIMEOUT_MS = 1e4;
+function assertProbeBudget(timeoutMs) {
+  if (timeoutMs === void 0) return DEFAULT_DAEMON_HEALTH_TIMEOUT_MS;
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > MAX_BRIDGE_HEALTH_TIMEOUT_MS) {
+    throw new Error(
+      `timeoutMs must be an integer in [1, ${MAX_BRIDGE_HEALTH_TIMEOUT_MS}]; got ${String(timeoutMs)}`
+    );
+  }
+  return timeoutMs;
+}
+var MAX_BRIDGE_HEALTH_TIMEOUT_MS = 12e4;
+function parseBridgeHealthTimeoutMs(value) {
+  if (value === void 0) return DEFAULT_DAEMON_HEALTH_TIMEOUT_MS;
+  const parsed = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  if (typeof parsed !== "number" || !Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 1 || parsed > MAX_BRIDGE_HEALTH_TIMEOUT_MS) {
+    throw new Error(
+      `bridgeHealthTimeoutMs must be an integer in [1, ${MAX_BRIDGE_HEALTH_TIMEOUT_MS}]; got ${String(value)}`
+    );
+  }
+  return parsed;
+}
+function parseOpenClawBridgeConfig(config) {
+  return {
+    healthTimeoutMs: parseBridgeHealthTimeoutMs(config.bridgeHealthTimeoutMs)
+  };
+}
 function readEnv(name) {
   const env = globalThis.process?.["env"];
   return env?.[name];
 }
-function resolveHomeDir() {
+function resolveHomeDir2() {
   return readEnv("HOME") ?? readEnv("USERPROFILE") ?? "~";
 }
 function readCompatEnv(primary, legacy) {
@@ -5453,27 +6131,27 @@ function readCompatEnv(primary, legacy) {
 function configPathCandidates() {
   const envPath = readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH");
   return [
-    ...envPath ? [path3.resolve(expandTildePath(envPath))] : [],
-    path3.join(resolveHomeDir(), ".config", "remnic", "config.json"),
-    path3.join(resolveHomeDir(), ".config", "engram", "config.json"),
-    path3.join(process.cwd(), "remnic.config.json"),
-    path3.join(process.cwd(), "engram.config.json")
+    ...envPath ? [path6.resolve(expandTildePath3(envPath))] : [],
+    path6.join(process.cwd(), "remnic.config.json"),
+    path6.join(process.cwd(), "engram.config.json"),
+    path6.join(resolveHomeDir2(), ".config", "remnic", "config.json"),
+    path6.join(resolveHomeDir2(), ".config", "engram", "config.json")
   ];
 }
-function fileExists(filePath) {
+function fileExists2(filePath) {
   try {
-    return fs.statSync(filePath).isFile();
+    return fs3.statSync(filePath).isFile();
   } catch {
     return false;
   }
 }
 function isDaemonRunning() {
   for (const pidFile of [
-    path3.join(resolveHomeDir(), ".remnic", "server.pid"),
-    path3.join(resolveHomeDir(), ".engram", "server.pid")
+    path6.join(resolveHomeDir2(), ".remnic", "server.pid"),
+    path6.join(resolveHomeDir2(), ".engram", "server.pid")
   ]) {
     try {
-      const pid = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10);
+      const pid = parseInt(fs3.readFileSync(pidFile, "utf8").trim(), 10);
       process.kill(pid, 0);
       return true;
     } catch {
@@ -5481,12 +6159,33 @@ function isDaemonRunning() {
   }
   return false;
 }
-function isDaemonServiceConfigured() {
-  const homeDir = resolveHomeDir();
-  for (const segments of [...LAUNCHD_SERVICE_PATHS, ...SYSTEMD_SERVICE_PATHS]) {
-    if (fileExists(path3.join(homeDir, ...segments))) return true;
+function isLoopbackDaemonHost(host) {
+  const normalized = host.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
+  if (normalized === "localhost") return true;
+  if (loopbackForWildcardBind(normalized) !== void 0) return true;
+  const ipv6 = canonicalIPv6(normalized);
+  if (ipv6 !== void 0) {
+    if (ipv6 === "::1") return true;
+    const mappedHex = /^::ffff:([0-9a-f]{1,4}):[0-9a-f]{1,4}$/.exec(ipv6);
+    if (mappedHex !== null) return Number.parseInt(mappedHex[1], 16) >> 8 === 127;
+    const mappedDotted = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(ipv6);
+    return mappedDotted !== null && isIPv4(mappedDotted[1]) && mappedDotted[1].split(".")[0] === "127";
+  }
+  return isIPv4(normalized) && normalized.split(".")[0] === "127";
+}
+function canonicalIPv6(value) {
+  if (!isIPv6(value)) return void 0;
+  try {
+    return new URL(`http://[${value}]`).hostname.replace(/^\[/, "").replace(/\]$/, "");
+  } catch {
+    return value;
   }
-  return false;
+}
+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(/^\[(.+)\]$/);
@@ -5496,130 +6195,362 @@ 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;
 }
-function checkDaemonHealthSync(host, port, timeoutMs = DEFAULT_DAEMON_HEALTH_TIMEOUT_MS) {
-  if (!host || !Number.isInteger(port) || port <= 0 || port > 65535) return false;
+var DAEMON_CAPTURE_BYTES = 1024;
+function probeDaemonSync(options) {
+  const { host, port, timeoutMs } = options;
+  if (!host || !Number.isInteger(port) || port <= 0 || port > 65535) return { ok: false };
   const deadline = Date.now() + timeoutMs;
   let worker;
   try {
     const state = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
     const view = new Int32Array(state);
+    const capture = options.captureField ? new SharedArrayBuffer(DAEMON_CAPTURE_BYTES) : void 0;
     const workerUrl = new URL(`data:text/javascript,${encodeURIComponent(HEALTH_WORKER_SOURCE)}`);
     const workerOptions = {
       type: "module",
       workerData: {
         host,
         port,
-        path: LIVENESS_PATH,
-        fallbackPath: LEGACY_HEALTH_PATH,
-        token: loadDaemonAuth().token,
+        path: options.path,
+        fallbackPath: options.fallbackPath,
+        token: options.authToken ?? loadDaemonAuth(options.configPath).token,
         deadline,
-        state
+        state,
+        ...capture ? { capture, captureField: options.captureField } : {}
       }
     };
     worker = new Worker(workerUrl, workerOptions);
     Atomics.wait(view, 0, 0, Math.max(0, deadline - Date.now()));
     const status = Atomics.load(view, 0);
     if (status === 0) void worker.terminate();
-    return status === 1;
+    if (status !== 1) return { ok: false, ...status === 3 ? { rejectedAuth: true } : {} };
+    if (!capture) return { ok: true };
+    const length = new DataView(capture).getUint32(0);
+    if (length === 0) return { ok: true };
+    if (length > capture.byteLength - 4) return { ok: true };
+    return { ok: true, captured: new TextDecoder().decode(new Uint8Array(capture, 4, length)) };
   } catch {
     if (worker) void worker.terminate();
-    return false;
+    return { ok: false };
   }
 }
-function shouldProbeDaemonHealth(host) {
-  const normalized = host.trim().toLowerCase();
-  return normalized === DEFAULT_HOST || normalized === "localhost" || normalized === "::1" || normalized === "[::1]" || isDaemonServiceConfigured();
-}
-function readDaemonHost() {
-  const envHost = readCompatEnv("REMNIC_HOST", "ENGRAM_HOST");
-  if (envHost !== void 0 && envHost.trim() !== "") return normalizeDaemonHost(envHost);
-  for (const p of configPathCandidates()) {
-    if (!fs.existsSync(p)) continue;
-    try {
-      const raw = JSON.parse(fs.readFileSync(p, "utf8"));
-      const configHost = raw.server?.host;
-      if (typeof configHost === "string" && configHost.trim() !== "") {
-        return normalizeDaemonHost(configHost);
-      }
-    } catch {
+function checkDaemonHealthSync(host, port, timeoutMs = DEFAULT_DAEMON_HEALTH_TIMEOUT_MS) {
+  assertProbeBudget(timeoutMs);
+  return probeDaemonSync({
+    host,
+    port,
+    timeoutMs,
+    path: LIVENESS_PATH,
+    fallbackPath: LEGACY_HEALTH_PATH
+  }).ok;
+}
+function readDaemonMemoryDirSync(host, port, timeoutMs = DEFAULT_DAEMON_HEALTH_TIMEOUT_MS, configPath, authToken) {
+  assertProbeBudget(timeoutMs);
+  const probe = probeDaemonSync({
+    host,
+    port,
+    timeoutMs,
+    path: LEGACY_HEALTH_PATH,
+    fallbackPath: null,
+    captureField: "memoryDir",
+    configPath,
+    authToken
+  });
+  return {
+    healthy: probe.ok,
+    memoryDir: probe.captured,
+    // Present only when true, so the result shape is unchanged for callers
+    // that compare it structurally.
+    ...probe.rejectedAuth === true ? { rejectedAuth: true } : {}
+  };
+}
+function shouldProbeDaemonHealth(host) {
+  return isLoopbackDaemonHost(host) || isDaemonServiceConfigured();
+}
+function readDaemonHost() {
+  const resolved = readConfiguredDaemonHost();
+  return loopbackForWildcardBind(resolved) ?? resolved;
+}
+function readDaemonServerConfig() {
+  for (const candidate of configPathCandidates()) {
+    const server = readServerBlock(candidate);
+    if (server !== void 0) return server;
+  }
+  return {};
+}
+function readServerBlock(candidate) {
+  if (!fileExists2(candidate)) return void 0;
+  let raw;
+  try {
+    raw = JSON.parse(fs3.readFileSync(candidate, "utf8"));
+  } catch {
+    return void 0;
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+  const server = raw.server;
+  if (server === void 0) return {};
+  if (typeof server !== "object" || server === null || Array.isArray(server)) return void 0;
+  const { host, port } = server;
+  const parsedPort = coerceDaemonPort(port);
+  const { authToken } = server;
+  return {
+    ...typeof host === "string" && host.trim() !== "" ? { host } : {},
+    ...parsedPort === void 0 ? {} : { port: parsedPort },
+    ...typeof authToken === "string" && authToken.length > 0 ? { authToken } : {}
+  };
+}
+function daemonEndpointCandidates() {
+  const envHost = readCompatEnv("REMNIC_HOST", "ENGRAM_HOST");
+  const envPort = coerceDaemonPort(readCompatEnv("REMNIC_PORT", "ENGRAM_PORT"));
+  const candidates = [];
+  const add = (host, port, configPath, authTokenOverride, authTokenUnit) => {
+    const resolvedHost = normalizeDaemonHost(
+      envHost !== void 0 && envHost.trim() !== "" ? envHost : host ?? DEFAULT_HOST
+    );
+    const dialHost = loopbackForWildcardBind(resolvedHost) ?? 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;
     }
+    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) => {
+    const server = readServerBlock(candidate);
+    if (server !== void 0) add(server.host, server.port, candidate);
+  };
+  if (envConfigPath !== void 0) addConfigCandidate(envConfigPath);
+  for (const unit of readServiceEndpoints()) {
+    const server = unit.configPath === void 0 ? {} : readServerBlock(unit.configPath) ?? {};
+    add(
+      unit.host ?? server.host,
+      unit.port ?? server.port,
+      unit.configPath,
+      unit.authToken,
+      unit.authTokenUnit
+    );
+  }
+  for (const candidate of configOrder) {
+    if (candidate === envConfigPath) continue;
+    addConfigCandidate(candidate);
   }
-  return DEFAULT_HOST;
+  add(void 0, void 0);
+  return candidates;
+}
+function readConfiguredDaemonHost() {
+  const envHost = readCompatEnv("REMNIC_HOST", "ENGRAM_HOST");
+  if (envHost !== void 0 && envHost.trim() !== "") return normalizeDaemonHost(envHost);
+  const configHost = readDaemonServerConfig().host;
+  return configHost === void 0 ? DEFAULT_HOST : normalizeDaemonHost(configHost);
 }
 function readDaemonPort() {
   const envPort = coerceDaemonPort(readCompatEnv("REMNIC_PORT", "ENGRAM_PORT"));
   if (envPort !== void 0) return envPort;
-  for (const p of configPathCandidates()) {
-    if (!fs.existsSync(p)) continue;
-    try {
-      const raw = JSON.parse(fs.readFileSync(p, "utf8"));
-      const configPort = coerceDaemonPort(raw.server?.port);
-      if (configPort !== void 0) return configPort;
-    } catch {
-    }
-  }
-  return DEFAULT_PORT;
+  return readDaemonServerConfig().port ?? DEFAULT_PORT;
 }
-function detectBridgeMode() {
-  const envMode = readCompatEnv("REMNIC_BRIDGE_MODE", "ENGRAM_BRIDGE_MODE")?.toLowerCase();
-  if (envMode === "delegate") {
-    return {
-      mode: "delegate",
-      daemonHost: readDaemonHost(),
-      daemonPort: readDaemonPort()
-    };
-  }
-  if (envMode === "embedded") {
-    return {
-      mode: "embedded",
-      daemonHost: DEFAULT_HOST,
-      daemonPort: readDaemonPort()
-    };
-  }
-  const daemonHost = readDaemonHost();
-  const daemonPort = readDaemonPort();
-  const hasDaemonPidHint = isDaemonRunning();
-  if ((hasDaemonPidHint || shouldProbeDaemonHealth(daemonHost)) && checkDaemonHealthSync(daemonHost, daemonPort)) {
+function detectDaemonBridgeMode(options) {
+  const endpoints = daemonEndpointCandidates();
+  const primary = endpoints[0] ?? { host: readDaemonHost(), port: readDaemonPort(), token: "" };
+  const embedded = {
+    mode: "embedded",
+    daemonHost: primary.host,
+    daemonPort: primary.port,
+    ...primary.configPath === void 0 ? {} : { daemonConfigPath: primary.configPath },
+    ...primary.authTokenOverride === void 0 ? {} : { daemonAuthTokenOverride: primary.authTokenOverride },
+    ...primary.authTokenUnit === void 0 ? {} : { daemonAuthUnit: primary.authTokenUnit }
+  };
+  if (options.memoryDir.trim() === "") {
+    throw new Error("detectDaemonBridgeMode requires a non-empty memoryDir to verify the daemon corpus");
+  }
+  const totalTimeoutMs = assertProbeBudget(options.timeoutMs);
+  const deadline = Date.now() + totalTimeoutMs;
+  const probeable = [];
+  for (const candidate of endpoints) {
+    if (!isLoopbackDaemonHost(candidate.host)) {
+      options.onSkip?.(
+        `daemon endpoint ${candidate.host}:${candidate.port} is not loopback; auto only delegates to a same-host daemon`
+      );
+      continue;
+    }
+    if (!isDaemonRunning() && !shouldProbeDaemonHealth(candidate.host)) {
+      options.onSkip?.("no daemon PID, service unit, or local endpoint to probe");
+      continue;
+    }
+    probeable.push(candidate);
+  }
+  let probed = 0;
+  for (const {
+    host: daemonHost,
+    port: daemonPort,
+    configPath,
+    authTokenOverride,
+    authTokenUnit,
+    fallbackToken
+  } of probeable) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      options.onSkip?.(
+        `preflight budget of ${totalTimeoutMs}ms is spent; ${daemonHost}:${daemonPort} was not probed`
+      );
+      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 firstAttemptMs = candidateDeadline - Date.now();
+    if (firstAttemptMs <= 0) {
+      options.onSkip?.(
+        `preflight budget of ${totalTimeoutMs}ms is spent; ${daemonHost}:${daemonPort} was not probed`
+      );
+      continue;
+    }
+    let usedToken = authTokenOverride;
+    let health = readDaemonMemoryDirSync(
+      daemonHost,
+      daemonPort,
+      firstAttemptMs,
+      configPath,
+      usedToken
+    );
+    if (health.rejectedAuth === true && fallbackToken !== void 0) {
+      const retryMs = candidateDeadline - Date.now();
+      if (retryMs > 0) {
+        usedToken = fallbackToken;
+        health = readDaemonMemoryDirSync(daemonHost, daemonPort, retryMs, configPath, usedToken);
+      }
+    }
+    if (!health.healthy) {
+      options.onSkip?.(`no healthy daemon at ${daemonHost}:${daemonPort}`);
+      continue;
+    }
+    if (health.memoryDir === void 0) {
+      options.onSkip?.(
+        `daemon at ${daemonHost}:${daemonPort} did not report a memoryDir, so its corpus cannot be confirmed`
+      );
+      continue;
+    }
+    if (!daemonServesCorpus(options.memoryDir, health.memoryDir)) {
+      options.onSkip?.(
+        `daemon at ${daemonHost}:${daemonPort} serves a different memoryDir than this plugin`
+      );
+      continue;
+    }
     return {
       mode: "delegate",
       daemonHost,
-      daemonPort
+      daemonPort,
+      healthVerified: true,
+      ...configPath === void 0 ? {} : { daemonConfigPath: configPath },
+      // A unit-supplied credential has no other source, so it is carried by
+      // value; a config-supplied one is re-read from its file per request.
+      ...usedToken !== void 0 && usedToken === authTokenOverride ? {
+        daemonAuthTokenOverride: usedToken,
+        // The unit rides along so the credential can be re-read per
+        // request; the frozen value stays as the fallback for a unit that
+        // later becomes unreadable.
+        ...authTokenUnit === void 0 ? {} : { daemonAuthUnit: authTokenUnit }
+      } : {},
+      ...usedToken !== void 0 && usedToken === fallbackToken ? { daemonAuthPrefersConfig: true } : {}
     };
   }
-  return {
-    mode: "embedded",
-    daemonHost: DEFAULT_HOST,
-    daemonPort
-  };
+  return embedded;
 }
-function resolveBridgeMode(configBridgeMode) {
+function resolveRequestedBridgeMode(configBridgeMode) {
   const envMode = readCompatEnv("REMNIC_BRIDGE_MODE", "ENGRAM_BRIDGE_MODE")?.toLowerCase();
-  let mode;
-  if (envMode === "delegate" || envMode === "embedded") {
-    mode = envMode;
-  } else if (envMode !== void 0 && envMode !== "") {
-    throw new Error(
-      `Invalid REMNIC_BRIDGE_MODE env override: ${envMode} (expected "embedded" or "delegate")`
-    );
-  } else if (configBridgeMode === void 0 || configBridgeMode === "" || configBridgeMode === "embedded") {
-    mode = "embedded";
-  } else if (configBridgeMode === "delegate") {
-    mode = "delegate";
-  } else {
-    throw new Error(
-      `Invalid bridgeMode: ${String(configBridgeMode)} (expected "embedded" or "delegate")`
-    );
+  const isRequest = (value) => value === "embedded" || value === "delegate" || value === "auto";
+  if (envMode !== void 0 && envMode !== "") {
+    if (!isRequest(envMode)) {
+      throw new Error(
+        `Invalid REMNIC_BRIDGE_MODE env override: ${envMode} (expected "embedded", "delegate", or "auto")`
+      );
+    }
+    return envMode;
   }
+  if (configBridgeMode === void 0 || configBridgeMode === "") return "embedded";
+  if (isRequest(configBridgeMode)) return configBridgeMode;
+  throw new Error(
+    `Invalid bridgeMode: ${String(configBridgeMode)} (expected "embedded", "delegate", or "auto")`
+  );
+}
+function detectBridgeMode(options = {}) {
+  const requested = resolveRequestedBridgeMode("");
+  if (requested === "auto" && !options.memoryDir?.trim()) {
+    return { mode: "embedded", daemonHost: readDaemonHost(), daemonPort: readDaemonPort() };
+  }
+  return resolveBridgeMode("", options);
+}
+function requestedDelegate(configBridgeMode) {
+  try {
+    return resolveRequestedBridgeMode(configBridgeMode) !== "embedded";
+  } catch {
+    return true;
+  }
+}
+function resolveBridgeMode(configBridgeMode, options = {}) {
+  const requested = resolveRequestedBridgeMode(configBridgeMode);
+  assertProbeBudget(options.timeoutMs);
+  if (requested === "auto") {
+    const memoryDir = options.memoryDir ?? "";
+    if (!memoryDir.trim()) {
+      throw new Error('bridgeMode "auto" requires a configured memoryDir to verify the daemon corpus');
+    }
+    return detectDaemonBridgeMode({
+      memoryDir,
+      timeoutMs: options.timeoutMs,
+      onSkip: options.onSkip
+    });
+  }
+  const selectedConfig = selectedDaemonConfigPath();
   return {
-    mode,
+    mode: requested,
     daemonHost: readDaemonHost(),
-    daemonPort: readDaemonPort()
+    daemonPort: readDaemonPort(),
+    ...selectedConfig === void 0 ? {} : { daemonConfigPath: selectedConfig }
   };
 }
+function readDaemonConfigAuthToken(configPath) {
+  return readServerBlock(configPath)?.authToken;
+}
+function selectedDaemonConfigPath() {
+  for (const candidate of configPathCandidates()) {
+    if (readServerBlock(candidate) !== void 0) return candidate;
+  }
+  return void 0;
+}
 function isOpenClawTokenEntry(value) {
   return value !== null && typeof value === "object" && "connector" in value && value.connector === "openclaw" && "token" in value && typeof value.token === "string";
 }
-function loadDaemonAuth() {
+function loadDaemonAuth(configPath) {
   const environmentTokens = [
     ["OPENCLAW_REMNIC_ACCESS_TOKEN", readEnv("OPENCLAW_REMNIC_ACCESS_TOKEN")],
     ["REMNIC_AUTH_TOKEN", readEnv("REMNIC_AUTH_TOKEN")],
@@ -5630,13 +6561,13 @@ function loadDaemonAuth() {
     if (token) return { token, source };
   }
   const tokenStores = [
-    { path: path3.join(resolveHomeDir(), ".remnic", "tokens.json"), source: "remnic token store" },
-    { path: path3.join(resolveHomeDir(), ".engram", "tokens.json"), source: "engram token store" }
+    { path: path6.join(resolveHomeDir2(), ".remnic", "tokens.json"), source: "remnic token store" },
+    { path: path6.join(resolveHomeDir2(), ".engram", "tokens.json"), source: "engram token store" }
   ];
   for (const tokenStore of tokenStores) {
-    if (!fs.existsSync(tokenStore.path)) continue;
+    if (!fs3.existsSync(tokenStore.path)) continue;
     try {
-      const store = JSON.parse(fs.readFileSync(tokenStore.path, "utf8"));
+      const store = JSON.parse(fs3.readFileSync(tokenStore.path, "utf8"));
       const tokens = Array.isArray(store.tokens) ? store.tokens : [];
       const openClawToken = tokens.find(isOpenClawTokenEntry)?.token;
       if (typeof openClawToken === "string" && openClawToken.length > 0) {
@@ -5649,17 +6580,19 @@ function loadDaemonAuth() {
       continue;
     }
   }
-  try {
-    for (const configPath of configPathCandidates()) {
-      if (!fs.existsSync(configPath)) continue;
-      const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
-      const token = raw.server?.authToken;
+  for (const candidate of configPath === void 0 ? configPathCandidates() : [configPath]) {
+    if (!fileExists2(candidate)) continue;
+    try {
+      const raw = JSON.parse(fs3.readFileSync(candidate, "utf8"));
+      const server = raw?.server;
+      const token = server?.authToken;
       if (typeof token === "string" && token.length > 0) {
         return { token, source: "daemon configuration" };
       }
+    } catch {
+      continue;
     }
-  } catch {
-    return { token: "", source: "no configured token" };
+    if (configPath !== void 0) break;
   }
   return { token: "", source: "no configured token" };
 }
@@ -5706,6 +6639,289 @@ async function checkDaemonHealth(host, port, timeoutMs = DEFAULT_DAEMON_HEALTH_T
   }
 }
 
+// src/delegate-authorization.ts
+var DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS = [
+  "recall",
+  "observe",
+  "lcm_compaction_flush",
+  // The daemon-backed memory-slot capability searches through
+  // /engram/v1/memories/search, which enforces its own `memory_search`
+  // operation. Omitting it here would let the preflight report a
+  // least-privilege token authorized while every capability search 403s.
+  "memory_search"
+];
+var daemonAuthFailureLogKeys = /* @__PURE__ */ new Set();
+function reportDaemonAuthorizationFailure(serviceId, pathname, status, tokenSource) {
+  const key = `${serviceId}:${pathname}:${status}:${tokenSource}`;
+  if (daemonAuthFailureLogKeys.has(key)) return;
+  daemonAuthFailureLogKeys.add(key);
+  log2.error(
+    `delegate ${pathname} authorization failed (${status}; token source: ${tokenSource})`
+  );
+}
+var AUTHORIZATION_PROBE_TIMEOUT_MS = 2e3;
+async function probeDelegateAuthorization(target, namespace = "", operations = DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS, timeoutMs) {
+  const auth = target.resolveAuthToken();
+  const headers = auth.token ? { Authorization: `Bearer ${auth.token}` } : void 0;
+  const query = new URLSearchParams();
+  for (const operation of operations) query.append("op", operation);
+  query.set("namespace", namespace);
+  try {
+    const response = await fetch(daemonUrl(target, `/engram/v1/authorization?${query}`), {
+      headers,
+      signal: AbortSignal.timeout(
+        timeoutMs === void 0 ? AUTHORIZATION_PROBE_TIMEOUT_MS : Math.min(AUTHORIZATION_PROBE_TIMEOUT_MS, timeoutMs)
+      )
+    });
+    await response.body?.cancel();
+    if (response.status === 200) {
+      return { state: "authorized", tokenSource: auth.source };
+    }
+    if (response.status === 401 || response.status === 403) {
+      return { state: "unauthorized", status: response.status, tokenSource: auth.source };
+    }
+  } catch {
+    return { state: "unavailable", tokenSource: auth.source };
+  }
+  return { state: "unavailable", tokenSource: auth.source };
+}
+
+// src/delegate-runtime.ts
+import {
+  SESSION_NAMESPACE_BINDING_MAX_ENTRIES,
+  SESSION_NAMESPACE_BINDING_MAX_NAMESPACES as SESSION_NAMESPACE_BINDING_MAX_NAMESPACES2,
+  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);
+  }
+  if (remembered.length > 0) return remembered.map((namespace) => namespace || void 0);
+  return [fallback.trim() || void 0];
+}
+
+// src/delegate-daemon-target.ts
+function daemonTargetFor(bridge) {
+  return {
+    host: bridge.daemonHost,
+    port: bridge.daemonPort,
+    resolveAuthToken: () => {
+      if (bridge.daemonAuthTokenOverride !== void 0) {
+        const unit = bridge.daemonAuthUnit === void 0 ? void 0 : readUnitAuthToken(bridge.daemonAuthUnit);
+        if (unit?.readable === true && unit.token !== void 0) {
+          return { token: unit.token, source: "daemon configuration" };
+        }
+        if (unit === void 0 || unit.readable === false) {
+          return { token: bridge.daemonAuthTokenOverride, source: "daemon configuration" };
+        }
+        if (bridge.daemonConfigPath !== void 0) {
+          const configToken = readDaemonConfigAuthToken(bridge.daemonConfigPath);
+          if (configToken !== void 0) {
+            return { token: configToken, source: "daemon configuration" };
+          }
+        }
+      }
+      if (bridge.daemonAuthPrefersConfig && bridge.daemonConfigPath !== void 0) {
+        const configToken = readDaemonConfigAuthToken(bridge.daemonConfigPath);
+        if (configToken !== void 0) {
+          return { token: configToken, source: "daemon configuration" };
+        }
+      }
+      return loadDaemonAuth(bridge.daemonConfigPath);
+    }
+  };
+}
+
+// src/delegate-flush-plan-ingest.ts
+import { lstat as lstat3, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path7 from "path";
+import { log as log4 } from "@remnic/core/logger";
+
+// src/memory-flush-plan.ts
+var DEFAULT_MAX_TURN_CHARS = 8e3;
+var MIN_MAX_TURN_CHARS = 1e3;
+var FLUSH_PROMPT = "Flush the recent OpenClaw transcript into Remnic memory by appending to the allowed flush-plan file only. Preserve durable user preferences, project facts, decisions, corrections, and commitments. Ignore runtime metadata, credentials, and transient command noise.";
+var FLUSH_SYSTEM_PROMPT = "You are Remnic's memory flush planner. Read the transcript and append concise durable memory notes to the file the write tool allows. Do not create files, directories, or dated paths; use only the allowed flush-plan file. Ignore runtime metadata, credentials, transient command noise, and content that is not worth remembering.";
+function buildMemoryFlushPlan(options) {
+  const maxTurnChars = typeof options.extractionMaxTurnChars === "number" && Number.isFinite(options.extractionMaxTurnChars) ? Math.max(MIN_MAX_TURN_CHARS, Math.floor(options.extractionMaxTurnChars)) : DEFAULT_MAX_TURN_CHARS;
+  const flushModel = typeof options.flushModel === "string" && options.flushModel.length > 0 ? options.flushModel : void 0;
+  return {
+    softThresholdTokens: 24e3,
+    forceFlushTranscriptBytes: Math.max(16384, maxTurnChars * 4),
+    reserveTokensFloor: 2e3,
+    ...flushModel ? { model: flushModel } : {},
+    prompt: FLUSH_PROMPT,
+    systemPrompt: FLUSH_SYSTEM_PROMPT,
+    relativePath: ["state", "plugins", options.serviceId, "flush-plan.md"].join("/")
+  };
+}
+
+// src/delegate-flush-plan-ingest.ts
+var MAX_OBSERVE_CHUNK_BYTES = 96 * 1024;
+var MIN_OBSERVE_CHUNK_BYTES = 4 * 1024;
+async function ingestFlushPlanNotes(options) {
+  if (options.workspaceDir === void 0) return;
+  const planPath = path7.join(
+    options.workspaceDir,
+    ...buildMemoryFlushPlan({ serviceId: options.serviceId }).relativePath.split("/")
+  );
+  if (!await isLinkFreeUnder(options.workspaceDir, planPath)) {
+    log4.warn(
+      `[${options.serviceId}] flush-plan ingestion skipped: ${planPath}, a parent, or the workspace root is a symlink`
+    );
+    return;
+  }
+  let pending = await readPlan(planPath);
+  if (pending === void 0 || pending.trim().length === 0) return;
+  let chunkBytes = MAX_OBSERVE_CHUNK_BYTES;
+  while (pending.trim().length > 0) {
+    const timeoutMs = options.remainingTimeoutMs();
+    if (timeoutMs <= 0) {
+      log4.warn(
+        `[${options.serviceId}] flush-plan ingestion stopped: the caller's deadline is spent; the remainder drains on the next flush`
+      );
+      return;
+    }
+    const [chunk] = chunkOnLineBoundaries(pending, chunkBytes);
+    if (chunk === void 0) return;
+    const accepted = await postJson(
+      options.target,
+      options.serviceId,
+      "/engram/v1/observe",
+      {
+        sessionKey: options.sessionKey,
+        messages: [{ role: "user", content: chunk }],
+        ...options.namespace === void 0 ? {} : { namespace: options.namespace }
+      },
+      timeoutMs
+    );
+    if (accepted === null) {
+      if (chunkBytes > MIN_OBSERVE_CHUNK_BYTES && chunkOnLineBoundaries(pending, chunkBytes).length > 1) {
+        chunkBytes = Math.max(MIN_OBSERVE_CHUNK_BYTES, Math.floor(chunkBytes / 2));
+        continue;
+      }
+      log4.warn(
+        `[${options.serviceId}] flush-plan notes were rejected by the daemon; keeping the remainder for the next flush`
+      );
+      return;
+    }
+    pending = await commitAcceptedPrefix(planPath, chunk) ?? "";
+  }
+}
+async function readPlan(planPath) {
+  try {
+    return await readFile2(planPath, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function commitAcceptedPrefix(planPath, accepted) {
+  const current = await readPlan(planPath);
+  if (current === void 0) return void 0;
+  const remainder = current.startsWith(accepted) ? current.slice(accepted.length) : current;
+  await writeFile2(planPath, remainder, "utf8");
+  return current.startsWith(accepted) ? remainder : void 0;
+}
+function chunkOnLineBoundaries(text, limit) {
+  if (Buffer.byteLength(text, "utf8") <= limit) return [text];
+  const chunks = [];
+  let current = "";
+  for (const line of text.split(/(?<=\n)/)) {
+    if (current !== "" && Buffer.byteLength(current + line, "utf8") > limit) {
+      chunks.push(current);
+      current = "";
+    }
+    current += line;
+  }
+  if (current !== "") chunks.push(current);
+  return chunks;
+}
+async function isLinkFreeUnder(root, target) {
+  const relative = path7.relative(root, target);
+  if (relative.startsWith("..") || path7.isAbsolute(relative)) return false;
+  let current = root;
+  try {
+    if ((await lstat3(current)).isSymbolicLink()) return false;
+  } catch {
+    return true;
+  }
+  for (const segment of relative.split(path7.sep)) {
+    current = path7.join(current, segment);
+    try {
+      if ((await lstat3(current)).isSymbolicLink()) return false;
+    } catch {
+      return true;
+    }
+  }
+  return true;
+}
+
+// src/delegate-runtime.ts
+import { createFileToggleStore } from "@remnic/core/session-toggles";
+
 // src/transcript-turns.ts
 function extractLastTurn(messages) {
   let lastUserIdx = -1;
@@ -5714,62 +6930,499 @@ function extractLastTurn(messages) {
       lastUserIdx = i;
       break;
     }
-  }
-  return lastUserIdx >= 0 ? messages.slice(lastUserIdx) : messages.slice(-2);
+  }
+  return lastUserIdx >= 0 ? messages.slice(lastUserIdx) : messages.slice(-2);
+}
+function extractTextContent(msg) {
+  if (typeof msg.content === "string") return msg.content;
+  if (Array.isArray(msg.content)) {
+    return msg.content.filter(
+      (block) => typeof block === "object" && block !== null && block.type === "text" && typeof block.text === "string"
+    ).map((block) => block.text).join("\n");
+  }
+  return "";
+}
+
+// src/delegate-capability.ts
+import { readFile as readFile3 } from "fs/promises";
+import { log as log5 } from "@remnic/core/logger";
+var HEALTH_CACHE_TTL_MS = 3e4;
+var SEARCH_CANDIDATE_CAP = 25e3;
+function searchCandidateCeiling(budget) {
+  return Math.max(SEARCH_CANDIDATE_CAP, budget * 2);
+}
+var HEALTH_FAILURE_BACKOFF_MS = 5e3;
+var LOCAL_READ_VERDICT_TTL_MS = 3e4;
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function readHealth(payload) {
+  const qmd = asRecord(payload.qmd) ?? {};
+  const searchBackend = payload.searchBackend === "qmd" ? "qmd" : "builtin";
+  const qmdEnabled = searchBackend === "qmd" && payload.qmdEnabled !== false;
+  return {
+    memoryDir: typeof payload.memoryDir === "string" ? payload.memoryDir : void 0,
+    defaultNamespace: typeof payload.defaultNamespace === "string" ? payload.defaultNamespace : void 0,
+    namespacesEnabled: typeof payload.namespacesEnabled === "boolean" ? payload.namespacesEnabled : void 0,
+    searchBackend,
+    qmdEnabled,
+    // `active && !degraded` is the daemon's own "search will actually answer"
+    // signal. A missing `active` means an older daemon, so fall back to
+    // `enabled` rather than reporting a false outage.
+    qmdAvailable: qmdEnabled && (typeof qmd.active === "boolean" ? qmd.active : qmd.enabled !== false) && qmd.degraded !== true,
+    qmdDebug: typeof qmd.debugStatus === "string" ? qmd.debugStatus : void 0
+  };
+}
+function createDelegateMemoryCapability(options) {
+  const { target, serviceId } = options;
+  const now = options.now ?? Date.now;
+  let daemonScope;
+  const sharedScope = () => {
+    const dir = health.memoryDir ?? options.memoryDir;
+    if (daemonScope?.dir !== dir) {
+      daemonScope = {
+        dir,
+        scope: createMemoryReadScope({
+          // The daemon's own directory comes first, so a relative hit resolves
+          // in the frame the daemon returned it in...
+          memoryDir: dir,
+          workspaceDir: options.workspaceDir,
+          // The gateway's own workspace is NOT a readable root here: health
+          // validates `memoryDir` only, so a relative path absent from the
+          // daemon corpus must not be served from a workspace the daemon
+          // never searched or authorized.
+          includeWorkspaceRoot: false,
+          // ...and the corpus ROOT stays readable, so a session bound to a
+          // NON-default namespace can still open the absolute hits its own
+          // search returns from `<root>/namespaces/<other>`.
+          additionalRoots: [options.memoryDir]
+        })
+      };
+    }
+    return daemonScope.scope;
+  };
+  let health = {
+    memoryDir: options.memoryDir,
+    searchBackend: options.configuredSearchBackend,
+    qmdEnabled: options.configuredSearchBackend === "qmd",
+    qmdAvailable: options.configuredSearchBackend === "qmd"
+    // Deliberately NOT seeded from the plugin's config: that describes this
+    // plugin's own deployment, never the daemon's partitioning. Only a
+    // successful probe can prove a flat corpus, and until one does, an absent
+    // namespace fails closed.
+  };
+  let healthExpiresAt = 0;
+  let healthCacheIsFailure = false;
+  let healthEverResolved = false;
+  const localReadVerdictAt = /* @__PURE__ */ new Map();
+  let healthInFlight;
+  let lastHealthFailure;
+  const daemonIsLocal = isLoopbackDaemonHost(target.host);
+  let corpusShared = daemonIsLocal ? void 0 : false;
+  let reportedCorpusMismatch = false;
+  const requireSharedCorpus = (surface) => {
+    if (corpusShared === true) return;
+    const detail = corpusShared !== false ? "the daemon's corpus has not been confirmed yet" : daemonIsLocal ? `daemon serves ${health.memoryDir ?? "an unknown memoryDir"}, plugin is configured for ${options.memoryDir}` : `daemon at ${target.host} is not local, so its corpus is not this host's files`;
+    throw new Error(`delegate ${surface} unavailable: ${detail}`);
+  };
+  const requireLocalReadAuthorized = async (surface, operations) => {
+    if (options.verifyNamespaceAuthorization === void 0) return;
+    const namespace = health.defaultNamespace ?? "";
+    const verdictKey = `${target.resolveAuthToken().token}\0${operations.join(",")}\0${namespace}`;
+    const cachedAt = localReadVerdictAt.get(verdictKey);
+    if (cachedAt !== void 0 && now() - cachedAt >= LOCAL_READ_VERDICT_TTL_MS) {
+      substitutedNamespaceVerdicts.delete(verdictKey);
+      localReadVerdictAt.delete(verdictKey);
+    }
+    if (!substitutedNamespaceVerdicts.has(verdictKey)) {
+      substitutedNamespaceVerdicts.set(
+        verdictKey,
+        await options.verifyNamespaceAuthorization(namespace, void 0, operations)
+      );
+      localReadVerdictAt.set(verdictKey, now());
+    }
+    if (substitutedNamespaceVerdicts.get(verdictKey) !== true) {
+      throw new Error(
+        `delegate ${surface} unavailable: the delegate token's authorization for ${operations.join(", ")} on the daemon's corpus ${substitutedNamespaceVerdicts.get(verdictKey) === false ? "was refused" : "could not be confirmed"}`
+      );
+    }
+  };
+  const requireSingleCorpusNamespacing = (surface) => {
+    if (health.namespacesEnabled === false) return;
+    throw new Error(
+      `delegate ${surface} unavailable: the daemon partitions namespaces (${health.namespacesEnabled === true ? `default: ${health.defaultNamespace ?? "unreported"}` : "namespacing unreported"}) and this surface carries no session, so a local read cannot be authorized for the caller's namespace`
+    );
+  };
+  const requireScopedNamespace = (explicit) => {
+    const namespace = explicit ?? health.defaultNamespace;
+    if (namespace === void 0 && health.namespacesEnabled !== false) {
+      throw new Error(
+        "delegate request unavailable: the daemon's default namespace is unknown, so the session scope cannot be resolved"
+      );
+    }
+    return namespace;
+  };
+  const substitutedNamespaceVerdicts = /* @__PURE__ */ new Map();
+  const resolveScopedNamespaceChecked = async (explicit, timeoutMs, healthIsFresh = true, operations) => {
+    if (!healthIsFresh && explicit === void 0) {
+      throw new Error(
+        "delegate request unavailable: the daemon's namespace posture could not be confirmed within the caller's deadline, so an unscoped request is not safe"
+      );
+    }
+    const namespace = requireScopedNamespace(explicit);
+    if (explicit !== void 0 || namespace === void 0) return namespace;
+    if (options.verifyNamespaceAuthorization === void 0) return namespace;
+    const verdictKey = `${target.resolveAuthToken().token}\0${(operations ?? []).join(",")}\0${namespace}`;
+    if (!substitutedNamespaceVerdicts.has(verdictKey)) {
+      if (timeoutMs !== void 0 && timeoutMs <= 0) {
+        throw new Error(
+          `delegate request unavailable: the delegate token's authorization for the daemon's default namespace (${namespace}) could not be verified within the caller's deadline, so an unscoped request is not safe`
+        );
+      }
+      substitutedNamespaceVerdicts.set(
+        verdictKey,
+        await options.verifyNamespaceAuthorization(namespace, timeoutMs, operations)
+      );
+    }
+    if (substitutedNamespaceVerdicts.get(verdictKey) === false) {
+      throw new Error(
+        `delegate request unavailable: this session has no namespace binding and the daemon's default (${namespace}) is not authorized for the delegate token \u2014 bind the session explicitly or configure the namespace this deployment should use`
+      );
+    }
+    return namespace;
+  };
+  const refreshHealth = async (timeoutMs, revalidate = false) => {
+    if (timeoutMs !== void 0 && (!Number.isInteger(timeoutMs) || !Number.isFinite(timeoutMs))) {
+      throw new Error(
+        `delegate request rejected (timeoutMs must be a finite integer): ${String(timeoutMs)}`
+      );
+    }
+    if (now() < healthExpiresAt) {
+      if (healthCacheIsFailure) return false;
+      if (!revalidate) return true;
+    }
+    if (timeoutMs !== void 0 && timeoutMs <= 0) return false;
+    if (healthInFlight !== void 0) {
+      if (timeoutMs === void 0) {
+        await healthInFlight;
+        return true;
+      }
+      const TIMED_OUT = /* @__PURE__ */ Symbol("timed-out");
+      const outcome = await Promise.race([
+        healthInFlight.then(() => void 0),
+        new Promise((resolve) => {
+          const timer = setTimeout(() => resolve(TIMED_OUT), timeoutMs);
+          timer.unref?.();
+        })
+      ]);
+      return outcome !== TIMED_OUT;
+    }
+    healthInFlight = (async () => {
+      try {
+        const response = await fetch(daemonUrl(target, "/engram/v1/health"), {
+          headers: daemonAuthHeaders(target),
+          signal: AbortSignal.timeout(
+            timeoutMs === void 0 ? options.healthTimeoutMs : Math.min(options.healthTimeoutMs, timeoutMs)
+          )
+        });
+        if (!response.ok) {
+          await response.body?.cancel();
+          throw new Error(`daemon /engram/v1/health responded ${response.status}`);
+        }
+        const payload = await response.json();
+        const healthPayload = asRecord(payload);
+        if (!healthPayload) {
+          throw new Error("daemon /engram/v1/health returned a malformed envelope");
+        }
+        health = readHealth(healthPayload);
+        healthExpiresAt = now() + HEALTH_CACHE_TTL_MS;
+        healthCacheIsFailure = false;
+        healthEverResolved = true;
+        lastHealthFailure = void 0;
+        corpusShared = daemonIsLocal && health.memoryDir !== void 0 && daemonServesCorpus(options.memoryDir, health.memoryDir);
+        if (!corpusShared && daemonIsLocal && !reportedCorpusMismatch) {
+          reportedCorpusMismatch = true;
+          log5.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`
+          );
+        }
+      } catch (err) {
+        health = {
+          ...health,
+          namespacesEnabled: void 0,
+          defaultNamespace: void 0,
+          memoryDir: void 0
+        };
+        corpusShared = daemonIsLocal ? void 0 : false;
+        healthExpiresAt = now() + HEALTH_FAILURE_BACKOFF_MS;
+        healthCacheIsFailure = true;
+        healthEverResolved = true;
+        const message = `[${serviceId}] delegate capability health probe failed: ${String(err)}`;
+        if (message !== lastHealthFailure) {
+          lastHealthFailure = message;
+          log5.warn(message);
+        }
+      } finally {
+        healthInFlight = void 0;
+      }
+    })();
+    await healthInFlight;
+    return true;
+  };
+  const search = async (query, opts) => {
+    if (opts?.minScore !== void 0 && !Number.isFinite(opts.minScore)) {
+      throw new Error(
+        `delegate search rejected (minScore must be a finite number): ${String(opts.minScore)}`
+      );
+    }
+    if (opts?.maxResults !== void 0 && (!Number.isInteger(opts.maxResults) || opts.maxResults < 0)) {
+      throw new Error(
+        `delegate search rejected (maxResults must be a non-negative integer): ${String(opts.maxResults)}`
+      );
+    }
+    const searchDeadline = now() + options.searchTimeoutMs;
+    const searchRemaining = () => searchDeadline - now();
+    const requestedResults = typeof opts?.maxResults === "number" ? opts.maxResults : void 0;
+    const searchScope = await options.resolveSearchNamespace(opts?.sessionKey);
+    const scopeIsFresh = searchScope === void 0 ? await refreshHealth(searchRemaining(), true) : true;
+    const namespace = await resolveScopedNamespaceChecked(
+      searchScope,
+      searchRemaining(),
+      scopeIsFresh,
+      ["memory_search"]
+    );
+    if (opts?.maxResults === 0) return [];
+    const searchMode = opts?.qmdSearchModeOverride === "vsearch" ? "vector" : "search";
+    const fetchPage = async (limit2) => {
+      const remaining = searchRemaining();
+      if (remaining <= 0) {
+        throw new Error(
+          `delegate search unavailable: the search budget of ${options.searchTimeoutMs}ms is spent`
+        );
+      }
+      const response = await fetch(daemonUrl(target, "/engram/v1/memories/search"), {
+        method: "POST",
+        headers: { ...daemonAuthHeaders(target), "Content-Type": "application/json" },
+        body: JSON.stringify({
+          query,
+          ...limit2 === void 0 ? {} : { maxResults: limit2 },
+          // Same override mapping the embedded manager applies, so a host asking
+          // for vector or lexical ranking gets the same semantics in either mode.
+          mode: searchMode,
+          ...namespace === void 0 ? {} : { namespace }
+        }),
+        // What is LEFT of the shared budget, not a fresh one.
+        signal: AbortSignal.timeout(remaining)
+      });
+      if (!response.ok) {
+        await response.body?.cancel();
+        throw new Error(`daemon /engram/v1/memories/search responded ${response.status}`);
+      }
+      const payload = await response.json();
+      const body = asRecord(payload);
+      if (!Array.isArray(body?.results)) {
+        throw new Error("daemon /engram/v1/memories/search returned a malformed envelope");
+      }
+      return body.results;
+    };
+    const keep = (rawResults) => {
+      const kept2 = [];
+      for (const raw of rawResults) {
+        const hit = asRecord(raw);
+        if (!hit || typeof hit.path !== "string" || hit.path.trim() === "") {
+          throw new Error("daemon /engram/v1/memories/search returned a malformed result entry");
+        }
+        const rawPath = hit.path;
+        const citation = sharedScope().relativizeToMemoryRoot(rawPath);
+        if (isMemoryArtifactPath(citation)) continue;
+        if (typeof hit.score !== "number" || !Number.isFinite(hit.score)) {
+          throw new Error("daemon /engram/v1/memories/search returned a malformed result entry");
+        }
+        const score = hit.score;
+        if (typeof opts?.minScore === "number" && score < opts.minScore) continue;
+        kept2.push({
+          // Absolute, so a follow-up readFile is unambiguous when the same
+          // relative path exists under more than one allowed root.
+          path: sharedScope().absolutize(rawPath),
+          // The daemon's ranked search returns whole-memory hits with no line
+          // span; the embedded runtime reports the same 1..1 default.
+          startLine: 1,
+          endLine: 1,
+          score,
+          snippet: typeof hit.snippet === "string" ? hit.snippet : "",
+          source: isSessionsMemoryPath(citation) ? "sessions" : "memory",
+          citation
+        });
+      }
+      return kept2;
+    };
+    let kept = [];
+    let budget = requestedResults;
+    let limit = requestedResults;
+    for (; ; ) {
+      const rawResults = await fetchPage(limit);
+      kept = keep(rawResults);
+      budget ??= rawResults.length;
+      if (kept.length >= budget) break;
+      const served = limit ?? rawResults.length;
+      if (rawResults.length === 0 || rawResults.length < served) break;
+      const ceiling = searchCandidateCeiling(budget);
+      if (served >= ceiling) break;
+      limit = Math.min(served * 2, ceiling);
+    }
+    return kept.slice(0, budget);
+  };
+  const readMemoryFile = async (params) => {
+    await refreshHealth(void 0, true);
+    requireSharedCorpus("readFile");
+    requireSingleCorpusNamespacing("readFile");
+    await requireLocalReadAuthorized("readFile", ["memory_get"]);
+    const requestedPath = sharedScope().normalizeWorkspacePath(params.relPath);
+    const absolutePath = await sharedScope().resolveReadablePath(params.relPath);
+    const allLines = (await readFile3(absolutePath, "utf8")).split(/\r?\n/);
+    if (params.from !== void 0 && (!Number.isInteger(params.from) || params.from < 1)) {
+      throw new Error(
+        `memory read rejected (from must be a positive integer): ${String(params.from)}`
+      );
+    }
+    if (params.lines !== void 0 && (!Number.isInteger(params.lines) || params.lines < 1)) {
+      throw new Error(
+        `memory read rejected (lines must be a positive integer): ${String(params.lines)}`
+      );
+    }
+    const from = typeof params.from === "number" ? params.from : 1;
+    const lines = typeof params.lines === "number" ? params.lines : void 0;
+    const startIndex = from - 1;
+    const endIndex = typeof lines === "number" ? startIndex + lines : allLines.length;
+    const truncated = endIndex < allLines.length;
+    return {
+      text: allLines.slice(startIndex, endIndex).join("\n"),
+      path: requestedPath,
+      truncated: truncated || void 0,
+      from,
+      lines,
+      nextFrom: truncated ? endIndex + 1 : void 0
+    };
+  };
+  const status = () => {
+    const usesQmd = health.searchBackend === "qmd";
+    return {
+      backend: usesQmd ? "qmd" : "builtin",
+      provider: usesQmd ? "qmd" : "builtin",
+      requestedProvider: usesQmd ? "qmd" : "builtin",
+      model: usesQmd ? options.configuredQmdCommand : "builtin",
+      dirty: false,
+      workspaceDir: options.workspaceDir,
+      dbPath: health.memoryDir ?? options.memoryDir,
+      sources: ["memory"],
+      sourceCounts: [],
+      vector: usesQmd ? { enabled: true, available: health.qmdAvailable } : { enabled: false },
+      fts: { enabled: true, available: usesQmd ? health.qmdAvailable : true },
+      custom: {
+        remnic: {
+          bridgeMode: "delegate",
+          daemon: `${target.host}:${target.port}`,
+          qmdAvailable: health.qmdAvailable,
+          qmdDebug: health.qmdDebug,
+          memoryDir: health.memoryDir ?? options.memoryDir
+        }
+      }
+    };
+  };
+  const manager = {
+    search,
+    readFile: readMemoryFile,
+    status,
+    // No `sync`: indexing belongs to the daemon in delegate mode. Omitting the
+    // optional member is honest — the host will not call what is not offered.
+    async probeEmbeddingAvailability() {
+      await refreshHealth();
+      if (health.searchBackend !== "qmd") return { ok: true };
+      if (health.qmdAvailable) return { ok: true };
+      return { ok: false, error: health.qmdDebug ?? "Remnic daemon QMD backend unavailable" };
+    },
+    async probeVectorAvailability() {
+      await refreshHealth();
+      return health.searchBackend === "qmd" && health.qmdAvailable;
+    },
+    async close() {
+    }
+  };
+  return {
+    resolveScopedNamespace: async (explicit, timeoutMs, operations) => {
+      if (explicit !== void 0) {
+        return await resolveScopedNamespaceChecked(explicit, timeoutMs, true, operations);
+      }
+      const deadline = timeoutMs === void 0 ? void 0 : now() + timeoutMs;
+      const fresh = await refreshHealth(timeoutMs, true);
+      const remaining = deadline === void 0 ? void 0 : Math.floor(deadline - now());
+      return await resolveScopedNamespaceChecked(void 0, remaining, fresh, operations);
+    },
+    runtime: {
+      async getMemorySearchManager() {
+        if (!healthEverResolved) await refreshHealth();
+        else void refreshHealth().catch(() => void 0);
+        return { manager };
+      },
+      resolveMemoryBackendConfig() {
+        return health.searchBackend === "qmd" ? { backend: "qmd", qmd: { command: options.configuredQmdCommand } } : { backend: "builtin" };
+      },
+      async closeAllMemorySearchManagers() {
+      }
+    },
+    flushPlanResolver: () => buildMemoryFlushPlan({
+      serviceId,
+      extractionMaxTurnChars: options.extractionMaxTurnChars,
+      flushModel: options.flushModel
+    }),
+    listArtifacts: async () => {
+      try {
+        await refreshHealth(void 0, true);
+        requireSharedCorpus("publicArtifacts");
+        requireSingleCorpusNamespacing("publicArtifacts");
+        await requireLocalReadAuthorized("publicArtifacts", ["memory_get"]);
+        return await listRemnicPublicArtifacts({
+          memoryDir: health.memoryDir ?? options.memoryDir,
+          workspaceDir: options.workspaceDir,
+          agentIds: options.agentIds
+        });
+      } catch (err) {
+        log5.error(`[${serviceId}] delegate publicArtifacts.listArtifacts failed`, err);
+        return [];
+      }
+    },
+    promptBuilder: (params) => options.readPromptLines(params?.sessionKey ?? "default")
+  };
 }
-function extractTextContent(msg) {
-  if (typeof msg.content === "string") return msg.content;
-  if (Array.isArray(msg.content)) {
-    return msg.content.filter(
-      (block) => typeof block === "object" && block !== null && block.type === "text" && typeof block.text === "string"
-    ).map((block) => block.text).join("\n");
+function registerDelegateMemoryCapability(api, options) {
+  const built = createDelegateMemoryCapability(options);
+  const hasUnified = typeof api.registerMemoryCapability === "function";
+  const hasRuntime = typeof api.registerMemoryRuntime === "function";
+  const hasFlushPlan = typeof api.registerMemoryFlushPlan === "function";
+  if (!hasUnified && !hasRuntime && !hasFlushPlan) {
+    log5.debug(
+      `[${options.serviceId}] delegate: host exposes no memory capability surface \u2014 nothing to register`
+    );
+    return built;
+  }
+  if (hasUnified) {
+    api.registerMemoryCapability?.({
+      ...options.allowPromptInjection ? { promptBuilder: built.promptBuilder } : {},
+      flushPlanResolver: built.flushPlanResolver,
+      runtime: built.runtime,
+      publicArtifacts: { listArtifacts: built.listArtifacts }
+    });
   }
-  return "";
+  if (hasRuntime) api.registerMemoryRuntime?.(built.runtime);
+  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}`);
+  return built;
 }
 
 // src/delegate-runtime.ts
 var DELEGATE_BATCH_FLUSH_CACHE_TTL_MS = 3e4;
-var DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS = [
-  "recall",
-  "observe",
-  "lcm_compaction_flush"
-];
-function daemonUrl(target, pathname) {
-  const host = target.host.includes(":") && !target.host.startsWith("[") ? `[${target.host}]` : target.host;
-  return `http://${host}:${target.port}${pathname}`;
-}
-var daemonAuthFailureLogKeys = /* @__PURE__ */ new Set();
-function reportDaemonAuthorizationFailure(serviceId, pathname, status, tokenSource) {
-  const key = `${serviceId}:${pathname}:${status}:${tokenSource}`;
-  if (daemonAuthFailureLogKeys.has(key)) return;
-  daemonAuthFailureLogKeys.add(key);
-  log2.error(
-    `delegate ${pathname} authorization failed (${status}; token source: ${tokenSource})`
-  );
-}
-async function probeDelegateAuthorization(target, namespace = "", operations = DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS) {
-  const auth = target.resolveAuthToken();
-  const headers = auth.token ? { Authorization: `Bearer ${auth.token}` } : void 0;
-  const query = new URLSearchParams();
-  for (const operation of operations) query.append("op", operation);
-  query.set("namespace", namespace);
-  try {
-    const response = await fetch(daemonUrl(target, `/engram/v1/authorization?${query}`), {
-      headers,
-      signal: AbortSignal.timeout(2e3)
-    });
-    await response.body?.cancel();
-    if (response.status === 200) {
-      return { state: "authorized", tokenSource: auth.source };
-    }
-    if (response.status === 401 || response.status === 403) {
-      return { state: "unauthorized", status: response.status, tokenSource: auth.source };
-    }
-  } catch {
-    return { state: "unavailable", tokenSource: auth.source };
-  }
-  return { state: "unavailable", tokenSource: auth.source };
-}
 async function postJson(target, serviceId, pathname, body, timeoutMs) {
   const headers = { "Content-Type": "application/json" };
   const auth = target.resolveAuthToken();
@@ -5853,69 +7506,6 @@ function cwdFrom(event, ctx, fallback) {
   }
   return fallback;
 }
-function withNamespace(namespace, body) {
-  return namespace ? { ...body, namespace } : body;
-}
-function explicitSessionNamespaceFrom(sessionKey, event, ctx) {
-  const eventSessionKey = typeof event.sessionKey === "string" ? event.sessionKey : void 0;
-  const ctxSessionKey = typeof ctx.sessionKey === "string" ? ctx.sessionKey : void 0;
-  const sources = eventSessionKey === sessionKey ? [event, ctx] : ctxSessionKey === sessionKey ? [ctx, event] : [ctx, event];
-  for (const source of sources) {
-    const sourceSessionKey = typeof source.sessionKey === "string" ? source.sessionKey : void 0;
-    if (sourceSessionKey !== sessionKey) continue;
-    const runtime = source.runtime;
-    if (typeof runtime !== "object" || runtime === null) continue;
-    const agent = runtime.agent;
-    if (typeof agent !== "object" || agent === null) continue;
-    const session = agent.session;
-    if (typeof session !== "object" || session === null) continue;
-    const namespace = session.namespace;
-    if (namespace !== void 0 && typeof namespace !== "string") {
-      throw new Error("delegate session namespace metadata must be a string");
-    }
-    return { namespace: typeof namespace === "string" ? namespace.trim() || void 0 : void 0 };
-  }
-  return void 0;
-}
-async function rememberedNamespacesFor(sessionKey, namespaceBindings) {
-  return namespaceBindings.namespacesFor(sessionKey);
-}
-async function rememberNamespace(sessionKey, namespace, namespaceBindings) {
-  if (namespace.length > SESSION_NAMESPACE_BINDING_MAX_NAMESPACE_LENGTH) {
-    throw new Error(
-      `delegate session namespace exceeds the daemon limit of ${SESSION_NAMESPACE_BINDING_MAX_NAMESPACE_LENGTH} characters`
-    );
-  }
-  try {
-    await namespaceBindings.remember(sessionKey, namespace);
-  } catch (err) {
-    log2.warn(`delegate namespace binding persistence failed: ${String(err)}`);
-    throw err;
-  }
-}
-async function sessionNamespaceFrom(sessionKey, event, ctx, fallback, namespaceBindings) {
-  const explicit = explicitSessionNamespaceFrom(sessionKey, event, ctx);
-  if (explicit !== void 0) {
-    await rememberNamespace(sessionKey, explicit.namespace ?? "", namespaceBindings);
-    return explicit.namespace;
-  }
-  const remembered = await rememberedNamespacesFor(sessionKey, namespaceBindings);
-  return remembered.length > 0 ? remembered.at(-1) || void 0 : fallback.trim() || void 0;
-}
-async function lifecycleSessionNamespacesFrom(sessionKey, event, ctx, fallback, namespaceBindings) {
-  const explicit = explicitSessionNamespaceFrom(sessionKey, event, ctx);
-  if (explicit !== void 0) {
-    await rememberNamespace(sessionKey, explicit.namespace ?? "", namespaceBindings);
-  }
-  const remembered = await rememberedNamespacesFor(sessionKey, namespaceBindings);
-  if (explicit !== void 0) {
-    const explicitNamespace = explicit.namespace ?? "";
-    const namespaces = remembered.includes(explicitNamespace) ? remembered : [...remembered, explicitNamespace];
-    return namespaces.map((namespace) => namespace || void 0);
-  }
-  if (remembered.length > 0) return remembered.map((namespace) => namespace || void 0);
-  return [fallback.trim() || void 0];
-}
 function readContextComposition(response, fallbackContext) {
   const candidate = response.contextComposition;
   if (typeof candidate !== "object" || candidate === null || !("context" in candidate) || typeof candidate.context !== "string") {
@@ -5930,28 +7520,82 @@ function registerDelegateRuntime(api, options) {
   const { target, namespace, namespaceBindings } = options;
   const now = options.now ?? Date.now;
   if (options.passive) {
-    log2.info(
+    log6.info(
       `[${options.serviceId}] bridge mode delegate: memory slot not owned \u2014 passive, no hooks registered`
     );
     return;
   }
-  if (options.allowPromptInjection && options.recallBudgetChars !== 0) {
-    const promptLinesBySession = /* @__PURE__ */ new Map();
-    const useSectionBuilder = typeof api.registerMemoryPromptSection === "function";
+  const promptLinesBySession = /* @__PURE__ */ new Map();
+  const promptInjectionEnabled = options.allowPromptInjection && options.recallBudgetChars !== 0;
+  const useSectionBuilder = typeof api.registerMemoryPromptSection === "function";
+  const useCapabilityBuilder = !useSectionBuilder && typeof api.registerMemoryCapability === "function";
+  const cachePromptLines = useSectionBuilder || useCapabilityBuilder;
+  const capability = registerDelegateMemoryCapability(api, {
+    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;
+    },
+    // 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) => {
+      const probe = await probeDelegateAuthorization(
+        target,
+        candidate,
+        // What the caller is about to do. A token that grants recall/observe/
+        // flush but not memory_search must not have those rejected locally.
+        operations ?? DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS,
+        timeoutMs
+      );
+      return probe.state === "unavailable" ? void 0 : probe.state === "authorized";
+    },
+    memoryDir: options.capability.memoryDir,
+    workspaceDir: options.capability.workspaceDir,
+    agentIds: options.capability.agentIds,
+    allowPromptInjection: promptInjectionEnabled,
+    // The section builder owns the destructive read when it exists; otherwise
+    // the capability builder IS the sole consumer and must evict, or a stale
+    // section would be re-injected on the next turn.
+    readPromptLines: (sessionKey) => {
+      const lines = promptLinesBySession.get(sessionKey) ?? null;
+      if (!useSectionBuilder) promptLinesBySession.delete(sessionKey);
+      return lines;
+    },
+    extractionMaxTurnChars: options.capability.extractionMaxTurnChars,
+    flushModel: options.capability.flushModel,
+    configuredSearchBackend: options.capability.configuredSearchBackend,
+    configuredQmdCommand: options.capability.configuredQmdCommand,
+    searchTimeoutMs: options.recallTimeoutMs,
+    healthTimeoutMs: options.recallTimeoutMs,
+    now: options.now
+  });
+  if (promptInjectionEnabled) {
     const recallHandler = async (event, ctx) => {
       const query = recallQueryFrom(event);
-      if (query.trim().length < 5) return void 0;
       const sessionKey = sessionKeyFrom(event, ctx);
-      if (useSectionBuilder) promptLinesBySession.delete(sessionKey);
+      if (cachePromptLines) promptLinesBySession.delete(sessionKey);
+      if (query.trim().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)) {
-          log2.debug(`delegate recall skipped: cron policy excludes ${sessionKey}`);
+          log6.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)) {
-          log2.debug(`delegate recall skipped: session toggle disables memory for ${sessionKey}`);
+          log6.debug(`delegate recall skipped: session toggle disables memory for ${sessionKey}`);
           return void 0;
         }
         const cwd = cwdFrom(event, ctx, options.cwd);
@@ -5966,14 +7610,21 @@ function registerDelegateRuntime(api, options) {
           target,
           options.serviceId,
           "/engram/v1/recall",
-          withNamespace(scopedNamespace, {
-            query,
-            sessionKey,
-            mode: "auto",
-            ...cwd ? { cwd } : {},
-            ...options.projectTag ? { projectTag: options.projectTag } : {}
-          }),
-          options.recallTimeoutMs
+          await withNamespace(
+            scopedNamespace,
+            {
+              query,
+              sessionKey,
+              mode: "auto",
+              ...cwd ? { cwd } : {},
+              ...options.projectTag ? { projectTag: options.projectTag } : {}
+            },
+            // ONE deadline for the whole hook: health resolution followed by
+            // a full-timeout recall could otherwise run past `hookTimeoutMs`
+            // and have the host abandon it with nothing injected.
+            (explicit) => capability.resolveScopedNamespace(explicit, promptRemaining(), ["recall"])
+          ),
+          Math.max(1, promptRemaining())
         );
         const rawContext = response?.context;
         if (typeof rawContext !== "string" || rawContext.trim().length === 0) {
@@ -5985,13 +7636,13 @@ function registerDelegateRuntime(api, options) {
         });
         if (!rendered) return void 0;
         const prompt = rendered.prompt;
-        if (useSectionBuilder) {
+        if (cachePromptLines) {
           promptLinesBySession.set(sessionKey, rendered.lines);
           return void 0;
         }
         return { prependSystemContext: prompt };
       } catch (err) {
-        log2.warn(`delegate recall failed: ${String(err)}`);
+        log6.warn(`delegate recall failed: ${String(err)}`);
         return void 0;
       }
     };
@@ -6013,7 +7664,7 @@ function registerDelegateRuntime(api, options) {
       api.registerMemoryPromptSection(memoryBuildFn);
     }
   } else {
-    log2.info(
+    log6.info(
       `[${options.serviceId}] bridge mode delegate: prompt injection disabled by hooks policy`
     );
   }
@@ -6032,6 +7683,8 @@ function registerDelegateRuntime(api, options) {
     );
     if (turn.length === 0) return;
     try {
+      const observeDeadline = Date.now() + options.observeTimeoutMs;
+      const observeRemaining = () => observeDeadline - Date.now();
       const cwd = cwdFrom(event, ctx, options.cwd);
       const scopedNamespace = await sessionNamespaceFrom(
         sessionKey,
@@ -6044,16 +7697,20 @@ function registerDelegateRuntime(api, options) {
         target,
         options.serviceId,
         "/engram/v1/observe",
-        withNamespace(scopedNamespace, {
-          sessionKey,
-          messages: turn,
-          ...cwd ? { cwd } : {},
-          ...options.projectTag ? { projectTag: options.projectTag } : {}
-        }),
-        options.observeTimeoutMs
+        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) {
-      log2.warn(`delegate observe failed: ${String(err)}`);
+      log6.warn(`delegate observe failed: ${String(err)}`);
     }
   });
   let cachedBatchFlushSupport;
@@ -6104,9 +7761,10 @@ function registerDelegateRuntime(api, options) {
     try {
       const deadline = Date.now() + options.flushTimeoutMs;
       const remainingTimeout = () => Math.max(1, deadline - Date.now());
+      const remainingBudget = () => deadline - Date.now();
       const sessionKey = lifecycleSessionKeyFrom(event, ctx);
       if (sessionKey === void 0) {
-        log2.warn("delegate flush skipped: lifecycle event has malformed session key");
+        log6.warn("delegate flush skipped: lifecycle event has malformed session key");
         return false;
       }
       const namespaces = await lifecycleSessionNamespacesFrom(
@@ -6116,11 +7774,38 @@ function registerDelegateRuntime(api, options) {
         namespace,
         namespaceBindings
       );
-      const flushNamespace = (sessionNamespace) => postJson(
+      try {
+        await ingestFlushPlanNotes({
+          target,
+          serviceId: options.serviceId,
+          workspaceDir: cwdFrom(event, ctx, options.capability.workspaceDir),
+          sessionKey,
+          // The session's CURRENT binding, which is the last entry of the
+          // ordered history — `namespaces[0]` is where it started, so a
+          // rebound session would file new notes under the previous tenant.
+          namespace: namespaces.at(-1),
+          // Re-read per chunk, not captured once: several posts must share
+          // the flush's remaining budget rather than each taking it whole.
+          remainingTimeoutMs: remainingBudget
+        });
+      } catch (err) {
+        log6.warn(`delegate flush-plan ingestion failed: ${String(err)}`);
+      }
+      const flushNamespace = async (sessionNamespace) => postJson(
         target,
         options.serviceId,
         "/engram/v1/lcm/compaction/flush",
-        withNamespace(sessionNamespace, { sessionKey }),
+        await withNamespace(
+          sessionNamespace,
+          { sessionKey },
+          (explicit) => (
+            // Inside the flush's SHARED deadline: a health probe started here
+            // with its own full timeout would overrun the hook.
+            capability.resolveScopedNamespace(explicit, remainingBudget(), [
+              "lcm_compaction_flush"
+            ])
+          )
+        ),
         remainingTimeout()
       );
       const flushIndividually = async () => {
@@ -6134,15 +7819,19 @@ function registerDelegateRuntime(api, options) {
           const response = await flushNamespace(namespaces[0]);
           return response !== null && response.flushed === true;
         }
+        const requestNamespaces = await Promise.all(
+          namespaces.map(
+            async (sessionNamespace) => await capability.resolveScopedNamespace(sessionNamespace || void 0, remainingBudget(), [
+              "lcm_compaction_flush"
+            ]) ?? ""
+          )
+        );
         try {
           const response = await postJson(
             target,
             options.serviceId,
             "/engram/v1/lcm/compaction/flush",
-            {
-              sessionKey,
-              namespaces: namespaces.map((sessionNamespace) => sessionNamespace ?? "")
-            },
+            { sessionKey, namespaces: requestNamespaces },
             remainingTimeout()
           );
           if (response === null) {
@@ -6151,9 +7840,9 @@ function registerDelegateRuntime(api, options) {
           }
           const responseNamespaces = response.namespaces;
           const responseResults = response.results;
-          const isBatchResponse = Array.isArray(responseNamespaces) && Array.isArray(responseResults) && responseNamespaces.length === namespaces.length && responseNamespaces.every(
-            (responseNamespace, index) => responseNamespace === (namespaces[index] ?? "")
-          ) && responseResults.length === namespaces.length;
+          const isBatchResponse = Array.isArray(responseNamespaces) && Array.isArray(responseResults) && responseNamespaces.length === requestNamespaces.length && responseNamespaces.every(
+            (responseNamespace, index) => responseNamespace === requestNamespaces[index]
+          ) && responseResults.length === requestNamespaces.length;
           if (!isBatchResponse) {
             invalidateCachedBatchFlushSupport();
             return flushIndividually();
@@ -6170,7 +7859,7 @@ function registerDelegateRuntime(api, options) {
       }
       return flushIndividually();
     } catch (err) {
-      log2.warn(`delegate flush failed: ${String(err)}`);
+      log6.warn(`delegate flush failed: ${String(err)}`);
       return false;
     }
   };
@@ -6180,12 +7869,12 @@ function registerDelegateRuntime(api, options) {
     api.on("before_reset", flushEndedSession);
     api.on("session_end", flushEndedSession);
   }
-  log2.info(
-    `[${options.serviceId}] bridge mode delegate: memory loop backed by daemon at ${target.host}:${target.port} (embedded orchestrator skipped; tools/CLI/surfaces stay daemon-side)`
+  log6.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.slice(1);
+  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) => {
@@ -6211,7 +7900,7 @@ var queueDelegateNamespaceMigration = (bindingPath, sessionKey, operation) => {
   return run;
 };
 function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapterActive) {
-  const bindingPath = (pluginId) => path4.join(memoryDir, "state", "plugins", pluginId, "session-namespace-bindings.json");
+  const bindingPath = (pluginId) => path8.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;
@@ -6237,7 +7926,7 @@ function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapt
       return previous;
     } catch (err) {
       if (current.length > 0) {
-        log2.warn(
+        log6.warn(
           `[${serviceId}] delegate legacy namespace read failed; using canonical bindings: ${String(err)}`
         );
         return [];
@@ -6252,7 +7941,7 @@ function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapt
       if (existing >= 0) merged.splice(existing, 1);
       merged.push(remembered);
     }
-    return merged.slice(-SESSION_NAMESPACE_BINDING_MAX_NAMESPACES);
+    return merged.slice(-SESSION_NAMESPACE_BINDING_MAX_NAMESPACES2);
   };
   const persistNamespaceHistory = async (store, sessionKey, namespaces) => {
     if (store.replace !== void 0) {
@@ -6268,7 +7957,7 @@ function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapt
       try {
         await legacy.replace?.(sessionKey, []);
       } catch (err) {
-        log2.warn(`[${serviceId}] delegate legacy namespace cleanup failed: ${String(err)}`);
+        log6.warn(`[${serviceId}] delegate legacy namespace cleanup failed: ${String(err)}`);
       }
     }
     rememberMigratedLegacySession(sessionKey);
@@ -6289,7 +7978,7 @@ function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapt
           await persistNamespaceHistory(primary, sessionKey, merged);
           await completeLegacyMigration(sessionKey);
         } catch (err) {
-          log2.warn(`[${serviceId}] delegate namespace migration failed: ${String(err)}`);
+          log6.warn(`[${serviceId}] delegate namespace migration failed: ${String(err)}`);
         }
         return merged;
       });
@@ -6312,50 +8001,67 @@ function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapt
 var delegateHookApiServices = /* @__PURE__ */ new WeakMap();
 var delegateActiveServiceIds = /* @__PURE__ */ new Set();
 var delegateEmbeddedFallbackApis = /* @__PURE__ */ new WeakSet();
+var delegateBoundApis = /* @__PURE__ */ new WeakSet();
 var delegateAuthorizationPreflightServices = /* @__PURE__ */ new WeakMap();
 function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkDaemonHealthSync }) {
-  let bridge;
-  try {
-    bridge = resolveBridgeMode(options.configBridgeMode);
-  } catch (err) {
-    log2.error(`${String(err)} \u2014 falling back to the embedded runtime`);
-    delegateEmbeddedFallbackApis.add(api);
-    return false;
-  }
-  if (delegateEmbeddedFallbackApis.has(api)) {
-    log2.debug(
-      `delegate register: ${options.serviceId} previously fell back to embedded on this api \u2014 staying embedded to avoid stacking memory paths`
-    );
-    return false;
-  }
-  if (bridge.mode !== "delegate") {
-    if (!options.passive) delegateEmbeddedFallbackApis.add(api);
-    return false;
-  }
   const boundServices = delegateHookApiServices.get(api);
   if (boundServices?.has(options.serviceId)) {
-    log2.debug(
+    log6.debug(
       `delegate register: ${options.serviceId} already has hooks bound on this api \u2014 skipping duplicate registration`
     );
     return true;
   }
+  if (delegateEmbeddedFallbackApis.has(api)) {
+    log6.debug(
+      `delegate register: ${options.serviceId} previously fell back to embedded on this api \u2014 staying embedded to avoid stacking memory paths`
+    );
+    return false;
+  }
+  let bridge;
   let bridgeHealthTimeoutMs;
   try {
     bridgeHealthTimeoutMs = parseOpenClawBridgeConfig({
       bridgeHealthTimeoutMs: options.bridgeHealthTimeoutMs
     }).healthTimeoutMs;
+    bridge = resolveBridgeMode(options.configBridgeMode, {
+      memoryDir: options.memoryDir,
+      timeoutMs: bridgeHealthTimeoutMs,
+      onSkip: (reason) => log6.info(`[${options.serviceId}] bridge mode auto: staying embedded \u2014 ${reason}`)
+    });
   } catch (err) {
-    log2.error(`${String(err)} \u2014 falling back to the embedded runtime`);
-    delegateEmbeddedFallbackApis.add(api);
+    const wantedDelegate = requestedDelegate(options.configBridgeMode);
+    log6.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);
     return false;
   }
-  if (!deps.checkHealth(
-    bridge.daemonHost,
-    bridge.daemonPort,
-    bridgeHealthTimeoutMs
-  )) {
+  if (bridge.mode !== "delegate") {
+    if (delegateBoundApis.has(api)) {
+      log6.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;
+    }
+    if (!options.passive) {
+      delegateEmbeddedFallbackApis.add(api);
+      if (resolveRequestedBridgeMode(options.configBridgeMode) === "auto") {
+        log6.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)) {
+      log6.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`
+      );
+      return true;
+    }
     delegateEmbeddedFallbackApis.add(api);
-    log2.error(
+    log6.error(
       `bridge mode delegate requested but no healthy daemon at ${bridge.daemonHost}:${bridge.daemonPort} \u2014 falling back to the embedded runtime`
     );
     return false;
@@ -6365,18 +8071,15 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
       options.serviceId
     );
     delegateActiveServiceIds.add(options.serviceId);
+    delegateBoundApis.add(api);
   }
   const toggleStore = options.sessionTogglesEnabled ? createFileToggleStore(
-    path4.join(options.memoryDir, "state", "plugins", options.serviceId, "session-toggles.json"),
+    path8.join(options.memoryDir, "state", "plugins", options.serviceId, "session-toggles.json"),
     {
-      secondaryReadOnlyPath: options.respectBundledActiveMemoryToggle ? path4.join(options.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0
+      secondaryReadOnlyPath: options.respectBundledActiveMemoryToggle ? path8.join(options.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0
     }
   ) : null;
-  const target = {
-    host: bridge.daemonHost,
-    port: bridge.daemonPort,
-    resolveAuthToken: loadDaemonAuth
-  };
+  const target = daemonTargetFor(bridge);
   registerDelegateRuntime(api, {
     serviceId: options.serviceId,
     target,
@@ -6397,6 +8100,7 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     cwd: options.cwd,
     projectTag: options.projectTag,
     flushOnResetEnabled: options.flushOnResetEnabled,
+    capability: options.capability,
     recallTimeoutMs: 25e3,
     observeTimeoutMs: 12e4,
     flushTimeoutMs: 55e3
@@ -6414,16 +8118,16 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     void probe(target, "", operations).then((result) => {
       if (result.state === "authorized") return;
       if (result.state === "unauthorized") {
-        log2.warn(
+        log6.warn(
           `delegate authorization preflight rejected ${operationLabel} (${result.status}; token source: ${result.tokenSource}) \u2014 runtime remains active`
         );
         return;
       }
-      log2.warn(
+      log6.warn(
         `delegate authorization preflight could not verify ${operationLabel} (token source: ${result.tokenSource}) \u2014 runtime remains active`
       );
     }).catch(() => {
-      log2.warn("delegate authorization preflight could not complete \u2014 runtime remains active");
+      log6.warn("delegate authorization preflight could not complete \u2014 runtime remains active");
     });
   }
   return true;
@@ -6526,7 +8230,7 @@ function buildTurnFingerprint(input) {
 // ../../src/index.ts
 import { planRecallMode } from "@remnic/core/intent";
 import {
-  expandTildePath as expandTildePath2,
+  expandTildePath as expandTildePath4,
   renderMemoryContextPrompt as renderSharedMemoryContextPrompt,
   resolveAgentAccessAuthToken,
   resolvePrincipal
@@ -6542,32 +8246,32 @@ __export(resolve_provider_secret_exports, {
   findGatewayRuntimeModules: () => findGatewayRuntimeModules
 });
 __reExport(resolve_provider_secret_exports, resolve_provider_secret_star);
-import path5 from "path";
+import path9 from "path";
 import * as resolve_provider_secret_star from "@remnic/core/resolve-provider-secret";
 async function findGatewayRuntimeModules(filePrefix) {
-  const { existsSync, readFileSync, readdirSync, realpathSync } = await import("fs");
+  const { existsSync, readFileSync, readdirSync, realpathSync: realpathSync2 } = await import("fs");
   const { createRequire: createRequire2 } = await import("module");
   const candidates = [];
   const isWithinRoot = (root, candidate) => {
-    const relative = path5.relative(root, candidate);
-    return relative.length === 0 || !relative.startsWith("..") && !path5.isAbsolute(relative);
+    const relative = path9.relative(root, candidate);
+    return relative.length === 0 || !relative.startsWith("..") && !path9.isAbsolute(relative);
   };
   let packageRoot;
   try {
     const req = createRequire2(import.meta.url);
-    const openclawEntrypoint = realpathSync(req.resolve("openclaw"));
-    let currentDir = path5.dirname(openclawEntrypoint);
+    const openclawEntrypoint = realpathSync2(req.resolve("openclaw"));
+    let currentDir = path9.dirname(openclawEntrypoint);
     while (true) {
-      const packageJsonPath = path5.join(currentDir, "package.json");
+      const packageJsonPath = path9.join(currentDir, "package.json");
       if (existsSync(packageJsonPath)) {
         const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
         if (packageJson.name !== "openclaw") {
           return [];
         }
-        packageRoot = realpathSync(currentDir);
+        packageRoot = realpathSync2(currentDir);
         break;
       }
-      const parent = path5.dirname(currentDir);
+      const parent = path9.dirname(currentDir);
       if (parent === currentDir) {
         return [];
       }
@@ -6577,14 +8281,14 @@ async function findGatewayRuntimeModules(filePrefix) {
     return [];
   }
   try {
-    const distDir = realpathSync(path5.join(packageRoot, "dist"));
+    const distDir = realpathSync2(path9.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 = realpathSync(path5.join(distDir, f));
+        const candidate = realpathSync2(path9.join(distDir, f));
         if (isWithinRoot(packageRoot, candidate) && isWithinRoot(distDir, candidate)) {
           candidates.push(candidate);
         }
@@ -6666,28 +8370,25 @@ var NODE_FS_MODULE_ID = ["node", "fs"].join(":");
 var NODE_FS_PROMISES_MODULE_ID = ["node", "fs/promises"].join(":");
 var READ_FILE_SYNC_FIELD = ["read", "File", "Sync"].join("");
 var EXISTS_SYNC_FIELD = ["exists", "Sync"].join("");
-function isMemoryArtifactPath(p) {
-  return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(p);
-}
 function readTextFileNow(filePath) {
   const nodeRequire = createRequire(import.meta.url);
-  const fs2 = nodeRequire(NODE_FS_MODULE_ID);
-  const reader = fs2[READ_FILE_SYNC_FIELD];
+  const fs4 = nodeRequire(NODE_FS_MODULE_ID);
+  const reader = fs4[READ_FILE_SYNC_FIELD];
   return reader(filePath, "utf-8");
 }
 function fileExistsNow(filePath) {
   const nodeRequire = createRequire(import.meta.url);
-  const fs2 = nodeRequire(NODE_FS_MODULE_ID);
-  const exists = fs2[EXISTS_SYNC_FIELD];
+  const fs4 = nodeRequire(NODE_FS_MODULE_ID);
+  const exists = fs4[EXISTS_SYNC_FIELD];
   return exists(filePath);
 }
 async function readTextFileLater(filePath) {
-  const fs2 = await import(NODE_FS_PROMISES_MODULE_ID);
-  return fs2.readFile(filePath, "utf-8");
+  const fs4 = await import(NODE_FS_PROMISES_MODULE_ID);
+  return fs4.readFile(filePath, "utf-8");
 }
 async function writeTextFileLater(filePath, data) {
-  const fs2 = await import(NODE_FS_PROMISES_MODULE_ID);
-  await fs2.writeFile(filePath, data, "utf-8");
+  const fs4 = await import(NODE_FS_PROMISES_MODULE_ID);
+  await fs4.writeFile(filePath, data, "utf-8");
 }
 function isRecordLike(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -6806,8 +8507,8 @@ function reconcileHourlySummaryCronRouting(existing, cfg, opts) {
   return { changed: true, job };
 }
 async function realPathLater(filePath) {
-  const fs2 = await import(NODE_FS_PROMISES_MODULE_ID);
-  return fs2.realpath(filePath);
+  const fs4 = await import(NODE_FS_PROMISES_MODULE_ID);
+  return fs4.realpath(filePath);
 }
 var SECRET_REF_RESOLVER_RETRY_BACKOFF_MS = 6e4;
 var SECRET_REF_RESOLVER_EXPORT_NAMES = [
@@ -6928,9 +8629,9 @@ function buildServiceKeys(serviceId) {
 function resolveOpenClawConfigFilePath() {
   const explicitConfigPath = readEnvVar("OPENCLAW_CONFIG_PATH") || readEnvVar("OPENCLAW_ENGRAM_CONFIG_PATH");
   if (explicitConfigPath && explicitConfigPath.length > 0) {
-    return expandTildePath2(explicitConfigPath);
+    return expandTildePath4(explicitConfigPath);
   }
-  return path6.join(resolveHomeDir2(), ".openclaw", "openclaw.json");
+  return path10.join(resolveHomeDir3(), ".openclaw", "openclaw.json");
 }
 function coerceRawConfigBoolean(value) {
   if (typeof value === "boolean") return value;
@@ -6977,7 +8678,7 @@ function readPluginHooksPolicy(apiConfig, pluginId) {
 }
 async function maybeRegisterLiveConnectorCron(orchestrator) {
   if (!hasEnabledLiveConnectorConfig(orchestrator.config.connectors)) return;
-  const jobsPath = path6.join(resolveHomeDir2(), ".openclaw", "cron", "jobs.json");
+  const jobsPath = path10.join(resolveHomeDir3(), ".openclaw", "cron", "jobs.json");
   try {
     if (!fileExistsNow(jobsPath)) {
       logger_exports.log.debug("live connectors cron: jobs.json not found, skipping auto-register");
@@ -7205,9 +8906,20 @@ function registerOpenClawHostEmbeddingProvider(params) {
   );
   return unregister;
 }
+function getOpenClawRuntimeAgent(api) {
+  if (!("runtime" in api)) return void 0;
+  const runtime = api.runtime;
+  if (typeof runtime !== "object" || runtime === null || !("agent" in runtime)) return void 0;
+  const agent = runtime.agent;
+  return typeof agent === "object" && agent !== null ? agent : void 0;
+}
 function getOpenClawRuntimeWorkspaceDir(api) {
-  const runtimeWorkspaceDir = api.runtime?.agent?.workspaceDir;
-  return typeof runtimeWorkspaceDir === "string" && runtimeWorkspaceDir.length > 0 ? runtimeWorkspaceDir : void 0;
+  const workspaceDir = getOpenClawRuntimeAgent(api)?.workspaceDir;
+  return typeof workspaceDir === "string" && workspaceDir.length > 0 ? workspaceDir : void 0;
+}
+function getOpenClawRuntimeAgentId(api) {
+  const agentId = getOpenClawRuntimeAgent(api)?.id;
+  return typeof agentId === "string" && agentId.length > 0 ? agentId : void 0;
 }
 function stableOpenClawConfigSignature(value, seen = /* @__PURE__ */ new WeakSet()) {
   if (value === null) return "null";
@@ -7439,7 +9151,19 @@ var pluginDefinition = {
       hookTimeoutMs: cfg.initGateTimeoutMs,
       shouldSkipRecall: (sk) => shouldSkipRecallForSession(sk, cfg),
       cwd: getOpenClawRuntimeWorkspaceDir(api),
-      flushOnResetEnabled: cfg.flushOnResetEnabled
+      flushOnResetEnabled: cfg.flushOnResetEnabled,
+      // Memory-slot capability inputs. Mirrors the embedded derivation: the
+      // registration-time runtime agent owns this memory, and QMD is the
+      // backend only when it is both selected and enabled.
+      capability: {
+        memoryDir: cfg.memoryDir,
+        workspaceDir: getOpenClawRuntimeWorkspaceDir(api) ?? cfg.workspaceDir ?? defaultWorkspaceDir(),
+        agentIds: [getOpenClawRuntimeAgentId(api) ?? "generalist"],
+        extractionMaxTurnChars: cfg.extractionMaxTurnChars,
+        flushModel: typeof cfg.summaryModel === "string" && cfg.summaryModel.length > 0 ? cfg.summaryModel : cfg.taskModelChain?.primary,
+        configuredSearchBackend: (cfg.searchBackend ?? "qmd") === "qmd" && cfg.qmdEnabled !== false ? "qmd" : "builtin",
+        configuredQmdCommand: typeof cfg.qmdPath === "string" && cfg.qmdPath.trim().length > 0 ? cfg.qmdPath.trim() : "qmd"
+      }
     });
     if (delegateHandled) return;
     const existing = globalThis[keys.ORCHESTRATOR];
@@ -7521,9 +9245,9 @@ var pluginDefinition = {
       emitLegacyTools: cfg.emitLegacyTools
     });
     globalThis[keys.ACCESS_HTTP_SERVER] = accessHttpServer;
-    const pluginStateDir = path6.join(cfg.memoryDir, "state", "plugins", serviceId);
-    const togglePrimaryPath = path6.join(pluginStateDir, "session-toggles.json");
-    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path6.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
+    const pluginStateDir = path10.join(cfg.memoryDir, "state", "plugins", serviceId);
+    const togglePrimaryPath = path10.join(pluginStateDir, "session-toggles.json");
+    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path10.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
     const sessionToggleStore = createFileToggleStore2(togglePrimaryPath, {
       secondaryReadOnlyPath: toggleSecondaryPath
     });
@@ -7545,11 +9269,11 @@ var pluginDefinition = {
     }
     function resolveDreamJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path6.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path6.join(workspaceRoot, cfg.dreaming.journalPath);
+      return path10.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path10.join(workspaceRoot, cfg.dreaming.journalPath);
     }
     function resolveHeartbeatJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path6.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path6.join(workspaceRoot, cfg.heartbeat.journalPath);
+      return path10.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path10.join(workspaceRoot, cfg.heartbeat.journalPath);
     }
     const existingFlushPlanProcessingChains = globalThis[keys.FLUSH_PLAN_PROCESSING_CHAINS];
     const flushPlanProcessingChains = existingFlushPlanProcessingChains instanceof Map ? existingFlushPlanProcessingChains : /* @__PURE__ */ new Map();
@@ -7826,7 +9550,7 @@ Keep the reflection grounded in the evidence below.
         timeoutMs: cfg.activeRecallTimeoutMs,
         cacheTtlMs: cfg.activeRecallCacheTtlMs,
         persistTranscripts: cfg.activeRecallPersistTranscripts,
-        transcriptDir: path6.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path6.join(pluginStateDir, cfg.activeRecallTranscriptDir),
+        transcriptDir: path10.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path10.join(pluginStateDir, cfg.activeRecallTranscriptDir),
         entityGraphDepth: cfg.activeRecallEntityGraphDepth,
         includeCausalTrajectories: cfg.activeRecallIncludeCausalTrajectories,
         includeDaySummary: cfg.activeRecallIncludeDaySummary,
@@ -8759,94 +10483,15 @@ Keep the reflection grounded in the evidence below.
           const key = params?.sessionKey ?? "default";
           return consumePromptMemoryLines2(key);
         };
-        const runtimeAgent = api.runtime?.agent;
-        const runtimeAgentId = typeof runtimeAgent?.id === "string" && runtimeAgent.id.length > 0 ? runtimeAgent.id : void 0;
-        const capabilityAgentIds = runtimeAgentId ? [runtimeAgentId] : ["generalist"];
-        const capabilityWorkspaceDir = (typeof runtimeAgent?.workspaceDir === "string" && runtimeAgent.workspaceDir.length > 0 ? runtimeAgent.workspaceDir : void 0) ?? orchestrator.config.workspaceDir ?? defaultWorkspaceDir();
+        const capabilityAgentIds = [getOpenClawRuntimeAgentId(api) ?? "generalist"];
+        const capabilityWorkspaceDir = getOpenClawRuntimeWorkspaceDir(api) ?? orchestrator.config.workspaceDir ?? defaultWorkspaceDir();
         const remnicUsesQmd = (orchestrator.config.searchBackend ?? "qmd") === "qmd" && orchestrator.config.qmdEnabled !== false;
         const remnicQmdCommand = typeof orchestrator.config.qmdPath === "string" && orchestrator.config.qmdPath.trim().length > 0 ? orchestrator.config.qmdPath.trim() : "qmd";
-        const readAllowedRoots = [
-          orchestrator.config.memoryDir,
-          capabilityWorkspaceDir ? path6.join(capabilityWorkspaceDir, "memory") : void 0
-        ].filter((root) => typeof root === "string" && root.length > 0);
-        const canonicalizeRootForContainment = async (rawPath) => {
-          const resolved = path6.resolve(rawPath);
-          try {
-            return path6.normalize(await realPathLater(resolved));
-          } catch {
-            return path6.normalize(resolved);
-          }
-        };
-        const canonicalizeForRead = async (rawPath) => {
-          const resolved = path6.resolve(rawPath);
-          const real = await realPathLater(resolved);
-          return path6.normalize(real);
-        };
-        const readAllowedCanonicalRootsPromise = Promise.all(
-          readAllowedRoots.map((root) => canonicalizeRootForContainment(root))
-        );
-        const isWithinAllowedRoot = async (candidatePath) => {
-          let canonicalCandidatePath;
-          try {
-            canonicalCandidatePath = await canonicalizeForRead(candidatePath);
-          } catch {
-            return false;
-          }
-          const canonicalRoots = await readAllowedCanonicalRootsPromise;
-          return canonicalRoots.some((root) => {
-            const relative = path6.relative(root, canonicalCandidatePath);
-            return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
-          });
-        };
-        const normalizeWorkspacePath = (rawPath) => {
-          if (!rawPath || typeof rawPath !== "string") return "memory";
-          const resolved = path6.isAbsolute(rawPath) ? path6.resolve(rawPath) : path6.resolve(capabilityWorkspaceDir, rawPath);
-          const relative = path6.relative(capabilityWorkspaceDir, resolved);
-          return relative && !relative.startsWith("..") && !path6.isAbsolute(relative) ? relative : rawPath;
-        };
-        const relativizeToMemoryRoot = (rawPath) => {
-          if (!rawPath || typeof rawPath !== "string") return "memory";
-          const resolved = path6.isAbsolute(rawPath) ? path6.resolve(rawPath) : path6.resolve(capabilityWorkspaceDir, rawPath);
-          for (const root of readAllowedRoots) {
-            const relative = path6.relative(root, resolved);
-            if (relative !== "" && !relative.startsWith("..") && !path6.isAbsolute(relative)) {
-              return relative;
-            }
-          }
-          return normalizeWorkspacePath(rawPath);
-        };
-        const resolveReadablePath = async (requestedPath) => {
-          const candidateAbsolutePaths = path6.isAbsolute(requestedPath) ? [path6.resolve(requestedPath)] : readAllowedRoots.map((root) => path6.resolve(root, requestedPath));
-          let canonicalPath;
-          let lastError;
-          for (const absolutePath of candidateAbsolutePaths) {
-            try {
-              canonicalPath = await canonicalizeForRead(absolutePath);
-              break;
-            } catch (err) {
-              lastError = err;
-            }
-          }
-          if (canonicalPath === void 0) {
-            throw new Error(
-              `memory read rejected (path unresolvable): ${requestedPath}`
-            );
-          }
-          const canonicalRoots = await readAllowedCanonicalRootsPromise;
-          const contained = canonicalRoots.some((root) => {
-            const relative = path6.relative(root, canonicalPath);
-            return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
-          });
-          if (!contained) {
-            throw new Error(`memory read outside allowed roots: ${requestedPath}`);
-          }
-          if (!canonicalPath.toLowerCase().endsWith(".md")) {
-            throw new Error(
-              `memory read restricted to .md files: ${requestedPath}`
-            );
-          }
-          return canonicalPath;
-        };
+        const readScope = createMemoryReadScope({
+          memoryDir: orchestrator.config.memoryDir,
+          workspaceDir: capabilityWorkspaceDir,
+          realpath: realPathLater
+        });
         const remnicMemoryRuntime = {
           async getMemorySearchManager(_params) {
             return {
@@ -8867,17 +10512,8 @@ Keep the reflection grounded in the evidence below.
                   }).map((result, index) => {
                     const candidate = result;
                     const rawPath = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : `memory-${index + 1}`;
-                    const absolutePath = path6.isAbsolute(rawPath) ? path6.resolve(rawPath) : (() => {
-                      for (const root of readAllowedRoots) {
-                        const candidateAbs = path6.resolve(root, rawPath);
-                        const relative = path6.relative(root, candidateAbs);
-                        if (!relative.startsWith("..") && !path6.isAbsolute(relative)) {
-                          return candidateAbs;
-                        }
-                      }
-                      return path6.resolve(capabilityWorkspaceDir, rawPath);
-                    })();
-                    const normalizedPath = relativizeToMemoryRoot(rawPath);
+                    const absolutePath = readScope.absolutize(rawPath);
+                    const normalizedPath = readScope.relativizeToMemoryRoot(rawPath);
                     const startLine = typeof candidate.startLine === "number" && Number.isFinite(candidate.startLine) ? Math.max(1, Math.floor(candidate.startLine)) : 1;
                     const endLine = typeof candidate.endLine === "number" && Number.isFinite(candidate.endLine) ? Math.max(startLine, Math.floor(candidate.endLine)) : startLine;
                     return {
@@ -8886,7 +10522,7 @@ Keep the reflection grounded in the evidence below.
                       endLine,
                       score: typeof candidate.score === "number" && Number.isFinite(candidate.score) ? candidate.score : 0,
                       snippet: typeof candidate.snippet === "string" ? candidate.snippet : typeof candidate.text === "string" ? candidate.text : "",
-                      source: normalizedPath.includes("sessions/") ? "sessions" : "memory",
+                      source: isSessionsMemoryPath(normalizedPath) ? "sessions" : "memory",
                       citation: normalizedPath
                     };
                   }).filter(
@@ -8894,8 +10530,8 @@ Keep the reflection grounded in the evidence below.
                   );
                 },
                 async readFile(params) {
-                  const requestedPath = normalizeWorkspacePath(params.relPath);
-                  const absolutePath = await resolveReadablePath(params.relPath);
+                  const requestedPath = readScope.normalizeWorkspacePath(params.relPath);
+                  const absolutePath = await readScope.resolveReadablePath(params.relPath);
                   const text = await readTextFileLater(absolutePath);
                   const allLines = text.split(/\r?\n/);
                   const from = typeof params.from === "number" ? Math.max(1, Math.floor(params.from)) : 1;
@@ -8975,19 +10611,13 @@ Keep the reflection grounded in the evidence below.
           async closeAllMemorySearchManagers() {
           }
         };
-        const remnicMemoryFlushPlanResolver = () => {
-          const maxTurnChars = typeof cfg.extractionMaxTurnChars === "number" && Number.isFinite(cfg.extractionMaxTurnChars) ? Math.max(1e3, Math.floor(cfg.extractionMaxTurnChars)) : 8e3;
-          const flushModel = typeof cfg.summaryModel === "string" && cfg.summaryModel.length > 0 ? cfg.summaryModel : cfg.taskModelChain?.primary;
-          return {
-            softThresholdTokens: 24e3,
-            forceFlushTranscriptBytes: Math.max(16384, maxTurnChars * 4),
-            reserveTokensFloor: 2e3,
-            ...flushModel ? { model: flushModel } : {},
-            prompt: "Flush the recent OpenClaw transcript into Remnic memory by appending to the allowed flush-plan file only. Preserve durable user preferences, project facts, decisions, corrections, and commitments. Ignore runtime metadata, credentials, and transient command noise.",
-            systemPrompt: "You are Remnic's memory flush planner. Read the transcript and append concise durable memory notes to the file the write tool allows. Do not create files, directories, or dated paths; use only the allowed flush-plan file. Ignore runtime metadata, credentials, transient command noise, and content that is not worth remembering.",
-            relativePath: ["state", "plugins", serviceId, "flush-plan.md"].join("/")
-          };
-        };
+        const remnicMemoryFlushPlanResolver = () => buildMemoryFlushPlan({
+          serviceId,
+          extractionMaxTurnChars: cfg.extractionMaxTurnChars,
+          // `summaryModel` already resolves explicit summary/base model →
+          // gateway task-chain primary → "" (gateway mode).
+          flushModel: typeof cfg.summaryModel === "string" && cfg.summaryModel.length > 0 ? cfg.summaryModel : cfg.taskModelChain?.primary
+        });
         const memoryCapability = {
           // Include the promptBuilder so runtimes that treat unified capability
           // registration as authoritative (SDK >=2026.4.5) continue to inject
@@ -9454,7 +11084,7 @@ Keep the reflection grounded in the evidence below.
                   `session reset via API for ${sessionKey}, new sessionId=${result.sessionId}`
                 );
                 const safeSessionKey = sanitizeSessionKeyForFilename(sessionKey);
-                const signalPath = path6.join(
+                const signalPath = path10.join(
                   workspaceDir,
                   `.compaction-reset-signal-${safeSessionKey}`
                 );
@@ -9673,7 +11303,7 @@ Keep the reflection grounded in the evidence below.
     }
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path6.join(
+      const cronFilePath = path10.join(
         os.homedir(),
         ".openclaw",
         "cron",
@@ -9732,32 +11362,32 @@ Keep the reflection grounded in the evidence below.
       };
       const normalizeCorpusPath = (value) => value.trim().replace(/\\/g, "/").replace(/^\.\//, "");
       const pathIsInside = (root, candidate) => {
-        const relative = path6.relative(root, candidate);
-        return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
+        const relative = path10.relative(root, candidate);
+        return relative === "" || !relative.startsWith("..") && !path10.isAbsolute(relative);
       };
       const corpusPathCandidates = (rawPath, storageDir) => {
         const candidates = /* @__PURE__ */ new Set();
         const trimmed = rawPath.trim();
         if (!trimmed) return [];
         candidates.add(normalizeCorpusPath(trimmed));
-        if (path6.isAbsolute(trimmed)) {
-          const absolutePath = path6.resolve(trimmed);
-          const absoluteStorageDir = path6.resolve(storageDir);
+        if (path10.isAbsolute(trimmed)) {
+          const absolutePath = path10.resolve(trimmed);
+          const absoluteStorageDir = path10.resolve(storageDir);
           if (pathIsInside(absoluteStorageDir, absolutePath)) {
-            candidates.add(normalizeCorpusPath(path6.relative(absoluteStorageDir, absolutePath)));
+            candidates.add(normalizeCorpusPath(path10.relative(absoluteStorageDir, absolutePath)));
           }
         }
-        candidates.add(path6.basename(trimmed));
+        candidates.add(path10.basename(trimmed));
         return [...candidates].filter((candidate) => candidate.length > 0);
       };
       const displayCorpusPath = (rawPath, storageDir) => {
         const trimmed = rawPath.trim();
         if (!trimmed) return "";
-        if (path6.isAbsolute(trimmed)) {
-          const absolutePath = path6.resolve(trimmed);
-          const absoluteStorageDir = path6.resolve(storageDir);
+        if (path10.isAbsolute(trimmed)) {
+          const absolutePath = path10.resolve(trimmed);
+          const absoluteStorageDir = path10.resolve(storageDir);
           if (pathIsInside(absoluteStorageDir, absolutePath)) {
-            return normalizeCorpusPath(path6.relative(absoluteStorageDir, absolutePath));
+            return normalizeCorpusPath(path10.relative(absoluteStorageDir, absolutePath));
           }
         }
         return normalizeCorpusPath(trimmed);
@@ -10267,9 +11897,9 @@ function truncateMetadataValue(value, maxChars) {
   return value.length <= maxChars ? value : value.slice(0, maxChars);
 }
 async function resolveFlushPlanProcessingChainKey(workspaceRoot) {
-  const lexicalRoot = path6.resolve(workspaceRoot);
+  const lexicalRoot = path10.resolve(workspaceRoot);
   try {
-    return path6.resolve(await realPathLater(lexicalRoot));
+    return path10.resolve(await realPathLater(lexicalRoot));
   } catch {
     return lexicalRoot;
   }
@@ -10280,12 +11910,15 @@ export {
   checkDaemonHealth,
   src_default as default,
   detectBridgeMode,
+  detectDaemonBridgeMode,
   embedWithOpenClawProvider,
   listRemnicPublicArtifacts,
   export_loadDaySummaryPrompt as loadDaySummaryPrompt,
   loadHourlySummaryCronJobsData,
   loadOpenClawMemoryEmbeddingSdk,
   parseHourlySummaryCronJobsData,
+  readDaemonMemoryDirSync,
   reconcileHourlySummaryCronRouting,
+  resolveBridgeMode,
   selectOpenClawMemoryEmbeddingSdk
 };