@phronesis-io/openclaw-eigenflux 0.0.15 → 0.0.17

package/dist/index.js

@@ -444,10 +444,104 @@ var EigenFluxStreamClient = class {
   }
 };
 
+// src/openclaw-context.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_os = require("os");
+var MEMORY_DIR_REL = ["workspace", "memory"];
+var EMPTY_CONTEXT = { memoryDirs: [], sessionSnippets: [] };
+function resolveOpenClawStateDir(logger) {
+  try {
+    const mod = require("openclaw/plugin-sdk/memory-core-host-runtime-core");
+    const dir = mod.resolveStateDir?.();
+    if (dir && typeof dir === "string") return dir;
+  } catch (err) {
+    logger.debug(`resolveOpenClawStateDir: SDK resolveStateDir unavailable: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const cwd = process.cwd();
+  if (cwd && (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "agents"))) return cwd;
+  const home = (0, import_node_path.join)((0, import_node_os.homedir)(), ".openclaw");
+  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(home, "agents"))) return home;
+  return void 0;
+}
+var MAX_SESSION_TURNS = 12;
+var MAX_SESSION_SNIPPET_CHARS = 280;
+function collectOpenClawContext(stateDir, logger, options) {
+  const agentName = options?.agentName ?? "main";
+  const memoryDir = (0, import_node_path.join)(stateDir, ...MEMORY_DIR_REL);
+  return {
+    memoryDirs: (0, import_node_fs.existsSync)(memoryDir) ? [memoryDir] : [],
+    sessionSnippets: readSessionSnippets(stateDir, agentName, logger)
+  };
+}
+function readSessionSnippets(stateDir, agentName, logger) {
+  try {
+    const dir = (0, import_node_path.join)(stateDir, "agents", agentName, "sessions");
+    const latest = latestSessionFile(dir);
+    if (!latest) return [];
+    const lines = (0, import_node_fs.readFileSync)(latest, "utf-8").split("\n");
+    const snippets = [];
+    for (let i = lines.length - 1; i >= 0 && snippets.length < MAX_SESSION_TURNS; i -= 1) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      const text = extractTurnText(line);
+      if (text) snippets.push(text);
+    }
+    return snippets.reverse();
+  } catch (err) {
+    logger.debug(`readSessionSnippets: ${err instanceof Error ? err.message : String(err)}`);
+    return [];
+  }
+}
+function latestSessionFile(dir) {
+  let newest;
+  let entries;
+  try {
+    entries = (0, import_node_fs.readdirSync)(dir);
+  } catch {
+    return void 0;
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".jsonl") || name.endsWith(".trajectory.jsonl")) continue;
+    const path4 = (0, import_node_path.join)(dir, name);
+    try {
+      const mtime = (0, import_node_fs.statSync)(path4).mtimeMs;
+      if (!newest || mtime > newest.mtime) newest = { path: path4, mtime };
+    } catch {
+    }
+  }
+  return newest?.path;
+}
+function extractTurnText(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  if (!obj || typeof obj !== "object") return void 0;
+  const message = obj.message;
+  if (!message || typeof message !== "object") return void 0;
+  const role = message.role;
+  if (role !== "user" && role !== "assistant") return void 0;
+  const content = message.content;
+  let text = "";
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    text = content.filter((c) => !!c && typeof c === "object" && c.type === "text" && typeof c.text === "string").map((c) => c.text).join(" ");
+  }
+  text = text.trim();
+  if (!text) return void 0;
+  if (/EIGENFLUX_FEED_PAYLOAD|profile is due for|EigenFlux feed payload/i.test(text)) return void 0;
+  if (/^(NO_REPLY|HEARTBEAT_OK|Triggered a silent profile refresh)/.test(text)) return void 0;
+  const oneLine = text.replace(/\s+/g, " ");
+  return oneLine.length > MAX_SESSION_SNIPPET_CHARS ? `${oneLine.slice(0, MAX_SESSION_SNIPPET_CHARS)}\u2026` : oneLine;
+}
+
 // src/profile-refresher.ts
 var REFRESH_WINDOW_START = 1;
 var REFRESH_WINDOW_END = 5;
-var ITEMS_LIMIT = 30;
 var EigenFluxProfileRefresher = class {
   constructor(config) {
     this.timeoutId = null;
@@ -472,6 +566,18 @@ var EigenFluxProfileRefresher = class {
     }
     this.config.logger.info(`Stopped profile refresher for server=${this.config.serverName}`);
   }
+  /**
+   * Run a refresh immediately, out of band from the daily timer. Intended for
+   * manual verification (`/eigenflux refresh`) so the full silent loop can be
+   * exercised on demand instead of waiting for the 1–5 AM window. Runs
+   * independently of the timer state — the command path may hold a refresher
+   * instance that was never start()ed, and a manual one-shot should still work.
+   * The next scheduled refresh (if any) is left untouched.
+   */
+  async triggerNow() {
+    this.config.logger.info(`Manual profile refresh triggered for server=${this.config.serverName}`);
+    await this.refresh({ manual: true });
+  }
   scheduleNext() {
     if (!this.running) return;
     const delay = msUntilNextRefresh(/* @__PURE__ */ new Date());
@@ -491,57 +597,98 @@ var EigenFluxProfileRefresher = class {
       this.scheduleNext();
     }, delay);
   }
-  async refresh() {
+  async refresh(opts = {}) {
     this.config.logger.info(`Running profile refresh for server=${this.config.serverName}`);
-    const [profileResult, itemsResult] = await Promise.all([
-      execEigenflux(
-        this.config.eigenfluxBin,
-        ["profile", "show", "-s", this.config.serverName, "-f", "json"],
-        { logger: this.config.logger }
-      ),
-      execEigenflux(
-        this.config.eigenfluxBin,
-        ["profile", "items", "-s", this.config.serverName, "-f", "json", "--limit", String(ITEMS_LIMIT)],
-        { logger: this.config.logger }
-      )
-    ]);
-    if (!this.running) return;
-    if (profileResult.kind === "auth_required" || itemsResult.kind === "auth_required") {
-      this.config.logger.warn(`Profile refresh: auth required for server=${this.config.serverName}`);
-      await this.config.onAuthRequired();
-      return;
+    let context = EMPTY_CONTEXT;
+    if (this.config.collectContext) {
+      try {
+        context = await this.config.collectContext() ?? EMPTY_CONTEXT;
+      } catch (err) {
+        this.config.logger.warn(
+          `Context collection failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
     }
-    if (profileResult.kind === "not_installed" || itemsResult.kind === "not_installed") {
-      this.config.logger.error(`eigenflux CLI not found (bin=${this.config.eigenfluxBin})`);
+    const memoryDirs = context.memoryDirs ?? [];
+    const sessionSnippets = context.sessionSnippets ?? [];
+    if (memoryDirs.length === 0 && sessionSnippets.length === 0) {
+      this.config.logger.info("Profile refresh skipped: no memory/session context");
+      this.emitTelemetry({ outcome: "skipped_no_context", memory_dirs: 0, session_snippets: 0, prompt_bytes: 0, delivered: false });
       return;
     }
-    if (profileResult.kind !== "success") {
-      this.config.logger.error(`Profile fetch failed: ${profileResult.kind}`);
+    if (!opts.manual && !this.running) return;
+    const args = [
+      "profile",
+      "refresh-prompt",
+      "-s",
+      this.config.serverName,
+      ...memoryDirs.flatMap((d) => ["--memory-dir", d]),
+      ...sessionSnippets.flatMap((s) => ["--session-snippet", s])
+    ];
+    const result = await execEigenflux(this.config.eigenfluxBin, args, {
+      logger: this.config.logger,
+      parseJson: false
+    });
+    if (!opts.manual && !this.running) return;
+    if (result.kind === "auth_required") {
+      this.config.logger.warn(`Profile refresh: auth required for server=${this.config.serverName}`);
+      this.emitTelemetry({ outcome: "auth_required", memory_dirs: memoryDirs.length, session_snippets: sessionSnippets.length, prompt_bytes: 0, delivered: false });
+      await this.config.onAuthRequired();
       return;
     }
-    if (itemsResult.kind !== "success") {
-      this.config.logger.error(`Items fetch failed: ${itemsResult.kind}`);
+    if (result.kind === "not_installed") {
+      this.config.logger.error(`eigenflux CLI not found (bin=${this.config.eigenfluxBin})`);
+      this.emitTelemetry({ outcome: "not_installed", memory_dirs: memoryDirs.length, session_snippets: sessionSnippets.length, prompt_bytes: 0, delivered: false });
       return;
     }
-    const profileData = profileResult.data;
-    if (!profileData) {
-      this.config.logger.error("Profile fetch returned empty data");
+    if (result.kind !== "success") {
+      this.config.logger.error(`refresh-prompt failed: ${result.error.message}`);
+      this.emitTelemetry({ outcome: "error", memory_dirs: memoryDirs.length, session_snippets: sessionSnippets.length, prompt_bytes: 0, delivered: false });
       return;
     }
-    const items = itemsResult.data?.items ?? [];
-    if (items.length === 0) {
-      this.config.logger.info("Profile refresh skipped: no recent items");
+    const prompt = (result.data ?? "").trim();
+    if (!prompt) {
+      this.config.logger.info("Profile refresh skipped: CLI produced no prompt");
+      this.emitTelemetry({ outcome: "skipped_no_context", memory_dirs: memoryDirs.length, session_snippets: sessionSnippets.length, prompt_bytes: 0, delivered: false });
       return;
     }
-    const prompt = buildRefreshPrompt(profileData, items);
+    this.config.logger.info(
+      `Profile refresh context: memory_dirs=${memoryDirs.length}, session_snippets=${sessionSnippets.length}`
+    );
     try {
-      if (!this.running) return;
+      if (!opts.manual && !this.running) return;
       await this.config.onRefreshPrompt(prompt);
       this.config.logger.info(`Profile refresh prompt delivered for server=${this.config.serverName}`);
+      this.emitTelemetry({
+        outcome: "delivered",
+        memory_dirs: memoryDirs.length,
+        session_snippets: sessionSnippets.length,
+        prompt_bytes: Buffer.byteLength(prompt, "utf-8"),
+        delivered: true
+      });
     } catch (err) {
       this.config.logger.error(
         `Profile refresh delivery failed: ${err instanceof Error ? err.message : String(err)}`
       );
+      this.emitTelemetry({
+        outcome: "delivery_failed",
+        memory_dirs: memoryDirs.length,
+        session_snippets: sessionSnippets.length,
+        prompt_bytes: Buffer.byteLength(prompt, "utf-8"),
+        delivered: false
+      });
+    }
+  }
+  /**
+   * Emit one structured layer-1 telemetry line. Grep `profile_refresh_telemetry`
+   * in plugin logs to confirm the daily refresh fired and was handed off for
+   * silent delivery. Best-effort: never throws.
+   */
+  emitTelemetry(t) {
+    try {
+      const payload = { server: this.config.serverName, ...t };
+      this.config.logger.info(`profile_refresh_telemetry ${JSON.stringify(payload)}`);
+    } catch {
     }
   }
 };
@@ -556,41 +703,6 @@ function msUntilNextRefresh(now) {
   }
   return target.getTime() - now.getTime();
 }
-function buildRefreshPrompt(profile, items) {
-  const name = profile.profile?.agent_name ?? "(unknown)";
-  const bio = profile.profile?.bio || "(empty)";
-  const totalItems = profile.influence?.total_items ?? 0;
-  const totalConsumed = profile.influence?.total_consumed ?? 0;
-  const totalScored = (profile.influence?.total_scored_1 ?? 0) + (profile.influence?.total_scored_2 ?? 0);
-  const lines = [
-    "Your EigenFlux profile is due for a refresh. Below is your current profile",
-    "and recent broadcast activity.",
-    "",
-    "## Current Profile",
-    `- Name: ${name}`,
-    `- Bio: ${bio}`,
-    `- Influence: ${totalItems} items published, ${totalConsumed} consumed, ${totalScored} scored`,
-    "",
-    "## Recent Broadcasts"
-  ];
-  for (const item of items) {
-    const summary = item.summary || "(no summary)";
-    let line = `- [${item.broadcast_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 broadcasts \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: eigenflux profile update --bio "YOUR NEW BIO"'
-  );
-  return lines.join("\n");
-}
 
 // src/settings-reporter.ts
 function resolveAgentMode(env = process.env) {
@@ -772,26 +884,6 @@ var CredentialsLoader = class {
       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 {
@@ -914,7 +1006,8 @@ function normalizeReplyTarget(value, options) {
 }
 
 // src/config.ts
-var PLUGIN_VERSION = "0.0.15";
+var PLUGIN_VERSION = "0.0.17";
+var EXPECTED_CLI_VERSION = "0.0.13";
 var DEFAULT_EIGENFLUX_BIN = "eigenflux";
 var DEFAULT_SESSION_KEY = "main";
 var DEFAULT_AGENT_ID = "main";
@@ -1004,6 +1097,30 @@ async function discoverServers(eigenfluxBin, logger) {
   logger?.error(`eigenflux server list failed: ${result.error.message}`);
   return { kind: "ok", servers: [] };
 }
+async function getInstalledCliVersion(eigenfluxBin, logger) {
+  const result = await execEigenflux(
+    eigenfluxBin,
+    ["version"],
+    { logger }
+  );
+  if (result.kind === "success" && typeof result.data?.cli_version === "string") {
+    return result.data.cli_version;
+  }
+  return null;
+}
+function isCliOutdated(installed, target) {
+  if (!installed) return false;
+  const parse = (v) => v.split(".").slice(0, 3).map((part) => parseInt(part, 10));
+  const a = parse(installed);
+  const b = parse(target);
+  for (let i = 0; i < 3; i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (Number.isNaN(x) || Number.isNaN(y)) return false;
+    if (x !== y) return x < y;
+  }
+  return false;
+}
 function resolveEigenfluxHome(baseDir) {
   const envHome = process.env.EIGENFLUX_HOME;
   if (envHome) {
@@ -1069,7 +1186,8 @@ var PLUGIN_CONFIG = {
   DEFAULT_AGENT_ID,
   DEFAULT_OPENCLAW_CLI_BIN,
   HOST_KIND,
-  PLUGIN_VERSION
+  PLUGIN_VERSION,
+  EXPECTED_CLI_VERSION
 };
 
 // src/notification-route-resolver.ts
@@ -1686,8 +1804,8 @@ async function resolveNotificationRoute(config, logger, options = {}) {
 }
 
 // src/agent-prompt-templates.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
 var FEED_OUTPUT_CONTRACT_FALLBACK = [
   "OUTPUT CONTRACT \u2014 non-negotiable subset of references/feed.md (full procedure there):",
   "1. Triage silently: push items relevant to the user, discard the rest. Never",
@@ -1713,8 +1831,8 @@ var FEED_OUTPUT_CONTRACT_FALLBACK = [
 ].join("\n");
 function loadFeedOutputContract() {
   try {
-    return (0, import_node_fs.readFileSync)(
-      (0, import_node_path.join)(__dirname, "../skills/ef-broadcast/references/contract.md"),
+    return (0, import_node_fs2.readFileSync)(
+      (0, import_node_path2.join)(__dirname, "../skills/ef-broadcast/references/contract.md"),
       "utf-8"
     ).trim();
   } catch {
@@ -1772,6 +1890,18 @@ function buildNotInstalledPromptTemplate({
     `\`${installCommand}\``
   ].join("\n");
 }
+function buildOutdatedPromptTemplate({
+  installed,
+  expected,
+  updateCommand
+}) {
+  return [
+    "[EIGENFLUX_CLI_OUTDATED]",
+    `The EigenFlux CLI is outdated (installed=${installed}, this plugin expects >=${expected}).`,
+    "Please update it to the latest version. You can run:",
+    `\`${updateCommand}\``
+  ].join("\n");
+}
 function buildPmStreamEventPromptTemplate(event, context) {
   const data = event.data ?? {};
   const parts = [];
@@ -1796,6 +1926,7 @@ function buildPmStreamEventPromptTemplate(event, context) {
 var import_node_crypto = require("crypto");
 var COMMAND_TIMEOUT_MS = 15e3;
 var SUBAGENT_WAIT_TIMEOUT_MS = 18e4;
+var BACKGROUND_LANE = "eigenflux-bg";
 var HEARTBEAT_REASON = "plugin:eigenflux";
 var EigenFluxNotifier = class {
   constructor(api, logger, config) {
@@ -1809,6 +1940,7 @@ var EigenFluxNotifier = class {
   }
   async deliver(message, options) {
     const targetKey = options?.targetSessionKey;
+    const silent = options?.silent === true;
     if (targetKey) {
       await this.drainPendingCleanups();
       const baseRoute = await this.resolveRoute();
@@ -1823,7 +1955,7 @@ var EigenFluxNotifier = class {
       this.logger.info(
         `Delivery route resolved: source=targeted-oneshot, ${formatRouteForLog(route)}, message_preview=${previewMessage(message)}`
       );
-      const result = await this.attemptDelivery(message, route, { skipHeartbeat: true });
+      const result = await this.attemptDelivery(message, route, { skipHeartbeat: true, silent });
       if (result.result.ok) {
         this.logDispatch(result.result);
       } else {
@@ -1836,7 +1968,7 @@ var EigenFluxNotifier = class {
     this.logger.info(
       `Delivery route resolved: source=${initial.source}, ${formatRouteForLog(initial.route)}, message_preview=${previewMessage(message)}`
     );
-    const firstAttempt = await this.attemptDelivery(message, initial.route);
+    const firstAttempt = await this.attemptDelivery(message, initial.route, { silent });
     if (firstAttempt.result.ok) {
       await this.rememberRouteIfChanged(firstAttempt.finalRoute, initial.source);
       this.logDispatch(firstAttempt.result);
@@ -1851,7 +1983,7 @@ var EigenFluxNotifier = class {
         this.logger.info(
           `Retrying delivery with fresh route: source=${fallback.source}, ${formatRouteForLog(fallback.route)}`
         );
-        const retry = await this.attemptDelivery(message, fallback.route);
+        const retry = await this.attemptDelivery(message, fallback.route, { silent });
         if (retry.result.ok) {
           await this.rememberRouteIfChanged(retry.finalRoute, fallback.source);
           this.logDispatch(retry.result);
@@ -1868,11 +2000,12 @@ var EigenFluxNotifier = class {
     return false;
   }
   async attemptDelivery(message, route, options = {}) {
+    const silent = options.silent === true;
     const attempts = [
-      () => this.tryNotifyViaRuntimeSubagent(message, route),
-      () => this.tryNotifyViaRuntimeCommandAgent(message, route)
+      () => this.tryNotifyViaRuntimeSubagent(message, route, silent),
+      () => this.tryNotifyViaRuntimeCommandAgent(message, route, silent)
     ];
-    if (!options.skipHeartbeat) {
+    if (!options.skipHeartbeat && !silent) {
       attempts.push(
         () => this.tryNotifyViaRuntimeHeartbeat(message, route),
         () => this.tryNotifyViaRuntimeCommandHeartbeat(message)
@@ -1902,7 +2035,7 @@ var EigenFluxNotifier = class {
       errors
     };
   }
-  async tryNotifyViaRuntimeSubagent(message, route) {
+  async tryNotifyViaRuntimeSubagent(message, route, silent = false) {
     const runtimeSubagent = this.runtime.subagent;
     if (!runtimeSubagent || typeof runtimeSubagent.run !== "function") {
       return {
@@ -1912,14 +2045,16 @@ var EigenFluxNotifier = class {
       };
     }
     try {
+      const deliver = !silent;
       this.logger.info(
-        `Attempting runtime.subagent delivery: ${formatRouteForLog(route)}, deliver=true`
+        `Attempting runtime.subagent delivery: ${formatRouteForLog(route)}, deliver=${deliver}, lane=${BACKGROUND_LANE}`
       );
       const { runId } = await runtimeSubagent.run({
         sessionKey: route.sessionKey,
         message,
-        deliver: true,
-        idempotencyKey: (0, import_node_crypto.randomUUID)()
+        deliver,
+        idempotencyKey: (0, import_node_crypto.randomUUID)(),
+        lane: BACKGROUND_LANE
       });
       if (typeof runtimeSubagent.waitForRun === "function") {
         const waited = await runtimeSubagent.waitForRun({
@@ -1933,6 +2068,9 @@ var EigenFluxNotifier = class {
             error: `subagent run error${waited.error ? `: ${waited.error}` : ""}`
           };
         }
+        if (waited.status === "timeout") {
+          await this.tryCancelRun(route.sessionKey, runId);
+        }
       }
       return {
         ok: true,
@@ -1948,10 +2086,40 @@ var EigenFluxNotifier = class {
       };
     }
   }
-  async tryNotifyViaRuntimeCommandAgent(message, route) {
+  /**
+   * Best-effort cancel of a background run that outlived SUBAGENT_WAIT_TIMEOUT_MS.
+   * Stopping the wait does not stop the run, so without this the orphaned run
+   * lingers on the host and accumulates. Failures are logged, never thrown.
+   */
+  async tryCancelRun(sessionKey, runId) {
+    const runs = this.runtime.tasks?.runs;
+    if (!runs || typeof runs.bindSession !== "function") {
+      this.logger.debug(
+        `tryCancelRun: runtime.tasks.runs unavailable; cannot cancel run_id=${runId}`
+      );
+      return;
+    }
+    try {
+      const bound = runs.bindSession({ sessionKey });
+      const task = bound.list().find((t) => t.runId === runId);
+      if (!task) {
+        this.logger.warn(
+          `tryCancelRun: no task found for run_id=${runId} on session=${sessionKey}; cannot cancel`
+        );
+        return;
+      }
+      const result = await bound.cancel({ taskId: task.id, cfg: this.api.config });
+      this.logger.warn(
+        `Cancelled stuck background run after ${Math.round(SUBAGENT_WAIT_TIMEOUT_MS / 1e3)}s: run_id=${runId}, task_id=${task.id}, found=${result.found}, cancelled=${result.cancelled}`
+      );
+    } catch (error) {
+      this.logger.warn(`tryCancelRun failed for run_id=${runId}: ${formatError(error)}`);
+    }
+  }
+  async tryNotifyViaRuntimeCommandAgent(message, route, silent = false) {
     return this.runRuntimeCommand(
       "runtime.command.agent",
-      this.buildAgentCliArgs(message, route),
+      this.buildAgentCliArgs(message, route, silent),
       route
     );
   }
@@ -2035,16 +2203,18 @@ var EigenFluxNotifier = class {
       };
     }
   }
-  buildAgentCliArgs(message, route) {
+  buildAgentCliArgs(message, route, silent = false) {
     const args = [
       this.config.openclawCliBin,
       "agent",
       "--message",
       message,
       "--agent",
-      route.agentId,
-      "--deliver"
+      route.agentId
     ];
+    if (!silent) {
+      args.push("--deliver");
+    }
     if (route.replyChannel) {
       args.push("--reply-channel", route.replyChannel);
     }
@@ -2201,7 +2371,7 @@ function formatCommandArgsForLog(argv) {
 }
 
 // src/index.ts
-var COMMAND_NAMES = ["auth", "profile", "servers", "feed", "pm", "here", "version"];
+var COMMAND_NAMES = ["auth", "profile", "refresh", "servers", "feed", "pm", "here", "version"];
 var COMMAND_NAME_SET = new Set(COMMAND_NAMES);
 var DEFAULT_ROUTING = {
   sessionKey: PLUGIN_CONFIG.DEFAULT_SESSION_KEY,
@@ -2227,6 +2397,7 @@ function registerPlugin(api) {
   const store = createInMemoryPluginStore();
   let runtimes = [];
   let notInstalledPromptDelivered = false;
+  let outdatedPromptDelivered = false;
   api.registerService({
     id: "eigenflux:discovery",
     start: async () => {
@@ -2263,6 +2434,23 @@ function registerPlugin(api) {
         await runtime.streamClient.start();
         runtime.profileRefresher.start();
       }
+      if (!outdatedPromptDelivered) {
+        const installedVersion = await getInstalledCliVersion(pluginConfig.eigenfluxBin, logger);
+        if (isCliOutdated(installedVersion, PLUGIN_CONFIG.EXPECTED_CLI_VERSION)) {
+          outdatedPromptDelivered = true;
+          logger.warn(
+            `EigenFlux CLI outdated (installed=${installedVersion}, expected>=${PLUGIN_CONFIG.EXPECTED_CLI_VERSION}); delivering upgrade prompt`
+          );
+          await deliverOutdatedPrompt(
+            api,
+            logger,
+            pluginConfig,
+            installedVersion,
+            PLUGIN_CONFIG.EXPECTED_CLI_VERSION,
+            store
+          );
+        }
+      }
     },
     stop: async () => {
       logger.info("Stopping EigenFlux discovery service...");
@@ -2276,6 +2464,7 @@ function registerPlugin(api) {
       }
       runtimes = [];
       notInstalledPromptDelivered = false;
+      outdatedPromptDelivered = false;
     }
   });
   registerCommand(
@@ -2323,11 +2512,6 @@ var PLUGIN_CONFIG_SCHEMA = (0, import_plugin_entry.buildJsonPluginConfigSchema)(
           replyAccountId: { type: "string" }
         }
       }
-    },
-    _credentialBackup: {
-      type: "object",
-      description: "Internal: persisted credential backups for sandbox environments",
-      additionalProperties: { type: "object" }
     }
   }
 });
@@ -2342,48 +2526,6 @@ var index_default = (0, import_plugin_entry.definePluginEntry)({
   }
 });
 var INSTALL_COMMAND = "curl -fsSL https://eigenflux.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: "eigenflux credential backup" },
-      mutate(draft) {
-        var _a, _b, _c, _d;
-        draft.plugins ?? (draft.plugins = {});
-        (_a = draft.plugins).entries ?? (_a.entries = {});
-        (_b = draft.plugins.entries)["openclaw-eigenflux"] ?? (_b["openclaw-eigenflux"] = {});
-        (_c = draft.plugins.entries["openclaw-eigenflux"]).config ?? (_c.config = {});
-        (_d = draft.plugins.entries["openclaw-eigenflux"].config)._credentialBackup ?? (_d._credentialBackup = {});
-        draft.plugins.entries["openclaw-eigenflux"].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, _eigenfluxHome, bin, store) {
   const notifier = new EigenFluxNotifier(api, logger, {
     sessionKey: DEFAULT_ROUTING.sessionKey,
@@ -2398,24 +2540,26 @@ async function deliverNotInstalledPrompt(api, logger, pluginConfig, _eigenfluxHo
     buildNotInstalledPromptTemplate({ bin, installCommand: INSTALL_COMMAND })
   );
 }
+async function deliverOutdatedPrompt(api, logger, pluginConfig, installed, expected, _store) {
+  const notifier = new EigenFluxNotifier(api, logger, {
+    sessionKey: DEFAULT_ROUTING.sessionKey,
+    agentId: DEFAULT_ROUTING.agentId,
+    replyChannel: DEFAULT_ROUTING.replyChannel,
+    replyTo: DEFAULT_ROUTING.replyTo,
+    replyAccountId: DEFAULT_ROUTING.replyAccountId,
+    openclawCliBin: pluginConfig.openclawCliBin,
+    routeOverrides: DEFAULT_ROUTING.routeOverrides
+  });
+  await notifier.deliver(
+    buildOutdatedPromptTemplate({ installed, expected, updateCommand: INSTALL_COMMAND })
+  );
+}
 function buildFeedSessionKey(serverName) {
   return `eigenflux:feed:${serverName}`;
 }
 function createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome, store) {
   const routing = pluginConfig.serverRouting[server.name] ?? DEFAULT_ROUTING;
   const credentialsLoader = new CredentialsLoader(logger, eigenfluxHome, 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 EigenFluxNotifier(api, logger, {
     store,
     eigenfluxBin: pluginConfig.eigenfluxBin,
@@ -2464,7 +2608,6 @@ function createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome, s
     logger,
     onFeedPolled: async (payload) => {
       resetAuthPromptGate();
-      backupCredentialsToConfig(api, logger, credentialsLoader, server.name);
       const items = payload.data?.items ?? [];
       const notifications = payload.data?.notifications ?? [];
       if (feedDeliveryInFlight && feedDeliveryStartedAt > 0) {
@@ -2526,9 +2669,27 @@ function createServerRuntime(api, logger, pluginConfig, server, eigenfluxHome, s
     serverName: server.name,
     eigenfluxBin: pluginConfig.eigenfluxBin,
     logger,
+    // OpenClaw adapter for the host-agnostic `eigenflux profile refresh-prompt`
+    // core: supply the host-specific inputs (memory dir + extracted session
+    // snippets); the CLI reads the memory markdown and assembles the prompt.
+    // The state dir is resolved via the SDK, NOT api.rootDir (which is the
+    // plugin's install directory). Best-effort; empty on error.
+    //
+    // TODO(multi-host): each host gets its own thin adapter that returns
+    // { memoryDirs, sessionSnippets } and delivers the CLI's prompt silently:
+    //   - Claude Code: memory from CLAUDE.md / ~/.claude memory; session from
+    //     ~/.claude/projects/**/*.jsonl; delivery via the claude/channel
+    //     (note: channel pushes are user-visible — true silence needs more work).
+    //   - Hermes: memory/session locations + silent-delivery mechanism TBD —
+    //     investigate the host before writing the adapter.
+    //   - Codex: memory likely AGENTS.md; session store + delivery TBD.
+    collectContext: () => {
+      const stateDir = resolveOpenClawStateDir(logger);
+      return stateDir ? collectOpenClawContext(stateDir, logger) : EMPTY_CONTEXT;
+    },
     onRefreshPrompt: async (prompt) => {
       resetAuthPromptGate();
-      await notifier.deliver(prompt);
+      await notifier.deliver(prompt, { silent: true });
     },
     onAuthRequired: async () => {
       await notifyAuthRequired({ reason: "auth_required" });
@@ -2588,7 +2749,7 @@ function registerCommand(api, logger, pluginConfig, eigenfluxHome, store, getRun
   };
   api.registerCommand({
     name: "eigenflux",
-    description: "EigenFlux plugin commands: auth, profile, servers, feed, pm, here, version",
+    description: "EigenFlux plugin commands: auth, profile, refresh, servers, feed, pm, here, version",
     acceptsArgs: true,
     handler: async (ctx) => {
       const parsed = parseCommandArgs(ctx.args);
@@ -2625,6 +2786,22 @@ function registerCommand(api, logger, pluginConfig, eigenfluxHome, store, getRun
           return {
             text: await buildProfileText(runtime, pluginConfig.eigenfluxBin)
           };
+        case "refresh": {
+          const probeStateDir = resolveOpenClawStateDir(logger);
+          const probe = probeStateDir ? collectOpenClawContext(probeStateDir, logger) : EMPTY_CONTEXT;
+          void runtime.profileRefresher.triggerNow().catch((err) => {
+            logger.error(
+              `Manual profile refresh failed for server=${runtime.server.name}: ${err instanceof Error ? err.message : String(err)}`
+            );
+          });
+          return {
+            text: [
+              `Triggered a silent profile refresh for server=${runtime.server.name} (running in background).`,
+              `context probe: memory_dirs=${probe.memoryDirs.length}, session=${probe.sessionSnippets.length} snippet(s), stateDir=${probeStateDir ?? "undefined"}`,
+              "No channel reply. Verify via a new agent_bio_history row if the bio changed."
+            ].join("\n")
+          };
+        }
         case "feed":
           return {
             text: await buildFeedText(runtime)
@@ -2715,6 +2892,7 @@ function buildHelpText(runtimes) {
     "",
     "/eigenflux auth \u2014 Show credential status",
     "/eigenflux profile \u2014 Fetch agent profile",
+    "/eigenflux refresh \u2014 Trigger a silent daily-style bio refresh now",
     "/eigenflux servers \u2014 List discovered servers",
     "/eigenflux feed \u2014 Run one feed refresh",
     "/eigenflux pm \u2014 Show PM stream status",