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

package/dist/cli.js

@@ -4492,7 +4492,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) {
@@ -4508,7 +4508,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;
@@ -4531,7 +4531,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;
@@ -6339,10 +6339,10 @@ var require_path = __commonJS({
     function isAbsolute4(path2) {
       return path2.charAt(0) === "/";
     }
-    function join33(...args) {
+    function join34(...args) {
       return normalizePath(args.join("/"));
     }
-    function dirname10(path2) {
+    function dirname11(path2) {
       const result = splitPath(path2);
       const root = result[0];
       let dir = result[1];
@@ -6362,9 +6362,9 @@ var require_path = __commonJS({
       return f;
     }
     exports2.basename = basename10;
-    exports2.dirname = dirname10;
+    exports2.dirname = dirname11;
     exports2.isAbsolute = isAbsolute4;
-    exports2.join = join33;
+    exports2.join = join34;
     exports2.normalizePath = normalizePath;
     exports2.relative = relative;
     exports2.resolve = resolve14;
@@ -19783,6 +19783,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",
@@ -19837,6 +19846,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",
@@ -20554,6 +20564,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,
@@ -24955,7 +24972,7 @@ var require_websocket2 = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes4, createHash: createHash6 } = require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash7 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -25615,7 +25632,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;
@@ -25982,7 +25999,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();
@@ -26283,7 +26300,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",
@@ -26648,7 +26665,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
@@ -26659,7 +26676,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 } : {}
@@ -28568,7 +28585,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)
     };
@@ -28857,7 +28874,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join33(s) {
+      BufferList.prototype.join = function join34(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -39138,8 +39155,8 @@ function readSqliteRows(dbPath, sql, params = []) {
   if (!(0, import_node_fs17.existsSync)(dbPath)) {
     throw unavailable(`SQLite database not found: ${dbPath}`);
   }
-  const { DatabaseSync: DatabaseSync4 } = loadSqlite3();
-  const db = new DatabaseSync4(dbPath, { readOnly: true });
+  const { DatabaseSync: DatabaseSync5 } = loadSqlite3();
+  const db = new DatabaseSync5(dbPath, { readOnly: true });
   try {
     return db.prepare(sql).all(...params);
   } finally {
@@ -39738,7 +39755,7 @@ async function exportDiagnosticLogs(options) {
     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,
@@ -58191,6 +58208,10 @@ var init_xmtp_sdk = __esm({
           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);
@@ -58218,9 +58239,14 @@ var init_xmtp_sdk = __esm({
       /**
        * 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(
@@ -58235,7 +58261,6 @@ var init_xmtp_sdk = __esm({
         }
         this.resolveStartupReplayCompletion?.();
         this.resolveStartupReplayCompletion = void 0;
-        this.notifyAgentsWakeupAfterReplay();
         return summary;
       }
       async startListeningForAddresses(addresses) {
@@ -64765,6 +64790,29 @@ var init_xmtp_debug = __esm({
   }
 });
 
+// src/ai-concurrency-config.ts
+function resolveMaxActiveAiExecutions(env = process.env) {
+  const raw = env.OKX_A2A_MAX_ACTIVE_AI_EXECUTIONS ?? env.OKX_AGENT_TASK_MAX_ACTIVE_AI_EXECUTIONS;
+  if (raw === void 0 || raw.trim() === "") {
+    return { limit: DEFAULT_MAX_ACTIVE_AI_EXECUTIONS, anomaly: null };
+  }
+  const parsed = Number(raw);
+  if (Number.isFinite(parsed) && Number.isInteger(parsed) && parsed > 0) {
+    return { limit: parsed, anomaly: null };
+  }
+  return {
+    limit: DEFAULT_MAX_ACTIVE_AI_EXECUTIONS,
+    anomaly: `invalid value "${raw}", using default ${DEFAULT_MAX_ACTIVE_AI_EXECUTIONS}`
+  };
+}
+var DEFAULT_MAX_ACTIVE_AI_EXECUTIONS;
+var init_ai_concurrency_config = __esm({
+  "src/ai-concurrency-config.ts"() {
+    "use strict";
+    DEFAULT_MAX_ACTIVE_AI_EXECUTIONS = 4;
+  }
+});
+
 // src/command-processor.ts
 function commandSentryExtra(command, extra = {}) {
   const base = {
@@ -64814,6 +64862,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();
@@ -64903,6 +64962,9 @@ function startCommandProcessor(params) {
       inFlight = false;
     }
   };
+  const AI_SNAPSHOT_MIN_INTERVAL_MS = 15e3;
+  let lastAiSnapshotSignature = "";
+  let lastAiSnapshotAtMs = 0;
   const aiTick = async () => {
     if (aiScanInFlight) {
       return;
@@ -64915,15 +64977,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, {
@@ -64934,13 +65014,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;
@@ -65513,6 +65600,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);
   }
@@ -65620,6 +65710,7 @@ var init_command_processor = __esm({
     init_user_attention_ipc();
     init_sentry_logger();
     init_xmtp_debug();
+    init_ai_concurrency_config();
     DEFAULT_COMMAND_EXECUTION_TIMEOUT_MS = 5e4;
     DEFAULT_COMMAND_STALE_TIMEOUT_MS = 12e4;
     DEFAULT_AI_COMMAND_STALE_TIMEOUT_MS = 30 * 6e4;
@@ -65627,6 +65718,152 @@ var init_command_processor = __esm({
   }
 });
 
+// src/wakeup-notify-client.ts
+function isTransientTransportError(err2) {
+  const message = err2 instanceof Error ? err2.message : String(err2);
+  return TRANSIENT_TRANSPORT_PATTERN.test(message);
+}
+function isPlainObject3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isValidWakeupItem(raw) {
+  if (!isPlainObject3(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 (!isPlainObject3(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_crypto14.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 sleep5 = opts.sleep ?? ((ms) => new Promise((resolve14) => setTimeout(resolve14, ms)));
+  const isRetryableError = opts.isRetryableError ?? isTransientTransportError;
+  const onRetry = opts.onRetry;
+  const fetchPageWithRetry = async (pageNum) => {
+    let attempt = 0;
+    while (true) {
+      attempt++;
+      try {
+        return await fetchPage({ agentIds, page: pageNum });
+      } catch (err2) {
+        if (!isRetryableError(err2) || attempt >= maxPageAttempts) {
+          throw err2;
+        }
+        onRetry?.({ page: pageNum, attempt, reason: "transient_transport" });
+        await sleep5(retryDelayMs * attempt + Math.floor(Math.random() * (retryDelayMs + 1)));
+      }
+    }
+  };
+  const items = [];
+  const rejects = [];
+  const visited = /* @__PURE__ */ new Set();
+  let pagesFetched = 0;
+  let page = 1;
+  let terminated = "empty";
+  try {
+    while (true) {
+      const resp = await fetchPageWithRetry(page);
+      pagesFetched++;
+      if (resp.code !== 0) {
+        terminated = "business_error";
+        break;
+      }
+      const rawList = resp.data?.list;
+      if (!Array.isArray(rawList)) {
+        rejects.push({ reason: "invalid_response_list" });
+        terminated = "invalid_response";
+        break;
+      }
+      const list = rawList;
+      let itemCount = 0;
+      let rejectedCount = 0;
+      for (const element of list) {
+        const check = isValidWakeupItem(element);
+        if (check.ok) {
+          items.push(check.item);
+          itemCount++;
+        } else {
+          rejects.push({ reason: check.reason });
+          rejectedCount++;
+        }
+      }
+      const nextPage = resp.data?.nextPage;
+      onPage?.({ page, itemCount, rejectedCount, hasNextPage: nextPage != null });
+      if (nextPage === null) {
+        terminated = items.length || rejects.length ? "next_page_null" : "empty";
+        break;
+      }
+      if (typeof nextPage !== "number" || !Number.isInteger(nextPage) || nextPage <= 0) {
+        rejects.push({ reason: "invalid_next_page" });
+        terminated = "invalid_response";
+        break;
+      }
+      visited.add(page);
+      page = nextPage;
+      if (visited.has(page) || pagesFetched >= maxPages) {
+        terminated = "max_pages";
+        break;
+      }
+    }
+  } catch {
+    terminated = "transport_error";
+  }
+  const summary = {
+    pagesFetched,
+    received: items.length + rejects.length,
+    persisted: 0,
+    partial: 0,
+    duplicates: 0,
+    rejected: rejects.length,
+    terminated
+  };
+  return { items, summary, rejects };
+}
+var import_node_crypto14, DEFAULT_MAX_PAGES, DEFAULT_MAX_PAGE_ATTEMPTS, DEFAULT_PAGE_RETRY_DELAY_MS, TRANSIENT_TRANSPORT_PATTERN;
+var init_wakeup_notify_client = __esm({
+  "src/wakeup-notify-client.ts"() {
+    "use strict";
+    import_node_crypto14 = require("node:crypto");
+    DEFAULT_MAX_PAGES = 200;
+    DEFAULT_MAX_PAGE_ATTEMPTS = 3;
+    DEFAULT_PAGE_RETRY_DELAY_MS = 500;
+    TRANSIENT_TRANSPORT_PATTERN = /timed out|timeout|ETIMEDOUT|ECONNRESET|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|socket hang up|network/i;
+  }
+});
+
 // src/ai-dispatch-queue.ts
 async function enqueueAiJobMessageDispatch(params) {
   const commands = params.commands ?? new CommandStore(params.homeDir);
@@ -65673,7 +65910,7 @@ function tryMarkProcessed(messageId) {
   }
   return true;
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function safeStringify(value) {
@@ -65730,9 +65967,9 @@ function readNumber(value) {
 }
 function resolveSessionAgentId(params) {
   const { chatType, payload, myXmtpAddress } = params;
-  const payloadObject = isPlainObject3(payload) ? payload : null;
-  const sender = isPlainObject3(payloadObject?.sender) ? payloadObject.sender : null;
-  const message = isPlainObject3(payloadObject?.message) ? payloadObject.message : null;
+  const payloadObject = isPlainObject4(payload) ? payload : null;
+  const sender = isPlainObject4(payloadObject?.sender) ? payloadObject.sender : null;
+  const message = isPlainObject4(payloadObject?.message) ? payloadObject.message : null;
   const localAgentId = XmtpService.getInstance().getAgentByAddress(myXmtpAddress)?.agentId ?? null;
   if (chatType === "group") {
     return readString5(sender?.agentId) ?? readString5(payloadObject?.receiverAgentId) ?? localAgentId;
@@ -65743,7 +65980,7 @@ function resolveSessionAgentId(params) {
   return localAgentId;
 }
 function routeMessage(chatType, parsed, payload) {
-  if (!parsed || !isPlainObject3(payload)) {
+  if (!parsed || !isPlainObject4(payload)) {
     return {
       jobId: BACKUP_JOB_ID,
       route: "backup",
@@ -65755,7 +65992,7 @@ function routeMessage(chatType, parsed, payload) {
     return jobId ? { jobId, route: "job", routeReason: "group-job-id" } : { jobId: BACKUP_JOB_ID, route: "backup", routeReason: "group-missing-job-id" };
   }
   if (chatType === "dm") {
-    const message = isPlainObject3(payload.message) ? payload.message : null;
+    const message = isPlainObject4(payload.message) ? payload.message : null;
     const nestedJobId = readString5(message?.jobId);
     const directJobId = readString5(payload.jobId);
     const jobId = nestedJobId ?? directJobId;
@@ -65768,10 +66005,10 @@ function routeMessage(chatType, parsed, payload) {
   return { jobId: BACKUP_JOB_ID, route: "backup", routeReason: "unknown-conversation" };
 }
 function extractDirectToUserNotification(payload) {
-  if (!isPlainObject3(payload)) {
+  if (!isPlainObject4(payload)) {
     return { kind: "none" };
   }
-  const message = isPlainObject3(payload.message) ? payload.message : null;
+  const message = isPlainObject4(payload.message) ? payload.message : null;
   if (message?.isDirectToUser !== true) {
     return { kind: "none" };
   }
@@ -65795,10 +66032,10 @@ function extractDirectToUserNotification(payload) {
   };
 }
 function extractSystemNotification(payload) {
-  if (!isPlainObject3(payload)) {
+  if (!isPlainObject4(payload)) {
     return null;
   }
-  const message = isPlainObject3(payload.message) ? payload.message : null;
+  const message = isPlainObject4(payload.message) ? payload.message : null;
   const isDirectCommunication = message?.isDirectCommunication === true;
   if (message?.source !== "system" && !isDirectCommunication) {
     return null;
@@ -66090,7 +66327,7 @@ function maybeNotifyInboundAgentMessage(params) {
     return;
   }
   const content2 = payloadObject.content;
-  const sender = isPlainObject3(payloadObject.sender) ? payloadObject.sender : null;
+  const sender = isPlainObject4(payloadObject.sender) ? payloadObject.sender : null;
   const localAgent = XmtpService.getInstance().getAgentByAddress(params.deps.myXmtpAddress);
   void notifyAgentMessageToUserAttention({
     direction: "inbound" /* INBOUND */,
@@ -66121,11 +66358,11 @@ function stringifySystemPayload(payload) {
   }
 }
 function summarizePayloadForLog(payload) {
-  if (!isPlainObject3(payload)) {
+  if (!isPlainObject4(payload)) {
     return "payload=non-object";
   }
-  const message = isPlainObject3(payload.message) ? payload.message : null;
-  const sender = isPlainObject3(payload.sender) ? payload.sender : null;
+  const message = isPlainObject4(payload.message) ? payload.message : null;
+  const sender = isPlainObject4(payload.sender) ? payload.sender : null;
   const jobId = readString5(payload.jobId) ?? readString5(message?.jobId);
   const parts = [
     readString5(payload.msgType) ? `type=${readString5(payload.msgType)}` : null,
@@ -66394,7 +66631,7 @@ async function verifyInboundA2AGroupMessage(params) {
       messageId,
       groupId,
       jobId,
-      agentId: readString5(isPlainObject3(payload.sender) ? payload.sender.agentId : null),
+      agentId: readString5(isPlainObject4(payload.sender) ? payload.sender.agentId : null),
       localAgentId: myAgent?.agentId ?? null,
       senderAddress,
       senderInboxId,
@@ -66420,7 +66657,7 @@ async function verifyInboundA2AGroupMessage(params) {
     });
     return false;
   }
-  const sender = isPlainObject3(payload.sender) ? payload.sender : null;
+  const sender = isPlainObject4(payload.sender) ? payload.sender : null;
   const senderAgentId = readString5(sender?.agentId);
   const senderRole = readNumber(sender?.role);
   if (!senderAgentId || !myAgent) {
@@ -66644,7 +66881,7 @@ async function processFileMessage(ctx, deps, options = {}) {
   timing.mark("payloadParse", parseStartedAt);
   const directToUser = chatType === "dm" && parseResult.ok ? extractDirectToUserNotification(parseResult.data) : { kind: "none" };
   if (directToUser.kind === "invalid") {
-    const droppedMessageId = messageId || `direct-to-user-${(0, import_node_crypto14.randomUUID)()}`;
+    const droppedMessageId = messageId || `direct-to-user-${(0, import_node_crypto15.randomUUID)()}`;
     logger.error(
       LogEvent.INBOUND_DROP_DM_INVALID_PAYLOAD,
       new Error("Invalid direct-to-user system DM"),
@@ -66668,7 +66905,7 @@ async function processFileMessage(ctx, deps, options = {}) {
     await dispatchDirectToUserNotification({
       deps,
       notification: directToUser.notification,
-      messageId: messageId || `direct-to-user-${(0, import_node_crypto14.randomUUID)()}`,
+      messageId: messageId || `direct-to-user-${(0, import_node_crypto15.randomUUID)()}`,
       timing,
       source: options.source ?? "live"
     });
@@ -66676,7 +66913,7 @@ async function processFileMessage(ctx, deps, options = {}) {
   }
   const systemNotification = chatType === "dm" && parseResult.ok ? extractSystemNotification(parseResult.data) : null;
   if (systemNotification) {
-    const systemMessageId = messageId || `system-${(0, import_node_crypto14.randomUUID)()}`;
+    const systemMessageId = messageId || `system-${(0, import_node_crypto15.randomUUID)()}`;
     logWithTimestamp(
       `[okx-agent-task:${deps.myXmtpAddress}] xmtp_system_message_received agentId=${systemNotification.agentId ?? ""} msg=${shortenLogValue(systemMessageId)} event=${systemNotification.event ?? ""} job=${shortenLogValue(systemNotification.jobId)} conv=${conversationId} source=${options.source ?? "live"} rawBytes=${Buffer.byteLength(rawText, "utf8")} rawPreview=${previewRawEnvelope(rawText)}`
     );
@@ -66875,7 +67112,7 @@ async function processFileMessage(ctx, deps, options = {}) {
     );
   }
   if (route.route === "job" && chatType === "group") {
-    const payloadObject = isPlainObject3(parseResult.ok ? parseResult.data : null) ? parseResult.data : null;
+    const payloadObject = isPlainObject4(parseResult.ok ? parseResult.data : null) ? parseResult.data : null;
     const service = XmtpService.getInstance();
     const trustedSystemSender = service.isTrustedSystemAccountSender({
       senderAddress,
@@ -66901,7 +67138,7 @@ async function processFileMessage(ctx, deps, options = {}) {
       });
       return true;
     }
-    const sender = isPlainObject3(payloadObject?.sender) ? payloadObject.sender : null;
+    const sender = isPlainObject4(payloadObject?.sender) ? payloadObject.sender : null;
     const localAgent = service.getAgentByAddress(deps.myXmtpAddress);
     const myAgentId = localAgent?.agentId ?? readString5(payloadObject?.receiverAgentId) ?? sessionAgentId ?? null;
     const toAgentId = readString5(sender?.agentId);
@@ -66921,7 +67158,7 @@ async function processFileMessage(ctx, deps, options = {}) {
     if (!accepted) {
       return true;
     }
-    const routedMessageId = messageId || `group-${(0, import_node_crypto14.randomUUID)()}`;
+    const routedMessageId = messageId || `group-${(0, import_node_crypto15.randomUUID)()}`;
     const sessionKey = ensureInboundGroupSession(deps, {
       jobId: route.jobId,
       myAgentId,
@@ -66987,7 +67224,7 @@ async function processFileMessage(ctx, deps, options = {}) {
     return true;
   }
   const stored = {
-    id: messageId || `local-${(0, import_node_crypto14.randomUUID)()}`,
+    id: messageId || `local-${(0, import_node_crypto15.randomUUID)()}`,
     direction: "inbound",
     route: route.route,
     routeReason: route.routeReason,
@@ -67005,8 +67242,8 @@ async function processFileMessage(ctx, deps, options = {}) {
   await deps.store.append(route.jobId, stored, sessionAgentId);
   timing.mark("storeAppend", storeAppendStartedAt);
   if ((route.route === "job" || parseResult.ok && !isA2AEnvelope(stored.payload)) && !options.skipNotify) {
-    const payloadObject = isPlainObject3(stored.payload) ? stored.payload : null;
-    const sender = isPlainObject3(payloadObject?.sender) ? payloadObject.sender : null;
+    const payloadObject = isPlainObject4(stored.payload) ? stored.payload : null;
+    const sender = isPlainObject4(payloadObject?.sender) ? payloadObject.sender : null;
     const localAgent = XmtpService.getInstance().getAgentByAddress(deps.myXmtpAddress);
     const sessionKey = route.route === "job" ? buildSessionKey({
       jobId: route.jobId,
@@ -67024,8 +67261,8 @@ async function processFileMessage(ctx, deps, options = {}) {
     });
   }
   if (route.route === "job" && chatType === "group" && conversationId && senderAddress) {
-    const payloadObject = isPlainObject3(stored.payload) ? stored.payload : null;
-    const sender = isPlainObject3(payloadObject?.sender) ? payloadObject.sender : null;
+    const payloadObject = isPlainObject4(stored.payload) ? stored.payload : null;
+    const sender = isPlainObject4(payloadObject?.sender) ? payloadObject.sender : null;
     await deps.store.updateXmtpSession(route.jobId, {
       xmtpGroupId: conversationId,
       myXmtpAddress: deps.myXmtpAddress,
@@ -67168,7 +67405,7 @@ function processOfflineFromCoreDeps(store, ctx, deps, options) {
 function buildSystemStoredMessage(params) {
   const now = Date.now();
   return {
-    id: params.id ?? `system-${now}-${(0, import_node_crypto14.randomUUID)()}`,
+    id: params.id ?? `system-${now}-${(0, import_node_crypto15.randomUUID)()}`,
     direction: "system",
     route: "backup",
     routeReason: params.reason,
@@ -67184,14 +67421,14 @@ function buildSystemStoredMessage(params) {
   };
 }
 function isA2AEnvelope(payload) {
-  return isPlainObject3(payload) && payload.msgType === A2A_MESSAGE_TYPE;
+  return isPlainObject4(payload) && payload.msgType === A2A_MESSAGE_TYPE;
 }
-var import_node_crypto14, PROCESSED_IDS_MAX, processedMessageIds, INBOUND_TRANSPORT, INBOUND_EVENT_FAMILY, INBOUND_TERMINAL_FIELDS;
+var import_node_crypto15, PROCESSED_IDS_MAX, processedMessageIds, INBOUND_TRANSPORT, INBOUND_EVENT_FAMILY, INBOUND_TERMINAL_FIELDS;
 var init_message_handler = __esm({
   "src/message-handler.ts"() {
     "use strict";
     init_log();
-    import_node_crypto14 = require("node:crypto");
+    import_node_crypto15 = require("node:crypto");
     init_dist2();
     init_a2a();
     init_envelope_shared();
@@ -67220,6 +67457,396 @@ var init_message_handler = __esm({
   }
 });
 
+// src/wakeup-notify-ingest.ts
+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
+  };
+}
+var MAX_TARGET_ENQUEUE_ATTEMPTS;
+var init_wakeup_notify_ingest = __esm({
+  "src/wakeup-notify-ingest.ts"() {
+    "use strict";
+    init_ai_dispatch_queue();
+    init_message_handler();
+    init_wakeup_notify_client();
+    MAX_TARGET_ENQUEUE_ATTEMPTS = 3;
+  }
+});
+
+// src/wakeup-dedupe-store.ts
+function loadSqlite5() {
+  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;
+  }
+}
+var import_node_path30, DatabaseSync4, WakeupDedupeStore;
+var init_wakeup_dedupe_store = __esm({
+  "src/wakeup-dedupe-store.ts"() {
+    "use strict";
+    import_node_path30 = require("node:path");
+    init_paths();
+    ({ DatabaseSync: DatabaseSync4 } = loadSqlite5());
+    WakeupDedupeStore = class {
+      db;
+      dbPath;
+      constructor(homeDir) {
+        this.dbPath = (0, import_node_path30.join)(resolveTaskPaths(homeDir).sqliteDir, "wakeup-dedupe.sqlite");
+        ensureTaskDir((0, import_node_path30.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
+      )
+    `);
+      }
+    };
+  }
+});
+
+// src/wakeup-notify-transport.ts
+function withTimeout3(promise, timeoutMs, label) {
+  return new Promise((resolve14, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve14(value);
+      },
+      (err2) => {
+        clearTimeout(timer);
+        reject(err2);
+      }
+    );
+  });
+}
+function resolveCliTimeoutMs(override) {
+  if (typeof override === "number" && Number.isFinite(override) && override > 0) {
+    return override;
+  }
+  const raw = Number(process.env.OKX_A2A_WAKEUP_CLI_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_CLI_TIMEOUT_MS;
+}
+function isPlainObject5(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function mapCliStdoutToWakeupResponse(parsed) {
+  const root = isPlainObject5(parsed) ? parsed : {};
+  const rootData = isPlainObject5(root.data) ? root.data : {};
+  const nestedData = isPlainObject5(rootData.data) ? rootData.data : {};
+  const candidates = [root, rootData, nestedData];
+  let code;
+  let msg;
+  let list = [];
+  let listFound = false;
+  let nextPage = null;
+  let nextPageFound = false;
+  for (const candidate of candidates) {
+    if (code === void 0 && typeof candidate.code === "number" && Number.isFinite(candidate.code)) {
+      code = candidate.code;
+    }
+    if (msg === void 0 && typeof candidate.msg === "string") {
+      msg = candidate.msg;
+    }
+    if (!listFound && Array.isArray(candidate.list)) {
+      list = candidate.list;
+      listFound = true;
+    }
+    if (!nextPageFound && "nextPage" in candidate) {
+      const raw = candidate.nextPage;
+      if (typeof raw === "number" && Number.isFinite(raw)) {
+        nextPage = raw;
+        nextPageFound = true;
+      } else if (raw === null) {
+        nextPage = null;
+        nextPageFound = true;
+      }
+    }
+  }
+  if (code === void 0) {
+    code = root.ok === true ? 0 : 1;
+  }
+  return {
+    code,
+    msg,
+    data: { list: listFound ? list : void 0, nextPage: nextPageFound ? nextPage : void 0 }
+  };
+}
+function createOnchainosWakeupFetchPage(deps = {}) {
+  const timeoutMs = resolveCliTimeoutMs(deps.timeoutMs);
+  const exec2 = deps.exec ?? ((args) => exec(args, { timeoutMs }));
+  return async ({ agentIds, page }) => {
+    const { stdout } = await withTimeout3(
+      exec2([
+        "agent",
+        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);
+  };
+}
+var WAKEUP_NOTIFY_CLI_COMMAND, DEFAULT_CLI_TIMEOUT_MS;
+var init_wakeup_notify_transport = __esm({
+  "src/wakeup-notify-transport.ts"() {
+    "use strict";
+    init_bin();
+    init_cli_response();
+    WAKEUP_NOTIFY_CLI_COMMAND = "wakeup-notify";
+    DEFAULT_CLI_TIMEOUT_MS = 3e4;
+  }
+});
+
+// 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();
+  }
+}
+var init_wakeup_recovery = __esm({
+  "src/wakeup-recovery.ts"() {
+    "use strict";
+    init_log();
+    init_sentry_logger();
+    init_wakeup_notify_client();
+    init_wakeup_notify_ingest();
+    init_wakeup_dedupe_store();
+    init_wakeup_notify_transport();
+  }
+});
+
 // src/user-attention-watchers.ts
 function createUserAttentionWatchParentMonitor(options = {}) {
   const parentPid = options.parentPid ?? process.ppid;
@@ -67258,7 +67885,7 @@ function isOriginalParentProcessAlive(options) {
 }
 function registerUserAttentionWatcher(options) {
   return options.store.registerUserAttentionWatcher({
-    id: options.id ?? (0, import_node_crypto15.randomUUID)(),
+    id: options.id ?? (0, import_node_crypto16.randomUUID)(),
     provider: options.provider,
     jobId: options.jobId,
     nowMs: options.nowMs ?? Date.now(),
@@ -67337,11 +67964,11 @@ function userWatchEventDeliveredSentryExtra(event) {
     hasDecision: String(event.hasDecision)
   };
 }
-var import_node_crypto15, USER_ATTENTION_WATCH_REPLACED_MESSAGE, USER_ATTENTION_WATCHER_SCAN_MS, USER_ATTENTION_WATCHER_TTL_MS, USER_ATTENTION_WATCH_PARENT_CHECK_MS;
+var import_node_crypto16, USER_ATTENTION_WATCH_REPLACED_MESSAGE, USER_ATTENTION_WATCHER_SCAN_MS, USER_ATTENTION_WATCHER_TTL_MS, USER_ATTENTION_WATCH_PARENT_CHECK_MS;
 var init_user_attention_watchers = __esm({
   "src/user-attention-watchers.ts"() {
     "use strict";
-    import_node_crypto15 = require("node:crypto");
+    import_node_crypto16 = require("node:crypto");
     init_sentry_logger();
     USER_ATTENTION_WATCH_REPLACED_MESSAGE = "Another okx-a2a user watch with the same job scope was started, so this watcher has been closed. Do not run this watch command again automatically, because starting another watcher may interrupt a different session that is already monitoring task progress.";
     USER_ATTENTION_WATCHER_SCAN_MS = 500;
@@ -67411,12 +68038,12 @@ async function isGatewayAvailableForHeartbeat(options) {
 }
 async function getHermesGatewayPluginStatus(options = {}) {
   const env = options.env ?? process.env;
-  const hermesHome = env.HERMES_HOME?.trim() || (0, import_node_path30.join)((0, import_node_os11.homedir)(), ".hermes");
-  const pluginYamlPath = (0, import_node_path30.join)(hermesHome, "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  const hermesHome = env.HERMES_HOME?.trim() || (0, import_node_path31.join)((0, import_node_os11.homedir)(), ".hermes");
+  const pluginYamlPath = (0, import_node_path31.join)(hermesHome, "plugins", "platforms", "okx-a2a", "plugin.yaml");
   if (!(0, import_node_fs25.existsSync)(pluginYamlPath)) {
     return { enabled: false, reason: "plugin_yaml_missing", hermesHome, checkedPath: pluginYamlPath };
   }
-  const configPath = (0, import_node_path30.join)(hermesHome, "config.yaml");
+  const configPath = (0, import_node_path31.join)(hermesHome, "config.yaml");
   let content2;
   try {
     content2 = await (0, import_promises13.readFile)(configPath, "utf8");
@@ -67648,12 +68275,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();
@@ -67671,7 +68298,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(
@@ -68044,6 +68671,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((err2) => {
+      logger.error(LogEvent.WAKEUP_PULL_FAILED, err2 instanceof Error ? err2 : new Error(String(err2)), {
+        component: "node_listener",
+        stage: "wakeup_recovery_start",
+        reason: "wakeup_recovery_unhandled_error"
+      });
+      logWithTimestamp("[okx-agent-task] WakeupNotify recovery failed to start:", err2);
+    });
+  } else {
+    service.notifyAgentsWakeupAfterReplay();
+  }
   await new Promise((resolve14) => {
     const shutdown2 = (signal) => {
       if (stopping) {
@@ -68099,7 +68746,7 @@ async function timeSettled(fn) {
     return { durationMs: Date.now() - startedAt, error };
   }
 }
-var import_node_fs25, import_promises13, import_node_os11, import_node_path30, DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC, DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC, XMTP_CLIENT_RECYCLE_INTERVAL_ENV, HEARTBEAT_GATEWAY_CHECK_TIMEOUT_MS, AUTH_RECOVERY_PROBE_INTERVAL_MS, AUTH_RECOVERY_REFRESH_BACKOFF_MS, AgentRefreshAuthGate, AgentRefreshCoordinator, ListenerDeferredTaskScheduler, ListenerMaintenanceGate, UPGRADE_RECOMMENDATION_IDEMPOTENCY_KEY, SHUTDOWN_FORCE_RESOLVE_MS;
+var import_node_fs25, import_promises13, import_node_os11, import_node_path31, DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC, DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC, XMTP_CLIENT_RECYCLE_INTERVAL_ENV, HEARTBEAT_GATEWAY_CHECK_TIMEOUT_MS, AUTH_RECOVERY_PROBE_INTERVAL_MS, AUTH_RECOVERY_REFRESH_BACKOFF_MS, AgentRefreshAuthGate, AgentRefreshCoordinator, ListenerDeferredTaskScheduler, ListenerMaintenanceGate, UPGRADE_RECOMMENDATION_IDEMPOTENCY_KEY, SHUTDOWN_FORCE_RESOLVE_MS;
 var init_listener = __esm({
   "src/listener.ts"() {
     "use strict";
@@ -68107,7 +68754,7 @@ var init_listener = __esm({
     import_node_fs25 = require("node:fs");
     import_promises13 = require("node:fs/promises");
     import_node_os11 = require("node:os");
-    import_node_path30 = require("node:path");
+    import_node_path31 = require("node:path");
     init_onchainos();
     init_system_config();
     init_offline_replay_capability();
@@ -68116,6 +68763,7 @@ var init_listener = __esm({
     init_file_store();
     init_session_store();
     init_command_processor();
+    init_wakeup_recovery();
     init_command_store();
     init_ai_dispatch_queue();
     init_message_handler();
@@ -68349,9 +68997,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_path31.join)(paths.homeDir, "xmtp-tests");
+  const testsDir = (0, import_node_path32.join)(paths.homeDir, "xmtp-tests");
   await ensurePrivateDir(testsDir);
-  const active = await readJsonIfExists((0, import_node_path31.join)(testsDir, ACTIVE_FILE));
+  const active = await readJsonIfExists((0, import_node_path32.join)(testsDir, ACTIVE_FILE));
   if (active?.runId) {
     throw new Error(
       `XMTP test ${active.runId} is already active. Run \`okx-a2a xmtp-test stop\` first.`
@@ -68390,7 +69038,7 @@ async function startXmtpTest(args, releaseInfo) {
     ...releaseInfo
   };
   await writeJson(files.manifestPath, manifest);
-  await writeJson((0, import_node_path31.join)(testsDir, ACTIVE_FILE), {
+  await writeJson((0, import_node_path32.join)(testsDir, ACTIVE_FILE), {
     runId,
     startedAt: manifest.startedAt
   });
@@ -68413,7 +69061,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_path31.join)(testsDir, ACTIVE_FILE);
+  const activePath = (0, import_node_path32.join)(testsDir, ACTIVE_FILE);
   const active = await readJsonIfExists(activePath);
   if (!active?.runId) {
     throw new Error("No active XMTP test.");
@@ -68707,17 +69355,17 @@ function formatJobEvent(event) {
   return `${timestamp}  ${businessEvent.padEnd(34)} ${role}#${agent} ${source}${timings.length > 0 ? `  ${timings.join(" ")}` : ""}`;
 }
 function resolveTestsDir() {
-  return (0, import_node_path31.join)(resolveTaskPaths().homeDir, "xmtp-tests");
+  return (0, import_node_path32.join)(resolveTaskPaths().homeDir, "xmtp-tests");
 }
 function resolveRunFiles(testsDir, runId) {
   validateRunId(runId);
-  const runDir = (0, import_node_path31.join)(testsDir, runId);
+  const runDir = (0, import_node_path32.join)(testsDir, runId);
   return {
     testsDir,
     runDir,
-    manifestPath: (0, import_node_path31.join)(runDir, "manifest.json"),
-    eventsPath: (0, import_node_path31.join)(runDir, "events.jsonl"),
-    summaryPath: (0, import_node_path31.join)(runDir, "summary.json")
+    manifestPath: (0, import_node_path32.join)(runDir, "manifest.json"),
+    eventsPath: (0, import_node_path32.join)(runDir, "events.jsonl"),
+    summaryPath: (0, import_node_path32.join)(runDir, "summary.json")
   };
 }
 async function resolveRequestedRunId(testsDir, args, preferActive = false) {
@@ -68725,7 +69373,7 @@ async function resolveRequestedRunId(testsDir, args, preferActive = false) {
   if (requested) {
     return validateRunId(requested);
   }
-  const active = await readJsonIfExists((0, import_node_path31.join)(testsDir, ACTIVE_FILE));
+  const active = await readJsonIfExists((0, import_node_path32.join)(testsDir, ACTIVE_FILE));
   if (active?.runId && (preferActive || !args.includes("--latest"))) {
     return validateRunId(active.runId);
   }
@@ -68751,7 +69399,7 @@ async function findLatestRunId(testsDir) {
       continue;
     }
     const manifest = await readJsonIfExists(
-      (0, import_node_path31.join)(testsDir, entry.name, "manifest.json")
+      (0, import_node_path32.join)(testsDir, entry.name, "manifest.json")
     );
     if (manifest?.runId && manifest.startedAt) {
       manifests.push(manifest);
@@ -68986,12 +69634,12 @@ function formatPercent(value) {
 function validTimestamp(value) {
   return typeof value === "string" && Number.isFinite(Date.parse(value));
 }
-var import_promises14, import_node_path31, RUN_ID_PATTERN2, ACTIVE_FILE;
+var import_promises14, import_node_path32, RUN_ID_PATTERN2, ACTIVE_FILE;
 var init_xmtp_test_cli = __esm({
   "src/xmtp-test-cli.ts"() {
     "use strict";
     import_promises14 = require("node:fs/promises");
-    import_node_path31 = require("node:path");
+    import_node_path32 = require("node:path");
     init_daemon();
     init_log_tail();
     init_paths();
@@ -86377,7 +87025,7 @@ var require_fetch_pb = __commonJS({
         }
       });
     }
-    function isPlainObject4(value) {
+    function isPlainObject6(value) {
       const isObject = Object.prototype.toString.call(value).slice(8, -1) === "Object";
       const isObjLike = value !== null && isObject;
       if (!isObjLike || !isObject) {
@@ -86400,7 +87048,7 @@ var require_fetch_pb = __commonJS({
         const isNonEmptyPrimitiveArray = Array.isArray(value) && value.every((v) => isPrimitive(v)) && value.length > 0;
         const isNonZeroValuePrimitive = isPrimitive(value) && !isZeroValuePrimitive(value);
         let objectToMerge = {};
-        if (isPlainObject4(value)) {
+        if (isPlainObject6(value)) {
           objectToMerge = flattenRequestPayload(value, newPath);
         } else if (isNonZeroValuePrimitive || isNonEmptyPrimitiveArray) {
           objectToMerge = { [newPath]: value };
@@ -111969,10 +112617,10 @@ var require_node4 = __commonJS({
 
 // ../../node_modules/@xmtp/content-type-remote-attachment/dist/index.js
 async function encrypt(plain, secret, additionalData) {
-  const salt = import_node_crypto16.webcrypto.getRandomValues(new Uint8Array(KDFSaltSize));
-  const nonce = import_node_crypto16.webcrypto.getRandomValues(new Uint8Array(AESGCMNonceSize));
+  const salt = import_node_crypto17.webcrypto.getRandomValues(new Uint8Array(KDFSaltSize));
+  const nonce = import_node_crypto17.webcrypto.getRandomValues(new Uint8Array(AESGCMNonceSize));
   const key = await hkdf(secret, salt);
-  const encrypted = await import_node_crypto16.webcrypto.subtle.encrypt(aesGcmParams(nonce), key, plain);
+  const encrypted = await import_node_crypto17.webcrypto.subtle.encrypt(aesGcmParams(nonce), key, plain);
   return new Ciphertext({
     aes256GcmHkdfSha256: {
       payload: new Uint8Array(encrypted),
@@ -111986,7 +112634,7 @@ async function decrypt(encrypted, secret, additionalData) {
     throw new Error("invalid payload ciphertext");
   }
   const key = await hkdf(secret, encrypted.aes256GcmHkdfSha256.hkdfSalt);
-  const decrypted = await import_node_crypto16.webcrypto.subtle.decrypt(aesGcmParams(encrypted.aes256GcmHkdfSha256.gcmNonce), key, encrypted.aes256GcmHkdfSha256.payload);
+  const decrypted = await import_node_crypto17.webcrypto.subtle.decrypt(aesGcmParams(encrypted.aes256GcmHkdfSha256.gcmNonce), key, encrypted.aes256GcmHkdfSha256.payload);
   return new Uint8Array(decrypted);
 }
 function aesGcmParams(nonce, additionalData) {
@@ -111997,18 +112645,18 @@ function aesGcmParams(nonce, additionalData) {
   return spec;
 }
 async function hkdf(secret, salt) {
-  const key = await import_node_crypto16.webcrypto.subtle.importKey("raw", secret, "HKDF", false, [
+  const key = await import_node_crypto17.webcrypto.subtle.importKey("raw", secret, "HKDF", false, [
     "deriveKey"
   ]);
-  return import_node_crypto16.webcrypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt, info: hkdfNoInfo }, key, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+  return import_node_crypto17.webcrypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt, info: hkdfNoInfo }, key, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
 }
-var import_proto, import_node_crypto16, ContentTypeAttachment, AttachmentCodec, KDFSaltSize, AESGCMNonceSize, AESGCMTagLength, Ciphertext, hkdfNoInfo, ContentTypeRemoteAttachment, RemoteAttachmentCodec;
+var import_proto, import_node_crypto17, ContentTypeAttachment, AttachmentCodec, KDFSaltSize, AESGCMNonceSize, AESGCMTagLength, Ciphertext, hkdfNoInfo, ContentTypeRemoteAttachment, RemoteAttachmentCodec;
 var init_dist6 = __esm({
   "../../node_modules/@xmtp/content-type-remote-attachment/dist/index.js"() {
     init_dist5();
     init_secp256k12();
     import_proto = __toESM(require_node4(), 1);
-    import_node_crypto16 = require("node:crypto");
+    import_node_crypto17 = require("node:crypto");
     ContentTypeAttachment = new ContentTypeId({
       authorityId: "xmtp.org",
       typeId: "attachment",
@@ -112088,7 +112736,7 @@ var init_dist6 = __esm({
         if (payload.length === 0) {
           throw new Error(`no payload for remote attachment at ${remoteAttachment.url}`);
         }
-        const digestBytes = new Uint8Array(await import_node_crypto16.webcrypto.subtle.digest("SHA-256", payload));
+        const digestBytes = new Uint8Array(await import_node_crypto17.webcrypto.subtle.digest("SHA-256", payload));
         const digest = etc.bytesToHex(digestBytes);
         if (digest !== remoteAttachment.contentDigest) {
           throw new Error("content digest does not match");
@@ -112112,7 +112760,7 @@ var init_dist6 = __esm({
         return codec.decode(encodedContent, codecRegistry);
       }
       static async encodeEncrypted(content$1, codec) {
-        const secret = import_node_crypto16.webcrypto.getRandomValues(new Uint8Array(32));
+        const secret = import_node_crypto17.webcrypto.getRandomValues(new Uint8Array(32));
         const encodedContent = import_proto.content.EncodedContent.encode(codec.encode(content$1, {
           codecFor() {
             return void 0;
@@ -112125,7 +112773,7 @@ var init_dist6 = __esm({
         if (!salt || !nonce || !payload) {
           throw new Error("missing encryption key");
         }
-        const digestBytes = new Uint8Array(await import_node_crypto16.webcrypto.subtle.digest("SHA-256", payload));
+        const digestBytes = new Uint8Array(await import_node_crypto17.webcrypto.subtle.digest("SHA-256", payload));
         const digest = etc.bytesToHex(digestBytes);
         return {
           digest,
@@ -112180,9 +112828,9 @@ var init_dist6 = __esm({
 
 // ../core/src/file-upload-safety.ts
 function getUnsafeFileUploadReason(filePath, sensitiveUploadReg = []) {
-  const expanded = (0, import_node_path32.resolve)(expandHome(filePath));
+  const expanded = (0, import_node_path33.resolve)(expandHome(filePath));
   const target = (0, import_node_fs26.realpathSync)(expanded);
-  const targetName = (0, import_node_path32.basename)(target);
+  const targetName = (0, import_node_path33.basename)(target);
   if (targetName === ".env" || targetName.startsWith(".env.")) {
     return ".env";
   }
@@ -112195,13 +112843,13 @@ function getUnsafeFileUploadReason(filePath, sensitiveUploadReg = []) {
     return null;
   }
   for (const dir of SENSITIVE_HOME_DIRS) {
-    const sensitiveDir = safeRealpath((0, import_node_path32.join)(home, dir));
+    const sensitiveDir = safeRealpath((0, import_node_path33.join)(home, dir));
     if (sensitiveDir && isPathInside(target, sensitiveDir)) {
       return `~/${dir}`;
     }
   }
   for (const file of SENSITIVE_HOME_FILES) {
-    const sensitiveFile = safeRealpath((0, import_node_path32.join)(home, file));
+    const sensitiveFile = safeRealpath((0, import_node_path33.join)(home, file));
     if (sensitiveFile && target === sensitiveFile) {
       return `~/${file}`;
     }
@@ -112229,8 +112877,8 @@ function expandHome(filePath) {
   if (filePath === "~") {
     return (0, import_node_os12.homedir)();
   }
-  if (filePath.startsWith(`~${import_node_path32.sep}`)) {
-    return (0, import_node_path32.join)((0, import_node_os12.homedir)(), filePath.slice(2));
+  if (filePath.startsWith(`~${import_node_path33.sep}`)) {
+    return (0, import_node_path33.join)((0, import_node_os12.homedir)(), filePath.slice(2));
   }
   return filePath;
 }
@@ -112241,15 +112889,15 @@ function safeRealpath(path2) {
   return (0, import_node_fs26.realpathSync)(path2);
 }
 function isPathInside(target, dir) {
-  return target === dir || target.startsWith(`${dir}${import_node_path32.sep}`);
+  return target === dir || target.startsWith(`${dir}${import_node_path33.sep}`);
 }
-var import_node_fs26, import_node_os12, import_node_path32, SENSITIVE_HOME_DIRS, SENSITIVE_HOME_FILES, UNSAFE_FILE_UPLOAD_MESSAGE;
+var import_node_fs26, import_node_os12, import_node_path33, SENSITIVE_HOME_DIRS, SENSITIVE_HOME_FILES, UNSAFE_FILE_UPLOAD_MESSAGE;
 var init_file_upload_safety = __esm({
   "../core/src/file-upload-safety.ts"() {
     "use strict";
     import_node_fs26 = require("node:fs");
     import_node_os12 = require("node:os");
-    import_node_path32 = require("node:path");
+    import_node_path33 = require("node:path");
     SENSITIVE_HOME_DIRS = [
       ".ssh",
       ".gnupg",
@@ -112257,7 +112905,7 @@ var init_file_upload_safety = __esm({
       ".azure",
       ".kube",
       ".docker",
-      (0, import_node_path32.join)(".config", "gcloud")
+      (0, import_node_path33.join)(".config", "gcloud")
     ];
     SENSITIVE_HOME_FILES = [
       ".npmrc",
@@ -112319,7 +112967,7 @@ function hasHelpFlag(args) {
   return args.some((arg) => arg === "-h" || arg === "--help" || arg === "help");
 }
 async function uploadFile(params) {
-  const filename = params.filename || (0, import_node_path33.basename)(params.filePath);
+  const filename = params.filename || (0, import_node_path34.basename)(params.filePath);
   const mimeType = params.mimeType || "application/octet-stream";
   const uploadConfig = readUploadSystemConfig();
   const unsafeReason = getUnsafeFileUploadReason(params.filePath, uploadConfig.sensitiveUploadReg);
@@ -112343,7 +112991,7 @@ async function uploadFile(params) {
   const attachment = { filename, mimeType, data: new Uint8Array(data) };
   const encrypted = await RemoteAttachmentCodec.encodeEncrypted(attachment, new AttachmentCodec());
   ensureFileDirs();
-  const encryptedPath = (0, import_node_path33.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto17.randomUUID)()}.enc`);
+  const encryptedPath = (0, import_node_path34.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto18.randomUUID)()}.enc`);
   (0, import_node_fs27.writeFileSync)(encryptedPath, encrypted.payload);
   try {
     const stdout = runOnchainos([
@@ -112387,7 +113035,7 @@ async function uploadFile(params) {
 }
 async function downloadFile(params) {
   ensureFileDirs();
-  const encryptedPath = (0, import_node_path33.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto17.randomUUID)()}.enc`);
+  const encryptedPath = (0, import_node_path34.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto18.randomUUID)()}.enc`);
   try {
     const stdout = runOnchainos([
       "agent",
@@ -112412,7 +113060,7 @@ async function downloadFile(params) {
       throw new Error(`file download failed: ${stdout}`);
     }
     const payload = new Uint8Array((0, import_node_fs27.readFileSync)(encryptedPath));
-    const digestBytes = new Uint8Array(await import_node_crypto17.webcrypto.subtle.digest("SHA-256", payload));
+    const digestBytes = new Uint8Array(await import_node_crypto18.webcrypto.subtle.digest("SHA-256", payload));
     const actualDigest = Array.from(digestBytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
     if (actualDigest !== params.digest) {
       throw new Error(`file download digest verification failed: expected=${params.digest}, actual=${actualDigest}`);
@@ -112420,10 +113068,10 @@ async function downloadFile(params) {
     const decryptedBytes = await decryptAttachmentPayload(payload, params);
     const encodedContent = import_proto2.content.EncodedContent.decode(decryptedBytes);
     const attachment = new AttachmentCodec().decode(encodedContent);
-    const outputFilename = params.filename || attachment.filename || `${(0, import_node_crypto17.randomUUID)()}.bin`;
+    const outputFilename = params.filename || attachment.filename || `${(0, import_node_crypto18.randomUUID)()}.bin`;
     const outputDir = DOWNLOADS_DIR;
     ensureA2aTaskDir(outputDir);
-    const outputPath = (0, import_node_path33.resolve)(outputDir, (0, import_node_path33.basename)(outputFilename));
+    const outputPath = (0, import_node_path34.resolve)(outputDir, (0, import_node_path34.basename)(outputFilename));
     (0, import_node_fs27.writeFileSync)(outputPath, attachment.data);
     console.log(outputPath);
   } finally {
@@ -112437,15 +113085,15 @@ async function decryptAttachmentPayload(payload, params) {
   const secretBytes = new Uint8Array(Buffer.from(params.secret, "base64"));
   const saltBytes = new Uint8Array(Buffer.from(params.salt, "base64"));
   const nonceBytes = new Uint8Array(Buffer.from(params.nonce, "base64"));
-  const hkdfKey = await import_node_crypto17.webcrypto.subtle.importKey("raw", secretBytes, "HKDF", false, ["deriveKey"]);
-  const aesKey = await import_node_crypto17.webcrypto.subtle.deriveKey(
+  const hkdfKey = await import_node_crypto18.webcrypto.subtle.importKey("raw", secretBytes, "HKDF", false, ["deriveKey"]);
+  const aesKey = await import_node_crypto18.webcrypto.subtle.deriveKey(
     { name: "HKDF", hash: "SHA-256", salt: saltBytes, info: new Uint8Array().buffer },
     hkdfKey,
     { name: "AES-GCM", length: 256 },
     false,
     ["decrypt"]
   );
-  return new Uint8Array(await import_node_crypto17.webcrypto.subtle.decrypt({ name: "AES-GCM", iv: nonceBytes }, aesKey, toArrayBuffer(payload)));
+  return new Uint8Array(await import_node_crypto18.webcrypto.subtle.decrypt({ name: "AES-GCM", iv: nonceBytes }, aesKey, toArrayBuffer(payload)));
 }
 function toArrayBuffer(bytes) {
   return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
@@ -112585,14 +113233,14 @@ function readRequiredOption(args, name) {
   }
   return value;
 }
-var import_node_crypto17, import_node_fs27, import_node_path33, import_proto2, OKX_A2A_PATHS, OKX_A2A_HOME_DIR, FILE_WORK_DIR, DOWNLOADS_DIR, SYSTEM_CONFIG_PATH;
+var import_node_crypto18, import_node_fs27, import_node_path34, import_proto2, OKX_A2A_PATHS, OKX_A2A_HOME_DIR, FILE_WORK_DIR, DOWNLOADS_DIR, SYSTEM_CONFIG_PATH;
 var init_file_cli = __esm({
   "src/file-cli.ts"() {
     "use strict";
     init_win_spawn();
-    import_node_crypto17 = require("node:crypto");
+    import_node_crypto18 = require("node:crypto");
     import_node_fs27 = require("node:fs");
-    import_node_path33 = require("node:path");
+    import_node_path34 = require("node:path");
     init_dist6();
     import_proto2 = __toESM(require_node4());
     init_a2a_paths();
@@ -112603,7 +113251,7 @@ var init_file_cli = __esm({
     OKX_A2A_HOME_DIR = OKX_A2A_PATHS.homeDir;
     FILE_WORK_DIR = process.env.OKX_A2A_FILE_WORK_DIR || OKX_A2A_PATHS.filesDir;
     DOWNLOADS_DIR = process.env.OKX_A2A_DOWNLOADS_DIR || OKX_A2A_PATHS.downloadsDir;
-    SYSTEM_CONFIG_PATH = (0, import_node_path33.resolve)(OKX_A2A_PATHS.xmtpDir, "system-config.json");
+    SYSTEM_CONFIG_PATH = (0, import_node_path34.resolve)(OKX_A2A_PATHS.xmtpDir, "system-config.json");
   }
 });
 
@@ -115243,13 +115891,13 @@ async function installWindowsNativeLauncher(options) {
   if (!(0, import_node_fs28.existsSync)(nodeExe)) {
     throw new Error(`cannot build okx-a2a.exe: node executable not found at ${nodeExe}`);
   }
-  const exePath = (0, import_node_path34.join)(options.targetDir, NATIVE_LAUNCHER_EXE_NAME);
+  const exePath = (0, import_node_path35.join)(options.targetDir, NATIVE_LAUNCHER_EXE_NAME);
   (0, import_node_fs28.mkdirSync)(options.targetDir, { recursive: true });
-  const work = (0, import_node_fs28.mkdtempSync)((0, import_node_path34.join)((0, import_node_os13.tmpdir)(), "okx-a2a-sea-"));
+  const work = (0, import_node_fs28.mkdtempSync)((0, import_node_path35.join)((0, import_node_os13.tmpdir)(), "okx-a2a-sea-"));
   try {
-    const entryPath = (0, import_node_path34.join)(work, "launcher-entry.js");
-    const blobPath = (0, import_node_path34.join)(work, "okx-a2a.blob");
-    const configPath = (0, import_node_path34.join)(work, "sea-config.json");
+    const entryPath = (0, import_node_path35.join)(work, "launcher-entry.js");
+    const blobPath = (0, import_node_path35.join)(work, "okx-a2a.blob");
+    const configPath = (0, import_node_path35.join)(work, "sea-config.json");
     (0, import_node_fs28.writeFileSync)(entryPath, buildLauncherEntryJs(options.cliPath), "utf8");
     (0, import_node_fs28.writeFileSync)(configPath, buildSeaConfig(entryPath, blobPath), "utf8");
     (0, import_node_child_process9.execFileSync)(nodeExe, ["--experimental-sea-config", configPath], {
@@ -115282,13 +115930,13 @@ async function installWindowsNativeLauncher(options) {
 function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2 = import_node_fs28.existsSync) {
   const dirs = pathValue.split(";").map((d) => d.trim()).filter(Boolean);
   if (appData) {
-    dirs.push((0, import_node_path34.join)(appData, "npm"));
+    dirs.push((0, import_node_path35.join)(appData, "npm"));
   }
   if (userProfile) {
-    dirs.push((0, import_node_path34.join)(userProfile, ".local", "bin"));
+    dirs.push((0, import_node_path35.join)(userProfile, ".local", "bin"));
   }
   for (const dir of dirs) {
-    const candidate = (0, import_node_path34.join)(dir, NATIVE_LAUNCHER_EXE_NAME);
+    const candidate = (0, import_node_path35.join)(dir, NATIVE_LAUNCHER_EXE_NAME);
     if (fileExists2(candidate)) {
       return candidate;
     }
@@ -115300,7 +115948,7 @@ function resolveRunningCliPath() {
   if (fromArgv && /(?:^|[\\/])cli\.js$/.test(fromArgv) && (0, import_node_fs28.existsSync)(fromArgv)) {
     return fromArgv;
   }
-  const beside = (0, import_node_path34.join)(__dirname, "cli.js");
+  const beside = (0, import_node_path35.join)(__dirname, "cli.js");
   if ((0, import_node_fs28.existsSync)(beside)) {
     return beside;
   }
@@ -115319,11 +115967,11 @@ async function ensureWindowsNativeLauncher(options = {}) {
   if (existing) {
     return { exePath: existing, installed: false };
   }
-  const targetDir = env.APPDATA ? (0, import_node_path34.join)(env.APPDATA, "npm") : (0, import_node_path34.join)(env.USERPROFILE ?? (0, import_node_os13.homedir)(), ".local", "bin");
+  const targetDir = env.APPDATA ? (0, import_node_path35.join)(env.APPDATA, "npm") : (0, import_node_path35.join)(env.USERPROFILE ?? (0, import_node_os13.homedir)(), ".local", "bin");
   const result = await installWindowsNativeLauncher({ cliPath: resolveRunningCliPath(), targetDir });
   return { exePath: result.exePath, installed: true };
 }
-var import_node_child_process9, import_node_fs28, import_node_module, import_node_os13, import_node_path34, SEA_SENTINEL_FUSE, NATIVE_LAUNCHER_EXE_NAME, POSTJECT_SPEC, POSTJECT_BIN;
+var import_node_child_process9, import_node_fs28, import_node_module, import_node_os13, import_node_path35, SEA_SENTINEL_FUSE, NATIVE_LAUNCHER_EXE_NAME, POSTJECT_SPEC, POSTJECT_BIN;
 var init_win_native_launcher = __esm({
   "src/win-native-launcher.ts"() {
     "use strict";
@@ -115331,7 +115979,7 @@ var init_win_native_launcher = __esm({
     import_node_fs28 = require("node:fs");
     import_node_module = require("node:module");
     import_node_os13 = require("node:os");
-    import_node_path34 = require("node:path");
+    import_node_path35 = require("node:path");
     init_win_compat();
     init_win_spawn();
     SEA_SENTINEL_FUSE = "NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2";
@@ -116073,7 +116721,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;
@@ -116258,17 +116906,17 @@ async function updateHermes(release, options) {
     assertNotRunningInsideGateway("hermes");
   }
   const spec = buildNpmPackageSpec("hermes", release);
-  const workDir = await (0, import_promises15.mkdtemp)((0, import_node_path35.join)((0, import_node_os14.tmpdir)(), `okx-a2a-${label}-hermes-`));
+  const workDir = await (0, import_promises15.mkdtemp)((0, import_node_path36.join)((0, import_node_os14.tmpdir)(), `okx-a2a-${label}-hermes-`));
   try {
     console.log(`[${label}] downloading ${spec}`);
     const npmTarball = await npmPack(spec, workDir);
-    const npmPackageDir = (0, import_node_path35.join)(workDir, "npm-package");
+    const npmPackageDir = (0, import_node_path36.join)(workDir, "npm-package");
     await runCommand("tar", ["-xzf", npmTarball, "-C", npmPackageDir], { ensureDir: npmPackageDir });
-    const pluginTarball = await findHermesPluginTarball((0, import_node_path35.join)(npmPackageDir, "package", "dist"));
-    const pluginDir = (0, import_node_path35.join)(workDir, "plugin");
+    const pluginTarball = await findHermesPluginTarball((0, import_node_path36.join)(npmPackageDir, "package", "dist"));
+    const pluginDir = (0, import_node_path36.join)(workDir, "plugin");
     await runCommand("tar", ["-xzf", pluginTarball, "-C", pluginDir], { ensureDir: pluginDir });
     const unpackedPluginDir = await findFirstDirectory(pluginDir);
-    const installer = (0, import_node_path35.join)(unpackedPluginDir, "scripts", "install-or-upgrade.sh");
+    const installer = (0, import_node_path36.join)(unpackedPluginDir, "scripts", "install-or-upgrade.sh");
     console.log(`[${label}] running ${installer}`);
     await runCommand("bash", [installer, ...options.restart ? ["--restart"] : []], { cwd: unpackedPluginDir });
     await normalizeHermesOkxA2aPluginConfig();
@@ -116283,7 +116931,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,
@@ -116334,7 +116982,7 @@ async function ensureHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPa
       if (options.dryRun) {
         return true;
       }
-      await (0, import_promises15.mkdir)((0, import_node_path35.resolve)(configFile, ".."), { recursive: true });
+      await (0, import_promises15.mkdir)((0, import_node_path36.resolve)(configFile, ".."), { recursive: true });
       await (0, import_promises15.writeFile)(configFile, "plugins:\n  enabled:\n    - okx-a2a\n");
       console.log(`[update] added Hermes plugins.enabled okx-a2a entry in ${configFile}`);
       return true;
@@ -116574,7 +117222,7 @@ function findFirstEnabledListItem(lines, startIndex, enabledIndent) {
   return null;
 }
 function resolveHermesConfigPath() {
-  return (0, import_node_path35.join)(process.env.HERMES_HOME ?? (0, import_node_path35.join)((0, import_node_os14.homedir)(), ".hermes"), "config.yaml");
+  return (0, import_node_path36.join)(process.env.HERMES_HOME ?? (0, import_node_path36.join)((0, import_node_os14.homedir)(), ".hermes"), "config.yaml");
 }
 function lineIndent(line) {
   const match = line.match(/^\s*/);
@@ -116652,7 +117300,7 @@ async function assertGatewayPluginInstalled(target) {
   );
 }
 function resolveHermesPluginYamlPath() {
-  return (0, import_node_path35.join)(process.env.HERMES_HOME ?? (0, import_node_path35.join)((0, import_node_os14.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  return (0, import_node_path36.join)(process.env.HERMES_HOME ?? (0, import_node_path36.join)((0, import_node_os14.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
 }
 async function isGatewayPluginInstalled(target) {
   if (target === "openclaw") {
@@ -116745,7 +117393,7 @@ function parsePackageVersionFromText(output5) {
   return output5.match(/@okxweb3\/a2a-openclaw@([0-9A-Za-z.+-]+)/)?.[1] ?? null;
 }
 async function getInstalledHermesPluginVersion() {
-  const pluginYaml = (0, import_node_path35.join)(process.env.HERMES_HOME ?? (0, import_node_path35.join)((0, import_node_os14.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  const pluginYaml = (0, import_node_path36.join)(process.env.HERMES_HOME ?? (0, import_node_path36.join)((0, import_node_os14.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
   try {
     const content2 = await (0, import_promises15.readFile)(pluginYaml, "utf8");
     return parsePluginYamlVersion(content2);
@@ -116803,7 +117451,7 @@ async function npmPack(spec, destination) {
   if (!tarballName) {
     throw new Error(`Unable to detect npm pack tarball from output: ${output5.trim()}`);
   }
-  return (0, import_node_path35.resolve)(destination, (0, import_node_path35.basename)(tarballName));
+  return (0, import_node_path36.resolve)(destination, (0, import_node_path36.basename)(tarballName));
 }
 async function findHermesPluginTarball(distDir) {
   const entries = await (0, import_promises15.readdir)(distDir);
@@ -116811,7 +117459,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_path35.join)(distDir, tarball);
+  return (0, import_node_path36.join)(distDir, tarball);
 }
 async function findFirstDirectory(parent) {
   const entries = await (0, import_promises15.readdir)(parent, { withFileTypes: true });
@@ -116819,7 +117467,7 @@ async function findFirstDirectory(parent) {
   if (!dir) {
     throw new Error(`No unpacked plugin directory found under ${parent}`);
   }
-  return (0, import_node_path35.join)(parent, dir.name);
+  return (0, import_node_path36.join)(parent, dir.name);
 }
 function readOption4(args, name) {
   const index2 = args.indexOf(name);
@@ -117040,7 +117688,7 @@ function buildExternalCommandInvocation(command, args, platform = process.platfo
 function formatExternalCommand(command, args) {
   return [command, ...args].join(" ");
 }
-var import_node_child_process10, import_node_fs29, import_promises15, import_node_os14, import_node_path35, 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_process10, import_node_fs29, import_promises15, import_node_os14, import_node_path36, 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";
@@ -117048,7 +117696,7 @@ var init_update_cli = __esm({
     import_node_fs29 = require("node:fs");
     import_promises15 = require("node:fs/promises");
     import_node_os14 = require("node:os");
-    import_node_path35 = require("node:path");
+    import_node_path36 = require("node:path");
     init_ai_command();
     init_win_spawn();
     init_ai_provider();
@@ -117329,7 +117977,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,
@@ -117537,11 +118185,11 @@ async function writeStdoutAndExit(output5, code) {
   });
   process.exit(code);
 }
-var import_node_path36, DOCTOR_MIN_NODE_VERSION, DOCTOR_DAEMON_READY_TIMEOUT_MS, DOCTOR_DAEMON_WAIT_HEARTBEAT_MS, NODE_PACKAGE_SPEC, CODEX_INSTALL_SPEC, CLAUDE_INSTALL_SPEC, nodeVersionChecker, npmChecker, cliVersionChecker, windowsNativeLauncherChecker, providerBindingChecker, providerCliChecker, gatewayPluginChecker, gatewayConfigChecker, daemonChecker, agentRefreshChecker, gatewayReachableChecker, autostartChecker, CHECKERS, STATUS_MARK;
+var import_node_path37, DOCTOR_MIN_NODE_VERSION, DOCTOR_DAEMON_READY_TIMEOUT_MS, DOCTOR_DAEMON_WAIT_HEARTBEAT_MS, NODE_PACKAGE_SPEC, CODEX_INSTALL_SPEC, CLAUDE_INSTALL_SPEC, nodeVersionChecker, npmChecker, cliVersionChecker, windowsNativeLauncherChecker, providerBindingChecker, providerCliChecker, gatewayPluginChecker, gatewayConfigChecker, daemonChecker, agentRefreshChecker, gatewayReachableChecker, autostartChecker, CHECKERS, STATUS_MARK;
 var init_doctor_cli = __esm({
   "src/doctor-cli.ts"() {
     "use strict";
-    import_node_path36 = require("node:path");
+    import_node_path37 = require("node:path");
     init_log();
     init_win_compat();
     init_ai_command();
@@ -117728,7 +118376,7 @@ var init_doctor_cli = __esm({
             command: "okx-a2a doctor --fix"
           },
           data: {
-            appDataNpm: ctx.env.APPDATA ? (0, import_node_path36.join)(ctx.env.APPDATA, "npm") : null
+            appDataNpm: ctx.env.APPDATA ? (0, import_node_path37.join)(ctx.env.APPDATA, "npm") : null
           }
         };
       },
@@ -118335,7 +118983,7 @@ var init_doctor_cli = __esm({
 var import_node_child_process11 = require("node:child_process");
 var import_node_fs30 = require("node:fs");
 var import_node_os15 = require("node:os");
-var import_node_path37 = require("node:path");
+var import_node_path38 = require("node:path");
 init_daemon();
 init_command_store();
 init_file_store();
@@ -118351,7 +118999,7 @@ init_sentry_logger();
 init_sentry_config();
 var CURRENT_GATEWAY_SESSION_KEYS_ENV4 = "OKX_A2A_CURRENT_GATEWAY_SESSION_KEYS";
 function printUsage3() {
-  console.log(`okx-a2a ${"0.2.7"}
+  console.log(`okx-a2a ${"0.2.8-beta-912b775358-260818171144"}
 
 Usage:
   okx-a2a <command> [options]
@@ -118391,7 +119039,7 @@ Run \`okx-a2a <command> -h\` for command-specific help.
 `);
 }
 function printVersion() {
-  console.log("0.2.7");
+  console.log("0.2.8-beta-912b775358-260818171144");
 }
 function printDaemonUsage() {
   console.log(`Usage: okx-a2a daemon <start|restart|stop|status|autostart> [options]
@@ -118665,7 +119313,7 @@ function maybeRedirectDaemonSelfLog() {
   }
   try {
     const logPath = resolveTaskPaths().listenerLogPath;
-    (0, import_node_fs30.mkdirSync)((0, import_node_path37.join)(logPath, ".."), { recursive: true });
+    (0, import_node_fs30.mkdirSync)((0, import_node_path38.join)(logPath, ".."), { recursive: true });
     const fd = (0, import_node_fs30.openSync)(logPath, "a");
     const writeToLog = ((chunk, encoding, cb) => {
       try {
@@ -118772,7 +119420,7 @@ async function handleLogs(args) {
     return;
   }
   if (subcommand === "llm") {
-    await tailLogFile((0, import_node_path37.join)(paths.logsDir, "llm.log"));
+    await tailLogFile((0, import_node_path38.join)(paths.logsDir, "llm.log"));
     return;
   }
   throw new Error("logs requires <server|llm|export>");
@@ -119694,7 +120342,7 @@ function initDirectCliSentry() {
   }
   cliSentryInitAttempted = true;
   try {
-    const configPath = (0, import_node_path37.join)(resolveTaskHomeForSentryConfig(), "xmtp", "system-config.json");
+    const configPath = (0, import_node_path38.join)(resolveTaskHomeForSentryConfig(), "xmtp", "system-config.json");
     if (!(0, import_node_fs30.existsSync)(configPath)) {
       return;
     }
@@ -119718,11 +120366,11 @@ function resolveTaskHomeForSentryConfig() {
   try {
     const home = (0, import_node_os15.homedir)();
     if (home) {
-      return (0, import_node_path37.join)(home, ".okx-agent-task");
+      return (0, import_node_path38.join)(home, ".okx-agent-task");
     }
   } catch {
   }
-  return (0, import_node_path37.resolve)(process.cwd(), ".okx-agent-task");
+  return (0, import_node_path38.resolve)(process.cwd(), ".okx-agent-task");
 }
 function directCliSentryExtra(operation, extra = {}) {
   return {
@@ -119830,7 +120478,7 @@ async function main() {
   if (command === "xmtp-test") {
     const { handleXmtpTestCommand: handleXmtpTestCommand2 } = await Promise.resolve().then(() => (init_xmtp_test_cli(), xmtp_test_cli_exports));
     await handleXmtpTestCommand2(process.argv.slice(3), {
-      packageVersion: "0.2.7",
+      packageVersion: "0.2.8-beta-912b775358-260818171144",
       agentSdkVersion: "2.3.0",
       nodeSdkVersion: "6.1.0",
       nodeBindingsVersion: "1.11.0"