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

package/dist/index.js

@@ -3992,7 +3992,7 @@ var require_is = __commonJS({
     function isPrimitive(wat) {
       return wat === null || typeof wat !== "object" && typeof wat !== "function";
     }
-    function isPlainObject4(wat) {
+    function isPlainObject6(wat) {
       return isBuiltin(wat, "Object");
     }
     function isEvent(wat) {
@@ -4008,7 +4008,7 @@ var require_is = __commonJS({
       return Boolean(wat && wat.then && typeof wat.then === "function");
     }
     function isSyntheticEvent(wat) {
-      return isPlainObject4(wat) && "nativeEvent" in wat && "preventDefault" in wat && "stopPropagation" in wat;
+      return isPlainObject6(wat) && "nativeEvent" in wat && "preventDefault" in wat && "stopPropagation" in wat;
     }
     function isNaN2(wat) {
       return typeof wat === "number" && wat !== wat;
@@ -4031,7 +4031,7 @@ var require_is = __commonJS({
     exports2.isEvent = isEvent;
     exports2.isInstanceOf = isInstanceOf;
     exports2.isNaN = isNaN2;
-    exports2.isPlainObject = isPlainObject4;
+    exports2.isPlainObject = isPlainObject6;
     exports2.isPrimitive = isPrimitive;
     exports2.isRegExp = isRegExp;
     exports2.isString = isString;
@@ -19284,6 +19284,17 @@ 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",
@@ -19338,6 +19349,7 @@ 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",
@@ -20145,6 +20157,15 @@ 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,
@@ -30985,7 +31006,7 @@ var require_websocket2 = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash6 } = require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash7 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -31645,7 +31666,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -32012,7 +32033,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = require("events");
     var http2 = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash6 } = require("crypto");
+    var { createHash: createHash7 } = require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -32313,7 +32334,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -32435,7 +32456,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.8",
+      release: "0.2.9-beta-912b775358-260824171011",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -33376,7 +33397,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.8" : null;
+  return true ? "0.2.9-beta-912b775358-260824171011" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -33586,7 +33607,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.8") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.9-beta-912b775358-260824171011") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -44299,6 +44320,7 @@ __export(index_exports, {
   CODEX_RECOVERY_ACTIONS: () => CODEX_RECOVERY_ACTIONS,
   CommandStore: () => CommandStore,
   DEFAULT_AI_PERMISSION_PRESET: () => DEFAULT_AI_PERMISSION_PRESET,
+  DEFAULT_MAX_ACTIVE_AI_EXECUTIONS: () => DEFAULT_MAX_ACTIVE_AI_EXECUTIONS,
   DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC: () => DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC,
   DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC: () => DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC,
   DOCTOR_MIN_NODE_VERSION: () => DOCTOR_MIN_NODE_VERSION,
@@ -44327,6 +44349,7 @@ __export(index_exports, {
   USER_ATTENTION_WATCH_PARENT_CHECK_MS: () => USER_ATTENTION_WATCH_PARENT_CHECK_MS,
   USER_ATTENTION_WATCH_REPLACED_MESSAGE: () => USER_ATTENTION_WATCH_REPLACED_MESSAGE,
   UserCancelledAiProviderSelectionError: () => UserCancelledAiProviderSelectionError,
+  WAKEUP_PAGE_SIZE: () => WAKEUP_PAGE_SIZE,
   WALLET_STATUS_TIMEOUT_MS: () => WALLET_STATUS_TIMEOUT_MS,
   XMTP_CLIENT_RECYCLE_INTERVAL_ENV: () => XMTP_CLIENT_RECYCLE_INTERVAL_ENV,
   XmtpDm: () => Dm,
@@ -44352,6 +44375,7 @@ __export(index_exports, {
   buildCodexRecoveryGuidance: () => buildCodexRecoveryGuidance,
   buildDispatchSessionKey: () => buildDispatchSessionKey,
   buildDoctorSentryExtra: () => buildDoctorSentryExtra,
+  buildDroppedWorkTelemetry: () => buildDroppedWorkTelemetry,
   buildExternalCommandInvocation: () => buildExternalCommandInvocation,
   buildGatewayOutboundExtra: () => buildGatewayOutboundExtra,
   buildInboundTerminalExtras: () => buildInboundTerminalExtras,
@@ -44391,9 +44415,11 @@ __export(index_exports, {
   commandExists: () => commandExists,
   createAiToolFailureTracker: () => createAiToolFailureTracker,
   createFileMessageHandler: () => createFileMessageHandler,
+  createOnchainosWakeupFetchPage: () => createOnchainosWakeupFetchPage,
   createOutboundBehavior: () => createOutboundBehavior,
   createUserAttentionWatchParentMonitor: () => createUserAttentionWatchParentMonitor,
   currentOpenClawGatewaySessionKey: () => currentOpenClawGatewaySessionKey,
+  deriveWakeupDedupeKey: () => deriveWakeupDedupeKey,
   detectAiProviders: () => detectAiProviders,
   detectAiRuntimeSurface: () => detectAiRuntimeSurface,
   detectCurrentAiProvider: () => detectCurrentAiProvider,
@@ -44409,7 +44435,9 @@ __export(index_exports, {
   exportDiagnosticLogs: () => exportDiagnosticLogs,
   extractAiSessionId: () => extractAiSessionId,
   extractDirectToUserNotification: () => extractDirectToUserNotification,
+  extractSystemNotification: () => extractSystemNotification,
   extractXmtpSentAtMs: () => extractXmtpSentAtMs2,
+  fetchAllWakeupNotifications: () => fetchAllWakeupNotifications,
   findWindowsNativeOkxA2aExe: () => findWindowsNativeOkxA2aExe,
   followFile: () => followFile,
   formatDoctorReportForHumans: () => formatDoctorReportForHumans,
@@ -44427,6 +44455,7 @@ __export(index_exports, {
   hashDiagnosticFileContent: () => hashDiagnosticFileContent,
   heartbeatUserAttentionWatcher: () => heartbeatUserAttentionWatcher,
   hermesConfigEnablesOkxA2a: () => hermesConfigEnablesOkxA2a,
+  ingestWakeupNotification: () => ingestWakeupNotification,
   installSystemdAutostart: () => installSystemdAutostart,
   installWindowsNativeLauncher: () => installWindowsNativeLauncher,
   installedAutostartHasCurrentConfiguration: () => installedAutostartHasCurrentConfiguration,
@@ -44445,12 +44474,15 @@ __export(index_exports, {
   isSqliteBusyError: () => isSqliteBusyError,
   isSystemdManagerUnavailableMessage: () => isSystemdManagerUnavailableMessage,
   isTagKey: () => isTagKey,
+  isValidWakeupItem: () => isValidWakeupItem,
   isWindowsElevated: () => isWindowsElevated,
   killProcessTree: () => killProcessTree,
   launchdPlistHasCurrentRestartPolicy: () => launchdPlistHasCurrentRestartPolicy,
   listAllAgentsWithMetadata: () => listAllAgentsWithMetadata,
+  logDroppedWakeupWorkOnShutdown: () => logDroppedWakeupWorkOnShutdown,
   logWinCompat: () => logWinCompat,
   logXmtpMessageSent: () => logXmtpMessageSent,
+  mapCliStdoutToWakeupResponse: () => mapCliStdoutToWakeupResponse,
   maybeRecommendOnchainosUpgrade: () => maybeRecommendOnchainosUpgrade,
   mergeA2AEnvelopeTips: () => mergeA2AEnvelopeTips,
   messageEligibleHelpAdvertisesOfflineReplay: () => messageEligibleHelpAdvertisesOfflineReplay,
@@ -44506,6 +44538,7 @@ __export(index_exports, {
   resolveDirectCommunicationSessionTarget: () => resolveDirectCommunicationSessionTarget,
   resolveDoctorTarget: () => resolveDoctorTarget,
   resolveEnvelopePayload: () => resolveEnvelopePayload,
+  resolveMaxActiveAiExecutions: () => resolveMaxActiveAiExecutions,
   resolveNpmCmdShimScript: () => resolveNpmCmdShimScript,
   resolveOfflineReplayCapabilityMarker: () => resolveOfflineReplayCapabilityMarker,
   resolveOfflineReplayIntervalSec: () => resolveOfflineReplayIntervalSec,
@@ -44519,6 +44552,7 @@ __export(index_exports, {
   resolveTaskHome: () => resolveTaskHome,
   resolveTaskPaths: () => resolveTaskPaths,
   resolveUserAttentionIpcPath: () => resolveUserAttentionIpcPath,
+  resolveWakeupChunkSize: () => resolveWakeupChunkSize,
   resolveWindowsAutostartPaths: () => resolveWindowsAutostartPaths,
   resolveXmtpClientRecycleIntervalSec: () => resolveXmtpClientRecycleIntervalSec,
   restartSystemdAutostart: () => restartSystemdAutostart,
@@ -44539,6 +44573,7 @@ __export(index_exports, {
   startDaemonRespectingSupervisor: () => startDaemonRespectingSupervisor,
   startUserAttentionEventServer: () => startUserAttentionEventServer,
   startUserAttentionWatcherCoordinator: () => startUserAttentionWatcherCoordinator,
+  startWakeupNotifyPull: () => startWakeupNotifyPull,
   stopDaemon: () => stopDaemon,
   stopOpenClawGateway: () => stopOpenClawGateway,
   stopSystemdAutostart: () => stopSystemdAutostart,
@@ -48170,6 +48205,34 @@ var CommandStore = class {
     }
     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();
   }
@@ -58251,36 +58314,15 @@ var XmtpService = class _XmtpService {
       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((err) => {
-      logWithTimestamp("[xmtp-sdk] notifyAgentsWakeup unexpected error:", err);
-      logger.error(
-        LogEvent.NOTIFY_AGENTS_WAKEUP_FAILED,
-        err instanceof Error ? err : new Error(String(err)),
-        {
-          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. Only then do we tell
-   * the backend that the agents are awake, so wakeup-triggered messages
-   * cannot overtake the stored backlog.
+   * 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.
    */
   async completeStartupReplay() {
     const startupGates = new Map(
@@ -58295,7 +58337,6 @@ var XmtpService = class _XmtpService {
     }
     this.resolveStartupReplayCompletion?.();
     this.resolveStartupReplayCompletion = void 0;
-    this.notifyAgentsWakeupAfterReplay();
     return summary;
   }
   async startListeningForAddresses(addresses) {
@@ -59967,39 +60008,6 @@ 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 (err) {
-    guardCatchSessionExpired2(err, "wakeup-notify");
-    logWithTimestamp(
-      `[onchainos] wakeup-notify failed (agent-ids=${ids}):`,
-      err?.message ?? err
-    );
-  }
-}
 async function sendHeartbeat(chainIndex) {
   logWithTimestamp(`[onchainos] sending heartbeat (chain-index=${chainIndex})`);
   try {
@@ -60933,7 +60941,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.8",
+      version: "0.2.9-beta-912b775358-260824171011",
       platform: "node",
       mode: "backend",
       instanceId
@@ -60944,7 +60952,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.8"}`,
+    userAgent: `okx-a2a-node/${"0.2.9-beta-912b775358-260824171011"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -64032,6 +64040,23 @@ function isRecord5(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
+// src/ai-concurrency-config.ts
+var DEFAULT_MAX_ACTIVE_AI_EXECUTIONS = 4;
+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}`
+  };
+}
+
 // src/command-processor.ts
 var DEFAULT_COMMAND_EXECUTION_TIMEOUT_MS = 5e4;
 var DEFAULT_COMMAND_STALE_TIMEOUT_MS = 12e4;
@@ -64085,6 +64110,17 @@ 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();
@@ -64174,6 +64210,9 @@ function startCommandProcessor(params) {
       inFlight = false;
     }
   };
+  const AI_SNAPSHOT_MIN_INTERVAL_MS = 15e3;
+  let lastAiSnapshotSignature = "";
+  let lastAiSnapshotAtMs = 0;
   const aiTick = async () => {
     if (aiScanInFlight) {
       return;
@@ -64186,15 +64225,33 @@ 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, {
@@ -64205,13 +64262,20 @@ function startCommandProcessor(params) {
             stage: "pending",
             ageMs: Date.now() - command.createdAt,
             timeoutMs: aiStaleTimeoutMs,
-            reason: "pending_expired"
+            reason: "queue_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;
@@ -64784,6 +64848,9 @@ 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);
   }
@@ -66537,6 +66604,10 @@ function createOnchainosSigner(agent) {
 // src/listener.ts
 init_session_store();
 
+// src/wakeup-pull.ts
+init_log();
+init_sentry_logger();
+
 // src/ai-dispatch-queue.ts
 async function enqueueAiJobMessageDispatch(params) {
   const commands = params.commands ?? new CommandStore(params.homeDir);
@@ -66562,11 +66633,539 @@ async function enqueueAiSessionMessageDispatch(params) {
   return command;
 }
 
+// src/wakeup-notify-client.ts
+var import_node_crypto13 = require("node:crypto");
+var DEFAULT_MAX_PAGE_ATTEMPTS = 3;
+var DEFAULT_PAGE_RETRY_DELAY_MS = 500;
+var TRANSIENT_TRANSPORT_PATTERN = /timed out|timeout|ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|socket hang up|network/i;
+function isTransientTransportError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  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_crypto13.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 sleep4 = opts.sleep ?? ((ms) => new Promise((resolve11) => setTimeout(resolve11, 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 (err) {
+        if (!isRetryableError(err) || attempt >= maxPageAttempts) {
+          throw err;
+        }
+        onRetry?.({ page: pageNum, attempt, reason: "transient_transport" });
+        await sleep4(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 };
+}
+
+// src/wakeup-notify-ingest.ts
+var MAX_TARGET_ENQUEUE_ATTEMPTS = 3;
+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
+  };
+}
+
+// src/wakeup-notify-transport.ts
+var TASK_WAKEUP_CLI_COMMAND = "task-wakeup";
+var DEFAULT_CLI_TIMEOUT_MS = 3e4;
+function withTimeout3(promise, timeoutMs, label) {
+  return new Promise((resolve11, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve11(value);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+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);
+  };
+}
+
+// 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}`
+  };
+}
+
+// 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;
+}
+var 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)
+    });
+  }
+};
+var MAX_LOGGED_PENDING_JOB_IDS = 100;
+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;
+}
+
 // src/listener.ts
 init_paths();
 
 // src/user-attention-watchers.ts
-var import_node_crypto13 = require("node:crypto");
+var import_node_crypto14 = require("node:crypto");
 init_sentry_logger();
 var 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.";
 var USER_ATTENTION_WATCHER_SCAN_MS = 500;
@@ -66609,7 +67208,7 @@ function isOriginalParentProcessAlive(options) {
 }
 function registerUserAttentionWatcher(options) {
   return options.store.registerUserAttentionWatcher({
-    id: options.id ?? (0, import_node_crypto13.randomUUID)(),
+    id: options.id ?? (0, import_node_crypto14.randomUUID)(),
     provider: options.provider,
     jobId: options.jobId,
     nowMs: options.nowMs ?? Date.now(),
@@ -67122,7 +67721,6 @@ 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,
@@ -67172,12 +67770,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.8");
+  service.setPluginVersion("0.2.9-beta-912b775358-260824171011");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.8"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.9-beta-912b775358-260824171011"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -67205,7 +67803,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.8"
+      pluginVersion: "0.2.9-beta-912b775358-260824171011"
     });
   }
   logWithTimestamp(
@@ -67448,6 +68046,7 @@ 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;
@@ -67466,6 +68065,7 @@ async function runListenerWithLock(options, paths) {
         versionRefresh: refreshOnchainosVersionMetadata,
         refresh: syncTick
       });
+      void wakeupDispatcher?.dispatchNextChunk();
     }, intervalSec * 1e3);
   };
   const scheduleOfflineReplayTimer = (nextIntervalSec) => {
@@ -67580,6 +68180,22 @@ 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((err) => {
+    logger.error(LogEvent.WAKEUP_PULL_FAILED, err instanceof Error ? err : new Error(String(err)), {
+      component: "node_listener",
+      stage: "wakeup_pull_start",
+      reason: "wakeup_pull_unhandled_error"
+    });
+    logWithTimestamp("[okx-agent-task] WakeupNotify pull failed to start:", err);
+  });
   await new Promise((resolve11) => {
     const shutdown2 = (signal) => {
       if (stopping) {
@@ -67592,6 +68208,7 @@ async function runListenerWithLock(options, paths) {
         resolve11();
       }, SHUTDOWN_FORCE_RESOLVE_MS);
       void (async () => {
+        logDroppedWakeupWorkOnShutdown(wakeupDispatcher);
         deferredMaintenanceTasks.cancelAll();
         if (timer) {
           clearInterval(timer);
@@ -68595,7 +69212,7 @@ var import_node_path33 = require("node:path");
 var import_jszip = __toESM(require_lib3());
 
 // src/logs-export-archive.ts
-var import_node_crypto14 = require("node:crypto");
+var import_node_crypto15 = require("node:crypto");
 var import_node_fs24 = require("node:fs");
 var import_promises13 = require("node:fs/promises");
 var import_node_path30 = require("node:path");
@@ -69231,7 +69848,7 @@ async function writeArchiveAtomically(outputPath, archive, overwrite) {
   await (0, import_promises13.mkdir)((0, import_node_path30.dirname)(outputPath), { recursive: true });
   const temporaryPath = (0, import_node_path30.join)(
     (0, import_node_path30.dirname)(outputPath),
-    `.${(0, import_node_path30.basename)(outputPath)}.${(0, import_node_crypto14.randomUUID)()}.tmp`
+    `.${(0, import_node_path30.basename)(outputPath)}.${(0, import_node_crypto15.randomUUID)()}.tmp`
   );
   try {
     await (0, import_promises13.writeFile)(temporaryPath, archive, { flag: "wx", mode: 384 });
@@ -69250,7 +69867,7 @@ async function writeArchiveAtomically(outputPath, archive, overwrite) {
   }
 }
 function hashDiagnosticFileContent(content) {
-  return (0, import_node_crypto14.createHash)("sha256").update(content).digest("hex");
+  return (0, import_node_crypto15.createHash)("sha256").update(content).digest("hex");
 }
 function isUnavailableError(err) {
   return !!err && typeof err === "object" && "diagnosticUnavailable" in err;
@@ -69510,7 +70127,7 @@ function isProvider2(value) {
 }
 
 // src/logs-export-utils.ts
-var import_node_crypto15 = require("node:crypto");
+var import_node_crypto16 = require("node:crypto");
 var import_node_fs26 = require("node:fs");
 var import_promises14 = require("node:fs/promises");
 var import_node_path32 = require("node:path");
@@ -69653,7 +70270,7 @@ async function assertRegularFile2(path2) {
 }
 async function inspectRegularFile(path2) {
   const file = await assertRegularFile2(path2);
-  const hash2 = (0, import_node_crypto15.createHash)("sha256");
+  const hash2 = (0, import_node_crypto16.createHash)("sha256");
   for await (const chunk of (0, import_node_fs26.createReadStream)(path2)) {
     hash2.update(chunk);
   }
@@ -69906,7 +70523,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.8" : "unknown",
+    packageVersion: true ? "0.2.9-beta-912b775358-260824171011" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -71788,7 +72405,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.8" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.9-beta-912b775358-260824171011" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -72007,6 +72624,9 @@ async function writeStdoutAndExit(output, code) {
 init_doctor_sentry();
 init_win_native_launcher();
 init_autostart_windows();
+
+// src/wakeup-notify-types.ts
+var WAKEUP_PAGE_SIZE = 50;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_GET_PAGE_TIMEOUT_MS,
@@ -72026,6 +72646,7 @@ init_autostart_windows();
   CODEX_RECOVERY_ACTIONS,
   CommandStore,
   DEFAULT_AI_PERMISSION_PRESET,
+  DEFAULT_MAX_ACTIVE_AI_EXECUTIONS,
   DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC,
   DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC,
   DOCTOR_MIN_NODE_VERSION,
@@ -72054,6 +72675,7 @@ init_autostart_windows();
   USER_ATTENTION_WATCH_PARENT_CHECK_MS,
   USER_ATTENTION_WATCH_REPLACED_MESSAGE,
   UserCancelledAiProviderSelectionError,
+  WAKEUP_PAGE_SIZE,
   WALLET_STATUS_TIMEOUT_MS,
   XMTP_CLIENT_RECYCLE_INTERVAL_ENV,
   XmtpDm,
@@ -72079,6 +72701,7 @@ init_autostart_windows();
   buildCodexRecoveryGuidance,
   buildDispatchSessionKey,
   buildDoctorSentryExtra,
+  buildDroppedWorkTelemetry,
   buildExternalCommandInvocation,
   buildGatewayOutboundExtra,
   buildInboundTerminalExtras,
@@ -72118,9 +72741,11 @@ init_autostart_windows();
   commandExists,
   createAiToolFailureTracker,
   createFileMessageHandler,
+  createOnchainosWakeupFetchPage,
   createOutboundBehavior,
   createUserAttentionWatchParentMonitor,
   currentOpenClawGatewaySessionKey,
+  deriveWakeupDedupeKey,
   detectAiProviders,
   detectAiRuntimeSurface,
   detectCurrentAiProvider,
@@ -72136,7 +72761,9 @@ init_autostart_windows();
   exportDiagnosticLogs,
   extractAiSessionId,
   extractDirectToUserNotification,
+  extractSystemNotification,
   extractXmtpSentAtMs,
+  fetchAllWakeupNotifications,
   findWindowsNativeOkxA2aExe,
   followFile,
   formatDoctorReportForHumans,
@@ -72154,6 +72781,7 @@ init_autostart_windows();
   hashDiagnosticFileContent,
   heartbeatUserAttentionWatcher,
   hermesConfigEnablesOkxA2a,
+  ingestWakeupNotification,
   installSystemdAutostart,
   installWindowsNativeLauncher,
   installedAutostartHasCurrentConfiguration,
@@ -72172,12 +72800,15 @@ init_autostart_windows();
   isSqliteBusyError,
   isSystemdManagerUnavailableMessage,
   isTagKey,
+  isValidWakeupItem,
   isWindowsElevated,
   killProcessTree,
   launchdPlistHasCurrentRestartPolicy,
   listAllAgentsWithMetadata,
+  logDroppedWakeupWorkOnShutdown,
   logWinCompat,
   logXmtpMessageSent,
+  mapCliStdoutToWakeupResponse,
   maybeRecommendOnchainosUpgrade,
   mergeA2AEnvelopeTips,
   messageEligibleHelpAdvertisesOfflineReplay,
@@ -72233,6 +72864,7 @@ init_autostart_windows();
   resolveDirectCommunicationSessionTarget,
   resolveDoctorTarget,
   resolveEnvelopePayload,
+  resolveMaxActiveAiExecutions,
   resolveNpmCmdShimScript,
   resolveOfflineReplayCapabilityMarker,
   resolveOfflineReplayIntervalSec,
@@ -72246,6 +72878,7 @@ init_autostart_windows();
   resolveTaskHome,
   resolveTaskPaths,
   resolveUserAttentionIpcPath,
+  resolveWakeupChunkSize,
   resolveWindowsAutostartPaths,
   resolveXmtpClientRecycleIntervalSec,
   restartSystemdAutostart,
@@ -72266,6 +72899,7 @@ init_autostart_windows();
   startDaemonRespectingSupervisor,
   startUserAttentionEventServer,
   startUserAttentionWatcherCoordinator,
+  startWakeupNotifyPull,
   stopDaemon,
   stopOpenClawGateway,
   stopSystemdAutostart,