shinjuku-shield 0.3.83 → 0.3.84

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.83. The npm packages `shinjuku-shield` and
+This is version 0.3.84. 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.83 setup
+npx -y --no-audit --no-fund shinjuku-shield@0.3.84 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.83
+npm install -g shinjuku@0.3.84
 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.83 mcp
+claude mcp add --scope user shinjuku-shielded -- npx -y --no-audit --no-fund shinjuku-shield@0.3.84 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.83", "mcp"] } } }
+{ "mcpServers": { "shinjuku-shielded": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.84", "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": "a59aa27b98cd1822c4651ed0567cd35b3f03e087818d8e5cfdb71e6320b7ffae",
-  "bytes": 12484127,
-  "sourceCommit": "ad531c40fe817d116a109d33472895bbbd854158",
+  "sha256": "b73f57e58ae0466a090f5b1728e7852bab48e7d28ad6bb0f0ba9657b6cc681b1",
+  "bytes": 12505075,
+  "sourceCommit": "52a8e17d03018f2cc026f9f9d306a785ef4da9f5",
   "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-23T18:18:57.601Z"
+  "publishedAt": "2026-10-23T19:32:52.495Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shield",
-  "version": "0.3.83",
+  "version": "0.3.84",
   "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": "a59aa27b",
-  "shinjukuSha256": "a59aa27b98cd1822c4651ed0567cd35b3f03e087818d8e5cfdb71e6320b7ffae",
+  "shinjukuRelease": "b73f57e5",
+  "shinjukuSha256": "b73f57e58ae0466a090f5b1728e7852bab48e7d28ad6bb0f0ba9657b6cc681b1",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -30309,7 +30309,7 @@ Message: ${transactionMessage2}.
         await this._unsubscribeClientSubscription(clientSubscriptionId, "root change");
       }
     };
-    var Keypair15 = class _Keypair {
+    var Keypair16 = class _Keypair {
       /**
        * Create a new keypair instance.
        * Generate random keypair if no {@link Ed25519Keypair} is provided.
@@ -30853,7 +30853,7 @@ Message: ${transactionMessage2}.
         } = params;
         assert(privateKey.length === PRIVATE_KEY_BYTES$1, `Private key must be ${PRIVATE_KEY_BYTES$1} bytes but received ${privateKey.length} bytes`);
         try {
-          const keypair = Keypair15.fromSecretKey(privateKey);
+          const keypair = Keypair16.fromSecretKey(privateKey);
           const publicKey4 = keypair.publicKey.toBytes();
           const signature3 = sign3(message, keypair.secretKey);
           return this.createInstructionWithPublicKey({
@@ -32293,7 +32293,7 @@ Message: ${transactionMessage2}.
     exports.Enum = Enum;
     exports.EpochSchedule = EpochSchedule;
     exports.FeeCalculatorLayout = FeeCalculatorLayout;
-    exports.Keypair = Keypair15;
+    exports.Keypair = Keypair16;
     exports.LAMPORTS_PER_SOL = LAMPORTS_PER_SOL;
     exports.LOOKUP_TABLE_INSTRUCTION_LAYOUTS = LOOKUP_TABLE_INSTRUCTION_LAYOUTS;
     exports.Loader = Loader;
@@ -42600,6 +42600,16 @@ var init_rpcDefault = __esm({
 });
 
 // wallet/src/net/facilitatorOnion.mjs
+function afterOnionRace(url, signal) {
+  let origin;
+  try {
+    origin = new URL(url instanceof Request ? url.url : String(url)).origin;
+  } catch {
+    return void 0;
+  }
+  const group = routedGroupOf.get(origin);
+  return group !== void 0 && !group.winner && !group.waitMs && group.pending ? untilAborted(group.pending, signal) : void 0;
+}
 function takeSiteOnionRaces() {
   if (siteRacesTaken) return Promise.resolve([]);
   siteRacesTaken = true;
@@ -42803,7 +42813,10 @@ async function routeFacilitatorsOverOnion(argv2, {
   }
   if (routes.size === 0) return { routes: /* @__PURE__ */ new Map(), stop: () => {
   } };
-  for (const [origin, group] of routes) routedOrigins.set(origin, group.onions);
+  for (const [origin, group] of routes) {
+    routedOrigins.set(origin, group.onions);
+    routedGroupOf.set(origin, group);
+  }
   const aborts = [];
   let stopped = false;
   const race = (group, onions, options) => {
@@ -42958,7 +42971,7 @@ async function routeFacilitatorsOverOnion(argv2, {
     }
   };
 }
-var SITE_ONIONS, SITE_SPARE_ONIONS, PINNED_FACILITATOR_ONIONS, PINNED_SPARE_ONIONS, HISTORY_ONIONS, PINNED_HISTORY_ONIONS, HISTORY_PROBE_PATH, FACILITATOR_FLAGS, V3_ONION, DISCOVERY_TIMEOUT_MS, WARM_TIMEOUT_MS, RACE_TIMEOUT_MS, ROUTE_WAIT_MS, SPARE_AFTER_MS, SPARE_CAUSE, routedGroups, liveOnions, hostOf, noAnswer, routedOnions, routedOrigins, onionsOfOrigin, routesOverOnion, firstRaces, siteRaces, siteRacesTaken, firstOnionRace, GLOBAL_DISPATCHER, onionDispatchers;
+var SITE_ONIONS, SITE_SPARE_ONIONS, PINNED_FACILITATOR_ONIONS, PINNED_SPARE_ONIONS, HISTORY_ONIONS, PINNED_HISTORY_ONIONS, HISTORY_PROBE_PATH, FACILITATOR_FLAGS, V3_ONION, DISCOVERY_TIMEOUT_MS, WARM_TIMEOUT_MS, RACE_TIMEOUT_MS, ROUTE_WAIT_MS, SPARE_AFTER_MS, SPARE_CAUSE, routedGroups, liveOnions, hostOf, noAnswer, routedOnions, routedOrigins, onionsOfOrigin, routesOverOnion, routedGroupOf, firstRaces, siteRaces, siteRacesTaken, firstOnionRace, GLOBAL_DISPATCHER, onionDispatchers;
 var init_facilitatorOnion = __esm({
   "wallet/src/net/facilitatorOnion.mjs"() {
     "use strict";
@@ -43008,6 +43021,7 @@ var init_facilitatorOnion = __esm({
     routedOrigins = /* @__PURE__ */ new Map();
     onionsOfOrigin = (origin) => routedOrigins.get(origin) ?? PINNED_FACILITATOR_ONIONS[origin] ?? [];
     routesOverOnion = (origin) => routedOrigins.has(origin);
+    routedGroupOf = /* @__PURE__ */ new Map();
     firstRaces = /* @__PURE__ */ new Map();
     siteRaces = [];
     siteRacesTaken = false;
@@ -47215,7 +47229,7 @@ function reexec(args, mode, plainProxy) {
   const quiet = quietRun(args);
   if (quiet) env[QUIET_RUN_MARK] = quiet;
   return new Promise((resolvePromise) => {
-    const child = spawn(process.execPath, [...process.execArgv, process.argv[1], ...args], { env, stdio: "inherit" });
+    const child = spawn(process.execPath, [...proxiedExecArgv(process.execArgv), process.argv[1], ...args], { env, stdio: "inherit" });
     const ignore = () => {
     };
     const forward = () => child.kill("SIGTERM");
@@ -47245,7 +47259,7 @@ async function proxyEntry(argv2, run5, { err = (text3) => process.stderr.write(t
     try {
       await proveProxy(mode, proxy);
     } catch (error) {
-      err(`shinjuku: ${error.message}
+      err(`shinjuku: ${error.message}${mode === "tor" && process.env[TOR_FROM_CONFIG_ENV] === "1" ? TOR_FROM_CONFIG_HINT : ""}
 `);
       if (mcpRefused2 && argv2[0] === "mcp" && !process.stdin.isTTY && !process.env[TOR_RUN_STARTED_ENV]) {
         return mcpRefused2({
@@ -47291,7 +47305,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;
+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 init_proxy = __esm({
   "wallet/src/net/proxy.mjs"() {
     "use strict";
@@ -47386,6 +47400,10 @@ var init_proxy = __esm({
     torCircuit = () => torCircuitId;
     GLOBAL_DISPATCHER2 = /* @__PURE__ */ Symbol.for("undici.globalDispatcher.1");
     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];
+    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)';
   }
 });
 
@@ -50760,6 +50778,7 @@ function poolLayoutForLength(length) {
 function connect2(rpcUrl, commitment = "finalized", { timeoutMs, wrapFetch = (fetch2) => fetch2 } = {}) {
   const pooled = (input, init) => rpcFetch(input, rpcKeepAliveInit(input, init));
   const fetch2 = wrapFetch(timeoutMs === void 0 ? pooled : async (input, { onResponseHead, ...init } = {}) => {
+    await afterOnionRace(input, init?.signal);
     const circuit = torCircuit();
     const timeout = AbortSignal.timeout(timeoutMs);
     try {
@@ -51744,6 +51763,7 @@ var init_chain2 = __esm({
     import_web395 = __toESM(require_index_cjs(), 1);
     init_esm2();
     init_proxy();
+    init_facilitatorOnion();
     init_keepAlive();
     init_compressedReplay();
     init_reference2();
@@ -51841,6 +51861,7 @@ var init_chain2 = __esm({
     historyRequestsSent = 0;
     historySourceState = () => ({ silentSince: historySilentSince, sent: historyRequestsSent });
     trackHistoryAnswers = (fetch2) => async (input, init) => {
+      await afterOnionRace(input, init?.signal);
       historyRequestsSent += 1;
       historySilentSince ??= Date.now();
       const response = await fetch2(input, init);
@@ -64207,6 +64228,8 @@ async function decryptKept(decrypt, items, eta, chainProgramId, pool2) {
   const program = chainProgramId.toBase58();
   const poolKey = pool2.toBase58();
   const keys3 = items.map(({ digest: digest2, context }) => decryptedKey(eta, program, poolKey, digest2, context));
+  if (RECOVERY_TOOK.size >= DECRYPTED_MAX) RECOVERY_TOOK.clear();
+  for (const key of keys3) RECOVERY_TOOK.add(key);
   const outputs = keys3.map((key) => {
     const kept = DECRYPTED.get(key);
     return kept === void 0 ? void 0 : copyOutputs(kept);
@@ -64435,6 +64458,7 @@ function prefetchRecoveryMemos({ store, finalizedHistory: finalizedHistory2, ser
 }
 async function decryptAhead({ store, contexts, reading, chainProgramId, pool: pool2 }) {
   const started = [];
+  memoReadsAhead += 1;
   try {
     const answers = await reading;
     const eta = deriveWalletViewingAuthority2({ seedBytes: seedBytes3(store.state), generator: pinnedGenerator2() }).eta;
@@ -64483,9 +64507,33 @@ async function decryptAhead({ store, contexts, reading, chainProgramId, pool: po
       DECRYPTED.set(keys3[index], copyOutputs(outputs[at]));
     });
     markPhase("memos-decrypted-ahead");
+    await new Promise((resolve40) => {
+      setImmediate(resolve40);
+    });
+    const keep = open4.flatMap((index, at) => RECOVERY_TOOK.has(keys3[index]) ? [] : [[index, at]]);
+    if (keep.length === 0) return;
+    const cache = openRecoveryCache(store, { programId: program, pool: poolKey });
+    if (!cache) return;
+    let kept = 0;
+    for (const [index, at] of keep) {
+      const { context } = items[index];
+      try {
+        assertFinalizedRecoveryContext(context, context.memoDigest, chainProgramId, pool2);
+      } catch {
+        continue;
+      }
+      const digest2 = hexOf2(context.memoDigest);
+      if (cache.lookup(digest2, context)) continue;
+      cache.remember(digest2, context, copyOutputs(outputs[at]));
+      kept += 1;
+    }
+    if (kept === 0) return;
+    cache.save();
+    markPhase("memos-kept-ahead", `n${kept}`);
   } catch {
   } finally {
     for (const [key, one] of started) if (DECRYPTING.get(key) === one) DECRYPTING.delete(key);
+    memoReadsAhead -= 1;
   }
 }
 function successorHistoriesFor(finalizedHistory2, given, chainProgramId) {
@@ -64625,7 +64673,7 @@ async function runRecover({ store, connection, programId, digests, serviceUrl: s
     ...Array.isArray(digests) && digests.length > 0 ? { narrowedByDigests: true } : {}
   };
 }
-var import_web3102, FIELD_MODULUS6, MODEL_DIR, seedBytes3, committedGenerator, REPLAY_VALUES, REPLAY_VALUES_MAX, DECRYPTED, DECRYPTED_MAX, DECRYPTING, copyOutputs, hexOf2, beforeMemoStart, decryptableContext;
+var import_web3102, FIELD_MODULUS6, MODEL_DIR, seedBytes3, committedGenerator, REPLAY_VALUES, REPLAY_VALUES_MAX, DECRYPTED, DECRYPTED_MAX, DECRYPTING, RECOVERY_TOOK, memoReadsAhead, memoReadsAheadRunning, copyOutputs, hexOf2, beforeMemoStart, decryptableContext;
 var init_recover = __esm({
   "wallet/src/recovery/recover.mjs"() {
     "use strict";
@@ -64650,6 +64698,9 @@ var init_recover = __esm({
     DECRYPTED = /* @__PURE__ */ new Map();
     DECRYPTED_MAX = 5e4;
     DECRYPTING = /* @__PURE__ */ new Map();
+    RECOVERY_TOOK = /* @__PURE__ */ new Set();
+    memoReadsAhead = 0;
+    memoReadsAheadRunning = () => memoReadsAhead;
     copyOutputs = (outputs) => outputs.map((output2) => ({
       ...output2,
       ...output2.account ? { account: { ...output2.account } } : {},
@@ -107698,10 +107749,10 @@ function facilitatorExitRelay(origin, { fetchImpl = fetch, pause: pause3 = (ms)
     }
   };
 }
-async function main3(args = process.argv.slice(2)) {
+async function main3(args = process.argv.slice(2), { output: output2 = (result) => console.log(JSON.stringify(result)) } = {}) {
   if (args.length === 1 && args[0] === "--help") {
     console.log(USAGE2);
-    return;
+    return void 0;
   }
   const options = {};
   for (let index = 0; index < args.length; index += 2) {
@@ -107749,8 +107800,9 @@ async function main3(args = process.argv.slice(2)) {
       if (!store2.readWal(`self-pay-${options["unshield-id"]}`)) assertUnshieldNotPromised(store2, options.amount);
       return unshieldOnce({ ...context, store: store2, unshieldId: options["unshield-id"], amountAtomic: options.amount });
     });
-    console.log(JSON.stringify({ success: true, ...result }));
-    return;
+    const answer2 = { success: true, ...result };
+    output2(answer2);
+    return answer2;
   }
   const partId = (index) => {
     const id = `${options["unshield-id"]}-p${index}`;
@@ -107798,7 +107850,9 @@ async function main3(args = process.argv.slice(2)) {
       return finishPrivateSend(opened, plan.sendId);
     })
   });
-  console.log(JSON.stringify({ success: true, privateSend: status }));
+  const answer = { success: true, privateSend: status };
+  output2(answer);
+  return answer;
 }
 async function unshieldOnce({ options, origin, historyUrl, walletPath: walletPath2, recipientOwner, payerTools, exitTools, profile, connection, store, unshieldId, amountAtomic }) {
   const paid = await selfPay({
@@ -109828,6 +109882,7 @@ function refusalSay(a, tool, again, npmVersion) {
   if (PAY_CAP_CODES.has(code2)) {
     const total = usdcText(a.totalAtomic ?? a.neededAtomic ?? a.amountAtomic);
     const cap = usdcText(a.capAtomic ?? a.limitAtomic);
+    if (a.capKind === "call" && total && cap) return `Nothing was paid: it costs ${total} USDC, over this request's ${cap} USDC cap. Allow ${total} USDC to pay it.`;
     return total && cap ? `Nothing was paid: ${total} USDC is over your ${cap} USDC limit. ${raiseLine("--max-payment", npmVersion)}` : `Nothing was paid: this is above your per-payment limit. ${raiseLine("--max-payment", npmVersion)}`;
   }
   if (MOVE_CAP_CODES.has(code2)) {
@@ -110055,7 +110110,9 @@ function balanceLine(a, room = SAY_MAX_WORDS) {
     if (moving) return MOVE_LINE;
     if (a.status === "reading") return "The first balance read of this wallet is not done yet. Ask again in 30 seconds.";
     if (a.refreshing === true) {
-      return Number(a.refreshingSeconds) >= 60 ? "The wallet is still reading the chain; this takes longer than usual. Ask again in a minute." : "The wallet is still reading the chain. Ask again in about 30 seconds.";
+      const last = a.lastRead && usdcText(a.lastRead.privateAtomic) && Number.isSafeInteger(a.lastRead.ageMinutes) && a.lastRead.ageMinutes > 0 ? ` The last full read, ${ageWords(a.lastRead.ageMinutes)} ago, showed ${usdcText(a.lastRead.privateAtomic)} USDC private.` : "";
+      const lines = Number(a.refreshingSeconds) >= 60 ? [`Still reading the chain; it takes longer than usual.${last} Ask again in a minute.`, "The wallet is still reading the chain; this takes longer than usual. Ask again in a minute."] : [`Still reading the chain.${last} Ask again in about 30 seconds.`, "The wallet is still reading the chain. Ask again in about 30 seconds."];
+      return last ? lines.find((text3) => words(text3) <= SAY_MAX_WORDS) ?? lines[1] : lines[1];
     }
     const why = refreshErrorWords(str(a.refreshError), a.lockedBy);
     return why ? `Your private balance is not known yet: ${why}. Ask again in a minute.` : "Your private balance is not known yet. Ask again in a minute.";
@@ -110235,6 +110292,10 @@ function build(a, tool, npmVersion) {
     const amount = usdcText(a.done === true ? a.sentAtomic ?? a.amountAtomic : a.amountAtomic);
     const what = amount ? `${amount} USDC` : "the USDC";
     if (a.done !== true) return `Sending ${what} privately to ${a.to}.`;
+    if (a.replayed === true) {
+      const ago = Number.isSafeInteger(a.finishedMinutesAgo) ? a.finishedMinutesAgo > 0 ? ` about ${minutesText(a.finishedMinutesAgo)} ago` : " under a minute ago" : " earlier";
+      return `Already sent${ago}: ${what} to ${a.to}. This request moved nothing new.`;
+    }
     const took = Number.isSafeInteger(a.joinedParts) && a.joinedParts > 1 && Number.isSafeInteger(a.tookSeconds) && a.tookSeconds >= 0 ? ` It took about ${a.tookSeconds} s because the wallet first joined your balance's ${a.joinedParts} parts.` : "";
     if (typeof a.exitTransaction === "string" && a.privateSend === void 0) {
       const head = `Sent ${what} to ${a.to} (transaction ${a.exitTransaction}).`;
@@ -110342,7 +110403,7 @@ function plainFields(parsed2, toolName) {
 function withSay(tool, options = {}) {
   return { ...tool, run: async (args, ctx) => addSay(await tool.run(args, ctx), tool.name, options) };
 }
-var SAY_MAX_WORDS, DECIMALS, ATOMIC3, SAY_FIRST, SAY_BANNED, CODE_TOKEN, LONG_NUMBER, REFUND_MINUTES, MOVE_LINE, minutesText, MOVING_ROLES, CLOSE_LATER, PAY_CAP_CODES, raiseLine, MOVE_CAP_CODES, OWNER_LIMIT_CODES, INSUFFICIENT, BUSY, SHIELD_TOOLS, words, positive, str, OWN_WORK_WORDS, DISCOVER_LIST_NAMES, TRANSFER_TOOLS;
+var SAY_MAX_WORDS, DECIMALS, ATOMIC3, SAY_FIRST, SAY_BANNED, CODE_TOKEN, LONG_NUMBER, REFUND_MINUTES, MOVE_LINE, minutesText, ageWords, MOVING_ROLES, CLOSE_LATER, PAY_CAP_CODES, raiseLine, MOVE_CAP_CODES, OWNER_LIMIT_CODES, INSUFFICIENT, BUSY, SHIELD_TOOLS, words, positive, str, OWN_WORK_WORDS, DISCOVER_LIST_NAMES, TRANSFER_TOOLS;
 var init_say = __esm({
   "wallet/src/mcp/say.mjs"() {
     "use strict";
@@ -110358,6 +110419,7 @@ var init_say = __esm({
     REFUND_MINUTES = 7;
     MOVE_LINE = "Your balance is moving to an upgraded pool by itself. Nothing to do.";
     minutesText = (n) => `${n} minute${Number(n) === 1 ? "" : "s"}`;
+    ageWords = (minutes) => minutes < 60 ? minutesText(minutes) : `${Math.round(minutes / 60)} hour${Math.round(minutes / 60) === 1 ? "" : "s"}`;
     MOVING_ROLES = /* @__PURE__ */ new Set(["draining", "old pool (switching)"]);
     CLOSE_LATER = "Cannot close yet: the seller could still take this payment. Ask again in about 2 minutes; if unpaid, it closes and the money comes back.";
     PAY_CAP_CODES = /* @__PURE__ */ new Set(["spend_payment_cap_exceeded", "mcp_cap_argument_above_launch_cap"]);
@@ -122379,7 +122441,8 @@ ${canonical5}`;
       const numbers = ASK_PAY_CODES.has(refusal3.error) || refusal3.error === "mcp_session_cap_exceeded" ? capNumbers(refusal3) : {};
       const launch = policy.limits.maxPaymentAtomic;
       if (refusal3.error === "spend_payment_cap_exceeded" && numbers.totalAtomic && numbers.capAtomic && BigInt(numbers.capAtomic) < BigInt(launch) && BigInt(numbers.totalAtomic) <= BigInt(launch)) {
-        return refuse12(refusal3.error, refusal3.detail, `Nothing was paid. This costs ${usdcText2(numbers.totalAtomic)} USDC, above this call's max_payment of ${usdcText2(numbers.capAtomic)} USDC. If the user agrees, call ${tool} again with request_id "${requestId}" and max_payment "${usdcText2(numbers.totalAtomic)}" (the limit is ${usdcText2(launch)} USDC)`, { requestId, ...numbers });
+        const limitWords = String(launch) === NO_LIMIT_ATOMIC2 ? "this wallet has no per-payment limit" : `the wallet's per-payment limit is ${usdcText2(launch)} USDC`;
+        return refuse12(refusal3.error, refusal3.detail, `Nothing was paid. This costs ${usdcText2(numbers.totalAtomic)} USDC, above this call's max_payment of ${usdcText2(numbers.capAtomic)} USDC. If the user agrees, call ${tool} again with request_id "${requestId}" and max_payment "${usdcText2(numbers.totalAtomic)}" (${limitWords})`, { requestId, ...numbers, capKind: "call" });
       }
       return refuse12(refusal3.error, refusal3.detail, mcpNext(refusal3.error, refusal3.detail, refusal3.next, refusal3), { requestId, ...numbers });
     }
@@ -122715,11 +122778,12 @@ ${canonical5}`;
       if (rows2.length === count2 && nextMs >= 0 && nextMs + 2e3 < rows2[count2 - 1].at) return rows2;
     }
   }
-  function walletCard({ one, unshielded, landingAtomic, parts, store }) {
+  function walletCard({ one, unshielded, landingAtomic, parts, store, lastRead }) {
     const known = ATOMIC_TEXT.test(String(one.balanceAtomic ?? ""));
     const landing = landingAtomic > 0n ? `; ${usdcText2(landingAtomic)} USDC you added is being counted` : "";
     const split5 = parts?.parts > 1 ? ` (in ${parts.parts} parts: a send of all of it joins them first, about ${minutesText2(parts.minutes)})` : "";
-    const lines = [known ? `Private balance: ${usdcText2(one.balanceAtomic)} USDC${split5}${landing}` : `Private balance: not known yet (the wallet is still reading it)${landing}`];
+    const reading = lastRead ? `the wallet is still reading it; the last full read, ${ageWords2(lastRead.ageMinutes)} ago, showed ${usdcText2(lastRead.privateAtomic)} USDC` : "the wallet is still reading it";
+    const lines = [known ? `Private balance: ${usdcText2(one.balanceAtomic)} USDC${split5}${landing}` : `Private balance: not known yet (${reading})${landing}`];
     lines.push(ATOMIC_TEXT.test(String(unshielded.unshieldedAtomic ?? "")) ? `Public USDC on this wallet's own key: ${usdcText2(unshielded.unshieldedAtomic)} USDC` : "Public USDC on this wallet's own key: not read yet");
     let mode;
     try {
@@ -123001,6 +123065,10 @@ ${canonical5}`;
       else if (one.balanceAtomic === "0" && shieldEnabled) {
         next = elsewhereEnabled ? `the shielded balance is 0, so x402_pay cannot pay yet. To add funds, call wallet_add_funds: it gives a one-time address; up to ${usdcText2(payMeRoundMax())} USDC sent there on Solana becomes private a few minutes after it arrives while this MCP server runs (or call wallet_add_funds with its request_id to finish it at once)` : `the shielded balance is 0, so x402_pay cannot pay yet. To add funds: send USDC on Solana to ownAddress (this wallet's own key), then call wallet_shield with amount (any amount from ${usdcText2(10000n)} to ${usdcText2(MAX_SHIELDED_BALANCE_ATOMIC)} USDC)`;
       } else next = "nothing to do; x402_pay pays from balanceAtomic, wallet_unshield sends from breakdown.shieldedAtomic";
+      const lastRead = one.balanceAtomic === null && refresh.refreshing === true && !firstRead && ATOMIC_TEXT.test(String(report.detail?.unspentAtomic ?? "")) && Number.isFinite(report.detail?.lastRefresh?.ageSeconds) ? { privateAtomic: String(report.detail.unspentAtomic), ageMinutes: Math.max(1, Math.round(report.detail.lastRefresh.ageSeconds / 60)) } : void 0;
+      if (lastRead) {
+        next = `${next}. Meanwhile tell the user: the last full read, ${ageWords2(lastRead.ageMinutes)} ago, showed ${usdcText2(lastRead.privateAtomic)} USDC private (lastRead); a payment or a refund since then is not in it, so it is not the balance now`;
+      }
       let landingAtomic = 0n;
       try {
         landingAtomic = landedNotCounted(store);
@@ -123111,7 +123179,7 @@ ${canonical5}`;
       }
       const balanceParts = parts?.parts > 1 && ATOMIC_TEXT.test(String(one.balanceAtomic ?? "")) ? parts.parts : void 0;
       if (balanceParts && !sendWaiting) {
-        next = `${next}. The balance is in ${balanceParts} parts: if the user asks to send all of it, tell them first that it takes about ${minutesText2(parts.minutes)}`;
+        next = `${next}. The balance is in ${balanceParts} parts, and a send of all of it joins them first: it takes about ${minutesText2(parts.minutes)}. If the user asks to send all of it, write that time to the user BEFORE you call wallet_unshield (some apps show nothing until that call ends)`;
       }
       if (earlierDeposits.length) next = `${next}. Tell the user each earlierDeposits notice`;
       const notices = takeRefundNotices();
@@ -123175,7 +123243,8 @@ ${canonical5}`;
         ...firstRead ? { status: "reading" } : {},
         balanceAtomic: one.balanceAtomic,
         balance: one.balance,
-        card: walletCard({ one, unshielded, landingAtomic, parts, store }),
+        card: walletCard({ one, unshielded, landingAtomic, parts, store, lastRead }),
+        ...lastRead ? { lastRead } : {},
         // joinMinutes: the card's minutes, so say.mjs names them too.
         ...balanceParts ? { balanceParts, ...Number.isSafeInteger(parts.minutes) ? { joinMinutes: parts.minutes } : {} } : {},
         ...report.detail ? { detail: detailPublic } : {},
@@ -125047,10 +125116,11 @@ ${canonical5}`;
     }
     return answer;
     async function startOrRead() {
+      const freshId = `${request.requestId.slice(0, 110)}-${Date.now().toString(36)}`;
       const reused = (detail) => refuse12(
         "mcp_request_id_reused",
         detail,
-        `read this one with the arguments it started with, or start a new ${spec.noun} with a NEW request_id`,
+        `read this one with the arguments it started with, or start a new ${spec.noun} with a NEW request_id such as "${freshId}" (or leave request_id out and the wallet makes one)`,
         { requestId: request.requestId }
       );
       const known = jobs.get(key);
@@ -125143,6 +125213,9 @@ ${canonical5}`;
         const finished = kind === "unshield" ? split5 ? record.state === "done" || record.state === "cancelled" && privateSendStatus(store, record).done : record.state === "exited" : ["published", "foreign_funded"].includes(record.state);
         if (finished) {
           const send3 = split5 ? privateSendStatus(store, record) : void 0;
+          const endedAtMs = Date.parse(String(record.doneAt ?? record.cancelledAt ?? "")) || record.exitedAtMs;
+          const earlier = kind === "unshield" ? { replayed: true, ...Number.isSafeInteger(endedAtMs) ? { finishedMinutesAgo: Math.max(0, Math.round((Date.now() - endedAtMs) / 6e4)) } : {} } : {};
+          const earlierWords = earlier.finishedMinutesAgo !== void 0 ? ` about ${minutesText2(earlier.finishedMinutesAgo)} ago` : " earlier";
           return json3({
             ok: true,
             requestId: request.requestId,
@@ -125152,10 +125225,11 @@ ${canonical5}`;
             done: true,
             stage: "done",
             state: record.state,
+            ...earlier,
             ...kind !== "unshield" ? { transaction: typeof record.receipt?.signature === "string" ? record.receipt.signature : null } : split5 ? sendHeadline(send3) : { selfPayTransaction: record.transaction ?? null, exitTransaction: record.exitTransaction ?? null },
             ...kind === "elsewhere" ? elsewhereFacts(request.requestId, record) : {},
             ...kind !== "unshield" && record.state === "foreign_funded" ? { fundedByThisWallet: false } : {},
-            next: kind === "unshield" ? split5 ? sendDoneNext(record.mcpTo ?? request.to, send3) : "the unshield is done; nothing more to do" : record.state === "foreign_funded" ? kind === "elsewhere" ? `another key landed this deposit's note first, so the USDC sent to the one-time address did not move; it stays the user's there, and ${reclaimHow(request.requestId)}. wallet_balance shows the shielded value (it reads the chain by itself)` : "another key funded this deposit; this wallet's unshielded USDC did not move. wallet_balance shows the shielded value (it reads the chain by itself)" : "the deposit is done; wallet_balance shows it (it reads the chain by itself)"
+            next: kind === "unshield" ? `This request_id finished${earlierWords}; this call sent nothing new. ${split5 ? sendDoneNext(record.mcpTo ?? request.to, send3).replace(/^the/, "The") : "The unshield is done; nothing more to do"}. To send again, call wallet_unshield with a NEW request_id, or leave request_id out and the wallet makes one` : record.state === "foreign_funded" ? kind === "elsewhere" ? `another key landed this deposit's note first, so the USDC sent to the one-time address did not move; it stays the user's there, and ${reclaimHow(request.requestId)}. wallet_balance shows the shielded value (it reads the chain by itself)` : "another key funded this deposit; this wallet's unshielded USDC did not move. wallet_balance shows the shielded value (it reads the chain by itself)" : "the deposit is done; wallet_balance shows it (it reads the chain by itself)"
           });
         }
         if (kind === "elsewhere" && record.state === "reclaimed" && record.relay.abandoned) {
@@ -126295,7 +126369,7 @@ ${canonical5}`;
   const unshield = {
     name: "wallet_unshield",
     title: "Send USDC privately from the shielded balance",
-    description: `Use this when the user says "send 2 USDC to <address>" or "withdraw to my wallet" (leave \`to\` out for the owner's own wallet when one is set): it sends amount (USDC, like "2"; or amount_atomic) from the SHIELDED balance as plain USDC to \`to\`, a public Solana address (the USDC goes to its USDC token account). 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. The facilitator pays every network fee; no SOL is needed. The owner's --unshield-to addresses send at once. Any other address is sent only after the user confirms it in the MCP client (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 hold USDC (have a USDC token account): an address without one is refused before any dialog (mcp_unshield_to_invalid). It takes minutes (one wait of up to 5 minutes is normal): the call answers within about 20 s with stage (confirming, queued, refreshing, self-pay = preparing, exit = sending, done; joining = the balance is in several parts and the wallet joins them first, then sends; the answer says how many more asks and when (joinAsks, joinMinutes), 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). One exception: for a single send (no parts, no delay) whose balance is in several parts, when this MCP app sends a progress token with the call, that one call joins the parts and then sends, taking up to ${JOIN_CALL_MAX_MS / 6e4} minutes, with a progress line every ${JOIN_STEP_MS / 1e3} s ("joining your balance's N parts first (about M min)"). Some apps show nothing during this call: BEFORE it, when wallet_balance shows balanceParts above 1, tell the user that sending all of it first joins the parts and takes about the minutes wallet_balance names. Without a progress token it answers within about 20 s with stage joining and when to ask again. 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 owner cap (--max-unshield) may bound each call and what this wallet sends in any 24 hours, from every MCP process (mcp_unshield_cap_exceeded: tell the owner). 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. PRIVATE SEND (optional): when the user says "send it in parts", "spread it out", or "do not send it all at once", pass parts (2-8) WITH max_delay_minutes (1-60; parts with no wait are refused: they would leave together): the amount is split into parts exits of unequal size (each at least 0.01 USDC), each sent after a random wait of up to max_delay_minutes (part 1 too), so the chain shows no single exit of this amount at this time. max_delay_minutes alone delays one exit. ` + SEND_RUNS_ON + ` Late parts never go together. While parts are unsent, x402_pay may spend only the rest of the balance. The plan is saved in the wallet before part 1, so the same request_id (with the same parts and max_delay_minutes) continues after a restart and never sends a part twice; the answer's privateSend lists each part (state, amount, when it may go, transactions), sentAtomic, and remainingAtomic. The user confirms the whole send once. Both left out: one exit, as before. Each part is a full unshield, so it takes as long as one, and the facilitator pays the network fee of each. Privacy limit: every part goes to the SAME \`to\`, so anyone who adds up that address's incoming transfers sees the total; the parts hide the time and the single amount of the exit, not the sum the address received. wallet_cancel with the same request_id stops the parts not sent yet (their value stays in the shielded balance); while a part is being sent, that call waits for the part to finish, up to about ${CALL_BUDGET_MS / 1e3} s.`,
+    description: `Use this when the user says "send 2 USDC to <address>" or "withdraw to my wallet" (leave \`to\` out for the owner's own wallet when one is set): it sends amount (USDC, like "2"; or amount_atomic) from the SHIELDED balance as plain USDC to \`to\`, a public Solana address (the USDC goes to its USDC token account). BEFORE you call it to send all of the balance when wallet_balance showed balanceParts above 1, write to the user that it takes about joinMinutes minutes (the wallet first joins the parts; 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. The facilitator pays every network fee; no SOL is needed. The owner's --unshield-to addresses send at once. Any other address is sent only after the user confirms it in the MCP client (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 hold USDC (have a USDC token account): an address without one is refused before any dialog (mcp_unshield_to_invalid). It takes minutes (one wait of up to 5 minutes is normal): the call answers within about 20 s with stage (confirming, queued, refreshing, self-pay = preparing, exit = sending, done; joining = the balance is in several parts and the wallet joins them first, then sends; the answer says how many more asks and when (joinAsks, joinMinutes), 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). One exception: for a single send (no parts, no delay) whose balance is in several parts, when this MCP app sends a progress token with the call, that one call joins the parts and then sends, taking up to ${JOIN_CALL_MAX_MS / 6e4} minutes, with a progress line every ${JOIN_STEP_MS / 1e3} s ("joining your balance's N parts first (about M min)"; some apps show none of them, so the time is said before the call, as above). Without a progress token it answers within about 20 s with stage joining and when to ask again. 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 owner cap (--max-unshield) may bound each call and what this wallet sends in any 24 hours, from every MCP process (mcp_unshield_cap_exceeded: tell the owner). 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. PRIVATE SEND (optional): when the user says "send it in parts", "spread it out", or "do not send it all at once", pass parts (2-8) WITH max_delay_minutes (1-60; parts with no wait are refused: they would leave together): the amount is split into parts exits of unequal size (each at least 0.01 USDC), each sent after a random wait of up to max_delay_minutes (part 1 too), so the chain shows no single exit of this amount at this time. max_delay_minutes alone delays one exit. ` + SEND_RUNS_ON + ` Late parts never go together. While parts are unsent, x402_pay may spend only the rest of the balance. The plan is saved in the wallet before part 1, so the same request_id (with the same parts and max_delay_minutes) continues after a restart and never sends a part twice; the answer's privateSend lists each part (state, amount, when it may go, transactions), sentAtomic, and remainingAtomic. The user confirms the whole send once. Both left out: one exit, as before. Each part is a full unshield, so it takes as long as one, and the facilitator pays the network fee of each. Privacy limit: every part goes to the SAME \`to\`, so anyone who adds up that address's incoming transfers sees the total; the parts hide the time and the single amount of the exit, not the sum the address received. wallet_cancel with the same request_id stops the parts not sent yet (their value stays in the shielded balance); while a part is being sent, that call waits for the part to finish, up to about ${CALL_BUDGET_MS / 1e3} s.`,
     inputSchema: {
       type: "object",
       properties: {
@@ -127287,7 +127361,8 @@ ${canonical5}`;
   const transferReused = (id) => refuse12(
     "mcp_request_id_reused",
     `request_id "${id}" already names a transfer with another token_mint, amount_atomic, to, parts, max_delay_minutes, or max_slippage_bps; nothing new was signed`,
-    `read it with wallet_transfer_token_status and request_id "${id}", or start a new transfer with a NEW request_id`,
+    // K28 T7 (2026-10-23): the agent hit this twice before it found a free id; next names one that is new (TRANSFER_ID: at most 40).
+    `read it with wallet_transfer_token_status and request_id "${id}", or start a new transfer with a NEW request_id such as "${id.slice(0, 31)}-${Date.now().toString(36)}"`,
     { requestId: id }
   );
   async function beginTransfer(args, call3 = {}) {
@@ -128003,7 +128078,7 @@ ${canonical5}`;
             return refuse12(
               "p03_float_over_maximum",
               floatRefusal(error)[1],
-              `Nothing was paid. Call inference_chat again with max_payment_atomic of at least ${error?.paidAtomic ?? "price + fee"} if the spending limit allows it, or lower max_tokens`,
+              `Nothing was paid. Call inference_chat again with max_payment of at least ${total !== void 0 ? `"${usdcText2(total)}"` : "price + fee"} (USDC) if the spending limit allows it, or lower max_tokens`,
               { requestId, paid: false, ...facts }
             );
           }
@@ -128731,7 +128806,7 @@ function createSetupTools({
   };
   return { tools: [setupTool, statusTool, ...MCP_TOOL_NAMES.map((name) => name === "x402_discover" ? discoverTool(discoverCacheDir) : notSetUp(name))], 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, MONEY_FIRST_ANSWER_MS, BALANCE_AFTER_LANDING_MS, JOIN_CALL_MAX_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, terminalCommand, capRaiseText, cheaperSellerText, limitNext, SAFE_TEXT, MCP_TOOL_ALIASES, POOL_SWITCH_WHY, POOL_SWITCH_NEXT, SWITCH_STATES, quietSwitch, switchKey, ATOMIC_TEXT, 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, MCP_CAP_FIX, capFix, ownerOnlyNext, mcpNext, CONFIDENTIAL_RETIRED, json3, answerResult, discoverTool, refuse12, publicOffer, FLOAT_PAID_CODES, FLOAT_PRIVATE_LEG, floatStillSettling, MONEY_ID2, toRecordId, linkKindOf, moneyId, REFUSED_CODES, refusedCodeOf, PLAIN_REASONS, plainReason, KEPT_SEND_TRIES, shownId, isSplitSend, sendPartId, PROMISED_NEXT, PUBLIC_READ_TIMEOUT_MS, withTimeout, ownKey, readFailure, OWN_KEY_TOKENS_MAX, OWN_TOKENS_GRACE_MS, tokenAmountText, elsewhereId, AGENT_ID_SCHEMA, agentIdName, minutesText2, DEPOSIT_SENT_STATES, depositLanded, usdcText2, walkWalletHistory, REFRESH_LEASE_WALK_MS, HOME_MARKS_SETTLED_MS2, AUTO_BACKUPS_KEPT, AUTO_BACKUP_NAME, AUTO_BACKUP_VERIFIED, FRONTED_SETTLE_MARGIN_SLOTS, BALANCE_REFRESH_WAIT_MS, BALANCE_REFRESH_GRACE_MS, BALANCE_REFRESH_LONG_MS, INBOUND_REFRESH_AGE_MS, 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, SWITCH_WAIT_MS, UNSHIELD_TO_NO_USDC_DETAIL, UNSHIELD_TO_INVALID_NEXT, INFERENCE_MIN_MAX_TOKENS, ELICIT_TIMEOUT_MS, ELICIT_UNSHOWN_MS, elicitUnshown, POLL_SECONDS3, 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_POLL_NEXT, PRIVATE_INFERENCE_WHY, PRIVATE_INFERENCE_NEXT;
+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, MONEY_FIRST_ANSWER_MS, BALANCE_AFTER_LANDING_MS, JOIN_CALL_MAX_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, terminalCommand, capRaiseText, cheaperSellerText, limitNext, SAFE_TEXT, MCP_TOOL_ALIASES, POOL_SWITCH_WHY, POOL_SWITCH_NEXT, SWITCH_STATES, quietSwitch, switchKey, ATOMIC_TEXT, 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, MCP_CAP_FIX, capFix, ownerOnlyNext, mcpNext, CONFIDENTIAL_RETIRED, json3, answerResult, discoverTool, refuse12, publicOffer, FLOAT_PAID_CODES, FLOAT_PRIVATE_LEG, floatStillSettling, MONEY_ID2, toRecordId, linkKindOf, moneyId, REFUSED_CODES, refusedCodeOf, PLAIN_REASONS, plainReason, KEPT_SEND_TRIES, shownId, isSplitSend, sendPartId, PROMISED_NEXT, PUBLIC_READ_TIMEOUT_MS, withTimeout, ownKey, readFailure, OWN_KEY_TOKENS_MAX, OWN_TOKENS_GRACE_MS, tokenAmountText, elsewhereId, AGENT_ID_SCHEMA, agentIdName, minutesText2, ageWords2, DEPOSIT_SENT_STATES, depositLanded, usdcText2, walkWalletHistory, REFRESH_LEASE_WALK_MS, HOME_MARKS_SETTLED_MS2, AUTO_BACKUPS_KEPT, AUTO_BACKUP_NAME, AUTO_BACKUP_VERIFIED, FRONTED_SETTLE_MARGIN_SLOTS, BALANCE_REFRESH_WAIT_MS, BALANCE_REFRESH_GRACE_MS, BALANCE_REFRESH_LONG_MS, INBOUND_REFRESH_AGE_MS, 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, SWITCH_WAIT_MS, UNSHIELD_TO_NO_USDC_DETAIL, UNSHIELD_TO_INVALID_NEXT, INFERENCE_MIN_MAX_TOKENS, ELICIT_TIMEOUT_MS, ELICIT_UNSHOWN_MS, elicitUnshown, POLL_SECONDS3, 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_POLL_NEXT, PRIVATE_INFERENCE_WHY, PRIVATE_INFERENCE_NEXT;
 var init_tools = __esm({
   "wallet/src/mcp/tools.mjs"() {
     "use strict";
@@ -129074,6 +129149,7 @@ var init_tools = __esm({
     AGENT_ID_SCHEMA = "shinjuku-mcp-agent-id-v1";
     agentIdName = (kind, recordId2) => `mcp-agent-id-${kind}-${recordId2}`;
     minutesText2 = (n) => `${n} minute${Number(n) === 1 ? "" : "s"}`;
+    ageWords2 = (minutes) => minutes < 60 ? minutesText2(minutes) : `${Math.round(minutes / 60)} hour${Math.round(minutes / 60) === 1 ? "" : "s"}`;
     DEPOSIT_SENT_STATES = /* @__PURE__ */ new Set(["signed", "finalized", "published"]);
     depositLanded = (deposit) => deposit?.schema === DEPOSIT_WAL_SCHEMA && (["finalized", "published"].includes(deposit.state) || deposit.state === "submitted" && typeof deposit.relay?.result?.signature === "string" && deposit.relay.result.signature.length > 0);
     usdcText2 = (atomic4, decimals = 6) => {
@@ -130249,6 +130325,7 @@ var init_stdioServer = __esm({
     init_session();
     init_payAndFetch();
     init_compact();
+    init_recover();
     init_recoveredPayment();
     init_recoveryBundle();
     init_rpcDefault();
@@ -130292,7 +130369,7 @@ var init_stdioServer = __esm({
     MCP_CLOSE_HISTORY_BOUND_MS = 45e3;
     MCP_CLOSE_UNREADABLE_BOUND_MS = 6e4;
     MCP_CLOSE_POLL_MS = 500;
-    closeHistoryBusy = (server) => () => compactHistoryReadsRunning() > 0 || server.refreshOpen?.() === true;
+    closeHistoryBusy = (server) => () => compactHistoryReadsRunning() > 0 || memoReadsAheadRunning() > 0 || server.refreshOpen?.() === true;
     SETUP_INSTRUCTIONS = `A self-custody Shinjuku Shield wallet server that is NOT SET UP on this machine yet. Every money tool answers wallet_not_set_up. When the user wants to pay, check a balance, or shield USDC, call shinjuku_setup: it asks the user to confirm in this client, then creates the wallet on this machine (the keys and a random passphrase stay in local files; no tool takes or returns them) and downloads and checks the proof tools. It takes minutes: call shinjuku_setup again as its answer's next says. When it answers stage done, the wallet tools are live in this same server (tools/list changes). ${INSTRUCTIONS}`;
   }
 });
@@ -151025,6 +151102,7 @@ import { resolve as resolve39 } from "node:path";
 // wallet/src/cli/shinjukuWallet.mjs
 init_fs();
 var import_web3138 = __toESM(require_index_cjs(), 1);
+init_esm2();
 init_shielded_wallet();
 init_walk();
 init_cli();
@@ -155684,6 +155762,7 @@ init_store();
 init_processLease();
 init_notes2();
 init_proxy();
+init_autoJoin();
 init_torMissingMcp();
 init_chain2();
 init_session();
@@ -156040,6 +156119,8 @@ var GUIDE = Object.freeze({
   facilitator: DEFAULT_FACILITATOR_ORIGIN
 });
 var WALLET_FILE = `"$SHIELDED_WALLET_HOME/${GUIDE.pool}/wallet.json"`;
+var FROM_SETUP = " (after setup, config.json gives it: no need to type it)";
+var UNSHIELD_EXAMPLE = `${CLI2} unshield --amount 0.5 --to <your wallet address>`;
 function hintForThisRun(text3, values) {
   let hint = String(text3);
   const get = (name) => {
@@ -157101,23 +157182,35 @@ function setupConfigOf(home) {
   }
 }
 function torArgv(argv2, env = process.env) {
-  if (!argv2.includes("--tor") || argv2.includes("--proxy")) return argv2;
   const rest = withoutConnectionFlags(argv2);
   const command2 = rest[0];
-  if (command2 === void 0 || command2.startsWith("-") || command2 === "setup") return argv2;
-  if (command2 === "mcp" && (argv2.includes("--pool") || argv2.includes("--wallet"))) return argv2;
   const walletAt = rest.indexOf("--wallet");
   const walletFile = walletAt >= 0 ? rest[walletAt + 1] : void 0;
   const walletHome2 = walletFile && !walletFile.startsWith("--") ? dirname32(dirname32(resolve38(walletFile))) : void 0;
   const home = walletHome2 && existsSync(join39(walletHome2, "config.json")) ? walletHome2 : setupHome(env);
-  let tunnel;
+  let config;
   try {
-    tunnel = readSetupConfig(home)?.torTunnel;
+    config = readSetupConfig(home);
   } catch {
-    tunnel = void 0;
+    config = void 0;
   }
-  return tunnel ? [...argv2, "--proxy", tunnel] : argv2;
-}
+  const ownTor = command2 === void 0 || command2.startsWith("-") || OWN_TOR_COMMANDS.has(command2);
+  let out = argv2;
+  if (argv2.includes("--no-tor")) {
+    env[NO_TOR_RUN_ENV] = "1";
+    if (!ownTor) out = argv2.filter((word) => word !== "--no-tor");
+  } else if (!ownTor && config?.tor === true && env[NO_TOR_RUN_ENV] !== "1" && !argv2.includes("--tor") && !argv2.includes("--proxy")) {
+    env[TOR_FROM_CONFIG_ENV] = "1";
+    out = [...argv2, "--tor"];
+  }
+  if (!out.includes("--tor") || out.includes("--proxy")) return out;
+  if (command2 === void 0 || command2.startsWith("-") || command2 === "setup") return out;
+  if (command2 === "mcp" && (out.includes("--pool") || out.includes("--wallet"))) return out;
+  const tunnel = config?.torTunnel;
+  return tunnel ? [...out, "--proxy", tunnel] : out;
+}
+var OWN_TOR_COMMANDS = /* @__PURE__ */ new Set(["mcp", "setup", "chat", "infer"]);
+var NO_TOR_RUN_ENV = "SHINJUKU_WALLET_NO_TOR";
 function fillFromConfig(values, home, config) {
   for (const [name, value] of mcpFlagsFromConfig(home, config)) if (!values.has(name)) values.set(name, value);
 }
@@ -157501,8 +157594,12 @@ function usdcArgs(command2, args) {
     if (value === void 0 || value.startsWith("--")) continue;
     index += 1;
     if (!spec.usdc || spec.usdc === "or-none" && /^none$/i.test(value)) continue;
+    if (spec.usdc === "or-all" && /^all$/i.test(value)) {
+      out[index] = "all";
+      continue;
+    }
     const read = usdcFlagAtomic(spec.name, value, { oldForm: command2.name === "mcp" ? "atomic" : "refuse" });
-    if (read.error) throw new UsageError(read.error, command2);
+    if (read.error) throw new UsageError(spec.usdc === "or-all" ? `${read.error}; or ${spec.name} all sends the whole private balance` : read.error, command2);
     if (read.old) oldForm.push(read.old);
     out[index] = read.atomic;
   }
@@ -158223,7 +158320,8 @@ var COMMANDS = [
       flag2("--pool", "<address>", "the shielded pool", { required: true, check: "pubkey" }),
       bool2("--refresh", "run the same chain walk as recover first (network)"),
       // --digests narrows recover's printed output; a balance needs the whole history.
-      ...recoverFlags({ refreshOnly: true }).filter((entry) => entry.name !== "--digests")
+      ...recoverFlags({ refreshOnly: true }).filter((entry) => entry.name !== "--digests"),
+      bool2("--json", "print the whole report as JSON in a terminal too (a file or a program gets JSON without this flag)")
     ],
     examples: [
       `${CLI2} balance --pool ${GUIDE.pool}`,
@@ -158234,6 +158332,7 @@ var COMMANDS = [
       "shinjukuShielded is what you can spend: unspent accounts and notes minus the ones in-flight payments or unshields will use.",
       "Without --refresh, balance reads only local files: the last walk (recover or balance --refresh) and the wallet log. It makes no network call.",
       "shinjukuShielded is null when the last walk is missing, stale, or incomplete. reasons says why; next shows the command to run.",
+      "In a terminal it prints one plain line: the private balance in USDC, and a short reason when it is not current (then the command to run). A program, or --json, gets the whole report as JSON (total, shinjukuShielded, status, reasons, next, detail).",
       "Payments that others send to this wallet appear only after a refresh.",
       "With --refresh it also reads the one-time deposit addresses of this home's earlier pools (one address per request). USDC found there goes into this pool by itself (the facilitator pays the fee), and earlierDeposits lists each one with a notice.",
       "paymentsWithoutWaiting (and detail.fundedAccounts): your funded accounts that no in-flight work holds. A payment spends one account, and its change pays only after the next pool anchor (up to 5 minutes; about 30 s on some pools), so this many payments can run before the next anchor without waiting (an account made since the last anchor, such as a change, waits for the next one). add-funds --split makes more of them."
@@ -158247,7 +158346,7 @@ var COMMANDS = [
         }
         return;
       }
-      const extra = [...values.keys()].find((name) => name !== "--pool");
+      const extra = [...values.keys()].find((name) => name !== "--pool" && name !== "--json");
       if (extra) throw new UsageError(`${extra} is used only with --refresh`);
     },
     rpcWhen: (values) => values.has("--refresh"),
@@ -158679,45 +158778,42 @@ var COMMANDS = [
   },
   {
     name: "unshield",
-    summary: "Send part of your balance to a public USDC account, privately.",
+    summary: "Send part or all of your private balance to a Solana wallet address, privately.",
     env: [],
     flags: [
-      flag2("--wallet", "<file>", "the encrypted wallet file", { required: true }),
-      flag2("--passphrase-file", "<file>", "a private file that holds the wallet passphrase", { required: true }),
+      flag2("--amount", "<usdc|all>", "USDC to send (0.5 = 50 cents), or all: the whole private balance", { required: true, check: "atomic", usdc: "or-all" }),
+      flag2("--to", "<address>", "the recipient's Solana wallet address (it gets the USDC in its USDC account). Not this wallet's own address. With --recipient-owner (the old form): the recipient's USDC token account itself", { required: true, check: "pubkey" }),
+      flag2("--unshield-id", "<id>", "optional: your name for this unshield. Without it the wallet makes a new one and prints it; to finish an unshield that stopped, run it again with that --unshield-id (it never sends twice)"),
+      flag2("--wallet", "<file>", `the encrypted wallet file${FROM_SETUP}`, { required: true }),
+      flag2("--passphrase-file", "<file>", `a private file that holds the wallet passphrase${FROM_SETUP}`, { required: true }),
       flag2("--rpc-file", "<file>", RPC_FILE_ABOUT),
-      flag2("--payer-proof-tools", "<file>", "the public payer proof-tools manifest", { required: true }),
-      flag2("--exit-proof-tools", "<file>", "the public exit proof-tools manifest", { required: true }),
-      flag2("--profile", "<file>", "the facilitator's public seller profile (public-profile.json)", { required: true }),
-      flag2("--program", "<address>", "the shielded pool program", { required: true, check: "pubkey" }),
-      flag2("--facilitator", "<https origin>", "the facilitator's https origin", { required: true, check: "origin" }),
-      flag2("--unshield-id", "<id>", "your name for this unshield; reuse it for every retry", { required: true }),
-      flag2("--amount", "<usdc>", "USDC to send (0.5 = 50 cents)", { required: true, check: "atomic", usdc: true }),
-      flag2("--to", "<token account>", "the recipient's USDC token account", { required: true, check: "pubkey" }),
-      flag2("--recipient-owner", "<address>", "the owner of that token account (not your deposit key)", { required: true, check: "pubkey" }),
+      flag2("--payer-proof-tools", "<file>", `the public payer proof-tools manifest${FROM_SETUP}`, { required: true }),
+      flag2("--exit-proof-tools", "<file>", `the public exit proof-tools manifest${FROM_SETUP}`, { required: true }),
+      flag2("--profile", "<file>", `the facilitator's public seller profile (public-profile.json)${FROM_SETUP}`, { required: true }),
+      flag2("--program", "<address>", `the shielded pool program${FROM_SETUP}`, { required: true, check: "pubkey" }),
+      flag2("--facilitator", "<https origin>", `the facilitator's https origin${FROM_SETUP}`, { required: true, check: "origin" }),
+      flag2("--recipient-owner", "<address>", "optional, the old form: with it, --to is a USDC token account and this is its owner (not your deposit key)", { check: "pubkey" }),
       HISTORY_RPC_FLAG,
       flag2("--parts", "<1-8>", "optional, default 1: send the amount as this many separate exits of unequal size (a private send); each part carries at least 0.01 USDC; above 1 it needs --max-delay-minutes 1-60, and --unshield-id may then be at most 45 characters", { check: "count" }),
-      flag2("--max-delay-minutes", "<0-60>", "optional, default 0: each part, part 1 included, is sent after a random wait of up to this many minutes; a part that is late (the command was stopped) waits a new random time", { check: "count" })
-    ],
-    examples: [
-      `${CLI2} unshield --wallet ${WALLET_FILE} --passphrase-file passphrase.txt --payer-proof-tools proof-tools.json --exit-proof-tools exit-proof-tools.json --profile public-profile.json --program ${GUIDE.program} --facilitator ${GUIDE.facilitator}/ --unshield-id u1 --amount 0.003 --to <recipient USDC account> --recipient-owner <recipient owner>`,
-      `${CLI2} unshield --wallet ${WALLET_FILE} --passphrase-file passphrase.txt --payer-proof-tools proof-tools.json --exit-proof-tools exit-proof-tools.json --profile public-profile.json --program ${GUIDE.program} --facilitator ${GUIDE.facilitator}/ --unshield-id s1 --amount 3 --parts 3 --max-delay-minutes 20 --to <recipient USDC account> --recipient-owner <recipient owner>`
+      flag2("--max-delay-minutes", "<0-60>", "optional, default 0: each part, part 1 included, is sent after a random wait of up to this many minutes; a part that is late (the command was stopped) waits a new random time", { check: "count" }),
+      bool2("--json", "end with the result as JSON in a terminal too (a file or a program gets JSON without this flag)")
     ],
+    // T9 (live run 2026-10-23 18:44 UTC, npm 0.3.83): the old two examples looked the same and neither had --amount or a
+    // plain --to; after setup these two work as typed (config.json gives every file flag).
+    examples: [UNSHIELD_EXAMPLE, `${CLI2} unshield --amount all --to <your wallet address>`],
     notes: [
+      "After setup it needs only --amount and --to: config.json gives the wallet, the passphrase file, the proof tools, the profile, the program, and the facilitator. Without setup, give every flag marked required (the old form also takes --to <USDC token account> --recipient-owner <owner>).",
       "The wallet pays exactly --amount to a note it owns and keeps the rest private. The facilitator relays the note's exit to the recipient and pays every fee. No wallet key signs.",
-      "Use a recipient that is NOT your deposit address; the command refuses the deposit key.",
-      "Rerun the same command after any interruption; it replays.",
-      "--parts and --max-delay-minutes make a private send: the plan (part sizes, part ids <unshield-id>-p1.., earliest times) is saved in the wallet before part 1, each part is one unshield, and a stopped run continues at the first part not yet exited when the same command runs again. The wallet is free for other commands while a part waits. Keep the command running until it prints its result.",
-      `Stop the parts of a private send not sent yet: ${CLI2} unshield-cancel --wallet ${WALLET_FILE} --passphrase-file passphrase.txt --unshield-id <id>.`,
+      "The recipient must already hold USDC (a Solana address with a USDC account, for example a Phantom address that received USDC); the command checks it first and sends nothing to an address without one. It refuses this wallet's own address: an exit there would show on chain that the money is yours. Best: an address that never sent USDC into this wallet.",
+      `--amount all sends the whole private balance. When the balance is in more than one part, it says so and sends nothing: join the parts first with ${CLI2} merge (a private move inside this wallet; about 2 minutes per extra part), then run it again.`,
+      "The command prints the unshield id first. If it stops, run the same command with --unshield-id <that id> added: it finishes that unshield and never sends twice.",
+      "In a terminal it ends with one plain line (what was sent, to whom, the exit transaction) and the new private balance: after an exit the wallet reads the balance again itself (the same walk as balance --refresh, over the same connection; Tor when setup recorded it). A program, or --json, gets the result as JSON.",
+      `--parts and --max-delay-minutes make a private send (${CLI2} unshield --amount 3 --parts 3 --max-delay-minutes 20 --to <your wallet address>): the plan (part sizes, part ids <unshield-id>-p1.., earliest times) is saved in the wallet before part 1, each part is one unshield, and a stopped run continues at the first part not yet exited when the same command with its --unshield-id runs again. The wallet is free for other commands while a part waits. Keep the command running until it prints its result.`,
+      `Stop the parts of a private send not sent yet: ${CLI2} unshield-cancel --unshield-id <id>.`,
       "Privacy limit of a private send: every part goes to the same --to, so anyone who adds up that account's incoming transfers sees the total. The parts hide the time and the single amount of the exit, not the sum the account received."
     ],
-    next: `back up (${CLI2} help backup-export), then refresh the balance (${CLI2} help balance)`,
-    run: async (args, values, deps, io) => deps.unshieldMain(await spendGate(
-      args,
-      values,
-      deps,
-      io,
-      { amountAtomic: values.get("--amount"), again: " with the same --unshield-id" }
-    ))
+    next: `back up the wallet (${CLI2} help backup-export); ${CLI2} balance shows the private balance`,
+    run: (args, values, deps, io) => runUnshieldCommand(args, values, deps, io)
   },
   {
     name: "unshield-cancel",
@@ -159190,6 +159286,8 @@ function overviewText() {
     "",
     "Hide your IP, any command:",
     "  --tor                    every request goes through Tor (torrc: HTTPTunnelPort 127.0.0.1:9080 IsolateDestAddr); the run starts only after the tunnel answers as Tor (else check.torproject.org must say IsTor)",
+    '                           after a setup that recorded Tor (config.json "tor": true) every command runs behind Tor by itself; a Tor that does not answer is refused, never a direct run',
+    "  --no-tor                 this one command runs without Tor although setup recorded Tor (the servers then see your IP address)",
     "  --proxy http://host:port another HTTP proxy (never socks5://: Node would send https directly); the run starts only after the proxy answers",
     "  with either, a facilitator may be an http://<v3 onion>/ origin; use a key-free RPC URL (a keyed one names you)",
     "  --ohttp-relay <url>      (or env SHINJUKU_OHTTP_RELAY) send POST /api/solana-rpc and /api/x402/* to the facilitator as Oblivious HTTP through this relay:",
@@ -159311,7 +159409,7 @@ var TRANSFER_START_FLAGS = /* @__PURE__ */ new Set([
 ]);
 var NOT_SHOWN = "; the value given is not one (it is not repeated here)";
 function checkValue(spec, value) {
-  if (spec.check === "atomic" && !/^[1-9][0-9]*$/.test(value)) {
+  if (spec.check === "atomic" && !(spec.usdc === "or-all" && value === "all") && !/^[1-9][0-9]*$/.test(value)) {
     return `${spec.name} must be a whole number of atomic units above 0 (1 USDC = 1000000)${NOT_SHOWN}`;
   }
   if (spec.check === "count" && !/^(0|[1-9][0-9]*)$/.test(value)) {
@@ -159379,9 +159477,12 @@ function configDefaults(command2, args, deps) {
     ["--program", config.program],
     ["--proof-tools", config.proofTools],
     ["--facilitator", config.memoService],
-    ["--service", config.memoService]
+    ["--service", config.memoService],
+    // T9 (live run 2026-10-23 18:44 UTC, npm 0.3.83): unshield refused "missing 7 flags" although config.json holds its
+    // files; merge (the step an unshield of the whole balance names) takes the same ones.
+    ...["unshield", "merge"].includes(command2.name) ? [["--payer-proof-tools", config.proofTools], ["--exit-proof-tools", config.exitProofTools], ["--profile", config.profile]] : []
   ];
-  const needed = (spec) => spec.required || spec.refreshOnly && given.has("--refresh");
+  const needed = (spec) => spec.required || spec.refreshOnly && given.has("--refresh") || spec.requiredUnless && !given.has(spec.requiredUnless);
   if (wantPool || wantWallet || given.has("--wallet") || given.get("--pool") === config.pool) {
     for (const [name, value] of fromConfig) {
       if (typeof value === "string" && command2.flags.some((spec) => spec.name === name && needed(spec)) && !given.has(name)) added.push(name, value);
@@ -159479,6 +159580,188 @@ function rpcFileArgs(command2, args, values, deps, io) {
   const { url } = resolveRpcUrl2({ env: {}, origin: facilitatorOriginOf(values.get("--service"), values.get("--facilitator"), values.get("--memo-service")), notice: io.err });
   return { args: [...args, "--rpc", url], url };
 }
+var UNSHIELD_MADE_ID = /* @__PURE__ */ Symbol("unshield id made here");
+var unshieldRefusal = (reason, text3) => new PublicFailure(`p03_unshield_${reason}: ${text3}`);
+function walletOwnAddress(store) {
+  try {
+    return import_web3138.Keypair.fromSecretKey(Uint8Array.from(store.state.solanaSecretKey), { skipValidation: true }).publicKey;
+  } catch {
+    return void 0;
+  }
+}
+async function recipientHoldsUsdc({ connection, mint, owner }) {
+  const account2 = getAssociatedTokenAddressSync(mint, owner, true, TOKEN_PROGRAM_ID);
+  let info;
+  try {
+    info = await getAccount(connection, account2, "finalized", TOKEN_PROGRAM_ID);
+  } catch (error) {
+    if (error instanceof TokenAccountNotFoundError) return false;
+    throw error;
+  }
+  return info.mint.equals(mint) && info.owner.equals(owner);
+}
+async function runUnshieldCommand(args, values, deps, io) {
+  const terminal = deps.stdoutIsTTY?.() === true && !values.has("--json");
+  let callArgs = args.filter((word) => word !== "--json");
+  const setArg = (name, value) => {
+    const at = callArgs.indexOf(name);
+    callArgs = at >= 0 ? callArgs.map((word, index) => index === at + 1 ? value : word) : [...callArgs, name, value];
+    values.set(name, value);
+  };
+  let store;
+  const openStore = () => store ??= (deps.openWalletStore ?? openWalletStore)(resolve38(values.get("--wallet")), payerPassphrase(values, deps));
+  const owner = values.has("--recipient-owner") ? new import_web3138.PublicKey(values.get("--recipient-owner")) : new import_web3138.PublicKey(values.get("--to"));
+  if (!values.has("--recipient-owner")) {
+    const wallet = openStore();
+    if (walletOwnAddress(wallet)?.equals(owner)) {
+      throw unshieldRefusal("recipient_owner_is_deposit_key", `--to is this wallet's own public address (its own key): an exit there would show on chain that the money is yours, so this private wallet does not send there; nothing was sent. Send to another address (best: one that never sent USDC into this wallet), like ${UNSHIELD_EXAMPLE}`);
+    }
+    const mint = new import_web3138.PublicKey(wallet.state.asset);
+    const check = deps.unshieldRecipientHoldsUsdc ?? ((input) => recipientHoldsUsdc({ ...input, connection: connectRelay(spendRpcUrl(values, deps), "finalized") }));
+    let holds;
+    try {
+      holds = await check({ mint, owner });
+    } catch {
+      holds = void 0;
+    }
+    if (holds === void 0) io.err("note: the recipient's USDC account could not be checked (the RPC did not answer); the unshield goes on\n");
+    if (holds === false) {
+      throw unshieldRefusal("exit_recipient_invalid", `this address has no USDC account yet (a new address, or a Shinjuku wallet's one-time add-funds address, which a Shinjuku wallet cannot pay yet); nothing was paid or sent. Use a Solana address that already holds USDC (for example a Phantom address), like ${UNSHIELD_EXAMPLE}`);
+    }
+    setArg("--to", getAssociatedTokenAddressSync(mint, owner, true, TOKEN_PROGRAM_ID).toBase58());
+    setArg("--recipient-owner", owner.toBase58());
+  }
+  if (values.get("--amount") === "all") setArg("--amount", await sendAllAtomic(values, deps, io, openStore));
+  let id = values.get("--unshield-id");
+  if (id === void 0) {
+    id = `unshield-${randomBytes35(6).toString("hex")}`;
+    setArg("--unshield-id", id);
+    values.set(UNSHIELD_MADE_ID, id);
+    io.err(`unshield id: ${id} (if this command stops, run it again with --unshield-id ${id} added: it finishes this unshield and never sends twice)
+`);
+  }
+  const gated = await spendGate(callArgs, values, deps, io, { amountAtomic: values.get("--amount"), again: ` with --unshield-id ${id}` });
+  let answer;
+  const returned = await deps.unshieldMain(gated, { output: (result) => {
+    answer = result;
+  } });
+  answer ??= returned;
+  if (!answer || typeof answer !== "object") return;
+  io.out(terminal ? unshieldDoneText(answer, owner.toBase58()) : `${JSON.stringify(answer)}
+`);
+  const sent = answer.privateSend ? answer.privateSend.sentAtomic : answer.exitTransaction ? answer.amountAtomic : void 0;
+  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")}
+`);
+}
+function unshieldDoneText(answer, to) {
+  const send3 = answer.privateSend;
+  if (!send3) {
+    const again = answer.replayed === true ? " (this unshield had finished before; nothing was sent twice)" : "";
+    return `Sent ${usdcOr(answer.amountAtomic)} privately to ${to}${again}.
+Exit transaction: ${answer.exitTransaction}
+`;
+  }
+  const parts = Array.isArray(send3.parts) ? send3.parts : [];
+  const lines = [`Sent ${usdcOr(send3.sentAtomic)} of ${usdcOr(send3.amountAtomic)} privately to ${to}, in ${parts.length} parts (unshield id ${send3.sendId}).`];
+  const exits = parts.filter((part) => typeof part.exitTransaction === "string").map((part) => `part ${part.index} ${part.exitTransaction}`);
+  if (exits.length) lines.push(`Exit transactions: ${exits.join(", ")}`);
+  if (send3.done !== true && send3.cancelled !== true) {
+    lines.push(`${usdcOr(send3.remainingAtomic)} is not sent yet: run the same command with --unshield-id ${send3.sendId} to send the rest.`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+var STALE_WORDS = Object.freeze({
+  first_check: "the first check of the pool history runs now",
+  payment_settling: "a payment or send is still settling",
+  account_join: "the wallet is joining your balance parts",
+  pool_move: "money is moving to the facilitator's new pool"
+});
+var balanceNotCurrentWhy = (report) => STALE_WORDS[staleCauseOf(report)] ?? (report?.status === "unknown" ? "this wallet has no balance walk yet" : "a payment, deposit, or send finished after the last balance walk");
+function privateBalanceLine(report, label = "Private balance") {
+  if (!report) return `${label}: not read again here; ${CLI2} balance --refresh shows it`;
+  const atomic4 = report.totalAtomic ?? report.atomic;
+  const pockets = report.split?.pocketsAtomic;
+  const amount = atomic4 === null || atomic4 === void 0 ? void 0 : `${usdcOr(atomic4)}${/^[1-9][0-9]*$/.test(String(pockets ?? "")) && report.totalAtomic ? ` (${usdcOr(report.atomic)} shielded, ${usdcOr(pockets)} in pockets)` : ""}`;
+  if (report.status === "current" || report.status === "empty") return `${label}: ${amount ?? "0 USDC"}`;
+  const why = balanceNotCurrentWhy(report);
+  return amount !== void 0 ? `${label}: ${amount} (not final yet: ${why}; ${CLI2} balance --refresh in a minute shows the final number)` : `${label}: not known yet (${why}); run ${CLI2} balance --refresh`;
+}
+async function refreshAfterUnshield(walletFile, values, deps, io) {
+  const pool2 = /([1-9A-HJ-NP-Za-km-z]{32,44})[\\/]wallet\.json$/.exec(resolve38(walletFile))?.[1];
+  if (!pool2 || resolve38(deps.walletPath(pool2)) !== resolve38(walletFile)) {
+    io.err(`note: this wallet file is not in SHIELDED_WALLET_HOME, so its balance was not read again; ${CLI2} balance --refresh with its --pool shows it
+`);
+    return void 0;
+  }
+  let restore = () => {
+  };
+  try {
+    const passphrase2 = payerPassphrase(values, deps);
+    const service = new URL(values.get("--facilitator")).origin;
+    const history = values.get("--history-rpc");
+    const refreshValues = new Map([
+      ["--pool", pool2],
+      ["--program", values.get("--program")],
+      ["--proof-tools", values.get("--payer-proof-tools")],
+      ["--service", service],
+      ["--fresh", true],
+      ...history ? [["--history-rpc", history]] : []
+    ]);
+    const args = [
+      "--pool",
+      pool2,
+      "--program",
+      values.get("--program"),
+      "--proof-tools",
+      values.get("--payer-proof-tools"),
+      "--service",
+      service,
+      "--fresh",
+      "--rpc",
+      spendRpcUrl(values, deps),
+      ...history ? ["--history-rpc", history] : []
+    ];
+    const runDeps = { ...deps, env: { ...deps.env, [PASSPHRASE_ENV2]: passphrase2 } };
+    restore = lendPassphrase(passphrase2);
+    io.err(`reading your private balance again (the same walk as ${CLI2} balance --refresh)
+`);
+    const refreshed = await refreshSnapshot(args, refreshValues, runDeps);
+    warnUnsavedSync(refreshed.result, io);
+    refreshed.save();
+    await refreshed.prune();
+    const store = openPoolWallet(refreshValues, runDeps);
+    return computeBalance({ store, snapshotRead: readBalanceSnapshot(store), source: "refresh", now: deps.now() });
+  } catch (error) {
+    io.err(`note: the private balance was not read again (${describeCliError(error, { fallback: "wallet_command_failed" })}); nothing about the send changes. ${CLI2} balance --refresh shows the new balance
+`);
+    return void 0;
+  } finally {
+    restore();
+  }
+}
+async function sendAllAtomic(values, deps, io, openStore) {
+  const store = openStore();
+  let report = computeBalance({ store, snapshotRead: readBalanceSnapshot(store), source: "local", now: deps.now() });
+  if (report.status !== "current") report = await refreshAfterUnshield(values.get("--wallet"), values, deps, io) ?? report;
+  const empty = report.status === "empty" || report.status === "current" && report.atomic === "0";
+  if (!empty && (report.status !== "current" || !/^[1-9][0-9]*$/.test(String(report.atomic ?? "")))) {
+    throw new PublicFailure(`balance_not_current: --amount all needs the current private balance, and it is not current (${balanceNotCurrentWhy(report)}); nothing was sent. Run ${CLI2} balance --refresh in a minute, then this command again, or give the amount, like ${UNSHIELD_EXAMPLE}`);
+  }
+  if (empty) {
+    throw new PublicFailure(`no_spendable_account: the private balance is 0 USDC, so --amount all has nothing to send; nothing was sent. Add funds first (${CLI2} help add-funds)`);
+  }
+  const parts = joinParts(store);
+  if (parts?.parts > 1) {
+    throw new PublicFailure(`unshield_joining_accounts: the private balance (${usdcOr(report.atomic)}) is in ${parts.parts} parts, and one unshield sends from one part; nothing was sent. Join the parts first with ${CLI2} merge (a private move inside this wallet, no fee; about ${parts.minutes} minutes), then run ${CLI2} unshield --amount all --to <your wallet address> again`);
+  }
+  io.err(`--amount all: the whole private balance, ${usdcOr(report.atomic)}
+`);
+  return report.atomic;
+}
 async function runUnshieldCancel(values, deps, io) {
   const walletFile = resolve38(values.get("--wallet"));
   const passphrase2 = payerPassphrase(values, deps);
@@ -159997,7 +160280,7 @@ async function runBalance(args, values, deps, io) {
   let store;
   let earlierDeposits = [];
   if (values.has("--refresh")) {
-    const refreshed = await refreshSnapshot(args, values, deps);
+    const refreshed = await refreshSnapshot(args.filter((word) => word !== "--json"), values, deps);
     warnUnsavedSync(refreshed.result, io);
     refreshed.save();
     await refreshed.prune();
@@ -160027,6 +160310,16 @@ 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`;
   }
+  if (deps.stdoutIsTTY?.() === true && !values.has("--json")) {
+    const notCurrent = report.status !== "current" && report.status !== "empty";
+    io.out(`${[
+      privateBalanceLine(report),
+      ...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)}
 `);
 }
@@ -160749,7 +161042,7 @@ var VERSION_WORDS = /* @__PURE__ */ new Set(["version", "--version", "-v"]);
 function withoutConnectionFlags(argv2) {
   const out = [];
   for (let index = 0; index < argv2.length; index += 1) {
-    if (argv2[index] === "--tor" || argv2[index].startsWith("--ohttp-relay=")) continue;
+    if (argv2[index] === "--tor" || argv2[index] === "--no-tor" || argv2[index].startsWith("--ohttp-relay=")) continue;
     if (argv2[index] === "--proxy" || argv2[index] === "--ohttp-relay") {
       index += 1;
       continue;
@@ -160946,10 +161239,13 @@ next: fund that address, then rerun the same command; it continues where it stop
 ` : /^p03_float_request_expired_nothing_paid/.test(reason) ? `why: ${floatExpiredWhy(floatError)}
 ` : "";
     const ambiguousLine = /^p03_float_refund_pending/.test(reason) && (error?.ambiguous ?? error?.cause?.ambiguous) === true && floatError.refundArrived !== true ? `note: ${FLOAT_AMBIGUOUS_NOTE}
+` : "";
+    const madeId = /use_new_unshield_id|new --unshield-id/.test(`${reason} ${hint ?? ""}`) ? void 0 : values?.get?.(UNSHIELD_MADE_ID);
+    const idLine = madeId ? `this unshield's id is ${madeId}: to rerun or finish it, run the same command with --unshield-id ${madeId} added (it never sends twice)
 ` : "";
     io.err(`${CLI2} ${command2.name} failed: ${reason}
 ${sellerLine}${landedLine}${whyLine}${ambiguousLine}${blockingLine}${hint ? `hint: ${hint}
-` : ""}Help: ${CLI2} help ${command2.name}
+` : ""}${idLine}Help: ${CLI2} help ${command2.name}
 `);
     return 1;
   } finally {
@@ -160961,10 +161257,10 @@ ${sellerLine}${landedLine}${whyLine}${ambiguousLine}${blockingLine}${hint ? `hin
 init_proxy();
 var argv = process.argv.slice(2);
 setCliEntry(process.argv[1] ? resolve39(process.argv[1]) : void 0);
-var wrapper = runNetworkMode() === null && (argv.includes("--tor") || argv.includes("--proxy"));
+var entryArgv = runNetworkMode() === null ? torArgv(argv) : argv;
+var wrapper = runNetworkMode() === null && (entryArgv.includes("--tor") || entryArgv.includes("--proxy"));
 var stopSetupWatch = process.env[KEEP_WARM_ONCE_PARENT_ENV] === "1" && !wrapper ? watchSetupParentPipe() : void 0;
 var mcpRefused = async (options) => (await Promise.resolve().then(() => (init_torMissingMcp(), torMissingMcp_exports))).serveTorMissingMcp(options);
-var entryArgv = runNetworkMode() === null ? torArgv(argv) : argv;
 var code = isHelpRequest(argv) ? await runShinjukuWallet(argv) : await proxyEntry(entryArgv, runShinjukuWallet, { mcpRefused });
 stopSetupWatch?.();
 process.exitCode = code;