@phronesis-io/openclaw-eigenflux 0.0.8 → 0.0.9

package/dist/index.js

@@ -1,520 +1,2328 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const polling_client_1 = require("./polling-client");
-const stream_client_1 = require("./stream-client");
-const cli_executor_1 = require("./cli-executor");
-const logger_1 = require("./logger");
-const credentials_loader_1 = require("./credentials-loader");
-const config_1 = require("./config");
-const notification_route_resolver_1 = require("./notification-route-resolver");
-const agent_prompt_templates_1 = require("./agent-prompt-templates");
-const notifier_1 = require("./notifier");
-const reply_target_1 = require("./reply-target");
-const session_route_memory_1 = require("./session-route-memory");
-const COMMAND_NAMES = ['auth', 'profile', 'servers', 'feed', 'pm', 'here', 'version'];
-const COMMAND_NAME_SET = new Set(COMMAND_NAMES);
-const DEFAULT_ROUTING = {
-    sessionKey: config_1.PLUGIN_CONFIG.DEFAULT_SESSION_KEY,
-    agentId: config_1.PLUGIN_CONFIG.DEFAULT_AGENT_ID,
-    routeOverrides: {
-        sessionKey: false,
-        agentId: false,
-        replyChannel: false,
-        replyTo: false,
-        replyAccountId: false,
-    },
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-function register(api) {
-    const logger = new logger_1.Logger(resolvePluginLogger(api));
-    const pluginConfig = (0, config_1.resolvePluginConfig)(api.pluginConfig, logger);
-    const eigenfluxHome = (0, config_1.resolveEigenfluxHome)();
-    let runtimes = [];
-    let notInstalledPromptDelivered = false;
-    // Register a single meta-service that discovers servers on start
-    api.registerService({
-        id: 'eigenflux:discovery',
-        start: async () => {
-            logger.info('Starting EigenFlux discovery service...');
-            const discovery = await (0, config_1.discoverServers)(pluginConfig.eigenfluxBin, logger);
-            if (discovery.kind === 'not_installed') {
-                logger.warn(`EigenFlux CLI not installed (bin=${discovery.bin}); delivering install prompt to user`);
-                if (!notInstalledPromptDelivered) {
-                    notInstalledPromptDelivered = true;
-                    await deliverNotInstalledPrompt(api, logger, pluginConfig, eigenfluxHome, discovery.bin);
-                }
-                return;
-            }
-            const servers = discovery.servers;
-            if (servers.length === 0) {
-                logger.warn('No EigenFlux servers discovered; services will not start');
-                return;
-            }
-            logger.info(`Discovered ${servers.length} server(s): ${servers.map((s) => s.name).join(', ')}`);
-            runtimes = servers.map((server) => createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome));
-            for (const runtime of runtimes) {
-                logger.info(`Starting services for server=${runtime.server.name}`);
-                await runtime.feedPoller.start();
-                await runtime.streamClient.start();
-            }
-        },
-        stop: async () => {
-            logger.info('Stopping EigenFlux discovery service...');
-            for (const runtime of runtimes) {
-                logger.info(`Stopping services for server=${runtime.server.name}`);
-                runtime.feedPoller.stop();
-                await runtime.streamClient.stop();
-            }
-            runtimes = [];
-            notInstalledPromptDelivered = false;
-        },
-    });
-    registerCommand(api, logger, pluginConfig, eigenfluxHome, () => runtimes, (next) => {
-        runtimes = next;
-    });
-}
-function resolvePluginLogger(api) {
-    const runtimeLogging = api.runtime?.logging;
-    if (runtimeLogging && typeof runtimeLogging.getChildLogger === 'function') {
-        try {
-            const child = runtimeLogging.getChildLogger({ plugin: 'eigenflux' });
-            if (child) {
-                return child;
-            }
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_plugin_entry = require("openclaw/plugin-sdk/plugin-entry");
+
+// src/cli-executor.ts
+var import_child_process = require("child_process");
+var EXIT_AUTH_REQUIRED = 4;
+var DEFAULT_TIMEOUT_MS = 3e4;
+function execEigenflux(bin, args, options) {
+  const timeout = options?.timeout ?? DEFAULT_TIMEOUT_MS;
+  const logger = options?.logger;
+  return new Promise((resolve) => {
+    logger?.debug(`execEigenflux: ${bin} ${args.join(" ")}`);
+    (0, import_child_process.execFile)(
+      bin,
+      args,
+      {
+        timeout,
+        maxBuffer: 10 * 1024 * 1024,
+        encoding: "utf-8",
+        ...options?.cwd ? { cwd: options.cwd } : {}
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          const exitCode = error.code;
+          if (exitCode === "ENOENT") {
+            logger?.warn(`execEigenflux: binary not found: ${bin}`);
+            resolve({ kind: "not_installed", bin });
+            return;
+          }
+          const numericExit = typeof exitCode === "number" ? exitCode : error.killed ? null : error.status ?? null;
+          if (numericExit === EXIT_AUTH_REQUIRED) {
+            logger?.warn(`execEigenflux auth required: ${stderr.trim()}`);
+            resolve({ kind: "auth_required", stderr: stderr.trim() });
+            return;
+          }
+          logger?.error(`execEigenflux failed (exit=${numericExit}): ${stderr.trim() || error.message}`);
+          resolve({
+            kind: "error",
+            error: new Error(stderr.trim() || error.message),
+            exitCode: numericExit,
+            stderr: stderr.trim()
+          });
+          return;
+        }
+        const trimmed = stdout.trim();
+        if (!trimmed) {
+          resolve({
+            kind: "success",
+            data: void 0
+          });
+          return;
         }
-        catch {
-            // fall through to api.logger
+        if (options?.parseJson === false) {
+          resolve({ kind: "success", data: trimmed });
+          return;
         }
+        try {
+          const data = JSON.parse(trimmed);
+          resolve({ kind: "success", data });
+        } catch (parseError) {
+          logger?.error(`execEigenflux JSON parse error: ${parseError.message}`);
+          resolve({
+            kind: "error",
+            error: new Error(`Failed to parse CLI output: ${parseError.message}`),
+            exitCode: 0,
+            stderr: ""
+          });
+        }
+      }
+    );
+  });
+}
+
+// src/polling-client.ts
+var POLL_INTERVAL_CONFIG_KEY = "feed_poll_interval";
+var DEFAULT_POLL_INTERVAL_SEC = 600;
+var MIN_POLL_INTERVAL_SEC = 10;
+var MAX_POLL_INTERVAL_SEC = 24 * 60 * 60;
+async function readPollIntervalSec(eigenfluxBin, serverName, logger) {
+  const result = await execEigenflux(
+    eigenfluxBin,
+    ["config", "get", "--key", POLL_INTERVAL_CONFIG_KEY, "--server", serverName, "--format", "json"],
+    { logger }
+  );
+  if (result.kind !== "success" || result.data === void 0 || result.data === null) {
+    return DEFAULT_POLL_INTERVAL_SEC;
+  }
+  let numeric;
+  if (typeof result.data === "number" && Number.isFinite(result.data)) {
+    numeric = result.data;
+  } else if (typeof result.data === "string") {
+    const parsed = Number(result.data.trim());
+    if (Number.isFinite(parsed)) {
+      numeric = parsed;
     }
-    return api.logger;
+  }
+  if (numeric === void 0) {
+    logger.warn(
+      `Ignoring non-numeric pollInterval from eigenflux config (server=${serverName}, value=${JSON.stringify(result.data)}); using ${DEFAULT_POLL_INTERVAL_SEC}s`
+    );
+    return DEFAULT_POLL_INTERVAL_SEC;
+  }
+  const floored = Math.floor(numeric);
+  if (floored < MIN_POLL_INTERVAL_SEC || floored > MAX_POLL_INTERVAL_SEC) {
+    logger.warn(
+      `pollInterval ${floored}s from eigenflux config (server=${serverName}) is outside [${MIN_POLL_INTERVAL_SEC}s, ${MAX_POLL_INTERVAL_SEC}s]; using ${DEFAULT_POLL_INTERVAL_SEC}s`
+    );
+    return DEFAULT_POLL_INTERVAL_SEC;
+  }
+  return floored;
 }
-const plugin = {
-    id: 'openclaw-eigenflux',
-    name: 'EigenFlux',
-    description: 'OpenClaw extension for EigenFlux with CLI-based feed polling and PM streaming',
-    configSchema: config_1.PLUGIN_CONFIG_SCHEMA,
-    register,
+var EigenFluxPollingClient = class {
+  constructor(config) {
+    this.timeoutId = null;
+    this.isRunning = false;
+    this.activePoll = null;
+    this.config = config;
+  }
+  async start() {
+    if (this.isRunning) {
+      this.config.logger.warn("Polling client already running");
+      return;
+    }
+    this.isRunning = true;
+    this.config.logger.info(
+      `Starting polling client for server=${this.config.serverName}`
+    );
+    await this.pollOnce();
+    this.scheduleNext();
+  }
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.config.logger.info(`Stopping polling client for server=${this.config.serverName}`);
+    this.isRunning = false;
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+  async scheduleNext() {
+    if (!this.isRunning) {
+      return;
+    }
+    let intervalSec;
+    try {
+      intervalSec = await this.config.resolvePollIntervalSec();
+    } catch (error) {
+      this.config.logger.warn(
+        `Failed to resolve pollInterval for server=${this.config.serverName}: ${error instanceof Error ? error.message : String(error)}; using ${DEFAULT_POLL_INTERVAL_SEC}s`
+      );
+      intervalSec = DEFAULT_POLL_INTERVAL_SEC;
+    }
+    if (!this.isRunning) {
+      return;
+    }
+    this.config.logger.debug(
+      `Scheduling next feed poll for server=${this.config.serverName} in ${intervalSec}s`
+    );
+    this.timeoutId = setTimeout(() => {
+      this.timeoutId = null;
+      this.pollOnce().catch((err) => {
+        this.config.logger.error(
+          `Polling error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }).finally(() => {
+        this.scheduleNext();
+      });
+    }, intervalSec * 1e3);
+  }
+  async pollOnce(options = {}) {
+    if (this.activePoll) {
+      this.config.logger.warn("Skipping feed poll because a previous poll is still in progress");
+      return this.activePoll;
+    }
+    const run = async () => {
+      const notifyFeed = options.notifyFeed ?? true;
+      const notifyAuthRequired = options.notifyAuthRequired ?? true;
+      try {
+        this.config.logger.info(`Polling feed via CLI for server=${this.config.serverName}`);
+        const result = await execEigenflux(
+          this.config.eigenfluxBin,
+          ["feed", "poll", "--limit", "20", "--action", "refresh", "-s", this.config.serverName, "-f", "json"],
+          { logger: this.config.logger }
+        );
+        if (result.kind === "auth_required") {
+          const authEvent = { reason: "auth_required" };
+          if (notifyAuthRequired) {
+            await this.config.onAuthRequired(authEvent);
+          }
+          return { kind: "auth_required", authEvent };
+        }
+        if (result.kind === "not_installed") {
+          return {
+            kind: "error",
+            error: new Error(`eigenflux CLI not installed (bin=${result.bin})`)
+          };
+        }
+        if (result.kind === "error") {
+          return { kind: "error", error: result.error };
+        }
+        const feedResponse = {
+          code: 0,
+          msg: "success",
+          data: result.data
+        };
+        const items = feedResponse.data.items ?? [];
+        const notifications = feedResponse.data.notifications ?? [];
+        this.config.logger.info(
+          `Polled feed: ${items.length} items, notifications=${notifications.length}, has_more=${feedResponse.data.has_more}`
+        );
+        if (notifyFeed && (items.length > 0 || notifications.length > 0)) {
+          await this.config.onFeedPolled(feedResponse);
+        }
+        return { kind: "success", payload: feedResponse };
+      } catch (error) {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        this.config.logger.error(
+          `Failed to poll feed for server=${this.config.serverName}: ${normalized.message}`
+        );
+        return { kind: "error", error: normalized };
+      }
+    };
+    this.activePoll = run().finally(() => {
+      this.activePoll = null;
+    });
+    return this.activePoll;
+  }
 };
-exports.default = plugin;
-const INSTALL_COMMAND = 'curl -fsSL https://eigenflux.ai/install.sh | bash';
-async function deliverNotInstalledPrompt(api, logger, pluginConfig, _eigenfluxHome, bin) {
-    // Intentionally no workdir: the bootstrap notifier must not read or persist
-    // any remembered session route under <eigenfluxHome>/bootstrap.
-    const notifier = new notifier_1.EigenFluxNotifier(api, logger, {
-        sessionKey: DEFAULT_ROUTING.sessionKey,
-        agentId: DEFAULT_ROUTING.agentId,
-        replyChannel: DEFAULT_ROUTING.replyChannel,
-        replyTo: DEFAULT_ROUTING.replyTo,
-        replyAccountId: DEFAULT_ROUTING.replyAccountId,
-        openclawCliBin: pluginConfig.openclawCliBin,
-        routeOverrides: DEFAULT_ROUTING.routeOverrides,
+
+// src/stream-client.ts
+var import_child_process2 = require("child_process");
+var import_readline = require("readline");
+var EXIT_AUTH_REQUIRED2 = 4;
+var INITIAL_BACKOFF_MS = 1e3;
+var MAX_BACKOFF_MS = 6e4;
+var BACKOFF_MULTIPLIER = 2;
+var STOP_GRACE_MS = 5e3;
+var MAX_CONSECUTIVE_FAILURES = 20;
+var EigenFluxStreamClient = class {
+  constructor(config) {
+    this.child = null;
+    this.readline = null;
+    this.stopping = false;
+    this.running = false;
+    this.lastCursor = null;
+    this.backoffMs = INITIAL_BACKOFF_MS;
+    this.consecutiveFailures = 0;
+    this.restartTimer = null;
+    this.config = config;
+  }
+  isRunning() {
+    return this.running;
+  }
+  getLastCursor() {
+    return this.lastCursor;
+  }
+  async start() {
+    if (this.running) {
+      this.config.logger.warn("Stream client already running");
+      return;
+    }
+    this.running = true;
+    this.stopping = false;
+    this.config.logger.info(`Starting stream client for server=${this.config.serverName}`);
+    this.spawnStreamProcess();
+  }
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    this.config.logger.info(`Stopping stream client for server=${this.config.serverName}`);
+    this.stopping = true;
+    this.running = false;
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = null;
+    }
+    if (this.readline) {
+      this.readline.close();
+      this.readline = null;
+    }
+    if (this.child) {
+      const child = this.child;
+      this.child = null;
+      child.kill("SIGTERM");
+      await new Promise((resolve) => {
+        const forceKillTimer = setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+          resolve();
+        }, STOP_GRACE_MS);
+        child.once("exit", () => {
+          clearTimeout(forceKillTimer);
+          resolve();
+        });
+      });
+    }
+  }
+  spawnStreamProcess() {
+    if (this.stopping || !this.running) {
+      return;
+    }
+    const args = ["stream", "-s", this.config.serverName, "-f", "json"];
+    if (this.lastCursor) {
+      args.push("--cursor", this.lastCursor);
+    }
+    this.config.logger.info(
+      `Spawning: ${this.config.eigenfluxBin} ${args.join(" ")}`
+    );
+    const child = (0, import_child_process2.spawn)(this.config.eigenfluxBin, args, {
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    await notifier.deliver((0, agent_prompt_templates_1.buildNotInstalledPromptTemplate)({ bin, installCommand: INSTALL_COMMAND }));
-}
-function createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome) {
-    const routing = pluginConfig.serverRouting[server.name] ?? DEFAULT_ROUTING;
-    const credentialsLoader = new credentials_loader_1.CredentialsLoader(logger, eigenfluxHome, server.name);
-    const notifier = new notifier_1.EigenFluxNotifier(api, logger, {
-        eigenfluxBin: pluginConfig.eigenfluxBin,
-        serverName: server.name,
-        sessionKey: routing.sessionKey,
-        agentId: routing.agentId,
-        replyChannel: routing.replyChannel,
-        replyTo: routing.replyTo,
-        replyAccountId: routing.replyAccountId,
-        openclawCliBin: pluginConfig.openclawCliBin,
-        routeOverrides: routing.routeOverrides,
+    this.child = child;
+    const rl = (0, import_readline.createInterface)({ input: child.stdout });
+    this.readline = rl;
+    rl.on("line", (line) => {
+      this.handleLine(line);
     });
-    const getPromptContext = () => ({
-        serverName: server.name,
-        eigenfluxHome,
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text) {
+        this.config.logger.debug(`[stream stderr] ${text}`);
+      }
     });
-    let lastAuthPromptKey = null;
-    const resetAuthPromptGate = () => {
-        lastAuthPromptKey = null;
-    };
-    const notifyAuthRequired = async (authEvent) => {
-        const promptKey = `auth_required:${server.name}`;
-        if (lastAuthPromptKey === promptKey) {
-            logger.debug(`Skipping duplicate auth prompt for server=${server.name}`);
-            return;
-        }
-        lastAuthPromptKey = promptKey;
-        await notifier.deliver((0, agent_prompt_templates_1.buildAuthRequiredPromptTemplate)({ context: getPromptContext() }));
-    };
-    const feedPoller = new polling_client_1.EigenFluxPollingClient({
-        serverName: server.name,
-        eigenfluxBin: pluginConfig.eigenfluxBin,
-        resolvePollIntervalSec: () => (0, polling_client_1.readPollIntervalSec)(pluginConfig.eigenfluxBin, server.name, logger),
-        logger,
-        onFeedPolled: async (payload) => {
-            resetAuthPromptGate();
-            await notifier.deliver((0, agent_prompt_templates_1.buildFeedPayloadPromptTemplate)(payload, getPromptContext()));
-        },
-        onAuthRequired: notifyAuthRequired,
+    child.on("error", (err) => {
+      this.config.logger.error(`Stream process error: ${err.message}`);
+      this.config.onStreamError?.(err);
+      this.scheduleRestart();
     });
-    const streamClient = new stream_client_1.EigenFluxStreamClient({
-        serverName: server.name,
-        eigenfluxBin: pluginConfig.eigenfluxBin,
-        logger,
-        onPmEvent: async (event) => {
-            resetAuthPromptGate();
-            await notifier.deliver((0, agent_prompt_templates_1.buildPmStreamEventPromptTemplate)(event, getPromptContext()));
-        },
-        onAuthRequired: async () => {
-            await notifyAuthRequired({ reason: 'auth_required' });
-        },
+    child.on("exit", (code, signal) => {
+      this.config.logger.info(
+        `Stream process exited (code=${code}, signal=${signal})`
+      );
+      if (this.stopping) {
+        return;
+      }
+      if (code === EXIT_AUTH_REQUIRED2) {
+        this.config.logger.warn("Stream auth required");
+        this.config.onAuthRequired().then(() => {
+          this.scheduleRestart();
+        }).catch((err) => {
+          this.config.logger.error(`Auth required handler error: ${err instanceof Error ? err.message : String(err)}`);
+          this.scheduleRestart();
+        });
+        return;
+      }
+      this.scheduleRestart();
     });
+  }
+  handleLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return;
+    }
+    try {
+      const event = JSON.parse(trimmed);
+      if (event.data?.next_cursor) {
+        this.lastCursor = event.data.next_cursor;
+      }
+      this.backoffMs = INITIAL_BACKOFF_MS;
+      this.consecutiveFailures = 0;
+      this.config.onPmEvent(event).catch((err) => {
+        this.config.logger.error(
+          `PM event handler error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
+    } catch (err) {
+      this.config.logger.warn(
+        `Failed to parse stream line: ${err.message}`
+      );
+    }
+  }
+  scheduleRestart() {
+    if (this.stopping || !this.running) {
+      return;
+    }
+    this.consecutiveFailures += 1;
+    if (this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+      this.config.logger.error(
+        `Stream client giving up after ${MAX_CONSECUTIVE_FAILURES} consecutive failures for server=${this.config.serverName}`
+      );
+      this.running = false;
+      return;
+    }
+    this.config.logger.info(
+      `Stream reconnecting in ${this.backoffMs}ms (failure #${this.consecutiveFailures}) for server=${this.config.serverName}`
+    );
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = null;
+      this.spawnStreamProcess();
+    }, this.backoffMs);
+    this.backoffMs = Math.min(
+      this.backoffMs * BACKOFF_MULTIPLIER,
+      MAX_BACKOFF_MS
+    );
+  }
+};
+
+// src/logger.ts
+var Logger = class {
+  constructor(baseLogger) {
+    this.baseLogger = baseLogger;
+  }
+  info(message, ...args) {
+    const formatted = args.length ? `[EigenFlux] ${message} ${args.map(String).join(" ")}` : `[EigenFlux] ${message}`;
+    this.baseLogger.info(formatted);
+  }
+  warn(message, ...args) {
+    const formatted = args.length ? `[EigenFlux] ${message} ${args.map(String).join(" ")}` : `[EigenFlux] ${message}`;
+    this.baseLogger.warn(formatted);
+  }
+  error(message, ...args) {
+    const formatted = args.length ? `[EigenFlux] ${message} ${args.map(String).join(" ")}` : `[EigenFlux] ${message}`;
+    this.baseLogger.error(formatted);
+  }
+  debug(message, ...args) {
+    this.baseLogger.debug?.(`[EigenFlux] ${message}`, ...args);
+  }
+};
+
+// src/credentials-loader.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var CredentialsLoader = class {
+  constructor(logger, eigenfluxHome, serverName) {
+    this.logger = logger;
+    this.credentialsDir = path.join(eigenfluxHome, "servers", serverName);
+    this.credentialsPath = path.join(this.credentialsDir, "credentials.json");
+  }
+  loadAccessToken() {
+    const authState = this.loadAuthState();
+    if (authState.status !== "available") {
+      if (authState.status === "missing") {
+        this.logger.error(`No access token found in ${authState.credentialsPath}`);
+      }
+      return null;
+    }
+    return authState.accessToken;
+  }
+  loadAuthState() {
+    if (fs.existsSync(this.credentialsPath)) {
+      try {
+        const content = fs.readFileSync(this.credentialsPath, "utf-8");
+        const credentials = JSON.parse(content);
+        if (credentials.access_token) {
+          if (credentials.expires_at) {
+            const now = Date.now();
+            if (now >= credentials.expires_at) {
+              this.logger.warn("Access token has expired");
+              return {
+                status: "expired",
+                credentialsPath: this.credentialsPath,
+                expiresAt: credentials.expires_at,
+                email: credentials.email
+              };
+            }
+          }
+          this.logger.info(`Loaded access token from ${this.credentialsPath}`);
+          return {
+            status: "available",
+            accessToken: credentials.access_token,
+            credentialsPath: this.credentialsPath,
+            expiresAt: credentials.expires_at,
+            email: credentials.email
+          };
+        }
+      } catch (error) {
+        this.logger.error(`Failed to read credentials file: ${this.credentialsPath}`, error);
+      }
+    }
     return {
-        server,
-        routing,
-        credentialsLoader,
-        notifier,
-        feedPoller,
-        streamClient,
-        getPromptContext,
+      status: "missing",
+      credentialsPath: this.credentialsPath
+    };
+  }
+  saveAccessToken(token, email, expiresAt) {
+    if (!fs.existsSync(this.credentialsDir)) {
+      fs.mkdirSync(this.credentialsDir, { recursive: true });
+    }
+    const credentials = {
+      access_token: token,
+      email,
+      expires_at: expiresAt
     };
+    try {
+      fs.writeFileSync(this.credentialsPath, JSON.stringify(credentials, null, 2), "utf-8");
+      this.logger.info(`Saved access token to ${this.credentialsPath}`);
+    } catch (error) {
+      this.logger.error("Failed to save credentials file", error);
+    }
+  }
+};
+
+// src/config.ts
+var os = __toESM(require("os"));
+var path2 = __toESM(require("path"));
+
+// src/reply-target.ts
+function readNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
 }
-// ─── Command Handler ────────────────────────────────────────────────────────
-function registerCommand(api, logger, pluginConfig, eigenfluxHome, getRuntimes, setRuntimes) {
-    if (!api.registerCommand) {
-        logger.warn('registerCommand API unavailable; skipping /eigenflux command registration');
-        return;
+function isNormalizedConversationTarget(value) {
+  return /^(user|chat|channel|room):/u.test(value);
+}
+function isSessionPeerShape(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized === "direct" || normalized === "dm" || normalized === "group" || normalized === "channel" || normalized === "room";
+}
+function supportsKindPrefixedTargets(channel) {
+  return channel === "feishu" || channel === "discord";
+}
+function parseSessionRoute(sessionKey) {
+  const trimmed = readNonEmptyString(sessionKey);
+  if (!trimmed) {
+    return {};
+  }
+  const parts = trimmed.split(":").filter((part) => part.length > 0);
+  if (parts[0]?.toLowerCase() !== "agent") {
+    return {};
+  }
+  const channel = readNonEmptyString(parts[2])?.toLowerCase();
+  const peerShapeRaw = parts.length >= 6 && isSessionPeerShape(parts[4]) ? parts[4].toLowerCase() : parts.length >= 5 && isSessionPeerShape(parts[3]) ? parts[3].toLowerCase() : void 0;
+  const peerShape = peerShapeRaw;
+  return { channel, peerShape };
+}
+function deriveReplyTargetKindFromSessionKey(sessionKey) {
+  const route = parseSessionRoute(sessionKey);
+  if (!supportsKindPrefixedTargets(route.channel)) {
+    return void 0;
+  }
+  switch (route.channel) {
+    case "feishu":
+      switch (route.peerShape) {
+        case "direct":
+        case "dm":
+          return "user";
+        case "group":
+          return "chat";
+        default:
+          return void 0;
+      }
+    case "discord":
+      switch (route.peerShape) {
+        case "direct":
+        case "dm":
+          return "user";
+        case "channel":
+          return "channel";
+        default:
+          return void 0;
+      }
+    default:
+      return void 0;
+  }
+}
+function deriveReplyTargetKindFromValue(value, channel) {
+  if (channel === "feishu") {
+    if (/^ou_/iu.test(value)) {
+      return "user";
     }
-    let inflightDiscovery = null;
-    const runDiscovery = async () => {
-        const discovery = await (0, config_1.discoverServers)(pluginConfig.eigenfluxBin, logger);
-        if (discovery.kind === 'not_installed') {
-            return { runtimes: getRuntimes(), notInstalledBin: discovery.bin };
-        }
-        if (discovery.servers.length === 0) {
-            return { runtimes: getRuntimes() };
-        }
-        const created = discovery.servers.map((server) => createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome));
-        setRuntimes(created);
-        return { runtimes: created };
+    if (/^oc_/iu.test(value)) {
+      return "chat";
+    }
+  }
+  return void 0;
+}
+function normalizeReplyTarget(value, options) {
+  const trimmed = readNonEmptyString(value);
+  if (!trimmed) {
+    return void 0;
+  }
+  if (isNormalizedConversationTarget(trimmed)) {
+    return trimmed;
+  }
+  const channel = readNonEmptyString(options?.channel)?.toLowerCase();
+  if (channel && trimmed.startsWith(`${channel}:`)) {
+    return normalizeReplyTarget(trimmed.slice(channel.length + 1), {
+      ...options,
+      channel
+    });
+  }
+  const fallbackKind = deriveReplyTargetKindFromValue(trimmed, channel) ?? (supportsKindPrefixedTargets(channel) ? options?.fallbackKind : void 0) ?? deriveReplyTargetKindFromSessionKey(options?.sessionKey);
+  return fallbackKind ? `${fallbackKind}:${trimmed}` : trimmed;
+}
+
+// src/config.ts
+var PLUGIN_VERSION = "0.0.9";
+var DEFAULT_EIGENFLUX_BIN = "eigenflux";
+var DEFAULT_SESSION_KEY = "main";
+var DEFAULT_AGENT_ID = "main";
+var DEFAULT_OPENCLAW_CLI_BIN = "openclaw";
+var HOST_KIND = "openclaw";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNonEmptyString2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function isSessionPeerShape2(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized === "direct" || normalized === "dm" || normalized === "group" || normalized === "channel";
+}
+function deriveNotificationRoute(sessionKey) {
+  const trimmed = readNonEmptyString2(sessionKey);
+  if (!trimmed) {
+    return {};
+  }
+  const parts = trimmed.split(":").filter((part) => part.length > 0);
+  if (parts.length < 3 || parts[0]?.toLowerCase() !== "agent") {
+    return {};
+  }
+  const agentId = readNonEmptyString2(parts[1]);
+  if (parts.length >= 6 && isSessionPeerShape2(parts[4])) {
+    return {
+      agentId,
+      replyChannel: readNonEmptyString2(parts[2]),
+      replyAccountId: readNonEmptyString2(parts[3]),
+      replyTo: normalizeReplyTarget(parts.slice(5).join(":"), {
+        channel: readNonEmptyString2(parts[2]),
+        sessionKey: trimmed
+      })
     };
-    const ensureRuntimes = async () => {
-        const existing = getRuntimes();
-        if (existing.length > 0) {
-            return { runtimes: existing };
-        }
-        if (!inflightDiscovery) {
-            inflightDiscovery = runDiscovery().finally(() => {
-                inflightDiscovery = null;
-            });
-        }
-        return inflightDiscovery;
+  }
+  if (parts.length >= 5 && isSessionPeerShape2(parts[3])) {
+    return {
+      agentId,
+      replyChannel: readNonEmptyString2(parts[2]),
+      replyTo: normalizeReplyTarget(parts.slice(4).join(":"), {
+        channel: readNonEmptyString2(parts[2]),
+        sessionKey: trimmed
+      })
     };
-    api.registerCommand({
-        name: 'eigenflux',
-        description: 'EigenFlux plugin commands: auth, profile, servers, feed, pm, here, version',
-        acceptsArgs: true,
-        handler: async (ctx) => {
-            const parsed = parseCommandArgs(ctx.args);
-            if (parsed.command === 'version') {
-                return {
-                    text: await buildVersionText(pluginConfig.eigenfluxBin),
-                };
-            }
-            const { runtimes, notInstalledBin } = await ensureRuntimes();
-            if (notInstalledBin && runtimes.length === 0) {
-                return {
-                    text: `EigenFlux CLI not installed (bin=${notInstalledBin}). Install with: ${INSTALL_COMMAND}`,
-                };
-            }
-            if (parsed.command === 'servers') {
-                return {
-                    text: buildServersText(runtimes),
-                };
-            }
-            const selection = selectServerRuntime(runtimes, parsed.serverName);
-            if (!selection.runtime) {
-                return {
-                    text: selection.error ?? buildHelpText(runtimes),
-                };
-            }
-            const runtime = selection.runtime;
-            await rememberCurrentCommandRouteIfPossible(ctx, runtime, pluginConfig.eigenfluxBin, logger);
-            switch (parsed.command) {
-                case 'auth':
-                    return {
-                        text: buildAuthStatusText(runtime),
-                    };
-                case 'profile':
-                    return {
-                        text: await buildProfileText(runtime, pluginConfig.eigenfluxBin),
-                    };
-                case 'feed':
-                    return {
-                        text: await buildFeedText(runtime),
-                    };
-                case 'pm':
-                    return {
-                        text: buildPmStatusText(runtime),
-                    };
-                case 'here':
-                    return {
-                        text: await buildHereText(ctx, runtime, pluginConfig.eigenfluxBin, logger),
-                    };
-                default:
-                    return {
-                        text: buildHelpText(runtimes),
-                    };
-            }
-        },
-    });
+  }
+  return { agentId };
 }
-function parseCommandArgs(args) {
-    const tokens = args?.trim().length ? args.trim().split(/\s+/u) : [];
-    let serverName;
-    const filtered = [];
-    for (let index = 0; index < tokens.length; index += 1) {
-        const token = tokens[index];
-        if ((token === '--server' || token === '-s') && tokens[index + 1]) {
-            serverName = tokens[index + 1];
-            index += 1;
-            continue;
+function createRouteOverrides(normalized) {
+  const sessionKey = readNonEmptyString2(normalized.sessionKey);
+  const agentId = readNonEmptyString2(normalized.agentId);
+  const replyChannel = readNonEmptyString2(normalized.replyChannel);
+  const replyTo = readNonEmptyString2(normalized.replyTo);
+  const replyAccountId = readNonEmptyString2(normalized.replyAccountId);
+  return {
+    sessionKey: sessionKey !== void 0 && sessionKey !== DEFAULT_SESSION_KEY,
+    agentId: agentId !== void 0 && agentId !== DEFAULT_AGENT_ID && !(sessionKey && deriveNotificationRoute(sessionKey).agentId === agentId),
+    replyChannel: replyChannel !== void 0,
+    replyTo: replyTo !== void 0,
+    replyAccountId: replyAccountId !== void 0
+  };
+}
+async function discoverServers(eigenfluxBin, logger) {
+  const result = await execEigenflux(
+    eigenfluxBin,
+    ["server", "list", "--format", "json"],
+    { logger }
+  );
+  if (result.kind === "success") {
+    if (Array.isArray(result.data)) {
+      return { kind: "ok", servers: result.data };
+    }
+    logger?.warn("eigenflux server list returned non-array data");
+    return { kind: "ok", servers: [] };
+  }
+  if (result.kind === "not_installed") {
+    return { kind: "not_installed", bin: result.bin };
+  }
+  if (result.kind === "auth_required") {
+    logger?.warn("eigenflux server list: auth required (unexpected)");
+    return { kind: "ok", servers: [] };
+  }
+  logger?.error(`eigenflux server list failed: ${result.error.message}`);
+  return { kind: "ok", servers: [] };
+}
+function resolveEigenfluxHome() {
+  const envHome = process.env.EIGENFLUX_HOME;
+  if (envHome) {
+    const expanded = expandHomeDir(envHome);
+    if (!expanded.endsWith(".eigenflux")) {
+      return path2.join(expanded, ".eigenflux");
+    }
+    return expanded;
+  }
+  return path2.join(os.homedir(), ".eigenflux");
+}
+function resolveRoutingConfig(raw, logger) {
+  const normalized = isRecord(raw) ? raw : {};
+  const sessionKey = readNonEmptyString2(normalized.sessionKey) ?? DEFAULT_SESSION_KEY;
+  const derivedRoute = deriveNotificationRoute(sessionKey);
+  const replyChannel = readNonEmptyString2(normalized.replyChannel) ?? derivedRoute.replyChannel;
+  const replyTo = normalizeReplyTarget(readNonEmptyString2(normalized.replyTo), {
+    channel: replyChannel,
+    sessionKey
+  }) ?? derivedRoute.replyTo;
+  return {
+    sessionKey,
+    agentId: readNonEmptyString2(normalized.agentId) ?? derivedRoute.agentId ?? DEFAULT_AGENT_ID,
+    replyChannel,
+    replyTo,
+    replyAccountId: readNonEmptyString2(normalized.replyAccountId) ?? derivedRoute.replyAccountId,
+    routeOverrides: createRouteOverrides(normalized)
+  };
+}
+function resolvePluginConfig(pluginConfig, logger) {
+  const normalized = isRecord(pluginConfig) ? pluginConfig : {};
+  const rawRouting = isRecord(normalized.serverRouting) ? normalized.serverRouting : {};
+  const serverRouting = {};
+  for (const [serverName, rawConfig] of Object.entries(rawRouting)) {
+    serverRouting[serverName] = resolveRoutingConfig(
+      isRecord(rawConfig) ? rawConfig : void 0,
+      logger
+    );
+  }
+  const rawSkills = Array.isArray(normalized.skills) ? normalized.skills.filter((s) => typeof s === "string" && s.trim().length > 0) : ["ef-broadcast", "ef-communication"];
+  return {
+    eigenfluxBin: readNonEmptyString2(normalized.eigenfluxBin) ?? DEFAULT_EIGENFLUX_BIN,
+    skills: rawSkills,
+    openclawCliBin: readNonEmptyString2(normalized.openclawCliBin) ?? DEFAULT_OPENCLAW_CLI_BIN,
+    serverRouting
+  };
+}
+function expandHomeDir(input) {
+  if (input === "~") {
+    return os.homedir();
+  }
+  if (input.startsWith("~/")) {
+    return path2.join(os.homedir(), input.slice(2));
+  }
+  return input;
+}
+var PLUGIN_CONFIG = {
+  DEFAULT_EIGENFLUX_BIN,
+  DEFAULT_SESSION_KEY,
+  DEFAULT_AGENT_ID,
+  DEFAULT_OPENCLAW_CLI_BIN,
+  HOST_KIND,
+  PLUGIN_VERSION
+};
+
+// src/notification-route-resolver.ts
+var fs2 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path3 = __toESM(require("path"));
+
+// src/session-route-memory.ts
+var DELIVER_SESSION_KEY_PREFIX = "deliver_session";
+function readNonEmptyString3(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeChannel(value) {
+  return readNonEmptyString3(value)?.toLowerCase();
+}
+function storeKey(serverName) {
+  return `${DELIVER_SESSION_KEY_PREFIX}:${serverName}`;
+}
+async function readStoredNotificationRoute(store, serverName, logger) {
+  const server = readNonEmptyString3(serverName);
+  if (!store || !server) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = await store.get(storeKey(server));
+  } catch (error) {
+    logger.debug(
+      `readStoredNotificationRoute: store.get failed for server=${server}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return void 0;
+  }
+  if (parsed === void 0 || parsed === null) {
+    return void 0;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return void 0;
+  }
+  const record = parsed;
+  const sessionKey = readNonEmptyString3(record.sessionKey);
+  const agentId = readNonEmptyString3(record.agentId);
+  if (!sessionKey || !agentId) {
+    logger.warn(
+      `Remembered route entry for server=${server} is incomplete (sessionKey/agentId missing)`
+    );
+    return void 0;
+  }
+  const route = {
+    sessionKey,
+    agentId,
+    replyChannel: normalizeChannel(record.replyChannel),
+    replyTo: normalizeReplyTarget(readNonEmptyString3(record.replyTo), {
+      channel: normalizeChannel(record.replyChannel),
+      sessionKey
+    }),
+    replyAccountId: readNonEmptyString3(record.replyAccountId),
+    updatedAt: typeof record.updatedAt === "number" && Number.isFinite(record.updatedAt) ? record.updatedAt : 0
+  };
+  logger.info(
+    `Remembered route loaded: server=${server}, session_key=${route.sessionKey}, agent_id=${route.agentId}, channel=${route.replyChannel ?? "n/a"}, to=${route.replyTo ?? "n/a"}, account=${route.replyAccountId ?? "n/a"}`
+  );
+  return route;
+}
+async function writeStoredNotificationRoute(store, serverName, route, logger) {
+  const server = readNonEmptyString3(serverName);
+  if (!store || !server) {
+    return false;
+  }
+  const normalized = {
+    sessionKey: route.sessionKey,
+    agentId: route.agentId,
+    replyChannel: normalizeChannel(route.replyChannel),
+    replyTo: normalizeReplyTarget(readNonEmptyString3(route.replyTo), {
+      channel: normalizeChannel(route.replyChannel),
+      sessionKey: route.sessionKey
+    }),
+    replyAccountId: readNonEmptyString3(route.replyAccountId)
+  };
+  const existing = await readStoredNotificationRoute(store, server, logger);
+  if (existing && existing.sessionKey === normalized.sessionKey && existing.agentId === normalized.agentId && existing.replyChannel === normalized.replyChannel && existing.replyTo === normalized.replyTo && existing.replyAccountId === normalized.replyAccountId) {
+    logger.debug(
+      `Remembered route unchanged for server=${server} (session_key=${normalized.sessionKey}); skipping write`
+    );
+    return true;
+  }
+  const payload = {
+    ...normalized,
+    updatedAt: Date.now()
+  };
+  try {
+    await store.set(storeKey(server), payload);
+  } catch (error) {
+    logger.warn(
+      `Failed to persist remembered session route via store.set (server=${server}): ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+  logger.info(
+    `Remembered route saved: server=${server}, session_key=${payload.sessionKey}, agent_id=${payload.agentId}, channel=${payload.replyChannel ?? "n/a"}, to=${payload.replyTo ?? "n/a"}, account=${payload.replyAccountId ?? "n/a"}`
+  );
+  return true;
+}
+
+// src/notification-route-resolver.ts
+var INTERNAL_CHANNELS = /* @__PURE__ */ new Set(["webchat"]);
+function getDefaultOpenClawStateDir() {
+  return path3.join(os2.homedir(), ".openclaw");
+}
+function readNonEmptyString4(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeChannel2(value) {
+  return readNonEmptyString4(value)?.toLowerCase();
+}
+function normalizeUpdatedAt(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  return 0;
+}
+function createRouteOverrides2(overrides) {
+  return {
+    sessionKey: overrides?.sessionKey === true,
+    agentId: overrides?.agentId === true,
+    replyChannel: overrides?.replyChannel === true,
+    replyTo: overrides?.replyTo === true,
+    replyAccountId: overrides?.replyAccountId === true
+  };
+}
+function isAnyRouteOverrideEnabled(overrides) {
+  return Object.values(overrides).some(Boolean);
+}
+function isInternalSessionKey(sessionKey) {
+  const trimmed = readNonEmptyString4(sessionKey);
+  if (!trimmed) {
+    return true;
+  }
+  const lower = trimmed.toLowerCase();
+  if (lower === "main" || lower === "heartbeat") {
+    return true;
+  }
+  const parts = lower.split(":").filter((part) => part.length > 0);
+  return parts[0] === "agent" && parts[2] === "heartbeat";
+}
+function isExternalChannel(channel) {
+  return Boolean(channel && !INTERNAL_CHANNELS.has(channel));
+}
+function isDirectSessionKey(sessionKey, entry) {
+  const parts = sessionKey.toLowerCase().split(":").filter(Boolean);
+  if (parts.includes("direct") || parts.includes("dm")) {
+    return true;
+  }
+  const chatType = readNonEmptyString4(entry.chatType)?.toLowerCase() ?? readNonEmptyString4(entry.origin?.chatType)?.toLowerCase();
+  if (chatType === "direct" || chatType === "dm") {
+    return true;
+  }
+  const toCandidates = [entry.deliveryContext?.to, entry.lastTo, entry.origin?.to];
+  return toCandidates.some((candidate) => {
+    const trimmed = readNonEmptyString4(candidate);
+    if (!trimmed) {
+      return false;
+    }
+    const colonAt = trimmed.indexOf(":");
+    if (colonAt <= 0) {
+      return false;
+    }
+    return trimmed.slice(0, colonAt).toLowerCase() === "user";
+  });
+}
+var GROUP_PEER_SHAPES = /* @__PURE__ */ new Set(["group", "channel", "room"]);
+var GROUP_TARGET_PREFIXES = /* @__PURE__ */ new Set(["chat", "channel", "room"]);
+function readChatTypeSignal(value) {
+  const normalized = readNonEmptyString4(value)?.toLowerCase();
+  return normalized && GROUP_PEER_SHAPES.has(normalized) ? normalized : void 0;
+}
+function readTargetPrefixSignal(value) {
+  const trimmed = readNonEmptyString4(value);
+  if (!trimmed) {
+    return void 0;
+  }
+  const colonAt = trimmed.indexOf(":");
+  if (colonAt <= 0) {
+    return void 0;
+  }
+  const prefix = trimmed.slice(0, colonAt).toLowerCase();
+  return GROUP_TARGET_PREFIXES.has(prefix) ? prefix : void 0;
+}
+function isGroupEntry(sessionKey, entry) {
+  const parts = sessionKey.toLowerCase().split(":").filter(Boolean);
+  if (parts.some((part) => GROUP_PEER_SHAPES.has(part))) {
+    return true;
+  }
+  if (readChatTypeSignal(entry.chatType) || readChatTypeSignal(entry.origin?.chatType)) {
+    return true;
+  }
+  const toCandidates = [entry.deliveryContext?.to, entry.lastTo, entry.origin?.to];
+  if (toCandidates.some((candidate) => readTargetPrefixSignal(candidate))) {
+    return true;
+  }
+  return false;
+}
+function isSessionPeerShape3(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized === "direct" || normalized === "dm" || normalized === "group" || normalized === "channel" || normalized === "room";
+}
+function routeTargetMatches(actual, expected) {
+  if (!expected) {
+    return true;
+  }
+  if (!actual) {
+    return false;
+  }
+  return actual === expected || actual.endsWith(`:${expected}`) || expected.endsWith(`:${actual}`);
+}
+function routeMatchesPreferred(route, preferred) {
+  if (!preferred) {
+    return true;
+  }
+  if (preferred.channel && route.replyChannel !== preferred.channel) {
+    return false;
+  }
+  if (!routeTargetMatches(route.replyTo, preferred.to)) {
+    return false;
+  }
+  if (preferred.accountId && route.replyAccountId !== preferred.accountId) {
+    return false;
+  }
+  return true;
+}
+function deriveAgentIdFromSessionKey(sessionKey) {
+  const trimmed = readNonEmptyString4(sessionKey);
+  if (!trimmed) {
+    return void 0;
+  }
+  const parts = trimmed.split(":").filter((part) => part.length > 0);
+  if (parts[0]?.toLowerCase() !== "agent") {
+    return void 0;
+  }
+  return readNonEmptyString4(parts[1]);
+}
+function deriveReplyTargetKindFromSessionKey2(sessionKey) {
+  const trimmed = readNonEmptyString4(sessionKey);
+  if (!trimmed) {
+    return void 0;
+  }
+  const parts = trimmed.split(":").filter((part) => part.length > 0);
+  if (parts[0]?.toLowerCase() !== "agent") {
+    return void 0;
+  }
+  const channel = readNonEmptyString4(parts[2])?.toLowerCase();
+  const peerShape = parts.length >= 6 && isSessionPeerShape3(parts[4]) ? parts[4].toLowerCase() : parts.length >= 5 && isSessionPeerShape3(parts[3]) ? parts[3].toLowerCase() : void 0;
+  switch (channel) {
+    case "feishu":
+      if (peerShape === "direct" || peerShape === "dm") {
+        return "user";
+      }
+      if (peerShape === "group") {
+        return "chat";
+      }
+      return void 0;
+    case "discord":
+      if (peerShape === "direct" || peerShape === "dm") {
+        return "user";
+      }
+      if (peerShape === "channel") {
+        return "channel";
+      }
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function normalizeSessionStoreTarget(value, channel, sessionKey) {
+  const trimmed = readNonEmptyString4(value);
+  if (!trimmed) {
+    return void 0;
+  }
+  const derivedKind = deriveReplyTargetKindFromSessionKey2(sessionKey);
+  if (derivedKind && !/^(user|chat|channel|room):/u.test(trimmed)) {
+    return `${derivedKind}:${trimmed}`;
+  }
+  return normalizeReplyTarget(trimmed, {
+    channel,
+    sessionKey
+  });
+}
+function deriveChannelFromSessionKey(sessionKey) {
+  const parts = sessionKey.split(":").filter(Boolean);
+  if (parts[0]?.toLowerCase() !== "agent") {
+    return void 0;
+  }
+  return normalizeChannel2(parts[2]);
+}
+function deriveTargetFromSessionKey(sessionKey, channel) {
+  const parts = sessionKey.split(":").filter(Boolean);
+  if (parts[0]?.toLowerCase() !== "agent") {
+    return void 0;
+  }
+  if (parts.length < 5 || !isSessionPeerShape3(parts[3])) {
+    return void 0;
+  }
+  const rawTarget = parts.length >= 6 ? parts[5] : parts[4];
+  if (!readNonEmptyString4(rawTarget)) {
+    return void 0;
+  }
+  return normalizeSessionStoreTarget(rawTarget, channel, sessionKey);
+}
+function extractRouteFromEntry(sessionKey, entry) {
+  if (!entry) {
+    return void 0;
+  }
+  const replyChannel = normalizeChannel2(entry.deliveryContext?.channel) ?? normalizeChannel2(entry.origin?.provider) ?? deriveChannelFromSessionKey(sessionKey);
+  const replyTo = normalizeSessionStoreTarget(entry.deliveryContext?.to, replyChannel, sessionKey) ?? normalizeSessionStoreTarget(entry.lastTo, replyChannel, sessionKey) ?? normalizeSessionStoreTarget(entry.origin?.to, replyChannel, sessionKey) ?? deriveTargetFromSessionKey(sessionKey, replyChannel);
+  const replyAccountId = readNonEmptyString4(entry.deliveryContext?.accountId) ?? readNonEmptyString4(entry.lastAccountId) ?? readNonEmptyString4(entry.origin?.accountId);
+  if (!replyChannel || !replyTo) {
+    return void 0;
+  }
+  return {
+    sessionKey,
+    agentId: deriveAgentIdFromSessionKey(sessionKey) ?? "main",
+    replyChannel,
+    replyTo,
+    replyAccountId
+  };
+}
+function tryDeriveAgentIdFromStorePath(sessionStorePath) {
+  const normalized = path3.normalize(sessionStorePath);
+  const parts = normalized.split(path3.sep).filter(Boolean);
+  const agentsIndex = parts.lastIndexOf("agents");
+  if (agentsIndex === -1) {
+    return void 0;
+  }
+  return readNonEmptyString4(parts[agentsIndex + 1]);
+}
+function listSessionStorePaths(explicitPath, baseAgentId) {
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addPath = (candidate) => {
+    const trimmed = readNonEmptyString4(candidate);
+    if (!trimmed) {
+      return;
+    }
+    const normalized = path3.normalize(trimmed);
+    if (seen.has(normalized)) {
+      return;
+    }
+    seen.add(normalized);
+    candidates.push(normalized);
+  };
+  addPath(explicitPath);
+  if (candidates.length > 0) {
+    return candidates;
+  }
+  const defaultOpenClawStateDir = getDefaultOpenClawStateDir();
+  addPath(path3.join(defaultOpenClawStateDir, "agents", baseAgentId, "sessions", "sessions.json"));
+  const agentsRoot = path3.join(defaultOpenClawStateDir, "agents");
+  try {
+    if (fs2.existsSync(agentsRoot)) {
+      for (const entry of fs2.readdirSync(agentsRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+          continue;
         }
-        filtered.push(token);
+        addPath(path3.join(agentsRoot, entry.name, "sessions", "sessions.json"));
+      }
     }
-    const command = filtered[0]?.toLowerCase() ?? '';
-    return {
-        command,
-        serverName,
-    };
+  } catch {
+  }
+  return candidates;
 }
-function selectServerRuntime(runtimes, requestedServerName) {
-    if (runtimes.length === 0) {
-        return {
-            error: 'No EigenFlux servers discovered. Ensure eigenflux CLI is configured with at least one server.',
-        };
+function readSessionStore(sessionStorePath, logger) {
+  try {
+    if (!fs2.existsSync(sessionStorePath)) {
+      return void 0;
     }
-    if (!requestedServerName) {
-        return {
-            runtime: runtimes[0],
-        };
+    const raw = fs2.readFileSync(sessionStorePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return void 0;
     }
-    const normalizedRequestedName = requestedServerName.trim().toLowerCase();
-    const runtime = runtimes.find((item) => item.server.name.trim().toLowerCase() === normalizedRequestedName);
-    if (runtime) {
-        return { runtime };
+    return parsed;
+  } catch (error) {
+    logger.debug(
+      `Failed to read session store ${sessionStorePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return void 0;
+  }
+}
+function readSessionStores(sessionStorePath, baseAgentId, logger) {
+  const snapshots = [];
+  const candidates = listSessionStorePaths(sessionStorePath, baseAgentId);
+  logger.info(
+    `Session store scan candidates: base_agent_id=${baseAgentId}, explicit_path=${sessionStorePath ?? "n/a"}, candidates=${JSON.stringify(candidates)}`
+  );
+  for (const candidate of candidates) {
+    const store = readSessionStore(candidate, logger);
+    if (store) {
+      const keys = Object.keys(store);
+      logger.info(
+        `Session store loaded: path=${candidate}, entries=${keys.length}, session_keys=${JSON.stringify(keys)}`
+      );
+      snapshots.push({ path: candidate, store });
     }
-    return {
-        error: [
-            `Unknown EigenFlux server: ${requestedServerName}`,
-            `Available servers: ${runtimes.map((item) => item.server.name).join(', ')}`,
-        ].join('\n'),
-    };
+  }
+  return snapshots;
 }
-function buildServersText(runtimes) {
-    if (runtimes.length === 0) {
-        return 'No EigenFlux servers discovered.';
+function mergeRoute(base, resolved, overrides, allowSessionOverride) {
+  const nextSessionKey = allowSessionOverride && !overrides.sessionKey ? resolved.sessionKey : base.sessionKey;
+  return {
+    sessionKey: nextSessionKey,
+    agentId: overrides.agentId === true ? base.agentId : resolved.agentId ?? deriveAgentIdFromSessionKey(nextSessionKey) ?? base.agentId,
+    replyChannel: overrides.replyChannel === true ? base.replyChannel : resolved.replyChannel ?? base.replyChannel,
+    replyTo: overrides.replyTo === true ? base.replyTo : resolved.replyTo ?? base.replyTo,
+    replyAccountId: overrides.replyAccountId === true ? base.replyAccountId : resolved.replyAccountId ?? base.replyAccountId
+  };
+}
+function selectExactRoute(snapshots, sessionKey) {
+  let best;
+  for (const snapshot of snapshots) {
+    const entry = snapshot.store[sessionKey];
+    const route = extractRouteFromEntry(sessionKey, entry);
+    if (!route || !isExternalChannel(route.replyChannel)) {
+      continue;
     }
-    return [
-        'EigenFlux servers (discovered via CLI):',
-        ...runtimes.map((runtime) => {
-            const flags = [
-                runtime.server.current ? 'default' : null,
-                runtime.streamClient.isRunning() ? 'streaming' : null,
-            ]
-                .filter(Boolean)
-                .join(', ');
-            const suffix = flags ? ` (${flags})` : '';
-            return `- ${runtime.server.name}: endpoint=${runtime.server.endpoint}${suffix}`;
-        }),
-    ].join('\n');
+    const updatedAt = normalizeUpdatedAt(entry?.updatedAt);
+    if (!best || updatedAt > best.updatedAt) {
+      best = { route, updatedAt };
+    }
+  }
+  return best;
 }
-function buildHelpText(runtimes) {
-    const defaultRuntime = runtimes[0];
-    const availableCommands = Array.from(COMMAND_NAME_SET).join('|');
-    return [
-        `Usage: /eigenflux [--server <name>] <${availableCommands}>`,
-        defaultRuntime ? `Default server: ${defaultRuntime.server.name}` : undefined,
-        runtimes.length > 0
-            ? `Available servers: ${runtimes.map((runtime) => runtime.server.name).join(', ')}`
-            : undefined,
-        '',
-        '/eigenflux auth — Show credential status',
-        '/eigenflux profile — Fetch agent profile',
-        '/eigenflux servers — List discovered servers',
-        '/eigenflux feed — Run one feed refresh',
-        '/eigenflux pm — Show PM stream status',
-        '/eigenflux here — Remember current conversation as delivery route',
-        '/eigenflux version — Show eigenflux CLI version info',
-    ]
-        .filter(Boolean)
-        .join('\n');
+function selectBestRoute(snapshots, preferred, preferredAgentId, logger) {
+  const candidates = [];
+  const autoScan = preferred === void 0;
+  for (const snapshot of snapshots) {
+    const pathAgentId = tryDeriveAgentIdFromStorePath(snapshot.path);
+    for (const [sessionKey, entry] of Object.entries(snapshot.store)) {
+      if (sessionKey.includes(":subagent:")) {
+        continue;
+      }
+      if (isInternalSessionKey(sessionKey)) {
+        logger?.debug(`Skipping ${sessionKey}: internal session`);
+        continue;
+      }
+      if (autoScan && isGroupEntry(sessionKey, entry)) {
+        logger?.debug(`Skipping ${sessionKey}: group entry in auto-scan`);
+        continue;
+      }
+      const route = extractRouteFromEntry(sessionKey, entry);
+      if (!route || !routeMatchesPreferred(route, preferred)) {
+        continue;
+      }
+      if (preferredAgentId && route.agentId !== preferredAgentId && pathAgentId !== preferredAgentId) {
+        continue;
+      }
+      candidates.push({
+        route,
+        updatedAt: normalizeUpdatedAt(entry.updatedAt),
+        isExternal: isExternalChannel(route.replyChannel),
+        isDirect: isDirectSessionKey(sessionKey, entry)
+      });
+    }
+  }
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  const externalPool = candidates.filter((c) => c.isExternal);
+  const channelPool = externalPool.length > 0 ? externalPool : candidates;
+  const directPool = channelPool.filter((c) => c.isDirect);
+  const finalPool = directPool.length > 0 ? directPool : channelPool;
+  const chosen = finalPool.reduce((best, c) => c.updatedAt > best.updatedAt ? c : best);
+  return { route: chosen.route, updatedAt: chosen.updatedAt };
 }
-function readNonEmptyString(value) {
-    if (typeof value !== 'string') {
-        return undefined;
+function findSessionRouteForBinding(options, logger) {
+  const channel = normalizeChannel2(options.channel);
+  const to = normalizeReplyTarget(options.to, { channel });
+  const accountId = readNonEmptyString4(options.accountId);
+  const agentId = readNonEmptyString4(options.agentId) ?? "main";
+  if (!channel || !to) {
+    return void 0;
+  }
+  const snapshots = readSessionStores(options.sessionStorePath, agentId, logger);
+  const best = selectBestRoute(snapshots, { channel, to, accountId }, agentId, logger);
+  if (best) {
+    return best.route;
+  }
+  const peerShape = inferPeerShape(channel, to);
+  const targetLocal = stripTargetPrefix(to);
+  if (!peerShape || !targetLocal) {
+    return void 0;
+  }
+  return {
+    sessionKey: `agent:${agentId}:${channel}:${peerShape}:${targetLocal}`,
+    agentId,
+    replyChannel: channel,
+    replyTo: to,
+    replyAccountId: accountId
+  };
+}
+function inferPeerShape(channel, to) {
+  const kind = to.split(":", 1)[0]?.toLowerCase();
+  switch (kind) {
+    case "user":
+      return "direct";
+    case "chat":
+      return channel === "feishu" ? "group" : "direct";
+    case "channel":
+      return "channel";
+    case "room":
+      return "group";
+    default:
+      return void 0;
+  }
+}
+function stripTargetPrefix(to) {
+  const idx = to.indexOf(":");
+  if (idx === -1) {
+    return readNonEmptyString4(to);
+  }
+  return readNonEmptyString4(to.slice(idx + 1));
+}
+async function resolveNotificationRoute(config, logger, options = {}) {
+  const overrides = createRouteOverrides2(config.routeOverrides);
+  const configRoute = {
+    sessionKey: readNonEmptyString4(config.sessionKey) ?? "main",
+    agentId: readNonEmptyString4(config.agentId) ?? deriveAgentIdFromSessionKey(config.sessionKey) ?? "main",
+    replyChannel: normalizeChannel2(config.replyChannel),
+    replyTo: normalizeReplyTarget(config.replyTo, {
+      channel: normalizeChannel2(config.replyChannel),
+      sessionKey: config.sessionKey
+    }),
+    replyAccountId: readNonEmptyString4(config.replyAccountId)
+  };
+  logger.info(
+    `Route resolve start: session_key=${configRoute.sessionKey}, agent_id=${configRoute.agentId}, channel=${configRoute.replyChannel ?? "n/a"}, to=${configRoute.replyTo ?? "n/a"}, account=${configRoute.replyAccountId ?? "n/a"}, overrides=${JSON.stringify(overrides)}, ignore_remembered=${options.ignoreRemembered === true}`
+  );
+  const hasExplicitConfig = isAnyRouteOverrideEnabled(overrides) || !isInternalSessionKey(configRoute.sessionKey) || Boolean(configRoute.replyChannel && configRoute.replyTo);
+  if (hasExplicitConfig) {
+    const snapshots2 = readSessionStores(config.sessionStorePath, configRoute.agentId, logger);
+    let enriched = selectExactRoute(snapshots2, configRoute.sessionKey)?.route;
+    if (!enriched && configRoute.replyChannel && configRoute.replyTo) {
+      enriched = selectBestRoute(
+        snapshots2,
+        {
+          channel: configRoute.replyChannel,
+          to: configRoute.replyTo,
+          accountId: configRoute.replyAccountId
+        },
+        void 0,
+        logger
+      )?.route;
+    }
+    const resolved = enriched ? mergeRoute(configRoute, enriched, overrides, isInternalSessionKey(configRoute.sessionKey)) : configRoute;
+    logger.info(
+      `Route resolve final (config): session_key=${resolved.sessionKey}, agent_id=${resolved.agentId}, channel=${resolved.replyChannel ?? "n/a"}, to=${resolved.replyTo ?? "n/a"}, account=${resolved.replyAccountId ?? "n/a"}`
+    );
+    return { route: resolved, source: "config" };
+  }
+  const snapshots = readSessionStores(config.sessionStorePath, configRoute.agentId, logger);
+  if (options.ignoreRemembered !== true) {
+    const remembered = await readStoredNotificationRoute(
+      config.store,
+      config.serverName,
+      logger
+    );
+    if (remembered) {
+      logger.info(
+        `Route resolve remembered: session_key=${remembered.sessionKey}, agent_id=${remembered.agentId}, channel=${remembered.replyChannel ?? "n/a"}, to=${remembered.replyTo ?? "n/a"}, account=${remembered.replyAccountId ?? "n/a"}`
+      );
+      const preferred = remembered.replyChannel && remembered.replyTo ? {
+        channel: remembered.replyChannel,
+        to: remembered.replyTo,
+        accountId: remembered.replyAccountId
+      } : void 0;
+      const peerMatch = selectBestRoute(snapshots, preferred, void 0, logger);
+      if (peerMatch) {
+        return { route: peerMatch.route, source: "remembered" };
+      }
+      if (!isInternalSessionKey(remembered.sessionKey)) {
+        return {
+          route: {
+            sessionKey: remembered.sessionKey,
+            agentId: remembered.agentId,
+            replyChannel: remembered.replyChannel,
+            replyTo: remembered.replyTo,
+            replyAccountId: remembered.replyAccountId
+          },
+          source: "remembered"
+        };
+      }
+      logger.warn(
+        `Remembered route has internal session_key=${remembered.sessionKey} and no peer match; falling through to session-store scan.`
+      );
     }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
+  }
+  const best = selectBestRoute(snapshots, void 0, void 0, logger);
+  if (best) {
+    logger.info(
+      `Route resolve from session store: session_key=${best.route.sessionKey}, agent_id=${best.route.agentId}, channel=${best.route.replyChannel ?? "n/a"}, to=${best.route.replyTo ?? "n/a"}, account=${best.route.replyAccountId ?? "n/a"}, updated_at=${best.updatedAt}`
+    );
+    return { route: best.route, source: "session-store" };
+  }
+  logger.warn(
+    `Route resolve fell back to config default: session_key=${configRoute.sessionKey}, agent_id=${configRoute.agentId}`
+  );
+  return { route: configRoute, source: "default" };
 }
-function normalizeChannel(value) {
-    return readNonEmptyString(value)?.toLowerCase();
+
+// src/agent-prompt-templates.ts
+function buildContextLines(context) {
+  return [
+    `homedir=${context.eigenfluxHome}`,
+    `server=${context.serverName}`
+  ];
 }
-async function resolveCurrentCommandRoute(ctx, runtime, logger) {
-    let channel = normalizeChannel(ctx.channel);
-    let to = (0, reply_target_1.normalizeReplyTarget)(ctx.to, { channel }) ??
-        (0, reply_target_1.normalizeReplyTarget)(ctx.from, { channel, fallbackKind: 'user' });
-    let accountId = readNonEmptyString(ctx.accountId);
-    if (typeof ctx.getCurrentConversationBinding === 'function') {
-        try {
-            const binding = await ctx.getCurrentConversationBinding();
-            if (binding) {
-                channel = normalizeChannel(binding.channel) ?? channel;
-                to =
-                    (0, reply_target_1.normalizeReplyTarget)(binding.conversationId, { channel }) ??
-                        (0, reply_target_1.normalizeReplyTarget)(binding.parentConversationId, { channel }) ??
-                        to;
-                accountId = readNonEmptyString(binding.accountId) ?? accountId;
-            }
+function buildAuthRequiredPromptTemplate({
+  context,
+  stderr
+}) {
+  const lines = [
+    "[EIGENFLUX_AUTH_REQUIRED]",
+    ...buildContextLines(context),
+    "EigenFlux authentication is required.",
+    `Run \`eigenflux auth login --email <email> -s ${context.serverName}\` to authenticate.`,
+    `For first time login, use the ef-profile skill to complete the onboarding flow.`
+  ];
+  if (stderr) {
+    lines.push(`detail=${stderr}`);
+  }
+  return lines.join("\n");
+}
+function buildFeedPayloadPromptTemplate(payload, context) {
+  return [
+    "[EIGENFLUX_FEED_PAYLOAD]",
+    ...buildContextLines(context),
+    `EigenFlux feed payload received. Use the ef-broadcast skill to process feed payload.`,
+    "Payload:",
+    "```json",
+    JSON.stringify(payload, null, 2),
+    "```"
+  ].join("\n");
+}
+function buildNotInstalledPromptTemplate({
+  bin,
+  installCommand
+}) {
+  return [
+    "[EIGENFLUX_NOT_INSTALLED]",
+    `The EigenFlux CLI is not installed on this machine (tried bin=${bin}).`,
+    "Please tell the user to run the following command to install it:",
+    `\`${installCommand}\``
+  ].join("\n");
+}
+function buildPmStreamEventPromptTemplate(event, context) {
+  return [
+    "[EIGENFLUX_MSG_PAYLOAD]",
+    ...buildContextLines(context),
+    `EigenFlux private messages received. Use the ef-communication skill to process private messages.`,
+    "Payload:",
+    "```json",
+    JSON.stringify(event, null, 2),
+    "```"
+  ].join("\n");
+}
+
+// src/notifier.ts
+var import_node_crypto = require("crypto");
+var COMMAND_TIMEOUT_MS = 15e3;
+var SUBAGENT_WAIT_TIMEOUT_MS = 18e4;
+var HEARTBEAT_REASON = "plugin:eigenflux";
+var EigenFluxNotifier = class {
+  constructor(api, logger, config) {
+    this.api = api;
+    this.logger = logger;
+    this.config = config;
+  }
+  get runtime() {
+    return this.api.runtime ?? {};
+  }
+  async deliver(message) {
+    const initial = await this.resolveRoute();
+    this.logger.info(
+      `Delivery route resolved: source=${initial.source}, ${formatRouteForLog(initial.route)}, message_preview=${previewMessage(message)}`
+    );
+    const firstAttempt = await this.attemptDelivery(message, initial.route);
+    if (firstAttempt.result.ok) {
+      await this.rememberRouteIfChanged(firstAttempt.finalRoute, initial.source);
+      this.logDispatch(firstAttempt.result);
+      return true;
+    }
+    if (initial.source === "remembered") {
+      this.logger.warn(
+        `All transports failed with remembered route; re-resolving without remembered config.`
+      );
+      const fallback = await this.resolveRoute({ ignoreRemembered: true });
+      if (fallback.route.sessionKey !== initial.route.sessionKey || fallback.route.replyTo !== initial.route.replyTo || fallback.route.replyChannel !== initial.route.replyChannel) {
+        this.logger.info(
+          `Retrying delivery with fresh route: source=${fallback.source}, ${formatRouteForLog(fallback.route)}`
+        );
+        const retry = await this.attemptDelivery(message, fallback.route);
+        if (retry.result.ok) {
+          await this.rememberRouteIfChanged(retry.finalRoute, fallback.source);
+          this.logDispatch(retry.result);
+          return true;
         }
-        catch (error) {
-            logger.debug(`Failed to read current conversation binding: ${error instanceof Error ? error.message : String(error)}`);
+        this.logger.error(
+          `Failed to deliver notification after fresh re-resolve: ${retry.errors.join(" | ")}`
+        );
+        return false;
+      }
+      this.logger.warn("Fresh re-resolve produced the same route; skipping retry.");
+    }
+    this.logger.error(`Failed to deliver notification: ${firstAttempt.errors.join(" | ")}`);
+    return false;
+  }
+  async attemptDelivery(message, route) {
+    const attempts = [
+      () => this.tryNotifyViaRuntimeSubagent(message, route),
+      () => this.tryNotifyViaRuntimeCommandAgent(message, route),
+      () => this.tryNotifyViaRuntimeHeartbeat(message, route),
+      () => this.tryNotifyViaRuntimeCommandHeartbeat(message)
+    ];
+    const errors = [];
+    for (const attempt of attempts) {
+      const result = await attempt();
+      if (result.ok) {
+        const finalRoute = {
+          sessionKey: result.sessionKey ?? route.sessionKey,
+          agentId: route.agentId,
+          replyChannel: route.replyChannel,
+          replyTo: route.replyTo,
+          replyAccountId: route.replyAccountId
+        };
+        return { result, finalRoute, errors };
+      }
+      this.logger.warn(
+        `Notification attempt failed: mode=${result.mode}, ${formatRouteForLog(route)}, error=${result.error}`
+      );
+      errors.push(`${result.mode}: ${result.error}`);
+    }
+    return {
+      result: { ok: false, mode: "all", error: errors.join(" | ") },
+      finalRoute: route,
+      errors
+    };
+  }
+  async tryNotifyViaRuntimeSubagent(message, route) {
+    const runtimeSubagent = this.runtime.subagent;
+    if (!runtimeSubagent || typeof runtimeSubagent.run !== "function") {
+      return {
+        ok: false,
+        mode: "runtime.subagent",
+        error: "runtime.subagent.run is unavailable"
+      };
+    }
+    try {
+      this.logger.info(
+        `Attempting runtime.subagent delivery: ${formatRouteForLog(route)}, deliver=true`
+      );
+      const { runId } = await runtimeSubagent.run({
+        sessionKey: route.sessionKey,
+        message,
+        deliver: true,
+        idempotencyKey: (0, import_node_crypto.randomUUID)()
+      });
+      if (typeof runtimeSubagent.waitForRun === "function") {
+        const waited = await runtimeSubagent.waitForRun({
+          runId,
+          timeoutMs: SUBAGENT_WAIT_TIMEOUT_MS
+        });
+        if (waited.status === "error") {
+          return {
+            ok: false,
+            mode: "runtime.subagent",
+            error: `subagent run error${waited.error ? `: ${waited.error}` : ""}`
+          };
         }
+      }
+      return {
+        ok: true,
+        mode: "runtime.subagent",
+        sessionKey: route.sessionKey,
+        runId
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        mode: "runtime.subagent",
+        error: formatError(error)
+      };
     }
-    if (!channel || !to) {
-        return undefined;
+  }
+  async tryNotifyViaRuntimeCommandAgent(message, route) {
+    return this.runRuntimeCommand(
+      "runtime.command.agent",
+      this.buildAgentCliArgs(message, route),
+      route
+    );
+  }
+  async tryNotifyViaRuntimeHeartbeat(message, route) {
+    const runtimeSystem = this.runtime.system;
+    if (!runtimeSystem || typeof runtimeSystem.enqueueSystemEvent !== "function" || typeof runtimeSystem.requestHeartbeatNow !== "function") {
+      return {
+        ok: false,
+        mode: "runtime.system.heartbeat",
+        error: "runtime.system heartbeat APIs are unavailable"
+      };
     }
-    return (0, notification_route_resolver_1.findSessionRouteForBinding)({
-        agentId: runtime.routing.agentId,
-        channel,
-        to,
-        accountId,
-    }, logger);
-}
-async function buildHereText(ctx, runtime, eigenfluxBin, logger) {
-    const route = await resolveCurrentCommandRoute(ctx, runtime, logger);
-    if (!route || !route.replyChannel || !route.replyTo) {
-        return [
-            `Unable to resolve the current external session for server=${runtime.server.name}.`,
-            'Run `/eigenflux here` inside the target conversation after OpenClaw has already created a session for it.',
-        ].join('\n');
+    try {
+      const deliveryContext = this.resolveHeartbeatDeliveryContext(route);
+      this.logger.info(
+        `Attempting runtime.system.heartbeat delivery: ${formatRouteForLog(route)}, delivery_context=${formatDeliveryContextForLog(deliveryContext)}`
+      );
+      const enqueued = runtimeSystem.enqueueSystemEvent(message, {
+        sessionKey: route.sessionKey,
+        ...deliveryContext ? { deliveryContext } : {}
+      });
+      runtimeSystem.requestHeartbeatNow({
+        reason: HEARTBEAT_REASON,
+        coalesceMs: 0,
+        agentId: route.agentId,
+        sessionKey: route.sessionKey
+      });
+      return {
+        ok: true,
+        mode: "runtime.system.heartbeat",
+        sessionKey: route.sessionKey,
+        detail: enqueued ? "enqueued" : "duplicate-enqueued"
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        mode: "runtime.system.heartbeat",
+        error: formatError(error)
+      };
     }
-    const saved = await (0, session_route_memory_1.writeStoredNotificationRoute)(eigenfluxBin, runtime.server.name, route, logger);
-    if (!saved) {
-        return `Failed to persist the current EigenFlux route for server=${runtime.server.name}; check plugin logs for details.`;
+  }
+  async tryNotifyViaRuntimeCommandHeartbeat(message) {
+    const { route } = await this.resolveRoute();
+    return this.runRuntimeCommand(
+      "runtime.command.heartbeat",
+      this.buildHeartbeatCliArgs(message),
+      route
+    );
+  }
+  async runRuntimeCommand(mode, argv, route) {
+    const runtimeCommand = this.runtime.system?.runCommandWithTimeout;
+    if (typeof runtimeCommand !== "function") {
+      return {
+        ok: false,
+        mode,
+        error: "runtime.system.runCommandWithTimeout is unavailable"
+      };
     }
+    try {
+      this.logger.info(
+        `Attempting ${mode} delivery: ${formatRouteForLog(route)}, argv=${formatCommandArgsForLog(argv)}`
+      );
+      const result = await runtimeCommand(argv, { timeoutMs: COMMAND_TIMEOUT_MS });
+      if (result.code === 0) {
+        return {
+          ok: true,
+          mode,
+          sessionKey: route.sessionKey
+        };
+      }
+      return {
+        ok: false,
+        mode,
+        error: `${formatCommandFailure(result)} (argv=${formatCommandArgsForLog(argv)})`
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        mode,
+        error: formatError(error)
+      };
+    }
+  }
+  buildAgentCliArgs(message, route) {
+    const args = [
+      this.config.openclawCliBin,
+      "agent",
+      "--message",
+      message,
+      "--agent",
+      route.agentId,
+      "--deliver"
+    ];
+    if (route.replyChannel) {
+      args.push("--reply-channel", route.replyChannel);
+    }
+    if (route.replyTo) {
+      args.push("--reply-to", route.replyTo);
+    }
+    if (route.replyAccountId) {
+      args.push("--reply-account", route.replyAccountId);
+    }
+    return args;
+  }
+  buildHeartbeatCliArgs(message) {
     return [
-        `EigenFlux server ${runtime.server.name} will deliver to this conversation by default:`,
-        `sessionKey: ${route.sessionKey}`,
-        `agentId: ${route.agentId}`,
-        `channel: ${route.replyChannel ?? 'unknown'}`,
-        `target: ${route.replyTo ?? 'unknown'}`,
-        route.replyAccountId ? `account: ${route.replyAccountId}` : undefined,
-    ]
-        .filter(Boolean)
-        .join('\n');
-}
-async function rememberCurrentCommandRouteIfPossible(ctx, runtime, eigenfluxBin, logger) {
-    const route = await resolveCurrentCommandRoute(ctx, runtime, logger);
-    if (!route || !route.replyChannel || !route.replyTo) {
-        return;
+      this.config.openclawCliBin,
+      "system",
+      "event",
+      "--text",
+      message,
+      "--mode",
+      "now"
+    ];
+  }
+  resolveHeartbeatDeliveryContext(route) {
+    if (!route.replyChannel && !route.replyTo && !route.replyAccountId) {
+      return void 0;
     }
-    if (await (0, session_route_memory_1.writeStoredNotificationRoute)(eigenfluxBin, runtime.server.name, route, logger)) {
-        logger.debug(`Remembered current command route for server=${runtime.server.name}: session_key=${route.sessionKey}, channel=${route.replyChannel ?? 'unknown'}, to=${route.replyTo ?? 'unknown'}`);
+    return {
+      ...route.replyChannel ? { channel: route.replyChannel } : {},
+      ...route.replyTo ? { to: route.replyTo } : {},
+      ...route.replyAccountId ? { accountId: route.replyAccountId } : {}
+    };
+  }
+  async resolveRoute(options = {}) {
+    return resolveNotificationRoute(
+      this.config,
+      this.logger,
+      options
+    );
+  }
+  /**
+   * Persist the successful route to the eigenflux CLI config unless it came from
+   * the remembered config already (no-op when unchanged).
+   */
+  async rememberRouteIfChanged(route, source) {
+    if (!route.sessionKey || !route.agentId) {
+      return;
     }
-}
-// ─── Command Handlers ───────────────────────────────────────────────────────
-function buildAuthStatusText(runtime) {
-    const authState = runtime.credentialsLoader.loadAuthState();
-    const lines = [`EigenFlux auth status (server=${runtime.server.name}):`];
-    lines.push(`- credentials_path: ${authState.credentialsPath}`);
-    lines.push(`- status: ${authState.status}`);
-    if (authState.expiresAt) {
-        lines.push(`- expires_at: ${authState.expiresAt}`);
+    if (isInternalSessionKey(route.sessionKey)) {
+      return;
     }
-    if (authState.status === 'available') {
-        lines.push(`- token: ${maskToken(authState.accessToken)}`);
+    if (!route.replyChannel || !route.replyTo) {
+      return;
     }
-    else {
-        lines.push('- token: unavailable');
+    if (source === "remembered") {
+      this.logger.debug(
+        `Skipping remembered-route write; route came from config (session_key=${route.sessionKey})`
+      );
+      return;
     }
-    return lines.join('\n');
+    await writeStoredNotificationRoute(
+      this.config.store,
+      this.config.serverName,
+      route,
+      this.logger
+    );
+  }
+  logDispatch(result) {
+    const details = [
+      `mode=${result.mode}`,
+      result.sessionKey ? `session_key=${result.sessionKey}` : null,
+      result.runId ? `run_id=${result.runId}` : null,
+      result.detail ? `detail=${result.detail}` : null
+    ].filter(Boolean).join(", ");
+    this.logger.info(`Notification dispatched: ${details}`);
+  }
+};
+function formatCommandFailure(result) {
+  return result.stderr?.trim() || result.stdout?.trim() || `command exited with ${result.code ?? "unknown"}`;
 }
-async function buildProfileText(runtime, eigenfluxBin) {
-    const result = await (0, cli_executor_1.execEigenflux)(eigenfluxBin, ['profile', 'show', '-s', runtime.server.name, '-f', 'json']);
-    if (result.kind === 'auth_required') {
-        return (0, agent_prompt_templates_1.buildAuthRequiredPromptTemplate)({ context: runtime.getPromptContext() });
+function formatError(error) {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+function formatRouteForLog(route) {
+  return [
+    `session_key=${route.sessionKey}`,
+    `agent_id=${route.agentId}`,
+    `channel=${route.replyChannel ?? "n/a"}`,
+    `to=${route.replyTo ?? "n/a"}`,
+    `account=${route.replyAccountId ?? "n/a"}`
+  ].join(", ");
+}
+function formatDeliveryContextForLog(deliveryContext) {
+  if (!deliveryContext) {
+    return "none";
+  }
+  return [
+    `channel=${deliveryContext.channel ?? "n/a"}`,
+    `to=${deliveryContext.to ?? "n/a"}`,
+    `account=${deliveryContext.accountId ?? "n/a"}`
+  ].join(", ");
+}
+function previewMessage(message, maxLength = 120) {
+  const singleLine = message.replace(/\s+/gu, " ").trim();
+  if (singleLine.length <= maxLength) {
+    return JSON.stringify(singleLine);
+  }
+  return JSON.stringify(`${singleLine.slice(0, maxLength - 3)}...`);
+}
+function formatCommandArgsForLog(argv) {
+  const sanitized = [...argv];
+  for (let index = 0; index < sanitized.length; index += 1) {
+    if (sanitized[index] === "--message" || sanitized[index] === "--text") {
+      if (typeof sanitized[index + 1] === "string") {
+        sanitized[index + 1] = `<len:${sanitized[index + 1].length}>`;
+      }
     }
-    if (result.kind === 'not_installed') {
-        return `EigenFlux CLI not installed (bin=${result.bin}). Install with: ${INSTALL_COMMAND}`;
+  }
+  return JSON.stringify(sanitized);
+}
+
+// src/index.ts
+var COMMAND_NAMES = ["auth", "profile", "servers", "feed", "pm", "here", "version"];
+var COMMAND_NAME_SET = new Set(COMMAND_NAMES);
+var DEFAULT_ROUTING = {
+  sessionKey: PLUGIN_CONFIG.DEFAULT_SESSION_KEY,
+  agentId: PLUGIN_CONFIG.DEFAULT_AGENT_ID,
+  routeOverrides: {
+    sessionKey: false,
+    agentId: false,
+    replyChannel: false,
+    replyTo: false,
+    replyAccountId: false
+  }
+};
+function registerPlugin(api) {
+  const logger = new Logger(resolvePluginLogger(api));
+  const pluginConfig = resolvePluginConfig(api.pluginConfig, logger);
+  const eigenfluxHome = resolveEigenfluxHome();
+  const store = createInMemoryPluginStore();
+  let runtimes = [];
+  let notInstalledPromptDelivered = false;
+  api.registerService({
+    id: "eigenflux:discovery",
+    start: async () => {
+      logger.info("Starting EigenFlux discovery service...");
+      const discovery = await discoverServers(pluginConfig.eigenfluxBin, logger);
+      if (discovery.kind === "not_installed") {
+        logger.warn(
+          `EigenFlux CLI not installed (bin=${discovery.bin}); delivering install prompt to user`
+        );
+        if (!notInstalledPromptDelivered) {
+          notInstalledPromptDelivered = true;
+          await deliverNotInstalledPrompt(api, logger, pluginConfig, eigenfluxHome, discovery.bin, store);
+        }
+        return;
+      }
+      const servers = discovery.servers;
+      if (servers.length === 0) {
+        logger.warn("No EigenFlux servers discovered; services will not start");
+        return;
+      }
+      logger.info(`Discovered ${servers.length} server(s): ${servers.map((s) => s.name).join(", ")}`);
+      runtimes = servers.map(
+        (server) => createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome, store)
+      );
+      for (const runtime of runtimes) {
+        logger.info(`Starting services for server=${runtime.server.name}`);
+        await runtime.feedPoller.start();
+        await runtime.streamClient.start();
+      }
+    },
+    stop: async () => {
+      logger.info("Stopping EigenFlux discovery service...");
+      for (const runtime of runtimes) {
+        logger.info(`Stopping services for server=${runtime.server.name}`);
+        runtime.feedPoller.stop();
+        await runtime.streamClient.stop();
+      }
+      runtimes = [];
+      notInstalledPromptDelivered = false;
     }
-    if (result.kind === 'error') {
-        return `Failed to fetch profile for server ${runtime.server.name}: ${result.error.message}`;
+  });
+  registerCommand(
+    api,
+    logger,
+    pluginConfig,
+    eigenfluxHome,
+    store,
+    () => runtimes,
+    (next) => {
+      runtimes = next;
     }
-    return [
-        `EigenFlux profile (server=${runtime.server.name}):`,
-        '```json',
-        safeJsonStringify(result.data),
-        '```',
-    ].join('\n');
+  );
 }
-async function buildFeedText(runtime) {
-    const result = await runtime.feedPoller.pollOnce({
-        notifyFeed: false,
-        notifyAuthRequired: false,
-    });
-    switch (result.kind) {
-        case 'success':
-            return [
-                `EigenFlux feed result (server=${runtime.server.name}):`,
-                '```json',
-                safeJsonStringify(result.payload),
-                '```',
-            ].join('\n');
-        case 'auth_required':
-            return (0, agent_prompt_templates_1.buildAuthRequiredPromptTemplate)({ context: runtime.getPromptContext() });
-        case 'error':
-            return `EigenFlux feed failed for server ${runtime.server.name}: ${result.error.message}`;
-        default:
-            return `EigenFlux feed finished with an unknown result for server ${runtime.server.name}.`;
+function resolvePluginLogger(api) {
+  const runtimeLogging = api.runtime?.logging;
+  if (runtimeLogging && typeof runtimeLogging.getChildLogger === "function") {
+    try {
+      const child = runtimeLogging.getChildLogger({ plugin: "eigenflux" });
+      if (child) {
+        return child;
+      }
+    } catch {
     }
+  }
+  return api.logger;
 }
-async function buildVersionText(eigenfluxBin) {
-    const result = await (0, cli_executor_1.execEigenflux)(eigenfluxBin, ['version']);
-    if (result.kind === 'not_installed') {
-        return `EigenFlux CLI not installed (bin=${result.bin}). Install with: ${INSTALL_COMMAND}`;
-    }
-    if (result.kind === 'auth_required') {
-        return `EigenFlux CLI reported auth_required while fetching version (stderr: ${result.stderr || 'n/a'}).`;
+var index_default = (0, import_plugin_entry.definePluginEntry)({
+  id: "openclaw-eigenflux",
+  name: "EigenFlux",
+  description: "OpenClaw extension for EigenFlux with CLI-based feed polling and PM streaming",
+  register(api) {
+    if (api.registrationMode && api.registrationMode !== "full") return;
+    registerPlugin(api);
+  }
+});
+var INSTALL_COMMAND = "curl -fsSL https://eigenflux.ai/install.sh | bash";
+async function deliverNotInstalledPrompt(api, logger, pluginConfig, _eigenfluxHome, bin, store) {
+  const notifier = new EigenFluxNotifier(api, logger, {
+    sessionKey: DEFAULT_ROUTING.sessionKey,
+    agentId: DEFAULT_ROUTING.agentId,
+    replyChannel: DEFAULT_ROUTING.replyChannel,
+    replyTo: DEFAULT_ROUTING.replyTo,
+    replyAccountId: DEFAULT_ROUTING.replyAccountId,
+    openclawCliBin: pluginConfig.openclawCliBin,
+    routeOverrides: DEFAULT_ROUTING.routeOverrides
+  });
+  await notifier.deliver(
+    buildNotInstalledPromptTemplate({ bin, installCommand: INSTALL_COMMAND })
+  );
+}
+function createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome, store) {
+  const routing = pluginConfig.serverRouting[server.name] ?? DEFAULT_ROUTING;
+  const credentialsLoader = new CredentialsLoader(logger, eigenfluxHome, server.name);
+  const notifier = new EigenFluxNotifier(api, logger, {
+    store,
+    eigenfluxBin: pluginConfig.eigenfluxBin,
+    serverName: server.name,
+    sessionKey: routing.sessionKey,
+    agentId: routing.agentId,
+    replyChannel: routing.replyChannel,
+    replyTo: routing.replyTo,
+    replyAccountId: routing.replyAccountId,
+    openclawCliBin: pluginConfig.openclawCliBin,
+    routeOverrides: routing.routeOverrides
+  });
+  const getPromptContext = () => ({
+    serverName: server.name,
+    eigenfluxHome
+  });
+  let lastAuthPromptKey = null;
+  const resetAuthPromptGate = () => {
+    lastAuthPromptKey = null;
+  };
+  const notifyAuthRequired = async (_authEvent) => {
+    const promptKey = `auth_required:${server.name}`;
+    if (lastAuthPromptKey === promptKey) {
+      logger.debug(`Skipping duplicate auth prompt for server=${server.name}`);
+      return;
     }
-    if (result.kind === 'error') {
-        return `Failed to fetch eigenflux version: ${result.error.message}`;
+    lastAuthPromptKey = promptKey;
+    await notifier.deliver(
+      buildAuthRequiredPromptTemplate({ context: getPromptContext() })
+    );
+  };
+  const feedPoller = new EigenFluxPollingClient({
+    serverName: server.name,
+    eigenfluxBin: pluginConfig.eigenfluxBin,
+    resolvePollIntervalSec: () => readPollIntervalSec(pluginConfig.eigenfluxBin, server.name, logger),
+    logger,
+    onFeedPolled: async (payload) => {
+      resetAuthPromptGate();
+      await notifier.deliver(buildFeedPayloadPromptTemplate(payload, getPromptContext()));
+    },
+    onAuthRequired: notifyAuthRequired
+  });
+  const streamClient = new EigenFluxStreamClient({
+    serverName: server.name,
+    eigenfluxBin: pluginConfig.eigenfluxBin,
+    logger,
+    onPmEvent: async (event) => {
+      resetAuthPromptGate();
+      await notifier.deliver(buildPmStreamEventPromptTemplate(event, getPromptContext()));
+    },
+    onAuthRequired: async () => {
+      await notifyAuthRequired({ reason: "auth_required" });
     }
-    const body = typeof result.data === 'string' ? result.data : safeJsonStringify(result.data);
-    return ['EigenFlux CLI version:', '```json', body, '```'].join('\n');
+  });
+  return {
+    server,
+    routing,
+    credentialsLoader,
+    notifier,
+    feedPoller,
+    streamClient,
+    getPromptContext
+  };
 }
-function buildPmStatusText(runtime) {
-    const running = runtime.streamClient.isRunning();
-    const cursor = runtime.streamClient.getLastCursor();
-    const lines = [`EigenFlux PM stream status (server=${runtime.server.name}):`];
-    lines.push(`- streaming: ${running ? 'active' : 'inactive'}`);
-    if (cursor) {
-        lines.push(`- last_cursor: ${cursor}`);
+function registerCommand(api, logger, pluginConfig, eigenfluxHome, store, getRuntimes, setRuntimes) {
+  if (!api.registerCommand) {
+    logger.warn("registerCommand API unavailable; skipping /eigenflux command registration");
+    return;
+  }
+  let inflightDiscovery = null;
+  const runDiscovery = async () => {
+    const discovery = await discoverServers(pluginConfig.eigenfluxBin, logger);
+    if (discovery.kind === "not_installed") {
+      return { runtimes: getRuntimes(), notInstalledBin: discovery.bin };
+    }
+    if (discovery.servers.length === 0) {
+      return { runtimes: getRuntimes() };
+    }
+    const created = discovery.servers.map(
+      (server) => createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome, store)
+    );
+    setRuntimes(created);
+    return { runtimes: created };
+  };
+  const ensureRuntimes = async () => {
+    const existing = getRuntimes();
+    if (existing.length > 0) {
+      return { runtimes: existing };
+    }
+    if (!inflightDiscovery) {
+      inflightDiscovery = runDiscovery().finally(() => {
+        inflightDiscovery = null;
+      });
     }
-    if (!running) {
-        lines.push('PM stream is not running. Check auth status or restart the service.');
+    return inflightDiscovery;
+  };
+  api.registerCommand({
+    name: "eigenflux",
+    description: "EigenFlux plugin commands: auth, profile, servers, feed, pm, here, version",
+    acceptsArgs: true,
+    handler: async (ctx) => {
+      const parsed = parseCommandArgs(ctx.args);
+      if (parsed.command === "version") {
+        return {
+          text: await buildVersionText(pluginConfig.eigenfluxBin)
+        };
+      }
+      const { runtimes, notInstalledBin } = await ensureRuntimes();
+      if (notInstalledBin && runtimes.length === 0) {
+        return {
+          text: `EigenFlux CLI not installed (bin=${notInstalledBin}). Install with: ${INSTALL_COMMAND}`
+        };
+      }
+      if (parsed.command === "servers") {
+        return {
+          text: buildServersText(runtimes)
+        };
+      }
+      const selection = selectServerRuntime(runtimes, parsed.serverName);
+      if (!selection.runtime) {
+        return {
+          text: selection.error ?? buildHelpText(runtimes)
+        };
+      }
+      const runtime = selection.runtime;
+      await rememberCurrentCommandRouteIfPossible(ctx, runtime, store, logger);
+      switch (parsed.command) {
+        case "auth":
+          return {
+            text: buildAuthStatusText(runtime)
+          };
+        case "profile":
+          return {
+            text: await buildProfileText(runtime, pluginConfig.eigenfluxBin)
+          };
+        case "feed":
+          return {
+            text: await buildFeedText(runtime)
+          };
+        case "pm":
+          return {
+            text: buildPmStatusText(runtime)
+          };
+        case "here":
+          return {
+            text: await buildHereText(ctx, runtime, store, logger)
+          };
+        default:
+          return {
+            text: buildHelpText(runtimes)
+          };
+      }
     }
-    return lines.join('\n');
+  });
 }
-// ─── Utilities ──────────────────────────────────────────────────────────────
-function maskToken(token) {
-    const trimmed = token.trim();
-    if (trimmed.length <= 10) {
-        return `${trimmed.slice(0, 2)}***`;
+function parseCommandArgs(args) {
+  const tokens = args?.trim().length ? args.trim().split(/\s+/u) : [];
+  let serverName;
+  const filtered = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if ((token === "--server" || token === "-s") && tokens[index + 1]) {
+      serverName = tokens[index + 1];
+      index += 1;
+      continue;
     }
-    return `${trimmed.slice(0, 6)}...${trimmed.slice(-4)}`;
+    filtered.push(token);
+  }
+  const command = filtered[0]?.toLowerCase() ?? "";
+  return {
+    command,
+    serverName
+  };
 }
-function safeJsonStringify(value) {
+function selectServerRuntime(runtimes, requestedServerName) {
+  if (runtimes.length === 0) {
+    return {
+      error: "No EigenFlux servers discovered. Ensure eigenflux CLI is configured with at least one server."
+    };
+  }
+  if (!requestedServerName) {
+    return {
+      runtime: runtimes[0]
+    };
+  }
+  const normalizedRequestedName = requestedServerName.trim().toLowerCase();
+  const runtime = runtimes.find(
+    (item) => item.server.name.trim().toLowerCase() === normalizedRequestedName
+  );
+  if (runtime) {
+    return { runtime };
+  }
+  return {
+    error: [
+      `Unknown EigenFlux server: ${requestedServerName}`,
+      `Available servers: ${runtimes.map((item) => item.server.name).join(", ")}`
+    ].join("\n")
+  };
+}
+function buildServersText(runtimes) {
+  if (runtimes.length === 0) {
+    return "No EigenFlux servers discovered.";
+  }
+  return [
+    "EigenFlux servers (discovered via CLI):",
+    ...runtimes.map((runtime) => {
+      const flags = [
+        runtime.server.current ? "default" : null,
+        runtime.streamClient.isRunning() ? "streaming" : null
+      ].filter(Boolean).join(", ");
+      const suffix = flags ? ` (${flags})` : "";
+      return `- ${runtime.server.name}: endpoint=${runtime.server.endpoint}${suffix}`;
+    })
+  ].join("\n");
+}
+function buildHelpText(runtimes) {
+  const defaultRuntime = runtimes[0];
+  const availableCommands = Array.from(COMMAND_NAME_SET).join("|");
+  return [
+    `Usage: /eigenflux [--server <name>] <${availableCommands}>`,
+    defaultRuntime ? `Default server: ${defaultRuntime.server.name}` : void 0,
+    runtimes.length > 0 ? `Available servers: ${runtimes.map((runtime) => runtime.server.name).join(", ")}` : void 0,
+    "",
+    "/eigenflux auth \u2014 Show credential status",
+    "/eigenflux profile \u2014 Fetch agent profile",
+    "/eigenflux servers \u2014 List discovered servers",
+    "/eigenflux feed \u2014 Run one feed refresh",
+    "/eigenflux pm \u2014 Show PM stream status",
+    "/eigenflux here \u2014 Remember current conversation as delivery route",
+    "/eigenflux version \u2014 Show eigenflux CLI version info"
+  ].filter(Boolean).join("\n");
+}
+function readNonEmptyString5(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeChannel3(value) {
+  return readNonEmptyString5(value)?.toLowerCase();
+}
+async function resolveCurrentCommandRoute(ctx, runtime, logger) {
+  let channel = normalizeChannel3(ctx.channel);
+  let to = normalizeReplyTarget(ctx.to, { channel }) ?? normalizeReplyTarget(ctx.from, { channel, fallbackKind: "user" });
+  let accountId = readNonEmptyString5(ctx.accountId);
+  if (typeof ctx.getCurrentConversationBinding === "function") {
     try {
-        return JSON.stringify(value, null, 2);
+      const binding = await ctx.getCurrentConversationBinding();
+      if (binding) {
+        channel = normalizeChannel3(binding.channel) ?? channel;
+        to = normalizeReplyTarget(binding.conversationId, { channel }) ?? normalizeReplyTarget(binding.parentConversationId, { channel }) ?? to;
+        accountId = readNonEmptyString5(binding.accountId) ?? accountId;
+      }
+    } catch (error) {
+      logger.debug(
+        `Failed to read current conversation binding: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
-    catch {
-        return String(value);
+  }
+  if (!channel || !to) {
+    return void 0;
+  }
+  return findSessionRouteForBinding(
+    {
+      agentId: runtime.routing.agentId,
+      channel,
+      to,
+      accountId
+    },
+    logger
+  );
+}
+async function buildHereText(ctx, runtime, store, logger) {
+  const route = await resolveCurrentCommandRoute(ctx, runtime, logger);
+  if (!route || !route.replyChannel || !route.replyTo) {
+    return [
+      `Unable to resolve the current external session for server=${runtime.server.name}.`,
+      "Run `/eigenflux here` inside the target conversation after OpenClaw has already created a session for it."
+    ].join("\n");
+  }
+  const saved = await writeStoredNotificationRoute(store, runtime.server.name, route, logger);
+  if (!saved) {
+    return `Failed to persist the current EigenFlux route for server=${runtime.server.name}; check plugin logs for details.`;
+  }
+  return [
+    `EigenFlux server ${runtime.server.name} will deliver to this conversation by default:`,
+    `sessionKey: ${route.sessionKey}`,
+    `agentId: ${route.agentId}`,
+    `channel: ${route.replyChannel ?? "unknown"}`,
+    `target: ${route.replyTo ?? "unknown"}`,
+    route.replyAccountId ? `account: ${route.replyAccountId}` : void 0
+  ].filter(Boolean).join("\n");
+}
+async function rememberCurrentCommandRouteIfPossible(ctx, runtime, store, logger) {
+  const route = await resolveCurrentCommandRoute(ctx, runtime, logger);
+  if (!route || !route.replyChannel || !route.replyTo) {
+    return;
+  }
+  if (await writeStoredNotificationRoute(store, runtime.server.name, route, logger)) {
+    logger.debug(
+      `Remembered current command route for server=${runtime.server.name}: session_key=${route.sessionKey}, channel=${route.replyChannel ?? "unknown"}, to=${route.replyTo ?? "unknown"}`
+    );
+  }
+}
+function buildAuthStatusText(runtime) {
+  const authState = runtime.credentialsLoader.loadAuthState();
+  const lines = [`EigenFlux auth status (server=${runtime.server.name}):`];
+  lines.push(`- credentials_path: ${authState.credentialsPath}`);
+  lines.push(`- status: ${authState.status}`);
+  if (authState.expiresAt) {
+    lines.push(`- expires_at: ${authState.expiresAt}`);
+  }
+  if (authState.status === "available") {
+    lines.push(`- token: ${maskToken(authState.accessToken)}`);
+  } else {
+    lines.push("- token: unavailable");
+  }
+  return lines.join("\n");
+}
+async function buildProfileText(runtime, eigenfluxBin) {
+  const result = await execEigenflux(
+    eigenfluxBin,
+    ["profile", "show", "-s", runtime.server.name, "-f", "json"]
+  );
+  if (result.kind === "auth_required") {
+    return buildAuthRequiredPromptTemplate({ context: runtime.getPromptContext() });
+  }
+  if (result.kind === "not_installed") {
+    return `EigenFlux CLI not installed (bin=${result.bin}). Install with: ${INSTALL_COMMAND}`;
+  }
+  if (result.kind === "error") {
+    return `Failed to fetch profile for server ${runtime.server.name}: ${result.error.message}`;
+  }
+  return [
+    `EigenFlux profile (server=${runtime.server.name}):`,
+    "```json",
+    safeJsonStringify(result.data),
+    "```"
+  ].join("\n");
+}
+async function buildFeedText(runtime) {
+  const result = await runtime.feedPoller.pollOnce({
+    notifyFeed: false,
+    notifyAuthRequired: false
+  });
+  switch (result.kind) {
+    case "success":
+      return [
+        `EigenFlux feed result (server=${runtime.server.name}):`,
+        "```json",
+        safeJsonStringify(result.payload),
+        "```"
+      ].join("\n");
+    case "auth_required":
+      return buildAuthRequiredPromptTemplate({ context: runtime.getPromptContext() });
+    case "error":
+      return `EigenFlux feed failed for server ${runtime.server.name}: ${result.error.message}`;
+    default:
+      return `EigenFlux feed finished with an unknown result for server ${runtime.server.name}.`;
+  }
+}
+async function buildVersionText(eigenfluxBin) {
+  const result = await execEigenflux(eigenfluxBin, ["version"]);
+  if (result.kind === "not_installed") {
+    return `EigenFlux CLI not installed (bin=${result.bin}). Install with: ${INSTALL_COMMAND}`;
+  }
+  if (result.kind === "auth_required") {
+    return `EigenFlux CLI reported auth_required while fetching version (stderr: ${result.stderr || "n/a"}).`;
+  }
+  if (result.kind === "error") {
+    return `Failed to fetch eigenflux version: ${result.error.message}`;
+  }
+  const body = typeof result.data === "string" ? result.data : safeJsonStringify(result.data);
+  return ["EigenFlux CLI version:", "```json", body, "```"].join("\n");
+}
+function buildPmStatusText(runtime) {
+  const running = runtime.streamClient.isRunning();
+  const cursor = runtime.streamClient.getLastCursor();
+  const lines = [`EigenFlux PM stream status (server=${runtime.server.name}):`];
+  lines.push(`- streaming: ${running ? "active" : "inactive"}`);
+  if (cursor) {
+    lines.push(`- last_cursor: ${cursor}`);
+  }
+  if (!running) {
+    lines.push("PM stream is not running. Check auth status or restart the service.");
+  }
+  return lines.join("\n");
+}
+function createInMemoryPluginStore() {
+  const data = /* @__PURE__ */ new Map();
+  return {
+    async get(key) {
+      return data.get(key);
+    },
+    async set(key, value) {
+      data.set(key, value);
     }
+  };
+}
+function maskToken(token) {
+  const trimmed = token.trim();
+  if (trimmed.length <= 10) {
+    return `${trimmed.slice(0, 2)}***`;
+  }
+  return `${trimmed.slice(0, 6)}...${trimmed.slice(-4)}`;
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
 }
-//# sourceMappingURL=index.js.map