shinjuku-shielded 0.3.128 → 0.3.129

package/README.md

@@ -6,19 +6,19 @@ 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.128. The npm packages `shinjuku-shield` and
+This is version 0.3.129. The npm packages `shinjuku-shield` and
 `shinjuku-shielded` hold the same files. The command is `shinjuku`.
 
 ## Set up
 
 ```sh
-npm install -g shinjuku@0.3.128
+npm install -g shinjuku@0.3.129
 shinjuku setup
 ```
 
 Type the two lines as they are. `npx install shinjuku` does not work: npx
 reads `install` as the name of another npm package. To set up without
-installing, type `npx shinjuku@0.3.128 setup`.
+installing, type `npx shinjuku@0.3.129 setup`.
 
 Setup makes the wallet on this machine, a private passphrase file, and the
 checked proof tools (about 191 MB), and writes `config.json`. It also writes
@@ -36,13 +36,13 @@ Every wallet command works after `shinjuku`, for example `shinjuku balance`,
 Claude Code:
 
 ```sh
-claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.128 mcp
+claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.129 mcp
 ```
 
 Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
 
 ```json
-{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.128", "mcp"] } } }
+{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.129", "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": "821b09a3d1295b30eee38eafb6aad2665a60808a3163baddeb14c02366109e56",
-  "bytes": 8815826,
-  "sourceCommit": "ec580ba0a4153e45f70cf7eabc6901665f19d88c",
+  "sha256": "1de148b9fd19cd1bac5b690267cb77c227a3e74300873fa9eda02085833ccb2f",
+  "bytes": 8826955,
+  "sourceCommit": "2c963caa0410c71651cd64a18c704efa8b0ce95c",
   "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",
@@ -1037,5 +1037,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-10-30T02:43:43.393Z"
+  "publishedAt": "2026-10-30T06:56:34.660Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.128",
+  "version": "0.3.129",
   "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": "821b09a3",
-  "shinjukuSha256": "821b09a3d1295b30eee38eafb6aad2665a60808a3163baddeb14c02366109e56",
+  "shinjukuRelease": "1de148b9",
+  "shinjukuSha256": "1de148b9fd19cd1bac5b690267cb77c227a3e74300873fa9eda02085833ccb2f",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-shield#readme",

package/shinjuku-wallet.mjs

@@ -47684,7 +47684,7 @@ function proxiedChild(args, mode, plainProxy, stdio) {
   delete env[QUIET_RUN_MARK];
   const quiet = quietRun(args);
   if (quiet) env[QUIET_RUN_MARK] = quiet;
-  return spawn(process.execPath, [...proxiedExecArgv(process.execArgv), process.argv[1], ...args], { env, stdio });
+  return spawn(process.execPath, [...proxiedExecArgv(process.execArgv), process.argv[1], ...args], { env, stdio, windowsHide: true });
 }
 function reexec(args, mode, plainProxy) {
   return new Promise((resolvePromise) => {
@@ -47721,7 +47721,8 @@ async function proxyEntry(argv2, run4, { err = (text3) => process.stderr.write(t
     try {
       torVersion = await proveProxy(mode, proxy);
     } catch (error) {
-      err(`shinjuku: ${error.message}${mode === "tor" && process.env[TOR_FROM_CONFIG_ENV] === "1" && !error.torHintInside ? TOR_FROM_CONFIG_HINT : ""}
+      const refusal3 = `${error.message}${mode === "tor" && process.env[TOR_FROM_CONFIG_ENV] === "1" && !error.torHintInside ? TOR_FROM_CONFIG_HINT : ""}`;
+      err(`shinjuku: ${process.stderr.isTTY ? refusal3.replace(/^[a-z][a-z0-9_]*: /, "") : refusal3}
 `);
       if (mcpRefused2 && argv2[0] === "mcp" && !process.stdin.isTTY && !process.env[TOR_RUN_STARTED_ENV]) {
         return mcpRefused2({
@@ -47776,7 +47777,7 @@ function torChild(argv2, stdio) {
   if (!options.mode) throw new ProxyUsageError("torChild needs --tor or --proxy");
   return proxiedChild(options.args, options.mode, options.proxy, stdio);
 }
-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_MIN_VERSION, localTorProof, TOR_EXPERT_BUNDLE, TOR_EXPERT_BUNDLE_SHA256, TUNNEL_LINE, TOR_DEB_KEY, TOR_DEB_KEYRING, TOR_INSTALL, torStart, LOCAL_TUNNEL, torStartText, TOR_WINDOW, torNotRunningMessage, torUpdateHow, torTooOldWhy, torTooOldMessage, NOTICE, TOR_NOTICE_LINE, ONION_DETAIL_LINE, withoutOnionDetail, QUIET_RUN_MARK, QUIET_NOTICE, QUIET_TERMINAL_COMMANDS, INFER_SUBCOMMANDS, quietRun, TOR_TROUBLE_LINE, TOR_WAIT_PLAIN, TOR_TROUBLE_PLAIN, TOR_TROUBLE_SAID, quietTorErr, withRunTag, proxyEnv, pacedSoFar, RESENDABLE_METHOD, torCircuit, GLOBAL_DISPATCHER3, laneDispatchers, laneOfDispatcher, PROXY_WARNING_FLAG, proxiedExecArgv, proxiedNodeOptions, TOR_FROM_CONFIG_ENV, TOR_FROM_CONFIG_HINT, TOR_FROM_CONFIG_SENTENCE;
+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_MIN_VERSION, localTorProof, TOR_EXPERT_BUNDLE, TOR_EXPERT_BUNDLE_SHA256, TUNNEL_LINE, TOR_DEB_KEY, TOR_DEB_KEYRING, TOR_INSTALL, torStart, LOCAL_TUNNEL, torStartText, TOR_WINDOW, torNotRunningMessage, torUpdateHow, TOR_STOP_OLD_WINDOWS, torTooOldWhy, torTooOldMessage, NOTICE, TOR_NOTICE_LINE, ONION_DETAIL_LINE, withoutOnionDetail, QUIET_RUN_MARK, QUIET_NOTICE, QUIET_TERMINAL_COMMANDS, INFER_SUBCOMMANDS, quietRun, TOR_TROUBLE_LINE, TOR_WAIT_PLAIN, TOR_TROUBLE_PLAIN, TOR_TROUBLE_SAID, quietTorErr, withRunTag, proxyEnv, pacedSoFar, RESENDABLE_METHOD, torCircuit, GLOBAL_DISPATCHER3, laneDispatchers, laneOfDispatcher, PROXY_WARNING_FLAG, proxiedExecArgv, proxiedNodeOptions, TOR_FROM_CONFIG_ENV, TOR_FROM_CONFIG_HINT, TOR_FROM_CONFIG_SENTENCE;
 var init_proxy = __esm({
   "wallet/src/net/proxy.mjs"() {
     "use strict";
@@ -47833,7 +47834,7 @@ var init_proxy = __esm({
     TOR_INSTALL = Object.freeze({
       windows: `iwr https://archive.torproject.org/tor-package-archive/torbrowser/${TOR_EXPERT_BUNDLE}/tor-expert-bundle-windows-x86_64-${TOR_EXPERT_BUNDLE}.tar.gz -OutFile $env:TEMP\\tor.tar.gz; if ((Get-FileHash $env:TEMP\\tor.tar.gz -Algorithm SHA256).Hash -ne '${TOR_EXPERT_BUNDLE_SHA256}') { Remove-Item $env:TEMP\\tor.tar.gz; throw 'The Tor download does not match its pinned sha256, so it was deleted and not run' }; mkdir -Force $env:LOCALAPPDATA\\tor | Out-Null; & $env:SystemRoot\\System32\\tar.exe -xzf $env:TEMP\\tor.tar.gz -C $env:LOCALAPPDATA\\tor; & $env:LOCALAPPDATA\\tor\\tor\\tor.exe --HTTPTunnelPort '127.0.0.1:9080 IsolateDestAddr' --SocksPort 0`,
       macos: `brew install tor && (grep -qxF '${TUNNEL_LINE}' "$(brew --prefix)/etc/tor/torrc" || echo '${TUNNEL_LINE}' >> "$(brew --prefix)/etc/tor/torrc") && brew services restart tor`,
-      linux: `sudo apt install -y apt-transport-https gnupg wget && wget -qO- ${TOR_DEB_KEY} | gpg --dearmor | sudo tee ${TOR_DEB_KEYRING} >/dev/null && printf 'Types: deb\\nURIs: https://deb.torproject.org/torproject.org/\\nSuites: %s\\nComponents: main\\nSigned-By: ${TOR_DEB_KEYRING}\\n' "$(. /etc/os-release && echo "$VERSION_CODENAME")" | sudo tee /etc/apt/sources.list.d/tor.sources >/dev/null && sudo apt update && sudo apt install -y tor deb.torproject.org-keyring && (grep -qxF '${TUNNEL_LINE}' /etc/tor/torrc || echo '${TUNNEL_LINE}' | sudo tee -a /etc/tor/torrc) && sudo systemctl restart tor`
+      linux: `sudo apt install -y apt-transport-https gnupg wget && wget -qO- ${TOR_DEB_KEY} | gpg --dearmor | sudo tee ${TOR_DEB_KEYRING} >/dev/null && printf 'Types: deb\\nURIs: https://deb.torproject.org/torproject.org/\\nSuites: %s\\nComponents: main\\nSigned-By: ${TOR_DEB_KEYRING}\\n' "$(. /etc/os-release && echo "$VERSION_CODENAME")" | sudo tee /etc/apt/sources.list.d/tor.sources >/dev/null && sudo apt update && sudo apt install -y tor deb.torproject.org-keyring && (grep -qxF '${TUNNEL_LINE}' /etc/tor/torrc || echo '${TUNNEL_LINE}' | sudo tee -a /etc/tor/torrc) && sudo service tor restart`
     });
     torStart = (platform = process.platform, tunnelHost) => {
       const base = platform === "win32" ? { where: "PowerShell (keep its window open while the wallet runs)", command: TOR_INSTALL.windows } : platform === "darwin" ? { where: "Terminal", command: TOR_INSTALL.macos } : { where: "a terminal", command: TOR_INSTALL.linux };
@@ -47860,7 +47861,8 @@ ${command}`;
       return `tor_not_running: Tor is not running on this machine, so nothing was sent.${fromConfig ? TOR_FROM_CONFIG_SENTENCE : ""} Tor hides your IP address. Start it with the command below in ${TOR_WINDOW[platform] ?? "a terminal"}${keep}:
   ${command}`;
     };
-    torUpdateHow = (platform = process.platform) => platform === "win32" ? "Stop your old Tor first. Start a newer Tor with the command below in PowerShell and keep that window open" : `Install a newer Tor with the command below in ${TOR_WINDOW[platform] ?? "a terminal"}`;
+    torUpdateHow = (platform = process.platform) => platform === "win32" ? `${TOR_STOP_OLD_WINDOWS} Then start a newer Tor with the command below in PowerShell and keep that window open` : `Install a newer Tor with the command below in ${TOR_WINDOW[platform] ?? "a terminal"}`;
+    TOR_STOP_OLD_WINDOWS = "Stop your old Tor first: close the window it runs in, or for a Tor in WSL run wsl -u root service tor stop .";
     torTooOldWhy = (version3) => `Your Tor program is too old (${version3}). It has a known fault that can link two of your payments, so the wallet sent nothing.`;
     torTooOldMessage = (version3, platform = process.platform, { fromConfig = false, tunnelHost } = {}) => {
       const { command } = torStart(platform, tunnelHost);
@@ -51152,7 +51154,7 @@ var init_anchorClock = __esm({
     init_phaseTiming();
     EPOCH_MS = 3e5;
     SUB_ANCHOR_MS = 3e4;
-    SUB_ANCHOR_FINALITY_MS = 2e4;
+    SUB_ANCHOR_FINALITY_MS = 6e3;
     OBSERVATION_MAX_AGE_MS = 6e5;
     ANCHOR_REQUEST_TIMEOUT_MS = 9e4;
     MAX_FOLLOW_UPS = 3;
@@ -60661,6 +60663,16 @@ function spendHeads(spendableAtomic, largestAtomic, change = {}, options = {}) {
     if (change?.changeSettling === true) {
       const seconds2 = change.changeReadyInSeconds;
       const upTo = String(change.changeUpToAtomic ?? "");
+      if (Number.isSafeInteger(change.changeCount) && change.changeCount >= 2 && ATOMIC.test(upTo) && BigInt(upTo) > 0n && BigInt(upTo) < BigInt(spendable)) {
+        const part = usdcWords(upTo);
+        return Number.isSafeInteger(seconds2) && seconds2 > 0 ? [
+          `You have ${total}; after your recent payments settle (about ${seconds2} s), one payment can use up to ${part} and later payments the rest`,
+          `You have ${total}; one payment can use ${part} in about ${seconds2} s`
+        ] : [
+          `You have ${total}; after your recent payments settle, one payment can use up to ${part} and later payments the rest`,
+          `You have ${total}, ${part} for one payment after your recent ones settle`
+        ];
+      }
       if (ATOMIC.test(upTo) && BigInt(upTo) > 0n && BigInt(upTo) < BigInt(spendable)) {
         const part = usdcWords(upTo);
         return Number.isSafeInteger(seconds2) && seconds2 > 0 ? [
@@ -67229,6 +67241,9 @@ var init_errorCodes = __esm({
       "fetch_gate_stopped",
       "mcp_cap_required",
       "mcp_cap_invalid",
+      // mcp/tools.mjs maxPaymentNotUsdc: max_payment written in atomic units (a whole number of 1000 or more, above the whole
+      // balance); nothing was requested or paid (UX129-12, 2026-10-30).
+      "mcp_max_payment_not_usdc",
       "fetch_proof_tools_unavailable",
       "fetch_offer_confidential",
       "wallet_spend_refused_per_payment_cap_exceeded",
@@ -101461,7 +101476,7 @@ function computeBalance({ store, snapshotRead, source = "local", now = Date.now(
   let heldAtomic;
   let heldWholeAtomic;
   let spareMost = 0n;
-  const report = (status, gross, next2, cause, largest2, change) => {
+  const report = (status, gross, next2, cause, largest2, change, changes) => {
     const atomic4 = gross === null || privateSendPending === null ? null : gross > privateSendPending ? gross - privateSendPending : 0n;
     const built = {
       // The one number: shielded + pockets. Null when either part is unknown.
@@ -101500,7 +101515,10 @@ function computeBalance({ store, snapshotRead, source = "local", now = Date.now(
       const cap = atomic4 - BigInt(detail.successionMovableAtomic ?? "0");
       const one = cap <= 0n ? 0n : largest2 < cap ? largest2 : cap;
       LARGEST_PAYMENTS.set(built, one.toString());
-      if (change !== void 0 && one === 0n && atomic4 > 0n) CHANGE_SETTLING.set(built, (change < atomic4 ? change : atomic4).toString());
+      if (change !== void 0 && one === 0n && atomic4 > 0n) {
+        CHANGE_SETTLING.set(built, (change < atomic4 ? change : atomic4).toString());
+        if (Number.isSafeInteger(changes) && changes >= 2) CHANGE_COUNT.set(built, changes);
+      }
     }
     return built;
   };
@@ -101789,12 +101807,16 @@ If a payment to this wallet settled, read the chain again with:
   }
   if (settling.length || movedInAtomic > 0n) {
     reasons.push(...settlingReasons);
-    const [only] = settling;
     const sendHeldAtomic = sendHold === null || sendHold.notes.size > 0 ? null : sum2(free.filter(isHeld).map((output2) => output2.valueAtomic));
-    const inputsAtomic = settling.length === 1 ? sum2(only.inputs.map((commitment) => unspent.get(commitment).valueAtomic)) : 0n;
-    const changeAtomic = inputsAtomic - (settling.length === 1 ? only.amountAtomic : 0n);
+    const inputsOf = (payment) => sum2(payment.inputs.map((commitment) => unspent.get(commitment).valueAtomic));
+    const distinctInputs = new Set(settling.flatMap((payment) => payment.inputs)).size === settling.reduce((count2, payment) => count2 + payment.inputs.length, 0);
+    const inputsAtomic = settling.length > 0 && distinctInputs ? sum2(settling.map(inputsOf)) : 0n;
+    const changeAtomic = settling.reduce((most, payment) => {
+      const change = inputsOf(payment) - payment.amountAtomic;
+      return change > most ? change : most;
+    }, 0n);
     const changeFreeAtomic = sendHold === null || sendHold.unpacked.length === 0 ? changeAtomic : changeAtomic > privateSendPending ? changeAtomic - privateSendPending : 0n;
-    const changeOnly = settling.length === 1 && only.join !== true && only.exit !== true && reservedAtomic === 0n && detail.joiningAtomic === "0" && successionMovableAtomic === 0n && sendHeldAtomic !== null && unspentAtomic - sendHeldAtomic === inputsAtomic && inputsAtomic > only.amountAtomic && changeFreeAtomic > 0n;
+    const changeOnly = settling.length > 0 && distinctInputs && (settling.length === 1 || sendHeldAtomic === 0n && privateSendPending === 0n) && settling.every((payment) => payment.join !== true && payment.exit !== true && inputsOf(payment) > payment.amountAtomic) && reservedAtomic === 0n && detail.joiningAtomic === "0" && successionMovableAtomic === 0n && sendHeldAtomic !== null && unspentAtomic - sendHeldAtomic === inputsAtomic && changeFreeAtomic > 0n;
     return report(
       "stale",
       spendable + successionMovableAtomic,
@@ -101803,7 +101825,8 @@ If a payment to this wallet settled, read the chain again with:
       // still settling" while the only answered item was a join).
       settlingRecent ? movedInAtomic === 0n && settling.length > 0 && settling.every((payment) => payment.join) ? "account_join" : "payment_settling" : movedInAtomic > 0n ? "pool_move" : void 0,
       largest,
-      changeOnly ? changeFreeAtomic : void 0
+      changeOnly ? changeFreeAtomic : void 0,
+      settling.length
     );
   }
   return report("current", spendable + successionMovableAtomic, next, void 0, largest);
@@ -101822,7 +101845,7 @@ function combinePoolBalances(partsAtomic, movingAtomic = "0") {
   if (!canonicalAtomic(String(movingAtomic))) return null;
   return (partsAtomic.reduce((total, part) => total + BigInt(part), 0n) + BigInt(movingAtomic)).toString();
 }
-var PAY_ME_WAL_SCHEMA, BALANCE_SNAPSHOT_SCHEMA, BALANCE_SNAPSHOT_FILE, STALE_CAUSES, staleCauseOf, LARGEST_PAYMENTS, largestPaymentOf, CHANGE_SETTLING, changeSettlingOf, changeUpToOf, SPEND_INPUTS, SEND_HOLDS, sendHoldOf, PAYMENT_SETTLING_MS, NO_VALUE_TYPES, PLAN_ONLY_TYPES, UNSENT_SELF_PAY_FIELDS, isUnsentSelfPay, planOnly, SNAPSHOT_KEY_LABEL, SPEND_STATUSES, MAINNET_USDC, SELF_PAY_ORIGIN, POCKET_FILL_RECORD, MERGE_RECORD2, POOL_MOVE_SCHEMA, FLOAT_PAYMENT_SCHEMA, POOL_MOVE_PATH, POOL_SUCCESSION_SCHEMAS, digestKey, canonicalAtomic, SUCCESSION_JOB_SCHEMA, MERGE_PAYMENT_PATH, spendEntry, PROOF_RECORD;
+var PAY_ME_WAL_SCHEMA, BALANCE_SNAPSHOT_SCHEMA, BALANCE_SNAPSHOT_FILE, STALE_CAUSES, staleCauseOf, LARGEST_PAYMENTS, largestPaymentOf, CHANGE_SETTLING, changeSettlingOf, changeUpToOf, CHANGE_COUNT, changeCountOf, SPEND_INPUTS, SEND_HOLDS, sendHoldOf, PAYMENT_SETTLING_MS, NO_VALUE_TYPES, PLAN_ONLY_TYPES, UNSENT_SELF_PAY_FIELDS, isUnsentSelfPay, planOnly, SNAPSHOT_KEY_LABEL, SPEND_STATUSES, MAINNET_USDC, SELF_PAY_ORIGIN, POCKET_FILL_RECORD, MERGE_RECORD2, POOL_MOVE_SCHEMA, FLOAT_PAYMENT_SCHEMA, POOL_MOVE_PATH, POOL_SUCCESSION_SCHEMAS, digestKey, canonicalAtomic, SUCCESSION_JOB_SCHEMA, MERGE_PAYMENT_PATH, spendEntry, PROOF_RECORD;
 var init_balance = __esm({
   "wallet/src/balance/balance.mjs"() {
     "use strict";
@@ -101847,6 +101870,8 @@ var init_balance = __esm({
     CHANGE_SETTLING = /* @__PURE__ */ new WeakMap();
     changeSettlingOf = (report) => report !== null && typeof report === "object" && CHANGE_SETTLING.has(report);
     changeUpToOf = (report) => report !== null && typeof report === "object" ? CHANGE_SETTLING.get(report) : void 0;
+    CHANGE_COUNT = /* @__PURE__ */ new WeakMap();
+    changeCountOf = (report) => report !== null && typeof report === "object" ? CHANGE_COUNT.get(report) : void 0;
     SPEND_INPUTS = /* @__PURE__ */ new WeakMap();
     SEND_HOLDS = /* @__PURE__ */ new WeakMap();
     sendHoldOf = (report) => report !== null && typeof report === "object" ? SEND_HOLDS.get(report) : void 0;
@@ -105596,15 +105621,7 @@ async function waitForNextAnchor(requirement, state, deps, ring) {
   const start = now();
   state.deadline ??= start + ANCHOR_WAIT_CAP_MS;
   const subAnchors = subAnchorPool(start) !== void 0;
-  let anchorAt;
-  let waitMs;
-  if (subAnchors) {
-    waitMs = nextAnchorWaitMs(start, ANCHOR_MARGIN_MS);
-    anchorAt = start + waitMs - SUB_ANCHOR_FINALITY_MS;
-  } else {
-    anchorAt = (epoch + 1) * ANCHOR_EPOCH_MS;
-    waitMs = Math.max(anchorAt - start, 0) + ANCHOR_MARGIN_MS;
-  }
+  const waitMs = subAnchors ? nextAnchorWaitMs(start, ANCHOR_MARGIN_MS) : Math.max((epoch + 1) * ANCHOR_EPOCH_MS - start, 0) + ANCHOR_MARGIN_MS;
   if (start + waitMs > state.deadline) return false;
   const before = subAnchors ? await readRingBefore(ring, start) : void 0;
   if (ringCoversTree(before) && !state.coveredSkip) {
@@ -105613,7 +105630,7 @@ async function waitForNextAnchor(requirement, state, deps, ring) {
     return true;
   }
   try {
-    process.stderr.write(`your change from the last payment (or your newest deposit) is spendable after the next pool anchor at ${new Date(anchorAt).toISOString().slice(11, 19)}Z; waiting ${before ? "at most " : ""}${Math.ceil(waitMs / 1e3)} s (nothing was signed). ` + (subAnchors ? `This pool takes a sub-anchor about every ${subAnchorSeconds(start) ?? 30} s, so the wait is short${before ? " (it ends as soon as that anchor is final)" : ""}. ` : "A payment spends one funded deposit, and its change pays only after the next pool anchor. ") + `To pay several times in a row without this wait, add funds as several deposits: ${commandLine("add-funds --route exchange --amount <usdc> --split <k>")} (${commandLine("help add-funds")})
+    process.stderr.write(`Waiting ${before ? "up to " : "about "}${Math.ceil(waitMs / 1e3)} s for your last payment or deposit to be ready to spend (nothing was signed yet); then it goes on by itself.
 `);
   } catch {
   }
@@ -106928,7 +106945,6 @@ var init_payResource = __esm({
     init_anchorClock();
     init_requestId();
     init_keepAlive();
-    init_commandName();
     fail24 = (reason) => {
       throw new Error(`p03_resource_payment_${reason}`);
     };
@@ -107545,6 +107561,10 @@ function refusalSay(a, tool, again, npmVersion) {
   const seller = tool === "inference_chat" ? "the AI provider" : "the seller";
   const Seller = `${seller[0].toUpperCase()}${seller.slice(1)}`;
   const data = tool === "inference_chat" ? "answer" : "data";
+  if (code2 === "mcp_max_payment_not_usdc") {
+    const cap = usdcText2(a.capAtomic);
+    return `Nothing was paid: ${cap ? `a cap of ${cap} USDC` : "the cap"} is more than your balance. A cap is in USDC, like 0.01 for one cent. Ask again.`;
+  }
   if (a.walletUpdateNeeded === true) {
     const cannot = "this wallet version cannot read the private balance record";
     const update3 = "Restart the wallet on the latest version, then ask again";
@@ -107624,7 +107644,10 @@ function refusalSay(a, tool, again, npmVersion) {
     const more = Number.isSafeInteger(a.retryMaxTokens) ? ` Ask again with a length limit of ${a.retryMaxTokens} tokens.` : " Ask again with a longer length limit.";
     if (a.replayed === true && a.paid === false) return `Nothing was paid, and the stored answer is empty.${more}`;
     if (a.replayed === true) return `Already paid; the stored answer is empty and nothing new was paid.${more}`;
-    return `${paid ? `Paid ${paid} USDC` : "Paid"}, but the model reached the answer's length limit before it answered.${more}`;
+    const price = usdcText2(a.priceAtomic);
+    const fee = usdcText2(a.feeAtomic);
+    const head = `${paid ? `Paid ${paid} USDC${price && positive(fee) ? ` (${price} price + ${fee} Shinjuku fee)` : ""}` : "Paid"}, but`;
+    return firstFit(`${head} the model reached the answer's length limit before it answered.${more}`, `${head} the answer hit its length limit.${more}`);
   }
   if (code2 === "inference_no_provider") {
     return "Nothing was paid: no AI provider can take this wallet's payment for this model right now. Ask for another model, or ask again later.";
@@ -108582,16 +108605,20 @@ function build(a, tool, npmVersion) {
     if (a.replayed === true) return "This request was already paid. Here is the same answer; nothing new was paid.";
     if (tool === "inference_chat" || typeof a.model === "string" && Object.hasOwn(a, "content")) {
       const paid = usdcText2(a.paidAtomic);
-      return `Answered by ${str(a.model).trim() || "the model"}.${paid ? ` Paid ${paid} USDC.` : ""}`;
+      const price2 = usdcText2(a.priceAtomic);
+      const fee2 = usdcText2(a.feeAtomic);
+      const split4 = paid && price2 && positive(fee2) ? ` (${price2} price + ${fee2} Shinjuku fee)` : "";
+      return `Answered by ${str(a.model).trim() || "the model"}.${paid ? ` Paid ${paid} USDC${split4}.` : ""}`;
     }
     const total = usdcText2(a.amountAtomic);
     const price = usdcText2(a.priceAtomic);
     const fee = usdcText2(a.feeAtomic);
     if (!total) return withBalance("Paid. Here is the answer.", a);
-    return withBalance([
-      price && positive(fee) ? `Paid ${total} USDC (${price} price + ${fee} fee). Here is the answer.` : `Paid ${total} USDC. Here is the answer.`,
-      `Paid ${total} USDC. Here is the answer.`
-    ], a);
+    if (price && positive(fee)) {
+      const paid = `Paid ${total} USDC (${price} price + ${fee} Shinjuku fee).`;
+      return withBalance([`${paid} Here is the answer.`, paid], a);
+    }
+    return withBalance(`Paid ${total} USDC. Here is the answer.`, a);
   }
   if (a.paid === false && !Object.hasOwn(a, "stage") && (tool === void 0 || tool === "x402_pay")) {
     const status = Number(a.status);
@@ -111304,6 +111331,7 @@ function partsOf(report, store, snapshot) {
     changeSettling,
     changeReadyInSeconds: changeSettling ? changeReadyInSeconds() : null,
     changeUpToAtomic: changeSettling ? changeUpToOf(report) ?? null : null,
+    ...changeSettling && Number.isSafeInteger(changeCountOf(report)) ? { changeCount: changeCountOf(report) } : {},
     refundsInFlightAtomic: refunds.proven.toString(),
     refundsNotCertainAtomic: refunds.notCertain.toString(),
     refundsInFlight: refunds.provenFor,
@@ -111558,10 +111586,9 @@ async function exitWhenAnchored(run4, { now = Date.now, sleep: sleep4 = (ms) =>
       const start = now();
       const subAnchors = subAnchorPool(start) !== void 0;
       const waitMs = nextAnchorWaitMs(start, EPOCH_MARGIN_MS);
-      const anchorAt = subAnchors ? start + waitMs - SUB_ANCHOR_FINALITY_MS : start - start % EPOCH_MS2 + EPOCH_MS2;
       if (start + waitMs > deadline) throw error;
       const before = subAnchors ? await readRingBefore(ring, start) : void 0;
-      progress(`your self-payment's note is spendable after the next pool anchor at ${new Date(anchorAt).toISOString().slice(11, 19)}Z; waiting ${Math.ceil(waitMs / 1e3)} s (nothing was signed for the exit): ${anchorWaitText(start)}; the exit then runs by itself`);
+      progress(`Waiting about ${Math.ceil(waitMs / 1e3)} s for your balance to be ready to send (nothing was signed yet); then the send goes on by itself`);
       markPhase("anchor-wait-start");
       await sleepForAnchor(waitMs, { ring, before, now, sleep: sleep4 });
       markPhase("anchor-wait-done");
@@ -124349,6 +124376,7 @@ async function tidyMove({ plan, steps, now }) {
         state: "signed",
         account: account.address,
         signature: built.signature,
+        ...typeof account.lamports === "bigint" ? { rentLamports: account.lamports.toString() } : {},
         txBase64: Buffer.from(built.raw).toString("base64"),
         lastValidBlockHeight: Number.isSafeInteger(built.lastValidBlockHeight) ? built.lastValidBlockHeight : null,
         signedAt: at()
@@ -124577,9 +124605,10 @@ function transferLeftoverView(plan) {
   const tidy = !plan.tidy || plan.tidy.state === "pending" ? { ...plan.tidy ?? {}, state: "kept", reason: TIDY_LATE_REASON } : plan.tidy;
   const state = tidy.state === "signed" ? "closing" : tidy.state;
   const lamports = /^\d+$/.test(String(tidy.solLamports ?? "")) ? BigInt(tidy.solLamports) : null;
+  const rent = /^\d+$/.test(String(tidy.rentLamports ?? "")) ? ` (${solText(BigInt(tidy.rentLamports))} SOL)` : "";
   const tokenAccount2 = {
-    closing: "the close of the sold token's empty holder on the own key, sent before the send started, is not final yet; its rent (about 0.00204 SOL) comes back to the key when it lands",
-    closed: "the wallet closed the sold token's empty holder on its own key, so its rent (about 0.00204 SOL) came back to the key",
+    closing: `the close of the sold token's empty holder on the own key, sent before the send started, is not final yet; its rent${rent} comes back to the key when it lands`,
+    closed: `the wallet closed the sold token's empty holder on its own key, so its rent${rent} came back to the key`,
     gone: "the own key holds none of the sold token and has no holder for it left",
     kept: `the sold token's holder on the own key stays open: ${tidy.reason ?? "it was not empty"}`,
     failed: `the sold token's empty holder on the own key stays open: ${tidy.reason ?? "its close did not land"}`
@@ -124866,7 +124895,7 @@ async function readSoldAccount({ connection, owner, mint, commitment = "finalize
     const { programId, address: address4 } = candidates[index];
     if (!info.owner.equals(programId)) continue;
     const account = unpackAccount(address4, info, programId);
-    const view2 = { address: address4.toBase58(), programId: programId.toBase58(), amountAtomic: account.amount };
+    const view2 = { address: address4.toBase58(), programId: programId.toBase58(), amountAtomic: account.amount, lamports: BigInt(info.lamports) };
     if (!account.mint.equals(mintKey) || !account.owner.equals(ownerKey)) return { ...view2, closeable: false, why: "the account is not the own key's account of this token" };
     if (account.isNative) return { ...view2, closeable: false, why: "the account is a wrapped SOL account" };
     if (account.closeAuthority && !account.closeAuthority.equals(ownerKey)) return { ...view2, closeable: false, why: "another key may close this account, not the own key" };
@@ -128333,6 +128362,29 @@ function createWalletTools({
       return null;
     }
   };
+  const maxPaymentNotUsdc = (args, atomic4, tool) => {
+    const raw = args?.max_payment;
+    const text3 = typeof raw === "number" && Number.isSafeInteger(raw) ? String(raw) : typeof raw === "string" ? raw.trim() : "";
+    if (atomic4 === void 0 || !/^[0-9]{1,31}$/.test(text3) || BigInt(text3) < MAX_PAYMENT_ATOMIC_LEAST) return void 0;
+    let whole;
+    try {
+      const parts = balanceNow(session.openStore(), { programId: session.programId });
+      if (!ATOMIC_TEXT.test(String(parts?.totalAtomic ?? ""))) return void 0;
+      const atomicOf = (value2) => ATOMIC_TEXT.test(String(value2 ?? "")) ? BigInt(value2) : 0n;
+      whole = BigInt(parts.totalAtomic) + atomicOf(parts.refundsNotCertainAtomic) + (parts.report?.detail?.pendingDeposits ?? []).reduce((sum2, deposit) => sum2 + atomicOf(deposit?.amountAtomic), 0n);
+    } catch {
+      return void 0;
+    }
+    if (BigInt(atomic4) <= whole) return void 0;
+    const cap = usdcText3(atomic4);
+    const meant = usdcText3(BigInt(text3));
+    return [
+      "mcp_max_payment_not_usdc",
+      `max_payment "${text3}" is ${cap} USDC (max_payment is in USDC, not atomic units), more than the wallet's whole balance of ${usdcText3(whole)} USDC; nothing was requested or paid`,
+      `max_payment is in USDC, like "0.01" for one cent; "${text3}" in atomic units is max_payment "${meant}". Call ${tool} again now with max_payment in USDC (the amount the user named), or leave max_payment out`,
+      { paid: false, capAtomic: String(atomic4), wholeBalanceAtomic: whole.toString() }
+    ];
+  };
   const savedBalanceShort = (store, neededAtomic) => {
     if (!store) return void 0;
     try {
@@ -128470,9 +128522,9 @@ function createWalletTools({
   const doneInMinutesFields = (joins, startAtMs) => {
     if (!Number.isSafeInteger(joins) || joins < 1) return {};
     const left = Number.isSafeInteger(startAtMs) ? Math.max(0, startAtMs - Date.now()) : void 0;
-    const likely = (left ?? joinSoonMaxMs / 2) + joins * JOIN_TIME_MS.joinLikely + JOIN_TIME_MS.sendLikely;
+    const least = (left ?? 0) + joins * JOIN_TIME_MS.joinLikely + JOIN_TIME_MS.sendLikely;
     const most = (left ?? joinSoonMaxMs) + joins * JOIN_TIME_MS.joinMost + JOIN_TIME_MS.sendMost;
-    const low = Math.max(1, Math.round(likely / 6e4));
+    const low = Math.max(1, Math.floor(least / 6e4));
     return { doneInMinutesLow: low, doneInMinutesHigh: Math.max(low + 1, Math.ceil(most / 6e4)) };
   };
   const doneInWords = ({ doneInMinutesLow: low, doneInMinutesHigh: high } = {}) => Number.isSafeInteger(low) && Number.isSafeInteger(high) ? `about ${low} to ${high} minutes` : "";
@@ -129074,7 +129126,7 @@ function createWalletTools({
         method: { type: "string", enum: ["GET", "POST"], description: "HTTP method; default GET." },
         headers: { type: "object", additionalProperties: { type: "string" }, description: "Extra request headers (never payment or transport headers)." },
         body: { type: "string", description: "Request body text (POST only)." },
-        max_payment: { type: "string", description: 'Optional: the most this call may pay, in USDC, like "0.05"; at most the spending limit.' },
+        max_payment: { type: "string", description: 'Optional: the most this call may pay, in USDC, like "0.01" (not atomic units); at most the spending limit.' },
         max_payment_atomic: { type: "string", pattern: "^[1-9][0-9]*$", description: "The same in atomic units (1000000 = 1 USDC). Give max_payment or max_payment_atomic, not both with different values." },
         request_id: { type: "string", pattern: "^[A-Za-z0-9._:-]{1,128}$", description: "Optional. Leave it out for a new payment (the answer names the id it made). Pass the request_id of an earlier answer only to resume that payment; it never pays twice." }
       },
@@ -129091,6 +129143,8 @@ function createWalletTools({
       if (request.refusal) return refuse12(...request.refusal);
       const capArg = payCapArgument(args);
       if (capArg.refusal) return refuse12(...capArg.refusal);
+      const notUsdc = maxPaymentNotUsdc(args, capArg.atomic, "x402_pay");
+      if (notUsdc) return refuse12(...notUsdc);
       const argument2 = capArg.atomic;
       const given = args.request_id !== void 0 && args.request_id !== null && args._autoRequestId !== true;
       const requestId = args.request_id !== void 0 && args.request_id !== null ? args.request_id : `mcp-${randomBytes23(8).toString("hex")}`;
@@ -129638,7 +129692,7 @@ ${canonical5}`;
         ...floatPaid ? { via: "shinjuku", shinjukuTransaction } : {},
         ...balanceAnswer(one),
         ...notices,
-        next: (unpaid ? "nothing was paid: this request id's payment never landed (the pool's public history proves it), and the answer it got came back again; nothing new was paid. Tell the user nothing was paid for it" : receipt.replayed === true ? "this request id was already paid: the stored receipt came back and nothing new was paid" : floatPaid ? "paid through Shinjuku (privately: the chain shows Shinjuku paying the seller, not this wallet); tell the user the price (priceAtomic), the fee (feeAtomic), the total (amountAtomic), and the transaction (the seller's settle transaction; null when the seller returned none)" + (shinjukuTransaction ? ". shinjukuTransaction is this wallet's private payment to Shinjuku" : ". shinjukuTransaction (this wallet's private payment to Shinjuku) is not recorded yet; wallet_receipts shows it once it settles") + ". wallet_balance shows the new balance" : "paid; tell the user what was paid (amountAtomic, transaction). wallet_receipts lists this payment, wallet_balance shows the new balance") + (notices.refundNotices ? ". Tell the user each refundNotices line" : "")
+        next: (unpaid ? "nothing was paid: this request id's payment never landed (the pool's public history proves it), and the answer it got came back again; nothing new was paid. Tell the user nothing was paid for it" : receipt.replayed === true ? "this request id was already paid: the stored receipt came back and nothing new was paid" : floatPaid ? "paid through Shinjuku (privately: the chain shows Shinjuku paying the seller, not this wallet); tell the user the price (priceAtomic), the Shinjuku fee (feeAtomic; never a network fee), the total (amountAtomic), and the transaction (the seller's settle transaction; null when the seller returned none)" + (shinjukuTransaction ? ". shinjukuTransaction is this wallet's private payment to Shinjuku" : ". shinjukuTransaction (this wallet's private payment to Shinjuku) is not recorded yet; wallet_receipts shows it once it settles") + ". wallet_balance shows the new balance" : "paid; tell the user what was paid (amountAtomic, transaction). wallet_receipts lists this payment, wallet_balance shows the new balance") + (notices.refundNotices ? ". Tell the user each refundNotices line" : "")
       }, "x402_pay")
     }));
   }
@@ -131755,7 +131809,7 @@ ${canonical5}`;
         }
       }
       let payments = kind === "moves" ? [] : paymentRows(store, names, refunds.states);
-      const missing = (row) => row.state === void 0 && row.privateTransaction === null && (row.scheme === "shielded-exact" || Boolean(row.facilitator));
+      const missing = (row) => row.state !== "never_landed" && row.state !== "cancelled" && row.privateTransaction === null && (row.scheme === "shielded-exact" || Boolean(row.facilitator));
       if (payments.some(missing) && [...payments].sort((left, right) => right.at - left.at).slice(0, limit).some(missing)) {
         try {
           if (latestPrewarmedWalletHistory() === void 0 && paysInFlight === 0 && !historyPrewarmRunning()) warmPaymentHistory(session);
@@ -134679,7 +134733,7 @@ ${canonical5}`;
   const unshield = {
     name: "wallet_unshield",
     title: "Send USDC privately",
-    description: `Use this when the user says "send 2 USDC to <address>" or "withdraw to my wallet" (leave \`to\` out for the user's own wallet when one is set): it sends amount (USDC, like "2"; or amount_atomic) from the PRIVATE balance as plain USDC to \`to\`, a public Solana address (it receives the USDC at that address). BEFORE you call it to send all of the balance when wallet_balance showed balanceParts above 1, write to the user that the wallet first gets the balance ready to send (do not tell the user how the wallet stores the balance; some apps show nothing until this call ends). Privately: the chain shows the pool paying the address, not which wallet paid. The wallet's own key (ownAddress in wallet_balance) is this wallet's public address: it holds the public USDC, wallet_shield deposits from it, and wallet_transfer_token sells from it. So it is refused as \`to\`: an exit there would show on chain that the private balance belongs to this wallet. This holds whether or not that key ever deposited: wallet_add_funds deposits come from one-time addresses, not from this key, so never tell the user the deposits came from it. Shinjuku pays every network fee; no SOL is needed. The user's saved own addresses (setup or this app's wallet entry) send at once. Any other address is sent only after the user confirms it in this app (a confirmation dialog); a client that cannot ask is refused (mcp_unshield_to_not_allowed) and a decline sends nothing (mcp_unshield_declined). \`to\` must already be able to receive USDC: an address that cannot is refused before any dialog (mcp_unshield_to_invalid). It runs in steps and may wait for the pool's next anchor: the call answers within about 20 s with stage (confirming, queued, refreshing, self-pay = preparing, exit = sending, done; joining = the wallet first gets the balance ready to send, then sends; each call goes on with it (joinSteps: its steps, one after another; doneInMinutesLow to doneInMinutesHigh: the time to say), ok: true); call wallet_unshield again with the SAME request_id, amount, and to for the status (each call answers within about 20 s, at once when the send ends; a confirmation dialog the user answers may take longer). When the wallet must first get the balance ready to send, the FIRST call answers at once with stage joining and joinTellFirst: true; write its say to the user, then call again with the same request_id at once. One exception: for a send whose balance must first be made ready, when this app sends a progress token with the call, that next call gets the balance ready and then sends, with a progress line every ${JOIN_STEP_MS / 1e3} s ("getting your balance ready to send"; some apps show none of them, so the line is said before the call, as above). It answers when the send is done, or after about ${joinAnswerSeconds(JOIN_CALL_MAX_MS)} s with how far it got (joinsDone; sendState sending: the USDC is leaving, never say nothing moved); then call again with the same request_id. Without a progress token it answers within about 20 s with stage joining: call again until it sends. The same request_id never sends twice, also after a restart. request_id is optional: without it the answer names the id it made, and the same call again within 10 minutes after it ends reads that same send. When it lands, the wallet writes an encrypted backup (backupPath). x402_pay calls wait while it runs. An optional limit the user sets (the unshield limit) may bound each call and what this wallet sends in any 24 hours, from every app that runs it (mcp_unshield_cap_exceeded: tell the user). Other refusals: mcp_argument_invalid, mcp_request_id_reused, mcp_unshield_to_invalid, wallet_locked, mcp_tool_disabled, mcp_unshield_failed, and the unshield's own p03_* codes. A send is one payment to \`to\`.`,
+    description: `Use this when the user says "send 2 USDC to <address>" or "withdraw to my wallet" (for "my wallet" leave \`to\` out: it uses the address saved at setup, or says how to set one; never ask the user first): it sends amount (USDC, like "2"; or amount_atomic) from the PRIVATE balance as plain USDC to \`to\`, a public Solana address (it receives the USDC at that address). BEFORE you call it to send all of the balance when wallet_balance showed balanceParts above 1, write to the user that the wallet first gets the balance ready to send (do not tell the user how the wallet stores the balance; some apps show nothing until this call ends). Privately: the chain shows the pool paying the address, not which wallet paid. The wallet's own key (ownAddress in wallet_balance) is this wallet's public address: it holds the public USDC, wallet_shield deposits from it, and wallet_transfer_token sells from it. So it is refused as \`to\`: an exit there would show on chain that the private balance belongs to this wallet. This holds whether or not that key ever deposited: wallet_add_funds deposits come from one-time addresses, not from this key, so never tell the user the deposits came from it. Shinjuku pays every network fee; no SOL is needed. The user's saved own addresses (setup or this app's wallet entry) send at once. Any other address is sent only after the user confirms it in this app (a confirmation dialog); a client that cannot ask is refused (mcp_unshield_to_not_allowed) and a decline sends nothing (mcp_unshield_declined). \`to\` must already be able to receive USDC: an address that cannot is refused before any dialog (mcp_unshield_to_invalid). It runs in steps and may wait for the pool's next anchor: the call answers within about 20 s with stage (confirming, queued, refreshing, self-pay = preparing, exit = sending, done; joining = the wallet first gets the balance ready to send, then sends; each call goes on with it (joinSteps: its steps, one after another; doneInMinutesLow to doneInMinutesHigh: the time to say), ok: true); call wallet_unshield again with the SAME request_id, amount, and to for the status (each call answers within about 20 s, at once when the send ends; a confirmation dialog the user answers may take longer). When the wallet must first get the balance ready to send, the FIRST call answers at once with stage joining and joinTellFirst: true; write its say to the user, then call again with the same request_id at once. One exception: for a send whose balance must first be made ready, when this app sends a progress token with the call, that next call gets the balance ready and then sends, with a progress line every ${JOIN_STEP_MS / 1e3} s ("getting your balance ready to send"; some apps show none of them, so the line is said before the call, as above). It answers when the send is done, or after about ${joinAnswerSeconds(JOIN_CALL_MAX_MS)} s with how far it got (joinsDone; sendState sending: the USDC is leaving, never say nothing moved); then call again with the same request_id. Without a progress token it answers within about 20 s with stage joining: call again until it sends. The same request_id never sends twice, also after a restart. request_id is optional: without it the answer names the id it made, and the same call again within 10 minutes after it ends reads that same send. When it lands, the wallet writes an encrypted backup (backupPath). x402_pay calls wait while it runs. An optional limit the user sets (the unshield limit) may bound each call and what this wallet sends in any 24 hours, from every app that runs it (mcp_unshield_cap_exceeded: tell the user). Other refusals: mcp_argument_invalid, mcp_request_id_reused, mcp_unshield_to_invalid, wallet_locked, mcp_tool_disabled, mcp_unshield_failed, and the unshield's own p03_* codes. A send is one payment to \`to\`. ${HOST_BLOCKED_LINE}`,
     inputSchema: {
       type: "object",
       properties: {
@@ -136389,7 +136443,7 @@ ${canonical5}`;
         prompt: { type: "string", description: "One user message (instead of messages)." },
         max_tokens: { type: "integer", minimum: 1, description: `Optional, default 4096 (512 for claude-opus-5), at least ${INFERENCE_MIN_MAX_TOKENS}. The answer's length limit, in tokens; the call pays for all of them up front. A reasoning model spends its first tokens thinking, so fewer can end with no answer.` },
         temperature: { type: "number", minimum: 0, maximum: 2, description: "Sampling temperature; leave it out for the model's default." },
-        max_payment: { type: "string", description: 'Optional: the most this call may pay, in USDC, like "0.05"; at most the spending limit.' },
+        max_payment: { type: "string", description: 'Optional: the most this call may pay, in USDC, like "0.01" (not atomic units); at most the spending limit.' },
         max_payment_atomic: { type: "string", pattern: "^[1-9][0-9]*$", description: "The most this call may pay, in atomic units; at most the spending limit." },
         request_id: { type: "string", pattern: "^[A-Za-z0-9._:-]{1,128}$", description: "Optional. Leave it out for a new question (the answer names the id it made). Pass the request_id of an earlier answer only to resume that call; it never pays twice." }
       },
@@ -136433,6 +136487,8 @@ ${canonical5}`;
       }
       const maxPayment = usdcAmountArg(args, { usdc: "max_payment", atomic: "max_payment_atomic", required: false });
       if (!maxPayment.ok) return refuse12("inference_max_payment_invalid", maxPayment.detail.replace(/nothing was moved/, "nothing was paid"), maxPayment.next);
+      const notUsdc = maxPaymentNotUsdc(args, maxPayment.atomic, "inference_chat");
+      if (notUsdc) return refuse12(...notUsdc);
       const messages = typeof args.prompt === "string" ? [{ role: "user", content: args.prompt }] : args.messages;
       const asked = { model: args.model, messages, maxTokens: args.max_tokens };
       let ceiling;
@@ -137633,7 +137689,7 @@ function createSetupTools({
     doneTool: sayOnRefusal(doneTool)
   };
 }
-var import_web3133, shownCaps, RELEASE_RETRY_MS, STAGE_WORDS, stageWords, INTERNAL_BALANCE_DETAIL, shownBreakdown, sessionLeftShown, TOKEN_UNIT_TOOLS, RESOURCE_PAYMENT_WAL_PREFIX2, POOL_LAYOUT_CODE, POOL_LAYOUT_UPDATE, USEPOD_VIA_INFERENCE_CHAT, SEND_RUNS_ON, DEPOSIT_RUNS_ON, CLI_FUNDS_PLAN_PREFIX, CLI_FUNDS_SCHEMA, SELF_PAY_ORIGIN3, REQUEST_ID4, POSITIVE_ATOMIC6, PRIVATE_HOST3, FORBIDDEN_HEADERS3, MAX_BODY_BYTES2, PREVIEW_TIMEOUT_MS, PREVIEW_SELLER_READ_MS, CALL_BUDGET_MS, budgetLeft, PAY_ANSWER_MARGIN_MS, MONEY_FIRST_ANSWER_MS, BALANCE_AFTER_LANDING_MS, JOIN_CALL_MAX_MS, JOIN_CALL_ANSWER_MARGIN_S, PAY_AFTER_JOIN_MS, joinAnswerSeconds, JOIN_TIME_MS, JOIN_NUDGE_QUIET_MS, JOIN_STEP_MS, sleep2, PROGRESS_EVERY_MS2, READ_BUDGET_MS, UNPAID_TOR_TRY_MS, UNPAID_CLEAR_MS, READ_BUDGET_TOOLS, FLOAT_BUSY_CODES, RETRY_MARGIN_MS, ASK_PAY_CODES, runningNpmVersion, terminalCommand2, capPlaceWords, noLimitSetLine, CAP_NAMES, capName, entryPlaces, capRaiseText, runningLimits, payCapFlag, noPriceFits, cheaperText, limitNext, overLimitStep, SAFE_TEXT, causesLog, MCP_TOOL_ALIASES, POOL_SWITCH_WHY, POOL_SWITCH_NEXT, SWITCH_STATES, quietSwitch, switchKey, ATOMIC_TEXT, movedTo, FLOAT_ID, ANSWERED_EXIT_RETRY_MS, ANSWERED_EXIT_UNCONFIRMED_MS, ANSWERED_EXIT_RETRY_WINDOW_MS, ANSWERED_EXIT_CLOSED, switchAmount, switchEta, switchRows, OWNER_CAP_CODES, JOIN_END_MCP, JOIN_END_TERMINAL_LIBRARY, JOIN_RETRY_BACKOFF_MS, WALLET_CAP_FIX, ENTRY_CAP_CODES, MCP_CAP_FIX, capFix, ownerOnlyNext, mcpNext, CONFIDENTIAL_RETIRED, json3, answerResult, discoverTool, LAUNCH_CAP_CODES, dayCapKind, refuse12, newRequestIdFor, payCapName, publicOffer, FLOAT_PAID_CODES, FLOAT_NOT_CERTAIN_CODES, FLOAT_PRIVATE_LEG, SELLER_ONLY_HERE, outsideWalletRule, proxyStartStep, MONEY_ID2, toRecordId, linkKindOf, moneyId, REFUSED_CODES, refusedCodeOf, PLAIN_REASONS, insufficientCause, INSUFFICIENT_REASONS, reasonOf, plainReason, KEPT_SEND_TRIES, shownId, isSplitSend, PROMISED_NEXT, partFailReason, sendAnswerOf, PUBLIC_READ_TIMEOUT_MS, RECIPIENT_CHECK_TIMEOUT_MS, withTimeout, ownKey, readFailure, OWN_KEY_TOKENS_MAX, tokenAmountText, elsewhereId, AGENT_ID_SCHEMA, agentIdName, minutesText2, ageWords2, DEPOSIT_SENT_STATES, depositLanded, usdcText3, walkWalletHistory, REFRESH_LEASE_WALK_MS, HOME_MARKS_SETTLED_MS2, AUTO_BACKUPS_KEPT, AUTO_BACKUP_NAME, AUTO_BACKUP_VERIFIED, FRONTED_SETTLE_MARGIN_SLOTS, UNSHIELD_WINDOW_YIELD_MS, NOT_FINAL_YET, FINISH_FINALITY_WAIT_MS, FINISH_FINALITY_WAITS, FINISH_FINALITY_RECENT_MS, walkStillCurrent, DIRECT_EXIT_GONE, BALANCE_REFRESH_WAIT_MS, BALANCE_REFRESH_GRACE_MS, BALANCE_REFRESH_LONG_MS, INBOUND_REFRESH_AGE_MS, changeFields, balanceAnswer, CAP_BALANCE_WAIT_MS, CAP_BALANCE_RETRY_MS, REFRESH_RETRY_MS, FINALITY_POLL_MS, FINALITY_WAIT_MS, FINALITY_REFRESH_LIMIT_MS, POOL_WATCH_MS, POOL_WATCH_POLL_MS, EARLY_BALANCE_DELAY_MS, FINALITY_SETTLE_WINDOW_SLOTS, PUBLIC_READ_ANSWER_MS, LINK_READ_ANSWER_MS, OWN_READS_AHEAD_MS, OWN_PUBLIC_KNOWN_MS, FLOAT_CORRECT_WAIT_MS, SWITCH_WAIT_MS, UNSHIELD_TO_NO_USDC_DETAIL, UNSHIELD_TO_INVALID_NEXT, INFERENCE_MIN_MAX_TOKENS, ELICIT_TIMEOUT_MS, ELICIT_UNSHOWN_MS, elicitUnshown, POLL_SECONDS2, TRANSFER_CHANGE_READ_MS, TEMP_CLEAN_DELAY_MS, KEPT_ON_DISK, MAX_SHIELDED_BALANCE_ATOMIC, receiveGenerator, MCP_TOOL_NAMES, MCP_HIDDEN_TOOL_NAMES, setupTerminalNext, SETUP_RUNNING_SAY, ACCEPTED_NEXT, SETUP_RUNNING_NEXT, SETUP_ANSWER_WAIT_MS, SETUP_CONFIRMING_SAY, SETUP_CONFIRMING_NEXT, OWN_ADDRESS_QUESTION, OWN_ADDRESS_WHERE, OWN_ADDRESS_INVALID, PRIVATE_INFERENCE_WHY, RESTART_STEPS, TOR_BROWSER_PORT, SETUP_TOR_TITLE, SETUP_TOR_WHY;
+var import_web3133, shownCaps, RELEASE_RETRY_MS, STAGE_WORDS, stageWords, INTERNAL_BALANCE_DETAIL, shownBreakdown, sessionLeftShown, TOKEN_UNIT_TOOLS, RESOURCE_PAYMENT_WAL_PREFIX2, POOL_LAYOUT_CODE, POOL_LAYOUT_UPDATE, USEPOD_VIA_INFERENCE_CHAT, SEND_RUNS_ON, DEPOSIT_RUNS_ON, CLI_FUNDS_PLAN_PREFIX, CLI_FUNDS_SCHEMA, SELF_PAY_ORIGIN3, REQUEST_ID4, POSITIVE_ATOMIC6, PRIVATE_HOST3, FORBIDDEN_HEADERS3, MAX_BODY_BYTES2, PREVIEW_TIMEOUT_MS, PREVIEW_SELLER_READ_MS, CALL_BUDGET_MS, budgetLeft, PAY_ANSWER_MARGIN_MS, MONEY_FIRST_ANSWER_MS, BALANCE_AFTER_LANDING_MS, JOIN_CALL_MAX_MS, JOIN_CALL_ANSWER_MARGIN_S, PAY_AFTER_JOIN_MS, joinAnswerSeconds, JOIN_TIME_MS, JOIN_NUDGE_QUIET_MS, JOIN_STEP_MS, sleep2, PROGRESS_EVERY_MS2, READ_BUDGET_MS, UNPAID_TOR_TRY_MS, UNPAID_CLEAR_MS, READ_BUDGET_TOOLS, FLOAT_BUSY_CODES, RETRY_MARGIN_MS, ASK_PAY_CODES, runningNpmVersion, terminalCommand2, capPlaceWords, noLimitSetLine, CAP_NAMES, capName, entryPlaces, capRaiseText, runningLimits, payCapFlag, noPriceFits, cheaperText, limitNext, overLimitStep, SAFE_TEXT, causesLog, MCP_TOOL_ALIASES, POOL_SWITCH_WHY, POOL_SWITCH_NEXT, SWITCH_STATES, quietSwitch, switchKey, ATOMIC_TEXT, MAX_PAYMENT_ATOMIC_LEAST, movedTo, FLOAT_ID, ANSWERED_EXIT_RETRY_MS, ANSWERED_EXIT_UNCONFIRMED_MS, ANSWERED_EXIT_RETRY_WINDOW_MS, ANSWERED_EXIT_CLOSED, switchAmount, switchEta, switchRows, OWNER_CAP_CODES, JOIN_END_MCP, JOIN_END_TERMINAL_LIBRARY, JOIN_RETRY_BACKOFF_MS, WALLET_CAP_FIX, ENTRY_CAP_CODES, MCP_CAP_FIX, capFix, ownerOnlyNext, mcpNext, CONFIDENTIAL_RETIRED, json3, answerResult, discoverTool, LAUNCH_CAP_CODES, dayCapKind, refuse12, newRequestIdFor, payCapName, publicOffer, FLOAT_PAID_CODES, FLOAT_NOT_CERTAIN_CODES, FLOAT_PRIVATE_LEG, SELLER_ONLY_HERE, outsideWalletRule, proxyStartStep, MONEY_ID2, toRecordId, linkKindOf, moneyId, REFUSED_CODES, refusedCodeOf, PLAIN_REASONS, insufficientCause, INSUFFICIENT_REASONS, reasonOf, plainReason, KEPT_SEND_TRIES, shownId, isSplitSend, PROMISED_NEXT, partFailReason, sendAnswerOf, PUBLIC_READ_TIMEOUT_MS, RECIPIENT_CHECK_TIMEOUT_MS, withTimeout, ownKey, readFailure, OWN_KEY_TOKENS_MAX, tokenAmountText, elsewhereId, AGENT_ID_SCHEMA, agentIdName, minutesText2, ageWords2, DEPOSIT_SENT_STATES, depositLanded, usdcText3, walkWalletHistory, REFRESH_LEASE_WALK_MS, HOME_MARKS_SETTLED_MS2, AUTO_BACKUPS_KEPT, AUTO_BACKUP_NAME, AUTO_BACKUP_VERIFIED, FRONTED_SETTLE_MARGIN_SLOTS, UNSHIELD_WINDOW_YIELD_MS, NOT_FINAL_YET, FINISH_FINALITY_WAIT_MS, FINISH_FINALITY_WAITS, FINISH_FINALITY_RECENT_MS, walkStillCurrent, DIRECT_EXIT_GONE, BALANCE_REFRESH_WAIT_MS, BALANCE_REFRESH_GRACE_MS, BALANCE_REFRESH_LONG_MS, INBOUND_REFRESH_AGE_MS, changeFields, balanceAnswer, CAP_BALANCE_WAIT_MS, CAP_BALANCE_RETRY_MS, REFRESH_RETRY_MS, FINALITY_POLL_MS, FINALITY_WAIT_MS, FINALITY_REFRESH_LIMIT_MS, POOL_WATCH_MS, POOL_WATCH_POLL_MS, EARLY_BALANCE_DELAY_MS, FINALITY_SETTLE_WINDOW_SLOTS, PUBLIC_READ_ANSWER_MS, LINK_READ_ANSWER_MS, OWN_READS_AHEAD_MS, OWN_PUBLIC_KNOWN_MS, FLOAT_CORRECT_WAIT_MS, SWITCH_WAIT_MS, UNSHIELD_TO_NO_USDC_DETAIL, UNSHIELD_TO_INVALID_NEXT, INFERENCE_MIN_MAX_TOKENS, ELICIT_TIMEOUT_MS, ELICIT_UNSHOWN_MS, elicitUnshown, POLL_SECONDS2, TRANSFER_CHANGE_READ_MS, TEMP_CLEAN_DELAY_MS, KEPT_ON_DISK, MAX_SHIELDED_BALANCE_ATOMIC, receiveGenerator, MCP_TOOL_NAMES, MCP_HIDDEN_TOOL_NAMES, setupTerminalNext, SETUP_RUNNING_SAY, ACCEPTED_NEXT, SETUP_RUNNING_NEXT, SETUP_ANSWER_WAIT_MS, SETUP_CONFIRMING_SAY, SETUP_CONFIRMING_NEXT, OWN_ADDRESS_QUESTION, OWN_ADDRESS_WHERE, OWN_ADDRESS_INVALID, PRIVATE_INFERENCE_WHY, RESTART_STEPS, HOST_BLOCKED_LINE, TOR_BROWSER_PORT, SETUP_TOR_TITLE, SETUP_TOR_WHY;
 var init_tools = __esm({
   "wallet/src/mcp/tools.mjs"() {
     "use strict";
@@ -137826,6 +137882,7 @@ var init_tools = __esm({
     quietSwitch = (item) => item.state === "done" && item.tellUser !== true;
     switchKey = (item) => `${item.from}:${item.state}`;
     ATOMIC_TEXT = /^[0-9]{1,31}$/;
+    MAX_PAYMENT_ATOMIC_LEAST = 1000n;
     movedTo = (response, requested) => {
       if (![301, 302, 303, 307, 308].includes(response.status)) return void 0;
       const location = response.headers.get("location");
@@ -138112,7 +138169,9 @@ var init_tools = __esm({
       return {
         changeSettling: true,
         ...Number.isSafeInteger(one.changeReadyInSeconds) ? { changeReadyInSeconds: one.changeReadyInSeconds } : {},
-        ...ATOMIC_TEXT.test(shown) && ATOMIC_TEXT.test(upTo) && BigInt(upTo) < BigInt(shown) ? { changeUpToAtomic: upTo } : {}
+        ...ATOMIC_TEXT.test(shown) && ATOMIC_TEXT.test(upTo) && BigInt(upTo) < BigInt(shown) ? { changeUpToAtomic: upTo } : {},
+        // UX129-9: the value is the changes of this many recent payments (2 or more); changeUpToAtomic is then the largest.
+        ...Number.isSafeInteger(one.changeCount) && one.changeCount >= 2 ? { changeCount: one.changeCount } : {}
       };
     };
     balanceAnswer = (one, { shown = true } = {}) => one ? {
@@ -138193,6 +138252,7 @@ var init_tools = __esm({
     OWN_ADDRESS_INVALID = "That is not a Solana address (32 to 44 letters and digits, as your wallet app shows it)";
     PRIVATE_INFERENCE_WHY = "Your agent then buys AI answers from an AI provider, paid from your private balance over Tor; the AI provider and the company that runs the model see the prompt, not who paid.";
     RESTART_STEPS = `In Claude Code: type /mcp, pick ${MCP_SERVER_NAME}, and choose Reconnect. In Claude Desktop: quit it and open it again. In another app: restart it`;
+    HOST_BLOCKED_LINE = "If this app blocks a wallet tool (Claude Code's auto mode can), say nothing moved; in Claude Code, shift+tab turns auto mode off, then ask again. Never suggest a rule that lets a payment or send run with no question, or another way around the block.";
     TOR_BROWSER_PORT = "http://127.0.0.1:9150";
     SETUP_TOR_TITLE = "Use Tor?";
     SETUP_TOR_WHY = "It hides your IP address from the payment service and sellers.";
@@ -139592,7 +139652,7 @@ async function runSetupModeServer({
   }
   return { closed: ended };
 }
-var import_web3134, SUPPORTED_PROTOCOL_VERSIONS, MAX_LINE_BYTES, POSITIVE_ATOMIC7, INSTRUCTIONS, MCP_LOG_LEVELS, POOL_SWITCH_LOG_LEVEL, validId, PRODUCT_NAME, listedTitle, BUNDLED_SOURCE_DIR, SHA256_HEX, UPDATE_NOTICE_TOOLS, UPDATE_NOTICE_MAX_TEXT, NPM_VERSION2, GIT_COMMIT, ownWalletVersion, mcpServerVersion, UPDATE_NOTICE_TEXT, updateNoticeLine, commandUpdateField, LAUNCH_NOTICE_TOOLS, withLaunchLine, capRequired, setupInvalid, TOOL_ROOTS_WAIT_MS, ROOTS_FREE_TOOLS, MCP_CLOSE_BOUND_MS, MCP_CLOSE_HISTORY_BOUND_MS, MCP_CLOSE_UNREADABLE_BOUND_MS, MCP_CLOSE_POLL_MS, closeHistoryBusy, SETUP_INSTRUCTIONS, TOR_RELAY_READY_MS, RELAY_INIT_ID, runMcp;
+var import_web3134, SUPPORTED_PROTOCOL_VERSIONS, MAX_LINE_BYTES, POSITIVE_ATOMIC7, INSTRUCTIONS_BASE, INSTRUCTIONS, MCP_LOG_LEVELS, POOL_SWITCH_LOG_LEVEL, validId, PRODUCT_NAME, listedTitle, BUNDLED_SOURCE_DIR, SHA256_HEX, UPDATE_NOTICE_TOOLS, UPDATE_NOTICE_MAX_TEXT, NPM_VERSION2, GIT_COMMIT, ownWalletVersion, mcpServerVersion, UPDATE_NOTICE_TEXT, updateNoticeLine, commandUpdateField, LAUNCH_NOTICE_TOOLS, withLaunchLine, capRequired, setupInvalid, TOOL_ROOTS_WAIT_MS, ROOTS_FREE_TOOLS, MCP_CLOSE_BOUND_MS, MCP_CLOSE_HISTORY_BOUND_MS, MCP_CLOSE_UNREADABLE_BOUND_MS, MCP_CLOSE_POLL_MS, closeHistoryBusy, SETUP_INSTRUCTIONS, TOR_RELAY_READY_MS, RELAY_INIT_ID, runMcp;
 var init_stdioServer = __esm({
   "wallet/src/mcp/stdioServer.mjs"() {
     "use strict";
@@ -139625,7 +139685,8 @@ var init_stdioServer = __esm({
     SUPPORTED_PROTOCOL_VERSIONS = Object.freeze(["2025-06-18", "2025-03-26", "2024-11-05"]);
     MAX_LINE_BYTES = 4 * 1024 * 1024;
     POSITIVE_ATOMIC7 = /^[1-9][0-9]{0,30}$/;
-    INSTRUCTIONS = `A self-custody Shinjuku Shield wallet on this machine; no tool takes or returns its keys or passphrase. Each answer's say is one plain sentence for the user; other fields hold the numbers. Never tell the user a tool, field, code or protocol name (x402, MCP) unless told to. Map the user's plain request to one tool: "what is my balance" -> wallet_balance (safe at any time); "add money" / "deposit" / "move USDC in from Phantom or an exchange" -> wallet_add_funds (a one-time address; the next wallet_balance after the USDC arrives makes it private, up to 5 USDC private); "shield the USDC on this wallet's own address" -> wallet_shield; "stop" / "cancel" -> wallet_cancel with the request_id of what to stop; "pay this URL" -> x402_pay (no preview needed); "what does this URL cost" -> x402_preview (only when asked); "find a paid API for X" -> x402_discover, then x402_pay on the url it found; "send 2 USDC to <address>" -> wallet_unshield; "show my payments" -> wallet_receipts; "send another token" -> wallet_transfer_token; "ask an AI model" / "which AI models" -> inference_chat (with no prompt it lists the models and prices); "give my other AI app a private AI" -> inference_server (a local OpenAI-compatible URL and key for that app). wallet_balance answers ONE balance (balanceAtomic), and x402_pay pays any paid URL from it (a seller that cannot take a private payment is paid through Shinjuku: max_payment covers amountAtomic, fee included). Fields ending in Atomic are atomic units (1000000 = 1 USDC); tell the user USDC. The wallet does its own upkeep (no user command). A shield, add-funds or unshield call can run for minutes: call again with the SAME request_id as next says. Pass your own request_id to x402_pay: the same request_id never pays or moves money twice (a code ending in _retry_same_request: call again with it). A wallet_unshield send to an address not approved ahead asks the user to confirm first. x402_pay never pays above the user's spending limits (one payment; any 24 hours); with none, the balance is the only bound. Never claim a payment happened unless the answer has a transaction. Privacy: the chain does not show which wallet paid, but this app and its model provider see every URL, body, price and paid answer you handle; reach a seller or its domain only through these tools, never yourself (no curl, browser or DNS lookup, DNS-over-HTTPS too), also when the user asks for no Tor: it shows the user's IP address to the site or a DNS company. When an item of an answer's poolSwitch.items[] has tellUser true, tell the user its message once, in plain words; the wallet moves the balance by itself.`;
+    INSTRUCTIONS_BASE = `A self-custody Shinjuku Shield wallet on this machine; no tool takes or returns its keys or passphrase. Each answer's say is one plain sentence for the user; other fields hold the numbers. Never tell the user a tool, field, code or protocol name (x402, MCP) unless told to. Map the user's plain request to one tool: "what is my balance" -> wallet_balance (safe at any time); "add money" / "deposit" / "move USDC in from Phantom or an exchange" -> wallet_add_funds (a one-time address; the next wallet_balance after the USDC arrives makes it private, up to 5 USDC private); "shield the USDC on this wallet's own address" -> wallet_shield; "stop" / "cancel" -> wallet_cancel with the request_id of what to stop; "pay this URL" -> x402_pay (no preview needed); "what does this URL cost" -> x402_preview (only when asked); "find a paid API for X" -> x402_discover, then x402_pay on the url it found; "send 2 USDC to <address>" -> wallet_unshield; "show my payments" -> wallet_receipts; "send another token" -> wallet_transfer_token; "ask an AI model" / "which AI models" -> inference_chat (with no prompt it lists the models and prices); "give my other AI app a private AI" -> inference_server (a local OpenAI-compatible URL and key for that app). wallet_balance answers ONE balance (balanceAtomic), and x402_pay pays any paid URL from it (a seller that cannot take a private payment is paid through Shinjuku: max_payment covers amountAtomic, fee included). Fields ending in Atomic are atomic units (1000000 = 1 USDC); tell the user USDC. The wallet does its own upkeep (no user command). A shield, add-funds or unshield call can run for minutes: call again with the SAME request_id as next says. Pass your own request_id to x402_pay: the same request_id never pays or moves money twice (a code ending in _retry_same_request: call again with it). A wallet_unshield send to an address not approved ahead asks the user to confirm first. x402_pay never pays above the user's spending limits (one payment; any 24 hours); with none, the balance is the only bound. Never claim a payment happened unless the answer has a transaction. Privacy: the chain does not show which wallet paid, but this app and its model provider see every URL, body, price and paid answer you handle; reach a seller or its domain only through these tools, never yourself (no curl, browser or DNS lookup, DNS-over-HTTPS too), also when the user asks for no Tor: it shows the user's IP address to the site or a DNS company. When an item of an answer's poolSwitch.items[] has tellUser true, tell the user its message once, in plain words; the wallet moves the balance by itself.`;
+    INSTRUCTIONS = `${INSTRUCTIONS_BASE} ${HOST_BLOCKED_LINE}`;
     MCP_LOG_LEVELS = Object.freeze(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
     POOL_SWITCH_LOG_LEVEL = "info";
     validId = (id) => id === null || typeof id === "string" || typeof id === "number" && Number.isFinite(id);
@@ -139663,7 +139724,7 @@ var init_stdioServer = __esm({
     MCP_CLOSE_UNREADABLE_BOUND_MS = 6e4;
     MCP_CLOSE_POLL_MS = 500;
     closeHistoryBusy = (server) => () => compactHistoryReadsRunning() > 0 || memoReadsAheadRunning() > 0 || server.refreshOpen?.() === true;
-    SETUP_INSTRUCTIONS = `This Shinjuku Shield wallet is NOT SET UP yet: every money tool answers wallet_not_set_up. When the user wants to pay, check a balance, or add money, call shinjuku_setup: it asks the user to confirm, creates the wallet and downloads the setup files (minutes: call again as next says). At stage done the wallet tools work. After setup: ${INSTRUCTIONS}`;
+    SETUP_INSTRUCTIONS = `This Shinjuku Shield wallet is NOT SET UP yet: every money tool answers wallet_not_set_up. When the user wants to pay, check a balance, or add money, call shinjuku_setup: it asks the user to confirm, creates the wallet and downloads the setup files (minutes: call again as next says). At stage done the wallet tools work. After setup: ${INSTRUCTIONS_BASE}`;
     TOR_RELAY_READY_MS = 18e4;
     RELAY_INIT_ID = "shinjuku-wallet-relay-initialize";
     runMcp = runMcpServer;
@@ -142007,7 +142068,7 @@ function torTooOldAnswer(version3, { tunnelHost, platform = process.platform } =
     ok: false,
     error: "tor_too_old",
     detail: `${torTooOldWhy(version3)} Tor 0.4.9.13 and newer fix that fault. Nothing was paid.`,
-    next: `Tell the user why: their Tor program is too old and has a known fault that can link two of their payments, and the wallet never falls back to a direct connection. Show torUpdateCommand in one code block, to copy into ${where}: it installs a newer Tor and starts it for the wallet.${platform === "win32" ? " The user stops the old Tor first." : ""} If you can run commands here, offer to run it for the user. When the newer Tor runs: ${RESTART}.`,
+    next: `Tell the user why: their Tor program is too old and has a known fault that can link two of their payments, and the wallet never falls back to a direct connection. Show torUpdateCommand in one code block, to copy into ${where}: it installs a newer Tor and starts it for the wallet.${platform === "win32" ? ` Before it, the user stops the old Tor: ${TOR_STOP_OLD_WINDOWS.replace(/^Stop your old Tor first: /, "")}` : ""} If you can run commands here, offer to run it for the user. When the newer Tor runs: ${RESTART}.`,
     torUpdateCommand: command
   };
 }
@@ -142056,7 +142117,7 @@ async function serveTorMissingMcp({ message, recheck = async () => ({ answer: fa
   const dispatch = createMcpDispatcher({
     tools,
     aliases: MCP_TOOL_ALIASES,
-    instructions: tooOldAtStart ? `The Shinjuku Shield wallet is set to run behind Tor, and the Tor program on this machine is too old (it has a known fault that can link two payments). Call wallet_balance: its answer has the command that installs a newer Tor. ${RESTART} after the newer Tor starts.` : `The Shinjuku Shield wallet is set to run behind Tor, and Tor is not running on this machine. Call wallet_balance: its answer has the install command for the user's OS. ${RESTART} after Tor starts.`
+    instructions: tooOldAtStart ? `The Shinjuku Shield wallet is set to run behind Tor, and the Tor program on this machine is too old (it has a known fault that can link two payments). Call any wallet tool you may use (x402_pay too): its answer has the command that installs a newer Tor, and it moves no money. ${RESTART} after the newer Tor starts.` : `The Shinjuku Shield wallet is set to run behind Tor, and Tor is not running on this machine. Call any wallet tool you may use (x402_pay too): its answer has the install command for the user's OS, and it moves no money. ${RESTART} after Tor starts.`
   });
   await serveStdio({ input, output: output2, dispatch, log });
   return 1;
@@ -147802,12 +147863,22 @@ function noticeLines(notice, width, compact = false) {
   }
   return lines;
 }
+function balanceShown(data) {
+  const balance = clean4(data.balance);
+  if (balance) return { bar: balance, row: balance, cls: "verm", step: null };
+  const command = `${clean4(data.command) || "shinjuku"} balance`;
+  if (data.balanceRead === "reading") return { bar: "reading your balance\u2026", row: "reading\u2026", cls: "mute", step: null };
+  if (data.balanceRead === "slow") return { bar: "balance not known yet", row: "not known yet: the read is slow", cls: "mute", step: "it goes on, and shows here when it ends." };
+  if (data.balanceRead === "failed") return { bar: "balance not known yet", row: "not known yet: the read failed", cls: "mute", step: `run ${command} to see why.` };
+  if (data.balanceRead === "done") return { bar: "balance not known yet", row: "not known yet", cls: "mute", step: `run ${command} to read it again.` };
+  return { bar: "balance not known yet", row: "not known yet", cls: "mute", step: null };
+}
 function homeStatus(data, wide, width) {
   const notices = walletNotices(data);
   const [notice] = notices;
   const head = notice ? [[" \u25CB ", "mute"], [notice.state, "bone"]] : [[" \u25CF ", "brass"], ["ready", "bone"]];
-  const balance = clean4(data.balance);
-  const middle = [[balance || "balance not known yet", balance ? "verm" : "mute"]];
+  const shown = balanceShown(data);
+  const middle = [[shown.bar, shown.cls]];
   if (data.tor === true || data.tor === false) middle.push([data.tor ? "tor on" : "tor off", "bone"]);
   const bar = (items) => [...head, ...items.flatMap((item) => [[" \u2502 ", "ash"], item])];
   const command = notices.find((item) => item.command)?.command;
@@ -147928,12 +147999,13 @@ function publicRows(data, w) {
   return { row: ["public", value2, "verm"], step: Object.hasOwn(PUBLIC_STEP, pub.step) ? [PUBLIC_STEP[pub.step]] : [] };
 }
 function walletBlock(data, wide, w, compact = false) {
-  const balance = clean4(data.balance);
+  const shown = balanceShown(data);
   const notices = walletNotices(data);
   const state = notices.length ? `\u25CB ${notices[0].state}` : "\u25CF ready";
   const extra = notices.flatMap((notice) => noticeLines(notice, w - 4, compact));
   if (compact) return rowsBlock(PANELS.wallet, state, "mute", [], extra, "dim");
-  const rows2 = [["balance", balance || "not known yet", balance ? "verm" : "mute"]];
+  const rows2 = [["balance", shown.row, shown.cls]];
+  if (shown.step) extra.unshift(...wrap(shown.step, w - 4));
   const adding = clean4(data.addingFunds);
   const moving = clean4(data.movingOut);
   const live = (value2) => value2 === "none" ? "bone" : "verm";
@@ -148165,7 +148237,7 @@ async function stopReading(stdin) {
     handle.readStop();
   }
 }
-async function openHomeScreen({ stdout = process.stdout, stdin = process.stdin, env = process.env, platform = process.platform, data } = {}) {
+async function openHomeScreen({ stdout = process.stdout, stdin = process.stdin, env = process.env, platform = process.platform, data, watch } = {}) {
   if (!homeScreenAllowed(stdout, env) || !stdin?.isTTY || typeof stdin.setRawMode !== "function") return { outcome: "off" };
   if (!compose(data, stdout.columns - 1, stdout.rows)) return { outcome: "off" };
   const codes = paletteFor(screenColor(stdout, env));
@@ -148228,6 +148300,7 @@ async function openHomeScreen({ stdout = process.stdout, stdin = process.stdin,
   const rawBefore = Boolean(stdin.isRaw);
   let reading = false;
   let timer;
+  let stopWatch;
   process.once("exit", restoreScreen);
   for (const signal of signals) process.on(signal, onSignal);
   stdout.on?.("resize", onResize);
@@ -148240,11 +148313,21 @@ async function openHomeScreen({ stdout = process.stdout, stdin = process.stdin,
     write("\x1B[?1049h\x1B[?25l");
     draw();
     timer = setInterval(spin, BAND_MS2);
+    stopWatch = watch?.((next) => {
+      if (result === void 0 && next) {
+        data = next;
+        draw();
+      }
+    });
     await settled;
   } catch {
     finish({ outcome: "off" });
   } finally {
     clearInterval(timer);
+    try {
+      stopWatch?.();
+    } catch {
+    }
     stdout.removeListener?.("resize", onResize);
     for (const signal of signals) process.removeListener(signal, onSignal);
     process.removeListener("exit", restoreScreen);
@@ -148357,12 +148440,16 @@ function sellerWords(seller) {
   return text3.length > SELLER_CHARS ? `${text3.slice(0, SELLER_CHARS - 3)}...` : text3;
 }
 var REFUND_WORDS = Object.freeze({ refunded: "refunded", refund_sent: "coming back", refund_pending: "coming back", refund_not_seen: "refund not seen" });
+function aiPaymentWords(item) {
+  const parts = /^private AI: (.+) \(([^()]+)\)$/.exec(item);
+  return parts ? `private AI, ${parts[2]}: ${parts[1]}` : item;
+}
 function paymentRow(name, record, store, walk) {
   let ok;
   let at;
   let words2;
   const view2 = receiptView(record);
-  const seller = view2.kind === "inference" && typeof view2.item === "string" ? view2.item : sellerWords(view2.seller);
+  const seller = view2.kind === "inference" && typeof view2.item === "string" ? aiPaymentWords(view2.item) : sellerWords(view2.seller);
   if (name.startsWith(FLOAT_PAYMENT_WAL_PREFIX2)) {
     if (record?.schema !== FLOAT_PAYMENT_SCHEMA2) return void 0;
     const state = floatRecordState(record);
@@ -150894,16 +150981,26 @@ function allowWalletChecks(deps) {
   const file = claudeCodeSettingsFile({ env: deps.env, home: deps.homedir() });
   try {
     const { changed, backup } = allowInClaudeCode(file);
-    return { same: !changed, say: `Claude Code runs the wallet's checks that move no money (balance, receipts) without a question${backup ? ` (its old settings file was copied to ${backup}, readable by you alone)` : ""}. Payments and sends still ask first. To undo that, remove the shinjuku rules in Claude Code's /permissions.` };
+    return { same: !changed, say: `Claude Code runs the wallet's checks that move no money (balance, receipts) without a question${backup ? ` (its old settings file was copied to ${backup}, readable by you alone)` : ""}. In Claude Code's default mode, payments and sends still ask first; its auto mode may pay with no question or block a send (press shift+tab until auto mode is off). To undo the wallet's rules, remove the shinjuku rules in Claude Code's /permissions.` };
   } catch (error) {
     const unreadable = String(error.message).startsWith("setup_host_config_unreadable:");
     return { same: false, say: `Claude Code still asks before each wallet check: ${unreadable ? `the wallet cannot read the settings in ${file}, so it did not change that file` : `the wallet could not write ${file}`}.` };
   }
 }
-function addToHosts(targets, home, deps, { force = false, npmVersion } = {}) {
+function otherHomeOfClaudeCodeEntry(existing, options) {
+  const named = existing?.env?.SHIELDED_WALLET_HOME;
+  const env = { ...options.env };
+  delete env.SHIELDED_WALLET_HOME;
+  if (typeof named === "string" && named) env.SHIELDED_WALLET_HOME = named;
+  const home = setupHome(env);
+  if (!isOlderClaudeCodeEntry(existing, { ...options, env, home })) return void 0;
+  return resolve33(home) === resolve33(options.home) ? void 0 : home;
+}
+async function addToHosts(targets, home, deps, { force = false, npmVersion, ask } = {}) {
   const io = deps.io;
   const options = { home, env: deps.env, platform: deps.platform ?? process.platform, npmVersion };
   const done = /* @__PURE__ */ new Set();
+  const kept2 = /* @__PURE__ */ new Set();
   for (const target of targets) {
     if (target === "claude-code") {
       const why = claudeCodeShellWhy(options);
@@ -150926,11 +151023,21 @@ function addToHosts(targets, home, deps, { force = false, npmVersion } = {}) {
         continue;
       }
       const olderOwn = !force && existing !== void 0 && isOlderClaudeCodeEntry(existing, options) && quiet(["mcp", "remove", "--scope", "user", MCP_SERVER_NAME]) === 0;
+      const otherHome = !force && !olderOwn && existing !== void 0 ? otherHomeOfClaudeCodeEntry(existing, options) : void 0;
+      const replace = otherHome !== void 0 && ask !== void 0 ? yes(await ask(`Claude Code already has a Shinjuku Shield entry for another wallet home (${otherHome}). Replace it with this one? [y/N] `)) : void 0;
+      if (replace === false) {
+        kept2.add(target);
+        io.out(`Claude Code keeps the wallet in ${otherHome}; nothing was changed. To use this wallet there instead, do this step again and answer y.
+`);
+        continue;
+      }
+      const replacedOther = replace === true && quiet(["mcp", "remove", "--scope", "user", MCP_SERVER_NAME]) === 0;
       let status = deps.runClaudeCli(claudeCodeArgs(options));
-      const removed = olderOwn || status !== 0 && force && quiet(["mcp", "remove", "--scope", "user", MCP_SERVER_NAME]) === 0;
+      const removed = olderOwn || replacedOther || status !== 0 && force && quiet(["mcp", "remove", "--scope", "user", MCP_SERVER_NAME]) === 0;
       if (removed && status !== 0) status = deps.runClaudeCli(claudeCodeArgs(options));
       if (status === 0) done.add(target);
-      io.out(status === 0 ? `${removed ? "Replaced the wallet in" : "Added the wallet to"} Claude Code, for all your folders. ${allowWalletChecks(deps).say} ${RESTART_APP("Claude Code")}
+      const homeNow = replacedOther ? ` Claude Code now uses the wallet in ${home}; the wallet in ${otherHome} is unchanged.` : "";
+      io.out(status === 0 ? `${removed ? "Replaced the wallet in" : "Added the wallet to"} Claude Code, for all your folders.${homeNow} ${allowWalletChecks(deps).say} ${RESTART_APP("Claude Code")}
 ` : `Claude Code did not take the server; its message is above. Run this yourself:
   ${claudeCodeCommand(options)}
 ` + (removed ? `Setup removed the old ${MCP_SERVER_NAME} entry first, so Claude Code has none until that line runs.
@@ -150956,7 +151063,7 @@ function addToHosts(targets, home, deps, { force = false, npmVersion } = {}) {
 `);
     }
   }
-  return done;
+  return { added: done, kept: kept2 };
 }
 function setupArgvOf(values) {
   const usdcNames = new Set(COMMAND_BY_NAME.get("setup").flags.filter((spec) => spec.usdc).map((spec) => spec.name));
@@ -151278,7 +151385,13 @@ Copy it to two offline places now; it is the only way to restore this wallet.
 `);
   const rerun = values.get(SETUP_RERUN) === "settings";
   const targets = values.get("--add-to") ?? [];
-  const added = targets.length ? addToHosts(targets, home, deps, { force: values.has("--force"), npmVersion }) : /* @__PURE__ */ new Set();
+  const hosts = targets.length ? await addToHosts(
+    targets,
+    home,
+    deps,
+    { force: values.has("--force"), npmVersion, ask: interactive && deps.stdinIsTTY() ? deps.ask : void 0 }
+  ) : void 0;
+  const added = /* @__PURE__ */ new Set([...hosts?.added ?? [], ...hosts?.kept ?? []]);
   const config = setupConfigOf(home);
   if (readsBack) {
     await readBackHere(config, deps, values.get(RESTORED) ?? `Run setup again when the connection works; it continues there:
@@ -154449,7 +154562,7 @@ async function runBalance(args, values, deps, io) {
     await refreshed.prune();
     publicSince = Date.now();
     store = refreshed.store;
-    earlierDeposits = await (deps.adoptOneTime ?? adoptOneTimeForBalance)({ store, values, deps, io });
+    if (deps.env[HOME_READ_ENV] !== "1") earlierDeposits = await (deps.adoptOneTime ?? adoptOneTimeForBalance)({ store, values, deps, io });
   } else {
     store = openPoolWallet(values, deps);
   }
@@ -154992,7 +155105,7 @@ function failureHint(command, reason, deps, values, floatError) {
     return "this payment settled, but in another transaction than the seller's receipt names; the wallet counts the settled one. Do not pay this request again";
   }
   if (/p03_quote_anchor_older_than_note_wait_next_epoch/.test(reason)) {
-    return `your newest deposit or change is newer than the newest pool anchor, so it cannot be spent yet. Nothing was signed, and the quote was dropped. pay, buy-item, pocket fill, and unshield wait for the next anchor by themselves (up to 5 minutes and 60 s); when that wait ran out, Shinjuku wrote no new anchor yet. Rerun the same command after the next pool anchor. To pay several times in a row without this wait, add funds as several deposits: ${cli2()} add-funds --route exchange --amount <usdc> --split <k> (${cli2()} help add-funds)`;
+    return "your last payment or deposit is not ready to spend yet, and the wallet's wait for it ran out. Nothing was signed or paid. Run the same command again in a minute";
   }
   if (/p03_merchant_respend_(insufficient_recovered_value|accounts_split_merge_first)/.test(reason)) {
     const parts = runBalanceParts(values, deps);
@@ -155426,21 +155539,104 @@ Every command: ${cli2()} help
 `;
 }
 var bareAnimationPlayed = false;
+var HOME_READ_CAP_MS = 6e4;
+var HOME_READ_ENV = "SHINJUKU_WALLET_HOME_READ";
+function homeBalanceReadRun(argv2, env) {
+  const words2 = ["balance", "--refresh", "--fresh"];
+  if (runNetworkMode() !== null) {
+    const proxy = childRunProxy(env);
+    return { args: [...words2, ...proxy.args], env: { ...proxy.env, [HOME_READ_ENV]: "1" } };
+  }
+  const own = { ...env, [HOME_READ_ENV]: "1" };
+  return { args: torArgv([...words2, ...argv2], own), env: own };
+}
+function startHomeBalanceRead(argv2, env) {
+  if (cliEntry2 === void 0) return void 0;
+  const run4 = homeBalanceReadRun(argv2, env);
+  let child;
+  try {
+    child = spawn9(process.execPath, [...process.execArgv, cliEntry2, ...run4.args], { env: run4.env, stdio: "ignore", detached: true, windowsHide: true });
+  } catch {
+    return void 0;
+  }
+  child.unref();
+  return new Promise((done) => {
+    child.once("error", () => done(1));
+    child.once("exit", (code2) => done(code2 ?? 1));
+  });
+}
+function homeBalanceRead(data, argv2, deps, readData) {
+  if (data?.setUp !== true || data.balance !== null || data.walletIssue || data.restoreUnread || data.setupFilesMissing) return void 0;
+  const ended = deps.homeBalanceRead(argv2, deps.env);
+  if (!ended) return void 0;
+  const startedAt = deps.now();
+  let current = { ...data, balanceRead: "reading" };
+  let endCode;
+  const watchers = /* @__PURE__ */ new Set();
+  const show = (next) => {
+    current = next;
+    for (const watcher of watchers) watcher(next);
+  };
+  const reread = () => {
+    let next;
+    try {
+      next = readData();
+    } catch {
+      next = { ...current, balance: null };
+    }
+    show(next?.balance !== null && next?.balance !== void 0 ? next : { ...next ?? current, balanceRead: endCode === 0 ? "done" : "failed" });
+  };
+  const cap = setTimeout(() => {
+    if (endCode === void 0) show({ ...current, balanceRead: "slow" });
+  }, HOME_READ_CAP_MS);
+  cap.unref?.();
+  const settled = ended.then((code2) => {
+    endCode = code2;
+    clearTimeout(cap);
+    if (watchers.size) reread();
+  });
+  return {
+    data: () => current,
+    watch(watcher) {
+      watchers.add(watcher);
+      if (endCode !== void 0 && current.balanceRead === "reading") reread();
+      return () => {
+        watchers.delete(watcher);
+      };
+    },
+    async finish(io) {
+      const left = HOME_READ_CAP_MS - (deps.now() - startedAt);
+      if (endCode !== void 0 || left <= 0) return;
+      io.err(`Finishing the balance read first (at most ${Math.ceil(left / 1e3)} s)\u2026
+`);
+      let timer;
+      await Promise.race([settled, new Promise((done) => {
+        timer = setTimeout(done, left);
+      })]);
+      clearTimeout(timer);
+    }
+  };
+}
 function defaultDependencies() {
   return {
     env: process.env,
     now: () => Date.now(),
     io: { out: (text3) => process.stdout.write(text3), err: (text3) => process.stderr.write(text3) },
     openAnimation: () => playOpenAnimation(),
-    /** The facts of the bare command's home screen (cli/homeData.mjs): local files only, never a network read. */
+    /**
+     * The facts of the bare command's home screen (cli/homeData.mjs), from local files only. The screen's one network
+     * read is homeBalanceRead, a balance child run behind the run's Tor, only when these facts give no balance.
+     */
     homeData: (options) => readHomeData(options),
+    /** The home screen's balance read (startHomeBalanceRead): a promise of its exit code, or undefined when none starts. */
+    homeBalanceRead: (argv2, env) => startHomeBalanceRead(argv2, env),
     /**
      * True when the bare command's home screen can draw: stdout and stdin a terminal, CI unset, TERM not dumb, a window it
      * fits. Only then are its facts read, so a pipe never opens the wallet.
      */
     homeScreenOn: (env) => homeScreenAllowed(process.stdout, env) && Boolean(process.stdin.isTTY),
-    /** The bare command's home screen (cli/homeScreen.mjs) for `data` (homeData): { outcome, key }. */
-    homeScreen: (data, env) => openHomeScreen({ env, data }),
+    /** The bare command's home screen (cli/homeScreen.mjs) for `data` (homeData), redrawn on each `watch` change: { outcome, key }. */
+    homeScreen: (data, env, watch) => openHomeScreen({ env, data, watch }),
     /**
      * The one job a home screen key runs, as the bin runs that typed command (bin/shinjuku-wallet.mjs): help text in this
      * process; any other command through torArgv and proxyEntry, so a home whose setup recorded Tor runs it behind Tor
@@ -155661,11 +155857,14 @@ async function runShinjukuWallet(argv2, overrides = {}) {
     if (name === void 0 || name === "help" || name === "--help" || name === "-h") {
       if (name === void 0) {
         const screenOn = deps.homeScreenOn(deps.env);
-        const data = screenOn ? deps.homeData({ env: deps.env, walletVersion: deps.walletVersion, torRun: homeJobTor(argv2, deps.env) }) : void 0;
+        const torRun = homeJobTor(argv2, deps.env);
+        const readData = () => deps.homeData({ env: deps.env, walletVersion: deps.walletVersion, torRun });
+        const data = screenOn ? readData() : void 0;
+        const balanceRead = screenOn ? homeBalanceRead(data, argv2, deps, readData) : void 0;
         const played = await deps.openAnimation();
         bareAnimationPlayed = true;
         if (played === "interrupted") return 130;
-        const screen = screenOn ? await deps.homeScreen(data, deps.env) : { outcome: "off" };
+        const screen = screenOn ? await deps.homeScreen(balanceRead ? balanceRead.data() : data, deps.env, balanceRead?.watch) : { outcome: "off" };
         if (screen.outcome === "interrupted") return 130;
         if (screen.outcome === "quit") return 0;
         if (screen.outcome !== "key") {
@@ -155676,7 +155875,10 @@ async function runShinjukuWallet(argv2, overrides = {}) {
           io.out(overviewText());
           return 0;
         }
-        const job = (words3) => deps.runHomeJob([...words3, ...argv2], overrides);
+        const job = async (words3) => {
+          await balanceRead?.finish(io);
+          return deps.runHomeJob([...words3, ...argv2], overrides);
+        };
         if (screen.key === "s") return job(["setup"]);
         if (screen.key === "a") return job(["add-funds"]);
         if (screen.key === "u") return job(["unshield"]);
@@ -155711,7 +155913,9 @@ ${HOST_TARGETS.map((host, index) => `  ${index + 1}  ${hostNames[host] ?? host}`
             }
             const home = setupHome(deps.env);
             const npmVersion = deps.walletVersion().npm;
-            if (addToHosts([host], home, deps, { npmVersion }).has(host)) {
+            const hosts = await addToHosts([host], home, deps, { npmVersion, ask: deps.stdinIsTTY() ? deps.ask : void 0 });
+            if (hosts.kept.has(host)) return 0;
+            if (hosts.added.has(host)) {
               io.out(`Next: ask ${hostNames[host]} "what is my balance".
 `);
               return 0;