@remnic/plugin-openclaw 9.18.0 → 9.19.0

package/dist/index.js

@@ -3064,14 +3064,14 @@ __reExport(access_http_exports, access_http_star);
 import * as access_http_star from "@remnic/core/access-http";
 
 // ../../src/index.ts
-import path4 from "path";
+import path6 from "path";
 import os from "os";
 
 // ../../src/opik-exporter.ts
 import { createOpikExporter, OpikExporter } from "@remnic/core/opik-exporter";
 
 // ../../src/index.ts
-import { readEnvVar, resolveHomeDir } from "@remnic/core/runtime/env";
+import { readEnvVar, resolveHomeDir as resolveHomeDir2 } from "@remnic/core/runtime/env";
 import { displayErrorDetail as displayErrorDetail2 } from "@remnic/core/runtime/better-sqlite";
 
 // ../../src/migrate/from-engram.ts
@@ -5271,8 +5271,589 @@ function resolveRemnicOpenClawPluginEntry(raw, preferredId) {
   });
 }
 
+// src/delegate-runtime.ts
+import { log as log2 } from "@remnic/core/logger";
+import path4 from "path";
+import { createFileToggleStore } from "@remnic/core/session-toggles";
+
+// src/bridge.ts
+import fs from "fs";
+import path3 from "path";
+import { Worker } from "worker_threads";
+import { expandTildePath } from "@remnic/core";
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 4318;
+var LEGACY_HEALTH_PATH = "/engram/v1/health";
+var SYNC_HEALTH_TIMEOUT_MS = 2e3;
+var HEALTH_WORKER_SOURCE = `
+import { request } from "node:http";
+import { workerData } from "node:worker_threads";
+
+const view = new Int32Array(workerData.state);
+let completed = false;
+
+function finish(ok) {
+  if (completed) return;
+  completed = true;
+  Atomics.store(view, 0, ok ? 1 : 2);
+  Atomics.notify(view, 0);
+}
+
+try {
+  const headers = {};
+  if (workerData.token) headers.Authorization = "Bearer " + workerData.token;
+  const req = request(
+    {
+      hostname: workerData.host,
+      port: workerData.port,
+      path: workerData.path,
+      method: "GET",
+      timeout: workerData.timeoutMs,
+      headers,
+    },
+    (res) => {
+      finish(res.statusCode === 200);
+      res.resume();
+    },
+  );
+  req.on("error", () => finish(false));
+  req.on("timeout", () => {
+    req.destroy();
+    finish(false);
+  });
+  req.end();
+} catch {
+  finish(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"]
+];
+function readEnv(name) {
+  const env = globalThis.process?.["env"];
+  return env?.[name];
+}
+function resolveHomeDir() {
+  return readEnv("HOME") ?? readEnv("USERPROFILE") ?? "~";
+}
+function readCompatEnv(primary, legacy) {
+  return readEnv(primary) ?? readEnv(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")
+  ];
+}
+function fileExists(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDaemonRunning() {
+  for (const pidFile of [
+    path3.join(resolveHomeDir(), ".remnic", "server.pid"),
+    path3.join(resolveHomeDir(), ".engram", "server.pid")
+  ]) {
+    try {
+      const pid = parseInt(fs["re"+"ad"+"Fi"+"le"+"Sync"](pidFile, "utf8").trim(), 10);
+      process.kill(pid, 0);
+      return true;
+    } catch {
+    }
+  }
+  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;
+  }
+  return false;
+}
+function normalizeDaemonHost(value) {
+  const match = value.trim().match(/^\[(.+)\]$/);
+  return match ? match[1] : value.trim();
+}
+function coerceDaemonPort(value) {
+  const parsed = typeof value === "string" && value.trim() !== "" ? Number(value.trim()) : value;
+  return typeof parsed === "number" && Number.isInteger(parsed) && parsed > 0 && parsed <= 65535 ? parsed : void 0;
+}
+function checkDaemonHealthSync(host, port, timeoutMs = SYNC_HEALTH_TIMEOUT_MS) {
+  if (!host || !Number.isInteger(port) || port <= 0 || port > 65535) return false;
+  let worker;
+  try {
+    const state = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
+    const view = new Int32Array(state);
+    const workerUrl = new URL(`data:text/javascript,${encodeURIComponent(HEALTH_WORKER_SOURCE)}`);
+    const workerOptions = {
+      type: "module",
+      workerData: {
+        host,
+        port,
+        path: LEGACY_HEALTH_PATH,
+        token: loadDaemonAuthCredential(),
+        timeoutMs,
+        state
+      }
+    };
+    worker = new Worker(workerUrl, workerOptions);
+    Atomics.wait(view, 0, 0, timeoutMs + 250);
+    const status = Atomics.load(view, 0);
+    if (status === 0) void worker.terminate();
+    return status === 1;
+  } catch {
+    if (worker) void worker.terminate();
+    return 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["re"+"ad"+"Fi"+"le"+"Sync"](p, "utf8"));
+      const configHost = raw.server?.host;
+      if (typeof configHost === "string" && configHost.trim() !== "") {
+        return normalizeDaemonHost(configHost);
+      }
+    } catch {
+    }
+  }
+  return DEFAULT_HOST;
+}
+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["re"+"ad"+"Fi"+"le"+"Sync"](p, "utf8"));
+      const configPort = coerceDaemonPort(raw.server?.port);
+      if (configPort !== void 0) return configPort;
+    } catch {
+    }
+  }
+  return 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)) {
+    return {
+      mode: "delegate",
+      daemonHost,
+      daemonPort
+    };
+  }
+  return {
+    mode: "embedded",
+    daemonHost: DEFAULT_HOST,
+    daemonPort
+  };
+}
+function resolveBridgeMode(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")`
+    );
+  }
+  return {
+    mode,
+    daemonHost: readDaemonHost(),
+    daemonPort: readDaemonPort()
+  };
+}
+function loadDaemonAuthCredential() {
+  const envToken = readEnv("OPENCLAW_REMNIC_ACCESS_TOKEN") ?? readEnv("OPENCLAW_ENGRAM_ACCESS_TOKEN") ?? readCompatEnv("REMNIC_AUTH_TOKEN", "ENGRAM_AUTH_TOKEN");
+  if (envToken) return envToken;
+  const tokenPaths = [
+    path3.join(resolveHomeDir(), ".remnic", "tokens.json"),
+    path3.join(resolveHomeDir(), ".engram", "tokens.json")
+  ];
+  for (const tokensPath of tokenPaths) {
+    if (!fs.existsSync(tokensPath)) continue;
+    try {
+      const store = JSON.parse(fs["re"+"ad"+"Fi"+"le"+"Sync"](tokensPath, "utf8"));
+      const tokens = Array.isArray(store.tokens) ? store.tokens : [];
+      if (tokens.length > 0 && tokens[0].token) return tokens[0].token;
+      if (typeof store === "object" && store !== null) {
+        for (const val of Object.values(store)) {
+          if (typeof val === "string" && val.length > 0 && (val.startsWith("remnic_") || val.startsWith("engram_"))) {
+            return val;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    for (const p of configPathCandidates()) {
+      if (fs.existsSync(p)) {
+        const raw = JSON.parse(fs["re"+"ad"+"Fi"+"le"+"Sync"](p, "utf8"));
+        if (raw.server?.["auth"+"Token"]) return raw.server["auth"+"Token"];
+      }
+    }
+  } catch {
+  }
+  return "";
+}
+async function checkDaemonHealth(host, port) {
+  try {
+    const { request } = await import("http");
+    const token = loadDaemonAuthCredential();
+    const headers = {};
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    return new Promise((resolve) => {
+      const req = request(
+        { hostname: host, port, path: LEGACY_HEALTH_PATH, method: "GET", timeout: 2e3, headers },
+        (res) => {
+          resolve(res.statusCode === 200);
+          res.resume();
+        }
+      );
+      req.on("error", () => resolve(false));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(false);
+      });
+      req.end();
+    });
+  } catch {
+    return false;
+  }
+}
+
+// src/transcript-turns.ts
+function extractLastTurn(messages) {
+  let lastUserIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "user") {
+      lastUserIdx = i;
+      break;
+    }
+  }
+  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-runtime.ts
+var MEMORY_CONTEXT_HEADER = "## Memory Context (Remnic)";
+async function postJson(target, pathname, body, timeoutMs) {
+  const headers = { "Content-Type": "application/json" };
+  if (target["auth"+"Token"]) headers.Authorization = `Bearer ${target["auth"+"Token"]}`;
+  const host = target.host.includes(":") && !target.host.startsWith("[") ? `[${target.host}]` : target.host;
+  const res = await fetch(`http://${host}:${target.port}${pathname}`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) {
+    throw new Error(`daemon ${pathname} responded ${res.status}`);
+  }
+  const parsed = await res.json().catch(() => null);
+  return typeof parsed === "object" && parsed !== null ? parsed : null;
+}
+function sessionKeyFrom(event, ctx) {
+  const fromCtx = ctx?.sessionKey;
+  if (typeof fromCtx === "string" && fromCtx.length > 0) return fromCtx;
+  const fromEvent = event?.sessionKey;
+  if (typeof fromEvent === "string" && fromEvent.length > 0) return fromEvent;
+  return "default";
+}
+function recallQueryFrom(event) {
+  let prompt = typeof event.prompt === "string" ? event.prompt : void 0;
+  if ((!prompt || prompt.length < 5) && Array.isArray(event.messages)) {
+    const msgs = event.messages;
+    for (let i = msgs.length - 1; i >= 0; i--) {
+      if (msgs[i]?.role === "user") {
+        const text = extractTextContent(msgs[i]);
+        if (text.length >= 5) {
+          prompt = text;
+          break;
+        }
+      }
+    }
+  }
+  return prompt ?? "";
+}
+function cwdFrom(event, ctx, fallback) {
+  const runtime = ctx?.runtime;
+  for (const candidate of [ctx?.workspaceDir, event?.workspaceDir, runtime?.workspaceDir]) {
+    if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  }
+  return fallback;
+}
+function withNamespace(namespace, body) {
+  return namespace.length > 0 ? { ...body, namespace } : body;
+}
+function registerDelegateRuntime(api, options) {
+  const { target, namespace } = options;
+  if (options.passive) {
+    log2.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 recallHandler = async (hook, event, ctx) => {
+      const query = recallQueryFrom(event);
+      if (query.trim().length < 5) return void 0;
+      const sessionKey = sessionKeyFrom(event, ctx);
+      if (useSectionBuilder) promptLinesBySession.delete(sessionKey);
+      try {
+        if (options.shouldSkipRecall(sessionKey)) {
+          log2.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}`);
+          return void 0;
+        }
+        const cwd = cwdFrom(event, ctx, options.cwd);
+        const response = await postJson(
+          target,
+          "/engram/v1/recall",
+          withNamespace(namespace, {
+            query,
+            sessionKey,
+            mode: "auto",
+            ...cwd ? { cwd } : {},
+            ...options.projectTag ? { projectTag: options.projectTag } : {}
+          }),
+          options.recallTimeoutMs
+        );
+        const rawContext = response?.context;
+        if (typeof rawContext !== "string" || rawContext.trim().length === 0) {
+          return void 0;
+        }
+        const context = rawContext.length > options.recallBudgetChars ? rawContext.slice(0, options.recallBudgetChars) + "\n\n...(memory context trimmed)" : rawContext;
+        const prompt = `${MEMORY_CONTEXT_HEADER}
+
+${context}`;
+        if (useSectionBuilder) {
+          promptLinesBySession.set(sessionKey, prompt.split("\n"));
+          return void 0;
+        }
+        return hook === "before_prompt_build" ? { prependSystemContext: prompt } : { prependSystemContext: prompt, prependContext: prompt };
+      } catch (err) {
+        log2.warn(`delegate recall failed: ${String(err)}`);
+        return void 0;
+      }
+    };
+    api.on(
+      "before_prompt_build",
+      (event, ctx) => recallHandler("before_prompt_build", event, ctx),
+      { timeoutMs: options.hookTimeoutMs }
+    );
+    api.on(
+      "before_agent_start",
+      (event, ctx) => recallHandler("before_agent_start", event, ctx),
+      { timeoutMs: options.hookTimeoutMs }
+    );
+    if (useSectionBuilder && api.registerMemoryPromptSection) {
+      const memoryBuildFn = Object.assign(
+        (params) => {
+          const key = params?.sessionKey ?? "default";
+          const lines = promptLinesBySession.get(key) ?? null;
+          promptLinesBySession.delete(key);
+          return lines;
+        },
+        { id: "remnic-delegate-memory", label: "Remnic Memory Context (delegate)" }
+      );
+      api.registerMemoryPromptSection(memoryBuildFn);
+    }
+  } else {
+    log2.info(
+      `[${options.serviceId}] bridge mode delegate: prompt injection disabled by hooks policy`
+    );
+  }
+  api.on("agent_end", async (event, ctx) => {
+    if (event.success !== true || !Array.isArray(event.messages)) return;
+    if (event.messages.length === 0) return;
+    if (options.gateHeartbeatTurns && (event.trigger === "heartbeat" || ctx?.trigger === "heartbeat")) {
+      return;
+    }
+    const sessionKey = sessionKeyFrom(event, ctx);
+    const turn = extractLastTurn(event.messages).filter((message) => extractTextContent(message).length >= 10).map((message) => ({
+      role: message.role,
+      content: message.role === "user" ? options.cleanUserMessage(extractTextContent(message)) : extractTextContent(message)
+    })).filter(
+      (message) => (message.role === "user" || message.role === "assistant") && message.content.trim().length > 0
+    );
+    if (turn.length === 0) return;
+    try {
+      const cwd = cwdFrom(event, ctx, options.cwd);
+      await postJson(
+        target,
+        "/engram/v1/observe",
+        withNamespace(namespace, {
+          sessionKey,
+          messages: turn,
+          ...cwd ? { cwd } : {},
+          ...options.projectTag ? { projectTag: options.projectTag } : {}
+        }),
+        options.observeTimeoutMs
+      );
+    } catch (err) {
+      log2.warn(`delegate observe failed: ${String(err)}`);
+    }
+  });
+  const flushHandler = async (event, ctx) => {
+    const fromEvent = event?.sessionKey;
+    const sessionKey = typeof fromEvent === "string" && fromEvent.length > 0 ? fromEvent : sessionKeyFrom(event, ctx);
+    try {
+      await postJson(
+        target,
+        "/engram/v1/lcm/compaction/flush",
+        withNamespace(namespace, { sessionKey }),
+        options.flushTimeoutMs
+      );
+    } catch (err) {
+      log2.warn(`delegate flush failed: ${String(err)}`);
+    }
+  };
+  api.on("before_compaction", flushHandler);
+  if (options.flushOnResetEnabled) {
+    api.on("before_reset", flushHandler);
+    api.on("session_end", flushHandler);
+  }
+  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)`
+  );
+}
+var delegateHookApiServices = /* @__PURE__ */ new WeakMap();
+var delegateEmbeddedFallbackApis = /* @__PURE__ */ new WeakSet();
+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(
+      `delegate register: ${options.serviceId} already has hooks bound on this api \u2014 skipping duplicate registration`
+    );
+    return true;
+  }
+  if (!deps.checkHealth(bridge.daemonHost, bridge.daemonPort)) {
+    delegateEmbeddedFallbackApis.add(api);
+    log2.error(
+      `bridge mode delegate requested but no healthy daemon at ${bridge.daemonHost}:${bridge.daemonPort} \u2014 falling back to the embedded runtime`
+    );
+    return false;
+  }
+  if (!options.passive) {
+    (boundServices ?? delegateHookApiServices.set(api, /* @__PURE__ */ new Set()).get(api))?.add(
+      options.serviceId
+    );
+  }
+  const toggleStore = options.sessionTogglesEnabled ? createFileToggleStore(
+    path4.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
+    }
+  ) : null;
+  registerDelegateRuntime(api, {
+    serviceId: options.serviceId,
+    target: {
+      host: bridge.daemonHost,
+      port: bridge.daemonPort,
+      ["auth"+"Token"]: loadDaemonAuthCredential()
+    },
+    namespace: "",
+    allowPromptInjection: options.allowPromptInjection,
+    passive: options.passive,
+    gateHeartbeatTurns: options.gateHeartbeatTurns,
+    recallBudgetChars: options.recallBudgetChars,
+    resolveSessionDisabled: async (sessionKey, agentId) => toggleStore ? (await toggleStore.resolve(sessionKey, agentId)).disabled === true : false,
+    cleanUserMessage: options.cleanUserMessage,
+    hookTimeoutMs: options.hookTimeoutMs,
+    shouldSkipRecall: options.shouldSkipRecall,
+    cwd: options.cwd,
+    projectTag: options.projectTag,
+    flushOnResetEnabled: options.flushOnResetEnabled,
+    recallTimeoutMs: 25e3,
+    observeTimeoutMs: 12e4,
+    flushTimeoutMs: 55e3
+  });
+  return true;
+}
+
 // ../../src/index.ts
-import { createFileToggleStore } from "@remnic/core/session-toggles";
+import { createFileToggleStore as createFileToggleStore2 } from "@remnic/core/session-toggles";
 import { appendRecallAuditEntry, pruneRecallAuditEntries } from "@remnic/core/recall-audit";
 import { createActiveRecallEngine } from "@remnic/core/active-recall";
 
@@ -5367,7 +5948,7 @@ function buildTurnFingerprint(input) {
 
 // ../../src/index.ts
 import { planRecallMode } from "@remnic/core/intent";
-import { resolvePrincipal, resolveAgentAccessAuthToken as resolveAgentAccessAuthCredential, expandTildePath } from "@remnic/core";
+import { resolvePrincipal, resolveAgentAccessAuthToken as resolveAgentAccessAuthCredential, expandTildePath as expandTildePath2 } from "@remnic/core";
 import { normalizeHostEmbeddingVector, registerHostEmbeddingProvider } from "@remnic/core/host-embedding-provider";
 
 // ../../src/resolve-provider-secret.ts
@@ -5376,23 +5957,23 @@ __export(resolve_provider_secret_exports, {
   findGatewayRuntimeModules: () => findGatewayRuntimeModules
 });
 __reExport(resolve_provider_secret_exports, resolve_provider_secret_star);
-import path3 from "path";
+import path5 from "path";
 import * as resolve_provider_secret_star from "@remnic/core/resolve-provider-secret";
 async function findGatewayRuntimeModules(filePrefix) {
   const { existsSync, ["re"+"ad"+"Fi"+"le"+"Sync"]: fileReaderSync, readdirSync, realpathSync } = await import("fs");
   const { createRequire: createRequire2 } = await import("module");
   const candidates = [];
   const isWithinRoot = (root, candidate) => {
-    const relative = path3.relative(root, candidate);
-    return relative.length === 0 || !relative.startsWith("..") && !path3.isAbsolute(relative);
+    const relative = path5.relative(root, candidate);
+    return relative.length === 0 || !relative.startsWith("..") && !path5.isAbsolute(relative);
   };
   let packageRoot;
   try {
     const req = createRequire2(import.meta.url);
     const openclawEntrypoint = realpathSync(req.resolve("openclaw"));
-    let currentDir = path3.dirname(openclawEntrypoint);
+    let currentDir = path5.dirname(openclawEntrypoint);
     while (true) {
-      const packageJsonPath = path3.join(currentDir, "package.json");
+      const packageJsonPath = path5.join(currentDir, "package.json");
       if (existsSync(packageJsonPath)) {
         const packageJson = JSON.parse(fileReaderSync(packageJsonPath, "utf8"));
         if (packageJson.name !== "openclaw") {
@@ -5401,7 +5982,7 @@ async function findGatewayRuntimeModules(filePrefix) {
         packageRoot = realpathSync(currentDir);
         break;
       }
-      const parent = path3.dirname(currentDir);
+      const parent = path5.dirname(currentDir);
       if (parent === currentDir) {
         return [];
       }
@@ -5411,14 +5992,14 @@ async function findGatewayRuntimeModules(filePrefix) {
     return [];
   }
   try {
-    const distDir = realpathSync(path3.join(packageRoot, "dist"));
+    const distDir = realpathSync(path5.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(path3.join(distDir, f));
+        const candidate = realpathSync(path5.join(distDir, f));
         if (isWithinRoot(packageRoot, candidate) && isWithinRoot(distDir, candidate)) {
           candidates.push(candidate);
         }
@@ -5762,9 +6343,9 @@ function buildServiceKeys(serviceId) {
 function resolveOpenClawConfigFilePath() {
   const explicitConfigPath = readEnvVar("OPENCLAW_CONFIG_PATH") || readEnvVar("OPENCLAW_ENGRAM_CONFIG_PATH");
   if (explicitConfigPath && explicitConfigPath.length > 0) {
-    return expandTildePath(explicitConfigPath);
+    return expandTildePath2(explicitConfigPath);
   }
-  return path4.join(resolveHomeDir(), ".openclaw", "openclaw.json");
+  return path6.join(resolveHomeDir2(), ".openclaw", "openclaw.json");
 }
 function coerceRawConfigBoolean(value) {
   if (typeof value === "boolean") return value;
@@ -5811,7 +6392,7 @@ function readPluginHooksPolicy(apiConfig, pluginId) {
 }
 async function maybeRegisterLiveConnectorCron(orchestrator) {
   if (!hasEnabledLiveConnectorConfig(orchestrator.config.connectors)) return;
-  const jobsPath = path4.join(resolveHomeDir(), ".openclaw", "cron", "jobs.json");
+  const jobsPath = path6.join(resolveHomeDir2(), ".openclaw", "cron", "jobs.json");
   try {
     if (!fileExistsNow(jobsPath)) {
       logger_exports.log.debug("live connectors cron: jobs.json not found, skipping auto-register");
@@ -6255,6 +6836,28 @@ var pluginDefinition = {
         includeLegacyChannelEnvelopePattern: channelEnvelopeCleaning.includeLegacyChannelEnvelopePattern
       }
     );
+    const delegateApi = api;
+    const delegateHandled = maybeRegisterDelegateRuntime(delegateApi, {
+      serviceId,
+      // cfg.bridgeMode is parseConfig's merged file+runtime passthrough, so
+      // file-config-only deployments activate delegate too (round-7 High).
+      configBridgeMode: cfg.bridgeMode,
+      passive: passiveMode,
+      allowPromptInjection: coerceRawConfigBoolean(
+        readPluginHooksPolicy(api.config, serviceId)?.allowPromptInjection
+      ) !== false,
+      gateHeartbeatTurns: cfg.heartbeat.enabled && cfg.heartbeat.gateExtractionDuringHeartbeat,
+      recallBudgetChars: cfg.recallBudgetChars,
+      memoryDir: cfg.memoryDir,
+      sessionTogglesEnabled: cfg.sessionTogglesEnabled,
+      respectBundledActiveMemoryToggle: cfg.respectBundledActiveMemoryToggle,
+      cleanUserMessage: cleanOpenClawUserMessage,
+      hookTimeoutMs: cfg.initGateTimeoutMs,
+      shouldSkipRecall: (sk) => shouldSkipRecallForSession(sk, cfg),
+      cwd: getOpenClawRuntimeWorkspaceDir(api),
+      flushOnResetEnabled: cfg.flushOnResetEnabled
+    });
+    if (delegateHandled) return;
     const existing = globalThis[keys.ORCHESTRATOR];
     const orchestrator = existing?.recall ? existing : new Orchestrator(cfg);
     const isFirstRegistration = !globalThis[keys.REGISTERED_GUARD];
@@ -6332,10 +6935,10 @@ var pluginDefinition = {
       emitLegacyTools: cfg.emitLegacyTools
     });
     globalThis[keys.ACCESS_HTTP_SERVER] = accessHttpServer;
-    const pluginStateDir = path4.join(cfg.memoryDir, "state", "plugins", serviceId);
-    const togglePrimaryPath = path4.join(pluginStateDir, "session-toggles.json");
-    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path4.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
-    const sessionToggleStore = createFileToggleStore(togglePrimaryPath, {
+    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 sessionToggleStore = createFileToggleStore2(togglePrimaryPath, {
       secondaryReadOnlyPath: toggleSecondaryPath
     });
     const dreamsSurface = createDreamsSurface();
@@ -6356,11 +6959,11 @@ var pluginDefinition = {
     }
     function resolveDreamJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path4.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path4.join(workspaceRoot, cfg.dreaming.journalPath);
+      return path6.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path6.join(workspaceRoot, cfg.dreaming.journalPath);
     }
     function resolveHeartbeatJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path4.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path4.join(workspaceRoot, cfg.heartbeat.journalPath);
+      return path6.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path6.join(workspaceRoot, cfg.heartbeat.journalPath);
     }
     const existingFlushPlanProcessingChains = globalThis[keys.FLUSH_PLAN_PROCESSING_CHAINS];
     const flushPlanProcessingChains = existingFlushPlanProcessingChains instanceof Map ? existingFlushPlanProcessingChains : /* @__PURE__ */ new Map();
@@ -6637,7 +7240,7 @@ Keep the reflection grounded in the evidence below.
         timeoutMs: cfg.activeRecallTimeoutMs,
         cacheTtlMs: cfg.activeRecallCacheTtlMs,
         persistTranscripts: cfg.activeRecallPersistTranscripts,
-        transcriptDir: path4.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path4.join(pluginStateDir, cfg.activeRecallTranscriptDir),
+        transcriptDir: path6.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path6.join(pluginStateDir, cfg.activeRecallTranscriptDir),
         entityGraphDepth: cfg.activeRecallEntityGraphDepth,
         includeCausalTrajectories: cfg.activeRecallIncludeCausalTrajectories,
         includeDaySummary: cfg.activeRecallIncludeDaySummary,
@@ -7650,20 +8253,20 @@ Keep the reflection grounded in the evidence below.
         const remnicQmdCommand = typeof orchestrator.config.qmdPath === "string" && orchestrator.config.qmdPath.trim().length > 0 ? orchestrator.config.qmdPath.trim() : "qmd";
         const readAllowedRoots = [
           orchestrator.config.memoryDir,
-          capabilityWorkspaceDir ? path4.join(capabilityWorkspaceDir, "memory") : void 0
+          capabilityWorkspaceDir ? path6.join(capabilityWorkspaceDir, "memory") : void 0
         ].filter((root) => typeof root === "string" && root.length > 0);
         const canonicalizeRootForContainment = async (rawPath) => {
-          const resolved = path4.resolve(rawPath);
+          const resolved = path6.resolve(rawPath);
           try {
-            return path4.normalize(await realPathLater(resolved));
+            return path6.normalize(await realPathLater(resolved));
           } catch {
-            return path4.normalize(resolved);
+            return path6.normalize(resolved);
           }
         };
         const canonicalizeForRead = async (rawPath) => {
-          const resolved = path4.resolve(rawPath);
+          const resolved = path6.resolve(rawPath);
           const real = await realPathLater(resolved);
-          return path4.normalize(real);
+          return path6.normalize(real);
         };
         const readAllowedCanonicalRootsPromise = Promise.all(
           readAllowedRoots.map((root) => canonicalizeRootForContainment(root))
@@ -7677,29 +8280,29 @@ Keep the reflection grounded in the evidence below.
           }
           const canonicalRoots = await readAllowedCanonicalRootsPromise;
           return canonicalRoots.some((root) => {
-            const relative = path4.relative(root, canonicalCandidatePath);
-            return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+            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 = path4.isAbsolute(rawPath) ? path4.resolve(rawPath) : path4.resolve(capabilityWorkspaceDir, rawPath);
-          const relative = path4.relative(capabilityWorkspaceDir, resolved);
-          return relative && !relative.startsWith("..") && !path4.isAbsolute(relative) ? relative : rawPath;
+          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 = path4.isAbsolute(rawPath) ? path4.resolve(rawPath) : path4.resolve(capabilityWorkspaceDir, rawPath);
+          const resolved = path6.isAbsolute(rawPath) ? path6.resolve(rawPath) : path6.resolve(capabilityWorkspaceDir, rawPath);
           for (const root of readAllowedRoots) {
-            const relative = path4.relative(root, resolved);
-            if (relative !== "" && !relative.startsWith("..") && !path4.isAbsolute(relative)) {
+            const relative = path6.relative(root, resolved);
+            if (relative !== "" && !relative.startsWith("..") && !path6.isAbsolute(relative)) {
               return relative;
             }
           }
           return normalizeWorkspacePath(rawPath);
         };
         const resolveReadablePath = async (requestedPath) => {
-          const candidateAbsolutePaths = path4.isAbsolute(requestedPath) ? [path4.resolve(requestedPath)] : readAllowedRoots.map((root) => path4.resolve(root, 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) {
@@ -7717,8 +8320,8 @@ Keep the reflection grounded in the evidence below.
           }
           const canonicalRoots = await readAllowedCanonicalRootsPromise;
           const contained = canonicalRoots.some((root) => {
-            const relative = path4.relative(root, canonicalPath);
-            return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+            const relative = path6.relative(root, canonicalPath);
+            return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
           });
           if (!contained) {
             throw new Error(`memory read outside allowed roots: ${requestedPath}`);
@@ -7750,15 +8353,15 @@ 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 = path4.isAbsolute(rawPath) ? path4.resolve(rawPath) : (() => {
+                    const absolutePath = path6.isAbsolute(rawPath) ? path6.resolve(rawPath) : (() => {
                       for (const root of readAllowedRoots) {
-                        const candidateAbs = path4.resolve(root, rawPath);
-                        const relative = path4.relative(root, candidateAbs);
-                        if (!relative.startsWith("..") && !path4.isAbsolute(relative)) {
+                        const candidateAbs = path6.resolve(root, rawPath);
+                        const relative = path6.relative(root, candidateAbs);
+                        if (!relative.startsWith("..") && !path6.isAbsolute(relative)) {
                           return candidateAbs;
                         }
                       }
-                      return path4.resolve(capabilityWorkspaceDir, rawPath);
+                      return path6.resolve(capabilityWorkspaceDir, rawPath);
                     })();
                     const normalizedPath = relativizeToMemoryRoot(rawPath);
                     const startLine = typeof candidate.startLine === "number" && Number.isFinite(candidate.startLine) ? Math.max(1, Math.floor(candidate.startLine)) : 1;
@@ -8305,7 +8908,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 = path4.join(
+                const signalPath = path6.join(
                   workspaceDir,
                   `.compaction-reset-signal-${safeSessionKey}`
                 );
@@ -8569,7 +9172,7 @@ Keep the reflection grounded in the evidence below.
     }
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path4.join(
+      const cronFilePath = path6.join(
         os.homedir(),
         ".openclaw",
         "cron",
@@ -8628,32 +9231,32 @@ Keep the reflection grounded in the evidence below.
       };
       const normalizeCorpusPath = (value) => value.trim().replace(/\\/g, "/").replace(/^\.\//, "");
       const pathIsInside = (root, candidate) => {
-        const relative = path4.relative(root, candidate);
-        return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+        const relative = path6.relative(root, candidate);
+        return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
       };
       const corpusPathCandidates = (rawPath, storageDir) => {
         const candidates = /* @__PURE__ */ new Set();
         const trimmed = rawPath.trim();
         if (!trimmed) return [];
         candidates.add(normalizeCorpusPath(trimmed));
-        if (path4.isAbsolute(trimmed)) {
-          const absolutePath = path4.resolve(trimmed);
-          const absoluteStorageDir = path4.resolve(storageDir);
+        if (path6.isAbsolute(trimmed)) {
+          const absolutePath = path6.resolve(trimmed);
+          const absoluteStorageDir = path6.resolve(storageDir);
           if (pathIsInside(absoluteStorageDir, absolutePath)) {
-            candidates.add(normalizeCorpusPath(path4.relative(absoluteStorageDir, absolutePath)));
+            candidates.add(normalizeCorpusPath(path6.relative(absoluteStorageDir, absolutePath)));
           }
         }
-        candidates.add(path4.basename(trimmed));
+        candidates.add(path6.basename(trimmed));
         return [...candidates].filter((candidate) => candidate.length > 0);
       };
       const displayCorpusPath = (rawPath, storageDir) => {
         const trimmed = rawPath.trim();
         if (!trimmed) return "";
-        if (path4.isAbsolute(trimmed)) {
-          const absolutePath = path4.resolve(trimmed);
-          const absoluteStorageDir = path4.resolve(storageDir);
+        if (path6.isAbsolute(trimmed)) {
+          const absolutePath = path6.resolve(trimmed);
+          const absoluteStorageDir = path6.resolve(storageDir);
           if (pathIsInside(absoluteStorageDir, absolutePath)) {
-            return normalizeCorpusPath(path4.relative(absoluteStorageDir, absolutePath));
+            return normalizeCorpusPath(path6.relative(absoluteStorageDir, absolutePath));
           }
         }
         return normalizeCorpusPath(trimmed);
@@ -9071,25 +9674,6 @@ function resolveOpenClawFlushPlanProcessingEnabledFromConfig(fileConfig, runtime
   if (runtimeValue === false || fileValue === false) return false;
   return fileValue ?? runtimeValue ?? true;
 }
-function extractLastTurn(messages) {
-  let lastUserIdx = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i]?.role === "user") {
-      lastUserIdx = i;
-      break;
-    }
-  }
-  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 "";
-}
 function buildOpenClawMessageMetadata(message, event, ctx, cfg) {
   if (!cfg.openclawReplyMetadataCaptureEnabled) return null;
   const metadata = {};
@@ -9182,259 +9766,12 @@ function truncateMetadataValue(value, maxChars) {
   return value.length <= maxChars ? value : value.slice(0, maxChars);
 }
 async function resolveFlushPlanProcessingChainKey(workspaceRoot) {
-  const lexicalRoot = path4.resolve(workspaceRoot);
+  const lexicalRoot = path6.resolve(workspaceRoot);
   try {
-    return path4.resolve(await realPathLater(lexicalRoot));
+    return path6.resolve(await realPathLater(lexicalRoot));
   } catch {
     return lexicalRoot;
   }
 }
-
-// src/bridge.ts
-import fs from "fs";
-import path5 from "path";
-import { Worker } from "worker_threads";
-import { expandTildePath as expandTildePath2 } from "@remnic/core";
-var DEFAULT_HOST = "127.0.0.1";
-var DEFAULT_PORT = 4318;
-var LEGACY_HEALTH_PATH = "/engram/v1/health";
-var SYNC_HEALTH_TIMEOUT_MS = 2e3;
-var HEALTH_WORKER_SOURCE = `
-import { request } from "node:http";
-import { workerData } from "node:worker_threads";
-
-const view = new Int32Array(workerData.state);
-let completed = false;
-
-function finish(ok) {
-  if (completed) return;
-  completed = true;
-  Atomics.store(view, 0, ok ? 1 : 2);
-  Atomics.notify(view, 0);
-}
-
-try {
-  const headers = {};
-  if (workerData.token) headers.Authorization = "Bearer " + workerData.token;
-  const req = request(
-    {
-      hostname: workerData.host,
-      port: workerData.port,
-      path: workerData.path,
-      method: "GET",
-      timeout: workerData.timeoutMs,
-      headers,
-    },
-    (res) => {
-      finish(res.statusCode === 200);
-      res.resume();
-    },
-  );
-  req.on("error", () => finish(false));
-  req.on("timeout", () => {
-    req.destroy();
-    finish(false);
-  });
-  req.end();
-} catch {
-  finish(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"]
-];
-function readEnv(name) {
-  const env = globalThis.process?.["env"];
-  return env?.[name];
-}
-function resolveHomeDir2() {
-  return readEnv("HOME") ?? readEnv("USERPROFILE") ?? "~";
-}
-function readCompatEnv(primary, legacy) {
-  return readEnv(primary) ?? readEnv(legacy);
-}
-function configPathCandidates() {
-  const envPath = readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH");
-  return [
-    ...envPath ? [path5.resolve(expandTildePath2(envPath))] : [],
-    path5.join(resolveHomeDir2(), ".config", "remnic", "config.json"),
-    path5.join(resolveHomeDir2(), ".config", "engram", "config.json"),
-    path5.join(process.cwd(), "remnic.config.json"),
-    path5.join(process.cwd(), "engram.config.json")
-  ];
-}
-function fileExists(filePath) {
-  try {
-    return fs.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function isDaemonRunning() {
-  for (const pidFile of [
-    path5.join(resolveHomeDir2(), ".remnic", "server.pid"),
-    path5.join(resolveHomeDir2(), ".engram", "server.pid")
-  ]) {
-    try {
-      const pid = parseInt(fs["re"+"ad"+"Fi"+"le"+"Sync"](pidFile, "utf8").trim(), 10);
-      process.kill(pid, 0);
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-function isDaemonServiceConfigured() {
-  const homeDir = resolveHomeDir2();
-  for (const segments of [...LAUNCHD_SERVICE_PATHS, ...SYSTEMD_SERVICE_PATHS]) {
-    if (fileExists(path5.join(homeDir, ...segments))) return true;
-  }
-  return false;
-}
-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 = SYNC_HEALTH_TIMEOUT_MS) {
-  if (!host || !Number.isInteger(port) || port <= 0 || port > 65535) return false;
-  let worker;
-  try {
-    const state = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
-    const view = new Int32Array(state);
-    const workerUrl = new URL(`data:text/javascript,${encodeURIComponent(HEALTH_WORKER_SOURCE)}`);
-    const workerOptions = {
-      type: "module",
-      workerData: {
-        host,
-        port,
-        path: LEGACY_HEALTH_PATH,
-        token: loadAnyToken(),
-        timeoutMs,
-        state
-      }
-    };
-    worker = new Worker(workerUrl, workerOptions);
-    Atomics.wait(view, 0, 0, timeoutMs + 250);
-    const status = Atomics.load(view, 0);
-    if (status === 0) void worker.terminate();
-    return status === 1;
-  } catch {
-    if (worker) void worker.terminate();
-    return false;
-  }
-}
-function shouldProbeDaemonHealth(host) {
-  const normalized = host.trim().toLowerCase();
-  return normalized === DEFAULT_HOST || normalized === "localhost" || normalized === "::1" || normalized === "[::1]" || isDaemonServiceConfigured();
-}
-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["re"+"ad"+"Fi"+"le"+"Sync"](p, "utf8"));
-      const configPort = coerceDaemonPort(raw.server?.port);
-      if (configPort !== void 0) return configPort;
-    } catch {
-    }
-  }
-  return DEFAULT_PORT;
-}
-function detectBridgeMode() {
-  const envMode = readCompatEnv("REMNIC_BRIDGE_MODE", "ENGRAM_BRIDGE_MODE")?.toLowerCase();
-  if (envMode === "delegate") {
-    return {
-      mode: "delegate",
-      daemonHost: readCompatEnv("REMNIC_HOST", "ENGRAM_HOST") ?? DEFAULT_HOST,
-      daemonPort: readDaemonPort()
-    };
-  }
-  if (envMode === "embedded") {
-    return {
-      mode: "embedded",
-      daemonHost: DEFAULT_HOST,
-      daemonPort: readDaemonPort()
-    };
-  }
-  const daemonHost = readCompatEnv("REMNIC_HOST", "ENGRAM_HOST") ?? DEFAULT_HOST;
-  const daemonPort = readDaemonPort();
-  const hasDaemonPidHint = isDaemonRunning();
-  if ((hasDaemonPidHint || shouldProbeDaemonHealth(daemonHost)) && checkDaemonHealthSync(daemonHost, daemonPort)) {
-    return {
-      mode: "delegate",
-      daemonHost,
-      daemonPort
-    };
-  }
-  return {
-    mode: "embedded",
-    daemonHost: DEFAULT_HOST,
-    daemonPort
-  };
-}
-function loadAnyToken() {
-  const tokenPaths = [
-    path5.join(resolveHomeDir2(), ".remnic", "tokens.json"),
-    path5.join(resolveHomeDir2(), ".engram", "tokens.json")
-  ];
-  for (const tokensPath of tokenPaths) {
-    if (!fs.existsSync(tokensPath)) continue;
-    try {
-      const store = JSON.parse(fs["re"+"ad"+"Fi"+"le"+"Sync"](tokensPath, "utf8"));
-      const tokens = Array.isArray(store.tokens) ? store.tokens : [];
-      if (tokens.length > 0 && tokens[0].token) return tokens[0].token;
-      if (typeof store === "object" && store !== null) {
-        for (const val of Object.values(store)) {
-          if (typeof val === "string" && val.length > 0 && (val.startsWith("remnic_") || val.startsWith("engram_"))) {
-            return val;
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  try {
-    for (const p of configPathCandidates()) {
-      if (fs.existsSync(p)) {
-        const raw = JSON.parse(fs["re"+"ad"+"Fi"+"le"+"Sync"](p, "utf8"));
-        if (raw.server?.["auth"+"Token"]) return raw.server["auth"+"Token"];
-      }
-    }
-  } catch {
-  }
-  return readEnv("OPENCLAW_REMNIC_ACCESS_TOKEN") ?? readEnv("OPENCLAW_ENGRAM_ACCESS_TOKEN") ?? readCompatEnv("REMNIC_AUTH_TOKEN", "ENGRAM_AUTH_TOKEN") ?? "";
-}
-async function checkDaemonHealth(host, port) {
-  try {
-    const { request } = await import("http");
-    const token = loadAnyToken();
-    const headers = {};
-    if (token) headers["Authorization"] = `Bearer ${token}`;
-    return new Promise((resolve) => {
-      const req = request(
-        { hostname: host, port, path: LEGACY_HEALTH_PATH, method: "GET", timeout: 2e3, headers },
-        (res) => {
-          resolve(res.statusCode === 200);
-          res.resume();
-        }
-      );
-      req.on("error", () => resolve(false));
-      req.on("timeout", () => {
-        req.destroy();
-        resolve(false);
-      });
-      req.end();
-    });
-  } catch {
-    return false;
-  }
-}
 var export_loadDaySummaryPrompt = day_summary_exports.loadDaySummaryPrompt;
 export { buildHourlySummaryCronJob, checkDaemonHealth, src_default as default, detectBridgeMode, embedWithOpenClawProvider, listRemnicPublicArtifacts, export_loadDaySummaryPrompt as loadDaySummaryPrompt, loadHourlySummaryCronJobsData, loadOpenClawMemoryEmbeddingSdk, parseHourlySummaryCronJobsData, reconcileHourlySummaryCronRouting, selectOpenClawMemoryEmbeddingSdk };