@okxweb3/a2a-node 0.2.7 → 0.2.8-beta-912b775358-260818171144

package/dist/index.js

@@ -3807,7 +3807,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) {
@@ -3823,7 +3823,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;
@@ -3846,7 +3846,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;
@@ -5654,10 +5654,10 @@ var require_path = __commonJS({
     function isAbsolute4(path2) {
       return path2.charAt(0) === "/";
     }
-    function join31(...args) {
+    function join32(...args) {
       return normalizePath(args.join("/"));
     }
-    function dirname10(path2) {
+    function dirname11(path2) {
       const result = splitPath(path2);
       const root = result[0];
       let dir = result[1];
@@ -5677,9 +5677,9 @@ var require_path = __commonJS({
       return f;
     }
     exports2.basename = basename8;
-    exports2.dirname = dirname10;
+    exports2.dirname = dirname11;
     exports2.isAbsolute = isAbsolute4;
-    exports2.join = join31;
+    exports2.join = join32;
     exports2.normalizePath = normalizePath;
     exports2.relative = relative;
     exports2.resolve = resolve11;
@@ -19098,6 +19098,15 @@ 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",
+      AI_CONCURRENCY_SNAPSHOT: "AI concurrency snapshot",
       // ── error ─────────────────────────────────────────────────────
       XMTP_CONNECTION_FAILED: "XMTP connection failed",
       CONVERSATIONS_STREAM_FAILED: "conversations.stream failed",
@@ -19152,6 +19161,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",
@@ -19872,6 +19882,13 @@ 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.AI_CONCURRENCY_SNAPSHOT,
       LogEvent.HERMES_SESSION_ROUTE_BINDING,
       LogEvent.INBOUND_BLOCKED_ADDRESS_MISMATCH,
       LogEvent.INBOUND_BLOCKED_INELIGIBLE,
@@ -30698,7 +30715,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();
@@ -31358,7 +31375,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;
@@ -31725,7 +31742,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();
@@ -32026,7 +32043,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",
@@ -32148,7 +32165,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.7",
+      release: "0.2.8-beta-912b775358-260818171144",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -32259,13 +32276,13 @@ async function installWindowsNativeLauncher(options) {
   if (!(0, import_node_fs21.existsSync)(nodeExe)) {
     throw new Error(`cannot build okx-a2a.exe: node executable not found at ${nodeExe}`);
   }
-  const exePath = (0, import_node_path27.join)(options.targetDir, NATIVE_LAUNCHER_EXE_NAME);
+  const exePath = (0, import_node_path28.join)(options.targetDir, NATIVE_LAUNCHER_EXE_NAME);
   (0, import_node_fs21.mkdirSync)(options.targetDir, { recursive: true });
-  const work = (0, import_node_fs21.mkdtempSync)((0, import_node_path27.join)((0, import_node_os10.tmpdir)(), "okx-a2a-sea-"));
+  const work = (0, import_node_fs21.mkdtempSync)((0, import_node_path28.join)((0, import_node_os10.tmpdir)(), "okx-a2a-sea-"));
   try {
-    const entryPath = (0, import_node_path27.join)(work, "launcher-entry.js");
-    const blobPath = (0, import_node_path27.join)(work, "okx-a2a.blob");
-    const configPath = (0, import_node_path27.join)(work, "sea-config.json");
+    const entryPath = (0, import_node_path28.join)(work, "launcher-entry.js");
+    const blobPath = (0, import_node_path28.join)(work, "okx-a2a.blob");
+    const configPath = (0, import_node_path28.join)(work, "sea-config.json");
     (0, import_node_fs21.writeFileSync)(entryPath, buildLauncherEntryJs(options.cliPath), "utf8");
     (0, import_node_fs21.writeFileSync)(configPath, buildSeaConfig(entryPath, blobPath), "utf8");
     (0, import_node_child_process7.execFileSync)(nodeExe, ["--experimental-sea-config", configPath], {
@@ -32298,13 +32315,13 @@ async function installWindowsNativeLauncher(options) {
 function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2 = import_node_fs21.existsSync) {
   const dirs = pathValue.split(";").map((d) => d.trim()).filter(Boolean);
   if (appData) {
-    dirs.push((0, import_node_path27.join)(appData, "npm"));
+    dirs.push((0, import_node_path28.join)(appData, "npm"));
   }
   if (userProfile) {
-    dirs.push((0, import_node_path27.join)(userProfile, ".local", "bin"));
+    dirs.push((0, import_node_path28.join)(userProfile, ".local", "bin"));
   }
   for (const dir of dirs) {
-    const candidate = (0, import_node_path27.join)(dir, NATIVE_LAUNCHER_EXE_NAME);
+    const candidate = (0, import_node_path28.join)(dir, NATIVE_LAUNCHER_EXE_NAME);
     if (fileExists2(candidate)) {
       return candidate;
     }
@@ -32316,7 +32333,7 @@ function resolveRunningCliPath() {
   if (fromArgv && /(?:^|[\\/])cli\.js$/.test(fromArgv) && (0, import_node_fs21.existsSync)(fromArgv)) {
     return fromArgv;
   }
-  const beside = (0, import_node_path27.join)(__dirname, "cli.js");
+  const beside = (0, import_node_path28.join)(__dirname, "cli.js");
   if ((0, import_node_fs21.existsSync)(beside)) {
     return beside;
   }
@@ -32335,11 +32352,11 @@ async function ensureWindowsNativeLauncher(options = {}) {
   if (existing) {
     return { exePath: existing, installed: false };
   }
-  const targetDir = env.APPDATA ? (0, import_node_path27.join)(env.APPDATA, "npm") : (0, import_node_path27.join)(env.USERPROFILE ?? (0, import_node_os10.homedir)(), ".local", "bin");
+  const targetDir = env.APPDATA ? (0, import_node_path28.join)(env.APPDATA, "npm") : (0, import_node_path28.join)(env.USERPROFILE ?? (0, import_node_os10.homedir)(), ".local", "bin");
   const result = await installWindowsNativeLauncher({ cliPath: resolveRunningCliPath(), targetDir });
   return { exePath: result.exePath, installed: true };
 }
-var import_node_child_process7, import_node_fs21, import_node_module, import_node_os10, import_node_path27, SEA_SENTINEL_FUSE, NATIVE_LAUNCHER_EXE_NAME, POSTJECT_SPEC, POSTJECT_BIN;
+var import_node_child_process7, import_node_fs21, import_node_module, import_node_os10, import_node_path28, SEA_SENTINEL_FUSE, NATIVE_LAUNCHER_EXE_NAME, POSTJECT_SPEC, POSTJECT_BIN;
 var init_win_native_launcher = __esm({
   "src/win-native-launcher.ts"() {
     "use strict";
@@ -32347,7 +32364,7 @@ var init_win_native_launcher = __esm({
     import_node_fs21 = require("node:fs");
     import_node_module = require("node:module");
     import_node_os10 = require("node:os");
-    import_node_path27 = require("node:path");
+    import_node_path28 = require("node:path");
     init_win_compat();
     init_win_spawn();
     SEA_SENTINEL_FUSE = "NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2";
@@ -33089,7 +33106,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.7" : null;
+  return true ? "0.2.8-beta-912b775358-260818171144" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -33274,17 +33291,17 @@ async function updateHermes(release, options) {
     assertNotRunningInsideGateway("hermes");
   }
   const spec = buildNpmPackageSpec("hermes", release);
-  const workDir = await (0, import_promises11.mkdtemp)((0, import_node_path28.join)((0, import_node_os11.tmpdir)(), `okx-a2a-${label}-hermes-`));
+  const workDir = await (0, import_promises11.mkdtemp)((0, import_node_path29.join)((0, import_node_os11.tmpdir)(), `okx-a2a-${label}-hermes-`));
   try {
     console.log(`[${label}] downloading ${spec}`);
     const npmTarball = await npmPack(spec, workDir);
-    const npmPackageDir = (0, import_node_path28.join)(workDir, "npm-package");
+    const npmPackageDir = (0, import_node_path29.join)(workDir, "npm-package");
     await runCommand("tar", ["-xzf", npmTarball, "-C", npmPackageDir], { ensureDir: npmPackageDir });
-    const pluginTarball = await findHermesPluginTarball((0, import_node_path28.join)(npmPackageDir, "package", "dist"));
-    const pluginDir = (0, import_node_path28.join)(workDir, "plugin");
+    const pluginTarball = await findHermesPluginTarball((0, import_node_path29.join)(npmPackageDir, "package", "dist"));
+    const pluginDir = (0, import_node_path29.join)(workDir, "plugin");
     await runCommand("tar", ["-xzf", pluginTarball, "-C", pluginDir], { ensureDir: pluginDir });
     const unpackedPluginDir = await findFirstDirectory(pluginDir);
-    const installer = (0, import_node_path28.join)(unpackedPluginDir, "scripts", "install-or-upgrade.sh");
+    const installer = (0, import_node_path29.join)(unpackedPluginDir, "scripts", "install-or-upgrade.sh");
     console.log(`[${label}] running ${installer}`);
     await runCommand("bash", [installer, ...options.restart ? ["--restart"] : []], { cwd: unpackedPluginDir });
     await normalizeHermesOkxA2aPluginConfig();
@@ -33299,7 +33316,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.7") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.8-beta-912b775358-260818171144") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -33350,7 +33367,7 @@ async function ensureHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPa
       if (options.dryRun) {
         return true;
       }
-      await (0, import_promises11.mkdir)((0, import_node_path28.resolve)(configFile, ".."), { recursive: true });
+      await (0, import_promises11.mkdir)((0, import_node_path29.resolve)(configFile, ".."), { recursive: true });
       await (0, import_promises11.writeFile)(configFile, "plugins:\n  enabled:\n    - okx-a2a\n");
       console.log(`[update] added Hermes plugins.enabled okx-a2a entry in ${configFile}`);
       return true;
@@ -33590,7 +33607,7 @@ function findFirstEnabledListItem(lines, startIndex, enabledIndent) {
   return null;
 }
 function resolveHermesConfigPath() {
-  return (0, import_node_path28.join)(process.env.HERMES_HOME ?? (0, import_node_path28.join)((0, import_node_os11.homedir)(), ".hermes"), "config.yaml");
+  return (0, import_node_path29.join)(process.env.HERMES_HOME ?? (0, import_node_path29.join)((0, import_node_os11.homedir)(), ".hermes"), "config.yaml");
 }
 function lineIndent(line) {
   const match = line.match(/^\s*/);
@@ -33668,7 +33685,7 @@ async function assertGatewayPluginInstalled(target) {
   );
 }
 function resolveHermesPluginYamlPath() {
-  return (0, import_node_path28.join)(process.env.HERMES_HOME ?? (0, import_node_path28.join)((0, import_node_os11.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  return (0, import_node_path29.join)(process.env.HERMES_HOME ?? (0, import_node_path29.join)((0, import_node_os11.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
 }
 async function isGatewayPluginInstalled(target) {
   if (target === "openclaw") {
@@ -33761,7 +33778,7 @@ function parsePackageVersionFromText(output) {
   return output.match(/@okxweb3\/a2a-openclaw@([0-9A-Za-z.+-]+)/)?.[1] ?? null;
 }
 async function getInstalledHermesPluginVersion() {
-  const pluginYaml = (0, import_node_path28.join)(process.env.HERMES_HOME ?? (0, import_node_path28.join)((0, import_node_os11.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  const pluginYaml = (0, import_node_path29.join)(process.env.HERMES_HOME ?? (0, import_node_path29.join)((0, import_node_os11.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
   try {
     const content = await (0, import_promises11.readFile)(pluginYaml, "utf8");
     return parsePluginYamlVersion(content);
@@ -33819,7 +33836,7 @@ async function npmPack(spec, destination) {
   if (!tarballName) {
     throw new Error(`Unable to detect npm pack tarball from output: ${output.trim()}`);
   }
-  return (0, import_node_path28.resolve)(destination, (0, import_node_path28.basename)(tarballName));
+  return (0, import_node_path29.resolve)(destination, (0, import_node_path29.basename)(tarballName));
 }
 async function findHermesPluginTarball(distDir) {
   const entries = await (0, import_promises11.readdir)(distDir);
@@ -33827,7 +33844,7 @@ async function findHermesPluginTarball(distDir) {
   if (!tarball) {
     throw new Error(`Hermes npm package did not contain dist/okx-a2a-hermes-plugin-*.tar.gz`);
   }
-  return (0, import_node_path28.join)(distDir, tarball);
+  return (0, import_node_path29.join)(distDir, tarball);
 }
 async function findFirstDirectory(parent) {
   const entries = await (0, import_promises11.readdir)(parent, { withFileTypes: true });
@@ -33835,7 +33852,7 @@ async function findFirstDirectory(parent) {
   if (!dir) {
     throw new Error(`No unpacked plugin directory found under ${parent}`);
   }
-  return (0, import_node_path28.join)(parent, dir.name);
+  return (0, import_node_path29.join)(parent, dir.name);
 }
 function readOption2(args, name) {
   const index2 = args.indexOf(name);
@@ -34056,7 +34073,7 @@ function buildExternalCommandInvocation(command, args, platform = process.platfo
 function formatExternalCommand(command, args) {
   return [command, ...args].join(" ");
 }
-var import_node_child_process8, import_node_fs22, import_promises11, import_node_os11, import_node_path28, UPDATE_PACKAGES, CODEX_NPM_PACKAGE, OPENCLAW_FORCE_INSTALL_FLAG, OPENCLAW_UNSAFE_INSTALL_FLAG, OKX_A2A_PLUGIN_ID, OPENCLAW_SESSION_DM_SCOPE_CONFIG_PATH, OPENCLAW_SESSION_DM_SCOPE_CONFIG_VALUE, OPENCLAW_PLUGIN_ALLOW_CONFIG_PATH, OPENCLAW_OKX_A2A_CONVERSATION_HOOK_ACCESS_CONFIG_PATH, DEFAULT_AI_PROVIDER_LOGIN_TIMEOUT_MS, PROVIDER_CLI_AUTH_PROBE_TIMEOUT_MS, SetupBlockedError, redirectCommandStdoutToStderr;
+var import_node_child_process8, import_node_fs22, import_promises11, import_node_os11, import_node_path29, UPDATE_PACKAGES, CODEX_NPM_PACKAGE, OPENCLAW_FORCE_INSTALL_FLAG, OPENCLAW_UNSAFE_INSTALL_FLAG, OKX_A2A_PLUGIN_ID, OPENCLAW_SESSION_DM_SCOPE_CONFIG_PATH, OPENCLAW_SESSION_DM_SCOPE_CONFIG_VALUE, OPENCLAW_PLUGIN_ALLOW_CONFIG_PATH, OPENCLAW_OKX_A2A_CONVERSATION_HOOK_ACCESS_CONFIG_PATH, DEFAULT_AI_PROVIDER_LOGIN_TIMEOUT_MS, PROVIDER_CLI_AUTH_PROBE_TIMEOUT_MS, SetupBlockedError, redirectCommandStdoutToStderr;
 var init_update_cli = __esm({
   "src/update-cli.ts"() {
     "use strict";
@@ -34064,7 +34081,7 @@ var init_update_cli = __esm({
     import_node_fs22 = require("node:fs");
     import_promises11 = require("node:fs/promises");
     import_node_os11 = require("node:os");
-    import_node_path28 = require("node:path");
+    import_node_path29 = require("node:path");
     init_ai_command();
     init_win_spawn();
     init_ai_provider();
@@ -34377,7 +34394,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join31(s) {
+      BufferList.prototype.join = function join32(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -44005,6 +44022,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,
@@ -44033,7 +44051,9 @@ __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,
+  WakeupDedupeStore: () => WakeupDedupeStore,
   XMTP_CLIENT_RECYCLE_INTERVAL_ENV: () => XMTP_CLIENT_RECYCLE_INTERVAL_ENV,
   XmtpDm: () => Dm,
   XmtpGroup: () => Group,
@@ -44097,9 +44117,11 @@ __export(index_exports, {
   commandExists: () => commandExists,
   createAiToolFailureTracker: () => createAiToolFailureTracker,
   createFileMessageHandler: () => createFileMessageHandler,
+  createOnchainosWakeupFetchPage: () => createOnchainosWakeupFetchPage,
   createOutboundBehavior: () => createOutboundBehavior,
   createUserAttentionWatchParentMonitor: () => createUserAttentionWatchParentMonitor,
   currentOpenClawGatewaySessionKey: () => currentOpenClawGatewaySessionKey,
+  deriveWakeupDedupeKey: () => deriveWakeupDedupeKey,
   detectAiProviders: () => detectAiProviders,
   detectCurrentAiProvider: () => detectCurrentAiProvider,
   detectGatewayInvocation: () => detectGatewayInvocation,
@@ -44114,7 +44136,9 @@ __export(index_exports, {
   exportDiagnosticLogs: () => exportDiagnosticLogs,
   extractAiSessionId: () => extractAiSessionId,
   extractDirectToUserNotification: () => extractDirectToUserNotification,
+  extractSystemNotification: () => extractSystemNotification,
   extractXmtpSentAtMs: () => extractXmtpSentAtMs2,
+  fetchAllWakeupNotifications: () => fetchAllWakeupNotifications,
   findWindowsNativeOkxA2aExe: () => findWindowsNativeOkxA2aExe,
   followFile: () => followFile,
   formatDoctorReportForHumans: () => formatDoctorReportForHumans,
@@ -44131,6 +44155,7 @@ __export(index_exports, {
   hashDiagnosticFileContent: () => hashDiagnosticFileContent,
   heartbeatUserAttentionWatcher: () => heartbeatUserAttentionWatcher,
   hermesConfigEnablesOkxA2a: () => hermesConfigEnablesOkxA2a,
+  ingestWakeupNotification: () => ingestWakeupNotification,
   installWindowsNativeLauncher: () => installWindowsNativeLauncher,
   installedAutostartHasCurrentConfiguration: () => installedAutostartHasCurrentConfiguration,
   installedAutostartHasCurrentRestartPolicy: () => installedAutostartHasCurrentRestartPolicy,
@@ -44145,12 +44170,14 @@ __export(index_exports, {
   isPrereleaseVersion: () => isPrereleaseVersion,
   isRetryableOpenClawGatewayError: () => isRetryableOpenClawGatewayError,
   isSqliteBusyError: () => isSqliteBusyError,
+  isValidWakeupItem: () => isValidWakeupItem,
   isWindowsElevated: () => isWindowsElevated,
   killProcessTree: () => killProcessTree,
   launchdPlistHasCurrentRestartPolicy: () => launchdPlistHasCurrentRestartPolicy,
   listAllAgentsWithMetadata: () => listAllAgentsWithMetadata,
   logWinCompat: () => logWinCompat,
   logXmtpMessageSent: () => logXmtpMessageSent,
+  mapCliStdoutToWakeupResponse: () => mapCliStdoutToWakeupResponse,
   maybeRecommendOnchainosUpgrade: () => maybeRecommendOnchainosUpgrade,
   mergeA2AEnvelopeTips: () => mergeA2AEnvelopeTips,
   messageEligibleHelpAdvertisesOfflineReplay: () => messageEligibleHelpAdvertisesOfflineReplay,
@@ -44201,6 +44228,7 @@ __export(index_exports, {
   resolveDirectCommunicationSessionTarget: () => resolveDirectCommunicationSessionTarget,
   resolveDoctorTarget: () => resolveDoctorTarget,
   resolveEnvelopePayload: () => resolveEnvelopePayload,
+  resolveMaxActiveAiExecutions: () => resolveMaxActiveAiExecutions,
   resolveNpmCmdShimScript: () => resolveNpmCmdShimScript,
   resolveOfflineReplayCapabilityMarker: () => resolveOfflineReplayCapabilityMarker,
   resolveOfflineReplayIntervalSec: () => resolveOfflineReplayIntervalSec,
@@ -44230,6 +44258,7 @@ __export(index_exports, {
   startDaemonRespectingSupervisor: () => startDaemonRespectingSupervisor,
   startUserAttentionEventServer: () => startUserAttentionEventServer,
   startUserAttentionWatcherCoordinator: () => startUserAttentionWatcherCoordinator,
+  startWakeupNotifyRecovery: () => startWakeupNotifyRecovery,
   stopDaemon: () => stopDaemon,
   stopOpenClawGateway: () => stopOpenClawGateway,
   subscribeUserAttentionEvents: () => subscribeUserAttentionEvents,
@@ -57938,6 +57967,10 @@ var XmtpService = class _XmtpService {
       timer
     });
   }
+  // Public so the daemon (listener.ts) can invoke the legacy fire-and-forget wakeup
+  // AFTER the command processor is ready, as one of two mutually-exclusive wakeup
+  // paths (the other being the paginated WakeupNotify pull). It is intentionally no
+  // longer called from completeStartupReplay — see the note there.
   notifyAgentsWakeupAfterReplay() {
     const notifyAgentsWakeup2 = this.tools.notifyAgentsWakeup;
     const agentIds = this.allAgents.map((agent) => agent.agentId);
@@ -57965,9 +57998,14 @@ var XmtpService = class _XmtpService {
   /**
    * 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) triggers exactly ONE wakeup path AFTER the bounded
+   * command processor is ready — the paginated WakeupNotify pull when enabled, or
+   * `notifyAgentsWakeupAfterReplay()` (the legacy fire-and-forget) otherwise — so
+   * the two paths never overlap and wakeup-triggered work cannot be dispatched
+   * before the processor exists.
    */
   async completeStartupReplay() {
     const startupGates = new Map(
@@ -57982,7 +58020,6 @@ var XmtpService = class _XmtpService {
     }
     this.resolveStartupReplayCompletion?.();
     this.resolveStartupReplayCompletion = void 0;
-    this.notifyAgentsWakeupAfterReplay();
     return summary;
   }
   async startListeningForAddresses(addresses) {
@@ -60534,7 +60571,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.7",
+      version: "0.2.8-beta-912b775358-260818171144",
       platform: "node",
       mode: "backend",
       instanceId
@@ -60545,7 +60582,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.7"}`,
+    userAgent: `okx-a2a-node/${"0.2.8-beta-912b775358-260818171144"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -63633,6 +63670,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;
@@ -63686,6 +63740,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();
@@ -63775,6 +63840,9 @@ function startCommandProcessor(params) {
       inFlight = false;
     }
   };
+  const AI_SNAPSHOT_MIN_INTERVAL_MS = 15e3;
+  let lastAiSnapshotSignature = "";
+  let lastAiSnapshotAtMs = 0;
   const aiTick = async () => {
     if (aiScanInFlight) {
       return;
@@ -63787,15 +63855,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, {
@@ -63806,13 +63892,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;
@@ -64385,6 +64478,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);
   }
@@ -66029,7 +66125,7 @@ init_log();
 var import_node_fs19 = require("node:fs");
 var import_promises8 = require("node:fs/promises");
 var import_node_os9 = require("node:os");
-var import_node_path25 = require("node:path");
+var import_node_path26 = require("node:path");
 
 // ../core/src/xmtp-sdk/onchainos/signer.ts
 init_log();
@@ -66138,6 +66234,150 @@ function createOnchainosSigner(agent) {
 // src/listener.ts
 init_session_store();
 
+// src/wakeup-recovery.ts
+init_log();
+init_sentry_logger();
+
+// src/wakeup-notify-client.ts
+var import_node_crypto13 = require("node:crypto");
+var DEFAULT_MAX_PAGES = 200;
+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 ?? DEFAULT_MAX_PAGES;
+  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) || 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/ai-dispatch-queue.ts
 async function enqueueAiJobMessageDispatch(params) {
   const commands = params.commands ?? new CommandStore(params.homeDir);
@@ -66163,11 +66403,367 @@ async function enqueueAiSessionMessageDispatch(params) {
   return command;
 }
 
+// src/wakeup-notify-ingest.ts
+var MAX_TARGET_ENQUEUE_ATTEMPTS = 3;
+async function ingestWakeupNotification(item, deps) {
+  const dedupeKey = deriveWakeupDedupeKey(item);
+  const itemJobId = item.message.jobId ?? null;
+  if (deps.dedupe.has(dedupeKey)) {
+    return { status: "duplicate", dedupeKey, jobId: itemJobId, targetCount: 0 };
+  }
+  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,
+      jobId: itemJobId,
+      targetCount: 0
+    };
+  }
+  const targets = resolveSystemNotificationTargets(
+    { sessionStore: deps.sessionStore, myXmtpAddress: deps.myXmtpAddress ?? "", store: void 0 },
+    notif
+  );
+  let succeeded = 0;
+  let alreadyDelivered = 0;
+  let failed = 0;
+  for (const target of targets) {
+    const targetKey = `${dedupeKey}:${target.sessionKey}`;
+    if (deps.dedupe.has(targetKey)) {
+      alreadyDelivered += 1;
+      continue;
+    }
+    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,
+            // Stable messageId (= dedupeKey) avoids the `session-${Date.now()}`
+            // intra-millisecond collision on rapid ingests.
+            messageId: dedupeKey,
+            jobId: target.jobId ?? null,
+            agentId: target.agentId ?? null
+          }
+        });
+        enqueued = true;
+      } catch {
+      }
+    }
+    if (enqueued) {
+      try {
+        deps.dedupe.recordIfNew(targetKey);
+      } catch {
+      }
+      succeeded += 1;
+    } else {
+      failed += 1;
+    }
+  }
+  const delivered = succeeded + alreadyDelivered;
+  if (targets.length > 0 && delivered === 0) {
+    return {
+      status: "rejected",
+      reason: "enqueue_failed",
+      dedupeKey,
+      jobId: notif.jobId ?? null,
+      targetCount: 0,
+      failedTargetCount: failed
+    };
+  }
+  if (failed > 0) {
+    return {
+      status: "partial",
+      reason: "partial_enqueue",
+      dedupeKey,
+      jobId: notif.jobId ?? null,
+      targetCount: succeeded,
+      failedTargetCount: failed
+    };
+  }
+  if (delivered === targets.length) {
+    try {
+      deps.dedupe.recordIfNew(dedupeKey);
+    } catch {
+    }
+  }
+  return {
+    status: "persisted",
+    dedupeKey,
+    jobId: notif.jobId ?? null,
+    targetCount: succeeded
+  };
+}
+
+// src/wakeup-dedupe-store.ts
+var import_node_path25 = require("node:path");
+init_paths();
+var { DatabaseSync: DatabaseSync4 } = loadSqlite4();
+var WakeupDedupeStore = class {
+  db;
+  dbPath;
+  constructor(homeDir) {
+    this.dbPath = (0, import_node_path25.join)(resolveTaskPaths(homeDir).sqliteDir, "wakeup-dedupe.sqlite");
+    ensureTaskDir((0, import_node_path25.dirname)(this.dbPath));
+    this.db = new DatabaseSync4(this.dbPath);
+    this.ensureReady();
+  }
+  /**
+   * Atomically record the first sighting of `key`. Returns true when the row was
+   * inserted (first sighting), false when it already existed (duplicate).
+   */
+  recordIfNew(key) {
+    const result = this.db.prepare(`
+      INSERT OR IGNORE INTO wakeup_ingest_dedupe (dedupe_key, first_seen_at_ms)
+      VALUES (?, ?)
+    `).run(key, Date.now());
+    return Number(result.changes ?? 0) > 0;
+  }
+  /** Pre-check used before enqueue: has this key already been recorded? */
+  has(key) {
+    const row = this.db.prepare("SELECT 1 FROM wakeup_ingest_dedupe WHERE dedupe_key = ? LIMIT 1").get(key);
+    return row !== void 0;
+  }
+  remove(key) {
+    this.db.prepare("DELETE FROM wakeup_ingest_dedupe WHERE dedupe_key = ?").run(key);
+  }
+  close() {
+    this.db.close();
+  }
+  ensureReady() {
+    this.db.exec("PRAGMA busy_timeout=5000");
+    this.db.exec("PRAGMA journal_mode=WAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS wakeup_ingest_dedupe (
+        dedupe_key TEXT PRIMARY KEY,
+        first_seen_at_ms INTEGER NOT NULL
+      )
+    `);
+  }
+};
+function loadSqlite4() {
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = ((warning, ...args) => {
+    const message = typeof warning === "string" ? warning : warning.message;
+    if (message.includes("SQLite is an experimental feature") && args.some((arg) => arg === "ExperimentalWarning")) {
+      return;
+    }
+    return originalEmitWarning.call(process, warning, ...args);
+  });
+  try {
+    return require("node:sqlite");
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
+
+// src/wakeup-notify-transport.ts
+var WAKEUP_NOTIFY_CLI_COMMAND = "wakeup-notify";
+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",
+        WAKEUP_NOTIFY_CLI_COMMAND,
+        "--agent-ids",
+        agentIds.join(","),
+        // TBC: flag name/shape unconfirmed by backend/CLI.
+        "--page",
+        String(page)
+      ]),
+      timeoutMs,
+      `onchainos ${WAKEUP_NOTIFY_CLI_COMMAND}`
+    );
+    const parsed = parseCliJson(stdout, WAKEUP_NOTIFY_CLI_COMMAND, {
+      page: String(page)
+    });
+    return mapCliStdoutToWakeupResponse(parsed);
+  };
+}
+
+// src/wakeup-recovery.ts
+async function startWakeupNotifyRecovery(opts) {
+  const env = opts.env ?? process.env;
+  const enabled = opts.enabled ?? env.OKX_A2A_WAKEUP_PULL_ENABLED === "1";
+  const fetchPage = opts.fetchPage ?? (enabled ? createOnchainosWakeupFetchPage() : void 0);
+  if (!enabled || !fetchPage) {
+    logWithTimestamp(
+      "[okx-agent-task] WakeupNotify pull skipped (disabled or transport not configured)"
+    );
+    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_recovery",
+    agentCount: String(agentIds.length)
+  });
+  const dedupe = new WakeupDedupeStore(opts.homeDir);
+  try {
+    const { items, summary, rejects } = await fetchAllWakeupNotifications({
+      agentIds,
+      fetchPage,
+      onPage: (p) => logger.info(LogEvent.WAKEUP_PULL_PAGE_FETCHED, {
+        component: "wakeup_recovery",
+        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_recovery",
+        page: String(r.page),
+        attempt: String(r.attempt),
+        reason: r.reason
+      })
+    });
+    for (const reject of rejects) {
+      logger.info(LogEvent.WAKEUP_NOTIFICATION_REJECTED, {
+        component: "wakeup_recovery",
+        reason: reject.reason
+      });
+    }
+    const shouldContinue = opts.shouldContinue;
+    for (const item of items) {
+      if (shouldContinue && !shouldContinue()) {
+        logWithTimestamp("[okx-agent-task] WakeupNotify recovery halted early (daemon stopping)");
+        break;
+      }
+      const outcome = await ingestWakeupNotification(item, {
+        commands: opts.commands,
+        sessionStore: opts.sessionStore,
+        dedupe,
+        myXmtpAddress: void 0
+      });
+      if (outcome.status === "persisted") {
+        summary.persisted++;
+      } else if (outcome.status === "partial") {
+        summary.partial++;
+        logger.info(LogEvent.WAKEUP_NOTIFICATION_REJECTED, {
+          component: "wakeup_recovery",
+          reason: outcome.reason ?? "partial_enqueue",
+          failedTargetCount: String(outcome.failedTargetCount ?? 0)
+        });
+      } else if (outcome.status === "duplicate") {
+        summary.duplicates++;
+      } else {
+        summary.rejected++;
+        logger.info(LogEvent.WAKEUP_NOTIFICATION_REJECTED, {
+          component: "wakeup_recovery",
+          reason: outcome.reason ?? "unknown"
+        });
+      }
+    }
+    if (summary.terminated === "transport_error" || summary.terminated === "business_error" || summary.terminated === "invalid_response") {
+      logger.error(LogEvent.WAKEUP_PULL_FAILED, void 0, {
+        component: "wakeup_recovery",
+        terminated: summary.terminated
+      });
+    }
+    logger.info(LogEvent.WAKEUP_PULL_COMPLETED, {
+      component: "wakeup_recovery",
+      pagesFetched: String(summary.pagesFetched),
+      received: String(summary.received),
+      persisted: String(summary.persisted),
+      partial: String(summary.partial),
+      duplicates: String(summary.duplicates),
+      rejected: String(summary.rejected),
+      terminated: summary.terminated
+    });
+    return summary;
+  } finally {
+    dedupe.close();
+  }
+}
+
 // 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;
@@ -66210,7 +66806,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(),
@@ -66494,12 +67090,12 @@ async function isGatewayAvailableForHeartbeat(options) {
 }
 async function getHermesGatewayPluginStatus(options = {}) {
   const env = options.env ?? process.env;
-  const hermesHome = env.HERMES_HOME?.trim() || (0, import_node_path25.join)((0, import_node_os9.homedir)(), ".hermes");
-  const pluginYamlPath = (0, import_node_path25.join)(hermesHome, "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  const hermesHome = env.HERMES_HOME?.trim() || (0, import_node_path26.join)((0, import_node_os9.homedir)(), ".hermes");
+  const pluginYamlPath = (0, import_node_path26.join)(hermesHome, "plugins", "platforms", "okx-a2a", "plugin.yaml");
   if (!(0, import_node_fs19.existsSync)(pluginYamlPath)) {
     return { enabled: false, reason: "plugin_yaml_missing", hermesHome, checkedPath: pluginYamlPath };
   }
-  const configPath = (0, import_node_path25.join)(hermesHome, "config.yaml");
+  const configPath = (0, import_node_path26.join)(hermesHome, "config.yaml");
   let content;
   try {
     content = await (0, import_promises8.readFile)(configPath, "utf8");
@@ -66732,12 +67328,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.7");
+  service.setPluginVersion("0.2.8-beta-912b775358-260818171144");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.7"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.8-beta-912b775358-260818171144"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -66755,7 +67351,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.7"
+      pluginVersion: "0.2.8-beta-912b775358-260818171144"
     });
   }
   logWithTimestamp(
@@ -67128,6 +67724,26 @@ async function runListenerWithLock(options, paths) {
   });
   await markDaemonReady(paths.daemonLockPath);
   logWithTimestamp(`[okx-agent-task] daemon ready lock=${paths.daemonLockPath}`);
+  if (process.env.OKX_A2A_WAKEUP_PULL_ENABLED === "1") {
+    void startWakeupNotifyRecovery({
+      service,
+      commands,
+      sessionStore,
+      store,
+      homeDir: options.homeDir,
+      // Stop enqueuing if a shutdown begins mid-pull (fire-and-forget recovery).
+      shouldContinue: () => !stopping
+    }).catch((err) => {
+      logger.error(LogEvent.WAKEUP_PULL_FAILED, err instanceof Error ? err : new Error(String(err)), {
+        component: "node_listener",
+        stage: "wakeup_recovery_start",
+        reason: "wakeup_recovery_unhandled_error"
+      });
+      logWithTimestamp("[okx-agent-task] WakeupNotify recovery failed to start:", err);
+    });
+  } else {
+    service.notifyAgentsWakeupAfterReplay();
+  }
   await new Promise((resolve11) => {
     const shutdown2 = (signal) => {
       if (stopping) {
@@ -67189,7 +67805,7 @@ init_paths();
 
 // src/xmtp-test-cli.ts
 var import_promises10 = require("node:fs/promises");
-var import_node_path26 = require("node:path");
+var import_node_path27 = require("node:path");
 init_daemon();
 
 // src/log-tail.ts
@@ -67432,9 +68048,9 @@ async function handleXmtpTestCommand(args, releaseInfo) {
 async function startXmtpTest(args, releaseInfo) {
   assertKnownOptions(args, /* @__PURE__ */ new Set(["--name", "--run-id", "--json"]));
   const paths = resolveTaskPaths();
-  const testsDir = (0, import_node_path26.join)(paths.homeDir, "xmtp-tests");
+  const testsDir = (0, import_node_path27.join)(paths.homeDir, "xmtp-tests");
   await ensurePrivateDir(testsDir);
-  const active = await readJsonIfExists((0, import_node_path26.join)(testsDir, ACTIVE_FILE));
+  const active = await readJsonIfExists((0, import_node_path27.join)(testsDir, ACTIVE_FILE));
   if (active?.runId) {
     throw new Error(
       `XMTP test ${active.runId} is already active. Run \`okx-a2a xmtp-test stop\` first.`
@@ -67473,7 +68089,7 @@ async function startXmtpTest(args, releaseInfo) {
     ...releaseInfo
   };
   await writeJson(files.manifestPath, manifest);
-  await writeJson((0, import_node_path26.join)(testsDir, ACTIVE_FILE), {
+  await writeJson((0, import_node_path27.join)(testsDir, ACTIVE_FILE), {
     runId,
     startedAt: manifest.startedAt
   });
@@ -67496,7 +68112,7 @@ Run \`okx-a2a xmtp-test watch\` to open the realtime dashboard.`);
 async function stopXmtpTest(args) {
   assertKnownOptions(args, /* @__PURE__ */ new Set(["--json"]));
   const testsDir = resolveTestsDir();
-  const activePath = (0, import_node_path26.join)(testsDir, ACTIVE_FILE);
+  const activePath = (0, import_node_path27.join)(testsDir, ACTIVE_FILE);
   const active = await readJsonIfExists(activePath);
   if (!active?.runId) {
     throw new Error("No active XMTP test.");
@@ -67790,17 +68406,17 @@ function formatJobEvent(event) {
   return `${timestamp}  ${businessEvent.padEnd(34)} ${role}#${agent} ${source}${timings.length > 0 ? `  ${timings.join(" ")}` : ""}`;
 }
 function resolveTestsDir() {
-  return (0, import_node_path26.join)(resolveTaskPaths().homeDir, "xmtp-tests");
+  return (0, import_node_path27.join)(resolveTaskPaths().homeDir, "xmtp-tests");
 }
 function resolveRunFiles(testsDir, runId) {
   validateRunId(runId);
-  const runDir = (0, import_node_path26.join)(testsDir, runId);
+  const runDir = (0, import_node_path27.join)(testsDir, runId);
   return {
     testsDir,
     runDir,
-    manifestPath: (0, import_node_path26.join)(runDir, "manifest.json"),
-    eventsPath: (0, import_node_path26.join)(runDir, "events.jsonl"),
-    summaryPath: (0, import_node_path26.join)(runDir, "summary.json")
+    manifestPath: (0, import_node_path27.join)(runDir, "manifest.json"),
+    eventsPath: (0, import_node_path27.join)(runDir, "events.jsonl"),
+    summaryPath: (0, import_node_path27.join)(runDir, "summary.json")
   };
 }
 async function resolveRequestedRunId(testsDir, args, preferActive = false) {
@@ -67808,7 +68424,7 @@ async function resolveRequestedRunId(testsDir, args, preferActive = false) {
   if (requested) {
     return validateRunId(requested);
   }
-  const active = await readJsonIfExists((0, import_node_path26.join)(testsDir, ACTIVE_FILE));
+  const active = await readJsonIfExists((0, import_node_path27.join)(testsDir, ACTIVE_FILE));
   if (active?.runId && (preferActive || !args.includes("--latest"))) {
     return validateRunId(active.runId);
   }
@@ -67834,7 +68450,7 @@ async function findLatestRunId(testsDir) {
       continue;
     }
     const manifest = await readJsonIfExists(
-      (0, import_node_path26.join)(testsDir, entry.name, "manifest.json")
+      (0, import_node_path27.join)(testsDir, entry.name, "manifest.json")
     );
     if (manifest?.runId && manifest.startedAt) {
       manifests.push(manifest);
@@ -68138,19 +68754,19 @@ var import_node_child_process10 = require("node:child_process");
 var import_node_fs27 = require("node:fs");
 var import_promises15 = require("node:fs/promises");
 var import_node_os13 = require("node:os");
-var import_node_path33 = require("node:path");
+var import_node_path34 = 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");
+var import_node_path31 = require("node:path");
 
 // src/logs-export-filter.ts
 var import_node_fs23 = require("node:fs");
 var import_promises12 = require("node:fs/promises");
-var import_node_path29 = require("node:path");
+var import_node_path30 = require("node:path");
 var import_node_readline2 = require("node:readline");
 var MAX_SINGLE_RECORD_BYTES = 2 * 1024 * 1024;
 var CONTENT_KEYS = /* @__PURE__ */ new Set([
@@ -68215,7 +68831,7 @@ async function readFilteredLog(path2, options, correlationIds, requireCorrelatio
   let excludedOutsideWindow = 0;
   let excludedNoCorrelation = 0;
   let truncated = false;
-  const mode = (0, import_node_path29.basename)(path2) === "llm.log" ? "llm" : recordMode;
+  const mode = (0, import_node_path30.basename)(path2) === "llm.log" ? "llm" : recordMode;
   const filterByTime = options.fromMs !== void 0 && options.toMs !== void 0;
   for await (const record of streamLogRecords(path2, mode)) {
     if (options.jobId && recordExplicitlyNamesForeignJob(record.lines, options.jobId)) {
@@ -68679,7 +69295,7 @@ async function assertRegularFile(path2) {
   const file = await (0, import_promises12.lstat)(path2);
   if (file.isSymbolicLink() || !file.isFile()) {
     throw Object.assign(
-      new Error(`Refusing non-regular diagnostic source: ${(0, import_node_path29.basename)(path2)}`),
+      new Error(`Refusing non-regular diagnostic source: ${(0, import_node_path30.basename)(path2)}`),
       { diagnosticUnavailable: true }
     );
   }
@@ -68760,7 +69376,7 @@ function recordCollector(state, result) {
 }
 async function resolveOutputPath(requested, input) {
   if (requested) {
-    const output2 = (0, import_node_path30.isAbsolute)(requested) ? requested : (0, import_node_path30.resolve)(input.cwd, requested);
+    const output2 = (0, import_node_path31.isAbsolute)(requested) ? requested : (0, import_node_path31.resolve)(input.cwd, requested);
     if ((0, import_node_fs24.existsSync)(output2) && !input.overwrite) {
       throw new Error(`Output already exists: ${output2}. Pass --overwrite to replace it.`);
     }
@@ -68768,17 +69384,17 @@ async function resolveOutputPath(requested, input) {
   }
   const stamp = input.now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
   const base = `okx-a2a-diagnostics-${stamp}.zip`;
-  let output = (0, import_node_path30.join)(input.cwd, base);
+  let output = (0, import_node_path31.join)(input.cwd, base);
   for (let suffix = 2; (0, import_node_fs24.existsSync)(output); suffix += 1) {
-    output = (0, import_node_path30.join)(input.cwd, `okx-a2a-diagnostics-${stamp}-${suffix}.zip`);
+    output = (0, import_node_path31.join)(input.cwd, `okx-a2a-diagnostics-${stamp}-${suffix}.zip`);
   }
   return output;
 }
 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`
+  await (0, import_promises13.mkdir)((0, import_node_path31.dirname)(outputPath), { recursive: true });
+  const temporaryPath = (0, import_node_path31.join)(
+    (0, import_node_path31.dirname)(outputPath),
+    `.${(0, import_node_path31.basename)(outputPath)}.${(0, import_node_crypto15.randomUUID)()}.tmp`
   );
   try {
     await (0, import_promises13.writeFile)(temporaryPath, archive, { flag: "wx", mode: 384 });
@@ -68797,7 +69413,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;
@@ -68905,8 +69521,8 @@ function readSqliteRows(dbPath, sql, params = []) {
   if (!(0, import_node_fs25.existsSync)(dbPath)) {
     throw unavailable(`SQLite database not found: ${dbPath}`);
   }
-  const { DatabaseSync: DatabaseSync4 } = loadSqlite4();
-  const db = new DatabaseSync4(dbPath, { readOnly: true });
+  const { DatabaseSync: DatabaseSync5 } = loadSqlite5();
+  const db = new DatabaseSync5(dbPath, { readOnly: true });
   try {
     return db.prepare(sql).all(...params);
   } finally {
@@ -68924,7 +69540,7 @@ function emptySqliteSnapshot() {
     storedProviderCommands: {}
   };
 }
-function loadSqlite4() {
+function loadSqlite5() {
   const originalEmitWarning = process.emitWarning;
   process.emitWarning = ((warning, ...args) => {
     const message = typeof warning === "string" ? warning : warning.message;
@@ -68962,13 +69578,13 @@ function unavailable(message) {
 // src/logs-export-provider.ts
 var import_node_child_process9 = require("node:child_process");
 var import_node_os12 = require("node:os");
-var import_node_path31 = require("node:path");
+var import_node_path32 = require("node:path");
 var PROVIDERS2 = ["codex", "claude", "openclaw", "hermes"];
 function providerConfigCandidates(provider, taskHome2) {
   if (provider === "codex") {
     return [
       {
-        path: (0, import_node_path31.join)(process.env.CODEX_HOME ?? (0, import_node_path31.join)((0, import_node_os12.homedir)(), ".codex"), "config.toml"),
+        path: (0, import_node_path32.join)(process.env.CODEX_HOME ?? (0, import_node_path32.join)((0, import_node_os12.homedir)(), ".codex"), "config.toml"),
         archiveName: "config.redacted.toml"
       }
     ];
@@ -68976,11 +69592,11 @@ function providerConfigCandidates(provider, taskHome2) {
   if (provider === "claude") {
     return [
       {
-        path: (0, import_node_path31.join)((0, import_node_os12.homedir)(), ".claude", "settings.json"),
+        path: (0, import_node_path32.join)((0, import_node_os12.homedir)(), ".claude", "settings.json"),
         archiveName: "settings.redacted.json"
       },
       {
-        path: (0, import_node_path31.join)(process.cwd(), ".claude", "settings.json"),
+        path: (0, import_node_path32.join)(process.cwd(), ".claude", "settings.json"),
         archiveName: "project-settings.redacted.json"
       }
     ];
@@ -68989,28 +69605,28 @@ function providerConfigCandidates(provider, taskHome2) {
     const openClawStateDir = resolveOpenClawStateDir();
     return [
       {
-        path: (0, import_node_path31.join)(openClawStateDir, "openclaw.json"),
+        path: (0, import_node_path32.join)(openClawStateDir, "openclaw.json"),
         archiveName: "config.redacted.json"
       },
       {
-        path: (0, import_node_path31.join)(taskHome2, "xmtp", "openclaw-gateway.json"),
+        path: (0, import_node_path32.join)(taskHome2, "xmtp", "openclaw-gateway.json"),
         archiveName: "gateway-config.redacted.json"
       }
     ];
   }
   return [
     {
-      path: (0, import_node_path31.join)(resolveHermesHome(), "config.yaml"),
+      path: (0, import_node_path32.join)(resolveHermesHome(), "config.yaml"),
       archiveName: "config.redacted.yaml"
     }
   ];
 }
 function resolveOpenClawStateDir() {
   const configured = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.OPENCLAW_HOME?.trim();
-  return (0, import_node_path31.resolve)(configured || (0, import_node_path31.join)((0, import_node_os12.homedir)(), ".openclaw"));
+  return (0, import_node_path32.resolve)(configured || (0, import_node_path32.join)((0, import_node_os12.homedir)(), ".openclaw"));
 }
 function resolveHermesHome() {
-  return (0, import_node_path31.resolve)(process.env.HERMES_HOME?.trim() || (0, import_node_path31.join)((0, import_node_os12.homedir)(), ".hermes"));
+  return (0, import_node_path32.resolve)(process.env.HERMES_HOME?.trim() || (0, import_node_path32.join)((0, import_node_os12.homedir)(), ".hermes"));
 }
 function providerEnvironment(provider) {
   const prefixes = provider === "codex" ? ["OKX_A2A_AI_CODEX_", "CODEX_"] : provider === "claude" ? ["OKX_A2A_AI_CLAUDE_", "ANTHROPIC_MODEL", "CLAUDE_"] : provider === "openclaw" ? ["OPENCLAW_", "OKX_A2A_OPENCLAW_"] : ["HERMES_", "OKX_A2A_HERMES_"];
@@ -69027,7 +69643,7 @@ function safeCommandLabel(command) {
     return "";
   }
   const executable = trimmed.match(/^"([^"]+)"/)?.[1] ?? trimmed.split(/\s+/, 1)[0];
-  return (0, import_node_path31.basename)(executable);
+  return (0, import_node_path32.basename)(executable);
 }
 function resolveProvider(requested, binding, fallback = null) {
   if (requested !== "auto") {
@@ -69057,10 +69673,10 @@ 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");
+var import_node_path33 = require("node:path");
 var MAX_JSON_FILE_BYTES = 20 * 1024 * 1024;
 var STRONG_CORRELATION_KEYS = /* @__PURE__ */ new Set([
   "approvalid",
@@ -69194,13 +69810,13 @@ async function readJsonObject(path2) {
 async function assertRegularFile2(path2) {
   const file = await (0, import_promises14.lstat)(path2);
   if (file.isSymbolicLink() || !file.isFile()) {
-    throw unavailable2(`Refusing non-regular diagnostic source: ${(0, import_node_path32.basename)(path2)}`);
+    throw unavailable2(`Refusing non-regular diagnostic source: ${(0, import_node_path33.basename)(path2)}`);
   }
   return file;
 }
 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);
   }
@@ -69352,7 +69968,7 @@ function parseLogsExportArgs(args, input = {}) {
 async function exportDiagnosticLogs(options) {
   validateOptions(options);
   const paths = diagnosticPaths(options.taskHome);
-  const cwd = (0, import_node_path33.resolve)(options.cwd ?? process.cwd());
+  const cwd = (0, import_node_path34.resolve)(options.cwd ?? process.cwd());
   const now = options.now ?? /* @__PURE__ */ new Date();
   const outputPath = await resolveOutputPath(options.outputPath, {
     cwd,
@@ -69446,14 +70062,14 @@ async function exportDiagnosticLogs(options) {
     scope,
     jobId: options.jobId,
     taskHome: {
-      basename: (0, import_node_path33.basename)(paths.taskHome),
+      basename: (0, import_node_path34.basename)(paths.taskHome),
       explicitlyConfigured: !!options.taskHome,
       absolutePathCollected: false
     },
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.7" : "unknown",
+    packageVersion: true ? "0.2.8-beta-912b775358-260818171144" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -69536,7 +70152,7 @@ async function collectJobMetadata(state, paths, options) {
       correlationIds.strong.add(options.jobId);
     }
     for (const name of names.filter((item) => item.endsWith(".json")).sort()) {
-      const path2 = (0, import_node_path33.join)(paths.jobsDir, name);
+      const path2 = (0, import_node_path34.join)(paths.jobsDir, name);
       let parsed;
       try {
         parsed = await readJsonObject(path2);
@@ -69607,7 +70223,7 @@ async function collectJobMetadata(state, paths, options) {
 }
 async function collectSessionSnapshot(state, paths, options, selectedJobIds) {
   return runCollector(state, "a2a-session-store", async () => {
-    const dbPath = (0, import_node_path33.join)(paths.sqliteDir, "session-store.sqlite");
+    const dbPath = (0, import_node_path34.join)(paths.sqliteDir, "session-store.sqlite");
     const snapshot = readSessionSqliteSnapshot(dbPath, options, selectedJobIds);
     addJsonEntry(state, "a2a/sessions.json", {
       sessions: snapshot.sessions,
@@ -69639,7 +70255,7 @@ async function collectA2aLogs(state, paths, options, sessionKeys, correlationIds
     const filterNotes = [];
     for (const [sourcePath, archivePath] of [
       [paths.listenerLogPath, "a2a/listener.log"],
-      [(0, import_node_path33.join)(paths.logsDir, "llm.log"), "a2a/llm.log"]
+      [(0, import_node_path34.join)(paths.logsDir, "llm.log"), "a2a/llm.log"]
     ]) {
       const output = await readFilteredLog(
         sourcePath,
@@ -69652,7 +70268,7 @@ async function collectA2aLogs(state, paths, options, sessionKeys, correlationIds
       if (!output?.text) {
         if (output?.excludedNoTimestamp) {
           filterNotes.push(
-            `${(0, import_node_path33.basename)(sourcePath)} excluded ${output.excludedNoTimestamp} timestamp-less records`
+            `${(0, import_node_path34.basename)(sourcePath)} excluded ${output.excludedNoTimestamp} timestamp-less records`
           );
         }
         continue;
@@ -69661,11 +70277,11 @@ async function collectA2aLogs(state, paths, options, sessionKeys, correlationIds
       collected.push(archivePath);
       if (output.excludedNoTimestamp) {
         filterNotes.push(
-          `${(0, import_node_path33.basename)(sourcePath)} excluded ${output.excludedNoTimestamp} timestamp-less records`
+          `${(0, import_node_path34.basename)(sourcePath)} excluded ${output.excludedNoTimestamp} timestamp-less records`
         );
       }
       if (output.truncated) {
-        filterNotes.push(`${(0, import_node_path33.basename)(sourcePath)} reached the configured size limit`);
+        filterNotes.push(`${(0, import_node_path34.basename)(sourcePath)} reached the configured size limit`);
       }
     }
     for (const name of await safeReadDir(paths.logsDir)) {
@@ -69680,7 +70296,7 @@ async function collectA2aLogs(state, paths, options, sessionKeys, correlationIds
       if (!matchesDirectJob && !matchesPersistedSession && !matchesJobSessionFilename) {
         continue;
       }
-      const sourcePath = (0, import_node_path33.join)(paths.logsDir, name);
+      const sourcePath = (0, import_node_path34.join)(paths.logsDir, name);
       let info;
       let filtered;
       try {
@@ -69753,7 +70369,7 @@ async function collectA2aLogs(state, paths, options, sessionKeys, correlationIds
 }
 async function collectCommands(state, paths, options) {
   return runCollector(state, "a2a-command-store", async () => {
-    const dbPath = (0, import_node_path33.join)(paths.sqliteDir, "command-store.sqlite");
+    const dbPath = (0, import_node_path34.join)(paths.sqliteDir, "command-store.sqlite");
     const hasWindow = hasTimeWindow(options);
     const rows = readSqliteRows(dbPath, `
       SELECT id, type, status, command_json, result_json,
@@ -69794,8 +70410,8 @@ async function collectCommands(state, paths, options) {
 }
 async function collectOnchainAudit(state, options, correlationIds) {
   await runCollector(state, "onchainos-audit", async () => {
-    const onchainHome = process.env.ONCHAINOS_HOME?.trim() ? (0, import_node_path33.resolve)(process.env.ONCHAINOS_HOME) : (0, import_node_path33.join)((0, import_node_os13.homedir)(), ".onchainos");
-    const auditPath = (0, import_node_path33.join)(onchainHome, "audit.jsonl");
+    const onchainHome = process.env.ONCHAINOS_HOME?.trim() ? (0, import_node_path34.resolve)(process.env.ONCHAINOS_HOME) : (0, import_node_path34.join)((0, import_node_os13.homedir)(), ".onchainos");
+    const auditPath = (0, import_node_path34.join)(onchainHome, "audit.jsonl");
     const output = await readFilteredLog(
       auditPath,
       options,
@@ -69910,7 +70526,7 @@ async function collectOpenClawSessionStore(state, options) {
   const jobId = options.jobId;
   const filterLabel = jobId ? "exact-job" : "time-window";
   await runCollector(state, "openclaw-session-store", async () => {
-    const agentsDir = (0, import_node_path33.join)(resolveOpenClawStateDir(), "agents");
+    const agentsDir = (0, import_node_path34.join)(resolveOpenClawStateDir(), "agents");
     const allAgentNames = (await safeReadDir(agentsDir)).sort();
     if (allAgentNames.length === 0) {
       throw unavailable2("No OpenClaw agent session stores were found");
@@ -69919,7 +70535,7 @@ async function collectOpenClawSessionStore(state, options) {
     let skippedSources = 0;
     let discoveryLimited = allAgentNames.length > MAX_OPENCLAW_AGENTS;
     for (const agentId of allAgentNames.slice(0, MAX_OPENCLAW_AGENTS)) {
-      const sessionsDir = (0, import_node_path33.join)(agentsDir, agentId, "sessions");
+      const sessionsDir = (0, import_node_path34.join)(agentsDir, agentId, "sessions");
       try {
         const info = await (0, import_promises15.lstat)(sessionsDir);
         if (info.isSymbolicLink() || !info.isDirectory()) {
@@ -69935,7 +70551,7 @@ async function collectOpenClawSessionStore(state, options) {
       try {
         for (const name of await safeReadDir(sessionsDir)) {
           if (isOpenClawSessionLogName(name)) {
-            candidates.push({ agentId, path: (0, import_node_path33.join)(sessionsDir, name) });
+            candidates.push({ agentId, path: (0, import_node_path34.join)(sessionsDir, name) });
           }
         }
       } catch {
@@ -69973,7 +70589,7 @@ async function collectOpenClawSessionStore(state, options) {
         if (!output?.text || output.matchedRecords === 0) {
           continue;
         }
-        const archivePath = `providers/openclaw/sessions/${safeArchiveName(candidate.agentId)}/${safeArchiveName((0, import_node_path33.basename)(candidate.path))}`;
+        const archivePath = `providers/openclaw/sessions/${safeArchiveName(candidate.agentId)}/${safeArchiveName((0, import_node_path34.basename)(candidate.path))}`;
         addTextEntry(state, archivePath, output.text);
         files.push(archivePath);
         matchedRecords += output.matchedRecords;
@@ -70022,11 +70638,11 @@ async function collectGatewayLogs(state, provider, paths, options, correlationId
     let candidates;
     if (provider === "openclaw") {
       candidates = [
-        (0, import_node_path33.join)(paths.logsDir, "gateway-openclaw.jsonl"),
-        (0, import_node_path33.join)(resolveOpenClawStateDir(), "logs", "gateway.log")
+        (0, import_node_path34.join)(paths.logsDir, "gateway-openclaw.jsonl"),
+        (0, import_node_path34.join)(resolveOpenClawStateDir(), "logs", "gateway.log")
       ];
     } else {
-      const hermesLogsDir = (0, import_node_path33.join)(resolveHermesHome(), "logs");
+      const hermesLogsDir = (0, import_node_path34.join)(resolveHermesHome(), "logs");
       let rotatedNames = [];
       try {
         rotatedNames = (await safeReadDir(hermesLogsDir)).filter(isHermesRotatedLogName).sort();
@@ -70040,12 +70656,12 @@ async function collectGatewayLogs(state, provider, paths, options, correlationId
         rotatedNames.length = MAX_HERMES_ROTATED_LOG_FILES;
       }
       candidates = [
-        (0, import_node_path33.join)(paths.logsDir, "gateway-hermes.jsonl"),
-        (0, import_node_path33.join)(hermesLogsDir, "agent.log"),
-        (0, import_node_path33.join)(hermesLogsDir, "gateway.log"),
-        (0, import_node_path33.join)(hermesLogsDir, "error.log"),
-        (0, import_node_path33.join)(hermesLogsDir, "errors.log"),
-        ...rotatedNames.map((name) => (0, import_node_path33.join)(hermesLogsDir, name)),
+        (0, import_node_path34.join)(paths.logsDir, "gateway-hermes.jsonl"),
+        (0, import_node_path34.join)(hermesLogsDir, "agent.log"),
+        (0, import_node_path34.join)(hermesLogsDir, "gateway.log"),
+        (0, import_node_path34.join)(hermesLogsDir, "error.log"),
+        (0, import_node_path34.join)(hermesLogsDir, "errors.log"),
+        ...rotatedNames.map((name) => (0, import_node_path34.join)(hermesLogsDir, name)),
         "/tmp/hermes-gateway.log"
       ];
     }
@@ -70067,7 +70683,7 @@ async function collectGatewayLogs(state, provider, paths, options, correlationId
       if (!output?.text) {
         continue;
       }
-      const archivePath = `providers/${provider}/gateway/${safeArchiveName((0, import_node_path33.basename)(candidate))}`;
+      const archivePath = `providers/${provider}/gateway/${safeArchiveName((0, import_node_path34.basename)(candidate))}`;
       addTextEntry(state, archivePath, output.text);
       files.push(archivePath);
     }
@@ -70240,13 +70856,13 @@ function formatEvidence(value, unavailableReason) {
   return unavailableReason ? `unknown (${unavailableReason})` : "unknown";
 }
 function diagnosticPaths(taskHome2) {
-  const home = (0, import_node_path33.resolve)(taskHome2 ?? resolveTaskHome());
+  const home = (0, import_node_path34.resolve)(taskHome2 ?? resolveTaskHome());
   return {
     taskHome: home,
-    jobsDir: (0, import_node_path33.join)(home, "jobs"),
-    logsDir: (0, import_node_path33.join)(home, "logs"),
-    sqliteDir: (0, import_node_path33.join)(home, "sqlite"),
-    listenerLogPath: (0, import_node_path33.join)(home, "logs", "listener.log")
+    jobsDir: (0, import_node_path34.join)(home, "jobs"),
+    logsDir: (0, import_node_path34.join)(home, "logs"),
+    sqliteDir: (0, import_node_path34.join)(home, "sqlite"),
+    listenerLogPath: (0, import_node_path34.join)(home, "logs", "listener.log")
   };
 }
 function validateOptions(options) {
@@ -70317,7 +70933,7 @@ init_ai_provider();
 init_update_cli();
 
 // src/doctor-cli.ts
-var import_node_path34 = require("node:path");
+var import_node_path35 = require("node:path");
 init_log();
 init_win_compat();
 init_ai_command();
@@ -70691,7 +71307,7 @@ var windowsNativeLauncherChecker = {
         command: "okx-a2a doctor --fix"
       },
       data: {
-        appDataNpm: ctx.env.APPDATA ? (0, import_node_path34.join)(ctx.env.APPDATA, "npm") : null
+        appDataNpm: ctx.env.APPDATA ? (0, import_node_path35.join)(ctx.env.APPDATA, "npm") : null
       }
     };
   },
@@ -71316,7 +71932,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.7" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.8-beta-912b775358-260818171144" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -71535,6 +72151,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,
@@ -71554,6 +72173,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,
@@ -71582,7 +72202,9 @@ init_autostart_windows();
   USER_ATTENTION_WATCH_PARENT_CHECK_MS,
   USER_ATTENTION_WATCH_REPLACED_MESSAGE,
   UserCancelledAiProviderSelectionError,
+  WAKEUP_PAGE_SIZE,
   WALLET_STATUS_TIMEOUT_MS,
+  WakeupDedupeStore,
   XMTP_CLIENT_RECYCLE_INTERVAL_ENV,
   XmtpDm,
   XmtpGroup,
@@ -71646,9 +72268,11 @@ init_autostart_windows();
   commandExists,
   createAiToolFailureTracker,
   createFileMessageHandler,
+  createOnchainosWakeupFetchPage,
   createOutboundBehavior,
   createUserAttentionWatchParentMonitor,
   currentOpenClawGatewaySessionKey,
+  deriveWakeupDedupeKey,
   detectAiProviders,
   detectCurrentAiProvider,
   detectGatewayInvocation,
@@ -71663,7 +72287,9 @@ init_autostart_windows();
   exportDiagnosticLogs,
   extractAiSessionId,
   extractDirectToUserNotification,
+  extractSystemNotification,
   extractXmtpSentAtMs,
+  fetchAllWakeupNotifications,
   findWindowsNativeOkxA2aExe,
   followFile,
   formatDoctorReportForHumans,
@@ -71680,6 +72306,7 @@ init_autostart_windows();
   hashDiagnosticFileContent,
   heartbeatUserAttentionWatcher,
   hermesConfigEnablesOkxA2a,
+  ingestWakeupNotification,
   installWindowsNativeLauncher,
   installedAutostartHasCurrentConfiguration,
   installedAutostartHasCurrentRestartPolicy,
@@ -71694,12 +72321,14 @@ init_autostart_windows();
   isPrereleaseVersion,
   isRetryableOpenClawGatewayError,
   isSqliteBusyError,
+  isValidWakeupItem,
   isWindowsElevated,
   killProcessTree,
   launchdPlistHasCurrentRestartPolicy,
   listAllAgentsWithMetadata,
   logWinCompat,
   logXmtpMessageSent,
+  mapCliStdoutToWakeupResponse,
   maybeRecommendOnchainosUpgrade,
   mergeA2AEnvelopeTips,
   messageEligibleHelpAdvertisesOfflineReplay,
@@ -71750,6 +72379,7 @@ init_autostart_windows();
   resolveDirectCommunicationSessionTarget,
   resolveDoctorTarget,
   resolveEnvelopePayload,
+  resolveMaxActiveAiExecutions,
   resolveNpmCmdShimScript,
   resolveOfflineReplayCapabilityMarker,
   resolveOfflineReplayIntervalSec,
@@ -71779,6 +72409,7 @@ init_autostart_windows();
   startDaemonRespectingSupervisor,
   startUserAttentionEventServer,
   startUserAttentionWatcherCoordinator,
+  startWakeupNotifyRecovery,
   stopDaemon,
   stopOpenClawGateway,
   subscribeUserAttentionEvents,