@okxweb3/a2a-node 0.2.9-beta-912b775358-260824171011 → 0.2.9

package/dist/cli.js

@@ -3992,34 +3992,6 @@ var init_command_store = __esm({
         }
         return null;
       }
-      /**
-       * Read-only lookup of a command's current lifecycle state by id. Returns null
-       * when no row exists. Used by the WakeupNotify recovery reconcile to decide
-       * whether an in-flight wakeup's command completed, failed, or was orphaned by a
-       * crash — it does not mutate the queue or alter recovery behavior.
-       */
-      getCommandState(commandId) {
-        const row = this.db.prepare(`
-      SELECT status, result_json, processing_started_at_ms FROM command_queue
-      WHERE id = ?
-    `).get(commandId);
-        if (!row?.status) {
-          return null;
-        }
-        let ok = null;
-        if (row.result_json) {
-          try {
-            ok = Boolean(JSON.parse(row.result_json).ok);
-          } catch {
-            ok = null;
-          }
-        }
-        return {
-          status: row.status,
-          ok,
-          processingStartedAtMs: row.processing_started_at_ms ?? null
-        };
-      }
       close() {
         this.db.close();
       }
@@ -4705,7 +4677,7 @@ var require_is = __commonJS({
     function isPrimitive(wat) {
       return wat === null || typeof wat !== "object" && typeof wat !== "function";
     }
-    function isPlainObject6(wat) {
+    function isPlainObject4(wat) {
       return isBuiltin(wat, "Object");
     }
     function isEvent(wat) {
@@ -4721,7 +4693,7 @@ var require_is = __commonJS({
       return Boolean(wat && wat.then && typeof wat.then === "function");
     }
     function isSyntheticEvent(wat) {
-      return isPlainObject6(wat) && "nativeEvent" in wat && "preventDefault" in wat && "stopPropagation" in wat;
+      return isPlainObject4(wat) && "nativeEvent" in wat && "preventDefault" in wat && "stopPropagation" in wat;
     }
     function isNaN2(wat) {
       return typeof wat === "number" && wat !== wat;
@@ -4744,7 +4716,7 @@ var require_is = __commonJS({
     exports2.isEvent = isEvent;
     exports2.isInstanceOf = isInstanceOf;
     exports2.isNaN = isNaN2;
-    exports2.isPlainObject = isPlainObject6;
+    exports2.isPlainObject = isPlainObject4;
     exports2.isPrimitive = isPrimitive;
     exports2.isRegExp = isRegExp;
     exports2.isString = isString;
@@ -19959,6 +19931,7 @@ var init_events = __esm({
       AGENT_CLIENT_REMOVED: "Agent client removed",
       AGENT_STREAM_RECOVERED: "Agent stream recovered",
       AGENT_STREAM_RECOVERY_REPLAY_COMPLETED: "Agent stream recovery replay completed",
+      AGENT_STREAM_RECOVERY_REPLAY_TERMINATED: "Agent stream recovery replay terminated",
       ADDRESS_SYNC_COMPLETED: "Address sync completed",
       AGENT_REFRESH_SESSION_EXPIRED: "Agent refresh aborted: onchainos session expired, local clients taken offline",
       OFFLINE_REPLAY_MESSAGE_REPLAYED: "Offline replay message replayed",
@@ -19997,17 +19970,6 @@ var init_events = __esm({
       SYSTEM_NOTIFICATION_ROUTED: "System notification routed",
       HERMES_SESSION_ROUTE_BINDING: "Hermes session route binding",
       DOCTOR_REPORT: "Doctor report",
-      // Paginated WakeupNotify recovery (BL-011) + bounded AI concurrency telemetry.
-      // All info-level events below must ALSO be listed in SENTRY_INFO_ALLOWLIST
-      // (index.ts) or info() drops them silently.
-      WAKEUP_PULL_STARTED: "WakeupNotify pull started",
-      WAKEUP_PULL_PAGE_FETCHED: "WakeupNotify pull page fetched",
-      WAKEUP_PULL_PAGE_RETRY: "WakeupNotify pull page retry",
-      WAKEUP_PULL_COMPLETED: "WakeupNotify pull completed",
-      WAKEUP_NOTIFICATION_REJECTED: "WakeupNotify notification rejected",
-      WAKEUP_CHUNK_DISPATCHED: "WakeupNotify chunk dispatched",
-      WAKEUP_IN_MEMORY_WORK_DROPPED: "WakeupNotify in-memory work dropped",
-      AI_CONCURRENCY_SNAPSHOT: "AI concurrency snapshot",
       // ── error ─────────────────────────────────────────────────────
       XMTP_CONNECTION_FAILED: "XMTP connection failed",
       CONVERSATIONS_STREAM_FAILED: "conversations.stream failed",
@@ -20062,7 +20024,6 @@ var init_events = __esm({
       AI_RUN_TOOL_FAILED: "AI run tool failed",
       IPC_FAILED: "IPC failed",
       NOTIFY_AGENTS_WAKEUP_FAILED: "Notify agents wakeup failed",
-      WAKEUP_PULL_FAILED: "WakeupNotify pull failed",
       OUTBOUND_AGENT_LOOKUP_FAILED: "Outbound agent lookup failed",
       OUTBOUND_ELIGIBILITY_CHECK_FAILED: "Outbound eligibility check failed",
       OUTBOUND_ELIGIBILITY_BYPASSED: "Outbound eligibility bypassed",
@@ -20864,15 +20825,6 @@ var init_sentry_logger = __esm({
       LogEvent.USER_CHANNEL_MESSAGE_DELIVERED,
       LogEvent.SYSTEM_NOTIFICATION_RECEIVED,
       LogEvent.SYSTEM_NOTIFICATION_ROUTED,
-      // Paginated WakeupNotify recovery (BL-011) + bounded AI concurrency telemetry.
-      LogEvent.WAKEUP_PULL_STARTED,
-      LogEvent.WAKEUP_PULL_PAGE_FETCHED,
-      LogEvent.WAKEUP_PULL_PAGE_RETRY,
-      LogEvent.WAKEUP_PULL_COMPLETED,
-      LogEvent.WAKEUP_NOTIFICATION_REJECTED,
-      LogEvent.WAKEUP_CHUNK_DISPATCHED,
-      LogEvent.WAKEUP_IN_MEMORY_WORK_DROPPED,
-      LogEvent.AI_CONCURRENCY_SNAPSHOT,
       LogEvent.HERMES_SESSION_ROUTE_BINDING,
       LogEvent.INBOUND_BLOCKED_ADDRESS_MISMATCH,
       LogEvent.INBOUND_BLOCKED_INELIGIBLE,
@@ -20895,6 +20847,7 @@ var init_sentry_logger = __esm({
       LogEvent.AGENT_STREAM_ERROR,
       LogEvent.AGENT_STREAM_RECOVERED,
       LogEvent.AGENT_STREAM_RECOVERY_REPLAY_COMPLETED,
+      LogEvent.AGENT_STREAM_RECOVERY_REPLAY_TERMINATED,
       LogEvent.ADDRESS_SYNC_COMPLETED,
       LogEvent.AGENTS_REFRESHED,
       LogEvent.AGENTS_WAKEUP_NOTIFIED,
@@ -25288,7 +25241,7 @@ var require_websocket2 = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes4, createHash: createHash7 } = require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash6 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -25948,7 +25901,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest = createHash6("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -26315,7 +26268,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = require("events");
     var http2 = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash7 } = require("crypto");
+    var { createHash: createHash6 } = require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -26616,7 +26569,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest = createHash6("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -26981,7 +26934,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.9-beta-912b775358-260824171011",
+      version: "0.2.9",
       platform: "node",
       mode: "backend",
       instanceId
@@ -26992,7 +26945,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.9-beta-912b775358-260824171011"}`,
+    userAgent: `okx-a2a-node/${"0.2.9"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -28959,7 +28912,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.9-beta-912b775358-260824171011",
+      release: "0.2.9",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -40129,7 +40082,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.9-beta-912b775358-260824171011" : "unknown",
+    packageVersion: true ? "0.2.9" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -57175,6 +57128,12 @@ function replayScanBackoffMs(consecutiveFailures) {
     REPLAY_SCAN_MAX_BACKOFF_MS
   );
 }
+function replayScanBackoffWithJitterMs(consecutiveFailures, randomValue = Math.random()) {
+  const baseMs = replayScanBackoffMs(consecutiveFailures);
+  const boundedRandom = Math.min(1, Math.max(0, randomValue));
+  const jitteredMs = Math.round(baseMs * (0.9 + boundedRandom * 0.2));
+  return Math.min(REPLAY_SCAN_MAX_BACKOFF_MS, jitteredMs);
+}
 function isOfflineReplayForTrigger(trigger) {
   return trigger === "startup";
 }
@@ -57361,6 +57320,7 @@ var init_xmtp_sdk = __esm({
       replayScanFailuresByAddress = /* @__PURE__ */ new Map();
       replayScanRetryByAddress = /* @__PURE__ */ new Map();
       replayScanNowMs = () => Date.now();
+      replayScanRandom = () => Math.random();
       replayScanSetTimeout = (callback, delayMs) => setTimeout(callback, delayMs);
       replayScanClearTimeout = (timer) => clearTimeout(timer);
       inboundReplayGates = /* @__PURE__ */ new Map();
@@ -57847,7 +57807,7 @@ var init_xmtp_sdk = __esm({
             this.clients.delete(address);
             this.inboundReplayGates.delete(address.toLowerCase());
             this.replayScanFailuresByAddress.delete(address.toLowerCase());
-            this.clearReplayScanRetry(address);
+            this.clearReplayScanRetry(address, "client_removed");
             logger.info(LogEvent.AGENT_CLIENT_REMOVED, {
               ...agentExtras({
                 walletAddress: address,
@@ -58063,7 +58023,7 @@ var init_xmtp_sdk = __esm({
             this.clients.delete(address);
             this.inboundReplayGates.delete(addressKey);
             this.replayScanFailuresByAddress.delete(addressKey);
-            this.clearReplayScanRetry(address);
+            this.clearReplayScanRetry(address, "client_recycled");
             logWithTimestamp(
               `[xmtp-sdk] recycle: stopped client: ${address} (agentId=${agentInfo.agentId})`
             );
@@ -58613,7 +58573,23 @@ var init_xmtp_sdk = __esm({
         this.clientGenerationByClient.set(client, generation);
         return generation;
       }
-      clearReplayScanRetry(address) {
+      logStreamRecoveryReplayTerminal(address, clientGeneration, recoveryIdentities, terminalReason) {
+        for (const recoverySequence of recoveryIdentities) {
+          logger.info(LogEvent.AGENT_STREAM_RECOVERY_REPLAY_TERMINATED, {
+            ...agentExtras({
+              walletAddress: address,
+              onchainosAgentId: this.getAgentByAddress(address)?.agentId,
+              role: this.getAgentByAddress(address)?.role
+            }),
+            clientGeneration: String(clientGeneration),
+            recoverySequence,
+            outcome: "terminal",
+            replayOutcome: "terminated",
+            terminalReason
+          });
+        }
+      }
+      clearReplayScanRetry(address, terminalReason) {
         const addressKey = address.toLowerCase();
         const scheduled = this.replayScanRetryByAddress.get(addressKey);
         if (!scheduled) {
@@ -58621,15 +58597,31 @@ var init_xmtp_sdk = __esm({
         }
         this.replayScanRetryByAddress.delete(addressKey);
         this.replayScanClearTimeout(scheduled.timer);
+        if (terminalReason) {
+          this.logStreamRecoveryReplayTerminal(
+            address,
+            scheduled.clientGeneration,
+            scheduled.recoveryIdentities,
+            terminalReason
+          );
+        }
       }
-      scheduleReplayScanRetry(address, expectedClient, clientGeneration, retryTrigger, delayMs) {
+      scheduleReplayScanRetry(address, expectedClient, clientGeneration, retryTrigger, delayMs, recoveryIdentities = []) {
         const addressKey = address.toLowerCase();
         const scheduled = this.replayScanRetryByAddress.get(addressKey);
         if (scheduled?.clientGeneration === clientGeneration) {
+          if (retryTrigger === "stream_recovery") {
+            scheduled.retryTrigger = retryTrigger;
+            for (const recoveryIdentity of recoveryIdentities) {
+              if (!scheduled.recoveryIdentities.includes(recoveryIdentity)) {
+                scheduled.recoveryIdentities.push(recoveryIdentity);
+              }
+            }
+          }
           return;
         }
         if (scheduled) {
-          this.clearReplayScanRetry(address);
+          this.clearReplayScanRetry(address, "client_replaced");
         }
         const timer = this.replayScanSetTimeout(() => {
           const current = this.replayScanRetryByAddress.get(addressKey);
@@ -58638,12 +58630,18 @@ var init_xmtp_sdk = __esm({
           }
           this.replayScanRetryByAddress.delete(addressKey);
           if (this.clients.get(address) !== expectedClient || this.stoppedAddresses.has(addressKey)) {
+            this.logStreamRecoveryReplayTerminal(
+              address,
+              current.clientGeneration,
+              current.recoveryIdentities,
+              this.stoppedAddresses.has(addressKey) ? "client_stopped" : "client_replaced"
+            );
             return;
           }
           void this.replayOfflineMessagesForAddressSingleFlight(
             address,
-            retryTrigger,
-            void 0,
+            current.retryTrigger,
+            current.recoveryIdentities.at(-1),
             expectedClient
           ).catch((err2) => {
             logWithTimestamp(
@@ -58664,18 +58662,41 @@ var init_xmtp_sdk = __esm({
         timer.unref?.();
         this.replayScanRetryByAddress.set(addressKey, {
           clientGeneration,
+          retryTrigger,
+          recoveryIdentities: retryTrigger === "stream_recovery" ? [...new Set(recoveryIdentities)] : [],
           timer
         });
       }
+      notifyAgentsWakeupAfterReplay() {
+        const notifyAgentsWakeup2 = this.tools.notifyAgentsWakeup;
+        const agentIds = this.allAgents.map((agent) => agent.agentId);
+        if (!notifyAgentsWakeup2 || agentIds.length === 0) {
+          return;
+        }
+        void notifyAgentsWakeup2(agentIds).then(() => {
+          logger.info(LogEvent.AGENTS_WAKEUP_NOTIFIED, {
+            count: String(agentIds.length),
+            onchainosAgentIds: agentIds.join(","),
+            stage: "after-startup-replay"
+          });
+        }).catch((err2) => {
+          logWithTimestamp("[xmtp-sdk] notifyAgentsWakeup unexpected error:", err2);
+          logger.error(
+            LogEvent.NOTIFY_AGENTS_WAKEUP_FAILED,
+            err2 instanceof Error ? err2 : new Error(String(err2)),
+            {
+              count: String(agentIds.length),
+              stage: "after-startup-replay"
+            }
+          );
+        });
+      }
       /**
        * Completes the startup handoff from stored history to the live stream.
        * Listeners are already attached, but their host handlers stay buffered
-       * until replay finishes and the buffer is drained.
-       *
-       * Telling the backend the agents are awake is deliberately NOT done here.
-       * The daemon (listener.ts) runs the paginated task-wakeup pull AFTER the bounded
-       * command processor is ready, so wakeup-triggered work cannot be dispatched
-       * before the processor exists.
+       * until replay finishes and the buffer is drained. Only then do we tell
+       * the backend that the agents are awake, so wakeup-triggered messages
+       * cannot overtake the stored backlog.
        */
       async completeStartupReplay() {
         const startupGates = new Map(
@@ -58690,6 +58711,7 @@ var init_xmtp_sdk = __esm({
         }
         this.resolveStartupReplayCompletion?.();
         this.resolveStartupReplayCompletion = void 0;
+        this.notifyAgentsWakeupAfterReplay();
         return summary;
       }
       async startListeningForAddresses(addresses) {
@@ -58928,7 +58950,7 @@ var init_xmtp_sdk = __esm({
                       String(recovery.recoverySequence),
                       agent
                     );
-                    if (summary.outcome === "completed" && !recoveryDisposed && this.clients.get(address) === agent) {
+                    if (summary.outcome === "completed" && summary.consecutiveFailures === void 0 && !recoveryDisposed && this.clients.get(address) === agent) {
                       logger.info(LogEvent.AGENT_STREAM_RECOVERY_REPLAY_COMPLETED, {
                         ...agentExtras(identity),
                         clientGeneration: String(clientGeneration),
@@ -59025,10 +59047,16 @@ var init_xmtp_sdk = __esm({
         let priorFailure = this.replayScanFailuresByAddress.get(addressKey);
         if (priorFailure && priorFailure.clientGeneration !== clientGeneration) {
           this.replayScanFailuresByAddress.delete(addressKey);
-          this.clearReplayScanRetry(address);
+          this.clearReplayScanRetry(address, "client_replaced");
           priorFailure = void 0;
         }
         if (priorFailure && attemptNowMs < priorFailure.nextAttemptAtMs) {
+          if (trigger === "stream_recovery") {
+            priorFailure.retryTrigger = trigger;
+            if (recoveryIdentity && !priorFailure.recoveryIdentities.includes(recoveryIdentity)) {
+              priorFailure.recoveryIdentities.push(recoveryIdentity);
+            }
+          }
           priorFailure.suppressedAttempts++;
           summary.outcome = "suppressed_backoff";
           summary.failureStage = priorFailure.lastFailureStage;
@@ -59045,7 +59073,8 @@ var init_xmtp_sdk = __esm({
             agent,
             clientGeneration,
             priorFailure.retryTrigger,
-            summary.backoffMs
+            summary.backoffMs,
+            priorFailure.recoveryIdentities
           );
           summary.durationMs = Date.now() - addressReplayStartedAt;
           return summary;
@@ -59058,15 +59087,23 @@ var init_xmtp_sdk = __esm({
         const recordScanFailure = (stage, err2) => {
           const previous = this.replayScanFailuresByAddress.get(addressKey);
           const consecutiveFailures = (previous?.consecutiveFailures ?? 0) + 1;
-          const backoffMs = replayScanBackoffMs(consecutiveFailures);
+          const backoffMs = replayScanBackoffWithJitterMs(
+            consecutiveFailures,
+            this.replayScanRandom()
+          );
           const suppressedAttempts = previous?.suppressedAttempts ?? 0;
           const failureNowMs = this.replayScanNowMs();
-          const retryTrigger = isOfflineReplayForTrigger(trigger) ? "startup" : "periodic_repair";
+          const recoveryIdentities = [...previous?.recoveryIdentities ?? []];
+          if (trigger === "stream_recovery" && recoveryIdentity && !recoveryIdentities.includes(recoveryIdentity)) {
+            recoveryIdentities.push(recoveryIdentity);
+          }
+          const retryTrigger = trigger === "stream_recovery" ? trigger : previous?.retryTrigger ?? trigger;
           this.replayScanFailuresByAddress.set(addressKey, {
             clientGeneration,
             consecutiveFailures,
             nextAttemptAtMs: failureNowMs + backoffMs,
             retryTrigger,
+            recoveryIdentities,
             suppressedAttempts: 0,
             lastFailureStage: stage
           });
@@ -59075,7 +59112,8 @@ var init_xmtp_sdk = __esm({
             agent,
             clientGeneration,
             retryTrigger,
-            backoffMs
+            backoffMs,
+            recoveryIdentities
           );
           summary.outcome = stage === "syncAll" ? "sync_failed" : "list_failed";
           summary.failureStage = stage;
@@ -59272,6 +59310,30 @@ var init_xmtp_sdk = __esm({
           recoveredAfterFailures: String(recoveredFailure?.consecutiveFailures ?? 0),
           suppressedAttempts: String(recoveredFailure?.suppressedAttempts ?? 0)
         });
+        if (recoveredFailure) {
+          for (const recoverySequence of recoveredFailure.recoveryIdentities) {
+            logger.info(LogEvent.AGENT_STREAM_RECOVERY_REPLAY_COMPLETED, {
+              ...agentExtras({
+                walletAddress: address,
+                inboxId: agent.client?.inboxId,
+                onchainosAgentId: this.getAgentByAddress(address)?.agentId,
+                role: this.getAgentByAddress(address)?.role
+              }),
+              clientGeneration: String(clientGeneration),
+              recoverySequence,
+              replayed: String(summary.replayed),
+              skipped: String(summary.skipped),
+              conversationCount: String(summary.conversations),
+              replayDurationMs: String(Date.now() - addressReplayStartedAt),
+              outcome: "success",
+              replayOutcome: "completed",
+              recoveredAfterFailures: String(
+                recoveredFailure.consecutiveFailures
+              ),
+              suppressedAttempts: String(recoveredFailure.suppressedAttempts)
+            });
+          }
+        }
         summary.outcome = "completed";
         summary.consecutiveFailures = recoveredFailure?.consecutiveFailures;
         summary.suppressedAttempts = recoveredFailure?.suppressedAttempts;
@@ -59928,6 +59990,39 @@ function fingerprintAgents(agents) {
 function filterNoisyAgentIdentityLog(stderr) {
   return stderr.split(/\r?\n/).filter((line) => !line.includes("[agent-identity] get response")).join("\n").trim();
 }
+function previewLogText(value, max = 300) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > max ? `${normalized.slice(0, max)}...` : normalized;
+}
+async function notifyAgentsWakeup(agentIds) {
+  if (agentIds.length === 0) {
+    logWithTimestamp("[onchainos] wakeup-notify: agentIds empty, skipping");
+    return;
+  }
+  const ids = agentIds.join(",");
+  logWithTimestamp(`[onchainos] sending wakeup-notify (agent-ids=${ids})`);
+  try {
+    const { stdout, stderr } = await exec([
+      "agent",
+      "wakeup-notify",
+      "--agent-ids",
+      ids
+    ]);
+    if (stderr) {
+      logWithTimestamp(`[onchainos] stderr (wakeup-notify): ${stderr}`);
+    }
+    logWithTimestamp(
+      `[onchainos] wakeup-notify result agentIds=${ids} stdoutBytes=${Buffer.byteLength(stdout ?? "", "utf8")} stdoutPreview=${previewLogText(stdout ?? "")}`
+    );
+    logWithTimestamp(`[onchainos] wakeup-notify succeeded (agent-ids=${ids})`);
+  } catch (err2) {
+    guardCatchSessionExpired2(err2, "wakeup-notify");
+    logWithTimestamp(
+      `[onchainos] wakeup-notify failed (agent-ids=${ids}):`,
+      err2?.message ?? err2
+    );
+  }
+}
 async function sendHeartbeat(chainIndex) {
   logWithTimestamp(`[onchainos] sending heartbeat (chain-index=${chainIndex})`);
   try {
@@ -65189,29 +65284,6 @@ var init_xmtp_debug = __esm({
   }
 });
 
-// src/ai-concurrency-config.ts
-function resolveMaxActiveAiExecutions(env = process.env) {
-  const raw = env.OKX_A2A_MAX_ACTIVE_AI_EXECUTIONS ?? env.OKX_AGENT_TASK_MAX_ACTIVE_AI_EXECUTIONS;
-  if (raw === void 0 || raw.trim() === "") {
-    return { limit: DEFAULT_MAX_ACTIVE_AI_EXECUTIONS, anomaly: null };
-  }
-  const parsed = Number(raw);
-  if (Number.isFinite(parsed) && Number.isInteger(parsed) && parsed > 0) {
-    return { limit: parsed, anomaly: null };
-  }
-  return {
-    limit: DEFAULT_MAX_ACTIVE_AI_EXECUTIONS,
-    anomaly: `invalid value "${raw}", using default ${DEFAULT_MAX_ACTIVE_AI_EXECUTIONS}`
-  };
-}
-var DEFAULT_MAX_ACTIVE_AI_EXECUTIONS;
-var init_ai_concurrency_config = __esm({
-  "src/ai-concurrency-config.ts"() {
-    "use strict";
-    DEFAULT_MAX_ACTIVE_AI_EXECUTIONS = 4;
-  }
-});
-
 // src/command-processor.ts
 function commandSentryExtra(command, extra = {}) {
   const base = {
@@ -65261,17 +65333,6 @@ function startCommandProcessor(params) {
   const executionTimeoutMs = readPositiveEnv("OKX_A2A_COMMAND_EXECUTION_TIMEOUT_MS", DEFAULT_COMMAND_EXECUTION_TIMEOUT_MS);
   const staleTimeoutMs = readPositiveEnv("OKX_A2A_COMMAND_STALE_TIMEOUT_MS", DEFAULT_COMMAND_STALE_TIMEOUT_MS);
   const aiStaleTimeoutMs = readPositiveEnv("OKX_A2A_AI_COMMAND_STALE_TIMEOUT_MS", DEFAULT_AI_COMMAND_STALE_TIMEOUT_MS);
-  const { limit: maxActiveAiExecutions, anomaly: aiLimitAnomaly } = resolveMaxActiveAiExecutions(process.env);
-  if (aiLimitAnomaly) {
-    logWithTimestamp(`[okx-agent-task] AI concurrency limit config anomaly: ${aiLimitAnomaly}`);
-    logger.info(LogEvent.AI_CONCURRENCY_SNAPSHOT, {
-      component: "node_command_processor",
-      stage: "config",
-      reason: "invalid_config_using_default",
-      configuredLimit: String(maxActiveAiExecutions),
-      anomaly: aiLimitAnomaly
-    });
-  }
   let inFlight = false;
   let aiScanInFlight = false;
   const activeAiQueueKeys = /* @__PURE__ */ new Set();
@@ -65361,9 +65422,6 @@ function startCommandProcessor(params) {
       inFlight = false;
     }
   };
-  const AI_SNAPSHOT_MIN_INTERVAL_MS = 15e3;
-  let lastAiSnapshotSignature = "";
-  let lastAiSnapshotAtMs = 0;
   const aiTick = async () => {
     if (aiScanInFlight) {
       return;
@@ -65376,33 +65434,15 @@ function startCommandProcessor(params) {
         skipCommandIds: activeAiCommandIds
       });
       const pending = await commands.listPendingEntries();
-      const pendingAi = pending.filter((entry) => isAiDispatchCommand(entry.command));
-      if (activeAiCommandIds.size > 0 || pendingAi.length > 0) {
-        const snapshotNow = Date.now();
-        const oldestQueuedAgeMs = pendingAi.reduce((oldest, entry) => {
-          const createdAt = Number.isFinite(entry.command.createdAt) ? entry.command.createdAt : entry.mtimeMs;
-          return Math.max(oldest, snapshotNow - createdAt);
-        }, 0);
-        const snapshotSignature = `${maxActiveAiExecutions}|${activeAiCommandIds.size}|${pendingAi.length}`;
-        if (snapshotSignature !== lastAiSnapshotSignature || snapshotNow - lastAiSnapshotAtMs >= AI_SNAPSHOT_MIN_INTERVAL_MS) {
-          lastAiSnapshotSignature = snapshotSignature;
-          lastAiSnapshotAtMs = snapshotNow;
-          logger.info(LogEvent.AI_CONCURRENCY_SNAPSHOT, {
-            component: "node_command_processor",
-            configuredLimit: String(maxActiveAiExecutions),
-            activeCount: String(activeAiCommandIds.size),
-            queueDepth: String(pendingAi.length),
-            oldestQueuedAgeMs: String(oldestQueuedAgeMs)
-          });
-        }
-      } else {
-        lastAiSnapshotSignature = "";
-      }
       for (const entry of pending) {
         const command = entry.command;
         if (!isAiDispatchCommand(command)) {
           continue;
         }
+        const queueKey = buildAiCommandQueueKey(command);
+        if (activeAiQueueKeys.has(queueKey)) {
+          continue;
+        }
         if (isStalePending(entry, aiStaleTimeoutMs)) {
           const message = `${command.type}/${command.kind} command expired after ${formatDuration2(Date.now() - command.createdAt)} in pending queue`;
           await commands.completePending(command, {
@@ -65413,20 +65453,13 @@ function startCommandProcessor(params) {
             stage: "pending",
             ageMs: Date.now() - command.createdAt,
             timeoutMs: aiStaleTimeoutMs,
-            reason: "queue_expired"
+            reason: "pending_expired"
           }));
           logWithTimestamp(
             `[okx-agent-task] ${command.type}/${command.kind} command expired id=${command.id}: ${message}`
           );
           continue;
         }
-        if (activeAiCommandIds.size >= maxActiveAiExecutions) {
-          continue;
-        }
-        const queueKey = buildAiCommandQueueKey(command);
-        if (activeAiQueueKeys.has(queueKey)) {
-          continue;
-        }
         const processingPath = await commands.take(command);
         if (!processingPath) {
           continue;
@@ -65999,9 +66032,6 @@ function isStalePending(entry, staleTimeoutMs) {
   return Date.now() - createdAt > staleTimeoutMs;
 }
 function buildAiCommandQueueKey(command) {
-  if (command.jobId) {
-    return `job:${command.jobId}`;
-  }
   if (command.kind === "job-message") {
     return buildDispatchSessionKey(command.jobId, command.sessionAgentId);
   }
@@ -66109,7 +66139,6 @@ var init_command_processor = __esm({
     init_user_attention_ipc();
     init_sentry_logger();
     init_xmtp_debug();
-    init_ai_concurrency_config();
     DEFAULT_COMMAND_EXECUTION_TIMEOUT_MS = 5e4;
     DEFAULT_COMMAND_STALE_TIMEOUT_MS = 12e4;
     DEFAULT_AI_COMMAND_STALE_TIMEOUT_MS = 30 * 6e4;
@@ -67710,575 +67739,6 @@ var init_message_handler = __esm({
   }
 });
 
-// src/wakeup-notify-client.ts
-function isTransientTransportError(err2) {
-  const message = err2 instanceof Error ? err2.message : String(err2);
-  return TRANSIENT_TRANSPORT_PATTERN.test(message);
-}
-function isPlainObject4(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function isValidWakeupItem(raw) {
-  if (!isPlainObject4(raw)) {
-    return { ok: false, reason: "malformed_item" };
-  }
-  if (typeof raw.agentId !== "string" || raw.agentId.length === 0) {
-    return { ok: false, reason: "missing_agent_id" };
-  }
-  const message = raw.message;
-  if (!isPlainObject4(message) || message.source !== "system") {
-    return { ok: false, reason: "not_system_notification" };
-  }
-  if (message.event !== "wakeup_notify") {
-    return { ok: false, reason: "not_wakeup_notify" };
-  }
-  return {
-    ok: true,
-    item: { agentId: raw.agentId, message }
-  };
-}
-function canonicalize(value) {
-  if (Array.isArray(value)) {
-    return value.map(canonicalize);
-  }
-  if (value && typeof value === "object") {
-    const source = value;
-    return Object.keys(source).sort().reduce((acc, key) => {
-      acc[key] = canonicalize(source[key]);
-      return acc;
-    }, {});
-  }
-  return value;
-}
-function deriveWakeupDedupeKey(item) {
-  const canonicalMessage = JSON.stringify(canonicalize(item.message ?? {}));
-  const identity = `${item.agentId}
-${canonicalMessage}`;
-  return `wakeup:${(0, import_node_crypto15.createHash)("sha256").update(identity).digest("hex").slice(0, 24)}`;
-}
-async function fetchAllWakeupNotifications(opts) {
-  const { agentIds, fetchPage, onPage } = opts;
-  const maxPages = opts.maxPages;
-  const maxPageAttempts = opts.maxPageAttempts ?? DEFAULT_MAX_PAGE_ATTEMPTS;
-  const retryDelayMs = opts.retryDelayMs ?? DEFAULT_PAGE_RETRY_DELAY_MS;
-  const sleep5 = opts.sleep ?? ((ms) => new Promise((resolve14) => setTimeout(resolve14, ms)));
-  const isRetryableError = opts.isRetryableError ?? isTransientTransportError;
-  const onRetry = opts.onRetry;
-  const fetchPageWithRetry = async (pageNum) => {
-    let attempt = 0;
-    while (true) {
-      attempt++;
-      try {
-        return await fetchPage({ agentIds, page: pageNum });
-      } catch (err2) {
-        if (!isRetryableError(err2) || attempt >= maxPageAttempts) {
-          throw err2;
-        }
-        onRetry?.({ page: pageNum, attempt, reason: "transient_transport" });
-        await sleep5(retryDelayMs * attempt + Math.floor(Math.random() * (retryDelayMs + 1)));
-      }
-    }
-  };
-  const items = [];
-  const rejects = [];
-  const visited = /* @__PURE__ */ new Set();
-  let pagesFetched = 0;
-  let page = 1;
-  let terminated = "empty";
-  try {
-    while (true) {
-      const resp = await fetchPageWithRetry(page);
-      pagesFetched++;
-      if (resp.code !== 0) {
-        terminated = "business_error";
-        break;
-      }
-      const rawList = resp.data?.list;
-      if (!Array.isArray(rawList)) {
-        rejects.push({ reason: "invalid_response_list" });
-        terminated = "invalid_response";
-        break;
-      }
-      const list = rawList;
-      let itemCount = 0;
-      let rejectedCount = 0;
-      for (const element of list) {
-        const check = isValidWakeupItem(element);
-        if (check.ok) {
-          items.push(check.item);
-          itemCount++;
-        } else {
-          rejects.push({ reason: check.reason });
-          rejectedCount++;
-        }
-      }
-      const nextPage = resp.data?.nextPage;
-      onPage?.({ page, itemCount, rejectedCount, hasNextPage: nextPage != null });
-      if (nextPage === null) {
-        terminated = items.length || rejects.length ? "next_page_null" : "empty";
-        break;
-      }
-      if (typeof nextPage !== "number" || !Number.isInteger(nextPage) || nextPage <= 0) {
-        rejects.push({ reason: "invalid_next_page" });
-        terminated = "invalid_response";
-        break;
-      }
-      visited.add(page);
-      page = nextPage;
-      if (visited.has(page) || maxPages !== void 0 && pagesFetched >= maxPages) {
-        terminated = "max_pages";
-        break;
-      }
-    }
-  } catch {
-    terminated = "transport_error";
-  }
-  const summary = {
-    pagesFetched,
-    received: items.length + rejects.length,
-    persisted: 0,
-    partial: 0,
-    duplicates: 0,
-    rejected: rejects.length,
-    terminated
-  };
-  return { items, summary, rejects };
-}
-var import_node_crypto15, DEFAULT_MAX_PAGE_ATTEMPTS, DEFAULT_PAGE_RETRY_DELAY_MS, TRANSIENT_TRANSPORT_PATTERN;
-var init_wakeup_notify_client = __esm({
-  "src/wakeup-notify-client.ts"() {
-    "use strict";
-    import_node_crypto15 = require("node:crypto");
-    DEFAULT_MAX_PAGE_ATTEMPTS = 3;
-    DEFAULT_PAGE_RETRY_DELAY_MS = 500;
-    TRANSIENT_TRANSPORT_PATTERN = /timed out|timeout|ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|socket hang up|network/i;
-  }
-});
-
-// src/wakeup-notify-ingest.ts
-async function ingestWakeupNotification(item, deps) {
-  const messageId = deriveWakeupDedupeKey(item);
-  const itemJobId = item.message.jobId ?? null;
-  const rawText = JSON.stringify({ agentId: item.agentId, message: item.message });
-  const notif = extractSystemNotification(JSON.parse(rawText));
-  if (!notif?.agentId) {
-    return {
-      status: "rejected",
-      reason: "invalid_system_notification",
-      dedupeKey: messageId,
-      jobId: itemJobId,
-      targetCount: 0
-    };
-  }
-  const targets = resolveSystemNotificationTargets(
-    { sessionStore: deps.sessionStore, myXmtpAddress: deps.myXmtpAddress ?? "", store: void 0 },
-    notif
-  );
-  let succeeded = 0;
-  let failed = 0;
-  for (const target of targets) {
-    let enqueued = false;
-    for (let attempt = 1; attempt <= MAX_TARGET_ENQUEUE_ATTEMPTS && !enqueued; attempt++) {
-      try {
-        await enqueueAiSessionMessageDispatch({
-          commands: deps.commands,
-          event: {
-            sessionKey: target.sessionKey,
-            content: rawText,
-            messageId,
-            jobId: target.jobId ?? null,
-            agentId: target.agentId ?? null
-          }
-        });
-        enqueued = true;
-      } catch {
-      }
-    }
-    if (enqueued) {
-      succeeded += 1;
-    } else {
-      failed += 1;
-    }
-  }
-  if (targets.length > 0 && succeeded === 0) {
-    return {
-      status: "rejected",
-      reason: "enqueue_failed",
-      dedupeKey: messageId,
-      jobId: notif.jobId ?? null,
-      targetCount: 0,
-      failedTargetCount: failed
-    };
-  }
-  if (failed > 0) {
-    return {
-      status: "partial",
-      reason: "partial_enqueue",
-      dedupeKey: messageId,
-      jobId: notif.jobId ?? null,
-      targetCount: succeeded,
-      failedTargetCount: failed
-    };
-  }
-  return {
-    status: "persisted",
-    dedupeKey: messageId,
-    jobId: notif.jobId ?? null,
-    targetCount: succeeded
-  };
-}
-var MAX_TARGET_ENQUEUE_ATTEMPTS;
-var init_wakeup_notify_ingest = __esm({
-  "src/wakeup-notify-ingest.ts"() {
-    "use strict";
-    init_ai_dispatch_queue();
-    init_message_handler();
-    init_wakeup_notify_client();
-    MAX_TARGET_ENQUEUE_ATTEMPTS = 3;
-  }
-});
-
-// src/wakeup-notify-transport.ts
-function withTimeout3(promise, timeoutMs, label) {
-  return new Promise((resolve14, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error(`${label} timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        resolve14(value);
-      },
-      (err2) => {
-        clearTimeout(timer);
-        reject(err2);
-      }
-    );
-  });
-}
-function resolveCliTimeoutMs(override) {
-  if (typeof override === "number" && Number.isFinite(override) && override > 0) {
-    return override;
-  }
-  const raw = Number(process.env.OKX_A2A_WAKEUP_CLI_TIMEOUT_MS);
-  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_CLI_TIMEOUT_MS;
-}
-function isPlainObject5(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function mapCliStdoutToWakeupResponse(parsed) {
-  const root = isPlainObject5(parsed) ? parsed : {};
-  const rootData = isPlainObject5(root.data) ? root.data : {};
-  const nestedData = isPlainObject5(rootData.data) ? rootData.data : {};
-  const candidates = [root, rootData, nestedData];
-  let code;
-  let msg;
-  let list = [];
-  let listFound = false;
-  let nextPage = null;
-  let nextPageFound = false;
-  for (const candidate of candidates) {
-    if (code === void 0 && typeof candidate.code === "number" && Number.isFinite(candidate.code)) {
-      code = candidate.code;
-    }
-    if (msg === void 0 && typeof candidate.msg === "string") {
-      msg = candidate.msg;
-    }
-    if (!listFound && Array.isArray(candidate.list)) {
-      list = candidate.list;
-      listFound = true;
-    }
-    if (!nextPageFound && "nextPage" in candidate) {
-      const raw = candidate.nextPage;
-      if (typeof raw === "number" && Number.isFinite(raw)) {
-        nextPage = raw;
-        nextPageFound = true;
-      } else if (raw === null) {
-        nextPage = null;
-        nextPageFound = true;
-      }
-    }
-  }
-  if (code === void 0) {
-    code = root.ok === true ? 0 : 1;
-  }
-  return {
-    code,
-    msg,
-    data: { list: listFound ? list : void 0, nextPage: nextPageFound ? nextPage : void 0 }
-  };
-}
-function createOnchainosWakeupFetchPage(deps = {}) {
-  const timeoutMs = resolveCliTimeoutMs(deps.timeoutMs);
-  const exec2 = deps.exec ?? ((args) => exec(args, { timeoutMs }));
-  return async ({ agentIds, page }) => {
-    const { stdout } = await withTimeout3(
-      exec2([
-        "agent",
-        TASK_WAKEUP_CLI_COMMAND,
-        "--agent-ids",
-        agentIds.join(","),
-        "--page",
-        String(page)
-      ]),
-      timeoutMs,
-      `onchainos ${TASK_WAKEUP_CLI_COMMAND}`
-    );
-    const parsed = parseCliJson(stdout, TASK_WAKEUP_CLI_COMMAND, {
-      page: String(page)
-    });
-    return mapCliStdoutToWakeupResponse(parsed);
-  };
-}
-var TASK_WAKEUP_CLI_COMMAND, DEFAULT_CLI_TIMEOUT_MS;
-var init_wakeup_notify_transport = __esm({
-  "src/wakeup-notify-transport.ts"() {
-    "use strict";
-    init_bin();
-    init_cli_response();
-    TASK_WAKEUP_CLI_COMMAND = "task-wakeup";
-    DEFAULT_CLI_TIMEOUT_MS = 3e4;
-  }
-});
-
-// src/wakeup-chunk-config.ts
-function resolveWakeupChunkSize(env = process.env) {
-  const fallback = resolveMaxActiveAiExecutions(env).limit;
-  const raw = env.OKX_A2A_WAKEUP_CHUNK_SIZE;
-  if (raw === void 0 || raw.trim() === "") {
-    return { chunkSize: fallback, anomaly: null };
-  }
-  const parsed = Number(raw);
-  if (Number.isFinite(parsed) && Number.isInteger(parsed) && parsed > 0) {
-    return { chunkSize: parsed, anomaly: null };
-  }
-  return {
-    chunkSize: fallback,
-    anomaly: `invalid value "${raw}", using default ${fallback}`
-  };
-}
-var init_wakeup_chunk_config = __esm({
-  "src/wakeup-chunk-config.ts"() {
-    "use strict";
-    init_ai_concurrency_config();
-  }
-});
-
-// src/wakeup-pull.ts
-function splitIntoChunks(items, size3) {
-  const chunkSize = Math.max(1, size3);
-  const chunks = [];
-  for (let i = 0; i < items.length; i += chunkSize) {
-    chunks.push(items.slice(i, i + chunkSize));
-  }
-  return chunks;
-}
-function buildDroppedWorkTelemetry(snapshot) {
-  return {
-    sentry: {
-      component: "wakeup_pull",
-      reason: "daemon_shutdown",
-      remainingChunks: String(snapshot.remainingChunks),
-      droppedMessages: String(snapshot.droppedMessages),
-      affectedJobCount: String(snapshot.pendingJobIds.length),
-      inFlightChunk: String(snapshot.inFlightChunk)
-    },
-    local: {
-      droppedMessages: snapshot.droppedMessages,
-      pendingJobIds: snapshot.pendingJobIds.slice(0, MAX_LOGGED_PENDING_JOB_IDS),
-      jobIdsTruncated: snapshot.pendingJobIds.length > MAX_LOGGED_PENDING_JOB_IDS,
-      inFlightChunk: snapshot.inFlightChunk
-    }
-  };
-}
-function logDroppedWakeupWorkOnShutdown(dispatcher) {
-  if (!dispatcher) {
-    return;
-  }
-  const snapshot = dispatcher.pendingSnapshot();
-  if (snapshot.droppedMessages === 0 && !snapshot.inFlightChunk) {
-    return;
-  }
-  const telemetry = buildDroppedWorkTelemetry(snapshot);
-  logger.info(LogEvent.WAKEUP_IN_MEMORY_WORK_DROPPED, telemetry.sentry);
-  logWithTimestamp("[okx-agent-task] WakeupNotify messages dropped on shutdown", telemetry.local);
-}
-async function startWakeupNotifyPull(opts) {
-  const enabled = opts.enabled ?? true;
-  const fetchPage = opts.fetchPage ?? (enabled ? createOnchainosWakeupFetchPage() : void 0);
-  if (!enabled || !fetchPage) {
-    logWithTimestamp("[okx-agent-task] WakeupNotify pull skipped (disabled)");
-    return null;
-  }
-  const agentIds = [
-    ...new Set(
-      [...opts.service.getClients().keys()].map((addr) => opts.service.getAgentByAddress(addr)?.agentId).filter((id) => typeof id === "string" && id.length > 0)
-    )
-  ];
-  if (agentIds.length === 0) {
-    logWithTimestamp("[okx-agent-task] WakeupNotify pull skipped (no active agents)");
-    return null;
-  }
-  logger.info(LogEvent.WAKEUP_PULL_STARTED, {
-    component: "wakeup_pull",
-    agentCount: String(agentIds.length)
-  });
-  const { items, summary, rejects } = await fetchAllWakeupNotifications({
-    agentIds,
-    fetchPage,
-    onPage: (p) => logger.info(LogEvent.WAKEUP_PULL_PAGE_FETCHED, {
-      component: "wakeup_pull",
-      page: String(p.page),
-      itemCount: String(p.itemCount),
-      rejectedCount: String(p.rejectedCount),
-      hasNextPage: String(p.hasNextPage)
-    }),
-    onRetry: (r) => logger.info(LogEvent.WAKEUP_PULL_PAGE_RETRY, {
-      component: "wakeup_pull",
-      page: String(r.page),
-      attempt: String(r.attempt),
-      reason: r.reason
-    })
-  });
-  for (const reject of rejects) {
-    logger.info(LogEvent.WAKEUP_NOTIFICATION_REJECTED, {
-      component: "wakeup_pull",
-      reason: reject.reason
-    });
-  }
-  if (summary.terminated === "transport_error" || summary.terminated === "business_error" || summary.terminated === "invalid_response") {
-    logger.error(LogEvent.WAKEUP_PULL_FAILED, void 0, {
-      component: "wakeup_pull",
-      terminated: summary.terminated
-    });
-  }
-  const resolved = opts.chunkSize != null ? { chunkSize: opts.chunkSize, anomaly: null } : resolveWakeupChunkSize(opts.env);
-  if (resolved.anomaly) {
-    logWithTimestamp(`[okx-agent-task] WakeupNotify chunk size ${resolved.anomaly}`);
-  }
-  const chunks = splitIntoChunks(items, resolved.chunkSize);
-  logger.info(LogEvent.WAKEUP_PULL_COMPLETED, {
-    component: "wakeup_pull",
-    pagesFetched: String(summary.pagesFetched),
-    received: String(summary.received),
-    rejected: String(summary.rejected),
-    chunkCount: String(chunks.length),
-    size: String(resolved.chunkSize),
-    terminated: summary.terminated
-  });
-  const deps = {
-    commands: opts.commands,
-    sessionStore: opts.sessionStore,
-    myXmtpAddress: void 0
-  };
-  const dispatcher = new HeartbeatChunkDispatcher(chunks, deps, opts.shouldContinue);
-  await dispatcher.dispatchNextChunk();
-  return dispatcher.hasPendingChunks() ? dispatcher : null;
-}
-var HeartbeatChunkDispatcher, MAX_LOGGED_PENDING_JOB_IDS;
-var init_wakeup_pull = __esm({
-  "src/wakeup-pull.ts"() {
-    "use strict";
-    init_log();
-    init_sentry_logger();
-    init_wakeup_notify_ingest();
-    init_wakeup_notify_client();
-    init_wakeup_notify_transport();
-    init_wakeup_chunk_config();
-    HeartbeatChunkDispatcher = class {
-      constructor(chunks, deps, shouldContinue) {
-        this.chunks = chunks;
-        this.deps = deps;
-        this.shouldContinue = shouldContinue;
-      }
-      chunks;
-      deps;
-      shouldContinue;
-      index = 0;
-      /** True while a chunk is mid-dispatch (between taking it and its enqueues settling). */
-      dispatching = false;
-      hasPendingChunks() {
-        return this.index < this.chunks.length;
-      }
-      remainingChunks() {
-        return Math.max(0, this.chunks.length - this.index);
-      }
-      /**
-       * Read-only view of the not-yet-started chunks (for shutdown telemetry). `index` has
-       * already advanced past any in-flight chunk, so `chunks.slice(index)` is exactly the work
-       * that has not begun dispatching — the in-flight chunk is excluded from the dropped counts
-       * and reflected only by `inFlightChunk`.
-       */
-      pendingSnapshot() {
-        const notStarted = this.chunks.slice(this.index);
-        let droppedMessages = 0;
-        const jobIds = /* @__PURE__ */ new Set();
-        for (const chunk of notStarted) {
-          for (const item of chunk) {
-            droppedMessages += 1;
-            const jobId = item.message.jobId;
-            if (typeof jobId === "string" && jobId.length > 0) {
-              jobIds.add(jobId);
-            }
-          }
-        }
-        return {
-          remainingChunks: notStarted.length,
-          droppedMessages,
-          pendingJobIds: [...jobIds],
-          inFlightChunk: this.dispatching
-        };
-      }
-      /** Dispatch the next chunk: enqueue every message in it in parallel. No-op when drained. */
-      async dispatchNextChunk() {
-        if (this.shouldContinue && !this.shouldContinue()) {
-          return;
-        }
-        if (this.index >= this.chunks.length) {
-          return;
-        }
-        const chunk = this.chunks[this.index];
-        this.index += 1;
-        const chunkNumber = this.index;
-        this.dispatching = true;
-        let persisted = 0;
-        let partial = 0;
-        let rejected = 0;
-        try {
-          const outcomes = await Promise.allSettled(
-            chunk.map((item) => ingestWakeupNotification(item, this.deps))
-          );
-          for (const outcome of outcomes) {
-            if (outcome.status === "fulfilled") {
-              if (outcome.value.status === "persisted") {
-                persisted += 1;
-              } else if (outcome.value.status === "partial") {
-                partial += 1;
-              } else {
-                rejected += 1;
-              }
-            } else {
-              rejected += 1;
-            }
-          }
-        } finally {
-          this.dispatching = false;
-        }
-        logger.info(LogEvent.WAKEUP_CHUNK_DISPATCHED, {
-          component: "wakeup_pull",
-          chunk: String(chunkNumber),
-          chunkCount: String(this.chunks.length),
-          size: String(chunk.length),
-          persisted: String(persisted),
-          partial: String(partial),
-          rejected: String(rejected)
-        });
-      }
-    };
-    MAX_LOGGED_PENDING_JOB_IDS = 100;
-  }
-});
-
 // src/user-attention-watchers.ts
 function createUserAttentionWatchParentMonitor(options = {}) {
   const parentPid = options.parentPid ?? process.ppid;
@@ -68317,7 +67777,7 @@ function isOriginalParentProcessAlive(options) {
 }
 function registerUserAttentionWatcher(options) {
   return options.store.registerUserAttentionWatcher({
-    id: options.id ?? (0, import_node_crypto16.randomUUID)(),
+    id: options.id ?? (0, import_node_crypto15.randomUUID)(),
     provider: options.provider,
     jobId: options.jobId,
     nowMs: options.nowMs ?? Date.now(),
@@ -68396,11 +67856,11 @@ function userWatchEventDeliveredSentryExtra(event) {
     hasDecision: String(event.hasDecision)
   };
 }
-var import_node_crypto16, USER_ATTENTION_WATCH_REPLACED_MESSAGE, USER_ATTENTION_WATCHER_SCAN_MS, USER_ATTENTION_WATCHER_TTL_MS, USER_ATTENTION_WATCH_PARENT_CHECK_MS;
+var import_node_crypto15, USER_ATTENTION_WATCH_REPLACED_MESSAGE, USER_ATTENTION_WATCHER_SCAN_MS, USER_ATTENTION_WATCHER_TTL_MS, USER_ATTENTION_WATCH_PARENT_CHECK_MS;
 var init_user_attention_watchers = __esm({
   "src/user-attention-watchers.ts"() {
     "use strict";
-    import_node_crypto16 = require("node:crypto");
+    import_node_crypto15 = require("node:crypto");
     init_sentry_logger();
     USER_ATTENTION_WATCH_REPLACED_MESSAGE = "Another okx-a2a user watch with the same job scope was started, so this watcher has been closed. Do not run this watch command again automatically, because starting another watcher may interrupt a different session that is already monitoring task progress.";
     USER_ATTENTION_WATCHER_SCAN_MS = 500;
@@ -68658,6 +68118,7 @@ async function runListenerWithLock(options, paths) {
     fetchSystemConfig: async () => fetchSystemConfig({
       notifySessionExpired: (command) => service.tools.notifySessionExpired?.(command)
     }),
+    notifyAgentsWakeup: async (agentIds) => notifyAgentsWakeup(agentIds),
     createSigner: (agent) => createOnchainosSigner(agent),
     createInboundMiddleware: (deps) => createMiddlewareFromCoreDeps(store, deps, {
       sessionStore,
@@ -68707,12 +68168,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.9-beta-912b775358-260824171011");
+  service.setPluginVersion("0.2.9");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.9-beta-912b775358-260824171011"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.9"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -68740,7 +68201,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.9-beta-912b775358-260824171011"
+      pluginVersion: "0.2.9"
     });
   }
   logWithTimestamp(
@@ -68983,7 +68444,6 @@ async function runListenerWithLock(options, paths) {
   let intervalSec = Math.max(10, service.getSystemConfig().heartbeatInterval);
   let offlineReplayIntervalSec = resolveOfflineReplayIntervalSec(service.getSystemConfig());
   let xmtpClientRecycleIntervalSec = resolveXmtpClientRecycleIntervalSec(service.getSystemConfig());
-  let wakeupDispatcher = null;
   let timer;
   let offlineReplayTimer;
   let xmtpClientRecycleTimer;
@@ -69002,7 +68462,6 @@ async function runListenerWithLock(options, paths) {
         versionRefresh: refreshOnchainosVersionMetadata,
         refresh: syncTick
       });
-      void wakeupDispatcher?.dispatchNextChunk();
     }, intervalSec * 1e3);
   };
   const scheduleOfflineReplayTimer = (nextIntervalSec) => {
@@ -69117,22 +68576,6 @@ async function runListenerWithLock(options, paths) {
   });
   await markDaemonReady(paths.daemonLockPath);
   logWithTimestamp(`[okx-agent-task] daemon ready lock=${paths.daemonLockPath}`);
-  void startWakeupNotifyPull({
-    service,
-    commands,
-    sessionStore,
-    // Stop enqueuing if a shutdown begins mid-delivery (fire-and-forget pull).
-    shouldContinue: () => !stopping
-  }).then((dispatcher) => {
-    wakeupDispatcher = dispatcher;
-  }).catch((err2) => {
-    logger.error(LogEvent.WAKEUP_PULL_FAILED, err2 instanceof Error ? err2 : new Error(String(err2)), {
-      component: "node_listener",
-      stage: "wakeup_pull_start",
-      reason: "wakeup_pull_unhandled_error"
-    });
-    logWithTimestamp("[okx-agent-task] WakeupNotify pull failed to start:", err2);
-  });
   await new Promise((resolve14) => {
     const shutdown2 = (signal) => {
       if (stopping) {
@@ -69145,7 +68588,6 @@ async function runListenerWithLock(options, paths) {
         resolve14();
       }, SHUTDOWN_FORCE_RESOLVE_MS);
       void (async () => {
-        logDroppedWakeupWorkOnShutdown(wakeupDispatcher);
         deferredMaintenanceTasks.cancelAll();
         if (timer) {
           clearInterval(timer);
@@ -69207,7 +68649,6 @@ var init_listener = __esm({
     init_file_store();
     init_session_store();
     init_command_processor();
-    init_wakeup_pull();
     init_command_store();
     init_ai_dispatch_queue();
     init_message_handler();
@@ -87471,7 +86912,7 @@ var require_fetch_pb = __commonJS({
         }
       });
     }
-    function isPlainObject6(value) {
+    function isPlainObject4(value) {
       const isObject = Object.prototype.toString.call(value).slice(8, -1) === "Object";
       const isObjLike = value !== null && isObject;
       if (!isObjLike || !isObject) {
@@ -87494,7 +86935,7 @@ var require_fetch_pb = __commonJS({
         const isNonEmptyPrimitiveArray = Array.isArray(value) && value.every((v) => isPrimitive(v)) && value.length > 0;
         const isNonZeroValuePrimitive = isPrimitive(value) && !isZeroValuePrimitive(value);
         let objectToMerge = {};
-        if (isPlainObject6(value)) {
+        if (isPlainObject4(value)) {
           objectToMerge = flattenRequestPayload(value, newPath);
         } else if (isNonZeroValuePrimitive || isNonEmptyPrimitiveArray) {
           objectToMerge = { [newPath]: value };
@@ -113063,10 +112504,10 @@ var require_node4 = __commonJS({
 
 // ../../node_modules/@xmtp/content-type-remote-attachment/dist/index.js
 async function encrypt(plain, secret, additionalData) {
-  const salt = import_node_crypto17.webcrypto.getRandomValues(new Uint8Array(KDFSaltSize));
-  const nonce = import_node_crypto17.webcrypto.getRandomValues(new Uint8Array(AESGCMNonceSize));
+  const salt = import_node_crypto16.webcrypto.getRandomValues(new Uint8Array(KDFSaltSize));
+  const nonce = import_node_crypto16.webcrypto.getRandomValues(new Uint8Array(AESGCMNonceSize));
   const key = await hkdf(secret, salt);
-  const encrypted = await import_node_crypto17.webcrypto.subtle.encrypt(aesGcmParams(nonce), key, plain);
+  const encrypted = await import_node_crypto16.webcrypto.subtle.encrypt(aesGcmParams(nonce), key, plain);
   return new Ciphertext({
     aes256GcmHkdfSha256: {
       payload: new Uint8Array(encrypted),
@@ -113080,7 +112521,7 @@ async function decrypt(encrypted, secret, additionalData) {
     throw new Error("invalid payload ciphertext");
   }
   const key = await hkdf(secret, encrypted.aes256GcmHkdfSha256.hkdfSalt);
-  const decrypted = await import_node_crypto17.webcrypto.subtle.decrypt(aesGcmParams(encrypted.aes256GcmHkdfSha256.gcmNonce), key, encrypted.aes256GcmHkdfSha256.payload);
+  const decrypted = await import_node_crypto16.webcrypto.subtle.decrypt(aesGcmParams(encrypted.aes256GcmHkdfSha256.gcmNonce), key, encrypted.aes256GcmHkdfSha256.payload);
   return new Uint8Array(decrypted);
 }
 function aesGcmParams(nonce, additionalData) {
@@ -113091,18 +112532,18 @@ function aesGcmParams(nonce, additionalData) {
   return spec;
 }
 async function hkdf(secret, salt) {
-  const key = await import_node_crypto17.webcrypto.subtle.importKey("raw", secret, "HKDF", false, [
+  const key = await import_node_crypto16.webcrypto.subtle.importKey("raw", secret, "HKDF", false, [
     "deriveKey"
   ]);
-  return import_node_crypto17.webcrypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt, info: hkdfNoInfo }, key, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+  return import_node_crypto16.webcrypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt, info: hkdfNoInfo }, key, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
 }
-var import_proto, import_node_crypto17, ContentTypeAttachment, AttachmentCodec, KDFSaltSize, AESGCMNonceSize, AESGCMTagLength, Ciphertext, hkdfNoInfo, ContentTypeRemoteAttachment, RemoteAttachmentCodec;
+var import_proto, import_node_crypto16, ContentTypeAttachment, AttachmentCodec, KDFSaltSize, AESGCMNonceSize, AESGCMTagLength, Ciphertext, hkdfNoInfo, ContentTypeRemoteAttachment, RemoteAttachmentCodec;
 var init_dist6 = __esm({
   "../../node_modules/@xmtp/content-type-remote-attachment/dist/index.js"() {
     init_dist5();
     init_secp256k12();
     import_proto = __toESM(require_node4(), 1);
-    import_node_crypto17 = require("node:crypto");
+    import_node_crypto16 = require("node:crypto");
     ContentTypeAttachment = new ContentTypeId({
       authorityId: "xmtp.org",
       typeId: "attachment",
@@ -113182,7 +112623,7 @@ var init_dist6 = __esm({
         if (payload.length === 0) {
           throw new Error(`no payload for remote attachment at ${remoteAttachment.url}`);
         }
-        const digestBytes = new Uint8Array(await import_node_crypto17.webcrypto.subtle.digest("SHA-256", payload));
+        const digestBytes = new Uint8Array(await import_node_crypto16.webcrypto.subtle.digest("SHA-256", payload));
         const digest = etc.bytesToHex(digestBytes);
         if (digest !== remoteAttachment.contentDigest) {
           throw new Error("content digest does not match");
@@ -113206,7 +112647,7 @@ var init_dist6 = __esm({
         return codec.decode(encodedContent, codecRegistry);
       }
       static async encodeEncrypted(content$1, codec) {
-        const secret = import_node_crypto17.webcrypto.getRandomValues(new Uint8Array(32));
+        const secret = import_node_crypto16.webcrypto.getRandomValues(new Uint8Array(32));
         const encodedContent = import_proto.content.EncodedContent.encode(codec.encode(content$1, {
           codecFor() {
             return void 0;
@@ -113219,7 +112660,7 @@ var init_dist6 = __esm({
         if (!salt || !nonce || !payload) {
           throw new Error("missing encryption key");
         }
-        const digestBytes = new Uint8Array(await import_node_crypto17.webcrypto.subtle.digest("SHA-256", payload));
+        const digestBytes = new Uint8Array(await import_node_crypto16.webcrypto.subtle.digest("SHA-256", payload));
         const digest = etc.bytesToHex(digestBytes);
         return {
           digest,
@@ -113437,7 +112878,7 @@ async function uploadFile(params) {
   const attachment = { filename, mimeType, data: new Uint8Array(data) };
   const encrypted = await RemoteAttachmentCodec.encodeEncrypted(attachment, new AttachmentCodec());
   ensureFileDirs();
-  const encryptedPath = (0, import_node_path33.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto18.randomUUID)()}.enc`);
+  const encryptedPath = (0, import_node_path33.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto17.randomUUID)()}.enc`);
   (0, import_node_fs27.writeFileSync)(encryptedPath, encrypted.payload);
   try {
     const stdout = runOnchainos([
@@ -113481,7 +112922,7 @@ async function uploadFile(params) {
 }
 async function downloadFile(params) {
   ensureFileDirs();
-  const encryptedPath = (0, import_node_path33.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto18.randomUUID)()}.enc`);
+  const encryptedPath = (0, import_node_path33.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto17.randomUUID)()}.enc`);
   try {
     const stdout = runOnchainos([
       "agent",
@@ -113506,7 +112947,7 @@ async function downloadFile(params) {
       throw new Error(`file download failed: ${stdout}`);
     }
     const payload = new Uint8Array((0, import_node_fs27.readFileSync)(encryptedPath));
-    const digestBytes = new Uint8Array(await import_node_crypto18.webcrypto.subtle.digest("SHA-256", payload));
+    const digestBytes = new Uint8Array(await import_node_crypto17.webcrypto.subtle.digest("SHA-256", payload));
     const actualDigest = Array.from(digestBytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
     if (actualDigest !== params.digest) {
       throw new Error(`file download digest verification failed: expected=${params.digest}, actual=${actualDigest}`);
@@ -113514,7 +112955,7 @@ async function downloadFile(params) {
     const decryptedBytes = await decryptAttachmentPayload(payload, params);
     const encodedContent = import_proto2.content.EncodedContent.decode(decryptedBytes);
     const attachment = new AttachmentCodec().decode(encodedContent);
-    const outputFilename = params.filename || attachment.filename || `${(0, import_node_crypto18.randomUUID)()}.bin`;
+    const outputFilename = params.filename || attachment.filename || `${(0, import_node_crypto17.randomUUID)()}.bin`;
     const outputDir = DOWNLOADS_DIR;
     ensureA2aTaskDir(outputDir);
     const outputPath = (0, import_node_path33.resolve)(outputDir, (0, import_node_path33.basename)(outputFilename));
@@ -113531,15 +112972,15 @@ async function decryptAttachmentPayload(payload, params) {
   const secretBytes = new Uint8Array(Buffer.from(params.secret, "base64"));
   const saltBytes = new Uint8Array(Buffer.from(params.salt, "base64"));
   const nonceBytes = new Uint8Array(Buffer.from(params.nonce, "base64"));
-  const hkdfKey = await import_node_crypto18.webcrypto.subtle.importKey("raw", secretBytes, "HKDF", false, ["deriveKey"]);
-  const aesKey = await import_node_crypto18.webcrypto.subtle.deriveKey(
+  const hkdfKey = await import_node_crypto17.webcrypto.subtle.importKey("raw", secretBytes, "HKDF", false, ["deriveKey"]);
+  const aesKey = await import_node_crypto17.webcrypto.subtle.deriveKey(
     { name: "HKDF", hash: "SHA-256", salt: saltBytes, info: new Uint8Array().buffer },
     hkdfKey,
     { name: "AES-GCM", length: 256 },
     false,
     ["decrypt"]
   );
-  return new Uint8Array(await import_node_crypto18.webcrypto.subtle.decrypt({ name: "AES-GCM", iv: nonceBytes }, aesKey, toArrayBuffer(payload)));
+  return new Uint8Array(await import_node_crypto17.webcrypto.subtle.decrypt({ name: "AES-GCM", iv: nonceBytes }, aesKey, toArrayBuffer(payload)));
 }
 function toArrayBuffer(bytes) {
   return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
@@ -113679,12 +113120,12 @@ function readRequiredOption(args, name) {
   }
   return value;
 }
-var import_node_crypto18, import_node_fs27, import_node_path33, import_proto2, OKX_A2A_PATHS, OKX_A2A_HOME_DIR, FILE_WORK_DIR, DOWNLOADS_DIR, SYSTEM_CONFIG_PATH;
+var import_node_crypto17, import_node_fs27, import_node_path33, import_proto2, OKX_A2A_PATHS, OKX_A2A_HOME_DIR, FILE_WORK_DIR, DOWNLOADS_DIR, SYSTEM_CONFIG_PATH;
 var init_file_cli = __esm({
   "src/file-cli.ts"() {
     "use strict";
     init_win_spawn();
-    import_node_crypto18 = require("node:crypto");
+    import_node_crypto17 = require("node:crypto");
     import_node_fs27 = require("node:fs");
     import_node_path33 = require("node:path");
     init_dist6();
@@ -117167,7 +116608,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.9-beta-912b775358-260824171011" : null;
+  return true ? "0.2.9" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -117377,7 +116818,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.9-beta-912b775358-260824171011") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.9") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -118430,7 +117871,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.9-beta-912b775358-260824171011" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.9" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -119458,7 +118899,7 @@ init_sentry_config();
 init_runtime_metadata();
 var CURRENT_GATEWAY_SESSION_KEYS_ENV4 = "OKX_A2A_CURRENT_GATEWAY_SESSION_KEYS";
 function printUsage3() {
-  console.log(`okx-a2a ${"0.2.9-beta-912b775358-260824171011"}
+  console.log(`okx-a2a ${"0.2.9"}
 
 Usage:
   okx-a2a <command> [options]
@@ -119498,7 +118939,7 @@ Run \`okx-a2a <command> -h\` for command-specific help.
 `);
 }
 function printVersion() {
-  console.log("0.2.9-beta-912b775358-260824171011");
+  console.log("0.2.9");
 }
 function printDaemonUsage() {
   console.log(`Usage: okx-a2a daemon <start|restart|stop|status|autostart> [options]
@@ -120979,7 +120420,7 @@ async function main() {
   if (command === "xmtp-test") {
     const { handleXmtpTestCommand: handleXmtpTestCommand2 } = await Promise.resolve().then(() => (init_xmtp_test_cli(), xmtp_test_cli_exports));
     await handleXmtpTestCommand2(process.argv.slice(3), {
-      packageVersion: "0.2.9-beta-912b775358-260824171011",
+      packageVersion: "0.2.9",
       agentSdkVersion: "2.3.0",
       nodeSdkVersion: "6.1.0",
       nodeBindingsVersion: "1.11.0"