@okxweb3/a2a-node 0.2.11 → 0.2.12-beta-7449a77b9d-260909165309

package/dist/cli.js

@@ -108,6 +108,7 @@ function resolveTaskPaths(homeDir = resolveTaskHome()) {
     workspaceDir: (0, import_node_path2.join)(homeDir, "workspace"),
     xmtpDir: (0, import_node_path2.join)(homeDir, "xmtp"),
     sqliteDir: (0, import_node_path2.join)(homeDir, "sqlite"),
+    bzRecordsDir: (0, import_node_path2.join)(homeDir, "bz-records"),
     pendingCommandsDir: (0, import_node_path2.join)(homeDir, "commands", "pending"),
     processingCommandsDir: (0, import_node_path2.join)(homeDir, "commands", "processing"),
     completedCommandsDir: (0, import_node_path2.join)(homeDir, "commands", "completed"),
@@ -713,6 +714,7 @@ var init_session_store = __esm({
         PRIMARY KEY(session_key, provider)
       )
     `);
+        this.db.exec("DROP TRIGGER IF EXISTS a2a_ai_sessions_delete_guard");
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS job_provider_bindings (
         job_id TEXT PRIMARY KEY,
@@ -6524,7 +6526,7 @@ var require_path = __commonJS({
     function isAbsolute4(path2) {
       return path2.charAt(0) === "/";
     }
-    function join33(...args) {
+    function join34(...args) {
       return normalizePath(args.join("/"));
     }
     function dirname11(path2) {
@@ -6549,7 +6551,7 @@ var require_path = __commonJS({
     exports2.basename = basename11;
     exports2.dirname = dirname11;
     exports2.isAbsolute = isAbsolute4;
-    exports2.join = join33;
+    exports2.join = join34;
     exports2.normalizePath = normalizePath;
     exports2.relative = relative;
     exports2.resolve = resolve14;
@@ -19902,6 +19904,7 @@ var init_events = __esm({
       INBOUND_BLOCKED_INELIGIBLE: "Inbound blocked: message-eligible check failed",
       INBOUND_DROP_EMPTY_CONTENT: "Inbound drop: empty content",
       INBOUND_DROP_MISSING_JOBID: "Inbound drop: missing jobId",
+      INBOUND_DROP_INVALID_JOBID: "Inbound drop: invalid jobId",
       INBOUND_DROP_UNSUPPORTED_MSGTYPE: "Inbound drop: unsupported msgType",
       INBOUND_DROP_DM_NON_SYSTEM: "Inbound drop: DM sender not in system whitelist",
       INBOUND_DROP_DM_INVALID_PAYLOAD: "Inbound drop: DM payload invalid",
@@ -20835,6 +20838,7 @@ var init_sentry_logger = __esm({
       LogEvent.INBOUND_DROP_DM_UNKNOWN_AGENT,
       LogEvent.INBOUND_DROP_EMPTY_CONTENT,
       LogEvent.INBOUND_DROP_MISSING_JOBID,
+      LogEvent.INBOUND_DROP_INVALID_JOBID,
       LogEvent.INBOUND_DROP_UNSUPPORTED_MSGTYPE,
       LogEvent.DM_DELIVERED,
       LogEvent.DM_FALLBACK_TO_BACKUP,
@@ -25241,7 +25245,7 @@ var require_websocket2 = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes4, createHash: createHash6 } = require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash7 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -25901,7 +25905,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -26268,7 +26272,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter2 = require("events");
     var http2 = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash6 } = require("crypto");
+    var { createHash: createHash7 } = require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -26569,7 +26573,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -26934,7 +26938,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.11",
+      version: "0.2.12-beta-7449a77b9d-260909165309",
       platform: "node",
       mode: "backend",
       instanceId
@@ -26945,7 +26949,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.11"}`,
+    userAgent: `okx-a2a-node/${"0.2.12-beta-7449a77b9d-260909165309"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -29004,7 +29008,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.11",
+      release: "0.2.12-beta-7449a77b9d-260909165309",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -29293,7 +29297,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join33(s) {
+      BufferList.prototype.join = function join34(s) {
         if (this.length === 0) return "";
         var p = this.head;
         var ret = "" + p.data;
@@ -38801,6 +38805,27 @@ var require_lib3 = __commonJS({
   }
 });
 
+// src/ai-run-log.ts
+function hashAiRunLogIdentifier(value) {
+  return (0, import_node_crypto7.createHash)("sha256").update(value).digest("hex").slice(0, 24);
+}
+function buildAiRunLogFileName(request) {
+  const messageIdHash = hashAiRunLogIdentifier(request.messageId);
+  const jobIdHash = hashAiRunLogIdentifier(request.jobId ?? "unknown");
+  if (request.source === "job-dispatch") {
+    return `ai-job-${jobIdHash}-${messageIdHash}.log`;
+  }
+  const sessionKeyHash = hashAiRunLogIdentifier(request.sessionKey);
+  return `ai-session-job-${jobIdHash}-${sessionKeyHash}-${messageIdHash}.log`;
+}
+var import_node_crypto7;
+var init_ai_run_log = __esm({
+  "src/ai-run-log.ts"() {
+    "use strict";
+    import_node_crypto7 = require("node:crypto");
+  }
+});
+
 // src/logs-export-filter.ts
 async function readFilteredLog(path2, options, correlationIds, requireCorrelation, includeDiagnosticContent = options.includeSensitiveContent, maxOutputBytes = Math.floor(options.maxSizeMb * 1024 * 1024), recordMode = "generic") {
   try {
@@ -39438,7 +39463,7 @@ async function writeArchiveAtomically(outputPath, archive, overwrite) {
   await (0, import_promises9.mkdir)((0, import_node_path20.dirname)(outputPath), { recursive: true });
   const temporaryPath = (0, import_node_path20.join)(
     (0, import_node_path20.dirname)(outputPath),
-    `.${(0, import_node_path20.basename)(outputPath)}.${(0, import_node_crypto7.randomUUID)()}.tmp`
+    `.${(0, import_node_path20.basename)(outputPath)}.${(0, import_node_crypto8.randomUUID)()}.tmp`
   );
   try {
     await (0, import_promises9.writeFile)(temporaryPath, archive, { flag: "wx", mode: 384 });
@@ -39457,16 +39482,16 @@ async function writeArchiveAtomically(outputPath, archive, overwrite) {
   }
 }
 function hashDiagnosticFileContent(content2) {
-  return (0, import_node_crypto7.createHash)("sha256").update(content2).digest("hex");
+  return (0, import_node_crypto8.createHash)("sha256").update(content2).digest("hex");
 }
 function isUnavailableError(err2) {
   return !!err2 && typeof err2 === "object" && "diagnosticUnavailable" in err2;
 }
-var import_node_crypto7, import_node_fs16, import_promises9, import_node_path20;
+var import_node_crypto8, import_node_fs16, import_promises9, import_node_path20;
 var init_logs_export_archive = __esm({
   "src/logs-export-archive.ts"() {
     "use strict";
-    import_node_crypto7 = require("node:crypto");
+    import_node_crypto8 = require("node:crypto");
     import_node_fs16 = require("node:fs");
     import_promises9 = require("node:fs/promises");
     import_node_path20 = require("node:path");
@@ -39574,8 +39599,8 @@ function readSqliteRows(dbPath, sql, params = []) {
   if (!(0, import_node_fs17.existsSync)(dbPath)) {
     throw unavailable(`SQLite database not found: ${dbPath}`);
   }
-  const { DatabaseSync: DatabaseSync4 } = loadSqlite3();
-  const db = new DatabaseSync4(dbPath, { readOnly: true });
+  const { DatabaseSync: DatabaseSync5 } = loadSqlite3();
+  const db = new DatabaseSync5(dbPath, { readOnly: true });
   try {
     return db.prepare(sql).all(...params);
   } finally {
@@ -39839,7 +39864,7 @@ async function assertRegularFile2(path2) {
 }
 async function inspectRegularFile(path2) {
   const file = await assertRegularFile2(path2);
-  const hash2 = (0, import_node_crypto8.createHash)("sha256");
+  const hash2 = (0, import_node_crypto9.createHash)("sha256");
   for await (const chunk of (0, import_node_fs18.createReadStream)(path2)) {
     hash2.update(chunk);
   }
@@ -39891,11 +39916,11 @@ function unavailable2(message) {
 function normalizeKey2(value) {
   return value.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-var import_node_crypto8, import_node_fs18, import_promises10, import_node_path22, MAX_JSON_FILE_BYTES, STRONG_CORRELATION_KEYS, WEAK_CORRELATION_KEYS;
+var import_node_crypto9, import_node_fs18, import_promises10, import_node_path22, MAX_JSON_FILE_BYTES, STRONG_CORRELATION_KEYS, WEAK_CORRELATION_KEYS;
 var init_logs_export_utils = __esm({
   "src/logs-export-utils.ts"() {
     "use strict";
-    import_node_crypto8 = require("node:crypto");
+    import_node_crypto9 = require("node:crypto");
     import_node_fs18 = require("node:fs");
     import_promises10 = require("node:fs/promises");
     import_node_path22 = require("node:path");
@@ -40174,7 +40199,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.11" : "unknown",
+    packageVersion: true ? "0.2.12-beta-7449a77b9d-260909165309" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -40393,9 +40418,11 @@ async function collectA2aLogs(state, paths, options, sessionKeys, correlationIds
       if (!name.endsWith(".log") || !name.startsWith("ai-") && !name.startsWith("ai-session-")) {
         continue;
       }
-      const matchesDirectJob = options.jobId ? name.startsWith(`ai-${encodeURIComponent(options.jobId)}-`) : true;
+      const matchesDirectJob = options.jobId ? name.startsWith(`ai-${encodeURIComponent(options.jobId)}-`) || name.startsWith(`ai-job-${hashAiRunLogIdentifier(options.jobId)}-`) : true;
       const matchesPersistedSession = sessionKeys.some(
-        (key) => name.startsWith(`ai-session-${encodeURIComponent(key)}-`)
+        (key) => name.startsWith(`ai-session-${encodeURIComponent(key)}-`) || new RegExp(
+          `^ai-session-job-[0-9a-f]{24}-${hashAiRunLogIdentifier(key)}-`
+        ).test(name)
       );
       const matchesJobSessionFilename = options.jobId ? matchesJobSessionLogFilename(name, options.jobId) : false;
       if (!matchesDirectJob && !matchesPersistedSession && !matchesJobSessionFilename) {
@@ -41008,7 +41035,7 @@ function matchesJobSessionLogFilename(name, jobId) {
   const encodedJobId = encodeURIComponent(jobId);
   const jobSessionPrefix = encodeURIComponent(`job:${encodedJobId}:`);
   const backupSessionKey = encodeURIComponent(`backup:${encodedJobId}`);
-  return name.startsWith(`ai-session-${jobSessionPrefix}`) || name.startsWith(`ai-session-${backupSessionKey}-`);
+  return name.startsWith(`ai-session-${jobSessionPrefix}`) || name.startsWith(`ai-session-${backupSessionKey}-`) || name.startsWith(`ai-session-job-${hashAiRunLogIdentifier(jobId)}-`);
 }
 function isOpenClawSessionLogName(name) {
   return name.endsWith(".jsonl") && name !== "sessions.json";
@@ -41042,6 +41069,7 @@ var init_logs_export = __esm({
     import_node_os8 = require("node:os");
     import_node_path23 = require("node:path");
     import_jszip = __toESM(require_lib3());
+    init_ai_run_log();
     init_logs_export_archive();
     init_logs_export_database();
     init_logs_export_filter();
@@ -41068,6 +41096,11 @@ function getA2ACapabilities() {
       ok: true,
       fixCommands: [],
       message: ""
+    },
+    tradeRecordsV1: {
+      ok: true,
+      fixCommands: [],
+      message: ""
     }
   };
 }
@@ -41097,6 +41130,1057 @@ var init_capabilities_cli = __esm({
   }
 });
 
+// src/trade-records-store.ts
+function resolveTradeRecordsDbPath(homeDir) {
+  return (0, import_node_path24.join)(resolveTaskPaths(homeDir).bzRecordsDir, TRADE_RECORDS_DB_NAME);
+}
+function tradeRecordsDbExists(homeDir) {
+  return (0, import_node_fs20.existsSync)(resolveTradeRecordsDbPath(homeDir));
+}
+function encodeTradeRecordCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeTradeRecordCursor(value) {
+  try {
+    const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    if (parsed.version !== 1 || parsed.sortBy !== "createdAt" && parsed.sortBy !== "updatedAt" || parsed.order !== "asc" && parsed.order !== "desc" || typeof parsed.timestamp !== "number" || !Number.isSafeInteger(parsed.timestamp) || parsed.timestamp < 0 || typeof parsed.deliveryId !== "string" || parsed.deliveryId.length === 0) {
+      throw new Error("invalid cursor payload");
+    }
+    return parsed;
+  } catch {
+    throw new TradeRecordsStoreError("INVALID_ARGUMENT", "--cursor is invalid");
+  }
+}
+function applyMigrationV1(db) {
+  db.exec(`
+    CREATE TABLE ${TABLE_NAME} (
+      delivery_id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      reason TEXT NOT NULL DEFAULT '',
+      extra TEXT NOT NULL DEFAULT '{}',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      deleted_at INTEGER,
+      CHECK (length(job_id) > 0),
+      CHECK (length(delivery_id) > 0),
+      CHECK (length(status) > 0),
+      CHECK (json_valid(extra)),
+      CHECK (json_type(extra) = 'object')
+    )
+  `);
+  db.exec(`CREATE INDEX idx_trade_records_job_updated ON ${TABLE_NAME}(job_id, updated_at DESC, delivery_id DESC)`);
+  db.exec(`CREATE INDEX idx_trade_records_status_updated ON ${TABLE_NAME}(status, updated_at DESC, delivery_id DESC)`);
+  db.exec(`CREATE INDEX idx_trade_records_created ON ${TABLE_NAME}(created_at DESC, delivery_id DESC)`);
+  db.exec(`CREATE INDEX idx_trade_records_deleted ON ${TABLE_NAME}(deleted_at, updated_at DESC)`);
+}
+function buildWhere(filter2, includeCursor) {
+  const clauses = [];
+  const params = [];
+  const add = (clause, ...values) => {
+    clauses.push(clause);
+    params.push(...values);
+  };
+  if (!filter2.includeDeleted) {
+    add(filter2.onlyDeleted ? "deleted_at IS NOT NULL" : "deleted_at IS NULL");
+  } else if (filter2.onlyDeleted) {
+    add("deleted_at IS NOT NULL");
+  }
+  if (filter2.jobId) add("job_id = ?", filter2.jobId);
+  if (filter2.deliveryId) add("delivery_id = ?", filter2.deliveryId);
+  if (filter2.statuses && filter2.statuses.length > 0) {
+    add(`status IN (${filter2.statuses.map(() => "?").join(", ")})`, ...filter2.statuses);
+  }
+  if (filter2.reason !== void 0) add("reason = ?", filter2.reason);
+  if (filter2.reasonContains !== void 0) {
+    add("reason LIKE ? ESCAPE '\\'", `%${escapeLike(filter2.reasonContains)}%`);
+  }
+  if (filter2.createdFrom !== void 0) add("created_at >= ?", filter2.createdFrom);
+  if (filter2.createdTo !== void 0) add("created_at <= ?", filter2.createdTo);
+  if (filter2.updatedFrom !== void 0) add("updated_at >= ?", filter2.updatedFrom);
+  if (filter2.updatedTo !== void 0) add("updated_at <= ?", filter2.updatedTo);
+  for (const extra of filter2.extraEquals ?? []) {
+    if (extra.value === null) {
+      add("json_type(extra, ?) = 'null'", extra.path);
+    } else {
+      add(
+        "json_extract(extra, ?) = ?",
+        extra.path,
+        typeof extra.value === "boolean" ? extra.value ? 1 : 0 : extra.value
+      );
+    }
+  }
+  if (includeCursor && filter2.cursor) {
+    const column = filter2.sortBy === "createdAt" ? "created_at" : "updated_at";
+    const operator = filter2.order === "asc" ? ">" : "<";
+    add(
+      `(${column} ${operator} ? OR (${column} = ? AND delivery_id ${operator} ?))`,
+      filter2.cursor.timestamp,
+      filter2.cursor.timestamp,
+      filter2.cursor.deliveryId
+    );
+  }
+  return { clauses, params };
+}
+function mapRow(row) {
+  const extra = JSON.parse(row.extra);
+  if (!isJsonObject(extra)) {
+    throw new TradeRecordsStoreError("DATABASE_READ_FAILED", "stored trade record extra is not a JSON object");
+  }
+  return {
+    jobId: row.job_id,
+    deliveryId: row.delivery_id,
+    status: row.status,
+    reason: row.reason,
+    extra,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    deletedAt: row.deleted_at
+  };
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, (character) => `\\${character}`);
+}
+function readPragmaNumber(db, name) {
+  const row = db.prepare(`PRAGMA ${name}`).get();
+  return Number(row[name] ?? 0);
+}
+function assertNotSymlink(path2, label) {
+  if (!(0, import_node_fs20.existsSync)(path2)) {
+    return;
+  }
+  if ((0, import_node_fs20.lstatSync)(path2).isSymbolicLink()) {
+    throw new TradeRecordsStoreError("DATABASE_PATH_UNSAFE", `${label} must not be a symbolic link`);
+  }
+}
+function assertSafeDatabasePath(dbPath) {
+  assertSafeDatabaseFile(dbPath);
+  for (const suffix of ["-journal", "-wal", "-shm"]) {
+    assertNotSymlink(`${dbPath}${suffix}`, `trade records database sidecar ${suffix}`);
+  }
+}
+function assertSafeDatabaseFile(dbPath) {
+  if (!(0, import_node_fs20.existsSync)(dbPath)) {
+    return;
+  }
+  const stat4 = (0, import_node_fs20.lstatSync)(dbPath);
+  if (stat4.isSymbolicLink()) {
+    throw new TradeRecordsStoreError(
+      "DATABASE_PATH_UNSAFE",
+      "trade records database must not be a symbolic link"
+    );
+  }
+  if (!stat4.isFile() || stat4.nlink !== 1) {
+    throw new TradeRecordsStoreError(
+      "DATABASE_PATH_UNSAFE",
+      "trade records database must be a regular file with one hard link"
+    );
+  }
+}
+function rollbackQuietly(db) {
+  try {
+    db.exec("ROLLBACK");
+  } catch {
+  }
+}
+function withBusyRetry(operation) {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return operation();
+    } catch (error) {
+      if (!isSqliteBusyError(error) || attempt >= WRITE_RETRY_ATTEMPTS) {
+        throw error;
+      }
+      sleepSyncMs2(Math.min(100 * 2 ** (attempt - 1), 1600));
+    }
+  }
+}
+function sleepSyncMs2(ms) {
+  const buffer2 = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(buffer2, 0, 0, ms);
+}
+function loadSqlite4() {
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = ((warning, ...args) => {
+    const message = typeof warning === "string" ? warning : warning.message;
+    if (message.includes("SQLite is an experimental feature") && args.some((arg) => arg === "ExperimentalWarning")) {
+      return;
+    }
+    return originalEmitWarning.call(process, warning, ...args);
+  });
+  try {
+    return require("node:sqlite");
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
+var import_node_fs20, import_node_path24, DatabaseSync3, TRADE_RECORDS_APPLICATION_ID, TRADE_RECORDS_SCHEMA_VERSION, TRADE_RECORDS_DB_NAME, TABLE_NAME, WRITE_RETRY_ATTEMPTS, TradeRecordsStoreError, TradeRecordsStore;
+var init_trade_records_store = __esm({
+  "src/trade-records-store.ts"() {
+    "use strict";
+    import_node_fs20 = require("node:fs");
+    import_node_path24 = require("node:path");
+    init_paths();
+    init_session_store();
+    ({ DatabaseSync: DatabaseSync3 } = loadSqlite4());
+    TRADE_RECORDS_APPLICATION_ID = 1329681490;
+    TRADE_RECORDS_SCHEMA_VERSION = 1;
+    TRADE_RECORDS_DB_NAME = "trade-records.sqlite";
+    TABLE_NAME = `"trade-records"`;
+    WRITE_RETRY_ATTEMPTS = 6;
+    TradeRecordsStoreError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.name = "TradeRecordsStoreError";
+        this.code = code;
+      }
+    };
+    TradeRecordsStore = class _TradeRecordsStore {
+      dbPath;
+      db;
+      constructor(dbPath, db) {
+        this.dbPath = dbPath;
+        this.db = db;
+      }
+      static openForWrite(homeDir) {
+        const paths = resolveTaskPaths(homeDir);
+        assertNotSymlink(paths.bzRecordsDir, "trade records directory");
+        ensureTaskDir(paths.bzRecordsDir);
+        assertNotSymlink(paths.bzRecordsDir, "trade records directory");
+        const dbPath = (0, import_node_path24.join)(paths.bzRecordsDir, TRADE_RECORDS_DB_NAME);
+        assertSafeDatabasePath(dbPath);
+        const db = new DatabaseSync3(dbPath);
+        const store = new _TradeRecordsStore(dbPath, db);
+        try {
+          store.configureConnectionForWrite();
+          store.ensureSchemaForWrite();
+          return store;
+        } catch (error) {
+          db.close();
+          throw error;
+        }
+      }
+      static openForRead(homeDir) {
+        const dbPath = resolveTradeRecordsDbPath(homeDir);
+        if (!(0, import_node_fs20.existsSync)(dbPath)) {
+          return null;
+        }
+        assertSafeDatabaseFile(dbPath);
+        const db = new DatabaseSync3(dbPath, { readOnly: true });
+        const store = new _TradeRecordsStore(dbPath, db);
+        try {
+          db.exec("PRAGMA query_only=ON");
+          store.assertReadableSchema();
+          return store;
+        } catch (error) {
+          db.close();
+          throw error;
+        }
+      }
+      close() {
+        this.db.close();
+      }
+      insert(records) {
+        return this.withWriteTransaction(() => {
+          const existingStatement = this.db.prepare(
+            `SELECT deleted_at FROM ${TABLE_NAME} WHERE delivery_id = ?`
+          );
+          const upsertStatement = this.db.prepare(`
+        INSERT INTO ${TABLE_NAME} (
+          delivery_id, job_id, status, reason, extra, created_at, updated_at, deleted_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL)
+        ON CONFLICT(delivery_id) DO UPDATE SET
+          job_id = excluded.job_id,
+          status = excluded.status,
+          reason = excluded.reason,
+          extra = excluded.extra,
+          updated_at = excluded.updated_at,
+          deleted_at = NULL
+      `);
+          const now = Date.now();
+          let insertedCount = 0;
+          let updatedCount = 0;
+          let restoredCount = 0;
+          for (const record of records) {
+            const existing = existingStatement.get(record.deliveryId);
+            if (!existing) {
+              insertedCount += 1;
+            } else if (existing.deleted_at === null) {
+              updatedCount += 1;
+            } else {
+              restoredCount += 1;
+            }
+            upsertStatement.run(
+              record.deliveryId,
+              record.jobId,
+              record.status,
+              record.reason,
+              JSON.stringify(record.extra),
+              now,
+              now
+            );
+          }
+          return { insertedCount, updatedCount, restoredCount };
+        });
+      }
+      delete(deliveryId, jobId) {
+        return this.withWriteTransaction(() => {
+          const existing = this.db.prepare(`
+        SELECT deleted_at FROM ${TABLE_NAME}
+        WHERE delivery_id = ?${jobId ? " AND job_id = ?" : ""}
+      `).get(...jobId ? [deliveryId, jobId] : [deliveryId]);
+          if (!existing) {
+            return { deliveryId, deleted: false, alreadyDeleted: false, notFound: true };
+          }
+          if (existing.deleted_at !== null) {
+            return { deliveryId, deleted: false, alreadyDeleted: true, notFound: false };
+          }
+          const now = Date.now();
+          this.db.prepare(`
+        UPDATE ${TABLE_NAME}
+        SET deleted_at = ?, updated_at = ?
+        WHERE delivery_id = ?${jobId ? " AND job_id = ?" : ""} AND deleted_at IS NULL
+      `).run(...jobId ? [now, now, deliveryId, jobId] : [now, now, deliveryId]);
+          return { deliveryId, deleted: true, alreadyDeleted: false, notFound: false };
+        });
+      }
+      query(filter2) {
+        const base = buildWhere(filter2, false);
+        const page = buildWhere(filter2, true);
+        const sortColumn = filter2.sortBy === "createdAt" ? "created_at" : "updated_at";
+        const direction = filter2.order.toUpperCase();
+        const rows = this.db.prepare(`
+      SELECT delivery_id, job_id, status, reason, extra, created_at, updated_at, deleted_at
+      FROM ${TABLE_NAME}
+      ${page.clauses.length > 0 ? `WHERE ${page.clauses.join(" AND ")}` : ""}
+      ORDER BY ${sortColumn} ${direction}, delivery_id ${direction}
+      LIMIT ?
+    `).all(...page.params, filter2.limit + 1);
+        const hasMore = rows.length > filter2.limit;
+        const visibleRows = hasMore ? rows.slice(0, filter2.limit) : rows;
+        const records = visibleRows.map(mapRow);
+        const last = visibleRows.at(-1);
+        const nextCursor = hasMore && last ? encodeTradeRecordCursor({
+          version: 1,
+          sortBy: filter2.sortBy,
+          order: filter2.order,
+          timestamp: filter2.sortBy === "createdAt" ? last.created_at : last.updated_at,
+          deliveryId: last.delivery_id
+        }) : null;
+        let count;
+        if (filter2.includeCount) {
+          const row = this.db.prepare(`
+        SELECT COUNT(*) AS count
+        FROM ${TABLE_NAME}
+        ${base.clauses.length > 0 ? `WHERE ${base.clauses.join(" AND ")}` : ""}
+      `).get(...base.params);
+          count = Number(row.count);
+        }
+        return { records, nextCursor, ...count === void 0 ? {} : { count } };
+      }
+      configureConnectionForWrite() {
+        this.db.exec("PRAGMA busy_timeout=5000");
+      }
+      ensureSchemaForWrite() {
+        withBusyRetry(() => {
+          this.db.exec("BEGIN IMMEDIATE");
+          try {
+            const applicationId = readPragmaNumber(this.db, "application_id");
+            const userVersion = readPragmaNumber(this.db, "user_version");
+            const hasTables = Boolean(this.db.prepare(
+              "SELECT 1 AS present FROM sqlite_master WHERE type = 'table' LIMIT 1"
+            ).get());
+            if (applicationId === 0 && !hasTables && userVersion === 0) {
+              this.db.exec(`PRAGMA application_id=${TRADE_RECORDS_APPLICATION_ID}`);
+            } else if (applicationId !== TRADE_RECORDS_APPLICATION_ID) {
+              throw new TradeRecordsStoreError(
+                "DATABASE_IDENTITY_MISMATCH",
+                "trade records database identity does not match"
+              );
+            }
+            if (userVersion > TRADE_RECORDS_SCHEMA_VERSION) {
+              throw new TradeRecordsStoreError(
+                "DATABASE_SCHEMA_TOO_NEW",
+                `trade records schema version ${userVersion} is newer than supported ${TRADE_RECORDS_SCHEMA_VERSION}`
+              );
+            }
+            if (userVersion < 1) {
+              applyMigrationV1(this.db);
+              this.db.exec("PRAGMA user_version=1");
+            }
+            this.db.exec("COMMIT");
+          } catch (error) {
+            rollbackQuietly(this.db);
+            throw error;
+          }
+        });
+        withBusyRetry(() => {
+          this.db.exec("PRAGMA journal_mode=WAL");
+          this.db.exec("PRAGMA synchronous=FULL");
+        });
+      }
+      assertReadableSchema() {
+        const applicationId = readPragmaNumber(this.db, "application_id");
+        if (applicationId !== TRADE_RECORDS_APPLICATION_ID) {
+          throw new TradeRecordsStoreError(
+            "DATABASE_IDENTITY_MISMATCH",
+            "trade records database identity does not match"
+          );
+        }
+        const userVersion = readPragmaNumber(this.db, "user_version");
+        if (userVersion > TRADE_RECORDS_SCHEMA_VERSION) {
+          throw new TradeRecordsStoreError(
+            "DATABASE_SCHEMA_TOO_NEW",
+            `trade records schema version ${userVersion} is newer than supported ${TRADE_RECORDS_SCHEMA_VERSION}`
+          );
+        }
+        if (userVersion < TRADE_RECORDS_SCHEMA_VERSION) {
+          throw new TradeRecordsStoreError(
+            "DATABASE_MIGRATION_REQUIRED",
+            "trade records database requires a write command to finish migration"
+          );
+        }
+      }
+      withWriteTransaction(operation) {
+        return withBusyRetry(() => {
+          this.db.exec("BEGIN IMMEDIATE");
+          try {
+            const result = operation();
+            this.db.exec("COMMIT");
+            return result;
+          } catch (error) {
+            rollbackQuietly(this.db);
+            throw error;
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/trade-records-cli.ts
+var trade_records_cli_exports = {};
+__export(trade_records_cli_exports, {
+  handleTradeRecordsCommand: () => handleTradeRecordsCommand,
+  printTradeRecordsUsage: () => printTradeRecordsUsage
+});
+async function handleTradeRecordsCommand(args) {
+  const wantsJson = args.includes("--json");
+  try {
+    const subcommand = args[0];
+    if (!subcommand || isHelpArg(subcommand)) {
+      printTradeRecordsUsage();
+      return;
+    }
+    if (args.slice(1).some(isHelpArg)) {
+      printSubcommandUsage(subcommand);
+      return;
+    }
+    if (subcommand === "insert") {
+      handleInsert(args.slice(1));
+      return;
+    }
+    if (subcommand === "query") {
+      handleQuery(args.slice(1));
+      return;
+    }
+    if (subcommand === "delete") {
+      handleDelete(args.slice(1));
+      return;
+    }
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", `Unknown trade-records command: ${subcommand}`);
+  } catch (error) {
+    outputError(wantsJson, normalizeError(error));
+    process.exitCode = 1;
+  }
+}
+function printTradeRecordsUsage() {
+  console.log(`Usage: okx-a2a trade-records <insert|query|delete> [options]
+
+Commands:
+  insert  Insert or replace trade records by deliveryId.
+  query   Query active or soft-deleted trade records.
+  delete  Soft-delete one trade record by deliveryId.
+
+Run \`okx-a2a trade-records <command> --help\` for command-specific help.`);
+}
+function printSubcommandUsage(subcommand) {
+  if (subcommand === "insert") {
+    console.log(`Usage: okx-a2a trade-records insert [options]
+
+Input modes (choose exactly one):
+  --job-id <id> --delivery-id <id> --status <status> [--reason <text>] [--extra <json-object>]
+  --input-json <json-array>
+  --input-file <path-to-json-array>
+
+Options:
+  --reason <text>       Default: empty string.
+  --extra <json>        Complete JSON object. Default: {}.
+  --json                Print machine-readable summary.`);
+    return;
+  }
+  if (subcommand === "query") {
+    console.log(`Usage: okx-a2a trade-records query [options]
+
+Options:
+  --job-id <id>                Filter by job id.
+  --delivery-id <id>           Filter by delivery id.
+  --status <status>            Filter by status; repeatable.
+  --reason <text>              Exact reason match.
+  --reason-contains <text>     Reason substring match.
+  --created-from <epoch-ms>    Inclusive createdAt lower bound.
+  --created-to <epoch-ms>      Inclusive createdAt upper bound.
+  --updated-from <epoch-ms>    Inclusive updatedAt lower bound.
+  --updated-to <epoch-ms>      Inclusive updatedAt upper bound.
+  --extra-eq <path=json>       Exact extra field match; repeatable.
+  --include-deleted            Include active and deleted records.
+  --only-deleted               Return only deleted records.
+  --sort-by <createdAt|updatedAt>  Default: updatedAt.
+  --order <asc|desc>           Default: desc.
+  --limit <n>                  Default: 100; maximum: 1000.
+  --cursor <cursor>            Continue keyset pagination.
+  --count                      Include total matching count.
+  --json                       Print machine-readable output.`);
+    return;
+  }
+  if (subcommand === "delete") {
+    console.log(`Usage: okx-a2a trade-records delete --delivery-id <id> [--job-id <id>] [--json]
+
+Soft-delete one trade record. Repeated deletes and missing records are idempotent.`);
+    return;
+  }
+  throw new TradeRecordsCliError("INVALID_ARGUMENT", `Unknown trade-records command: ${subcommand}`);
+}
+function handleInsert(args) {
+  const parsed = parseArgs(args, {
+    command: "trade-records insert",
+    options: /* @__PURE__ */ new Set([...INPUT_FIELD_OPTIONS, "input-json", "input-file"]),
+    flags: /* @__PURE__ */ new Set(["json"])
+  });
+  const json = parsed.flags.has("json");
+  const loaded = loadInsertRecords(parsed);
+  const coalesced = coalesceByLastDeliveryId(loaded.records);
+  const store = TradeRecordsStore.openForWrite();
+  try {
+    const result = store.insert(coalesced.records);
+    const payload = {
+      ok: true,
+      operation: "insert",
+      inputCount: loaded.records.length,
+      finalRecordCount: coalesced.records.length,
+      insertedCount: result.insertedCount,
+      updatedCount: result.updatedCount,
+      restoredCount: result.restoredCount,
+      duplicateInputCount: coalesced.duplicateInputCount
+    };
+    if (json) {
+      console.log(JSON.stringify(payload));
+      return;
+    }
+    if (loaded.records.length === 1) {
+      const operation = result.insertedCount === 1 ? "inserted" : result.restoredCount === 1 ? "restored" : "updated";
+      console.log(`Trade record saved: deliveryId=${coalesced.records[0].deliveryId}, result=${operation}`);
+      return;
+    }
+    console.log(`Trade records saved: ${loaded.records.length} inputs, ${coalesced.records.length} final records`);
+    console.log(
+      `Inserted: ${result.insertedCount}, updated: ${result.updatedCount}, restored: ${result.restoredCount}, duplicate inputs overwritten: ${coalesced.duplicateInputCount}`
+    );
+  } finally {
+    store.close();
+  }
+}
+function handleQuery(args) {
+  const parsed = parseArgs(args, {
+    command: "trade-records query",
+    options: /* @__PURE__ */ new Set([
+      "job-id",
+      "delivery-id",
+      "status",
+      "reason",
+      "reason-contains",
+      "created-from",
+      "created-to",
+      "updated-from",
+      "updated-to",
+      "extra-eq",
+      "sort-by",
+      "order",
+      "limit",
+      "cursor"
+    ]),
+    flags: /* @__PURE__ */ new Set(["include-deleted", "only-deleted", "count", "json"]),
+    repeatable: /* @__PURE__ */ new Set(["status", "extra-eq"])
+  });
+  const json = parsed.flags.has("json");
+  if (parsed.flags.has("include-deleted") && parsed.flags.has("only-deleted")) {
+    throw new TradeRecordsCliError(
+      "INVALID_ARGUMENT",
+      "--include-deleted and --only-deleted cannot be used together"
+    );
+  }
+  const sortBy = readChoice(parsed, "sort-by", ["createdAt", "updatedAt"]) ?? "updatedAt";
+  const order = readChoice(parsed, "order", ["asc", "desc"]) ?? "desc";
+  const cursorRaw = readSingle(parsed, "cursor");
+  const cursor = cursorRaw ? decodeTradeRecordCursor(cursorRaw) : void 0;
+  if (cursor && (cursor.sortBy !== sortBy || cursor.order !== order)) {
+    throw new TradeRecordsCliError(
+      "INVALID_ARGUMENT",
+      "--cursor does not match the requested --sort-by and --order"
+    );
+  }
+  const createdFrom = readTimestamp(parsed, "created-from");
+  const createdTo = readTimestamp(parsed, "created-to");
+  const updatedFrom = readTimestamp(parsed, "updated-from");
+  const updatedTo = readTimestamp(parsed, "updated-to");
+  assertRange("created", createdFrom, createdTo);
+  assertRange("updated", updatedFrom, updatedTo);
+  const filter2 = {
+    sortBy,
+    order,
+    limit: readLimit(parsed),
+    statuses: parsed.options.get("status")?.map((value) => requireText(value, "--status", MAX_STATUS_LENGTH)),
+    extraEquals: (parsed.options.get("extra-eq") ?? []).map(parseExtraFilter),
+    includeDeleted: parsed.flags.has("include-deleted"),
+    onlyDeleted: parsed.flags.has("only-deleted"),
+    includeCount: parsed.flags.has("count"),
+    ...readOptionalText(parsed, "job-id", MAX_ID_LENGTH) ? { jobId: readOptionalText(parsed, "job-id", MAX_ID_LENGTH) } : {},
+    ...readOptionalText(parsed, "delivery-id", MAX_ID_LENGTH) ? { deliveryId: readOptionalText(parsed, "delivery-id", MAX_ID_LENGTH) } : {},
+    ...readSingle(parsed, "reason") !== void 0 ? { reason: readSingle(parsed, "reason") } : {},
+    ...readSingle(parsed, "reason-contains") !== void 0 ? { reasonContains: readSingle(parsed, "reason-contains") } : {},
+    ...createdFrom === void 0 ? {} : { createdFrom },
+    ...createdTo === void 0 ? {} : { createdTo },
+    ...updatedFrom === void 0 ? {} : { updatedFrom },
+    ...updatedTo === void 0 ? {} : { updatedTo },
+    ...cursor ? { cursor } : {}
+  };
+  const store = TradeRecordsStore.openForRead();
+  if (!store) {
+    outputQuery(json, [], filter2.limit, null, filter2.includeCount ? 0 : void 0);
+    return;
+  }
+  try {
+    const result = store.query(filter2);
+    outputQuery(json, result.records, filter2.limit, result.nextCursor, result.count);
+  } finally {
+    store.close();
+  }
+}
+function handleDelete(args) {
+  const parsed = parseArgs(args, {
+    command: "trade-records delete",
+    options: /* @__PURE__ */ new Set(["delivery-id", "job-id"]),
+    flags: /* @__PURE__ */ new Set(["json"])
+  });
+  const json = parsed.flags.has("json");
+  const deliveryId = requireText(readSingle(parsed, "delivery-id"), "--delivery-id", MAX_ID_LENGTH);
+  const jobId = readOptionalText(parsed, "job-id", MAX_ID_LENGTH);
+  if (!tradeRecordsDbExists()) {
+    outputDelete(json, {
+      deliveryId,
+      deleted: false,
+      alreadyDeleted: false,
+      notFound: true
+    });
+    return;
+  }
+  const store = TradeRecordsStore.openForWrite();
+  try {
+    outputDelete(json, store.delete(deliveryId, jobId));
+  } finally {
+    store.close();
+  }
+}
+function loadInsertRecords(parsed) {
+  const inputJson = readSingle(parsed, "input-json");
+  const inputFile = readSingle(parsed, "input-file");
+  const providedFieldOptions = [...INPUT_FIELD_OPTIONS].filter((name) => parsed.options.has(name));
+  const modeCount = Number(inputJson !== void 0) + Number(inputFile !== void 0) + Number(providedFieldOptions.length > 0);
+  if (modeCount !== 1) {
+    throw new TradeRecordsCliError(
+      "INVALID_ARGUMENT",
+      "trade-records insert requires exactly one input mode: field options, --input-json, or --input-file"
+    );
+  }
+  if (inputJson !== void 0) {
+    assertInputSize(inputJson, "--input-json");
+    return { records: parseRecordArray(inputJson, "--input-json") };
+  }
+  if (inputFile !== void 0) {
+    let content2;
+    try {
+      const stat4 = (0, import_node_fs21.statSync)(inputFile);
+      if (!stat4.isFile()) {
+        throw new Error("not a regular file");
+      }
+      if (stat4.size > MAX_INPUT_BYTES) {
+        throw new TradeRecordsCliError("INPUT_TOO_LARGE", `--input-file exceeds ${MAX_INPUT_BYTES} bytes`);
+      }
+      content2 = (0, import_node_fs21.readFileSync)(inputFile, "utf8");
+    } catch (error) {
+      if (error instanceof TradeRecordsCliError) throw error;
+      throw new TradeRecordsCliError("INVALID_INPUT_FILE", `could not read --input-file: ${String(error)}`);
+    }
+    return { records: parseRecordArray(content2, "--input-file") };
+  }
+  const extraRaw = readSingle(parsed, "extra");
+  let extra = {};
+  if (extraRaw !== void 0) {
+    extra = parseJsonObject(extraRaw, "--extra");
+  }
+  return {
+    records: [normalizeRecord({
+      jobId: readSingle(parsed, "job-id"),
+      deliveryId: readSingle(parsed, "delivery-id"),
+      status: readSingle(parsed, "status"),
+      reason: readSingle(parsed, "reason") ?? "",
+      extra
+    }, 0)]
+  };
+}
+function parseRecordArray(raw, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new TradeRecordsCliError("INVALID_INPUT_JSON", `${label} must contain valid JSON`);
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    throw new TradeRecordsCliError("INVALID_INPUT_JSON", `${label} must contain a non-empty JSON array`);
+  }
+  if (parsed.length > MAX_BATCH_RECORDS) {
+    throw new TradeRecordsCliError(
+      "TOO_MANY_RECORDS",
+      `${label} contains ${parsed.length} records; maximum is ${MAX_BATCH_RECORDS}`
+    );
+  }
+  const records = [];
+  const details = [];
+  for (let index2 = 0; index2 < parsed.length; index2 += 1) {
+    try {
+      records.push(normalizeRecord(parsed[index2], index2));
+    } catch (error) {
+      const normalized = normalizeError(error);
+      details.push(...normalized.details ?? [{ index: index2, reason: normalized.message }]);
+    }
+  }
+  if (details.length > 0) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", "one or more trade records are invalid", details);
+  }
+  return records;
+}
+function normalizeRecord(value, index2) {
+  if (!isJsonObject2(value)) {
+    throw invalidField(index2, void 0, "must be a JSON object");
+  }
+  for (const field of Object.keys(value)) {
+    if (FORBIDDEN_RECORD_FIELDS.has(field)) {
+      throw invalidField(index2, field, "business callers must not provide timestamp fields");
+    }
+    if (!ALLOWED_RECORD_FIELDS.has(field)) {
+      throw invalidField(index2, field, "unknown field; put extensible fields inside extra");
+    }
+  }
+  const jobId = requireRecordText(value.jobId, index2, "jobId", MAX_ID_LENGTH);
+  const deliveryId = requireRecordText(value.deliveryId, index2, "deliveryId", MAX_ID_LENGTH);
+  const status = requireRecordText(value.status, index2, "status", MAX_STATUS_LENGTH);
+  const reason = value.reason === void 0 ? "" : requireRecordString(value.reason, index2, "reason", MAX_REASON_LENGTH, true);
+  const extra = value.extra === void 0 ? {} : value.extra;
+  if (!isJsonObject2(extra)) {
+    throw invalidField(index2, "extra", "must be a JSON object");
+  }
+  const serializedExtra = JSON.stringify(extra);
+  if (Buffer.byteLength(serializedExtra, "utf8") > MAX_EXTRA_BYTES) {
+    throw invalidField(index2, "extra", `serialized JSON exceeds ${MAX_EXTRA_BYTES} bytes`);
+  }
+  return { jobId, deliveryId, status, reason, extra };
+}
+function coalesceByLastDeliveryId(records) {
+  const lastIndexes = /* @__PURE__ */ new Map();
+  records.forEach((record, index2) => lastIndexes.set(record.deliveryId, index2));
+  const coalesced = records.filter((record, index2) => lastIndexes.get(record.deliveryId) === index2);
+  return { records: coalesced, duplicateInputCount: records.length - coalesced.length };
+}
+function parseArgs(args, spec) {
+  const options = /* @__PURE__ */ new Map();
+  const flags = /* @__PURE__ */ new Set();
+  for (let index2 = 0; index2 < args.length; index2 += 1) {
+    const token = args[index2];
+    if (!token.startsWith("--")) {
+      throw new TradeRecordsCliError("INVALID_ARGUMENT", `${spec.command} unexpected positional argument: ${token}`);
+    }
+    const name = token.slice(2);
+    if (spec.flags.has(name)) {
+      if (flags.has(name)) {
+        throw new TradeRecordsCliError("INVALID_ARGUMENT", `${token} must not be repeated`);
+      }
+      flags.add(name);
+      continue;
+    }
+    if (!spec.options.has(name)) {
+      throw new TradeRecordsCliError("INVALID_ARGUMENT", `${spec.command} unknown option ${token}`);
+    }
+    if (index2 + 1 >= args.length) {
+      throw new TradeRecordsCliError("INVALID_ARGUMENT", `${token} requires a value`);
+    }
+    const value = args[++index2];
+    if (value.startsWith("--")) {
+      throw new TradeRecordsCliError("INVALID_ARGUMENT", `${token} requires a value`);
+    }
+    const values = options.get(name) ?? [];
+    if (values.length > 0 && !spec.repeatable?.has(name)) {
+      throw new TradeRecordsCliError("INVALID_ARGUMENT", `${token} must not be repeated`);
+    }
+    values.push(value);
+    options.set(name, values);
+  }
+  return { options, flags };
+}
+function readSingle(parsed, name) {
+  return parsed.options.get(name)?.[0];
+}
+function readOptionalText(parsed, name, maxLength) {
+  const value = readSingle(parsed, name);
+  return value === void 0 ? void 0 : requireText(value, `--${name}`, maxLength);
+}
+function requireText(value, label, maxLength) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", `${label} is required and must be a non-empty string`);
+  }
+  const normalized = value.trim();
+  if (normalized.length > maxLength) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", `${label} exceeds ${maxLength} characters`);
+  }
+  return normalized;
+}
+function requireRecordText(value, index2, field, maxLength) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw invalidField(index2, field, "must be a non-empty string");
+  }
+  const normalized = value.trim();
+  if (normalized.length > maxLength) {
+    throw invalidField(index2, field, `exceeds ${maxLength} characters`);
+  }
+  return normalized;
+}
+function requireRecordString(value, index2, field, maxLength, allowEmpty) {
+  if (typeof value !== "string" || !allowEmpty && value.length === 0) {
+    throw invalidField(index2, field, allowEmpty ? "must be a string" : "must be a non-empty string");
+  }
+  if (value.length > maxLength) {
+    throw invalidField(index2, field, `exceeds ${maxLength} characters`);
+  }
+  return value;
+}
+function invalidField(index2, field, reason) {
+  return new TradeRecordsCliError("INVALID_ARGUMENT", `invalid trade record at index ${index2}`, [
+    { index: index2, ...field ? { field } : {}, reason }
+  ]);
+}
+function parseJsonObject(raw, label) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", `${label} must be valid JSON`);
+  }
+  if (!isJsonObject2(value)) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", `${label} must be a JSON object`);
+  }
+  if (Buffer.byteLength(JSON.stringify(value), "utf8") > MAX_EXTRA_BYTES) {
+    throw new TradeRecordsCliError("INPUT_TOO_LARGE", `${label} exceeds ${MAX_EXTRA_BYTES} bytes`);
+  }
+  return value;
+}
+function parseExtraFilter(raw) {
+  const separator = raw.indexOf("=");
+  if (separator <= 0 || separator === raw.length - 1) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", "--extra-eq must use path=jsonValue syntax");
+  }
+  const path2 = raw.slice(0, separator).trim();
+  const segments = path2.split(".");
+  if (segments.some((segment) => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment))) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", `--extra-eq has invalid JSON path: ${path2}`);
+  }
+  let value;
+  try {
+    value = JSON.parse(raw.slice(separator + 1));
+  } catch {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", "--extra-eq value must be a JSON primitive");
+  }
+  if (typeof value === "object" && value !== null) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", "--extra-eq value must be a JSON primitive");
+  }
+  if (!["string", "number", "boolean"].includes(typeof value) && value !== null) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", "--extra-eq value must be a JSON primitive");
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", "--extra-eq number must be finite");
+  }
+  return { path: `$.${segments.join(".")}`, value };
+}
+function readTimestamp(parsed, name) {
+  const raw = readSingle(parsed, name);
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", `--${name} must be a non-negative integer`);
+  }
+  return value;
+}
+function assertRange(label, from, to) {
+  if (from !== void 0 && to !== void 0 && from > to) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", `--${label}-from must not exceed --${label}-to`);
+  }
+}
+function readLimit(parsed) {
+  const raw = readSingle(parsed, "limit");
+  if (raw === void 0) return 100;
+  const limit = Number(raw);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 1e3) {
+    throw new TradeRecordsCliError("INVALID_ARGUMENT", "--limit must be an integer between 1 and 1000");
+  }
+  return limit;
+}
+function readChoice(parsed, name, choices) {
+  const value = readSingle(parsed, name);
+  if (value === void 0) return void 0;
+  if (!choices.includes(value)) {
+    throw new TradeRecordsCliError(
+      "INVALID_ARGUMENT",
+      `--${name} must be one of: ${choices.join(", ")}`
+    );
+  }
+  return value;
+}
+function assertInputSize(value, label) {
+  if (Buffer.byteLength(value, "utf8") > MAX_INPUT_BYTES) {
+    throw new TradeRecordsCliError("INPUT_TOO_LARGE", `${label} exceeds ${MAX_INPUT_BYTES} bytes`);
+  }
+}
+function outputQuery(json, records, limit, nextCursor, count) {
+  if (json) {
+    console.log(JSON.stringify({
+      ok: true,
+      records,
+      page: { limit, nextCursor },
+      ...count === void 0 ? {} : { count }
+    }));
+    return;
+  }
+  if (records.length === 0) {
+    console.log("No trade records found.");
+    return;
+  }
+  for (const record of records) {
+    console.log(
+      `${record.deliveryId} job=${record.jobId} status=${record.status} reason=${JSON.stringify(record.reason)} extra=${JSON.stringify(record.extra)} createdAt=${record.createdAt} updatedAt=${record.updatedAt} deletedAt=${record.deletedAt ?? ""}`
+    );
+  }
+  if (nextCursor) {
+    console.log(`Next cursor: ${nextCursor}`);
+  }
+  if (count !== void 0) {
+    console.log(`Count: ${count}`);
+  }
+}
+function outputDelete(json, result) {
+  if (json) {
+    console.log(JSON.stringify({ ok: true, operation: "delete", ...result }));
+    return;
+  }
+  if (result.deleted) {
+    console.log(`Trade record deleted: deliveryId=${result.deliveryId}`);
+  } else if (result.alreadyDeleted) {
+    console.log(`Trade record already deleted: deliveryId=${result.deliveryId}`);
+  } else {
+    console.log(`Trade record not found: deliveryId=${result.deliveryId}`);
+  }
+}
+function outputError(json, error) {
+  if (json) {
+    console.log(JSON.stringify({
+      ok: false,
+      code: error.code,
+      message: error.message,
+      ...error.details ? { details: error.details } : {}
+    }));
+    return;
+  }
+  console.error(`Trade records error [${error.code}]: ${error.message}`);
+  for (const detail of error.details ?? []) {
+    console.error(
+      `  index=${detail.index ?? ""} field=${detail.field ?? ""} reason=${detail.reason}`
+    );
+  }
+}
+function normalizeError(error) {
+  if (error instanceof TradeRecordsCliError) return error;
+  if (error instanceof TradeRecordsStoreError) {
+    return new TradeRecordsCliError(error.code, error.message);
+  }
+  if (isBusyError(error)) {
+    return new TradeRecordsCliError("DATABASE_BUSY", "trade records database is busy; retry later");
+  }
+  return new TradeRecordsCliError(
+    "TRADE_RECORDS_FAILED",
+    error instanceof Error ? error.message : String(error)
+  );
+}
+function isBusyError(error) {
+  if (!(error instanceof Error)) return false;
+  const code = error.errcode;
+  return typeof code === "number" && ((code & 255) === 5 || (code & 255) === 6) || /database is locked|database table is locked/i.test(error.message);
+}
+function isJsonObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isHelpArg(value) {
+  return value === "help" || value === "-h" || value === "--help";
+}
+var import_node_fs21, MAX_BATCH_RECORDS, MAX_INPUT_BYTES, MAX_EXTRA_BYTES, MAX_ID_LENGTH, MAX_STATUS_LENGTH, MAX_REASON_LENGTH, INPUT_FIELD_OPTIONS, FORBIDDEN_RECORD_FIELDS, ALLOWED_RECORD_FIELDS, TradeRecordsCliError;
+var init_trade_records_cli = __esm({
+  "src/trade-records-cli.ts"() {
+    "use strict";
+    import_node_fs21 = require("node:fs");
+    init_trade_records_store();
+    MAX_BATCH_RECORDS = 1e3;
+    MAX_INPUT_BYTES = 10 * 1024 * 1024;
+    MAX_EXTRA_BYTES = 256 * 1024;
+    MAX_ID_LENGTH = 512;
+    MAX_STATUS_LENGTH = 128;
+    MAX_REASON_LENGTH = 4096;
+    INPUT_FIELD_OPTIONS = /* @__PURE__ */ new Set(["job-id", "delivery-id", "status", "reason", "extra"]);
+    FORBIDDEN_RECORD_FIELDS = /* @__PURE__ */ new Set([
+      "createdAt",
+      "createAt",
+      "updatedAt",
+      "updateAt",
+      "deletedAt",
+      "created_at",
+      "create_at",
+      "updated_at",
+      "update_at",
+      "deleted_at"
+    ]);
+    ALLOWED_RECORD_FIELDS = /* @__PURE__ */ new Set(["jobId", "deliveryId", "status", "reason", "extra"]);
+    TradeRecordsCliError = class extends Error {
+      code;
+      details;
+      constructor(code, message, details) {
+        super(message);
+        this.name = "TradeRecordsCliError";
+        this.code = code;
+        this.details = details;
+      }
+    };
+  }
+});
+
 // ../core/src/xmtp-sdk/onchainos/bin.ts
 async function refreshOnchainosVersionMetadata(options = {}) {
   const now = options.now ?? Date.now;
@@ -41216,11 +42300,11 @@ function isResolvedBinUsable(bin) {
   if (!isPathLikeCommand(bin)) {
     return true;
   }
-  return process.platform === "win32" ? (0, import_node_fs20.existsSync)(bin) : isExecutable2(bin);
+  return process.platform === "win32" ? (0, import_node_fs22.existsSync)(bin) : isExecutable2(bin);
 }
 function resolvePosixBareCommand(command, pathValue) {
   for (const dir of pathValue.split(":")) {
-    const candidate = (0, import_node_path24.join)(dir || ".", command);
+    const candidate = (0, import_node_path25.join)(dir || ".", command);
     if (isExecutable2(candidate)) {
       return candidate;
     }
@@ -41503,12 +42587,12 @@ function buildWin32CandidatePaths(names, pathValue, userProfile) {
     addDir(dir);
   }
   if (userProfile?.trim()) {
-    addDir((0, import_node_path24.join)(userProfile, ".local", "bin"));
+    addDir((0, import_node_path25.join)(userProfile, ".local", "bin"));
   }
   const candidates = [];
   for (const dir of dirs) {
     for (const name of names) {
-      candidates.push((0, import_node_path24.join)(dir, name));
+      candidates.push((0, import_node_path25.join)(dir, name));
     }
   }
   return candidates;
@@ -41521,7 +42605,7 @@ function buildWin32OnchainosCandidates(pathValue, userProfile) {
   );
 }
 function resolveWin32BareCommandCandidate(command, pathValue, pathExtValue, userProfile) {
-  const names = (0, import_node_path24.extname)(command) ? [command] : [
+  const names = (0, import_node_path25.extname)(command) ? [command] : [
     ...new Set(
       pathExtValue.split(";").map((extension) => extension.trim().toLowerCase()).filter(Boolean).map(
         (extension) => `${command}${extension.startsWith(".") ? extension : `.${extension}`}`
@@ -41537,7 +42621,7 @@ function resolveWin32BareCommandCandidate(command, pathValue, pathExtValue, user
   return null;
 }
 function win32CandidatePriority(candidate) {
-  const extension = (0, import_node_path24.extname)(candidate).toLowerCase();
+  const extension = (0, import_node_path25.extname)(candidate).toLowerCase();
   if (extension === ".exe") {
     return 0;
   }
@@ -41553,7 +42637,7 @@ function isWindowsAppsAlias(candidate) {
   return candidate.toLowerCase().includes(WINDOWS_APPS_ALIAS_MARKER);
 }
 function win32FileExists(path2) {
-  return (0, import_node_fs20.existsSync)(path2);
+  return (0, import_node_fs22.existsSync)(path2);
 }
 function pickOnchainosWin32Candidate(lines, fileExists2 = win32FileExists) {
   const candidates = lines.map((line) => {
@@ -41609,7 +42693,7 @@ function extractExecutablePath(stdout) {
 }
 function isExecutable2(path2) {
   try {
-    (0, import_node_fs20.accessSync)(path2, import_node_fs20.constants.X_OK);
+    (0, import_node_fs22.accessSync)(path2, import_node_fs22.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -41714,14 +42798,14 @@ async function exec(args, options = {}) {
   }
   throw new Error("OnchainOS command retry exhausted");
 }
-var import_node_fs20, import_node_child_process8, import_node_path24, 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_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 init_bin = __esm({
   "../core/src/xmtp-sdk/onchainos/bin.ts"() {
     "use strict";
     init_log();
-    import_node_fs20 = require("node:fs");
+    import_node_fs22 = require("node:fs");
     import_node_child_process8 = require("node:child_process");
-    import_node_path24 = require("node:path");
+    import_node_path25 = require("node:path");
     import_node_util2 = require("node:util");
     init_sentry_logger();
     init_runtime_metadata();
@@ -41783,15 +42867,15 @@ function createAsyncStreamProxy(stream) {
     }
   });
 }
-var import_node_bindings, import_node_bindings2, import_node_crypto9, import_types, import_node_path25, 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_path25 = require("node:path");
+    import_node_path26 = require("node:path");
     import_node_process = __toESM(require("node:process"), 1);
     HistorySyncUrls = {
       local: "http://localhost:5558",
@@ -43430,7 +44514,7 @@ var init_dist2 = __esm({
       const env = envToString(backend.env);
       let dbPath;
       if (options?.dbPath === void 0) {
-        dbPath = (0, import_node_path25.join)(import_node_process.default.cwd(), `xmtp-${env}-${inboxId}.db3`);
+        dbPath = (0, import_node_path26.join)(import_node_process.default.cwd(), `xmtp-${env}-${inboxId}.db3`);
       } else if (typeof options.dbPath === "function") {
         dbPath = options.dbPath(inboxId);
       } else {
@@ -43472,7 +44556,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) => {
@@ -55721,20 +56805,20 @@ async function createRemoteAttachmentFromFile(unencryptedFile, uploadCallback) {
   const fileUrl = await uploadCallback(encryptedAttachment);
   return createRemoteAttachment(encryptedAttachment, fileUrl);
 }
-var import_node_events, import_node_fs21, import_node_path26, 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_fs23, 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_fs21 = __toESM(require("node:fs"), 1);
-    import_node_path26 = __toESM(require("node:path"), 1);
+    import_node_fs23 = __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;
@@ -56094,9 +57178,9 @@ var init_dist4 = __esm({
           initializedOptions.gatewayHost = XMTP_GATEWAY_HOST;
         }
         if (typeof XMTP_DB_DIRECTORY === "string") {
-          import_node_fs21.default.mkdirSync(XMTP_DB_DIRECTORY, { recursive: true, mode: 448 });
+          import_node_fs23.default.mkdirSync(XMTP_DB_DIRECTORY, { recursive: true, mode: 448 });
           initializedOptions.dbPath = (inboxId) => {
-            const dbPath = import_node_path26.default.join(XMTP_DB_DIRECTORY, `xmtp-${inboxId}.db3`);
+            const dbPath = import_node_path27.default.join(XMTP_DB_DIRECTORY, `xmtp-${inboxId}.db3`);
             console.info(`Saving local database to "${dbPath}"`);
             return dbPath;
           };
@@ -56404,7 +57488,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;
@@ -57139,7 +58223,7 @@ var init_session_expired = __esm({
 
 // ../core/src/xmtp-sdk/index.ts
 function cachePath(dataDir, fileName) {
-  return (0, import_node_path27.join)(dataDir, fileName);
+  return (0, import_node_path28.join)(dataDir, fileName);
 }
 function formatLogTimestamp2(timestampMs) {
   return timestampMs && timestampMs > 0 ? new Date(timestampMs).toISOString() : "(none)";
@@ -57167,10 +58251,10 @@ function ensureCacheDir(dataDir) {
 function loadSensitiveWordsFromCache(dataDir) {
   try {
     const path2 = cachePath(dataDir, "sensitive-words.json");
-    if (!(0, import_node_fs22.existsSync)(path2)) {
+    if (!(0, import_node_fs24.existsSync)(path2)) {
       return null;
     }
-    const data = JSON.parse((0, import_node_fs22.readFileSync)(path2, "utf-8"));
+    const data = JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf-8"));
     if (Array.isArray(data)) {
       return data;
     }
@@ -57184,7 +58268,7 @@ function loadSensitiveWordsFromCache(dataDir) {
 function saveSensitiveWordsToCache(dataDir, words) {
   try {
     ensureCacheDir(dataDir);
-    (0, import_node_fs22.writeFileSync)(cachePath(dataDir, "sensitive-words.json"), JSON.stringify(words));
+    (0, import_node_fs24.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" });
@@ -57226,10 +58310,10 @@ async function loadSensitiveWordsWith(dataDir, fetcher) {
 function loadSystemConfigFromCache(dataDir) {
   try {
     const path2 = cachePath(dataDir, "system-config.json");
-    if (!(0, import_node_fs22.existsSync)(path2)) {
+    if (!(0, import_node_fs24.existsSync)(path2)) {
       return null;
     }
-    const data = JSON.parse((0, import_node_fs22.readFileSync)(path2, "utf-8"));
+    const data = JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf-8"));
     if (data && typeof data === "object" && !Array.isArray(data)) {
       return data;
     }
@@ -57243,7 +58327,7 @@ function loadSystemConfigFromCache(dataDir) {
 function saveSystemConfigToCache(dataDir, config) {
   try {
     ensureCacheDir(dataDir);
-    (0, import_node_fs22.writeFileSync)(cachePath(dataDir, "system-config.json"), JSON.stringify(config));
+    (0, import_node_fs24.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" });
@@ -57293,10 +58377,10 @@ function loadSyncByAddress(dataDir) {
   const map = /* @__PURE__ */ new Map();
   try {
     const path2 = cachePath(dataDir, "last-sync.json");
-    if (!(0, import_node_fs22.existsSync)(path2)) {
+    if (!(0, import_node_fs24.existsSync)(path2)) {
       return map;
     }
-    const data = JSON.parse((0, import_node_fs22.readFileSync)(path2, "utf-8"));
+    const data = JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf-8"));
     const obj = data?.syncByAddress;
     if (obj && typeof obj === "object" && !Array.isArray(obj)) {
       for (const [addr, ts] of Object.entries(obj)) {
@@ -57315,9 +58399,9 @@ function saveSyncForAddress(dataDir, address, timestampMs) {
   try {
     let data = {};
     const path2 = cachePath(dataDir, "last-sync.json");
-    if ((0, import_node_fs22.existsSync)(path2)) {
+    if ((0, import_node_fs24.existsSync)(path2)) {
       try {
-        const raw = JSON.parse((0, import_node_fs22.readFileSync)(path2, "utf-8"));
+        const raw = JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf-8"));
         if (raw && typeof raw === "object" && !Array.isArray(raw)) {
           data = raw;
         }
@@ -57328,7 +58412,7 @@ function saveSyncForAddress(dataDir, address, timestampMs) {
       data.syncByAddress = {};
     }
     data.syncByAddress[address] = timestampMs;
-    (0, import_node_fs22.writeFileSync)(path2, JSON.stringify(data, null, 2));
+    (0, import_node_fs24.writeFileSync)(path2, JSON.stringify(data, null, 2));
   } catch (err2) {
     logWithTimestamp(
       `[xmtp-sdk] failed to write last-sync.json (address=${address}):`,
@@ -57547,13 +58631,13 @@ function createOfflineReplayAddressSummary(address) {
     durationMs: 0
   };
 }
-var import_node_fs22, import_node_path27, 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_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 init_xmtp_sdk = __esm({
   "../core/src/xmtp-sdk/index.ts"() {
     "use strict";
     init_log();
-    import_node_fs22 = require("node:fs");
-    import_node_path27 = require("node:path");
+    import_node_fs24 = require("node:fs");
+    import_node_path28 = require("node:path");
     init_dist4();
     init_dist2();
     init_sentry_logger();
@@ -60789,7 +61873,7 @@ var init_envelope = __esm({
 });
 
 // src/invalid-message-store.ts
-function loadSqlite4() {
+function loadSqlite5() {
   const originalEmitWarning = process.emitWarning;
   process.emitWarning = ((warning, ...args) => {
     const message = typeof warning === "string" ? warning : warning.message;
@@ -60804,22 +61888,22 @@ function loadSqlite4() {
     process.emitWarning = originalEmitWarning;
   }
 }
-var import_node_fs23, import_node_path28, DatabaseSync3, InvalidXmtpMessageStore;
+var import_node_fs25, import_node_path29, DatabaseSync4, InvalidXmtpMessageStore;
 var init_invalid_message_store = __esm({
   "src/invalid-message-store.ts"() {
     "use strict";
-    import_node_fs23 = require("node:fs");
-    import_node_path28 = require("node:path");
+    import_node_fs25 = require("node:fs");
+    import_node_path29 = require("node:path");
     init_paths();
-    ({ DatabaseSync: DatabaseSync3 } = loadSqlite4());
+    ({ DatabaseSync: DatabaseSync4 } = loadSqlite5());
     InvalidXmtpMessageStore = class {
       dbPath;
       db;
       constructor(homeDir) {
         const paths = resolveTaskPaths(homeDir);
-        this.dbPath = (0, import_node_path28.join)(paths.sqliteDir, "invalid-xmtp-messages.sqlite");
-        (0, import_node_fs23.mkdirSync)((0, import_node_path28.dirname)(this.dbPath), { recursive: true });
-        this.db = new DatabaseSync3(this.dbPath);
+        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);
         this.ensureReady();
       }
       close() {
@@ -61195,14 +62279,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();
@@ -61759,7 +62843,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: {
@@ -61888,7 +62972,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",
@@ -62107,7 +63191,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",
@@ -62153,14 +63237,14 @@ async function handleXmtpSendCommand(params) {
     ownedStore?.close();
   }
 }
-var import_node_crypto12, TASK_MIN_VERSION, sqliteGroupSessionPromises, conversationSyncPromises, XMTP_SEND_CHECKPOINT, resolvedAgentByIdCache, resolvedAgentByAddressCache;
+var import_node_crypto13, TASK_MIN_VERSION, sqliteGroupSessionPromises, conversationSyncPromises, XMTP_SEND_CHECKPOINT, resolvedAgentByIdCache, resolvedAgentByAddressCache;
 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();
@@ -62264,7 +63348,7 @@ function buildAiAdapterCommand(options) {
 function readCodexAddDirs(env = process.env) {
   const raw = env.OKX_A2A_AI_CODEX_ADD_DIRS ?? env.OKX_AGENT_TASK_CODEX_ADD_DIRS ?? "";
   const seen = /* @__PURE__ */ new Set();
-  return raw.split(import_node_path29.delimiter).map((value) => expandHomePath(value.trim())).filter(Boolean).filter((dir) => {
+  return raw.split(import_node_path30.delimiter).map((value) => expandHomePath(value.trim())).filter(Boolean).filter((dir) => {
     if (seen.has(dir)) {
       return false;
     }
@@ -62277,7 +63361,7 @@ function expandHomePath(value) {
     return (0, import_node_os9.homedir)();
   }
   if (value.startsWith("~/")) {
-    return (0, import_node_path29.join)((0, import_node_os9.homedir)(), value.slice(2));
+    return (0, import_node_path30.join)((0, import_node_os9.homedir)(), value.slice(2));
   }
   return value;
 }
@@ -62494,9 +63578,9 @@ function formatOpenClawSessionKey(sessionKey, agentId) {
 function buildClaudeAddDirArgs(homeDir, env) {
   const dirs = [
     homeDir,
-    (0, import_node_path29.join)((0, import_node_os9.homedir)(), ".agents"),
-    (0, import_node_path29.join)(__dirname, ".."),
-    ...env.OKX_A2A_AI_CLAUDE_ADD_DIRS ? env.OKX_A2A_AI_CLAUDE_ADD_DIRS.split(import_node_path29.delimiter).filter(Boolean) : []
+    (0, import_node_path30.join)((0, import_node_os9.homedir)(), ".agents"),
+    (0, import_node_path30.join)(__dirname, ".."),
+    ...env.OKX_A2A_AI_CLAUDE_ADD_DIRS ? env.OKX_A2A_AI_CLAUDE_ADD_DIRS.split(import_node_path30.delimiter).filter(Boolean) : []
   ];
   return ["--add-dir", ...[...new Set(dirs)]];
 }
@@ -62548,16 +63632,16 @@ function applyArgTemplate(template, options) {
   const homeDir = options.homeDir ?? resolveTaskPaths().homeDir;
   const cwd = options.cwd ?? process.cwd();
   return template.map((arg) => {
-    return arg.replaceAll("{prompt}", options.prompt).replaceAll("{sessionId}", options.sessionId ?? "").replaceAll("{homeDir}", homeDir).replaceAll("{cwd}", cwd).replaceAll("{repoCli}", (0, import_node_path29.join)(__dirname, "cli.js"));
+    return arg.replaceAll("{prompt}", options.prompt).replaceAll("{sessionId}", options.sessionId ?? "").replaceAll("{homeDir}", homeDir).replaceAll("{cwd}", cwd).replaceAll("{repoCli}", (0, import_node_path30.join)(__dirname, "cli.js"));
   });
 }
-var import_node_os9, import_node_path29, CLAUDE_ALLOWED_TOOLS, CLAUDE_PERMISSION_MODES, CODEX_SANDBOX_MODES, CODEX_APPROVAL_POLICIES;
+var import_node_os9, import_node_path30, CLAUDE_ALLOWED_TOOLS, CLAUDE_PERMISSION_MODES, CODEX_SANDBOX_MODES, CODEX_APPROVAL_POLICIES;
 var init_ai_adapter = __esm({
   "src/ai-adapter.ts"() {
     "use strict";
     init_log();
     import_node_os9 = require("node:os");
-    import_node_path29 = require("node:path");
+    import_node_path30 = require("node:path");
     init_ai_command();
     init_paths();
     init_session_store();
@@ -62617,7 +63701,7 @@ function aiRunSentryExtra(input) {
     closeSignal: input.closeSignal ?? "",
     timedOut: input.timedOut === void 0 ? "" : String(input.timedOut),
     aiSessionId: input.aiSessionId ?? "",
-    aiLogFile: input.logPath ? (0, import_node_path30.basename)(input.logPath) : "",
+    aiLogFile: input.logPath ? (0, import_node_path31.basename)(input.logPath) : "",
     commandPendingMs: input.commandPendingMs ?? "",
     queueWaitMs: input.queueWaitMs ?? "",
     storeReadMs: input.storeReadMs ?? "",
@@ -62645,7 +63729,7 @@ function resolveProviderCommandWithSelfHeal(options) {
   const env = options.env ?? process.env;
   const storedCommand = options.provider === "codex" ? options.store.getAiProviderCommand(options.provider) : null;
   const resolved = resolveAiProviderCommandWithSource(options.provider, env, storedCommand, options.platform);
-  if (options.provider === "codex" && resolved.source !== "explicit_override" && resolved.command !== storedCommand && (0, import_node_path30.isAbsolute)(resolved.command)) {
+  if (options.provider === "codex" && resolved.source !== "explicit_override" && resolved.command !== storedCommand && (0, import_node_path31.isAbsolute)(resolved.command)) {
     options.store.setAiProviderCommand(options.provider, resolved.command);
   }
   return { command: resolved.command, commandSource: resolved.source };
@@ -62677,7 +63761,7 @@ function aiRunToolFailureSentryExtra(failure, context) {
     closeSignal: context.closeSignal ?? "",
     timedOut: String(context.timedOut),
     aiSessionId: context.aiSessionId ?? "",
-    aiLogFile: (0, import_node_path30.basename)(context.logPath)
+    aiLogFile: (0, import_node_path31.basename)(context.logPath)
   }).filter(([, value]) => value !== "");
   return entries.reduce((out, [key, value]) => {
     out[key] = String(value);
@@ -62700,7 +63784,7 @@ function safeProcessCwd() {
 }
 function isDirectory(path2) {
   try {
-    return (0, import_node_fs24.statSync)(path2).isDirectory();
+    return (0, import_node_fs26.statSync)(path2).isDirectory();
   } catch {
     return false;
   }
@@ -63039,9 +64123,9 @@ function getPreferredCodexWritableRoot(target) {
   const expanded = expandHomePath2(target);
   const home = (0, import_node_os10.homedir)();
   const appRoots = [
-    (0, import_node_path30.join)(home, ".onchainos", "task"),
-    (0, import_node_path30.join)(home, ".onchainos", "deliverables"),
-    (0, import_node_path30.join)(home, ".okx-agent-task")
+    (0, import_node_path31.join)(home, ".onchainos", "task"),
+    (0, import_node_path31.join)(home, ".onchainos", "deliverables"),
+    (0, import_node_path31.join)(home, ".okx-agent-task")
   ];
   for (const root of appRoots) {
     if (expanded === root || expanded.startsWith(`${root}/`)) {
@@ -63056,7 +64140,7 @@ function inferAppOwnedCodexWritableRoot(failure) {
     return void 0;
   }
   if (containsOnchainosCommand(command) && /\b0x[0-9a-fA-F]{16,}\b/.test(command)) {
-    return (0, import_node_path30.join)((0, import_node_os10.homedir)(), ".onchainos", "task");
+    return (0, import_node_path31.join)((0, import_node_os10.homedir)(), ".onchainos", "task");
   }
   return void 0;
 }
@@ -63065,7 +64149,7 @@ function expandHomePath2(value) {
     return (0, import_node_os10.homedir)();
   }
   if (value.startsWith("~/")) {
-    return (0, import_node_path30.join)((0, import_node_os10.homedir)(), value.slice(2));
+    return (0, import_node_path31.join)((0, import_node_os10.homedir)(), value.slice(2));
   }
   return value;
 }
@@ -64026,7 +65110,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(" ");
@@ -64050,16 +65134,16 @@ function shortenJobId2(jobId) {
   }
   return `${jobId.slice(0, 6)}\u2026${jobId.slice(-4)}`;
 }
-var import_node_crypto13, import_node_fs24, import_promises12, import_node_os10, import_node_path30, AiRunner, CODEX_TOOL_FAILURE_MARKER;
+var import_node_crypto14, import_node_fs26, import_promises12, import_node_os10, 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_fs24 = require("node:fs");
+    import_node_crypto14 = require("node:crypto");
+    import_node_fs26 = require("node:fs");
     import_promises12 = require("node:fs/promises");
     import_node_os10 = require("node:os");
-    import_node_path30 = require("node:path");
+    import_node_path31 = require("node:path");
     init_ai_command();
     init_paths();
     init_file_store();
@@ -64067,6 +65151,7 @@ var init_ai_runner = __esm({
     init_ai_adapter();
     init_task_config();
     init_win_spawn();
+    init_ai_run_log();
     init_session_store();
     init_user_attention_ipc();
     init_sentry_logger();
@@ -64204,7 +65289,7 @@ var init_ai_runner = __esm({
         ensureTaskDir(this.logsDir);
         const lifecycleLogsEnabled = isAiLifecycleLoggingEnabled();
         const logPath = lifecycleLogsEnabled ? this.buildRunLogPath(request) : "";
-        const log = lifecycleLogsEnabled ? (0, import_node_fs24.createWriteStream)(logPath, { flags: "a" }) : null;
+        const log = lifecycleLogsEnabled ? (0, import_node_fs26.createWriteStream)(logPath, { flags: "a" }) : null;
         let existing = null;
         let storeReadStartedAt;
         let storeReadEndedAt;
@@ -64688,13 +65773,7 @@ var init_ai_runner = __esm({
         );
       }
       buildRunLogPath(request) {
-        const safeMessageId = encodeURIComponent(request.messageId);
-        if (request.source === "job-dispatch") {
-          const safeJobId = encodeURIComponent(request.jobId ?? "unknown");
-          return (0, import_node_path30.join)(this.logsDir, `ai-${safeJobId}-${safeMessageId}.log`);
-        }
-        const safeSessionKey = encodeURIComponent(request.sessionKey);
-        return (0, import_node_path30.join)(this.logsDir, `ai-session-${safeSessionKey}-${safeMessageId}.log`);
+        return (0, import_node_path31.join)(this.logsDir, buildAiRunLogFileName(request));
       }
       readRunAiSessionId(provider, request, file, sessionMeta) {
         if (request.source === "job-dispatch" && request.jobId) {
@@ -65033,7 +66112,7 @@ var init_ai_runner = __esm({
       async appendLlmLog(entry) {
         try {
           ensureTaskDir(this.logsDir);
-          await (0, import_promises12.appendFile)((0, import_node_path30.join)(this.logsDir, "llm.log"), formatLlmLogEntry(entry), "utf8");
+          await (0, import_promises12.appendFile)((0, import_node_path31.join)(this.logsDir, "llm.log"), formatLlmLogEntry(entry), "utf8");
         } catch (err2) {
           errorWithTimestamp("[okx-agent-task] failed to append llm.log:", err2);
         }
@@ -66774,6 +67853,9 @@ function parseJson2(rawText) {
 function readString5(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
+function isValidExternalJobId(value) {
+  return typeof value === "string" && EXTERNAL_JOB_ID_PATTERN.test(value);
+}
 function readNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
@@ -67693,7 +68775,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"),
@@ -67717,7 +68799,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"
     });
@@ -67725,7 +68807,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)}`
     );
@@ -67884,7 +68966,38 @@ async function processFileMessage(ctx, deps, options = {}) {
   const routeStartedAt = Date.now();
   const route = routeMessage(chatType, parseResult.ok, parseResult.data);
   timing.mark("routeResolve", routeStartedAt);
-  if (route.route === "job") {
+  if (route.route === "job" && parseResult.ok && isA2AEnvelope(parseResult.data) && !isValidExternalJobId(route.jobId)) {
+    const payloadObject = parseResult.data;
+    const sender = isPlainObject3(payloadObject.sender) ? payloadObject.sender : null;
+    logWithTimestamp(
+      `[okx-agent-task:${deps.myXmtpAddress}] inbound A2A message has invalid jobId, dropping: jobLength=${route.jobId.length} group=${conversationId}`
+    );
+    logger.info(LogEvent.INBOUND_DROP_INVALID_JOBID, timing.extras({
+      ...agentExtras({ walletAddress: deps.myXmtpAddress }),
+      peerWalletAddress: "",
+      peerInboxId: ctx.message.senderInboxId ?? "",
+      peerAgentId: readString5(sender?.agentId) ?? "",
+      conversationId,
+      messageId,
+      chatType,
+      ...inboundStageExtras("inbound/job_id_validation", "dropped"),
+      reason: "invalid_job_id_format"
+    }));
+    recordInvalidXmtpMessageBestEffort({
+      messageId,
+      groupId: conversationId,
+      jobId: null,
+      agentId: readString5(sender?.agentId),
+      localAgentId: XmtpService.getInstance().getAgentByAddress(deps.myXmtpAddress)?.agentId ?? null,
+      senderAddress: null,
+      senderInboxId: ctx.message.senderInboxId ?? "",
+      reason: "invalid_job_id_format",
+      stage: "inbound/job_id_validation",
+      logTag: `[okx-agent-task:${deps.myXmtpAddress}]`
+    });
+    return true;
+  }
+  if (route.route === "job" && chatType !== "group") {
     const providerBindStartedAt = Date.now();
     const providerGate = await bindMessageJobProviderToCurrentDefault(deps, route.jobId, "inbound-xmtp");
     timing.mark("providerBind", providerBindStartedAt);
@@ -67970,7 +69083,27 @@ async function processFileMessage(ctx, deps, options = {}) {
     if (!accepted) {
       return true;
     }
-    const routedMessageId = messageId || `group-${(0, import_node_crypto14.randomUUID)()}`;
+    const providerBindStartedAt = Date.now();
+    const providerGate = await bindMessageJobProviderToCurrentDefault(deps, route.jobId, "inbound-xmtp");
+    timing.mark("providerBind", providerBindStartedAt);
+    if (!providerGate.allowed) {
+      logger.info(LogEvent.INBOUND_IGNORED_NON_BUSINESS, timing.extras({
+        ...buildInboundTerminalExtras({
+          terminalState: "provider_gate_denied",
+          myXmtpAddress: deps.myXmtpAddress,
+          messageId,
+          conversationId,
+          chatType,
+          jobId: route.jobId,
+          route: route.route,
+          reason: "job_provider_gate_denied"
+        }),
+        routeReason: route.routeReason,
+        providerBinding: providerGate.provider ?? ""
+      }));
+      return true;
+    }
+    const routedMessageId = messageId || `group-${(0, import_node_crypto15.randomUUID)()}`;
     const sessionKey = ensureInboundGroupSession(deps, {
       jobId: route.jobId,
       myAgentId,
@@ -68036,7 +69169,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,
@@ -68217,7 +69350,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,
@@ -68235,12 +69368,12 @@ function buildSystemStoredMessage(params) {
 function isA2AEnvelope(payload) {
   return isPlainObject3(payload) && payload.msgType === A2A_MESSAGE_TYPE;
 }
-var import_node_crypto14, PROCESSED_IDS_MAX, processedMessageIds, INBOUND_TRANSPORT, INBOUND_EVENT_FAMILY, INBOUND_TERMINAL_FIELDS;
+var import_node_crypto15, PROCESSED_IDS_MAX, processedMessageIds, 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();
@@ -68257,6 +69390,7 @@ var init_message_handler = __esm({
     init_ai_provider();
     PROCESSED_IDS_MAX = 1e3;
     processedMessageIds = /* @__PURE__ */ new Map();
+    EXTERNAL_JOB_ID_PATTERN = /^0x[0-9a-fA-F]{64}$/;
     INBOUND_TRANSPORT = "xmtp";
     INBOUND_EVENT_FAMILY = "inbound";
     INBOUND_TERMINAL_FIELDS = {
@@ -68307,7 +69441,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(),
@@ -68386,11 +69520,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;
@@ -68461,12 +69595,12 @@ async function isGatewayAvailableForHeartbeat(options) {
 }
 async function getHermesGatewayPluginStatus(options = {}) {
   const env = options.env ?? process.env;
-  const hermesHome = env.HERMES_HOME?.trim() || (0, import_node_path31.join)((0, import_node_os11.homedir)(), ".hermes");
-  const pluginYamlPath = (0, import_node_path31.join)(hermesHome, "plugins", "platforms", "okx-a2a", "plugin.yaml");
-  if (!(0, import_node_fs25.existsSync)(pluginYamlPath)) {
+  const hermesHome = env.HERMES_HOME?.trim() || (0, import_node_path32.join)((0, import_node_os11.homedir)(), ".hermes");
+  const pluginYamlPath = (0, import_node_path32.join)(hermesHome, "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  if (!(0, import_node_fs27.existsSync)(pluginYamlPath)) {
     return { enabled: false, reason: "plugin_yaml_missing", hermesHome, checkedPath: pluginYamlPath };
   }
-  const configPath = (0, import_node_path31.join)(hermesHome, "config.yaml");
+  const configPath = (0, import_node_path32.join)(hermesHome, "config.yaml");
   let content2;
   try {
     content2 = await (0, import_promises13.readFile)(configPath, "utf8");
@@ -68698,12 +69832,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.11");
+  service.setPluginVersion("0.2.12-beta-7449a77b9d-260909165309");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.11"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.12-beta-7449a77b9d-260909165309"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -68731,7 +69865,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.11"
+      pluginVersion: "0.2.12-beta-7449a77b9d-260909165309"
     });
   }
   logWithTimestamp(
@@ -69081,15 +70215,15 @@ async function timeSettled(fn) {
     return { durationMs: Date.now() - startedAt, error };
   }
 }
-var import_node_fs25, import_promises13, import_node_os11, import_node_path31, DEFAULT_OFFLINE_REPLAY_INTERVAL_SEC, DEFAULT_XMTP_CLIENT_RECYCLE_INTERVAL_SEC, XMTP_CLIENT_RECYCLE_INTERVAL_ENV, HEARTBEAT_GATEWAY_CHECK_TIMEOUT_MS, AUTH_RECOVERY_PROBE_INTERVAL_MS, AUTH_RECOVERY_REFRESH_BACKOFF_MS, AgentRefreshAuthGate, AgentRefreshCoordinator, ListenerDeferredTaskScheduler, ListenerMaintenanceGate, UPGRADE_RECOMMENDATION_IDEMPOTENCY_KEY, SHUTDOWN_FORCE_RESOLVE_MS;
+var import_node_fs27, import_promises13, import_node_os11, 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_fs25 = require("node:fs");
+    import_node_fs27 = require("node:fs");
     import_promises13 = require("node:fs/promises");
     import_node_os11 = require("node:os");
-    import_node_path31 = require("node:path");
+    import_node_path32 = require("node:path");
     init_onchainos();
     init_system_config();
     init_offline_replay_capability();
@@ -69334,9 +70468,9 @@ async function handleXmtpTestCommand(args, releaseInfo) {
 async function startXmtpTest(args, releaseInfo) {
   assertKnownOptions(args, /* @__PURE__ */ new Set(["--name", "--run-id", "--json"]));
   const paths = resolveTaskPaths();
-  const testsDir = (0, import_node_path32.join)(paths.homeDir, "xmtp-tests");
+  const testsDir = (0, import_node_path33.join)(paths.homeDir, "xmtp-tests");
   await ensurePrivateDir(testsDir);
-  const active = await readJsonIfExists((0, import_node_path32.join)(testsDir, ACTIVE_FILE));
+  const active = await readJsonIfExists((0, import_node_path33.join)(testsDir, ACTIVE_FILE));
   if (active?.runId) {
     throw new Error(
       `XMTP test ${active.runId} is already active. Run \`okx-a2a xmtp-test stop\` first.`
@@ -69375,7 +70509,7 @@ async function startXmtpTest(args, releaseInfo) {
     ...releaseInfo
   };
   await writeJson(files.manifestPath, manifest);
-  await writeJson((0, import_node_path32.join)(testsDir, ACTIVE_FILE), {
+  await writeJson((0, import_node_path33.join)(testsDir, ACTIVE_FILE), {
     runId,
     startedAt: manifest.startedAt
   });
@@ -69398,7 +70532,7 @@ Run \`okx-a2a xmtp-test watch\` to open the realtime dashboard.`);
 async function stopXmtpTest(args) {
   assertKnownOptions(args, /* @__PURE__ */ new Set(["--json"]));
   const testsDir = resolveTestsDir();
-  const activePath = (0, import_node_path32.join)(testsDir, ACTIVE_FILE);
+  const activePath = (0, import_node_path33.join)(testsDir, ACTIVE_FILE);
   const active = await readJsonIfExists(activePath);
   if (!active?.runId) {
     throw new Error("No active XMTP test.");
@@ -69692,17 +70826,17 @@ function formatJobEvent(event) {
   return `${timestamp}  ${businessEvent.padEnd(34)} ${role}#${agent} ${source}${timings.length > 0 ? `  ${timings.join(" ")}` : ""}`;
 }
 function resolveTestsDir() {
-  return (0, import_node_path32.join)(resolveTaskPaths().homeDir, "xmtp-tests");
+  return (0, import_node_path33.join)(resolveTaskPaths().homeDir, "xmtp-tests");
 }
 function resolveRunFiles(testsDir, runId) {
   validateRunId(runId);
-  const runDir = (0, import_node_path32.join)(testsDir, runId);
+  const runDir = (0, import_node_path33.join)(testsDir, runId);
   return {
     testsDir,
     runDir,
-    manifestPath: (0, import_node_path32.join)(runDir, "manifest.json"),
-    eventsPath: (0, import_node_path32.join)(runDir, "events.jsonl"),
-    summaryPath: (0, import_node_path32.join)(runDir, "summary.json")
+    manifestPath: (0, import_node_path33.join)(runDir, "manifest.json"),
+    eventsPath: (0, import_node_path33.join)(runDir, "events.jsonl"),
+    summaryPath: (0, import_node_path33.join)(runDir, "summary.json")
   };
 }
 async function resolveRequestedRunId(testsDir, args, preferActive = false) {
@@ -69710,7 +70844,7 @@ async function resolveRequestedRunId(testsDir, args, preferActive = false) {
   if (requested) {
     return validateRunId(requested);
   }
-  const active = await readJsonIfExists((0, import_node_path32.join)(testsDir, ACTIVE_FILE));
+  const active = await readJsonIfExists((0, import_node_path33.join)(testsDir, ACTIVE_FILE));
   if (active?.runId && (preferActive || !args.includes("--latest"))) {
     return validateRunId(active.runId);
   }
@@ -69736,7 +70870,7 @@ async function findLatestRunId(testsDir) {
       continue;
     }
     const manifest = await readJsonIfExists(
-      (0, import_node_path32.join)(testsDir, entry.name, "manifest.json")
+      (0, import_node_path33.join)(testsDir, entry.name, "manifest.json")
     );
     if (manifest?.runId && manifest.startedAt) {
       manifests.push(manifest);
@@ -69971,12 +71105,12 @@ function formatPercent(value) {
 function validTimestamp(value) {
   return typeof value === "string" && Number.isFinite(Date.parse(value));
 }
-var import_promises14, import_node_path32, RUN_ID_PATTERN2, ACTIVE_FILE;
+var import_promises14, 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_node_path32 = require("node:path");
+    import_node_path33 = require("node:path");
     init_daemon();
     init_log_tail();
     init_paths();
@@ -112954,10 +114088,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),
@@ -112971,7 +114105,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) {
@@ -112982,18 +114116,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",
@@ -113073,7 +114207,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");
@@ -113097,7 +114231,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;
@@ -113110,7 +114244,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,
@@ -113165,9 +114299,9 @@ var init_dist6 = __esm({
 
 // ../core/src/file-upload-safety.ts
 function getUnsafeFileUploadReason(filePath, sensitiveUploadReg = []) {
-  const expanded = (0, import_node_path33.resolve)(expandHome(filePath));
-  const target = (0, import_node_fs26.realpathSync)(expanded);
-  const targetName = (0, import_node_path33.basename)(target);
+  const expanded = (0, import_node_path34.resolve)(expandHome(filePath));
+  const target = (0, import_node_fs28.realpathSync)(expanded);
+  const targetName = (0, import_node_path34.basename)(target);
   if (targetName === ".env" || targetName.startsWith(".env.")) {
     return ".env";
   }
@@ -113180,13 +114314,13 @@ function getUnsafeFileUploadReason(filePath, sensitiveUploadReg = []) {
     return null;
   }
   for (const dir of SENSITIVE_HOME_DIRS) {
-    const sensitiveDir = safeRealpath((0, import_node_path33.join)(home, dir));
+    const sensitiveDir = safeRealpath((0, import_node_path34.join)(home, dir));
     if (sensitiveDir && isPathInside(target, sensitiveDir)) {
       return `~/${dir}`;
     }
   }
   for (const file of SENSITIVE_HOME_FILES) {
-    const sensitiveFile = safeRealpath((0, import_node_path33.join)(home, file));
+    const sensitiveFile = safeRealpath((0, import_node_path34.join)(home, file));
     if (sensitiveFile && target === sensitiveFile) {
       return `~/${file}`;
     }
@@ -113214,27 +114348,27 @@ function expandHome(filePath) {
   if (filePath === "~") {
     return (0, import_node_os12.homedir)();
   }
-  if (filePath.startsWith(`~${import_node_path33.sep}`)) {
-    return (0, import_node_path33.join)((0, import_node_os12.homedir)(), filePath.slice(2));
+  if (filePath.startsWith(`~${import_node_path34.sep}`)) {
+    return (0, import_node_path34.join)((0, import_node_os12.homedir)(), filePath.slice(2));
   }
   return filePath;
 }
 function safeRealpath(path2) {
-  if (!(0, import_node_fs26.existsSync)(path2)) {
+  if (!(0, import_node_fs28.existsSync)(path2)) {
     return null;
   }
-  return (0, import_node_fs26.realpathSync)(path2);
+  return (0, import_node_fs28.realpathSync)(path2);
 }
 function isPathInside(target, dir) {
-  return target === dir || target.startsWith(`${dir}${import_node_path33.sep}`);
+  return target === dir || target.startsWith(`${dir}${import_node_path34.sep}`);
 }
-var import_node_fs26, import_node_os12, import_node_path33, SENSITIVE_HOME_DIRS, SENSITIVE_HOME_FILES, UNSAFE_FILE_UPLOAD_MESSAGE;
+var import_node_fs28, import_node_os12, 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_fs26 = require("node:fs");
+    import_node_fs28 = require("node:fs");
     import_node_os12 = require("node:os");
-    import_node_path33 = require("node:path");
+    import_node_path34 = require("node:path");
     SENSITIVE_HOME_DIRS = [
       ".ssh",
       ".gnupg",
@@ -113242,7 +114376,7 @@ var init_file_upload_safety = __esm({
       ".azure",
       ".kube",
       ".docker",
-      (0, import_node_path33.join)(".config", "gcloud")
+      (0, import_node_path34.join)(".config", "gcloud")
     ];
     SENSITIVE_HOME_FILES = [
       ".npmrc",
@@ -113304,7 +114438,7 @@ function hasHelpFlag(args) {
   return args.some((arg) => arg === "-h" || arg === "--help" || arg === "help");
 }
 async function uploadFile(params) {
-  const filename = params.filename || (0, import_node_path34.basename)(params.filePath);
+  const filename = params.filename || (0, import_node_path35.basename)(params.filePath);
   const mimeType = params.mimeType || "application/octet-stream";
   const uploadConfig = readUploadSystemConfig();
   const unsafeReason = getUnsafeFileUploadReason(params.filePath, uploadConfig.sensitiveUploadReg);
@@ -113320,16 +114454,16 @@ async function uploadFile(params) {
     return;
   }
   const maxFileSizeBytes = uploadConfig.maxFileSizeBytes;
-  const fileSize = (0, import_node_fs27.statSync)(params.filePath).size;
+  const fileSize = (0, import_node_fs29.statSync)(params.filePath).size;
   if (fileSize > maxFileSizeBytes) {
     throw new Error(formatFileTooLargeMessage(maxFileSizeBytes));
   }
-  const data = (0, import_node_fs27.readFileSync)(params.filePath);
+  const data = (0, import_node_fs29.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_path34.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto17.randomUUID)()}.enc`);
-  (0, import_node_fs27.writeFileSync)(encryptedPath, encrypted.payload);
+  const encryptedPath = (0, import_node_path35.resolve)(FILE_WORK_DIR, `${(0, import_node_crypto18.randomUUID)()}.enc`);
+  (0, import_node_fs29.writeFileSync)(encryptedPath, encrypted.payload);
   try {
     const stdout = runOnchainos([
       "agent",
@@ -113365,14 +114499,14 @@ async function uploadFile(params) {
     }, null, 2));
   } finally {
     try {
-      (0, import_node_fs27.unlinkSync)(encryptedPath);
+      (0, import_node_fs29.unlinkSync)(encryptedPath);
     } catch {
     }
   }
 }
 async function downloadFile(params) {
   ensureFileDirs();
-  const encryptedPath = (0, import_node_path34.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",
@@ -113396,8 +114530,8 @@ async function downloadFile(params) {
       }));
       throw new Error(`file download failed: ${stdout}`);
     }
-    const payload = new Uint8Array((0, import_node_fs27.readFileSync)(encryptedPath));
-    const digestBytes = new Uint8Array(await import_node_crypto17.webcrypto.subtle.digest("SHA-256", payload));
+    const payload = new Uint8Array((0, import_node_fs29.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}`);
@@ -113405,15 +114539,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_path34.resolve)(outputDir, (0, import_node_path34.basename)(outputFilename));
-    (0, import_node_fs27.writeFileSync)(outputPath, attachment.data);
+    const outputPath = (0, import_node_path35.resolve)(outputDir, (0, import_node_path35.basename)(outputFilename));
+    (0, import_node_fs29.writeFileSync)(outputPath, attachment.data);
     console.log(outputPath);
   } finally {
     try {
-      (0, import_node_fs27.unlinkSync)(encryptedPath);
+      (0, import_node_fs29.unlinkSync)(encryptedPath);
     } catch {
     }
   }
@@ -113422,15 +114556,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);
@@ -113510,7 +114644,7 @@ function readUploadSystemConfig() {
     const res = parseCliJson2(stdout, "system-config");
     if (res.data && typeof res.data === "object") {
       ensureA2aTaskDir(OKX_A2A_PATHS.xmtpDir);
-      (0, import_node_fs27.writeFileSync)(SYSTEM_CONFIG_PATH, JSON.stringify(res.data));
+      (0, import_node_fs29.writeFileSync)(SYSTEM_CONFIG_PATH, JSON.stringify(res.data));
     }
     return parseUploadSystemConfig(res.data ?? {});
   } catch {
@@ -113533,10 +114667,10 @@ function fileCliSentryExtra(operation, reason, extra = {}) {
 }
 function readSystemConfigFromCache() {
   try {
-    if (!(0, import_node_fs27.existsSync)(SYSTEM_CONFIG_PATH)) {
+    if (!(0, import_node_fs29.existsSync)(SYSTEM_CONFIG_PATH)) {
       return null;
     }
-    return JSON.parse((0, import_node_fs27.readFileSync)(SYSTEM_CONFIG_PATH, "utf8"));
+    return JSON.parse((0, import_node_fs29.readFileSync)(SYSTEM_CONFIG_PATH, "utf8"));
   } catch {
     return null;
   }
@@ -113570,14 +114704,14 @@ function readRequiredOption(args, name) {
   }
   return value;
 }
-var import_node_crypto17, import_node_fs27, import_node_path34, import_proto2, OKX_A2A_PATHS, OKX_A2A_HOME_DIR, FILE_WORK_DIR, DOWNLOADS_DIR, SYSTEM_CONFIG_PATH;
+var import_node_crypto18, import_node_fs29, 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_fs27 = require("node:fs");
-    import_node_path34 = require("node:path");
+    import_node_crypto18 = require("node:crypto");
+    import_node_fs29 = require("node:fs");
+    import_node_path35 = require("node:path");
     init_dist6();
     import_proto2 = __toESM(require_node4());
     init_a2a_paths();
@@ -113588,7 +114722,7 @@ var init_file_cli = __esm({
     OKX_A2A_HOME_DIR = OKX_A2A_PATHS.homeDir;
     FILE_WORK_DIR = process.env.OKX_A2A_FILE_WORK_DIR || OKX_A2A_PATHS.filesDir;
     DOWNLOADS_DIR = process.env.OKX_A2A_DOWNLOADS_DIR || OKX_A2A_PATHS.downloadsDir;
-    SYSTEM_CONFIG_PATH = (0, import_node_path34.resolve)(OKX_A2A_PATHS.xmtpDir, "system-config.json");
+    SYSTEM_CONFIG_PATH = (0, import_node_path35.resolve)(OKX_A2A_PATHS.xmtpDir, "system-config.json");
   }
 });
 
@@ -113599,12 +114733,12 @@ __export(user_attention_cli_exports, {
 });
 async function handleUserCommand(args) {
   const subcommand = args[0];
-  if (!subcommand || args.every(isHelpArg)) {
+  if (!subcommand || args.every(isHelpArg2)) {
     printUserUsage();
     return;
   }
   if (subcommand === "help") {
-    const helpTarget = args.slice(1).find((arg) => !isHelpArg(arg));
+    const helpTarget = args.slice(1).find((arg) => !isHelpArg2(arg));
     if (!helpTarget) {
       printUserUsage();
       return;
@@ -113621,7 +114755,7 @@ async function handleUserCommand(args) {
     return;
   }
   const commandStartedAt = Date.now();
-  const parsed = parseArgs(args.slice(1));
+  const parsed = parseArgs2(args.slice(1));
   const json = parsed.flags.has("json");
   const storeInitStartedAt = Date.now();
   const store = new SessionStore();
@@ -113738,7 +114872,7 @@ async function handleUserCommand(args) {
 function hasHelpFlag2(args) {
   return args.some((arg) => arg === "-h" || arg === "--help");
 }
-function isHelpArg(arg) {
+function isHelpArg2(arg) {
   return arg === "-h" || arg === "--help" || arg === "help";
 }
 function printUserUsage() {
@@ -114257,7 +115391,7 @@ function runSyncWithoutConsoleOutput(fn) {
     console.error = originalError;
   }
 }
-function parseArgs(args) {
+function parseArgs2(args) {
   const positional = [];
   const options = /* @__PURE__ */ new Map();
   const flags = /* @__PURE__ */ new Set();
@@ -114711,12 +115845,12 @@ __export(session_cli_exports, {
 });
 async function handleSessionCommand(args) {
   const subcommand = args[0];
-  if (!subcommand || args.every(isHelpArg2)) {
+  if (!subcommand || args.every(isHelpArg3)) {
     printSessionUsage();
     return;
   }
   if (subcommand === "help") {
-    const helpTarget = args.slice(1).find((arg) => !isHelpArg2(arg));
+    const helpTarget = args.slice(1).find((arg) => !isHelpArg3(arg));
     if (!helpTarget) {
       printSessionUsage();
       return;
@@ -114732,7 +115866,7 @@ async function handleSessionCommand(args) {
     }
     return;
   }
-  const parsed = parseArgs2(args.slice(1));
+  const parsed = parseArgs3(args.slice(1));
   const json = parsed.flags.has("json");
   const store = new SessionStore();
   let usedOpenClawGateway = false;
@@ -114898,9 +116032,9 @@ async function handleSessionCommand(args) {
   }
 }
 function hasHelpFlag3(args) {
-  return args.some(isHelpArg2);
+  return args.some(isHelpArg3);
 }
-function isHelpArg2(arg) {
+function isHelpArg3(arg) {
   return arg === "-h" || arg === "--help" || arg === "help";
 }
 function printSessionUsage() {
@@ -115706,7 +116840,7 @@ function normalizeOptionalText4(value) {
   const normalized = value?.trim();
   return normalized ? normalized : null;
 }
-function parseArgs2(args) {
+function parseArgs3(args) {
   const positional = [];
   const options = /* @__PURE__ */ new Map();
   const flags = /* @__PURE__ */ new Set();
@@ -115789,7 +116923,7 @@ async function handleXmtpDebugCli(args) {
     throw new Error(`Unknown xmtp-debug command: ${subcommand}`);
   }
   const action = subcommand;
-  const parsed = parseArgs3(args.slice(1));
+  const parsed = parseArgs4(args.slice(1));
   rejectAccountOverride(parsed);
   const groupId = parsed.options.get("group-id");
   const jobId = parsed.options.get("job-id");
@@ -115883,7 +117017,7 @@ Options:
   --json              Print machine-readable JSON.
 `);
 }
-function parseArgs3(args) {
+function parseArgs4(args) {
   const options = /* @__PURE__ */ new Map();
   const flags = /* @__PURE__ */ new Set();
   for (let index2 = 0; index2 < args.length; index2 += 1) {
@@ -115971,7 +117105,7 @@ async function handleAiCommand(args) {
     return;
   }
   const subcommand = args[0] ?? "status";
-  const parsed = parseArgs4(args.slice(1));
+  const parsed = parseArgs5(args.slice(1));
   const json = parsed.flags.has("json");
   const store = new SessionStore();
   try {
@@ -116095,7 +117229,7 @@ function output4(json, payload, human) {
   }
   console.log(human);
 }
-function parseArgs4(args) {
+function parseArgs5(args) {
   const positional = [];
   const options = /* @__PURE__ */ new Map();
   const flags = /* @__PURE__ */ new Set();
@@ -116151,7 +117285,7 @@ function isPostjectRunnable() {
 function resolvePostjectCommand() {
   try {
     const cliPath = (0, import_node_module.createRequire)(__filename).resolve("postject/dist/cli.js");
-    if ((0, import_node_fs28.existsSync)(cliPath)) {
+    if ((0, import_node_fs30.existsSync)(cliPath)) {
       return { command: process.execPath, prefixArgs: [cliPath] };
     }
   } catch {
@@ -116222,26 +117356,26 @@ function buildSeaConfig(entryPath, blobPath) {
 }
 async function installWindowsNativeLauncher(options) {
   const nodeExe = options.nodeExe ?? process.execPath;
-  if (!(0, import_node_fs28.existsSync)(options.cliPath)) {
+  if (!(0, import_node_fs30.existsSync)(options.cliPath)) {
     throw new Error(`cannot build okx-a2a.exe: CLI entry not found at ${options.cliPath}`);
   }
-  if (!(0, import_node_fs28.existsSync)(nodeExe)) {
+  if (!(0, import_node_fs30.existsSync)(nodeExe)) {
     throw new Error(`cannot build okx-a2a.exe: node executable not found at ${nodeExe}`);
   }
-  const exePath = (0, import_node_path35.join)(options.targetDir, NATIVE_LAUNCHER_EXE_NAME);
-  (0, import_node_fs28.mkdirSync)(options.targetDir, { recursive: true });
-  const work = (0, import_node_fs28.mkdtempSync)((0, import_node_path35.join)((0, import_node_os13.tmpdir)(), "okx-a2a-sea-"));
+  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_os13.tmpdir)(), "okx-a2a-sea-"));
   try {
-    const entryPath = (0, import_node_path35.join)(work, "launcher-entry.js");
-    const blobPath = (0, import_node_path35.join)(work, "okx-a2a.blob");
-    const configPath = (0, import_node_path35.join)(work, "sea-config.json");
-    (0, import_node_fs28.writeFileSync)(entryPath, buildLauncherEntryJs(options.cliPath), "utf8");
-    (0, import_node_fs28.writeFileSync)(configPath, buildSeaConfig(entryPath, blobPath), "utf8");
+    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_child_process9.execFileSync)(nodeExe, ["--experimental-sea-config", configPath], {
       stdio: "ignore",
       windowsHide: true
     });
-    (0, import_node_fs28.copyFileSync)(nodeExe, exePath);
+    (0, import_node_fs30.copyFileSync)(nodeExe, exePath);
     const isMac = process.platform === "darwin";
     if (isMac) {
       try {
@@ -116261,19 +117395,19 @@ async function installWindowsNativeLauncher(options) {
     );
     return { exePath, cliPath: options.cliPath, nodeExe };
   } finally {
-    (0, import_node_fs28.rmSync)(work, { recursive: true, force: true });
+    (0, import_node_fs30.rmSync)(work, { recursive: true, force: true });
   }
 }
-function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2 = import_node_fs28.existsSync) {
+function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2 = import_node_fs30.existsSync) {
   const dirs = pathValue.split(";").map((d) => d.trim()).filter(Boolean);
   if (appData) {
-    dirs.push((0, import_node_path35.join)(appData, "npm"));
+    dirs.push((0, import_node_path36.join)(appData, "npm"));
   }
   if (userProfile) {
-    dirs.push((0, import_node_path35.join)(userProfile, ".local", "bin"));
+    dirs.push((0, import_node_path36.join)(userProfile, ".local", "bin"));
   }
   for (const dir of dirs) {
-    const candidate = (0, import_node_path35.join)(dir, NATIVE_LAUNCHER_EXE_NAME);
+    const candidate = (0, import_node_path36.join)(dir, NATIVE_LAUNCHER_EXE_NAME);
     if (fileExists2(candidate)) {
       return candidate;
     }
@@ -116282,11 +117416,11 @@ function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2
 }
 function resolveRunningCliPath() {
   const fromArgv = process.argv[1];
-  if (fromArgv && /(?:^|[\\/])cli\.js$/.test(fromArgv) && (0, import_node_fs28.existsSync)(fromArgv)) {
+  if (fromArgv && /(?:^|[\\/])cli\.js$/.test(fromArgv) && (0, import_node_fs30.existsSync)(fromArgv)) {
     return fromArgv;
   }
-  const beside = (0, import_node_path35.join)(__dirname, "cli.js");
-  if ((0, import_node_fs28.existsSync)(beside)) {
+  const beside = (0, import_node_path36.join)(__dirname, "cli.js");
+  if ((0, import_node_fs30.existsSync)(beside)) {
     return beside;
   }
   if (fromArgv) {
@@ -116304,19 +117438,19 @@ async function ensureWindowsNativeLauncher(options = {}) {
   if (existing) {
     return { exePath: existing, installed: false };
   }
-  const targetDir = env.APPDATA ? (0, import_node_path35.join)(env.APPDATA, "npm") : (0, import_node_path35.join)(env.USERPROFILE ?? (0, import_node_os13.homedir)(), ".local", "bin");
+  const targetDir = env.APPDATA ? (0, import_node_path36.join)(env.APPDATA, "npm") : (0, import_node_path36.join)(env.USERPROFILE ?? (0, import_node_os13.homedir)(), ".local", "bin");
   const result = await installWindowsNativeLauncher({ cliPath: resolveRunningCliPath(), targetDir });
   return { exePath: result.exePath, installed: true };
 }
-var import_node_child_process9, import_node_fs28, import_node_module, import_node_os13, import_node_path35, SEA_SENTINEL_FUSE, NATIVE_LAUNCHER_EXE_NAME, POSTJECT_SPEC, POSTJECT_BIN;
+var import_node_child_process9, import_node_fs30, import_node_module, import_node_os13, 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_fs28 = require("node:fs");
+    import_node_fs30 = require("node:fs");
     import_node_module = require("node:module");
     import_node_os13 = require("node:os");
-    import_node_path35 = require("node:path");
+    import_node_path36 = require("node:path");
     init_win_compat();
     init_win_spawn();
     SEA_SENTINEL_FUSE = "NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2";
@@ -116455,7 +117589,7 @@ function buildProviderMismatchWarning(target, provider) {
   ].join("\n");
 }
 async function handleUpdateCommand(args) {
-  if (args.some(isHelpArg3)) {
+  if (args.some(isHelpArg4)) {
     printUpdateUsage();
     return;
   }
@@ -116496,7 +117630,7 @@ function resolveUpdateTarget(target) {
   return detectGatewayInvocation() ?? "node";
 }
 async function handleSetupCommand(args) {
-  if (args.some(isHelpArg3)) {
+  if (args.some(isHelpArg4)) {
     printSetupUsage();
     return;
   }
@@ -117058,7 +118192,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.11" : null;
+  return true ? "0.2.12-beta-7449a77b9d-260909165309" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -117243,17 +118377,17 @@ async function updateHermes(release, options) {
     assertNotRunningInsideGateway("hermes");
   }
   const spec = buildNpmPackageSpec("hermes", release);
-  const workDir = await (0, import_promises15.mkdtemp)((0, import_node_path36.join)((0, import_node_os14.tmpdir)(), `okx-a2a-${label}-hermes-`));
+  const workDir = await (0, import_promises15.mkdtemp)((0, import_node_path37.join)((0, import_node_os14.tmpdir)(), `okx-a2a-${label}-hermes-`));
   try {
     console.log(`[${label}] downloading ${spec}`);
     const npmTarball = await npmPack(spec, workDir);
-    const npmPackageDir = (0, import_node_path36.join)(workDir, "npm-package");
+    const npmPackageDir = (0, import_node_path37.join)(workDir, "npm-package");
     await runCommand("tar", ["-xzf", npmTarball, "-C", npmPackageDir], { ensureDir: npmPackageDir });
-    const pluginTarball = await findHermesPluginTarball((0, import_node_path36.join)(npmPackageDir, "package", "dist"));
-    const pluginDir = (0, import_node_path36.join)(workDir, "plugin");
+    const pluginTarball = await findHermesPluginTarball((0, import_node_path37.join)(npmPackageDir, "package", "dist"));
+    const pluginDir = (0, import_node_path37.join)(workDir, "plugin");
     await runCommand("tar", ["-xzf", pluginTarball, "-C", pluginDir], { ensureDir: pluginDir });
     const unpackedPluginDir = await findFirstDirectory(pluginDir);
-    const installer = (0, import_node_path36.join)(unpackedPluginDir, "scripts", "install-or-upgrade.sh");
+    const installer = (0, import_node_path37.join)(unpackedPluginDir, "scripts", "install-or-upgrade.sh");
     console.log(`[${label}] running ${installer}`);
     await runCommand("bash", [installer, ...options.restart ? ["--restart"] : []], { cwd: unpackedPluginDir });
     await normalizeHermesOkxA2aPluginConfig();
@@ -117268,7 +118402,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.11") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.12-beta-7449a77b9d-260909165309") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -117319,7 +118453,7 @@ async function ensureHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPa
       if (options.dryRun) {
         return true;
       }
-      await (0, import_promises15.mkdir)((0, import_node_path36.resolve)(configFile, ".."), { recursive: 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");
       console.log(`[update] added Hermes plugins.enabled okx-a2a entry in ${configFile}`);
       return true;
@@ -117559,7 +118693,7 @@ function findFirstEnabledListItem(lines, startIndex, enabledIndent) {
   return null;
 }
 function resolveHermesConfigPath() {
-  return (0, import_node_path36.join)(process.env.HERMES_HOME ?? (0, import_node_path36.join)((0, import_node_os14.homedir)(), ".hermes"), "config.yaml");
+  return (0, import_node_path37.join)(process.env.HERMES_HOME ?? (0, import_node_path37.join)((0, import_node_os14.homedir)(), ".hermes"), "config.yaml");
 }
 function lineIndent(line) {
   const match = line.match(/^\s*/);
@@ -117637,13 +118771,13 @@ async function assertGatewayPluginInstalled(target) {
   );
 }
 function resolveHermesPluginYamlPath() {
-  return (0, import_node_path36.join)(process.env.HERMES_HOME ?? (0, import_node_path36.join)((0, import_node_os14.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  return (0, import_node_path37.join)(process.env.HERMES_HOME ?? (0, import_node_path37.join)((0, import_node_os14.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
 }
 async function isGatewayPluginInstalled(target) {
   if (target === "openclaw") {
     return (await getInstalledOpenClawPluginInfo()).installed;
   }
-  return (0, import_node_fs29.existsSync)(resolveHermesPluginYamlPath());
+  return (0, import_node_fs31.existsSync)(resolveHermesPluginYamlPath());
 }
 async function getInstalledGatewayPluginVersion(target) {
   if (target === "hermes") {
@@ -117730,7 +118864,7 @@ function parsePackageVersionFromText(output5) {
   return output5.match(/@okxweb3\/a2a-openclaw@([0-9A-Za-z.+-]+)/)?.[1] ?? null;
 }
 async function getInstalledHermesPluginVersion() {
-  const pluginYaml = (0, import_node_path36.join)(process.env.HERMES_HOME ?? (0, import_node_path36.join)((0, import_node_os14.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  const pluginYaml = (0, import_node_path37.join)(process.env.HERMES_HOME ?? (0, import_node_path37.join)((0, import_node_os14.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
   try {
     const content2 = await (0, import_promises15.readFile)(pluginYaml, "utf8");
     return parsePluginYamlVersion(content2);
@@ -117788,7 +118922,7 @@ async function npmPack(spec, destination) {
   if (!tarballName) {
     throw new Error(`Unable to detect npm pack tarball from output: ${output5.trim()}`);
   }
-  return (0, import_node_path36.resolve)(destination, (0, import_node_path36.basename)(tarballName));
+  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);
@@ -117796,7 +118930,7 @@ async function findHermesPluginTarball(distDir) {
   if (!tarball) {
     throw new Error(`Hermes npm package did not contain dist/okx-a2a-hermes-plugin-*.tar.gz`);
   }
-  return (0, import_node_path36.join)(distDir, tarball);
+  return (0, import_node_path37.join)(distDir, tarball);
 }
 async function findFirstDirectory(parent) {
   const entries = await (0, import_promises15.readdir)(parent, { withFileTypes: true });
@@ -117804,7 +118938,7 @@ async function findFirstDirectory(parent) {
   if (!dir) {
     throw new Error(`No unpacked plugin directory found under ${parent}`);
   }
-  return (0, import_node_path36.join)(parent, dir.name);
+  return (0, import_node_path37.join)(parent, dir.name);
 }
 function readOption4(args, name) {
   const index2 = args.indexOf(name);
@@ -117816,7 +118950,7 @@ function readOption4(args, name) {
 function hasFlag(args, name) {
   return args.includes(name);
 }
-function isHelpArg3(value) {
+function isHelpArg4(value) {
   return value === "-h" || value === "--help" || value === "help";
 }
 function isSupportedRelease(value) {
@@ -118025,15 +119159,15 @@ function buildExternalCommandInvocation(command, args, platform = process.platfo
 function formatExternalCommand(command, args) {
   return [command, ...args].join(" ");
 }
-var import_node_child_process10, import_node_fs29, import_promises15, import_node_os14, import_node_path36, UPDATE_PACKAGES, CODEX_NPM_PACKAGE, OPENCLAW_FORCE_INSTALL_FLAG, OPENCLAW_UNSAFE_INSTALL_FLAG, OKX_A2A_PLUGIN_ID, OPENCLAW_SESSION_DM_SCOPE_CONFIG_PATH, OPENCLAW_SESSION_DM_SCOPE_CONFIG_VALUE, OPENCLAW_PLUGIN_ALLOW_CONFIG_PATH, OPENCLAW_OKX_A2A_CONVERSATION_HOOK_ACCESS_CONFIG_PATH, DEFAULT_AI_PROVIDER_LOGIN_TIMEOUT_MS, PROVIDER_CLI_AUTH_PROBE_TIMEOUT_MS, SetupBlockedError, redirectCommandStdoutToStderr;
+var import_node_child_process10, import_node_fs31, import_promises15, import_node_os14, 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_fs29 = require("node:fs");
+    import_node_fs31 = require("node:fs");
     import_promises15 = require("node:fs/promises");
     import_node_os14 = require("node:os");
-    import_node_path36 = require("node:path");
+    import_node_path37 = require("node:path");
     init_ai_command();
     init_win_spawn();
     init_ai_provider();
@@ -118321,7 +119455,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.11" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.12-beta-7449a77b9d-260909165309" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -118529,11 +119663,11 @@ async function writeStdoutAndExit(output5, code) {
   });
   process.exit(code);
 }
-var import_node_path37, DOCTOR_MIN_NODE_VERSION, DOCTOR_DAEMON_READY_TIMEOUT_MS, DOCTOR_DAEMON_WAIT_HEARTBEAT_MS, NODE_PACKAGE_SPEC, CODEX_INSTALL_SPEC, CLAUDE_INSTALL_SPEC, nodeVersionChecker, npmChecker, cliVersionChecker, windowsNativeLauncherChecker, providerBindingChecker, providerCliChecker, gatewayPluginChecker, gatewayConfigChecker, daemonChecker, agentRefreshChecker, gatewayReachableChecker, autostartChecker, CHECKERS, STATUS_MARK;
+var import_node_path38, DOCTOR_MIN_NODE_VERSION, DOCTOR_DAEMON_READY_TIMEOUT_MS, DOCTOR_DAEMON_WAIT_HEARTBEAT_MS, NODE_PACKAGE_SPEC, CODEX_INSTALL_SPEC, CLAUDE_INSTALL_SPEC, nodeVersionChecker, npmChecker, cliVersionChecker, windowsNativeLauncherChecker, providerBindingChecker, providerCliChecker, gatewayPluginChecker, gatewayConfigChecker, daemonChecker, agentRefreshChecker, gatewayReachableChecker, autostartChecker, CHECKERS, STATUS_MARK;
 var init_doctor_cli = __esm({
   "src/doctor-cli.ts"() {
     "use strict";
-    import_node_path37 = require("node:path");
+    import_node_path38 = require("node:path");
     init_log();
     init_win_compat();
     init_ai_command();
@@ -118720,7 +119854,7 @@ var init_doctor_cli = __esm({
             command: "okx-a2a doctor --fix"
           },
           data: {
-            appDataNpm: ctx.env.APPDATA ? (0, import_node_path37.join)(ctx.env.APPDATA, "npm") : null
+            appDataNpm: ctx.env.APPDATA ? (0, import_node_path38.join)(ctx.env.APPDATA, "npm") : null
           }
         };
       },
@@ -119328,9 +120462,9 @@ var init_doctor_cli = __esm({
 });
 
 // src/cli.ts
-var import_node_fs30 = require("node:fs");
+var import_node_fs32 = require("node:fs");
 var import_node_os15 = require("node:os");
-var import_node_path38 = require("node:path");
+var import_node_path39 = require("node:path");
 init_daemon();
 init_command_store();
 init_file_store();
@@ -119398,7 +120532,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.11"}
+  console.log(`okx-a2a ${"0.2.12-beta-7449a77b9d-260909165309"}
 
 Usage:
   okx-a2a <command> [options]
@@ -119428,6 +120562,8 @@ Commands:
               Alias for runtime switch-current
   job-provider Manage job-to-provider bindings
   xmtp-send    Queue an XMTP message through the running daemon
+  trade-records
+              Insert, query, and soft-delete local business trade records
   capabilities Print machine-readable A2A capability negotiation status (used by OnchainOS)
 
 Global options:
@@ -119438,7 +120574,7 @@ Run \`okx-a2a <command> -h\` for command-specific help.
 `);
 }
 function printVersion() {
-  console.log("0.2.11");
+  console.log("0.2.12-beta-7449a77b9d-260909165309");
 }
 function printDaemonUsage() {
   console.log(`Usage: okx-a2a daemon <start|restart|stop|status|autostart> [options]
@@ -119600,8 +120736,22 @@ function printCommandUsage(command) {
     printXmtpSendUsage();
     return true;
   }
+  if (command === "trade-records") {
+    printTradeRecordsUsageProxy();
+    return true;
+  }
   return false;
 }
+function printTradeRecordsUsageProxy() {
+  console.log(`Usage: okx-a2a trade-records <insert|query|delete> [options]
+
+Commands:
+  insert  Insert or replace trade records by deliveryId.
+  query   Query active or soft-deleted trade records.
+  delete  Soft-delete one trade record by deliveryId.
+
+Run \`okx-a2a trade-records <command> --help\` for command-specific help.`);
+}
 function printUserUsageProxy() {
   console.log(`Usage: okx-a2a user <notify|decision-request|list|outdated-list|consume|check|watch>
 
@@ -119688,11 +120838,11 @@ Commands:
           Print setup status JSON to stdout. Installer logs are written to stderr.
 `);
 }
-function isHelpArg4(value) {
+function isHelpArg5(value) {
   return value === "-h" || value === "--help" || value === "help";
 }
 function hasHelpFlag5(args) {
-  return args.some(isHelpArg4);
+  return args.some(isHelpArg5);
 }
 function isVersionArg(value) {
   return value === "-v" || value === "--version" || value === "version";
@@ -119719,14 +120869,14 @@ function maybeRedirectDaemonSelfLog() {
   }
   try {
     const logPath = resolveTaskPaths().listenerLogPath;
-    (0, import_node_fs30.mkdirSync)((0, import_node_path38.join)(logPath, ".."), { recursive: true });
-    const fd = (0, import_node_fs30.openSync)(logPath, "a");
+    (0, import_node_fs32.mkdirSync)((0, import_node_path39.join)(logPath, ".."), { recursive: true });
+    const fd = (0, import_node_fs32.openSync)(logPath, "a");
     const writeToLog = ((chunk, encoding, cb) => {
       try {
         if (typeof chunk === "string") {
-          (0, import_node_fs30.writeSync)(fd, chunk);
+          (0, import_node_fs32.writeSync)(fd, chunk);
         } else {
-          (0, import_node_fs30.writeSync)(fd, chunk);
+          (0, import_node_fs32.writeSync)(fd, chunk);
         }
       } catch {
       }
@@ -119816,7 +120966,7 @@ async function handleLogs(args) {
     return;
   }
   if (subcommand === "llm") {
-    await tailLogFile((0, import_node_path38.join)(paths.logsDir, "llm.log"), parseLogsTailArgs(args.slice(1), subcommand));
+    await tailLogFile((0, import_node_path39.join)(paths.logsDir, "llm.log"), parseLogsTailArgs(args.slice(1), subcommand));
     return;
   }
   throw new Error("logs requires <server|llm|export>");
@@ -120082,12 +121232,12 @@ async function queueXmtpDaemonCommand(args, type) {
 }
 async function handleTaskCommand(args) {
   const subcommand = args[0];
-  if (!subcommand || args.every(isHelpArg4)) {
+  if (!subcommand || args.every(isHelpArg5)) {
     printTaskUsage();
     return;
   }
   if (subcommand === "help") {
-    const helpTarget = args.slice(1).find((arg) => !isHelpArg4(arg));
+    const helpTarget = args.slice(1).find((arg) => !isHelpArg5(arg));
     if (!helpTarget) {
       printTaskUsage();
       return;
@@ -120775,11 +121925,11 @@ async function initDirectCliSentry() {
   }
   cliSentryInitAttempted = true;
   try {
-    const configPath = (0, import_node_path38.join)(resolveTaskHomeForSentryConfig(), "xmtp", "system-config.json");
-    if (!(0, import_node_fs30.existsSync)(configPath)) {
+    const configPath = (0, import_node_path39.join)(resolveTaskHomeForSentryConfig(), "xmtp", "system-config.json");
+    if (!(0, import_node_fs32.existsSync)(configPath)) {
       return;
     }
-    const config = JSON.parse((0, import_node_fs30.readFileSync)(configPath, "utf8"));
+    const config = JSON.parse((0, import_node_fs32.readFileSync)(configPath, "utf8"));
     if (typeof config.sentryDsn !== "string" || !config.sentryDsn) {
       return;
     }
@@ -120804,11 +121954,11 @@ function resolveTaskHomeForSentryConfig() {
   try {
     const home = (0, import_node_os15.homedir)();
     if (home) {
-      return (0, import_node_path38.join)(home, ".okx-agent-task");
+      return (0, import_node_path39.join)(home, ".okx-agent-task");
     }
   } catch {
   }
-  return (0, import_node_path38.resolve)(process.cwd(), ".okx-agent-task");
+  return (0, import_node_path39.resolve)(process.cwd(), ".okx-agent-task");
 }
 function directCliSentryExtra(operation, extra = {}) {
   return {
@@ -120841,7 +121991,7 @@ async function main() {
     assertSupportedNodeVersion();
   }
   const args = process.argv.slice(3);
-  if (isHelpArg4(command)) {
+  if (isHelpArg5(command)) {
     printUsage3();
     return;
   }
@@ -120857,6 +122007,11 @@ async function main() {
     handleCapabilitiesCommand2(process.argv.slice(3));
     return;
   }
+  if (command === "trade-records") {
+    const { handleTradeRecordsCommand: handleTradeRecordsCommand2 } = await Promise.resolve().then(() => (init_trade_records_cli(), trade_records_cli_exports));
+    await handleTradeRecordsCommand2(args);
+    return;
+  }
   if (command === "daemon") {
     if (hasHelpFlag5(args)) {
       printDaemonUsage();
@@ -120916,7 +122071,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.11",
+      packageVersion: "0.2.12-beta-7449a77b9d-260909165309",
       agentSdkVersion: "2.3.0",
       nodeSdkVersion: "6.1.0",
       nodeBindingsVersion: "1.11.0"
@@ -121021,10 +122176,13 @@ function shouldDeferHelpToNestedHandler(command, args) {
   if (command === "xmtp-test") {
     return true;
   }
+  if (command === "trade-records") {
+    return args.some((arg) => !isHelpArg5(arg));
+  }
   if (command !== "session" && command !== "user" && command !== "task") {
     return false;
   }
-  return args.some((arg) => !isHelpArg4(arg));
+  return args.some((arg) => !isHelpArg5(arg));
 }
 main().then(() => {
   if (cliSentryFlushTimedOut) {