@vultisig/cli 2.17.0 → 2.18.6

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # @vultisig/cli
 
+## 2.18.6
+
+### Patch Changes
+
+- [#1003](https://github.com/vultisig/vultisig-sdk/pull/1003) [`b27786d`](https://github.com/vultisig/vultisig-sdk/commit/b27786d8ac596ea3d2d4a13da958b266f589b73c) Thanks [@neavra](https://github.com/neavra)! - fix(agent): sign purely from the `tool-output-available` channel and remove the `tx_ready` signing path ([#927](https://github.com/vultisig/vultisig-sdk/issues/927) Phase 2). The client-enriched tool-output candidate (flat builders and `execute_*` prep) is now the sole signing source, matching what the production backend emits — it writes the signable payload on tool-output and emits `data-tx_ready` only as a hollow `{typed_confirm}` marker the CLI never consumed. Removes the Phase-1 dual-read + parity cross-check machinery, the tx_ready capture/selection, and the recovered-tx_ready replay. Fail-closed postures are preserved (a structurally-unsignable candidate is never buffered), and a disconnect that ran a signable tool now warns to re-run rather than signing. Patch: no CLI API change and the same real transactions still sign — this aligns the internal signing source with production.
+
+- [#1024](https://github.com/vultisig/vultisig-sdk/pull/1024) [`3bc7904`](https://github.com/vultisig/vultisig-sdk/commit/3bc790403483dd7e90dac2efc33d7bc64c18b921) Thanks [@neavra](https://github.com/neavra)! - Stop `tx-status` from reporting malformed or never-seen transaction hashes as `pending` forever.
+
+  - The EVM status resolver now distinguishes a genuinely-pending tx (the node knows the hash, receipt still lagging) from one the node has never seen, returning a new terminal `not_found` status for the latter instead of an indefinite `pending`.
+  - New `isValidTxHash(chain, hash)` helper validates a hash's shape per chain-kind; the CLI `tx-status` command validates `--tx-hash` before any RPC and fails fast with `INVALID_INPUT` (exit 4) on a malformed hash.
+  - CLI `tx-status` polling is now bounded by a total wait budget (`--timeout <seconds>`, default 120) and exits non-zero on give-up — `TX_NOT_FOUND` (exit 5) when the node has no record of the hash, `TX_STATUS_TIMEOUT` (exit 3, retryable) when it is still pending.
+  - The poll loop now caps each sleep at the remaining wait budget instead of always sleeping the full poll interval, so a small `--timeout` gives up promptly instead of overshooting by up to one poll interval.
+
+- Updated dependencies [[`ce38186`](https://github.com/vultisig/vultisig-sdk/commit/ce381864b977b19668702eae6e1ecad63ecbdf2b), [`3bc7904`](https://github.com/vultisig/vultisig-sdk/commit/3bc790403483dd7e90dac2efc33d7bc64c18b921)]:
+  - @vultisig/sdk@2.18.6
+  - @vultisig/core-chain@2.23.3
+
+## 2.18.0
+
+### Minor Changes
+
+- [#1004](https://github.com/vultisig/vultisig-sdk/pull/1004) [`42fe389`](https://github.com/vultisig/vultisig-sdk/commit/42fe3893196e7d8945f852695387828eb49bfb41) Thanks [@neavra](https://github.com/neavra)! - feat(cli): surface a typed turn-outcome for `agent ask` (success / blocked / refusal / error)
+
+  The CLI now advertises the `turn_outcome` surface and parses the backend's
+  `data-turn_outcome` SSE part, so a headless `agent ask` caller can tell four turn
+  endings apart WITHOUT parsing prose:
+
+  - **success** — the turn completed normally
+  - **blocked** — a fund-safety guardrail deliberately blocked the requested action
+  - **refusal** — the model refused or asked a clarifying question (no action taken)
+  - **error** — an infrastructure error ended the turn
+
+  Two additive surfaces:
+
+  - `agent ask --output json` gains a top-level `outcome` field
+    (`{ kind, code?, detail? }`) on both the success and error envelopes. Human
+    output prints a greppable `outcome:<kind>[:<code>]` line for non-success turns.
+  - New dedicated exit codes (additive; the 0–9 taxonomy is unchanged):
+    `10` = a fund-safety block, `11` = a refusal/clarifying question. A frame-less
+    infrastructure error now exits `1` instead of a false `0`. Success stays `0`.
+
+  Behavior change to note: a turn the backend BLOCKS or the model REFUSES previously
+  exited `0` (indistinguishable from success); it now exits `10`/`11`. Scripts that
+  treated every `agent ask` as success-on-0 should branch on `outcome.kind` (or the
+  exit code). Against an older backend that does not emit `data-turn_outcome`, the
+  `outcome` field is absent and exit codes are unchanged.
+
+### Patch Changes
+
+- Updated dependencies [[`31814c4`](https://github.com/vultisig/vultisig-sdk/commit/31814c4b452ef5b2628dc12bc46e427fcf0b7237), [`b37dc3c`](https://github.com/vultisig/vultisig-sdk/commit/b37dc3c31d6f93af982cd1e082e0b4d1382dc19d), [`01c5630`](https://github.com/vultisig/vultisig-sdk/commit/01c56303d0b872a76de07da9685331106f586c80)]:
+  - @vultisig/sdk@2.18.0
+  - @vultisig/rujira@51.0.0
+
 ## 2.17.0
 
 ### Patch Changes

package/dist/index.js

@@ -5316,7 +5316,9 @@ var EXIT_CODE_DESCRIPTIONS = {
   [6 /* EXTERNAL_SERVICE */]: "External service error (retryable)",
   [7 /* UNKNOWN */]: "Unknown/unexpected error",
   [8 /* ACK_FAILED */]: "Broadcast succeeded but post-broadcast report failed \u2014 hash is valid, do NOT retry",
-  [9 /* DUPLICATE_BROADCAST */]: "Duplicate broadcast refused (nothing sent) \u2014 retry with --force to override"
+  [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)"
 };
 var VsigError = class extends Error {
   hint;
@@ -5398,6 +5400,21 @@ var TokenNotFoundError = class extends VsigError {
     super(message, hint, suggestions, context);
   }
 };
+var TxNotFoundError = class extends VsigError {
+  exitCode = 5 /* RESOURCE_NOT_FOUND */;
+  code = "TX_NOT_FOUND";
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
+  }
+};
+var TxStatusTimeoutError = class extends VsigError {
+  exitCode = 3 /* NETWORK */;
+  code = "TX_STATUS_TIMEOUT";
+  retryable = true;
+  constructor(message, hint, suggestions, context) {
+    super(message, hint, suggestions, context);
+  }
+};
 var ExternalServiceError = class extends VsigError {
   exitCode = 6 /* EXTERNAL_SERVICE */;
   code = "EXTERNAL_SERVICE";
@@ -6536,33 +6553,78 @@ async function executeBroadcast(ctx2, params) {
 }
 
 // src/commands/tx-status.ts
-import { Chain as Chain5, Vultisig as Vultisig5 } from "@vultisig/sdk";
+import { Chain as Chain5, isValidTxHash, Vultisig as Vultisig5 } from "@vultisig/sdk";
 var POLL_INTERVAL_MS = 5e3;
-async function executeTxStatus(ctx2, params) {
+var DEFAULT_TIMEOUT_SEC = 120;
+var isTerminal = (status) => status === "success" || status === "error";
+function resolveTimeoutMs(timeoutSec) {
+  if (typeof timeoutSec !== "number" || !Number.isFinite(timeoutSec)) {
+    return DEFAULT_TIMEOUT_SEC * 1e3;
+  }
+  return Math.max(0, timeoutSec) * 1e3;
+}
+async function executeTxStatus(ctx2, params, opts = {}) {
   const vault = await ctx2.ensureActiveVault();
   if (!Object.values(Chain5).includes(params.chain)) {
-    throw new Error(`Invalid chain: ${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 {
     let result = await vault.getTxStatus({ chain: params.chain, txHash: params.txHash });
-    if (!params.noWait) {
-      let polls = 1;
-      while (result.status === "pending") {
-        spinner.text = `Transaction pending... (${polls * 5}s)`;
-        await sleep(POLL_INTERVAL_MS);
+    if (!params.noWait && !isTerminal(result.status)) {
+      const deadline = Date.now() + resolveTimeoutMs(params.timeoutSec);
+      let waited = 0;
+      while (!isTerminal(result.status)) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+          spinner.fail(`Gave up waiting after ${Math.round(waited / 1e3)}s (status: ${result.status})`);
+          throw giveUpError(params, result, waited);
+        }
+        const sleepMs = Math.min(pollIntervalMs, remainingMs);
+        waited += sleepMs;
+        spinner.text = `Transaction ${result.status}... (${Math.round(waited / 1e3)}s)`;
+        await sleep(sleepMs);
         result = await vault.getTxStatus({ chain: params.chain, txHash: params.txHash });
-        polls++;
       }
     }
     spinner.succeed(`Transaction status: ${result.status}`);
     displayResult(params.chain, params.txHash, result);
     return result;
   } catch (error2) {
+    if (error2 instanceof TxNotFoundError || error2 instanceof TxStatusTimeoutError) {
+      throw error2;
+    }
     spinner.fail("Failed to check transaction status");
     throw error2;
   }
 }
+function giveUpError(params, result, waitedMs) {
+  const seconds = Math.round(waitedMs / 1e3);
+  const context = { chain: params.chain, txHash: params.txHash, status: result.status };
+  if (result.status === "not_found") {
+    return new TxNotFoundError(
+      `Transaction not found on ${params.chain} after ${seconds}s: ${params.txHash}`,
+      "The node has no record of this hash \u2014 it may have been dropped, replaced, or never broadcast.",
+      ["Verify the transaction hash", "Re-broadcast if it was never sent"],
+      context
+    );
+  }
+  return new TxStatusTimeoutError(
+    `Transaction still ${result.status} on ${params.chain} after ${seconds}s: ${params.txHash}`,
+    "The transaction may still confirm later.",
+    ["Re-run to keep checking", "Increase the wait budget with --timeout <seconds>"],
+    context
+  );
+}
 function displayResult(chain, txHash, result) {
   if (isJsonOutput()) {
     outputJson({
@@ -8249,6 +8311,7 @@ var AskInterface = class {
   toolCalls = [];
   transactions = [];
   cards = [];
+  outcome;
   error;
   // Initialize-time error, kept SEPARATE from the turn error so it stays the
   // LOWEST-priority signal. initialize() drives getCallbacks() BEFORE the first
@@ -8311,6 +8374,9 @@ var AskInterface = class {
       onBalanceSummary: (card) => {
         this.cards.push(card);
       },
+      onTurnOutcome: (outcome) => {
+        this.outcome = outcome;
+      },
       onSuggestions: (_suggestions) => {
       },
       onTxStatus: (txHash, chain, status, explorerUrl) => {
@@ -8327,12 +8393,12 @@ var AskInterface = class {
         }
       },
       onError: (message, code) => {
-        const isTerminal = isTerminalAgentErrorCode(code);
+        const isTerminal2 = isTerminalAgentErrorCode(code);
         if (!this.hasAsked) {
           this.initError = { message, code };
-        } else if (!this.error || isTerminal && !this.errorIsTerminal) {
+        } else if (!this.error || isTerminal2 && !this.errorIsTerminal) {
           this.error = { message, code };
-          this.errorIsTerminal = isTerminal;
+          this.errorIsTerminal = isTerminal2;
         }
         process.stderr.write(`[error] ${message} [${code}]
 `);
@@ -8363,6 +8429,7 @@ var AskInterface = class {
     this.toolCalls = [];
     this.transactions = [];
     this.cards = [];
+    this.outcome = void 0;
     this.error = void 0;
     if (this.hasAsked) {
       this.initError = void 0;
@@ -8390,7 +8457,8 @@ var AskInterface = class {
       cards: this.cards,
       // A real turn error wins; fall back to the init-time signal (e.g. stale
       // --session SESSION_NOT_FOUND) only when the turn produced no error.
-      error: this.error ?? this.initError
+      error: this.error ?? this.initError,
+      ...this.outcome ? { outcome: this.outcome } : {}
     };
   }
 };
@@ -8797,7 +8865,19 @@ function padTo32Bytes(buf) {
 
 // src/agent/cards.ts
 import chalk8 from "chalk";
-var CLI_SUPPORTED_SURFACES = ["balance_summary"];
+var CLI_SUPPORTED_SURFACES = ["balance_summary", "turn_outcome"];
+function parseTurnOutcome(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const kind = raw.kind;
+  if (kind !== "success" && kind !== "blocked" && kind !== "refusal" && kind !== "error") return null;
+  const code = raw.code;
+  const detail = raw.detail;
+  return {
+    kind,
+    ...typeof code === "string" ? { code } : {},
+    ...typeof detail === "string" ? { detail } : {}
+  };
+}
 function stripControlChars(s) {
   let out = "";
   for (const ch of s) {
@@ -11749,7 +11829,7 @@ var CLI_SIGNABLE_FLAT_TOOLS = /* @__PURE__ */ new Set([
   "build_max_subscription_renewal",
   "build_pro_subscription_renewal"
 ]);
-var CLI_PARITY_PREP_TOOLS = /* @__PURE__ */ new Set([
+var CLI_SIGNABLE_PREP_TOOLS = /* @__PURE__ */ new Set([
   "execute_swap",
   "execute_send",
   "execute_contract_call"
@@ -11809,6 +11889,22 @@ function asChainIdString(value) {
   if (typeof value === "number" && Number.isFinite(value)) return String(value);
   return void 0;
 }
+function resolvePrepChain(txArgs) {
+  const byName = asChainString(txArgs.chain) ? resolveChain(asChainString(txArgs.chain)) : null;
+  const byId = asChainIdString(txArgs.chain_id) ? resolveChainId(asChainIdString(txArgs.chain_id)) : null;
+  if (!byName && !byId) return null;
+  if (byName && byId && byName !== byId) return null;
+  return byName ?? byId;
+}
+function resolvePrepParentChain(env) {
+  const byChain = asChainString(env.chain) ? resolveChain(asChainString(env.chain)) : null;
+  const byFromChain = asChainString(env.from_chain) ? resolveChain(asChainString(env.from_chain)) : null;
+  const byId = asChainIdString(env.chain_id) ? resolveChainId(asChainIdString(env.chain_id)) : null;
+  const candidates = [byChain, byFromChain, byId].filter((c) => c !== null);
+  if (candidates.length === 0) return null;
+  if (candidates.some((c) => c !== candidates[0])) return null;
+  return candidates[0];
+}
 function buildTxReadyFromToolOutput(toolName, output) {
   if (!CLI_SIGNABLE_FLAT_TOOLS.has(toolName)) return null;
   const env = asRecord(output);
@@ -11843,12 +11939,24 @@ function deriveToolOutputCandidate(toolName, output) {
     const payload = buildTxReadyFromToolOutput(toolName, output);
     return payload ? { payload, source: "flat", toolName } : null;
   }
-  if (CLI_PARITY_PREP_TOOLS.has(toolName)) {
+  if (CLI_SIGNABLE_PREP_TOOLS.has(toolName)) {
     const env = asRecord(output);
     if (!env || env.status === "error" || "error" in env) return null;
     const txArgs = asRecord(env.txArgs);
     if (!txArgs) return null;
     if (typeof txArgs.tx_encoding !== "string" || txArgs.tx_encoding === "") return null;
+    const prepChain = resolvePrepChain(txArgs);
+    if (!prepChain) return null;
+    const hasParentChainMetadata = asChainString(env.chain) !== void 0 || asChainString(env.from_chain) !== void 0 || asChainIdString(env.chain_id) !== void 0;
+    if (hasParentChainMetadata) {
+      const parentChain = resolvePrepParentChain(env);
+      if (!parentChain || parentChain !== prepChain) return null;
+    }
+    const approvalTxArgs = asRecord(env.approvalTxArgs);
+    if (approvalTxArgs) {
+      const approvalChain = resolvePrepChain(approvalTxArgs);
+      if (!approvalChain || approvalChain !== prepChain) return null;
+    }
     return { payload: env, source: "prep", toolName };
   }
   return null;
@@ -11858,105 +11966,6 @@ function str(value) {
   if (typeof value === "number" && Number.isFinite(value)) return String(value);
   return void 0;
 }
-function nestedSource(legObj) {
-  const nested = (asRecord(legObj.tx) || asRecord(legObj.swap_tx) || asRecord(legObj.send_tx) || asRecord(legObj.txArgs?.tx)) ?? asRecord(legObj.txArgs) ?? legObj;
-  return nested;
-}
-function canonGasLimit(value) {
-  if (typeof value === "number" && Number.isInteger(value) && value > 0) return String(value);
-  if (typeof value === "string") {
-    const t = value.trim();
-    if (/^\d+$/.test(t) || /^0x[0-9a-fA-F]+$/.test(t)) {
-      try {
-        const n = BigInt(t);
-        return n > 0n ? n.toString() : void 0;
-      } catch {
-        return void 0;
-      }
-    }
-  }
-  return void 0;
-}
-function canonLeg(legObj) {
-  const src = nestedSource(legObj);
-  const txArgs = asRecord(legObj.txArgs);
-  const toRaw = str(src.to) ?? str(src.to_address);
-  const dataRaw = str(src.data) ?? str(src.calldata);
-  const leg = {
-    to: toRaw ? toRaw.toLowerCase() : void 0,
-    value: normalizeValue(src.value),
-    data: dataRaw ? dataRaw.toLowerCase() : void 0,
-    gasLimit: canonGasLimit(src.gas_limit),
-    chain: str(legObj.chain) ?? str(txArgs?.chain) ?? str(src.chain),
-    chainId: str(legObj.chain_id) ?? str(txArgs?.chain_id) ?? str(src.chain_id),
-    txEncoding: str(src.tx_encoding) ?? str(txArgs?.tx_encoding),
-    amount: str(src.amount) ?? str(txArgs?.amount),
-    memo: str(src.memo) ?? str(txArgs?.memo)
-  };
-  return leg;
-}
-var TX_READY_EXCLUSIVE_KEYS = ["typed_confirm", "sequence_id", "sequence_index", "sequence_total"];
-function collectExclusive(payload) {
-  const found = [];
-  const scan = (obj) => {
-    if (!obj) return;
-    for (const k of TX_READY_EXCLUSIVE_KEYS) if (k in obj && !found.includes(k)) found.push(k);
-  };
-  scan(payload);
-  scan(asRecord(payload.tx));
-  scan(asRecord(payload.txArgs));
-  return found;
-}
-function canonicalizeForParity(payload) {
-  const env = asRecord(payload);
-  if (!env) return null;
-  const approval = asRecord(env.approvalTxArgs);
-  const main = asRecord(env.txArgs);
-  const legs = approval && main ? [canonLeg(approval), canonLeg(main)] : [canonLeg(env)];
-  return { legs, exclusive: collectExclusive(env) };
-}
-var HARD_FIELDS = [
-  "to",
-  "value",
-  "data",
-  "chain",
-  "chainId",
-  "txEncoding",
-  "amount",
-  "memo",
-  // gas_limit is signing-relevant, NOT advisory: signEvmServerTx copies a
-  // server-supplied gas_limit into the signed ethereumSpecific.gasLimit when it
-  // exceeds the SDK estimate, so a gas_limit divergence means different signed
-  // bytes/fee. Parity must surface it.
-  "gasLimit"
-];
-function diffToolOutputParity(enriched, txReady) {
-  const ce = canonicalizeForParity(enriched);
-  const ct = canonicalizeForParity(txReady);
-  const divergences = [];
-  if (!ce || !ct) {
-    return {
-      match: false,
-      divergences: [`uncomparable payload (enriched=${ce ? "ok" : "null"}, tx_ready=${ct ? "ok" : "null"})`],
-      txReadyExclusive: ct?.exclusive ?? []
-    };
-  }
-  if (ce.legs.length !== ct.legs.length) {
-    divergences.push(`leg count: tool-output ${ce.legs.length} vs tx_ready ${ct.legs.length}`);
-  }
-  const n = Math.min(ce.legs.length, ct.legs.length);
-  for (let i = 0; i < n; i++) {
-    for (const f of HARD_FIELDS) {
-      const a = ce.legs[i][f];
-      const b = ct.legs[i][f];
-      if (a !== b && !(a === void 0 && b === void 0)) {
-        divergences.push(`leg[${i}].${f}: tool-output ${a ?? "\u2205"} vs tx_ready ${b ?? "\u2205"}`);
-      }
-    }
-  }
-  const txReadyExclusive = ct.exclusive.filter((k) => !ce.exclusive.includes(k));
-  return { match: divergences.length === 0, divergences, txReadyExclusive };
-}
 function payloadLooksSignable(payload) {
   const env = asRecord(payload);
   if (!env) return false;
@@ -12246,7 +12255,6 @@ var AgentClient = class {
     const result = {
       fullText: "",
       suggestions: [],
-      transactions: [],
       message: null,
       finished: false,
       disconnected: false,
@@ -12257,7 +12265,6 @@ var AgentClient = class {
       serverNow: res.headers.get("X-Server-Now")
     };
     const toolNameByCallId = /* @__PURE__ */ new Map();
-    const parity = { lastSignableToolCallId: null };
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -12272,7 +12279,7 @@ var AgentClient = class {
         currentData += (currentData ? "\n" : "") + stripLeadingSpace(line.slice(5));
       } else if (line === "") {
         if (currentData) {
-          this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks, toolNameByCallId, parity);
+          this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks, toolNameByCallId);
         }
         currentEvent = "";
         currentData = "";
@@ -12292,7 +12299,7 @@ var AgentClient = class {
         if (done) {
           if (trailing) processLine(trailing);
           if (currentData) {
-            this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks, toolNameByCallId, parity);
+            this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks, toolNameByCallId);
           }
           break;
         }
@@ -12309,7 +12316,7 @@ var AgentClient = class {
     }
     return result;
   }
-  handleSSEEvent(event, data, result, callbacks, toolNameByCallId, parity) {
+  handleSSEEvent(event, data, result, callbacks, toolNameByCallId) {
     try {
       const parsed = JSON.parse(data);
       const v1Type = getV1Type(parsed);
@@ -12320,7 +12327,7 @@ var AgentClient = class {
           this.handleTextDelta(parsed, result, callbacks);
           break;
         case "tool_progress":
-          this.handleToolProgress(parsed, data, callbacks, toolNameByCallId, v1Type, parity);
+          this.handleToolProgress(parsed, data, callbacks, toolNameByCallId, v1Type);
           break;
         case "title": {
           const title = v1Data?.title ?? parsed.title;
@@ -12333,20 +12340,16 @@ var AgentClient = class {
           callbacks.onSuggestions?.(suggestions);
           break;
         }
-        case "tx_ready":
-          if (this.verbose) process.stderr.write(`[SSE:tx_ready] raw: ${data.slice(0, 2e3)}
-`);
-          {
-            const txReady = v1Data ?? parsed;
-            result.transactions.push(txReady);
-            callbacks.onTxReady?.(txReady, parity.lastSignableToolCallId ?? void 0);
-          }
-          break;
         case "balance_summary": {
           const card = v1Data ?? parsed.data ?? parsed;
           callbacks.onBalanceSummary?.(card);
           break;
         }
+        case "turn_outcome": {
+          const outcome = parseTurnOutcome(v1Data ?? parsed.data ?? parsed);
+          if (outcome) callbacks.onTurnOutcome?.(outcome);
+          break;
+        }
         case "message": {
           const msg = v1Data?.message ?? parsed.message ?? parsed;
           result.message = msg;
@@ -12375,7 +12378,7 @@ var AgentClient = class {
     result.fullText += parsed.delta;
     callbacks.onTextDelta?.(parsed.delta);
   }
-  handleToolProgress(parsed, data, callbacks, toolNameByCallId, v1Type, parity) {
+  handleToolProgress(parsed, data, callbacks, toolNameByCallId, v1Type) {
     if (this.verbose) process.stderr.write(`[SSE:tool_progress] raw: ${data.slice(0, 1e3)}
 `);
     const status = parsed.status ?? v1StatusFromType(v1Type);
@@ -12388,32 +12391,27 @@ var AgentClient = class {
     this.maybeEmitClientSideToolCall(parsed, callbacks, v1Type, callId, toolName);
     const ok = deriveToolDoneOk(status, parsed.output);
     if (status && toolName) callbacks.onToolProgress?.(toolName, status, label, ok);
-    this.maybeSignToolOutput(status, toolName, parsed.output, callbacks, callId, parity);
+    this.maybeSignToolOutput(status, toolName, parsed.output, callbacks);
     if (status === "done" && callId) toolNameByCallId.delete(callId);
   }
   /**
-   * Phase-1 dual-read: derive a client-side signable candidate from a signable
-   * tool's raw `tool-output-available` output — the same envelope mobile reads —
-   * and hand it to the session via `onToolOutputTx` (SEPARATE from the backend
-   * `tx_ready` channel). The session decides how to use it:
-   *  - flat off-chain tools with NO `tx_ready` (polymarket) → the sign source
-   *    (unchanged from #922);
-   *  - `produces_calldata` tools that also emit `tx_ready` (`execute_*`,
-   *    `erc20_approve`, `build_custom_*`) → the PARITY reference; `tx_ready`
-   *    stays authoritative when signable.
-   * The bridge guards against non-tx results (`no_op` / `insufficient_*` /
-   * errors) so those never reach the signer. Zero backend change.
+   * #927 Phase 2: derive a client-side signable candidate from a signable tool's
+   * raw `tool-output-available` output — the same envelope mobile reads — and
+   * hand it to the session via `onToolOutputTx` as the SOLE signing source
+   * (production emits the payload here; `data-tx_ready` is a hollow marker). The
+   * bridge guards against non-tx results (`no_op` / `insufficient_*` / errors)
+   * and phantom-card prep envelopes so those never reach the signer. Zero backend
+   * change.
    */
-  maybeSignToolOutput(status, toolName, output, callbacks, callId, parity) {
+  maybeSignToolOutput(status, toolName, output, callbacks) {
     if (status !== "done" || !toolName || !callbacks.onToolOutputTx) return;
-    if (!CLI_SIGNABLE_FLAT_TOOLS.has(toolName) && !CLI_PARITY_PREP_TOOLS.has(toolName)) return;
+    if (!CLI_SIGNABLE_FLAT_TOOLS.has(toolName) && !CLI_SIGNABLE_PREP_TOOLS.has(toolName)) return;
     const candidate = deriveToolOutputCandidate(toolName, output);
     if (!candidate) return;
-    if (callId) parity.lastSignableToolCallId = callId;
     if (this.verbose)
       process.stderr.write(`[SSE:tool_output] ${toolName} \u2192 onToolOutputTx (${candidate.source} candidate)
 `);
-    callbacks.onToolOutputTx(candidate.payload, toolName, candidate.source, callId ?? void 0);
+    callbacks.onToolOutputTx(candidate.payload, toolName, candidate.source);
   }
   maybeEmitClientSideToolCall(parsed, callbacks, v1Type, callId, toolName) {
     if (v1Type !== "tool-input-available" || !callId || !toolName || !this.clientSideToolNames.has(toolName) || !callbacks.onClientSideToolCall) {
@@ -12430,7 +12428,9 @@ 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.
+  // to 'ignore' which is a no-op. `data-tx_ready` also routes to 'ignore':
+  // #927 Phase 2 signs purely from `tool-output-available`, and production emits
+  // `data-tx_ready` only as a hollow `{typed_confirm}` marker the CLI doesn't use.
   mapV1EventType(type) {
     switch (type) {
       case "text-delta":
@@ -12444,10 +12444,10 @@ var AgentClient = class {
         return "title";
       case "data-suggestions":
         return "suggestions";
-      case "data-tx_ready":
-        return "tx_ready";
       case "data-balance_summary":
         return "balance_summary";
+      case "data-turn_outcome":
+        return "turn_outcome";
       case "data-message":
         return "message";
       case "error":
@@ -13239,8 +13239,6 @@ var AgentSession = class {
 `);
       }
     }
-    let txReadyCandidate = null;
-    let txReadyTwinCallId = null;
     let toolOutputCandidate = null;
     let balanceCardRendered = false;
     const pendingDispatches = [];
@@ -13266,20 +13264,12 @@ var AgentSession = class {
       onSuggestions: (suggestions) => {
         ui.onSuggestions(suggestions);
       },
-      onTxReady: (tx, toolCallId) => {
-        if (txReadyCandidate !== null) {
-          this.reportDeferredSignable(ui);
-          return;
-        }
-        txReadyCandidate = tx;
-        txReadyTwinCallId = toolCallId ?? null;
-      },
-      onToolOutputTx: (payload, toolName, source, toolCallId) => {
+      onToolOutputTx: (payload, toolName, source) => {
         if (toolOutputCandidate !== null) {
           this.reportDeferredSignable(ui);
           return;
         }
-        toolOutputCandidate = { payload, toolName, source, callId: toolCallId ?? null };
+        toolOutputCandidate = { payload, toolName, source };
       },
       onBalanceSummary: (raw) => {
         const card = parseBalanceSummaryEnvelope(raw);
@@ -13288,6 +13278,9 @@ var AgentSession = class {
           ui.onBalanceSummary?.(card);
         }
       },
+      onTurnOutcome: (outcome) => {
+        ui.onTurnOutcome?.(outcome);
+      },
       onMessage: (_msg) => {
       },
       onError: (error2, code) => {
@@ -13310,7 +13303,7 @@ var AgentSession = class {
     }
     if (streamResult.disconnected && !streamResult.message) {
       ui.onReconnecting?.();
-      await this.recoverDisconnectedTurn(streamResult, callbacks.onTxReady, callbacks.onBalanceSummary);
+      await this.recoverDisconnectedTurn(streamResult, callbacks.onBalanceSummary);
     }
     const responseText = streamResult.message?.content || streamResult.fullText || "";
     let displayText = stripLeakedToolCallTags(responseText);
@@ -13320,7 +13313,7 @@ var AgentSession = class {
     if (displayText) {
       ui.onAssistantMessage(displayText);
     }
-    const bufferedSignable = this.selectAndBufferSignable(txReadyCandidate, txReadyTwinCallId, toolOutputCandidate, ui);
+    const bufferedSignable = this.selectAndBufferSignable(toolOutputCandidate);
     if (bufferedSignable) {
       if (this.config.verbose) process.stderr.write(`[session] buffered a signable server tx, signing client-side
 `);
@@ -13370,102 +13363,42 @@ var AgentSession = class {
     );
   }
   /**
-   * Phase-1 dual-read reconciliation. Given the two per-turn candidates, run the
-   * parity cross-check (when both are the SAME tool call) and buffer the SAFE
-   * sign source into the executor. Returns true when something was buffered.
-   *
-   * Selection order (fund-safety):
-   *  1. a SIGNABLE `tx_ready` — AUTHORITATIVE, unchanged from today's behavior;
-   *  2. the client tool-output candidate — covers flat off-chain tools with no
-   *     `tx_ready` (polymarket) and flat tools whose `tx_ready` is structurally
-   *     unsignable (`build_custom_*`, divergent `to_address`/`calldata`);
-   *  3. an unsignable `tx_ready` as last resort — preserves today's behavior (it
-   *     surfaces its own error at sign time) rather than silently dropping it.
-   * `payloadLooksSignable` mirrors the executor's real requirements so a
-   * structurally-present-but-unsignable `tx_ready` (which `storeServerTransaction`
-   * would still buffer, only to throw at sign time) doesn't pre-empt a good
-   * tool-output candidate.
-   *
-   * FAIL-CLOSED on divergence (review — gomesalexandre): a flat tool-output is a
-   * sign source ONLY when (a) there is NO `tx_ready` at all, or (b) the same-turn
-   * `tx_ready` MATCHED parity. Whenever a `tx_ready` is present and the flat did
-   * not prove equal to it, we do NOT sign the client-enriched candidate — we fall
-   * closed to the `tx_ready` path (which, when unsignable, errors at sign time).
-   *
-   * This sign gate is DELIBERATELY INDEPENDENT of the pairing heuristic below:
-   * whether the two same-turn candidates are "the same tool call" affects only
-   * divergence TELEMETRY, never the sign decision. So even if the pairing were
-   * wrong (e.g. the backend batched two tool-output frames before a `tx_ready`
-   * against the documented per-pending order — agent-backend agent.go:6397), a
-   * diverging flat still cannot be signed: it is gated by `parityMatched`, not by
-   * pairing. The fund-safety guarantee therefore rests on parity equality alone,
-   * not on a cross-repo wire-ordering invariant (security + Codex convergence).
+   * #927 Phase 2 sign gate. Buffer the client-enriched tool-output candidate —
+   * the SOLE signing source — into the executor. Returns true when something was
+   * buffered (signed downstream), false otherwise.
    *
-   * Pairing (review — gomesalexandre) — TELEMETRY ONLY: the two channels are the
-   * SAME tool call iff their tool-call ids match (`txReadyTwinCallId` is the id of
-   * the tool-output frame this `tx_ready` was emitted next to — client.ts). A
-   * DEFINITELY-unpaired pair (both ids present AND different) skips the parity
-   * diff so an unrelated same-turn pair does not emit a false `[DIVERGENCE]`; a
-   * missing id falls back to running the diff so a real divergence is never
-   * suppressed. This gate never enqueues a sign source — it only silences noise.
+   * FAIL-CLOSED, two structural gates:
+   *  1. `deriveToolOutputCandidate` (client.ts) already rejected non-tx envelopes
+   *     (`no_op` / `insufficient_*` / errors) and phantom-card prep envelopes
+   *     (no `tx_encoding`) — so a candidate that reaches here is well-formed.
+   *  2. `payloadLooksSignable` mirrors the executor's real signer requirements
+   *     (`extractNestedTx().to` for EVM; `txArgs.{to,amount}` for non-EVM; both
+   *     legs for multi-leg). A structurally-present-but-unsignable candidate is
+   *     NOT routed to the signer — the mutation-check target for this gate.
+   * `storeServerTransaction` is the final backstop (returns false if it can't
+   * resolve a tx body / cross-chain multi-leg), so a false is never a wrong sign.
    */
-  selectAndBufferSignable(txReadyCandidate, txReadyTwinCallId, toolOutputCandidate, ui) {
-    const toolOutputCallId = toolOutputCandidate?.callId ?? null;
-    const definitelyUnpaired = txReadyCandidate !== null && toolOutputCandidate !== null && toolOutputCallId !== null && txReadyTwinCallId !== null && toolOutputCallId !== txReadyTwinCallId;
-    let parityMatched = false;
-    if (txReadyCandidate && toolOutputCandidate && !definitelyUnpaired) {
-      parityMatched = this.logToolOutputParity(toolOutputCandidate, txReadyCandidate);
-    }
-    const ordered = [];
-    if (txReadyCandidate && payloadLooksSignable(txReadyCandidate)) {
-      ordered.push({ surface: "tx_ready", payload: txReadyCandidate });
-    }
-    const flatIsSignSource = toolOutputCandidate?.source === "flat" && (txReadyCandidate === null || parityMatched);
-    if (toolOutputCandidate && flatIsSignSource) {
-      ordered.push({ surface: "tool_output", payload: toolOutputCandidate.payload });
-    }
-    if (txReadyCandidate && !payloadLooksSignable(txReadyCandidate)) {
-      ordered.push({ surface: "tx_ready", payload: txReadyCandidate });
-    }
-    for (const { surface, payload } of ordered) {
-      if (this.executor.storeServerTransaction(payload)) {
-        if (this.config.password) this.executor.setPassword(this.config.password);
-        if (this.config.verbose) {
-          const both = txReadyCandidate && toolOutputCandidate ? "both channels" : "single channel";
-          process.stderr.write(`[session] buffered signable from ${surface} (${both})
-`);
-        }
-        if (surface === "tx_ready" && toolOutputCandidate?.source === "flat" && !parityMatched) {
-          this.reportDeferredSignable(ui);
-        }
-        return true;
+  selectAndBufferSignable(toolOutputCandidate) {
+    if (!toolOutputCandidate) return false;
+    if (!payloadLooksSignable(toolOutputCandidate.payload)) {
+      if (this.config.verbose) {
+        process.stderr.write(
+          `[session] tool-output candidate (${toolOutputCandidate.toolName}, ${toolOutputCandidate.source}) not structurally signable; not buffering
+`
+        );
       }
+      return false;
     }
-    return false;
-  }
-  /**
-   * Compare the client-enriched tool-output candidate to the backend `tx_ready`
-   * for the same turn and log the result. On a safety-relevant divergence this
-   * logs LOUDLY (always to stderr, not just under --verbose) — that divergence
-   * signal is exactly what Phase 1 exists to surface before Phase 2 makes
-   * tool-output the sole signing source.
-   */
-  logToolOutputParity(toolOutput, txReady) {
-    const result = diffToolOutputParity(toolOutput.payload, txReady);
-    const exclusive = result.txReadyExclusive.length ? ` | tx_ready-exclusive: ${result.txReadyExclusive.join(",")}` : "";
-    if (result.match) {
+    if (this.executor.storeServerTransaction(toolOutputCandidate.payload)) {
+      if (this.config.password) this.executor.setPassword(this.config.password);
       if (this.config.verbose) {
         process.stderr.write(
-          `[parity] ${toolOutput.toolName} (${toolOutput.source}): tool-output == tx_ready \u2713${exclusive}
+          `[session] buffered signable from tool-output (${toolOutputCandidate.toolName}, ${toolOutputCandidate.source})
 `
         );
       }
       return true;
     }
-    process.stderr.write(
-      `[parity][DIVERGENCE] ${toolOutput.toolName} (${toolOutput.source}): tool-output != tx_ready \u2014 ${result.divergences.join("; ")}${exclusive}
-`
-    );
     return false;
   }
   /**
@@ -13473,15 +13406,14 @@ var AgentSession = class {
    * assistant message. Polls /messages/since (server-clock anchored via
    * X-Server-Now) until the persisted assistant message lands or the bounded
    * budget is exhausted. On success it patches `streamResult.message` so the
-   * normal downstream flow surfaces the answer, and replays any persisted
-   * `data-tx_ready` part through `onTxReady` so a recovered signable card hits
-   * the same confirm/sign gate as a live one.
+   * normal downstream flow surfaces the answer, and replays any persisted balance
+   * card. #927 Phase 2: a signable tx is NEVER recovered — the signable payload
+   * rides tool-output-available, which the persisted parts don't reconstruct — so
+   * a recovered turn that ran a signable tool warns to re-run instead of signing.
    */
-  async recoverDisconnectedTurn(streamResult, onTxReady, onBalanceSummary) {
+  async recoverDisconnectedTurn(streamResult, onBalanceSummary) {
     if (!this.conversationId) return;
-    const serverAnchor = serverNowToIso(streamResult.serverNow);
-    const since = serverAnchor ?? new Date(Date.now() - 2e3).toISOString();
-    const replaySignableCards = serverAnchor !== null;
+    const since = serverNowToIso(streamResult.serverNow) ?? new Date(Date.now() - 2e3).toISOString();
     let cursor;
     let authRecovered = false;
     for (let attempt = 0; attempt < this.recoveryMaxPolls; attempt++) {
@@ -13502,13 +13434,13 @@ var AgentSession = class {
         continue;
       }
       if (resp.cursor) cursor = resp.cursor;
-      const assistant = [...resp.messages].reverse().find((m) => m.role === "assistant" && (!!m.content || hasTxReadyPart(m.parts)));
+      const assistant = [...resp.messages].reverse().find((m) => m.role === "assistant" && (!!m.content || hasSignableToolPart(m.parts)));
       if (assistant) {
         if (this.config.verbose) {
           process.stderr.write(`[session] recovered assistant message after ${attempt + 1} poll(s)
 `);
         }
-        this.applyRecoveredMessage(assistant, streamResult, onTxReady, replaySignableCards, onBalanceSummary);
+        this.applyRecoveredMessage(assistant, streamResult, onBalanceSummary);
         return;
       }
       await this.recoverySleep();
@@ -13596,38 +13528,30 @@ var AgentSession = class {
   }
   /**
    * Fold a recovered assistant message back into the live stream result: the
-   * authoritative message wins over any partial deltas, and any persisted
-   * `data-tx_ready` part is replayed through the live tx_ready callback so the
-   * card flows through the same confirm/sign gate.
-   *
-   * `replaySignableCards` gates the tx_ready replay: it is false when the
-   * recovery anchor was the local-clock fallback (no X-Server-Now), where a
-   * recovered card cannot be proven to belong to the current turn. See
-   * recoverDisconnectedTurn — a stale tx_ready must never reach the signer.
+   * authoritative message wins over any partial deltas, and any persisted balance
+   * card is replayed. #927 Phase 2: a signable transaction is NEVER recovered —
+   * the signable payload rides tool-output-available, which the persisted parts
+   * do not reconstruct — so a recovered turn that ran a signable tool warns the
+   * user to re-run rather than signing (fail-CLOSED, never a wrong sign).
    */
-  applyRecoveredMessage(msg, streamResult, onTxReady, replaySignableCards, onBalanceSummary) {
+  applyRecoveredMessage(msg, streamResult, onBalanceSummary) {
     streamResult.message = msg;
-    let replayedTxReady = false;
-    let signableFlatToolPart;
+    let signableToolPart;
     for (const part of msg.parts ?? []) {
       if (part.type === "data-balance_summary" && part.data) {
         onBalanceSummary?.(part.data);
         continue;
       }
-      if (replaySignableCards && part.type === "data-tx_ready" && part.data && typeof part.data === "object") {
-        const tx = part.data;
-        streamResult.transactions.push(tx);
-        onTxReady?.(tx);
-        replayedTxReady = true;
-      }
       if (typeof part.type === "string" && part.type.startsWith("tool-")) {
         const toolName = part.type.slice("tool-".length);
-        if (CLI_SIGNABLE_FLAT_TOOLS.has(toolName)) signableFlatToolPart = toolName;
+        if (CLI_SIGNABLE_FLAT_TOOLS.has(toolName) || CLI_SIGNABLE_PREP_TOOLS.has(toolName)) {
+          signableToolPart = toolName;
+        }
       }
     }
-    if (signableFlatToolPart && !replayedTxReady) {
+    if (signableToolPart) {
       process.stderr.write(
-        `[session][recovery] recovered turn ran signable tool '${signableFlatToolPart}', whose signable output rides tool-output-available (no data-tx_ready). The recovery path does not reconstruct that candidate, so NO transaction was signed this turn \u2014 re-run the request to sign. (Known Phase-1 limitation.)
+        `[session][recovery] recovered turn ran signable tool '${signableToolPart}', whose signable output rides tool-output-available. The recovery path does not reconstruct that candidate, so NO transaction was signed this turn \u2014 re-run the request to sign.
 `
       );
     }
@@ -13795,8 +13719,12 @@ function serverNowToIso(serverNow) {
   if (!Number.isFinite(ms) || ms <= 0) return null;
   return new Date(ms).toISOString();
 }
-function hasTxReadyPart(parts) {
-  return !!parts?.some((p) => p.type === "data-tx_ready" && !!p.data);
+function hasSignableToolPart(parts) {
+  return !!parts?.some((p) => {
+    if (typeof p.type !== "string" || !p.type.startsWith("tool-")) return false;
+    const toolName = p.type.slice("tool-".length);
+    return CLI_SIGNABLE_FLAT_TOOLS.has(toolName) || CLI_SIGNABLE_PREP_TOOLS.has(toolName);
+  });
 }
 function isAuthError(err) {
   const msg = err instanceof Error ? err.message : String(err ?? "");
@@ -14280,6 +14208,7 @@ function outputAskError(wantsJson, message, code, conversationId, result) {
     if (result?.transactions.length) data.transactions = result.transactions;
     if (result?.toolCalls.length) data.tool_calls = result.toolCalls;
     if (result?.response) data.response = result.response;
+    if (result?.outcome) data.outcome = result.outcome;
     outputErrorJson({
       success: false,
       v: 1,
@@ -14294,6 +14223,11 @@ function outputAskError(wantsJson, message, code, conversationId, result) {
 function outputAskHuman(result, confirmationRequired, proposed) {
   process.stdout.write(`session:${result.sessionId}
 `);
+  if (result.outcome && result.outcome.kind !== "success") {
+    const { kind, code } = result.outcome;
+    process.stdout.write(`outcome:${kind}${code ? `:${code}` : ""}
+`);
+  }
   if (confirmationRequired) {
     process.stdout.write(`confirmation-required:pass --yes to authorize signing
 `);
@@ -14336,6 +14270,12 @@ function outputAskSuccess(wantsJson, result, conversationId) {
       tool_calls: result.toolCalls,
       transactions: result.transactions,
       ...result.cards.length > 0 ? { cards: result.cards } : {},
+      // 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).
+      ...result.outcome ? { outcome: result.outcome } : {},
       ...confirmationRequired ? { confirmation_required: true } : {},
       ...proposed ? { proposed } : {}
     });
@@ -14343,6 +14283,21 @@ function outputAskSuccess(wantsJson, result, conversationId) {
   }
   outputAskHuman(result, confirmationRequired, proposed);
 }
+function outcomeToExitCode(outcome) {
+  switch (outcome?.kind) {
+    case "blocked":
+      return 10 /* AGENT_TURN_BLOCKED */;
+    case "refusal":
+      return 11 /* 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 */;
+    default:
+      return void 0;
+  }
+}
 async function executeAgentAsk(ctx2, message, options) {
   setSilentMode(true);
   const originalConsoleLog = console.log;
@@ -14376,6 +14331,7 @@ async function executeAgentAsk(ctx2, message, options) {
       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);
     }
   } catch (err) {
@@ -14494,7 +14450,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "2.17.0";
+    cachedVersion = "2.18.6";
     return cachedVersion;
   }
   try {
@@ -16886,19 +16842,27 @@ 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").addHelpText(
+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(
   "after",
   `
 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, {
       chain: findChainByName(options.chain) || options.chain,
       txHash: options.txHash,
-      noWait: !options.wait
+      noWait: !options.wait,
+      timeoutSec
     });
   })
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vultisig/cli",
-  "version": "2.17.0",
+  "version": "2.18.6",
   "description": "The self-custody MPC wallet CLI for AI coding agents (Claude Code, Cursor, OpenCode). Natural-language agent mode, 36+ chains, DKLS23 threshold signatures. Seedless.",
   "type": "module",
   "bin": {
@@ -74,9 +74,9 @@
     "@napi-rs/keyring": "^1.3.0",
     "@noble/hashes": "^2.2.0",
     "@vultisig/client-shared": "^0.2.17",
-    "@vultisig/core-chain": "^2.23.1",
-    "@vultisig/rujira": "^50.0.0",
-    "@vultisig/sdk": "^2.17.0",
+    "@vultisig/core-chain": "^2.23.3",
+    "@vultisig/rujira": "^51.0.0",
+    "@vultisig/sdk": "^2.18.6",
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
     "commander": "^15.0.0",