@okx_ai/okx-trade-cli 1.3.1-beta.2 → 1.3.1-beta.4

package/dist/index.js

@@ -5,24 +5,39 @@ import { createRequire as createRequire3 } from "module";
 
 // ../core/dist/index.js
 import { ProxyAgent } from "undici";
+import { isIP } from "net";
+import { lookup as dnsLookup } from "dns";
+import { Agent } from "undici";
+import { execFile } from "child_process";
+import { homedir } from "os";
+import { join } from "path";
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  unlinkSync,
+  renameSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname } from "path";
 import { createHmac } from "crypto";
 import fs from "fs";
 import path from "path";
 import os from "os";
-import { writeFileSync, renameSync, unlinkSync, mkdirSync } from "fs";
-import { join, resolve, basename, sep } from "path";
+import { writeFileSync as writeFileSync2, renameSync as renameSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, resolve, basename, sep } from "path";
 import { randomUUID } from "crypto";
 import yauzl from "yauzl";
-import { createWriteStream, mkdirSync as mkdirSync2 } from "fs";
-import { resolve as resolve2, dirname } from "path";
-import { readFileSync, existsSync } from "fs";
-import { join as join2 } from "path";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync2 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
-import { homedir } from "os";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync3 } from "fs";
-import { join as join4, dirname as dirname3 } from "path";
-import { homedir as homedir2 } from "os";
+import { createWriteStream, mkdirSync as mkdirSync3 } from "fs";
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync2, existsSync } from "fs";
+import { join as join4 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync2 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+import { homedir as homedir3 } from "os";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync3 } from "fs";
+import { join as join6, dirname as dirname4 } from "path";
+import { homedir as homedir4 } from "os";
 
 // ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -851,9 +866,9 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
 }
 
 // ../core/dist/index.js
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir3 } from "os";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, existsSync as existsSync4 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir5 } from "os";
 import fs2 from "fs";
 import path2 from "path";
 import os2 from "os";
@@ -861,6 +876,290 @@ import * as fs3 from "fs";
 import * as path3 from "path";
 import * as os3 from "os";
 import { execFileSync } from "child_process";
+var EXEC_TIMEOUT_MS = 3e4;
+var ALLOWED_DOMAIN_RE = /^[\w.-]+\.okx\.com$/;
+var DOH_BIN_DIR = join(homedir(), ".okx", "bin");
+function getDohBinaryPath() {
+  if (process.env.OKX_DOH_BINARY_PATH) {
+    return process.env.OKX_DOH_BINARY_PATH;
+  }
+  const ext = process.platform === "win32" ? ".exe" : "";
+  return join(DOH_BIN_DIR, `okx-doh-resolver${ext}`);
+}
+function execDohBinary(domain, exclude = [], userAgent) {
+  if (!ALLOWED_DOMAIN_RE.test(domain)) {
+    return Promise.resolve(null);
+  }
+  const binPath = getDohBinaryPath();
+  const args = ["--domain", domain];
+  if (exclude.length > 0) {
+    args.push("--exclude", exclude.join(","));
+  }
+  if (userAgent) {
+    args.push("--user-agent", userAgent);
+  }
+  return new Promise((resolve3) => {
+    execFile(
+      binPath,
+      args,
+      { timeout: EXEC_TIMEOUT_MS, encoding: "utf-8" },
+      (error, stdout) => {
+        if (error) {
+          resolve3(null);
+          return;
+        }
+        try {
+          const result = JSON.parse(stdout);
+          if (result.code === 0 && result.data) {
+            resolve3(result.data);
+          } else {
+            resolve3(null);
+          }
+        } catch {
+          resolve3(null);
+        }
+      }
+    );
+  });
+}
+function getDefaultCachePath() {
+  return process.env.OKX_DOH_CACHE_PATH || join2(homedir2(), ".okx", "doh-cache.json");
+}
+function readCache(hostname, cachePath = getDefaultCachePath()) {
+  try {
+    const raw = readFileSync(cachePath, "utf-8");
+    const file = JSON.parse(raw);
+    return file[hostname] ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeCache(hostname, entry, cachePath = getDefaultCachePath()) {
+  try {
+    const dir = dirname(cachePath);
+    mkdirSync(dir, { recursive: true });
+    let file = {};
+    try {
+      file = JSON.parse(readFileSync(cachePath, "utf-8"));
+    } catch {
+    }
+    file[hostname] = entry;
+    const tmpPath = `${cachePath}.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(file));
+    renameSync(tmpPath, cachePath);
+  } catch {
+  }
+}
+var FAILED_NODE_TTL_MS = 60 * 60 * 1e3;
+function classifyAndCache(node, hostname, failedNodes, cachePath) {
+  if (!node) {
+    return { mode: null, node: null };
+  }
+  if (node.ip === hostname || node.host === hostname) {
+    writeCache(hostname, {
+      mode: "direct",
+      node: null,
+      failedNodes,
+      updatedAt: Date.now()
+    }, cachePath);
+    return { mode: "direct", node: null };
+  }
+  writeCache(hostname, {
+    mode: "proxy",
+    node,
+    failedNodes,
+    updatedAt: Date.now()
+  }, cachePath);
+  return { mode: "proxy", node };
+}
+function getActiveFailedNodes(nodes) {
+  if (!nodes || nodes.length === 0) return [];
+  const now = Date.now();
+  return nodes.filter((n) => now - n.failedAt < FAILED_NODE_TTL_MS);
+}
+function resolveDoh(hostname, cachePath) {
+  const entry = readCache(hostname, cachePath);
+  if (entry) {
+    if (entry.mode === "direct") {
+      return { mode: "direct", node: null };
+    }
+    if (entry.mode === "proxy" && entry.node) {
+      return { mode: "proxy", node: entry.node };
+    }
+  }
+  return { mode: null, node: null };
+}
+async function reResolveDoh(hostname, failedIp, userAgent, cachePath) {
+  const entry = readCache(hostname, cachePath);
+  const active = getActiveFailedNodes(entry?.failedNodes);
+  const now = Date.now();
+  const alreadyFailed = failedIp && active.some((n) => n.ip === failedIp);
+  const failedNodes = failedIp && !alreadyFailed ? [...active, { ip: failedIp, failedAt: now }] : active;
+  const excludeIps = failedNodes.map((n) => n.ip);
+  const node = await execDohBinary(hostname, excludeIps, userAgent);
+  return classifyAndCache(node, hostname, failedNodes, cachePath);
+}
+function vlog(message) {
+  process.stderr.write(`[verbose] ${message}
+`);
+}
+var DohManager = class {
+  opts;
+  // DoH proxy state (lazy-resolved on first request)
+  dohResolved = false;
+  dohRetried = false;
+  directUnverified = false;
+  // The first direct connection has not yet been verified
+  dohNode = null;
+  dohAgent = null;
+  dohBaseUrl = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Lazily resolve the DoH proxy node on the first request.
+   * Uses cache-first strategy via the resolver.
+   */
+  prepareDoh() {
+    if (this.dohResolved || this.opts.hasCustomProxy) return;
+    this.dohResolved = true;
+    try {
+      const { hostname, protocol } = new URL(this.opts.baseUrl);
+      const result = resolveDoh(hostname);
+      if (!result.mode) {
+        this.directUnverified = true;
+        if (this.opts.verbose) {
+          vlog("DoH: no cache, trying direct connection first");
+        }
+        return;
+      }
+      if (result.mode === "direct") {
+        if (this.opts.verbose) {
+          vlog("DoH: mode=direct (overseas or cached), using direct connection");
+        }
+        return;
+      }
+      if (result.node) {
+        this.applyNode(result.node, protocol);
+      }
+    } catch (err) {
+      if (this.opts.verbose) {
+        const cause = err instanceof Error ? err.message : String(err);
+        vlog(`DoH resolution failed, falling back to direct: ${cause}`);
+      }
+    }
+  }
+  /** Get connection parameters for the current request. */
+  getConnectionParams() {
+    const baseUrl = this.dohNode ? this.dohBaseUrl : this.opts.baseUrl;
+    const result = { baseUrl };
+    if (this.dohAgent) {
+      result.dispatcher = this.dohAgent;
+    }
+    if (this.dohNode) {
+      result.userAgent = this.dohUserAgent;
+    }
+    return result;
+  }
+  /** Whether a DoH proxy node is currently active. */
+  get isProxyActive() {
+    return this.dohNode !== null;
+  }
+  /** Whether we have already retried after network failure. */
+  get hasRetried() {
+    return this.dohRetried;
+  }
+  /**
+   * Handle network failure: re-resolve with --exclude and retry once.
+   * Returns true if retry should proceed, false if already retried.
+   */
+  async handleNetworkFailure() {
+    if (this.dohRetried) return false;
+    this.dohRetried = true;
+    const failedIp = this.dohNode?.ip ?? "";
+    const { hostname, protocol } = new URL(this.opts.baseUrl);
+    this.dohNode = null;
+    this.dohAgent = null;
+    this.dohBaseUrl = null;
+    if (!failedIp) this.directUnverified = false;
+    if (this.opts.verbose) {
+      vlog(failedIp ? `DoH: proxy node ${failedIp} failed, re-resolving with --exclude` : "DoH: direct connection failed, calling binary for DoH resolution");
+    }
+    try {
+      const result = await reResolveDoh(hostname, failedIp, this.dohUserAgent);
+      if (result.mode === "proxy" && result.node) {
+        this.applyNode(result.node, protocol);
+        this.dohRetried = false;
+        return true;
+      }
+    } catch {
+    }
+    if (this.opts.verbose) {
+      vlog("DoH: re-resolution failed or switched to direct, retrying with direct connection");
+    }
+    return true;
+  }
+  /**
+   * After a successful HTTP response on direct connection, cache mode=direct.
+   * (Even if the business response is an error, the network path is valid.)
+   */
+  cacheDirectIfNeeded() {
+    if (!this.directUnverified || this.dohNode) return;
+    this.directUnverified = false;
+    const { hostname } = new URL(this.opts.baseUrl);
+    writeCache(hostname, {
+      mode: "direct",
+      node: null,
+      failedNodes: [],
+      updatedAt: Date.now()
+    });
+    if (this.opts.verbose) {
+      vlog("DoH: direct connection succeeded, cached mode=direct");
+    }
+  }
+  /** User-Agent for DoH proxy requests: OKX/@okx_ai/{packageName}/{version} */
+  get dohUserAgent() {
+    return `OKX/@okx_ai/${this.opts.packageUserAgent ?? "unknown"}`;
+  }
+  /**
+   * Apply a DoH node: set up the custom Agent + base URL.
+   *
+   * node.ip may be a real IP or a domain (CNAME like *.aliyunddos1021.com).
+   * - Real IP → use directly in lookup callback
+   * - Domain  → dns.lookup on every connection to get a fresh IP
+   */
+  applyNode(node, protocol) {
+    this.dohNode = node;
+    this.dohBaseUrl = `${protocol}//${node.host}`;
+    const nodeIpIsRealIp = !!isIP(node.ip);
+    this.dohAgent = new Agent({
+      connect: {
+        lookup: (_hostname, options, callback) => {
+          if (nodeIpIsRealIp) {
+            if (options?.all) {
+              callback(null, [{ address: node.ip, family: 4 }]);
+            } else {
+              callback(null, node.ip, 4);
+            }
+          } else {
+            dnsLookup(node.ip, { family: 4 }, (err, address, family) => {
+              if (err) {
+                callback(err, "", 0);
+              } else if (options?.all) {
+                callback(null, [{ address, family }]);
+              } else {
+                callback(null, address, family);
+              }
+            });
+          }
+        }
+      }
+    });
+    if (this.opts.verbose) {
+      vlog(`DoH proxy active: \u2192 ${node.host} (${node.ip}), ttl=${node.ttl}s`);
+    }
+  }
+};
 function getNow() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -1071,7 +1370,7 @@ function maskKey(key) {
   if (key.length <= 8) return "***";
   return `${key.slice(0, 3)}***${key.slice(-3)}`;
 }
-function vlog(message) {
+function vlog2(message) {
   process.stderr.write(`[verbose] ${message}
 `);
 }
@@ -1079,25 +1378,32 @@ var OkxRestClient = class _OkxRestClient {
   config;
   rateLimiter;
   dispatcher;
+  doh;
   constructor(config) {
     this.config = config;
     this.rateLimiter = new RateLimiter(3e4, config.verbose);
     if (config.proxyUrl) {
       this.dispatcher = new ProxyAgent(config.proxyUrl);
     }
+    this.doh = new DohManager({
+      baseUrl: config.baseUrl,
+      packageUserAgent: config.userAgent,
+      verbose: config.verbose,
+      hasCustomProxy: !!config.proxyUrl
+    });
   }
   logRequest(method, url, auth) {
     if (!this.config.verbose) return;
-    vlog(`\u2192 ${method} ${url}`);
+    vlog2(`\u2192 ${method} ${url}`);
     const authInfo = auth === "private" && this.config.apiKey ? `auth=\u2713(${maskKey(this.config.apiKey)})` : `auth=${auth}`;
-    vlog(`  ${authInfo} demo=${this.config.demo} timeout=${this.config.timeoutMs}ms`);
+    vlog2(`  ${authInfo} demo=${this.config.demo} timeout=${this.config.timeoutMs}ms`);
   }
   logResponse(status, rawLen, elapsed, traceId, code, msg) {
     if (!this.config.verbose) return;
     if (code && code !== "0" && code !== "1") {
-      vlog(`\u2717 ${status} | code=${code} | msg=${msg ?? "-"} | ${rawLen}B | ${elapsed}ms | trace=${traceId ?? "-"}`);
+      vlog2(`\u2717 ${status} | code=${code} | msg=${msg ?? "-"} | ${rawLen}B | ${elapsed}ms | trace=${traceId ?? "-"}`);
     } else {
-      vlog(`\u2190 ${status} | code=${code ?? "0"} | ${rawLen}B | ${elapsed}ms | trace=${traceId ?? "-"}`);
+      vlog2(`\u2190 ${status} | code=${code ?? "0"} | ${rawLen}B | ${elapsed}ms | trace=${traceId ?? "-"}`);
     }
   }
   async publicGet(path42, query, rateLimit, simulatedTrading) {
@@ -1256,17 +1562,30 @@ var OkxRestClient = class _OkxRestClient {
    * Security: validates Content-Type and enforces maxBytes limit.
    */
   async privatePostBinary(path42, body, opts) {
+    this.doh.prepareDoh();
     const maxBytes = opts?.maxBytes ?? _OkxRestClient.DEFAULT_MAX_BYTES;
     const expectedCT = opts?.expectedContentType ?? "application/octet-stream";
     const bodyJson = body ? JSON.stringify(body) : "";
     const endpoint = `POST ${path42}`;
-    this.logRequest("POST", `${this.config.baseUrl}${path42}`, "private");
+    const conn = this.doh.getConnectionParams();
+    this.logRequest("POST", `${conn.baseUrl}${path42}`, "private");
     const reqConfig = { method: "POST", path: path42, auth: "private" };
     const headers = this.buildHeaders(reqConfig, path42, bodyJson, getNow());
+    if (conn.userAgent) {
+      headers.set("User-Agent", conn.userAgent);
+    }
     const t0 = Date.now();
-    const response = await this.fetchBinary(path42, endpoint, headers, bodyJson, t0);
+    let response;
+    try {
+      response = await this.fetchBinary(path42, endpoint, headers, bodyJson, t0);
+    } catch (error) {
+      this.doh.handleNetworkFailure().catch(() => {
+      });
+      throw error;
+    }
     const elapsed = Date.now() - t0;
     const traceId = extractTraceId(response.headers);
+    this.doh.cacheDirectIfNeeded();
     if (!response.ok) {
       const text = await response.text();
       this.logResponse(response.status, text.length, elapsed, traceId, String(response.status));
@@ -1285,24 +1604,25 @@ var OkxRestClient = class _OkxRestClient {
       throw new OkxApiError(`Response size ${buffer.length} bytes exceeds limit of ${maxBytes} bytes.`, { code: "RESPONSE_TOO_LARGE", endpoint, traceId });
     }
     if (this.config.verbose) {
-      vlog(`\u2190 ${response.status} | binary ${buffer.length}B | ${elapsed}ms | trace=${traceId ?? "-"}`);
+      vlog2(`\u2190 ${response.status} | binary ${buffer.length}B | ${elapsed}ms | trace=${traceId ?? "-"}`);
     }
     return { endpoint, requestTime: (/* @__PURE__ */ new Date()).toISOString(), data: buffer, contentType: ct, contentLength: buffer.length, traceId };
   }
   /** Execute fetch for binary endpoint, wrapping network errors. */
   async fetchBinary(path42, endpoint, headers, bodyJson, t0) {
+    const conn = this.doh.getConnectionParams();
     try {
       const fetchOptions = {
         method: "POST",
         headers,
         body: bodyJson || void 0,
-        signal: AbortSignal.timeout(this.config.timeoutMs)
+        signal: AbortSignal.timeout(this.config.timeoutMs),
+        dispatcher: this.dispatcher ?? conn.dispatcher
       };
-      if (this.dispatcher) fetchOptions.dispatcher = this.dispatcher;
-      return await fetch(`${this.config.baseUrl}${path42}`, fetchOptions);
+      return await fetch(`${conn.baseUrl}${path42}`, fetchOptions);
     } catch (error) {
       if (this.config.verbose) {
-        vlog(`\u2717 NetworkError after ${Date.now() - t0}ms: ${error instanceof Error ? error.message : String(error)}`);
+        vlog2(`\u2717 NetworkError after ${Date.now() - t0}ms: ${error instanceof Error ? error.message : String(error)}`);
       }
       throw new NetworkError(`Failed to call OKX endpoint ${endpoint}.`, endpoint, error);
     }
@@ -1330,10 +1650,38 @@ var OkxRestClient = class _OkxRestClient {
   // ---------------------------------------------------------------------------
   // JSON request
   // ---------------------------------------------------------------------------
+  /**
+   * Handle network error during a JSON request: refresh DoH and maybe retry.
+   * Always either returns a retry result or throws NetworkError.
+   */
+  async handleRequestNetworkError(error, reqConfig, requestPath, t0) {
+    if (!this.doh.hasRetried) {
+      if (this.config.verbose) {
+        const cause = error instanceof Error ? error.message : String(error);
+        vlog2(`Network failure, refreshing DoH: ${cause}`);
+      }
+      const shouldRetry = await this.doh.handleNetworkFailure();
+      if (shouldRetry && reqConfig.method === "GET") {
+        return this.request(reqConfig);
+      }
+    }
+    if (this.config.verbose) {
+      const elapsed = Date.now() - t0;
+      const cause = error instanceof Error ? error.message : String(error);
+      vlog2(`\u2717 NetworkError after ${elapsed}ms: ${cause}`);
+    }
+    throw new NetworkError(
+      `Failed to call OKX endpoint ${reqConfig.method} ${requestPath}.`,
+      `${reqConfig.method} ${requestPath}`,
+      error
+    );
+  }
   async request(reqConfig) {
+    this.doh.prepareDoh();
     const queryString = buildQueryString(reqConfig.query);
     const requestPath = queryString.length > 0 ? `${reqConfig.path}?${queryString}` : reqConfig.path;
-    const url = `${this.config.baseUrl}${requestPath}`;
+    const conn = this.doh.getConnectionParams();
+    const url = `${conn.baseUrl}${requestPath}`;
     const bodyJson = reqConfig.body ? JSON.stringify(reqConfig.body) : "";
     const timestamp = getNow();
     this.logRequest(reqConfig.method, url, reqConfig.auth);
@@ -1341,6 +1689,9 @@ var OkxRestClient = class _OkxRestClient {
       await this.rateLimiter.consume(reqConfig.rateLimit);
     }
     const headers = this.buildHeaders(reqConfig, requestPath, bodyJson, timestamp);
+    if (conn.userAgent) {
+      headers.set("User-Agent", conn.userAgent);
+    }
     const t0 = Date.now();
     let response;
     try {
@@ -1348,27 +1699,17 @@ var OkxRestClient = class _OkxRestClient {
         method: reqConfig.method,
         headers,
         body: reqConfig.method === "POST" ? bodyJson : void 0,
-        signal: AbortSignal.timeout(this.config.timeoutMs)
+        signal: AbortSignal.timeout(this.config.timeoutMs),
+        dispatcher: this.dispatcher ?? conn.dispatcher
       };
-      if (this.dispatcher) {
-        fetchOptions.dispatcher = this.dispatcher;
-      }
       response = await fetch(url, fetchOptions);
     } catch (error) {
-      if (this.config.verbose) {
-        const elapsed2 = Date.now() - t0;
-        const cause = error instanceof Error ? error.message : String(error);
-        vlog(`\u2717 NetworkError after ${elapsed2}ms: ${cause}`);
-      }
-      throw new NetworkError(
-        `Failed to call OKX endpoint ${reqConfig.method} ${requestPath}.`,
-        `${reqConfig.method} ${requestPath}`,
-        error
-      );
+      return await this.handleRequestNetworkError(error, reqConfig, requestPath, t0);
     }
     const rawText = await response.text();
     const elapsed = Date.now() - t0;
     const traceId = extractTraceId(response.headers);
+    this.doh.cacheDirectIfNeeded();
     return this.processResponse(rawText, response, elapsed, traceId, reqConfig, requestPath);
   }
 };
@@ -1393,9 +1734,6 @@ function readNumber(args, key) {
   if (value === void 0 || value === null) {
     return void 0;
   }
-  if (typeof value === "string" && /^-?\d+(\.\d+)?$/.test(value)) {
-    return parseFloat(value);
-  }
   if (typeof value !== "number" || Number.isNaN(value)) {
     throw new ValidationError(`Parameter "${key}" must be a number.`);
   }
@@ -1475,8 +1813,7 @@ var OKX_INST_TYPES = [
   "SWAP",
   "FUTURES",
   "OPTION",
-  "MARGIN",
-  "EVENTS"
+  "MARGIN"
 ];
 function publicRateLimit(key, rps = 20) {
   return {
@@ -1774,7 +2111,6 @@ var MODULES = [
   "futures",
   "option",
   "account",
-  "event",
   ...EARN_SUB_MODULE_IDS,
   ...BOT_SUB_MODULE_IDS,
   "skills"
@@ -1968,7 +2304,7 @@ function registerAccountTools() {
         properties: {
           instType: {
             type: "string",
-            enum: ["SPOT", "MARGIN", "SWAP", "FUTURES", "OPTION", "EVENTS"]
+            enum: ["SPOT", "MARGIN", "SWAP", "FUTURES", "OPTION"]
           },
           ccy: {
             type: "string",
@@ -2034,7 +2370,7 @@ function registerAccountTools() {
         properties: {
           instType: {
             type: "string",
-            enum: ["SWAP", "FUTURES", "MARGIN", "OPTION", "EVENTS"],
+            enum: ["SWAP", "FUTURES", "MARGIN", "OPTION"],
             description: "Default SWAP"
           },
           instId: {
@@ -2095,7 +2431,7 @@ function registerAccountTools() {
         properties: {
           instType: {
             type: "string",
-            enum: ["SPOT", "MARGIN", "SWAP", "FUTURES", "OPTION", "EVENTS"]
+            enum: ["SPOT", "MARGIN", "SWAP", "FUTURES", "OPTION"]
           },
           instId: {
             type: "string",
@@ -2206,14 +2542,14 @@ function registerAccountTools() {
     {
       name: "account_get_positions",
       module: "account",
-      description: "Get current open positions across all instrument types (MARGIN, SWAP, FUTURES, OPTION, EVENTS). Use swap_get_positions for SWAP/FUTURES-only queries.",
+      description: "Get current open positions across all instrument types (MARGIN, SWAP, FUTURES, OPTION). Use swap_get_positions for SWAP/FUTURES-only queries.",
       isWrite: false,
       inputSchema: {
         type: "object",
         properties: {
           instType: {
             type: "string",
-            enum: ["MARGIN", "SWAP", "FUTURES", "OPTION", "EVENTS"]
+            enum: ["MARGIN", "SWAP", "FUTURES", "OPTION"]
           },
           instId: {
             type: "string",
@@ -3252,19 +3588,19 @@ function safeWriteFile(targetDir, fileName, data) {
     throw new Error(`Invalid file name: "${fileName}"`);
   }
   const resolvedDir = resolve(targetDir);
-  const filePath = join(resolvedDir, safeName);
+  const filePath = join3(resolvedDir, safeName);
   const resolvedPath = resolve(filePath);
   if (!resolvedPath.startsWith(resolvedDir + sep)) {
     throw new Error(`Path traversal detected: "${fileName}" resolves outside target directory`);
   }
-  mkdirSync(resolvedDir, { recursive: true });
+  mkdirSync2(resolvedDir, { recursive: true });
   const tmpPath = `${resolvedPath}.${randomUUID()}.tmp`;
   try {
-    writeFileSync(tmpPath, data);
-    renameSync(tmpPath, resolvedPath);
+    writeFileSync2(tmpPath, data);
+    renameSync2(tmpPath, resolvedPath);
   } catch (err) {
     try {
-      unlinkSync(tmpPath);
+      unlinkSync2(tmpPath);
     } catch {
     }
     throw err;
@@ -3330,7 +3666,7 @@ async function extractSkillZip(zipPath, targetDir, limits) {
   const maxFiles = limits?.maxFiles ?? DEFAULT_MAX_FILES;
   const maxCompressionRatio = limits?.maxCompressionRatio ?? DEFAULT_MAX_COMPRESSION_RATIO;
   const resolvedTarget = resolve2(targetDir);
-  mkdirSync2(resolvedTarget, { recursive: true });
+  mkdirSync3(resolvedTarget, { recursive: true });
   return new Promise((resolvePromise, reject) => {
     yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
       if (err) return reject(err);
@@ -3353,7 +3689,7 @@ async function extractSkillZip(zipPath, targetDir, limits) {
             zipfile.close();
             return reject(streamErr);
           }
-          mkdirSync2(dirname(resolvedPath), { recursive: true });
+          mkdirSync3(dirname2(resolvedPath), { recursive: true });
           const writeStream = createWriteStream(resolvedPath);
           readStream.pipe(writeStream);
           writeStream.on("close", () => zipfile.readEntry());
@@ -3369,11 +3705,11 @@ async function extractSkillZip(zipPath, targetDir, limits) {
   });
 }
 function readMetaJson(contentDir) {
-  const metaPath = join2(contentDir, "_meta.json");
+  const metaPath = join4(contentDir, "_meta.json");
   if (!existsSync(metaPath)) {
     throw new Error(`_meta.json not found in ${contentDir}. Invalid skill package.`);
   }
-  const raw = readFileSync(metaPath, "utf-8");
+  const raw = readFileSync2(metaPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -3395,26 +3731,26 @@ function readMetaJson(contentDir) {
   };
 }
 function validateSkillMdExists(contentDir) {
-  const skillMdPath = join2(contentDir, "SKILL.md");
+  const skillMdPath = join4(contentDir, "SKILL.md");
   if (!existsSync(skillMdPath)) {
     throw new Error(`SKILL.md not found in ${contentDir}. Invalid skill package.`);
   }
 }
-var DEFAULT_REGISTRY_PATH = join3(homedir(), ".okx", "skills", "registry.json");
+var DEFAULT_REGISTRY_PATH = join5(homedir3(), ".okx", "skills", "registry.json");
 function readRegistry(registryPath = DEFAULT_REGISTRY_PATH) {
   if (!existsSync2(registryPath)) {
     return { version: 1, skills: {} };
   }
   try {
-    const raw = readFileSync2(registryPath, "utf-8");
+    const raw = readFileSync3(registryPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { version: 1, skills: {} };
   }
 }
 function writeRegistry(registry, registryPath = DEFAULT_REGISTRY_PATH) {
-  mkdirSync3(dirname2(registryPath), { recursive: true });
-  writeFileSync2(registryPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+  mkdirSync4(dirname3(registryPath), { recursive: true });
+  writeFileSync3(registryPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
 }
 function upsertSkillRecord(meta, registryPath = DEFAULT_REGISTRY_PATH) {
   const registry = readRegistry(registryPath);
@@ -5049,838 +5385,79 @@ function registerDcdTools() {
                   termRate: newQuote["termRate"]
                 }
               };
-            }
-            throw error;
-          }
-        });
-      }
-    }
-  ];
-}
-function registerAutoEarnTools() {
-  return [
-    {
-      name: "earn_auto_set",
-      module: "earn.autoearn",
-      description: "Enable or disable auto-earn for a currency. earnType='0' for auto-lend+stake (most currencies); earnType='1' for USDG earn (USDG, BUIDL). Use account_get_balance first: if autoLendStatus or autoStakingStatus != 'unsupported', use earnType='0'; for USDG/BUIDL use earnType='1'. [CAUTION] Cannot disable within 24h of enabling.",
-      isWrite: true,
-      inputSchema: {
-        type: "object",
-        properties: {
-          ccy: {
-            type: "string",
-            description: "Currency, e.g. SOL, USDG"
-          },
-          action: {
-            type: "string",
-            description: "turn_on or turn_off"
-          },
-          earnType: {
-            type: "string",
-            description: "0=auto-lend+stake (default), 1=USDG earn. Omit to use default."
-          }
-        },
-        required: ["ccy", "action"]
-      },
-      handler: async (rawArgs, context) => {
-        const args = asRecord(rawArgs);
-        const response = await context.client.privatePost(
-          "/api/v5/account/set-auto-earn",
-          compactObject({
-            ccy: requireString(args, "ccy"),
-            action: requireString(args, "action"),
-            earnType: readString(args, "earnType") ?? "0"
-          }),
-          privateRateLimit("earn_auto_set", 10)
-        );
-        return normalizeResponse(response);
-      }
-    }
-  ];
-}
-var EARN_DEMO_MESSAGE = "Earn features (savings, DCD, on-chain staking, auto-earn) are not available in simulated trading mode.";
-var EARN_DEMO_SUGGESTION = "Switch to a live account to use Earn features.";
-var DEMO_GUARD_SKIP = /* @__PURE__ */ new Set(["dcd_redeem", "earn_fixed_purchase"]);
-function withDemoGuard(tool) {
-  if (!tool.isWrite || DEMO_GUARD_SKIP.has(tool.name)) return tool;
-  const originalHandler = tool.handler;
-  return {
-    ...tool,
-    handler: async (args, context) => {
-      if (context.config.demo) {
-        throw new ConfigError(EARN_DEMO_MESSAGE, EARN_DEMO_SUGGESTION);
-      }
-      return originalHandler(args, context);
-    }
-  };
-}
-function registerAllEarnTools() {
-  const tools = [
-    ...registerEarnTools(),
-    ...registerOnchainEarnTools(),
-    ...registerDcdTools(),
-    ...registerAutoEarnTools()
-  ];
-  return tools.map(withDemoGuard);
-}
-function findDateIdx(parts) {
-  for (let i = 1; i < parts.length; i++) {
-    if (/^\d{6}$/.test(parts[i])) return i;
-  }
-  return -1;
-}
-function inferExpiryMsFromInstId(instId) {
-  const parts = instId.split("-");
-  const upper = instId.toUpperCase();
-  const dateIdx = findDateIdx(parts);
-  if (dateIdx < 0) return null;
-  const dp = parts[dateIdx];
-  const year = 2e3 + parseInt(dp.slice(0, 2), 10);
-  const month = parseInt(dp.slice(2, 4), 10) - 1;
-  const day = parseInt(dp.slice(4, 6), 10);
-  const isUpDown = upper.includes("UPDOWN");
-  let timePart;
-  if (isUpDown) {
-    const candidate = parts[dateIdx + 2];
-    timePart = candidate && /^\d{4}$/.test(candidate) ? candidate : parts[dateIdx + 1];
-  } else {
-    timePart = parts[dateIdx + 1];
-  }
-  if (!timePart || !/^\d{4}$/.test(timePart)) return null;
-  const hour = parseInt(timePart.slice(0, 2), 10);
-  const min = parseInt(timePart.slice(2, 4), 10);
-  return Date.UTC(year, month, day, hour - 8, min, 0, 0);
-}
-function extractSeriesId(instId) {
-  const parts = instId.split("-");
-  for (let i = 0; i < parts.length; i++) {
-    if (/^\d{6}$/.test(parts[i])) {
-      return parts.slice(0, i).join("-");
-    }
-  }
-  return instId;
-}
-function fmtTimeToken(t) {
-  return t.length === 4 ? `${t.slice(0, 2)}:${t.slice(2)}` : t;
-}
-function fmtUpDownName(seriesId, dateStr, parts, dateIdx) {
-  const t1 = parts[dateIdx + 1] ?? "";
-  const t2 = parts[dateIdx + 2] ?? "";
-  const timeRange = t1 && t2 ? ` ${fmtTimeToken(t1)}-${fmtTimeToken(t2)}` : "";
-  return `${seriesId} Up/Down \xB7 ${dateStr}${timeRange}`;
-}
-function fmtStrikeName(seriesId, dateStr, label, parts, dateIdx) {
-  const strike = parts[dateIdx + 2] ?? "";
-  const strikeStr = strike && /^\d+$/.test(strike) ? Number(strike).toLocaleString("en-US") : "";
-  return strikeStr ? `${seriesId} ${label} ${strikeStr} \xB7 ${dateStr}` : `${seriesId} \xB7 ${dateStr}`;
-}
-function formatDisplayTitle(instId) {
-  const parts = instId.split("-");
-  const upper = instId.toUpperCase();
-  const seriesId = parts[0] ?? instId;
-  const dateIdx = findDateIdx(parts);
-  if (dateIdx < 0) return instId;
-  const d = parts[dateIdx];
-  const month = parseInt(d.slice(2, 4), 10);
-  const day = parseInt(d.slice(4, 6), 10);
-  const dateStr = `${month}/${day}`;
-  if (upper.includes("UPDOWN") || upper.includes("UP-DOWN")) {
-    return fmtUpDownName(seriesId, dateStr, parts, dateIdx);
-  }
-  if (upper.includes("ABOVE")) {
-    return fmtStrikeName(seriesId, dateStr, "above", parts, dateIdx);
-  }
-  if (upper.includes("TOUCH")) {
-    return fmtStrikeName(seriesId, dateStr, "touch", parts, dateIdx);
-  }
-  return `${seriesId} \xB7 ${dateStr}`;
-}
-var OUTCOME_LABELS = {
-  "0": "pending",
-  "1": "YES",
-  "2": "NO"
-};
-var ORDER_STATE_MAP = {
-  live: "Unfilled",
-  partially_filled: "Partially filled",
-  filled: "Filled",
-  canceled: "Canceled",
-  mmp_canceled: "Canceled"
-};
-function mapOrderState(raw) {
-  return ORDER_STATE_MAP[raw] ?? raw;
-}
-var TIMESTAMP_FIELDS = /* @__PURE__ */ new Set([
-  "expTime",
-  "settleTime",
-  "listTime",
-  "uTime",
-  "cTime",
-  "fixTime"
-]);
-var DEFAULT_SETTLE_CCY = "USDT";
-function convertTimestamps(item) {
-  const result = { ...item };
-  for (const key of TIMESTAMP_FIELDS) {
-    if (!(key in result)) continue;
-    const v = Number(result[key]);
-    if (v > 0) {
-      const d = new Date(v + 8 * 60 * 60 * 1e3);
-      const yyyy = d.getUTCFullYear();
-      const mo = String(d.getUTCMonth() + 1).padStart(2, "0");
-      const dd = String(d.getUTCDate()).padStart(2, "0");
-      const hh = String(d.getUTCHours()).padStart(2, "0");
-      const mi = String(d.getUTCMinutes()).padStart(2, "0");
-      result[key] = `${yyyy}-${mo}-${dd} ${hh}:${mi} UTC+8`;
-    } else {
-      delete result[key];
-    }
-  }
-  return result;
-}
-function normalizeWrite3(response) {
-  const data = response.data;
-  if (Array.isArray(data) && data.length > 0) {
-    const failed = data.filter(
-      (item) => item !== null && typeof item === "object" && "sCode" in item && item["sCode"] !== "0"
-    );
-    if (failed.length > 0) {
-      const messages2 = failed.map(
-        (item) => `[${item["sCode"]}] ${item["sMsg"] ?? "Operation failed"}`
-      );
-      throw new OkxApiError(messages2.join("; "), {
-        code: String(failed[0]["sCode"] ?? ""),
-        endpoint: response.endpoint
-      });
-    }
-  }
-  return { endpoint: response.endpoint, requestTime: response.requestTime, data };
-}
-function extractQuoteCcy(underlying) {
-  if (!underlying) return DEFAULT_SETTLE_CCY;
-  const parts = underlying.split("-");
-  return parts.length >= 2 ? parts[parts.length - 1].toUpperCase() : DEFAULT_SETTLE_CCY;
-}
-async function fetchAvailableBalance(client, ccy = DEFAULT_SETTLE_CCY) {
-  try {
-    const r = await client.privateGet(
-      "/api/v5/account/balance",
-      { ccy }
-    );
-    const data = r["data"];
-    if (Array.isArray(data) && data.length > 0) {
-      const details = data[0]["details"];
-      if (Array.isArray(details) && details.length > 0) {
-        const entry = details.find(
-          (d) => String(d["ccy"] ?? "").toUpperCase() === ccy.toUpperCase()
-        );
-        if (!entry) return { balance: null, ccy };
-        const bal = String(entry["availBal"] ?? "") || null;
-        return { balance: bal, ccy };
-      }
-    }
-  } catch {
-  }
-  return { balance: null, ccy };
-}
-var KNOWN_UNDERLYINGS = /^(BTC|ETH|TRX|EOS|SOL|IOTA|KISHU|SUSHI|BTG|XTZ|SOLVU)/i;
-function extractUnderlying(seriesId) {
-  const m = seriesId.match(KNOWN_UNDERLYINGS);
-  return m ? m[1].toUpperCase() : null;
-}
-function resolveOutcome(value) {
-  const map = {
-    up: "yes",
-    yes: "yes",
-    down: "no",
-    no: "no"
-  };
-  const resolved = map[value.toLowerCase()];
-  if (!resolved) {
-    throw new Error(
-      `Invalid outcome "${value}". Use: UP or YES for Up/Yes, DOWN or NO for Down/No.`
-    );
-  }
-  return resolved;
-}
-function filterBrowseCandidates(allSeries, underlyingFilter) {
-  const isHumanReadable = (id) => /^(BTC|ETH|TRX|EOS|SOL|IOTA|KISHU|SUSHI|BTG|XTZ|SOLVU)-/.test(id);
-  const seen = /* @__PURE__ */ new Set();
-  const candidates = [];
-  for (const s of allSeries) {
-    const settlement = s["settlement"];
-    const method = String(settlement?.["method"] ?? "");
-    const uly = String(settlement?.["underlying"] ?? "");
-    if (underlyingFilter && !uly.startsWith(underlyingFilter)) continue;
-    const key = `${method}:${uly}`;
-    if (!seen.has(key) && isHumanReadable(String(s["seriesId"] ?? ""))) {
-      seen.add(key);
-      candidates.push(s);
-    }
-  }
-  return candidates;
-}
-function isActiveMarket(m, isUpDown, now) {
-  if (!isUpDown && (!m["floorStrike"] || m["floorStrike"] === "")) return false;
-  const expMs = Number(m["expTime"] ?? 0);
-  return expMs <= 0 || expMs > now;
-}
-function toContractSummary(m) {
-  const converted = convertTimestamps(m);
-  const id = String(m["instId"] ?? "");
-  return {
-    instId: id,
-    displayTitle: formatDisplayTitle(id),
-    expTime: converted["expTime"],
-    floorStrike: m["floorStrike"],
-    px: m["px"],
-    outcome: OUTCOME_LABELS[String(m["outcome"] ?? "")] ?? m["outcome"]
-  };
-}
-async function fetchActiveContractsForSeries(client, s) {
-  const seriesId = String(s["seriesId"] ?? "");
-  const settlement = s["settlement"];
-  const method = String(settlement?.["method"] ?? "");
-  const isUpDown = method === "price_up_down";
-  try {
-    const r = await client.privateGet(
-      "/api/v5/public/event-contract/markets",
-      compactObject({ seriesId, state: "live" }),
-      privateRateLimit("event_browse", 20)
-    );
-    const normalized = normalizeResponse(r);
-    const markets = Array.isArray(normalized["data"]) ? normalized["data"] : [];
-    const now = Date.now();
-    const active = markets.filter((m) => isActiveMarket(m, isUpDown, now)).map(toContractSummary);
-    if (active.length === 0) return null;
-    return {
-      seriesId,
-      method: String(settlement?.["method"] ?? ""),
-      underlying: String(settlement?.["underlying"] ?? ""),
-      freq: String(s["freq"] ?? ""),
-      contracts: active
-    };
-  } catch {
-    return null;
-  }
-}
-function resolveUnderlyingFromSeriesResp(seriesResp) {
-  if (!seriesResp) return null;
-  const sResp = seriesResp;
-  const sData = Array.isArray(sResp["data"]) ? sResp["data"] : [];
-  if (sData.length > 0) {
-    const settlement = sData[0]["settlement"];
-    return String(settlement?.["underlying"] ?? "") || null;
-  }
-  return null;
-}
-function translateAndSortMarkets(rawData, limit) {
-  const sorted = [...rawData].sort((a, b) => {
-    const tA = Number(a["expTime"] ?? 0);
-    const tB = Number(b["expTime"] ?? 0);
-    return tA - tB;
-  });
-  const sliced = limit && limit > 0 ? sorted.slice(0, limit) : sorted;
-  return sliced.map((item) => {
-    const converted = convertTimestamps(item);
-    if (typeof converted["outcome"] === "string") {
-      converted["outcome"] = OUTCOME_LABELS[converted["outcome"]] ?? converted["outcome"];
-    }
-    converted["displayTitle"] = formatDisplayTitle(String(item["instId"] ?? ""));
-    return converted;
-  });
-}
-function enrichFill(item) {
-  const subType = String(item["subType"] ?? "");
-  const isSettle = subType === "414" || subType === "415";
-  const enriched = {
-    ...item,
-    displayTitle: formatDisplayTitle(String(item["instId"] ?? "")),
-    outcome: OUTCOME_LABELS[String(item["outcome"] ?? "")] ?? item["outcome"],
-    type: isSettle ? "settlement" : "fill"
-  };
-  if (isSettle) {
-    const fillPnl = parseFloat(String(item["fillPnl"] ?? "NaN"));
-    const isWin = subType === "414";
-    enriched["settlementResult"] = isWin ? "win" : "loss";
-    enriched["pnl"] = isNaN(fillPnl) ? void 0 : fillPnl;
-  }
-  return enriched;
-}
-async function fetchIdxPx(client, underlying) {
-  try {
-    const r = await client.publicGet(
-      "/api/v5/market/index-tickers",
-      { instId: underlying },
-      publicRateLimit("fetchIdxPx", 20)
-    );
-    const data = r["data"];
-    if (Array.isArray(data) && data.length > 0) {
-      return String(data[0]["idxPx"] ?? "") || null;
-    }
-  } catch {
-  }
-  return null;
-}
-function handlePlaceOrderError(base, rawArgs, endpoint) {
-  if (!Array.isArray(base["data"])) return;
-  const item = base["data"][0];
-  const sCode = item && String(item["sCode"] ?? "");
-  if (!sCode || sCode === "0") return;
-  const sMsg = String(item["sMsg"] ?? "Order failed");
-  if (sCode === "51001") {
-    const instId = requireString(asRecord(rawArgs), "instId");
-    const seriesId = extractSeriesId(instId);
-    const expiryMs = inferExpiryMsFromInstId(instId);
-    const isExpired = expiryMs !== null && expiryMs < Date.now();
-    const reason = isExpired ? `The contract (${instId}) has expired.` : `The contract (${instId}) was not found \u2014 it may not exist or has not started yet.`;
-    throw new OkxApiError(
-      `${reason} Ask the user if they'd like to place the same order on the next session. If yes, call event_get_markets with seriesId=${seriesId} and state=live to find available contracts.`,
-      { code: sCode, endpoint }
-    );
-  }
-  throw new OkxApiError(`[${sCode}] ${sMsg}`, { code: sCode, endpoint });
-}
-var OUTCOME_SCHEMA = {
-  type: "string",
-  enum: ["UP", "YES", "DOWN", "NO"],
-  description: `Which outcome to trade.
-UP/DOWN direction contracts: UP (price rises during the period) or DOWN (price falls).
-YES/NO price-target or touch contracts: YES (condition met) or NO (condition not met).
-Check the series type from event_get_series to determine which applies.
-NOTE: px is the event contract price (0.01\u20130.99), NOT the underlying asset price. It reflects market-implied probability when actively trading.`
-};
-function registerEventContractTools() {
-  return [
-    // -----------------------------------------------------------------------
-    // Read-only — browse (user-facing) + series / events / markets (internal)
-    // -----------------------------------------------------------------------
-    {
-      name: "event_browse",
-      module: "event",
-      description: "Browse currently active (in-progress) event contracts. Call when user asks what event contracts are available to trade. Internally fetches series and live markets in parallel, returns only in-progress contracts (floorStrike set). If a live quote field px is present, it is the event contract price (0.01\u20130.99), not the underlying asset price; it reflects the market-implied probability when actively trading. Grouped by settlement type and underlying.",
-      isWrite: false,
-      inputSchema: {
-        type: "object",
-        properties: {
-          underlying: {
-            type: "string",
-            description: "Filter by underlying asset, e.g. BTC-USD, ETH-USD. Omit for all."
-          }
-        }
-      },
-      handler: async (rawArgs, context) => {
-        const args = asRecord(rawArgs);
-        const underlyingFilter = readString(args, "underlying");
-        const seriesResp = await context.client.privateGet(
-          "/api/v5/public/event-contract/series",
-          compactObject({}),
-          privateRateLimit("event_browse", 10)
-        );
-        const normalizedSeries = normalizeResponse(seriesResp);
-        const allSeries = Array.isArray(normalizedSeries["data"]) ? normalizedSeries["data"] : [];
-        const candidates = filterBrowseCandidates(allSeries, underlyingFilter);
-        const marketResults = await Promise.all(
-          candidates.map((s) => fetchActiveContractsForSeries(context.client, s))
-        );
-        const results = marketResults.filter(Boolean);
-        return {
-          data: results,
-          total: results.reduce((n, r) => n + (r?.contracts?.length ?? 0), 0)
-        };
-      }
-    },
-    {
-      name: "event_get_series",
-      module: "event",
-      description: "List event contract series. Returns all available series with settlement type and underlying. Use event_browse to see currently active contracts.",
-      isWrite: false,
-      inputSchema: {
-        type: "object",
-        properties: {
-          seriesId: {
-            type: "string",
-            description: "Filter by series ID, e.g. BTC-ABOVE-DAILY. Omit for all."
-          }
-        }
-      },
-      handler: async (rawArgs, context) => {
-        const args = asRecord(rawArgs);
-        const response = await context.client.privateGet(
-          "/api/v5/public/event-contract/series",
-          compactObject({ seriesId: readString(args, "seriesId") }),
-          privateRateLimit("event_get_series", 20)
-        );
-        return normalizeResponse(response);
-      }
-    },
-    {
-      name: "event_get_events",
-      module: "event",
-      description: "List expiry periods within a series. state: preopen|live|settling|expired. expTime is pre-formatted UTC+8.",
-      isWrite: false,
-      inputSchema: {
-        type: "object",
-        properties: {
-          seriesId: {
-            type: "string",
-            description: "Series ID, e.g. BTC-ABOVE-DAILY (required)"
-          },
-          eventId: {
-            type: "string",
-            description: "Filter by event ID, e.g. BTC-ABOVE-DAILY-260224-1600"
-          },
-          state: {
-            type: "string",
-            enum: ["preopen", "live", "settling", "expired"],
-            description: "preopen=markets not yet trading; live=active; settling=awaiting settlement; expired=done"
-          },
-          limit: {
-            type: "number",
-            description: "Max results (default 100, max 100)"
-          },
-          before: {
-            type: "string",
-            description: "Pagination: return records newer than this expTime"
-          },
-          after: {
-            type: "string",
-            description: "Pagination: return records older than this expTime"
-          }
-        },
-        required: ["seriesId"]
-      },
-      handler: async (rawArgs, context) => {
-        const args = asRecord(rawArgs);
-        const response = await context.client.privateGet(
-          "/api/v5/public/event-contract/events",
-          compactObject({
-            seriesId: requireString(args, "seriesId"),
-            eventId: readString(args, "eventId"),
-            state: readString(args, "state"),
-            limit: readNumber(args, "limit"),
-            before: readString(args, "before"),
-            after: readString(args, "after")
-          }),
-          privateRateLimit("event_get_events", 20)
-        );
-        const base = normalizeResponse(response);
-        const data = Array.isArray(base["data"]) ? base["data"].map(convertTimestamps) : base["data"];
-        return { ...base, data };
-      }
-    },
-    {
-      name: "event_get_markets",
-      module: "event",
-      description: "List tradeable contracts within a series. state=live for active contracts, state=expired for settlement results. floorStrike=strike price; px (when present) is the event contract price (0.01\u20130.99), not the underlying asset price \u2014 reflects the market-implied probability when actively trading; outcome pre-translated (pending/YES/NO/UP/DOWN); timestamps UTC+8.",
-      isWrite: false,
-      inputSchema: {
-        type: "object",
-        properties: {
-          seriesId: {
-            type: "string",
-            description: "Series ID, e.g. BTC-ABOVE-DAILY (required)"
-          },
-          eventId: {
-            type: "string",
-            description: "Filter by event ID, e.g. BTC-ABOVE-DAILY-260224-1600"
-          },
-          instId: {
-            type: "string",
-            description: "Filter by instrument ID"
-          },
-          state: {
-            type: "string",
-            enum: ["preopen", "live", "settling", "expired"],
-            description: "preopen=not yet trading; live=active; settling=awaiting settlement; expired=settled"
-          },
-          limit: {
-            type: "number",
-            description: "Max results (default 100, max 100)"
-          },
-          before: {
-            type: "string",
-            description: "Pagination: return records newer than this expTime"
-          },
-          after: {
-            type: "string",
-            description: "Pagination: return records older than this expTime"
-          }
-        },
-        required: ["seriesId"]
-      },
-      handler: async (rawArgs, context) => {
-        const args = asRecord(rawArgs);
-        const seriesId = requireString(args, "seriesId");
-        const knownUnderlying = extractUnderlying(seriesId);
-        const [marketsResp, seriesResp, idxPxFromKnown] = await Promise.all([
-          context.client.privateGet(
-            "/api/v5/public/event-contract/markets",
-            compactObject({
-              seriesId,
-              eventId: readString(args, "eventId"),
-              instId: readString(args, "instId"),
-              state: readString(args, "state"),
-              before: readString(args, "before"),
-              after: readString(args, "after")
-            }),
-            privateRateLimit("event_get_markets", 20)
-          ),
-          knownUnderlying ? Promise.resolve(null) : context.client.privateGet(
-            "/api/v5/public/event-contract/series",
-            compactObject({ seriesId }),
-            privateRateLimit("event_get_series", 20)
-          ),
-          knownUnderlying ? fetchIdxPx(context.client, knownUnderlying + "-USDT") : Promise.resolve(null)
-        ]);
-        let underlying = knownUnderlying ? knownUnderlying + "-USDT" : null;
-        if (!underlying) {
-          underlying = resolveUnderlyingFromSeriesResp(seriesResp);
-        }
-        const idxPx = idxPxFromKnown ?? (underlying && !knownUnderlying ? await fetchIdxPx(context.client, underlying) : null);
-        const base = normalizeResponse(marketsResp);
-        const limit = readNumber(args, "limit");
-        const rawData = Array.isArray(base["data"]) ? base["data"] : [];
-        const translated = translateAndSortMarkets(rawData, limit);
-        return {
-          ...base,
-          data: translated,
-          currentIdxPx: idxPx,
-          underlying
-        };
-      }
-    },
-    {
-      name: "event_get_orders",
-      module: "event",
-      description: "Query event contract orders. state=live for open orders; omit for history. outcome pre-translated (YES/NO/UP/DOWN).",
-      isWrite: false,
-      inputSchema: {
-        type: "object",
-        properties: {
-          instId: {
-            type: "string",
-            description: "Event contract instrument ID"
-          },
-          state: {
-            type: "string",
-            description: "live=pending orders; omit for history"
-          },
-          limit: {
-            type: "number",
-            description: "Max results (default 20)"
-          }
-        }
-      },
-      handler: async (rawArgs, context) => {
-        const args = asRecord(rawArgs);
-        const state = readString(args, "state");
-        const isPending = state === "live";
-        const endpoint = isPending ? "/api/v5/trade/orders-pending" : "/api/v5/trade/orders-history";
-        const response = await context.client.privateGet(
-          endpoint,
-          compactObject({
-            instType: "EVENTS",
-            instId: readString(args, "instId"),
-            limit: readNumber(args, "limit")
-          }),
-          privateRateLimit("event_get_orders", 20)
-        );
-        const base = normalizeResponse(response);
-        const data = Array.isArray(base["data"]) ? base["data"].map((item) => ({
-          ...item,
-          displayTitle: formatDisplayTitle(String(item["instId"] ?? "")),
-          outcome: OUTCOME_LABELS[String(item["outcome"] ?? "")] ?? item["outcome"],
-          state: String(item["state"] ?? ""),
-          stateLabel: mapOrderState(String(item["state"] ?? ""))
-        })) : base["data"];
-        return { ...base, data };
-      }
-    },
-    {
-      name: "event_get_fills",
-      module: "event",
-      description: "Get event contract fill history. outcome pre-translated (YES/NO/UP/DOWN). Each record includes a 'type' field: 'fill' (subType 410, opening trade) or 'settlement' (subType 414 win / subType 415 loss, contract expiry payout). Settlement records include 'settlementResult' (win/loss) and 'pnl' fields \u2014 no separate market lookup needed to determine outcome.",
-      isWrite: false,
-      inputSchema: {
-        type: "object",
-        properties: {
-          instId: {
-            type: "string",
-            description: "Event contract instrument ID"
-          },
-          limit: {
-            type: "number",
-            description: "Max results (default 20)"
-          }
-        }
-      },
-      handler: async (rawArgs, context) => {
-        const args = asRecord(rawArgs);
-        const response = await context.client.privateGet(
-          "/api/v5/trade/fills",
-          compactObject({
-            instType: "EVENTS",
-            instId: readString(args, "instId"),
-            limit: readNumber(args, "limit")
-          }),
-          privateRateLimit("event_get_fills", 20)
-        );
-        const base = normalizeResponse(response);
-        const data = Array.isArray(base["data"]) ? base["data"].map(enrichFill) : base["data"];
-        return { ...base, data };
-      }
-    },
-    // -----------------------------------------------------------------------
-    // Private — write
-    // -----------------------------------------------------------------------
-    {
-      name: "event_place_order",
-      module: "event",
-      description: `Place an event contract order. [CAUTION] Places a real order.
-- outcome: UP/YES (bet price goes up/condition met) or DOWN/NO (bet price goes down/condition not met)
-- For limit orders: px is the event contract price (0.01\u20130.99), NOT the underlying asset price. It reflects market-implied probability when actively trading
-- tdMode is always isolated; speedBump is auto-set per exchange requirement \u2014 do not pass either`,
-      isWrite: true,
-      inputSchema: {
-        type: "object",
-        properties: {
-          instId: {
-            type: "string",
-            description: "Event contract instrument ID, e.g. BTC-ABOVE-DAILY-260224-1600-120000"
-          },
-          side: {
-            type: "string",
-            enum: ["buy", "sell"],
-            description: "buy=open position, sell=close position"
-          },
-          outcome: OUTCOME_SCHEMA,
-          ordType: {
-            type: "string",
-            enum: ["market", "limit", "post_only"],
-            description: "Order type (default market)"
-          },
-          sz: {
-            type: "string",
-            description: "For limit/post_only: number of contracts. For market: quote currency amount (server converts to contracts using best available price; actual fill count may differ)."
-          },
-          px: {
-            type: "string",
-            description: "Event contract price (0.01\u20130.99). Required when ordType=limit. Do NOT use for market orders."
+            }
+            throw error;
           }
-        },
-        required: ["instId", "side", "outcome", "sz"]
-      },
-      handler: async (rawArgs, context) => {
-        const args = asRecord(rawArgs);
-        const ordType = readString(args, "ordType") ?? "market";
-        const speedBump = ordType !== "post_only" ? "1" : void 0;
-        const instId = requireString(args, "instId");
-        const response = await context.client.privatePost(
-          "/api/v5/trade/order",
-          compactObject({
-            instId,
-            tdMode: "isolated",
-            side: requireString(args, "side"),
-            outcome: resolveOutcome(requireString(args, "outcome")),
-            ordType,
-            sz: requireString(args, "sz"),
-            px: readString(args, "px"),
-            speedBump,
-            tag: context.config.sourceTag
-          }),
-          privateRateLimit("event_place_order", 60)
-        );
-        const base = normalizeResponse(response);
-        handlePlaceOrderError(base, asRecord(rawArgs), response.endpoint);
-        const data = Array.isArray(base["data"]) ? base["data"].map(({ tag: _t, ...rest }) => rest) : base["data"];
-        const placeSeriesId = extractSeriesId(instId);
-        const placeUnderlying = extractUnderlying(placeSeriesId);
-        const placeCcy = extractQuoteCcy(placeUnderlying ? placeUnderlying + "-USDT" : null);
-        const balResult = await fetchAvailableBalance(context.client, placeCcy);
-        const result = { ...base, data };
-        if (balResult.balance) {
-          result["availableBalance"] = balResult.balance;
-          result["availableBalanceCcy"] = balResult.ccy;
-        }
-        if (ordType === "market") {
-          result["orderNote"] = "Market order: sz is a quote currency amount. The exchange converts it to contracts based on best available price.";
-        }
-        return result;
-      }
-    },
-    {
-      name: "event_amend_order",
-      module: "event",
-      description: "Amend a pending event contract order (change price or size). [CAUTION] Modifies a real order. Only limit/post_only orders can be amended.",
-      isWrite: true,
-      inputSchema: {
-        type: "object",
-        properties: {
-          instId: { type: "string", description: "Event contract instrument ID" },
-          ordId: { type: "string", description: "Order ID to amend" },
-          newPx: { type: "string", description: "New event contract price (0.01\u20130.99). Omit to keep current." },
-          newSz: { type: "string", description: "New size in contracts (omit to keep current)" }
-        },
-        required: ["instId", "ordId"]
-      },
-      handler: async (rawArgs, context) => {
-        const args = asRecord(rawArgs);
-        const response = await context.client.privatePost(
-          "/api/v5/trade/amend-order",
-          compactObject({
-            instId: requireString(args, "instId"),
-            ordId: requireString(args, "ordId"),
-            newPx: readString(args, "newPx"),
-            newSz: readString(args, "newSz"),
-            speedBump: "1"
-          }),
-          privateRateLimit("event_amend_order", 60)
-        );
-        return normalizeWrite3(response);
+        });
       }
-    },
+    }
+  ];
+}
+function registerAutoEarnTools() {
+  return [
     {
-      name: "event_cancel_order",
-      module: "event",
-      description: "Cancel a pending event contract order. [CAUTION] Cancels a real order. instId must be the full event contract instrument ID (e.g. BTC-ABOVE-DAILY-260224-1600-69700), NOT a spot trading pair.",
+      name: "earn_auto_set",
+      module: "earn.autoearn",
+      description: "Enable or disable auto-earn for a currency. earnType='0' for auto-lend+stake (most currencies); earnType='1' for USDG earn (USDG, BUIDL). Use account_get_balance first: if autoLendStatus or autoStakingStatus != 'unsupported', use earnType='0'; for USDG/BUIDL use earnType='1'. [CAUTION] Cannot disable within 24h of enabling.",
       isWrite: true,
       inputSchema: {
         type: "object",
         properties: {
-          instId: {
+          ccy: {
             type: "string",
-            description: "Event contract instrument ID"
+            description: "Currency, e.g. SOL, USDG"
           },
-          ordId: {
+          action: {
+            type: "string",
+            description: "turn_on or turn_off"
+          },
+          earnType: {
             type: "string",
-            description: "Order ID to cancel"
+            description: "0=auto-lend+stake (default), 1=USDG earn. Omit to use default."
           }
         },
-        required: ["instId", "ordId"]
+        required: ["ccy", "action"]
       },
       handler: async (rawArgs, context) => {
         const args = asRecord(rawArgs);
-        const instId = requireString(args, "instId");
         const response = await context.client.privatePost(
-          "/api/v5/trade/cancel-order",
-          { instId, ordId: requireString(args, "ordId") },
-          privateRateLimit("event_cancel_order", 60)
+          "/api/v5/account/set-auto-earn",
+          compactObject({
+            ccy: requireString(args, "ccy"),
+            action: requireString(args, "action"),
+            earnType: readString(args, "earnType") ?? "0"
+          }),
+          privateRateLimit("earn_auto_set", 10)
         );
-        if (Array.isArray(response.data) && response.data.length > 0) {
-          const item = response.data[0];
-          const sCode = item && String(item["sCode"] ?? "");
-          if (sCode === "51001") {
-            const expiryMs = inferExpiryMsFromInstId(instId);
-            const isExpired = expiryMs !== null && expiryMs < Date.now();
-            const reason = isExpired ? `The contract (${instId}) has already expired \u2014 the order was auto-cancelled at settlement. Check event_get_fills to confirm the outcome.` : `Instrument (${instId}) not found. Verify the instId with event_get_markets before retrying.`;
-            throw new OkxApiError(reason, { code: sCode, endpoint: response.endpoint });
-          }
-        }
-        return normalizeWrite3(response);
+        return normalizeResponse(response);
+      }
+    }
+  ];
+}
+var EARN_DEMO_MESSAGE = "Earn features (savings, DCD, on-chain staking, auto-earn) are not available in simulated trading mode.";
+var EARN_DEMO_SUGGESTION = "Switch to a live account to use Earn features.";
+var DEMO_GUARD_SKIP = /* @__PURE__ */ new Set(["dcd_redeem", "earn_fixed_purchase"]);
+function withDemoGuard(tool) {
+  if (!tool.isWrite || DEMO_GUARD_SKIP.has(tool.name)) return tool;
+  const originalHandler = tool.handler;
+  return {
+    ...tool,
+    handler: async (args, context) => {
+      if (context.config.demo) {
+        throw new ConfigError(EARN_DEMO_MESSAGE, EARN_DEMO_SUGGESTION);
       }
+      return originalHandler(args, context);
     }
+  };
+}
+function registerAllEarnTools() {
+  const tools = [
+    ...registerEarnTools(),
+    ...registerOnchainEarnTools(),
+    ...registerDcdTools(),
+    ...registerAutoEarnTools()
   ];
+  return tools.map(withDemoGuard);
 }
 function buildContractTradeTools(cfg) {
   const { prefix, module, label, instTypes, instIdExample } = cfg;
@@ -8520,7 +8097,6 @@ function allToolSpecs() {
     ...registerOptionAlgoTools(),
     ...registerAlgoTradeTools(),
     ...registerAccountTools(),
-    ...registerEventContractTools(),
     ...registerBotTools(),
     ...registerAllEarnTools(),
     ...registerAuditTools(),
@@ -8539,12 +8115,12 @@ function createToolRunner(client, config) {
   };
 }
 function configFilePath() {
-  return join4(homedir2(), ".okx", "config.toml");
+  return join6(homedir4(), ".okx", "config.toml");
 }
 function readFullConfig() {
   const path42 = configFilePath();
   if (!existsSync3(path42)) return { profiles: {} };
-  const raw = readFileSync3(path42, "utf-8");
+  const raw = readFileSync4(path42, "utf-8");
   try {
     return parse(raw);
   } catch (err) {
@@ -8572,11 +8148,11 @@ var CONFIG_HEADER = `# OKX Trade Kit Configuration
 `;
 function writeFullConfig(config) {
   const path42 = configFilePath();
-  const dir = dirname3(path42);
+  const dir = dirname4(path42);
   if (!existsSync3(dir)) {
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync5(dir, { recursive: true });
   }
-  writeFileSync3(path42, CONFIG_HEADER + stringify(config), "utf-8");
+  writeFileSync4(path42, CONFIG_HEADER + stringify(config), "utf-8");
 }
 function expandShorthand(moduleId) {
   if (moduleId === "all") return [...MODULES];
@@ -8690,21 +8266,21 @@ function loadConfig(cli) {
     verbose: cli.verbose ?? false
   };
 }
-var CACHE_FILE = join5(homedir3(), ".okx", "update-check.json");
+var CACHE_FILE = join7(homedir5(), ".okx", "update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-function readCache() {
+function readCache2() {
   try {
     if (existsSync4(CACHE_FILE)) {
-      return JSON.parse(readFileSync4(CACHE_FILE, "utf-8"));
+      return JSON.parse(readFileSync5(CACHE_FILE, "utf-8"));
     }
   } catch {
   }
   return {};
 }
-function writeCache(cache) {
+function writeCache2(cache) {
   try {
-    mkdirSync5(join5(homedir3(), ".okx"), { recursive: true });
-    writeFileSync4(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+    mkdirSync6(join7(homedir5(), ".okx"), { recursive: true });
+    writeFileSync5(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
   } catch {
   }
 }
@@ -8751,14 +8327,14 @@ async function fetchLatestVersion(packageName) {
 function refreshCacheInBackground(packageName) {
   fetchLatestVersion(packageName).then((latest) => {
     if (!latest) return;
-    const cache = readCache();
+    const cache = readCache2();
     cache[packageName] = { latestVersion: latest, checkedAt: Date.now() };
-    writeCache(cache);
+    writeCache2(cache);
   }).catch(() => {
   });
 }
 function checkForUpdates(packageName, currentVersion) {
-  const cache = readCache();
+  const cache = readCache2();
   const entry = cache[packageName];
   if (entry && isNewerVersion(currentVersion, entry.latestVersion)) {
     process.stderr.write(
@@ -9613,7 +9189,7 @@ async function cmdDiagnoseMcp(options = {}) {
 
 // src/commands/diagnose.ts
 var CLI_VERSION = readCliVersion();
-var GIT_HASH = true ? "765bfa2" : "dev";
+var GIT_HASH = true ? "980de10" : "dev";
 function maskKey2(key) {
   if (!key) return "(not set)";
   if (key.length <= 8) return "****";
@@ -9910,24 +9486,24 @@ async function runCliChecks(config, profile, outputPath) {
 
 // src/commands/upgrade.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7 } from "fs";
-import { dirname as dirname5, join as join7 } from "path";
-import { homedir as homedir5 } from "os";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8 } from "fs";
+import { dirname as dirname6, join as join9 } from "path";
+import { homedir as homedir7 } from "os";
 var PACKAGES = ["@okx_ai/okx-trade-mcp", "@okx_ai/okx-trade-cli"];
-var CACHE_FILE2 = join7(homedir5(), ".okx", "last_check");
+var CACHE_FILE2 = join9(homedir7(), ".okx", "last_check");
 var THROTTLE_MS = 12 * 60 * 60 * 1e3;
-var NPM_BIN = join7(dirname5(process.execPath), process.platform === "win32" ? "npm.cmd" : "npm");
+var NPM_BIN = join9(dirname6(process.execPath), process.platform === "win32" ? "npm.cmd" : "npm");
 function readLastCheck() {
   try {
-    return parseInt(readFileSync6(CACHE_FILE2, "utf-8").trim(), 10) || 0;
+    return parseInt(readFileSync7(CACHE_FILE2, "utf-8").trim(), 10) || 0;
   } catch {
     return 0;
   }
 }
 function writeLastCheck() {
   try {
-    mkdirSync7(join7(homedir5(), ".okx"), { recursive: true });
-    writeFileSync6(CACHE_FILE2, String(Math.floor(Date.now() / 1e3)), "utf-8");
+    mkdirSync8(join9(homedir7(), ".okx"), { recursive: true });
+    writeFileSync7(CACHE_FILE2, String(Math.floor(Date.now() / 1e3)), "utf-8");
   } catch {
   }
 }
@@ -10602,47 +10178,6 @@ var HELP_TREE = {
       }
     }
   },
-  event: {
-    description: "Event contract trading \u2014 binary outcome prediction markets (Yes/No, Up/Down)",
-    commands: {
-      browse: {
-        usage: "okx event browse [--underlying <asset>]",
-        description: "Browse all active (in-progress) event contracts; px is event contract price (0.01\u20130.99), not the underlying asset price \u2014 reflects market-implied probability when actively trading"
-      },
-      series: {
-        usage: "okx event series [--seriesId <id>]",
-        description: "List event contract series grouped by type (UP/DOWN direction or YES/NO price-target)"
-      },
-      events: {
-        usage: "okx event events <seriesId> [--state <preopen|live|settling|expired>] [--limit <n>]",
-        description: "List events in a series (each event = one expiry)"
-      },
-      markets: {
-        usage: "okx event markets <seriesId> [--eventId <id>] [--state <preopen|live|settling|expired>] [--limit <n>]",
-        description: "List markets; px is event contract price (0.01\u20130.99), not the underlying asset price \u2014 reflects market-implied probability when actively trading; expired includes translated outcome and settleValue"
-      },
-      place: {
-        usage: "okx event place <instId> <side> <outcome> <sz> [--px <price>] [--ordType <market|limit|post_only>]",
-        description: "[CAUTION] Place an event contract order. outcome: UP/YES or DOWN/NO. limit: sz=contracts, px required. market: sz=quote currency amount, no px."
-      },
-      amend: {
-        usage: "okx event amend <instId> <ordId> [--px <price>] [--sz <n>]",
-        description: "[CAUTION] Amend a pending limit order (change price or size)"
-      },
-      cancel: {
-        usage: "okx event cancel <instId> <ordId>",
-        description: "Cancel a pending event contract order"
-      },
-      orders: {
-        usage: "okx event orders [--instId <id>] [--state live] [--limit <n>]",
-        description: "List event orders (state=live for pending; omit for history)"
-      },
-      fills: {
-        usage: "okx event fills [--instId <id>] [--limit <n>]",
-        description: "Get event contract fill history"
-      }
-    }
-  },
   config: {
     description: "Manage CLI configuration profiles",
     commands: {
@@ -11001,11 +10536,6 @@ var CLI_OPTIONS = {
   dir: { type: "string" },
   page: { type: "string" },
   format: { type: "string" },
-  // event contract
-  underlying: { type: "string" },
-  seriesId: { type: "string" },
-  eventId: { type: "string" },
-  outcome: { type: "string" },
   // diagnostics — cli/mcp/all/output are diagnose-specific; verbose is shared
   verbose: { type: "boolean", default: false },
   mcp: { type: "boolean", default: false },
@@ -13836,13 +13366,13 @@ async function cmdDcdQuoteAndBuy(run, opts) {
 }
 
 // src/commands/skill.ts
-import { tmpdir, homedir as homedir7 } from "os";
-import { join as join9, dirname as dirname6 } from "path";
-import { mkdirSync as mkdirSync8, rmSync, existsSync as existsSync7, copyFileSync as copyFileSync2 } from "fs";
+import { tmpdir, homedir as homedir9 } from "os";
+import { join as join11, dirname as dirname7 } from "path";
+import { mkdirSync as mkdirSync9, rmSync, existsSync as existsSync7, copyFileSync as copyFileSync2 } from "fs";
 import { execFileSync as execFileSync2 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 function resolveNpx() {
-  const sibling = join9(dirname6(process.execPath), "npx");
+  const sibling = join11(dirname7(process.execPath), "npx");
   if (existsSync7(sibling)) return sibling;
   return "npx";
 }
@@ -13896,13 +13426,13 @@ async function cmdSkillCategories(run, json) {
   outputLine("");
 }
 async function cmdSkillAdd(name, config, json) {
-  const tmpBase = join9(tmpdir(), `okx-skill-${randomUUID2()}`);
-  mkdirSync8(tmpBase, { recursive: true });
+  const tmpBase = join11(tmpdir(), `okx-skill-${randomUUID2()}`);
+  mkdirSync9(tmpBase, { recursive: true });
   try {
     outputLine(`Downloading ${name}...`);
     const client = new OkxRestClient(config);
     const zipPath = await downloadSkillZip(client, name, tmpBase);
-    const contentDir = await extractSkillZip(zipPath, join9(tmpBase, "content"));
+    const contentDir = await extractSkillZip(zipPath, join11(tmpBase, "content"));
     const meta = readMetaJson(contentDir);
     validateSkillMdExists(contentDir);
     outputLine("Installing to detected agents...");
@@ -13912,7 +13442,7 @@ async function cmdSkillAdd(name, config, json) {
         timeout: 6e4
       });
     } catch (e) {
-      const savedZip = join9(process.cwd(), `${name}.zip`);
+      const savedZip = join11(process.cwd(), `${name}.zip`);
       try {
         copyFileSync2(zipPath, savedZip);
       } catch {
@@ -13951,7 +13481,7 @@ function cmdSkillRemove(name, json) {
       timeout: 6e4
     });
   } catch {
-    const agentsPath = join9(homedir7(), ".agents", "skills", name);
+    const agentsPath = join11(homedir9(), ".agents", "skills", name);
     try {
       rmSync(agentsPath, { recursive: true, force: true });
     } catch {
@@ -14024,462 +13554,10 @@ function printSkillInstallResult(meta, json) {
   }
 }
 
-// src/commands/event-contract.ts
-function getData8(result) {
-  return result.data;
-}
-function fmtMethod(raw) {
-  const map = {
-    // API returns values in various cases; normalise to lowercase for lookup
-    price_above: "Price Above",
-    price_up_down: "Up/Down",
-    price_once_touch: "One Touch",
-    // Uppercase variants (in case API returns them)
-    PRICE_ABOVE: "Price Above",
-    PRICE_UP_DOWN: "Up/Down",
-    PRICE_ONCE_TOUCH: "One Touch"
-  };
-  return map[String(raw)] ?? String(raw ?? "");
-}
-function fmtFreq(raw) {
-  const map = {
-    fifteen_min: "15min",
-    daily: "Daily",
-    hourly: "1h",
-    weekly: "Weekly",
-    FIFTEEN_MIN: "15min",
-    DAILY: "Daily",
-    HOURLY: "1h",
-    WEEKLY: "Weekly"
-  };
-  return map[String(raw)] ?? String(raw ?? "");
-}
-function fmtOutcome(raw) {
-  const s = String(raw ?? "").toLowerCase();
-  if (s === "" || s === "pending") return "";
-  return String(raw ?? "");
-}
-function fmtMarketOutcome(instId, outcome) {
-  const formatted = fmtOutcome(outcome);
-  if (formatted === "") return "";
-  return fmtOrderOutcome(instId, formatted);
-}
-function fmtOrderOutcome(instId, outcome) {
-  const id = String(instId ?? "").toUpperCase();
-  const isUpDown = id.includes("UPDOWN") || id.includes("UP-DOWN");
-  const normalized = String(outcome ?? "").toLowerCase();
-  if (outcome === "1" || outcome === 1 || normalized === "yes") return isUpDown ? "UP" : "YES";
-  if (outcome === "2" || outcome === 2 || normalized === "no") return isUpDown ? "DOWN" : "NO";
-  return String(outcome ?? "");
-}
-function fmtPeriodFromInstId(instId) {
-  const parts = instId.split("-");
-  const upper = instId.toUpperCase();
-  const dateIdx = findDateIdx(parts);
-  if (dateIdx < 0) return instId;
-  const dp = parts[dateIdx];
-  const date = `20${dp.slice(0, 2)}-${dp.slice(2, 4)}-${dp.slice(4, 6)}`;
-  const fmt = (t) => t.length === 4 ? `${t.slice(0, 2)}:${t.slice(2)}` : t;
-  const t1 = parts[dateIdx + 1] ?? "";
-  const t2 = parts[dateIdx + 2] ?? "";
-  const isUpDown = upper.includes("UPDOWN");
-  if (isUpDown && /^\d{4}$/.test(t1) && /^\d{4}$/.test(t2)) {
-    return `${date} ${fmt(t1)} ~ ${fmt(t2)} UTC+8`;
-  }
-  if (/^\d{4}$/.test(t1)) {
-    return `${date} ${fmt(t1)} UTC+8`;
-  }
-  return instId;
-}
-function fmtTs(raw) {
-  if (!raw) return "";
-  const n = Number(raw);
-  if (Number.isNaN(n)) return String(raw);
-  return new Date(n).toISOString().replace("T", " ").replace(".000Z", " UTC");
-}
-function fmtProbability(raw) {
-  if (raw === "" || raw == null) return "";
-  const n = Number(raw);
-  if (Number.isNaN(n)) return String(raw);
-  return `${(n * 100).toFixed(1)}%`;
-}
-async function cmdEventBrowse(run, opts) {
-  const result = await run("event_browse", { underlying: opts.underlying });
-  const data = getData8(result);
-  if (opts.json) return printJson(data);
-  if (!data || data.length === 0) {
-    process.stdout.write("No active event contracts found.\n");
-    return;
-  }
-  for (const group of data) {
-    const contracts = group["contracts"] ?? [];
-    const methodLabel = fmtMethod(group["method"]);
-    const freqLabel = fmtFreq(group["freq"]);
-    process.stdout.write(`
-[${methodLabel}] ${group["underlying"]}  (${freqLabel})
-`);
-    printTable(
-      contracts.map((c) => ({
-        "Contract": formatDisplayTitle(String(c["instId"] ?? "")),
-        "Expiry": c["expTime"] ?? "",
-        "Target Price": c["floorStrike"] ? String(c["floorStrike"]) : "\u2014",
-        "Probability": fmtProbability(c["px"]),
-        "Outcome": fmtOutcome(c["outcome"]) || "\u2014",
-        "instId": c["instId"]
-      }))
-    );
-  }
-  const total = data.reduce((n, g) => n + (g["contracts"]?.length ?? 0), 0);
-  process.stdout.write(`
-${total} active contract(s) across ${data.length} series.
-`);
-}
-var FEATURED_SERIES = /* @__PURE__ */ new Set([
-  "BTC-UPDOWN-15MIN",
-  "ETH-UPDOWN-15MIN",
-  "TRX-UPDOWN-15MIN",
-  "BTC-ABOVE-DAILY",
-  "ETH-ABOVE-DAILY"
-]);
-var KNOWN_PREFIXES = /^(BTC|ETH|TRX|SOL|EOS|BNB|XRP|ADA|DOGE|IOTA|SUSHI|KISHU|BTG|XTZ)-/i;
-function getSeriesMethod(s) {
-  const settlement = s["settlement"];
-  const method = settlement?.["method"] ?? s["method"];
-  return String(method ?? "").toLowerCase();
-}
-function isUpDownSeries(s) {
-  const m = getSeriesMethod(s);
-  return m.includes("up_down") || m.includes("updown");
-}
-function isFeatured(s) {
-  return FEATURED_SERIES.has(String(s["seriesId"] ?? ""));
-}
-function isKnownSeries(s) {
-  return KNOWN_PREFIXES.test(String(s["seriesId"] ?? ""));
-}
-function classifySeries(all) {
-  const featured = [];
-  const standard = [];
-  const testSeries = [];
-  for (const s of all) {
-    if (isFeatured(s)) featured.push(s);
-    else if (isKnownSeries(s)) standard.push(s);
-    else testSeries.push(s);
-  }
-  return { featured, standard, testSeries };
-}
-async function cmdEventSeries(run, opts) {
-  const result = await run("event_get_series", { seriesId: opts.seriesId });
-  const data = getData8(result);
-  if (opts.json) return printJson(data);
-  const toRow = (s, featured2) => {
-    const settlement = s["settlement"];
-    const method = settlement?.["method"] ?? s["method"];
-    const underlying = settlement?.["underlying"] ?? s["underlying"] ?? s["baseCcy"];
-    return {
-      Series: `${featured2 ? "\u2B50 " : ""}${String(s["seriesId"] ?? "")}`,
-      Type: fmtMethod(method),
-      Freq: fmtFreq(s["freq"]),
-      Underlying: String(underlying ?? ""),
-      State: String(s["state"] ?? "")
-    };
-  };
-  const all = data ?? [];
-  const { featured, standard, testSeries } = classifySeries(all);
-  const mainSeries = [...featured, ...standard];
-  const updown = mainSeries.filter(isUpDownSeries);
-  const above = mainSeries.filter((s) => !isUpDownSeries(s));
-  if (updown.length > 0) {
-    process.stdout.write("\n\u2500\u2500 Up/Down \u2500\u2500\n");
-    printTable(updown.map((s) => toRow(s, isFeatured(s))));
-  }
-  if (above.length > 0) {
-    process.stdout.write("\n\u2500\u2500 Price Above \u2500\u2500\n");
-    printTable(above.map((s) => toRow(s, isFeatured(s))));
-  }
-  if (testSeries.length > 0) {
-    if (opts.all) {
-      process.stdout.write("\n\u2500\u2500 Test / Other \u2500\u2500\n");
-      printTable(testSeries.map((s) => toRow(s, false)));
-    } else {
-      process.stdout.write(`
-${testSeries.length} test series hidden (use --all to show)
-`);
-    }
-  }
-}
-async function cmdEventEvents(run, opts) {
-  const result = await run("event_get_events", {
-    seriesId: opts.seriesId,
-    state: opts.state,
-    limit: opts.limit
-  });
-  const data = getData8(result);
-  if (opts.json) return printJson(data);
-  printTable(
-    (data ?? []).map((e) => ({
-      eventId: e["eventId"],
-      state: e["state"],
-      expTime: fmtTs(e["expTime"]),
-      settleTime: fmtTs(e["settleTime"])
-    }))
-  );
-}
-function sortByExpiry(data) {
-  return [...data].sort((a, b) => {
-    const ea = inferExpiryMsFromInstId(String(a["instId"] ?? "")) ?? Infinity;
-    const eb = inferExpiryMsFromInstId(String(b["instId"] ?? "")) ?? Infinity;
-    return ea - eb;
-  });
-}
-async function cmdEventMarkets(run, opts) {
-  const result = await run("event_get_markets", {
-    seriesId: opts.seriesId,
-    eventId: opts.eventId,
-    instId: opts.instId,
-    state: opts.state,
-    limit: opts.limit
-  });
-  const data = getData8(result);
-  if (opts.json) return printJson(data);
-  const ext = result;
-  const currentIdxPx = ext["currentIdxPx"];
-  const underlying = ext["underlying"];
-  if (currentIdxPx != null) {
-    process.stdout.write(
-      `${underlying ?? ""} current index price: $${currentIdxPx}
-`
-    );
-  }
-  const sorted = sortByExpiry(data ?? []);
-  printTable(
-    sorted.map((m) => {
-      const id = String(m["instId"] ?? "");
-      const outcome = fmtMarketOutcome(m["instId"], m["outcome"]);
-      return {
-        contract: formatDisplayTitle(id),
-        expTime: m["expTime"] ?? "",
-        targetPrice: m["floorStrike"] ?? "",
-        probability: fmtProbability(m["px"]),
-        outcome: outcome.toLowerCase() === "pending" ? "\u2014" : outcome,
-        settleValue: m["settleValue"] ?? "",
-        instId: id
-      };
-    })
-  );
-}
-async function cmdEventOrders(run, opts) {
-  const result = await run("event_get_orders", {
-    instId: opts.instId,
-    state: opts.state,
-    limit: opts.limit
-  });
-  const data = getData8(result);
-  if (opts.json) return printJson(data);
-  printTable(
-    (data ?? []).map((o) => ({
-      "Contract": formatDisplayTitle(String(o["instId"] ?? "")),
-      "Time": fmtTs(o["cTime"]),
-      "Direction": `${String(o["side"] ?? "").toUpperCase()} ${fmtOrderOutcome(o["instId"], o["outcome"]).toUpperCase()}`,
-      "Price": o["px"],
-      "Size": `${o["fillSz"] ?? 0} / ${o["sz"]}`,
-      "Status": o["stateLabel"] ?? o["state"],
-      "Order number": o["ordId"]
-    }))
-  );
-}
-async function cmdEventFills(run, opts) {
-  const result = await run("event_get_fills", {
-    instId: opts.instId,
-    limit: opts.limit
-  });
-  const data = getData8(result);
-  if (opts.json) return printJson(data);
-  printTable(
-    (data ?? []).map((f) => ({
-      "Contract": formatDisplayTitle(String(f["instId"] ?? "")),
-      "Direction": (() => {
-        const side = String(f["side"] ?? "").toUpperCase();
-        const outcome = fmtOrderOutcome(f["instId"], f["outcome"]).toUpperCase();
-        const dir = `${side} ${outcome}`.trim();
-        return dir || "\u2014";
-      })(),
-      "Fill Price": f["fillPx"],
-      "Fill Size": f["fillSz"],
-      "Time": fmtTs(f["ts"]),
-      "Order number": f["ordId"]
-    }))
-  );
-}
-async function handleExpiredContractFallback(run, opts) {
-  process.stdout.write(
-    `Order failed: Contract ${opts.instId} has expired.
-Checking next available contracts in this series...
-`
-  );
-  const seriesId = extractSeriesId(opts.instId);
-  try {
-    const mkts = await run("event_get_markets", { seriesId, state: "live" });
-    const mData = getData8(mkts) ?? [];
-    const active = mData.filter((m) => m["floorStrike"] && m["floorStrike"] !== "");
-    if (active.length > 0) {
-      printTable(
-        active.slice(0, 3).map((m) => ({
-          instId: m["instId"],
-          expTime: m["expTime"] ?? "",
-          targetPrice: m["floorStrike"] ?? ""
-        }))
-      );
-      const next = active[0];
-      const nextInstId = String(next["instId"]);
-      const pxFlag = opts.px ? ` --px ${opts.px}` : "";
-      const ordTypeFlag = opts.ordType ? ` --ordType ${opts.ordType}` : "";
-      process.stdout.write(
-        `
-To place the same order on the next contract:
-  okx event place ${nextInstId} ${opts.side} ${opts.outcome} ${opts.sz}${pxFlag}${ordTypeFlag}
-`
-      );
-    } else {
-      process.stdout.write(`No active contracts found in this series.
-`);
-    }
-  } catch {
-  }
-}
-function handlePlaceOrderError2(msg, instId) {
-  if (msg.includes("not found") || msg.includes("51001")) {
-    process.stdout.write(`Order failed: Contract ${instId} not found or not yet available.
-`);
-  } else {
-    process.stdout.write(`Order failed: ${msg}
-`);
-  }
-}
-function buildPlaceConfirmation(opts, ordType) {
-  const contractName = formatDisplayTitle(opts.instId);
-  const direction = `${opts.side.toUpperCase()} ${opts.outcome.toUpperCase()}`;
-  if (ordType === "market") {
-    return `Placing: ${contractName}  ${direction}  sz=${opts.sz} (market order, exchange converts to contracts)
-`;
-  }
-  const px = parseFloat(opts.px ?? "0");
-  const sz = parseFloat(opts.sz);
-  const cost = (sz * px).toFixed(2);
-  const maxGain = (sz * (1 - px)).toFixed(2);
-  return `Placing: ${contractName}  ${direction}  ${opts.sz} contracts at px=${opts.px} (cost \u2248 ${cost}, max gain \u2248 ${maxGain})
-`;
-}
-async function cmdEventPlace(run, opts) {
-  const ordType = opts.ordType ?? "market";
-  if (ordType === "limit" && !opts.px) {
-    process.stderr.write("Error: --px is required for limit orders.\n");
-    process.exitCode = 1;
-    return;
-  }
-  if (!opts.json) {
-    process.stdout.write(buildPlaceConfirmation(opts, ordType));
-  }
-  let result;
-  try {
-    result = await run("event_place_order", {
-      instId: opts.instId,
-      side: opts.side,
-      outcome: opts.outcome,
-      sz: opts.sz,
-      px: opts.px,
-      ordType: opts.ordType
-    });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    const expiryMs = inferExpiryMsFromInstId(opts.instId);
-    const isExpired = expiryMs !== null && expiryMs < Date.now();
-    if (isExpired) {
-      await handleExpiredContractFallback(run, opts);
-    } else {
-      handlePlaceOrderError2(msg, opts.instId);
-    }
-    return;
-  }
-  const data = getData8(result);
-  if (opts.json) return printJson(data);
-  const order = data?.[0];
-  const stateHint = ordType === "market" ? "market order \u2014 typically fills immediately" : `${ordType} order \u2014 may still be live; verify with: okx event orders --instId ${opts.instId} --state live`;
-  const period = fmtPeriodFromInstId(opts.instId);
-  const pxPart = opts.px ? `  px: ${opts.px}` : "";
-  process.stdout.write(
-    `Order submitted: ${order?.["ordId"]}
-  Period: ${period}
-  ${opts.side.toUpperCase()} ${opts.outcome.toUpperCase()}  sz: ${opts.sz}${pxPart}  type: ${ordType}
-  (${stateHint})
-`
-  );
-  if (ordType === "market") {
-    process.stdout.write("  Note: exchange converts sz (amount) to contracts based on best available price\n");
-  }
-}
-async function cmdEventAmend(run, opts) {
-  let result;
-  try {
-    result = await run("event_amend_order", {
-      instId: opts.instId,
-      ordId: opts.ordId,
-      newPx: opts.px,
-      newSz: opts.sz
-    });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stdout.write(`Failed to amend order ${opts.ordId}: ${msg}
-`);
-    return;
-  }
-  const data = getData8(result);
-  if (opts.json) return printJson(data);
-  const r = data?.[0];
-  const pxPart = opts.px ? `  new px: ${opts.px}` : "";
-  const szPart = opts.sz ? `  new sz: ${opts.sz}` : "";
-  process.stdout.write(
-    `Amended: ${r?.["ordId"] ?? opts.ordId}${pxPart}${szPart}
-`
-  );
-}
-function handleCancelCatchError(instId, ordId, err) {
-  const msg = err instanceof Error ? err.message : String(err);
-  const expiryMs = inferExpiryMsFromInstId(instId);
-  const isExpired = expiryMs !== null && expiryMs < Date.now();
-  if (isExpired) {
-    process.stdout.write(
-      `Cannot cancel: contract ${instId} has already expired.
-  The order was auto-cancelled at settlement \u2014 no action needed.
-`
-    );
-  } else {
-    process.stdout.write(`Failed to cancel order ${ordId}: ${msg}
-`);
-  }
-}
-async function cmdEventCancel(run, opts) {
-  let result;
-  try {
-    result = await run("event_cancel_order", {
-      instId: opts.instId,
-      ordId: opts.ordId
-    });
-  } catch (err) {
-    handleCancelCatchError(opts.instId, opts.ordId, err);
-    return;
-  }
-  const data = getData8(result);
-  if (opts.json) return printJson(data);
-  const r = data?.[0];
-  process.stdout.write(`Cancelled: ${r?.["ordId"] ?? opts.ordId}
-`);
-}
-
 // src/index.ts
 var _require3 = createRequire3(import.meta.url);
 var CLI_VERSION2 = _require3("../package.json").version;
-var GIT_HASH2 = true ? "765bfa2" : "dev";
+var GIT_HASH2 = true ? "980de10" : "dev";
 function handleConfigCommand(action, rest, json, lang, force) {
   if (action === "init") return cmdConfigInit(lang === "zh" ? "zh" : "en");
   if (action === "show") return cmdConfigShow(json);
@@ -15289,33 +14367,6 @@ function handleSkillCommand(run, action, rest, v, json, config) {
   errorLine("Valid: search, categories, add, download, remove, check, list");
   process.exitCode = 1;
 }
-function handleEventCommand(run, action, rest, v, json) {
-  const limit = v.limit !== void 0 ? Number(v.limit) : void 0;
-  const handlers = {
-    browse: () => cmdEventBrowse(run, { underlying: v.underlying ?? rest[0], json }),
-    series: () => cmdEventSeries(run, { seriesId: v.seriesId, all: v.all, json }),
-    events: () => cmdEventEvents(run, { seriesId: v.seriesId ?? rest[0], state: v.state, limit, json }),
-    markets: () => cmdEventMarkets(run, { seriesId: v.seriesId ?? rest[0], eventId: v.eventId, instId: v.instId, state: v.state, limit, json }),
-    place: () => cmdEventPlace(run, {
-      instId: v.instId ?? rest[0],
-      side: v.side ?? rest[1],
-      outcome: v.outcome ?? rest[2],
-      sz: v.sz ?? rest[3],
-      px: v.px,
-      ordType: v.ordType,
-      json
-    }),
-    amend: () => cmdEventAmend(run, { instId: v.instId ?? rest[0], ordId: v.ordId ?? rest[1], px: v.px, sz: v.sz, json }),
-    cancel: () => cmdEventCancel(run, { instId: v.instId ?? rest[0], ordId: v.ordId ?? rest[1], json }),
-    orders: () => cmdEventOrders(run, { instId: v.instId, state: v.state, limit, json }),
-    fills: () => cmdEventFills(run, { instId: v.instId, limit, json })
-  };
-  const handler = handlers[action];
-  if (handler) return handler();
-  process.stderr.write(`Unknown event command: ${action}
-`);
-  process.exitCode = 1;
-}
 function outputResult(result, json) {
   if (json) {
     outputLine(JSON.stringify(result, null, 2));
@@ -15394,7 +14445,6 @@ async function main() {
     swap: () => handleSwapCommand(run, action, rest, v, json),
     futures: () => handleFuturesCommand(run, action, rest, v, json),
     option: () => handleOptionCommand(run, action, rest, v, json),
-    event: () => handleEventCommand(run, action, rest, v, json),
     bot: () => handleBotCommand(run, action, rest, v, json),
     earn: () => handleEarnCommand(run, action, rest, v, json),
     skill: () => handleSkillCommand(run, action, rest, v, json, config)
@@ -15419,7 +14469,6 @@ export {
   handleBotGridCommand,
   handleConfigCommand,
   handleEarnCommand,
-  handleEventCommand,
   handleFuturesAlgoCommand,
   handleFuturesCommand,
   handleMarketCommand,