@okx_ai/okx-trade-cli 1.3.0-beta.1 → 1.3.0-beta.3

package/dist/index.js

@@ -4,25 +4,37 @@
 import { createRequire as createRequire3 } from "module";
 
 // ../core/dist/index.js
-import { ProxyAgent } from "undici";
+import { Agent, ProxyAgent } 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,13 +863,137 @@ 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 * 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 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) {
+  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);
+        }
+      }
+    );
+  });
+}
+var DOH_CACHE_PATH = join2(homedir2(), ".okx", "doh-node-cache.json");
+function readCache(hostname, cachePath = DOH_CACHE_PATH) {
+  try {
+    const raw = readFileSync(cachePath, "utf-8");
+    const file = JSON.parse(raw);
+    return file[hostname] ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeCache(hostname, entry, cachePath = DOH_CACHE_PATH) {
+  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) {
+  if (!node) {
+    if (failedNodes.length > 0) {
+      writeCache(hostname, {
+        mode: "direct",
+        node: null,
+        failedNodes,
+        updatedAt: Date.now()
+      });
+    }
+    return { mode: null, node: null };
+  }
+  if (node.ip === hostname || node.host === hostname) {
+    writeCache(hostname, {
+      mode: "direct",
+      node: null,
+      failedNodes,
+      updatedAt: Date.now()
+    });
+    return { mode: "direct", node: null };
+  }
+  writeCache(hostname, {
+    mode: "proxy",
+    node,
+    failedNodes,
+    updatedAt: Date.now()
+  });
+  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);
+}
+async function resolveDoh(hostname) {
+  const entry = readCache(hostname);
+  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) {
+  const entry = readCache(hostname);
+  const active = getActiveFailedNodes(entry?.failedNodes);
+  const now = Date.now();
+  const failedNodes = failedIp ? active.some((n) => n.ip === failedIp) ? active : [...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);
+}
 function getNow() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -1076,6 +1212,14 @@ var OkxRestClient = class _OkxRestClient {
   config;
   rateLimiter;
   dispatcher;
+  // 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(config) {
     this.config = config;
     this.rateLimiter = new RateLimiter(3e4, config.verbose);
@@ -1083,6 +1227,97 @@ var OkxRestClient = class _OkxRestClient {
       this.dispatcher = new ProxyAgent(config.proxyUrl);
     }
   }
+  /**
+   * Lazily resolve the DoH proxy node on the first request.
+   * Uses cache-first strategy via the resolver.
+   */
+  async ensureDoh() {
+    if (this.dohResolved || this.dispatcher) return;
+    this.dohResolved = true;
+    try {
+      const { hostname, protocol } = new URL(this.config.baseUrl);
+      const result = await resolveDoh(hostname);
+      if (!result.mode) {
+        this.directUnverified = true;
+        if (this.config.verbose) {
+          vlog("DoH: no cache, trying direct connection first");
+        }
+        return;
+      }
+      if (result.mode === "direct") {
+        if (this.config.verbose) {
+          vlog("DoH: mode=direct (overseas or cached), using direct connection");
+        }
+        return;
+      }
+      if (result.node) {
+        this.applyDohNode(result.node, protocol);
+      }
+    } catch (err) {
+      if (this.config.verbose) {
+        const cause = err instanceof Error ? err.message : String(err);
+        vlog(`DoH resolution failed, falling back to direct: ${cause}`);
+      }
+    }
+  }
+  /** Apply a DoH node: set up the custom Agent + base URL. */
+  applyDohNode(node, protocol) {
+    this.dohNode = node;
+    this.dohBaseUrl = `${protocol}//${node.host}`;
+    this.dohAgent = new Agent({
+      connect: {
+        lookup: (_hostname, options, callback) => {
+          if (options?.all) {
+            callback(null, [{ address: node.ip, family: 4 }]);
+          } else {
+            callback(null, node.ip, 4);
+          }
+        }
+      }
+    });
+    if (this.config.verbose) {
+      vlog(`DoH proxy active: \u2192 ${node.host} (${node.ip}), ttl=${node.ttl}s`);
+    }
+  }
+  /**
+   * Handle network failure: re-resolve with --exclude and retry once.
+   * Returns true if retry should proceed, false if already retried.
+   */
+  async handleDohNetworkFailure() {
+    if (this.dohRetried) return false;
+    this.dohRetried = true;
+    const failedIp = this.dohNode?.ip ?? "";
+    const { hostname, protocol } = new URL(this.config.baseUrl);
+    this.dohNode = null;
+    this.dohAgent = null;
+    this.dohBaseUrl = null;
+    if (!failedIp) this.directUnverified = false;
+    if (this.config.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.applyDohNode(result.node, protocol);
+        return true;
+      }
+    } catch {
+    }
+    if (this.config.verbose) {
+      vlog("DoH: re-resolution failed or switched to direct, retrying with direct connection");
+    }
+    return true;
+  }
+  get activeBaseUrl() {
+    return this.dohNode ? this.dohBaseUrl : this.config.baseUrl;
+  }
+  get activeDispatcher() {
+    return this.dispatcher ?? this.dohAgent ?? void 0;
+  }
+  /** User-Agent for DoH proxy requests: OKX/@okx_ai/{packageName}/{version} */
+  get dohUserAgent() {
+    return `OKX/@okx_ai/${this.config.userAgent ?? "unknown"}`;
+  }
   logRequest(method, url, auth) {
     if (!this.config.verbose) return;
     vlog(`\u2192 ${method} ${url}`);
@@ -1252,13 +1487,17 @@ var OkxRestClient = class _OkxRestClient {
    * Security: validates Content-Type and enforces maxBytes limit.
    */
   async privatePostBinary(path42, body, opts) {
+    await this.ensureDoh();
     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");
+    this.logRequest("POST", `${this.activeBaseUrl}${path42}`, "private");
     const reqConfig = { method: "POST", path: path42, auth: "private" };
     const headers = this.buildHeaders(reqConfig, path42, bodyJson, getNow());
+    if (this.dohNode) {
+      headers.set("User-Agent", this.dohUserAgent);
+    }
     const t0 = Date.now();
     const response = await this.fetchBinary(path42, endpoint, headers, bodyJson, t0);
     const elapsed = Date.now() - t0;
@@ -1292,10 +1531,10 @@ var OkxRestClient = class _OkxRestClient {
         method: "POST",
         headers,
         body: bodyJson || void 0,
-        signal: AbortSignal.timeout(this.config.timeoutMs)
+        signal: AbortSignal.timeout(this.config.timeoutMs),
+        dispatcher: this.activeDispatcher
       };
-      if (this.dispatcher) fetchOptions.dispatcher = this.dispatcher;
-      return await fetch(`${this.config.baseUrl}${path42}`, fetchOptions);
+      return await fetch(`${this.activeBaseUrl}${path42}`, fetchOptions);
     } catch (error) {
       if (this.config.verbose) {
         vlog(`\u2717 NetworkError after ${Date.now() - t0}ms: ${error instanceof Error ? error.message : String(error)}`);
@@ -1326,9 +1565,10 @@ var OkxRestClient = class _OkxRestClient {
   // JSON request
   // ---------------------------------------------------------------------------
   async request(reqConfig) {
+    await this.ensureDoh();
     const queryString = buildQueryString(reqConfig.query);
     const requestPath = queryString.length > 0 ? `${reqConfig.path}?${queryString}` : reqConfig.path;
-    const url = `${this.config.baseUrl}${requestPath}`;
+    const url = `${this.activeBaseUrl}${requestPath}`;
     const bodyJson = reqConfig.body ? JSON.stringify(reqConfig.body) : "";
     const timestamp = getNow();
     this.logRequest(reqConfig.method, url, reqConfig.auth);
@@ -1336,6 +1576,9 @@ var OkxRestClient = class _OkxRestClient {
       await this.rateLimiter.consume(reqConfig.rateLimit);
     }
     const headers = this.buildHeaders(reqConfig, requestPath, bodyJson, timestamp);
+    if (this.dohNode) {
+      headers.set("User-Agent", this.dohUserAgent);
+    }
     const t0 = Date.now();
     let response;
     try {
@@ -1343,13 +1586,20 @@ 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.activeDispatcher
       };
-      if (this.dispatcher) {
-        fetchOptions.dispatcher = this.dispatcher;
-      }
       response = await fetch(url, fetchOptions);
     } catch (error) {
+      if (!this.dohRetried) {
+        if (this.config.verbose) {
+          vlog(`Network failure, refreshing DoH: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const shouldRetry = await this.handleDohNetworkFailure();
+        if (shouldRetry && reqConfig.method === "GET") {
+          return this.request(reqConfig);
+        }
+      }
       if (this.config.verbose) {
         const elapsed2 = Date.now() - t0;
         const cause = error instanceof Error ? error.message : String(error);
@@ -1364,6 +1614,19 @@ var OkxRestClient = class _OkxRestClient {
     const rawText = await response.text();
     const elapsed = Date.now() - t0;
     const traceId = extractTraceId(response.headers);
+    if (this.directUnverified && !this.dohNode) {
+      this.directUnverified = false;
+      const { hostname: h } = new URL(this.config.baseUrl);
+      writeCache(h, {
+        mode: "direct",
+        node: null,
+        failedNodes: [],
+        updatedAt: Date.now()
+      });
+      if (this.config.verbose) {
+        vlog("DoH: direct connection succeeded, cached mode=direct");
+      }
+    }
     return this.processResponse(rawText, response, elapsed, traceId, reqConfig, requestPath);
   }
 };
@@ -1503,137 +1766,14 @@ var INDICATOR_BARS = [
   "1Wutc"
 ];
 var INDICATOR_CODE_OVERRIDES = {
-  // Aliases
-  "boll": "BB",
-  // server supports BB not BOLL
-  // Names where default rule produces underscores but backend uses no separator
   "rainbow": "BTCRAINBOW",
-  // default: RAINBOW
+  "range-filter": "RANGEFILTER",
   "stoch-rsi": "STOCHRSI",
-  // default: STOCH_RSI
-  "bull-engulf": "BULLENGULF",
-  // default: BULL_ENGULF
-  "bear-engulf": "BEARENGULF",
-  // default: BEAR_ENGULF
-  "bull-harami": "BULLHARAMI",
-  // default: BULL_HARAMI
-  "bear-harami": "BEARHARAMI",
-  // default: BEAR_HARAMI
-  "bull-harami-cross": "BULLHARAMICROSS",
-  // default: BULL_HARAMI_CROSS
-  "bear-harami-cross": "BEARHARAMICROSS",
-  // default: BEAR_HARAMI_CROSS
-  "three-soldiers": "THREESOLDIERS",
-  // default: THREE_SOLDIERS
-  "three-crows": "THREECROWS",
-  // default: THREE_CROWS
-  "hanging-man": "HANGINGMAN",
-  // default: HANGING_MAN
-  "inverted-hammer": "INVERTEDH",
-  // default: INVERTED_HAMMER (backend uses INVERTEDH)
-  "shooting-star": "SHOOTINGSTAR",
-  // default: SHOOTING_STAR
-  "nvi-pvi": "NVIPVI",
-  // default: NVI_PVI
-  "top-long-short": "TOPLONGSHORT"
-  // default: TOP_LONG_SHORT
-  // Note: range-filter → RANGE_FILTER is correct via the default rule; no override needed.
+  "pi-cycle-top": "PI_CYCLE_TOP",
+  "pi-cycle-bottom": "PI_CYCLE_BOTTOM",
+  // boll is an alias for bb; server supports BB not BOLL
+  "boll": "BB"
 };
-var KNOWN_INDICATORS = [
-  // Moving Averages
-  { name: "ma", description: "Simple Moving Average" },
-  { name: "ema", description: "Exponential Moving Average" },
-  { name: "wma", description: "Weighted Moving Average" },
-  { name: "dema", description: "Double Exponential Moving Average" },
-  { name: "tema", description: "Triple Exponential Moving Average" },
-  { name: "zlema", description: "Zero-Lag Exponential Moving Average" },
-  { name: "hma", description: "Hull Moving Average" },
-  { name: "kama", description: "Kaufman Adaptive Moving Average" },
-  // Trend
-  { name: "macd", description: "MACD" },
-  { name: "sar", description: "Parabolic SAR" },
-  { name: "adx", description: "Average Directional Index" },
-  { name: "aroon", description: "Aroon Indicator" },
-  { name: "cci", description: "Commodity Channel Index" },
-  { name: "dpo", description: "Detrended Price Oscillator" },
-  { name: "envelope", description: "Envelope" },
-  { name: "halftrend", description: "HalfTrend" },
-  { name: "alphatrend", description: "AlphaTrend" },
-  // Momentum
-  { name: "rsi", description: "Relative Strength Index" },
-  { name: "stoch-rsi", description: "Stochastic RSI" },
-  { name: "stoch", description: "Stochastic Oscillator" },
-  { name: "roc", description: "Rate of Change" },
-  { name: "mom", description: "Momentum" },
-  { name: "ppo", description: "Price Percentage Oscillator" },
-  { name: "trix", description: "TRIX" },
-  { name: "ao", description: "Awesome Oscillator" },
-  { name: "uo", description: "Ultimate Oscillator" },
-  { name: "wr", description: "Williams %R" },
-  // Volatility
-  { name: "bb", description: "Bollinger Bands" },
-  { name: "boll", description: "Bollinger Bands (alias for bb)" },
-  { name: "bbwidth", description: "Bollinger Band Width" },
-  { name: "bbpct", description: "Bollinger Band %B" },
-  { name: "atr", description: "Average True Range" },
-  { name: "keltner", description: "Keltner Channel" },
-  { name: "donchian", description: "Donchian Channel" },
-  { name: "hv", description: "Historical Volatility" },
-  { name: "stddev", description: "Standard Deviation" },
-  // Volume
-  { name: "obv", description: "On-Balance Volume" },
-  { name: "vwap", description: "Volume Weighted Average Price" },
-  { name: "mvwap", description: "Moving VWAP" },
-  { name: "cmf", description: "Chaikin Money Flow" },
-  { name: "mfi", description: "Money Flow Index" },
-  { name: "ad", description: "Accumulation/Distribution" },
-  // Statistical
-  { name: "lr", description: "Linear Regression" },
-  { name: "slope", description: "Linear Regression Slope" },
-  { name: "angle", description: "Linear Regression Angle" },
-  { name: "variance", description: "Variance" },
-  { name: "meandev", description: "Mean Deviation" },
-  { name: "sigma", description: "Sigma" },
-  { name: "stderr", description: "Standard Error" },
-  // Custom
-  { name: "kdj", description: "KDJ Stochastic Oscillator" },
-  { name: "supertrend", description: "Supertrend" },
-  // Ichimoku
-  { name: "tenkan", description: "Ichimoku Tenkan-sen (Conversion Line)" },
-  { name: "kijun", description: "Ichimoku Kijun-sen (Base Line)" },
-  { name: "senkoa", description: "Ichimoku Senkou Span A (Leading Span A)" },
-  { name: "senkob", description: "Ichimoku Senkou Span B (Leading Span B)" },
-  { name: "chikou", description: "Ichimoku Chikou Span (Lagging Span)" },
-  // Candlestick Patterns
-  { name: "doji", description: "Doji candlestick pattern" },
-  { name: "bull-engulf", description: "Bullish Engulfing pattern" },
-  { name: "bear-engulf", description: "Bearish Engulfing pattern" },
-  { name: "bull-harami", description: "Bullish Harami pattern" },
-  { name: "bear-harami", description: "Bearish Harami pattern" },
-  { name: "bull-harami-cross", description: "Bullish Harami Cross pattern" },
-  { name: "bear-harami-cross", description: "Bearish Harami Cross pattern" },
-  { name: "three-soldiers", description: "Three White Soldiers pattern" },
-  { name: "three-crows", description: "Three Black Crows pattern" },
-  { name: "hanging-man", description: "Hanging Man pattern" },
-  { name: "inverted-hammer", description: "Inverted Hammer pattern" },
-  { name: "shooting-star", description: "Shooting Star pattern" },
-  // Bitcoin On-Chain
-  { name: "ahr999", description: "AHR999 Bitcoin accumulation index" },
-  { name: "rainbow", description: "Bitcoin Rainbow Chart" },
-  // Other
-  { name: "fisher", description: "Fisher Transform" },
-  { name: "nvi-pvi", description: "Negative/Positive Volume Index (returns both)" },
-  { name: "pmax", description: "PMAX" },
-  { name: "qqe", description: "QQE Mod" },
-  { name: "tdi", description: "Traders Dynamic Index" },
-  { name: "waddah", description: "Waddah Attar Explosion" },
-  { name: "range-filter", description: "Range Filter" },
-  { name: "cho", description: "Chande Momentum Oscillator" },
-  { name: "tr", description: "True Range" },
-  { name: "tp", description: "Typical Price" },
-  { name: "mp", description: "Median Price" },
-  { name: "top-long-short", description: "Top Trader Long/Short Ratio (timeframe-independent)" }
-];
 function resolveIndicatorCode(name) {
   const lower = name.toLowerCase();
   return INDICATOR_CODE_OVERRIDES[lower] ?? name.toUpperCase().replace(/-/g, "_");
@@ -1660,7 +1800,7 @@ function registerIndicatorTools() {
           },
           indicator: {
             type: "string",
-            description: "Indicator name (case-insensitive). Call market_list_indicators to see all supported names."
+            description: "Indicator name (case-insensitive). Examples: ma, ema, rsi, macd, bb, kdj, supertrend, ahr999, rainbow, pi-cycle-top, pi-cycle-bottom, mayer, envelope, halftrend, alphatrend, pmax, waddah, tdi, qqe, range-filter"
           },
           bar: {
             type: "string",
@@ -1717,14 +1857,6 @@ function registerIndicatorTools() {
         );
         return normalizeResponse(response);
       }
-    },
-    {
-      name: "market_list_indicators",
-      module: "market",
-      description: "List all supported technical indicator names and descriptions. Call this before market_get_indicator to discover valid indicator names. No credentials required.",
-      isWrite: false,
-      inputSchema: { type: "object", properties: {} },
-      handler: async () => ({ data: KNOWN_INDICATORS })
     }
   ];
 }
@@ -2322,59 +2454,6 @@ function registerAccountTools() {
     }
   ];
 }
-async function resolveQuoteCcySz(instId, sz, tgtCcy, instType, client) {
-  if (tgtCcy !== "quote_ccy") {
-    return { sz, tgtCcy, conversionNote: void 0 };
-  }
-  const [instrumentsRes, tickerRes] = await Promise.all([
-    client.publicGet("/api/v5/public/instruments", {
-      instType,
-      instId
-    }),
-    client.publicGet("/api/v5/market/ticker", { instId })
-  ]);
-  const instruments = Array.isArray(instrumentsRes.data) ? instrumentsRes.data : [];
-  if (instruments.length === 0) {
-    throw new Error(
-      `Failed to fetch instrument info for ${instId}: empty instrument list. Cannot determine ctVal for quote_ccy conversion.`
-    );
-  }
-  const ctValStr = String(instruments[0].ctVal ?? "");
-  const ctVal = parseFloat(ctValStr);
-  if (!isFinite(ctVal) || ctVal <= 0) {
-    throw new Error(
-      `Invalid ctVal "${ctValStr}" for ${instId}. ctVal must be a positive number for quote_ccy conversion.`
-    );
-  }
-  const tickers = Array.isArray(tickerRes.data) ? tickerRes.data : [];
-  if (tickers.length === 0) {
-    throw new Error(
-      `Failed to fetch ticker price for ${instId}: empty ticker response. Cannot determine last price for quote_ccy conversion.`
-    );
-  }
-  const lastStr = String(tickers[0].last ?? "");
-  const lastPx = parseFloat(lastStr);
-  if (!isFinite(lastPx) || lastPx <= 0) {
-    throw new Error(
-      `Invalid last price "${lastStr}" for ${instId}. Last price must be a positive number for quote_ccy conversion.`
-    );
-  }
-  const usdtAmount = parseFloat(sz);
-  const contractValue = ctVal * lastPx;
-  const contracts = Math.floor(usdtAmount / contractValue);
-  if (contracts <= 0) {
-    const minUsdt = contractValue.toFixed(2);
-    throw new Error(
-      `sz=${sz} USDT is too small to buy even 1 contract of ${instId}. Minimum amount required is at least ${minUsdt} USDT (ctVal=${ctValStr}, lastPx=${lastStr}, 1 contract = ${minUsdt} USDT).`
-    );
-  }
-  const conversionNote = `Converting ${sz} USDT \u2192 ${contracts} contracts (ctVal=${ctValStr}, lastPx=${lastStr}, formula: floor(${sz} / (${ctValStr} \xD7 ${lastStr})) = ${contracts})`;
-  return {
-    sz: String(contracts),
-    tgtCcy: void 0,
-    conversionNote
-  };
-}
 function registerAlgoTradeTools() {
   return [
     {
@@ -2470,13 +2549,6 @@ function registerAlgoTradeTools() {
       handler: async (rawArgs, context) => {
         const args = asRecord(rawArgs);
         const reduceOnly = args.reduceOnly;
-        const resolved = await resolveQuoteCcySz(
-          requireString(args, "instId"),
-          requireString(args, "sz"),
-          readString(args, "tgtCcy"),
-          "SWAP",
-          context.client
-        );
         const response = await context.client.privatePost(
           "/api/v5/trade/order-algo",
           compactObject({
@@ -2485,8 +2557,8 @@ function registerAlgoTradeTools() {
             side: requireString(args, "side"),
             posSide: readString(args, "posSide"),
             ordType: requireString(args, "ordType"),
-            sz: resolved.sz,
-            tgtCcy: resolved.tgtCcy,
+            sz: requireString(args, "sz"),
+            tgtCcy: readString(args, "tgtCcy"),
             tpTriggerPx: readString(args, "tpTriggerPx"),
             tpOrdPx: readString(args, "tpOrdPx"),
             tpTriggerPxType: readString(args, "tpTriggerPxType"),
@@ -2502,11 +2574,7 @@ function registerAlgoTradeTools() {
           }),
           privateRateLimit("swap_place_algo_order", 20)
         );
-        const result = normalizeResponse(response);
-        if (resolved.conversionNote) {
-          result._conversion = resolved.conversionNote;
-        }
-        return result;
+        return normalizeResponse(response);
       }
     },
     {
@@ -2814,13 +2882,6 @@ function registerFuturesAlgoTools() {
       handler: async (rawArgs, context) => {
         const args = asRecord(rawArgs);
         const reduceOnly = args.reduceOnly;
-        const resolved = await resolveQuoteCcySz(
-          requireString(args, "instId"),
-          requireString(args, "sz"),
-          readString(args, "tgtCcy"),
-          "FUTURES",
-          context.client
-        );
         const response = await context.client.privatePost(
           "/api/v5/trade/order-algo",
           compactObject({
@@ -2829,8 +2890,8 @@ function registerFuturesAlgoTools() {
             side: requireString(args, "side"),
             posSide: readString(args, "posSide"),
             ordType: requireString(args, "ordType"),
-            sz: resolved.sz,
-            tgtCcy: resolved.tgtCcy,
+            sz: requireString(args, "sz"),
+            tgtCcy: readString(args, "tgtCcy"),
             tpTriggerPx: readString(args, "tpTriggerPx"),
             tpOrdPx: readString(args, "tpOrdPx"),
             tpTriggerPxType: readString(args, "tpTriggerPxType"),
@@ -2846,11 +2907,7 @@ function registerFuturesAlgoTools() {
           }),
           privateRateLimit("futures_place_algo_order", 20)
         );
-        const result = normalizeResponse(response);
-        if (resolved.conversionNote) {
-          result._conversion = resolved.conversionNote;
-        }
-        return result;
+        return normalizeResponse(response);
       }
     },
     {
@@ -3181,19 +3238,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;
@@ -3258,7 +3315,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);
@@ -3281,7 +3338,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());
@@ -3297,11 +3354,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);
@@ -3323,26 +3380,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);
@@ -3415,7 +3472,7 @@ function registerSkillsTools() {
     {
       name: "skills_download",
       module: "skills",
-      description: "Download a skill zip file from OKX Skills Marketplace to a local directory. Always call skills_search first to confirm the skill name exists. Downloads the latest approved version. NOTE: Downloads third-party developer content as a zip \u2014 does NOT install to agents. For full installation use CLI: okx skill add <name>. Use when the user wants to inspect or manually install a skill package.",
+      description: "Download a skill zip file from OKX Skills Marketplace to a local directory. Always call skills_search first to confirm the skill name exists. Downloads the latest approved version. NOTE: This only downloads the zip \u2014 it does NOT install to agents. For full installation use CLI: okx skill add <name>. Use when the user wants to inspect or manually install a skill package.",
       inputSchema: {
         type: "object",
         properties: {
@@ -4563,7 +4620,7 @@ function registerDcdTools() {
     {
       name: "dcd_get_products",
       module: "earn.dcd",
-      description: "Get DCD products with yield and quota info. Yields in response are decimal fractions, not percentages.",
+      description: "Get DCD products with yield and quota info.",
       isWrite: false,
       inputSchema: {
         type: "object",
@@ -4617,7 +4674,7 @@ function registerDcdTools() {
     {
       name: "dcd_get_orders",
       module: "earn.dcd",
-      description: "Get DCD order history. Yields in response are decimal fractions, not percentages.",
+      description: "Get DCD order history.",
       isWrite: false,
       inputSchema: {
         type: "object",
@@ -4661,7 +4718,7 @@ function registerDcdTools() {
     {
       name: "dcd_subscribe",
       module: "earn.dcd",
-      description: "Subscribe to a DCD product: get quote and execute atomically. Confirm product, amount, and currency with user before calling. Optional minAnnualizedYield rejects the order if quote yield falls below threshold. Returns order result with quote snapshot (minAnnualizedYield is in percent; response yields are decimal fractions).",
+      description: "Subscribe to a DCD product: get quote and execute atomically. Confirm product, amount, and currency with user before calling. Optional minAnnualizedYield (percent) rejects the order if quote yield falls below threshold. Returns order result with quote snapshot (annualizedYield, absYield).",
       isWrite: true,
       inputSchema: {
         type: "object",
@@ -4700,23 +4757,13 @@ function registerDcdTools() {
             });
           }
           if (minAnnualizedYield !== void 0) {
-            const rawYield = parseFloat(quote["annualizedYield"]);
-            if (isNaN(rawYield)) {
+            const actualYield = parseFloat(quote["annualizedYield"]);
+            if (!isNaN(actualYield) && actualYield < minAnnualizedYield) {
               throw new OkxApiError(
-                "Quote returned non-numeric annualizedYield, cannot verify minimum yield threshold.",
-                {
-                  code: "INVALID_YIELD_VALUE",
-                  suggestion: "Order not placed. The quote did not include a valid annualizedYield. Retry or pick a different product."
-                }
-              );
-            }
-            const actualYieldPct = rawYield * 100;
-            if (actualYieldPct < minAnnualizedYield) {
-              throw new OkxApiError(
-                `Quote yield ${actualYieldPct.toFixed(2)}% is below the minimum threshold of ${minAnnualizedYield}%.`,
+                `Quote yield ${actualYield}% is below the minimum threshold of ${minAnnualizedYield}%.`,
                 {
                   code: "YIELD_BELOW_MIN",
-                  suggestion: `Order not placed. Actual: ${actualYieldPct.toFixed(2)}%, required: >= ${minAnnualizedYield}%. Try a different product or lower your minimum yield.`
+                  suggestion: `Order not placed. Actual: ${actualYield}%, required: >= ${minAnnualizedYield}%. Try a different product or lower your minimum yield.`
                 }
               );
             }
@@ -4946,13 +4993,6 @@ function buildContractTradeTools(cfg) {
         const args = asRecord(rawArgs);
         const reduceOnly = args.reduceOnly;
         const attachAlgoOrds = buildAttachAlgoOrds(args);
-        const resolved = await resolveQuoteCcySz(
-          requireString(args, "instId"),
-          requireString(args, "sz"),
-          readString(args, "tgtCcy"),
-          defaultType,
-          context.client
-        );
         const response = await context.client.privatePost(
           "/api/v5/trade/order",
           compactObject({
@@ -4961,8 +5001,8 @@ function buildContractTradeTools(cfg) {
             side: requireString(args, "side"),
             posSide: readString(args, "posSide"),
             ordType: requireString(args, "ordType"),
-            sz: resolved.sz,
-            tgtCcy: resolved.tgtCcy,
+            sz: requireString(args, "sz"),
+            tgtCcy: readString(args, "tgtCcy"),
             px: readString(args, "px"),
             reduceOnly: typeof reduceOnly === "boolean" ? String(reduceOnly) : void 0,
             clOrdId: readString(args, "clOrdId"),
@@ -4971,11 +5011,7 @@ function buildContractTradeTools(cfg) {
           }),
           privateRateLimit(n("place_order"), 60)
         );
-        const result = normalizeResponse(response);
-        if (resolved.conversionNote) {
-          result._conversion = resolved.conversionNote;
-        }
-        return result;
+        return normalizeResponse(response);
       }
     },
     // ── cancel_order ─────────────────────────────────────────────────────────
@@ -6050,7 +6086,7 @@ function registerOptionAlgoTools() {
           tgtCcy: {
             type: "string",
             enum: ["base_ccy", "quote_ccy"],
-            description: "Size unit. base_ccy(default): sz in contracts, quote_ccy: sz in USDT (auto-converted to contracts)"
+            description: "Size unit. base_ccy(default): sz in contracts, quote_ccy: sz in USDT (may not be supported for options)"
           },
           reduceOnly: {
             type: "boolean",
@@ -6066,13 +6102,6 @@ function registerOptionAlgoTools() {
       handler: async (rawArgs, context) => {
         const args = asRecord(rawArgs);
         const reduceOnly = readBoolean(args, "reduceOnly");
-        const resolved = await resolveQuoteCcySz(
-          requireString(args, "instId"),
-          requireString(args, "sz"),
-          readString(args, "tgtCcy"),
-          "OPTION",
-          context.client
-        );
         const response = await context.client.privatePost(
           "/api/v5/trade/order-algo",
           compactObject({
@@ -6080,8 +6109,8 @@ function registerOptionAlgoTools() {
             tdMode: requireString(args, "tdMode"),
             side: requireString(args, "side"),
             ordType: requireString(args, "ordType"),
-            sz: resolved.sz,
-            tgtCcy: resolved.tgtCcy,
+            sz: requireString(args, "sz"),
+            tgtCcy: readString(args, "tgtCcy"),
             tpTriggerPx: readString(args, "tpTriggerPx"),
             tpOrdPx: readString(args, "tpOrdPx"),
             tpTriggerPxType: readString(args, "tpTriggerPxType"),
@@ -6288,12 +6317,7 @@ function registerOptionTools() {
           },
           sz: {
             type: "string",
-            description: "Contracts count by default. Set tgtCcy=quote_ccy to use USDT amount instead."
-          },
-          tgtCcy: {
-            type: "string",
-            enum: ["base_ccy", "quote_ccy"],
-            description: "Size unit. base_ccy(default): sz in contracts, quote_ccy: sz in USDT (auto-converted to contracts)"
+            description: "Contracts count (NOT USDT). Use market_get_instruments for ctVal."
           },
           px: {
             type: "string",
@@ -6330,13 +6354,6 @@ function registerOptionTools() {
         const args = asRecord(rawArgs);
         const reduceOnly = args.reduceOnly;
         const attachAlgoOrds = buildAttachAlgoOrds(args);
-        const resolved = await resolveQuoteCcySz(
-          requireString(args, "instId"),
-          requireString(args, "sz"),
-          readString(args, "tgtCcy"),
-          "OPTION",
-          context.client
-        );
         const response = await context.client.privatePost(
           "/api/v5/trade/order",
           compactObject({
@@ -6344,8 +6361,7 @@ function registerOptionTools() {
             tdMode: requireString(args, "tdMode"),
             side: requireString(args, "side"),
             ordType: requireString(args, "ordType"),
-            sz: resolved.sz,
-            tgtCcy: resolved.tgtCcy,
+            sz: requireString(args, "sz"),
             px: readString(args, "px"),
             reduceOnly: typeof reduceOnly === "boolean" ? String(reduceOnly) : void 0,
             clOrdId: readString(args, "clOrdId"),
@@ -7501,12 +7517,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) {
@@ -7534,11 +7550,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];
@@ -7652,21 +7668,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 {
   }
 }
@@ -7713,14 +7729,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(
@@ -7901,10 +7917,6 @@ var activeOutput = stdioOutput;
 function setOutput(impl) {
   activeOutput = impl;
 }
-var envContext = null;
-function setEnvContext(ctx) {
-  envContext = ctx;
-}
 function output(message) {
   activeOutput.out(message);
 }
@@ -7918,18 +7930,9 @@ function errorLine(message) {
   activeOutput.err(message + EOL);
 }
 function printJson(data) {
-  const payload = envContext ? {
-    env: envContext.demo ? "demo" : "live",
-    profile: envContext.profile,
-    data
-  } : data;
-  activeOutput.out(JSON.stringify(payload, null, 2) + EOL);
+  activeOutput.out(JSON.stringify(data, null, 2) + EOL);
 }
 function printTable(rows) {
-  if (envContext) {
-    const envLabel = envContext.demo ? "demo (simulated trading)" : "live";
-    activeOutput.out(`Environment: ${envLabel}` + EOL + EOL);
-  }
   if (rows.length === 0) {
     activeOutput.out("(no data)" + EOL);
     return;
@@ -8508,7 +8511,7 @@ async function cmdDiagnoseMcp(options = {}) {
 
 // src/commands/diagnose.ts
 var CLI_VERSION = readCliVersion();
-var GIT_HASH = true ? "ab11ece" : "dev";
+var GIT_HASH = true ? "19e8da3" : "dev";
 function maskKey2(key) {
   if (!key) return "(not set)";
   if (key.length <= 8) return "****";
@@ -8805,24 +8808,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 {
   }
 }
@@ -10040,10 +10043,6 @@ async function cmdMarketCandles(run, instId, opts) {
     }))
   );
 }
-function cmdMarketIndicatorList(json) {
-  if (json) return printJson(KNOWN_INDICATORS);
-  printTable(KNOWN_INDICATORS.map(({ name, description }) => ({ name, description })));
-}
 async function cmdMarketIndicator(run, indicator, instId, opts) {
   const params = opts.params ? opts.params.split(",").map((p) => Number(p.trim())).filter((n) => !Number.isNaN(n)) : void 0;
   const result = await run("market_get_indicator", {
@@ -11361,7 +11360,6 @@ async function cmdOptionPlace(run, opts) {
     side: opts.side,
     ordType: opts.ordType,
     sz: opts.sz,
-    tgtCcy: opts.tgtCcy,
     px: opts.px,
     reduceOnly: opts.reduceOnly,
     clOrdId: opts.clOrdId,
@@ -12408,7 +12406,7 @@ async function cmdDcdRedeemExecute(run, opts) {
     ordId: r["ordId"],
     state: r["state"],
     redeemSz: q["redeemSz"] ? `${parseFloat(q["redeemSz"]).toFixed(8)} ${q["redeemCcy"]}` : "\u2014",
-    termRate: q["termRate"] ? `${(parseFloat(q["termRate"]) * 100).toFixed(2)}%` : "\u2014"
+    termRate: q["termRate"] ? `${q["termRate"]}%` : "\u2014"
   });
 }
 async function cmdDcdOrderState(run, opts) {
@@ -12461,7 +12459,7 @@ async function cmdDcdOrders(run, opts) {
     quoteCcy: r["quoteCcy"],
     strike: r["strike"],
     notionalSz: r["notionalSz"],
-    annualizedYield: r["annualizedYield"] ? `${(parseFloat(r["annualizedYield"]) * 100).toFixed(2)}%` : "\u2014",
+    annualizedYield: r["annualizedYield"],
     yieldSz: r["yieldSz"],
     settleTime: r["settleTime"] ? new Date(Number(r["settleTime"])).toLocaleDateString() : "",
     // scheduled settlement time
@@ -12501,7 +12499,7 @@ async function cmdDcdQuoteAndBuy(run, opts) {
     outputLine("Quote:");
     printKv({
       quoteId: q["quoteId"],
-      annualizedYield: q["annualizedYield"] ? `${(parseFloat(q["annualizedYield"]) * 100).toFixed(2)}%` : "\u2014",
+      annualizedYield: q["annualizedYield"] ? `${q["annualizedYield"]}%` : "\u2014",
       absYield: q["absYield"],
       notionalSz: q["notionalSz"],
       notionalCcy: q["notionalCcy"]
@@ -12525,17 +12523,16 @@ 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";
 }
-var THIRD_PARTY_INSTALL_NOTICE = "Note: This skill was created by a third-party developer, not by OKX. Review SKILL.md before use.";
 async function cmdSkillSearch(run, opts) {
   const args = {};
   if (opts.keyword) args.keyword = opts.keyword;
@@ -12585,13 +12582,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...");
@@ -12601,7 +12598,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 {
@@ -12611,7 +12608,11 @@ async function cmdSkillAdd(name, config, json) {
       throw e;
     }
     upsertSkillRecord(meta);
-    printSkillInstallResult(meta, json);
+    if (json) {
+      outputLine(JSON.stringify({ name: meta.name, version: meta.version, status: "installed" }, null, 2));
+    } else {
+      outputLine(`\u2713 Skill "${meta.name}" v${meta.version} installed`);
+    }
   } finally {
     rmSync(tmpBase, { recursive: true, force: true });
   }
@@ -12640,7 +12641,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 {
@@ -12704,19 +12705,11 @@ function cmdSkillList(json) {
   outputLine("");
   outputLine(`${skills.length} skills installed.`);
 }
-function printSkillInstallResult(meta, json) {
-  if (json) {
-    outputLine(JSON.stringify({ name: meta.name, version: meta.version, status: "installed" }, null, 2));
-  } else {
-    outputLine(`\u2713 Skill "${meta.name}" v${meta.version} installed`);
-    outputLine(`  ${THIRD_PARTY_INSTALL_NOTICE}`);
-  }
-}
 
 // src/index.ts
 var _require3 = createRequire3(import.meta.url);
 var CLI_VERSION2 = _require3("../package.json").version;
-var GIT_HASH2 = true ? "ab11ece" : "dev";
+var GIT_HASH2 = true ? "19e8da3" : "dev";
 function handleConfigCommand(action, rest, json, lang, force) {
   if (action === "init") return cmdConfigInit(lang === "zh" ? "zh" : "en");
   if (action === "show") return cmdConfigShow(json);
@@ -12766,20 +12759,18 @@ function handleMarketPublicCommand(run, action, rest, v, json) {
       instId: v.instId,
       json
     });
-  if (action === "indicator") return handleIndicatorAction(run, rest, v, json);
-}
-function handleIndicatorAction(run, rest, v, json) {
-  if (rest[0] === "list") return cmdMarketIndicatorList(json);
-  const limit = v.limit !== void 0 ? Number(v.limit) : void 0;
-  const backtestTime = v["backtest-time"] !== void 0 ? Number(v["backtest-time"]) : void 0;
-  return cmdMarketIndicator(run, rest[0], rest[1], {
-    bar: v.bar,
-    params: v.params,
-    list: v.list,
-    limit,
-    backtestTime,
-    json
-  });
+  if (action === "indicator") {
+    const limit = v.limit !== void 0 ? Number(v.limit) : void 0;
+    const backtestTime = v["backtest-time"] !== void 0 ? Number(v["backtest-time"]) : void 0;
+    return cmdMarketIndicator(run, rest[0], rest[1], {
+      bar: v.bar,
+      params: v.params,
+      list: v.list,
+      limit,
+      backtestTime,
+      json
+    });
+  }
 }
 function handleMarketDataCommand(run, action, rest, v, json) {
   const limit = v.limit !== void 0 ? Number(v.limit) : void 0;
@@ -13125,7 +13116,6 @@ function handleOptionCommand(run, action, rest, v, json) {
       side: v.side,
       ordType: v.ordType,
       sz: v.sz,
-      tgtCcy: v.tgtCcy,
       px: v.px,
       reduceOnly: v.reduceOnly,
       clOrdId: v.clOrdId,
@@ -13534,14 +13524,6 @@ function printHelpForLevel(positionals) {
   else if (!subgroup) printHelp(module);
   else printHelp(module, subgroup);
 }
-async function runDiagnose(v) {
-  let config;
-  try {
-    config = loadProfileConfig({ profile: v.profile, demo: v.demo, live: v.live, verbose: v.verbose, userAgent: `okx-trade-cli/${CLI_VERSION2}`, sourceTag: "CLI" });
-  } catch {
-  }
-  return cmdDiagnose(config, v.profile ?? "default", { mcp: v.mcp, cli: v.cli, all: v.all, output: v.output });
-}
 async function main() {
   setOutput({
     out: (m) => process.stdout.write(m),
@@ -13563,9 +13545,15 @@ async function main() {
   if (module === "config") return handleConfigCommand(action, rest, json, v.lang, v.force);
   if (module === "setup") return handleSetupCommand(v);
   if (module === "upgrade") return cmdUpgrade(CLI_VERSION2, { beta: v.beta, check: v.check, force: v.force }, json);
-  if (module === "diagnose") return runDiagnose(v);
+  if (module === "diagnose") {
+    let config2;
+    try {
+      config2 = loadProfileConfig({ profile: v.profile, demo: v.demo, live: v.live, verbose: v.verbose, userAgent: `okx-trade-cli/${CLI_VERSION2}`, sourceTag: "CLI" });
+    } catch {
+    }
+    return cmdDiagnose(config2, v.profile ?? "default", { mcp: v.mcp, cli: v.cli, all: v.all, output: v.output });
+  }
   const config = loadProfileConfig({ profile: v.profile, demo: v.demo, live: v.live, verbose: v.verbose, userAgent: `okx-trade-cli/${CLI_VERSION2}`, sourceTag: "CLI" });
-  setEnvContext({ demo: config.demo, profile: v.profile ?? "default" });
   const client = new OkxRestClient(config);
   const baseRunner = createToolRunner(client, config);
   const writeToolNames = new Set(allToolSpecs().filter((t) => t.isWrite).map((t) => t.name));