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

package/dist/cli.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";
   }
 });
 
@@ -4935,8 +4937,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;
@@ -19981,6 +19983,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",
@@ -20046,7 +20056,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"
     };
   }
 });
@@ -20885,7 +20916,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;
@@ -27001,7 +27051,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
@@ -27012,7 +27062,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 } : {}
@@ -29072,7 +29122,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)
     };
@@ -39642,8 +39692,8 @@ function readSqliteRows(dbPath, sql, params = []) {
   if (!(0, import_node_fs17.existsSync)(dbPath)) {
     throw unavailable(`SQLite database not found: ${dbPath}`);
   }
-  const { DatabaseSync: DatabaseSync5 } = loadSqlite3();
-  const db = new DatabaseSync5(dbPath, { readOnly: true });
+  const { DatabaseSync: DatabaseSync6 } = loadSqlite3();
+  const db = new DatabaseSync6(dbPath, { readOnly: true });
   try {
     return db.prepare(sql).all(...params);
   } finally {
@@ -40242,7 +40292,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,
@@ -42221,6 +42271,701 @@ var init_trade_records_cli = __esm({
   }
 });
 
+// src/devkit-server-store.ts
+function resolveDevkitServerDbPath(homeDir) {
+  return resolveTaskPaths(homeDir).devkitServerDbPath;
+}
+function applyMigrationV12(db) {
+  db.exec(`
+    CREATE TABLE ${TABLE_NAME2} (
+      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 readPragmaNumber2(db, name) {
+  const row = db.prepare(`PRAGMA ${name}`).get();
+  return Number(row[name] ?? 0);
+}
+function assertNotSymlink2(path2, label) {
+  if (!(0, import_node_fs22.existsSync)(path2)) {
+    return;
+  }
+  if ((0, import_node_fs22.lstatSync)(path2).isSymbolicLink()) {
+    throw new DevkitServerStoreError("DATABASE_PATH_UNSAFE", `${label} must not be a symbolic link`);
+  }
+}
+function assertSafeDatabasePath2(dbPath) {
+  assertSafeDatabaseFile2(dbPath);
+  for (const suffix of ["-journal", "-wal", "-shm"]) {
+    assertNotSymlink2(`${dbPath}${suffix}`, `devkit server database sidecar ${suffix}`);
+  }
+}
+function assertSafeDatabaseFile2(dbPath) {
+  if (!(0, import_node_fs22.existsSync)(dbPath)) {
+    return;
+  }
+  const stat4 = (0, import_node_fs22.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 rollbackQuietly2(db) {
+  try {
+    db.exec("ROLLBACK");
+  } catch {
+  }
+}
+function withBusyRetry2(operation) {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return operation();
+    } catch (error) {
+      if (!isSqliteBusyError(error) || attempt >= WRITE_RETRY_ATTEMPTS2) {
+        throw error;
+      }
+      sleepSyncMs3(Math.min(100 * 2 ** (attempt - 1), 1600));
+    }
+  }
+}
+function sleepSyncMs3(ms) {
+  const buffer2 = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(buffer2, 0, 0, ms);
+}
+function loadSqlite5() {
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = ((warning, ...args) => {
+    const message = typeof warning === "string" ? warning : warning.message;
+    if (message.includes("SQLite is an experimental feature") && args.some((arg) => arg === "ExperimentalWarning")) {
+      return;
+    }
+    return originalEmitWarning.call(process, warning, ...args);
+  });
+  try {
+    return require("node:sqlite");
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
+var import_node_fs22, DatabaseSync4, DEVKIT_SERVER_APPLICATION_ID, DEVKIT_SERVER_SCHEMA_VERSION, TABLE_NAME2, WRITE_RETRY_ATTEMPTS2, DevkitServerStoreError, DevkitServerStore;
+var init_devkit_server_store = __esm({
+  "src/devkit-server-store.ts"() {
+    "use strict";
+    import_node_fs22 = require("node:fs");
+    init_paths();
+    init_session_store();
+    ({ DatabaseSync: DatabaseSync4 } = loadSqlite5());
+    DEVKIT_SERVER_APPLICATION_ID = 1329677395;
+    DEVKIT_SERVER_SCHEMA_VERSION = 1;
+    TABLE_NAME2 = `"devkit-server"`;
+    WRITE_RETRY_ATTEMPTS2 = 6;
+    DevkitServerStoreError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.name = "DevkitServerStoreError";
+        this.code = code;
+      }
+    };
+    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;
+        assertNotSymlink2(paths.sqliteDir, "devkit server directory");
+        ensureTaskDir(paths.sqliteDir);
+        assertNotSymlink2(paths.sqliteDir, "devkit server directory");
+        assertSafeDatabasePath2(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_fs22.existsSync)(dbPath)) {
+          return null;
+        }
+        assertSafeDatabaseFile2(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_NAME2} WHERE id = 1`).get();
+          const configVersion = (existing?.config_version ?? 0) + 1;
+          const updatedAt = Date.now();
+          this.db.prepare(`
+          INSERT INTO ${TABLE_NAME2} (
+            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_NAME2} 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_NAME2} 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() {
+        withBusyRetry2(() => {
+          this.db.exec("BEGIN IMMEDIATE");
+          try {
+            const applicationId = readPragmaNumber2(this.db, "application_id");
+            const userVersion = readPragmaNumber2(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) {
+              applyMigrationV12(this.db);
+              this.db.exec("PRAGMA user_version=1");
+            }
+            this.db.exec("COMMIT");
+          } catch (error) {
+            rollbackQuietly2(this.db);
+            throw error;
+          }
+        });
+        withBusyRetry2(() => {
+          this.db.exec("PRAGMA journal_mode=WAL");
+          this.db.exec("PRAGMA synchronous=FULL");
+        });
+      }
+      assertReadableSchema() {
+        const applicationId = readPragmaNumber2(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 = readPragmaNumber2(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 withBusyRetry2(() => {
+          this.db.exec("BEGIN IMMEDIATE");
+          try {
+            const result = operation();
+            this.db.exec("COMMIT");
+            return result;
+          } catch (error) {
+            rollbackQuietly2(this.db);
+            throw error;
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/devkit-cli.ts
+var devkit_cli_exports = {};
+__export(devkit_cli_exports, {
+  handleDevkitCommand: () => handleDevkitCommand,
+  printDevkitUsage: () => printDevkitUsage
+});
+async function handleDevkitCommand(args) {
+  const wantsJson = args.includes("--json");
+  const subcommand = args[0];
+  if (!subcommand || isHelpArg2(subcommand)) {
+    printDevkitUsage();
+    return;
+  }
+  if (args.slice(1).some(isHelpArg2)) {
+    printDevkitUsage();
+    return;
+  }
+  if (subcommand === "register") {
+    await handleRegister(args.slice(1), wantsJson);
+    return;
+  }
+  if (subcommand === "unregister") {
+    await handleUnregister(args.slice(1), wantsJson);
+    return;
+  }
+  outputError2(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_crypto9.randomUUID)();
+  const startedAt = Date.now();
+  logger.info(LogEvent.DEVKIT_REGISTER_REQUESTED, devkitSentryExtra({ operationId, phase: "requested" }));
+  try {
+    const parsed = parseArgs2(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 })
+      );
+      outputError2(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 = normalizeError2(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 })
+    );
+    outputError2(wantsJson, detail);
+    process.exitCode = 1;
+  }
+}
+async function handleUnregister(args, wantsJson) {
+  const operationId = (0, import_node_crypto9.randomUUID)();
+  const startedAt = Date.now();
+  logger.info(LogEvent.DEVKIT_UNREGISTER_REQUESTED, devkitSentryExtra({ operationId, phase: "requested" }));
+  try {
+    parseArgs2(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 })
+      );
+      outputError2(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 = normalizeError2(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 })
+    );
+    outputError2(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 parseArgs2(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 outputError2(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 normalizeError2(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 isHelpArg2(value) {
+  return value === "help" || value === "-h" || value === "--help";
+}
+var import_node_crypto9, DAEMON_NOT_RUNNING_MESSAGE, DAEMON_STATUS_UNKNOWN_MESSAGE, LOOPBACK_IPV4_PATTERN, DevkitCliError;
+var init_devkit_cli = __esm({
+  "src/devkit-cli.ts"() {
+    "use strict";
+    import_node_crypto9 = require("node:crypto");
+    init_daemon();
+    init_devkit_server_store();
+    init_sentry_logger();
+    DAEMON_NOT_RUNNING_MESSAGE = "\u5F53\u524D daemon \u672A\u8FD0\u884C,\u8BF7\u4F7F\u7528 okx-a2a start \u542F\u52A8 daemon";
+    DAEMON_STATUS_UNKNOWN_MESSAGE = "\u914D\u7F6E\u5DF2\u5199\u5165,\u4F46\u65E0\u6CD5\u786E\u8BA4 daemon \u8FD0\u884C\u72B6\u6001";
+    LOOPBACK_IPV4_PATTERN = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+    DevkitCliError = class extends Error {
+      field;
+      constructor(field, reason) {
+        super(reason);
+        this.name = "DevkitCliError";
+        this.field = field;
+      }
+      toValidationError() {
+        return { field: this.field, reason: this.message };
+      }
+    };
+  }
+});
+
+// ../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 (err2) {
+    ctx.onCloseError?.(err2);
+    return { stopped, closed: false, closeFailed: true };
+  }
+}
+var init_client_lifecycle = __esm({
+  "../core/src/xmtp-sdk/client-lifecycle.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/xmtp-sdk/onchainos/bin.ts
 async function refreshOnchainosVersionMetadata(options = {}) {
   const now = options.now ?? Date.now;
@@ -42340,7 +43085,7 @@ function isResolvedBinUsable(bin) {
   if (!isPathLikeCommand(bin)) {
     return true;
   }
-  return process.platform === "win32" ? (0, import_node_fs22.existsSync)(bin) : isExecutable2(bin);
+  return process.platform === "win32" ? (0, import_node_fs23.existsSync)(bin) : isExecutable2(bin);
 }
 function resolvePosixBareCommand(command, pathValue) {
   for (const dir of pathValue.split(":")) {
@@ -42677,7 +43422,7 @@ function isWindowsAppsAlias(candidate) {
   return candidate.toLowerCase().includes(WINDOWS_APPS_ALIAS_MARKER);
 }
 function win32FileExists(path2) {
-  return (0, import_node_fs22.existsSync)(path2);
+  return (0, import_node_fs23.existsSync)(path2);
 }
 function pickOnchainosWin32Candidate(lines, fileExists2 = win32FileExists) {
   const candidates = lines.map((line) => {
@@ -42733,7 +43478,7 @@ function extractExecutablePath(stdout) {
 }
 function isExecutable2(path2) {
   try {
-    (0, import_node_fs22.accessSync)(path2, import_node_fs22.constants.X_OK);
+    (0, import_node_fs23.accessSync)(path2, import_node_fs23.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -42838,12 +43583,12 @@ async function exec(args, options = {}) {
   }
   throw new Error("OnchainOS command retry exhausted");
 }
-var import_node_fs22, import_node_child_process8, import_node_path25, import_node_util2, execFileAsync2, resolvedBin, resolvedForEnvBin, resolverRevision, versionProbeInFlight, posixDiscoveryFlights, REDACTED_VALUE_FLAGS, COMMAND_UNAVAILABLE_CODES, ONCHAINOS_VERSION_PROBE_TIMEOUT_MS, ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS, WINDOWS_APPS_ALIAS_MARKER;
+var import_node_fs23, import_node_child_process8, import_node_path25, import_node_util2, execFileAsync2, resolvedBin, resolvedForEnvBin, resolverRevision, versionProbeInFlight, posixDiscoveryFlights, REDACTED_VALUE_FLAGS, COMMAND_UNAVAILABLE_CODES, ONCHAINOS_VERSION_PROBE_TIMEOUT_MS, ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS, WINDOWS_APPS_ALIAS_MARKER;
 var init_bin = __esm({
   "../core/src/xmtp-sdk/onchainos/bin.ts"() {
     "use strict";
     init_log();
-    import_node_fs22 = require("node:fs");
+    import_node_fs23 = require("node:fs");
     import_node_child_process8 = require("node:child_process");
     import_node_path25 = require("node:path");
     import_node_util2 = require("node:util");
@@ -42907,12 +43652,12 @@ function createAsyncStreamProxy(stream) {
     }
   });
 }
-var import_node_bindings, import_node_bindings2, import_node_crypto9, import_types, import_node_path26, import_node_process, HistorySyncUrls, envMap, reverseEnvMap, envToString, createBackend, InboxReassignError, AccountAlreadyAssociatedError, MissingContentTypeError, SignerUnavailableError, ClientNotInitializedError, StreamFailedError, StreamInvalidRetryAttemptsError, generateInboxId, getInboxIdForIdentifier, isReaction, isReply, isText, isRemoteAttachment, isAttachment, isMultiRemoteAttachment, isTransactionReference, isGroupUpdated, isReadReceipt, isLeaveRequest, isWalletSendCalls, isIntent, isActions, isMarkdown, CodecRegistry, getContentFromDecodedMessageContent, getContentTypeFromDecodedMessageContent, DecodedMessage, AsyncStream, usableProperties, isUsableProperty, wait, DEFAULT_RETRY_DELAY, DEFAULT_RETRY_ATTEMPTS, createStream, Conversation, Dm, Group, Conversations, DebugInformation, Preferences, networkOptionKeys, hasBackend, resolveBackend$1, createClient, resolveBackend, createEphemeralIdentifier, toInboxUpdatesCountMap, Client;
+var import_node_bindings, import_node_bindings2, import_node_crypto10, import_types, import_node_path26, import_node_process, HistorySyncUrls, envMap, reverseEnvMap, envToString, createBackend, InboxReassignError, AccountAlreadyAssociatedError, MissingContentTypeError, SignerUnavailableError, ClientNotInitializedError, StreamFailedError, StreamInvalidRetryAttemptsError, generateInboxId, getInboxIdForIdentifier, isReaction, isReply, isText, isRemoteAttachment, isAttachment, isMultiRemoteAttachment, isTransactionReference, isGroupUpdated, isReadReceipt, isLeaveRequest, isWalletSendCalls, isIntent, isActions, isMarkdown, CodecRegistry, getContentFromDecodedMessageContent, getContentTypeFromDecodedMessageContent, DecodedMessage, AsyncStream, usableProperties, isUsableProperty, wait, DEFAULT_RETRY_DELAY, DEFAULT_RETRY_ATTEMPTS, createStream, Conversation, Dm, Group, Conversations, DebugInformation, Preferences, networkOptionKeys, hasBackend, resolveBackend$1, createClient, resolveBackend, createEphemeralIdentifier, toInboxUpdatesCountMap, Client;
 var init_dist2 = __esm({
   "../../node_modules/@xmtp/node-sdk/dist/index.js"() {
     import_node_bindings = require("@xmtp/node-bindings");
     import_node_bindings2 = require("@xmtp/node-bindings");
-    import_node_crypto9 = require("node:crypto");
+    import_node_crypto10 = require("node:crypto");
     init_dist();
     import_types = require("node:util/types");
     import_node_path26 = require("node:path");
@@ -44596,7 +45341,7 @@ var init_dist2 = __esm({
       return createBackend({ env: envOrBackend, gatewayHost });
     };
     createEphemeralIdentifier = () => ({
-      identifier: `0x${(0, import_node_crypto9.randomBytes)(20).toString("hex")}`,
+      identifier: `0x${(0, import_node_crypto10.randomBytes)(20).toString("hex")}`,
       identifierKind: 0
     });
     toInboxUpdatesCountMap = (value) => {
@@ -56845,20 +57590,20 @@ async function createRemoteAttachmentFromFile(unencryptedFile, uploadCallback) {
   const fileUrl = await uploadCallback(encryptedAttachment);
   return createRemoteAttachment(encryptedAttachment, fileUrl);
 }
-var import_node_events, import_node_fs23, import_node_path27, import_ts_retry_promise, import_node_crypto10, version2, fromSelf, hasContent, isDM, isGroup, isGroupAdmin, isGroupSuperAdmin, usesCodec, filter, validLogLevels, isLogLevel, getValidLogLevels, parseLogLevel, logDetails, getInstallationInfo, createUser, createIdentifier, createSigner, AgentError, AgentStreamingError, ClientContext, ConversationContext, MessageContext, Agent, CANCEL_ACTION_ID, LimitedMap, cache;
+var import_node_events, import_node_fs24, import_node_path27, import_ts_retry_promise, import_node_crypto11, version2, fromSelf, hasContent, isDM, isGroup, isGroupAdmin, isGroupSuperAdmin, usesCodec, filter, validLogLevels, isLogLevel, getValidLogLevels, parseLogLevel, logDetails, getInstallationInfo, createUser, createIdentifier, createSigner, AgentError, AgentStreamingError, ClientContext, ConversationContext, MessageContext, Agent, CANCEL_ACTION_ID, LimitedMap, cache;
 var init_dist4 = __esm({
   "../../node_modules/@xmtp/agent-sdk/dist/index.js"() {
     init_dist2();
     init_dist2();
     import_node_events = __toESM(require("node:events"), 1);
-    import_node_fs23 = __toESM(require("node:fs"), 1);
+    import_node_fs24 = __toESM(require("node:fs"), 1);
     import_node_path27 = __toESM(require("node:path"), 1);
     import_ts_retry_promise = __toESM(require_retry_promise(), 1);
     init_dist3();
     init_esm();
     init_accounts();
     init_chains();
-    import_node_crypto10 = require("node:crypto");
+    import_node_crypto11 = require("node:crypto");
     version2 = "2.3.0";
     fromSelf = (message, client) => {
       return message.senderInboxId === client.inboxId;
@@ -57218,7 +57963,7 @@ var init_dist4 = __esm({
           initializedOptions.gatewayHost = XMTP_GATEWAY_HOST;
         }
         if (typeof XMTP_DB_DIRECTORY === "string") {
-          import_node_fs23.default.mkdirSync(XMTP_DB_DIRECTORY, { recursive: true, mode: 448 });
+          import_node_fs24.default.mkdirSync(XMTP_DB_DIRECTORY, { recursive: true, mode: 448 });
           initializedOptions.dbPath = (inboxId) => {
             const dbPath = import_node_path27.default.join(XMTP_DB_DIRECTORY, `xmtp-${inboxId}.db3`);
             console.info(`Saving local database to "${dbPath}"`);
@@ -57528,7 +58273,7 @@ var init_dist4 = __esm({
         return this.#client.accountIdentifier?.identifier;
       }
     };
-    CANCEL_ACTION_ID = (0, import_node_crypto10.randomUUID)();
+    CANCEL_ACTION_ID = (0, import_node_crypto11.randomUUID)();
     LimitedMap = class {
       #map = /* @__PURE__ */ new Map();
       #limit;
@@ -58261,6 +59006,169 @@ var init_session_expired = __esm({
   }
 });
 
+// ../core/src/xmtp-sdk/rate-limit-cooldown.ts
+function asErrorLike2(value) {
+  return value instanceof Error ? value : void 0;
+}
+function causeChain2(err2) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = err2;
+  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(err2) {
+  if (err2 === void 0 || err2 === null) {
+    return false;
+  }
+  const chain = causeChain2(err2);
+  return chain.some(
+    (node) => RATE_LIMIT_PATTERNS.some((pattern) => pattern.test(messageOf(node)))
+  );
+}
+function extractRateLimitEndpoint(err2) {
+  if (err2 === void 0 || err2 === null) {
+    return void 0;
+  }
+  const chain = causeChain2(err2);
+  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;
+}
+function getXmtpCreationCooldown() {
+  if (!singleton2) {
+    singleton2 = new XmtpCreationCooldown();
+  }
+  return singleton2;
+}
+var MAX_CAUSE_DEPTH2, XMTP_CREATION_COOLDOWN_MS, RATE_LIMIT_PATTERNS, KNOWN_RATE_LIMIT_ENDPOINTS, XmtpCreationCooldownSkipError, XmtpCreationCooldown, singleton2;
+var init_rate_limit_cooldown = __esm({
+  "../core/src/xmtp-sdk/rate-limit-cooldown.ts"() {
+    "use strict";
+    MAX_CAUSE_DEPTH2 = 4;
+    XMTP_CREATION_COOLDOWN_MS = 33e4;
+    RATE_LIMIT_PATTERNS = [
+      /some resource has been exhausted/i,
+      /exceeds rate limit/i,
+      /resource_exhausted/i
+    ];
+    KNOWN_RATE_LIMIT_ENDPOINTS = [
+      /\bGetInboxIds\b/i,
+      /\bGetIdentityUpdates\b/i
+    ];
+    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;
+      }
+    };
+    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;
+      }
+    };
+  }
+});
+
 // ../core/src/xmtp-sdk/index.ts
 function cachePath(dataDir, fileName) {
   return (0, import_node_path28.join)(dataDir, fileName);
@@ -58291,10 +59199,10 @@ function ensureCacheDir(dataDir) {
 function loadSensitiveWordsFromCache(dataDir) {
   try {
     const path2 = cachePath(dataDir, "sensitive-words.json");
-    if (!(0, import_node_fs24.existsSync)(path2)) {
+    if (!(0, import_node_fs25.existsSync)(path2)) {
       return null;
     }
-    const data = JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf-8"));
+    const data = JSON.parse((0, import_node_fs25.readFileSync)(path2, "utf-8"));
     if (Array.isArray(data)) {
       return data;
     }
@@ -58308,7 +59216,7 @@ function loadSensitiveWordsFromCache(dataDir) {
 function saveSensitiveWordsToCache(dataDir, words) {
   try {
     ensureCacheDir(dataDir);
-    (0, import_node_fs24.writeFileSync)(cachePath(dataDir, "sensitive-words.json"), JSON.stringify(words));
+    (0, import_node_fs25.writeFileSync)(cachePath(dataDir, "sensitive-words.json"), JSON.stringify(words));
   } catch (err2) {
     logWithTimestamp(`[xmtp-sdk] failed to write sensitive-words.json:`, err2);
     logger.error(LogEvent.CACHE_WRITE_FAILED, err2 instanceof Error ? err2 : new Error(String(err2)), { cacheName: "sensitive-words" });
@@ -58350,10 +59258,10 @@ async function loadSensitiveWordsWith(dataDir, fetcher) {
 function loadSystemConfigFromCache(dataDir) {
   try {
     const path2 = cachePath(dataDir, "system-config.json");
-    if (!(0, import_node_fs24.existsSync)(path2)) {
+    if (!(0, import_node_fs25.existsSync)(path2)) {
       return null;
     }
-    const data = JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf-8"));
+    const data = JSON.parse((0, import_node_fs25.readFileSync)(path2, "utf-8"));
     if (data && typeof data === "object" && !Array.isArray(data)) {
       return data;
     }
@@ -58367,7 +59275,7 @@ function loadSystemConfigFromCache(dataDir) {
 function saveSystemConfigToCache(dataDir, config) {
   try {
     ensureCacheDir(dataDir);
-    (0, import_node_fs24.writeFileSync)(cachePath(dataDir, "system-config.json"), JSON.stringify(config));
+    (0, import_node_fs25.writeFileSync)(cachePath(dataDir, "system-config.json"), JSON.stringify(config));
   } catch (err2) {
     logWithTimestamp(`[xmtp-sdk] failed to write system-config.json:`, err2);
     logger.error(LogEvent.CACHE_WRITE_FAILED, err2 instanceof Error ? err2 : new Error(String(err2)), { cacheName: "system-config" });
@@ -58417,10 +59325,10 @@ function loadSyncByAddress(dataDir) {
   const map = /* @__PURE__ */ new Map();
   try {
     const path2 = cachePath(dataDir, "last-sync.json");
-    if (!(0, import_node_fs24.existsSync)(path2)) {
+    if (!(0, import_node_fs25.existsSync)(path2)) {
       return map;
     }
-    const data = JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf-8"));
+    const data = JSON.parse((0, import_node_fs25.readFileSync)(path2, "utf-8"));
     const obj = data?.syncByAddress;
     if (obj && typeof obj === "object" && !Array.isArray(obj)) {
       for (const [addr, ts] of Object.entries(obj)) {
@@ -58439,9 +59347,9 @@ function saveSyncForAddress(dataDir, address, timestampMs) {
   try {
     let data = {};
     const path2 = cachePath(dataDir, "last-sync.json");
-    if ((0, import_node_fs24.existsSync)(path2)) {
+    if ((0, import_node_fs25.existsSync)(path2)) {
       try {
-        const raw = JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf-8"));
+        const raw = JSON.parse((0, import_node_fs25.readFileSync)(path2, "utf-8"));
         if (raw && typeof raw === "object" && !Array.isArray(raw)) {
           data = raw;
         }
@@ -58452,7 +59360,7 @@ function saveSyncForAddress(dataDir, address, timestampMs) {
       data.syncByAddress = {};
     }
     data.syncByAddress[address] = timestampMs;
-    (0, import_node_fs24.writeFileSync)(path2, JSON.stringify(data, null, 2));
+    (0, import_node_fs25.writeFileSync)(path2, JSON.stringify(data, null, 2));
   } catch (err2) {
     logWithTimestamp(
       `[xmtp-sdk] failed to write last-sync.json (address=${address}):`,
@@ -58671,12 +59579,12 @@ function createOfflineReplayAddressSummary(address) {
     durationMs: 0
   };
 }
-var import_node_fs24, import_node_path28, DEFAULT_DATA_DIR, XMTP_INSTALLATION_WARNING_THRESHOLD, XMTP_INSTALLATION_NEAR_LIMIT_THRESHOLD, REPLAY_SCAN_INITIAL_BACKOFF_MS, REPLAY_SCAN_MAX_BACKOFF_MS, SENSITIVE_WORDS_LAZY_RETRY_COOLDOWN_MS, InboundReplayGate, SYSTEM_CONFIG_DEFAULTS, STREAM_RECOVERY_ALERT_THRESHOLD_MS, STREAM_RECOVERY_STABILITY_WINDOW_MS, REPLAY_GATE_DRAIN_MAX_ATTEMPTS, REPLAY_GATE_DRAIN_RETRY_DELAY_MS, SEMVER_RE, isRecord5, isPositiveNumber, SYSTEM_CONFIG_VALIDATORS, XmtpService;
+var import_node_fs25, import_node_path28, DEFAULT_DATA_DIR, XMTP_INSTALLATION_WARNING_THRESHOLD, XMTP_INSTALLATION_NEAR_LIMIT_THRESHOLD, REPLAY_SCAN_INITIAL_BACKOFF_MS, REPLAY_SCAN_MAX_BACKOFF_MS, SENSITIVE_WORDS_LAZY_RETRY_COOLDOWN_MS, InboundReplayGate, SYSTEM_CONFIG_DEFAULTS, STREAM_RECOVERY_ALERT_THRESHOLD_MS, STREAM_RECOVERY_STABILITY_WINDOW_MS, REPLAY_GATE_DRAIN_MAX_ATTEMPTS, REPLAY_GATE_DRAIN_RETRY_DELAY_MS, SEMVER_RE, isRecord5, isPositiveNumber, SYSTEM_CONFIG_VALIDATORS, XmtpService;
 var init_xmtp_sdk = __esm({
   "../core/src/xmtp-sdk/index.ts"() {
     "use strict";
     init_log();
-    import_node_fs24 = require("node:fs");
+    import_node_fs25 = require("node:fs");
     import_node_path28 = require("node:path");
     init_dist4();
     init_dist2();
@@ -58690,6 +59598,8 @@ var init_xmtp_sdk = __esm({
     init_a2a_paths();
     init_installation_prune();
     init_session_expired();
+    init_rate_limit_cooldown();
+    init_client_lifecycle();
     DEFAULT_DATA_DIR = resolveA2aTaskPaths().xmtpDir;
     XMTP_INSTALLATION_WARNING_THRESHOLD = 2;
     XMTP_INSTALLATION_NEAR_LIMIT_THRESHOLD = 8;
@@ -58987,21 +59897,78 @@ var init_xmtp_sdk = __esm({
       }
       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 (err2) {
+          if (isXmtpRateLimitError(err2)) {
+            cooldown.recordRateLimit(decision);
+            logger.info(LogEvent.XMTP_RATE_LIMIT_COOLDOWN_STARTED, {
+              ...agentExtras({ walletAddress: address, onchainosAgentId: agentInfo.agentId }),
+              rateLimitIdentified: "true",
+              endpoint: extractRateLimitEndpoint(err2) ?? "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 err2;
+        }
       }
       async recordInstallationHealth(params) {
         const { address, agent, agentInfo, phase, attempt } = params;
@@ -59152,22 +60119,28 @@ var init_xmtp_sdk = __esm({
             });
           } 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...`
           );
@@ -59207,6 +60180,11 @@ var init_xmtp_sdk = __esm({
                 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(
@@ -59302,7 +60280,16 @@ var init_xmtp_sdk = __esm({
             try {
               this.cancelStreamRecoveryForAddress(address);
               this.stoppedAddresses.add(address.toLowerCase());
-              client.stop();
+              await stopAndCloseXmtpClient(client, {
+                address,
+                agentId: agentInfo.agentId,
+                phase: "refresh/remove",
+                onCloseError: (err2) => logger.error(
+                  LogEvent.XMTP_CLIENT_CLOSE_FAILED,
+                  err2 instanceof Error ? err2 : new Error(String(err2)),
+                  { walletAddress: address, onchainosAgentId: agentInfo.agentId, phase: "refresh/remove" }
+                )
+              });
               logWithTimestamp(
                 `[xmtp-sdk] refresh: stopped client: ${address} (agentId=${agentInfo.agentId})`
               );
@@ -59389,23 +60376,29 @@ var init_xmtp_sdk = __esm({
               });
             } 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...`
             );
@@ -59448,6 +60441,11 @@ var init_xmtp_sdk = __esm({
                   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(
@@ -59511,6 +60509,18 @@ var init_xmtp_sdk = __esm({
       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;
@@ -59529,7 +60539,16 @@ var init_xmtp_sdk = __esm({
           try {
             this.cancelStreamRecoveryForAddress(address);
             this.stoppedAddresses.add(addressKey);
-            await Promise.resolve(oldClient.stop());
+            await stopAndCloseXmtpClient(oldClient, {
+              address,
+              agentId: agentInfo.agentId,
+              phase: "recycle",
+              onCloseError: (err2) => logger.error(
+                LogEvent.XMTP_CLIENT_CLOSE_FAILED,
+                err2 instanceof Error ? err2 : new Error(String(err2)),
+                { walletAddress: address, onchainosAgentId: agentInfo.agentId, phase: "recycle" }
+              )
+            });
             this.clients.delete(address);
             this.inboundReplayGates.delete(addressKey);
             this.replayScanFailuresByAddress.delete(addressKey);
@@ -59616,6 +60635,12 @@ var init_xmtp_sdk = __esm({
                 phase: "recycle/create-client"
               }
             );
+            if (isXmtpRateLimitError(err2)) {
+              logWithTimestamp(
+                "[xmtp-sdk] recycle: rate-limit on recreate \u2014 stopping remaining recycles"
+              );
+              break;
+            }
           }
         }
         return {
@@ -61867,7 +62892,7 @@ var init_envelope = __esm({
 });
 
 // src/invalid-message-store.ts
-function loadSqlite5() {
+function loadSqlite6() {
   const originalEmitWarning = process.emitWarning;
   process.emitWarning = ((warning, ...args) => {
     const message = typeof warning === "string" ? warning : warning.message;
@@ -61882,22 +62907,22 @@ function loadSqlite5() {
     process.emitWarning = originalEmitWarning;
   }
 }
-var import_node_fs25, import_node_path29, DatabaseSync4, InvalidXmtpMessageStore;
+var import_node_fs26, import_node_path29, DatabaseSync5, InvalidXmtpMessageStore;
 var init_invalid_message_store = __esm({
   "src/invalid-message-store.ts"() {
     "use strict";
-    import_node_fs25 = require("node:fs");
+    import_node_fs26 = require("node:fs");
     import_node_path29 = require("node:path");
     init_paths();
-    ({ DatabaseSync: DatabaseSync4 } = loadSqlite5());
+    ({ DatabaseSync: DatabaseSync5 } = loadSqlite6());
     InvalidXmtpMessageStore = class {
       dbPath;
       db;
       constructor(homeDir) {
         const paths = resolveTaskPaths(homeDir);
         this.dbPath = (0, import_node_path29.join)(paths.sqliteDir, "invalid-xmtp-messages.sqlite");
-        (0, import_node_fs25.mkdirSync)((0, import_node_path29.dirname)(this.dbPath), { recursive: true });
-        this.db = new DatabaseSync4(this.dbPath);
+        (0, import_node_fs26.mkdirSync)((0, import_node_path29.dirname)(this.dbPath), { recursive: true });
+        this.db = new DatabaseSync5(this.dbPath);
         this.ensureReady();
       }
       close() {
@@ -62273,14 +63298,14 @@ function buildSystemMessageIdempotencyKey(input) {
   return `system-message:${identity}`;
 }
 function stableHash(value) {
-  return (0, import_node_crypto11.createHash)("sha256").update(value).digest("hex").slice(0, 24);
+  return (0, import_node_crypto12.createHash)("sha256").update(value).digest("hex").slice(0, 24);
 }
-var import_node_crypto11, DIRECTION_PREFIX, CONTENT_SEPARATOR, ADDRESS_SHORT_HEAD, ADDRESS_SHORT_TAIL, JOB_ID_HEAD, JOB_ID_TAIL, ELLIPSIS, CONTENT_MAX_LINES;
+var import_node_crypto12, DIRECTION_PREFIX, CONTENT_SEPARATOR, ADDRESS_SHORT_HEAD, ADDRESS_SHORT_TAIL, JOB_ID_HEAD, JOB_ID_TAIL, ELLIPSIS, CONTENT_MAX_LINES;
 var init_agent_message_notice = __esm({
   "src/agent-message-notice.ts"() {
     "use strict";
     init_log();
-    import_node_crypto11 = require("node:crypto");
+    import_node_crypto12 = require("node:crypto");
     init_session_store();
     init_ai_provider();
     init_outbound_behavior();
@@ -62763,7 +63788,7 @@ async function handleSqliteGroupSendCommand(params) {
     role: senderAgent?.role,
     sendDurationMs: Date.now() - sendStartMs
   });
-  const messageId = `outbound-${(0, import_node_crypto12.randomUUID)()}`;
+  const messageId = `outbound-${(0, import_node_crypto13.randomUUID)()}`;
   await notifyAgentMessageToUserAttention({
     direction: "outbound" /* OUTBOUND */,
     sender: {
@@ -62884,7 +63909,7 @@ async function handleGroupSendCommand(params) {
     sendDurationMs: Date.now() - sendStartMs
   });
   const now = Date.now();
-  const messageId = `outbound-${(0, import_node_crypto12.randomUUID)()}`;
+  const messageId = `outbound-${(0, import_node_crypto13.randomUUID)()}`;
   const stored = {
     id: messageId,
     direction: "outbound",
@@ -63103,7 +64128,7 @@ async function handleXmtpSendCommand(params) {
       sendDurationMs: Date.now() - sendStartMs
     });
     const now = Date.now();
-    const messageId = `outbound-${(0, import_node_crypto12.randomUUID)()}`;
+    const messageId = `outbound-${(0, import_node_crypto13.randomUUID)()}`;
     const stored = {
       id: messageId,
       direction: "outbound",
@@ -63149,14 +64174,14 @@ async function handleXmtpSendCommand(params) {
     ownedStore?.close();
   }
 }
-var import_node_crypto12, TASK_MIN_VERSION, sqliteGroupSessionPromises, conversationSyncPromises, XMTP_SEND_CHECKPOINT, resolvedAgentByIdCache;
+var import_node_crypto13, TASK_MIN_VERSION, sqliteGroupSessionPromises, conversationSyncPromises, XMTP_SEND_CHECKPOINT, resolvedAgentByIdCache;
 var init_xmtp_send = __esm({
   "src/xmtp-send.ts"() {
     "use strict";
     init_log();
     init_sentry_logger();
     init_log_fields();
-    import_node_crypto12 = require("node:crypto");
+    import_node_crypto13 = require("node:crypto");
     init_dist2();
     init_envelope();
     init_concurrency2();
@@ -63695,7 +64720,7 @@ function safeProcessCwd() {
 }
 function isDirectory(path2) {
   try {
-    return (0, import_node_fs26.statSync)(path2).isDirectory();
+    return (0, import_node_fs27.statSync)(path2).isDirectory();
   } catch {
     return false;
   }
@@ -65021,7 +66046,7 @@ function normalizeAttentionProvider(provider) {
   return provider === "unknown" ? null : provider;
 }
 function stableHash2(value) {
-  return (0, import_node_crypto13.createHash)("sha256").update(value).digest("hex").slice(0, 24);
+  return (0, import_node_crypto14.createHash)("sha256").update(value).digest("hex").slice(0, 24);
 }
 function formatCommand(args) {
   return args.map(shellQuote).join(" ");
@@ -65045,13 +66070,13 @@ function shortenJobId2(jobId) {
   }
   return `${jobId.slice(0, 6)}\u2026${jobId.slice(-4)}`;
 }
-var import_node_crypto13, import_node_fs26, import_promises12, import_node_os9, import_node_path31, AiRunner, CODEX_TOOL_FAILURE_MARKER;
+var import_node_crypto14, import_node_fs27, import_promises12, import_node_os9, import_node_path31, AiRunner, CODEX_TOOL_FAILURE_MARKER;
 var init_ai_runner = __esm({
   "src/ai-runner.ts"() {
     "use strict";
     init_log();
-    import_node_crypto13 = require("node:crypto");
-    import_node_fs26 = require("node:fs");
+    import_node_crypto14 = require("node:crypto");
+    import_node_fs27 = require("node:fs");
     import_promises12 = require("node:fs/promises");
     import_node_os9 = require("node:os");
     import_node_path31 = require("node:path");
@@ -65199,7 +66224,7 @@ var init_ai_runner = __esm({
         ensureTaskDir(this.logsDir);
         const lifecycleLogsEnabled = isAiLifecycleLoggingEnabled();
         const logPath = lifecycleLogsEnabled ? this.buildRunLogPath(request) : "";
-        const log = lifecycleLogsEnabled ? (0, import_node_fs26.createWriteStream)(logPath, { flags: "a" }) : null;
+        const log = lifecycleLogsEnabled ? (0, import_node_fs27.createWriteStream)(logPath, { flags: "a" }) : null;
         let existing = null;
         let storeReadStartedAt;
         let storeReadEndedAt;
@@ -67671,6 +68696,409 @@ var init_command_processor = __esm({
   }
 });
 
+// src/devkit-types.ts
+var DEVKIT_MAX_CONCURRENCY, DEVKIT_MAX_PENDING, DEVKIT_MAX_PENDING_BYTES, DEVKIT_MAX_MESSAGE_BYTES, DEVKIT_REQUEST_BUDGET_MS, DEVKIT_RESPONSE_DIAGNOSTIC_MAX_BYTES, DEVKIT_RESPONSE_SUMMARY_MAX_CHARS, DEVKIT_OUTCOME, DEVKIT_DROP_REASON;
+var init_devkit_types = __esm({
+  "src/devkit-types.ts"() {
+    "use strict";
+    DEVKIT_MAX_CONCURRENCY = 16;
+    DEVKIT_MAX_PENDING = 256;
+    DEVKIT_MAX_PENDING_BYTES = 16 * 1024 * 1024;
+    DEVKIT_MAX_MESSAGE_BYTES = 1 * 1024 * 1024;
+    DEVKIT_REQUEST_BUDGET_MS = 5e3;
+    DEVKIT_RESPONSE_DIAGNOSTIC_MAX_BYTES = 4 * 1024;
+    DEVKIT_RESPONSE_SUMMARY_MAX_CHARS = 256;
+    DEVKIT_OUTCOME = {
+      HTTP_ACCEPTED: "http_accepted",
+      DROPPED: "dropped"
+    };
+    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
+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, sep4) => `${keyQuote}${key}${keyQuoteClose}${sep4}[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_promises13.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((resolve14) => setTimeout(resolve14, Math.max(0, ms)));
+}
+var import_node_net2, import_promises13, COMPONENT, SECRET_KEYS, SECRET_SCHEME_PATTERN, SECRET_KV_PATTERN, DevkitDeliveryDispatcher;
+var init_devkit_delivery = __esm({
+  "src/devkit-delivery.ts"() {
+    "use strict";
+    import_node_net2 = require("node:net");
+    import_promises13 = require("node:dns/promises");
+    init_sentry_logger();
+    init_error_diagnostics();
+    init_devkit_types();
+    COMPONENT = "node_devkit";
+    SECRET_KEYS = "authorization|bearer|basic|jwt|password|api[_-]?key|secret|token";
+    SECRET_SCHEME_PATTERN = new RegExp(`\\b(?:${SECRET_KEYS})\\s+\\S+`, "gi");
+    SECRET_KV_PATTERN = new RegExp(
+      `("?)(${SECRET_KEYS})("?)\\s*([:=])\\s*"?[^"\\s,}]+`,
+      "gi"
+    );
+    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 (err2) {
+          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,
+            err2 instanceof Error ? err2 : void 0,
+            {}
+          );
+          const reason = classifyFetchFailure({
+            cancelledByShutdown: item.cancelledByShutdown,
+            timedOut: item.timedOut,
+            errorCategory: diagnostics.errorCategory
+          });
+          this.emitHttpFailed(item, reason, diagnostics, durationMs2, err2 instanceof Error ? err2 : 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, err2) {
+        logger.error(LogEvent.DEVKIT_DELIVERY_HTTP_FAILED, err2, {
+          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);
@@ -67702,6 +69130,95 @@ var init_ai_dispatch_queue = __esm({
   }
 });
 
+// src/devkit-router.ts
+function createDevkitAutoRouter(deps) {
+  const { commands, dispatcher, readSnapshot } = deps;
+  function readConfigOrNull(phase) {
+    try {
+      return { ok: true, config: readSnapshot() };
+    } catch (err2) {
+      logger.error(
+        LogEvent.DEVKIT_ROUTE_CONFIG_READ_FAILED,
+        err2 instanceof Error ? err2 : new Error(String(err2)),
+        {
+          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 };
+}
+var init_devkit_router = __esm({
+  "src/devkit-router.ts"() {
+    "use strict";
+    init_ai_dispatch_queue();
+    init_devkit_delivery();
+    init_sentry_logger();
+  }
+});
+
 // src/message-handler.ts
 function tryMarkProcessed(messageId) {
   if (processedMessageIds.has(messageId)) {
@@ -68691,7 +70208,7 @@ async function processFileMessage(ctx, deps, options = {}) {
   timing.mark("payloadParse", parseStartedAt);
   const directToUser = chatType === "dm" && parseResult.ok ? extractDirectToUserNotification(parseResult.data) : { kind: "none" };
   if (directToUser.kind === "invalid") {
-    const droppedMessageId = messageId || `direct-to-user-${(0, import_node_crypto14.randomUUID)()}`;
+    const droppedMessageId = messageId || `direct-to-user-${(0, import_node_crypto15.randomUUID)()}`;
     logger.error(
       LogEvent.INBOUND_DROP_DM_INVALID_PAYLOAD,
       new Error("Invalid direct-to-user system DM"),
@@ -68715,7 +70232,7 @@ async function processFileMessage(ctx, deps, options = {}) {
     await dispatchDirectToUserNotification({
       deps,
       notification: directToUser.notification,
-      messageId: messageId || `direct-to-user-${(0, import_node_crypto14.randomUUID)()}`,
+      messageId: messageId || `direct-to-user-${(0, import_node_crypto15.randomUUID)()}`,
       timing,
       source: options.source ?? "live"
     });
@@ -68723,7 +70240,7 @@ async function processFileMessage(ctx, deps, options = {}) {
   }
   const systemNotification = chatType === "dm" && parseResult.ok ? extractSystemNotification(parseResult.data) : null;
   if (systemNotification) {
-    const systemMessageId = messageId || `system-${(0, import_node_crypto14.randomUUID)()}`;
+    const systemMessageId = messageId || `system-${(0, import_node_crypto15.randomUUID)()}`;
     logWithTimestamp(
       `[okx-agent-task:${deps.myXmtpAddress}] xmtp_system_message_received agentId=${systemNotification.agentId ?? ""} msg=${shortenLogValue(systemMessageId)} event=${systemNotification.event ?? ""} job=${shortenLogValue(systemNotification.jobId)} conv=${conversationId} source=${options.source ?? "live"} rawBytes=${Buffer.byteLength(rawText, "utf8")} rawPreview=${previewRawEnvelope(rawText)}`
     );
@@ -69019,7 +70536,7 @@ async function processFileMessage(ctx, deps, options = {}) {
       }));
       return true;
     }
-    const routedMessageId = messageId || `group-${(0, import_node_crypto14.randomUUID)()}`;
+    const routedMessageId = messageId || `group-${(0, import_node_crypto15.randomUUID)()}`;
     const sessionKey = ensureInboundGroupSession(deps, {
       jobId: route.jobId,
       myAgentId,
@@ -69085,7 +70602,7 @@ async function processFileMessage(ctx, deps, options = {}) {
     return true;
   }
   const stored = {
-    id: messageId || `local-${(0, import_node_crypto14.randomUUID)()}`,
+    id: messageId || `local-${(0, import_node_crypto15.randomUUID)()}`,
     direction: "inbound",
     route: route.route,
     routeReason: route.routeReason,
@@ -69266,7 +70783,7 @@ function processOfflineFromCoreDeps(store, ctx, deps, options) {
 function buildSystemStoredMessage(params) {
   const now = Date.now();
   return {
-    id: params.id ?? `system-${now}-${(0, import_node_crypto14.randomUUID)()}`,
+    id: params.id ?? `system-${now}-${(0, import_node_crypto15.randomUUID)()}`,
     direction: "system",
     route: "backup",
     routeReason: params.reason,
@@ -69284,12 +70801,12 @@ function buildSystemStoredMessage(params) {
 function isA2AEnvelope(payload) {
   return isPlainObject3(payload) && payload.msgType === A2A_MESSAGE_TYPE;
 }
-var import_node_crypto14, PROCESSED_IDS_MAX, processedMessageIds, EXTERNAL_JOB_ID_PATTERN, INBOUND_TRANSPORT, INBOUND_EVENT_FAMILY, INBOUND_TERMINAL_FIELDS;
+var import_node_crypto15, PROCESSED_IDS_MAX, processedMessageIds, EXTERNAL_JOB_ID_PATTERN, INBOUND_TRANSPORT, INBOUND_EVENT_FAMILY, INBOUND_TERMINAL_FIELDS;
 var init_message_handler = __esm({
   "src/message-handler.ts"() {
     "use strict";
     init_log();
-    import_node_crypto14 = require("node:crypto");
+    import_node_crypto15 = require("node:crypto");
     init_dist2();
     init_a2a();
     init_envelope_shared();
@@ -69357,7 +70874,7 @@ function isOriginalParentProcessAlive(options) {
 }
 function registerUserAttentionWatcher(options) {
   return options.store.registerUserAttentionWatcher({
-    id: options.id ?? (0, import_node_crypto15.randomUUID)(),
+    id: options.id ?? (0, import_node_crypto16.randomUUID)(),
     provider: options.provider,
     jobId: options.jobId,
     nowMs: options.nowMs ?? Date.now(),
@@ -69436,11 +70953,11 @@ function userWatchEventDeliveredSentryExtra(event) {
     hasDecision: String(event.hasDecision)
   };
 }
-var import_node_crypto15, USER_ATTENTION_WATCH_REPLACED_MESSAGE, USER_ATTENTION_WATCHER_SCAN_MS, USER_ATTENTION_WATCHER_TTL_MS, USER_ATTENTION_WATCH_PARENT_CHECK_MS;
+var import_node_crypto16, USER_ATTENTION_WATCH_REPLACED_MESSAGE, USER_ATTENTION_WATCHER_SCAN_MS, USER_ATTENTION_WATCHER_TTL_MS, USER_ATTENTION_WATCH_PARENT_CHECK_MS;
 var init_user_attention_watchers = __esm({
   "src/user-attention-watchers.ts"() {
     "use strict";
-    import_node_crypto15 = require("node:crypto");
+    import_node_crypto16 = require("node:crypto");
     init_sentry_logger();
     USER_ATTENTION_WATCH_REPLACED_MESSAGE = "Another okx-a2a user watch with the same job scope was started, so this watcher has been closed. Do not run this watch command again automatically, because starting another watcher may interrupt a different session that is already monitoring task progress.";
     USER_ATTENTION_WATCHER_SCAN_MS = 500;
@@ -69513,13 +71030,13 @@ async function getHermesGatewayPluginStatus(options = {}) {
   const env = options.env ?? process.env;
   const hermesHome = env.HERMES_HOME?.trim() || (0, import_node_path32.join)((0, import_node_os10.homedir)(), ".hermes");
   const pluginYamlPath = (0, import_node_path32.join)(hermesHome, "plugins", "platforms", "okx-a2a", "plugin.yaml");
-  if (!(0, import_node_fs27.existsSync)(pluginYamlPath)) {
+  if (!(0, import_node_fs28.existsSync)(pluginYamlPath)) {
     return { enabled: false, reason: "plugin_yaml_missing", hermesHome, checkedPath: pluginYamlPath };
   }
   const configPath = (0, import_node_path32.join)(hermesHome, "config.yaml");
   let content2;
   try {
-    content2 = await (0, import_promises13.readFile)(configPath, "utf8");
+    content2 = await (0, import_promises14.readFile)(configPath, "utf8");
   } catch {
     return { enabled: false, reason: "config_read_error", hermesHome, checkedPath: configPath };
   }
@@ -69603,12 +71120,12 @@ function parseYamlInlineEnabledList(line) {
 }
 function stopClients(service) {
   for (const [address, client] of service.getClients()) {
-    try {
-      client.stop();
-      logWithTimestamp(`[okx-agent-task] stopped XMTP client ${address}`);
-    } catch (err2) {
-      logWithTimestamp(`[okx-agent-task] failed to stop XMTP client ${address}:`, err2);
-    }
+    void stopAndCloseXmtpClient(client, {
+      address,
+      agentId: "",
+      phase: "shutdown",
+      onCloseError: (err2) => logWithTimestamp(`[okx-agent-task] failed to close XMTP client ${address}:`, err2)
+    }).then(() => logWithTimestamp(`[okx-agent-task] stopped XMTP client ${address}`)).catch((err2) => logWithTimestamp(`[okx-agent-task] failed to stop XMTP client ${address}:`, err2));
   }
 }
 async function runListener(options = {}) {
@@ -69640,6 +71157,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 {
@@ -69703,20 +71241,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) => {
@@ -69748,12 +71286,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();
@@ -69781,7 +71319,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(
@@ -70113,6 +71651,7 @@ async function runListenerWithLock(options, paths) {
           logWithTimestamp("[okx-agent-task] failed to close user_attention IPC wake:", err2);
         }
         stopClients(service);
+        await devkitDispatcher.shutdown(SHUTDOWN_FORCE_RESOLVE_MS);
         sessionStore.close();
         clearTimeout(forceResolve);
         resolve14();
@@ -70131,13 +71670,14 @@ async function timeSettled(fn) {
     return { durationMs: Date.now() - startedAt, error };
   }
 }
-var import_node_fs27, import_promises13, import_node_os10, import_node_path32, DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC, DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC, XMTP_CLIENT_RECYCLE_INTERVAL_ENV, HEARTBEAT_GATEWAY_CHECK_TIMEOUT_MS, AUTH_RECOVERY_PROBE_INTERVAL_MS, AUTH_RECOVERY_REFRESH_BACKOFF_MS, AgentRefreshAuthGate, AgentRefreshCoordinator, ListenerDeferredTaskScheduler, ListenerMaintenanceGate, UPGRADE_RECOMMENDATION_IDEMPOTENCY_KEY, SHUTDOWN_FORCE_RESOLVE_MS;
+var import_node_fs28, import_promises14, import_node_os10, import_node_path32, DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC, DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC, XMTP_CLIENT_RECYCLE_INTERVAL_ENV, HEARTBEAT_GATEWAY_CHECK_TIMEOUT_MS, AUTH_RECOVERY_PROBE_INTERVAL_MS, AUTH_RECOVERY_REFRESH_BACKOFF_MS, AgentRefreshAuthGate, AgentRefreshCoordinator, ListenerDeferredTaskScheduler, ListenerMaintenanceGate, UPGRADE_RECOMMENDATION_IDEMPOTENCY_KEY, SHUTDOWN_FORCE_RESOLVE_MS;
 var init_listener = __esm({
   "src/listener.ts"() {
     "use strict";
     init_log();
-    import_node_fs27 = require("node:fs");
-    import_promises13 = require("node:fs/promises");
+    init_client_lifecycle();
+    import_node_fs28 = require("node:fs");
+    import_promises14 = require("node:fs/promises");
     import_node_os10 = require("node:os");
     import_node_path32 = require("node:path");
     init_onchainos();
@@ -70150,7 +71690,9 @@ var init_listener = __esm({
     init_session_store();
     init_command_processor();
     init_command_store();
-    init_ai_dispatch_queue();
+    init_devkit_delivery();
+    init_devkit_router();
+    init_devkit_server_store();
     init_message_handler();
     init_agent_message_notice();
     init_paths();
@@ -70403,7 +71945,7 @@ async function startXmtpTest(args, releaseInfo) {
   const runId = requestedRunId ? validateRunId(requestedRunId) : createRunId(requestedName);
   const files = resolveRunFiles(testsDir, runId);
   try {
-    await (0, import_promises14.stat)(files.runDir);
+    await (0, import_promises15.stat)(files.runDir);
     throw new Error(`XMTP test run already exists: ${runId}`);
   } catch (error) {
     if (error.code !== "ENOENT") {
@@ -70411,7 +71953,7 @@ async function startXmtpTest(args, releaseInfo) {
     }
   }
   await ensurePrivateDir(files.runDir);
-  await (0, import_promises14.writeFile)(files.eventsPath, "", { encoding: "utf8", mode: 384 });
+  await (0, import_promises15.writeFile)(files.eventsPath, "", { encoding: "utf8", mode: 384 });
   const manifest = {
     runId,
     name: requestedName,
@@ -70455,7 +71997,7 @@ async function stopXmtpTest(args) {
   }
   const runId = validateRunId(active.runId);
   const files = resolveRunFiles(testsDir, runId);
-  await (0, import_promises14.unlink)(activePath);
+  await (0, import_promises15.unlink)(activePath);
   const manifest = await readRequiredJson(files.manifestPath);
   const completed = {
     ...manifest,
@@ -70773,7 +72315,7 @@ async function resolveRequestedRunId(testsDir, args, preferActive = false) {
 async function findLatestRunId(testsDir) {
   let entries;
   try {
-    entries = await (0, import_promises14.readdir)(testsDir, { withFileTypes: true });
+    entries = await (0, import_promises15.readdir)(testsDir, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") {
       return null;
@@ -70798,7 +72340,7 @@ async function findLatestRunId(testsDir) {
 async function readMetricEvents(path2) {
   let text;
   try {
-    text = await (0, import_promises14.readFile)(path2, "utf8");
+    text = await (0, import_promises15.readFile)(path2, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -70822,9 +72364,9 @@ function parseMetricEvent(line) {
   }
 }
 async function ensurePrivateDir(path2) {
-  await (0, import_promises14.mkdir)(path2, { recursive: true, mode: 448 });
+  await (0, import_promises15.mkdir)(path2, { recursive: true, mode: 448 });
   try {
-    await (0, import_promises14.chmod)(path2, 448);
+    await (0, import_promises15.chmod)(path2, 448);
   } catch (error) {
     const code = error.code;
     if (code !== "EPERM" && code !== "EACCES") {
@@ -70834,12 +72376,12 @@ async function ensurePrivateDir(path2) {
 }
 async function writeJson(path2, value) {
   const temporary = `${path2}.${process.pid}.tmp`;
-  await (0, import_promises14.writeFile)(temporary, `${JSON.stringify(value, null, 2)}
+  await (0, import_promises15.writeFile)(temporary, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
   });
-  await (0, import_promises14.rename)(temporary, path2);
+  await (0, import_promises15.rename)(temporary, path2);
 }
 async function readRequiredJson(path2) {
   const value = await readJsonIfExists(path2);
@@ -70850,7 +72392,7 @@ async function readRequiredJson(path2) {
 }
 async function readJsonIfExists(path2) {
   try {
-    return JSON.parse(await (0, import_promises14.readFile)(path2, "utf8"));
+    return JSON.parse(await (0, import_promises15.readFile)(path2, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") {
       return null;
@@ -71021,11 +72563,11 @@ function formatPercent(value) {
 function validTimestamp(value) {
   return typeof value === "string" && Number.isFinite(Date.parse(value));
 }
-var import_promises14, import_node_path33, RUN_ID_PATTERN2, ACTIVE_FILE;
+var import_promises15, import_node_path33, RUN_ID_PATTERN2, ACTIVE_FILE;
 var init_xmtp_test_cli = __esm({
   "src/xmtp-test-cli.ts"() {
     "use strict";
-    import_promises14 = require("node:fs/promises");
+    import_promises15 = require("node:fs/promises");
     import_node_path33 = require("node:path");
     init_daemon();
     init_log_tail();
@@ -114004,10 +115546,10 @@ var require_node4 = __commonJS({
 
 // ../../node_modules/@xmtp/content-type-remote-attachment/dist/index.js
 async function encrypt(plain, secret, additionalData) {
-  const salt = import_node_crypto16.webcrypto.getRandomValues(new Uint8Array(KDFSaltSize));
-  const nonce = import_node_crypto16.webcrypto.getRandomValues(new Uint8Array(AESGCMNonceSize));
+  const salt = import_node_crypto17.webcrypto.getRandomValues(new Uint8Array(KDFSaltSize));
+  const nonce = import_node_crypto17.webcrypto.getRandomValues(new Uint8Array(AESGCMNonceSize));
   const key = await hkdf(secret, salt);
-  const encrypted = await import_node_crypto16.webcrypto.subtle.encrypt(aesGcmParams(nonce), key, plain);
+  const encrypted = await import_node_crypto17.webcrypto.subtle.encrypt(aesGcmParams(nonce), key, plain);
   return new Ciphertext({
     aes256GcmHkdfSha256: {
       payload: new Uint8Array(encrypted),
@@ -114021,7 +115563,7 @@ async function decrypt(encrypted, secret, additionalData) {
     throw new Error("invalid payload ciphertext");
   }
   const key = await hkdf(secret, encrypted.aes256GcmHkdfSha256.hkdfSalt);
-  const decrypted = await import_node_crypto16.webcrypto.subtle.decrypt(aesGcmParams(encrypted.aes256GcmHkdfSha256.gcmNonce), key, encrypted.aes256GcmHkdfSha256.payload);
+  const decrypted = await import_node_crypto17.webcrypto.subtle.decrypt(aesGcmParams(encrypted.aes256GcmHkdfSha256.gcmNonce), key, encrypted.aes256GcmHkdfSha256.payload);
   return new Uint8Array(decrypted);
 }
 function aesGcmParams(nonce, additionalData) {
@@ -114032,18 +115574,18 @@ function aesGcmParams(nonce, additionalData) {
   return spec;
 }
 async function hkdf(secret, salt) {
-  const key = await import_node_crypto16.webcrypto.subtle.importKey("raw", secret, "HKDF", false, [
+  const key = await import_node_crypto17.webcrypto.subtle.importKey("raw", secret, "HKDF", false, [
     "deriveKey"
   ]);
-  return import_node_crypto16.webcrypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt, info: hkdfNoInfo }, key, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+  return import_node_crypto17.webcrypto.subtle.deriveKey({ name: "HKDF", hash: "SHA-256", salt, info: hkdfNoInfo }, key, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
 }
-var import_proto, import_node_crypto16, ContentTypeAttachment, AttachmentCodec, KDFSaltSize, AESGCMNonceSize, AESGCMTagLength, Ciphertext, hkdfNoInfo, ContentTypeRemoteAttachment, RemoteAttachmentCodec;
+var import_proto, import_node_crypto17, ContentTypeAttachment, AttachmentCodec, KDFSaltSize, AESGCMNonceSize, AESGCMTagLength, Ciphertext, hkdfNoInfo, ContentTypeRemoteAttachment, RemoteAttachmentCodec;
 var init_dist6 = __esm({
   "../../node_modules/@xmtp/content-type-remote-attachment/dist/index.js"() {
     init_dist5();
     init_secp256k12();
     import_proto = __toESM(require_node4(), 1);
-    import_node_crypto16 = require("node:crypto");
+    import_node_crypto17 = require("node:crypto");
     ContentTypeAttachment = new ContentTypeId({
       authorityId: "xmtp.org",
       typeId: "attachment",
@@ -114123,7 +115665,7 @@ var init_dist6 = __esm({
         if (payload.length === 0) {
           throw new Error(`no payload for remote attachment at ${remoteAttachment.url}`);
         }
-        const digestBytes = new Uint8Array(await import_node_crypto16.webcrypto.subtle.digest("SHA-256", payload));
+        const digestBytes = new Uint8Array(await import_node_crypto17.webcrypto.subtle.digest("SHA-256", payload));
         const digest = etc.bytesToHex(digestBytes);
         if (digest !== remoteAttachment.contentDigest) {
           throw new Error("content digest does not match");
@@ -114147,7 +115689,7 @@ var init_dist6 = __esm({
         return codec.decode(encodedContent, codecRegistry);
       }
       static async encodeEncrypted(content$1, codec) {
-        const secret = import_node_crypto16.webcrypto.getRandomValues(new Uint8Array(32));
+        const secret = import_node_crypto17.webcrypto.getRandomValues(new Uint8Array(32));
         const encodedContent = import_proto.content.EncodedContent.encode(codec.encode(content$1, {
           codecFor() {
             return void 0;
@@ -114160,7 +115702,7 @@ var init_dist6 = __esm({
         if (!salt || !nonce || !payload) {
           throw new Error("missing encryption key");
         }
-        const digestBytes = new Uint8Array(await import_node_crypto16.webcrypto.subtle.digest("SHA-256", payload));
+        const digestBytes = new Uint8Array(await import_node_crypto17.webcrypto.subtle.digest("SHA-256", payload));
         const digest = etc.bytesToHex(digestBytes);
         return {
           digest,
@@ -114216,7 +115758,7 @@ var init_dist6 = __esm({
 // ../core/src/file-upload-safety.ts
 function getUnsafeFileUploadReason(filePath, sensitiveUploadReg = []) {
   const expanded = (0, import_node_path34.resolve)(expandHome(filePath));
-  const target = (0, import_node_fs28.realpathSync)(expanded);
+  const target = (0, import_node_fs29.realpathSync)(expanded);
   const targetName = (0, import_node_path34.basename)(target);
   if (targetName === ".env" || targetName.startsWith(".env.")) {
     return ".env";
@@ -114270,19 +115812,19 @@ function expandHome(filePath) {
   return filePath;
 }
 function safeRealpath(path2) {
-  if (!(0, import_node_fs28.existsSync)(path2)) {
+  if (!(0, import_node_fs29.existsSync)(path2)) {
     return null;
   }
-  return (0, import_node_fs28.realpathSync)(path2);
+  return (0, import_node_fs29.realpathSync)(path2);
 }
 function isPathInside(target, dir) {
   return target === dir || target.startsWith(`${dir}${import_node_path34.sep}`);
 }
-var import_node_fs28, import_node_os11, import_node_path34, SENSITIVE_HOME_DIRS, SENSITIVE_HOME_FILES, UNSAFE_FILE_UPLOAD_MESSAGE;
+var import_node_fs29, import_node_os11, import_node_path34, SENSITIVE_HOME_DIRS, SENSITIVE_HOME_FILES, UNSAFE_FILE_UPLOAD_MESSAGE;
 var init_file_upload_safety = __esm({
   "../core/src/file-upload-safety.ts"() {
     "use strict";
-    import_node_fs28 = require("node:fs");
+    import_node_fs29 = require("node:fs");
     import_node_os11 = require("node:os");
     import_node_path34 = require("node:path");
     SENSITIVE_HOME_DIRS = [
@@ -114370,16 +115912,16 @@ async function uploadFile(params) {
     return;
   }
   const maxFileSizeBytes = uploadConfig.maxFileSizeBytes;
-  const fileSize = (0, import_node_fs29.statSync)(params.filePath).size;
+  const fileSize = (0, import_node_fs30.statSync)(params.filePath).size;
   if (fileSize > maxFileSizeBytes) {
     throw new Error(formatFileTooLargeMessage(maxFileSizeBytes));
   }
-  const data = (0, import_node_fs29.readFileSync)(params.filePath);
+  const data = (0, import_node_fs30.readFileSync)(params.filePath);
   const attachment = { filename, mimeType, data: new Uint8Array(data) };
   const encrypted = await RemoteAttachmentCodec.encodeEncrypted(attachment, new AttachmentCodec());
   ensureFileDirs();
-  const encryptedPath = (0, import_node_path35.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto17.randomUUID)()}.enc`);
-  (0, import_node_fs29.writeFileSync)(encryptedPath, encrypted.payload);
+  const encryptedPath = (0, import_node_path35.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto18.randomUUID)()}.enc`);
+  (0, import_node_fs30.writeFileSync)(encryptedPath, encrypted.payload);
   try {
     const stdout = runOnchainos([
       "agent",
@@ -114415,14 +115957,14 @@ async function uploadFile(params) {
     }, null, 2));
   } finally {
     try {
-      (0, import_node_fs29.unlinkSync)(encryptedPath);
+      (0, import_node_fs30.unlinkSync)(encryptedPath);
     } catch {
     }
   }
 }
 async function downloadFile(params) {
   ensureFileDirs();
-  const encryptedPath = (0, import_node_path35.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto17.randomUUID)()}.enc`);
+  const encryptedPath = (0, import_node_path35.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto18.randomUUID)()}.enc`);
   try {
     const stdout = runOnchainos([
       "agent",
@@ -114446,8 +115988,8 @@ async function downloadFile(params) {
       }));
       throw new Error(`file download failed: ${stdout}`);
     }
-    const payload = new Uint8Array((0, import_node_fs29.readFileSync)(encryptedPath));
-    const digestBytes = new Uint8Array(await import_node_crypto17.webcrypto.subtle.digest("SHA-256", payload));
+    const payload = new Uint8Array((0, import_node_fs30.readFileSync)(encryptedPath));
+    const digestBytes = new Uint8Array(await import_node_crypto18.webcrypto.subtle.digest("SHA-256", payload));
     const actualDigest = Array.from(digestBytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
     if (actualDigest !== params.digest) {
       throw new Error(`file download digest verification failed: expected=${params.digest}, actual=${actualDigest}`);
@@ -114455,15 +115997,15 @@ async function downloadFile(params) {
     const decryptedBytes = await decryptAttachmentPayload(payload, params);
     const encodedContent = import_proto2.content.EncodedContent.decode(decryptedBytes);
     const attachment = new AttachmentCodec().decode(encodedContent);
-    const outputFilename = params.filename || attachment.filename || `${(0, import_node_crypto17.randomUUID)()}.bin`;
+    const outputFilename = params.filename || attachment.filename || `${(0, import_node_crypto18.randomUUID)()}.bin`;
     const outputDir = DOWNLOADS_DIR;
     ensureA2aTaskDir(outputDir);
     const outputPath = (0, import_node_path35.resolve)(outputDir, (0, import_node_path35.basename)(outputFilename));
-    (0, import_node_fs29.writeFileSync)(outputPath, attachment.data);
+    (0, import_node_fs30.writeFileSync)(outputPath, attachment.data);
     console.log(outputPath);
   } finally {
     try {
-      (0, import_node_fs29.unlinkSync)(encryptedPath);
+      (0, import_node_fs30.unlinkSync)(encryptedPath);
     } catch {
     }
   }
@@ -114472,15 +116014,15 @@ async function decryptAttachmentPayload(payload, params) {
   const secretBytes = new Uint8Array(Buffer.from(params.secret, "base64"));
   const saltBytes = new Uint8Array(Buffer.from(params.salt, "base64"));
   const nonceBytes = new Uint8Array(Buffer.from(params.nonce, "base64"));
-  const hkdfKey = await import_node_crypto17.webcrypto.subtle.importKey("raw", secretBytes, "HKDF", false, ["deriveKey"]);
-  const aesKey = await import_node_crypto17.webcrypto.subtle.deriveKey(
+  const hkdfKey = await import_node_crypto18.webcrypto.subtle.importKey("raw", secretBytes, "HKDF", false, ["deriveKey"]);
+  const aesKey = await import_node_crypto18.webcrypto.subtle.deriveKey(
     { name: "HKDF", hash: "SHA-256", salt: saltBytes, info: new Uint8Array().buffer },
     hkdfKey,
     { name: "AES-GCM", length: 256 },
     false,
     ["decrypt"]
   );
-  return new Uint8Array(await import_node_crypto17.webcrypto.subtle.decrypt({ name: "AES-GCM", iv: nonceBytes }, aesKey, toArrayBuffer(payload)));
+  return new Uint8Array(await import_node_crypto18.webcrypto.subtle.decrypt({ name: "AES-GCM", iv: nonceBytes }, aesKey, toArrayBuffer(payload)));
 }
 function toArrayBuffer(bytes) {
   return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
@@ -114560,7 +116102,7 @@ function readUploadSystemConfig() {
     const res = parseCliJson2(stdout, "system-config");
     if (res.data && typeof res.data === "object") {
       ensureA2aTaskDir(OKX_A2A_PATHS.xmtpDir);
-      (0, import_node_fs29.writeFileSync)(SYSTEM_CONFIG_PATH, JSON.stringify(res.data));
+      (0, import_node_fs30.writeFileSync)(SYSTEM_CONFIG_PATH, JSON.stringify(res.data));
     }
     return parseUploadSystemConfig(res.data ?? {});
   } catch {
@@ -114583,10 +116125,10 @@ function fileCliSentryExtra(operation, reason, extra = {}) {
 }
 function readSystemConfigFromCache() {
   try {
-    if (!(0, import_node_fs29.existsSync)(SYSTEM_CONFIG_PATH)) {
+    if (!(0, import_node_fs30.existsSync)(SYSTEM_CONFIG_PATH)) {
       return null;
     }
-    return JSON.parse((0, import_node_fs29.readFileSync)(SYSTEM_CONFIG_PATH, "utf8"));
+    return JSON.parse((0, import_node_fs30.readFileSync)(SYSTEM_CONFIG_PATH, "utf8"));
   } catch {
     return null;
   }
@@ -114620,13 +116162,13 @@ function readRequiredOption(args, name) {
   }
   return value;
 }
-var import_node_crypto17, import_node_fs29, import_node_path35, import_proto2, OKX_A2A_PATHS, OKX_A2A_HOME_DIR, FILE_WORK_DIR, DOWNLOADS_DIR, SYSTEM_CONFIG_PATH;
+var import_node_crypto18, import_node_fs30, import_node_path35, import_proto2, OKX_A2A_PATHS, OKX_A2A_HOME_DIR, FILE_WORK_DIR, DOWNLOADS_DIR, SYSTEM_CONFIG_PATH;
 var init_file_cli = __esm({
   "src/file-cli.ts"() {
     "use strict";
     init_win_spawn();
-    import_node_crypto17 = require("node:crypto");
-    import_node_fs29 = require("node:fs");
+    import_node_crypto18 = require("node:crypto");
+    import_node_fs30 = require("node:fs");
     import_node_path35 = require("node:path");
     init_dist6();
     import_proto2 = __toESM(require_node4());
@@ -114649,12 +116191,12 @@ __export(user_attention_cli_exports, {
 });
 async function handleUserCommand(args) {
   const subcommand = args[0];
-  if (!subcommand || args.every(isHelpArg2)) {
+  if (!subcommand || args.every(isHelpArg3)) {
     printUserUsage();
     return;
   }
   if (subcommand === "help") {
-    const helpTarget = args.slice(1).find((arg) => !isHelpArg2(arg));
+    const helpTarget = args.slice(1).find((arg) => !isHelpArg3(arg));
     if (!helpTarget) {
       printUserUsage();
       return;
@@ -114671,7 +116213,7 @@ async function handleUserCommand(args) {
     return;
   }
   const commandStartedAt = Date.now();
-  const parsed = parseArgs2(args.slice(1));
+  const parsed = parseArgs3(args.slice(1));
   const json = parsed.flags.has("json");
   const storeInitStartedAt = Date.now();
   const store = new SessionStore();
@@ -114788,7 +116330,7 @@ async function handleUserCommand(args) {
 function hasHelpFlag2(args) {
   return args.some((arg) => arg === "-h" || arg === "--help");
 }
-function isHelpArg2(arg) {
+function isHelpArg3(arg) {
   return arg === "-h" || arg === "--help" || arg === "help";
 }
 function printUserUsage() {
@@ -115120,7 +116662,7 @@ async function watchUserAttentionViaDaemon(store, parsed, json, options) {
         nextHeartbeatAt = Date.now() + Math.min(1e3, Math.max(100, pollMs));
       }
       const waitMs = deadline ? Math.max(0, Math.min(pollMs, USER_ATTENTION_WATCH_PARENT_CHECK_MS, deadline - Date.now())) : Math.min(pollMs, USER_ATTENTION_WATCH_PARENT_CHECK_MS);
-      await sleep4(waitMs);
+      await sleep5(waitMs);
     }
   } finally {
     watcherCleanup.cleanup();
@@ -115140,7 +116682,7 @@ async function registerWatcherWithBusyRetry(options) {
       if (!isSqliteBusyError(err2) || attempt >= attempts) {
         throw err2;
       }
-      await sleep4(250 * attempt);
+      await sleep5(250 * attempt);
     }
   }
 }
@@ -115266,7 +116808,7 @@ function createWakeSignal() {
     }
   };
 }
-function sleep4(ms) {
+function sleep5(ms) {
   return new Promise((resolve14) => setTimeout(resolve14, ms));
 }
 function output(json, payload, human) {
@@ -115307,7 +116849,7 @@ function runSyncWithoutConsoleOutput(fn) {
     console.error = originalError;
   }
 }
-function parseArgs2(args) {
+function parseArgs3(args) {
   const positional = [];
   const options = /* @__PURE__ */ new Map();
   const flags = /* @__PURE__ */ new Set();
@@ -115761,12 +117303,12 @@ __export(session_cli_exports, {
 });
 async function handleSessionCommand(args) {
   const subcommand = args[0];
-  if (!subcommand || args.every(isHelpArg3)) {
+  if (!subcommand || args.every(isHelpArg4)) {
     printSessionUsage();
     return;
   }
   if (subcommand === "help") {
-    const helpTarget = args.slice(1).find((arg) => !isHelpArg3(arg));
+    const helpTarget = args.slice(1).find((arg) => !isHelpArg4(arg));
     if (!helpTarget) {
       printSessionUsage();
       return;
@@ -115782,7 +117324,7 @@ async function handleSessionCommand(args) {
     }
     return;
   }
-  const parsed = parseArgs3(args.slice(1));
+  const parsed = parseArgs4(args.slice(1));
   const json = parsed.flags.has("json");
   const store = new SessionStore();
   let usedOpenClawGateway = false;
@@ -115948,9 +117490,9 @@ async function handleSessionCommand(args) {
   }
 }
 function hasHelpFlag3(args) {
-  return args.some(isHelpArg3);
+  return args.some(isHelpArg4);
 }
-function isHelpArg3(arg) {
+function isHelpArg4(arg) {
   return arg === "-h" || arg === "--help" || arg === "help";
 }
 function printSessionUsage() {
@@ -116756,7 +118298,7 @@ function normalizeOptionalText4(value) {
   const normalized = value?.trim();
   return normalized ? normalized : null;
 }
-function parseArgs3(args) {
+function parseArgs4(args) {
   const positional = [];
   const options = /* @__PURE__ */ new Map();
   const flags = /* @__PURE__ */ new Set();
@@ -116839,7 +118381,7 @@ async function handleXmtpDebugCli(args) {
     throw new Error(`Unknown xmtp-debug command: ${subcommand}`);
   }
   const action = subcommand;
-  const parsed = parseArgs4(args.slice(1));
+  const parsed = parseArgs5(args.slice(1));
   rejectAccountOverride(parsed);
   const groupId = parsed.options.get("group-id");
   const jobId = parsed.options.get("job-id");
@@ -116933,7 +118475,7 @@ Options:
   --json              Print machine-readable JSON.
 `);
 }
-function parseArgs4(args) {
+function parseArgs5(args) {
   const options = /* @__PURE__ */ new Map();
   const flags = /* @__PURE__ */ new Set();
   for (let index2 = 0; index2 < args.length; index2 += 1) {
@@ -117021,7 +118563,7 @@ async function handleAiCommand(args) {
     return;
   }
   const subcommand = args[0] ?? "status";
-  const parsed = parseArgs5(args.slice(1));
+  const parsed = parseArgs6(args.slice(1));
   const json = parsed.flags.has("json");
   const store = new SessionStore();
   try {
@@ -117145,7 +118687,7 @@ function output4(json, payload, human) {
   }
   console.log(human);
 }
-function parseArgs5(args) {
+function parseArgs6(args) {
   const positional = [];
   const options = /* @__PURE__ */ new Map();
   const flags = /* @__PURE__ */ new Set();
@@ -117201,7 +118743,7 @@ function isPostjectRunnable() {
 function resolvePostjectCommand() {
   try {
     const cliPath = (0, import_node_module.createRequire)(__filename).resolve("postject/dist/cli.js");
-    if ((0, import_node_fs30.existsSync)(cliPath)) {
+    if ((0, import_node_fs31.existsSync)(cliPath)) {
       return { command: process.execPath, prefixArgs: [cliPath] };
     }
   } catch {
@@ -117272,26 +118814,26 @@ function buildSeaConfig(entryPath, blobPath) {
 }
 async function installWindowsNativeLauncher(options) {
   const nodeExe = options.nodeExe ?? process.execPath;
-  if (!(0, import_node_fs30.existsSync)(options.cliPath)) {
+  if (!(0, import_node_fs31.existsSync)(options.cliPath)) {
     throw new Error(`cannot build okx-a2a.exe: CLI entry not found at ${options.cliPath}`);
   }
-  if (!(0, import_node_fs30.existsSync)(nodeExe)) {
+  if (!(0, import_node_fs31.existsSync)(nodeExe)) {
     throw new Error(`cannot build okx-a2a.exe: node executable not found at ${nodeExe}`);
   }
   const exePath = (0, import_node_path36.join)(options.targetDir, NATIVE_LAUNCHER_EXE_NAME);
-  (0, import_node_fs30.mkdirSync)(options.targetDir, { recursive: true });
-  const work = (0, import_node_fs30.mkdtempSync)((0, import_node_path36.join)((0, import_node_os12.tmpdir)(), "okx-a2a-sea-"));
+  (0, import_node_fs31.mkdirSync)(options.targetDir, { recursive: true });
+  const work = (0, import_node_fs31.mkdtempSync)((0, import_node_path36.join)((0, import_node_os12.tmpdir)(), "okx-a2a-sea-"));
   try {
     const entryPath = (0, import_node_path36.join)(work, "launcher-entry.js");
     const blobPath = (0, import_node_path36.join)(work, "okx-a2a.blob");
     const configPath = (0, import_node_path36.join)(work, "sea-config.json");
-    (0, import_node_fs30.writeFileSync)(entryPath, buildLauncherEntryJs(options.cliPath), "utf8");
-    (0, import_node_fs30.writeFileSync)(configPath, buildSeaConfig(entryPath, blobPath), "utf8");
+    (0, import_node_fs31.writeFileSync)(entryPath, buildLauncherEntryJs(options.cliPath), "utf8");
+    (0, import_node_fs31.writeFileSync)(configPath, buildSeaConfig(entryPath, blobPath), "utf8");
     (0, import_node_child_process9.execFileSync)(nodeExe, ["--experimental-sea-config", configPath], {
       stdio: "ignore",
       windowsHide: true
     });
-    (0, import_node_fs30.copyFileSync)(nodeExe, exePath);
+    (0, import_node_fs31.copyFileSync)(nodeExe, exePath);
     const isMac = process.platform === "darwin";
     if (isMac) {
       try {
@@ -117311,10 +118853,10 @@ async function installWindowsNativeLauncher(options) {
     );
     return { exePath, cliPath: options.cliPath, nodeExe };
   } finally {
-    (0, import_node_fs30.rmSync)(work, { recursive: true, force: true });
+    (0, import_node_fs31.rmSync)(work, { recursive: true, force: true });
   }
 }
-function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2 = import_node_fs30.existsSync) {
+function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2 = import_node_fs31.existsSync) {
   const dirs = pathValue.split(";").map((d) => d.trim()).filter(Boolean);
   if (appData) {
     dirs.push((0, import_node_path36.join)(appData, "npm"));
@@ -117332,11 +118874,11 @@ function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2
 }
 function resolveRunningCliPath() {
   const fromArgv = process.argv[1];
-  if (fromArgv && /(?:^|[\\/])cli\.js$/.test(fromArgv) && (0, import_node_fs30.existsSync)(fromArgv)) {
+  if (fromArgv && /(?:^|[\\/])cli\.js$/.test(fromArgv) && (0, import_node_fs31.existsSync)(fromArgv)) {
     return fromArgv;
   }
   const beside = (0, import_node_path36.join)(__dirname, "cli.js");
-  if ((0, import_node_fs30.existsSync)(beside)) {
+  if ((0, import_node_fs31.existsSync)(beside)) {
     return beside;
   }
   if (fromArgv) {
@@ -117358,12 +118900,12 @@ async function ensureWindowsNativeLauncher(options = {}) {
   const result = await installWindowsNativeLauncher({ cliPath: resolveRunningCliPath(), targetDir });
   return { exePath: result.exePath, installed: true };
 }
-var import_node_child_process9, import_node_fs30, import_node_module, import_node_os12, import_node_path36, SEA_SENTINEL_FUSE, NATIVE_LAUNCHER_EXE_NAME, POSTJECT_SPEC, POSTJECT_BIN;
+var import_node_child_process9, import_node_fs31, import_node_module, import_node_os12, import_node_path36, 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_process9 = require("node:child_process");
-    import_node_fs30 = require("node:fs");
+    import_node_fs31 = require("node:fs");
     import_node_module = require("node:module");
     import_node_os12 = require("node:os");
     import_node_path36 = require("node:path");
@@ -117505,7 +119047,7 @@ function buildProviderMismatchWarning(target, provider) {
   ].join("\n");
 }
 async function handleUpdateCommand(args) {
-  if (args.some(isHelpArg4)) {
+  if (args.some(isHelpArg5)) {
     printUpdateUsage();
     return;
   }
@@ -117546,7 +119088,7 @@ function resolveUpdateTarget(target) {
   return detectGatewayInvocation() ?? "node";
 }
 async function handleSetupCommand(args) {
-  if (args.some(isHelpArg4)) {
+  if (args.some(isHelpArg5)) {
     printSetupUsage();
     return;
   }
@@ -118123,7 +119665,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;
@@ -118308,7 +119850,7 @@ async function updateHermes(release, options) {
     assertNotRunningInsideGateway("hermes");
   }
   const spec = buildNpmPackageSpec("hermes", release);
-  const workDir = await (0, import_promises15.mkdtemp)((0, import_node_path37.join)((0, import_node_os13.tmpdir)(), `okx-a2a-${label}-hermes-`));
+  const workDir = await (0, import_promises16.mkdtemp)((0, import_node_path37.join)((0, import_node_os13.tmpdir)(), `okx-a2a-${label}-hermes-`));
   try {
     console.log(`[${label}] downloading ${spec}`);
     const npmTarball = await npmPack(spec, workDir);
@@ -118329,11 +119871,11 @@ async function updateHermes(release, options) {
     }
     console.log(`[${label}] hermes ${label} done`);
   } finally {
-    await (0, import_promises15.rm)(workDir, { recursive: true, force: true });
+    await (0, import_promises16.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,
@@ -118360,7 +119902,7 @@ function setupReadyMessage(target) {
 async function normalizeHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPath()) {
   let content2;
   try {
-    content2 = await (0, import_promises15.readFile)(configFile, "utf8");
+    content2 = await (0, import_promises16.readFile)(configFile, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return false;
@@ -118371,21 +119913,21 @@ async function normalizeHermesOkxA2aPluginConfig(configFile = resolveHermesConfi
   if (!normalized.changed) {
     return false;
   }
-  await (0, import_promises15.writeFile)(configFile, normalized.content);
+  await (0, import_promises16.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 content2;
   try {
-    content2 = await (0, import_promises15.readFile)(configFile, "utf8");
+    content2 = await (0, import_promises16.readFile)(configFile, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       if (options.dryRun) {
         return true;
       }
-      await (0, import_promises15.mkdir)((0, import_node_path37.resolve)(configFile, ".."), { recursive: true });
-      await (0, import_promises15.writeFile)(configFile, "plugins:\n  enabled:\n    - okx-a2a\n");
+      await (0, import_promises16.mkdir)((0, import_node_path37.resolve)(configFile, ".."), { recursive: true });
+      await (0, import_promises16.writeFile)(configFile, "plugins:\n  enabled:\n    - okx-a2a\n");
       console.log(`[update] added Hermes plugins.enabled okx-a2a entry in ${configFile}`);
       return true;
     }
@@ -118396,7 +119938,7 @@ async function ensureHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPa
     if (options.dryRun) {
       return true;
     }
-    await (0, import_promises15.writeFile)(configFile, normalized.content);
+    await (0, import_promises16.writeFile)(configFile, normalized.content);
     console.log(`[update] normalized Hermes plugins.enabled okx-a2a entry in ${configFile}`);
     return true;
   }
@@ -118407,7 +119949,7 @@ async function ensureHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPa
     return true;
   }
   const updated = addHermesOkxA2aEnabled(content2);
-  await (0, import_promises15.writeFile)(configFile, updated);
+  await (0, import_promises16.writeFile)(configFile, updated);
   console.log(`[update] added Hermes plugins.enabled okx-a2a entry in ${configFile}`);
   return true;
 }
@@ -118708,7 +120250,7 @@ async function isGatewayPluginInstalled(target) {
   if (target === "openclaw") {
     return (await getInstalledOpenClawPluginInfo()).installed;
   }
-  return (0, import_node_fs31.existsSync)(resolveHermesPluginYamlPath());
+  return (0, import_node_fs32.existsSync)(resolveHermesPluginYamlPath());
 }
 async function getInstalledGatewayPluginVersion(target) {
   if (target === "hermes") {
@@ -118797,7 +120339,7 @@ function parsePackageVersionFromText(output5) {
 async function getInstalledHermesPluginVersion() {
   const pluginYaml = (0, import_node_path37.join)(process.env.HERMES_HOME ?? (0, import_node_path37.join)((0, import_node_os13.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
   try {
-    const content2 = await (0, import_promises15.readFile)(pluginYaml, "utf8");
+    const content2 = await (0, import_promises16.readFile)(pluginYaml, "utf8");
     return parsePluginYamlVersion(content2);
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
@@ -118856,7 +120398,7 @@ async function npmPack(spec, destination) {
   return (0, import_node_path37.resolve)(destination, (0, import_node_path37.basename)(tarballName));
 }
 async function findHermesPluginTarball(distDir) {
-  const entries = await (0, import_promises15.readdir)(distDir);
+  const entries = await (0, import_promises16.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`);
@@ -118864,7 +120406,7 @@ async function findHermesPluginTarball(distDir) {
   return (0, import_node_path37.join)(distDir, tarball);
 }
 async function findFirstDirectory(parent) {
-  const entries = await (0, import_promises15.readdir)(parent, { withFileTypes: true });
+  const entries = await (0, import_promises16.readdir)(parent, { withFileTypes: true });
   const dir = entries.find((entry) => entry.isDirectory());
   if (!dir) {
     throw new Error(`No unpacked plugin directory found under ${parent}`);
@@ -118881,7 +120423,7 @@ function readOption4(args, name) {
 function hasFlag(args, name) {
   return args.includes(name);
 }
-function isHelpArg4(value) {
+function isHelpArg5(value) {
   return value === "-h" || value === "--help" || value === "help";
 }
 function isSupportedRelease(value) {
@@ -119090,13 +120632,13 @@ function buildExternalCommandInvocation(command, args, platform = process.platfo
 function formatExternalCommand(command, args) {
   return [command, ...args].join(" ");
 }
-var import_node_child_process10, import_node_fs31, import_promises15, import_node_os13, import_node_path37, UPDATE_PACKAGES, CODEX_NPM_PACKAGE, OPENCLAW_FORCE_INSTALL_FLAG, OPENCLAW_UNSAFE_INSTALL_FLAG, OKX_A2A_PLUGIN_ID, OPENCLAW_SESSION_DM_SCOPE_CONFIG_PATH, OPENCLAW_SESSION_DM_SCOPE_CONFIG_VALUE, OPENCLAW_PLUGIN_ALLOW_CONFIG_PATH, OPENCLAW_OKX_A2A_CONVERSATION_HOOK_ACCESS_CONFIG_PATH, DEFAULT_AI_PROVIDER_LOGIN_TIMEOUT_MS, PROVIDER_CLI_AUTH_PROBE_TIMEOUT_MS, SetupBlockedError, redirectCommandStdoutToStderr;
+var import_node_child_process10, import_node_fs32, import_promises16, import_node_os13, import_node_path37, 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_process10 = require("node:child_process");
-    import_node_fs31 = require("node:fs");
-    import_promises15 = require("node:fs/promises");
+    import_node_fs32 = require("node:fs");
+    import_promises16 = require("node:fs/promises");
     import_node_os13 = require("node:os");
     import_node_path37 = require("node:path");
     init_ai_command();
@@ -119386,7 +120928,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,
@@ -120423,7 +121965,7 @@ var init_doctor_cli = __esm({
 });
 
 // src/cli.ts
-var import_node_fs32 = require("node:fs");
+var import_node_fs33 = require("node:fs");
 var import_node_os14 = require("node:os");
 var import_node_path39 = require("node:path");
 init_daemon();
@@ -120493,7 +122035,7 @@ init_sentry_config();
 init_runtime_metadata();
 var CURRENT_GATEWAY_SESSION_KEYS_ENV4 = "OKX_A2A_CURRENT_GATEWAY_SESSION_KEYS";
 function printUsage3() {
-  console.log(`okx-a2a ${"0.2.16"}
+  console.log(`okx-a2a ${"0.2.17-beta-ab42219842-261020165552"}
 
 Usage:
   okx-a2a <command> [options]
@@ -120526,6 +122068,7 @@ Commands:
   trade-records
               Insert, query, and soft-delete local business trade records
   capabilities Print machine-readable A2A capability negotiation status (used by OnchainOS)
+  devkit       Register/unregister a local custom server for daemon message delivery
 
 Global options:
   -h, --help     Show help
@@ -120535,7 +122078,7 @@ Run \`okx-a2a <command> -h\` for command-specific help.
 `);
 }
 function printVersion() {
-  console.log("0.2.16");
+  console.log("0.2.17-beta-ab42219842-261020165552");
 }
 function printDaemonUsage() {
   console.log(`Usage: okx-a2a daemon <start|restart|stop|status|autostart> [options]
@@ -120803,11 +122346,11 @@ Commands:
           Print setup status JSON to stdout. Installer logs are written to stderr.
 `);
 }
-function isHelpArg5(value) {
+function isHelpArg6(value) {
   return value === "-h" || value === "--help" || value === "help";
 }
 function hasHelpFlag5(args) {
-  return args.some(isHelpArg5);
+  return args.some(isHelpArg6);
 }
 function isVersionArg(value) {
   return value === "-v" || value === "--version" || value === "version";
@@ -120834,14 +122377,14 @@ function maybeRedirectDaemonSelfLog() {
   }
   try {
     const logPath = resolveTaskPaths().listenerLogPath;
-    (0, import_node_fs32.mkdirSync)((0, import_node_path39.join)(logPath, ".."), { recursive: true });
-    const fd = (0, import_node_fs32.openSync)(logPath, "a");
+    (0, import_node_fs33.mkdirSync)((0, import_node_path39.join)(logPath, ".."), { recursive: true });
+    const fd = (0, import_node_fs33.openSync)(logPath, "a");
     const writeToLog = ((chunk, encoding, cb) => {
       try {
         if (typeof chunk === "string") {
-          (0, import_node_fs32.writeSync)(fd, chunk);
+          (0, import_node_fs33.writeSync)(fd, chunk);
         } else {
-          (0, import_node_fs32.writeSync)(fd, chunk);
+          (0, import_node_fs33.writeSync)(fd, chunk);
         }
       } catch {
       }
@@ -121191,12 +122734,12 @@ async function queueXmtpDaemonCommand(args, type) {
 }
 async function handleTaskCommand(args) {
   const subcommand = args[0];
-  if (!subcommand || args.every(isHelpArg5)) {
+  if (!subcommand || args.every(isHelpArg6)) {
     printTaskUsage();
     return;
   }
   if (subcommand === "help") {
-    const helpTarget = args.slice(1).find((arg) => !isHelpArg5(arg));
+    const helpTarget = args.slice(1).find((arg) => !isHelpArg6(arg));
     if (!helpTarget) {
       printTaskUsage();
       return;
@@ -121885,10 +123428,10 @@ async function initDirectCliSentry() {
   cliSentryInitAttempted = true;
   try {
     const configPath = (0, import_node_path39.join)(resolveTaskHomeForSentryConfig(), "xmtp", "system-config.json");
-    if (!(0, import_node_fs32.existsSync)(configPath)) {
+    if (!(0, import_node_fs33.existsSync)(configPath)) {
       return;
     }
-    const config = JSON.parse((0, import_node_fs32.readFileSync)(configPath, "utf8"));
+    const config = JSON.parse((0, import_node_fs33.readFileSync)(configPath, "utf8"));
     if (typeof config.sentryDsn !== "string" || !config.sentryDsn) {
       return;
     }
@@ -121950,7 +123493,7 @@ async function main() {
     assertSupportedNodeVersion();
   }
   const args = process.argv.slice(3);
-  if (isHelpArg5(command)) {
+  if (isHelpArg6(command)) {
     printUsage3();
     return;
   }
@@ -121971,6 +123514,15 @@ async function main() {
     await handleTradeRecordsCommand2(args);
     return;
   }
+  if (command === "devkit") {
+    const { handleDevkitCommand: handleDevkitCommand2, printDevkitUsage: printDevkitUsage2 } = await Promise.resolve().then(() => (init_devkit_cli(), devkit_cli_exports));
+    if (hasHelpFlag5(args)) {
+      printDevkitUsage2();
+      return;
+    }
+    await handleDevkitCommand2(args);
+    return;
+  }
   if (command === "daemon") {
     if (hasHelpFlag5(args)) {
       printDaemonUsage();
@@ -122030,7 +123582,7 @@ async function main() {
   if (command === "xmtp-test") {
     const { handleXmtpTestCommand: handleXmtpTestCommand2 } = await Promise.resolve().then(() => (init_xmtp_test_cli(), xmtp_test_cli_exports));
     await handleXmtpTestCommand2(process.argv.slice(3), {
-      packageVersion: "0.2.16",
+      packageVersion: "0.2.17-beta-ab42219842-261020165552",
       agentSdkVersion: "2.3.0",
       nodeSdkVersion: "6.1.0",
       nodeBindingsVersion: "1.11.0"
@@ -122136,12 +123688,12 @@ function shouldDeferHelpToNestedHandler(command, args) {
     return true;
   }
   if (command === "trade-records") {
-    return args.some((arg) => !isHelpArg5(arg));
+    return args.some((arg) => !isHelpArg6(arg));
   }
   if (command !== "session" && command !== "user" && command !== "task") {
     return false;
   }
-  return args.some((arg) => !isHelpArg5(arg));
+  return args.some((arg) => !isHelpArg6(arg));
 }
 main().then(() => {
   if (cliSentryFlushTimedOut) {