@okxweb3/a2a-node 0.2.16 → 0.2.17-beta-ab42219842-261020165552

package/dist/index.js

@@ -114,7 +114,8 @@ function resolveTaskPaths(homeDir = resolveTaskHome()) {
     completedCommandsDir: (0, import_node_path2.join)(homeDir, "commands", "completed"),
     pidPath: (0, import_node_path2.join)(homeDir, "run", "listener.pid"),
     daemonLockPath: (0, import_node_path2.join)(homeDir, "run", "daemon.lock"),
-    listenerLogPath: (0, import_node_path2.join)(homeDir, "logs", "listener.log")
+    listenerLogPath: (0, import_node_path2.join)(homeDir, "logs", "listener.log"),
+    devkitServerDbPath: (0, import_node_path2.join)(homeDir, "sqlite", DEVKIT_SERVER_DB_NAME)
   };
 }
 function ensureTaskHome(homeDir) {
@@ -126,13 +127,14 @@ function encodeJobIdForFile(jobId) {
 function ensureTaskDir(dir) {
   return ensureA2aTaskDir(dir);
 }
-var import_node_path2, BACKUP_JOB_ID;
+var import_node_path2, BACKUP_JOB_ID, DEVKIT_SERVER_DB_NAME;
 var init_paths = __esm({
   "src/paths.ts"() {
     "use strict";
     import_node_path2 = require("node:path");
     init_a2a_paths();
     BACKUP_JOB_ID = "backup";
+    DEVKIT_SERVER_DB_NAME = "devkit-server.sqlite";
   }
 });
 
@@ -4256,8 +4258,8 @@ var require_worldwide = __commonJS({
     function getGlobalSingleton(name, creator, obj) {
       const gbl = obj || GLOBAL_OBJ;
       const __SENTRY__ = gbl.__SENTRY__ = gbl.__SENTRY__ || {};
-      const singleton2 = __SENTRY__[name] || (__SENTRY__[name] = creator());
-      return singleton2;
+      const singleton3 = __SENTRY__[name] || (__SENTRY__[name] = creator());
+      return singleton3;
     }
     exports2.GLOBAL_OBJ = GLOBAL_OBJ;
     exports2.getGlobalObject = getGlobalObject;
@@ -19302,6 +19304,14 @@ var init_events = __esm({
       SYSTEM_NOTIFICATION_ROUTED: "System notification routed",
       HERMES_SESSION_ROUTE_BINDING: "Hermes session route binding",
       DOCTOR_REPORT: "Doctor report",
+      // XMTP creation rate-limit cooldown (DEXMARKET-9116). All four are logger.info,
+      // so each one must also be listed in SENTRY_INFO_ALLOWLIST (index.ts) or info()
+      // drops it silently. Extras are bounded tokens/ints/bools only — never raw SDK
+      // error text (no-content-leak invariant).
+      XMTP_RATE_LIMIT_COOLDOWN_STARTED: "XMTP rate limit cooldown started",
+      XMTP_RATE_LIMIT_CREATE_SUPPRESSED: "XMTP rate limit create suppressed",
+      XMTP_RATE_LIMIT_PROBE: "XMTP rate limit probe",
+      XMTP_RATE_LIMIT_RECOVERED: "XMTP rate limit recovered",
       // ── error ─────────────────────────────────────────────────────
       XMTP_CONNECTION_FAILED: "XMTP connection failed",
       CONVERSATIONS_STREAM_FAILED: "conversations.stream failed",
@@ -19367,7 +19377,28 @@ var init_events = __esm({
       AGENT_DB_DIR_CREATE_FAILED: "Agent DB dir create failed",
       AGENT_INSTALLATION_LIMIT_NEAR: "Agent installation limit near",
       XMTP_HISTORY_SYNC_REQUEST_FAILED: "XMTP history sync request failed",
-      XMTP_DEBUG_SYNC_FAILED: "XMTP debug sync failed"
+      XMTP_DEBUG_SYNC_FAILED: "XMTP debug sync failed",
+      // Underlying XMTP SDK client close failed during recycle/removal/shutdown
+      // (DEXMARKET-9116). Error-level → NOT added to SENTRY_INFO_ALLOWLIST.
+      XMTP_CLIENT_CLOSE_FAILED: "XMTP client close failed",
+      // ── devkit custom-server registry + delivery (DEXMARKET-9165) ──────────────
+      // info-level (registered in SENTRY_INFO_ALLOWLIST below):
+      DEVKIT_REGISTER_REQUESTED: "Devkit register requested",
+      DEVKIT_REGISTER_COMPLETED: "Devkit register completed",
+      DEVKIT_UNREGISTER_REQUESTED: "Devkit unregister requested",
+      DEVKIT_UNREGISTER_COMPLETED: "Devkit unregister completed",
+      DEVKIT_DAEMON_STATUS_UNKNOWN: "Devkit daemon status unknown",
+      DEVKIT_ROUTE_DEFAULT_AI: "Devkit route default AI",
+      DEVKIT_ROUTE_CUSTOM_SERVER: "Devkit route custom server",
+      DEVKIT_DELIVERY_ACCEPTED: "Devkit delivery accepted",
+      DEVKIT_DELIVERY_HTTP_ACCEPTED: "Devkit delivery http accepted",
+      DEVKIT_DELIVERY_DROPPED: "Devkit delivery dropped",
+      DEVKIT_DELIVERY_CANCELLED: "Devkit delivery cancelled",
+      // error-level (NOT allowlisted — logger.error):
+      DEVKIT_REGISTER_REJECTED: "Devkit register rejected",
+      DEVKIT_CONFIG_PERSIST_FAILED: "Devkit config persist failed",
+      DEVKIT_ROUTE_CONFIG_READ_FAILED: "Devkit route config read failed",
+      DEVKIT_DELIVERY_HTTP_FAILED: "Devkit delivery http failed"
     };
   }
 });
@@ -20212,7 +20243,26 @@ var init_sentry_logger = __esm({
       LogEvent.PENDING_LIST_QUERIED,
       LogEvent.SESSION_KEY_DERIVED,
       LogEvent.SESSIONS_QUERIED,
-      LogEvent.SYNC_TICK_COMPLETED
+      LogEvent.SYNC_TICK_COMPLETED,
+      // XMTP creation rate-limit cooldown checkpoints (DEXMARKET-9116). info() drops
+      // any event not listed here, so these must stay registered.
+      LogEvent.XMTP_RATE_LIMIT_COOLDOWN_STARTED,
+      LogEvent.XMTP_RATE_LIMIT_CREATE_SUPPRESSED,
+      LogEvent.XMTP_RATE_LIMIT_PROBE,
+      LogEvent.XMTP_RATE_LIMIT_RECOVERED,
+      // devkit custom-server registry + delivery info checkpoints (DEXMARKET-9165).
+      // info() drops any event not listed here, so these must stay registered.
+      LogEvent.DEVKIT_REGISTER_REQUESTED,
+      LogEvent.DEVKIT_REGISTER_COMPLETED,
+      LogEvent.DEVKIT_UNREGISTER_REQUESTED,
+      LogEvent.DEVKIT_UNREGISTER_COMPLETED,
+      LogEvent.DEVKIT_DAEMON_STATUS_UNKNOWN,
+      LogEvent.DEVKIT_ROUTE_DEFAULT_AI,
+      LogEvent.DEVKIT_ROUTE_CUSTOM_SERVER,
+      LogEvent.DEVKIT_DELIVERY_ACCEPTED,
+      LogEvent.DEVKIT_DELIVERY_HTTP_ACCEPTED,
+      LogEvent.DEVKIT_DELIVERY_DROPPED,
+      LogEvent.DEVKIT_DELIVERY_CANCELLED
     ]);
     MAX_EXTRA_STRING_LENGTH = 256;
     MAX_TAG_VALUE_LENGTH = 128;
@@ -32448,7 +32498,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.16",
+      release: "0.2.17-beta-ab42219842-261020165552",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -32482,7 +32532,7 @@ function isPostjectRunnable() {
 function resolvePostjectCommand() {
   try {
     const cliPath = (0, import_node_module.createRequire)(__filename).resolve("postject/dist/cli.js");
-    if ((0, import_node_fs21.existsSync)(cliPath)) {
+    if ((0, import_node_fs22.existsSync)(cliPath)) {
       return { command: process.execPath, prefixArgs: [cliPath] };
     }
   } catch {
@@ -32553,26 +32603,26 @@ function buildSeaConfig(entryPath, blobPath) {
 }
 async function installWindowsNativeLauncher(options) {
   const nodeExe = options.nodeExe ?? process.execPath;
-  if (!(0, import_node_fs21.existsSync)(options.cliPath)) {
+  if (!(0, import_node_fs22.existsSync)(options.cliPath)) {
     throw new Error(`cannot build okx-a2a.exe: CLI entry not found at ${options.cliPath}`);
   }
-  if (!(0, import_node_fs21.existsSync)(nodeExe)) {
+  if (!(0, import_node_fs22.existsSync)(nodeExe)) {
     throw new Error(`cannot build okx-a2a.exe: node executable not found at ${nodeExe}`);
   }
   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_path28.join)((0, import_node_os9.tmpdir)(), "okx-a2a-sea-"));
+  (0, import_node_fs22.mkdirSync)(options.targetDir, { recursive: true });
+  const work = (0, import_node_fs22.mkdtempSync)((0, import_node_path28.join)((0, import_node_os9.tmpdir)(), "okx-a2a-sea-"));
   try {
     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_fs22.writeFileSync)(entryPath, buildLauncherEntryJs(options.cliPath), "utf8");
+    (0, import_node_fs22.writeFileSync)(configPath, buildSeaConfig(entryPath, blobPath), "utf8");
     (0, import_node_child_process7.execFileSync)(nodeExe, ["--experimental-sea-config", configPath], {
       stdio: "ignore",
       windowsHide: true
     });
-    (0, import_node_fs21.copyFileSync)(nodeExe, exePath);
+    (0, import_node_fs22.copyFileSync)(nodeExe, exePath);
     const isMac = process.platform === "darwin";
     if (isMac) {
       try {
@@ -32592,10 +32642,10 @@ async function installWindowsNativeLauncher(options) {
     );
     return { exePath, cliPath: options.cliPath, nodeExe };
   } finally {
-    (0, import_node_fs21.rmSync)(work, { recursive: true, force: true });
+    (0, import_node_fs22.rmSync)(work, { recursive: true, force: true });
   }
 }
-function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2 = import_node_fs21.existsSync) {
+function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2 = import_node_fs22.existsSync) {
   const dirs = pathValue.split(";").map((d) => d.trim()).filter(Boolean);
   if (appData) {
     dirs.push((0, import_node_path28.join)(appData, "npm"));
@@ -32613,11 +32663,11 @@ function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2
 }
 function resolveRunningCliPath() {
   const fromArgv = process.argv[1];
-  if (fromArgv && /(?:^|[\\/])cli\.js$/.test(fromArgv) && (0, import_node_fs21.existsSync)(fromArgv)) {
+  if (fromArgv && /(?:^|[\\/])cli\.js$/.test(fromArgv) && (0, import_node_fs22.existsSync)(fromArgv)) {
     return fromArgv;
   }
   const beside = (0, import_node_path28.join)(__dirname, "cli.js");
-  if ((0, import_node_fs21.existsSync)(beside)) {
+  if ((0, import_node_fs22.existsSync)(beside)) {
     return beside;
   }
   if (fromArgv) {
@@ -32639,12 +32689,12 @@ async function ensureWindowsNativeLauncher(options = {}) {
   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_os9, import_node_path28, SEA_SENTINEL_FUSE, NATIVE_LAUNCHER_EXE_NAME, POSTJECT_SPEC, POSTJECT_BIN;
+var import_node_child_process7, import_node_fs22, import_node_module, import_node_os9, 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";
     import_node_child_process7 = require("node:child_process");
-    import_node_fs21 = require("node:fs");
+    import_node_fs22 = require("node:fs");
     import_node_module = require("node:module");
     import_node_os9 = require("node:os");
     import_node_path28 = require("node:path");
@@ -32786,7 +32836,7 @@ function buildProviderMismatchWarning(target, provider) {
   ].join("\n");
 }
 async function handleUpdateCommand(args) {
-  if (args.some(isHelpArg)) {
+  if (args.some(isHelpArg2)) {
     printUpdateUsage();
     return;
   }
@@ -32827,7 +32877,7 @@ function resolveUpdateTarget(target) {
   return detectGatewayInvocation() ?? "node";
 }
 async function handleSetupCommand(args) {
-  if (args.some(isHelpArg)) {
+  if (args.some(isHelpArg2)) {
     printSetupUsage();
     return;
   }
@@ -33404,7 +33454,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.16" : null;
+  return true ? "0.2.17-beta-ab42219842-261020165552" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -33589,7 +33639,7 @@ async function updateHermes(release, options) {
     assertNotRunningInsideGateway("hermes");
   }
   const spec = buildNpmPackageSpec("hermes", release);
-  const workDir = await (0, import_promises11.mkdtemp)((0, import_node_path29.join)((0, import_node_os10.tmpdir)(), `okx-a2a-${label}-hermes-`));
+  const workDir = await (0, import_promises12.mkdtemp)((0, import_node_path29.join)((0, import_node_os10.tmpdir)(), `okx-a2a-${label}-hermes-`));
   try {
     console.log(`[${label}] downloading ${spec}`);
     const npmTarball = await npmPack(spec, workDir);
@@ -33610,11 +33660,11 @@ async function updateHermes(release, options) {
     }
     console.log(`[${label}] hermes ${label} done`);
   } finally {
-    await (0, import_promises11.rm)(workDir, { recursive: true, force: true });
+    await (0, import_promises12.rm)(workDir, { recursive: true, force: true });
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.16") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.17-beta-ab42219842-261020165552") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -33641,7 +33691,7 @@ function setupReadyMessage(target) {
 async function normalizeHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPath()) {
   let content;
   try {
-    content = await (0, import_promises11.readFile)(configFile, "utf8");
+    content = await (0, import_promises12.readFile)(configFile, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return false;
@@ -33652,21 +33702,21 @@ async function normalizeHermesOkxA2aPluginConfig(configFile = resolveHermesConfi
   if (!normalized.changed) {
     return false;
   }
-  await (0, import_promises11.writeFile)(configFile, normalized.content);
+  await (0, import_promises12.writeFile)(configFile, normalized.content);
   console.log(`[update] normalized Hermes plugins.enabled okx-a2a entry in ${configFile}`);
   return true;
 }
 async function ensureHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPath(), options = {}) {
   let content;
   try {
-    content = await (0, import_promises11.readFile)(configFile, "utf8");
+    content = await (0, import_promises12.readFile)(configFile, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       if (options.dryRun) {
         return 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");
+      await (0, import_promises12.mkdir)((0, import_node_path29.resolve)(configFile, ".."), { recursive: true });
+      await (0, import_promises12.writeFile)(configFile, "plugins:\n  enabled:\n    - okx-a2a\n");
       console.log(`[update] added Hermes plugins.enabled okx-a2a entry in ${configFile}`);
       return true;
     }
@@ -33677,7 +33727,7 @@ async function ensureHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPa
     if (options.dryRun) {
       return true;
     }
-    await (0, import_promises11.writeFile)(configFile, normalized.content);
+    await (0, import_promises12.writeFile)(configFile, normalized.content);
     console.log(`[update] normalized Hermes plugins.enabled okx-a2a entry in ${configFile}`);
     return true;
   }
@@ -33688,7 +33738,7 @@ async function ensureHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPa
     return true;
   }
   const updated = addHermesOkxA2aEnabled(content);
-  await (0, import_promises11.writeFile)(configFile, updated);
+  await (0, import_promises12.writeFile)(configFile, updated);
   console.log(`[update] added Hermes plugins.enabled okx-a2a entry in ${configFile}`);
   return true;
 }
@@ -33989,7 +34039,7 @@ async function isGatewayPluginInstalled(target) {
   if (target === "openclaw") {
     return (await getInstalledOpenClawPluginInfo()).installed;
   }
-  return (0, import_node_fs22.existsSync)(resolveHermesPluginYamlPath());
+  return (0, import_node_fs23.existsSync)(resolveHermesPluginYamlPath());
 }
 async function getInstalledGatewayPluginVersion(target) {
   if (target === "hermes") {
@@ -34078,7 +34128,7 @@ function parsePackageVersionFromText(output) {
 async function getInstalledHermesPluginVersion() {
   const pluginYaml = (0, import_node_path29.join)(process.env.HERMES_HOME ?? (0, import_node_path29.join)((0, import_node_os10.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
   try {
-    const content = await (0, import_promises11.readFile)(pluginYaml, "utf8");
+    const content = await (0, import_promises12.readFile)(pluginYaml, "utf8");
     return parsePluginYamlVersion(content);
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
@@ -34137,7 +34187,7 @@ async function npmPack(spec, destination) {
   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);
+  const entries = await (0, import_promises12.readdir)(distDir);
   const tarball = entries.find((entry) => /^okx-a2a-hermes-plugin-.+\.tar\.gz$/.test(entry));
   if (!tarball) {
     throw new Error(`Hermes npm package did not contain dist/okx-a2a-hermes-plugin-*.tar.gz`);
@@ -34145,7 +34195,7 @@ async function findHermesPluginTarball(distDir) {
   return (0, import_node_path29.join)(distDir, tarball);
 }
 async function findFirstDirectory(parent) {
-  const entries = await (0, import_promises11.readdir)(parent, { withFileTypes: true });
+  const entries = await (0, import_promises12.readdir)(parent, { withFileTypes: true });
   const dir = entries.find((entry) => entry.isDirectory());
   if (!dir) {
     throw new Error(`No unpacked plugin directory found under ${parent}`);
@@ -34162,7 +34212,7 @@ function readOption2(args, name) {
 function hasFlag(args, name) {
   return args.includes(name);
 }
-function isHelpArg(value) {
+function isHelpArg2(value) {
   return value === "-h" || value === "--help" || value === "help";
 }
 function isSupportedRelease(value) {
@@ -34371,13 +34421,13 @@ 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_os10, 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 import_node_child_process8, import_node_fs23, import_promises12, import_node_os10, 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";
     import_node_child_process8 = require("node:child_process");
-    import_node_fs22 = require("node:fs");
-    import_promises11 = require("node:fs/promises");
+    import_node_fs23 = require("node:fs");
+    import_promises12 = require("node:fs/promises");
     import_node_os10 = require("node:os");
     import_node_path29 = require("node:path");
     init_ai_command();
@@ -44330,7 +44380,22 @@ __export(index_exports, {
   DEFAULT_LOG_TAIL_LIMIT: () => DEFAULT_LOG_TAIL_LIMIT,
   DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC: () => DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC,
   DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC: () => DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC,
+  DEVKIT_DROP_REASON: () => DEVKIT_DROP_REASON,
+  DEVKIT_MAX_CONCURRENCY: () => DEVKIT_MAX_CONCURRENCY,
+  DEVKIT_MAX_MESSAGE_BYTES: () => DEVKIT_MAX_MESSAGE_BYTES,
+  DEVKIT_MAX_PENDING: () => DEVKIT_MAX_PENDING,
+  DEVKIT_MAX_PENDING_BYTES: () => DEVKIT_MAX_PENDING_BYTES,
+  DEVKIT_OUTCOME: () => DEVKIT_OUTCOME,
+  DEVKIT_REQUEST_BUDGET_MS: () => DEVKIT_REQUEST_BUDGET_MS,
+  DEVKIT_RESPONSE_DIAGNOSTIC_MAX_BYTES: () => DEVKIT_RESPONSE_DIAGNOSTIC_MAX_BYTES,
+  DEVKIT_RESPONSE_SUMMARY_MAX_CHARS: () => DEVKIT_RESPONSE_SUMMARY_MAX_CHARS,
+  DEVKIT_SERVER_APPLICATION_ID: () => DEVKIT_SERVER_APPLICATION_ID,
+  DEVKIT_SERVER_DB_NAME: () => DEVKIT_SERVER_DB_NAME,
+  DEVKIT_SERVER_SCHEMA_VERSION: () => DEVKIT_SERVER_SCHEMA_VERSION,
   DOCTOR_MIN_NODE_VERSION: () => DOCTOR_MIN_NODE_VERSION,
+  DevkitDeliveryDispatcher: () => DevkitDeliveryDispatcher,
+  DevkitServerStore: () => DevkitServerStore,
+  DevkitServerStoreError: () => DevkitServerStoreError,
   GatewayOutboundBehavior: () => GatewayOutboundBehavior,
   HEARTBEAT_GATEWAY_CHECK_TIMEOUT_MS: () => HEARTBEAT_GATEWAY_CHECK_TIMEOUT_MS,
   InboundReplayGate: () => InboundReplayGate,
@@ -44359,6 +44424,9 @@ __export(index_exports, {
   UserCancelledAiProviderSelectionError: () => UserCancelledAiProviderSelectionError,
   WALLET_STATUS_TIMEOUT_MS: () => WALLET_STATUS_TIMEOUT_MS,
   XMTP_CLIENT_RECYCLE_INTERVAL_ENV: () => XMTP_CLIENT_RECYCLE_INTERVAL_ENV,
+  XMTP_CREATION_COOLDOWN_MS: () => XMTP_CREATION_COOLDOWN_MS,
+  XmtpCreationCooldown: () => XmtpCreationCooldown,
+  XmtpCreationCooldownSkipError: () => XmtpCreationCooldownSkipError,
   XmtpDm: () => Dm,
   XmtpGroup: () => Group,
   XmtpService: () => XmtpService,
@@ -44385,6 +44453,7 @@ __export(index_exports, {
   buildExternalCommandInvocation: () => buildExternalCommandInvocation,
   buildGatewayOutboundExtra: () => buildGatewayOutboundExtra,
   buildInboundTerminalExtras: () => buildInboundTerminalExtras,
+  buildJobEnvelope: () => buildJobEnvelope,
   buildLaunchdPlist: () => buildLaunchdPlist,
   buildLauncherEntryJs: () => buildLauncherEntryJs,
   buildMessageEligibleArgs: () => buildMessageEligibleArgs,
@@ -44395,6 +44464,7 @@ __export(index_exports, {
   buildSchtasksRunArgs: () => buildSchtasksRunArgs,
   buildSeaConfig: () => buildSeaConfig,
   buildServicePath: () => buildServicePath,
+  buildSessionEnvelope: () => buildSessionEnvelope,
   buildSessionKey: () => buildSessionKey,
   buildSystemMessageNotice: () => buildSystemMessageNotice,
   buildSystemStoredMessage: () => buildSystemStoredMessage,
@@ -44412,6 +44482,8 @@ __export(index_exports, {
   checkCodexCliAuthStatus: () => checkCodexCliAuthStatus,
   checkCodexReadiness: () => checkCodexReadiness,
   claimActiveDaemon: () => claimActiveDaemon,
+  classifyFetchFailure: () => classifyFetchFailure,
+  classifyHttpOutcome: () => classifyHttpOutcome,
   classifyJobBindingSource: () => classifyJobBindingSource,
   clearCodexReadinessCache: () => clearCodexReadinessCache,
   codexCommandResolvesWithoutOverride: () => codexCommandResolvesWithoutOverride,
@@ -44420,6 +44492,7 @@ __export(index_exports, {
   collectCodexCommandCandidates: () => collectCodexCommandCandidates,
   commandExists: () => commandExists,
   createAiToolFailureTracker: () => createAiToolFailureTracker,
+  createDevkitAutoRouter: () => createDevkitAutoRouter,
   createFileMessageHandler: () => createFileMessageHandler,
   createOutboundBehavior: () => createOutboundBehavior,
   createUserAttentionWatchParentMonitor: () => createUserAttentionWatchParentMonitor,
@@ -44430,6 +44503,7 @@ __export(index_exports, {
   detectGatewayInvocation: () => detectGatewayInvocation,
   detectMessageEligibleOfflineReplaySupport: () => detectMessageEligibleOfflineReplaySupport,
   detectRuntime: () => detectRuntime,
+  devkitServerDbExists: () => devkitServerDbExists,
   ensureDaemonReady: () => ensureDaemonReady,
   ensureDefaultAiProvider: () => ensureDefaultAiProvider,
   ensureOpenClawOkxA2aPluginConfig: () => ensureOpenClawOkxA2aPluginConfig,
@@ -44439,6 +44513,7 @@ __export(index_exports, {
   exportDiagnosticLogs: () => exportDiagnosticLogs,
   extractAiSessionId: () => extractAiSessionId,
   extractDirectToUserNotification: () => extractDirectToUserNotification,
+  extractRateLimitEndpoint: () => extractRateLimitEndpoint,
   extractXmtpSentAtMs: () => extractXmtpSentAtMs2,
   findWindowsNativeOkxA2aExe: () => findWindowsNativeOkxA2aExe,
   followFile: () => followFile,
@@ -44449,7 +44524,9 @@ __export(index_exports, {
   getResolvedOnchainosBinForTests: () => getResolvedOnchainosBinForTests,
   getRuntimeMetadata: () => getRuntimeMetadata,
   getSessionBusyTracker: () => getSessionBusyTracker,
+  getXmtpCreationCooldown: () => getXmtpCreationCooldown,
   handleCapabilitiesCommand: () => handleCapabilitiesCommand,
+  handleDevkitCommand: () => handleDevkitCommand,
   handleDoctorCommand: () => handleDoctorCommand,
   handleXmtpDebugCommand: () => handleXmtpDebugCommand,
   handleXmtpSendCommand: () => handleXmtpSendCommand,
@@ -44479,6 +44556,7 @@ __export(index_exports, {
   isTagKey: () => isTagKey,
   isValidExternalJobId: () => isValidExternalJobId,
   isWindowsElevated: () => isWindowsElevated,
+  isXmtpRateLimitError: () => isXmtpRateLimitError,
   killProcessTree: () => killProcessTree,
   launchdPlistHasCurrentRestartPolicy: () => launchdPlistHasCurrentRestartPolicy,
   listAllAgentsWithMetadata: () => listAllAgentsWithMetadata,
@@ -44506,6 +44584,7 @@ __export(index_exports, {
   persistCurrentRuntimeSelectionForNewJob: () => persistCurrentRuntimeSelectionForNewJob,
   pickOnchainosWin32Candidate: () => pickOnchainosWin32Candidate,
   prepareAndBindCurrentRuntimeForNewJob: () => prepareAndBindCurrentRuntimeForNewJob,
+  printDevkitUsage: () => printDevkitUsage,
   printLogsExportUsage: () => printLogsExportUsage,
   printXmtpTestUsage: () => printXmtpTestUsage,
   probeCodexAuthStatus: () => probeCodexAuthStatus,
@@ -44517,6 +44596,7 @@ __export(index_exports, {
   readLastLines: () => readLastLines,
   readParentProcessCommandForPlatform: () => readParentProcessCommandForPlatform,
   readUserAttentionWatcherEvent: () => readUserAttentionWatcherEvent,
+  redactSummary: () => redactSummary,
   refreshAgentsAndWait: () => refreshAgentsAndWait,
   refreshOnchainosVersionMetadata: () => refreshOnchainosVersionMetadata,
   registerUserAttentionWatcher: () => registerUserAttentionWatcher,
@@ -44528,6 +44608,7 @@ __export(index_exports, {
   reportUserNotificationFailure: () => reportUserNotificationFailure,
   resetMessageEligibleOfflineReplayCapabilityForTests: () => resetMessageEligibleOfflineReplayCapabilityForTests,
   resetResolvedOnchainosBinForTests: () => resetResolvedOnchainosBinForTests,
+  resetXmtpCreationCooldownForTests: () => resetXmtpCreationCooldownForTests,
   resolveAiPermissionPreset: () => resolveAiPermissionPreset,
   resolveAiProviderCommand: () => resolveAiProviderCommand,
   resolveAiProviderCommandWithSource: () => resolveAiProviderCommandWithSource,
@@ -44538,6 +44619,7 @@ __export(index_exports, {
   resolveCodexCommandSource: () => resolveCodexCommandSource,
   resolveConfiguredAiProvider: () => resolveConfiguredAiProvider,
   resolveConfiguredAiProviderForJob: () => resolveConfiguredAiProviderForJob,
+  resolveDevkitServerDbPath: () => resolveDevkitServerDbPath,
   resolveDirectCommunicationSessionTarget: () => resolveDirectCommunicationSessionTarget,
   resolveDoctorTarget: () => resolveDoctorTarget,
   resolveEnvelopePayload: () => resolveEnvelopePayload,
@@ -44575,6 +44657,7 @@ __export(index_exports, {
   startDaemonRespectingSupervisor: () => startDaemonRespectingSupervisor,
   startUserAttentionEventServer: () => startUserAttentionEventServer,
   startUserAttentionWatcherCoordinator: () => startUserAttentionWatcherCoordinator,
+  stopAndCloseXmtpClient: () => stopAndCloseXmtpClient,
   stopDaemon: () => stopDaemon,
   stopOpenClawGateway: () => stopOpenClawGateway,
   stopSystemdAutostart: () => stopSystemdAutostart,
@@ -56467,6 +56550,188 @@ function reportSessionExpired(command) {
   );
 }
 
+// ../core/src/xmtp-sdk/rate-limit-cooldown.ts
+var MAX_CAUSE_DEPTH2 = 4;
+var XMTP_CREATION_COOLDOWN_MS = 33e4;
+var RATE_LIMIT_PATTERNS = [
+  /some resource has been exhausted/i,
+  /exceeds rate limit/i,
+  /resource_exhausted/i
+];
+var KNOWN_RATE_LIMIT_ENDPOINTS = [
+  /\bGetInboxIds\b/i,
+  /\bGetIdentityUpdates\b/i
+];
+function asErrorLike2(value) {
+  return value instanceof Error ? value : void 0;
+}
+function causeChain2(err) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = err;
+  while (chain.length < MAX_CAUSE_DEPTH2) {
+    chain.push(current);
+    const errorLike = asErrorLike2(current);
+    if (!errorLike || seen.has(errorLike)) {
+      break;
+    }
+    seen.add(errorLike);
+    current = errorLike.cause;
+    if (current === void 0) {
+      break;
+    }
+  }
+  return chain;
+}
+function messageOf(node) {
+  return (node instanceof Error ? node.message : String(node)).toLowerCase();
+}
+function isXmtpRateLimitError(err) {
+  if (err === void 0 || err === null) {
+    return false;
+  }
+  const chain = causeChain2(err);
+  return chain.some(
+    (node) => RATE_LIMIT_PATTERNS.some((pattern) => pattern.test(messageOf(node)))
+  );
+}
+function extractRateLimitEndpoint(err) {
+  if (err === void 0 || err === null) {
+    return void 0;
+  }
+  const chain = causeChain2(err);
+  for (const node of chain) {
+    const message = messageOf(node);
+    for (const pattern of KNOWN_RATE_LIMIT_ENDPOINTS) {
+      const match = pattern.exec(message);
+      if (match) {
+        return /GetInboxIds/i.test(match[0]) ? "GetInboxIds" : "GetIdentityUpdates";
+      }
+    }
+  }
+  return void 0;
+}
+var XmtpCreationCooldownSkipError = class extends Error {
+  remainingMs;
+  address;
+  agentId;
+  constructor(remainingMs, address, agentId) {
+    super("xmtp creation suppressed during rate-limit cooldown");
+    this.name = "XmtpCreationCooldownSkipError";
+    this.remainingMs = remainingMs;
+    this.address = address;
+    this.agentId = agentId;
+  }
+};
+var XmtpCreationCooldown = class {
+  cooldownUntilMs = null;
+  probeInFlight = false;
+  suppressedCreateCount = 0;
+  rateLimitHitCount = 0;
+  probeCount = 0;
+  inFlightCreateCount = 0;
+  beginCreateAttempt(nowMs = Date.now()) {
+    if (this.cooldownUntilMs === null) {
+      this.inFlightCreateCount++;
+      return { allowed: true, mode: "normal" };
+    }
+    if (nowMs < this.cooldownUntilMs) {
+      this.suppressedCreateCount++;
+      return {
+        allowed: false,
+        mode: "blocked",
+        remainingMs: Math.max(0, this.cooldownUntilMs - nowMs)
+      };
+    }
+    if (this.probeInFlight) {
+      this.suppressedCreateCount++;
+      return { allowed: false, mode: "blocked", remainingMs: 0 };
+    }
+    this.probeInFlight = true;
+    this.inFlightCreateCount++;
+    this.probeCount++;
+    return { allowed: true, mode: "probe" };
+  }
+  recordCreateSuccess(decision, _nowMs = Date.now()) {
+    this.inFlightCreateCount = Math.max(0, this.inFlightCreateCount - 1);
+    if (decision.mode === "probe") {
+      this.cooldownUntilMs = null;
+      this.probeInFlight = false;
+    }
+  }
+  recordRateLimit(decision, nowMs = Date.now()) {
+    this.inFlightCreateCount = Math.max(0, this.inFlightCreateCount - 1);
+    this.cooldownUntilMs = nowMs + XMTP_CREATION_COOLDOWN_MS;
+    this.rateLimitHitCount++;
+    this.probeInFlight = false;
+    void decision;
+  }
+  recordCreateFailure(decision, nowMs = Date.now()) {
+    this.inFlightCreateCount = Math.max(0, this.inFlightCreateCount - 1);
+    if (decision.mode === "probe") {
+      this.cooldownUntilMs = nowMs + XMTP_CREATION_COOLDOWN_MS;
+      this.probeInFlight = false;
+    }
+  }
+  isCoolingDown(nowMs = Date.now()) {
+    return this.cooldownUntilMs !== null && nowMs < this.cooldownUntilMs;
+  }
+  remainingMs(nowMs = Date.now()) {
+    return this.cooldownUntilMs === null ? 0 : Math.max(0, this.cooldownUntilMs - nowMs);
+  }
+  snapshot(nowMs = Date.now()) {
+    return {
+      coolingDown: this.isCoolingDown(nowMs),
+      cooldownUntilMs: this.cooldownUntilMs,
+      remainingMs: this.remainingMs(nowMs),
+      probeInFlight: this.probeInFlight,
+      suppressedCreateCount: this.suppressedCreateCount,
+      rateLimitHitCount: this.rateLimitHitCount,
+      probeCount: this.probeCount,
+      inFlightCreateCount: this.inFlightCreateCount
+    };
+  }
+  resetForTests() {
+    this.cooldownUntilMs = null;
+    this.probeInFlight = false;
+    this.suppressedCreateCount = 0;
+    this.rateLimitHitCount = 0;
+    this.probeCount = 0;
+    this.inFlightCreateCount = 0;
+  }
+};
+var singleton;
+function getXmtpCreationCooldown() {
+  if (!singleton) {
+    singleton = new XmtpCreationCooldown();
+  }
+  return singleton;
+}
+function resetXmtpCreationCooldownForTests() {
+  getXmtpCreationCooldown().resetForTests();
+}
+
+// ../core/src/xmtp-sdk/client-lifecycle.ts
+async function stopAndCloseXmtpClient(agent, ctx) {
+  let stopped = true;
+  try {
+    await Promise.resolve(agent.stop());
+  } catch {
+    stopped = false;
+  }
+  const close2 = agent.client?.close;
+  if (typeof close2 !== "function") {
+    return { stopped, closed: false, closeFailed: false };
+  }
+  try {
+    await Promise.resolve(close2.call(agent.client));
+    return { stopped, closed: true, closeFailed: false };
+  } catch (err) {
+    ctx.onCloseError?.(err);
+    return { stopped, closed: false, closeFailed: true };
+  }
+}
+
 // ../core/src/xmtp-sdk/index.ts
 var DEFAULT_DATA_DIR = resolveA2aTaskPaths().xmtpDir;
 var XMTP_INSTALLATION_WARNING_THRESHOLD = 2;
@@ -57150,21 +57415,78 @@ var XmtpService = class _XmtpService {
   }
   async createClientForAgent(agentInfo, options = {}) {
     const address = agentInfo.communicationAddress;
-    const signer = this.tools.createSigner(agentInfo);
-    const dbPath = (inboxId2) => `${this.dataDir}/${inboxId2}-${this.env}.db3`;
-    const agent = await createAgentWithInstallationPrune(signer, {
-      dbPath,
-      env: this.env
-    }, {
-      address,
-      agentId: agentInfo.agentId,
-      logPrefix: options.logPrefix
-    });
-    const inboxId = agent.client?.inboxId ?? "";
-    logWithTimestamp(
-      `[xmtp-sdk] xmtp_client_ready agentId=${agentInfo.agentId} address=${address} inboxId=${inboxId} dbPath=${inboxId ? dbPath(inboxId) : "(unknown)"} lastSync=${formatLogTimestamp2(this.syncByAddress.get(address))}`
-    );
-    return { address, agent, agentInfo };
+    const phase = options.logPrefix ?? "[xmtp-sdk]";
+    const cooldown = getXmtpCreationCooldown();
+    const decision = cooldown.beginCreateAttempt();
+    if (!decision.allowed) {
+      logger.info(LogEvent.XMTP_RATE_LIMIT_CREATE_SUPPRESSED, {
+        onchainosAgentId: agentInfo.agentId,
+        walletAddress: address,
+        cooldownRemainingMs: String(decision.remainingMs ?? 0),
+        phase
+      });
+      throw new XmtpCreationCooldownSkipError(
+        decision.remainingMs ?? 0,
+        address,
+        agentInfo.agentId
+      );
+    }
+    if (decision.mode === "probe") {
+      logger.info(LogEvent.XMTP_RATE_LIMIT_PROBE, {
+        onchainosAgentId: agentInfo.agentId,
+        walletAddress: address,
+        phase: "probe-start",
+        probeCount: String(cooldown.snapshot().probeCount)
+      });
+    }
+    try {
+      const signer = this.tools.createSigner(agentInfo);
+      const dbPath = (inboxId2) => `${this.dataDir}/${inboxId2}-${this.env}.db3`;
+      const agent = await createAgentWithInstallationPrune(signer, {
+        dbPath,
+        env: this.env
+      }, {
+        address,
+        agentId: agentInfo.agentId,
+        logPrefix: options.logPrefix
+      });
+      cooldown.recordCreateSuccess(decision);
+      if (decision.mode === "probe") {
+        logger.info(LogEvent.XMTP_RATE_LIMIT_RECOVERED, {
+          onchainosAgentId: agentInfo.agentId,
+          walletAddress: address,
+          phase: "probe-success"
+        });
+      }
+      const inboxId = agent.client?.inboxId ?? "";
+      logWithTimestamp(
+        `[xmtp-sdk] xmtp_client_ready agentId=${agentInfo.agentId} address=${address} inboxId=${inboxId} dbPath=${inboxId ? dbPath(inboxId) : "(unknown)"} lastSync=${formatLogTimestamp2(this.syncByAddress.get(address))}`
+      );
+      return { address, agent, agentInfo };
+    } catch (err) {
+      if (isXmtpRateLimitError(err)) {
+        cooldown.recordRateLimit(decision);
+        logger.info(LogEvent.XMTP_RATE_LIMIT_COOLDOWN_STARTED, {
+          ...agentExtras({ walletAddress: address, onchainosAgentId: agentInfo.agentId }),
+          rateLimitIdentified: "true",
+          endpoint: extractRateLimitEndpoint(err) ?? "unknown",
+          cooldownMs: String(XMTP_CREATION_COOLDOWN_MS),
+          cooldownExpiresAtMs: String(cooldown.snapshot().cooldownUntilMs ?? ""),
+          inFlightCreateCount: String(cooldown.snapshot().inFlightCreateCount),
+          probe: String(decision.mode === "probe")
+        });
+      } else {
+        cooldown.recordCreateFailure(decision);
+        if (decision.mode === "probe") {
+          logger.info(LogEvent.XMTP_RATE_LIMIT_PROBE, {
+            onchainosAgentId: agentInfo.agentId,
+            walletAddress: address,
+            phase: "probe-failed-nonratelimit"
+          });
+        }
+      }
+      throw err;
+    }
   }
   async recordInstallationHealth(params) {
     const { address, agent, agentInfo, phase, attempt } = params;
@@ -57315,22 +57637,28 @@ var XmtpService = class _XmtpService {
         });
       } else {
         failedAgents.push(agents[i]);
-        logWithTimestamp(
-          `[xmtp-sdk] identity init failed: ${agents[i].communicationAddress} (agentId=${agents[i].agentId})`,
-          r.reason
-        );
-        logger.error(
-          LogEvent.XMTP_CONNECTION_FAILED,
-          r.reason instanceof Error ? r.reason : new Error(String(r.reason)),
-          {
-            walletAddress: agents[i].communicationAddress,
-            onchainosAgentId: agents[i].agentId,
-            attempt: "1"
-          }
-        );
+        if (r.reason instanceof XmtpCreationCooldownSkipError) {
+          logWithTimestamp(
+            `[xmtp-sdk] identity init suppressed (rate-limit cooldown): ${agents[i].communicationAddress} (agentId=${agents[i].agentId})`
+          );
+        } else {
+          logWithTimestamp(
+            `[xmtp-sdk] identity init failed: ${agents[i].communicationAddress} (agentId=${agents[i].agentId})`,
+            r.reason
+          );
+          logger.error(
+            LogEvent.XMTP_CONNECTION_FAILED,
+            r.reason instanceof Error ? r.reason : new Error(String(r.reason)),
+            {
+              walletAddress: agents[i].communicationAddress,
+              onchainosAgentId: agents[i].agentId,
+              attempt: "1"
+            }
+          );
+        }
       }
     }
-    if (failedAgents.length > 0) {
+    if (failedAgents.length > 0 && !getXmtpCreationCooldown().isCoolingDown()) {
       logWithTimestamp(
         `[xmtp-sdk] ${failedAgents.length} client(s) failed to initialize, retrying in 1s...`
       );
@@ -57370,6 +57698,11 @@ var XmtpService = class _XmtpService {
             phase: "init",
             attempt: "2"
           });
+        } else if (r.reason instanceof XmtpCreationCooldownSkipError) {
+          const info = failedAgents[i];
+          logWithTimestamp(
+            `[xmtp-sdk] retry suppressed (rate-limit cooldown): ${info.communicationAddress} (agentId=${info.agentId})`
+          );
         } else {
           const info = failedAgents[i];
           logWithTimestamp(
@@ -57465,7 +57798,16 @@ var XmtpService = class _XmtpService {
         try {
           this.cancelStreamRecoveryForAddress(address);
           this.stoppedAddresses.add(address.toLowerCase());
-          client.stop();
+          await stopAndCloseXmtpClient(client, {
+            address,
+            agentId: agentInfo.agentId,
+            phase: "refresh/remove",
+            onCloseError: (err) => logger.error(
+              LogEvent.XMTP_CLIENT_CLOSE_FAILED,
+              err instanceof Error ? err : new Error(String(err)),
+              { walletAddress: address, onchainosAgentId: agentInfo.agentId, phase: "refresh/remove" }
+            )
+          });
           logWithTimestamp(
             `[xmtp-sdk] refresh: stopped client: ${address} (agentId=${agentInfo.agentId})`
           );
@@ -57552,23 +57894,29 @@ var XmtpService = class _XmtpService {
           });
         } else {
           failedAgents.push(added[i]);
-          logWithTimestamp(
-            `[xmtp-sdk] refresh: identity init failed: ${added[i].communicationAddress} (agentId=${added[i].agentId})`,
-            r.reason
-          );
-          logger.error(
-            LogEvent.XMTP_CONNECTION_FAILED,
-            r.reason instanceof Error ? r.reason : new Error(String(r.reason)),
-            {
-              walletAddress: added[i].communicationAddress,
-              onchainosAgentId: added[i].agentId,
-              phase: "refresh",
-              attempt: "1"
-            }
-          );
+          if (r.reason instanceof XmtpCreationCooldownSkipError) {
+            logWithTimestamp(
+              `[xmtp-sdk] refresh: identity init suppressed (rate-limit cooldown): ${added[i].communicationAddress} (agentId=${added[i].agentId})`
+            );
+          } else {
+            logWithTimestamp(
+              `[xmtp-sdk] refresh: identity init failed: ${added[i].communicationAddress} (agentId=${added[i].agentId})`,
+              r.reason
+            );
+            logger.error(
+              LogEvent.XMTP_CONNECTION_FAILED,
+              r.reason instanceof Error ? r.reason : new Error(String(r.reason)),
+              {
+                walletAddress: added[i].communicationAddress,
+                onchainosAgentId: added[i].agentId,
+                phase: "refresh",
+                attempt: "1"
+              }
+            );
+          }
         }
       }
-      if (failedAgents.length > 0) {
+      if (failedAgents.length > 0 && !getXmtpCreationCooldown().isCoolingDown()) {
         logWithTimestamp(
           `[xmtp-sdk] refresh: ${failedAgents.length} client(s) failed to initialize, retrying in 1s...`
         );
@@ -57611,6 +57959,11 @@ var XmtpService = class _XmtpService {
               phase: "refresh",
               attempt: "2"
             });
+          } else if (r.reason instanceof XmtpCreationCooldownSkipError) {
+            const info = failedAgents[i];
+            logWithTimestamp(
+              `[xmtp-sdk] refresh: retry suppressed (rate-limit cooldown): ${info.communicationAddress} (agentId=${info.agentId})`
+            );
           } else {
             const info = failedAgents[i];
             logWithTimestamp(
@@ -57674,6 +58027,18 @@ var XmtpService = class _XmtpService {
   async recycleXmtpClients() {
     await this._backupReady;
     const startedAt = Date.now();
+    if (getXmtpCreationCooldown().isCoolingDown()) {
+      logWithTimestamp("[xmtp-sdk] recycle skipped \u2014 rate-limit cooldown active");
+      return {
+        clients: this.clients.size,
+        recycled: 0,
+        failed: 0,
+        replayed: 0,
+        skipped: 0,
+        durationMs: Date.now() - startedAt,
+        addresses: []
+      };
+    }
     const addresses = [];
     let recycled = 0;
     let failed = 0;
@@ -57692,7 +58057,16 @@ var XmtpService = class _XmtpService {
       try {
         this.cancelStreamRecoveryForAddress(address);
         this.stoppedAddresses.add(addressKey);
-        await Promise.resolve(oldClient.stop());
+        await stopAndCloseXmtpClient(oldClient, {
+          address,
+          agentId: agentInfo.agentId,
+          phase: "recycle",
+          onCloseError: (err) => logger.error(
+            LogEvent.XMTP_CLIENT_CLOSE_FAILED,
+            err instanceof Error ? err : new Error(String(err)),
+            { walletAddress: address, onchainosAgentId: agentInfo.agentId, phase: "recycle" }
+          )
+        });
         this.clients.delete(address);
         this.inboundReplayGates.delete(addressKey);
         this.replayScanFailuresByAddress.delete(addressKey);
@@ -57779,6 +58153,12 @@ var XmtpService = class _XmtpService {
             phase: "recycle/create-client"
           }
         );
+        if (isXmtpRateLimitError(err)) {
+          logWithTimestamp(
+            "[xmtp-sdk] recycle: rate-limit on recreate \u2014 stopping remaining recycles"
+          );
+          break;
+        }
       }
     }
     return {
@@ -60854,12 +61234,12 @@ var SessionBusyTracker = class {
     }
   }
 };
-var singleton = null;
+var singleton2 = null;
 function getSessionBusyTracker() {
-  if (!singleton) {
-    singleton = new SessionBusyTracker();
+  if (!singleton2) {
+    singleton2 = new SessionBusyTracker();
   }
-  return singleton;
+  return singleton2;
 }
 
 // src/openclaw-gateway.ts
@@ -61394,7 +61774,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.16",
+      version: "0.2.17-beta-ab42219842-261020165552",
       platform: "node",
       mode: "backend",
       instanceId
@@ -61405,7 +61785,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.16"}`,
+    userAgent: `okx-a2a-node/${"0.2.17-beta-ab42219842-261020165552"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -66998,8 +67378,8 @@ function isA2AEnvelope(payload) {
 
 // src/listener.ts
 init_log();
-var import_node_fs19 = require("node:fs");
-var import_promises8 = require("node:fs/promises");
+var import_node_fs20 = require("node:fs");
+var import_promises9 = require("node:fs/promises");
 var import_node_os8 = require("node:os");
 var import_node_path25 = require("node:path");
 
@@ -67110,6 +67490,398 @@ function createOnchainosSigner(agent) {
 // src/listener.ts
 init_session_store();
 
+// src/devkit-delivery.ts
+var import_node_net2 = require("node:net");
+var import_promises8 = require("node:dns/promises");
+init_sentry_logger();
+init_error_diagnostics();
+
+// src/devkit-types.ts
+var DEVKIT_MAX_CONCURRENCY = 16;
+var DEVKIT_MAX_PENDING = 256;
+var DEVKIT_MAX_PENDING_BYTES = 16 * 1024 * 1024;
+var DEVKIT_MAX_MESSAGE_BYTES = 1 * 1024 * 1024;
+var DEVKIT_REQUEST_BUDGET_MS = 5e3;
+var DEVKIT_RESPONSE_DIAGNOSTIC_MAX_BYTES = 4 * 1024;
+var DEVKIT_RESPONSE_SUMMARY_MAX_CHARS = 256;
+var DEVKIT_OUTCOME = {
+  HTTP_ACCEPTED: "http_accepted",
+  DROPPED: "dropped"
+};
+var DEVKIT_DROP_REASON = {
+  REQUEST_TOO_LARGE: "request_too_large",
+  // serialized > 1 MiB (FR-3-AC-6)
+  PENDING_OVERFLOW: "pending_overflow",
+  // > 256 items or > 16 MiB total pending (NFR-2-AC-1)
+  CONFIG_CHANGED: "config_changed",
+  // snapshot version changed/removed before send (FR-2-AC-6)
+  CONFIG_READ_FAILED: "config_read_failed",
+  // snapshot unreadable/corrupt (FR-2-AC-5)
+  HTTP_STATUS: "http_status",
+  // non-2xx response (FR-3-AC-3)
+  REDIRECT_BLOCKED: "redirect_blocked",
+  // 3xx response, not followed (NFR-3-AC-2)
+  CONNECTION_FAILED: "connection_failed",
+  // ECONNREFUSED / reset / unreachable (FR-3-AC-4)
+  TIMEOUT: "timeout",
+  // exceeded the 5 s budget (FR-3-AC-4)
+  REQUEST_BUILD_ERROR: "request_build_error",
+  // serialization / target build failure
+  RESPONSE_READ_ERROR: "response_read_error",
+  // diagnostic read failure
+  SHUTDOWN_CANCELLED: "shutdown_cancelled"
+  // daemon stopped before send (NFR-2-AC-3)
+};
+
+// src/devkit-delivery.ts
+var COMPONENT = "node_devkit";
+var SECRET_KEYS = "authorization|bearer|basic|jwt|password|api[_-]?key|secret|token";
+var SECRET_SCHEME_PATTERN = new RegExp(`\\b(?:${SECRET_KEYS})\\s+\\S+`, "gi");
+var SECRET_KV_PATTERN = new RegExp(
+  `("?)(${SECRET_KEYS})("?)\\s*([:=])\\s*"?[^"\\s,}]+`,
+  "gi"
+);
+function fallbackDeliveryId(parts) {
+  return `devkit-${parts.jobId ?? "none"}-${parts.sessionKey ?? "none"}-${parts.receivedAt}`;
+}
+function buildSessionEnvelope(ev, ctx = {}) {
+  const now = ctx.now ?? Date.now;
+  const receivedAt = Math.floor(now() / 1e3);
+  const jobId = ev.jobId ?? null;
+  const agentId = ev.agentId ?? null;
+  const deliveryId = ev.messageId ?? fallbackDeliveryId({ jobId, sessionKey: ev.sessionKey, receivedAt });
+  const messageId = ev.messageId ?? deliveryId;
+  return {
+    deliveryId,
+    receivedAt,
+    kind: "session",
+    agentId,
+    event: {
+      sessionKey: ev.sessionKey,
+      content: ev.content,
+      messageId,
+      jobId,
+      agentId
+    }
+  };
+}
+function buildJobEnvelope(ev, _ctx = {}) {
+  const sessionAgentId = ev.sessionAgentId ?? null;
+  const receivedAt = Math.floor(ev.message.receivedAtMs / 1e3);
+  return {
+    deliveryId: ev.message.id,
+    receivedAt,
+    kind: "job",
+    agentId: sessionAgentId,
+    event: {
+      jobId: ev.jobId,
+      sessionAgentId,
+      message: {
+        ...ev.message,
+        content: ev.message.rawText
+      }
+    }
+  };
+}
+function classifyHttpOutcome(status) {
+  if (status >= 200 && status < 300) {
+    return { outcome: DEVKIT_OUTCOME.HTTP_ACCEPTED };
+  }
+  if (status >= 300 && status < 400) {
+    return { outcome: DEVKIT_OUTCOME.DROPPED, reason: DEVKIT_DROP_REASON.REDIRECT_BLOCKED };
+  }
+  return { outcome: DEVKIT_OUTCOME.DROPPED, reason: DEVKIT_DROP_REASON.HTTP_STATUS };
+}
+function classifyFetchFailure(params) {
+  if (params.cancelledByShutdown) {
+    return DEVKIT_DROP_REASON.SHUTDOWN_CANCELLED;
+  }
+  if (params.timedOut || params.errorCategory === "timeout") {
+    return DEVKIT_DROP_REASON.TIMEOUT;
+  }
+  return DEVKIT_DROP_REASON.CONNECTION_FAILED;
+}
+function redactSummary(raw) {
+  const collapsed = raw.replace(/\s+/g, " ").trim();
+  const redacted = collapsed.replace(SECRET_SCHEME_PATTERN, "[REDACTED]").replace(
+    SECRET_KV_PATTERN,
+    (_match, keyQuote, key, keyQuoteClose, sep3) => `${keyQuote}${key}${keyQuoteClose}${sep3}[REDACTED]`
+  );
+  const truncated = redacted.length > DEVKIT_RESPONSE_SUMMARY_MAX_CHARS;
+  return { text: redacted.slice(0, DEVKIT_RESPONSE_SUMMARY_MAX_CHARS), truncated };
+}
+async function readRedactedResponse(response) {
+  let bodyText;
+  try {
+    bodyText = await response.text();
+  } catch {
+    return { responseBytesRead: 0, responseTruncated: false, responseSummary: "" };
+  }
+  const bytes = Buffer.from(bodyText, "utf8");
+  const diagnosticSlice = bytes.subarray(0, DEVKIT_RESPONSE_DIAGNOSTIC_MAX_BYTES);
+  const sliceTruncated = bytes.byteLength > DEVKIT_RESPONSE_DIAGNOSTIC_MAX_BYTES;
+  const summary = redactSummary(diagnosticSlice.toString("utf8"));
+  return {
+    responseBytesRead: diagnosticSlice.byteLength,
+    responseTruncated: sliceTruncated || summary.truncated,
+    responseSummary: summary.text
+  };
+}
+async function isLoopbackTarget(origin) {
+  let hostname;
+  try {
+    hostname = new URL(origin).hostname;
+  } catch {
+    return false;
+  }
+  const version3 = (0, import_node_net2.isIP)(hostname);
+  if (version3 === 4) {
+    return hostname.startsWith("127.");
+  }
+  if (version3 === 6) {
+    return hostname === "::1";
+  }
+  if (hostname.toLowerCase() !== "localhost") {
+    return false;
+  }
+  try {
+    const resolved = await (0, import_promises8.lookup)(hostname);
+    return resolved.family === 4 ? resolved.address.startsWith("127.") : resolved.address === "::1";
+  } catch {
+    return false;
+  }
+}
+function orderingKeyFor(envelope) {
+  if (envelope.kind === "session") {
+    return `session:${envelope.event.sessionKey}`;
+  }
+  return `job:${envelope.event.jobId}`;
+}
+function sleep4(ms) {
+  return new Promise((resolve11) => setTimeout(resolve11, Math.max(0, ms)));
+}
+var DevkitDeliveryDispatcher = class {
+  readSnapshot;
+  now;
+  fetchImpl;
+  pendingQueue = [];
+  pendingBytes = 0;
+  activeKeys = /* @__PURE__ */ new Set();
+  inFlight = /* @__PURE__ */ new Set();
+  activeControllers = /* @__PURE__ */ new Map();
+  shuttingDown = false;
+  constructor(options) {
+    this.readSnapshot = options.readSnapshot;
+    this.now = options.now ?? Date.now;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  enqueue(input) {
+    const serialized = JSON.stringify(input.envelope);
+    const bytes = Buffer.byteLength(serialized, "utf8");
+    const kind = input.envelope.kind;
+    const deliveryId = input.envelope.deliveryId;
+    if (bytes > DEVKIT_MAX_MESSAGE_BYTES) {
+      this.emitDropped({ deliveryId, kind, reason: DEVKIT_DROP_REASON.REQUEST_TOO_LARGE, durationMs: 0 });
+      return true;
+    }
+    if (this.pendingQueue.length >= DEVKIT_MAX_PENDING || this.pendingBytes + bytes > DEVKIT_MAX_PENDING_BYTES) {
+      this.emitDropped({ deliveryId, kind, reason: DEVKIT_DROP_REASON.PENDING_OVERFLOW, durationMs: 0 });
+      return false;
+    }
+    this.pendingQueue.push({
+      envelope: input.envelope,
+      config: input.config,
+      serialized,
+      bytes,
+      cancelledByShutdown: false,
+      timedOut: false
+    });
+    this.pendingBytes += bytes;
+    logger.info(LogEvent.DEVKIT_DELIVERY_ACCEPTED, {
+      component: COMPONENT,
+      deliveryId,
+      kind,
+      agentId: input.envelope.agentId ?? void 0
+    });
+    this.pump();
+    return true;
+  }
+  pump() {
+    if (this.shuttingDown) {
+      return;
+    }
+    while (this.activeKeys.size < DEVKIT_MAX_CONCURRENCY) {
+      const index2 = this.pendingQueue.findIndex((item2) => !this.activeKeys.has(orderingKeyFor(item2.envelope)));
+      if (index2 === -1) {
+        break;
+      }
+      const [item] = this.pendingQueue.splice(index2, 1);
+      this.pendingBytes -= item.bytes;
+      const key = orderingKeyFor(item.envelope);
+      this.activeKeys.add(key);
+      const promise = this.send(item).finally(() => {
+        this.activeKeys.delete(key);
+        this.inFlight.delete(promise);
+        this.pump();
+      });
+      this.inFlight.add(promise);
+    }
+  }
+  async send(item) {
+    const startedAt = this.now();
+    const { envelope } = item;
+    let snapshot;
+    try {
+      snapshot = this.readSnapshot();
+    } catch {
+      this.emitDropped({
+        deliveryId: envelope.deliveryId,
+        kind: envelope.kind,
+        reason: DEVKIT_DROP_REASON.CONFIG_READ_FAILED,
+        durationMs: this.now() - startedAt
+      });
+      return;
+    }
+    if (snapshot?.configVersion !== item.config.configVersion) {
+      this.emitDropped({
+        deliveryId: envelope.deliveryId,
+        kind: envelope.kind,
+        reason: DEVKIT_DROP_REASON.CONFIG_CHANGED,
+        durationMs: this.now() - startedAt
+      });
+      return;
+    }
+    const loopbackOk = await isLoopbackTarget(snapshot.origin);
+    if (!loopbackOk) {
+      this.emitHttpFailed(
+        item,
+        DEVKIT_DROP_REASON.CONNECTION_FAILED,
+        { errorCategory: "network_unavailable" },
+        this.now() - startedAt
+      );
+      return;
+    }
+    const url = `${snapshot.origin}:${snapshot.port}${snapshot.eventPath}`;
+    const controller = new AbortController();
+    this.activeControllers.set(item, controller);
+    const timeoutTimer = setTimeout(() => {
+      item.timedOut = true;
+      controller.abort();
+    }, DEVKIT_REQUEST_BUDGET_MS);
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: item.serialized,
+        redirect: "manual",
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timeoutTimer);
+      this.activeControllers.delete(item);
+      const durationMs2 = this.now() - startedAt;
+      if (item.cancelledByShutdown) {
+        this.emitCancelled(item, durationMs2);
+        return;
+      }
+      const diagnostics = buildErrorDiagnostics(
+        LogEvent.DEVKIT_DELIVERY_HTTP_FAILED,
+        err instanceof Error ? err : void 0,
+        {}
+      );
+      const reason = classifyFetchFailure({
+        cancelledByShutdown: item.cancelledByShutdown,
+        timedOut: item.timedOut,
+        errorCategory: diagnostics.errorCategory
+      });
+      this.emitHttpFailed(item, reason, diagnostics, durationMs2, err instanceof Error ? err : void 0);
+      return;
+    }
+    clearTimeout(timeoutTimer);
+    this.activeControllers.delete(item);
+    const durationMs = this.now() - startedAt;
+    if (item.cancelledByShutdown) {
+      this.emitCancelled(item, durationMs);
+      return;
+    }
+    const status = response.status;
+    const classified = classifyHttpOutcome(status);
+    if (classified.outcome === DEVKIT_OUTCOME.HTTP_ACCEPTED) {
+      logger.info(LogEvent.DEVKIT_DELIVERY_HTTP_ACCEPTED, {
+        component: COMPONENT,
+        deliveryId: envelope.deliveryId,
+        kind: envelope.kind,
+        statusCode: status,
+        durationMs
+      });
+      return;
+    }
+    const redaction = await readRedactedResponse(response);
+    this.emitDropped({
+      deliveryId: envelope.deliveryId,
+      kind: envelope.kind,
+      reason: classified.reason,
+      statusCode: status,
+      durationMs,
+      ...redaction
+    });
+  }
+  async shutdown(deadlineMs) {
+    this.shuttingDown = true;
+    const deadline = this.now() + Math.max(0, deadlineMs);
+    if (this.inFlight.size > 0) {
+      const remaining = Math.max(0, deadline - this.now());
+      await Promise.race([Promise.allSettled(Array.from(this.inFlight)), sleep4(remaining)]);
+    }
+    for (const [item, controller] of this.activeControllers) {
+      item.cancelledByShutdown = true;
+      controller.abort();
+    }
+    const stillPending = this.pendingQueue.splice(0, this.pendingQueue.length);
+    this.pendingBytes = 0;
+    for (const item of stillPending) {
+      this.emitCancelled(item, 0);
+    }
+  }
+  emitDropped(params) {
+    logger.info(LogEvent.DEVKIT_DELIVERY_DROPPED, {
+      component: COMPONENT,
+      outcome: DEVKIT_OUTCOME.DROPPED,
+      deliveryId: params.deliveryId,
+      kind: params.kind,
+      reason: params.reason,
+      durationMs: params.durationMs,
+      ...params.statusCode !== void 0 ? { statusCode: params.statusCode } : {},
+      ...params.responseBytesRead !== void 0 ? { responseBytesRead: params.responseBytesRead } : {},
+      ...params.responseTruncated !== void 0 ? { responseTruncated: params.responseTruncated } : {},
+      ...params.responseSummary !== void 0 ? { responseSummary: params.responseSummary } : {}
+    });
+  }
+  emitHttpFailed(item, reason, diagnostics, durationMs, err) {
+    logger.error(LogEvent.DEVKIT_DELIVERY_HTTP_FAILED, err, {
+      component: COMPONENT,
+      outcome: DEVKIT_OUTCOME.DROPPED,
+      deliveryId: item.envelope.deliveryId,
+      kind: item.envelope.kind,
+      reason,
+      durationMs,
+      ...diagnostics.errorCategory ? { errorCategory: diagnostics.errorCategory } : {},
+      ...diagnostics.errorCode ? { errorCode: diagnostics.errorCode } : {}
+    });
+  }
+  emitCancelled(item, durationMs) {
+    logger.info(LogEvent.DEVKIT_DELIVERY_CANCELLED, {
+      component: COMPONENT,
+      outcome: DEVKIT_OUTCOME.DROPPED,
+      deliveryId: item.envelope.deliveryId,
+      kind: item.envelope.kind,
+      reason: DEVKIT_DROP_REASON.SHUTDOWN_CANCELLED,
+      durationMs
+    });
+  }
+};
+
 // src/ai-dispatch-queue.ts
 async function enqueueAiJobMessageDispatch(params) {
   const commands = params.commands ?? new CommandStore(params.homeDir);
@@ -67135,6 +67907,381 @@ async function enqueueAiSessionMessageDispatch(params) {
   return command;
 }
 
+// src/devkit-router.ts
+init_sentry_logger();
+function createDevkitAutoRouter(deps) {
+  const { commands, dispatcher, readSnapshot } = deps;
+  function readConfigOrNull(phase) {
+    try {
+      return { ok: true, config: readSnapshot() };
+    } catch (err) {
+      logger.error(
+        LogEvent.DEVKIT_ROUTE_CONFIG_READ_FAILED,
+        err instanceof Error ? err : new Error(String(err)),
+        {
+          component: "node_devkit",
+          phase,
+          outcome: "dropped",
+          reason: "config_read_failed"
+        }
+      );
+      return { ok: false };
+    }
+  }
+  async function routeSession(event) {
+    const read = readConfigOrNull("session");
+    if (!read.ok) {
+      return;
+    }
+    if (read.config === null) {
+      await enqueueAiSessionMessageDispatch({ commands, event });
+      logger.info(LogEvent.DEVKIT_ROUTE_DEFAULT_AI, {
+        component: "node_devkit",
+        phase: "session",
+        kind: "session",
+        messageId: event.messageId ?? "",
+        jobId: event.jobId ?? "",
+        agentId: event.agentId ?? ""
+      });
+      return;
+    }
+    const config = read.config;
+    const envelope = buildSessionEnvelope(event);
+    dispatcher.enqueue({ envelope, config });
+    logger.info(LogEvent.DEVKIT_ROUTE_CUSTOM_SERVER, {
+      component: "node_devkit",
+      phase: "session",
+      kind: "session",
+      deliveryId: envelope.deliveryId,
+      messageId: event.messageId ?? "",
+      jobId: event.jobId ?? "",
+      agentId: event.agentId ?? ""
+    });
+  }
+  async function routeJob(event) {
+    const read = readConfigOrNull("job");
+    if (!read.ok) {
+      return;
+    }
+    if (read.config === null) {
+      await enqueueAiJobMessageDispatch({ commands, event });
+      logger.info(LogEvent.DEVKIT_ROUTE_DEFAULT_AI, {
+        component: "node_devkit",
+        phase: "job",
+        kind: "job",
+        jobId: event.jobId,
+        agentId: event.sessionAgentId ?? ""
+      });
+      return;
+    }
+    const config = read.config;
+    const envelope = buildJobEnvelope(event);
+    dispatcher.enqueue({ envelope, config });
+    logger.info(LogEvent.DEVKIT_ROUTE_CUSTOM_SERVER, {
+      component: "node_devkit",
+      phase: "job",
+      kind: "job",
+      deliveryId: envelope.deliveryId,
+      jobId: event.jobId,
+      agentId: event.sessionAgentId ?? ""
+    });
+  }
+  return { routeJob, routeSession };
+}
+
+// src/devkit-server-store.ts
+var import_node_fs19 = require("node:fs");
+init_paths();
+init_session_store();
+var { DatabaseSync: DatabaseSync4 } = loadSqlite4();
+var DEVKIT_SERVER_APPLICATION_ID = 1329677395;
+var DEVKIT_SERVER_SCHEMA_VERSION = 1;
+var TABLE_NAME = `"devkit-server"`;
+var WRITE_RETRY_ATTEMPTS = 6;
+var DevkitServerStoreError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "DevkitServerStoreError";
+    this.code = code;
+  }
+};
+function resolveDevkitServerDbPath(homeDir) {
+  return resolveTaskPaths(homeDir).devkitServerDbPath;
+}
+function devkitServerDbExists(homeDir) {
+  return (0, import_node_fs19.existsSync)(resolveDevkitServerDbPath(homeDir));
+}
+var DevkitServerStore = class _DevkitServerStore {
+  dbPath;
+  db;
+  constructor(dbPath, db) {
+    this.dbPath = dbPath;
+    this.db = db;
+  }
+  static openForWrite(homeDir) {
+    const paths = resolveTaskPaths(homeDir);
+    const dbPath = paths.devkitServerDbPath;
+    assertNotSymlink(paths.sqliteDir, "devkit server directory");
+    ensureTaskDir(paths.sqliteDir);
+    assertNotSymlink(paths.sqliteDir, "devkit server directory");
+    assertSafeDatabasePath(dbPath);
+    const db = new DatabaseSync4(dbPath);
+    const store = new _DevkitServerStore(dbPath, db);
+    try {
+      store.configureConnectionForWrite();
+      store.ensureSchemaForWrite();
+      return store;
+    } catch (error) {
+      db.close();
+      throw error;
+    }
+  }
+  static openForRead(homeDir) {
+    const dbPath = resolveDevkitServerDbPath(homeDir);
+    if (!(0, import_node_fs19.existsSync)(dbPath)) {
+      return null;
+    }
+    assertSafeDatabaseFile(dbPath);
+    const db = new DatabaseSync4(dbPath, { readOnly: true });
+    const store = new _DevkitServerStore(dbPath, db);
+    try {
+      db.exec("PRAGMA query_only=ON");
+      store.assertReadableSchema();
+      return store;
+    } catch (error) {
+      db.close();
+      throw error;
+    }
+  }
+  close() {
+    this.db.close();
+  }
+  register(input) {
+    return this.withWriteTransaction(() => {
+      const existing = this.db.prepare(`SELECT config_version FROM ${TABLE_NAME} WHERE id = 1`).get();
+      const configVersion = (existing?.config_version ?? 0) + 1;
+      const updatedAt = Date.now();
+      this.db.prepare(`
+          INSERT INTO ${TABLE_NAME} (
+            id, origin, port, event_path, health_path, config_version, updated_at
+          ) VALUES (1, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(id) DO UPDATE SET
+            origin = excluded.origin,
+            port = excluded.port,
+            event_path = excluded.event_path,
+            health_path = excluded.health_path,
+            config_version = excluded.config_version,
+            updated_at = excluded.updated_at
+        `).run(input.origin, input.port, input.eventPath, input.healthPath, configVersion, updatedAt);
+      return {
+        origin: input.origin,
+        port: input.port,
+        eventPath: input.eventPath,
+        healthPath: input.healthPath,
+        configVersion,
+        updatedAt
+      };
+    });
+  }
+  unregister() {
+    return this.withWriteTransaction(() => {
+      const result = this.db.prepare(`DELETE FROM ${TABLE_NAME} WHERE id = 1`).run();
+      return { removed: Number(result.changes) > 0 };
+    });
+  }
+  readSnapshot() {
+    let row;
+    try {
+      row = this.db.prepare(`
+          SELECT origin, port, event_path, health_path, config_version, updated_at
+          FROM ${TABLE_NAME} WHERE id = 1
+        `).get();
+    } catch (error) {
+      throw new DevkitServerStoreError(
+        "DATABASE_READ_FAILED",
+        `failed to read devkit server config: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (!row) {
+      return null;
+    }
+    return {
+      origin: row.origin,
+      port: row.port,
+      eventPath: row.event_path,
+      healthPath: row.health_path,
+      configVersion: row.config_version,
+      updatedAt: row.updated_at
+    };
+  }
+  configureConnectionForWrite() {
+    this.db.exec("PRAGMA busy_timeout=5000");
+  }
+  ensureSchemaForWrite() {
+    withBusyRetry(() => {
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const applicationId = readPragmaNumber(this.db, "application_id");
+        const userVersion = readPragmaNumber(this.db, "user_version");
+        const hasTables = Boolean(
+          this.db.prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' LIMIT 1").get()
+        );
+        if (applicationId === 0 && !hasTables && userVersion === 0) {
+          this.db.exec(`PRAGMA application_id=${DEVKIT_SERVER_APPLICATION_ID}`);
+        } else if (applicationId !== DEVKIT_SERVER_APPLICATION_ID) {
+          throw new DevkitServerStoreError(
+            "DATABASE_IDENTITY_MISMATCH",
+            "devkit server database identity does not match"
+          );
+        }
+        if (userVersion > DEVKIT_SERVER_SCHEMA_VERSION) {
+          throw new DevkitServerStoreError(
+            "DATABASE_SCHEMA_TOO_NEW",
+            `devkit server schema version ${userVersion} is newer than supported ${DEVKIT_SERVER_SCHEMA_VERSION}`
+          );
+        }
+        if (userVersion < 1) {
+          applyMigrationV1(this.db);
+          this.db.exec("PRAGMA user_version=1");
+        }
+        this.db.exec("COMMIT");
+      } catch (error) {
+        rollbackQuietly(this.db);
+        throw error;
+      }
+    });
+    withBusyRetry(() => {
+      this.db.exec("PRAGMA journal_mode=WAL");
+      this.db.exec("PRAGMA synchronous=FULL");
+    });
+  }
+  assertReadableSchema() {
+    const applicationId = readPragmaNumber(this.db, "application_id");
+    if (applicationId !== DEVKIT_SERVER_APPLICATION_ID) {
+      throw new DevkitServerStoreError(
+        "DATABASE_IDENTITY_MISMATCH",
+        "devkit server database identity does not match"
+      );
+    }
+    const userVersion = readPragmaNumber(this.db, "user_version");
+    if (userVersion > DEVKIT_SERVER_SCHEMA_VERSION) {
+      throw new DevkitServerStoreError(
+        "DATABASE_SCHEMA_TOO_NEW",
+        `devkit server schema version ${userVersion} is newer than supported ${DEVKIT_SERVER_SCHEMA_VERSION}`
+      );
+    }
+    if (userVersion < DEVKIT_SERVER_SCHEMA_VERSION) {
+      throw new DevkitServerStoreError(
+        "DATABASE_MIGRATION_REQUIRED",
+        "devkit server database requires a write command to finish migration"
+      );
+    }
+  }
+  withWriteTransaction(operation) {
+    return withBusyRetry(() => {
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = operation();
+        this.db.exec("COMMIT");
+        return result;
+      } catch (error) {
+        rollbackQuietly(this.db);
+        throw error;
+      }
+    });
+  }
+};
+function applyMigrationV1(db) {
+  db.exec(`
+    CREATE TABLE ${TABLE_NAME} (
+      id INTEGER PRIMARY KEY CHECK (id = 1),
+      origin TEXT NOT NULL,
+      port INTEGER NOT NULL CHECK (port >= 1 AND port <= 65535),
+      event_path TEXT NOT NULL,
+      health_path TEXT NOT NULL,
+      config_version INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      CHECK (length(origin) > 0),
+      CHECK (substr(event_path,1,1) = '/'),
+      CHECK (substr(health_path,1,1) = '/')
+    )
+  `);
+}
+function readPragmaNumber(db, name) {
+  const row = db.prepare(`PRAGMA ${name}`).get();
+  return Number(row[name] ?? 0);
+}
+function assertNotSymlink(path2, label) {
+  if (!(0, import_node_fs19.existsSync)(path2)) {
+    return;
+  }
+  if ((0, import_node_fs19.lstatSync)(path2).isSymbolicLink()) {
+    throw new DevkitServerStoreError("DATABASE_PATH_UNSAFE", `${label} must not be a symbolic link`);
+  }
+}
+function assertSafeDatabasePath(dbPath) {
+  assertSafeDatabaseFile(dbPath);
+  for (const suffix of ["-journal", "-wal", "-shm"]) {
+    assertNotSymlink(`${dbPath}${suffix}`, `devkit server database sidecar ${suffix}`);
+  }
+}
+function assertSafeDatabaseFile(dbPath) {
+  if (!(0, import_node_fs19.existsSync)(dbPath)) {
+    return;
+  }
+  const stat4 = (0, import_node_fs19.lstatSync)(dbPath);
+  if (stat4.isSymbolicLink()) {
+    throw new DevkitServerStoreError(
+      "DATABASE_PATH_UNSAFE",
+      "devkit server database must not be a symbolic link"
+    );
+  }
+  if (!stat4.isFile() || stat4.nlink !== 1) {
+    throw new DevkitServerStoreError(
+      "DATABASE_PATH_UNSAFE",
+      "devkit server database must be a regular file with one hard link"
+    );
+  }
+}
+function rollbackQuietly(db) {
+  try {
+    db.exec("ROLLBACK");
+  } catch {
+  }
+}
+function withBusyRetry(operation) {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return operation();
+    } catch (error) {
+      if (!isSqliteBusyError(error) || attempt >= WRITE_RETRY_ATTEMPTS) {
+        throw error;
+      }
+      sleepSyncMs2(Math.min(100 * 2 ** (attempt - 1), 1600));
+    }
+  }
+}
+function sleepSyncMs2(ms) {
+  const buffer2 = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(buffer2, 0, 0, ms);
+}
+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/listener.ts
 init_paths();
 
@@ -67509,13 +68656,13 @@ async function getHermesGatewayPluginStatus(options = {}) {
   const env = options.env ?? process.env;
   const hermesHome = env.HERMES_HOME?.trim() || (0, import_node_path25.join)((0, import_node_os8.homedir)(), ".hermes");
   const pluginYamlPath = (0, import_node_path25.join)(hermesHome, "plugins", "platforms", "okx-a2a", "plugin.yaml");
-  if (!(0, import_node_fs19.existsSync)(pluginYamlPath)) {
+  if (!(0, import_node_fs20.existsSync)(pluginYamlPath)) {
     return { enabled: false, reason: "plugin_yaml_missing", hermesHome, checkedPath: pluginYamlPath };
   }
   const configPath = (0, import_node_path25.join)(hermesHome, "config.yaml");
   let content;
   try {
-    content = await (0, import_promises8.readFile)(configPath, "utf8");
+    content = await (0, import_promises9.readFile)(configPath, "utf8");
   } catch {
     return { enabled: false, reason: "config_read_error", hermesHome, checkedPath: configPath };
   }
@@ -67600,12 +68747,12 @@ function parseYamlInlineEnabledList(line) {
 var SHUTDOWN_FORCE_RESOLVE_MS = 5e3;
 function stopClients(service) {
   for (const [address, client] of service.getClients()) {
-    try {
-      client.stop();
-      logWithTimestamp(`[okx-agent-task] stopped XMTP client ${address}`);
-    } catch (err) {
-      logWithTimestamp(`[okx-agent-task] failed to stop XMTP client ${address}:`, err);
-    }
+    void stopAndCloseXmtpClient(client, {
+      address,
+      agentId: "",
+      phase: "shutdown",
+      onCloseError: (err) => logWithTimestamp(`[okx-agent-task] failed to close XMTP client ${address}:`, err)
+    }).then(() => logWithTimestamp(`[okx-agent-task] stopped XMTP client ${address}`)).catch((err) => logWithTimestamp(`[okx-agent-task] failed to stop XMTP client ${address}:`, err));
   }
 }
 async function runListener(options = {}) {
@@ -67637,6 +68784,27 @@ async function runListenerWithLock(options, paths) {
   const store = new TaskMessageStore(options.homeDir);
   const sessionStore = new SessionStore({ homeDir: options.homeDir });
   const commands = new CommandStore(options.homeDir);
+  const devkitReadSnapshot = () => {
+    const snapshotStore = DevkitServerStore.openForRead(options.homeDir);
+    if (!snapshotStore) {
+      return null;
+    }
+    try {
+      return snapshotStore.readSnapshot();
+    } finally {
+      snapshotStore.close();
+    }
+  };
+  const devkitDispatcher = new DevkitDeliveryDispatcher({
+    homeDir: options.homeDir,
+    readSnapshot: devkitReadSnapshot
+  });
+  const devkitRouter = createDevkitAutoRouter({
+    homeDir: options.homeDir,
+    commands,
+    dispatcher: devkitDispatcher,
+    readSnapshot: devkitReadSnapshot
+  });
   await store.ensureReady();
   let userAttentionEvents = null;
   try {
@@ -67700,20 +68868,20 @@ async function runListenerWithLock(options, paths) {
     createInboundMiddleware: (deps) => createMiddlewareFromCoreDeps(store, deps, {
       sessionStore,
       onJobMessageStored: async (event) => {
-        await enqueueAiJobMessageDispatch({ commands, event });
+        await devkitRouter.routeJob(event);
       },
       onSessionMessage: async (event) => {
-        await enqueueAiSessionMessageDispatch({ commands, event });
+        await devkitRouter.routeSession(event);
       }
     }),
     processOfflineMessage: (ctx, deps, replayOptions) => processOfflineFromCoreDeps(store, ctx, deps, {
       ...replayOptions,
       sessionStore,
       onJobMessageStored: async (event) => {
-        await enqueueAiJobMessageDispatch({ commands, event });
+        await devkitRouter.routeJob(event);
       },
       onSessionMessage: async (event) => {
-        await enqueueAiSessionMessageDispatch({ commands, event });
+        await devkitRouter.routeSession(event);
       }
     }),
     notifySessionExpired: (command) => {
@@ -67745,12 +68913,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.16");
+  service.setPluginVersion("0.2.17-beta-ab42219842-261020165552");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.16"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.17-beta-ab42219842-261020165552"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -67778,7 +68946,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.16"
+      pluginVersion: "0.2.17-beta-ab42219842-261020165552"
     });
   }
   logWithTimestamp(
@@ -68110,6 +69278,7 @@ async function runListenerWithLock(options, paths) {
           logWithTimestamp("[okx-agent-task] failed to close user_attention IPC wake:", err);
         }
         stopClients(service);
+        await devkitDispatcher.shutdown(SHUTDOWN_FORCE_RESOLVE_MS);
         sessionStore.close();
         clearTimeout(forceResolve);
         resolve11();
@@ -68132,14 +69301,375 @@ async function timeSettled(fn) {
 // src/index.ts
 init_paths();
 
+// src/devkit-cli.ts
+var import_node_crypto14 = require("node:crypto");
+init_daemon();
+init_sentry_logger();
+var DAEMON_NOT_RUNNING_MESSAGE = "\u5F53\u524D daemon \u672A\u8FD0\u884C,\u8BF7\u4F7F\u7528 okx-a2a start \u542F\u52A8 daemon";
+var DAEMON_STATUS_UNKNOWN_MESSAGE = "\u914D\u7F6E\u5DF2\u5199\u5165,\u4F46\u65E0\u6CD5\u786E\u8BA4 daemon \u8FD0\u884C\u72B6\u6001";
+var LOOPBACK_IPV4_PATTERN = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+var DevkitCliError = class extends Error {
+  field;
+  constructor(field, reason) {
+    super(reason);
+    this.name = "DevkitCliError";
+    this.field = field;
+  }
+  toValidationError() {
+    return { field: this.field, reason: this.message };
+  }
+};
+async function handleDevkitCommand(args) {
+  const wantsJson = args.includes("--json");
+  const subcommand = args[0];
+  if (!subcommand || isHelpArg(subcommand)) {
+    printDevkitUsage();
+    return;
+  }
+  if (args.slice(1).some(isHelpArg)) {
+    printDevkitUsage();
+    return;
+  }
+  if (subcommand === "register") {
+    await handleRegister(args.slice(1), wantsJson);
+    return;
+  }
+  if (subcommand === "unregister") {
+    await handleUnregister(args.slice(1), wantsJson);
+    return;
+  }
+  outputError(wantsJson, { field: "command", reason: `unknown devkit command: ${subcommand}` });
+  process.exitCode = 1;
+}
+function printDevkitUsage() {
+  console.log(`Usage: okx-a2a devkit <register|unregister> [options]
+
+Commands:
+  register    Register a local custom server for daemon auto-message delivery.
+              --url <origin> --port <n> --paths '{"event":"/path","health":"/path"}'
+  unregister  Remove the registered custom server; daemon reverts to default AI delivery.
+
+Options:
+  --json      Print machine-readable output.`);
+}
+async function handleRegister(args, wantsJson) {
+  const operationId = (0, import_node_crypto14.randomUUID)();
+  const startedAt = Date.now();
+  logger.info(LogEvent.DEVKIT_REGISTER_REQUESTED, devkitSentryExtra({ operationId, phase: "requested" }));
+  try {
+    const parsed = parseArgs(args, { options: /* @__PURE__ */ new Set(["url", "port", "paths"]), flags: /* @__PURE__ */ new Set(["json"]) });
+    const origin = validateUrl(requireOption(parsed, "url"));
+    const port = validatePort(requireOption(parsed, "port"));
+    const { eventPath, healthPath } = validatePaths(requireOption(parsed, "paths"));
+    let config;
+    try {
+      const store = DevkitServerStore.openForWrite();
+      try {
+        config = store.register({ origin, port, eventPath, healthPath });
+      } finally {
+        store.close();
+      }
+    } catch (error) {
+      logger.error(
+        LogEvent.DEVKIT_CONFIG_PERSIST_FAILED,
+        error instanceof Error ? error : new Error(String(error)),
+        devkitSentryExtra({ operationId, phase: "persist_failed", durationMs: Date.now() - startedAt })
+      );
+      outputError(wantsJson, {
+        field: "config",
+        reason: error instanceof DevkitServerStoreError ? error.message : "failed to persist devkit configuration"
+      });
+      process.exitCode = 1;
+      return;
+    }
+    const outcome = config.configVersion === 1 ? "created" : "replaced";
+    const { daemonRunning, warning } = await resolveDaemonStatus(operationId);
+    logger.info(
+      LogEvent.DEVKIT_REGISTER_COMPLETED,
+      devkitSentryExtra({
+        operationId,
+        phase: "completed",
+        outcome,
+        registrationId: String(config.configVersion),
+        daemonRunning: String(daemonRunning),
+        durationMs: Date.now() - startedAt
+      })
+    );
+    outputSuccess(wantsJson, { daemonRunning, warning, configVersion: config.configVersion });
+  } catch (error) {
+    const detail = normalizeError(error);
+    logger.error(
+      LogEvent.DEVKIT_REGISTER_REJECTED,
+      error instanceof Error ? error : new Error(String(error)),
+      devkitSentryExtra({ operationId, phase: "rejected", reason: detail.field, durationMs: Date.now() - startedAt })
+    );
+    outputError(wantsJson, detail);
+    process.exitCode = 1;
+  }
+}
+async function handleUnregister(args, wantsJson) {
+  const operationId = (0, import_node_crypto14.randomUUID)();
+  const startedAt = Date.now();
+  logger.info(LogEvent.DEVKIT_UNREGISTER_REQUESTED, devkitSentryExtra({ operationId, phase: "requested" }));
+  try {
+    parseArgs(args, { options: /* @__PURE__ */ new Set(), flags: /* @__PURE__ */ new Set(["json"]) });
+    let removed;
+    try {
+      const store = DevkitServerStore.openForWrite();
+      try {
+        removed = store.unregister().removed;
+      } finally {
+        store.close();
+      }
+    } catch (error) {
+      logger.error(
+        LogEvent.DEVKIT_CONFIG_PERSIST_FAILED,
+        error instanceof Error ? error : new Error(String(error)),
+        devkitSentryExtra({ operationId, phase: "persist_failed", durationMs: Date.now() - startedAt })
+      );
+      outputError(wantsJson, {
+        field: "config",
+        reason: error instanceof DevkitServerStoreError ? error.message : "failed to persist devkit configuration"
+      });
+      process.exitCode = 1;
+      return;
+    }
+    const outcome = removed ? "removed" : "noop";
+    const { daemonRunning, warning } = await resolveDaemonStatus(operationId);
+    logger.info(
+      LogEvent.DEVKIT_UNREGISTER_COMPLETED,
+      devkitSentryExtra({
+        operationId,
+        phase: "completed",
+        outcome,
+        daemonRunning: String(daemonRunning),
+        durationMs: Date.now() - startedAt
+      })
+    );
+    outputSuccess(wantsJson, { daemonRunning, warning });
+  } catch (error) {
+    const detail = normalizeError(error);
+    logger.error(
+      LogEvent.DEVKIT_REGISTER_REJECTED,
+      error instanceof Error ? error : new Error(String(error)),
+      devkitSentryExtra({ operationId, phase: "rejected", reason: detail.field, durationMs: Date.now() - startedAt })
+    );
+    outputError(wantsJson, detail);
+    process.exitCode = 1;
+  }
+}
+async function resolveDaemonStatus(operationId) {
+  try {
+    const status = await getDaemonStatus();
+    if (status.running) {
+      return { daemonRunning: true };
+    }
+    return {
+      daemonRunning: false,
+      warning: { code: "DAEMON_NOT_RUNNING", message: DAEMON_NOT_RUNNING_MESSAGE }
+    };
+  } catch {
+    logger.info(LogEvent.DEVKIT_DAEMON_STATUS_UNKNOWN, devkitSentryExtra({ operationId, phase: "status_unknown" }));
+    return {
+      daemonRunning: null,
+      warning: { code: "DAEMON_STATUS_UNKNOWN", message: DAEMON_STATUS_UNKNOWN_MESSAGE }
+    };
+  }
+}
+function validateUrl(raw) {
+  if (raw.includes("\\")) {
+    throw new DevkitCliError("url", "--url must not contain a backslash");
+  }
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new DevkitCliError("url", "--url must be a valid HTTP/HTTPS origin");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new DevkitCliError("url", "--url scheme must be http or https");
+  }
+  if (url.username !== "" || url.password !== "") {
+    throw new DevkitCliError("url", "--url must not contain userinfo");
+  }
+  if (url.port !== "") {
+    throw new DevkitCliError("url", "--url must not contain an embedded port; use --port");
+  }
+  if (url.pathname !== "/" && url.pathname !== "") {
+    throw new DevkitCliError("url", "--url must not contain a path");
+  }
+  if (url.search !== "") {
+    throw new DevkitCliError("url", "--url must not contain a query");
+  }
+  if (url.hash !== "") {
+    throw new DevkitCliError("url", "--url must not contain a fragment");
+  }
+  const hostname = url.hostname.toLowerCase();
+  if (!isLoopbackHostname(hostname)) {
+    throw new DevkitCliError(
+      "url",
+      "--url host must be a loopback address (127.0.0.0/8, ::1, or localhost)"
+    );
+  }
+  return `${url.protocol}//${hostname}`;
+}
+function isLoopbackHostname(hostname) {
+  if (hostname === "localhost") {
+    return true;
+  }
+  if (hostname === "::1") {
+    return true;
+  }
+  const match = LOOPBACK_IPV4_PATTERN.exec(hostname);
+  if (!match) {
+    return false;
+  }
+  const octets = match.slice(1, 5).map((segment) => Number(segment));
+  if (octets.some((octet) => !Number.isInteger(octet) || octet < 0 || octet > 255)) {
+    return false;
+  }
+  return octets[0] === 127;
+}
+function validatePort(raw) {
+  if (!/^[1-9][0-9]{0,4}$/.test(raw)) {
+    throw new DevkitCliError("port", "--port must be an integer between 1 and 65535");
+  }
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new DevkitCliError("port", "--port must be an integer between 1 and 65535");
+  }
+  return port;
+}
+function validatePaths(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new DevkitCliError("paths", "--paths must be valid JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new DevkitCliError("paths", "--paths must be a JSON object");
+  }
+  const record = parsed;
+  const keys = Object.keys(record);
+  if (keys.length !== 2 || !keys.includes("event") || !keys.includes("health")) {
+    throw new DevkitCliError("paths", '--paths must contain exactly the keys "event" and "health"');
+  }
+  const eventPath = validatePathValue(record.event, "event");
+  const healthPath = validatePathValue(record.health, "health");
+  return { eventPath, healthPath };
+}
+function validatePathValue(value, key) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new DevkitCliError("paths", `--paths.${key} must be a non-empty string`);
+  }
+  if (!value.startsWith("/") || value.startsWith("//")) {
+    throw new DevkitCliError("paths", `--paths.${key} must start with a single "/"`);
+  }
+  if (value.includes("\\") || value.includes("?") || value.includes("#") || value.includes("..")) {
+    throw new DevkitCliError(
+      "paths",
+      `--paths.${key} must not contain a query, fragment, backslash, "..", or an absolute URL`
+    );
+  }
+  if (/^\/[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value)) {
+    throw new DevkitCliError("paths", `--paths.${key} must not be an absolute URL`);
+  }
+  return value;
+}
+function parseArgs(args, spec) {
+  const options = /* @__PURE__ */ new Map();
+  const flags = /* @__PURE__ */ new Set();
+  for (let index2 = 0; index2 < args.length; index2 += 1) {
+    const token = args[index2];
+    if (!token.startsWith("--")) {
+      throw new DevkitCliError("command", `unexpected positional argument: ${token}`);
+    }
+    const name = token.slice(2);
+    if (spec.flags.has(name)) {
+      if (flags.has(name)) {
+        throw new DevkitCliError("command", `${token} must not be repeated`);
+      }
+      flags.add(name);
+      continue;
+    }
+    if (!spec.options.has(name)) {
+      throw new DevkitCliError("command", `unknown option ${token}`);
+    }
+    if (index2 + 1 >= args.length) {
+      throw new DevkitCliError("command", `${token} requires a value`);
+    }
+    const value = args[++index2];
+    if (value.startsWith("--")) {
+      throw new DevkitCliError("command", `${token} requires a value`);
+    }
+    if (options.has(name)) {
+      throw new DevkitCliError("command", `${token} must not be repeated`);
+    }
+    options.set(name, [value]);
+  }
+  return { options, flags };
+}
+function requireOption(parsed, name) {
+  const value = parsed.options.get(name)?.[0];
+  if (value === void 0 || value.length === 0) {
+    throw new DevkitCliError(name, `--${name} is required`);
+  }
+  return value;
+}
+function outputSuccess(json, result) {
+  if (json) {
+    console.log(JSON.stringify({
+      ok: true,
+      daemonRunning: result.daemonRunning,
+      ...result.warning ? { warning: result.warning } : {},
+      ...result.configVersion === void 0 ? {} : { configVersion: result.configVersion }
+    }));
+    return;
+  }
+  const daemonText = result.daemonRunning === null ? "unknown" : String(result.daemonRunning);
+  console.log(`ok=true daemonRunning=${daemonText}${result.warning ? ` warning=${result.warning.code}` : ""}`);
+  if (result.warning) {
+    console.log(result.warning.message);
+  }
+}
+function outputError(json, detail) {
+  if (json) {
+    console.log(JSON.stringify({ ok: false, error: detail.reason }));
+    return;
+  }
+  console.error(`ok=false field=${detail.field} error=${detail.reason}`);
+}
+function normalizeError(error) {
+  if (error instanceof DevkitCliError) {
+    return error.toValidationError();
+  }
+  if (error instanceof DevkitServerStoreError) {
+    return { field: "config", reason: error.message };
+  }
+  return { field: "unknown", reason: error instanceof Error ? error.message : String(error) };
+}
+function devkitSentryExtra(extra) {
+  const normalized = { component: "node_devkit" };
+  for (const [key, value] of Object.entries(extra)) {
+    if (value !== void 0) {
+      normalized[key] = String(value);
+    }
+  }
+  return normalized;
+}
+function isHelpArg(value) {
+  return value === "help" || value === "-h" || value === "--help";
+}
+
 // src/xmtp-test-cli.ts
-var import_promises10 = require("node:fs/promises");
+var import_promises11 = require("node:fs/promises");
 var import_node_path27 = require("node:path");
 init_daemon();
 
 // src/log-tail.ts
-var import_node_fs20 = require("node:fs");
-var import_promises9 = require("node:fs/promises");
+var import_node_fs21 = require("node:fs");
+var import_promises10 = require("node:fs/promises");
 var import_node_path26 = require("node:path");
 var import_node_string_decoder = require("node:string_decoder");
 init_win_spawn();
@@ -68234,7 +69764,7 @@ async function followFile(filePath, onData, options = {}) {
       let handle;
       try {
         try {
-          handle = await (0, import_promises9.open)(filePath, "r");
+          handle = await (0, import_promises10.open)(filePath, "r");
         } catch (error) {
           if (error.code === "ENOENT") {
             markMissing();
@@ -68299,7 +69829,7 @@ async function followFile(filePath, onData, options = {}) {
     }, pollIntervalMs);
     const targetName = (0, import_node_path26.basename)(filePath);
     try {
-      watcher = (0, import_node_fs20.watch)((0, import_node_path26.dirname)(filePath), (_eventType, filename) => {
+      watcher = (0, import_node_fs21.watch)((0, import_node_path26.dirname)(filePath), (_eventType, filename) => {
         if (filename === null || filename.toString() === targetName) {
           void check();
         }
@@ -68340,7 +69870,7 @@ async function readTailSnapshot(filePath, maxLines) {
 async function readTailSnapshotOnce(filePath, maxLines) {
   let handle;
   try {
-    handle = await (0, import_promises9.open)(filePath, "r");
+    handle = await (0, import_promises10.open)(filePath, "r");
   } catch (error) {
     if (error.code === "ENOENT") {
       return { text: "", offset: 0, fileIdentity: null };
@@ -68397,7 +69927,7 @@ async function readTailSnapshotOnce(filePath, maxLines) {
 }
 async function currentPositionOrMissing(filePath) {
   try {
-    const stats = await (0, import_promises9.stat)(filePath);
+    const stats = await (0, import_promises10.stat)(filePath);
     return { offset: stats.size, fileIdentity: identityForStats(stats) };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -68494,7 +70024,7 @@ async function startXmtpTest(args, releaseInfo) {
   const runId = requestedRunId ? validateRunId(requestedRunId) : createRunId(requestedName);
   const files = resolveRunFiles(testsDir, runId);
   try {
-    await (0, import_promises10.stat)(files.runDir);
+    await (0, import_promises11.stat)(files.runDir);
     throw new Error(`XMTP test run already exists: ${runId}`);
   } catch (error) {
     if (error.code !== "ENOENT") {
@@ -68502,7 +70032,7 @@ async function startXmtpTest(args, releaseInfo) {
     }
   }
   await ensurePrivateDir(files.runDir);
-  await (0, import_promises10.writeFile)(files.eventsPath, "", { encoding: "utf8", mode: 384 });
+  await (0, import_promises11.writeFile)(files.eventsPath, "", { encoding: "utf8", mode: 384 });
   const manifest = {
     runId,
     name: requestedName,
@@ -68546,7 +70076,7 @@ async function stopXmtpTest(args) {
   }
   const runId = validateRunId(active.runId);
   const files = resolveRunFiles(testsDir, runId);
-  await (0, import_promises10.unlink)(activePath);
+  await (0, import_promises11.unlink)(activePath);
   const manifest = await readRequiredJson(files.manifestPath);
   const completed = {
     ...manifest,
@@ -68864,7 +70394,7 @@ async function resolveRequestedRunId(testsDir, args, preferActive = false) {
 async function findLatestRunId(testsDir) {
   let entries;
   try {
-    entries = await (0, import_promises10.readdir)(testsDir, { withFileTypes: true });
+    entries = await (0, import_promises11.readdir)(testsDir, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") {
       return null;
@@ -68889,7 +70419,7 @@ async function findLatestRunId(testsDir) {
 async function readMetricEvents(path2) {
   let text;
   try {
-    text = await (0, import_promises10.readFile)(path2, "utf8");
+    text = await (0, import_promises11.readFile)(path2, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -68913,9 +70443,9 @@ function parseMetricEvent(line) {
   }
 }
 async function ensurePrivateDir(path2) {
-  await (0, import_promises10.mkdir)(path2, { recursive: true, mode: 448 });
+  await (0, import_promises11.mkdir)(path2, { recursive: true, mode: 448 });
   try {
-    await (0, import_promises10.chmod)(path2, 448);
+    await (0, import_promises11.chmod)(path2, 448);
   } catch (error) {
     const code = error.code;
     if (code !== "EPERM" && code !== "EACCES") {
@@ -68925,12 +70455,12 @@ async function ensurePrivateDir(path2) {
 }
 async function writeJson(path2, value) {
   const temporary = `${path2}.${process.pid}.tmp`;
-  await (0, import_promises10.writeFile)(temporary, `${JSON.stringify(value, null, 2)}
+  await (0, import_promises11.writeFile)(temporary, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
   });
-  await (0, import_promises10.rename)(temporary, path2);
+  await (0, import_promises11.rename)(temporary, path2);
 }
 async function readRequiredJson(path2) {
   const value = await readJsonIfExists(path2);
@@ -68941,7 +70471,7 @@ async function readRequiredJson(path2) {
 }
 async function readJsonIfExists(path2) {
   try {
-    return JSON.parse(await (0, import_promises10.readFile)(path2, "utf8"));
+    return JSON.parse(await (0, import_promises11.readFile)(path2, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") {
       return null;
@@ -69233,21 +70763,21 @@ function parseLogsTailArgs(args, subcommand) {
 
 // src/logs-export.ts
 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_fs28 = require("node:fs");
+var import_promises16 = require("node:fs/promises");
 var import_node_os12 = require("node:os");
 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_fs24 = require("node:fs");
-var import_promises13 = require("node:fs/promises");
+var import_node_crypto15 = require("node:crypto");
+var import_node_fs25 = require("node:fs");
+var import_promises14 = require("node:fs/promises");
 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_fs24 = require("node:fs");
+var import_promises13 = require("node:fs/promises");
 var import_node_path30 = require("node:path");
 var import_node_readline2 = require("node:readline");
 var MAX_SINGLE_RECORD_BYTES = 2 * 1024 * 1024;
@@ -69357,7 +70887,7 @@ async function readFilteredLog(path2, options, correlationIds, requireCorrelatio
   };
 }
 async function* streamLogRecords(path2, mode) {
-  const input = (0, import_node_fs23.createReadStream)(path2, { encoding: "utf8" });
+  const input = (0, import_node_fs24.createReadStream)(path2, { encoding: "utf8" });
   const lines = (0, import_node_readline2.createInterface)({ input, crlfDelay: Infinity });
   let current = null;
   try {
@@ -69774,7 +71304,7 @@ function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 async function assertRegularFile(path2) {
-  const file = await (0, import_promises12.lstat)(path2);
+  const file = await (0, import_promises13.lstat)(path2);
   if (file.isSymbolicLink() || !file.isFile()) {
     throw Object.assign(
       new Error(`Refusing non-regular diagnostic source: ${(0, import_node_path30.basename)(path2)}`),
@@ -69859,7 +71389,7 @@ function recordCollector(state, result) {
 async function resolveOutputPath(requested, input) {
   if (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) {
+    if ((0, import_node_fs25.existsSync)(output2) && !input.overwrite) {
       throw new Error(`Output already exists: ${output2}. Pass --overwrite to replace it.`);
     }
     return output2;
@@ -69867,42 +71397,42 @@ 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_path31.join)(input.cwd, base);
-  for (let suffix = 2; (0, import_node_fs24.existsSync)(output); suffix += 1) {
+  for (let suffix = 2; (0, import_node_fs25.existsSync)(output); suffix += 1) {
     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_path31.dirname)(outputPath), { recursive: true });
+  await (0, import_promises14.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_crypto14.randomUUID)()}.tmp`
+    `.${(0, import_node_path31.basename)(outputPath)}.${(0, import_node_crypto15.randomUUID)()}.tmp`
   );
   try {
-    await (0, import_promises13.writeFile)(temporaryPath, archive, { flag: "wx", mode: 384 });
+    await (0, import_promises14.writeFile)(temporaryPath, archive, { flag: "wx", mode: 384 });
     if (overwrite) {
-      if ((0, import_node_fs24.existsSync)(outputPath)) {
-        await (0, import_promises13.rm)(outputPath, { force: true });
+      if ((0, import_node_fs25.existsSync)(outputPath)) {
+        await (0, import_promises14.rm)(outputPath, { force: true });
       }
-      await (0, import_promises13.rename)(temporaryPath, outputPath);
+      await (0, import_promises14.rename)(temporaryPath, outputPath);
     } else {
-      await (0, import_promises13.link)(temporaryPath, outputPath);
-      await (0, import_promises13.rm)(temporaryPath, { force: true });
+      await (0, import_promises14.link)(temporaryPath, outputPath);
+      await (0, import_promises14.rm)(temporaryPath, { force: true });
     }
   } catch (err) {
-    await (0, import_promises13.rm)(temporaryPath, { force: true }).catch(() => void 0);
+    await (0, import_promises14.rm)(temporaryPath, { force: true }).catch(() => void 0);
     throw err;
   }
 }
 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;
 }
 
 // src/logs-export-database.ts
-var import_node_fs25 = require("node:fs");
+var import_node_fs26 = require("node:fs");
 var PROVIDERS = ["codex", "claude", "openclaw", "hermes"];
 function readSessionSqliteSnapshot(dbPath, options, selectedJobIds) {
   const hasTimeWindow2 = options.fromMs !== void 0 && options.toMs !== void 0;
@@ -70000,11 +71530,11 @@ function readSessionSqliteSnapshot(dbPath, options, selectedJobIds) {
   };
 }
 function readSqliteRows(dbPath, sql, params = []) {
-  if (!(0, import_node_fs25.existsSync)(dbPath)) {
+  if (!(0, import_node_fs26.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 {
@@ -70022,7 +71552,7 @@ function emptySqliteSnapshot() {
     storedProviderCommands: {}
   };
 }
-function loadSqlite4() {
+function loadSqlite5() {
   const originalEmitWarning = process.emitWarning;
   process.emitWarning = ((warning, ...args) => {
     const message = typeof warning === "string" ? warning : warning.message;
@@ -70155,9 +71685,9 @@ function isProvider2(value) {
 }
 
 // src/logs-export-utils.ts
-var import_node_crypto15 = require("node:crypto");
-var import_node_fs26 = require("node:fs");
-var import_promises14 = require("node:fs/promises");
+var import_node_crypto16 = require("node:crypto");
+var import_node_fs27 = require("node:fs");
+var import_promises15 = require("node:fs/promises");
 var import_node_path33 = require("node:path");
 var MAX_JSON_FILE_BYTES = 20 * 1024 * 1024;
 var STRONG_CORRELATION_KEYS = /* @__PURE__ */ new Set([
@@ -70273,7 +71803,7 @@ function collectCorrelationIds(value, output, key = "", depth = 0) {
 }
 async function safeReadDir(path2) {
   try {
-    return await (0, import_promises14.readdir)(path2);
+    return await (0, import_promises15.readdir)(path2);
   } catch (err) {
     if (err.code === "ENOENT") {
       return [];
@@ -70286,11 +71816,11 @@ async function readJsonObject(path2) {
   if (file.size > MAX_JSON_FILE_BYTES) {
     throw unavailable2(`JSON source exceeds ${MAX_JSON_FILE_BYTES} bytes`);
   }
-  const value = parseJsonValue3(await (0, import_promises14.readFile)(path2, "utf8"));
+  const value = parseJsonValue3(await (0, import_promises15.readFile)(path2, "utf8"));
   return isRecord7(value) ? value : null;
 }
 async function assertRegularFile2(path2) {
-  const file = await (0, import_promises14.lstat)(path2);
+  const file = await (0, import_promises15.lstat)(path2);
   if (file.isSymbolicLink() || !file.isFile()) {
     throw unavailable2(`Refusing non-regular diagnostic source: ${(0, import_node_path33.basename)(path2)}`);
   }
@@ -70298,8 +71828,8 @@ async function assertRegularFile2(path2) {
 }
 async function inspectRegularFile(path2) {
   const file = await assertRegularFile2(path2);
-  const hash2 = (0, import_node_crypto15.createHash)("sha256");
-  for await (const chunk of (0, import_node_fs26.createReadStream)(path2)) {
+  const hash2 = (0, import_node_crypto16.createHash)("sha256");
+  for await (const chunk of (0, import_node_fs27.createReadStream)(path2)) {
     hash2.update(chunk);
   }
   return {
@@ -70551,7 +72081,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.16" : "unknown",
+    packageVersion: true ? "0.2.17-beta-ab42219842-261020165552" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -70968,7 +72498,7 @@ async function collectProviderDiagnostics(state, provider, storedCommand, option
     const configCandidates = providerConfigCandidates(provider, paths.taskHome);
     const configNotes = [];
     for (const candidate of configCandidates) {
-      if (!(0, import_node_fs27.existsSync)(candidate.path)) {
+      if (!(0, import_node_fs28.existsSync)(candidate.path)) {
         continue;
       }
       let info;
@@ -71019,7 +72549,7 @@ async function collectOpenClawSessionStore(state, options) {
     for (const agentId of allAgentNames.slice(0, MAX_OPENCLAW_AGENTS)) {
       const sessionsDir = (0, import_node_path34.join)(agentsDir, agentId, "sessions");
       try {
-        const info = await (0, import_promises15.lstat)(sessionsDir);
+        const info = await (0, import_promises16.lstat)(sessionsDir);
         if (info.isSymbolicLink() || !info.isDirectory()) {
           skippedSources += 1;
           continue;
@@ -71196,7 +72726,7 @@ async function collectGatewayLogs(state, provider, paths, options, correlationId
 async function collectDoctorSnapshot(state, options) {
   await runCollector(state, "doctor", async () => {
     const cliPath = process.argv[1];
-    if (!cliPath || !(0, import_node_fs27.existsSync)(cliPath)) {
+    if (!cliPath || !(0, import_node_fs28.existsSync)(cliPath)) {
       throw unavailable2("Unable to resolve the running okx-a2a CLI path");
     }
     const result = (0, import_node_child_process10.spawnSync)(process.execPath, [
@@ -72463,7 +73993,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.16" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.17-beta-ab42219842-261020165552" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -72704,7 +74234,22 @@ init_autostart_windows();
   DEFAULT_LOG_TAIL_LIMIT,
   DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC,
   DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC,
+  DEVKIT_DROP_REASON,
+  DEVKIT_MAX_CONCURRENCY,
+  DEVKIT_MAX_MESSAGE_BYTES,
+  DEVKIT_MAX_PENDING,
+  DEVKIT_MAX_PENDING_BYTES,
+  DEVKIT_OUTCOME,
+  DEVKIT_REQUEST_BUDGET_MS,
+  DEVKIT_RESPONSE_DIAGNOSTIC_MAX_BYTES,
+  DEVKIT_RESPONSE_SUMMARY_MAX_CHARS,
+  DEVKIT_SERVER_APPLICATION_ID,
+  DEVKIT_SERVER_DB_NAME,
+  DEVKIT_SERVER_SCHEMA_VERSION,
   DOCTOR_MIN_NODE_VERSION,
+  DevkitDeliveryDispatcher,
+  DevkitServerStore,
+  DevkitServerStoreError,
   GatewayOutboundBehavior,
   HEARTBEAT_GATEWAY_CHECK_TIMEOUT_MS,
   InboundReplayGate,
@@ -72733,6 +74278,9 @@ init_autostart_windows();
   UserCancelledAiProviderSelectionError,
   WALLET_STATUS_TIMEOUT_MS,
   XMTP_CLIENT_RECYCLE_INTERVAL_ENV,
+  XMTP_CREATION_COOLDOWN_MS,
+  XmtpCreationCooldown,
+  XmtpCreationCooldownSkipError,
   XmtpDm,
   XmtpGroup,
   XmtpService,
@@ -72759,6 +74307,7 @@ init_autostart_windows();
   buildExternalCommandInvocation,
   buildGatewayOutboundExtra,
   buildInboundTerminalExtras,
+  buildJobEnvelope,
   buildLaunchdPlist,
   buildLauncherEntryJs,
   buildMessageEligibleArgs,
@@ -72769,6 +74318,7 @@ init_autostart_windows();
   buildSchtasksRunArgs,
   buildSeaConfig,
   buildServicePath,
+  buildSessionEnvelope,
   buildSessionKey,
   buildSystemMessageNotice,
   buildSystemStoredMessage,
@@ -72786,6 +74336,8 @@ init_autostart_windows();
   checkCodexCliAuthStatus,
   checkCodexReadiness,
   claimActiveDaemon,
+  classifyFetchFailure,
+  classifyHttpOutcome,
   classifyJobBindingSource,
   clearCodexReadinessCache,
   codexCommandResolvesWithoutOverride,
@@ -72794,6 +74346,7 @@ init_autostart_windows();
   collectCodexCommandCandidates,
   commandExists,
   createAiToolFailureTracker,
+  createDevkitAutoRouter,
   createFileMessageHandler,
   createOutboundBehavior,
   createUserAttentionWatchParentMonitor,
@@ -72804,6 +74357,7 @@ init_autostart_windows();
   detectGatewayInvocation,
   detectMessageEligibleOfflineReplaySupport,
   detectRuntime,
+  devkitServerDbExists,
   ensureDaemonReady,
   ensureDefaultAiProvider,
   ensureOpenClawOkxA2aPluginConfig,
@@ -72813,6 +74367,7 @@ init_autostart_windows();
   exportDiagnosticLogs,
   extractAiSessionId,
   extractDirectToUserNotification,
+  extractRateLimitEndpoint,
   extractXmtpSentAtMs,
   findWindowsNativeOkxA2aExe,
   followFile,
@@ -72823,7 +74378,9 @@ init_autostart_windows();
   getResolvedOnchainosBinForTests,
   getRuntimeMetadata,
   getSessionBusyTracker,
+  getXmtpCreationCooldown,
   handleCapabilitiesCommand,
+  handleDevkitCommand,
   handleDoctorCommand,
   handleXmtpDebugCommand,
   handleXmtpSendCommand,
@@ -72853,6 +74410,7 @@ init_autostart_windows();
   isTagKey,
   isValidExternalJobId,
   isWindowsElevated,
+  isXmtpRateLimitError,
   killProcessTree,
   launchdPlistHasCurrentRestartPolicy,
   listAllAgentsWithMetadata,
@@ -72880,6 +74438,7 @@ init_autostart_windows();
   persistCurrentRuntimeSelectionForNewJob,
   pickOnchainosWin32Candidate,
   prepareAndBindCurrentRuntimeForNewJob,
+  printDevkitUsage,
   printLogsExportUsage,
   printXmtpTestUsage,
   probeCodexAuthStatus,
@@ -72891,6 +74450,7 @@ init_autostart_windows();
   readLastLines,
   readParentProcessCommandForPlatform,
   readUserAttentionWatcherEvent,
+  redactSummary,
   refreshAgentsAndWait,
   refreshOnchainosVersionMetadata,
   registerUserAttentionWatcher,
@@ -72902,6 +74462,7 @@ init_autostart_windows();
   reportUserNotificationFailure,
   resetMessageEligibleOfflineReplayCapabilityForTests,
   resetResolvedOnchainosBinForTests,
+  resetXmtpCreationCooldownForTests,
   resolveAiPermissionPreset,
   resolveAiProviderCommand,
   resolveAiProviderCommandWithSource,
@@ -72912,6 +74473,7 @@ init_autostart_windows();
   resolveCodexCommandSource,
   resolveConfiguredAiProvider,
   resolveConfiguredAiProviderForJob,
+  resolveDevkitServerDbPath,
   resolveDirectCommunicationSessionTarget,
   resolveDoctorTarget,
   resolveEnvelopePayload,
@@ -72949,6 +74511,7 @@ init_autostart_windows();
   startDaemonRespectingSupervisor,
   startUserAttentionEventServer,
   startUserAttentionWatcherCoordinator,
+  stopAndCloseXmtpClient,
   stopDaemon,
   stopOpenClawGateway,
   stopSystemdAutostart,