@vultisig/cli 2.19.14 → 2.20.0

package/dist/index.js

@@ -4872,7 +4872,7 @@ var init_secp256k1 = __esm({
 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 { Chain as Chain14, parseKeygenQR, Vultisig as Vultisig6 } from "@vultisig/sdk";
 import chalk16 from "chalk";
 import { InvalidArgumentError, program } from "commander";
 
@@ -4966,7 +4966,8 @@ var EXIT_CODE_DESCRIPTIONS = {
   [9 /* DUPLICATE_BROADCAST */]: "Duplicate broadcast refused (nothing sent) \u2014 retry with --force to override",
   [10 /* AGENT_TURN_BLOCKED */]: "agent ask: a fund-safety guardrail blocked the requested action",
   [11 /* AGENT_TURN_REFUSAL */]: "agent ask: the model refused or asked a clarifying question (no action taken)",
-  [12 /* CONFIRMATION_REQUIRED */]: "Interactive confirmation/input required but the session is non-interactive \u2014 pass --yes/--confirm or the required flag"
+  [12 /* CONFIRMATION_REQUIRED */]: "Interactive confirmation/input required but the session is non-interactive \u2014 pass --yes/--confirm or the required flag",
+  [13 /* BROADCAST_COMMITTED */]: "agent ask: transaction broadcast but the overall request may be incomplete \u2014 inspect the hash, do NOT blindly retry"
 };
 var VsigError = class extends Error {
   hint;
@@ -5027,6 +5028,13 @@ var InvalidInputError = class extends VsigError {
     super(message, hint, suggestions, context);
   }
 };
+var InvalidTxHashError = class extends VsigError {
+  exitCode = 4 /* INVALID_INPUT */;
+  code = "INVALID_HASH";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
+  }
+};
 var InsufficientBalanceError = class extends VsigError {
   exitCode = 4 /* INVALID_INPUT */;
   code = "INSUFFICIENT_BALANCE";
@@ -5055,6 +5063,13 @@ var TxNotFoundError = class extends VsigError {
     super(message, hint, suggestions, context);
   }
 };
+var VaultNotFoundError = class extends VsigError {
+  exitCode = 5 /* RESOURCE_NOT_FOUND */;
+  code = "VAULT_NOT_FOUND";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
+  }
+};
 var TxStatusTimeoutError = class extends VsigError {
   exitCode = 3 /* NETWORK */;
   code = "TX_STATUS_TIMEOUT";
@@ -5103,53 +5118,78 @@ var DuplicateBroadcastRefusedError = class extends VsigError {
     ]);
   }
 };
-function classifyError(err) {
-  if (err instanceof VsigError) return err;
-  if (err.code === "DUPLICATE_BROADCAST") {
-    return new DuplicateBroadcastRefusedError(err.message);
+function isPermanentBroadcastInputError(err) {
+  const details = `${err.message}
+${err.originalError?.message ?? ""}`;
+  return /failed to decode signed transaction|could not decode (?:signed )?transaction|invalid raw transaction|invalid transaction encoding|invalid (?:transaction )?signature|invalid sender|invalid rlp|rlp:|unsupported transaction type/i.test(
+    details
+  );
+}
+var INVALID_ADDRESS_RE = /invalid (?:receiver |recipient |destination )?address|bad address|malformed address/i;
+function invalidAddressError(message) {
+  const addrMatch = message.match(/(0x[a-fA-F0-9]+|bc1[a-z0-9]+|[13][a-km-zA-HJ-NP-Z1-9]+)/i);
+  return new InvalidAddressError(message, void 0, void 0, addrMatch ? { address: addrMatch[1] } : void 0);
+}
+function classifyVaultError(err) {
+  if (err.code === VaultErrorCode.BalanceFetchFailed && err.originalError) {
+    const inner = classifyError(err.originalError);
+    if (!(inner instanceof UnknownError)) return inner;
   }
-  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
+        );
+      }
+      if (INVALID_ADDRESS_RE.test(lowerMsg)) return invalidAddressError(err.message);
+      if (lowerMsg.includes("failed to unlock vault") || lowerMsg.includes("invalid password")) {
+        return new AuthRequiredError(err.message);
+      }
+      return new UsageError(err.message);
     }
-    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:
+    case VaultErrorCode.VaultNotFound:
+      return new VaultNotFoundError(err.message);
+    case VaultErrorCode.UnsupportedToken:
+      return new TokenNotFoundError(err.message);
+    case VaultErrorCode.BroadcastFailed:
+      if (isPermanentBroadcastInputError(err)) {
+        return new InvalidInputError(err.message, "Check the signed transaction encoding and signature");
+      }
+      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:
+      if (/must be 32 bytes|expected 32 bytes|non-32-byte/i.test(err.message)) {
         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);
-    }
+      return new UnknownError(err.message);
+    default:
+      return new UnknownError(err.message);
+  }
+}
+function classifyError(err) {
+  if (err instanceof VsigError) return err;
+  if (err.code === "DUPLICATE_BROADCAST") {
+    return new DuplicateBroadcastRefusedError(err.message);
   }
+  if (err instanceof VaultError) return classifyVaultError(err);
   if (err instanceof VaultImportError) {
     switch (err.code) {
       case VaultImportErrorCode.PASSWORD_REQUIRED:
@@ -5159,18 +5199,24 @@ function classifyError(err) {
         return new UsageError(err.message);
     }
   }
+  if (err.code === "ENOENT") {
+    return new InvalidInputError(err.message, "Check that the file or directory exists");
+  }
   const msg = err.message.toLowerCase();
+  if (msg.includes("no vault found matching") || msg.includes("vault not found")) {
+    return new VaultNotFoundError(err.message);
+  }
   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 (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);
-  }
+  if (INVALID_ADDRESS_RE.test(msg)) return invalidAddressError(err.message);
   if (msg.includes("insufficient") && msg.includes("balance")) {
     return new InsufficientBalanceError(err.message);
   }
+  if (msg.includes("invalid currency") || msg.includes("invalid amount") || msg.includes("invalid mnemonic") || msg.includes("invalid seedphrase") || msg.includes("must be 32 bytes") || msg.includes("expected 32 bytes") || msg.includes("non-32-byte")) {
+    return new InvalidInputError(err.message);
+  }
   if (msg.includes("no route") || msg.includes("no swap") || msg.includes("no provider")) {
     return new NoRouteError(err.message);
   }
@@ -5482,16 +5528,30 @@ function clearCachedPassword(vaultIdOrName) {
 }
 function parseVaultPasswords() {
   const passwordMap = /* @__PURE__ */ new Map();
-  const passwordsEnv = process.env.VAULT_PASSWORDS;
-  if (passwordsEnv) {
-    const pairs = passwordsEnv.trim().split(/\s+/);
-    for (const pair of pairs) {
-      const colonIndex = pair.indexOf(":");
-      if (colonIndex > 0) {
-        const vaultKey = pair.substring(0, colonIndex);
-        const password = pair.substring(colonIndex + 1);
-        passwordMap.set(vaultKey, password);
+  const passwordsEnv = process.env.VAULT_PASSWORDS?.trim();
+  if (!passwordsEnv) return passwordMap;
+  if (passwordsEnv.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(passwordsEnv);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const entries = Object.entries(parsed);
+        if (entries.every(([vaultKey, password]) => vaultKey.length > 0 && typeof password === "string")) {
+          return new Map(entries);
+        }
       }
+      throw new Error("expected an object with string values");
+    } catch {
+      process.stderr.write(
+        "Warning: VAULT_PASSWORDS is not a valid JSON object with string values; falling back to legacy key:password parsing.\n"
+      );
+    }
+  }
+  for (const pair of passwordsEnv.split(/\s+/)) {
+    const colonIndex = pair.indexOf(":");
+    if (colonIndex > 0) {
+      const vaultKey = pair.substring(0, colonIndex);
+      const password = pair.substring(colonIndex + 1);
+      passwordMap.set(vaultKey, password);
     }
   }
   return passwordMap;
@@ -5511,7 +5571,7 @@ function getPasswordFromEnv(vaultId, vaultName) {
 }
 async function promptForPassword(vaultName, vaultId) {
   requireInteractive(
-    'Use --password flag, VAULT_PASSWORD env var, or "vsig auth setup" to store credentials in keyring.'
+    'Use --password, a vault password environment variable, or "vsig auth setup" to store credentials.'
   );
   const displayName = vaultName || vaultId || "vault";
   const { password } = await prompt([
@@ -5530,11 +5590,11 @@ async function resolvePasswordNonInteractive(vaultId, vaultName) {
     return cachedPassword;
   }
   try {
-    const keyringPassword = await getServerPassword(vaultId);
-    if (keyringPassword) {
-      cachePassword(vaultId, keyringPassword);
-      if (vaultName) cachePassword(vaultName, keyringPassword);
-      return keyringPassword;
+    const storedPassword = await getStoredServerPassword(vaultId);
+    if (storedPassword) {
+      cachePassword(vaultId, storedPassword);
+      if (vaultName) cachePassword(vaultName, storedPassword);
+      return storedPassword;
     }
   } catch {
   }
@@ -5703,7 +5763,7 @@ function displayVaultInfo(vault) {
   printResult(`  Chain Code:    ${vault.hexChainCode.substring(0, 20)}...
 `);
 }
-function displayTransactionPreview(fromAddress, toAddress, amount, symbol, chain, memo, gas) {
+function displayTransactionPreview(fromAddress, toAddress, amount, symbol, chain, memo, destinationTag, gas) {
   if (gas) {
     const bigIntReplacer2 = (_k, v) => typeof v === "bigint" ? v.toString() : v;
     info(chalk2.blue(`
@@ -5717,6 +5777,9 @@ Estimated gas: ${JSON.stringify(gas, bigIntReplacer2, 2)}`));
   if (memo) {
     printResult(`  Memo:   ${memo}`);
   }
+  if (destinationTag !== void 0) {
+    printResult(`  Destination tag: ${destinationTag}`);
+  }
 }
 function displayTransactionResult(chain, txHash) {
   const explorerUrl = Vultisig.getTxExplorerUrl(chain, txHash);
@@ -5985,6 +6048,122 @@ function shouldAutoSelectActiveVault(hasActiveVault, corruptPointer, vaultCount)
   return !hasActiveVault && !corruptPointer && vaultCount > 0;
 }
 
+// ../../packages/core/chain/dist/Chain.js
+var EthereumL2Chain = {
+  Arbitrum: "Arbitrum",
+  Base: "Base",
+  Blast: "Blast",
+  Optimism: "Optimism",
+  Zksync: "Zksync",
+  Mantle: "Mantle"
+};
+var EvmChain = {
+  ...EthereumL2Chain,
+  Avalanche: "Avalanche",
+  CronosChain: "CronosChain",
+  BSC: "BSC",
+  Ethereum: "Ethereum",
+  Polygon: "Polygon",
+  Hyperliquid: "Hyperliquid",
+  Sei: "Sei"
+};
+var UtxoChain;
+(function(UtxoChain2) {
+  UtxoChain2["Bitcoin"] = "Bitcoin";
+  UtxoChain2["BitcoinCash"] = "Bitcoin-Cash";
+  UtxoChain2["Litecoin"] = "Litecoin";
+  UtxoChain2["Dogecoin"] = "Dogecoin";
+  UtxoChain2["Dash"] = "Dash";
+  UtxoChain2["Zcash"] = "Zcash";
+})(UtxoChain || (UtxoChain = {}));
+var cosmosChainsByKind = {
+  ibcEnabled: {
+    Cosmos: "Cosmos",
+    Osmosis: "Osmosis",
+    Dydx: "Dydx",
+    Kujira: "Kujira",
+    Terra: "Terra",
+    TerraClassic: "TerraClassic",
+    Noble: "Noble",
+    Akash: "Akash"
+  },
+  vaultBased: {
+    THORChain: "THORChain",
+    MayaChain: "MayaChain"
+  }
+};
+var IbcEnabledCosmosChain = cosmosChainsByKind.ibcEnabled;
+var VaultBasedCosmosChain = cosmosChainsByKind.vaultBased;
+var CosmosChain = {
+  ...IbcEnabledCosmosChain,
+  ...VaultBasedCosmosChain
+};
+var OtherChain;
+(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 = {}));
+var Chain = {
+  ...EvmChain,
+  ...UtxoChain,
+  ...CosmosChain,
+  ...OtherChain
+};
+var UtxoBasedChain = [...Object.values(UtxoChain), OtherChain.Cardano];
+var defaultChains = [Chain.Bitcoin, Chain.Ethereum, Chain.THORChain, Chain.Solana, Chain.BSC];
+
+// ../../packages/core/chain/dist/ChainKind.js
+var chainKindRecord = {
+  [EvmChain.Arbitrum]: "evm",
+  [EvmChain.Avalanche]: "evm",
+  [EvmChain.Base]: "evm",
+  [EvmChain.CronosChain]: "evm",
+  [EvmChain.BSC]: "evm",
+  [EvmChain.Blast]: "evm",
+  [EvmChain.Ethereum]: "evm",
+  [EvmChain.Optimism]: "evm",
+  [EvmChain.Polygon]: "evm",
+  [EvmChain.Zksync]: "evm",
+  [EvmChain.Mantle]: "evm",
+  [EvmChain.Hyperliquid]: "evm",
+  [EvmChain.Sei]: "evm",
+  [UtxoChain.Bitcoin]: "utxo",
+  [UtxoChain.BitcoinCash]: "utxo",
+  [UtxoChain.Litecoin]: "utxo",
+  [UtxoChain.Dogecoin]: "utxo",
+  [UtxoChain.Dash]: "utxo",
+  [UtxoChain.Zcash]: "utxo",
+  [CosmosChain.THORChain]: "cosmos",
+  [CosmosChain.Cosmos]: "cosmos",
+  [CosmosChain.Osmosis]: "cosmos",
+  [CosmosChain.MayaChain]: "cosmos",
+  [CosmosChain.Dydx]: "cosmos",
+  [CosmosChain.Kujira]: "cosmos",
+  [CosmosChain.Terra]: "cosmos",
+  [CosmosChain.TerraClassic]: "cosmos",
+  [CosmosChain.Noble]: "cosmos",
+  [CosmosChain.Akash]: "cosmos",
+  [OtherChain.Sui]: "sui",
+  [OtherChain.Solana]: "solana",
+  [OtherChain.Polkadot]: "polkadot",
+  [OtherChain.Bittensor]: "bittensor",
+  [OtherChain.Ton]: "ton",
+  [OtherChain.Ripple]: "ripple",
+  [OtherChain.Tron]: "tron",
+  [OtherChain.Cardano]: "cardano",
+  [OtherChain.QBTC]: "qbtc"
+};
+function getChainKind(chain) {
+  return chainKindRecord[chain];
+}
+
 // src/agent/broadcastJournal.ts
 import { createHash } from "node:crypto";
 import {
@@ -6019,6 +6198,10 @@ var AgentErrorCode = /* @__PURE__ */ ((AgentErrorCode3) => {
   AgentErrorCode3["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
   AgentErrorCode3["SIGNING_FAILED"] = "SIGNING_FAILED";
   AgentErrorCode3["ACK_FAILED"] = "ACK_FAILED";
+  AgentErrorCode3["BROADCAST_COMMITTED"] = "BROADCAST_COMMITTED";
+  AgentErrorCode3["AGENT_TURN_BLOCKED"] = "AGENT_TURN_BLOCKED";
+  AgentErrorCode3["AGENT_TURN_REFUSAL"] = "AGENT_TURN_REFUSAL";
+  AgentErrorCode3["AGENT_TURN_ERROR"] = "AGENT_TURN_ERROR";
   AgentErrorCode3["DUPLICATE_BROADCAST"] = "DUPLICATE_BROADCAST";
   AgentErrorCode3["SESSION_NOT_INITIALIZED"] = "SESSION_NOT_INITIALIZED";
   AgentErrorCode3["LOOP_DEPTH_EXCEEDED"] = "LOOP_DEPTH_EXCEEDED";
@@ -6138,6 +6321,14 @@ function agentErrorCodeToExitCode(code) {
   switch (code) {
     case "ACK_FAILED" /* ACK_FAILED */:
       return 8 /* ACK_FAILED */;
+    case "BROADCAST_COMMITTED" /* BROADCAST_COMMITTED */:
+      return 13 /* BROADCAST_COMMITTED */;
+    case "AGENT_TURN_BLOCKED" /* AGENT_TURN_BLOCKED */:
+      return 10 /* AGENT_TURN_BLOCKED */;
+    case "AGENT_TURN_REFUSAL" /* AGENT_TURN_REFUSAL */:
+      return 11 /* AGENT_TURN_REFUSAL */;
+    case "AGENT_TURN_ERROR" /* AGENT_TURN_ERROR */:
+      return 1 /* USAGE */;
     case "AUTH_FAILED" /* AUTH_FAILED */:
     case "VAULT_LOCKED" /* VAULT_LOCKED */:
     case "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */:
@@ -6157,8 +6348,9 @@ function agentErrorCodeToExitCode(code) {
     case "ACTION_NOT_IMPLEMENTED" /* ACTION_NOT_IMPLEMENTED */:
     case "TOOL_UNSUPPORTED" /* TOOL_UNSUPPORTED */:
     case "SESSION_NOT_INITIALIZED" /* SESSION_NOT_INITIALIZED */:
-    case "CONFIRMATION_REQUIRED" /* CONFIRMATION_REQUIRED */:
       return 1 /* USAGE */;
+    case "CONFIRMATION_REQUIRED" /* CONFIRMATION_REQUIRED */:
+      return 12 /* CONFIRMATION_REQUIRED */;
     case "SIGNING_FAILED" /* SIGNING_FAILED */:
     case "LOOP_DEPTH_EXCEEDED" /* LOOP_DEPTH_EXCEEDED */:
     case "UNKNOWN_ERROR" /* UNKNOWN_ERROR */:
@@ -6214,8 +6406,9 @@ function journalPath() {
   const dir = process.env.VULTISIG_CONFIG_DIR && process.env.VULTISIG_CONFIG_DIR.trim() ? process.env.VULTISIG_CONFIG_DIR : join(homedir(), ".vultisig");
   return join(dir, "broadcasts.jsonl");
 }
-function normalize(v) {
-  return (v ?? "").trim().toLowerCase();
+function normalize(v, canonicalizeEmptyCalldata = false) {
+  const normalized = (v ?? "").trim().toLowerCase();
+  return canonicalizeEmptyCalldata && normalized === "0x" ? "" : normalized;
 }
 function computeFingerprint(intent) {
   const canonical = [
@@ -6223,7 +6416,10 @@ function computeFingerprint(intent) {
     normalize(intent.chain),
     normalize(intent.to),
     normalize(intent.value),
-    normalize(intent.data),
+    // Fold empty `"0x"` calldata to `""` for EVM only. For a memo (the default)
+    // `"0x"` is a real, distinct value and must survive — collapsing it would
+    // falsely dedupe two different memo-chain sends (PR #1259).
+    normalize(intent.data, intent.dataIsEvmCalldata === true),
     normalize(intent.asset)
   ].join("|");
   return createHash("sha256").update(canonical).digest("hex").slice(0, 32);
@@ -6528,7 +6724,17 @@ function buildSendBroadcastIntent(vault, chain, keysignPayload, opts = {}) {
     chain: chain.toString(),
     to: keysignPayload.toAddress || void 0,
     value: opts.isMax ? MAX_AMOUNT_SENTINEL : keysignPayload.toAmount || void 0,
+    // `data` is the user-supplied memo. On an EVM chain the signer encodes a
+    // `0x`-prefixed memo AS calldata (memoToTxData), so a memo of `"0x"` is empty
+    // calldata — functionally identical to a no-memo native transfer, and it must
+    // fold to `""` to cross-path dedupe with the agent path (which fingerprints the
+    // same send as empty `"0x"` calldata). On a memo-routed chain (THORChain,
+    // Cosmos, UTXO) the memo is a real distinct value and must NOT fold (PR #1259).
+    // So the fold is gated on chain kind — the single "is this data EVM calldata?"
+    // authority — not hardcoded, which keeps a new chain family from silently
+    // reintroducing the memo collision.
     data: keysignPayload.memo || void 0,
+    dataIsEvmCalldata: getChainKind(chain) === "evm",
     asset: isNative ? void 0 : coin?.contractAddress || coin?.ticker || void 0
   };
 }
@@ -6794,11 +7000,37 @@ Use --add <contractAddress> to add or --remove <tokenId> to remove`));
   }
 }
 
+// ../../packages/core/chain/dist/chains/ripple/address.js
+import { classicAddressToXAddress, isValidXAddress, xAddressToClassicAddress } from "ripple-address-codec";
+var assertSupportedTag = (tag) => {
+  if (tag === false)
+    return void 0;
+  return tag;
+};
+var decodeRippleXAddress = (address) => {
+  const value = address.trim();
+  if (!isValidXAddress(value))
+    throw new Error("Invalid XRP X-address");
+  const decoded = xAddressToClassicAddress(value);
+  if (decoded.test)
+    throw new Error("XRP testnet X-addresses are not supported");
+  return {
+    address: decoded.classicAddress,
+    destinationTag: assertSupportedTag(decoded.tag)
+  };
+};
+var normalizeRippleDestination = (address) => {
+  const value = address.trim();
+  if (value.startsWith("X") || value.startsWith("T"))
+    return decodeRippleXAddress(value);
+  return { address: value };
+};
+
 // src/commands/transaction.ts
-import { Chain, Vultisig as Vultisig2 } from "@vultisig/sdk";
+import { Chain as Chain2, Vultisig as Vultisig2 } from "@vultisig/sdk";
 async function executeSend(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
-  if (!Object.values(Chain).includes(params.chain)) {
+  if (!Object.values(Chain2).includes(params.chain)) {
     throw new Error(`Invalid chain: ${params.chain}`);
   }
   const isMax = params.amount === "max";
@@ -6814,6 +7046,14 @@ async function sendTransaction(vault, params) {
       "Pass --yes to confirm, or --dry-run to preview without signing."
     );
   }
+  const rippleDestination = params.chain === Chain2.Ripple ? normalizeRippleDestination(params.to) : { address: params.to };
+  const to = rippleDestination.address;
+  if (params.destinationTag !== void 0 && rippleDestination.destinationTag !== void 0 && params.destinationTag !== rippleDestination.destinationTag) {
+    throw new Error(
+      `Conflicting XRP destination tags: --destination-tag=${params.destinationTag} does not match the tag embedded in the X-address (${rippleDestination.destinationTag})`
+    );
+  }
+  const destinationTag = params.destinationTag ?? rippleDestination.destinationTag;
   const prepareSpinner = createSpinner("Preparing transaction...");
   const dryResult = await vault.send({
     chain: params.chain,
@@ -6821,6 +7061,7 @@ async function sendTransaction(vault, params) {
     amount: params.amount,
     symbol: params.tokenId,
     memo: params.memo,
+    destinationTag,
     dryRun: true
   });
   prepareSpinner.succeed("Transaction prepared");
@@ -6831,10 +7072,11 @@ async function sendTransaction(vault, params) {
     const result = {
       dryRun: true,
       chain: params.chain,
-      to: params.to,
+      to,
       amount: params.amount,
       symbol: balance2.symbol,
-      balance: balance2.formattedAmount
+      balance: balance2.formattedAmount,
+      destinationTag
     };
     if (hasInsufficientBalance) {
       result.warning = `Insufficient balance: you have ${balance2.formattedAmount} ${balance2.symbol}`;
@@ -6847,6 +7089,7 @@ Dry-run preview:`);
       info(`  Chain:   ${result.chain}`);
       info(`  To:      ${result.to}`);
       info(`  Amount:  ${result.amount} ${result.symbol}`);
+      if (result.destinationTag !== void 0) info(`  Destination tag: ${result.destinationTag}`);
       info(`  Fee:     ${dryResult.fee} ${result.symbol}`);
       info(`  Balance: ${result.balance} ${result.symbol}`);
       if (result.warning) warn(`  Warning: ${result.warning}`);
@@ -6862,7 +7105,16 @@ Dry-run preview:`);
   const balance = await vault.balance(params.chain, params.tokenId);
   if (!isJsonOutput()) {
     const address = await vault.address(params.chain);
-    displayTransactionPreview(address, params.to, dryResult.total, balance.symbol, params.chain, params.memo, gas);
+    displayTransactionPreview(
+      address,
+      to,
+      dryResult.total,
+      balance.symbol,
+      params.chain,
+      params.memo,
+      destinationTag,
+      gas
+    );
   }
   if (!params.yes) {
     const confirmed = await confirmTransaction();
@@ -6889,7 +7141,8 @@ Dry-run preview:`);
         to: params.to,
         amount: params.amount,
         symbol: params.tokenId,
-        memo: params.memo
+        memo: params.memo,
+        destinationTag
       });
       if (result.dryRun) throw new Error("unreachable");
       return result;
@@ -6916,7 +7169,7 @@ Dry-run preview:`);
 
 // src/commands/execute.ts
 var import_qrcode_terminal = __toESM(require_main(), 1);
-import { Vultisig as Vultisig3 } from "@vultisig/sdk";
+import { buildCosmosWasmExecuteMsg, Vultisig as Vultisig3 } from "@vultisig/sdk";
 var COSMOS_CHAIN_CONFIG = {
   THORChain: {
     chainId: "thorchain-1",
@@ -6948,7 +7201,9 @@ async function executeExecute(ctx2, params) {
   const chainConfig = COSMOS_CHAIN_CONFIG[params.chain];
   if (!chainConfig) {
     throw new Error(
-      `Chain ${params.chain} does not support CosmWasm execute. Supported chains: ${Object.keys(COSMOS_CHAIN_CONFIG).join(", ")}`
+      `Chain ${params.chain} does not support CosmWasm execute. Supported chains: ${Object.keys(
+        COSMOS_CHAIN_CONFIG
+      ).join(", ")}`
     );
   }
   let msg;
@@ -7069,15 +7324,12 @@ Or use this URL: ${qrPayload}
       decimals: chainConfig.decimals,
       ticker: chainConfig.denom.toUpperCase()
     };
-    const executeContractMsg = {
-      type: "wasm/MsgExecuteContract",
-      value: JSON.stringify({
-        sender: address,
-        contract: params.contract,
-        msg,
-        funds: funds.map((f) => ({ denom: f.denom, amount: f.amount }))
-      })
-    };
+    const executeContractMsg = buildCosmosWasmExecuteMsg({
+      sender: address,
+      contract: params.contract,
+      msg,
+      funds
+    });
     const fee = {
       amount: [{ denom: chainConfig.denom, amount: "0" }],
       gas: chainConfig.gasLimit
@@ -7128,10 +7380,10 @@ Or use this URL: ${qrPayload}
 
 // src/commands/sign.ts
 var import_qrcode_terminal2 = __toESM(require_main(), 1);
-import { Chain as Chain3 } from "@vultisig/sdk";
+import { Chain as Chain4 } from "@vultisig/sdk";
 async function executeSignBytes(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
-  if (!Object.values(Chain3).includes(params.chain)) {
+  if (!Object.values(Chain4).includes(params.chain)) {
     throw new Error(`Invalid chain: ${params.chain}`);
   }
   return signBytes(vault, params);
@@ -7211,10 +7463,10 @@ Or use this URL: ${qrPayload}
 }
 
 // src/commands/broadcast.ts
-import { Chain as Chain4, Vultisig as Vultisig4 } from "@vultisig/sdk";
+import { Chain as Chain5, Vultisig as Vultisig4 } from "@vultisig/sdk";
 async function executeBroadcast(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
-  if (!Object.values(Chain4).includes(params.chain)) {
+  if (!Object.values(Chain5).includes(params.chain)) {
     throw new Error(`Invalid chain: ${params.chain}`);
   }
   const broadcastSpinner = createSpinner("Broadcasting transaction...");
@@ -7243,7 +7495,21 @@ async function executeBroadcast(ctx2, params) {
 }
 
 // src/commands/tx-status.ts
-import { Chain as Chain5, isValidTxHash, Vultisig as Vultisig5 } from "@vultisig/sdk";
+import { Chain as Chain6, isValidTxHash, Vultisig as Vultisig5 } from "@vultisig/sdk";
+function resolveTxStatusParams(params) {
+  if (!Object.values(Chain6).includes(params.chain)) {
+    throw new InvalidInputError(`Invalid chain: ${params.chain}`);
+  }
+  if (!isValidTxHash(params.chain, params.txHash)) {
+    throw new InvalidTxHashError(
+      `Invalid transaction hash for ${params.chain}: "${params.txHash}"`,
+      "Check the hash \u2014 it must match the expected format for the chain.",
+      void 0,
+      { chain: params.chain, txHash: params.txHash, status: "invalid_hash" }
+    );
+  }
+  return params;
+}
 var POLL_INTERVAL_MS = 5e3;
 var DEFAULT_TIMEOUT_SEC = 120;
 var isTerminal = (status) => status === "success" || status === "error";
@@ -7251,21 +7517,12 @@ function resolveTimeoutMs(timeoutSec) {
   if (typeof timeoutSec !== "number" || !Number.isFinite(timeoutSec)) {
     return DEFAULT_TIMEOUT_SEC * 1e3;
   }
-  return Math.max(0, timeoutSec) * 1e3;
+  const ms = Math.max(0, timeoutSec) * 1e3;
+  return Number.isFinite(ms) ? ms : Number.MAX_SAFE_INTEGER;
 }
 async function executeTxStatus(ctx2, params, opts = {}) {
+  resolveTxStatusParams(params);
   const vault = await ctx2.ensureActiveVault();
-  if (!Object.values(Chain5).includes(params.chain)) {
-    throw new InvalidInputError(`Invalid chain: ${params.chain}`);
-  }
-  if (!isValidTxHash(params.chain, params.txHash)) {
-    throw new InvalidInputError(
-      `Invalid transaction hash for ${params.chain}: "${params.txHash}"`,
-      "Check the hash \u2014 it must match the expected format for the chain.",
-      void 0,
-      { chain: params.chain, txHash: params.txHash }
-    );
-  }
   const pollIntervalMs = opts.pollIntervalMs ?? POLL_INTERVAL_MS;
   const spinner = createSpinner("Checking transaction status...");
   try {
@@ -7286,7 +7543,12 @@ async function executeTxStatus(ctx2, params, opts = {}) {
         result = await vault.getTxStatus({ chain: params.chain, txHash: params.txHash });
       }
     }
-    spinner.succeed(`Transaction status: ${result.status}`);
+    if (result.status === "success") {
+      recordResolution(params.txHash, "confirmed");
+    } else if (result.status === "error") {
+      recordResolution(params.txHash, "failed");
+    }
+    spinner.succeed(`Transaction status: ${toCliStatus(result.status)}`);
     displayResult(params.chain, params.txHash, result);
     return result;
   } catch (error2) {
@@ -7316,11 +7578,12 @@ function giveUpError(params, result, waitedMs) {
   );
 }
 function displayResult(chain, txHash, result) {
+  const status = toCliStatus(result.status);
   if (isJsonOutput()) {
     outputJson({
       chain,
       txHash,
-      status: result.status,
+      status,
       receipt: result.receipt ? {
         feeAmount: result.receipt.feeAmount.toString(),
         feeDecimals: result.receipt.feeDecimals,
@@ -7329,7 +7592,7 @@ function displayResult(chain, txHash, result) {
       explorerUrl: Vultisig5.getTxExplorerUrl(chain, txHash)
     });
   } else {
-    printResult(`Status: ${result.status}`);
+    printResult(`Status: ${status}`);
     if (result.receipt) {
       const fee = formatFee(result.receipt.feeAmount, result.receipt.feeDecimals);
       printResult(`Fee: ${fee} ${result.receipt.feeTicker}`);
@@ -7337,6 +7600,11 @@ function displayResult(chain, txHash, result) {
     printResult(`Explorer: ${Vultisig5.getTxExplorerUrl(chain, txHash)}`);
   }
 }
+function toCliStatus(status) {
+  if (status === "success") return "confirmed";
+  if (status === "error") return "failed";
+  return status;
+}
 function formatFee(amount, decimals) {
   const str2 = amount.toString().padStart(decimals + 1, "0");
   const whole = str2.slice(0, -decimals) || "0";
@@ -8394,7 +8662,7 @@ async function executeSwap(ctx2, options) {
 }
 
 // src/commands/settings.ts
-import { Chain as Chain6, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
+import { Chain as Chain7, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
 import chalk6 from "chalk";
 async function executeCurrency(ctx2, newCurrency) {
   const vault = await ctx2.ensureActiveVault();
@@ -8461,7 +8729,7 @@ async function executeAddressBook(ctx2, options = {}) {
         type: "select",
         name: "chain",
         message: "Select chain:",
-        choices: Object.values(Chain6)
+        choices: Object.values(Chain7)
       });
     }
     if (!address) {
@@ -9340,11 +9608,11 @@ var genKeccak = (suffix, blockLen, outputLen, info2 = {}) => createHasher(() =>
 var keccak_256 = /* @__PURE__ */ genKeccak(1, 136, 32);
 
 // src/agent/auth.ts
-import { Chain as Chain7 } from "@vultisig/sdk";
+import { Chain as Chain8 } from "@vultisig/sdk";
 async function authenticateVault(client, vault, password, maxAttempts = 3) {
   const publicKey = vault.publicKeys.ecdsa;
   const chainCode = vault.hexChainCode;
-  const ethAddress = await vault.address(Chain7.Ethereum);
+  const ethAddress = await vault.address(Chain8.Ethereum);
   const nonce = "0x" + randomBytes(16).toString("hex");
   const expiresAt = new Date(Date.now() + 15 * 60 * 1e3).toISOString();
   const authMessage = JSON.stringify({
@@ -9361,7 +9629,7 @@ async function authenticateVault(client, vault, password, maxAttempts = 3) {
         process.stderr.write(`  Retry ${attempt}/${maxAttempts}...
 `);
       }
-      const signature = await vault.signBytes({ data: Buffer.from(messageHash), chain: Chain7.Ethereum }, {});
+      const signature = await vault.signBytes({ data: Buffer.from(messageHash), chain: Chain8.Ethereum }, {});
       const sigHex = formatSignature65(signature.signature, signature.recovery ?? 0);
       const authResponse = await client.authenticate({
         public_key: publicKey,
@@ -9592,380 +9860,19 @@ function renderBalanceSummaryCard(card) {
   return lines.join("\n");
 }
 
-// ../../packages/core/chain/dist/Chain.js
-var EthereumL2Chain = {
-  Arbitrum: "Arbitrum",
-  Base: "Base",
-  Blast: "Blast",
-  Optimism: "Optimism",
-  Zksync: "Zksync",
-  Mantle: "Mantle"
-};
-var EvmChain = {
-  ...EthereumL2Chain,
-  Avalanche: "Avalanche",
-  CronosChain: "CronosChain",
-  BSC: "BSC",
-  Ethereum: "Ethereum",
-  Polygon: "Polygon",
-  Hyperliquid: "Hyperliquid",
-  Sei: "Sei"
-};
-var UtxoChain;
-(function(UtxoChain2) {
-  UtxoChain2["Bitcoin"] = "Bitcoin";
-  UtxoChain2["BitcoinCash"] = "Bitcoin-Cash";
-  UtxoChain2["Litecoin"] = "Litecoin";
-  UtxoChain2["Dogecoin"] = "Dogecoin";
-  UtxoChain2["Dash"] = "Dash";
-  UtxoChain2["Zcash"] = "Zcash";
-})(UtxoChain || (UtxoChain = {}));
-var cosmosChainsByKind = {
-  ibcEnabled: {
-    Cosmos: "Cosmos",
-    Osmosis: "Osmosis",
-    Dydx: "Dydx",
-    Kujira: "Kujira",
-    Terra: "Terra",
-    TerraClassic: "TerraClassic",
-    Noble: "Noble",
-    Akash: "Akash"
-  },
-  vaultBased: {
-    THORChain: "THORChain",
-    MayaChain: "MayaChain"
-  }
-};
-var IbcEnabledCosmosChain = cosmosChainsByKind.ibcEnabled;
-var VaultBasedCosmosChain = cosmosChainsByKind.vaultBased;
-var CosmosChain = {
-  ...IbcEnabledCosmosChain,
-  ...VaultBasedCosmosChain
-};
-var OtherChain;
-(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 = {}));
-var Chain8 = {
-  ...EvmChain,
-  ...UtxoChain,
-  ...CosmosChain,
-  ...OtherChain
-};
-var UtxoBasedChain = [...Object.values(UtxoChain), OtherChain.Cardano];
-var defaultChains = [Chain8.Bitcoin, Chain8.Ethereum, Chain8.THORChain, Chain8.Solana, Chain8.BSC];
-
-// ../../packages/core/chain/dist/ChainKind.js
-var chainKindRecord = {
-  [EvmChain.Arbitrum]: "evm",
-  [EvmChain.Avalanche]: "evm",
-  [EvmChain.Base]: "evm",
-  [EvmChain.CronosChain]: "evm",
-  [EvmChain.BSC]: "evm",
-  [EvmChain.Blast]: "evm",
-  [EvmChain.Ethereum]: "evm",
-  [EvmChain.Optimism]: "evm",
-  [EvmChain.Polygon]: "evm",
-  [EvmChain.Zksync]: "evm",
-  [EvmChain.Mantle]: "evm",
-  [EvmChain.Hyperliquid]: "evm",
-  [EvmChain.Sei]: "evm",
-  [UtxoChain.Bitcoin]: "utxo",
-  [UtxoChain.BitcoinCash]: "utxo",
-  [UtxoChain.Litecoin]: "utxo",
-  [UtxoChain.Dogecoin]: "utxo",
-  [UtxoChain.Dash]: "utxo",
-  [UtxoChain.Zcash]: "utxo",
-  [CosmosChain.THORChain]: "cosmos",
-  [CosmosChain.Cosmos]: "cosmos",
-  [CosmosChain.Osmosis]: "cosmos",
-  [CosmosChain.MayaChain]: "cosmos",
-  [CosmosChain.Dydx]: "cosmos",
-  [CosmosChain.Kujira]: "cosmos",
-  [CosmosChain.Terra]: "cosmos",
-  [CosmosChain.TerraClassic]: "cosmos",
-  [CosmosChain.Noble]: "cosmos",
-  [CosmosChain.Akash]: "cosmos",
-  [OtherChain.Sui]: "sui",
-  [OtherChain.Solana]: "solana",
-  [OtherChain.Polkadot]: "polkadot",
-  [OtherChain.Bittensor]: "bittensor",
-  [OtherChain.Ton]: "ton",
-  [OtherChain.Ripple]: "ripple",
-  [OtherChain.Tron]: "tron",
-  [OtherChain.Cardano]: "cardano",
-  [OtherChain.QBTC]: "qbtc"
-};
-function getChainKind(chain) {
-  return chainKindRecord[chain];
-}
-
-// ../../packages/lib/utils/dist/record/recordMap.js
-function recordMap(record, fn) {
-  return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, fn(value, key)]));
-}
-
-// ../../packages/lib/utils/dist/record/makeRecord/index.js
-var makeRecord = (keys, getValue) => {
-  const record = {};
-  keys.forEach((key, index) => {
-    record[key] = getValue(key, index);
-  });
-  return record;
-};
-
-// ../../packages/core/chain/dist/chains/cosmos/thor/kujira-merge/index.js
-var kujiraCoinsMigratedToThorChain = ["kuji", "rkuji", "fuzn", "nstk", "wink", "lvn"];
-var kujiraCoinsMigratedToThorChainMetadata = {
-  kuji: {
-    ticker: "KUJI",
-    logo: "kuji",
-    priceProviderId: "kujira"
-  },
-  rkuji: {
-    ticker: "rKUJI",
-    logo: "rkuji.png",
-    priceProviderId: "kujira"
-  },
-  fuzn: {
-    ticker: "FUZN",
-    logo: "fuzn.png",
-    priceProviderId: "fuzion"
-  },
-  lvn: {
-    ticker: "LVN",
-    logo: "levana",
-    priceProviderId: "levana-protocol"
-  },
-  nstk: {
-    ticker: "NSTK",
-    logo: "nstk.png",
-    priceProviderId: "unstake-fi"
-  },
-  wink: {
-    ticker: "WINK",
-    logo: "wink.png",
-    priceProviderId: "winkhub"
-  }
-};
-var kujiraCoinMigratedToThorChainDestinationId = makeRecord(kujiraCoinsMigratedToThorChain, (id) => `thor.${id}`);
-
-// ../../packages/core/chain/dist/coin/chainFeeCoin.js
-var ether = {
-  ticker: "ETH",
-  logo: "eth",
-  decimals: 18,
-  priceProviderId: "ethereum"
-};
-var leanChainFeeCoin = {
-  [Chain8.Bitcoin]: {
-    ticker: "BTC",
-    logo: "btc",
-    decimals: 8,
-    priceProviderId: "bitcoin"
-  },
-  [Chain8.BitcoinCash]: {
-    ticker: "BCH",
-    logo: "bch",
-    decimals: 8,
-    priceProviderId: "bitcoin-cash"
-  },
-  [Chain8.Litecoin]: {
-    ticker: "LTC",
-    logo: "ltc",
-    decimals: 8,
-    priceProviderId: "litecoin"
-  },
-  [Chain8.Dogecoin]: {
-    ticker: "DOGE",
-    logo: "doge",
-    decimals: 8,
-    priceProviderId: "dogecoin"
-  },
-  [Chain8.Dash]: {
-    ticker: "DASH",
-    logo: "dash",
-    decimals: 8,
-    priceProviderId: "dash"
-  },
-  [Chain8.Ripple]: {
-    ticker: "XRP",
-    logo: "xrp",
-    decimals: 6,
-    priceProviderId: "ripple"
-  },
-  [Chain8.THORChain]: {
-    ticker: "RUNE",
-    logo: "rune",
-    decimals: 8,
-    priceProviderId: "thorchain"
-  },
-  [Chain8.MayaChain]: {
-    ticker: "CACAO",
-    logo: "cacao",
-    decimals: 10,
-    priceProviderId: "cacao"
-  },
-  [Chain8.Solana]: {
-    ticker: "SOL",
-    logo: "solana",
-    decimals: 9,
-    priceProviderId: "solana"
-  },
-  [Chain8.Ton]: {
-    ticker: "GRAM",
-    logo: "gram",
-    decimals: 9,
-    priceProviderId: "the-open-network"
-  },
-  [Chain8.Ethereum]: ether,
-  [Chain8.Avalanche]: {
-    ticker: "AVAX",
-    logo: "avax",
-    decimals: 18,
-    priceProviderId: "avalanche-2"
-  },
-  [Chain8.BSC]: {
-    ticker: "BNB",
-    logo: "bsc",
-    decimals: 18,
-    priceProviderId: "binancecoin"
-  },
-  [Chain8.Polygon]: {
-    ticker: "POL",
-    logo: "polygon",
-    decimals: 18,
-    priceProviderId: "polygon-ecosystem-token"
-  },
-  [Chain8.CronosChain]: {
-    ticker: "CRO",
-    logo: "cro",
-    decimals: 18,
-    priceProviderId: "crypto-com-chain"
-  },
-  [Chain8.Dydx]: {
-    ticker: "DYDX",
-    logo: "dydx",
-    decimals: 18,
-    priceProviderId: "dydx-chain"
-  },
-  [Chain8.Kujira]: {
-    ...kujiraCoinsMigratedToThorChainMetadata.kuji,
-    decimals: 6
-  },
-  [Chain8.Terra]: {
-    ticker: "LUNA",
-    logo: "luna",
-    decimals: 6,
-    priceProviderId: "terra-luna-2"
-  },
-  [Chain8.TerraClassic]: {
-    ticker: "LUNC",
-    logo: "lunc",
-    decimals: 6,
-    priceProviderId: "terra-luna"
-  },
-  [Chain8.Sui]: {
-    ticker: "SUI",
-    logo: "sui",
-    decimals: 9,
-    priceProviderId: "sui"
-  },
-  [Chain8.Polkadot]: {
-    ticker: "DOT",
-    logo: "dot",
-    decimals: 10,
-    priceProviderId: "polkadot"
-  },
-  [Chain8.Bittensor]: {
-    ticker: "TAO",
-    logo: "bittensor",
-    decimals: 9,
-    priceProviderId: "bittensor"
-  },
-  [Chain8.Noble]: {
-    ticker: "USDC",
-    logo: "noble",
-    decimals: 6,
-    priceProviderId: "usd-coin"
-  },
-  [Chain8.Akash]: {
-    ticker: "AKT",
-    logo: "akash",
-    decimals: 6,
-    priceProviderId: "akash-network"
-  },
-  [Chain8.Cosmos]: {
-    ticker: "ATOM",
-    logo: "atom",
-    decimals: 6,
-    priceProviderId: "cosmos"
-  },
-  [Chain8.Osmosis]: {
-    ticker: "OSMO",
-    logo: "osmo",
-    decimals: 6,
-    priceProviderId: "osmosis"
-  },
-  [Chain8.Tron]: {
-    ticker: "TRX",
-    logo: "tron",
-    decimals: 6,
-    priceProviderId: "tron"
-  },
-  ...recordMap(EthereumL2Chain, () => ether),
-  [Chain8.Zcash]: {
-    ticker: "ZEC",
-    logo: "zec",
-    decimals: 8,
-    priceProviderId: "zcash"
-  },
-  [Chain8.Cardano]: {
-    ticker: "ADA",
-    logo: "ada",
-    decimals: 6,
-    priceProviderId: "cardano"
-  },
-  [Chain8.Mantle]: {
-    ticker: "MNT",
-    logo: "mantle",
-    decimals: 18,
-    priceProviderId: "mantle"
-  },
-  [Chain8.Hyperliquid]: {
-    ticker: "HYPE",
-    logo: "hyperliquid",
-    decimals: 18,
-    priceProviderId: "hyperliquid"
-  },
-  [Chain8.Sei]: {
-    ticker: "SEI",
-    logo: "sei",
-    decimals: 18,
-    priceProviderId: "sei-network"
-  },
-  [Chain8.QBTC]: {
-    ticker: "QBTC",
-    logo: "qbtc",
-    decimals: 8,
-    priceProviderId: "qbtc-testnet"
-  }
-};
-var chainFeeCoin = recordMap(leanChainFeeCoin, (coin, chain) => ({
-  ...coin,
-  chain
-}));
+// src/agent/toolOutputSigning.ts
+import { getChainKind as getChainKind3 } from "@vultisig/sdk";
 
 // src/agent/executor.ts
-import { Chain as Chain9, VaultError as VaultError3, VaultErrorCode as VaultErrorCode3, Vultisig as VultisigSdk } from "@vultisig/sdk";
+import {
+  Chain as Chain9,
+  chainFeeCoin,
+  getChainKind as getChainKind2,
+  resolveChainReference,
+  VaultError as VaultError3,
+  VaultErrorCode as VaultErrorCode3,
+  Vultisig as VultisigSdk
+} from "@vultisig/sdk";
 
 // ../../node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
 init_getAddress();
@@ -10496,6 +10403,14 @@ var AgentExecutor = class {
   setPassword(password) {
     this.password = password;
   }
+  /**
+   * Whether a password is already held (set at unlock via the keyring/env chain
+   * or `--password`). The sign gate consults this so a session unlocked
+   * non-interactively doesn't get re-prompted for a secret it already has.
+   */
+  hasPassword() {
+    return this.password != null;
+  }
   /** Opt out of the persistent broadcast-journal duplicate guard (`--force`). */
   setForceBroadcast(force) {
     this.forceBroadcast = force;
@@ -10510,6 +10425,7 @@ var AgentExecutor = class {
    */
   buildBroadcastIntent(payload, chain, overrideTx) {
     const source = overrideTx ?? payload;
+    const dataIsEvmCalldata = getChainKind2(chain) === "evm";
     const nested = extractNestedTx(source);
     if (nested && (nested.to || nested.value || nested.data)) {
       return {
@@ -10517,7 +10433,8 @@ var AgentExecutor = class {
         chain: chain.toString(),
         to: nested.to != null ? String(nested.to) : void 0,
         value: nested.value != null ? String(nested.value) : void 0,
-        data: nested.data != null ? String(nested.data) : void 0
+        data: nested.data != null ? String(nested.data) : void 0,
+        dataIsEvmCalldata
       };
     }
     const txArgs = source?.txArgs ?? source;
@@ -10528,6 +10445,7 @@ var AgentExecutor = class {
       to: txArgs?.to != null ? String(txArgs.to) : void 0,
       value: txArgs?.amount != null ? String(txArgs.amount) : void 0,
       data: txArgs?.memo != null ? String(txArgs.memo) : void 0,
+      dataIsEvmCalldata,
       asset: asset != null ? String(asset) : void 0
     };
   }
@@ -10613,7 +10531,7 @@ var AgentExecutor = class {
       const txArgs = txReadyData.txArgs;
       if (txArgs && typeof txArgs === "object" && typeof txArgs.to === "string" && typeof txArgs.amount === "string") {
         const chain2 = resolveChainFromTxReady(txReadyData) || Chain9.Ethereum;
-        if (getChainKind(chain2) !== "evm") {
+        if (getChainKind2(chain2) !== "evm") {
           this.pendingPayloads.clear();
           this.pendingLegs = [];
           this.pendingPayloads.set("latest", {
@@ -10624,7 +10542,7 @@ var AgentExecutor = class {
           });
           if (this.verbose)
             process.stderr.write(
-              `[executor] Stored non-EVM server tx for chain ${chain2} (kind=${getChainKind(chain2)})
+              `[executor] Stored non-EVM server tx for chain ${chain2} (kind=${getChainKind2(chain2)})
 `
             );
           return true;
@@ -10973,7 +10891,7 @@ var AgentExecutor = class {
    */
   async signServerTx(serverTxData, defaultChain, params) {
     const chain = resolveChainFromTxReady(serverTxData) || defaultChain;
-    const chainKind = getChainKind(chain);
+    const chainKind = getChainKind2(chain);
     if (chainKind === "evm") {
       return this.signEvmServerTx(serverTxData, defaultChain, params);
     }
@@ -11816,41 +11734,7 @@ var AgentExecutor = class {
   }
 };
 function resolveChain(name) {
-  if (!name) return null;
-  if (Object.values(Chain9).includes(name)) {
-    return name;
-  }
-  const lower = name.toLowerCase();
-  for (const [, value] of Object.entries(Chain9)) {
-    if (typeof value === "string" && value.toLowerCase() === lower) {
-      return value;
-    }
-  }
-  const aliases = {
-    eth: "Ethereum",
-    btc: "Bitcoin",
-    sol: "Solana",
-    bnb: "BSC",
-    avax: "Avalanche",
-    matic: "Polygon",
-    arb: "Arbitrum",
-    op: "Optimism",
-    ltc: "Litecoin",
-    doge: "Dogecoin",
-    dot: "Polkadot",
-    atom: "Cosmos",
-    rune: "THORChain",
-    thor: "THORChain",
-    sui: "Sui",
-    ton: "Ton",
-    trx: "Tron",
-    xrp: "Ripple"
-  };
-  const aliased = aliases[lower];
-  if (aliased && Object.values(Chain9).includes(aliased)) {
-    return aliased;
-  }
-  return null;
+  return resolveChainReference(name) ?? null;
 }
 function resolveChainFromTxReady(txReadyData) {
   if (txReadyData.chain) {
@@ -11953,21 +11837,7 @@ function parseThorSwapMemo(memo) {
   return { destChainCode, destAsset, destAddress };
 }
 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
-  };
-  return chainIdMap[id] || null;
+  return resolveChainReference(chainId) ?? null;
 }
 function computeEIP712Hash(domain, types, primaryType, message) {
   const messageTypes = { ...types };
@@ -12099,7 +11969,7 @@ function resolveStrictEvmChain(chain, chainId) {
   const byName = resolveChain(chain);
   const byId = resolveChainId(chainId);
   if (!byName || !byId || byName !== byId) return null;
-  if (getChainKind(byName) !== "evm") return null;
+  if (getChainKind3(byName) !== "evm") return null;
   return byName;
 }
 function asChainString(value) {
@@ -12752,7 +12622,7 @@ var AgentClient = class {
 };
 
 // src/agent/context.ts
-import { Chain as Chain10 } from "@vultisig/sdk";
+import { Chain as Chain11 } from "@vultisig/sdk";
 function applyChainPublicKeys(vault, context) {
   const raw = vault.data.chainPublicKeys;
   if (!raw) return;
@@ -12865,57 +12735,57 @@ async function buildMinimalContext(vault) {
 }
 function getNativeTokenTicker(chain) {
   const tickers = {
-    [Chain10.Ethereum]: "ETH",
-    [Chain10.Bitcoin]: "BTC",
-    [Chain10.Solana]: "SOL",
-    [Chain10.THORChain]: "RUNE",
-    [Chain10.Cosmos]: "ATOM",
-    [Chain10.Avalanche]: "AVAX",
-    [Chain10.BSC]: "BNB",
-    [Chain10.Polygon]: "MATIC",
-    [Chain10.Arbitrum]: "ETH",
-    [Chain10.Optimism]: "ETH",
-    [Chain10.Base]: "ETH",
-    [Chain10.Blast]: "ETH",
-    [Chain10.Litecoin]: "LTC",
-    [Chain10.Dogecoin]: "DOGE",
-    [Chain10.Dash]: "DASH",
-    [Chain10.MayaChain]: "CACAO",
-    [Chain10.Polkadot]: "DOT",
-    [Chain10.Sui]: "SUI",
-    [Chain10.Ton]: "TON",
-    [Chain10.Tron]: "TRX",
-    [Chain10.Ripple]: "XRP",
-    [Chain10.Dydx]: "DYDX",
-    [Chain10.Osmosis]: "OSMO",
-    [Chain10.Terra]: "LUNA",
-    [Chain10.Noble]: "USDC",
-    [Chain10.Kujira]: "KUJI",
-    [Chain10.Zksync]: "ETH",
-    [Chain10.CronosChain]: "CRO"
+    [Chain11.Ethereum]: "ETH",
+    [Chain11.Bitcoin]: "BTC",
+    [Chain11.Solana]: "SOL",
+    [Chain11.THORChain]: "RUNE",
+    [Chain11.Cosmos]: "ATOM",
+    [Chain11.Avalanche]: "AVAX",
+    [Chain11.BSC]: "BNB",
+    [Chain11.Polygon]: "MATIC",
+    [Chain11.Arbitrum]: "ETH",
+    [Chain11.Optimism]: "ETH",
+    [Chain11.Base]: "ETH",
+    [Chain11.Blast]: "ETH",
+    [Chain11.Litecoin]: "LTC",
+    [Chain11.Dogecoin]: "DOGE",
+    [Chain11.Dash]: "DASH",
+    [Chain11.MayaChain]: "CACAO",
+    [Chain11.Polkadot]: "DOT",
+    [Chain11.Sui]: "SUI",
+    [Chain11.Ton]: "TON",
+    [Chain11.Tron]: "TRX",
+    [Chain11.Ripple]: "XRP",
+    [Chain11.Dydx]: "DYDX",
+    [Chain11.Osmosis]: "OSMO",
+    [Chain11.Terra]: "LUNA",
+    [Chain11.Noble]: "USDC",
+    [Chain11.Kujira]: "KUJI",
+    [Chain11.Zksync]: "ETH",
+    [Chain11.CronosChain]: "CRO"
   };
   return tickers[chain] || chain.toString();
 }
 function getNativeTokenDecimals(chain) {
   const decimals = {
-    [Chain10.Bitcoin]: 8,
-    [Chain10.Litecoin]: 8,
-    [Chain10.Dogecoin]: 8,
-    [Chain10.Dash]: 8,
-    [Chain10.Solana]: 9,
-    [Chain10.Sui]: 9,
-    [Chain10.Ton]: 9,
-    [Chain10.Polkadot]: 10,
-    [Chain10.Cosmos]: 6,
-    [Chain10.THORChain]: 8,
-    [Chain10.MayaChain]: 10,
-    [Chain10.Osmosis]: 6,
-    [Chain10.Dydx]: 18,
-    [Chain10.Tron]: 6,
-    [Chain10.Ripple]: 6,
-    [Chain10.Noble]: 6,
-    [Chain10.Kujira]: 6,
-    [Chain10.Terra]: 6
+    [Chain11.Bitcoin]: 8,
+    [Chain11.Litecoin]: 8,
+    [Chain11.Dogecoin]: 8,
+    [Chain11.Dash]: 8,
+    [Chain11.Solana]: 9,
+    [Chain11.Sui]: 9,
+    [Chain11.Ton]: 9,
+    [Chain11.Polkadot]: 10,
+    [Chain11.Cosmos]: 6,
+    [Chain11.THORChain]: 8,
+    [Chain11.MayaChain]: 10,
+    [Chain11.Osmosis]: 6,
+    [Chain11.Dydx]: 18,
+    [Chain11.Tron]: 6,
+    [Chain11.Ripple]: 6,
+    [Chain11.Noble]: 6,
+    [Chain11.Kujira]: 6,
+    [Chain11.Terra]: 6
   };
   return decimals[chain] || 18;
 }
@@ -13290,6 +13160,16 @@ var AgentSession = class {
         const conv = await this.withAuthRetry(() => this.client.getConversation(this.conversationId, this.publicKey));
         this.historyMessages = conv.messages || [];
       } catch (err) {
+        if (this.config.askMode) {
+          this.conversationId = null;
+          this.historyMessages = [];
+          throw Object.assign(
+            new Error(
+              `Session ${this.config.sessionId} could not be resumed (${err?.message ?? "unknown error"}); refusing to execute the request without its conversation context`
+            ),
+            { code: "SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */ }
+          );
+        }
         this.conversationId = null;
         this.historyMessages = [];
         const conv = await this.withAuthRetry(() => this.client.createConversation(this.publicKey));
@@ -13833,28 +13713,37 @@ var AgentSession = class {
     }
     let promptedPassword;
     if (PASSWORD_REQUIRED_TOOLS.has(toolName) && !this.config.password) {
-      try {
-        promptedPassword = await ui.requestPassword();
-        this.executor.setPassword(promptedPassword);
-      } catch {
-        const failure = {
-          tool: toolName,
-          success: false,
-          data: {
-            error: "Password not provided",
-            code: "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */
+      const vaultLocked = this.vault.isEncrypted && !this.vault.isUnlocked();
+      const needsPassword = vaultLocked && !this.executor.hasPassword();
+      if (needsPassword) {
+        const resolved = await resolvePasswordNonInteractive(this.vault.id, this.vault.name);
+        if (resolved) {
+          this.executor.setPassword(resolved);
+        } else {
+          try {
+            promptedPassword = await ui.requestPassword();
+            this.executor.setPassword(promptedPassword);
+          } catch {
+            const failure = {
+              tool: toolName,
+              success: false,
+              data: {
+                error: "Password not provided",
+                code: "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */
+              }
+            };
+            ui.onToolCall(toolCallId, toolName, input);
+            ui.onToolResult(
+              toolCallId,
+              toolName,
+              false,
+              failure.data,
+              "Password not provided",
+              "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */
+            );
+            return failure;
           }
-        };
-        ui.onToolCall(toolCallId, toolName, input);
-        ui.onToolResult(
-          toolCallId,
-          toolName,
-          false,
-          failure.data,
-          "Password not provided",
-          "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */
-        );
-        return failure;
+        }
       }
     }
     ui.onToolCall(toolCallId, toolName, input);
@@ -14437,10 +14326,79 @@ function outputAskError(wantsJson, message, code, conversationId, result) {
       ...Object.keys(data).length > 0 ? { data } : {}
     });
   } else {
+    if (result) {
+      process.stderr.write(`session:${result.sessionId}
+`);
+      if (result.outcome) {
+        const { kind, code: outcomeCode } = result.outcome;
+        process.stderr.write(`outcome:${kind}${outcomeCode ? `:${outcomeCode}` : ""}
+`);
+      }
+      if (result.response) process.stderr.write(`${result.response}
+`);
+    }
     process.stderr.write(`Error: ${message} [${code}]
 `);
   }
 }
+var BROADCAST_COMMITTED_MESSAGE = "A transaction was broadcast, but the overall agent request may be incomplete. Inspect the transaction status before continuing.";
+var ACK_FAILED_MESSAGE = "A transaction was broadcast, but its post-broadcast report failed. Inspect the transaction status before continuing.";
+function hasCommittedBroadcast(result) {
+  return !!result?.transactions.some((tx) => tx.hash.trim().length > 0 && tx.status !== "failed");
+}
+var SIGNING_TOOLS = /* @__PURE__ */ new Set(["sign_tx", "sign_typed_data"]);
+function failedSigningError(result) {
+  const failed = [...result.toolCalls].reverse().find((call) => SIGNING_TOOLS.has(call.action));
+  if (!failed || failed.success) return void 0;
+  const message = failed.error ?? (typeof failed.data?.error === "string" ? failed.data.error : void 0) ?? `${failed.action} failed`;
+  const dataCode = failed.data?.code;
+  const code = failed.code ?? (typeof dataCode === "string" && isAgentErrorCode(dataCode) ? dataCode : inferAgentErrorCodeFromMessage(message));
+  return { message, code };
+}
+function outputPostBroadcastFailure(wantsJson, result, conversationId, classification, originalError) {
+  const message = classification === "ACK_FAILED" /* ACK_FAILED */ ? ACK_FAILED_MESSAGE : BROADCAST_COMMITTED_MESSAGE;
+  if (wantsJson) {
+    const data = {
+      transactions: result.transactions,
+      tool_calls: result.toolCalls,
+      response: result.response,
+      ...result.outcome ? { outcome: result.outcome } : {},
+      ...originalError ? { original_error: originalError } : {}
+    };
+    outputErrorJson({
+      success: false,
+      v: 1,
+      error: { message, code: classification, conversation_id: conversationId },
+      data
+    });
+    return;
+  }
+  const label = classification === "ACK_FAILED" /* ACK_FAILED */ ? "Broadcast acknowledgement failed" : "Broadcast committed";
+  process.stderr.write(`session:${result.sessionId}
+`);
+  process.stderr.write(`${label}: ${message}
+`);
+  if (result.outcome) {
+    const { kind, code } = result.outcome;
+    process.stderr.write(`outcome:${kind}${code ? `:${code}` : ""}
+`);
+  }
+  if (originalError) {
+    process.stderr.write(`backend-error:${originalError.message} [${originalError.code}]
+`);
+  }
+  for (const tx of result.transactions) {
+    process.stderr.write(`tx:${tx.chain}:${tx.hash}
+`);
+    process.stderr.write(`status:${tx.status ?? "unknown"}
+`);
+    if (tx.explorerUrl) process.stderr.write(`explorer:${tx.explorerUrl}
+`);
+  }
+  process.stderr.write(
+    "WARNING: DO NOT blindly retry. Verify each transaction hash and continue only the incomplete step.\n"
+  );
+}
 function outputAskHuman(result, confirmationRequired, proposed) {
   process.stdout.write(`session:${result.sessionId}
 `);
@@ -14494,8 +14452,7 @@ function outputAskSuccess(wantsJson, result, conversationId) {
       // a2a-02: the typed turn ending (success | blocked | refusal | error) at
       // `data.outcome` — the same relative slot as on the error envelope. Present
       // only against a backend that honored the advertised turn_outcome surface;
-      // headless callers should branch on this (and the exit code), not `success`
-      // (which stays true for a completed-but-blocked/refused turn).
+      // headless callers can inspect it without parsing response prose.
       ...result.outcome ? { outcome: result.outcome } : {},
       ...confirmationRequired ? { confirmation_required: true } : {},
       ...proposed ? { proposed } : {}
@@ -14504,17 +14461,23 @@ function outputAskSuccess(wantsJson, result, conversationId) {
   }
   outputAskHuman(result, confirmationRequired, proposed);
 }
-function outcomeToExitCode(outcome) {
+function outcomeError(outcome) {
   switch (outcome?.kind) {
     case "blocked":
-      return 10 /* AGENT_TURN_BLOCKED */;
+      return {
+        message: "The agent request was blocked by a safety guardrail.",
+        code: "AGENT_TURN_BLOCKED" /* AGENT_TURN_BLOCKED */
+      };
     case "refusal":
-      return 11 /* AGENT_TURN_REFUSAL */;
+      return {
+        message: "The agent did not complete the requested action. Refine or clarify the request.",
+        code: "AGENT_TURN_REFUSAL" /* AGENT_TURN_REFUSAL */
+      };
     case "error":
-      return 1 /* USAGE */;
-    // 1 — generic failure; a stream error-frame path sets a more specific code first
-    case "success":
-      return 0 /* SUCCESS */;
+      return {
+        message: "The agent could not complete the requested action.",
+        code: "AGENT_TURN_ERROR" /* AGENT_TURN_ERROR */
+      };
     default:
       return void 0;
   }
@@ -14549,24 +14512,40 @@ async function executeAgentAsk(ctx2, message, options) {
     const result = await ask.ask(message);
     conversationId = result.sessionId;
     if (result.error) {
-      exitCode = agentErrorCodeToExitCode(result.error.code);
-      outputAskError(wantsJson, result.error.message, result.error.code, conversationId, result);
+      if (hasCommittedBroadcast(result)) {
+        exitCode = 13 /* BROADCAST_COMMITTED */;
+        outputPostBroadcastFailure(wantsJson, result, conversationId, "BROADCAST_COMMITTED" /* BROADCAST_COMMITTED */, result.error);
+      } else {
+        exitCode = agentErrorCodeToExitCode(result.error.code);
+        outputAskError(wantsJson, result.error.message, result.error.code, conversationId, result);
+      }
     } else {
-      exitCode = outcomeToExitCode(result.outcome) ?? 0;
-      outputAskSuccess(wantsJson, result, conversationId);
+      const failure = failedSigningError(result) ?? outcomeError(result.outcome);
+      if (failure && hasCommittedBroadcast(result)) {
+        exitCode = 13 /* BROADCAST_COMMITTED */;
+        outputPostBroadcastFailure(wantsJson, result, conversationId, "BROADCAST_COMMITTED" /* BROADCAST_COMMITTED */, failure);
+      } else if (failure) {
+        exitCode = agentErrorCodeToExitCode(failure.code);
+        outputAskError(wantsJson, failure.message, failure.code, conversationId, result);
+      } else {
+        exitCode = 0 /* SUCCESS */;
+        outputAskSuccess(wantsJson, result, conversationId);
+      }
     }
   } catch (err) {
     const normalized = normalizeAgentError(err);
-    let code = normalized.code;
+    const code = normalized.code;
     const message2 = normalized.message;
     const partial = ask?.partialResult();
     if (partial && !conversationId) conversationId = partial.sessionId;
-    const liveBroadcast = !!partial && partial.transactions.some((t) => t.hash && t.status !== "failed");
-    if (liveBroadcast && ask?.hasUnacknowledgedBroadcast()) {
-      code = "ACK_FAILED" /* ACK_FAILED */;
+    if (partial && hasCommittedBroadcast(partial)) {
+      const classification = ask?.hasUnacknowledgedBroadcast() ? "ACK_FAILED" /* ACK_FAILED */ : "BROADCAST_COMMITTED" /* BROADCAST_COMMITTED */;
+      exitCode = agentErrorCodeToExitCode(classification);
+      outputPostBroadcastFailure(wantsJson, partial, conversationId, classification, { message: message2, code });
+    } else {
+      exitCode = agentErrorCodeToExitCode(code);
+      outputAskError(wantsJson, message2, code, conversationId, partial);
     }
-    exitCode = agentErrorCodeToExitCode(code);
-    outputAskError(wantsJson, message2, code, conversationId, partial);
   } finally {
     console.log = originalConsoleLog;
     setSilentMode(false);
@@ -14671,7 +14650,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "2.19.14";
+    cachedVersion = "2.20.0";
     return cachedVersion;
   }
   try {
@@ -14954,7 +14933,7 @@ function readArgValue(args, optionName) {
 }
 
 // src/interactive/completer.ts
-import { Chain as Chain11 } from "@vultisig/sdk";
+import { Chain as Chain12 } from "@vultisig/sdk";
 import fs3 from "fs";
 import path3 from "path";
 var COMMANDS = [
@@ -15098,7 +15077,7 @@ function completeVaultName(ctx2, partial) {
   return [show, partial];
 }
 function completeChainName(partial) {
-  const allChains = Object.values(Chain11);
+  const allChains = Object.values(Chain12);
   const partialLower = partial.toLowerCase();
   const matches = allChains.filter((chain) => chain.toLowerCase().startsWith(partialLower));
   matches.sort();
@@ -15106,7 +15085,7 @@ function completeChainName(partial) {
   return [show, partial];
 }
 function findChainByName(name) {
-  const allChains = Object.values(Chain11);
+  const allChains = Object.values(Chain12);
   const nameLower = name.toLowerCase();
   const found = allChains.find((chain) => chain.toLowerCase() === nameLower);
   return found ? found : null;
@@ -15289,7 +15268,7 @@ var EventBuffer = class {
 };
 
 // src/interactive/session.ts
-import { fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
+import { Chain as Chain13, fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
 import chalk14 from "chalk";
 import ora3 from "ora";
 import * as readline3 from "readline";
@@ -16115,24 +16094,40 @@ Error: ${error2.message}`));
   }
   async runSend(args) {
     if (args.length < 3) {
-      console.log(chalk14.yellow("Usage: send <chain> <to> <amount> [--token <tokenId>] [--memo <memo>]"));
+      console.log(
+        chalk14.yellow("Usage: send <chain> <to> <amount> [--token <tokenId>] [--memo <memo>] [--destination-tag <tag>]")
+      );
       return;
     }
     const [chainStr, to, amount, ...rest] = args;
     const chain = findChainByName(chainStr) || chainStr;
     let tokenId;
     let memo;
+    let destinationTag;
     for (let i = 0; i < rest.length; i++) {
       if (rest[i] === "--token" && i + 1 < rest.length) {
         tokenId = rest[i + 1];
         i++;
       } else if (rest[i] === "--memo" && i + 1 < rest.length) {
-        memo = rest.slice(i + 1).join(" ");
-        break;
+        const nextOption = rest.findIndex(
+          (arg, index) => index > i && ["--token", "--memo", "--destination-tag"].includes(arg)
+        );
+        memo = rest.slice(i + 1, nextOption === -1 ? void 0 : nextOption).join(" ");
+        i = nextOption === -1 ? rest.length : nextOption - 1;
+      } else if (rest[i] === "--destination-tag") {
+        const tag = rest[i + 1];
+        const parsedTag = Number(tag);
+        if (chain !== Chain13.Ripple || !/^(0|[1-9]\d*)$/.test(tag ?? "") || !Number.isSafeInteger(parsedTag) || parsedTag > 4294967295) {
+          throw new Error("Invalid XRP DestinationTag: expected an integer from 0 to 4294967295");
+        }
+        destinationTag = parsedTag;
+        i++;
       }
     }
     try {
-      await this.withAbortHandler((signal) => executeSend(this.ctx, { chain, to, amount, tokenId, memo, signal }));
+      await this.withAbortHandler(
+        (signal) => executeSend(this.ctx, { chain, to, amount, tokenId, memo, destinationTag, signal })
+      );
     } catch (err) {
       if (err.message === "Transaction cancelled by user" || err.message === "Operation cancelled" || err.message === "Operation aborted") {
         console.log(chalk14.yellow("\nTransaction cancelled"));
@@ -16718,7 +16713,7 @@ program.name("vultisig").description("Vultisig CLI - Secure multi-party crypto w
   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  VULTISIG_HTTP_TIMEOUT_MS  Agent-backend request timeout in ms (default 30000)\n  NO_COLOR                Disable colored output"
+  "\nExit codes:\n" + Object.entries(EXIT_CODE_DESCRIPTIONS).map(([k, v]) => `  ${k}  ${v}`).join("\n") + "\n\nEnvironment variables:\n  VAULT_PASSWORD          Single fallback; unlocks the vault for reads and signing\n  VULTISIG_PASSWORD       Alias during normal unlock/signing (not auth setup)\n  VAULT_PASSWORDS         JSON object or space-separated key:password pairs\n  VAULT_DECRYPT_PASSWORD  Decrypt an encrypted .vult file during auth setup\n  VULTISIG_CREDENTIALS_PASSPHRASE  Encrypt credentials on disk without a keyring\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  VULTISIG_HTTP_TIMEOUT_MS  Agent-backend request timeout in ms (default 30000)\n  NO_COLOR                Disable colored output"
 ).hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   if (opts.ci) {
@@ -16996,7 +16991,7 @@ Examples:
     });
   })
 );
-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("--force", "Bypass the duplicate-broadcast guard (re-send an identical, recently-broadcast tx)").option("--password <password>", "Vault password for signing").addHelpText(
+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("--destination-tag <tag>", "XRP DestinationTag (0 to 4294967295)").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("--force", "Bypass the duplicate-broadcast guard (re-send an identical, recently-broadcast tx)").option("--password <password>", "Vault password for signing").addHelpText(
   "after",
   `
 Examples:
@@ -17006,7 +17001,7 @@ Examples:
 
 Environment variables:
   VAULT_PASSWORD    Vault password (bypasses prompt)
-  VAULT_PASSWORDS   Space-separated VaultName:password pairs
+  VAULT_PASSWORDS   JSON object or space-separated key:password pairs
 
 See also: balance, tx-status`
 ).action(
@@ -17014,14 +17009,23 @@ See also: balance, tx-status`
     async (chainStr, to, amount, options) => {
       if (!amount && !options.max) throw new Error("Provide an amount or use --max");
       if (amount && options.max) throw new Error("Cannot specify both amount and --max");
+      const chain = findChainByName(chainStr) || chainStr;
+      if (options.destinationTag !== void 0 && chain !== Chain14.Ripple) {
+        throw new Error("--destination-tag is only supported for XRP");
+      }
+      const destinationTag = options.destinationTag === void 0 ? void 0 : Number(options.destinationTag);
+      if (options.destinationTag !== void 0 && (!/^(0|[1-9]\d*)$/.test(options.destinationTag) || !Number.isSafeInteger(destinationTag) || destinationTag > 4294967295)) {
+        throw new Error("Invalid XRP DestinationTag: expected an integer from 0 to 4294967295");
+      }
       const context = await init(program.opts().vault);
       try {
         await executeSend(context, {
-          chain: findChainByName(chainStr) || chainStr,
+          chain,
           to,
           amount: amount ?? "max",
           tokenId: options.token,
           memo: options.memo,
+          destinationTag,
           dryRun: options.dryRun,
           yes: options.yes || options.confirm,
           force: options.force,
@@ -17087,28 +17091,32 @@ 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").option("--timeout <seconds>", "Max seconds to poll before giving up (default 120)").addHelpText(
+program.command("tx-status").description("Check transaction status (polls until terminal or timeout)").requiredOption("--chain <chain>", "Target blockchain").requiredOption("--tx-hash <hash>", "Transaction hash to check").option("--no-wait", "Return immediately without waiting for confirmation").option("--timeout <seconds>", "Max seconds to poll before giving up (default 120)").addHelpText(
   "after",
   `
+Statuses: pending, not_found, confirmed, failed
+Malformed hashes fail with INVALID_HASH (exit 4).
+
 Examples:
   vultisig tx-status --chain Ethereum --tx-hash 0xabc...
   vultisig tx-status --chain Ethereum --tx-hash 0xabc... --timeout 300
   vultisig tx-status --chain Bitcoin --tx-hash abc... --no-wait --output json`
 ).action(
   withExit(async (options) => {
-    const context = await init(program.opts().vault);
     const timeoutSec = options.timeout !== void 0 ? Number(options.timeout) : void 0;
     if (timeoutSec !== void 0 && (!Number.isFinite(timeoutSec) || timeoutSec < 0)) {
       throw new InvalidInputError(
         `Invalid --timeout: "${options.timeout}" (expected a non-negative number of seconds)`
       );
     }
-    await executeTxStatus(context, {
+    const params = resolveTxStatusParams({
       chain: findChainByName(options.chain) || options.chain,
       txHash: options.txHash,
       noWait: !options.wait,
       timeoutSec
     });
+    const context = await init(program.opts().vault);
+    await executeTxStatus(context, params);
   })
 );
 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(
@@ -17465,7 +17473,12 @@ Exit codes:
   7  unknown/unexpected error
   8  ACK_FAILED \u2014 broadcast succeeded but the post-broadcast report failed; the
      emitted tx hash IS VALID, do NOT blindly retry (that risks a double-spend)
-  9  duplicate-broadcast refused \u2014 nothing was sent; retry with --force`
+  9  duplicate-broadcast refused \u2014 nothing was sent; retry with --force
+  10 agent turn blocked by a fund-safety guardrail
+  11 model refusal or clarifying question; no action taken
+  12 non-interactive confirmation/input required
+  13 BROADCAST_COMMITTED \u2014 a transaction was submitted but the overall request may
+     be incomplete; inspect every emitted hash and DO NOT blindly retry`
 ).action(
   async (message, options) => {
     const parentOpts = agentCmd.opts();
@@ -17537,14 +17550,20 @@ 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(
+var authCmd = program.command("auth").description("Manage stored vault credentials");
+authCmd.command("setup").description("Import a .vult file and store credentials in the OS keyring or encrypted file").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`
+
+Keychain-less Docker/CI:
+  VULTISIG_CONFIG_DIR=/data/vultisig \\
+  VAULT_DECRYPT_PASSWORD=backup-password \\
+  VAULT_PASSWORD=server-password \\
+  VULTISIG_CREDENTIALS_PASSPHRASE=file-passphrase \\
+  vultisig auth setup --non-interactive --vault-file /vaults/vault.vult`
 ).action(
   withExit(async (options) => {
     const result = await executeAuthSetup({