@okxweb3/a2a-node 0.2.3 → 0.2.4-beta-e7a52faf6f-260812104443

package/dist/index.js

@@ -32104,7 +32104,7 @@ var init_sentry_config = __esm({
     environment = process.env.SENTRY_ENV === "dev" ? "dev" : "prod";
     SENTRY_CONFIG = {
       projectName: "okx/openclaw-okx-a2a-extension",
-      release: "0.2.3",
+      release: "0.2.4-beta-e7a52faf6f-260812104443",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -33045,7 +33045,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.3" : null;
+  return true ? "0.2.4-beta-e7a52faf6f-260812104443" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -33255,7 +33255,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.3") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.4-beta-e7a52faf6f-260812104443") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -43946,6 +43946,8 @@ var index_exports = {};
 __export(index_exports, {
   AI_PROVIDERS: () => AI_PROVIDERS,
   AgentMessageDirection: () => AgentMessageDirection,
+  AgentRefreshAuthGate: () => AgentRefreshAuthGate,
+  AgentRefreshCoordinator: () => AgentRefreshCoordinator,
   AiRunner: () => AiRunner,
   BACKUP_JOB_ID: () => BACKUP_JOB_ID,
   CODEX_APP_DIRS_ENV: () => CODEX_APP_DIRS_ENV,
@@ -43965,6 +43967,8 @@ __export(index_exports, {
   InboundReplayGate: () => InboundReplayGate,
   InvalidXmtpMessageStore: () => InvalidXmtpMessageStore,
   JOB_PROVIDER_BINDING_SOURCES: () => JOB_PROVIDER_BINDING_SOURCES,
+  ListenerDeferredTaskScheduler: () => ListenerDeferredTaskScheduler,
+  ListenerMaintenanceGate: () => ListenerMaintenanceGate,
   LogEvent: () => LogEvent,
   MESSAGE_ELIGIBLE_OFFLINE_REPLAY_FLAG: () => MESSAGE_ELIGIBLE_OFFLINE_REPLAY_FLAG,
   MESSAGE_ELIGIBLE_OFFLINE_REPLAY_HELP_TOKEN: () => MESSAGE_ELIGIBLE_OFFLINE_REPLAY_HELP_TOKEN,
@@ -44109,6 +44113,7 @@ __export(index_exports, {
   notifyUserAttentionChanged: () => notifyUserAttentionChanged,
   parseLogsExportArgs: () => parseLogsExportArgs,
   parsePluginYamlVersion: () => parsePluginYamlVersion,
+  parseWalletLoginStatus: () => parseWalletLoginStatus,
   parseWindowsParentProcessJson: () => parseWindowsParentProcessJson,
   performRuntimeSwitch: () => performRuntimeSwitch,
   persistCurrentRuntimeSelectionForNewJob: () => persistCurrentRuntimeSelectionForNewJob,
@@ -44161,6 +44166,7 @@ __export(index_exports, {
   resolveXmtpClientRecycleIntervalSec: () => resolveXmtpClientRecycleIntervalSec,
   runAiAdapter: () => runAiAdapter,
   runDoctor: () => runDoctor,
+  runHeartbeatRefreshCycle: () => runHeartbeatRefreshCycle,
   runListener: () => runListener,
   scanUserAttentionWatchers: () => scanUserAttentionWatchers,
   setOpenClawWebSocketFactoryForTests: () => setOpenClawWebSocketFactoryForTests,
@@ -55865,6 +55871,63 @@ function compareTimestamp(a, b) {
   return 0;
 }
 
+// ../core/src/xmtp-sdk/onchainos/session-expired.ts
+init_sentry_logger();
+var SESSION_EXPIRED_RE = /session expired/i;
+var AUTH_FAILURE_PATTERNS = [
+  ["session_expired", /session expired/i],
+  ["not_logged_in", /not logged in/i],
+  ["login_required", /login required/i],
+  ["authentication_required", /authentication required/i]
+];
+function isSessionExpired(stdout) {
+  try {
+    const res = JSON.parse(stdout);
+    return res.ok === false && SESSION_EXPIRED_RE.test(String(res.error ?? ""));
+  } catch {
+    return SESSION_EXPIRED_RE.test(stdout);
+  }
+}
+function classifyOnchainosAuthError(err) {
+  if (!err) {
+    return null;
+  }
+  const values = [String(err)];
+  if (typeof err === "object") {
+    const anyErr = err;
+    values.push(anyErr.stdout, anyErr.stderr, anyErr.message);
+  }
+  for (const value of values) {
+    if (typeof value !== "string") {
+      continue;
+    }
+    for (const [reason, pattern] of AUTH_FAILURE_PATTERNS) {
+      if (pattern.test(value)) {
+        return reason;
+      }
+    }
+  }
+  return null;
+}
+function isOnchainosAuthError(err) {
+  return classifyOnchainosAuthError(err) !== null;
+}
+function reportSessionExpired(command) {
+  logger.error(
+    LogEvent.ONCHAINOS_SESSION_EXPIRED,
+    new Error("onchainos session expired"),
+    {
+      component: "onchainos_cli",
+      source: "onchainos",
+      stage: "session_expired",
+      operation: command,
+      command,
+      communicationClass: "onchainos_auth_issue",
+      reason: "session_expired"
+    }
+  );
+}
+
 // ../core/src/xmtp-sdk/index.ts
 var DEFAULT_DATA_DIR = resolveA2aTaskPaths().xmtpDir;
 var XMTP_INSTALLATION_WARNING_THRESHOLD = 2;
@@ -55898,22 +55961,6 @@ function ensureCacheDir(dataDir) {
   ensureA2aTaskDir(dataDir);
 }
 var SENSITIVE_WORDS_LAZY_RETRY_COOLDOWN_MS = 10 * 60 * 1e3;
-var SESSION_EXPIRED_RE = /session expired/i;
-function isSessionExpiredError(err) {
-  if (!err) {
-    return false;
-  }
-  if (typeof err === "object") {
-    const anyErr = err;
-    if (typeof anyErr.stdout === "string" && SESSION_EXPIRED_RE.test(anyErr.stdout)) {
-      return true;
-    }
-    if (typeof anyErr.message === "string" && SESSION_EXPIRED_RE.test(anyErr.message)) {
-      return true;
-    }
-  }
-  return SESSION_EXPIRED_RE.test(String(err));
-}
 function loadSensitiveWordsFromCache(dataDir) {
   try {
     const path2 = cachePath(dataDir, "sensitive-words.json");
@@ -56832,12 +56879,14 @@ var XmtpService = class _XmtpService {
       newAgents = agentList.agents;
       changed = agentList.changed;
     } catch (err) {
-      if (isSessionExpiredError(err)) {
+      const authFailureReason = classifyOnchainosAuthError(err);
+      if (authFailureReason) {
         logWithTimestamp(
-          "[xmtp-sdk] refresh: onchainos session expired, taking all local clients offline"
+          `[xmtp-sdk] refresh: onchainos auth unavailable (${authFailureReason}), taking all local clients offline`
         );
         logger.info(LogEvent.AGENT_REFRESH_SESSION_EXPIRED, {
           onchainosAgentId: "*",
+          authFailureReason,
           previousClientCount: String(this.clients.size),
           previousAgentCount: String(this.allAgents.length),
           previousAgentIds: this.allAgents.map((a) => a.agentId).join(","),
@@ -58744,33 +58793,6 @@ function parseCliJson(stdout, command, extras = {}) {
   }
 }
 
-// ../core/src/xmtp-sdk/onchainos/session-expired.ts
-init_sentry_logger();
-var SESSION_EXPIRED_RE2 = /session expired/i;
-function isSessionExpired(stdout) {
-  try {
-    const res = JSON.parse(stdout);
-    return res.ok === false && SESSION_EXPIRED_RE2.test(String(res.error ?? ""));
-  } catch {
-    return SESSION_EXPIRED_RE2.test(stdout);
-  }
-}
-function reportSessionExpired(command) {
-  logger.error(
-    LogEvent.ONCHAINOS_SESSION_EXPIRED,
-    new Error("onchainos session expired"),
-    {
-      component: "onchainos_cli",
-      source: "onchainos",
-      stage: "session_expired",
-      operation: command,
-      command,
-      communicationClass: "onchainos_auth_issue",
-      reason: "session_expired"
-    }
-  );
-}
-
 // ../core/src/xmtp-sdk/onchainos/offline-replay-capability.ts
 init_log();
 var MESSAGE_ELIGIBLE_OFFLINE_REPLAY_FLAG = "--is-offline-replay";
@@ -58926,6 +58948,42 @@ async function fetchSystemConfig(options) {
   return res.data;
 }
 
+// ../core/src/xmtp-sdk/onchainos/wallet-status.ts
+init_log();
+init_sentry_logger();
+function parseWalletLoginStatus(stdout) {
+  const response = parseCliJson(stdout, "wallet-status");
+  if (!response.ok) {
+    const error = new Error("onchainos wallet status failed");
+    logger.error(
+      LogEvent.ONCHAINOS_CLI_ERROR,
+      error,
+      cliOkFalseExtras(stdout, "wallet-status")
+    );
+    throw error;
+  }
+  if (typeof response.data?.loggedIn !== "boolean") {
+    const error = new Error("onchainos wallet status returned invalid loggedIn state");
+    logger.error(LogEvent.ONCHAINOS_CLI_ERROR, error, {
+      component: "onchainos_cli",
+      source: "onchainos",
+      stage: "response_validation",
+      communicationClass: "onchainos_cli_or_api_issue",
+      operation: "wallet-status",
+      reason: "invalid_logged_in_state"
+    });
+    throw error;
+  }
+  return response.data.loggedIn;
+}
+async function queryWalletLoginStatus() {
+  logWithTimestamp("[onchainos] checking wallet login status");
+  const { stdout } = await exec(["wallet", "status"]);
+  const loggedIn = parseWalletLoginStatus(stdout);
+  logWithTimestamp(`[onchainos] wallet login status: ${loggedIn ? "logged in" : "logged out"}`);
+  return loggedIn;
+}
+
 // ../core/src/xmtp-sdk/onchainos/index.ts
 var MESSAGE_ELIGIBILITY_SERVICE_UNAVAILABLE_AI_HINT = "Message eligibility service is temporarily unavailable. Please try again later.";
 function messageEligibleUnavailableError(input) {
@@ -59056,7 +59114,10 @@ async function fetchAgentPage(page) {
   );
   if (!res.ok) {
     guardSessionExpired2(stdout, "list-agents");
-    const parseErr = new Error("onchainos agent get failed");
+    const detail = typeof res.error === "string" ? res.error.trim() : "";
+    const parseErr = new Error(
+      detail ? `onchainos agent get failed: ${detail}` : "onchainos agent get failed"
+    );
     logger.error(
       LogEvent.ONCHAINOS_CLI_ERROR,
       parseErr,
@@ -60181,7 +60242,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.3",
+      version: "0.2.4-beta-e7a52faf6f-260812104443",
       platform: "node",
       mode: "backend",
       instanceId
@@ -60192,7 +60253,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.3"}`,
+    userAgent: `okx-a2a-node/${"0.2.4-beta-e7a52faf6f-260812104443"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -63621,7 +63682,7 @@ async function handleDaemonCommand(command, params) {
     const payload = await handleXmtpDebugCommand(command, params.service);
     return { ok: true, payload };
   }
-  const refresh = await params.service.refreshAgents();
+  const refresh = await (params.refreshAgents?.() ?? params.service.refreshAgents());
   return {
     ok: true,
     payload: {
@@ -65974,6 +66035,144 @@ var DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC = 300;
 var DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC = 6 * 60 * 60;
 var XMTP_CLIENT_RECYCLE_INTERVAL_ENV = "OKX_A2A_XMTP_CLIENT_RECYCLE_INTERVAL_SEC";
 var HEARTBEAT_GATEWAY_CHECK_TIMEOUT_MS = 2e3;
+var AUTH_RECOVERY_PROBE_INTERVAL_MS = 6e4;
+async function runHeartbeatRefreshCycle(options) {
+  const heartbeat = await timeSettled(options.heartbeat);
+  const refreshAllowed = heartbeat.value === "performed" || heartbeat.value === "refresh_safe";
+  const refresh = options.refresh && refreshAllowed ? await timeSettled(options.refresh) : void 0;
+  return { heartbeat, refresh };
+}
+var AgentRefreshAuthGate = class {
+  authBlocked = false;
+  get blocked() {
+    return this.authBlocked;
+  }
+  recordSuccess() {
+    this.authBlocked = false;
+  }
+  recordFailure(err) {
+    if (!isOnchainosAuthError(err)) {
+      return false;
+    }
+    this.authBlocked = true;
+    return true;
+  }
+};
+var AgentRefreshCoordinator = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  authGate = new AgentRefreshAuthGate();
+  refreshInFlight = null;
+  recoveryProbeInFlight = null;
+  get blocked() {
+    return this.authGate.blocked;
+  }
+  async lookup(previousFingerprint) {
+    const wasBlocked = this.authGate.blocked;
+    try {
+      const result = await this.options.lookup(previousFingerprint);
+      this.authGate.recordSuccess();
+      if (wasBlocked) {
+        this.options.onAuthRecovered?.();
+      }
+      return result;
+    } catch (err) {
+      if (this.authGate.recordFailure(err) && !wasBlocked) {
+        this.options.onAuthBlocked?.();
+      }
+      throw err;
+    }
+  }
+  async runScheduled() {
+    if (this.options.isStopping() || this.authGate.blocked) {
+      return null;
+    }
+    return this.runRefresh();
+  }
+  async runManual() {
+    return this.runRefresh();
+  }
+  runRecoveryProbe() {
+    if (this.options.isStopping() || !this.authGate.blocked || !this.options.checkLoggedIn) {
+      return Promise.resolve(null);
+    }
+    if (this.recoveryProbeInFlight) {
+      return this.recoveryProbeInFlight;
+    }
+    this.recoveryProbeInFlight = (async () => {
+      const loggedIn = await this.options.checkLoggedIn?.();
+      if (this.options.isStopping() || !this.authGate.blocked || !loggedIn) {
+        return null;
+      }
+      const refresh = await this.runRefresh();
+      return this.authGate.blocked ? null : refresh;
+    })().finally(() => {
+      this.recoveryProbeInFlight = null;
+    });
+    return this.recoveryProbeInFlight;
+  }
+  runRefresh() {
+    if (this.refreshInFlight) {
+      return this.refreshInFlight;
+    }
+    this.refreshInFlight = this.options.refresh().finally(() => {
+      this.refreshInFlight = null;
+    });
+    return this.refreshInFlight;
+  }
+};
+var ListenerDeferredTaskScheduler = class {
+  timers = /* @__PURE__ */ new Set();
+  schedule(task) {
+    const timer = setTimeout(() => {
+      this.timers.delete(timer);
+      task();
+    }, 0);
+    this.timers.add(timer);
+  }
+  cancelAll() {
+    for (const timer of this.timers) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+  }
+};
+var ListenerMaintenanceGate = class {
+  inFlight = null;
+  offlineReplayPending = false;
+  xmtpRecyclePending = false;
+  tryEnter(task) {
+    if (task !== "xmtp_recycle" && this.xmtpRecyclePending || this.inFlight) {
+      if (task === "offline_replay") {
+        this.offlineReplayPending = true;
+      } else if (task === "xmtp_recycle") {
+        this.xmtpRecyclePending = true;
+      }
+      return false;
+    }
+    if (task === "xmtp_recycle") {
+      this.xmtpRecyclePending = false;
+    }
+    this.inFlight = task;
+    return true;
+  }
+  leave(task) {
+    if (this.inFlight !== task) {
+      return null;
+    }
+    this.inFlight = null;
+    if (this.xmtpRecyclePending) {
+      return "xmtp_recycle";
+    }
+    if (this.offlineReplayPending) {
+      this.offlineReplayPending = false;
+      return "offline_replay";
+    }
+    return null;
+  }
+};
 var UPGRADE_RECOMMENDATION_IDEMPOTENCY_KEY = "system:onchainos-offline-replay-upgrade";
 function resolveOfflineReplayIntervalSec(systemConfig) {
   const interval = systemConfig.offlineReplayInterval;
@@ -66173,10 +66372,25 @@ async function runListenerWithLock(options, paths) {
     }
   });
   logWithTimestamp("[okx-agent-task] user_attention watcher coordinator scanning SQLite watcher state");
+  let stopping = false;
   const service = XmtpService.getInstance();
+  const agentRefreshCoordinator = new AgentRefreshCoordinator({
+    lookup: (previousFingerprint) => listAllAgentsWithMetadata(previousFingerprint),
+    refresh: () => service.refreshAgents(),
+    checkLoggedIn: () => queryWalletLoginStatus(),
+    isStopping: () => stopping,
+    onAuthBlocked: () => {
+      logWithTimestamp(
+        "[okx-agent-task] agent refresh auth blocked; periodic agent get paused. Wallet login recovery will be checked every 60s; run `okx-a2a agent refresh` to recover immediately"
+      );
+    },
+    onAuthRecovered: () => {
+      logWithTimestamp("[okx-agent-task] agent refresh auth recovered; periodic refresh resumed");
+    }
+  });
   service.setDataDir(paths.xmtpDir);
   service.setTools({
-    listAllAgentsWithMetadata: async (previousFingerprint) => listAllAgentsWithMetadata(previousFingerprint),
+    listAllAgentsWithMetadata: (previousFingerprint) => agentRefreshCoordinator.lookup(previousFingerprint),
     fetchSensitiveWords: async () => fetchSensitiveWords(),
     fetchSystemConfig: async () => fetchSystemConfig({
       notifySessionExpired: (command) => service.tools.notifySessionExpired?.(command)
@@ -66203,7 +66417,7 @@ async function runListenerWithLock(options, paths) {
       }
     }),
     notifySessionExpired: (command) => {
-      const rawText = `The onchainos login session has expired while running ${command}. Run \`onchainos wallet login\` and restart \`okx-a2a\`.`;
+      const rawText = `The onchainos login session has expired while running ${command}. Run \`onchainos wallet login\`; A2A will recover within 60 seconds, or run \`okx-a2a agent refresh\` to recover immediately.`;
       void store.appendBackup(buildSystemStoredMessage({
         reason: "onchainos-session-expired",
         rawText,
@@ -66231,12 +66445,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.3");
+  service.setPluginVersion("0.2.4-beta-e7a52faf6f-260812104443");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.3"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.4-beta-e7a52faf6f-260812104443"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -66254,7 +66468,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.3"
+      pluginVersion: "0.2.4-beta-e7a52faf6f-260812104443"
     });
   }
   logWithTimestamp(
@@ -66266,37 +66480,56 @@ async function runListenerWithLock(options, paths) {
   logWithTimestamp(
     `[okx-agent-task] startup replay complete clients=${startupReplaySummary.clients} replayed=${startupReplaySummary.replayed} skipped=${startupReplaySummary.skipped} duration=${startupReplaySummary.durationMs}ms`
   );
-  let maintenanceInFlight = null;
   let lastRecycleReplayAtMs = 0;
-  let xmtpRecyclePending = false;
-  const tryEnterMaintenanceTask = (task) => {
-    if (task !== "xmtp_recycle" && xmtpRecyclePending) {
-      return false;
-    }
-    if (maintenanceInFlight) {
-      return false;
+  const maintenanceGate = new ListenerMaintenanceGate();
+  const deferredMaintenanceTasks = new ListenerDeferredTaskScheduler();
+  const leaveMaintenanceTask = (task) => {
+    const pendingTask = maintenanceGate.leave(task);
+    if (stopping) {
+      return;
     }
-    if (task === "xmtp_recycle") {
-      xmtpRecyclePending = false;
+    if (pendingTask === "xmtp_recycle") {
+      deferredMaintenanceTasks.schedule(() => void xmtpRecycleTick());
+    } else if (pendingTask === "offline_replay") {
+      deferredMaintenanceTasks.schedule(() => void offlineReplayTick());
     }
-    maintenanceInFlight = task;
-    return true;
   };
-  const leaveMaintenanceTask = (task) => {
-    if (maintenanceInFlight === task) {
-      maintenanceInFlight = null;
-      if (xmtpRecyclePending && !stopping) {
-        setTimeout(() => void xmtpRecycleTick(), 0);
+  const syncTick = async () => {
+    if (stopping || agentRefreshCoordinator.blocked) {
+      return;
+    }
+    if (!maintenanceGate.tryEnter("sync")) {
+      return;
+    }
+    const tickStartedAt = Date.now();
+    try {
+      const refresh = await agentRefreshCoordinator.runScheduled();
+      if (!refresh) {
+        return;
       }
+      logWithTimestamp(
+        `[okx-agent-task] sync tick agents=${refresh.agentCount} changed=${refresh.changed ? "yes" : "no"} added=${refresh.added.length} removed=${refresh.removed.length}`
+      );
+    } catch (err) {
+      logger.error(LogEvent.DAEMON_TICK_FAILED, err instanceof Error ? err : new Error(String(err)), {
+        component: "node_listener",
+        stage: "sync_tick",
+        durationMs: String(Date.now() - tickStartedAt),
+        reason: "sync_tick_exception"
+      });
+      logWithTimestamp(`[okx-agent-task] sync tick failed total=${Date.now() - tickStartedAt}ms:`, err);
+    } finally {
+      leaveMaintenanceTask("sync");
     }
   };
-  const syncTick = async () => {
-    if (!tryEnterMaintenanceTask("sync")) {
-      return;
+  let heartbeatInFlight = false;
+  const heartbeatTick = async () => {
+    if (heartbeatInFlight || stopping) {
+      return "blocked";
     }
+    heartbeatInFlight = true;
     const tickStartedAt = Date.now();
     try {
-      const refresh = await service.refreshAgents();
       const hasActiveAgents = service.getClients().size > 0;
       let shouldHeartbeat = hasActiveAgents;
       const heartbeatProvider = resolveConfiguredAiProvider({ store: sessionStore }) ?? detectGatewayInvocation();
@@ -66311,7 +66544,7 @@ async function runListenerWithLock(options, paths) {
             new Error(`heartbeat gateway check failed: provider=hermes reason=${hermesStatus.reason}`),
             {
               component: "node_listener",
-              stage: "sync_tick",
+              stage: "heartbeat_tick",
               reason: hermesStatus.reason ?? "unknown",
               provider: "hermes",
               hermesHome: hermesStatus.hermesHome,
@@ -66335,7 +66568,7 @@ async function runListenerWithLock(options, paths) {
             new Error(`heartbeat skipped: provider=${heartbeatProvider ?? "(not set)"} gateway unavailable`),
             {
               component: "node_listener",
-              stage: "sync_tick",
+              stage: "heartbeat_tick",
               reason: "gateway_unavailable",
               provider: heartbeatProvider ?? "(not set)",
               chainIndex: ONCHAINOS_CHAIN_INDEX,
@@ -66351,7 +66584,7 @@ async function runListenerWithLock(options, paths) {
           new Error("heartbeat skipped: no active agents"),
           {
             component: "node_listener",
-            stage: "sync_tick",
+            stage: "heartbeat_tick",
             reason: "no_active_agents",
             provider: heartbeatProvider ?? "(not set)",
             chainIndex: ONCHAINOS_CHAIN_INDEX
@@ -66364,7 +66597,7 @@ async function runListenerWithLock(options, paths) {
       if (shouldHeartbeat && heartbeatResult.error) {
         logger.error(LogEvent.HEARTBEAT_FAILED, heartbeatResult.error instanceof Error ? heartbeatResult.error : new Error(String(heartbeatResult.error)), {
           component: "node_listener",
-          stage: "sync_tick",
+          stage: "heartbeat_tick",
           reason: heartbeatResult.error instanceof Error ? heartbeatResult.error.name : "unknown_error",
           durationMs: String(heartbeatMs),
           chainIndex: ONCHAINOS_CHAIN_INDEX,
@@ -66372,23 +66605,27 @@ async function runListenerWithLock(options, paths) {
         });
         logWithTimestamp(`[okx-agent-task] heartbeat failed duration=${heartbeatMs}ms:`, heartbeatResult.error);
       }
-      logWithTimestamp(
-        `[okx-agent-task] sync tick agents=${refresh.agentCount} changed=${refresh.changed ? "yes" : "no"} added=${refresh.added.length} removed=${refresh.removed.length}`
-      );
+      return shouldHeartbeat ? "performed" : "refresh_safe";
     } catch (err) {
-      logger.error(LogEvent.DAEMON_TICK_FAILED, err instanceof Error ? err : new Error(String(err)), {
+      logger.error(LogEvent.HEARTBEAT_FAILED, err instanceof Error ? err : new Error(String(err)), {
         component: "node_listener",
-        stage: "sync_tick",
+        stage: "heartbeat_tick",
         durationMs: String(Date.now() - tickStartedAt),
-        reason: "sync_tick_exception"
+        reason: "heartbeat_tick_exception",
+        chainIndex: ONCHAINOS_CHAIN_INDEX,
+        communicationClass: "onchainos_or_network"
       });
-      logWithTimestamp(`[okx-agent-task] sync tick failed total=${Date.now() - tickStartedAt}ms:`, err);
+      logWithTimestamp(`[okx-agent-task] heartbeat tick failed total=${Date.now() - tickStartedAt}ms:`, err);
+      return "blocked";
     } finally {
-      leaveMaintenanceTask("sync");
+      heartbeatInFlight = false;
     }
   };
   const offlineReplayTick = async () => {
-    if (!tryEnterMaintenanceTask("offline_replay")) {
+    if (stopping) {
+      return;
+    }
+    if (!maintenanceGate.tryEnter("offline_replay")) {
       return;
     }
     const tickStartedAt = Date.now();
@@ -66430,8 +66667,10 @@ async function runListenerWithLock(options, paths) {
     }
   };
   const xmtpRecycleTick = async () => {
-    if (!tryEnterMaintenanceTask("xmtp_recycle")) {
-      xmtpRecyclePending = true;
+    if (stopping) {
+      return;
+    }
+    if (!maintenanceGate.tryEnter("xmtp_recycle")) {
       return;
     }
     const tickStartedAt = Date.now();
@@ -66475,7 +66714,6 @@ async function runListenerWithLock(options, paths) {
   let timer;
   let offlineReplayTimer;
   let xmtpClientRecycleTimer;
-  let stopping = false;
   const scheduleSyncTimer = (nextIntervalSec) => {
     if (stopping) {
       return;
@@ -66486,7 +66724,10 @@ async function runListenerWithLock(options, paths) {
     intervalSec = Math.max(10, nextIntervalSec);
     logWithTimestamp(`[okx-agent-task] scheduled sync interval ${intervalSec}s`);
     timer = setInterval(() => {
-      void syncTick();
+      void runHeartbeatRefreshCycle({
+        heartbeat: heartbeatTick,
+        refresh: syncTick
+      });
     }, intervalSec * 1e3);
   };
   const scheduleOfflineReplayTimer = (nextIntervalSec) => {
@@ -66568,9 +66809,32 @@ async function runListenerWithLock(options, paths) {
   const systemConfigRefreshTimer = setInterval(() => {
     void refreshSystemConfigTick();
   }, 60 * 60 * 1e3);
-  void syncTick();
+  const authRecoveryProbeTimer = setInterval(() => {
+    if (stopping || !agentRefreshCoordinator.blocked) {
+      return;
+    }
+    void agentRefreshCoordinator.runRecoveryProbe().then((refresh) => {
+      if (!refresh) {
+        return;
+      }
+      logWithTimestamp(
+        `[okx-agent-task] auth recovery refresh agents=${refresh.agentCount} added=${refresh.added.length} removed=${refresh.removed.length}`
+      );
+    }).catch((err) => {
+      logger.error(LogEvent.DAEMON_TICK_FAILED, err instanceof Error ? err : new Error(String(err)), {
+        component: "node_listener",
+        stage: "auth_recovery_probe",
+        reason: "auth_recovery_probe_failed"
+      });
+      logWithTimestamp("[okx-agent-task] auth recovery probe failed:", err);
+    });
+  }, AUTH_RECOVERY_PROBE_INTERVAL_MS);
+  void runHeartbeatRefreshCycle({
+    heartbeat: heartbeatTick
+  });
   const commandProcessor = startCommandProcessor({
     service,
+    refreshAgents: () => agentRefreshCoordinator.runManual(),
     store,
     sessionStore,
     homeDir: options.homeDir
@@ -66589,6 +66853,7 @@ async function runListenerWithLock(options, paths) {
         resolve11();
       }, SHUTDOWN_FORCE_RESOLVE_MS);
       void (async () => {
+        deferredMaintenanceTasks.cancelAll();
         if (timer) {
           clearInterval(timer);
         }
@@ -66599,6 +66864,7 @@ async function runListenerWithLock(options, paths) {
           clearInterval(xmtpClientRecycleTimer);
         }
         clearInterval(systemConfigRefreshTimer);
+        clearInterval(authRecoveryProbeTimer);
         commandProcessor.stop();
         await watcherCoordinator.stop();
         try {
@@ -68900,7 +69166,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.3" : "unknown",
+    packageVersion: true ? "0.2.4-beta-e7a52faf6f-260812104443" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -70736,7 +71002,7 @@ async function runDoctor(options = {}) {
     platform: options.platform ?? process.platform,
     env: options.env ?? process.env,
     target: options.target ?? resolveDoctorTarget(options.env ?? process.env),
-    cliVersion: options.cliVersion ?? (true ? "0.2.3" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.4-beta-e7a52faf6f-260812104443" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -70959,6 +71225,8 @@ init_autostart_windows();
 0 && (module.exports = {
   AI_PROVIDERS,
   AgentMessageDirection,
+  AgentRefreshAuthGate,
+  AgentRefreshCoordinator,
   AiRunner,
   BACKUP_JOB_ID,
   CODEX_APP_DIRS_ENV,
@@ -70978,6 +71246,8 @@ init_autostart_windows();
   InboundReplayGate,
   InvalidXmtpMessageStore,
   JOB_PROVIDER_BINDING_SOURCES,
+  ListenerDeferredTaskScheduler,
+  ListenerMaintenanceGate,
   LogEvent,
   MESSAGE_ELIGIBLE_OFFLINE_REPLAY_FLAG,
   MESSAGE_ELIGIBLE_OFFLINE_REPLAY_HELP_TOKEN,
@@ -71122,6 +71392,7 @@ init_autostart_windows();
   notifyUserAttentionChanged,
   parseLogsExportArgs,
   parsePluginYamlVersion,
+  parseWalletLoginStatus,
   parseWindowsParentProcessJson,
   performRuntimeSwitch,
   persistCurrentRuntimeSelectionForNewJob,
@@ -71174,6 +71445,7 @@ init_autostart_windows();
   resolveXmtpClientRecycleIntervalSec,
   runAiAdapter,
   runDoctor,
+  runHeartbeatRefreshCycle,
   runListener,
   scanUserAttentionWatchers,
   setOpenClawWebSocketFactoryForTests,