shinjuku-shield 0.3.84 → 0.3.86

package/README.md

@@ -6,13 +6,13 @@ answers privately, in a terminal chat or for your agent app. Its `mcp`
 command runs a local MCP server (stdio) for your agent. Your keys never
 leave your machine.
 
-This is version 0.3.84. The npm packages `shinjuku-shield` and
+This is version 0.3.86. The npm packages `shinjuku-shield` and
 `shinjuku-shielded` hold the same files; `shinjuku` is the short command.
 
 ## Set up
 
 ```sh
-npx -y --no-audit --no-fund shinjuku-shield@0.3.84 setup
+npx -y --no-audit --no-fund shinjuku-shield@0.3.86 setup
 ```
 
 Setup makes the wallet on this machine, a private passphrase file, and the
@@ -24,7 +24,7 @@ server to that host's config.
 ## The `shinjuku` command
 
 ```sh
-npm install -g shinjuku@0.3.84
+npm install -g shinjuku@0.3.86
 shinjuku help
 ```
 
@@ -36,13 +36,13 @@ Every wallet command works after `shinjuku`, for example `shinjuku balance`,
 Claude Code:
 
 ```sh
-claude mcp add --scope user shinjuku-shielded -- npx -y --no-audit --no-fund shinjuku-shield@0.3.84 mcp
+claude mcp add --scope user shinjuku-shielded -- npx -y --no-audit --no-fund shinjuku-shield@0.3.86 mcp
 ```
 
 Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
 
 ```json
-{ "mcpServers": { "shinjuku-shielded": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.84", "mcp"] } } }
+{ "mcpServers": { "shinjuku-shielded": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.86", "mcp"] } } }
 ```
 
 On native Windows, if the host cannot find `npx`, use `"command": "cmd"` and

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "b73f57e58ae0466a090f5b1728e7852bab48e7d28ad6bb0f0ba9657b6cc681b1",
-  "bytes": 12505075,
-  "sourceCommit": "52a8e17d03018f2cc026f9f9d306a785ef4da9f5",
+  "sha256": "b650bf0682830e05207f52bad2ba426ec7f8fa1bbbfdb7e028057865e3d83d24",
+  "bytes": 12522998,
+  "sourceCommit": "435a594c2af5c17d16a0f700bf2d9b7ff79af533",
   "sourceDirty": false,
   "installRecordMatchesLockfile": true,
   "releaseRule": "valid only when two fresh npm ci --ignore-scripts builds on different OSes give the same sha256; installRecordMatchesLockfile true means every entry npm installed equals its package-lock.json entry and every entry not marked optional, devOptional included, is installed: an optional entry (a package for another platform) may be absent",
@@ -1282,5 +1282,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-10-23T19:32:52.495Z"
+  "publishedAt": "2026-10-23T21:42:59.534Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shield",
-  "version": "0.3.84",
+  "version": "0.3.86",
   "mcpName": "io.github.ShinjukuStaition/shinjuku-mcp",
   "description": "Shinjuku Shielded, the private x402 facilitator on Solana: the self-custody wallet CLI and its MCP server. Shield, pay, and unshield USDC from any MCP agent, under caps you set.",
-  "shinjukuRelease": "b73f57e5",
-  "shinjukuSha256": "b73f57e58ae0466a090f5b1728e7852bab48e7d28ad6bb0f0ba9657b6cc681b1",
+  "shinjukuRelease": "b650bf06",
+  "shinjukuSha256": "b650bf0682830e05207f52bad2ba426ec7f8fa1bbbfdb7e028057865e3d83d24",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -47222,6 +47222,7 @@ function reexec(args, mode, plainProxy) {
   const env = {
     ...process.env,
     NODE_USE_ENV_PROXY: "1",
+    NODE_OPTIONS: proxiedNodeOptions(process.env.NODE_OPTIONS),
     ...proxyEnv(proxy),
     [MARK]: `${mode} ${proxy}`
   };
@@ -47305,7 +47306,7 @@ async function proxyEntry(argv2, run5, { err = (text3) => process.stderr.write(t
   }
   return reexec(options.args, options.mode, options.proxy);
 }
-var TOR_HTTP_TUNNEL, TOR_CHECK, PROOF_TIMEOUT_MS, LOCAL_PROOF_TIMEOUT_MS, LOCAL_PROOF_MAX_BYTES, torProvenAt, proxyProvenAt, MARK, TOR_RUN_STARTED_ENV, ownProxyRefused, ONION_V3, RETRY_AFTER_CAP_MS, RETRY_AFTER_FLOOR_MS, RETRY_AFTER_DEFAULT_MS, RPC_NO_ANSWER_LIMIT_MS, RPC_PACING_CAP_MS, PACING_NOTICE_EVERY_MS, PACING_RATE_WINDOW_MS, TOR_MAX_ROTATIONS, runStartedAt, rpcNotBefore, pacingWaiters, pacingSince, pacedMs, rpcAnswered, lastAnswerAt, readSteps, pacingNoticeAt, pacingSamples, torMoves, torCircuitId, torMovesRefused, pendingMove, inTorRun, runNetworkMode, isOnionOrigin, ProxyUsageError, isOnionHost, TOR_EXPERT_BUNDLE, TUNNEL_LINE, TOR_INSTALL, OS_NAMES, osKey, torNotRunningMessage, NOTICE, QUIET_RUN_MARK, QUIET_NOTICE, quietRun, TOR_TROUBLE_LINE, quietTorErr, withRunTag, proxyEnv, pacedSoFar, RESENDABLE_METHOD, torCircuit, GLOBAL_DISPATCHER2, laneDispatchers, paymentWarmStop, PROXY_WARNING_FLAG, proxiedExecArgv, TOR_FROM_CONFIG_ENV, TOR_FROM_CONFIG_HINT;
+var TOR_HTTP_TUNNEL, TOR_CHECK, PROOF_TIMEOUT_MS, LOCAL_PROOF_TIMEOUT_MS, LOCAL_PROOF_MAX_BYTES, torProvenAt, proxyProvenAt, MARK, TOR_RUN_STARTED_ENV, ownProxyRefused, ONION_V3, RETRY_AFTER_CAP_MS, RETRY_AFTER_FLOOR_MS, RETRY_AFTER_DEFAULT_MS, RPC_NO_ANSWER_LIMIT_MS, RPC_PACING_CAP_MS, PACING_NOTICE_EVERY_MS, PACING_RATE_WINDOW_MS, TOR_MAX_ROTATIONS, runStartedAt, rpcNotBefore, pacingWaiters, pacingSince, pacedMs, rpcAnswered, lastAnswerAt, readSteps, pacingNoticeAt, pacingSamples, torMoves, torCircuitId, torMovesRefused, pendingMove, inTorRun, runNetworkMode, isOnionOrigin, ProxyUsageError, isOnionHost, TOR_EXPERT_BUNDLE, TUNNEL_LINE, TOR_INSTALL, OS_NAMES, osKey, torNotRunningMessage, NOTICE, QUIET_RUN_MARK, QUIET_NOTICE, quietRun, TOR_TROUBLE_LINE, quietTorErr, withRunTag, proxyEnv, pacedSoFar, RESENDABLE_METHOD, torCircuit, GLOBAL_DISPATCHER2, laneDispatchers, paymentWarmStop, PROXY_WARNING_FLAG, proxiedExecArgv, proxiedNodeOptions, TOR_FROM_CONFIG_ENV, TOR_FROM_CONFIG_HINT;
 var init_proxy = __esm({
   "wallet/src/net/proxy.mjs"() {
     "use strict";
@@ -47402,6 +47403,10 @@ var init_proxy = __esm({
     laneDispatchers = /* @__PURE__ */ new Map();
     PROXY_WARNING_FLAG = "--disable-warning=UNDICI-EHPA";
     proxiedExecArgv = (execArgv = process.execArgv) => execArgv.includes(PROXY_WARNING_FLAG) ? [...execArgv] : [...execArgv, PROXY_WARNING_FLAG];
+    proxiedNodeOptions = (nodeOptions = process.env.NODE_OPTIONS) => {
+      const options = String(nodeOptions ?? "").trim();
+      return options.split(/\s+/).includes(PROXY_WARNING_FLAG) ? options : `${options} ${PROXY_WARNING_FLAG}`.trim();
+    };
     TOR_FROM_CONFIG_ENV = "SHINJUKU_WALLET_TOR_FROM_CONFIG";
     TOR_FROM_CONFIG_HINT = '. Tor is on for every command because setup recorded it (config.json "tor": true); to run this one command without Tor, add --no-tor (the servers then see your IP address)';
   }
@@ -62798,7 +62803,7 @@ async function readRelayConfig({ serviceUrl: serviceUrl2, fetchImpl, id }) {
 async function submitRelayedDeposit(input) {
   return withWalletLease(input.store, input.deps ?? {}, () => submitRelayedDepositLeased(input));
 }
-async function submitRelayedDepositLeased({ store, connection, programId, proofTools, depositId, serviceUrl: serviceUrl2, deps = {} }) {
+async function submitRelayedDepositLeased({ store, connection, programId, proofTools, depositId, serviceUrl: serviceUrl2, historyUrl, deps = {} }) {
   assertDepositId(depositId);
   const name = walName(depositId);
   const record = store.readWal(name);
@@ -62812,7 +62817,8 @@ async function submitRelayedDepositLeased({ store, connection, programId, proofT
   const source = new import_web3101.PublicKey(record.relay.tokenAccount);
   const pause3 = deps.pause ?? delay;
   const fetchImpl = deps.fetchImpl ?? fetch;
-  const loadHistory = () => finalizedHistory({ store, connection, id, proofTools, deps });
+  const historyConnection = connection.historyRpcChoice !== void 0 || connection.historyRpc ? connection : connectSplit(connection, historyUrl);
+  const loadHistory = () => finalizedHistory({ store, connection: historyConnection, id, proofTools, deps });
   const refuse19 = async (reason) => {
     record.relay.approvedOnChain = (await relaySource(connection, id, record)).approved;
     record.relay.lastRefusal = { reason, at: (/* @__PURE__ */ new Date()).toISOString() };
@@ -62981,8 +62987,42 @@ function settleTransaction(connection, signature2) {
     maxSupportedTransactionVersion: 1
   }));
 }
+async function foundSettle(connection, id, record, intent) {
+  let entries;
+  try {
+    if (typeof connection.getSignaturesForAddress !== "function") return void 0;
+    entries = await retryRpc2(() => connection.getSignaturesForAddress(intent.address, { limit: SETTLE_SEARCH_LIMIT }, "finalized"));
+  } catch {
+    return void 0;
+  }
+  if (!Array.isArray(entries)) return void 0;
+  for (const entry of [...entries].reverse()) {
+    if (entry?.err !== null || typeof entry.signature !== "string") continue;
+    const transaction = await settleTransaction(connection, entry.signature).catch(() => void 0);
+    if (!transaction?.meta || transaction.meta.err) continue;
+    const landing = returnedIntent(transaction, id, record);
+    if (landing) return { signature: entry.signature, transaction, landing };
+  }
+  return void 0;
+}
 async function relayReceipt({ connection, id, record, intent, loadHistory, transaction: read, walkMs }) {
   const signature2 = record.relay.result?.signature;
+  if (!signature2) {
+    const found = await foundSettle(connection, id, record, intent);
+    if (found) {
+      const { transaction, landing } = found;
+      record.relay.result = { signature: found.signature, slot: transaction.slot };
+      return {
+        intent: intent.address.toBase58(),
+        indexAfter: landing.indexAfter,
+        signature: found.signature,
+        slot: transaction.slot,
+        feeLamports: transaction.meta.fee,
+        broadcaster: landing.broadcaster.toBase58(),
+        source: landing.source.toBase58()
+      };
+    }
+  }
   if (signature2) {
     const transaction = (read ? await read : void 0) ?? await settleTransaction(connection, signature2);
     const landing = transaction?.meta && !transaction.meta.err ? returnedIntent(transaction, id, record) ?? settleFunder(transaction, id, intent.address) : void 0;
@@ -63378,7 +63418,7 @@ async function publishDepositMemo({ serviceUrl: serviceUrl2, record, fetchImpl =
   const stored = await fetchMemoFromService(serviceUrl2, record.memoDigest, { fetchImpl });
   if (!stored || !Buffer.from(stored).equals(bytes2)) fail11("memo_publish_readback_mismatch");
 }
-var import_web3101, DEPOSIT_WAL_SCHEMA, P03_BINDING, BUFFER_SIZE, DEPOSIT_INTENT_LEN, DEPOSIT_RECORD_LEN, CLOSE_BUFFER, COMPACT_DEPOSIT_INTENT, BUFFER_LIFETIME_SLOTS, BUFFER_MIN_REMAINING_SLOTS, FEE_MARGIN_LAMPORTS, RESOLVED_STATES, LANDED_STATES, hex, field32, walName, LANDED_WALK_MS, SLOW_WALK, delay, DEPOSIT_RELAY_SCHEMA, DEPOSIT_RECLAIM_SCHEMA, DEPOSIT_RELAY_CONFIG_SCHEMA, APPROVE_COMPUTE_UNITS, RECLAIM_COMPUTE_UNITS, RELAY_ROUNDS, RELAY_KEY_PROBES, MAX_SCAN_COUNT, RELAY_REQUEST_TIMEOUT_MS, RELAY_MAX_WAIT_SECONDS, RELAY_REFUSALS, RECLAIM_REFUSALS, relayHex, SPLIT_MAX, DEFAULT_SPLIT_PARTS, SPLIT_UNIT_ATOMIC, FUNDS_PLAN_SCHEMA, FUNDS_PLAN_PREFIX, relayKeyPool, __test;
+var import_web3101, DEPOSIT_WAL_SCHEMA, P03_BINDING, BUFFER_SIZE, DEPOSIT_INTENT_LEN, DEPOSIT_RECORD_LEN, CLOSE_BUFFER, COMPACT_DEPOSIT_INTENT, BUFFER_LIFETIME_SLOTS, BUFFER_MIN_REMAINING_SLOTS, FEE_MARGIN_LAMPORTS, RESOLVED_STATES, LANDED_STATES, hex, field32, walName, LANDED_WALK_MS, SLOW_WALK, delay, DEPOSIT_RELAY_SCHEMA, DEPOSIT_RECLAIM_SCHEMA, DEPOSIT_RELAY_CONFIG_SCHEMA, APPROVE_COMPUTE_UNITS, RECLAIM_COMPUTE_UNITS, RELAY_ROUNDS, RELAY_KEY_PROBES, MAX_SCAN_COUNT, RELAY_REQUEST_TIMEOUT_MS, RELAY_MAX_WAIT_SECONDS, RELAY_REFUSALS, RECLAIM_REFUSALS, relayHex, SPLIT_MAX, DEFAULT_SPLIT_PARTS, SPLIT_UNIT_ATOMIC, FUNDS_PLAN_SCHEMA, FUNDS_PLAN_PREFIX, relayKeyPool, SETTLE_SEARCH_LIMIT, __test;
 var init_deposit = __esm({
   "wallet/src/deposit/deposit.mjs"() {
     "use strict";
@@ -63486,6 +63526,7 @@ var init_deposit = __esm({
     FUNDS_PLAN_SCHEMA = "carbon-shielded-wallet/add-funds/v1";
     FUNDS_PLAN_PREFIX = "add-funds-";
     relayKeyPool = (store, record) => record.relay.keyPool ?? record.pool ?? store.state.pool;
+    SETTLE_SEARCH_LIMIT = 10;
     __test = Object.freeze({ parseBuffer });
   }
 });
@@ -65833,6 +65874,27 @@ var init_errorCodes = __esm({
       "relay_reclaim_nothing_held",
       "relay_refused_deposit_body_invalid",
       "relay_refused_deposit_replay_conflict",
+      // The exit relay's refusals (ShieldedSolanaP03ExitRelay.ts, createShieldedFacilitatorRoutes.ts), as
+      // p03_unshield_relay_refused_<reason> (T16, 2026-10-23: an unknown one printed a bare p03_resource_cli_failed).
+      "exit_amount_invalid",
+      "exit_anchor_not_retained",
+      "exit_body_invalid",
+      "exit_buffer_unavailable",
+      "exit_memo_digest_mismatch",
+      "exit_operator_review_required",
+      "exit_pending_retry_same_request",
+      "exit_pool_busy_retry_same_request",
+      "exit_pool_domain_mismatch",
+      "exit_pool_invalid",
+      "exit_proof_invalid",
+      "exit_quote_expired",
+      "exit_relay_busy",
+      "exit_relay_unavailable",
+      "exit_relayer_underfunded",
+      "exit_replay_conflict",
+      "exit_replay_consumed",
+      "exit_settlement_not_landed_retry_same_request",
+      "exit_vault_insufficient",
       "relay_relayer_underfunded_retry_later",
       "relay_service_required",
       "relay_transaction_invalid",
@@ -75305,6 +75367,7 @@ async function runSelfCustodyDeposit(args) {
     throw new Error("deposit requires --program, --deposit-id, --amount <atomic>, --proof-tools, and --rpc-file <file> (or --rpc, or UNDERMARKET_SOLANA_RPC_URL)");
   }
   const proofTools = loadP03PublicPaymentProofTools(flag(args, "--proof-tools"));
+  const historyUrl = historyRpcUrl(flag(args, "--history-rpc"));
   const path = walletPath(pool2);
   const relay = args.includes("--relay");
   const indexFlag = flag(args, "--one-time-index");
@@ -75361,7 +75424,7 @@ async function runSelfCustodyDeposit(args) {
       }, null, 2));
       return;
     }
-    const result = await (relay ? submitRelayedDeposit : submitDeposit)({ ...common, serviceUrl: flag(args, "--service") });
+    const result = await (relay ? submitRelayedDeposit : submitDeposit)({ ...common, serviceUrl: flag(args, "--service"), ...relay ? { historyUrl } : {} });
     console.log(JSON.stringify({
       ...result,
       next: result.state === "published" ? "run recover; export and verify two fresh backups" : "rerun with --submit --service <facilitator URL> to publish the memo"
@@ -107699,10 +107762,23 @@ function markedAnchorRequest(requestAnchor) {
 }
 async function exitWhenAnchored(run5, { now = Date.now, sleep: sleep6 = (ms) => new Promise((resolve40) => setTimeout(resolve40, ms)), ring } = {}) {
   const deadline = now() + EXIT_ANCHOR_WAIT_MS;
+  let reproved = false;
+  let clockWaits = 0;
   for (; ; ) {
     try {
       return await run5();
     } catch (error) {
+      if (!reproved && /p03_unshield_relay_refused_exit_quote_expired/.test(String(error?.message))) {
+        reproved = true;
+        progress("the exit proof's time window ended before the facilitator's exit transaction landed; nothing was sent. The wallet makes a new exit proof now and sends it");
+        continue;
+      }
+      if (reproved && clockWaits < EXPIRED_PROOF_CLOCK_WAITS && /p03_note_exit_proved_still_valid_rerun_later/.test(String(error?.message))) {
+        clockWaits += 1;
+        progress(`the finalized chain clock has not passed the old exit proof's end yet; waiting ${EXPIRED_PROOF_CLOCK_WAIT_MS / 1e3} s, then the wallet makes the new proof (wait ${clockWaits}/${EXPIRED_PROOF_CLOCK_WAITS}; nothing was sent)`);
+        await sleep6(EXPIRED_PROOF_CLOCK_WAIT_MS);
+        continue;
+      }
       if (!/p03_note_exit_anchor_not_current_wait_next_epoch/.test(String(error?.message))) throw error;
       const start = now();
       const subAnchors = subAnchorPool(start) !== void 0;
@@ -107739,7 +107815,13 @@ function facilitatorExitRelay(origin, { fetchImpl = fetch, pause: pause3 = (ms)
       const answer = await response.json().catch(() => ({}));
       if (response.status === 200 && answer.success === true && isSolanaSignature(answer.transaction)) return answer.transaction;
       if (response.status === 200 && answer.success === true) fail29("relay_transaction_invalid");
-      if (response.status === 200) fail29(`relay_refused_${String(answer.errorReason ?? "unknown").replace(/[^a-z0-9_]/g, "")}`);
+      const refused = String(answer.errorReason ?? "unknown").replace(/[^a-z0-9_]/g, "");
+      if (response.status === 200 && RELAY_RETRY_SAME.test(refused) && attempt < attempts) {
+        progress(`waiting: the facilitator's exit relay answered ${refused} (its exit transaction has not landed yet); sending the same exit again in ${RELAY_RETRY_SAME_SECONDS} s (retry ${attempt}/${attempts - 1}). Nothing is lost: the note is still yours, and a rerun of the same command continues`);
+        await pause3(RELAY_RETRY_SAME_SECONDS * 1e3);
+        continue;
+      }
+      if (response.status === 200) fail29(`relay_refused_${refused}`);
       if (![429, 503].includes(response.status) || attempt >= attempts) fail29(`relay_status_${response.status}_retry_same_unshield`);
       const seconds2 = Number(response.headers.get("retry-after"));
       const waitSeconds = Number.isFinite(seconds2) && seconds2 > 0 ? Math.min(seconds2, 120) : 15;
@@ -107897,7 +107979,7 @@ async function unshieldOnce({ options, origin, historyUrl, walletPath: walletPat
   store.writeWal(`self-pay-${unshieldId}`, { ...store.readWal(`self-pay-${unshieldId}`), state: "exited", exitTransaction: exit.signature });
   return { amountAtomic: String(exit.amountAtomic), selfPayTransaction: paid.transaction, exitTransaction: exit.signature, replayed: exit.replayed };
 }
-var import_web3121, USAGE2, REQUIRED2, OPTIONAL, fail29, progress, EPOCH_MS2, EPOCH_MARGIN_MS, EXIT_ANCHOR_WAIT_MS;
+var import_web3121, USAGE2, REQUIRED2, OPTIONAL, fail29, RELAY_RETRY_SAME, RELAY_RETRY_SAME_SECONDS, progress, EPOCH_MS2, EPOCH_MARGIN_MS, EXIT_ANCHOR_WAIT_MS, EXPIRED_PROOF_CLOCK_WAITS, EXPIRED_PROOF_CLOCK_WAIT_MS;
 var init_cli2 = __esm({
   "wallet/src/unshield/cli.mjs"() {
     "use strict";
@@ -107942,6 +108024,8 @@ var init_cli2 = __esm({
     fail29 = (reason) => {
       throw new Error(`p03_unshield_${reason}`);
     };
+    RELAY_RETRY_SAME = /_retry_same_request$|^p03_e1_value_pending$|^p03_e1_proof_unavailable$|^p03_validity_proof_unavailable$/;
+    RELAY_RETRY_SAME_SECONDS = 10;
     progress = (text3) => {
       try {
         process.stderr.write(`${text3}
@@ -107952,6 +108036,8 @@ var init_cli2 = __esm({
     EPOCH_MS2 = 3e5;
     EPOCH_MARGIN_MS = 35e3;
     EXIT_ANCHOR_WAIT_MS = EPOCH_MS2 + 6e4;
+    EXPIRED_PROOF_CLOCK_WAITS = 8;
+    EXPIRED_PROOF_CLOCK_WAIT_MS = 15e3;
     if (process.argv[1] && resolve19(process.argv[1]) === fileURLToPath13(new URL("__bundled_source__/wallet/src/unshield/cli.mjs", import.meta.url).href)) {
       main3().catch((error) => {
         console.error(describeCliErrorWithHint(error));
@@ -109894,6 +109980,12 @@ function refusalSay(a, tool, again, npmVersion) {
   if (code2 === "mcp_move_count_unreadable") {
     return "Nothing was moved. This wallet's 24-hour limit cannot be checked just now. Try again in a minute; if it repeats, tell your owner.";
   }
+  if (code2 === "inference_ceiling_over_cap" && a.capKind === "call" && usdcText(a.capAtomic) && usdcText(a.ceilingAtomic) && usdcText(a.capNeededAtomic)) {
+    const needed = usdcText(a.capNeededAtomic);
+    const pays = usdcText(a.paysUpToAtomic);
+    const allow = pays && BigInt(a.paysUpToAtomic) < BigInt(a.capNeededAtomic) ? `Allow ${needed} USDC; it still pays only up to ${pays} USDC.` : `Allow ${needed} USDC to pay it.`;
+    return `Nothing was paid: this request's ${usdcText(a.capAtomic)} USDC cap is below the ${usdcText(a.ceilingAtomic)} USDC ceiling. ${allow}`;
+  }
   if ((code2 === "inference_ceiling_over_cap" || code2 === "p03_float_over_maximum") && usdcText(a.totalAtomic) && usdcText(a.capAtomic)) {
     return `Nothing was paid: up to ${usdcText(a.totalAtomic)} USDC is over your ${usdcText(a.capAtomic)} USDC limit. ${raiseLine("--max-payment", npmVersion)}`;
   }
@@ -127738,6 +127830,15 @@ ${canonical5}`;
   const proxied = () => typeof ops.proxied === "function" ? ops.proxied() : proxyProvenAt() !== void 0;
   const usd = (atomic4) => `$${formatAtomic(atomic4, 6)}`;
   const INFERENCE_COST_WORDS = "A short qwen3-8-flash answer pays about 0.0011 USDC: usePod's price (often 0.00001-0.0001 USDC) plus the Shinjuku fee (0.001 USDC). The call's cap (max_payment, else --max-payment) must still cover the call's ceiling: max_tokens at the model's output price plus the prompt, and at least 0.01 USDC";
+  const paysUpToAtomic = (inference, asked) => {
+    try {
+      const extra = inference.listModels().find((model) => model.id === asked.model).priceOutPerMAtomic * 100n;
+      const lifted = BigInt(inference.ceilingAtomic({ ...asked, maxTokens: asked.maxTokens + 1e8 }));
+      return lifted > BigInt(inference.USEPOD_MIN_PAYMENT_ATOMIC ?? 10000n) ? lifted - extra + 1000n : void 0;
+    } catch {
+      return void 0;
+    }
+  };
   const moreTokens = (maxTokens) => Math.max(1024, 2 * maxTokens);
   const torRefusal = () => refuse12(
     "inference_tor_required",
@@ -127827,7 +127928,7 @@ ${canonical5}`;
   const inferenceChat2 = {
     name: "inference_chat",
     title: "Ask an AI model, paid privately",
-    description: `Use this when the user wants an AI model's answer paid from the SHIELDED balance: it calls usePod's x402 chat endpoint (usePod picks the provider) and pays it privately (the chain does not show which wallet paid); use this tool, not x402_pay, for usePod. Only prompt (or messages) is needed: model defaults to qwen3-8-flash and max_tokens to 512. Called with neither prompt nor messages, it lists the models and their prices and pays nothing (for example qwen3-8-flash, deepseek-v4-1-flash, claude-opus-5). COST: a short qwen3-8-flash answer pays about 0.0011 USDC (usePod's price, often 0.00001-0.0001 USDC, plus the Shinjuku fee 0.001 USDC). The call's cap (max_payment, in USDC like "0.05", or max_payment_atomic; else --max-payment) must still cover the call's ceiling: max_tokens of output plus the prompt at the model's prices, and at least 0.01 USDC (usePod's floor for its standard offer). The total paid is never above the cap. The unused part is NOT refunded when the answer is shorter. max_tokens must be at least ${INFERENCE_MIN_MAX_TOKENS} (a reasoning model spends its first tokens thinking). Example: { "prompt": "Name three prime numbers" }. PRIVACY: usePod and the model's provider see the prompt and the answer; never put keys, passphrases, or secrets in it. It runs only when this MCP server was started with --tor or --proxy (else inference_tor_required, nothing paid), so they never see this machine's IP. The same caps as x402_pay apply (max_payment can only lower --max-payment). When the call can cost more than --max-payment and the MCP client can ask the user, the wallet asks the user once to allow this one call; else the answer says the cost and the limit. On an error code that ends in _retry_same_request, call inference_chat again with the SAME request_id and arguments: it never pays twice. No streaming.`,
+    description: `Use this when the user wants an AI model's answer paid from the SHIELDED balance: it calls usePod's x402 chat endpoint (usePod picks the provider) and pays it privately (the chain does not show which wallet paid); use this tool, not x402_pay, for usePod. Only prompt (or messages) is needed: model defaults to qwen3-8-flash and max_tokens to 512. Called with neither prompt nor messages, it lists the models and their prices and pays nothing (for example qwen3-8-flash, deepseek-v4-1-flash, claude-opus-5). COST: a short qwen3-8-flash answer pays about 0.0011 USDC (usePod's price, often 0.00001-0.0001 USDC, plus the Shinjuku fee 0.001 USDC). The call's cap (max_payment, in USDC like "0.05", or max_payment_atomic; else --max-payment) must still cover the call's ceiling: max_tokens of output plus the prompt at the model's prices, and at least 0.01 USDC (usePod's floor for its standard offer). The total paid is never above the cap, and the cap is only a limit: a larger cap never pays more. The unused part of max_tokens is NOT refunded when the answer is shorter. max_tokens must be at least ${INFERENCE_MIN_MAX_TOKENS} (a reasoning model spends its first tokens thinking). Example: { "prompt": "Name three prime numbers" }. PRIVACY: usePod and the model's provider see the prompt and the answer; never put keys, passphrases, or secrets in it. It runs only when this MCP server was started with --tor or --proxy (else inference_tor_required, nothing paid), so they never see this machine's IP. The same caps as x402_pay apply (max_payment can only lower --max-payment). When the call can cost more than --max-payment and the MCP client can ask the user, the wallet asks the user once to allow this one call; else the answer says the cost and the limit. On an error code that ends in _retry_same_request, call inference_chat again with the SAME request_id and arguments: it never pays twice. No streaming.`,
     inputSchema: {
       type: "object",
       properties: {
@@ -127930,15 +128031,24 @@ ${canonical5}`;
       let askedLimit = false;
       let narrowed = cap.maxPaymentAtomic;
       if (ceiling > BigInt(narrowed)) {
-        const detail = `up to ${args.max_tokens} output tokens on ${args.model} have a ceiling of ${usdcText2(ceiling)} USDC, above this call's cap of ${usdcText2(narrowed)} USDC; the cap must be at least the ceiling; nothing was paid`;
+        const detail = `up to ${args.max_tokens} output tokens on ${args.model} have a ceiling of ${usdcText2(ceiling)} USDC, above this call's cap of ${usdcText2(narrowed)} USDC; the cap must be at least the ceiling; nothing was paid; the cap is only a limit, not the price`;
         const atFloor = ceiling <= BigInt(inference.USEPOD_MIN_PAYMENT_ATOMIC ?? 10000n);
-        const pays = atFloor ? `The cap must be at least the ceiling ${usdcText2(ceiling)} USDC; the call usually pays about 0.0011 USDC (usePod's price plus the 0.001 USDC Shinjuku fee).` : `The cap must be at least the ceiling ${usdcText2(ceiling)} USDC; the call pays usePod's price for these max_tokens, at most the ceiling, plus the 0.001 USDC Shinjuku fee.`;
+        const paysUpTo = paysUpToAtomic(inference, { model: args.model, messages, maxTokens: args.max_tokens });
+        const pays = `A cap (max_payment, or --max-payment) is only a limit, not the price: the call pays usePod's price for its max_tokens plus the 0.001 USDC Shinjuku fee${paysUpTo === void 0 ? "" : ` (up to ${usdcText2(paysUpTo)} USDC in all at this model's listed prices)`}, and a larger cap never makes it pay more. The cap must still be at least the ceiling ${usdcText2(ceiling)} USDC.`;
         if (BigInt(narrowed) !== BigInt(launch)) {
           return refuse12(
             "inference_ceiling_over_cap",
             detail,
             atFloor ? `${pays} So pass max_payment "${usdcText2(ceiling + 1000n)}" (the ceiling plus the fee) or more if the spending limit allows it, or leave max_payment out` : `${pays} So lower max_tokens (at least ${INFERENCE_MIN_MAX_TOKENS}), pick a cheaper model (inference_chat with no prompt lists them), or pass max_payment "${usdcText2(ceiling + 1000n)}" (the ceiling plus the fee) if the spending limit allows it`,
-            { requestId, paid: false, ...facts }
+            {
+              requestId,
+              paid: false,
+              ...facts,
+              capKind: "call",
+              capAtomic: String(narrowed),
+              capNeededAtomic: (ceiling + 1000n).toString(),
+              ...paysUpTo === void 0 ? {} : { paysUpToAtomic: paysUpTo.toString() }
+            }
           );
         }
         askedLimit = true;
@@ -151811,7 +151921,7 @@ function parseArgs2(args) {
   if (!options["dry-run"] && FOR_RUN.some((key) => !options[key])) fail41("arguments_missing");
   return options;
 }
-async function main5(args = process.argv.slice(2)) {
+async function main5(args = process.argv.slice(2), { output: output2 = (result) => console.log(JSON.stringify(result)) } = {}) {
   if (args.length === 1 && args[0] === "--help") {
     console.log(USAGE3);
     return;
@@ -151894,20 +152004,20 @@ async function main5(args = process.argv.slice(2)) {
         return { id, amountAtomic: record.amountAtomic, accountCommitment: record.mergeAccountCommitment, noteCommitments: record.mergeNoteCommitments ?? [] };
       });
       if (dryRun) {
-        console.log(JSON.stringify({
+        output2({
           dryRun: true,
           resume: resume.map((entry) => ({ amountAtomic: entry.amountAtomic, amount: usdc9(entry.amountAtomic) })),
           next: "run the same command without --dry-run: it finishes these merges first (never pays twice)"
-        }));
+        });
         return;
       }
       const results2 = [];
       for (const entry of resume) results2.push(await runOne(entry));
-      console.log(JSON.stringify({
+      output2({
         success: true,
         resumed: results2,
         next: "after the next pool anchor (up to 5 minutes; about 30 s on a pool with sub-anchors): balance --refresh, then rerun merge (it plans the next round, or says nothing is left) or your payment"
-      }));
+      });
       return;
     }
     const snapshotRead = readBalanceSnapshot(store);
@@ -151915,8 +152025,8 @@ async function main5(args = process.argv.slice(2)) {
     if (balance.status !== "current" || snapshotRead.snapshot?.programId !== String(options.program)) fail41("balance_walk_not_current_run_balance_refresh");
     if (balance.detail.inFlight.some((item) => item.kind !== "merge")) fail41("in_flight_work_finish_first");
     const plan = planMerge({ snapshot: snapshotRead.snapshot, exitReserved: exitReservedNoteCommitments(store) });
-    const shown = (output2) => ({ amountAtomic: output2.valueAtomic, amount: usdc9(output2.valueAtomic) });
-    const merges = plan.merge.map((output2) => ({ id: nextMergeId(store, output2.commitment), amountAtomic: output2.valueAtomic, accountCommitment: output2.commitment })).filter((entry) => entry.id !== void 0);
+    const shown = (output3) => ({ amountAtomic: output3.valueAtomic, amount: usdc9(output3.valueAtomic) });
+    const merges = plan.merge.map((output3) => ({ id: nextMergeId(store, output3.commitment), amountAtomic: output3.valueAtomic, accountCommitment: output3.commitment })).filter((entry) => entry.id !== void 0);
     const summary = {
       totalAtomic: plan.totalAtomic,
       total: usdc9(plan.totalAtomic),
@@ -151928,19 +152038,19 @@ async function main5(args = process.argv.slice(2)) {
     const nothing = merges.length === 0;
     const why = !plan.keep || plan.merge.length + plan.later.length === 0 ? "nothing to merge: one funded account (or none) holds the shielded balance, so one payment already draws it all (with up to 3 notes)" : plan.merge.length === 0 ? `nothing to merge this round: a payment already draws ${plan.notes.length} notes, the most one spend takes is ${MAX_RESPEND_NOTES}. Make one payment first (its change joins those notes into one account), then rerun merge` : void 0;
     if (dryRun || nothing) {
-      console.log(JSON.stringify({ dryRun, ...summary, ...why ? { next: why } : nothing ? { next: "nothing left to merge" } : {
+      output2({ dryRun, ...summary, ...why ? { next: why } : nothing ? { next: "nothing left to merge" } : {
         next: "run the same command without --dry-run (with --proof-tools, --profile, --facilitator); nothing was signed or sent"
-      } }));
+      } });
       return;
     }
     const results = [];
     for (const entry of merges) results.push(await runOne(entry));
-    console.log(JSON.stringify({
+    output2({
       success: true,
       ...summary,
       merged: results,
       next: plan.later.length ? "after the next pool anchor (up to 5 minutes; about 30 s on a pool with sub-anchors): make your payment (it draws the kept account and the new notes), then balance --refresh and rerun merge for the accounts in later" : "after the next pool anchor (up to 5 minutes; about 30 s on a pool with sub-anchors), rerun your payment: it draws the kept account plus the new notes. balance --refresh shows the new state"
-    }));
+    });
   } finally {
     await release();
   }
@@ -154914,7 +155024,8 @@ function fundsView(store, plan, { now = Date.now(), running } = {}) {
       state: last?.stopped ? "stopped" : idle ? "not running" : last?.until ? "waiting" : "next",
       ...last?.waitsFor ? { waitsFor: last.waitsFor } : {},
       ...last?.until && !idle ? { until: last.until } : {},
-      ...last?.stopped ? { code: last.stopped } : {},
+      // A wait's code (K29 T13): the terminal says the wait in words only.
+      ...last?.stopped ? { code: last.stopped } : last?.code ? { code: last.code } : {},
       ...last?.said?.length ? { said: last.said } : {}
     };
   });
@@ -155087,20 +155198,44 @@ var TRANSIENT = [
   /^E[A-Z0-9_]{1,40}$/
 ];
 var SOON_CODES = /(_retry_same_|_rerun$|wallet_process_locked|wallet_locked|_wait_next_epoch|_anchor_not_finalized)/;
-function transient(ctx, run5, waitsFor) {
+var RETRY_WORDS = [
+  [/^p03_deposit_landed_history_walk_slow_retry_later$/, {
+    now: "the deposit is in the pool; the wallet could not read the pool history in time to confirm it, so it reads again",
+    waitsFor: "a new read of the pool history to confirm the deposit (the deposit is in the pool)"
+  }],
+  [/^p03_deposit_(landed_history_pending|receipt_transaction_unavailable|receipt_evidence_missing)_retry_later$/, {
+    now: "the deposit is in the pool; the chain does not show the wallet its receipt yet, so it reads again",
+    waitsFor: "the chain to show the deposit's receipt (the deposit is in the pool)"
+  }],
+  [/^p03_deposit_relay_not_settled_rerun_same_id$/, {
+    now: "the facilitator has not moved the deposit into the pool yet, so the wallet asks again",
+    waitsFor: "the facilitator to move the deposit into the pool"
+  }],
+  [/^rpc_unreachable$/, { now: "the RPC did not answer, so the wallet asks again", waitsFor: "an answer from the RPC (it did not answer)" }],
+  [/^rpc_rate_limited$/, { now: "the RPC asked the wallet to slow down, so it asks again", waitsFor: "the RPC to take requests again (it asked the wallet to slow down)" }],
+  [/^(wallet_process_locked|p03_pocket_cli_wallet_locked)$/, {
+    now: "another wallet command uses this wallet right now, so add-funds tries again",
+    waitsFor: "the other wallet command to finish with this wallet"
+  }]
+];
+var RETRY_ANY = { now: "the step did not finish this time and nothing was lost, so it runs again", waitsFor: "a new try of the step (nothing was lost)" };
+var NO_CODE = { now: "the step ended without an error code (it was stopped, or a connection was refused), so it runs again", waitsFor: "a new try of the step (it ended without an error code)" };
+function transient(ctx, run5, words2) {
   ctx.transient += 1;
-  if (ctx.transient > MAX_TRANSIENT) return stop2(run5, `the step failed ${MAX_TRANSIENT} times in a row (${run5.code ?? "no error code"})`);
-  return wait(has(run5, SOON_CODES) ? SOON_MS : LATER_MS, waitsFor, { transient: true });
+  if (ctx.transient > MAX_TRANSIENT) return { ...stop2(run5, words2.waitsFor), tries: true };
+  const code2 = run5.code ?? run5.codes[0];
+  return wait(has(run5, SOON_CODES) ? SOON_MS : LATER_MS, words2.waitsFor, { transient: true, said: words2.now, ...code2 ? { code: code2 } : {} });
 }
 function otherwise(ctx, run5) {
   if (run5.aborted) return stop2(run5, "stopped");
   if (run5.exit === 2) return stop2(run5, "the step's command line was refused");
-  if (!run5.code && !run5.codes.length) return transient(ctx, run5, "a new try of the step (it ended without an error code)");
+  if (!run5.code && !run5.codes.length) return transient(ctx, run5, NO_CODE);
   if (has(run5, FACILITATOR_LATER)) {
     return wait(LATER_MS, has(run5, /_paused_retry_later$/) ? "the facilitator to take this step again (it is paused right now)" : "the facilitator's relayer to have its fee money again");
   }
   if (run5.codes.some((code2) => TRANSIENT.some((pattern) => pattern.test(code2)))) {
-    return transient(ctx, run5, `a new try (${run5.code ?? run5.codes[0]}: a later run clears it)`);
+    const codes = [run5.code, ...run5.codes].filter(Boolean);
+    return transient(ctx, run5, RETRY_WORDS.find(([pattern]) => codes.some((code2) => pattern.test(code2)))?.[1] ?? RETRY_ANY);
   }
   return stop2(run5, `the step refused (${run5.code ?? run5.codes[0]})`);
 }
@@ -155121,7 +155256,7 @@ function depositArgs(ctx, submit, part) {
     usdcFlag(part.amountAtomic),
     "--service",
     values.service,
-    ...submit ? ["--submit"] : []
+    ...submit ? ["--submit", ...historyRpcArgs(ctx)] : []
   ];
 }
 function crowdFlags(ctx) {
@@ -155687,20 +155822,26 @@ async function addFunds(values, deps) {
       }
       const label = outcome.label ?? next ?? stage;
       if (outcome.kind === "stop") {
-        const said = (outcome.run?.held ?? []).filter((text3) => !/^(Help|next): /.test(text3));
-        if (!said.length && outcome.run?.last) said.push(outcome.run.last);
+        const said = outcome.tries ? [] : (outcome.run?.held ?? []).filter((text3) => !/^(Help|next): /.test(text3));
+        if (!said.length && outcome.run?.last && !outcome.tries) said.push(outcome.run.last);
         for (const text3 of said) io.err(`  ${text3}
 `);
         plan.status = { stage: label, at: iso2(deps.now()), stopped: outcome.run?.code ?? outcome.run?.codes?.[0] ?? "refused", waitsFor: outcome.waitsFor, ...said.length ? { said } : {} };
         save2();
-        throw failure("stopped", `the ${label} step needs you: ${outcome.waitsFor}${said.length ? " (its own line and hint are above)" : ""}. Fix that, then rerun this same add-funds command: it continues at ${label}`);
+        throw failure("stopped", outcome.tries ? `add-funds stopped after ${MAX_TRANSIENT} tries of the ${label} step: it still waits for ${outcome.waitsFor}. Nothing was lost. Run this same add-funds command again later: it continues at ${label}` : `the ${label} step needs you: ${outcome.waitsFor}${said.length ? " (its own line and hint are above)" : ""}. Fix that, then rerun this same add-funds command: it continues at ${label}`);
       }
       const until = iso2(deps.now() + outcome.ms);
-      plan.status = { stage: label, at: iso2(deps.now()), waitsFor: outcome.waitsFor, until };
+      plan.status = { stage: label, at: iso2(deps.now()), waitsFor: outcome.waitsFor, until, ...outcome.code ? { code: outcome.code } : {} };
       save2();
-      if (outcome.waitsFor !== lastWait) {
+      if (outcome.transient) {
+        const at = `${until.slice(11, 19)} UTC`;
+        ctx.say(label, values.has("--once") ? `${outcome.said} on the next add-funds run (--once ends this one here; the next try can start at ${at})` : ctx.transient === 1 ? `${outcome.said} at ${at} by itself (nothing to do)` : `try ${ctx.transient} of ${MAX_TRANSIENT}: still waits for ${outcome.waitsFor}; next try at ${at}`);
+        lastWait = outcome.waitsFor;
+      } else if (outcome.waitsFor !== lastWait) {
         ctx.say(label, `waits for ${outcome.waitsFor}; next try at ${until}${outcome.every ? ` (${outcome.every})` : ""}`);
         lastWait = outcome.waitsFor;
+      } else if (!outcome.every) {
+        ctx.say(label, `still waits for ${outcome.waitsFor}; next try at ${until}`);
       }
       if (values.has("--once")) {
         plan.status = { ...plan.status, ended: iso2(deps.now()) };
@@ -155708,7 +155849,7 @@ async function addFunds(values, deps) {
         printEnd(deps, fundsView(store, plan, { now: deps.now(), running: false }), ctx.terminal);
         return;
       }
-      await sleep3(outcome.ms, abort.signal);
+      await (deps.sleep ?? sleep3)(outcome.ms, abort.signal);
     }
     plan.status = { ...plan.status ?? { stage: currentStage(store, plan) }, ended: iso2(deps.now()) };
     save2();
@@ -155771,6 +155912,7 @@ init_job();
 init_rpcDefault();
 init_adoptOneTime();
 init_privateSend();
+init_selfPay();
 init_payMe();
 init_transferToken();
 init_recoveredPayment();
@@ -156650,7 +156792,7 @@ function inferPreflight(inference, values, prompt) {
   const floor = BigInt(inference.USEPOD_MIN_PAYMENT_ATOMIC ?? 0n);
   const worst = ceiling > floor ? ceiling : floor;
   if (worst > BigInt(values.get("--max-payment"))) {
-    throw new PublicFailure(`inference_ceiling_over_cap: usePod's price for this request may be up to ${usdcOr(worst)} (ceiling ${usdcOr(ceiling)}, minimum ${usdcOr(floor)}), and Shinjuku's fee comes on top; that is above --max-payment ${usdcFlagText(values.get("--max-payment"))} (${usdcOr(values.get("--max-payment"))}); nothing was paid. Raise --max-payment to at least ${usdcFlagText(worst)} (${usdcOr(worst)}) plus Shinjuku's fee${ceiling > floor ? ", or lower --max-tokens" : ""}`);
+    throw new PublicFailure(`inference_ceiling_over_cap: usePod's price for this request may be up to ${usdcOr(worst)} (ceiling ${usdcOr(ceiling)}, minimum ${usdcOr(floor)}), and Shinjuku's fee comes on top; that is above --max-payment ${usdcFlagText(values.get("--max-payment"))} (${usdcOr(values.get("--max-payment"))}); nothing was paid. Raise --max-payment to at least ${usdcFlagText(worst)} (${usdcOr(worst)}) plus Shinjuku's fee${ceiling > floor ? ", or lower --max-tokens" : ""}. The cap is only a limit, not the price: the call pays usePod's price for its tokens plus the 0.001 USDC fee, and a larger cap never pays more`);
   }
   return { model, maxTokens, ceiling, worst };
 }
@@ -158018,7 +158160,7 @@ var COMMANDS = [
       flag2("--profile", "<file>", "the facilitator's public seller profile, public-profile.json (pocket fill; needed only with --pockets 1 or more)"),
       flag2("--pockets", "<n>", "0 to 20; default 0 (no pocket and no dwell). 1 or more fills that many pockets after the deposit (pocket fill). A new payment never pays from a pocket: it pays through Shinjuku from the shielded balance, so most wallets leave this out", { check: "count" }),
       flag2("--pocket-size", "<usdc>", "the size of each pocket, in USDC; default 1 (1 USDC), the size our facilitator uses", { check: "atomic", usdc: true }),
-      { ...HISTORY_RPC_FLAG, about: `add-funds passes it only to the steps that read the pool's history (balance --refresh, pocket fill, and its dwell check; never to a deposit or Privacy Cash step): ${HISTORY_RPC_FLAG.about}` },
+      { ...HISTORY_RPC_FLAG, about: `add-funds passes it only to the steps that read the pool's history (balance --refresh, pocket fill, its dwell check, and the deposit's walk that confirms a deposit that landed without the facilitator's answer; never to a Privacy Cash step): ${HISTORY_RPC_FLAG.about}` },
       flag2("--from-key-file", "<file>", "--route privacy-cash: a solana-keygen JSON key of your own wallet that pays into Privacy Cash and owns its notes"),
       flag2("--crowd-amount", "<usdc>", "--route privacy-cash: whole USDC to put into Privacy Cash first (13 = 13 USDC); leave it out to spend notes that key already holds there", { check: "atomic", usdc: true }),
       { ...PRIVACY_CASH_VIA_FLAG, about: `--route privacy-cash: ${PRIVACY_CASH_VIA_FLAG.about}` },
@@ -158103,6 +158245,7 @@ var COMMANDS = [
       flag2("--deposit-id", "<id>", "your name for this deposit; reuse it for every retry", { required: true }),
       flag2("--amount", "<usdc>", "USDC to deposit (0.03 = 3 cents)", { required: true, check: "atomic", usdc: true }),
       ...rpcFlags,
+      { ...HISTORY_RPC_FLAG, about: `with --relay --submit, only for the pool-history walk that confirms a deposit that landed without the facilitator's answer: ${HISTORY_RPC_FLAG.about}` },
       bool2("--submit", "send the recorded deposit (second run)"),
       flag2("--service", "<url>", "facilitator that stores the deposit memo (use with --submit; with --relay, on both runs)"),
       bool2("--relay", "deposit from a one-time address of this wallet that holds only USDC; the facilitator pays every fee and rent, so it needs no SOL"),
@@ -158805,7 +158948,7 @@ var COMMANDS = [
       "After setup it needs only --amount and --to: config.json gives the wallet, the passphrase file, the proof tools, the profile, the program, and the facilitator. Without setup, give every flag marked required (the old form also takes --to <USDC token account> --recipient-owner <owner>).",
       "The wallet pays exactly --amount to a note it owns and keeps the rest private. The facilitator relays the note's exit to the recipient and pays every fee. No wallet key signs.",
       "The recipient must already hold USDC (a Solana address with a USDC account, for example a Phantom address that received USDC); the command checks it first and sends nothing to an address without one. It refuses this wallet's own address: an exit there would show on chain that the money is yours. Best: an address that never sent USDC into this wallet.",
-      `--amount all sends the whole private balance. When the balance is in more than one part, it says so and sends nothing: join the parts first with ${CLI2} merge (a private move inside this wallet; about 2 minutes per extra part), then run it again.`,
+      "--amount all sends the whole private balance. When the balance is in more than one part, the same command joins the parts first (a private move inside this wallet, no fee; nothing leaves it; about 2 minutes per extra part, after a random wait of up to 60 s), then sends all of it. Ctrl+C stops it; the same command again goes on and never sends twice.",
       "The command prints the unshield id first. If it stops, run the same command with --unshield-id <that id> added: it finishes that unshield and never sends twice.",
       "In a terminal it ends with one plain line (what was sent, to whom, the exit transaction) and the new private balance: after an exit the wallet reads the balance again itself (the same walk as balance --refresh, over the same connection; Tor when setup recorded it). A program, or --json, gets the result as JSON.",
       `--parts and --max-delay-minutes make a private send (${CLI2} unshield --amount 3 --parts 3 --max-delay-minutes 20 --to <your wallet address>): the plan (part sizes, part ids <unshield-id>-p1.., earliest times) is saved in the wallet before part 1, each part is one unshield, and a stopped run continues at the first part not yet exited when the same command with its --unshield-id runs again. The wallet is free for other commands while a part waits. Keep the command running until it prints its result.`,
@@ -159631,15 +159774,34 @@ async function runUnshieldCommand(args, values, deps, io) {
     setArg("--to", getAssociatedTokenAddressSync(mint, owner, true, TOKEN_PROGRAM_ID).toBase58());
     setArg("--recipient-owner", owner.toBase58());
   }
-  if (values.get("--amount") === "all") setArg("--amount", await sendAllAtomic(values, deps, io, openStore));
   let id = values.get("--unshield-id");
-  if (id === void 0) {
+  let recorded;
+  if (id !== void 0) {
+    let opened;
+    try {
+      opened = openStore();
+    } catch {
+      opened = void 0;
+    }
+    recorded = opened === void 0 ? void 0 : recordedUnshield(opened, id, values);
+  }
+  if (recorded && values.get("--amount") === "all") {
+    setArg("--amount", recorded.amountAtomic);
+    io.err(`--amount all: unshield ${id} started earlier with ${usdcOr(recorded.amountAtomic)}; this run finishes it (it never sends twice)
+`);
+  } else if (recorded && values.get("--amount") !== recorded.amountAtomic) {
+    throw unshieldRefusal("id_reused_with_different_amount", `unshield ${id} started earlier with ${usdcOr(recorded.amountAtomic)}, not ${usdcOr(values.get("--amount"))}, and one unshield id always sends the amount it started with; nothing was sent. Finish it: ${CLI2} unshield --amount all${recorded.flags} --to ${owner.toBase58()} --unshield-id ${id} (it never sends twice). To send another amount, leave out --unshield-id`);
+  }
+  const ensureId = () => {
+    if (id !== void 0) return;
     id = `unshield-${randomBytes35(6).toString("hex")}`;
     setArg("--unshield-id", id);
     values.set(UNSHIELD_MADE_ID, id);
     io.err(`unshield id: ${id} (if this command stops, run it again with --unshield-id ${id} added: it finishes this unshield and never sends twice)
 `);
-  }
+  };
+  if (values.get("--amount") === "all") setArg("--amount", await sendAllAtomic(values, deps, io, openStore, ensureId));
+  ensureId();
   const gated = await spendGate(callArgs, values, deps, io, { amountAtomic: values.get("--amount"), again: ` with --unshield-id ${id}` });
   let answer;
   const returned = await deps.unshieldMain(gated, { output: (result) => {
@@ -159653,9 +159815,36 @@ async function runUnshieldCommand(args, values, deps, io) {
   if (!/^[1-9][0-9]*$/.test(String(sent ?? ""))) return;
   const walletAt = gated.indexOf("--wallet");
   const report = await refreshAfterUnshield(walletAt >= 0 ? gated[walletAt + 1] : values.get("--wallet"), values, deps, io);
-  if (terminal) io.out(`${privateBalanceLine(report, "Private balance now")}
+  if (!terminal) return;
+  let unfinished2 = [];
+  try {
+    unfinished2 = unfinishedUnshields(openStore());
+  } catch {
+  }
+  io.out(`${[privateBalanceLine(report, "Private balance now"), ...unfinished2.map(unfinishedUnshieldLine)].join("\n")}
 `);
 }
+function recordedUnshield(store, id, values) {
+  if (!/^[0-9a-zA-Z_-]{1,48}$/.test(id)) return void 0;
+  const whole = (atomic4) => /^[1-9][0-9]*$/.test(String(atomic4 ?? ""));
+  if (isSingleSend(values.get("--parts") ?? 1, values.get("--max-delay-minutes") ?? 0)) {
+    const record = store.readWal(`self-pay-${id}`);
+    return record?.schema === SELF_PAY_WAL_SCHEMA && whole(record.amountAtomic) ? { amountAtomic: String(record.amountAtomic), flags: "" } : void 0;
+  }
+  const plan = store.readWal(privateSendPlanName(id));
+  return plan?.schema === PRIVATE_SEND_WAL_SCHEMA && whole(plan.amountAtomic) && Array.isArray(plan.parts) ? { amountAtomic: String(plan.amountAtomic), flags: ` --parts ${plan.parts.length} --max-delay-minutes ${plan.maxDelayMinutes}` } : void 0;
+}
+function unfinishedUnshields(store) {
+  const read = (name) => {
+    try {
+      return store.readWal(name);
+    } catch {
+      return void 0;
+    }
+  };
+  return store.listWal().filter((name) => name.startsWith("self-pay-")).map((name) => name.slice("self-pay-".length)).filter((unshieldId) => !unshieldId.startsWith("merge-") && !/^pocket-\d+-f\d+$/.test(unshieldId)).map((unshieldId) => ({ unshieldId, record: read(`self-pay-${unshieldId}`) })).filter(({ record }) => record?.schema === SELF_PAY_WAL_SCHEMA && record.ownerUnshield === true && record.state === "paid" && record.mode !== DIRECT_EXIT_MODE && /^[1-9][0-9]*$/.test(String(record.amountAtomic ?? ""))).map(({ unshieldId, record }) => ({ unshieldId, amountAtomic: String(record.amountAtomic) }));
+}
+var unfinishedUnshieldLine = ({ unshieldId, amountAtomic }) => `${usdcOr(amountAtomic)} is in an unshield that has not finished (unshield id ${unshieldId}): run ${CLI2} unshield --amount all --to <the address you sent it to> --unshield-id ${unshieldId} to finish it; it never sends twice`;
 function unshieldDoneText(answer, to) {
   const send3 = answer.privateSend;
   if (!send3) {
@@ -159743,25 +159932,86 @@ async function refreshAfterUnshield(walletFile, values, deps, io) {
     restore();
   }
 }
-async function sendAllAtomic(values, deps, io, openStore) {
+async function sendAllAtomic(values, deps, io, openStore, ensureId) {
   const store = openStore();
   let report = computeBalance({ store, snapshotRead: readBalanceSnapshot(store), source: "local", now: deps.now() });
   if (report.status !== "current") report = await refreshAfterUnshield(values.get("--wallet"), values, deps, io) ?? report;
+  const notCurrent = (read) => new PublicFailure(`balance_not_current: --amount all needs the current private balance, and it is not current (${balanceNotCurrentWhy(read)}); nothing was sent. Run ${CLI2} balance --refresh in a minute, then this command again, or give the amount, like ${UNSHIELD_EXAMPLE}`);
   const empty = report.status === "empty" || report.status === "current" && report.atomic === "0";
-  if (!empty && (report.status !== "current" || !/^[1-9][0-9]*$/.test(String(report.atomic ?? "")))) {
-    throw new PublicFailure(`balance_not_current: --amount all needs the current private balance, and it is not current (${balanceNotCurrentWhy(report)}); nothing was sent. Run ${CLI2} balance --refresh in a minute, then this command again, or give the amount, like ${UNSHIELD_EXAMPLE}`);
-  }
   if (empty) {
     throw new PublicFailure(`no_spendable_account: the private balance is 0 USDC, so --amount all has nothing to send; nothing was sent. Add funds first (${CLI2} help add-funds)`);
   }
   const parts = joinParts(store);
-  if (parts?.parts > 1) {
-    throw new PublicFailure(`unshield_joining_accounts: the private balance (${usdcOr(report.atomic)}) is in ${parts.parts} parts, and one unshield sends from one part; nothing was sent. Join the parts first with ${CLI2} merge (a private move inside this wallet, no fee; about ${parts.minutes} minutes), then run ${CLI2} unshield --amount all --to <your wallet address> again`);
-  }
-  io.err(`--amount all: the whole private balance, ${usdcOr(report.atomic)}
+  const join40 = parts?.joining > 0 || parts?.parts > 1 && report.status === "current";
+  if (join40) report = await joinForSendAll(report, parts, store, values, deps, io, ensureId);
+  if (report.status !== "current" || !/^[1-9][0-9]*$/.test(String(report.atomic ?? ""))) throw notCurrent(report);
+  if (!join40) io.err(`--amount all: the whole private balance, ${usdcOr(report.atomic)}
 `);
   return report.atomic;
 }
+var SEND_ALL_JOIN_ROUNDS = 3;
+async function joinForSendAll(report, parts, store, values, deps, io, ensureId) {
+  const count2 = parts.parts + parts.joining;
+  const known = /^[0-9]+$/.test(String(report.atomic ?? ""));
+  io.err(`--amount all: the private balance${known ? `, ${usdcOr(report.atomic)},` : ""} is in ${count2} parts, and one unshield sends from one part. The wallet joins the parts first (a private move inside this wallet, no fee; nothing leaves it), then sends all of it: about ${joinMinutes(count2)} min. Ctrl+C stops it; the same command again goes on and never sends twice
+`);
+  ensureId();
+  if (parts.joining === 0) {
+    const waitMs = Math.floor((deps.random ?? Math.random)() * (JOIN_SOON_MAX_MS + 1));
+    io.err(`the join starts in ${Math.round(waitMs / 1e3)} s: a random wait, so the chain does not show the join right after your request
+`);
+    await (deps.sleep ?? ((ms) => new Promise((done) => {
+      setTimeout(done, ms);
+    })))(waitMs);
+  }
+  const history = values.get("--history-rpc");
+  const mergeArgs = [
+    "--wallet",
+    values.get("--wallet"),
+    "--passphrase-file",
+    values.get("--passphrase-file"),
+    "--program",
+    values.get("--program"),
+    "--proof-tools",
+    values.get("--payer-proof-tools"),
+    "--profile",
+    values.get("--profile"),
+    "--facilitator",
+    new URL(values.get("--facilitator")).origin,
+    ...values.has("--rpc-file") ? ["--rpc-file", values.get("--rpc-file")] : [],
+    ...history ? ["--history-rpc", history] : []
+  ];
+  const startedAt = deps.now();
+  let joined = 0;
+  let left = parts;
+  let keep;
+  let read;
+  for (let round = 1; round <= SEND_ALL_JOIN_ROUNDS; round += 1) {
+    let answer;
+    try {
+      await deps.mergeMain(mergeArgs, { output: (result) => {
+        answer = result;
+      } });
+    } catch (error) {
+      io.err("note: the join stopped, so the unshield did not start; nothing was sent\n");
+      throw error;
+    }
+    const merged = (answer?.merged ?? answer?.resumed ?? []).filter((entry) => entry?.state === "merged").length;
+    joined += merged;
+    keep = answer?.keep?.amountAtomic ?? keep;
+    read = await refreshAfterUnshield(values.get("--wallet"), values, deps, io);
+    left = joinParts(store);
+    if (read?.status === "current" && left?.parts <= 1 && left.joining === 0) {
+      const seconds2 = Math.max(0, Math.round((deps.now() - startedAt) / 1e3));
+      io.err(`joined the ${count2} parts in ${Math.floor(seconds2 / 60)} min ${seconds2 % 60} s; sending all ${usdcOr(read.atomic)} now
+`);
+      return read;
+    }
+    if (!read || read.status !== "current" || merged === 0) break;
+  }
+  const remaining = left ? left.parts + left.joining : void 0;
+  throw new PublicFailure(`unshield_joining_accounts: the wallet joined ${joined} part${joined === 1 ? "" : "s"} of your private balance into the largest one` + (remaining > 1 ? `, and it is still in ${remaining} parts` : read ? ", but the balance walk after the join is not current yet" : ", but the balance could not be read again after the join") + `; nothing was sent. Send a fixed amount up to the largest part${keep ? ` (${usdcOr(keep)})` : ""} now, like ${UNSHIELD_EXAMPLE} (that send also joins the parts it draws), or run ${CLI2} unshield --amount all --to <your wallet address> again in a few minutes: it goes on with the next join`);
+}
 async function runUnshieldCancel(values, deps, io) {
   const walletFile = resolve38(values.get("--wallet"));
   const passphrase2 = payerPassphrase(values, deps);
@@ -160310,17 +160560,19 @@ async function runBalance(args, values, deps, io) {
     }
     if (config?.pool === store.state.pool && config.program && config.proofTools && config.memoService) report.next = `${CLI2} balance --refresh --fresh`;
   }
+  const unfinished2 = unfinishedUnshields(store);
   if (deps.stdoutIsTTY?.() === true && !values.has("--json")) {
     const notCurrent = report.status !== "current" && report.status !== "empty";
     io.out(`${[
       privateBalanceLine(report),
+      ...unfinished2.map(unfinishedUnshieldLine),
       ...shown.map((entry) => entry.notice).filter((notice) => typeof notice === "string" && notice),
       ...notCurrent && typeof report.next === "string" ? [`next: ${report.next}`] : []
     ].join("\n")}
 `);
     return;
   }
-  io.out(`${JSON.stringify(shown.length ? { ...report, earlierDeposits: shown } : report, null, 2)}
+  io.out(`${JSON.stringify({ ...report, ...shown.length ? { earlierDeposits: shown } : {}, ...unfinished2.length ? { unfinishedUnshields: unfinished2 } : {} }, null, 2)}
 `);
 }
 async function adoptOneTimeForBalance({ store, values, deps, io }) {
@@ -160637,6 +160889,8 @@ function failureHint(command2, reason, deps, values, floatError) {
   if (relayHint) return relayHint;
   const privacyCashHint = privacyCashFailureHint(reason);
   if (privacyCashHint) return privacyCashHint;
+  const exitRelayHint = exitRelayFailureHint(reason);
+  if (exitRelayHint) return exitRelayHint;
   if (/_retry_same_request/.test(reason) && /the quote ended/.test(reason)) {
     return `the quote of this request ended, so the same payment can no longer settle. Run ${CLI2} cancel with the same request id (${CLI2} help cancel): it checks on chain that nothing was paid and frees the request. Then pay again with a new --request-id`;
   }
@@ -160655,6 +160909,25 @@ function failureHint(command2, reason, deps, values, floatError) {
   }
   return void 0;
 }
+function exitRelayFailureHint(reason) {
+  if (!/p03_unshield_relay_refused_/.test(reason) || /_retry_same_request|exit_pocket_/.test(reason)) return void 0;
+  if (/relay_refused_exit_quote_expired/.test(reason)) {
+    return "the exit proof's time window ended before the facilitator's exit transaction landed, and the new proof met the same; nothing was sent and the note is still yours. Rerun the same command (same --unshield-id): it makes a new proof, and it never sends twice";
+  }
+  if (/relay_refused_exit_anchor_not_retained/.test(reason)) {
+    return "the pool no longer keeps the anchor this exit proof names; nothing was sent and the note is still yours. Rerun the same command after the proof's time window ends (at most 10 minutes after it was made): the wallet then makes a new proof";
+  }
+  if (/relay_refused_exit_replay_consumed/.test(reason)) {
+    return `the chain shows this exit's note is already spent (an earlier exit of it landed, or another payment of this wallet spent it); nothing new was sent. ${CLI2} balance --refresh shows where the value is now`;
+  }
+  if (/relay_refused_exit_operator_review_required/.test(reason)) {
+    return "the facilitator cannot tell yet whether its exit transaction for this note landed, so it holds this exit for its operator and sends nothing more. Keep the wallet folder as it is and rerun the same command later (same --unshield-id); it never sends twice";
+  }
+  if (/relay_refused_exit_vault_insufficient/.test(reason)) {
+    return "the pool's vault holds less than this exit right now; nothing was sent and the note is still yours. Rerun the same command later (same --unshield-id)";
+  }
+  return "the facilitator's exit relay refused this exit (the code names why); nothing was sent and the note is still yours. Rerun the same command once (same --unshield-id); if the same code comes back, keep the wallet folder as it is and ask for help";
+}
 function relayDepositFailureHint(reason) {
   if (/p03_deposit_relay_approval_standing/.test(reason)) {
     return `your USDC is still at the one-time address with an approval that names this deposit alone: it can only become your own note, so it is safe to leave. Rerun the same command later; it signs nothing new while the approval stands. To take the USDC back instead: ${CLI2} help deposit-reclaim`;