shinjuku-shield 0.3.85 → 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.85. 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.85 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.85
+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.85 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.85", "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": "654041bce4139bfb928180cc1a3c1ff05e570d9fc51ddfa718e9d0ef7fbf9095",
-  "bytes": 12513236,
-  "sourceCommit": "1e2a8c09784450c8bc0a5d391c428d08f699c44a",
+  "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-23T20:33:40.235Z"
+  "publishedAt": "2026-10-23T21:42:59.534Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shield",
-  "version": "0.3.85",
+  "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": "654041bc",
-  "shinjukuSha256": "654041bce4139bfb928180cc1a3c1ff05e570d9fc51ddfa718e9d0ef7fbf9095",
+  "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)';
   }
@@ -65869,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",
@@ -107736,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;
@@ -107776,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;
@@ -107934,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";
@@ -107979,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}
@@ -107989,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));
@@ -109931,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)}`;
   }
@@ -127775,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",
@@ -127864,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: {
@@ -127967,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;
@@ -155839,6 +155912,7 @@ init_job();
 init_rpcDefault();
 init_adoptOneTime();
 init_privateSend();
+init_selfPay();
 init_payMe();
 init_transferToken();
 init_recoveredPayment();
@@ -156718,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 };
 }
@@ -159701,6 +159775,23 @@ async function runUnshieldCommand(args, values, deps, io) {
     setArg("--recipient-owner", owner.toBase58());
   }
   let id = values.get("--unshield-id");
+  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")}`;
@@ -159724,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) {
@@ -160442,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 }) {
@@ -160769,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`;
   }
@@ -160787,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`;