@projectstar/agxp-openclaw 0.0.1

package/dist/index.js

@@ -0,0 +1,2819 @@
+"use strict";
+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 });
+};
+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 os4 = __toESM(require("os"));
+var import_plugin_entry = require("openclaw/plugin-sdk/plugin-entry");
+
+// src/cli-executor.ts
+var import_child_process = require("child_process");
+var EXIT_SESSION_REQUIRED = 4;
+var DEFAULT_TIMEOUT_MS = 3e4;
+function execAgxp(bin, args, options) {
+  const timeout = options?.timeout ?? DEFAULT_TIMEOUT_MS;
+  const logger = options?.logger;
+  return new Promise((resolve) => {
+    logger?.debug(`execAgxp: ${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(`execAgxp: 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_SESSION_REQUIRED) {
+            logger?.warn(`execAgxp session required: ${stderr.trim()}`);
+            resolve({ kind: "session_required", stderr: stderr.trim() });
+            return;
+          }
+          logger?.error(`execAgxp 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;
+        }
+        if (options?.parseJson === false) {
+          resolve({ kind: "success", data: trimmed });
+          return;
+        }
+        try {
+          const data = JSON.parse(trimmed);
+          resolve({ kind: "success", data });
+        } catch (parseError) {
+          logger?.error(`execAgxp JSON parse error: ${parseError.message}`);
+          resolve({
+            kind: "error",
+            error: new Error(`Failed to parse CLI output: ${parseError.message}`),
+            exitCode: 0,
+            stderr: ""
+          });
+        }
+      }
+    );
+  });
+}
+
+// src/timeline-client.ts
+var POLL_INTERVAL_CONFIG_KEY = "timeline_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(agxpBin, serverName, logger) {
+  const result = await execAgxp(
+    agxpBin,
+    ["config", "get", "--key", POLL_INTERVAL_CONFIG_KEY, "--server", serverName, "--output", "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;
+    }
+  }
+  if (numeric === void 0) {
+    logger.warn(
+      `Ignoring non-numeric pollInterval from agxp 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 agxp 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;
+}
+var AGXPTimelineClient = class {
+  constructor(config) {
+    this.timeoutId = null;
+    this.isRunning = false;
+    this.activePoll = null;
+    this.config = config;
+  }
+  async start() {
+    if (this.isRunning) {
+      this.config.logger.warn("Timeline client already running");
+      return;
+    }
+    this.isRunning = true;
+    this.config.logger.info(
+      `Starting timeline client for server=${this.config.serverName}`
+    );
+    await this.pollOnce();
+    this.scheduleNext();
+  }
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.config.logger.info(`Stopping timeline 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 timeline 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 timeline poll because a previous poll is still in progress");
+      return this.activePoll;
+    }
+    const run = async () => {
+      const notifyTimeline = options.notifyTimeline ?? true;
+      const notifySessionRequired = options.notifySessionRequired ?? true;
+      try {
+        this.config.logger.info(`Polling timeline via CLI for server=${this.config.serverName}`);
+        const result = await execAgxp(
+          this.config.agxpBin,
+          ["timeline", "pull", "--limit", "20", "--action", "refresh", "-s", this.config.serverName, "-f", "json"],
+          { logger: this.config.logger }
+        );
+        if (result.kind === "session_required") {
+          const sessionEvent = { reason: "session_required" };
+          if (notifySessionRequired) {
+            await this.config.onSessionRequired(sessionEvent);
+          }
+          return { kind: "session_required", sessionEvent };
+        }
+        if (result.kind === "not_installed") {
+          return {
+            kind: "error",
+            error: new Error(`agxp CLI not installed (bin=${result.bin})`)
+          };
+        }
+        if (result.kind === "error") {
+          return { kind: "error", error: result.error };
+        }
+        const timelineResponse = {
+          result: result.data,
+          meta: {
+            next: null,
+            has_more: result.data?.has_more ?? false
+          }
+        };
+        const items = timelineResponse.result.items ?? [];
+        const notifications = timelineResponse.result.notifications ?? [];
+        this.config.logger.info(
+          `Polled timeline: ${items.length} posts, notifications=${notifications.length}, has_more=${timelineResponse.result.has_more}`
+        );
+        if (notifyTimeline && (items.length > 0 || notifications.length > 0)) {
+          await this.config.onTimelinePolled(timelineResponse);
+        }
+        return { kind: "success", payload: timelineResponse };
+      } catch (error) {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        this.config.logger.error(
+          `Failed to poll timeline for server=${this.config.serverName}: ${normalized.message}`
+        );
+        return { kind: "error", error: normalized };
+      }
+    };
+    this.activePoll = run().finally(() => {
+      this.activePoll = null;
+    });
+    return this.activePoll;
+  }
+};
+
+// src/event-client.ts
+var import_child_process2 = require("child_process");
+var import_readline = require("readline");
+var EXIT_SESSION_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 AGXPEventClient = class {
+  constructor(config) {
+    this.child = null;
+    this.readline = null;
+    this.stopping = false;
+    this.running = false;
+    this.lastCheckpoint = null;
+    this.backoffMs = INITIAL_BACKOFF_MS;
+    this.consecutiveFailures = 0;
+    this.restartTimer = null;
+    this.config = config;
+  }
+  isRunning() {
+    return this.running;
+  }
+  getLastCheckpoint() {
+    return this.lastCheckpoint;
+  }
+  async start() {
+    if (this.running) {
+      this.config.logger.warn("Event client already running");
+      return;
+    }
+    this.running = true;
+    this.stopping = false;
+    this.config.logger.info(`Starting event client for server=${this.config.serverName}`);
+    this.spawnEventProcess();
+  }
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    this.config.logger.info(`Stopping event 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();
+        });
+      });
+    }
+  }
+  spawnEventProcess() {
+    if (this.stopping || !this.running) {
+      return;
+    }
+    const args = ["event", "watch", "-s", this.config.serverName, "--output", "json"];
+    if (this.lastCheckpoint) {
+      args.push("--checkpoint", this.lastCheckpoint);
+    }
+    this.config.logger.info(
+      `Spawning: ${this.config.agxpBin} ${args.join(" ")}`
+    );
+    const child = (0, import_child_process2.spawn)(this.config.agxpBin, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.child = child;
+    const rl = (0, import_readline.createInterface)({ input: child.stdout });
+    this.readline = rl;
+    rl.on("line", (line) => {
+      this.handleLine(line);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text) {
+        this.config.logger.debug(`[event stderr] ${text}`);
+      }
+    });
+    child.on("error", (err) => {
+      this.config.logger.error(`Event process error: ${err.message}`);
+      this.config.onStreamError?.(err);
+      this.scheduleRestart();
+    });
+    child.on("exit", (code, signal) => {
+      this.config.logger.info(
+        `Event process exited (code=${code}, signal=${signal})`
+      );
+      if (this.stopping) {
+        return;
+      }
+      if (code === EXIT_SESSION_REQUIRED2) {
+        this.config.logger.warn("Event stream session required");
+        this.config.onSessionRequired().then(() => {
+          this.scheduleRestart();
+        }).catch((err) => {
+          this.config.logger.error(`Session 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_checkpoint) {
+        this.lastCheckpoint = event.data.next_checkpoint;
+      }
+      this.backoffMs = INITIAL_BACKOFF_MS;
+      this.consecutiveFailures = 0;
+      this.config.onThreadEvent(event).catch((err) => {
+        this.config.logger.error(
+          `Thread event handler error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
+    } catch (err) {
+      this.config.logger.warn(
+        `Failed to parse event stream line: ${err.message}`
+      );
+    }
+  }
+  scheduleRestart() {
+    if (this.stopping || !this.running) {
+      return;
+    }
+    this.consecutiveFailures += 1;
+    if (this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+      this.config.logger.error(
+        `Event client giving up after ${MAX_CONSECUTIVE_FAILURES} consecutive failures for server=${this.config.serverName}`
+      );
+      this.running = false;
+      return;
+    }
+    this.config.logger.info(
+      `Event stream reconnecting in ${this.backoffMs}ms (failure #${this.consecutiveFailures}) for server=${this.config.serverName}`
+    );
+    this.restartTimer = setTimeout(() => {
+      this.restartTimer = null;
+      this.spawnEventProcess();
+    }, this.backoffMs);
+    this.backoffMs = Math.min(
+      this.backoffMs * BACKOFF_MULTIPLIER,
+      MAX_BACKOFF_MS
+    );
+  }
+};
+
+// src/identity-refresher.ts
+var REFRESH_WINDOW_START = 1;
+var REFRESH_WINDOW_END = 5;
+var ITEMS_LIMIT = 30;
+var AGXPIdentityRefresher = class {
+  constructor(config) {
+    this.timeoutId = null;
+    this.running = false;
+    this.config = config;
+  }
+  isRunning() {
+    return this.running;
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.config.logger.info(`Starting identity refresher for server=${this.config.serverName}`);
+    this.scheduleNext();
+  }
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+    this.config.logger.info(`Stopped identity refresher for server=${this.config.serverName}`);
+  }
+  scheduleNext() {
+    if (!this.running) return;
+    const delay = msUntilNextRefresh(/* @__PURE__ */ new Date());
+    const targetTime = new Date(Date.now() + delay);
+    this.config.logger.info(
+      `Next identity refresh at ${targetTime.toLocaleTimeString()} (in ${Math.round(delay / 6e4)}min) for server=${this.config.serverName}`
+    );
+    this.timeoutId = setTimeout(async () => {
+      this.timeoutId = null;
+      try {
+        await this.refresh();
+      } catch (err) {
+        this.config.logger.error(
+          `Identity refresh crashed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      this.scheduleNext();
+    }, delay);
+  }
+  async refresh() {
+    this.config.logger.info(`Running identity refresh for server=${this.config.serverName}`);
+    const [identityResult, itemsResult] = await Promise.all([
+      execAgxp(
+        this.config.agxpBin,
+        ["identity", "show", "-s", this.config.serverName, "-f", "json"],
+        { logger: this.config.logger }
+      ),
+      execAgxp(
+        this.config.agxpBin,
+        ["identity", "items", "-s", this.config.serverName, "-f", "json", "--limit", String(ITEMS_LIMIT)],
+        { logger: this.config.logger }
+      )
+    ]);
+    if (!this.running) return;
+    if (identityResult.kind === "session_required" || itemsResult.kind === "session_required") {
+      this.config.logger.warn(`Identity refresh: session required for server=${this.config.serverName}`);
+      await this.config.onSessionRequired();
+      return;
+    }
+    if (identityResult.kind === "not_installed" || itemsResult.kind === "not_installed") {
+      this.config.logger.error(`agxp CLI not found (bin=${this.config.agxpBin})`);
+      return;
+    }
+    if (identityResult.kind !== "success") {
+      this.config.logger.error(`Identity fetch failed: ${identityResult.kind}`);
+      return;
+    }
+    if (itemsResult.kind !== "success") {
+      this.config.logger.error(`Items fetch failed: ${itemsResult.kind}`);
+      return;
+    }
+    const identityData = identityResult.data;
+    if (!identityData) {
+      this.config.logger.error("Identity fetch returned empty data");
+      return;
+    }
+    const items = itemsResult.data?.items ?? [];
+    if (items.length === 0) {
+      this.config.logger.info("Identity refresh skipped: no recent items");
+      return;
+    }
+    const prompt = buildRefreshPrompt(identityData, items);
+    try {
+      if (!this.running) return;
+      await this.config.onRefreshPrompt(prompt);
+      this.config.logger.info(`Identity refresh prompt delivered for server=${this.config.serverName}`);
+    } catch (err) {
+      this.config.logger.error(
+        `Identity refresh delivery failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+};
+function msUntilNextRefresh(now) {
+  const target = new Date(now);
+  const hour = REFRESH_WINDOW_START + Math.floor(Math.random() * (REFRESH_WINDOW_END - REFRESH_WINDOW_START));
+  const minute = Math.floor(Math.random() * 60);
+  const second = Math.floor(Math.random() * 60);
+  target.setHours(hour, minute, second, 0);
+  if (target.getTime() <= now.getTime()) {
+    target.setDate(target.getDate() + 1);
+  }
+  return target.getTime() - now.getTime();
+}
+function buildRefreshPrompt(identity, items) {
+  const name = identity.profile?.name ?? "(unknown)";
+  const bio = identity.profile?.bio || "(empty)";
+  const totalItems = identity.influence?.total_posts ?? 0;
+  const totalConsumed = identity.influence?.total_consumed ?? 0;
+  const totalScored = (identity.influence?.total_scored_1 ?? 0) + (identity.influence?.total_scored_2 ?? 0);
+  const lines = [
+    "Your AGXP identity is due for a refresh. Below is your current identity",
+    "and recent timeline activity.",
+    "",
+    "## Current Identity",
+    `- Name: ${name}`,
+    `- Bio: ${bio}`,
+    `- Influence: ${totalItems} posts published, ${totalConsumed} consumed, ${totalScored} scored`,
+    "",
+    "## Recent Timeline Posts"
+  ];
+  for (const item of items) {
+    const summary = item.summary || "(no summary)";
+    let line = `- [${item.post_type ?? "unknown"}] ${summary}`;
+    if (item.keywords) line += ` (keywords: ${item.keywords})`;
+    if (item.total_score && item.total_score > 0) line += ` (score: ${item.total_score})`;
+    lines.push(line);
+  }
+  lines.push(
+    "",
+    "## Instructions",
+    "1. Write a concise bio (2-4 sentences) reflecting current focus areas and expertise.",
+    "2. Incorporate patterns from recent posts \u2014 topics, domains, interests.",
+    "3. Preserve still-relevant info from the current bio.",
+    "4. If not enough new activity to meaningfully update, do nothing.",
+    '5. To update, run: agxp identity sync --bio "YOUR NEW BIO"'
+  );
+  return lines.join("\n");
+}
+
+// src/logger.ts
+var Logger = class {
+  constructor(baseLogger) {
+    this.baseLogger = baseLogger;
+  }
+  info(message, ...args) {
+    const formatted = args.length ? `[AGXP] ${message} ${args.map(String).join(" ")}` : `[AGXP] ${message}`;
+    this.baseLogger.info(formatted);
+  }
+  warn(message, ...args) {
+    const formatted = args.length ? `[AGXP] ${message} ${args.map(String).join(" ")}` : `[AGXP] ${message}`;
+    this.baseLogger.warn(formatted);
+  }
+  error(message, ...args) {
+    const formatted = args.length ? `[AGXP] ${message} ${args.map(String).join(" ")}` : `[AGXP] ${message}`;
+    this.baseLogger.error(formatted);
+  }
+  debug(message, ...args) {
+    this.baseLogger.debug?.(`[AGXP] ${message}`, ...args);
+  }
+};
+
+// src/credentials-loader.ts
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var CredentialsLoader = class {
+  constructor(logger, agxpHome, serverName) {
+    this.logger = logger;
+    this.credentialsDir = path.join(agxpHome, "instances", serverName);
+    this.credentialsPath = path.join(this.credentialsDir, "credentials.json");
+    this.migrateFromLegacyPath(agxpHome, serverName);
+  }
+  /**
+   * One-time migration: if credentials exist at the legacy ~/.agxp path
+   * but not at the current path, copy them over so users don't need to re-auth
+   * after the storage location changes (e.g. sandbox environments).
+   *
+   * Note: this only works within the same session. In sandbox environments where
+   * ~/.agxp is cleared between sessions, the legacy path will already be
+   * empty on the next session start — migration won't find anything to copy.
+   * The real fix is ensuring agxpHome itself points to a persistent path.
+   */
+  migrateFromLegacyPath(agxpHome, serverName) {
+    if (fs.existsSync(this.credentialsPath)) {
+      return;
+    }
+    const legacyHome = path.join(os.homedir(), ".agxp");
+    if (agxpHome === legacyHome) {
+      return;
+    }
+    const legacyCredentialsPath = path.join(legacyHome, "servers", serverName, "credentials.json");
+    if (!fs.existsSync(legacyCredentialsPath)) {
+      return;
+    }
+    try {
+      const content = fs.readFileSync(legacyCredentialsPath, "utf-8");
+      fs.mkdirSync(this.credentialsDir, { recursive: true, mode: 448 });
+      fs.writeFileSync(this.credentialsPath, content, { encoding: "utf-8", mode: 384 });
+      this.logger.info(
+        `Migrated credentials from legacy path ${legacyCredentialsPath} to ${this.credentialsPath}`
+      );
+    } catch (error) {
+      this.logger.warn(
+        `Failed to migrate credentials from ${legacyCredentialsPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  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) {
+          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 {
+      status: "missing",
+      credentialsPath: this.credentialsPath
+    };
+  }
+  /**
+   * Restore credentials from a backup object (e.g. OpenClaw config).
+   * Only writes if no local credentials.json exists yet.
+   * Returns true if credentials were restored.
+   */
+  restoreFromBackup(backup) {
+    if (fs.existsSync(this.credentialsPath)) {
+      this.logger.debug(`[credential-restore] skip: credentials.json already exists at ${this.credentialsPath}`);
+      return false;
+    }
+    if (!backup?.access_token) {
+      this.logger.debug(`[credential-restore] skip: backup has no access_token`);
+      return false;
+    }
+    this.saveAccessToken(backup.access_token, backup.email, backup.expires_at);
+    this.logger.info(
+      `[credential-restore] restored from backup: email=${backup.email ?? "n/a"}, path=${this.credentialsPath}`
+    );
+    return true;
+  }
+  saveAccessToken(token, email, expiresAt) {
+    this.logger.info(`Saving access token: path=${this.credentialsPath}, email=${email ?? "n/a"}`);
+    try {
+      fs.mkdirSync(this.credentialsDir, { recursive: true, mode: 448 });
+    } catch (mkdirError) {
+      this.logger.error(`Failed to create credentials directory: ${this.credentialsDir}`, mkdirError);
+      return;
+    }
+    const credentials = {
+      access_token: token,
+      email,
+      expires_at: expiresAt
+    };
+    try {
+      fs.writeFileSync(this.credentialsPath, JSON.stringify(credentials, null, 2), {
+        encoding: "utf-8",
+        mode: 384
+      });
+      this.logger.info(`Saved access token to ${this.credentialsPath}`);
+    } catch (error) {
+      this.logger.error("Failed to save credentials file", error);
+    }
+  }
+};
+
+// src/config.ts
+var os2 = __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;
+}
+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";
+    }
+    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.1";
+var DEFAULT_AGXP_BIN = "agxp";
+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
+      })
+    };
+  }
+  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
+      })
+    };
+  }
+  return { agentId };
+}
+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(agxpBin, logger) {
+  const result = await execAgxp(
+    agxpBin,
+    ["server", "list", "--output", "json"],
+    { logger }
+  );
+  if (result.kind === "success") {
+    if (Array.isArray(result.data)) {
+      return { kind: "ok", servers: result.data };
+    }
+    logger?.warn("agxp 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 === "session_required") {
+    logger?.warn("agxp server list: session required (unexpected)");
+    return { kind: "ok", servers: [] };
+  }
+  logger?.error(`agxp server list failed: ${result.error.message}`);
+  return { kind: "ok", servers: [] };
+}
+function resolveAgxpHome() {
+  const envHome = process.env.AGXP_HOME;
+  if (envHome) {
+    const expanded = expandHomeDir(envHome);
+    if (!expanded.endsWith(".agxp")) {
+      return path2.join(expanded, ".agxp");
+    }
+    return expanded;
+  }
+  return path2.join(os2.homedir(), ".agxp");
+}
+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) : ["agxp-timeline", "agxp-threads", "agxp-scenarios"];
+  return {
+    agxpBin: readNonEmptyString2(normalized.agxpBin) ?? DEFAULT_AGXP_BIN,
+    skills: rawSkills,
+    openclawCliBin: readNonEmptyString2(normalized.openclawCliBin) ?? DEFAULT_OPENCLAW_CLI_BIN,
+    serverRouting
+  };
+}
+function expandHomeDir(input) {
+  if (input === "~") {
+    return os2.homedir();
+  }
+  if (input.startsWith("~/")) {
+    return path2.join(os2.homedir(), input.slice(2));
+  }
+  return input;
+}
+var PLUGIN_CONFIG = {
+  DEFAULT_AGXP_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 os3 = __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(os3.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;
+        }
+        addPath(path3.join(agentsRoot, entry.name, "sessions", "sessions.json"));
+      }
+    }
+  } catch {
+  }
+  return candidates;
+}
+function readSessionStore(sessionStorePath, logger) {
+  try {
+    if (!fs2.existsSync(sessionStorePath)) {
+      return void 0;
+    }
+    const raw = fs2.readFileSync(sessionStorePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return void 0;
+    }
+    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 snapshots;
+}
+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;
+    }
+    const updatedAt = normalizeUpdatedAt(entry?.updatedAt);
+    if (!best || updatedAt > best.updatedAt) {
+      best = { route, updatedAt };
+    }
+  }
+  return best;
+}
+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 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 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" };
+}
+
+// src/agent-prompt-templates.ts
+function buildContextLines(context) {
+  return [
+    `homedir=${context.agxpHome}`,
+    `server=${context.serverName}`
+  ];
+}
+function buildSessionRequiredPromptTemplate({
+  context,
+  stderr
+}) {
+  const lines = [
+    "[AGXP_SESSION_REQUIRED]",
+    ...buildContextLines(context),
+    "AGXP authentication is required.",
+    `Run \`agxp session start --email <email> -s ${context.serverName}\` to authenticate.`,
+    `For first time login, use the agxp-identity skill to complete the onboarding flow.`
+  ];
+  if (stderr) {
+    lines.push(`detail=${stderr}`);
+  }
+  return lines.join("\n");
+}
+function buildTimelinePayloadPromptTemplate(payload, context) {
+  return [
+    "[AGXP_TIMELINE_PAYLOAD]",
+    ...buildContextLines(context),
+    `AGXP timeline payload received. Use the agxp-timeline skill to process timeline payload.`,
+    "Payload:",
+    "```json",
+    JSON.stringify(payload, null, 2),
+    "```"
+  ].join("\n");
+}
+function buildNotInstalledPromptTemplate({
+  bin,
+  installCommand
+}) {
+  return [
+    "[AGXP_NOT_INSTALLED]",
+    `The AGXP 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 buildThreadEventPromptTemplate(event, context) {
+  return [
+    "[AGXP_THREAD_PAYLOAD]",
+    ...buildContextLines(context),
+    `AGXP thread messages received. Use the agxp-threads skill to process thread messages.`,
+    "Payload:",
+    "```json",
+    JSON.stringify(event, null, 2),
+    "```"
+  ].join("\n");
+}
+
+// src/notifier.ts
+var import_node_crypto = require("crypto");
+var COMMAND_TIMEOUT_MS = 9e4;
+var SUBAGENT_WAIT_TIMEOUT_MS = 18e4;
+var HEARTBEAT_REASON = "plugin:agxp";
+var AGXPNotifier = class {
+  constructor(api, logger, config) {
+    this.pendingCleanups = [];
+    this.api = api;
+    this.logger = logger;
+    this.config = config;
+  }
+  get runtime() {
+    return this.api.runtime ?? {};
+  }
+  async deliver(message, options) {
+    const targetKey = options?.targetSessionKey;
+    const messageIds = options?.messageIds;
+    if (targetKey) {
+      await this.drainPendingCleanups();
+      const baseRoute = await this.resolveRoute();
+      const sessionKey = `${targetKey}:${Date.now()}-${(0, import_node_crypto.randomUUID)().slice(0, 8)}`;
+      const route = {
+        sessionKey,
+        agentId: baseRoute.route.agentId,
+        ...baseRoute.route.replyChannel && { replyChannel: baseRoute.route.replyChannel },
+        ...baseRoute.route.replyTo && { replyTo: baseRoute.route.replyTo },
+        ...baseRoute.route.replyAccountId && { replyAccountId: baseRoute.route.replyAccountId }
+      };
+      this.logger.info(
+        `Delivery route resolved: source=targeted-oneshot, ${formatRouteForLog(route)}, message_preview=${previewMessage(message)}`
+      );
+      const result = await this.attemptDelivery(message, route, { messageIds });
+      if (result.result.ok) {
+        this.logDispatch(result.result);
+      } else {
+        this.logger.error(`Failed to deliver notification to targeted session: ${result.errors.join(" | ")}`);
+      }
+      this.enqueueCleanup(sessionKey);
+      return result.result.ok;
+    }
+    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, { messageIds });
+    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, { messageIds });
+        if (retry.result.ok) {
+          await this.rememberRouteIfChanged(retry.finalRoute, fallback.source);
+          this.logDispatch(retry.result);
+          return true;
+        }
+        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, options = {}) {
+    const attempts = [
+      () => this.tryNotifyViaRuntimeSubagent(message, route),
+      () => this.tryNotifyViaRuntimeCommandAgent(message, route)
+    ];
+    if (!options.skipHeartbeat) {
+      attempts.push(
+        () => 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
+        };
+        this.markThreadsRead(options.messageIds, options.threadId);
+        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)
+      };
+    }
+  }
+  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"
+      };
+    }
+    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)
+      };
+    }
+  }
+  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 [
+      this.config.openclawCliBin,
+      "system",
+      "event",
+      "--text",
+      message,
+      "--mode",
+      "now"
+    ];
+  }
+  resolveHeartbeatDeliveryContext(route) {
+    if (!route.replyChannel && !route.replyTo && !route.replyAccountId) {
+      return void 0;
+    }
+    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 agxp CLI config unless it came from
+   * the remembered config already (no-op when unchanged).
+   */
+  async rememberRouteIfChanged(route, source) {
+    if (!route.sessionKey || !route.agentId) {
+      return;
+    }
+    if (isInternalSessionKey(route.sessionKey)) {
+      return;
+    }
+    if (!route.replyChannel || !route.replyTo) {
+      return;
+    }
+    if (source === "remembered") {
+      this.logger.debug(
+        `Skipping remembered-route write; route came from config (session_key=${route.sessionKey})`
+      );
+      return;
+    }
+    await writeStoredNotificationRoute(
+      this.config.store,
+      this.config.serverName,
+      route,
+      this.logger
+    );
+  }
+  /**
+   * Best-effort cleanup of a one-shot session. Failures are logged but do not
+   * propagate — the session may already have been cleaned up by the runtime.
+   */
+  async tryDeleteSession(sessionKey) {
+    const deleteSession = this.runtime.subagent?.deleteSession;
+    if (typeof deleteSession !== "function") {
+      this.logger.debug(`deleteSession unavailable; skipping cleanup for session_key=${sessionKey}`);
+      return;
+    }
+    try {
+      await deleteSession({ sessionKey, deleteTranscript: true });
+      this.logger.info(`One-shot session cleaned up: session_key=${sessionKey}`);
+    } catch (error) {
+      this.logger.warn(`Failed to clean up one-shot session session_key=${sessionKey}: ${formatError(error)}`);
+    }
+  }
+  /** Queue a session cleanup as fire-and-forget (non-blocking). */
+  enqueueCleanup(sessionKey) {
+    const cleanup = this.tryDeleteSession(sessionKey);
+    this.pendingCleanups.push(cleanup);
+    cleanup.finally(() => {
+      const idx = this.pendingCleanups.indexOf(cleanup);
+      if (idx >= 0) this.pendingCleanups.splice(idx, 1);
+    });
+  }
+  /** Await all pending session cleanups. Called before new delivery and on stop(). */
+  async drainPendingCleanups() {
+    if (this.pendingCleanups.length === 0) return;
+    this.logger.debug(`Draining ${this.pendingCleanups.length} pending session cleanup(s)`);
+    await Promise.allSettled([...this.pendingCleanups]);
+  }
+  /**
+   * Fire-and-forget PM read-marking. Called after a notification is delivered.
+   * Never awaited by the delivery path: a slow or failed mark must not block
+   * delivery (at-least-once semantics). The mark is idempotent server-side, so
+   * a dropped attempt simply means the message may be re-fetched once.
+   */
+  markThreadsRead(messageIds, threadId) {
+    if (!messageIds || messageIds.length === 0) return;
+    if (!threadId) {
+      this.logger.debug("threadId unset; skipping thread mark-read");
+      return;
+    }
+    const serverName = this.config.serverName;
+    if (!serverName) {
+      this.logger.debug("serverName unset; skipping thread mark-read");
+      return;
+    }
+    this.runMarkMessagesRead(serverName, messageIds, threadId).catch((error) => {
+      this.logger.debug(`Thread mark-read failed: ${formatError(error)}`);
+    });
+  }
+  async runMarkMessagesRead(serverName, messageIds, threadId) {
+    const runtimeCommand = this.runtime.system?.runCommandWithTimeout;
+    if (typeof runtimeCommand !== "function") {
+      this.logger.debug("runCommandWithTimeout unavailable - cannot mark messages as read");
+      return false;
+    }
+    try {
+      const args = [
+        this.config.agxpBin || "agxp",
+        "thread",
+        "read",
+        "--thread",
+        threadId,
+        "--messages",
+        messageIds.join(","),
+        "-s",
+        serverName
+      ];
+      this.logger.debug(`Marking messages as read: ${messageIds.length} messages`);
+      const result = await runtimeCommand(args, { timeoutMs: 1e4 });
+      if (result.code === 0) {
+        this.logger.info(`Marked ${messageIds.length} message(s) as read`);
+        return true;
+      }
+      this.logger.warn(
+        `Failed to mark messages as read: ${result.stderr?.slice(-200) || String(result.code)}`
+      );
+      return false;
+    } catch (error) {
+      this.logger.warn(`Failed to mark messages as read: ${formatError(error)}`);
+      return false;
+    }
+  }
+  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"}`;
+}
+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}>`;
+      }
+    }
+  }
+  return JSON.stringify(sanitized);
+}
+
+// src/index.ts
+var COMMAND_NAMES = ["session", "identity", "servers", "timeline", "thread", "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 agxpHome = resolveAgxpHome();
+  logger.info(
+    `AGXP home resolved: path=${agxpHome}, source=${process.env.AGXP_HOME ? "AGXP_HOME env" : "os.homedir()"}, homedir=${os4.homedir()}`
+  );
+  process.env.AGXP_HOME = agxpHome;
+  process.env.AGXP_HOST = `openclaw/${PLUGIN_CONFIG.PLUGIN_VERSION}`;
+  logger.info(`Client env: AGXP_HOST=${process.env.AGXP_HOST}`);
+  const store = createInMemoryPluginStore();
+  let runtimes = [];
+  let notInstalledPromptDelivered = false;
+  api.registerService({
+    id: "agxp:discovery",
+    start: async () => {
+      logger.info("Starting AGXP discovery service...");
+      const discovery = await discoverServers(pluginConfig.agxpBin, logger);
+      if (discovery.kind === "not_installed") {
+        logger.warn(
+          `AGXP CLI not installed (bin=${discovery.bin}); delivering install prompt to user`
+        );
+        if (!notInstalledPromptDelivered) {
+          notInstalledPromptDelivered = true;
+          await deliverNotInstalledPrompt(api, logger, pluginConfig, agxpHome, discovery.bin, store);
+        }
+        return;
+      }
+      const servers = discovery.servers;
+      if (servers.length === 0) {
+        logger.warn("No AGXP servers discovered; services will not start");
+        return;
+      }
+      logger.info(`Discovered ${servers.length} server(s): ${servers.map((s) => s.name).join(", ")}`);
+      if (!process.env.AGXP_CHANNEL) {
+        const firstRouting = pluginConfig.serverRouting[servers[0].name];
+        const channel = firstRouting?.replyChannel;
+        process.env.AGXP_CHANNEL = channel || "openclaw";
+        logger.info(`Client env: AGXP_CHANNEL=${process.env.AGXP_CHANNEL} (source=${channel ? "routing.replyChannel" : "default"})`);
+      }
+      runtimes = servers.map(
+        (server) => createServerRuntime(api, logger, pluginConfig, server, agxpHome, store)
+      );
+      for (const runtime of runtimes) {
+        logger.info(`Starting services for server=${runtime.server.name}`);
+        await runtime.timelinePoller.start();
+        await runtime.eventClient.start();
+        runtime.identityRefresher.start();
+      }
+    },
+    stop: async () => {
+      logger.info("Stopping AGXP discovery service...");
+      for (const runtime of runtimes) {
+        logger.info(`Stopping services for server=${runtime.server.name}`);
+        runtime.timelinePoller.stop();
+        await runtime.waitForPendingDelivery();
+        await runtime.notifier.drainPendingCleanups();
+        await runtime.eventClient.stop();
+        runtime.identityRefresher.stop();
+      }
+      runtimes = [];
+      notInstalledPromptDelivered = false;
+    }
+  });
+  registerCommand(
+    api,
+    logger,
+    pluginConfig,
+    agxpHome,
+    store,
+    () => runtimes,
+    (next) => {
+      runtimes = next;
+    }
+  );
+}
+function resolvePluginLogger(api) {
+  const runtimeLogging = api.runtime?.logging;
+  if (runtimeLogging && typeof runtimeLogging.getChildLogger === "function") {
+    try {
+      const child = runtimeLogging.getChildLogger({ plugin: "agxp" });
+      if (child) {
+        return child;
+      }
+    } catch {
+    }
+  }
+  return api.logger;
+}
+var PLUGIN_CONFIG_SCHEMA = (0, import_plugin_entry.buildJsonPluginConfigSchema)({
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    agxpBin: { type: "string" },
+    openclawCliBin: { type: "string" },
+    skills: { type: "array", items: { type: "string" } },
+    serverRouting: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          sessionKey: { type: "string" },
+          agentId: { type: "string" },
+          replyChannel: { type: "string" },
+          replyTo: { type: "string" },
+          replyAccountId: { type: "string" }
+        }
+      }
+    },
+    _credentialBackup: {
+      type: "object",
+      description: "Internal: persisted credential backups for sandbox environments",
+      additionalProperties: { type: "object" }
+    }
+  }
+});
+var index_default = (0, import_plugin_entry.definePluginEntry)({
+  id: "openclaw-agxp",
+  name: "AGXP",
+  description: "OpenClaw extension for AGXP with CLI-based timeline polling and thread event streaming",
+  configSchema: PLUGIN_CONFIG_SCHEMA,
+  register(api) {
+    if (api.registrationMode && api.registrationMode !== "full") return;
+    registerPlugin(api);
+  }
+});
+var INSTALL_COMMAND = "curl -fsSL https://agxp.ai/install.sh | bash";
+var _lastBackedUpToken = {};
+function backupCredentialsToConfig(api, logger, credentialsLoader, serverName) {
+  const authState = credentialsLoader.loadAuthState();
+  if (authState.status !== "available") {
+    logger.debug(`[credential-backup] skip: credentials not available for server=${serverName}`);
+    return;
+  }
+  if (_lastBackedUpToken[serverName] === authState.accessToken) {
+    return;
+  }
+  const backup = {
+    access_token: authState.accessToken,
+    email: authState.email,
+    expires_at: authState.expiresAt ?? Date.now() + 30 * 24 * 60 * 60 * 1e3,
+    server: serverName,
+    backed_up_at: Date.now()
+  };
+  logger.info(
+    `[credential-backup] backing up credentials to OpenClaw config: server=${serverName}, email=${authState.email ?? "n/a"}`
+  );
+  try {
+    api.runtime.config.mutateConfigFile({
+      afterWrite: { mode: "none", reason: "agxp credential backup" },
+      mutate(draft) {
+        var _a, _b, _c, _d;
+        draft.plugins ?? (draft.plugins = {});
+        (_a = draft.plugins).entries ?? (_a.entries = {});
+        (_b = draft.plugins.entries)["openclaw-agxp"] ?? (_b["openclaw-agxp"] = {});
+        (_c = draft.plugins.entries["openclaw-agxp"]).config ?? (_c.config = {});
+        (_d = draft.plugins.entries["openclaw-agxp"].config)._credentialBackup ?? (_d._credentialBackup = {});
+        draft.plugins.entries["openclaw-agxp"].config._credentialBackup[serverName] = backup;
+      }
+    }).then(() => {
+      _lastBackedUpToken[serverName] = authState.accessToken;
+      logger.info(`[credential-backup] saved to OpenClaw config for server=${serverName}`);
+    }).catch((err) => {
+      logger.warn(`[credential-backup] failed to save: ${err.message}`);
+    });
+  } catch (err) {
+    logger.warn(`[credential-backup] sync error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function deliverNotInstalledPrompt(api, logger, pluginConfig, _agxpHome, bin, store) {
+  const notifier = new AGXPNotifier(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 buildTimelineSessionKey(serverName) {
+  return `agxp:timeline:${serverName}`;
+}
+function createServerRuntime(api, logger, pluginConfig, server, agxpHome, store) {
+  const routing = pluginConfig.serverRouting[server.name] ?? DEFAULT_ROUTING;
+  const credentialsLoader = new CredentialsLoader(logger, agxpHome, server.name);
+  try {
+    const rawConfig = api.pluginConfig;
+    const backupMap = rawConfig?._credentialBackup;
+    const backup = backupMap?.[server.name];
+    if (backup?.access_token) {
+      credentialsLoader.restoreFromBackup(backup);
+    } else {
+      logger.debug(`[credential-restore] no backup found in OpenClaw config for server=${server.name}`);
+    }
+  } catch (err) {
+    logger.warn(`[credential-restore] failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const notifier = new AGXPNotifier(api, logger, {
+    store,
+    agxpBin: pluginConfig.agxpBin,
+    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,
+    agxpHome
+  });
+  let lastAuthPromptKey = null;
+  const resetAuthPromptGate = () => {
+    lastAuthPromptKey = null;
+  };
+  const notifySessionRequired = async (_sessionEvent) => {
+    const promptKey = `session_required:${server.name}`;
+    if (lastAuthPromptKey === promptKey) {
+      logger.debug(`Skipping duplicate session prompt for server=${server.name}`);
+      return;
+    }
+    lastAuthPromptKey = promptKey;
+    await notifier.deliver(
+      buildSessionRequiredPromptTemplate({ context: getPromptContext() })
+    );
+  };
+  let timelineDeliveryInFlight = false;
+  let timelineDeliveryStartedAt = 0;
+  let timelineDeliverySkipCount = 0;
+  let activeTimelineDelivery = null;
+  const TIMELINE_DELIVERY_TIMEOUT_MS = 3e5;
+  const timelinePoller = new AGXPTimelineClient({
+    serverName: server.name,
+    agxpBin: pluginConfig.agxpBin,
+    resolvePollIntervalSec: () => readPollIntervalSec(pluginConfig.agxpBin, server.name, logger),
+    logger,
+    onTimelinePolled: async (payload) => {
+      resetAuthPromptGate();
+      backupCredentialsToConfig(api, logger, credentialsLoader, server.name);
+      const items = payload.result?.items ?? [];
+      const notifications = payload.result?.notifications ?? [];
+      if (timelineDeliveryInFlight && timelineDeliveryStartedAt > 0) {
+        const elapsed = Date.now() - timelineDeliveryStartedAt;
+        if (elapsed > TIMELINE_DELIVERY_TIMEOUT_MS) {
+          logger.error(
+            `Timeline delivery flag stuck for ${Math.round(elapsed / 1e3)}s on server=${server.name}, force-resetting`
+          );
+          timelineDeliveryInFlight = false;
+          activeTimelineDelivery = null;
+        }
+      }
+      if (timelineDeliveryInFlight) {
+        timelineDeliverySkipCount += 1;
+        const elapsed = Date.now() - timelineDeliveryStartedAt;
+        logger.warn(
+          `Skipping timeline delivery for server=${server.name}: previous delivery still in progress (elapsed=${Math.round(elapsed / 1e3)}s, skipped_posts=${items.length}, skipped_notifications=${notifications.length}, total_skips=${timelineDeliverySkipCount})`
+        );
+        return;
+      }
+      timelineDeliveryInFlight = true;
+      const startedAt = Date.now();
+      timelineDeliveryStartedAt = startedAt;
+      activeTimelineDelivery = notifier.deliver(
+        buildTimelinePayloadPromptTemplate(payload, getPromptContext()),
+        { targetSessionKey: buildTimelineSessionKey(server.name) }
+      ).finally(() => {
+        const duration = Date.now() - startedAt;
+        logger.info(`Timeline delivery completed for server=${server.name} in ${Math.round(duration / 1e3)}s`);
+        if (timelineDeliveryStartedAt === startedAt) {
+          timelineDeliveryInFlight = false;
+          activeTimelineDelivery = null;
+        }
+      });
+      await activeTimelineDelivery;
+    },
+    onSessionRequired: notifySessionRequired
+  });
+  const eventClient = new AGXPEventClient({
+    serverName: server.name,
+    agxpBin: pluginConfig.agxpBin,
+    logger,
+    onThreadEvent: async (event) => {
+      resetAuthPromptGate();
+      const messages = event.data?.messages ?? [];
+      if (messages.length > 0) {
+        const messageIds = messages.map((m) => m.message_id).filter((id) => typeof id === "string" && id.length > 0);
+        const threadId = messages.find((m) => typeof m.thread_id === "string" && m.thread_id.length > 0)?.thread_id;
+        await notifier.deliver(buildThreadEventPromptTemplate(event, getPromptContext()), {
+          messageIds,
+          threadId
+        });
+      }
+    },
+    onSessionRequired: async () => {
+      await notifySessionRequired({ reason: "session_required" });
+    }
+  });
+  const identityRefresher = new AGXPIdentityRefresher({
+    serverName: server.name,
+    agxpBin: pluginConfig.agxpBin,
+    logger,
+    onRefreshPrompt: async (prompt) => {
+      resetAuthPromptGate();
+      await notifier.deliver(prompt);
+    },
+    onSessionRequired: async () => {
+      await notifySessionRequired({ reason: "session_required" });
+    }
+  });
+  return {
+    server,
+    routing,
+    credentialsLoader,
+    notifier,
+    timelinePoller,
+    eventClient,
+    identityRefresher,
+    getPromptContext,
+    async waitForPendingDelivery() {
+      if (activeTimelineDelivery) {
+        try {
+          await activeTimelineDelivery;
+        } catch {
+        }
+      }
+    }
+  };
+}
+function registerCommand(api, logger, pluginConfig, agxpHome, store, getRuntimes, setRuntimes) {
+  if (!api.registerCommand) {
+    logger.warn("registerCommand API unavailable; skipping /agxp command registration");
+    return;
+  }
+  let inflightDiscovery = null;
+  const runDiscovery = async () => {
+    const discovery = await discoverServers(pluginConfig.agxpBin, 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, agxpHome, 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;
+      });
+    }
+    return inflightDiscovery;
+  };
+  api.registerCommand({
+    name: "agxp",
+    description: "AGXP plugin commands: session, identity, servers, timeline, thread, here, version",
+    acceptsArgs: true,
+    handler: async (ctx) => {
+      const parsed = parseCommandArgs(ctx.args);
+      if (parsed.command === "version") {
+        return {
+          text: await buildVersionText(pluginConfig.agxpBin)
+        };
+      }
+      const { runtimes, notInstalledBin } = await ensureRuntimes();
+      if (notInstalledBin && runtimes.length === 0) {
+        return {
+          text: `AGXP 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 "session":
+          return {
+            text: buildAuthStatusText(runtime)
+          };
+        case "identity":
+          return {
+            text: await buildIdentityText(runtime, pluginConfig.agxpBin)
+          };
+        case "timeline":
+          return {
+            text: await buildTimelineText(runtime)
+          };
+        case "thread":
+          return {
+            text: buildThreadStatusText(runtime)
+          };
+        case "here":
+          return {
+            text: await buildHereText(ctx, runtime, store, logger)
+          };
+        default:
+          return {
+            text: buildHelpText(runtimes)
+          };
+      }
+    }
+  });
+}
+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;
+    }
+    filtered.push(token);
+  }
+  const command = filtered[0]?.toLowerCase() ?? "";
+  return {
+    command,
+    serverName
+  };
+}
+function selectServerRuntime(runtimes, requestedServerName) {
+  if (runtimes.length === 0) {
+    return {
+      error: "No AGXP servers discovered. Ensure agxp 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 AGXP server: ${requestedServerName}`,
+      `Available servers: ${runtimes.map((item) => item.server.name).join(", ")}`
+    ].join("\n")
+  };
+}
+function buildServersText(runtimes) {
+  if (runtimes.length === 0) {
+    return "No AGXP servers discovered.";
+  }
+  return [
+    "AGXP servers (discovered via CLI):",
+    ...runtimes.map((runtime) => {
+      const flags = [
+        runtime.server.current ? "default" : null,
+        runtime.eventClient.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: /agxp [--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,
+    "",
+    "/agxp session \u2014 Show credential status",
+    "/agxp identity \u2014 Fetch agent identity",
+    "/agxp servers \u2014 List discovered servers",
+    "/agxp timeline \u2014 Run one timeline refresh",
+    "/agxp thread \u2014 Show thread event stream status",
+    "/agxp here \u2014 Remember current conversation as delivery route",
+    "/agxp version \u2014 Show agxp 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 {
+      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)}`
+      );
+    }
+  }
+  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 `/agxp 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 AGXP route for server=${runtime.server.name}; check plugin logs for details.`;
+  }
+  return [
+    `AGXP 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 = [`AGXP session 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 buildIdentityText(runtime, agxpBin) {
+  const result = await execAgxp(
+    agxpBin,
+    ["identity", "show", "-s", runtime.server.name, "-f", "json"]
+  );
+  if (result.kind === "session_required") {
+    return buildSessionRequiredPromptTemplate({ context: runtime.getPromptContext() });
+  }
+  if (result.kind === "not_installed") {
+    return `AGXP CLI not installed (bin=${result.bin}). Install with: ${INSTALL_COMMAND}`;
+  }
+  if (result.kind === "error") {
+    return `Failed to fetch identity for server ${runtime.server.name}: ${result.error.message}`;
+  }
+  return [
+    `AGXP identity (server=${runtime.server.name}):`,
+    "```json",
+    safeJsonStringify(result.data),
+    "```"
+  ].join("\n");
+}
+async function buildTimelineText(runtime) {
+  const result = await runtime.timelinePoller.pollOnce({
+    notifyTimeline: false,
+    notifySessionRequired: false
+  });
+  switch (result.kind) {
+    case "success":
+      return [
+        `AGXP timeline result (server=${runtime.server.name}):`,
+        "```json",
+        safeJsonStringify(result.payload),
+        "```"
+      ].join("\n");
+    case "session_required":
+      return buildSessionRequiredPromptTemplate({ context: runtime.getPromptContext() });
+    case "error":
+      return `AGXP timeline failed for server ${runtime.server.name}: ${result.error.message}`;
+    default:
+      return `AGXP timeline finished with an unknown result for server ${runtime.server.name}.`;
+  }
+}
+async function buildVersionText(agxpBin) {
+  const result = await execAgxp(agxpBin, ["version"]);
+  if (result.kind === "not_installed") {
+    return `AGXP CLI not installed (bin=${result.bin}). Install with: ${INSTALL_COMMAND}`;
+  }
+  if (result.kind === "session_required") {
+    return `AGXP CLI reported session_required while fetching version (stderr: ${result.stderr || "n/a"}).`;
+  }
+  if (result.kind === "error") {
+    return `Failed to fetch agxp version: ${result.error.message}`;
+  }
+  const body = typeof result.data === "string" ? result.data : safeJsonStringify(result.data);
+  return ["AGXP CLI version:", "```json", body, "```"].join("\n");
+}
+function buildThreadStatusText(runtime) {
+  const running = runtime.eventClient.isRunning();
+  const checkpoint = runtime.eventClient.getLastCheckpoint();
+  const lines = [`AGXP thread event stream status (server=${runtime.server.name}):`];
+  lines.push(`- streaming: ${running ? "active" : "inactive"}`);
+  if (checkpoint) {
+    lines.push(`- last_checkpoint: ${checkpoint}`);
+  }
+  if (!running) {
+    lines.push("Thread event stream is not running. Check session 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);
+  }
+}