@vultisig/cli 0.15.4 → 0.17.0

package/dist/index.js

@@ -1049,14 +1049,14 @@ var require_main = __commonJS({
           cb = opts;
           opts = {};
         }
-        var qrcode5 = new QRCode(-1, this.error);
-        qrcode5.addData(input);
-        qrcode5.make();
+        var qrcode4 = new QRCode(-1, this.error);
+        qrcode4.addData(input);
+        qrcode4.make();
         var output = "";
         if (opts && opts.small) {
           var BLACK = true, WHITE = false;
-          var moduleCount = qrcode5.getModuleCount();
-          var moduleData = qrcode5.modules.slice();
+          var moduleCount = qrcode4.getModuleCount();
+          var moduleData = qrcode4.modules.slice();
           var oddRow = moduleCount % 2 === 1;
           if (oddRow) {
             moduleData.push(fill(moduleCount, WHITE));
@@ -1089,9 +1089,9 @@ var require_main = __commonJS({
             output += borderBottom;
           }
         } else {
-          var border = repeat(white).times(qrcode5.getModuleCount() + 3);
+          var border = repeat(white).times(qrcode4.getModuleCount() + 3);
           output += border + "\n";
-          qrcode5.modules.forEach(function(row2) {
+          qrcode4.modules.forEach(function(row2) {
             output += white;
             output += row2.map(toCell).join("");
             output += white + "\n";
@@ -1430,7 +1430,7 @@ var init_sha3 = __esm({
   }
 });
 
-// node_modules/viem/_esm/utils/unit/formatUnits.js
+// ../../node_modules/viem/_esm/utils/unit/formatUnits.js
 function formatUnits(value, decimals) {
   let display = value.toString();
   const negative = display.startsWith("-");
@@ -1445,16 +1445,991 @@ function formatUnits(value, decimals) {
   return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
 }
 var init_formatUnits = __esm({
-  "node_modules/viem/_esm/utils/unit/formatUnits.js"() {
+  "../../node_modules/viem/_esm/utils/unit/formatUnits.js"() {
+  }
+});
+
+// ../../packages/lib/utils/dist/promise/isPromise.js
+function isPromise(value) {
+  return !!value && typeof value.then === "function";
+}
+var init_isPromise = __esm({
+  "../../packages/lib/utils/dist/promise/isPromise.js"() {
+  }
+});
+
+// ../../packages/lib/utils/dist/attempt.js
+function attempt(input) {
+  if (typeof input === "function") {
+    try {
+      const result = input();
+      if (isPromise(result)) {
+        return attempt(result);
+      }
+      return { data: result };
+    } catch (error2) {
+      return { error: error2 };
+    }
+  } else {
+    return input.then((data) => ({ data }), (error2) => ({ error: error2 }));
+  }
+}
+function withFallback(result, fallback) {
+  if (isPromise(result)) {
+    return result.then((res) => {
+      if ("error" in res) {
+        return fallback;
+      }
+      return res.data;
+    });
+  }
+  if ("error" in result) {
+    return fallback;
+  }
+  return result.data;
+}
+var init_attempt = __esm({
+  "../../packages/lib/utils/dist/attempt.js"() {
+    init_isPromise();
+  }
+});
+
+// ../../packages/lib/utils/dist/error/extractErrorMsg/index.js
+var extractErrorMsg;
+var init_extractErrorMsg = __esm({
+  "../../packages/lib/utils/dist/error/extractErrorMsg/index.js"() {
+    init_attempt();
+    extractErrorMsg = (err) => {
+      if (typeof err === "string") {
+        return err;
+      }
+      if (typeof err === "number" || typeof err === "boolean") {
+        return String(err);
+      }
+      if (typeof err === "object" && err && "message" in err) {
+        return extractErrorMsg(err.message);
+      }
+      return withFallback(attempt(() => JSON.stringify(err)), "Unknown Error");
+    };
+  }
+});
+
+// ../../packages/lib/utils/dist/array/isEmpty/index.js
+var isEmpty;
+var init_isEmpty = __esm({
+  "../../packages/lib/utils/dist/array/isEmpty/index.js"() {
+    isEmpty = (items) => items.length === 0;
+  }
+});
+
+// ../../packages/lib/utils/dist/promise/asyncFallbackChain/index.js
+var asyncFallbackChain;
+var init_asyncFallbackChain = __esm({
+  "../../packages/lib/utils/dist/promise/asyncFallbackChain/index.js"() {
+    init_isEmpty();
+    asyncFallbackChain = async (...functions) => {
+      if (isEmpty(functions)) {
+        throw new Error("No functions provided");
+      }
+      try {
+        const result = await functions[0]();
+        return result;
+      } catch (error2) {
+        if (functions.length <= 1) {
+          throw error2;
+        }
+        return asyncFallbackChain(...functions.slice(1));
+      }
+    };
+  }
+});
+
+// ../../packages/lib/utils/dist/fetch/HttpResponseError.js
+var HttpResponseError;
+var init_HttpResponseError = __esm({
+  "../../packages/lib/utils/dist/fetch/HttpResponseError.js"() {
+    HttpResponseError = class extends Error {
+      status;
+      statusText;
+      url;
+      body;
+      constructor(opts) {
+        super(opts.message);
+        this.name = "HttpResponseError";
+        this.status = opts.status;
+        this.statusText = opts.statusText;
+        this.url = opts.url;
+        this.body = opts.body;
+      }
+    };
+  }
+});
+
+// ../../packages/lib/utils/dist/fetch/assertFetchResponse.js
+var assertFetchResponse;
+var init_assertFetchResponse = __esm({
+  "../../packages/lib/utils/dist/fetch/assertFetchResponse.js"() {
+    init_extractErrorMsg();
+    init_asyncFallbackChain();
+    init_HttpResponseError();
+    assertFetchResponse = async (response) => {
+      if (!response.ok) {
+        const body = await asyncFallbackChain(async () => response.json(), async () => response.text(), async () => `HTTP ${response.status} ${response.statusText || "Error"}: Request failed for ${response.url}`);
+        const msg = extractErrorMsg(body);
+        throw new HttpResponseError({
+          message: msg,
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          body
+        });
+      }
+    };
+  }
+});
+
+// ../../packages/lib/utils/dist/record/getRecordKeys/index.js
+var getRecordKeys;
+var init_getRecordKeys = __esm({
+  "../../packages/lib/utils/dist/record/getRecordKeys/index.js"() {
+    getRecordKeys = (record) => {
+      return Object.keys(record);
+    };
+  }
+});
+
+// ../../packages/lib/utils/dist/record/withoutUndefinedFields.js
+function withoutUndefinedFields(record) {
+  const result = {};
+  getRecordKeys(record).forEach((key) => {
+    const typedKey = key;
+    const value = record[typedKey];
+    if (value !== void 0) {
+      result[typedKey] = value;
+    }
+  });
+  return result;
+}
+var init_withoutUndefinedFields = __esm({
+  "../../packages/lib/utils/dist/record/withoutUndefinedFields.js"() {
+    init_getRecordKeys();
+  }
+});
+
+// ../../packages/lib/utils/dist/query/queryUrl.js
+async function queryUrl(url, options = {}) {
+  const { responseType = "json", body, headers, method } = options;
+  const response = await fetch(url, withoutUndefinedFields({
+    method: method ?? (body ? "POST" : "GET"),
+    headers: withoutUndefinedFields({
+      ...headers,
+      "Content-Type": body ? "application/json" : void 0
+    }),
+    body: processBody(body)
+  }));
+  await assertFetchResponse(response);
+  if (responseType !== "none") {
+    return response[responseType]();
+  }
+}
+var processBody;
+var init_queryUrl = __esm({
+  "../../packages/lib/utils/dist/query/queryUrl.js"() {
+    init_assertFetchResponse();
+    init_withoutUndefinedFields();
+    processBody = (body) => {
+      if (body === void 0) {
+        return void 0;
+      }
+      if (typeof body === "string") {
+        return body;
+      }
+      return JSON.stringify(body);
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/pools.js
+var thorchainMidgardBaseUrl, POOL_ID_RE, assertValidPoolId, isValidPoolId, normalizePool, getThorchainPools;
+var init_pools = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/pools.js"() {
+    init_queryUrl();
+    thorchainMidgardBaseUrl = "https://midgard.ninerealms.com";
+    POOL_ID_RE = /^[A-Z0-9]+\.[A-Z0-9]+(-[A-Z0-9]+)?$/;
+    assertValidPoolId = (pool) => {
+      if (typeof pool !== "string" || pool.length === 0) {
+        throw new Error(`assertValidPoolId: pool id must be a non-empty string, got ${typeof pool} ${pool === "" ? '""' : ""}`);
+      }
+      if (!POOL_ID_RE.test(pool)) {
+        throw new Error(`assertValidPoolId: ${JSON.stringify(pool)} is not a valid THORChain pool id. Expected uppercase CHAIN.ASSET (e.g. "BTC.BTC") or CHAIN.ASSET-CONTRACT (e.g. "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48").`);
+      }
+    };
+    isValidPoolId = (pool) => {
+      if (typeof pool !== "string" || pool.length === 0)
+        return false;
+      return POOL_ID_RE.test(pool);
+    };
+    normalizePool = (raw) => ({
+      asset: raw.asset ?? "",
+      status: raw.status ?? "",
+      assetDepth: raw.assetDepth ?? "0",
+      runeDepth: raw.runeDepth ?? "0",
+      liquidityUnits: raw.liquidityUnits ?? "0",
+      volume24h: raw.volume24h ?? "0",
+      annualPercentageRate: raw.annualPercentageRate ?? "0"
+    });
+    getThorchainPools = async (options = {}) => {
+      const status = options.status === void 0 ? "available" : options.status;
+      const url = status === null ? `${thorchainMidgardBaseUrl}/v2/pools` : `${thorchainMidgardBaseUrl}/v2/pools?status=${encodeURIComponent(status)}`;
+      const raw = await queryUrl(url);
+      if (!Array.isArray(raw)) {
+        throw new Error(`getThorchainPools: expected an array from ${url}, got ${typeof raw}`);
+      }
+      return raw.map(normalizePool);
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/memo.js
+var assertMemoSegmentSafe, addLpMemo, removeLpMemo;
+var init_memo = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/memo.js"() {
+    init_pools();
+    assertMemoSegmentSafe = (value, fieldName) => {
+      if (typeof value !== "string") {
+        throw new Error(`${fieldName} must be a string, got ${typeof value}`);
+      }
+      if (value.includes(":")) {
+        throw new Error(`${fieldName} must not contain \`:\` (would inject extra memo segments), got ${JSON.stringify(value)}`);
+      }
+      if (/\s/.test(value)) {
+        throw new Error(`${fieldName} must not contain whitespace, got ${JSON.stringify(value)}`);
+      }
+    };
+    addLpMemo = ({ pool, pairedAddress }) => {
+      assertValidPoolId(pool);
+      if (pairedAddress && pairedAddress.length > 0) {
+        assertMemoSegmentSafe(pairedAddress, "pairedAddress");
+        return `+:${pool}:${pairedAddress}`;
+      }
+      return `+:${pool}`;
+    };
+    removeLpMemo = ({ pool, basisPoints, withdrawToAsset }) => {
+      assertValidPoolId(pool);
+      if (!Number.isInteger(basisPoints) || basisPoints < 1 || basisPoints > 1e4) {
+        throw new Error(`removeLpMemo: basisPoints must be an integer in [1, 10000], got ${basisPoints}`);
+      }
+      if (withdrawToAsset && withdrawToAsset.length > 0) {
+        assertMemoSegmentSafe(withdrawToAsset, "withdrawToAsset");
+        return `-:${pool}:${basisPoints}:${withdrawToAsset}`;
+      }
+      return `-:${pool}:${basisPoints}`;
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/payload.js
+var LP_REMOVE_DUST_RUNE_BASE_UNITS, isPositiveBaseUnitString, buildThorchainLpAddPayload, buildThorchainLpRemovePayload;
+var init_payload = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/payload.js"() {
+    init_memo();
+    LP_REMOVE_DUST_RUNE_BASE_UNITS = "2000000";
+    isPositiveBaseUnitString = (value) => /^\d+$/.test(value) && BigInt(value) > 0n;
+    buildThorchainLpAddPayload = ({ pool, amountRuneBaseUnits, pairedAddress }) => {
+      if (!isPositiveBaseUnitString(amountRuneBaseUnits)) {
+        throw new Error(`buildThorchainLpAddPayload: amountRuneBaseUnits must be a positive integer string, got ${amountRuneBaseUnits}`);
+      }
+      const memo = addLpMemo({ pool, pairedAddress });
+      return {
+        kind: "thorchain_lp_add",
+        chain: "THORChain",
+        denom: "rune",
+        amount: amountRuneBaseUnits,
+        memo,
+        pool,
+        ...pairedAddress ? { pairedAddress } : {}
+      };
+    };
+    buildThorchainLpRemovePayload = ({ pool, basisPoints, withdrawToAsset }) => {
+      if (!Number.isInteger(basisPoints) || basisPoints < 1 || basisPoints > 1e4) {
+        throw new Error(`buildThorchainLpRemovePayload: basisPoints must be an integer in [1, 10000], got ${basisPoints}`);
+      }
+      const memo = removeLpMemo({ pool, basisPoints, withdrawToAsset });
+      return {
+        kind: "thorchain_lp_remove",
+        chain: "THORChain",
+        denom: "rune",
+        amount: LP_REMOVE_DUST_RUNE_BASE_UNITS,
+        memo,
+        pool,
+        basisPoints,
+        ...withdrawToAsset ? { withdrawToAsset } : {}
+      };
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/Chain.js
+var EthereumL2Chain, EvmChain, UtxoChain, cosmosChainsByKind, IbcEnabledCosmosChain, VaultBasedCosmosChain, CosmosChain, OtherChain, Chain9, UtxoBasedChain, defaultChains;
+var init_Chain = __esm({
+  "../../packages/core/chain/dist/Chain.js"() {
+    EthereumL2Chain = {
+      Arbitrum: "Arbitrum",
+      Base: "Base",
+      Blast: "Blast",
+      Optimism: "Optimism",
+      Zksync: "Zksync",
+      Mantle: "Mantle"
+    };
+    EvmChain = {
+      ...EthereumL2Chain,
+      Avalanche: "Avalanche",
+      CronosChain: "CronosChain",
+      BSC: "BSC",
+      Ethereum: "Ethereum",
+      Polygon: "Polygon",
+      Hyperliquid: "Hyperliquid",
+      Sei: "Sei"
+    };
+    (function(UtxoChain2) {
+      UtxoChain2["Bitcoin"] = "Bitcoin";
+      UtxoChain2["BitcoinCash"] = "Bitcoin-Cash";
+      UtxoChain2["Litecoin"] = "Litecoin";
+      UtxoChain2["Dogecoin"] = "Dogecoin";
+      UtxoChain2["Dash"] = "Dash";
+      UtxoChain2["Zcash"] = "Zcash";
+    })(UtxoChain || (UtxoChain = {}));
+    cosmosChainsByKind = {
+      ibcEnabled: {
+        Cosmos: "Cosmos",
+        Osmosis: "Osmosis",
+        Dydx: "Dydx",
+        Kujira: "Kujira",
+        Terra: "Terra",
+        TerraClassic: "TerraClassic",
+        Noble: "Noble",
+        Akash: "Akash"
+      },
+      vaultBased: {
+        THORChain: "THORChain",
+        MayaChain: "MayaChain"
+      }
+    };
+    IbcEnabledCosmosChain = cosmosChainsByKind.ibcEnabled;
+    VaultBasedCosmosChain = cosmosChainsByKind.vaultBased;
+    CosmosChain = {
+      ...IbcEnabledCosmosChain,
+      ...VaultBasedCosmosChain
+    };
+    (function(OtherChain2) {
+      OtherChain2["Sui"] = "Sui";
+      OtherChain2["Solana"] = "Solana";
+      OtherChain2["Polkadot"] = "Polkadot";
+      OtherChain2["Bittensor"] = "Bittensor";
+      OtherChain2["Ton"] = "Ton";
+      OtherChain2["Ripple"] = "Ripple";
+      OtherChain2["Tron"] = "Tron";
+      OtherChain2["Cardano"] = "Cardano";
+      OtherChain2["QBTC"] = "QBTC";
+    })(OtherChain || (OtherChain = {}));
+    Chain9 = {
+      ...EvmChain,
+      ...UtxoChain,
+      ...CosmosChain,
+      ...OtherChain
+    };
+    UtxoBasedChain = [
+      ...Object.values(UtxoChain),
+      OtherChain.Cardano
+    ];
+    defaultChains = [
+      Chain9.Bitcoin,
+      Chain9.Ethereum,
+      Chain9.THORChain,
+      Chain9.Solana,
+      Chain9.BSC
+    ];
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/cosmosRpcUrl.js
+var cosmosRpcUrl;
+var init_cosmosRpcUrl = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/cosmosRpcUrl.js"() {
+    cosmosRpcUrl = {
+      Cosmos: "https://cosmos-rest.publicnode.com",
+      Osmosis: "https://osmosis-rest.publicnode.com",
+      Dydx: "https://dydx-rest.publicnode.com",
+      Kujira: "https://kujira-rest.publicnode.com",
+      Terra: "https://terra-lcd.publicnode.com",
+      TerraClassic: "https://terra-classic-lcd.publicnode.com",
+      Noble: "https://noble-api.polkachu.com",
+      THORChain: "https://thornode.thorchain.network",
+      MayaChain: "https://mayanode.mayachain.info",
+      Akash: "https://akash-rest.publicnode.com"
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/memberPool.js
+var isNonZeroBaseUnit, normalizeMemberPool;
+var init_memberPool = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/memberPool.js"() {
+    isNonZeroBaseUnit = (value) => {
+      if (!value)
+        return false;
+      try {
+        return BigInt(value) > 0n;
+      } catch {
+        return false;
+      }
+    };
+    normalizeMemberPool = (raw) => ({
+      pool: raw.pool ?? "",
+      liquidityUnits: raw.liquidityUnits ?? "0",
+      runeAdded: raw.runeAdded ?? "0",
+      assetAdded: raw.assetAdded ?? "0",
+      runePending: raw.runePending ?? "0",
+      assetPending: raw.assetPending ?? "0",
+      runeAddress: raw.runeAddress ?? "",
+      assetAddress: raw.assetAddress ?? "",
+      dateLastAdded: raw.dateLastAdded ?? "0",
+      lastAddHeight: "",
+      isPending: isNonZeroBaseUnit(raw.runePending) || isNonZeroBaseUnit(raw.assetPending)
+    });
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/position.js
+var isMidgardNotFoundError, getThorchainLpPosition, getThorchainLpPositionFromThornode;
+var init_position = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/position.js"() {
+    init_Chain();
+    init_cosmosRpcUrl();
+    init_HttpResponseError();
+    init_queryUrl();
+    init_memberPool();
+    init_pools();
+    isMidgardNotFoundError = (err) => err instanceof HttpResponseError && err.status === 404;
+    getThorchainLpPosition = async ({ thorAddress, pool }) => {
+      assertValidPoolId(pool);
+      const url = `${thorchainMidgardBaseUrl}/v2/member/${encodeURIComponent(thorAddress)}`;
+      let midgardNotFound = false;
+      let raw = {};
+      try {
+        raw = await queryUrl(url);
+      } catch (err) {
+        if (isMidgardNotFoundError(err)) {
+          midgardNotFound = true;
+        } else {
+          throw err;
+        }
+      }
+      if (!midgardNotFound) {
+        const pools = Array.isArray(raw.pools) ? raw.pools : [];
+        const found = pools.find((p) => p.pool === pool);
+        if (found)
+          return normalizeMemberPool(found);
+      }
+      return getThorchainLpPositionFromThornode({ thorAddress, pool });
+    };
+    getThorchainLpPositionFromThornode = async ({ thorAddress, pool }) => {
+      assertValidPoolId(pool);
+      const url = `${cosmosRpcUrl[Chain9.THORChain]}/thorchain/pool/${encodeURIComponent(pool)}/liquidity_provider/${encodeURIComponent(thorAddress)}`;
+      let raw;
+      try {
+        raw = await queryUrl(url);
+      } catch (err) {
+        if (err instanceof HttpResponseError && err.status === 404)
+          return null;
+        throw err;
+      }
+      const units = raw.units ?? "0";
+      const pendingRune = raw.pending_rune ?? "0";
+      const pendingAsset = raw.pending_asset ?? "0";
+      if (!isNonZeroBaseUnit(units) && !isNonZeroBaseUnit(pendingRune) && !isNonZeroBaseUnit(pendingAsset)) {
+        return null;
+      }
+      return {
+        pool: raw.asset ?? pool,
+        liquidityUnits: units,
+        // Thornode doesn't track historical added amounts — those are a
+        // Midgard-only enrichment. Surface them as 0; the caller can still
+        // act on units/pending.
+        runeAdded: "0",
+        assetAdded: "0",
+        runePending: pendingRune,
+        assetPending: pendingAsset,
+        runeAddress: raw.rune_address ?? thorAddress,
+        assetAddress: raw.asset_address ?? "",
+        // Thornode exposes the last-add block height, not a Unix timestamp.
+        // Keep `dateLastAdded` semantically Unix-seconds-or-0 and expose the
+        // block height via the dedicated `lastAddHeight` field so lockup
+        // checks can use either source.
+        dateLastAdded: "0",
+        lastAddHeight: typeof raw.last_add_height === "number" ? String(raw.last_add_height) : "",
+        isPending: isNonZeroBaseUnit(pendingRune) || isNonZeroBaseUnit(pendingAsset)
+      };
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/validation.js
+var extractPoolStatus, poolPauseMimirKey, getThorchainMimir, assertPoolDepositable;
+var init_validation = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/validation.js"() {
+    init_Chain();
+    init_cosmosRpcUrl();
+    init_queryUrl();
+    init_pools();
+    extractPoolStatus = (raw) => {
+      if (raw && typeof raw === "object" && "status" in raw) {
+        const status = raw.status;
+        return typeof status === "string" ? status : void 0;
+      }
+      return void 0;
+    };
+    poolPauseMimirKey = (pool) => {
+      const dotIdx = pool.indexOf(".");
+      if (dotIdx <= 0 || dotIdx >= pool.length - 1) {
+        throw new Error(`poolPauseMimirKey: invalid pool id ${pool}`);
+      }
+      const chain = pool.slice(0, dotIdx);
+      const asset = pool.slice(dotIdx + 1);
+      return `PAUSELPDEPOSIT-${chain}-${asset}`;
+    };
+    getThorchainMimir = async () => {
+      const url = `${cosmosRpcUrl[Chain9.THORChain]}/thorchain/mimir`;
+      const raw = await queryUrl(url);
+      if (!raw || typeof raw !== "object") {
+        throw new Error(`getThorchainMimir: unexpected response shape from ${url}`);
+      }
+      const out = {};
+      for (const [k, v] of Object.entries(raw)) {
+        if (typeof v === "number" && Number.isFinite(v)) {
+          out[k] = v;
+        } else if (typeof v === "string" && /^-?\d+$/.test(v)) {
+          out[k] = Number(v);
+        }
+      }
+      return out;
+    };
+    assertPoolDepositable = async (pool) => {
+      assertValidPoolId(pool);
+      const [poolRaw, mimir] = await Promise.all([
+        queryUrl(`${cosmosRpcUrl[Chain9.THORChain]}/thorchain/pool/${encodeURIComponent(pool)}`),
+        getThorchainMimir()
+      ]);
+      const status = extractPoolStatus(poolRaw);
+      if (status === void 0) {
+        throw new Error(`assertPoolDepositable: pool ${pool} response from thornode did not include a string \`status\` field`);
+      }
+      if (status !== "Available") {
+        throw new Error(`assertPoolDepositable: pool ${pool} status is ${status}, must be Available for LP add`);
+      }
+      const pauseKey = poolPauseMimirKey(pool);
+      const pauseValue = mimir[pauseKey];
+      if (typeof pauseValue === "number" && pauseValue > 0) {
+        throw new Error(`assertPoolDepositable: pool ${pool} has LP deposits paused on-chain via mimir ${pauseKey}=${pauseValue}. THORChain validators have disabled new adds for this pool; any tx would be rejected at handler execution time.`);
+      }
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/thorchainLp.js
+var thorchainLpChainCode;
+var init_thorchainLp = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/thorchainLp.js"() {
+    init_Chain();
+    thorchainLpChainCode = {
+      [Chain9.Avalanche]: "AVAX",
+      [Chain9.Base]: "BASE",
+      [Chain9.BitcoinCash]: "BCH",
+      [Chain9.BSC]: "BSC",
+      [Chain9.Bitcoin]: "BTC",
+      [Chain9.Dash]: "DASH",
+      [Chain9.Dogecoin]: "DOGE",
+      [Chain9.Ethereum]: "ETH",
+      [Chain9.Cosmos]: "GAIA",
+      [Chain9.Kujira]: "KUJI",
+      [Chain9.Litecoin]: "LTC",
+      [Chain9.THORChain]: "THOR",
+      [Chain9.Tron]: "TRON",
+      [Chain9.Ripple]: "XRP",
+      [Chain9.Arbitrum]: "ARB",
+      [Chain9.Zcash]: "ZEC"
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/lpChainMap.js
+var lpChainMap, chainPrefixToChain, chainToLpPrefix;
+var init_lpChainMap = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/lpChainMap.js"() {
+    init_thorchainLp();
+    lpChainMap = Object.freeze(Object.entries(thorchainLpChainCode).reduce((acc, [chainKey, prefix]) => {
+      if (prefix) {
+        acc[prefix] = chainKey;
+      }
+      return acc;
+    }, {}));
+    chainPrefixToChain = (prefix) => lpChainMap[prefix.toUpperCase()];
+    chainToLpPrefix = (chain) => thorchainLpChainCode[chain];
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/pairing.js
+var resolvePairedAddressForLpAdd;
+var init_pairing = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/pairing.js"() {
+    init_Chain();
+    init_lpChainMap();
+    init_pools();
+    resolvePairedAddressForLpAdd = ({ pool, side, vaultAddresses }) => {
+      assertValidPoolId(pool);
+      const [chainPrefix] = pool.split(".");
+      if (!chainPrefix)
+        return void 0;
+      const assetChain = chainPrefixToChain(chainPrefix);
+      if (!assetChain)
+        return void 0;
+      if (side === "asset") {
+        return vaultAddresses[Chain9.THORChain];
+      }
+      return vaultAddresses[assetChain];
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/math.js
+var assertBaseUnitString, getLiquidityUnits, getPoolShare, getLpAddSlippage, estimateLpAdd;
+var init_math = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/math.js"() {
+    init_Chain();
+    init_cosmosRpcUrl();
+    init_queryUrl();
+    init_pools();
+    assertBaseUnitString = (value, fieldName) => {
+      if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${fieldName} must be a non-empty base-unit string, got ${typeof value === "string" ? JSON.stringify(value) : typeof value}`);
+      }
+      if (!/^\d+$/.test(value)) {
+        throw new Error(`${fieldName} must be a non-negative integer base-unit string, got ${JSON.stringify(value)}`);
+      }
+      return BigInt(value);
+    };
+    getLiquidityUnits = ({ pool, assetAmountBaseUnit, runeAmountBaseUnit }) => {
+      const P = assertBaseUnitString(pool.poolUnits, "pool.poolUnits");
+      const R = assertBaseUnitString(pool.runeDepth, "pool.runeDepth");
+      const A = assertBaseUnitString(pool.assetDepth, "pool.assetDepth");
+      const r = assertBaseUnitString(runeAmountBaseUnit, "runeAmountBaseUnit");
+      const a = assertBaseUnitString(assetAmountBaseUnit, "assetAmountBaseUnit");
+      if (R === 0n || A === 0n || P === 0n) {
+        return "0";
+      }
+      const numerator = P * (R * a + r * A);
+      const denominator = 2n * R * A;
+      return (numerator / denominator).toString();
+    };
+    getPoolShare = ({ pool, liquidityUnits }) => {
+      const P = assertBaseUnitString(pool.poolUnits, "pool.poolUnits");
+      const L = assertBaseUnitString(liquidityUnits, "liquidityUnits");
+      if (P === 0n || L === 0n) {
+        return { poolShareDecimal: "0" };
+      }
+      const totalAfter = P + L;
+      const SCALE = 10n ** 18n;
+      const scaled = L * SCALE / totalAfter;
+      const decimal = scaled.toString().padStart(19, "0");
+      const intPart = decimal.slice(0, -18) || "0";
+      const fracPart = decimal.slice(-18).replace(/0+$/, "");
+      return {
+        poolShareDecimal: fracPart.length > 0 ? `${intPart}.${fracPart}` : intPart
+      };
+    };
+    getLpAddSlippage = ({ pool, assetAmountBaseUnit, runeAmountBaseUnit }) => {
+      const R = assertBaseUnitString(pool.runeDepth, "pool.runeDepth");
+      const A = assertBaseUnitString(pool.assetDepth, "pool.assetDepth");
+      const r = assertBaseUnitString(runeAmountBaseUnit, "runeAmountBaseUnit");
+      const a = assertBaseUnitString(assetAmountBaseUnit, "assetAmountBaseUnit");
+      if (R === 0n || A === 0n) {
+        return { decimalPercent: "0", slippageInRuneBaseUnit: "0" };
+      }
+      const ra = R * a;
+      const ar = A * r;
+      const numerator = ra > ar ? ra - ar : ar - ra;
+      const denominator = A * r + R * A;
+      if (denominator === 0n) {
+        return { decimalPercent: "0", slippageInRuneBaseUnit: "0" };
+      }
+      const SCALE = 10n ** 18n;
+      const scaled = numerator * SCALE / denominator;
+      const decimal = scaled.toString().padStart(19, "0");
+      const intPart = decimal.slice(0, -18) || "0";
+      const fracPart = decimal.slice(-18).replace(/0+$/, "");
+      const decimalPercent = fracPart.length > 0 ? `${intPart}.${fracPart}` : intPart;
+      const imbalanceNumerator = ra > ar ? ra - ar : ar - ra;
+      const imbalanceInRune = A === 0n ? 0n : imbalanceNumerator / (2n * A);
+      const slippageInRune = imbalanceInRune * scaled / SCALE;
+      return {
+        decimalPercent,
+        slippageInRuneBaseUnit: slippageInRune.toString()
+      };
+    };
+    estimateLpAdd = async ({ pool, assetAmountBaseUnit, runeAmountBaseUnit, thornodeBaseUrl }) => {
+      assertValidPoolId(pool);
+      const base = thornodeBaseUrl ?? cosmosRpcUrl[Chain9.THORChain];
+      const url = `${base}/thorchain/pool/${encodeURIComponent(pool)}`;
+      const raw = await queryUrl(url);
+      if (!raw || typeof raw !== "object" || typeof raw.balance_asset !== "string" || typeof raw.balance_rune !== "string") {
+        throw new Error(`estimateLpAdd: pool ${pool} response from ${url} missing balance fields`);
+      }
+      const poolUnitsRaw = raw.pool_units ?? raw.LP_units;
+      if (typeof poolUnitsRaw !== "string" || poolUnitsRaw.length === 0) {
+        throw new Error(`estimateLpAdd: pool ${pool} response from ${url} missing pool_units / LP_units`);
+      }
+      const poolState = {
+        assetDepth: raw.balance_asset,
+        runeDepth: raw.balance_rune,
+        poolUnits: poolUnitsRaw
+      };
+      const liquidityUnits = getLiquidityUnits({
+        pool: poolState,
+        assetAmountBaseUnit,
+        runeAmountBaseUnit
+      });
+      const share = getPoolShare({
+        pool: poolState,
+        liquidityUnits
+      });
+      const slip = getLpAddSlippage({
+        pool: poolState,
+        assetAmountBaseUnit,
+        runeAmountBaseUnit
+      });
+      const R = BigInt(poolState.runeDepth);
+      const A = BigInt(poolState.assetDepth);
+      const P = BigInt(poolState.poolUnits);
+      const r = BigInt(runeAmountBaseUnit);
+      const a = BigInt(assetAmountBaseUnit);
+      const L = BigInt(liquidityUnits);
+      const totalAfter = P + L;
+      const runeDepthAfter = R + r;
+      const assetDepthAfter = A + a;
+      const runeShareBaseUnit = totalAfter === 0n ? "0" : (runeDepthAfter * L / totalAfter).toString();
+      const assetShareBaseUnit = totalAfter === 0n ? "0" : (assetDepthAfter * L / totalAfter).toString();
+      return {
+        liquidityUnits,
+        poolShareDecimal: share.poolShareDecimal,
+        runeShareBaseUnit,
+        assetShareBaseUnit,
+        slippageDecimal: slip.decimalPercent,
+        slippageRuneBaseUnit: slip.slippageInRuneBaseUnit
+      };
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/positions.js
+var getThorchainLpPositions;
+var init_positions = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/positions.js"() {
+    init_HttpResponseError();
+    init_queryUrl();
+    init_memberPool();
+    init_pools();
+    getThorchainLpPositions = async ({ thorAddress }) => {
+      const url = `${thorchainMidgardBaseUrl}/v2/member/${encodeURIComponent(thorAddress)}`;
+      let raw;
+      try {
+        raw = await queryUrl(url);
+      } catch (err) {
+        if (err instanceof HttpResponseError && err.status === 404)
+          return [];
+        throw err;
+      }
+      if (!raw || typeof raw !== "object") {
+        throw new Error(`getThorchainLpPositions: unexpected Midgard response shape from ${url}`);
+      }
+      if (raw.pools === void 0) {
+        return [];
+      }
+      if (!Array.isArray(raw.pools)) {
+        throw new Error(`getThorchainLpPositions: Midgard response ${url} has non-array \`pools\` field`);
+      }
+      return raw.pools.map(normalizeMemberPool);
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/lockup.js
+var THORCHAIN_BLOCK_TIME_SECONDS, getThorchainLpLockupSeconds, getLpWithdrawReadiness;
+var init_lockup = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/lockup.js"() {
+    init_validation();
+    THORCHAIN_BLOCK_TIME_SECONDS = 6;
+    getThorchainLpLockupSeconds = async () => {
+      const mimir = await getThorchainMimir();
+      const blocks = mimir["LIQUIDITYLOCKUPBLOCKS"];
+      if (typeof blocks !== "number" || !Number.isFinite(blocks) || blocks < 0) {
+        throw new Error(`getThorchainLpLockupSeconds: mimir did not include a valid LIQUIDITYLOCKUPBLOCKS value`);
+      }
+      return blocks * THORCHAIN_BLOCK_TIME_SECONDS;
+    };
+    getLpWithdrawReadiness = async ({ position, lockupSeconds: providedLockupSeconds, nowUnix = Math.floor(Date.now() / 1e3) }) => {
+      const lockupSeconds = providedLockupSeconds ?? await getThorchainLpLockupSeconds();
+      const lastAdded = Number(position.dateLastAdded);
+      if (!Number.isFinite(lastAdded) || lastAdded <= 0) {
+        return {
+          isWithdrawable: true,
+          unlockAtUnix: 0,
+          remainingSeconds: 0
+        };
+      }
+      const unlockAtUnix = lastAdded + lockupSeconds;
+      const remainingSeconds = Math.max(unlockAtUnix - nowUnix, 0);
+      return {
+        isWithdrawable: remainingSeconds === 0,
+        unlockAtUnix,
+        remainingSeconds
+      };
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/getThorchainInboundAddress.js
+var getThorchainInboundAddress_exports = {};
+__export(getThorchainInboundAddress_exports, {
+  getThorchainInboundAddress: () => getThorchainInboundAddress
+});
+var thorchainInboundAddressApi, getThorchainInboundAddress;
+var init_getThorchainInboundAddress = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/getThorchainInboundAddress.js"() {
+    init_queryUrl();
+    init_Chain();
+    init_cosmosRpcUrl();
+    thorchainInboundAddressApi = `${cosmosRpcUrl[Chain9.THORChain]}/thorchain/inbound_addresses`;
+    getThorchainInboundAddress = () => queryUrl(thorchainInboundAddressApi);
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/halts.js
+var buildStatus, getThorchainLpHaltStatusAll, getThorchainLpHaltStatus, getThorchainLpPoolPauseStatus;
+var init_halts = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/halts.js"() {
+    init_getThorchainInboundAddress();
+    init_validation();
+    buildStatus = (raw) => {
+      const reasons = [];
+      if (raw.halted)
+        reasons.push(`${raw.chain} chain is halted`);
+      if (raw.global_trading_paused)
+        reasons.push("global trading paused");
+      if (raw.chain_trading_paused)
+        reasons.push(`${raw.chain} chain trading paused`);
+      if (raw.chain_lp_actions_paused)
+        reasons.push(`${raw.chain} LP actions paused`);
+      const depositable = !raw.halted && !raw.chain_lp_actions_paused && !raw.chain_trading_paused && !raw.global_trading_paused;
+      const withdrawable = !raw.halted && !raw.chain_lp_actions_paused;
+      return {
+        chain: raw.chain,
+        depositable,
+        withdrawable,
+        reasons,
+        raw: {
+          halted: raw.halted,
+          chain_trading_paused: raw.chain_trading_paused,
+          chain_lp_actions_paused: raw.chain_lp_actions_paused,
+          global_trading_paused: raw.global_trading_paused
+        }
+      };
+    };
+    getThorchainLpHaltStatusAll = async () => {
+      const addresses = await getThorchainInboundAddress();
+      return addresses.map((a) => buildStatus({
+        chain: a.chain,
+        halted: a.halted,
+        chain_trading_paused: a.chain_trading_paused,
+        chain_lp_actions_paused: a.chain_lp_actions_paused,
+        global_trading_paused: a.global_trading_paused
+      }));
+    };
+    getThorchainLpHaltStatus = async (chain) => {
+      const all = await getThorchainLpHaltStatusAll();
+      const upper = chain.toUpperCase();
+      const match = all.find((s) => s.chain.toUpperCase() === upper);
+      if (!match) {
+        throw new Error(`getThorchainLpHaltStatus: chain ${chain} not found in inbound_addresses`);
+      }
+      return match;
+    };
+    getThorchainLpPoolPauseStatus = async (pool) => {
+      const mimir = await getThorchainMimir();
+      const mimirKey = poolPauseMimirKey(pool);
+      const mimirValue = mimir[mimirKey];
+      if (typeof mimirValue === "number" && mimirValue > 0) {
+        return { paused: true, mimirKey, mimirValue };
+      }
+      return { paused: false };
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/index.js
+var lp_exports = {};
+__export(lp_exports, {
+  THORCHAIN_BLOCK_TIME_SECONDS: () => THORCHAIN_BLOCK_TIME_SECONDS,
+  addLpMemo: () => addLpMemo,
+  assertPoolDepositable: () => assertPoolDepositable,
+  assertValidPoolId: () => assertValidPoolId,
+  buildThorchainLpAddPayload: () => buildThorchainLpAddPayload,
+  buildThorchainLpRemovePayload: () => buildThorchainLpRemovePayload,
+  chainPrefixToChain: () => chainPrefixToChain,
+  chainToLpPrefix: () => chainToLpPrefix,
+  estimateLpAdd: () => estimateLpAdd,
+  getLiquidityUnits: () => getLiquidityUnits,
+  getLpAddSlippage: () => getLpAddSlippage,
+  getLpWithdrawReadiness: () => getLpWithdrawReadiness,
+  getPoolShare: () => getPoolShare,
+  getThorchainLpHaltStatus: () => getThorchainLpHaltStatus,
+  getThorchainLpHaltStatusAll: () => getThorchainLpHaltStatusAll,
+  getThorchainLpLockupSeconds: () => getThorchainLpLockupSeconds,
+  getThorchainLpPoolPauseStatus: () => getThorchainLpPoolPauseStatus,
+  getThorchainLpPosition: () => getThorchainLpPosition,
+  getThorchainLpPositionFromThornode: () => getThorchainLpPositionFromThornode,
+  getThorchainLpPositions: () => getThorchainLpPositions,
+  getThorchainMimir: () => getThorchainMimir,
+  getThorchainPools: () => getThorchainPools,
+  isValidPoolId: () => isValidPoolId,
+  lpChainMap: () => lpChainMap,
+  poolPauseMimirKey: () => poolPauseMimirKey,
+  removeLpMemo: () => removeLpMemo,
+  resolvePairedAddressForLpAdd: () => resolvePairedAddressForLpAdd,
+  thorchainMidgardBaseUrl: () => thorchainMidgardBaseUrl
+});
+var init_lp = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/index.js"() {
+    init_memo();
+    init_payload();
+    init_pools();
+    init_position();
+    init_validation();
+    init_pairing();
+    init_lpChainMap();
+    init_math();
+    init_positions();
+    init_lockup();
+    init_halts();
   }
 });
 
 // src/index.ts
 import "dotenv/config";
 import { promises as fs4 } from "node:fs";
+import { descriptions } from "@vultisig/client-shared";
 import { parseKeygenQR, Vultisig as Vultisig6 } from "@vultisig/sdk";
 import chalk15 from "chalk";
-import { program } from "commander";
+import { InvalidArgumentError, program } from "commander";
 import inquirer8 from "inquirer";
 
 // src/core/command-context.ts
@@ -1536,12 +2511,32 @@ import chalk from "chalk";
 import ora from "ora";
 var silentMode = false;
 var outputFormat = "table";
+var nonInteractive = false;
+var quietMode = false;
+var fieldFilter;
 function setSilentMode(silent) {
   silentMode = silent;
 }
 function isSilent() {
   return silentMode;
 }
+function setNonInteractive(value) {
+  nonInteractive = value;
+}
+function isNonInteractive() {
+  return nonInteractive;
+}
+function requireInteractive(hint) {
+  if (nonInteractive) {
+    throw new Error(`Interactive prompt required but --non-interactive is set. ${hint}`);
+  }
+}
+function setQuiet(value) {
+  quietMode = value;
+}
+function setFields(fields) {
+  fieldFilter = fields;
+}
 function initOutputMode(options) {
   outputFormat = options.output ?? "table";
   silentMode = options.silent ?? process.env.VULTISIG_SILENT === "1";
@@ -1552,14 +2547,72 @@ function initOutputMode(options) {
 function isJsonOutput() {
   return outputFormat === "json";
 }
+function stripEmpty(data) {
+  if (Array.isArray(data)) return data.map(stripEmpty);
+  if (data !== null && typeof data === "object") {
+    return Object.fromEntries(
+      Object.entries(data).filter(([, v]) => v != null && v !== "").map(([k, v]) => [k, stripEmpty(v)])
+    );
+  }
+  return data;
+}
+function filterFields(data, fields) {
+  if (!fields.length) return data;
+  if (Array.isArray(data)) return data.map((item) => filterFields(item, fields));
+  if (data !== null && typeof data === "object") {
+    const entries = Object.entries(data);
+    const matched = entries.filter(([k]) => fields.includes(k));
+    if (matched.length > 0) return Object.fromEntries(matched);
+    const recursed = entries.map(([k, v]) => [k, filterFields(v, fields)]);
+    return Object.fromEntries(recursed);
+  }
+  return data;
+}
+function collectKeys(data) {
+  const keys = /* @__PURE__ */ new Set();
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      if (item !== null && typeof item === "object") {
+        for (const k of Object.keys(item)) keys.add(k);
+      }
+    }
+  } else if (data !== null && typeof data === "object") {
+    for (const [k, v] of Object.entries(data)) {
+      keys.add(k);
+      if (v !== null && typeof v === "object") {
+        for (const nested of collectKeys(v)) keys.add(nested);
+      }
+    }
+  }
+  return keys;
+}
+function warnInvalidFields(data, fields) {
+  const available = collectKeys(data);
+  if (available.size === 0) return;
+  const invalid = fields.filter((f) => !available.has(f));
+  if (invalid.length > 0) {
+    process.stderr.write(`Warning: unknown field(s): ${invalid.join(", ")}. Available: ${[...available].join(", ")}
+`);
+  }
+}
+function applyOutputTransforms(data) {
+  let out = quietMode ? stripEmpty(data) : data;
+  if (fieldFilter?.length) {
+    warnInvalidFields(out, fieldFilter);
+    out = filterFields(out, fieldFilter);
+  }
+  return out;
+}
 function bigIntReplacer(_key, value) {
   return typeof value === "bigint" ? value.toString() : value;
 }
 function outputJson(data) {
-  console.log(JSON.stringify({ success: true, data }, bigIntReplacer, 2));
+  const transformed = applyOutputTransforms(data);
+  console.log(JSON.stringify({ success: true, v: 1, data: transformed }, bigIntReplacer, 2));
 }
-function outputJsonError(message, code) {
-  console.log(JSON.stringify({ success: false, error: { message, code } }, bigIntReplacer, 2));
+function outputErrorJson(errJson) {
+  const transformed = applyOutputTransforms(errJson);
+  console.log(JSON.stringify(transformed, bigIntReplacer, 2));
 }
 function info(message) {
   if (!silentMode) {
@@ -1661,11 +2714,24 @@ function createSpinner(text) {
     activeSpinners.add(spinner2);
     return spinner2;
   }
-  const spinner = wrapOraSpinner(ora(text).start());
+  const spinner = wrapOraSpinner(ora({ text, stream: process.stderr }).start());
   activeSpinners.add(spinner);
   return spinner;
 }
 
+// src/core/credential-store.ts
+import {
+  _resetAll,
+  clearCredentials,
+  getDecryptionPassword,
+  getServerPassword,
+  getStoredServerPassword,
+  isUsingFileFallback,
+  setDecryptionPassword,
+  setFilePassphrase,
+  setServerPassword
+} from "@vultisig/client-shared";
+
 // src/core/password-manager.ts
 var passwordCache = /* @__PURE__ */ new Map();
 function cachePassword(vaultIdOrName, password) {
@@ -1700,12 +2766,15 @@ function getPasswordFromEnv(vaultId, vaultName) {
   if (vaultPasswords.has(vaultId)) {
     return vaultPasswords.get(vaultId);
   }
-  if (process.env.VAULT_PASSWORD) {
-    return process.env.VAULT_PASSWORD;
+  if (process.env.VAULT_PASSWORD || process.env.VULTISIG_PASSWORD) {
+    return process.env.VAULT_PASSWORD || process.env.VULTISIG_PASSWORD;
   }
   return null;
 }
 async function promptForPassword(vaultName, vaultId) {
+  requireInteractive(
+    'Use --password flag, VAULT_PASSWORD env var, or "vsig auth setup" to store credentials in keyring.'
+  );
   const displayName = vaultName || vaultId || "vault";
   const { password } = await inquirer.prompt([
     {
@@ -1722,51 +2791,281 @@ async function getPassword(vaultId, vaultName) {
   if (cachedPassword) {
     return cachedPassword;
   }
-  const envPassword = getPasswordFromEnv(vaultId, vaultName);
-  if (envPassword) {
-    cachePassword(vaultId, envPassword);
-    if (vaultName) cachePassword(vaultName, envPassword);
-    return envPassword;
+  try {
+    const keyringPassword = await getServerPassword(vaultId);
+    if (keyringPassword) {
+      cachePassword(vaultId, keyringPassword);
+      if (vaultName) cachePassword(vaultName, keyringPassword);
+      return keyringPassword;
+    }
+  } catch {
+  }
+  const envPassword = getPasswordFromEnv(vaultId, vaultName);
+  if (envPassword) {
+    cachePassword(vaultId, envPassword);
+    if (vaultName) cachePassword(vaultName, envPassword);
+    return envPassword;
+  }
+  if (isSilent() || isJsonOutput() || isNonInteractive()) {
+    throw new Error(
+      "Password required but not provided. Set VAULT_PASSWORD or VAULT_PASSWORDS environment variable, or use --password flag."
+    );
+  }
+  const password = await promptForPassword(vaultName, vaultId);
+  cachePassword(vaultId, password);
+  if (vaultName) cachePassword(vaultName, password);
+  return password;
+}
+function createPasswordCallback() {
+  return async (vaultId, vaultName) => {
+    return getPassword(vaultId, vaultName);
+  };
+}
+async function ensureVaultUnlocked(vault, password) {
+  if (!vault.isEncrypted || vault.isUnlocked()) {
+    return;
+  }
+  const resolvedPassword = password || await getPassword(vault.id, vault.name);
+  await vault.unlock(resolvedPassword);
+}
+
+// src/adapters/cli-context.ts
+var CLIContext = class extends BaseCommandContext {
+  get isInteractive() {
+    return false;
+  }
+  /**
+   * Get password for a vault
+   * In CLI mode, we check env vars first, then prompt
+   * No caching since each command runs independently
+   */
+  async getPassword(vaultId, vaultName) {
+    return getPassword(vaultId, vaultName);
+  }
+};
+
+// src/core/errors.ts
+import { VaultError, VaultErrorCode, VaultImportError, VaultImportErrorCode } from "@vultisig/sdk";
+var EXIT_CODE_DESCRIPTIONS = {
+  [0 /* SUCCESS */]: "Success",
+  [1 /* USAGE */]: "Usage error (bad arguments, unknown command)",
+  [2 /* AUTH_REQUIRED */]: "Authentication required",
+  [3 /* NETWORK */]: "Network error (retryable)",
+  [4 /* INVALID_INPUT */]: "Invalid input (bad chain, address, amount)",
+  [5 /* RESOURCE_NOT_FOUND */]: "Resource not found (token, route)",
+  [6 /* EXTERNAL_SERVICE */]: "External service error (retryable)",
+  [7 /* UNKNOWN */]: "Unknown/unexpected error"
+};
+var VsigError = class extends Error {
+  hint;
+  suggestions;
+  context;
+  retryable = false;
+  constructor(message, hint, suggestions, context) {
+    super(message);
+    this.name = this.constructor.name;
+    this.hint = hint;
+    this.suggestions = suggestions;
+    this.context = context;
+  }
+};
+var UsageError = class extends VsigError {
+  exitCode = 1 /* USAGE */;
+  code = "USAGE_ERROR";
+  constructor(message, hint, suggestions) {
+    super(message, hint, suggestions);
+  }
+};
+var AuthRequiredError = class extends VsigError {
+  exitCode = 2 /* AUTH_REQUIRED */;
+  code = "AUTH_REQUIRED";
+  constructor(message) {
+    super(message ?? "Authentication required. Set up vault credentials.", "Ensure your vault is unlocked", [
+      "vsig vaults",
+      "vsig create"
+    ]);
+  }
+};
+var NetworkError = class extends VsigError {
+  exitCode = 3 /* NETWORK */;
+  code = "NETWORK_ERROR";
+  retryable = true;
+  constructor(message, hint, suggestions) {
+    super(message, hint, suggestions);
+  }
+};
+var InvalidChainError = class extends VsigError {
+  exitCode = 4 /* INVALID_INPUT */;
+  code = "INVALID_CHAIN";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
+  }
+};
+var InvalidAddressError = class extends VsigError {
+  exitCode = 4 /* INVALID_INPUT */;
+  code = "INVALID_ADDRESS";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
+  }
+};
+var InvalidInputError = class extends VsigError {
+  exitCode = 4 /* INVALID_INPUT */;
+  code = "INVALID_INPUT";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
+  }
+};
+var InsufficientBalanceError = class extends VsigError {
+  exitCode = 4 /* INVALID_INPUT */;
+  code = "INSUFFICIENT_BALANCE";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
+  }
+};
+var NoRouteError = class extends VsigError {
+  exitCode = 5 /* RESOURCE_NOT_FOUND */;
+  code = "NO_ROUTE";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
+  }
+};
+var TokenNotFoundError = class extends VsigError {
+  exitCode = 5 /* RESOURCE_NOT_FOUND */;
+  code = "TOKEN_NOT_FOUND";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
+  }
+};
+var ExternalServiceError = class extends VsigError {
+  exitCode = 6 /* EXTERNAL_SERVICE */;
+  code = "EXTERNAL_SERVICE";
+  retryable = true;
+  constructor(message, hint, suggestions) {
+    super(message, hint, suggestions);
+  }
+};
+var PricingUnavailableError = class extends VsigError {
+  exitCode = 6 /* EXTERNAL_SERVICE */;
+  code = "PRICING_UNAVAILABLE";
+  retryable = true;
+  constructor(message, hint, suggestions) {
+    super(message, hint, suggestions);
+  }
+};
+var UnknownError = class extends VsigError {
+  exitCode = 7 /* UNKNOWN */;
+  code = "UNKNOWN_ERROR";
+  constructor(message) {
+    super(message);
+  }
+};
+function classifyError(err) {
+  if (err instanceof VsigError) return err;
+  if (err instanceof VaultError) {
+    if (err.code === VaultErrorCode.BalanceFetchFailed && err.originalError) {
+      const inner = classifyError(err.originalError);
+      if (!(inner instanceof UnknownError)) return inner;
+    }
+    switch (err.code) {
+      case VaultErrorCode.UnsupportedChain:
+      case VaultErrorCode.ChainNotSupported:
+        return new InvalidChainError(err.message);
+      case VaultErrorCode.NetworkError:
+      case VaultErrorCode.BalanceFetchFailed:
+      case VaultErrorCode.Timeout:
+        return new NetworkError(err.message);
+      case VaultErrorCode.InvalidAmount:
+        return new InvalidInputError(err.message);
+      case VaultErrorCode.InvalidConfig: {
+        const lowerMsg = err.message.toLowerCase();
+        if (lowerMsg.includes("unknown chain") || lowerMsg.includes("unsupported chain") || lowerMsg.includes("chain not supported")) {
+          const chainMatch = err.message.match(/chain[:\s]*"([^"]+)"/i);
+          return new InvalidChainError(
+            err.message,
+            void 0,
+            void 0,
+            chainMatch ? { chain: chainMatch[1] } : void 0
+          );
+        }
+        return new UsageError(err.message);
+      }
+      case VaultErrorCode.UnsupportedToken:
+        return new TokenNotFoundError(err.message);
+      case VaultErrorCode.BroadcastFailed:
+        return new ExternalServiceError(err.message, "Broadcast failed \u2014 the node may be temporarily unavailable", [
+          "Retry the transaction"
+        ]);
+      case VaultErrorCode.GasEstimationFailed:
+        return new InvalidInputError(err.message, "Gas estimation failed \u2014 check balance and transaction params");
+      case VaultErrorCode.SigningFailed:
+        return new UnknownError(err.message);
+      default:
+        return new UnknownError(err.message);
+    }
+  }
+  if (err instanceof VaultImportError) {
+    switch (err.code) {
+      case VaultImportErrorCode.PASSWORD_REQUIRED:
+      case VaultImportErrorCode.INVALID_PASSWORD:
+        return new AuthRequiredError(err.message);
+      default:
+        return new UsageError(err.message);
+    }
+  }
+  const msg = err.message.toLowerCase();
+  if (msg.includes("unsupported chain") || msg.includes("invalid chain") || msg.includes("unknown chain")) {
+    const chainMatch = err.message.match(/chain[:\s]*"([^"]+)"/i) || err.message.match(/chain[:\s]+(\S+)/i);
+    return new InvalidChainError(err.message, void 0, void 0, chainMatch ? { chain: chainMatch[1] } : void 0);
   }
-  if (isSilent() || isJsonOutput()) {
-    throw new Error("Password required but not provided. Set VAULT_PASSWORD or VAULT_PASSWORDS environment variable.");
+  if (msg.includes("invalid address") || msg.includes("bad address") || msg.includes("malformed address")) {
+    const addrMatch = err.message.match(/(0x[a-fA-F0-9]+|bc1[a-z0-9]+|[13][a-km-zA-HJ-NP-Z1-9]+)/i);
+    return new InvalidAddressError(err.message, void 0, void 0, addrMatch ? { address: addrMatch[1] } : void 0);
   }
-  const password = await promptForPassword(vaultName, vaultId);
-  cachePassword(vaultId, password);
-  if (vaultName) cachePassword(vaultName, password);
-  return password;
-}
-function createPasswordCallback() {
-  return async (vaultId, vaultName) => {
-    return getPassword(vaultId, vaultName);
-  };
-}
-async function ensureVaultUnlocked(vault, password) {
-  if (!vault.isEncrypted || vault.isUnlocked()) {
-    return;
+  if (msg.includes("insufficient") && msg.includes("balance")) {
+    return new InsufficientBalanceError(err.message);
   }
-  if (password) {
-    await vault.unlock(password);
-    return;
+  if (msg.includes("no route") || msg.includes("no swap") || msg.includes("no provider")) {
+    return new NoRouteError(err.message);
   }
-  const inputPassword = await promptForPassword(vault.name, vault.id);
-  await vault.unlock(inputPassword);
-}
-
-// src/adapters/cli-context.ts
-var CLIContext = class extends BaseCommandContext {
-  get isInteractive() {
-    return false;
+  if (msg.includes("token not found") || msg.includes("unknown token")) {
+    return new TokenNotFoundError(err.message);
   }
-  /**
-   * Get password for a vault
-   * In CLI mode, we check env vars first, then prompt
-   * No caching since each command runs independently
-   */
-  async getPassword(vaultId, vaultName) {
-    return getPassword(vaultId, vaultName);
+  if (msg.includes("pricing") || msg.includes("price unavailable") || msg.includes("price service")) {
+    return new PricingUnavailableError(err.message);
   }
-};
+  if (msg.includes("econnrefused") || msg.includes("etimedout") || msg.includes("enotfound") || msg.includes("econnreset") || msg.includes("fetch failed") || msg.includes("network") || msg.includes("socket hang up") || msg.includes("dns")) {
+    return new NetworkError(err.message);
+  }
+  return new UnknownError(err.message);
+}
+function toErrorJson(err) {
+  if (err instanceof VsigError) {
+    const json = {
+      success: false,
+      v: 1,
+      error: {
+        code: err.code,
+        exitCode: err.exitCode,
+        message: err.message,
+        hint: err.hint,
+        retryable: err.retryable
+      }
+    };
+    if (err.suggestions?.length) json.error.suggestions = err.suggestions;
+    if (err.context) json.error.context = err.context;
+    return json;
+  }
+  return {
+    success: false,
+    v: 1,
+    error: {
+      code: "UNKNOWN_ERROR",
+      exitCode: 7 /* UNKNOWN */,
+      message: err.message,
+      retryable: false
+    }
+  };
+}
 
 // src/adapters/cli-runner.ts
 function withExit(handler) {
@@ -1775,17 +3074,18 @@ function withExit(handler) {
       await handler(...args);
       process.exit(0);
     } catch (err) {
-      const exitCode = err.exitCode ?? 1;
+      const classified = err instanceof VsigError ? err : err instanceof Error ? classifyError(err) : classifyError(new Error(String(err)));
       if (isJsonOutput()) {
-        outputJsonError(err.message, err.code ?? "GENERAL_ERROR");
-        process.exit(exitCode);
-      }
-      if (err.exitCode !== void 0) {
-        process.exit(err.exitCode);
+        outputErrorJson(toErrorJson(classified));
+        process.exit(classified.exitCode);
       }
       printError(`
-x ${err.message}`);
-      process.exit(1);
+x ${classified.message}`);
+      if (classified.hint) printError(`  hint: ${classified.hint}`);
+      if (classified.suggestions?.length) {
+        for (const s of classified.suggestions) printError(`  - ${s}`);
+      }
+      process.exit(classified.exitCode);
     }
   };
 }
@@ -1914,6 +3214,7 @@ function displayVaultsList(vaults, activeVault) {
   printTable(table);
 }
 async function confirmTransaction() {
+  requireInteractive("Use --yes to skip confirmation, or --password to provide password non-interactively.");
   const { confirmed } = await inquirer2.prompt([
     {
       type: "confirm",
@@ -2033,6 +3334,7 @@ function displaySwapChains(chains) {
 Total: ${chains.length} chains`);
 }
 async function confirmSwap() {
+  requireInteractive("Use --yes to skip confirmation, or --password to provide password non-interactively.");
   const { confirmed } = await inquirer2.prompt([
     {
       type: "confirm",
@@ -2121,13 +3423,25 @@ async function executeChains(ctx2, options = {}) {
     return;
   }
   if (options.add) {
-    await vault.addChain(options.add);
-    success(`
-+ Added chain: ${options.add}`);
+    const alreadyActive = vault.chains.includes(options.add);
+    if (!alreadyActive) {
+      await vault.addChain(options.add);
+    }
     const address = await vault.address(options.add);
+    if (isJsonOutput()) {
+      outputJson({ chain: options.add, alreadyActive, address, chains: [...vault.chains] });
+      return;
+    }
+    success(alreadyActive ? `
+Chain already active: ${options.add}` : `
++ Added chain: ${options.add}`);
     info(`Address: ${address}`);
   } else if (options.remove) {
     await vault.removeChain(options.remove);
+    if (isJsonOutput()) {
+      outputJson({ chain: options.remove, removed: true, chains: [...vault.chains] });
+      return;
+    }
     success(`
 + Removed chain: ${options.remove}`);
   } else {
@@ -2162,6 +3476,10 @@ import chalk4 from "chalk";
 import inquirer3 from "inquirer";
 async function executeTokens(ctx2, options) {
   await ctx2.ensureActiveVault();
+  if (options.discover) {
+    await discoverTokens(ctx2, options.chain);
+    return;
+  }
   if (options.add) {
     let symbol = options.symbol;
     let name = options.name;
@@ -2193,6 +3511,7 @@ async function executeTokens(ctx2, options) {
       });
     }
     if (prompts.length > 0) {
+      requireInteractive("Provide --symbol, --name, and --decimals flags for non-interactive token addition.");
       const answers = await inquirer3.prompt(prompts);
       symbol = symbol || answers.symbol?.trim();
       name = name || answers.name?.trim();
@@ -2231,6 +3550,57 @@ async function removeToken(ctx2, chain, tokenId) {
   success(`
 + Removed token ${tokenId} from ${chain}`);
 }
+async function discoverTokens(ctx2, chain) {
+  const vault = await ctx2.ensureActiveVault();
+  const spinner = createSpinner(`Discovering tokens on ${chain}...`);
+  let discovered;
+  try {
+    discovered = await vault.discoverTokens(chain);
+  } catch (err) {
+    spinner.fail(`Token discovery failed for ${chain}`);
+    throw err;
+  }
+  if (discovered.length === 0) {
+    spinner.succeed(`No new tokens found on ${chain}`);
+    if (isJsonOutput()) {
+      outputJson({ chain, discovered: [], count: 0 });
+    }
+    return;
+  }
+  const existingTokens = vault.getTokens(chain);
+  const existingAddresses = new Set(existingTokens.map((t) => t.contractAddress ?? t.id));
+  const newTokens = discovered.filter((d) => d.contractAddress && !existingAddresses.has(d.contractAddress));
+  for (const d of newTokens) {
+    await vault.addToken(chain, {
+      id: d.contractAddress,
+      symbol: d.ticker,
+      name: d.ticker,
+      decimals: d.decimals,
+      contractAddress: d.contractAddress,
+      chainId: chain,
+      isNative: false
+    });
+  }
+  const allTokens = vault.getTokens(chain);
+  spinner.succeed(`Discovered ${newTokens.length} new token(s) on ${chain}`);
+  if (isJsonOutput()) {
+    outputJson({
+      chain,
+      discovered: newTokens.map((d) => ({
+        symbol: d.ticker,
+        contractAddress: d.contractAddress,
+        decimals: d.decimals
+      })),
+      count: newTokens.length
+    });
+    return;
+  }
+  for (const d of newTokens) {
+    printResult(`  ${d.ticker} (${d.contractAddress})`);
+  }
+  info(chalk4.gray(`
+${allTokens.length} total token(s) tracked on ${chain}`));
+}
 async function listTokens(ctx2, chain) {
   const vault = await ctx2.ensureActiveVault();
   const spinner = createSpinner(`Loading tokens for ${chain}...`);
@@ -2263,8 +3633,15 @@ Use --add <contractAddress> to add or --remove <tokenId> to remove`));
 }
 
 // src/commands/transaction.ts
-var import_qrcode_terminal = __toESM(require_main(), 1);
 import { Chain, Vultisig as Vultisig2 } from "@vultisig/sdk";
+
+// src/core/config-store.ts
+import { getConfigPath, loadConfig, saveConfig } from "@vultisig/client-shared";
+
+// src/core/vault-discovery.ts
+import { discoverVaultFiles, SEARCH_DIRS } from "@vultisig/client-shared";
+
+// src/commands/transaction.ts
 async function executeSend(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
   if (!Object.values(Chain).includes(params.chain)) {
@@ -2278,59 +3655,59 @@ async function executeSend(ctx2, params) {
 }
 async function sendTransaction(vault, params) {
   const prepareSpinner = createSpinner("Preparing transaction...");
-  const address = await vault.address(params.chain);
-  const balance = await vault.balance(params.chain, params.tokenId);
-  const coin = {
+  const dryResult = await vault.send({
     chain: params.chain,
-    address,
-    decimals: balance.decimals,
-    ticker: balance.symbol,
-    id: params.tokenId
-  };
-  const isMax = params.amount === "max";
-  let amount;
-  let displayAmount;
-  if (isMax) {
-    const maxInfo = await vault.getMaxSendAmount({ coin, receiver: params.to, memo: params.memo });
-    amount = maxInfo.maxSendable;
-    if (amount === 0n) {
-      throw new Error("Insufficient balance to cover network fees");
-    }
-    displayAmount = formatBigintAmount(amount, balance.decimals);
-  } else {
-    const [whole, frac = ""] = params.amount.split(".");
-    if (frac.length > balance.decimals) {
-      throw new Error(`Amount has more than ${balance.decimals} decimal places`);
-    }
-    const paddedFrac = frac.padEnd(balance.decimals, "0");
-    amount = BigInt(whole || "0") * 10n ** BigInt(balance.decimals) + BigInt(paddedFrac || "0");
-    displayAmount = params.amount;
-  }
-  const payload = await vault.prepareSendTx({
-    coin,
-    receiver: params.to,
-    amount,
-    memo: params.memo
+    to: params.to,
+    amount: params.amount,
+    symbol: params.tokenId,
+    memo: params.memo,
+    dryRun: true
   });
   prepareSpinner.succeed("Transaction prepared");
+  if (!dryResult.dryRun) throw new Error("unreachable");
+  if (params.dryRun) {
+    const balance2 = await vault.balance(params.chain, params.tokenId);
+    const hasInsufficientBalance = parseFloat(dryResult.total) > parseFloat(balance2.formattedAmount);
+    const result = {
+      dryRun: true,
+      chain: params.chain,
+      to: params.to,
+      amount: params.amount,
+      symbol: balance2.symbol,
+      balance: balance2.formattedAmount
+    };
+    if (hasInsufficientBalance) {
+      result.warning = `Insufficient balance: you have ${balance2.formattedAmount} ${balance2.symbol}`;
+    }
+    if (isJsonOutput()) {
+      outputJson(result);
+    } else {
+      info(`
+Dry-run preview:`);
+      info(`  Chain:   ${result.chain}`);
+      info(`  To:      ${result.to}`);
+      info(`  Amount:  ${result.amount} ${result.symbol}`);
+      info(`  Fee:     ${dryResult.fee} ${result.symbol}`);
+      info(`  Balance: ${result.balance} ${result.symbol}`);
+      if (result.warning) warn(`  Warning: ${result.warning}`);
+    }
+    return result;
+  }
   let gas;
   try {
     gas = await vault.gas(params.chain);
   } catch {
     warn("\nGas estimation unavailable");
   }
+  const balance = await vault.balance(params.chain, params.tokenId);
   if (!isJsonOutput()) {
-    displayTransactionPreview(
-      payload.coin.address,
-      params.to,
-      displayAmount,
-      payload.coin.ticker,
-      params.chain,
-      params.memo,
-      gas
-    );
+    const address = await vault.address(params.chain);
+    displayTransactionPreview(address, params.to, dryResult.total, balance.symbol, params.chain, params.memo, gas);
   }
-  if (!params.yes && !isJsonOutput()) {
+  if (!params.yes) {
+    if (isNonInteractive()) {
+      throw new Error("Transaction requires confirmation. Use --yes to skip, or --dry-run to preview.");
+    }
     const confirmed = await confirmTransaction();
     if (!confirmed) {
       warn("Transaction cancelled");
@@ -2338,90 +3715,55 @@ async function sendTransaction(vault, params) {
     }
   }
   await ensureVaultUnlocked(vault, params.password);
-  const isSecureVault = vault.type === "secure";
-  const signSpinner = createSpinner(isSecureVault ? "Preparing secure signing session..." : "Signing transaction...");
+  const signSpinner = createSpinner(
+    vault.type === "secure" ? "Preparing secure signing session..." : "Signing transaction..."
+  );
   vault.on("signingProgress", ({ step }) => {
     signSpinner.text = `${step.message} (${step.progress}%)`;
   });
-  if (isSecureVault) {
-    vault.on("qrCodeReady", ({ qrPayload }) => {
-      if (isJsonOutput()) {
-        printResult(qrPayload);
-      } else if (isSilent()) {
-        printResult(`QR Payload: ${qrPayload}`);
-      } else {
-        signSpinner.stop();
-        info("\nScan this QR code with your Vultisig mobile app to sign:");
-        import_qrcode_terminal.default.generate(qrPayload, { small: true });
-        info(`
-Or use this URL: ${qrPayload}
-`);
-        signSpinner.start("Waiting for devices to join signing session...");
-      }
-    });
-    vault.on(
-      "deviceJoined",
-      ({ deviceId, totalJoined, required }) => {
-        if (!isSilent()) {
-          signSpinner.text = `Device joined: ${totalJoined}/${required} (${deviceId})`;
-        } else if (!isJsonOutput()) {
-          printResult(`Device joined: ${totalJoined}/${required}`);
-        }
-      }
-    );
-  }
   try {
-    const messageHashes = await vault.extractMessageHashes(payload);
-    const signature = await vault.sign(
-      {
-        transaction: payload,
-        chain: payload.coin.chain,
-        messageHashes
-      },
-      { signal: params.signal }
-    );
-    signSpinner.succeed("Transaction signed");
-    const broadcastSpinner = createSpinner("Broadcasting transaction...");
-    const txHash = await vault.broadcastTx({
+    const result = await vault.send({
       chain: params.chain,
-      keysignPayload: payload,
-      signature
+      to: params.to,
+      amount: params.amount,
+      symbol: params.tokenId,
+      memo: params.memo
     });
-    broadcastSpinner.succeed(`Transaction broadcast: ${txHash}`);
-    const result = {
-      txHash,
+    if (result.dryRun) throw new Error("unreachable");
+    const broadcast = result;
+    signSpinner.succeed(`Transaction broadcast: ${broadcast.txHash}`);
+    const txResult = {
+      txHash: broadcast.txHash,
       chain: params.chain,
-      explorerUrl: Vultisig2.getTxExplorerUrl(params.chain, txHash)
+      explorerUrl: Vultisig2.getTxExplorerUrl(params.chain, broadcast.txHash)
     };
     if (isJsonOutput()) {
-      outputJson(result);
+      outputJson(txResult);
     } else {
-      displayTransactionResult(params.chain, txHash);
+      displayTransactionResult(params.chain, broadcast.txHash);
     }
-    return result;
+    return txResult;
   } finally {
     vault.removeAllListeners("signingProgress");
-    if (isSecureVault) {
-      vault.removeAllListeners("qrCodeReady");
-      vault.removeAllListeners("deviceJoined");
-    }
   }
 }
 
 // src/commands/execute.ts
-var import_qrcode_terminal2 = __toESM(require_main(), 1);
+var import_qrcode_terminal = __toESM(require_main(), 1);
 import { Vultisig as Vultisig3 } from "@vultisig/sdk";
 var COSMOS_CHAIN_CONFIG = {
   THORChain: {
     chainId: "thorchain-1",
     prefix: "thor",
     denom: "rune",
+    decimals: 8,
     gasLimit: "500000"
   },
   MayaChain: {
     chainId: "mayachain-mainnet-v1",
     prefix: "maya",
     denom: "cacao",
+    decimals: 10,
     gasLimit: "500000"
   }
 };
@@ -2456,8 +3798,42 @@ async function executeContractTransaction(vault, params, chainConfig, msg, funds
   const prepareSpinner = createSpinner("Preparing contract execution...");
   const address = await vault.address(params.chain);
   prepareSpinner.succeed("Transaction prepared");
+  if (params.dryRun) {
+    if (isJsonOutput()) {
+      outputJson({
+        dryRun: true,
+        chain: params.chain,
+        contract: params.contract,
+        msg,
+        funds,
+        address,
+        memo: params.memo
+      });
+    } else {
+      info("\nContract Execution Preview (dry-run)");
+      info("\u2501".repeat(50));
+      info(`Chain:      ${params.chain}`);
+      info(`From:       ${address}`);
+      info(`Contract:   ${params.contract}`);
+      info(
+        `Message:    ${JSON.stringify(msg, null, 2).substring(0, 200)}${JSON.stringify(msg).length > 200 ? "..." : ""}`
+      );
+      if (funds.length > 0) {
+        info(`Funds:      ${funds.map((f) => `${f.amount} ${f.denom}`).join(", ")}`);
+      }
+      if (params.memo) {
+        info(`Memo:       ${params.memo}`);
+      }
+      info("\u2501".repeat(50));
+    }
+    return {
+      txHash: "",
+      chain: params.chain,
+      explorerUrl: ""
+    };
+  }
   if (!isJsonOutput()) {
-    info("\n\u{1F4DD} Contract Execution Preview");
+    info("\nContract Execution Preview");
     info("\u2501".repeat(50));
     info(`Chain:      ${params.chain}`);
     info(`From:       ${address}`);
@@ -2473,7 +3849,10 @@ async function executeContractTransaction(vault, params, chainConfig, msg, funds
     }
     info("\u2501".repeat(50));
   }
-  if (!params.yes && !isJsonOutput()) {
+  if (!params.yes) {
+    if (isNonInteractive()) {
+      throw new Error("Transaction requires confirmation. Use --yes to skip, or --dry-run to preview.");
+    }
     const confirmed = await confirmTransaction();
     if (!confirmed) {
       warn("Transaction cancelled");
@@ -2495,7 +3874,7 @@ async function executeContractTransaction(vault, params, chainConfig, msg, funds
       } else {
         signSpinner.stop();
         info("\nScan this QR code with your Vultisig mobile app to sign:");
-        import_qrcode_terminal2.default.generate(qrPayload, { small: true });
+        import_qrcode_terminal.default.generate(qrPayload, { small: true });
         info(`
 Or use this URL: ${qrPayload}
 `);
@@ -2518,8 +3897,7 @@ Or use this URL: ${qrPayload}
     const coin = {
       chain: cosmosChain,
       address,
-      decimals: 8,
-      // THORChain uses 8 decimals
+      decimals: chainConfig.decimals,
       ticker: chainConfig.denom.toUpperCase()
     };
     const executeContractMsg = {
@@ -2580,7 +3958,7 @@ Or use this URL: ${qrPayload}
 }
 
 // src/commands/sign.ts
-var import_qrcode_terminal3 = __toESM(require_main(), 1);
+var import_qrcode_terminal2 = __toESM(require_main(), 1);
 import { Chain as Chain3 } from "@vultisig/sdk";
 async function executeSignBytes(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
@@ -2606,7 +3984,7 @@ async function signBytes(vault, params) {
       } else {
         signSpinner.stop();
         info("\nScan this QR code with your Vultisig mobile app to sign:");
-        import_qrcode_terminal3.default.generate(qrPayload, { small: true });
+        import_qrcode_terminal2.default.generate(qrPayload, { small: true });
         info(`
 Or use this URL: ${qrPayload}
 `);
@@ -2756,7 +4134,7 @@ function sleep(ms) {
 }
 
 // src/commands/vault-management.ts
-var import_qrcode_terminal4 = __toESM(require_main(), 1);
+var import_qrcode_terminal3 = __toESM(require_main(), 1);
 import { FastVault } from "@vultisig/sdk";
 import chalk5 from "chalk";
 import { promises as fs } from "fs";
@@ -2904,7 +4282,7 @@ async function executeCreateSecure(ctx2, options) {
           } else {
             spinner.stop();
             info("\nScan this QR code with your Vultisig mobile app:");
-            import_qrcode_terminal4.default.generate(qrPayload, { small: true });
+            import_qrcode_terminal3.default.generate(qrPayload, { small: true });
             info(`
 Or use this URL: ${qrPayload}
 `);
@@ -3427,7 +4805,7 @@ async function executeCreateFromSeedphraseSecure(ctx2, options) {
           } else {
             importSpinner.stop();
             info("\nScan this QR code with your Vultisig mobile app:");
-            import_qrcode_terminal4.default.generate(qrPayload, { small: true });
+            import_qrcode_terminal3.default.generate(qrPayload, { small: true });
             info(`
 Or use this URL: ${qrPayload}
 `);
@@ -3616,35 +4994,24 @@ async function executeSwapQuote(ctx2, options) {
   if (!isMax && (isNaN(options.amount) || options.amount <= 0)) {
     throw new Error("Invalid amount");
   }
-  const isSupported = await vault.isSwapSupported(options.fromChain, options.toChain);
-  if (!isSupported) {
-    throw new Error(`Swaps from ${options.fromChain} to ${options.toChain} are not supported`);
-  }
-  let resolvedAmount;
-  if (isMax) {
-    const bal = await vault.balance(options.fromChain, options.fromToken);
-    resolvedAmount = parseFloat(bal.formattedAmount);
-    if (resolvedAmount <= 0) {
-      throw new Error("Zero balance \u2014 nothing to swap");
-    }
-  } else {
-    resolvedAmount = options.amount;
-  }
   const spinner = createSpinner("Getting swap quote...");
-  const quote = await vault.getSwapQuote({
-    fromCoin: { chain: options.fromChain, token: options.fromToken },
-    toCoin: { chain: options.toChain, token: options.toToken },
-    amount: resolvedAmount,
-    fiatCurrency: "usd"
-    // Request fiat conversion
+  const result = await vault.swap({
+    fromChain: options.fromChain,
+    fromSymbol: options.fromToken || "",
+    toChain: options.toChain,
+    toSymbol: options.toToken || "",
+    amount: isMax ? "max" : String(options.amount),
+    dryRun: true
   });
+  if (!result.dryRun) throw new Error("unreachable");
   spinner.succeed("Quote received");
-  const fromAmountDisplay = isMax ? `${formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals)} (max)` : String(resolvedAmount);
+  const quote = result.quote;
+  const fromAmountDisplay = isMax ? `${formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals)} (max)` : String(options.amount);
   if (isJsonOutput()) {
     outputJson({
       fromChain: options.fromChain,
       toChain: options.toChain,
-      amount: resolvedAmount,
+      amount: isMax ? "max" : options.amount,
       isMax,
       quote
     });
@@ -3668,30 +5035,57 @@ async function executeSwap(ctx2, options) {
   if (!isMax && (isNaN(options.amount) || options.amount <= 0)) {
     throw new Error("Invalid amount");
   }
-  const isSupported = await vault.isSwapSupported(options.fromChain, options.toChain);
-  if (!isSupported) {
-    throw new Error(`Swaps from ${options.fromChain} to ${options.toChain} are not supported`);
-  }
-  let resolvedAmount;
-  if (isMax) {
-    const bal = await vault.balance(options.fromChain, options.fromToken);
-    resolvedAmount = parseFloat(bal.formattedAmount);
-    if (resolvedAmount <= 0) {
-      throw new Error("Zero balance \u2014 nothing to swap");
-    }
-  } else {
-    resolvedAmount = options.amount;
-  }
+  const amountStr = isMax ? "max" : String(options.amount);
   const quoteSpinner = createSpinner("Getting swap quote...");
-  const quote = await vault.getSwapQuote({
-    fromCoin: { chain: options.fromChain, token: options.fromToken },
-    toCoin: { chain: options.toChain, token: options.toToken },
-    amount: resolvedAmount,
-    fiatCurrency: "usd"
-    // Request fiat conversion
+  const dryResult = await vault.swap({
+    fromChain: options.fromChain,
+    fromSymbol: options.fromToken || "",
+    toChain: options.toChain,
+    toSymbol: options.toToken || "",
+    amount: amountStr,
+    dryRun: true
   });
+  if (!dryResult.dryRun) throw new Error("unreachable");
   quoteSpinner.succeed("Quote received");
-  const fromAmountDisplay = isMax ? `${formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals)} (max)` : String(resolvedAmount);
+  const quote = dryResult.quote;
+  const fromAmountRaw = isMax ? formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals) : String(options.amount);
+  const fromAmountDisplay = isMax ? `${fromAmountRaw} (max)` : fromAmountRaw;
+  if (options.dryRun) {
+    const estimatedOutput = formatBigintAmount(quote.estimatedOutput, quote.toCoin.decimals);
+    const result = {
+      dryRun: true,
+      fromChain: String(options.fromChain),
+      fromToken: quote.fromCoin.ticker,
+      toChain: String(options.toChain),
+      toToken: quote.toCoin.ticker,
+      inputAmount: fromAmountRaw,
+      ...isMax && { isMax: true },
+      estimatedOutput,
+      provider: quote.provider
+    };
+    if (quote.estimatedOutputFiat != null) {
+      result.estimatedOutputFiat = parseFloat(quote.estimatedOutputFiat.toFixed(2));
+    }
+    if (quote.requiresApproval) {
+      result.requiresApproval = true;
+    }
+    if (quote.warnings && quote.warnings.length > 0) {
+      result.warnings = [...quote.warnings];
+    }
+    if (isJsonOutput()) {
+      outputJson(result);
+    } else {
+      info(`
+Dry-run preview:`);
+      info(`  From:             ${result.inputAmount} ${result.fromToken} (${result.fromChain})`);
+      info(`  To:               ${result.estimatedOutput} ${result.toToken} (${result.toChain})`);
+      info(`  Provider:         ${result.provider}`);
+      if (result.estimatedOutputFiat != null) info(`  Est. value (USD): $${result.estimatedOutputFiat}`);
+      if (result.requiresApproval) info(`  Requires approval: yes`);
+      if (result.warnings?.length) result.warnings.forEach((w) => warn(`  Warning: ${w}`));
+    }
+    return result;
+  }
   const feeBalance = await vault.balance(options.fromChain);
   const discountTier = await vault.getDiscountTier();
   if (!isJsonOutput()) {
@@ -3703,86 +5097,43 @@ async function executeSwap(ctx2, options) {
       discountTier
     });
   }
-  if (!options.yes && !isJsonOutput()) {
+  if (!options.yes) {
+    if (isNonInteractive()) {
+      throw new Error("Swap requires confirmation. Use --yes to skip, or --dry-run to preview.");
+    }
     const confirmed = await confirmSwap();
     if (!confirmed) {
       warn("Swap cancelled");
       throw new Error("Swap cancelled by user");
     }
   }
-  const prepSpinner = createSpinner("Preparing swap transaction...");
-  const { keysignPayload, approvalPayload } = await vault.prepareSwapTx({
-    fromCoin: { chain: options.fromChain, token: options.fromToken },
-    toCoin: { chain: options.toChain, token: options.toToken },
-    amount: resolvedAmount,
-    swapQuote: quote,
-    autoApprove: false
-  });
-  prepSpinner.succeed("Swap prepared");
   await ensureVaultUnlocked(vault, options.password);
-  if (approvalPayload) {
-    info("\nToken approval required before swap...");
-    const approvalSpinner = createSpinner("Signing approval transaction...");
-    vault.on("signingProgress", ({ step }) => {
-      approvalSpinner.text = `Approval: ${step.message} (${step.progress}%)`;
-    });
-    try {
-      const approvalHashes = await vault.extractMessageHashes(approvalPayload);
-      const approvalSig = await vault.sign(
-        {
-          transaction: approvalPayload,
-          chain: options.fromChain,
-          messageHashes: approvalHashes
-        },
-        { signal: options.signal }
-      );
-      approvalSpinner.succeed("Approval signed");
-      const broadcastApprovalSpinner = createSpinner("Broadcasting approval...");
-      const approvalTxHash = await vault.broadcastTx({
-        chain: options.fromChain,
-        keysignPayload: approvalPayload,
-        signature: approvalSig
-      });
-      broadcastApprovalSpinner.succeed(`Approval broadcast: ${approvalTxHash}`);
-      info("Waiting for approval to confirm...");
-      await new Promise((resolve) => setTimeout(resolve, 5e3));
-    } finally {
-      vault.removeAllListeners("signingProgress");
-    }
-  }
   const signSpinner = createSpinner("Signing swap transaction...");
   vault.on("signingProgress", ({ step }) => {
     signSpinner.text = `${step.message} (${step.progress}%)`;
   });
   try {
-    const messageHashes = await vault.extractMessageHashes(keysignPayload);
-    const signature = await vault.sign(
-      {
-        transaction: keysignPayload,
-        chain: options.fromChain,
-        messageHashes
-      },
-      { signal: options.signal }
-    );
-    signSpinner.succeed("Swap transaction signed");
-    const broadcastSpinner = createSpinner("Broadcasting swap transaction...");
-    const txHash = await vault.broadcastTx({
-      chain: options.fromChain,
-      keysignPayload,
-      signature
+    const result = await vault.swap({
+      fromChain: options.fromChain,
+      fromSymbol: options.fromToken || "",
+      toChain: options.toChain,
+      toSymbol: options.toToken || "",
+      amount: amountStr
     });
-    broadcastSpinner.succeed(`Swap broadcast: ${txHash}`);
+    if (result.dryRun) throw new Error("unreachable");
+    const broadcast = result;
+    signSpinner.succeed(`Swap broadcast: ${broadcast.txHash}`);
     if (isJsonOutput()) {
       outputJson({
-        txHash,
+        txHash: broadcast.txHash,
         fromChain: options.fromChain,
         toChain: options.toChain,
         quote
       });
     } else {
-      displaySwapResult(options.fromChain, options.toChain, txHash, quote, quote.toCoin.decimals);
+      displaySwapResult(options.fromChain, options.toChain, broadcast.txHash, quote, quote.toCoin.decimals);
     }
-    return { txHash, quote };
+    return { txHash: broadcast.txHash, quote };
   } finally {
     vault.removeAllListeners("signingProgress");
   }
@@ -4067,20 +5418,31 @@ async function executeRujiraSwap(ctx2, options) {
     slippageBps: options.slippageBps
   });
   quoteSpinner.succeed("Quote received");
-  if (isJsonOutput()) {
-    const result2 = await client.swap.execute(quote, { slippageBps: options.slippageBps });
-    outputJson({ quote, result: result2 });
+  if (options.dryRun) {
+    if (isJsonOutput()) {
+      outputJson({ dryRun: true, quote });
+    } else {
+      printResult("FIN Swap Preview (dry-run)");
+      printResult(`  From:        ${options.fromAsset}`);
+      printResult(`  To:          ${options.toAsset}`);
+      printResult(`  Amount (in): ${options.amount}`);
+      printResult(`  Expected out:${quote.expectedOutput}`);
+      printResult(`  Min out:     ${quote.minimumOutput}`);
+      printResult(`  Contract:    ${quote.contractAddress}`);
+    }
     return;
   }
-  printResult("FIN Swap Preview");
-  printResult(`  From:        ${options.fromAsset}`);
-  printResult(`  To:          ${options.toAsset}`);
-  printResult(`  Amount (in): ${options.amount}`);
-  printResult(`  Expected out:${quote.expectedOutput}`);
-  printResult(`  Min out:     ${quote.minimumOutput}`);
-  printResult(`  Contract:    ${quote.contractAddress}`);
-  if (quote.warning) {
-    warn(quote.warning);
+  if (!isJsonOutput()) {
+    printResult("FIN Swap Preview");
+    printResult(`  From:        ${options.fromAsset}`);
+    printResult(`  To:          ${options.toAsset}`);
+    printResult(`  Amount (in): ${options.amount}`);
+    printResult(`  Expected out:${quote.expectedOutput}`);
+    printResult(`  Min out:     ${quote.minimumOutput}`);
+    printResult(`  Contract:    ${quote.contractAddress}`);
+    if (quote.warning) {
+      warn(quote.warning);
+    }
   }
   if (!options.yes) {
     warn("This command will execute a swap. Re-run with -y/--yes to skip this warning.");
@@ -4089,7 +5451,11 @@ async function executeRujiraSwap(ctx2, options) {
   const execSpinner = createSpinner("Executing FIN swap...");
   const result = await client.swap.execute(quote, { slippageBps: options.slippageBps });
   execSpinner.succeed("Swap submitted");
-  printResult(`Tx Hash: ${result.txHash}`);
+  if (isJsonOutput()) {
+    outputJson({ quote, result });
+  } else {
+    printResult(`Tx Hash: ${result.txHash}`);
+  }
 }
 async function executeRujiraWithdraw(ctx2, options) {
   const vault = await ctx2.ensureActiveVault();
@@ -4103,17 +5469,27 @@ async function executeRujiraWithdraw(ctx2, options) {
     maxFeeBps: options.maxFeeBps
   });
   prepSpinner.succeed("Withdrawal prepared");
-  if (isJsonOutput()) {
-    const result2 = await client.withdraw.execute(prepared);
-    outputJson({ prepared, result: result2 });
+  if (options.dryRun) {
+    if (isJsonOutput()) {
+      outputJson({ dryRun: true, prepared });
+    } else {
+      printResult("Withdraw Preview (dry-run)");
+      printResult(`  Asset:       ${prepared.asset}`);
+      printResult(`  Amount:      ${prepared.amount}`);
+      printResult(`  Destination: ${prepared.destination}`);
+      printResult(`  Memo:        ${prepared.memo}`);
+      printResult(`  Est. fee:    ${prepared.estimatedFee}`);
+    }
     return;
   }
-  printResult("Withdraw Preview");
-  printResult(`  Asset:       ${prepared.asset}`);
-  printResult(`  Amount:      ${prepared.amount}`);
-  printResult(`  Destination: ${prepared.destination}`);
-  printResult(`  Memo:        ${prepared.memo}`);
-  printResult(`  Est. fee:    ${prepared.estimatedFee}`);
+  if (!isJsonOutput()) {
+    printResult("Withdraw Preview");
+    printResult(`  Asset:       ${prepared.asset}`);
+    printResult(`  Amount:      ${prepared.amount}`);
+    printResult(`  Destination: ${prepared.destination}`);
+    printResult(`  Memo:        ${prepared.memo}`);
+    printResult(`  Est. fee:    ${prepared.estimatedFee}`);
+  }
   if (!options.yes) {
     warn("This command will broadcast a THORChain MsgDeposit withdrawal. Re-run with -y/--yes to proceed.");
     throw new Error("Confirmation required (use --yes)");
@@ -4121,7 +5497,11 @@ async function executeRujiraWithdraw(ctx2, options) {
   const execSpinner = createSpinner("Broadcasting withdrawal...");
   const result = await client.withdraw.execute(prepared);
   execSpinner.succeed("Withdrawal submitted");
-  printResult(`Tx Hash: ${result.txHash}`);
+  if (isJsonOutput()) {
+    outputJson({ prepared, result });
+  } else {
+    printResult(`Tx Hash: ${result.txHash}`);
+  }
 }
 
 // src/commands/discount.ts
@@ -4222,12 +5602,15 @@ function displayDiscountTier(tierInfo) {
   printResult("");
 }
 
+// src/commands/auth.ts
+import { executeAuthLogout, executeAuthSetup, executeAuthStatus } from "@vultisig/client-shared";
+
 // src/commands/agent.ts
 import chalk9 from "chalk";
 import Table from "cli-table3";
 
 // src/agent/agentErrors.ts
-import { VaultError, VaultErrorCode, VaultImportError, VaultImportErrorCode } from "@vultisig/sdk";
+import { VaultError as VaultError2, VaultErrorCode as VaultErrorCode2, VaultImportError as VaultImportError2, VaultImportErrorCode as VaultImportErrorCode2 } from "@vultisig/sdk";
 var AgentErrorCode = /* @__PURE__ */ ((AgentErrorCode3) => {
   AgentErrorCode3["BACKEND_UNREACHABLE"] = "BACKEND_UNREACHABLE";
   AgentErrorCode3["AUTH_FAILED"] = "AUTH_FAILED";
@@ -4249,32 +5632,32 @@ function isAgentErrorCode(value) {
   return AGENT_ERROR_CODE_VALUES.has(value);
 }
 function mapVaultError(err) {
-  if (err.code === VaultErrorCode.InvalidConfig && /failed to unlock vault/i.test(err.message)) {
+  if (err.code === VaultErrorCode2.InvalidConfig && /failed to unlock vault/i.test(err.message)) {
     return "AUTH_FAILED" /* AUTH_FAILED */;
   }
   switch (err.code) {
-    case VaultErrorCode.Timeout:
+    case VaultErrorCode2.Timeout:
       return "TIMEOUT" /* TIMEOUT */;
-    case VaultErrorCode.NetworkError:
-    case VaultErrorCode.BalanceFetchFailed:
+    case VaultErrorCode2.NetworkError:
+    case VaultErrorCode2.BalanceFetchFailed:
       return "NETWORK_ERROR" /* NETWORK_ERROR */;
-    case VaultErrorCode.SigningFailed:
+    case VaultErrorCode2.SigningFailed:
       return "SIGNING_FAILED" /* SIGNING_FAILED */;
-    case VaultErrorCode.BroadcastFailed:
-    case VaultErrorCode.GasEstimationFailed:
+    case VaultErrorCode2.BroadcastFailed:
+    case VaultErrorCode2.GasEstimationFailed:
       return "TRANSACTION_FAILED" /* TRANSACTION_FAILED */;
-    case VaultErrorCode.NotImplemented:
+    case VaultErrorCode2.NotImplemented:
       return "ACTION_NOT_IMPLEMENTED" /* ACTION_NOT_IMPLEMENTED */;
-    case VaultErrorCode.InvalidAmount:
-    case VaultErrorCode.UnsupportedChain:
-    case VaultErrorCode.UnsupportedToken:
-    case VaultErrorCode.ChainNotSupported:
-    case VaultErrorCode.InvalidVault:
-    case VaultErrorCode.InvalidPublicKey:
-    case VaultErrorCode.InvalidChainCode:
-    case VaultErrorCode.AddressDerivationFailed:
+    case VaultErrorCode2.InvalidAmount:
+    case VaultErrorCode2.UnsupportedChain:
+    case VaultErrorCode2.UnsupportedToken:
+    case VaultErrorCode2.ChainNotSupported:
+    case VaultErrorCode2.InvalidVault:
+    case VaultErrorCode2.InvalidPublicKey:
+    case VaultErrorCode2.InvalidChainCode:
+    case VaultErrorCode2.AddressDerivationFailed:
       return "INVALID_INPUT" /* INVALID_INPUT */;
-    case VaultErrorCode.InvalidConfig:
+    case VaultErrorCode2.InvalidConfig:
       return "INVALID_INPUT" /* INVALID_INPUT */;
     default:
       return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
@@ -4282,9 +5665,9 @@ function mapVaultError(err) {
 }
 function mapVaultImportError(err) {
   switch (err.code) {
-    case VaultImportErrorCode.PASSWORD_REQUIRED:
+    case VaultImportErrorCode2.PASSWORD_REQUIRED:
       return "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */;
-    case VaultImportErrorCode.INVALID_PASSWORD:
+    case VaultImportErrorCode2.INVALID_PASSWORD:
       return "AUTH_FAILED" /* AUTH_FAILED */;
     default:
       return "INVALID_INPUT" /* INVALID_INPUT */;
@@ -4322,10 +5705,10 @@ function nodeErrCode(err) {
   return void 0;
 }
 function normalizeAgentError(err) {
-  if (err instanceof VaultError) {
+  if (err instanceof VaultError2) {
     return { code: mapVaultError(err), message: err.message };
   }
-  if (err instanceof VaultImportError) {
+  if (err instanceof VaultImportError2) {
     return { code: mapVaultImportError(err), message: err.message };
   }
   const name = err instanceof Error ? err.name : "";
@@ -4441,10 +5824,10 @@ async function authenticateVault(client, vault, password, maxAttempts = 3) {
   });
   const messageHash = computePersonalSignHash(authMessage);
   let lastError = null;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+  for (let attempt2 = 1; attempt2 <= maxAttempts; attempt2++) {
     try {
-      if (attempt > 1) {
-        process.stderr.write(`  Retry ${attempt}/${maxAttempts}...
+      if (attempt2 > 1) {
+        process.stderr.write(`  Retry ${attempt2}/${maxAttempts}...
 `);
       }
       const signature = await vault.signBytes({ data: Buffer.from(messageHash), chain: Chain7.Ethereum }, {});
@@ -4461,7 +5844,7 @@ async function authenticateVault(client, vault, password, maxAttempts = 3) {
       };
     } catch (err) {
       lastError = err;
-      if (attempt < maxAttempts && err.message?.includes("timeout")) {
+      if (attempt2 < maxAttempts && err.message?.includes("timeout")) {
         continue;
       }
       throw err;
@@ -4522,6 +5905,18 @@ function padTo32Bytes(buf) {
 }
 
 // src/agent/client.ts
+function v1StatusFromType(type) {
+  switch (type) {
+    case "tool-input-start":
+    case "tool-input-available":
+    case "tool-input-delta":
+      return "running";
+    case "tool-output-available":
+      return "done";
+    default:
+      return void 0;
+  }
+}
 function sseErrorToMessage(value) {
   if (value == null) return "";
   if (typeof value === "string") return value;
@@ -4625,6 +6020,7 @@ var AgentClient = class {
       transactions: [],
       message: null
     };
+    const toolNameByCallId = /* @__PURE__ */ new Map();
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -4639,7 +6035,7 @@ var AgentClient = class {
         currentData += (currentData ? "\n" : "") + stripLeadingSpace(line.slice(5));
       } else if (line === "") {
         if (currentData) {
-          this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks);
+          this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks, toolNameByCallId);
         }
         currentEvent = "";
         currentData = "";
@@ -4659,7 +6055,7 @@ var AgentClient = class {
         if (done) {
           if (trailing) processLine(trailing);
           if (currentData) {
-            this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks);
+            this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks, toolNameByCallId);
           }
           break;
         }
@@ -4669,49 +6065,75 @@ var AgentClient = class {
     }
     return result;
   }
-  handleSSEEvent(event, data, result, callbacks) {
+  handleSSEEvent(event, data, result, callbacks, toolNameByCallId) {
     try {
       const parsed = JSON.parse(data);
-      switch (event) {
+      const v1Type = typeof parsed?.type === "string" && parsed.type.length > 0 ? parsed.type : null;
+      const routingEvent = v1Type ? this.mapV1EventType(v1Type) : event;
+      const v1Data = typeof parsed?.type === "string" && parsed.type.startsWith("data-") ? parsed.data : null;
+      switch (routingEvent) {
         case "text_delta":
           if (typeof parsed.delta === "string") {
             result.fullText += parsed.delta;
             callbacks.onTextDelta?.(parsed.delta);
           }
           break;
-        case "tool_progress":
+        case "tool_progress": {
           if (this.verbose) process.stderr.write(`[SSE:tool_progress] raw: ${data.slice(0, 1e3)}
 `);
-          callbacks.onToolProgress?.(parsed.tool, parsed.status, parsed.label);
+          const v1Status = v1StatusFromType(v1Type);
+          const status = parsed.status ?? v1Status;
+          const callId = typeof parsed.toolCallId === "string" ? parsed.toolCallId : null;
+          const rawInlineName = parsed.tool ?? parsed.toolName;
+          const inlineName = typeof rawInlineName === "string" && rawInlineName.length > 0 ? rawInlineName : void 0;
+          if (callId && inlineName) {
+            toolNameByCallId.set(callId, inlineName);
+          }
+          const toolName = inlineName ?? (callId ? toolNameByCallId.get(callId) : void 0);
+          const label = typeof parsed.label === "string" ? parsed.label : void 0;
+          if (status && toolName) {
+            callbacks.onToolProgress?.(toolName, status, label);
+          }
+          if (status === "done" && callId) toolNameByCallId.delete(callId);
           break;
-        case "title":
-          callbacks.onTitle?.(parsed.title);
+        }
+        case "title": {
+          const title = v1Data?.title ?? parsed.title;
+          if (typeof title === "string") callbacks.onTitle?.(title);
           break;
-        case "actions":
+        }
+        case "actions": {
           if (this.verbose) process.stderr.write(`[SSE:actions] raw: ${data.slice(0, 1e3)}
 `);
-          result.actions.push(...parsed.actions || []);
-          callbacks.onActions?.(parsed.actions || []);
+          const actions = v1Data?.actions ?? parsed.actions ?? [];
+          result.actions.push(...actions);
+          callbacks.onActions?.(actions);
           break;
-        case "suggestions":
-          result.suggestions.push(...parsed.suggestions || []);
-          callbacks.onSuggestions?.(parsed.suggestions || []);
+        }
+        case "suggestions": {
+          const suggestions = v1Data?.suggestions ?? parsed.suggestions ?? [];
+          result.suggestions.push(...suggestions);
+          callbacks.onSuggestions?.(suggestions);
           break;
+        }
         case "tx_ready":
           if (this.verbose) process.stderr.write(`[SSE:tx_ready] raw: ${data.slice(0, 2e3)}
 `);
           {
-            const txReady = parsed;
+            const txReady = v1Data ?? parsed;
             result.transactions.push(txReady);
             callbacks.onTxReady?.(txReady);
           }
           break;
-        case "message":
-          result.message = parsed.message || parsed;
+        case "message": {
+          const msg = v1Data?.message ?? parsed.message ?? parsed;
+          result.message = msg;
           callbacks.onMessage?.(result.message);
           break;
+        }
         case "error": {
-          const msg = sseErrorToMessage(parsed.error);
+          const errorText = typeof parsed.errorText === "string" ? parsed.errorText : parsed.error;
+          const msg = sseErrorToMessage(errorText);
           const codeFromBackend = typeof parsed.code === "string" && isAgentErrorCode(parsed.code) ? parsed.code : inferAgentErrorCodeFromMessage(msg);
           callbacks.onError?.(msg, codeFromBackend);
           break;
@@ -4728,6 +6150,37 @@ var AgentClient = class {
       }
     }
   }
+  // Maps a V1 `type` field to the legacy event bucket used by handleSSEEvent's
+  // switch. Frame-level types (start, text-start, text-end, finish-step) and
+  // non-critical telemetry (data-tokens, data-usage, data-confirmation) route
+  // to 'ignore' which is a no-op.
+  mapV1EventType(type) {
+    switch (type) {
+      case "text-delta":
+        return "text_delta";
+      case "tool-input-start":
+      case "tool-input-available":
+      case "tool-input-delta":
+      case "tool-output-available":
+        return "tool_progress";
+      case "data-title":
+        return "title";
+      case "data-actions":
+        return "actions";
+      case "data-suggestions":
+        return "suggestions";
+      case "data-tx_ready":
+        return "tx_ready";
+      case "data-message":
+        return "message";
+      case "error":
+        return "error";
+      case "finish":
+        return "done";
+      default:
+        return "ignore";
+    }
+  }
   // ============================================================================
   // Calldata
   // ============================================================================
@@ -4922,9 +6375,9 @@ function getNativeTokenDecimals(chain) {
 }
 
 // src/agent/executor.ts
-import { Chain as Chain9, evmCall, fiatCurrencies as fiatCurrencies3, Vultisig as VultisigSdk } from "@vultisig/sdk";
+import { Chain as Chain10, evmCall, fiatCurrencies as fiatCurrencies3, Vultisig as VultisigSdk } from "@vultisig/sdk";
 
-// node_modules/viem/_esm/index.js
+// ../../node_modules/viem/_esm/index.js
 init_formatUnits();
 
 // src/core/VaultStateStore.ts
@@ -5102,7 +6555,10 @@ var AUTO_EXECUTE_ACTIONS = /* @__PURE__ */ new Set([
   "sign_tx",
   "sign_typed_data",
   "read_evm_contract",
-  "scan_tx"
+  "scan_tx",
+  "thorchain_pool_info",
+  "thorchain_add_liquidity",
+  "thorchain_remove_liquidity"
 ]);
 var PASSWORD_REQUIRED_ACTIONS = /* @__PURE__ */ new Set(["sign_tx", "sign_typed_data", "build_custom_tx"]);
 
@@ -5137,7 +6593,7 @@ var EVM_GAS_RPC = {
   Hyperliquid: "https://rpc.hyperliquid.xyz/evm",
   Sei: "https://evm-rpc.sei-apis.com"
 };
-var AgentExecutor = class {
+var AgentExecutor = class _AgentExecutor {
   vault;
   /** Owning SDK (optional); used for address book backed by app storage */
   vultisig;
@@ -5147,6 +6603,7 @@ var AgentExecutor = class {
   stateStore = null;
   /** Held chain lock release functions, keyed by chain name */
   chainLockReleases = /* @__PURE__ */ new Map();
+  evmLastBroadcast = /* @__PURE__ */ new Map();
   /** Backend client for resolving calldata_id references. */
   backendClient = null;
   constructor(vault, verbose = false, vaultId, vultisig) {
@@ -5187,7 +6644,7 @@ var AgentExecutor = class {
 `);
       return false;
     }
-    const chain = resolveChainFromTxReady(txReadyData) || Chain9.Ethereum;
+    const chain = resolveChainFromTxReady(txReadyData) || Chain10.Ethereum;
     this.pendingPayloads.clear();
     this.pendingPayloads.set("latest", {
       payload: { __serverTx: true, ...txReadyData },
@@ -5276,6 +6733,12 @@ var AgentExecutor = class {
         return this.scanTx(params);
       case "read_evm_contract":
         return this.readEvmContract(params);
+      case "thorchain_pool_info":
+        return this.thorchainPoolInfo(params);
+      case "thorchain_add_liquidity":
+        return this.thorchainAddLiquidity(params);
+      case "thorchain_remove_liquidity":
+        return this.thorchainRemoveLiquidity(params);
       default:
         throw new Error(
           `Action type '${action.type}' is not implemented locally. The backend may handle this action server-side.`
@@ -5545,6 +7008,227 @@ var AgentExecutor = class {
       throw err;
     }
   }
+  // ============================================================================
+  // THORChain LP (RUNE-side asym add / remove via prepareSendTx + memo)
+  // ============================================================================
+  /**
+   * Pool stats from Midgard (no signing). Optional `pool` filters to one row.
+   */
+  async thorchainPoolInfo(params) {
+    const { assertValidPoolId: assertValidPoolId2, getThorchainPools: getThorchainPools2, thorchainMidgardBaseUrl: thorchainMidgardBaseUrl2 } = await Promise.resolve().then(() => (init_lp(), lp_exports));
+    const statusRaw = params.status;
+    let poolFetchOpts = {};
+    if (statusRaw === null || String(statusRaw).toLowerCase() === "all") {
+      poolFetchOpts = { status: null };
+    } else if (statusRaw !== void 0) {
+      poolFetchOpts = { status: String(statusRaw) };
+    }
+    const pools = await getThorchainPools2(poolFetchOpts);
+    const poolArg = params.pool;
+    if (poolArg) {
+      const normalized = poolArg.trim().toUpperCase();
+      assertValidPoolId2(normalized);
+      const row = pools.find((p) => p.asset.toUpperCase() === normalized);
+      return {
+        found: !!row,
+        pool_id: normalized,
+        summary: row ?? null,
+        midgard: thorchainMidgardBaseUrl2
+      };
+    }
+    const limitRaw = params.limit;
+    const limit = Math.min(500, Math.max(1, typeof limitRaw === "number" ? limitRaw : Number(limitRaw) || 80));
+    return {
+      pools: pools.slice(0, limit),
+      total: pools.length,
+      midgard: thorchainMidgardBaseUrl2
+    };
+  }
+  async thorchainAddLiquidity(params) {
+    const { assertValidPoolId: assertValidPoolId2, buildThorchainLpAddPayload: buildThorchainLpAddPayload2, resolvePairedAddressForLpAdd: resolvePairedAddressForLpAdd2 } = await Promise.resolve().then(() => (init_lp(), lp_exports));
+    const { getThorchainInboundAddress: getThorchainInboundAddress2 } = await Promise.resolve().then(() => (init_getThorchainInboundAddress(), getThorchainInboundAddress_exports));
+    const pool = this.normalizeThorchainPoolId(params.pool, assertValidPoolId2);
+    const amountStr = String(params.amount ?? "").trim();
+    if (!amountStr) {
+      throw new Error('amount is required (RUNE amount as a decimal string, e.g. "0.25")');
+    }
+    if (!/^\d+(\.\d+)?$/.test(amountStr)) {
+      throw new Error('amount must be a positive decimal string (no sign or scientific notation), e.g. "0.25"');
+    }
+    const [, frac = ""] = amountStr.split(".");
+    if (frac.length > 8) {
+      throw new Error("RUNE amount supports at most 8 decimal places");
+    }
+    const amountRuneBaseUnits = parseAmount(amountStr, 8);
+    if (amountRuneBaseUnits <= 0n) {
+      throw new Error("amount must be greater than zero");
+    }
+    let pairedAddress = params.paired_address?.trim() || void 0;
+    const autoPairRaw = params.auto_pair ?? params.autoPair;
+    const autoPairDisabled = autoPairRaw === false || autoPairRaw === 0 || typeof autoPairRaw === "string" && ["false", "0"].includes(autoPairRaw.toLowerCase());
+    const autoPair = !pairedAddress && !autoPairDisabled;
+    if (autoPair) {
+      const vaultAddresses = await this.buildVaultAddressMap();
+      pairedAddress = resolvePairedAddressForLpAdd2({
+        pool,
+        side: "rune",
+        vaultAddresses
+      }) || void 0;
+    }
+    const lpPayload = buildThorchainLpAddPayload2({
+      pool,
+      amountRuneBaseUnits: amountRuneBaseUnits.toString(),
+      ...pairedAddress ? { pairedAddress } : {}
+    });
+    const receiver = await this.getThorchainNativeInboundAddress(getThorchainInboundAddress2);
+    const address = await this.vault.address(Chain10.THORChain);
+    const coin = {
+      chain: Chain10.THORChain,
+      address,
+      decimals: 8,
+      ticker: "RUNE"
+    };
+    const payload = await this.vault.prepareSendTx({
+      coin,
+      receiver,
+      amount: BigInt(lpPayload.amount),
+      memo: lpPayload.memo
+    });
+    const messageHashes = await this.vault.extractMessageHashes(payload);
+    this.pendingPayloads.clear();
+    const payloadId = `tc_lp_add_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this.pendingPayloads.set(payloadId, {
+      payload,
+      coin,
+      chain: Chain10.THORChain,
+      timestamp: Date.now()
+    });
+    this.pendingPayloads.set("latest", {
+      payload,
+      coin,
+      chain: Chain10.THORChain,
+      timestamp: Date.now()
+    });
+    return {
+      keysign_payload: payloadId,
+      chain: "THORChain",
+      pool: lpPayload.pool,
+      memo: lpPayload.memo,
+      amount_rune: amountStr,
+      paired_address: pairedAddress,
+      inbound_receiver: receiver,
+      sender: address,
+      message_hashes: messageHashes
+    };
+  }
+  async thorchainRemoveLiquidity(params) {
+    const { assertValidPoolId: assertValidPoolId2, buildThorchainLpRemovePayload: buildThorchainLpRemovePayload2 } = await Promise.resolve().then(() => (init_lp(), lp_exports));
+    const { getThorchainInboundAddress: getThorchainInboundAddress2 } = await Promise.resolve().then(() => (init_getThorchainInboundAddress(), getThorchainInboundAddress_exports));
+    const pool = this.normalizeThorchainPoolId(params.pool, assertValidPoolId2);
+    let basisPoints;
+    if (params.basis_points != null) {
+      basisPoints = Number(params.basis_points);
+    } else if (params.basisPoints != null) {
+      basisPoints = Number(params.basisPoints);
+    }
+    if (basisPoints == null && params.withdraw_percent != null) {
+      const pct = Number(params.withdraw_percent);
+      if (Number.isFinite(pct)) {
+        basisPoints = Math.round(pct * 100);
+      }
+    }
+    if (basisPoints == null || !Number.isInteger(basisPoints)) {
+      throw new Error("basis_points (integer 1\u201310000) or withdraw_percent (0.01\u2013100, maps to basis points) is required");
+    }
+    let withdrawToAsset = params.withdraw_to_asset?.trim();
+    if (!withdrawToAsset && params.withdrawToAsset) {
+      withdrawToAsset = String(params.withdrawToAsset).trim();
+    }
+    if (withdrawToAsset) {
+      withdrawToAsset = withdrawToAsset.toUpperCase();
+    }
+    const lpPayload = buildThorchainLpRemovePayload2({
+      pool,
+      basisPoints,
+      ...withdrawToAsset ? { withdrawToAsset } : {}
+    });
+    const receiver = await this.getThorchainNativeInboundAddress(getThorchainInboundAddress2);
+    const address = await this.vault.address(Chain10.THORChain);
+    const coin = {
+      chain: Chain10.THORChain,
+      address,
+      decimals: 8,
+      ticker: "RUNE"
+    };
+    const payload = await this.vault.prepareSendTx({
+      coin,
+      receiver,
+      amount: BigInt(lpPayload.amount),
+      memo: lpPayload.memo
+    });
+    const messageHashes = await this.vault.extractMessageHashes(payload);
+    this.pendingPayloads.clear();
+    const payloadId = `tc_lp_rm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this.pendingPayloads.set(payloadId, {
+      payload,
+      coin,
+      chain: Chain10.THORChain,
+      timestamp: Date.now()
+    });
+    this.pendingPayloads.set("latest", {
+      payload,
+      coin,
+      chain: Chain10.THORChain,
+      timestamp: Date.now()
+    });
+    return {
+      keysign_payload: payloadId,
+      chain: "THORChain",
+      pool: lpPayload.pool,
+      memo: lpPayload.memo,
+      basis_points: basisPoints,
+      withdraw_to_asset: withdrawToAsset || void 0,
+      dust_rune_base_units: lpPayload.amount,
+      inbound_receiver: receiver,
+      sender: address,
+      message_hashes: messageHashes
+    };
+  }
+  normalizeThorchainPoolId(raw, assertValidPoolId2) {
+    const pool = String(raw ?? "").trim();
+    if (!pool) {
+      throw new Error('pool is required (e.g. "BTC.BTC")');
+    }
+    const upper = pool.toUpperCase();
+    assertValidPoolId2(upper);
+    return upper;
+  }
+  async buildVaultAddressMap() {
+    const map = {};
+    for (const c of this.vault.chains) {
+      try {
+        map[c] = await this.vault.address(c);
+      } catch {
+      }
+    }
+    return map;
+  }
+  /** THORChain protocol vault for native RUNE deposits (SWAP/LP memos). Matches SDK e2e fixture. */
+  static THORCHAIN_RUNE_DEPOSIT_ADDRESS = "thor1g98cy3n9mmjrpn0sxmn63lztelera37n8n67c0";
+  async getThorchainNativeInboundAddress(getInbound) {
+    const rows = await getInbound();
+    const thor = rows.find((r) => r.chain.toUpperCase() === "THOR");
+    if (thor?.address) {
+      return thor.address;
+    }
+    if (this.verbose) {
+      process.stderr.write(
+        `[thorchain_lp] THOR inbound row missing; using static RUNE deposit vault ${_AgentExecutor.THORCHAIN_RUNE_DEPOSIT_ADDRESS}
+`
+      );
+    }
+    return _AgentExecutor.THORCHAIN_RUNE_DEPOSIT_ADDRESS;
+  }
   async buildTx(params) {
     if (params.calldata_id && !params.data && this.backendClient) {
       const id = params.calldata_id;
@@ -5576,7 +7260,7 @@ var AgentExecutor = class {
       if (!stored) {
         throw new Error("Could not stage calldata transaction for signing (invalid or empty tx payload)");
       }
-      const chain = resolveChain(params.chain) || Chain9.Ethereum;
+      const chain = resolveChain(params.chain) || Chain10.Ethereum;
       const address = await this.vault.address(chain);
       return {
         status: "ready",
@@ -5693,6 +7377,7 @@ var AgentExecutor = class {
         keysignPayload: payload,
         signature
       });
+      this.evmLastBroadcast.set(chain.toString(), Date.now());
       try {
         this.recordEvmNonceFromPayload(chain, payload, messageHashes.length);
       } catch (nonceErr) {
@@ -5790,6 +7475,7 @@ var AgentExecutor = class {
         keysignPayload,
         signature
       });
+      this.evmLastBroadcast.set(chain.toString(), Date.now());
       try {
         this.recordEvmNonceFromPayload(chain, keysignPayload, messageHashes.length);
       } catch (nonceErr) {
@@ -5948,6 +7634,16 @@ var AgentExecutor = class {
     const rpcNonce = bs.value.nonce;
     const nextNonce = this.stateStore.getNextEvmNonce(chain, rpcNonce);
     if (nextNonce !== rpcNonce) {
+      const lastBroadcast = this.evmLastBroadcast.get(chain.toString()) ?? 0;
+      if (Date.now() - lastBroadcast < 15e3) {
+        if (this.verbose)
+          process.stderr.write(
+            `[nonce] Keeping local nonce ${nextNonce} for ${chain} (broadcast ${Date.now() - lastBroadcast}ms ago)
+`
+          );
+        bs.value.nonce = nextNonce;
+        return;
+      }
       const pendingNonce = await this.fetchEvmPendingNonce(chain);
       if (pendingNonce !== null && pendingNonce === rpcNonce) {
         if (this.verbose)
@@ -6115,11 +7811,11 @@ var AgentExecutor = class {
 `);
     const chainName = params.chain;
     const chainId = domain.chainId;
-    let chain = Chain9.Ethereum;
+    let chain = Chain10.Ethereum;
     if (chainName) {
-      chain = resolveChain(chainName) || Chain9.Ethereum;
+      chain = resolveChain(chainName) || Chain10.Ethereum;
     } else if (chainId) {
-      chain = resolveChainId(chainId) || Chain9.Ethereum;
+      chain = resolveChainId(chainId) || Chain10.Ethereum;
     }
     const sigResult = await this.vault.signBytes({
       data: eip712Hash,
@@ -6189,7 +7885,7 @@ var AgentExecutor = class {
       return { tokens };
     }
     const out = [];
-    for (const c of Object.values(Chain9)) {
+    for (const c of Object.values(Chain10)) {
       for (const t of VultisigSdk.getKnownTokens(c)) {
         if (!tokenMatchesQuery(t)) continue;
         out.push(t);
@@ -6272,11 +7968,11 @@ function abiEncodeParam(type, value) {
 }
 function resolveChain(name) {
   if (!name) return null;
-  if (Object.values(Chain9).includes(name)) {
+  if (Object.values(Chain10).includes(name)) {
     return name;
   }
   const lower = name.toLowerCase();
-  for (const [, value] of Object.entries(Chain9)) {
+  for (const [, value] of Object.entries(Chain10)) {
     if (typeof value === "string" && value.toLowerCase() === lower) {
       return value;
     }
@@ -6302,7 +7998,7 @@ function resolveChain(name) {
     xrp: "Ripple"
   };
   const aliased = aliases[lower];
-  if (aliased && Object.values(Chain9).includes(aliased)) {
+  if (aliased && Object.values(Chain10).includes(aliased)) {
     return aliased;
   }
   return null;
@@ -6336,16 +8032,16 @@ function resolveChainId(chainId) {
   const id = typeof chainId === "string" ? parseInt(chainId, 10) : chainId;
   if (isNaN(id)) return null;
   const chainIdMap = {
-    1: Chain9.Ethereum,
-    56: Chain9.BSC,
-    137: Chain9.Polygon,
-    43114: Chain9.Avalanche,
-    42161: Chain9.Arbitrum,
-    10: Chain9.Optimism,
-    8453: Chain9.Base,
-    81457: Chain9.Blast,
-    324: Chain9.Zksync,
-    25: Chain9.CronosChain
+    1: Chain10.Ethereum,
+    56: Chain10.BSC,
+    137: Chain10.Polygon,
+    43114: Chain10.Avalanche,
+    42161: Chain10.Arbitrum,
+    10: Chain10.Optimism,
+    8453: Chain10.Base,
+    81457: Chain10.Blast,
+    324: Chain10.Zksync,
+    25: Chain10.CronosChain
   };
   return chainIdMap[id] || null;
 }
@@ -7524,15 +9220,13 @@ async function executeAgentAsk(ctx2, message, options) {
     const callbacks = ask.getCallbacks();
     await session.initialize(callbacks);
     const result = await ask.ask(message);
-    if (options.json) {
-      process.stdout.write(
-        JSON.stringify({
-          session_id: result.sessionId,
-          response: result.response,
-          tool_calls: result.toolCalls,
-          transactions: result.transactions
-        }) + "\n"
-      );
+    if (options.json || isJsonOutput()) {
+      outputJson({
+        session_id: result.sessionId,
+        response: result.response,
+        tool_calls: result.toolCalls,
+        transactions: result.transactions
+      });
     } else {
       process.stdout.write(`session:${result.sessionId}
 `);
@@ -7598,46 +9292,294 @@ async function executeAgentSessionsList(ctx2, options) {
     printResult("No sessions found.");
     return;
   }
-  const table = new Table({
-    head: [chalk9.cyan("ID"), chalk9.cyan("Title"), chalk9.cyan("Created"), chalk9.cyan("Updated")]
-  });
-  for (const conv of allConversations) {
-    table.push([
-      conv.id,
-      conv.title || chalk9.gray("(untitled)"),
-      formatDate(conv.created_at),
-      formatDate(conv.updated_at)
-    ]);
+  const table = new Table({
+    head: [chalk9.cyan("ID"), chalk9.cyan("Title"), chalk9.cyan("Created"), chalk9.cyan("Updated")]
+  });
+  for (const conv of allConversations) {
+    table.push([
+      conv.id,
+      conv.title || chalk9.gray("(untitled)"),
+      formatDate(conv.created_at),
+      formatDate(conv.updated_at)
+    ]);
+  }
+  printResult(table.toString());
+  printResult(chalk9.gray(`
+  ${totalCount} session(s) total`));
+}
+async function executeAgentSessionsDelete(ctx2, sessionId, options) {
+  const vault = await ctx2.ensureActiveVault();
+  const backendUrl = options.backendUrl || process.env.VULTISIG_AGENT_URL || "https://abe.vultisig.com";
+  const client = await createAuthenticatedClient(backendUrl, vault, options.password);
+  const publicKey = vault.publicKeys.ecdsa;
+  await client.deleteConversation(sessionId, publicKey);
+  if (isJsonOutput()) {
+    outputJson({ deleted: sessionId });
+    return;
+  }
+  printResult(chalk9.green(`Session ${sessionId} deleted.`));
+}
+async function createAuthenticatedClient(backendUrl, vault, password) {
+  const client = new AgentClient(backendUrl);
+  const auth = await authenticateVault(client, vault, password);
+  client.setAuthToken(auth.token);
+  return client;
+}
+function formatDate(iso) {
+  try {
+    const d = new Date(iso);
+    return d.toLocaleDateString() + " " + d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  } catch {
+    return iso;
+  }
+}
+
+// src/lib/version.ts
+import chalk10 from "chalk";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var cachedVersion = null;
+function getVersion() {
+  if (cachedVersion) return cachedVersion;
+  if (true) {
+    cachedVersion = "0.17.0";
+    return cachedVersion;
+  }
+  try {
+    const packagePath = new URL("../../package.json", import.meta.url);
+    const pkg = JSON.parse(readFileSync3(packagePath, "utf-8"));
+    cachedVersion = pkg.version;
+    return cachedVersion;
+  } catch {
+    cachedVersion = "0.0.0-unknown";
+    return cachedVersion;
+  }
+}
+var CACHE_DIR = join3(homedir3(), ".vultisig", "cache");
+var VERSION_CACHE_FILE = join3(CACHE_DIR, "version-check.json");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function readVersionCache() {
+  try {
+    if (!existsSync2(VERSION_CACHE_FILE)) return null;
+    const data = readFileSync3(VERSION_CACHE_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function writeVersionCache(cache) {
+  try {
+    if (!existsSync2(CACHE_DIR)) {
+      mkdirSync3(CACHE_DIR, { recursive: true });
+    }
+    writeFileSync3(VERSION_CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch("https://registry.npmjs.org/@vultisig/cli/latest", {
+      signal: controller.signal,
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isNewerVersion(v1, v2) {
+  const parse = (v) => {
+    const clean2 = v.replace(/^v/, "").replace(/-.*$/, "");
+    return clean2.split(".").map((n) => parseInt(n, 10) || 0);
+  };
+  const p1 = parse(v1);
+  const p2 = parse(v2);
+  for (let i = 0; i < 3; i++) {
+    const n1 = p1[i] ?? 0;
+    const n2 = p2[i] ?? 0;
+    if (n2 > n1) return true;
+    if (n2 < n1) return false;
+  }
+  if (v1.includes("-") && !v2.includes("-")) return true;
+  return false;
+}
+async function checkForUpdates() {
+  if (process.env.VULTISIG_NO_UPDATE_CHECK === "1") {
+    return null;
+  }
+  const currentVersion = getVersion();
+  const cache = readVersionCache();
+  if (cache && Date.now() - cache.lastCheck < CACHE_TTL_MS) {
+    return {
+      currentVersion,
+      latestVersion: cache.latestVersion,
+      updateAvailable: cache.latestVersion ? isNewerVersion(currentVersion, cache.latestVersion) : false
+    };
+  }
+  const latestVersion = await fetchLatestVersion();
+  writeVersionCache({
+    lastCheck: Date.now(),
+    latestVersion
+  });
+  return {
+    currentVersion,
+    latestVersion,
+    updateAvailable: latestVersion ? isNewerVersion(currentVersion, latestVersion) : false
+  };
+}
+function formatVersionShort() {
+  return `vultisig/${getVersion()}`;
+}
+function formatVersionDetailed() {
+  const lines = [];
+  lines.push(chalk10.bold(`Vultisig CLI v${getVersion()}`));
+  lines.push("");
+  lines.push(`  Node.js:   ${process.version}`);
+  lines.push(`  Platform:  ${process.platform}-${process.arch}`);
+  lines.push(`  Config:    ~/.vultisig/`);
+  return lines.join("\n");
+}
+function detectInstallMethod() {
+  const execPath = process.execPath;
+  if (execPath.includes("homebrew") || execPath.includes("Cellar")) {
+    return "homebrew";
+  }
+  if (process.env.npm_execpath?.includes("yarn")) {
+    return "yarn";
+  }
+  if (process.env.npm_config_user_agent?.includes("npm")) {
+    return "npm";
+  }
+  if (execPath.includes("node_modules")) {
+    return "npm";
+  }
+  return "unknown";
+}
+function getUpdateCommand() {
+  const method = detectInstallMethod();
+  switch (method) {
+    case "npm":
+      return "npm update -g @vultisig/cli";
+    case "yarn":
+      return "yarn global upgrade @vultisig/cli";
+    case "homebrew":
+      return "brew upgrade vultisig";
+    default:
+      return "npm update -g @vultisig/cli";
   }
-  printResult(table.toString());
-  printResult(chalk9.gray(`
-  ${totalCount} session(s) total`));
 }
-async function executeAgentSessionsDelete(ctx2, sessionId, options) {
-  const vault = await ctx2.ensureActiveVault();
-  const backendUrl = options.backendUrl || process.env.VULTISIG_AGENT_URL || "https://abe.vultisig.com";
-  const client = await createAuthenticatedClient(backendUrl, vault, options.password);
-  const publicKey = vault.publicKeys.ecdsa;
-  await client.deleteConversation(sessionId, publicKey);
-  if (isJsonOutput()) {
-    outputJson({ deleted: sessionId });
-    return;
+
+// src/commands/schema.ts
+var COMMAND_EXAMPLES = {
+  balance: {
+    examples: [
+      "vultisig balance",
+      "vultisig balance Ethereum --tokens",
+      "vultisig balance --output json --fields amount,symbol"
+    ]
+  },
+  addresses: {
+    examples: ["vultisig addresses", "vultisig addresses --output json"]
+  },
+  send: {
+    examples: [
+      "vultisig send Ethereum 0x... 0.1",
+      "vultisig send Bitcoin bc1q... --max --yes",
+      "vultisig send Ethereum 0x... 0.5 --dry-run --output json"
+    ]
+  },
+  execute: {
+    examples: [`vultisig execute THORChain <contract> '{"swap":{}}'`]
+  },
+  "swap-quote": {
+    examples: ["vultisig swap-quote Ethereum Bitcoin 0.1 --output json"]
+  },
+  vaults: {
+    examples: ["vultisig vaults", "vultisig vaults --output json"]
+  },
+  chains: {
+    examples: ["vultisig chains", "vultisig chains --add Solana"]
+  },
+  import: {
+    examples: ["vultisig import ~/vault.vult", "vultisig import ~/vault.vult --password secret"]
+  },
+  export: {
+    examples: ["vultisig export ~/backup.vult"]
+  },
+  "create.fast": {
+    examples: ["vultisig create fast --name mywallet --password secret --email me@example.com"]
+  },
+  "agent.ask": {
+    examples: [
+      'vultisig agent ask "What is my ETH balance?" --output json',
+      'vultisig agent ask "Send 0.1 ETH to 0x..." --session abc123'
+    ]
   }
-  printResult(chalk9.green(`Session ${sessionId} deleted.`));
+};
+var GLOBAL_ENUM_VALUES = {
+  "--output": ["json", "table"]
+};
+function mapOption(o, enumValues) {
+  return {
+    flags: o.flags,
+    description: o.description,
+    required: !!o.mandatory,
+    defaultValue: o.defaultValue,
+    ...enumValues?.[o.long] ? { enumValues: enumValues[o.long] } : {}
+  };
 }
-async function createAuthenticatedClient(backendUrl, vault, password) {
-  const client = new AgentClient(backendUrl);
-  const auth = await authenticateVault(client, vault, password);
-  client.setAuthToken(auth.token);
-  return client;
+function mapArguments(cmd) {
+  const args = cmd.registeredArguments;
+  if (!args?.length) return void 0;
+  return args.map((a) => ({
+    name: a._name ?? a.name?.(),
+    required: a.required,
+    description: a.description
+  }));
 }
-function formatDate(iso) {
-  try {
-    const d = new Date(iso);
-    return d.toLocaleDateString() + " " + d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
-  } catch {
-    return iso;
-  }
+function executeSchema(prog) {
+  const schema = {
+    name: prog.name(),
+    version: getVersion(),
+    exitCodes: Object.fromEntries(Object.entries(EXIT_CODE_DESCRIPTIONS).map(([k, v]) => [String(k), v])),
+    globalOptions: prog.options.filter((o) => !o.hidden).map((o) => mapOption(o, GLOBAL_ENUM_VALUES)),
+    commands: prog.commands.filter((c) => !c._hidden).map((c) => {
+      const meta = COMMAND_EXAMPLES[c.name()];
+      const args = mapArguments(c);
+      return {
+        name: c.name(),
+        description: c.description(),
+        ...args ? { arguments: args } : {},
+        options: c.options.filter((o) => !o.hidden && o.long !== "--help").map((o) => mapOption(o, meta?.enumValues)),
+        ...meta?.examples ? { examples: meta.examples } : {},
+        subcommands: c.commands.length ? c.commands.map((sub) => {
+          const subMeta = COMMAND_EXAMPLES[`${c.name()}.${sub.name()}`];
+          const subArgs = mapArguments(sub);
+          return {
+            name: sub.name(),
+            description: sub.description(),
+            ...subArgs ? { arguments: subArgs } : {},
+            options: sub.options.filter((o) => !o.hidden && o.long !== "--help").map((o) => ({
+              flags: o.flags,
+              description: o.description,
+              required: !!o.mandatory
+            })),
+            ...subMeta?.examples ? { examples: subMeta.examples } : {}
+          };
+        }) : void 0
+      };
+    })
+  };
+  process.stdout.write(`${JSON.stringify(schema, null, 2)}
+`);
 }
 
 // src/core/server-endpoints.ts
@@ -7684,7 +9626,7 @@ function readArgValue(args, optionName) {
 }
 
 // src/interactive/completer.ts
-import { Chain as Chain10 } from "@vultisig/sdk";
+import { Chain as Chain11 } from "@vultisig/sdk";
 import fs3 from "fs";
 import path3 from "path";
 var COMMANDS = [
@@ -7828,7 +9770,7 @@ function completeVaultName(ctx2, partial) {
   return [show, partial];
 }
 function completeChainName(partial) {
-  const allChains = Object.values(Chain10);
+  const allChains = Object.values(Chain11);
   const partialLower = partial.toLowerCase();
   const matches = allChains.filter((chain) => chain.toLowerCase().startsWith(partialLower));
   matches.sort();
@@ -7836,14 +9778,14 @@ function completeChainName(partial) {
   return [show, partial];
 }
 function findChainByName(name) {
-  const allChains = Object.values(Chain10);
+  const allChains = Object.values(Chain11);
   const nameLower = name.toLowerCase();
   const found = allChains.find((chain) => chain.toLowerCase() === nameLower);
   return found ? found : null;
 }
 
 // src/interactive/event-buffer.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 var EventBuffer = class {
   eventBuffer = [];
   isCommandRunning = false;
@@ -7883,17 +9825,17 @@ var EventBuffer = class {
   displayEvent(message, type) {
     switch (type) {
       case "success":
-        console.log(chalk10.green(message));
+        console.log(chalk11.green(message));
         break;
       case "warning":
-        console.log(chalk10.yellow(message));
+        console.log(chalk11.yellow(message));
         break;
       case "error":
-        console.error(chalk10.red(message));
+        console.error(chalk11.red(message));
         break;
       case "info":
       default:
-        console.log(chalk10.blue(message));
+        console.log(chalk11.blue(message));
         break;
     }
   }
@@ -7904,13 +9846,13 @@ var EventBuffer = class {
     if (this.eventBuffer.length === 0) {
       return;
     }
-    console.log(chalk10.gray("\n--- Background Events ---"));
+    console.log(chalk11.gray("\n--- Background Events ---"));
     this.eventBuffer.forEach((event) => {
       const timeStr = event.timestamp.toLocaleTimeString();
       const message = `[${timeStr}] ${event.message}`;
       this.displayEvent(message, event.type);
     });
-    console.log(chalk10.gray("--- End Events ---\n"));
+    console.log(chalk11.gray("--- End Events ---\n"));
   }
   /**
    * Setup all vault event listeners
@@ -8020,12 +9962,12 @@ var EventBuffer = class {
 
 // src/interactive/session.ts
 import { fiatCurrencies as fiatCurrencies4 } from "@vultisig/sdk";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 import ora3 from "ora";
 import * as readline3 from "readline";
 
 // src/interactive/shell-commands.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import Table2 from "cli-table3";
 import inquirer6 from "inquirer";
 import ora2 from "ora";
@@ -8042,25 +9984,25 @@ function formatTimeRemaining(ms) {
 async function executeLock(ctx2) {
   const vault = ctx2.getActiveVault();
   if (!vault) {
-    console.log(chalk11.red("No active vault."));
-    console.log(chalk11.yellow('Use "vault <name>" to switch to a vault first.'));
+    console.log(chalk12.red("No active vault."));
+    console.log(chalk12.yellow('Use "vault <name>" to switch to a vault first.'));
     return;
   }
   ctx2.lockVault(vault.id);
-  console.log(chalk11.green("\n+ Vault locked"));
-  console.log(chalk11.gray("Password cache cleared. You will need to enter the password again."));
+  console.log(chalk12.green("\n+ Vault locked"));
+  console.log(chalk12.gray("Password cache cleared. You will need to enter the password again."));
 }
 async function executeUnlock(ctx2) {
   const vault = ctx2.getActiveVault();
   if (!vault) {
-    console.log(chalk11.red("No active vault."));
-    console.log(chalk11.yellow('Use "vault <name>" to switch to a vault first.'));
+    console.log(chalk12.red("No active vault."));
+    console.log(chalk12.yellow('Use "vault <name>" to switch to a vault first.'));
     return;
   }
   if (ctx2.isVaultUnlocked(vault.id)) {
     const timeRemaining = ctx2.getUnlockTimeRemaining(vault.id);
-    console.log(chalk11.yellow("\nVault is already unlocked."));
-    console.log(chalk11.gray(`Time remaining: ${formatTimeRemaining(timeRemaining)}`));
+    console.log(chalk12.yellow("\nVault is already unlocked."));
+    console.log(chalk12.gray(`Time remaining: ${formatTimeRemaining(timeRemaining)}`));
     return;
   }
   const { password } = await inquirer6.prompt([
@@ -8077,19 +10019,19 @@ async function executeUnlock(ctx2) {
     ctx2.cachePassword(vault.id, password);
     const timeRemaining = ctx2.getUnlockTimeRemaining(vault.id);
     spinner.succeed("Vault unlocked");
-    console.log(chalk11.green(`
+    console.log(chalk12.green(`
 + Vault unlocked for ${formatTimeRemaining(timeRemaining)}`));
   } catch (err) {
     spinner.fail("Failed to unlock vault");
-    console.error(chalk11.red(`
+    console.error(chalk12.red(`
 x ${err.message}`));
   }
 }
 async function executeStatus(ctx2) {
   const vault = ctx2.getActiveVault();
   if (!vault) {
-    console.log(chalk11.red("No active vault."));
-    console.log(chalk11.yellow('Use "vault <name>" to switch to a vault first.'));
+    console.log(chalk12.red("No active vault."));
+    console.log(chalk12.yellow('Use "vault <name>" to switch to a vault first.'));
     return;
   }
   const isUnlocked = ctx2.isVaultUnlocked(vault.id);
@@ -8120,30 +10062,30 @@ async function executeStatus(ctx2) {
   displayStatus(status);
 }
 function displayStatus(status) {
-  console.log(chalk11.cyan("\n+----------------------------------------+"));
-  console.log(chalk11.cyan("|            Vault Status                |"));
-  console.log(chalk11.cyan("+----------------------------------------+\n"));
-  console.log(chalk11.bold("Vault:"));
-  console.log(`  Name:     ${chalk11.green(status.name)}`);
+  console.log(chalk12.cyan("\n+----------------------------------------+"));
+  console.log(chalk12.cyan("|            Vault Status                |"));
+  console.log(chalk12.cyan("+----------------------------------------+\n"));
+  console.log(chalk12.bold("Vault:"));
+  console.log(`  Name:     ${chalk12.green(status.name)}`);
   console.log(`  ID:       ${status.id}`);
-  console.log(`  Type:     ${chalk11.yellow(status.type)}`);
-  console.log(chalk11.bold("\nSecurity:"));
+  console.log(`  Type:     ${chalk12.yellow(status.type)}`);
+  console.log(chalk12.bold("\nSecurity:"));
   if (status.isUnlocked) {
-    console.log(`  Status:   ${chalk11.green("Unlocked")} ${chalk11.green("\u{1F513}")}`);
+    console.log(`  Status:   ${chalk12.green("Unlocked")} ${chalk12.green("\u{1F513}")}`);
     console.log(`  Expires:  ${status.timeRemainingFormatted}`);
   } else {
-    console.log(`  Status:   ${chalk11.yellow("Locked")} ${chalk11.yellow("\u{1F512}")}`);
+    console.log(`  Status:   ${chalk12.yellow("Locked")} ${chalk12.yellow("\u{1F512}")}`);
   }
-  console.log(`  Encrypted: ${status.isEncrypted ? chalk11.green("Yes") : chalk11.gray("No")}`);
-  console.log(`  Backed Up: ${status.isBackedUp ? chalk11.green("Yes") : chalk11.yellow("No")}`);
-  console.log(chalk11.bold("\nMPC Configuration:"));
+  console.log(`  Encrypted: ${status.isEncrypted ? chalk12.green("Yes") : chalk12.gray("No")}`);
+  console.log(`  Backed Up: ${status.isBackedUp ? chalk12.green("Yes") : chalk12.yellow("No")}`);
+  console.log(chalk12.bold("\nMPC Configuration:"));
   console.log(`  Library:   ${status.libType}`);
-  console.log(`  Threshold: ${chalk11.cyan(status.threshold)} of ${chalk11.cyan(status.totalSigners)}`);
-  console.log(chalk11.bold("\nSigning Modes:"));
+  console.log(`  Threshold: ${chalk12.cyan(status.threshold)} of ${chalk12.cyan(status.totalSigners)}`);
+  console.log(chalk12.bold("\nSigning Modes:"));
   status.availableSigningModes.forEach((mode) => {
     console.log(`  - ${mode}`);
   });
-  console.log(chalk11.bold("\nDetails:"));
+  console.log(chalk12.bold("\nDetails:"));
   console.log(`  Chains:   ${status.chains}`);
   console.log(`  Currency: ${status.currency.toUpperCase()}`);
   console.log(`  Created:  ${new Date(status.createdAt).toLocaleString()}`);
@@ -8152,7 +10094,7 @@ function displayStatus(status) {
 }
 function showHelp() {
   const table = new Table2({
-    head: [chalk11.bold("Available Commands")],
+    head: [chalk12.bold("Available Commands")],
     colWidths: [50],
     chars: {
       mid: "",
@@ -8166,7 +10108,7 @@ function showHelp() {
     }
   });
   table.push(
-    [chalk11.bold("Vault Management:")],
+    [chalk12.bold("Vault Management:")],
     ["  vaults              - List all vaults"],
     ["  vault <name>        - Switch to vault"],
     ["  import <file>       - Import vault from file"],
@@ -8175,7 +10117,7 @@ function showHelp() {
     ["  info                - Show vault details"],
     ["  export [path]       - Export vault to file"],
     [""],
-    [chalk11.bold("Wallet Operations:")],
+    [chalk12.bold("Wallet Operations:")],
     ["  balance [chain]     - Show balances"],
     ["  send <chain> <to> <amount> - Send transaction"],
     ["  tx-status <chain> <txHash> - Check transaction status"],
@@ -8184,22 +10126,22 @@ function showHelp() {
     ["  chains [--add/--remove/--add-all] - Manage chains"],
     ["  tokens <chain>      - Manage tokens"],
     [""],
-    [chalk11.bold("Swap Operations:")],
+    [chalk12.bold("Swap Operations:")],
     ["  swap-chains         - List swap-enabled chains"],
     ["  swap-quote <from> <to> <amount> - Get quote"],
     ["  swap <from> <to> <amount> - Execute swap"],
     [""],
-    [chalk11.bold("Session Commands (shell only):")],
+    [chalk12.bold("Session Commands (shell only):")],
     ["  lock                - Lock vault"],
     ["  unlock              - Unlock vault"],
     ["  status              - Show vault status"],
     [""],
-    [chalk11.bold("Settings:")],
+    [chalk12.bold("Settings:")],
     ["  currency [code]     - View/set currency"],
     ["  server              - Check server status"],
     ["  address-book        - Manage saved addresses"],
     [""],
-    [chalk11.bold("Help & Navigation:")],
+    [chalk12.bold("Help & Navigation:")],
     ["  help, ?             - Show this help"],
     ["  .clear              - Clear screen"],
     ["  .exit               - Exit shell"]
@@ -8337,12 +10279,12 @@ var ShellSession = class {
    */
   async start() {
     console.clear();
-    console.log(chalk12.cyan.bold("\n=============================================="));
-    console.log(chalk12.cyan.bold("         Vultisig Interactive Shell"));
-    console.log(chalk12.cyan.bold("==============================================\n"));
+    console.log(chalk13.cyan.bold("\n=============================================="));
+    console.log(chalk13.cyan.bold("         Vultisig Interactive Shell"));
+    console.log(chalk13.cyan.bold("==============================================\n"));
     await this.loadAllVaults();
     this.displayVaultList();
-    console.log(chalk12.gray('Type "help" for available commands, "exit" to quit\n'));
+    console.log(chalk13.gray('Type "help" for available commands, "exit" to quit\n'));
     this.promptLoop().catch(() => {
     });
   }
@@ -8376,12 +10318,12 @@ var ShellSession = class {
         const now = Date.now();
         if (now - this.lastSigintTime < this.DOUBLE_CTRL_C_TIMEOUT) {
           rl.close();
-          console.log(chalk12.yellow("\nGoodbye!"));
+          console.log(chalk13.yellow("\nGoodbye!"));
           this.ctx.dispose();
           process.exit(0);
         }
         this.lastSigintTime = now;
-        console.log(chalk12.yellow("\n(Press Ctrl+C again to exit)"));
+        console.log(chalk13.yellow("\n(Press Ctrl+C again to exit)"));
         rl.close();
         resolve("");
       });
@@ -8476,7 +10418,7 @@ var ShellSession = class {
       stopAllSpinners();
       process.stdout.write("\x1B[?25h");
       process.stdout.write("\r\x1B[K");
-      console.log(chalk12.yellow("\nCancelling operation..."));
+      console.log(chalk13.yellow("\nCancelling operation..."));
     };
     const cleanup = () => {
       process.removeListener("SIGINT", onSigint);
@@ -8513,10 +10455,10 @@ var ShellSession = class {
         stopAllSpinners();
         process.stdout.write("\x1B[?25h");
         process.stdout.write("\r\x1B[K");
-        console.log(chalk12.yellow("Operation cancelled"));
+        console.log(chalk13.yellow("Operation cancelled"));
         return;
       }
-      console.error(chalk12.red(`
+      console.error(chalk13.red(`
 Error: ${error2.message}`));
     }
   }
@@ -8549,7 +10491,7 @@ Error: ${error2.message}`));
         break;
       case "rename":
         if (args.length === 0) {
-          console.log(chalk12.yellow("Usage: rename <newName>"));
+          console.log(chalk13.yellow("Usage: rename <newName>"));
           return;
         }
         await executeRename(this.ctx, args.join(" "));
@@ -8625,41 +10567,41 @@ Error: ${error2.message}`));
       // Exit
       case "exit":
       case "quit":
-        console.log(chalk12.yellow("\nGoodbye!"));
+        console.log(chalk13.yellow("\nGoodbye!"));
         this.ctx.dispose();
         process.exit(0);
         break;
       // eslint requires break even after process.exit
       default:
-        console.log(chalk12.yellow(`Unknown command: ${command}`));
-        console.log(chalk12.gray('Type "help" for available commands'));
+        console.log(chalk13.yellow(`Unknown command: ${command}`));
+        console.log(chalk13.gray('Type "help" for available commands'));
         break;
     }
   }
   // ===== Command Helpers =====
   async switchVault(args) {
     if (args.length === 0) {
-      console.log(chalk12.yellow("Usage: vault <name>"));
-      console.log(chalk12.gray('Run "vaults" to see available vaults'));
+      console.log(chalk13.yellow("Usage: vault <name>"));
+      console.log(chalk13.gray('Run "vaults" to see available vaults'));
       return;
     }
     const vaultName = args.join(" ");
     const vault = this.ctx.findVaultByName(vaultName);
     if (!vault) {
-      console.log(chalk12.red(`Vault not found: ${vaultName}`));
-      console.log(chalk12.gray('Run "vaults" to see available vaults'));
+      console.log(chalk13.red(`Vault not found: ${vaultName}`));
+      console.log(chalk13.gray('Run "vaults" to see available vaults'));
       return;
     }
     await this.ctx.setActiveVault(vault);
-    console.log(chalk12.green(`
+    console.log(chalk13.green(`
 + Switched to: ${vault.name}`));
     const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
-    const status = isUnlocked ? chalk12.green("Unlocked") : chalk12.yellow("Locked");
+    const status = isUnlocked ? chalk13.green("Unlocked") : chalk13.yellow("Locked");
     console.log(`Status: ${status}`);
   }
   async importVault(args) {
     if (args.length === 0) {
-      console.log(chalk12.yellow("Usage: import <file>"));
+      console.log(chalk13.yellow("Usage: import <file>"));
       return;
     }
     const filePath = args.join(" ");
@@ -8674,45 +10616,45 @@ Error: ${error2.message}`));
   async createVault(args) {
     const type = args[0]?.toLowerCase();
     if (!type || type !== "fast" && type !== "secure") {
-      console.log(chalk12.yellow("Usage: create <fast|secure>"));
-      console.log(chalk12.gray("  create fast   - Create a fast vault (server-assisted 2-of-2)"));
-      console.log(chalk12.gray("  create secure - Create a secure vault (multi-device MPC)"));
+      console.log(chalk13.yellow("Usage: create <fast|secure>"));
+      console.log(chalk13.gray("  create fast   - Create a fast vault (server-assisted 2-of-2)"));
+      console.log(chalk13.gray("  create secure - Create a secure vault (multi-device MPC)"));
       return;
     }
     let vault;
     if (type === "fast") {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk12.red("Name is required"));
+        console.log(chalk13.red("Name is required"));
         return;
       }
       const password = await this.promptPassword("Vault password");
       if (!password) {
-        console.log(chalk12.red("Password is required"));
+        console.log(chalk13.red("Password is required"));
         return;
       }
       const email = await this.prompt("Email for verification");
       if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-        console.log(chalk12.red("Valid email is required"));
+        console.log(chalk13.red("Valid email is required"));
         return;
       }
       vault = await this.withCancellation((signal) => executeCreateFast(this.ctx, { name, password, email, signal }));
     } else {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk12.red("Name is required"));
+        console.log(chalk13.red("Name is required"));
         return;
       }
       const sharesStr = await this.prompt("Total shares (devices)", "3");
       const shares = parseInt(sharesStr, 10);
       if (isNaN(shares) || shares < 2) {
-        console.log(chalk12.red("Must have at least 2 shares"));
+        console.log(chalk13.red("Must have at least 2 shares"));
         return;
       }
       const thresholdStr = await this.prompt("Signing threshold", "2");
       const threshold = parseInt(thresholdStr, 10);
       if (isNaN(threshold) || threshold < 1 || threshold > shares) {
-        console.log(chalk12.red(`Threshold must be between 1 and ${shares}`));
+        console.log(chalk13.red(`Threshold must be between 1 and ${shares}`));
         return;
       }
       const password = await this.promptPassword("Vault password (optional, press Enter to skip)");
@@ -8734,37 +10676,37 @@ Error: ${error2.message}`));
   async importSeedphrase(args) {
     const type = args[0]?.toLowerCase();
     if (!type || type !== "fast" && type !== "secure") {
-      console.log(chalk12.cyan("Usage: create-from-seedphrase <fast|secure>"));
-      console.log(chalk12.gray("  fast   - Import with VultiServer (2-of-2)"));
-      console.log(chalk12.gray("  secure - Import with device coordination (N-of-M)"));
+      console.log(chalk13.cyan("Usage: create-from-seedphrase <fast|secure>"));
+      console.log(chalk13.gray("  fast   - Import with VultiServer (2-of-2)"));
+      console.log(chalk13.gray("  secure - Import with device coordination (N-of-M)"));
       return;
     }
-    console.log(chalk12.cyan("\nEnter your recovery phrase (words separated by spaces):"));
+    console.log(chalk13.cyan("\nEnter your recovery phrase (words separated by spaces):"));
     const mnemonic = await this.promptPassword("Seedphrase");
     const validation = await this.ctx.sdk.validateSeedphrase(mnemonic);
     if (!validation.valid) {
-      console.log(chalk12.red(`Invalid seedphrase: ${validation.error}`));
+      console.log(chalk13.red(`Invalid seedphrase: ${validation.error}`));
       if (validation.invalidWords?.length) {
-        console.log(chalk12.yellow(`Invalid words: ${validation.invalidWords.join(", ")}`));
+        console.log(chalk13.yellow(`Invalid words: ${validation.invalidWords.join(", ")}`));
       }
       return;
     }
-    console.log(chalk12.green(`\u2713 Valid ${validation.wordCount}-word seedphrase`));
+    console.log(chalk13.green(`\u2713 Valid ${validation.wordCount}-word seedphrase`));
     let vault;
     if (type === "fast") {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk12.red("Name is required"));
+        console.log(chalk13.red("Name is required"));
         return;
       }
       const password = await this.promptPassword("Vault password");
       if (!password) {
-        console.log(chalk12.red("Password is required"));
+        console.log(chalk13.red("Password is required"));
         return;
       }
       const email = await this.prompt("Email for verification");
       if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-        console.log(chalk12.red("Valid email is required"));
+        console.log(chalk13.red("Valid email is required"));
         return;
       }
       const discoverStr = await this.prompt("Discover chains with balances? (y/n)", "y");
@@ -8782,19 +10724,19 @@ Error: ${error2.message}`));
     } else {
       const name = await this.prompt("Vault name");
       if (!name) {
-        console.log(chalk12.red("Name is required"));
+        console.log(chalk13.red("Name is required"));
         return;
       }
       const sharesStr = await this.prompt("Total shares (devices)", "3");
       const shares = parseInt(sharesStr, 10);
       if (isNaN(shares) || shares < 2) {
-        console.log(chalk12.red("Must have at least 2 shares"));
+        console.log(chalk13.red("Must have at least 2 shares"));
         return;
       }
       const thresholdStr = await this.prompt("Signing threshold", "2");
       const threshold = parseInt(thresholdStr, 10);
       if (isNaN(threshold) || threshold < 1 || threshold > shares) {
-        console.log(chalk12.red(`Threshold must be between 1 and ${shares}`));
+        console.log(chalk13.red(`Threshold must be between 1 and ${shares}`));
         return;
       }
       const password = await this.promptPassword("Vault password (optional, Enter to skip)");
@@ -8838,8 +10780,8 @@ Error: ${error2.message}`));
       }
     }
     if (!fiatCurrencies4.includes(currency)) {
-      console.log(chalk12.red(`Invalid currency: ${currency}`));
-      console.log(chalk12.yellow(`Supported currencies: ${fiatCurrencies4.join(", ")}`));
+      console.log(chalk13.red(`Invalid currency: ${currency}`));
+      console.log(chalk13.yellow(`Supported currencies: ${fiatCurrencies4.join(", ")}`));
       return;
     }
     const raw = args.includes("--raw");
@@ -8847,7 +10789,7 @@ Error: ${error2.message}`));
   }
   async runSend(args) {
     if (args.length < 3) {
-      console.log(chalk12.yellow("Usage: send <chain> <to> <amount> [--token <tokenId>] [--memo <memo>]"));
+      console.log(chalk13.yellow("Usage: send <chain> <to> <amount> [--token <tokenId>] [--memo <memo>]"));
       return;
     }
     const [chainStr, to, amount, ...rest] = args;
@@ -8867,7 +10809,7 @@ Error: ${error2.message}`));
       await this.withAbortHandler((signal) => executeSend(this.ctx, { chain, to, amount, tokenId, memo, signal }));
     } catch (err) {
       if (err.message === "Transaction cancelled by user" || err.message === "Operation cancelled" || err.message === "Operation aborted") {
-        console.log(chalk12.yellow("\nTransaction cancelled"));
+        console.log(chalk13.yellow("\nTransaction cancelled"));
         return;
       }
       throw err;
@@ -8875,7 +10817,7 @@ Error: ${error2.message}`));
   }
   async runTxStatus(args) {
     if (args.length < 2) {
-      console.log(chalk12.yellow("Usage: tx-status <chain> <txHash> [--no-wait]"));
+      console.log(chalk13.yellow("Usage: tx-status <chain> <txHash> [--no-wait]"));
       return;
     }
     const [chainStr, txHash, ...rest] = args;
@@ -8893,8 +10835,8 @@ Error: ${error2.message}`));
       } else if (args[i] === "--add" && i + 1 < args.length) {
         const chain = findChainByName(args[i + 1]);
         if (!chain) {
-          console.log(chalk12.red(`Unknown chain: ${args[i + 1]}`));
-          console.log(chalk12.gray("Use tab completion to see available chains"));
+          console.log(chalk13.red(`Unknown chain: ${args[i + 1]}`));
+          console.log(chalk13.gray("Use tab completion to see available chains"));
           return;
         }
         addChain = chain;
@@ -8902,8 +10844,8 @@ Error: ${error2.message}`));
       } else if (args[i] === "--remove" && i + 1 < args.length) {
         const chain = findChainByName(args[i + 1]);
         if (!chain) {
-          console.log(chalk12.red(`Unknown chain: ${args[i + 1]}`));
-          console.log(chalk12.gray("Use tab completion to see available chains"));
+          console.log(chalk13.red(`Unknown chain: ${args[i + 1]}`));
+          console.log(chalk13.gray("Use tab completion to see available chains"));
           return;
         }
         removeChain = chain;
@@ -8914,7 +10856,7 @@ Error: ${error2.message}`));
   }
   async runTokens(args) {
     if (args.length === 0) {
-      console.log(chalk12.yellow("Usage: tokens <chain> [--add <address>] [--remove <tokenId>]"));
+      console.log(chalk13.yellow("Usage: tokens <chain> [--add <address>] [--remove <tokenId>]"));
       return;
     }
     const chainStr = args[0];
@@ -8935,7 +10877,7 @@ Error: ${error2.message}`));
   async runSwapQuote(args) {
     if (args.length < 3) {
       console.log(
-        chalk12.yellow("Usage: swap-quote <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>]")
+        chalk13.yellow("Usage: swap-quote <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>]")
       );
       return;
     }
@@ -8959,7 +10901,7 @@ Error: ${error2.message}`));
   async runSwap(args) {
     if (args.length < 3) {
       console.log(
-        chalk12.yellow(
+        chalk13.yellow(
           "Usage: swap <fromChain> <toChain> <amount> [--from-token <addr>] [--to-token <addr>] [--slippage <pct>]"
         )
       );
@@ -8990,7 +10932,7 @@ Error: ${error2.message}`));
       );
     } catch (err) {
       if (err.message === "Swap cancelled by user" || err.message === "Operation cancelled" || err.message === "Operation aborted") {
-        console.log(chalk12.yellow("\nSwap cancelled"));
+        console.log(chalk13.yellow("\nSwap cancelled"));
         return;
       }
       throw err;
@@ -9052,24 +10994,24 @@ Error: ${error2.message}`));
   }
   getPrompt() {
     const vault = this.ctx.getActiveVault();
-    if (!vault) return chalk12.cyan("wallet> ");
+    if (!vault) return chalk13.cyan("wallet> ");
     const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
-    const status = isUnlocked ? chalk12.green("\u{1F513}") : chalk12.yellow("\u{1F512}");
-    return chalk12.cyan(`wallet[${vault.name}]${status}> `);
+    const status = isUnlocked ? chalk13.green("\u{1F513}") : chalk13.yellow("\u{1F512}");
+    return chalk13.cyan(`wallet[${vault.name}]${status}> `);
   }
   displayVaultList() {
     const vaults = Array.from(this.ctx.getVaults().values());
     const activeVault = this.ctx.getActiveVault();
     if (vaults.length === 0) {
-      console.log(chalk12.yellow('No vaults found. Use "create" or "import <file>" to add a vault.\n'));
+      console.log(chalk13.yellow('No vaults found. Use "create" or "import <file>" to add a vault.\n'));
       return;
     }
-    console.log(chalk12.cyan("Loaded Vaults:\n"));
+    console.log(chalk13.cyan("Loaded Vaults:\n"));
     vaults.forEach((vault) => {
       const isActive = vault.id === activeVault?.id;
       const isUnlocked = this.ctx.isVaultUnlocked(vault.id);
-      const activeMarker = isActive ? chalk12.green(" (active)") : "";
-      const lockIcon = isUnlocked ? chalk12.green("\u{1F513}") : chalk12.yellow("\u{1F512}");
+      const activeMarker = isActive ? chalk13.green(" (active)") : "";
+      const lockIcon = isUnlocked ? chalk13.green("\u{1F513}") : chalk13.yellow("\u{1F512}");
       console.log(`  ${lockIcon} ${vault.name}${activeMarker} - ${vault.type}`);
     });
     console.log();
@@ -9077,150 +11019,7 @@ Error: ${error2.message}`));
 };
 
 // src/lib/errors.ts
-import chalk13 from "chalk";
-
-// src/lib/version.ts
 import chalk14 from "chalk";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
-var cachedVersion = null;
-function getVersion() {
-  if (cachedVersion) return cachedVersion;
-  if (true) {
-    cachedVersion = "0.15.4";
-    return cachedVersion;
-  }
-  try {
-    const packagePath = new URL("../../package.json", import.meta.url);
-    const pkg = JSON.parse(readFileSync3(packagePath, "utf-8"));
-    cachedVersion = pkg.version;
-    return cachedVersion;
-  } catch {
-    cachedVersion = "0.0.0-unknown";
-    return cachedVersion;
-  }
-}
-var CACHE_DIR = join3(homedir3(), ".vultisig", "cache");
-var VERSION_CACHE_FILE = join3(CACHE_DIR, "version-check.json");
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-function readVersionCache() {
-  try {
-    if (!existsSync2(VERSION_CACHE_FILE)) return null;
-    const data = readFileSync3(VERSION_CACHE_FILE, "utf-8");
-    return JSON.parse(data);
-  } catch {
-    return null;
-  }
-}
-function writeVersionCache(cache) {
-  try {
-    if (!existsSync2(CACHE_DIR)) {
-      mkdirSync3(CACHE_DIR, { recursive: true });
-    }
-    writeFileSync3(VERSION_CACHE_FILE, JSON.stringify(cache, null, 2));
-  } catch {
-  }
-}
-async function fetchLatestVersion() {
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5e3);
-    const response = await fetch("https://registry.npmjs.org/@vultisig/cli/latest", {
-      signal: controller.signal,
-      headers: {
-        Accept: "application/json"
-      }
-    });
-    clearTimeout(timeout);
-    if (!response.ok) return null;
-    const data = await response.json();
-    return data.version ?? null;
-  } catch {
-    return null;
-  }
-}
-function isNewerVersion(v1, v2) {
-  const parse = (v) => {
-    const clean2 = v.replace(/^v/, "").replace(/-.*$/, "");
-    return clean2.split(".").map((n) => parseInt(n, 10) || 0);
-  };
-  const p1 = parse(v1);
-  const p2 = parse(v2);
-  for (let i = 0; i < 3; i++) {
-    const n1 = p1[i] ?? 0;
-    const n2 = p2[i] ?? 0;
-    if (n2 > n1) return true;
-    if (n2 < n1) return false;
-  }
-  if (v1.includes("-") && !v2.includes("-")) return true;
-  return false;
-}
-async function checkForUpdates() {
-  if (process.env.VULTISIG_NO_UPDATE_CHECK === "1") {
-    return null;
-  }
-  const currentVersion = getVersion();
-  const cache = readVersionCache();
-  if (cache && Date.now() - cache.lastCheck < CACHE_TTL_MS) {
-    return {
-      currentVersion,
-      latestVersion: cache.latestVersion,
-      updateAvailable: cache.latestVersion ? isNewerVersion(currentVersion, cache.latestVersion) : false
-    };
-  }
-  const latestVersion = await fetchLatestVersion();
-  writeVersionCache({
-    lastCheck: Date.now(),
-    latestVersion
-  });
-  return {
-    currentVersion,
-    latestVersion,
-    updateAvailable: latestVersion ? isNewerVersion(currentVersion, latestVersion) : false
-  };
-}
-function formatVersionShort() {
-  return `vultisig/${getVersion()}`;
-}
-function formatVersionDetailed() {
-  const lines = [];
-  lines.push(chalk14.bold(`Vultisig CLI v${getVersion()}`));
-  lines.push("");
-  lines.push(`  Node.js:   ${process.version}`);
-  lines.push(`  Platform:  ${process.platform}-${process.arch}`);
-  lines.push(`  Config:    ~/.vultisig/`);
-  return lines.join("\n");
-}
-function detectInstallMethod() {
-  const execPath = process.execPath;
-  if (execPath.includes("homebrew") || execPath.includes("Cellar")) {
-    return "homebrew";
-  }
-  if (process.env.npm_execpath?.includes("yarn")) {
-    return "yarn";
-  }
-  if (process.env.npm_config_user_agent?.includes("npm")) {
-    return "npm";
-  }
-  if (execPath.includes("node_modules")) {
-    return "npm";
-  }
-  return "unknown";
-}
-function getUpdateCommand() {
-  const method = detectInstallMethod();
-  switch (method) {
-    case "npm":
-      return "npm update -g @vultisig/cli";
-    case "yarn":
-      return "yarn global upgrade @vultisig/cli";
-    case "homebrew":
-      return "brew upgrade vultisig";
-    default:
-      return "npm update -g @vultisig/cli";
-  }
-}
 
 // src/lib/completion.ts
 import { homedir as homedir4 } from "os";
@@ -9561,9 +11360,32 @@ setupUserAgent();
   if (handled) process.exit(0);
 })();
 var ctx;
-program.name("vultisig").description("Vultisig CLI - Secure multi-party crypto wallet").version(formatVersionShort(), "-v, --version", "Show version").option("--debug", "Enable debug output").option("--silent", "Suppress informational output, show only results").option("-o, --output <format>", "Output format: table, json (default: table)", "table").option("-i, --interactive", "Start interactive shell mode").option("--vault <nameOrId>", "Specify vault by name or ID").option("--server-url <url>", "Base Vultisig API URL for FastVault and relay endpoints").hook("preAction", (thisCommand) => {
+program.name("vultisig").description("Vultisig CLI - Secure multi-party crypto wallet").version(formatVersionShort(), "-v, --version", "Show version").option("--debug", "Enable debug output").option("--silent", "Suppress informational output, show only results").option(
+  "-o, --output <format>",
+  "Output format: json, table (defaults to json when piped)",
+  (val) => {
+    if (!["json", "table"].includes(val)) throw new InvalidArgumentError('Must be "json" or "table"');
+    return val;
+  },
+  process.stdout.isTTY ? "table" : "json"
+).option("-q, --quiet", "Strip empty/zero fields from output").option("--fields <fields>", "Comma-separated list of fields to include in output").option("--non-interactive", "Disable interactive prompts (fail instead of asking)").option("--ci", "CI/automation mode (equivalent to --output json --non-interactive --quiet)").option("-i, --interactive", "Start interactive shell mode").option("--vault <nameOrId>", "Specify vault by name or ID").option("--server-url <url>", "Base Vultisig API URL for FastVault and relay endpoints").addHelpText(
+  "after",
+  "\nExit codes:\n" + Object.entries(EXIT_CODE_DESCRIPTIONS).map(([k, v]) => `  ${k}  ${v}`).join("\n") + "\n\nEnvironment variables:\n  VAULT_PASSWORD          Vault password for signing (bypasses prompt)\n  VULTISIG_PASSWORD       Alias for VAULT_PASSWORD\n  VAULT_PASSWORDS         Space-separated VaultName:password pairs\n  VULTISIG_VAULT          Default vault name or ID\n  VULTISIG_CONFIG_DIR     Override config directory (~/.vultisig)\n  VULTISIG_SILENT         Set to 1 for silent mode\n  NO_COLOR                Disable colored output"
+).hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
+  if (opts.ci) {
+    const outputExplicit = process.argv.some((a) => a === "--output" || a === "-o" || a.startsWith("--output="));
+    opts.output = opts.output === "table" && !outputExplicit ? "json" : opts.output;
+    opts.quiet = true;
+    opts.nonInteractive = true;
+  }
   initOutputMode({ silent: opts.silent, output: opts.output });
+  setQuiet(!!opts.quiet);
+  setNonInteractive(!!opts.nonInteractive);
+  const fields = opts.fields;
+  setFields(
+    fields ? fields.split(",").map((f) => f.trim()).filter(Boolean) : void 0
+  );
 });
 async function findVaultByNameOrId(sdk, nameOrId) {
   const vaults = await sdk.listVaults();
@@ -9607,7 +11429,15 @@ async function init(vaultOverride, unlockPassword, passwordTTL) {
   return ctx;
 }
 var createCmd = program.command("create").description("Create a vault");
-createCmd.command("fast").description("Create a fast vault (server-assisted 2-of-2)").requiredOption("--name <name>", "Vault name").requiredOption("--password <password>", "Vault password").requiredOption("--email <email>", "Email for verification").option("--two-step", 'Create vault without verifying OTP (verify later with "vultisig verify")').action(
+createCmd.command("fast").description("Create a fast vault (server-assisted 2-of-2)").requiredOption("--name <name>", "Vault name").requiredOption("--password <password>", "Vault password").requiredOption("--email <email>", "Email for verification").option("--two-step", 'Create vault without verifying OTP (verify later with "vultisig verify")').addHelpText(
+  "after",
+  `
+Examples:
+  vultisig create fast --name mywallet --password secret --email me@example.com
+  vultisig create fast --name mywallet --password secret --email me@example.com --two-step
+
+See also: verify, auth setup`
+).action(
   withExit(async (options) => {
     const context = await init(program.opts().vault);
     await executeCreateFast(context, { ...options, twoStep: options.twoStep });
@@ -9633,7 +11463,13 @@ program.command("add-mldsa").description("Add ML-DSA (post-quantum) keys to the
     });
   })
 );
-program.command("import <file>").description("Import vault from .vult file").option("--password <password>", "Password to decrypt the vault file").action(
+program.command("import <file>").description("Import vault from .vult file").option("--password <password>", "Password to decrypt the vault file").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig import ~/vault-backup.vult
+  vultisig import ~/vault-backup.vult --password mypassword`
+).action(
   withExit(async (file, options) => {
     const context = await init(program.opts().vault);
     await executeImport(context, file, options.password);
@@ -9641,6 +11477,7 @@ program.command("import <file>").description("Import vault from .vult file").opt
 );
 var createFromSeedphraseCmd = program.command("create-from-seedphrase").description("Create vault from BIP39 seedphrase");
 async function promptSeedphrase() {
+  requireInteractive("Use --mnemonic flag to provide seedphrase non-interactively.");
   info("\nEnter your 12 or 24-word recovery phrase.");
   info("Words will be hidden as you type.\n");
   const answer = await inquirer8.prompt([
@@ -9661,6 +11498,7 @@ async function promptSeedphrase() {
   return answer.mnemonic.trim().toLowerCase();
 }
 async function promptQrPayload() {
+  requireInteractive("Use --qr or --qr-file flag to provide QR payload non-interactively.");
   info("\nEnter the QR code payload from the initiator device.");
   info('The payload starts with "vultisig://".\n');
   const answer = await inquirer8.prompt([
@@ -9786,7 +11624,15 @@ program.command("verify <vaultId>").description("Verify vault with email verific
     }
   )
 );
-program.command("balance [chain]").description("Show balance for a chain or all chains").option("-t, --tokens", "Include token balances").option("--raw", "Show raw values (wei/satoshis) for programmatic use").action(
+program.command("balance [chain]").description(descriptions.balance.description).option("-t, --tokens", descriptions.balance.params.includeTokens).option("--raw", "Show raw values (wei/satoshis) for programmatic use").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig balance
+  vultisig balance Ethereum --tokens
+  vultisig balance --output json --fields chain,amount
+  vultisig balance --output json -q`
+).action(
   withExit(async (chainStr, options) => {
     const context = await init(program.opts().vault);
     await executeBalance(context, {
@@ -9796,7 +11642,20 @@ program.command("balance [chain]").description("Show balance for a chain or all
     });
   })
 );
-program.command("send <chain> <to> [amount]").description("Send tokens to an address").option("--max", "Send maximum amount (balance minus fees)").option("--token <tokenId>", "Token to send (default: native)").option("--memo <memo>", "Transaction memo").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").action(
+program.command("send <chain> <to> [amount]").description(descriptions.send.description).option("--max", "Send maximum amount (balance minus fees)").option("--token <tokenId>", "Token to send (default: native)").option("--memo <memo>", "Transaction memo").option("--dry-run", "Preview transaction without signing or broadcasting").option("--confirm", "Confirm and broadcast (without this flag, runs as a preview)").option("-y, --yes", "Alias for --confirm").option("--password <password>", "Vault password for signing").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig send Ethereum 0x1234...abcd 0.1
+  vultisig send Bitcoin bc1q... --max --confirm
+  vultisig send Ethereum 0x... 0.5 --dry-run --output json
+
+Environment variables:
+  VAULT_PASSWORD    Vault password (bypasses prompt)
+  VAULT_PASSWORDS   Space-separated VaultName:password pairs
+
+See also: balance, tx-status`
+).action(
   withExit(
     async (chainStr, to, amount, options) => {
       if (!amount && !options.max) throw new Error("Provide an amount or use --max");
@@ -9809,7 +11668,8 @@ program.command("send <chain> <to> [amount]").description("Send tokens to an add
           amount: amount ?? "max",
           tokenId: options.token,
           memo: options.memo,
-          yes: options.yes,
+          dryRun: options.dryRun,
+          yes: options.yes || options.confirm,
           password: options.password
         });
       } catch (err) {
@@ -9822,7 +11682,13 @@ program.command("send <chain> <to> [amount]").description("Send tokens to an add
     }
   )
 );
-program.command("execute <chain> <contract> <msg>").description("Execute a CosmWasm smart contract (THORChain, MayaChain)").option("--funds <funds>", 'Funds to send with execution (format: "denom:amount" or "denom:amount,denom2:amount2")').option("--memo <memo>", "Transaction memo").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").action(
+program.command("execute <chain> <contract> <msg>").description("Execute a CosmWasm smart contract (THORChain, MayaChain)").option("--funds <funds>", 'Funds to send with execution (format: "denom:amount" or "denom:amount,denom2:amount2")').option("--memo <memo>", "Transaction memo").option("--dry-run", "Preview execution without signing or broadcasting").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig execute THORChain <contract> '{"swap":{}}' --yes
+  vultisig execute THORChain <contract> '{"deposit":{}}' --funds rune:1000000 --output json`
+).action(
   withExit(
     async (chainStr, contract, msg, options) => {
       const context = await init(program.opts().vault, options.password);
@@ -9833,6 +11699,7 @@ program.command("execute <chain> <contract> <msg>").description("Execute a CosmW
           msg,
           funds: options.funds,
           memo: options.memo,
+          dryRun: options.dryRun,
           yes: options.yes,
           password: options.password
         });
@@ -9865,7 +11732,13 @@ program.command("broadcast").description("Broadcast a pre-signed raw transaction
     });
   })
 );
-program.command("tx-status").description("Check the status of a transaction (polls until confirmed)").requiredOption("--chain <chain>", "Target blockchain").requiredOption("--tx-hash <hash>", "Transaction hash to check").option("--no-wait", "Return immediately without waiting for confirmation").action(
+program.command("tx-status").description("Check the status of a transaction (polls until confirmed)").requiredOption("--chain <chain>", "Target blockchain").requiredOption("--tx-hash <hash>", "Transaction hash to check").option("--no-wait", "Return immediately without waiting for confirmation").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig tx-status --chain Ethereum --tx-hash 0xabc...
+  vultisig tx-status --chain Bitcoin --tx-hash abc... --no-wait --output json`
+).action(
   withExit(async (options) => {
     const context = await init(program.opts().vault);
     await executeTxStatus(context, {
@@ -9875,7 +11748,13 @@ program.command("tx-status").description("Check the status of a transaction (pol
     });
   })
 );
-program.command("portfolio").description("Show total portfolio value").option("-c, --currency <currency>", "Fiat currency (usd, eur, gbp, etc.)", "usd").option("--raw", "Show raw values (wei/satoshis) for programmatic use").action(
+program.command("portfolio").description(descriptions.portfolio.description).option("-c, --currency <currency>", "Fiat currency (usd, eur, gbp, etc.)", "usd").option("--raw", "Show raw values (wei/satoshis) for programmatic use").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig portfolio
+  vultisig portfolio --currency eur --output json`
+).action(
   withExit(async (options) => {
     const context = await init(program.opts().vault);
     await executePortfolio(context, {
@@ -9902,7 +11781,13 @@ program.command("discount").description("Show your VULT discount tier for swap f
     await executeDiscount(context, { refresh: options.refresh });
   })
 );
-program.command("export [path]").description("Export vault to file").option("--password <password>", "Password to unlock the vault (for encrypted vaults)").option("--exportPassword <password>", "Password to encrypt the exported file (defaults to --password)").action(
+program.command("export [path]").description("Export vault to file").option("--password <password>", "Password to unlock the vault (for encrypted vaults)").option("--exportPassword <password>", "Password to encrypt the exported file (defaults to --password)").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig export ~/backup.vult
+  vultisig export ~/backup.vult --password mypass --output json`
+).action(
   withExit(async (path4, options) => {
     const context = await init(program.opts().vault, options.password);
     await executeExport(context, {
@@ -9912,7 +11797,13 @@ program.command("export [path]").description("Export vault to file").option("--p
     });
   })
 );
-program.command("addresses").description("Show all vault addresses").action(
+program.command("addresses").description(descriptions.address.description).addHelpText(
+  "after",
+  `
+Examples:
+  vultisig addresses
+  vultisig addresses --output json --fields chain,address`
+).action(
   withExit(async () => {
     const context = await init(program.opts().vault);
     await executeAddresses(context);
@@ -9930,7 +11821,14 @@ program.command("address-book").description("Manage address book entries").optio
     });
   })
 );
-program.command("chains").description("List and manage chains").option("--add <chain>", "Add a chain").option("--add-all", "Add all supported chains").option("--remove <chain>", "Remove a chain").action(
+program.command("chains").description("List and manage chains").option("--add <chain>", "Add a chain").option("--add-all", "Add all supported chains").option("--remove <chain>", "Remove a chain").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig chains
+  vultisig chains --add Solana
+  vultisig chains --add-all --output json`
+).action(
   withExit(async (options) => {
     const context = await init(program.opts().vault);
     await executeChains(context, {
@@ -9940,7 +11838,13 @@ program.command("chains").description("List and manage chains").option("--add <c
     });
   })
 );
-program.command("vaults").description("List all stored vaults").action(
+program.command("vaults").description("List all stored vaults").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig vaults
+  vultisig vaults --output json`
+).action(
   withExit(async () => {
     const context = await init(program.opts().vault);
     await executeVaults(context);
@@ -9958,7 +11862,7 @@ program.command("rename <newName>").description("Rename the active vault").actio
     await executeRename(context, newName);
   })
 );
-program.command("info").description("Show detailed vault information").action(
+program.command("info").description(descriptions.vaultInfo.description).action(
   withExit(async () => {
     const context = await init(program.opts().vault);
     await executeInfo(context);
@@ -9973,7 +11877,14 @@ program.command("delete [vault]").description("Delete a vault from local storage
     });
   })
 );
-program.command("tokens <chain>").description("List and manage tokens for a chain").option("--add <contractAddress>", "Add a token by contract address").option("--remove <tokenId>", "Remove a token by ID").option("--symbol <symbol>", "Token symbol (for --add)").option("--name <name>", "Token name (for --add)").option("--decimals <decimals>", "Token decimals (for --add)", "18").action(
+program.command("tokens <chain>").description("List and manage tokens for a chain").option("--add <contractAddress>", "Add a token by contract address").option("--remove <tokenId>", "Remove a token by ID").option("--discover", "Auto-discover tokens with balances on the chain").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig tokens Ethereum
+  vultisig tokens Ethereum --discover --output json
+  vultisig tokens Ethereum --add 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 --symbol USDC --decimals 6`
+).option("--symbol <symbol>", "Token symbol (for --add)").option("--name <name>", "Token name (for --add)").option("--decimals <decimals>", "Token decimals (for --add)", "18").action(
   withExit(
     async (chainStr, options) => {
       const context = await init(program.opts().vault);
@@ -9981,6 +11892,7 @@ program.command("tokens <chain>").description("List and manage tokens for a chai
         chain: findChainByName(chainStr) || chainStr,
         add: options.add,
         remove: options.remove,
+        discover: options.discover,
         symbol: options.symbol,
         name: options.name,
         decimals: options.decimals ? parseInt(options.decimals, 10) : void 0
@@ -9988,13 +11900,19 @@ program.command("tokens <chain>").description("List and manage tokens for a chai
     }
   )
 );
-program.command("swap-chains").description("List chains that support swaps").action(
+program.command("swap-chains").description(descriptions.supportedChains.description).action(
   withExit(async () => {
     const context = await init(program.opts().vault);
     await executeSwapChains(context);
   })
 );
-program.command("swap-quote <fromChain> <toChain> [amount]").description("Get a swap quote without executing").option("--max", "Swap maximum amount (full balance minus fees for native)").option("--from-token <address>", "Token address to swap from (default: native)").option("--to-token <address>", "Token address to swap to (default: native)").action(
+program.command("swap-quote <fromChain> <toChain> [amount]").description(descriptions.swapQuote.description).option("--max", "Swap maximum amount (full balance minus fees for native)").option("--from-token <address>", "Token address to swap from (default: native)").option("--to-token <address>", "Token address to swap to (default: native)").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig swap-quote Ethereum Bitcoin 0.1
+  vultisig swap-quote Ethereum Bitcoin --max --output json`
+).action(
   withExit(
     async (fromChainStr, toChainStr, amountStr, options) => {
       if (!amountStr && !options.max) throw new Error("Provide an amount or use --max");
@@ -10010,7 +11928,16 @@ program.command("swap-quote <fromChain> <toChain> [amount]").description("Get a
     }
   )
 );
-program.command("swap <fromChain> <toChain> [amount]").description("Swap tokens between chains").option("--max", "Swap maximum amount (full balance minus fees for native)").option("--from-token <address>", "Token address to swap from (default: native)").option("--to-token <address>", "Token address to swap to (default: native)").option("--slippage <percent>", "Slippage tolerance in percent", "1").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").action(
+program.command("swap <fromChain> <toChain> [amount]").description(descriptions.swap.description).option("--max", "Swap maximum amount (full balance minus fees for native)").option("--from-token <address>", "Token address to swap from (default: native)").option("--to-token <address>", "Token address to swap to (default: native)").option("--slippage <percent>", "Slippage tolerance in percent", "1").option("--dry-run", "Preview swap without signing or broadcasting").option("--confirm", "Confirm and broadcast (without this flag, runs as a preview)").option("-y, --yes", "Alias for --confirm").option("--password <password>", "Vault password for signing").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig swap Ethereum Bitcoin 0.1
+  vultisig swap Ethereum Bitcoin --max --confirm
+  vultisig swap Ethereum Bitcoin 0.5 --dry-run --output json
+
+See also: swap-quote, swap-chains, balance`
+).action(
   withExit(
     async (fromChainStr, toChainStr, amountStr, options) => {
       if (!amountStr && !options.max) throw new Error("Provide an amount or use --max");
@@ -10024,7 +11951,8 @@ program.command("swap <fromChain> <toChain> [amount]").description("Swap tokens
           fromToken: options.fromToken,
           toToken: options.toToken,
           slippage: options.slippage ? parseFloat(options.slippage) : void 0,
-          yes: options.yes,
+          dryRun: options.dryRun,
+          yes: options.yes || options.confirm,
           password: options.password
         });
       } catch (err) {
@@ -10068,7 +11996,7 @@ rujiraCmd.command("deposit").description("Show deposit instructions (inbound add
     }
   )
 );
-rujiraCmd.command("swap <fromAsset> <toAsset> <amount>").description("Execute a FIN swap (amount in base units)").option("--slippage-bps <bps>", "Slippage tolerance in basis points (default: 100 = 1%)", "100").option("--destination <thorAddress>", "Destination THOR address (default: vault THORChain address)").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").option("--rpc <url>", "Override THORChain RPC endpoint").option("--rest <url>", "Override THORNode REST endpoint").action(
+rujiraCmd.command("swap <fromAsset> <toAsset> <amount>").description("Execute a FIN swap (amount in base units)").option("--slippage-bps <bps>", "Slippage tolerance in basis points (default: 100 = 1%)", "100").option("--destination <thorAddress>", "Destination THOR address (default: vault THORChain address)").option("--dry-run", "Preview swap quote without executing").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").option("--rpc <url>", "Override THORChain RPC endpoint").option("--rest <url>", "Override THORNode REST endpoint").action(
   withExit(
     async (fromAsset, toAsset, amount, options) => {
       const context = await init(program.opts().vault, options.password);
@@ -10078,6 +12006,7 @@ rujiraCmd.command("swap <fromAsset> <toAsset> <amount>").description("Execute a
         amount,
         slippageBps: options.slippageBps ? parseInt(options.slippageBps, 10) : void 0,
         destination: options.destination,
+        dryRun: options.dryRun,
         yes: options.yes,
         password: options.password,
         rpcEndpoint: options.rpc,
@@ -10086,7 +12015,7 @@ rujiraCmd.command("swap <fromAsset> <toAsset> <amount>").description("Execute a
     }
   )
 );
-rujiraCmd.command("withdraw <asset> <amount> <l1Address>").description("Withdraw secured assets to L1 (amount in base units)").option("--max-fee-bps <bps>", "Max outbound fee as bps of amount (optional)").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").option("--rpc <url>", "Override THORChain RPC endpoint").option("--rest <url>", "Override THORNode REST endpoint").action(
+rujiraCmd.command("withdraw <asset> <amount> <l1Address>").description("Withdraw secured assets to L1 (amount in base units)").option("--max-fee-bps <bps>", "Max outbound fee as bps of amount (optional)").option("--dry-run", "Preview withdrawal without executing").option("-y, --yes", "Skip confirmation prompt").option("--password <password>", "Vault password for signing").option("--rpc <url>", "Override THORChain RPC endpoint").option("--rest <url>", "Override THORNode REST endpoint").action(
   withExit(
     async (asset, amount, l1Address, options) => {
       const context = await init(program.opts().vault, options.password);
@@ -10095,6 +12024,7 @@ rujiraCmd.command("withdraw <asset> <amount> <l1Address>").description("Withdraw
         amount,
         l1Address,
         maxFeeBps: options.maxFeeBps ? parseInt(options.maxFeeBps, 10) : void 0,
+        dryRun: options.dryRun,
         yes: options.yes,
         password: options.password,
         rpcEndpoint: options.rpc,
@@ -10129,7 +12059,13 @@ var agentCmd = program.command("agent").description("AI-powered chat interface f
     });
   }
 );
-agentCmd.command("ask <message>").description("Send a single message and get the response (for AI agent integration)").option("--session <id>", "Continue an existing conversation").option("--backend-url <url>", "Agent backend URL (default: https://abe.vultisig.com)").option("--password <password>", "Vault password for signing operations").option("--verbose", "Show tool calls and debug info on stderr").option("--json", "Output structured JSON instead of text").action(
+agentCmd.command("ask <message>").description("Send a single message and get the response (for AI agent integration)").option("--session <id>", "Continue an existing conversation").option("--backend-url <url>", "Agent backend URL (default: https://abe.vultisig.com)").option("--password <password>", "Vault password for signing operations").option("--verbose", "Show tool calls and debug info on stderr").option("--json", "Output structured JSON (deprecated: use --output json)").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig agent ask "What is my ETH balance?" --output json
+  vultisig agent ask "Send 0.1 ETH to 0x..." --session abc123 --yes`
+).action(
   async (message, options) => {
     const parentOpts = agentCmd.opts();
     const context = await init(program.opts().vault, options.password || parentOpts.password);
@@ -10197,7 +12133,66 @@ program.command("update").description("Check for updates and show update command
     }
   })
 );
+var authCmd = program.command("auth").description("Manage keyring-stored vault credentials");
+authCmd.command("setup").description("Discover .vult files, prompt for passwords, and store credentials in the OS keyring").option("--vault-file <path>", "Path to a specific .vult file").option("--non-interactive", "Fail instead of prompting (use env vars)").addHelpText(
+  "after",
+  `
+Examples:
+  vultisig auth setup
+  vultisig auth setup --vault-file ~/vault.vult
+  VAULT_PASSWORD=secret VAULT_DECRYPT_PASSWORD=pass vultisig auth setup --non-interactive`
+).action(
+  withExit(async (options) => {
+    const result = await executeAuthSetup({
+      vaultFile: options.vaultFile,
+      nonInteractive: options.nonInteractive || isNonInteractive()
+    });
+    if (isJsonOutput()) {
+      outputJson({
+        stored: true,
+        vaultId: result.vaultId,
+        vaultName: result.vaultName,
+        storageBackend: result.storageBackend
+      });
+    } else {
+      printResult(
+        chalk15.green(`Vault "${result.vaultName}" (${result.vaultId}) credentials stored in ${result.storageBackend}.`)
+      );
+    }
+  })
+);
+authCmd.command("status").description("List configured vaults and their keyring credential status").action(
+  withExit(async () => {
+    const vaults = await executeAuthStatus();
+    if (isJsonOutput()) {
+      outputJson({
+        vaults: vaults.map((v) => ({ id: v.id, name: v.name, filePath: v.filePath, hasCredentials: v.hasCredentials }))
+      });
+      return;
+    }
+    if (vaults.length === 0) {
+      printResult("No vaults configured. Run: vsig auth setup");
+      return;
+    }
+    for (const v of vaults) {
+      const status = v.hasCredentials ? chalk15.green("authenticated") : chalk15.red("no credentials");
+      printResult(`  ${v.name} (${v.id}) - ${status}`);
+      printResult(`    File: ${v.filePath}`);
+    }
+  })
+);
+authCmd.command("logout").description("Clear keyring credentials for a vault").option("--vault-id <id>", "Specific vault ID to clear").option("--all", "Clear credentials for all configured vaults").action(
+  withExit(async (options) => {
+    await executeAuthLogout({ vaultId: options.vaultId, all: options.all });
+    if (isJsonOutput()) {
+      outputJson({ cleared: true, vaultId: options.vaultId ?? null, all: !!options.all });
+    } else {
+      printResult(chalk15.green("Credentials cleared."));
+    }
+  })
+);
 setupCompletionCommand(program);
+program.command("schema", { hidden: true }).description("Output machine-readable command schema (JSON introspection for agents)").helpOption(false).action(withExit(async () => executeSchema(program)));
 async function startInteractiveMode() {
   const serverEndpoints = resolveServerEndpoints(parseServerEndpointOverridesFromArgv(process.argv.slice(2)));
   const sdk = new Vultisig6({