shinjuku-shielded 0.3.54 → 0.3.55

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "285d2c1db3cfd9d8a5df47acc2c70e7e65816539c3f2ad216ede6a16358d762b",
-  "bytes": 12117554,
-  "sourceCommit": "9df252eb8f4e71413bfcb8ff3ad289a96079e147",
+  "sha256": "70ff655b113c19d39c8594566c77d38fe7d459ea415f66cda1c09919841ad1a9",
+  "bytes": 12128720,
+  "sourceCommit": "d13f57d40a91eecbd9b06acd4f8c587d34bc256a",
   "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-21T20:41:22.351Z"
+  "publishedAt": "2026-10-21T23:25:11.303Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.54",
+  "version": "0.3.55",
   "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": "285d2c1d",
-  "shinjukuSha256": "285d2c1db3cfd9d8a5df47acc2c70e7e65816539c3f2ad216ede6a16358d762b",
+  "shinjukuRelease": "70ff655b",
+  "shinjukuSha256": "70ff655b113c19d39c8594566c77d38fe7d459ea415f66cda1c09919841ad1a9",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -42692,7 +42692,7 @@ async function routeFacilitatorsOverOnion(argv2, {
       if (!groups.has(key)) groups.set(key, { onions });
       routes.set(origin, groups.get(key));
       routes.set(payHostOf(origin), groups.get(key));
-      const hosts = onions.map((onion) => `${new URL(onion).host.slice(0, 8)}\u2026`).join(", ");
+      const hosts = onions.map((onion) => `${new URL(onion).host.slice(0, 8)}...`).join(", ");
       const source = pinned ? "pinned in this wallet" : `published by ${origin}`;
       err(`tor: ${origin} is reached over its onion service ${hosts} (${onions.length > 1 ? `${source}; the first to answer serves this run` : source}), so no Tor exit and no front such as Cloudflare sees these requests
 `);
@@ -42702,7 +42702,7 @@ async function routeFacilitatorsOverOnion(argv2, {
     }
   }
   for (const [origin, onions] of Object.entries(PINNED_HISTORY_ONIONS)) {
-    const group = { onions, path: HISTORY_PROBE_PATH, onNone: () => err(`tor: no history-proxy onion answered its start probe (${onions.length} tried); the pool history reads go to the pinned onion ${new URL(onions[0]).host.slice(0, 8)}\u2026 and wait for it
+    const group = { onions, path: HISTORY_PROBE_PATH, onNone: () => err(`tor: no history-proxy onion answered its start probe (${onions.length} tried); the pool history reads go to the pinned onion ${new URL(onions[0]).host.slice(0, 8)}... and wait for it
 `) };
     groups.set(onions.join(" "), group);
     routes.set(origin, group);
@@ -42757,7 +42757,7 @@ async function routeFacilitatorsOverOnion(argv2, {
     }
   };
 }
-var SITE_ONIONS, PINNED_FACILITATOR_ONIONS, HISTORY_ONIONS, PINNED_HISTORY_ONIONS, HISTORY_PROBE_PATH, FACILITATOR_FLAGS, V3_ONION, DISCOVERY_TIMEOUT_MS, WARM_TIMEOUT_MS, RACE_TIMEOUT_MS, routedGroups, routedOnions, routedOrigins, onionsOfOrigin, GLOBAL_DISPATCHER, onionDispatchers;
+var SITE_ONIONS, PINNED_FACILITATOR_ONIONS, HISTORY_ONIONS, PINNED_HISTORY_ONIONS, HISTORY_PROBE_PATH, FACILITATOR_FLAGS, V3_ONION, DISCOVERY_TIMEOUT_MS, WARM_TIMEOUT_MS, RACE_TIMEOUT_MS, routedGroups, routedOnions, routedOrigins, onionsOfOrigin, routesOverOnion, GLOBAL_DISPATCHER, onionDispatchers;
 var init_facilitatorOnion = __esm({
   "wallet/src/net/facilitatorOnion.mjs"() {
     "use strict";
@@ -42788,6 +42788,7 @@ var init_facilitatorOnion = __esm({
     routedOnions = () => [...new Set(routedGroups.flatMap((group) => group.winner ? [group.winner] : group.onions))];
     routedOrigins = /* @__PURE__ */ new Map();
     onionsOfOrigin = (origin) => routedOrigins.get(origin) ?? PINNED_FACILITATOR_ONIONS[origin] ?? [];
+    routesOverOnion = (origin) => routedOrigins.has(origin);
     GLOBAL_DISPATCHER = /* @__PURE__ */ Symbol.for("undici.globalDispatcher.1");
     onionDispatchers = /* @__PURE__ */ new Map();
   }
@@ -47037,7 +47038,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, torRotations, torCircuitId, torRotationsRefused, pendingMove, inTorRun, isOnionOrigin, ProxyUsageError, isOnionHost, TOR_EXPERT_BUNDLE, TUNNEL_LINE, TOR_INSTALL, OS_NAMES, osKey, torNotRunningMessage, NOTICE, 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, torRotations, torCircuitId, torRotationsRefused, pendingMove, inTorRun, runNetworkMode, isOnionOrigin, ProxyUsageError, isOnionHost, TOR_EXPERT_BUNDLE, TUNNEL_LINE, TOR_INSTALL, OS_NAMES, osKey, torNotRunningMessage, NOTICE, withRunTag, proxyEnv, pacedSoFar, RESENDABLE_METHOD, torCircuit, GLOBAL_DISPATCHER2, laneDispatchers, paymentWarmStop;
 var init_proxy = __esm({
   "wallet/src/net/proxy.mjs"() {
     "use strict";
@@ -47075,6 +47076,10 @@ var init_proxy = __esm({
     torCircuitId = 0;
     torRotationsRefused = false;
     inTorRun = () => String(process.env[MARK] ?? "").startsWith("tor ");
+    runNetworkMode = () => {
+      const mode = String(process.env[MARK] ?? "").split(" ")[0];
+      return mode === "tor" || mode === "proxy" ? mode : null;
+    };
     isOnionOrigin = (url) => inTorRun() && url?.protocol === "http:" && ONION_V3.test(url.hostname);
     ProxyUsageError = class extends Error {
     };
@@ -104623,7 +104628,8 @@ async function getRangeOnce(fetchImpl, url, start, end, label, { lane, signal, s
   if (at !== length) throw passing(fail26("setup_download_failed", `${label} answered a range of the wrong length; rerun setup: it keeps what it already checked`));
   return { bytes: bytes2, start, total };
 }
-async function downloadSet({ fetchImpl, base, entries, budget, onFile }) {
+async function downloadSet({ fetchImpl, base, entries, budget, onFile, onBytes = () => {
+} }) {
   const stop3 = new AbortController();
   const files = entries.map((entry) => ({ entry, url: new URL(entry.path, base).href, label: `the proof-tool file ${entry.path}`, buffer: void 0, left: 0 }));
   const queue = files.map((file) => ({ file, start: 0, end: RANGE_BYTES - 1, head: true, attempts: 0 })).sort((x, y) => Number(y.file.entry.path.endsWith(".params")) - Number(x.file.entry.path.endsWith(".params")));
@@ -104660,6 +104666,7 @@ async function downloadSet({ fetchImpl, base, entries, budget, onFile }) {
     }
     if (answer.whole) {
       const bytes2 = await getBytes(fetchImpl, file.url, FILE_TIMEOUT_MS, file.label, LIMITS.file, budget, { lane: task.lane, stop: stop3.signal });
+      onBytes(bytes2.length);
       await finish(file, bytes2);
       return;
     }
@@ -104669,6 +104676,7 @@ async function downloadSet({ fetchImpl, base, entries, budget, onFile }) {
       throw fail26("setup_download_failed", `${file.label} changed size during the download; rerun setup: it keeps what it already checked`);
     }
     answer.bytes.copy(file.buffer, answer.start);
+    onBytes(answer.bytes.length);
     file.left -= 1;
     if (file.left === 0) await finish(file, file.buffer);
   };
@@ -104721,6 +104729,7 @@ async function downloadSet({ fetchImpl, base, entries, budget, onFile }) {
         }
         if (got) {
           got.copy(task.file.buffer, error.from);
+          onBytes(got.length);
           task.start = Math.max(task.start, error.from + got.length);
         }
         if (!got || got.length < RANGE_FLOOR_BYTES) task.attempts += 1;
@@ -104760,6 +104769,8 @@ async function fetchRelease(facilitator, { fetchImpl = fetch } = {}) {
   if (!HEX643.test(String(tools.sumsSha256)) || !DIR2.test(String(tools.dir)) || tools.sumsSha256.slice(0, 8) !== tools.dir) {
     throw fail26("setup_release_invalid", "the release document names a proof-tool set whose folder is not the first 8 hex of its list hash");
   }
+  const setBytes = Number(tools.bytes);
+  if (Number.isSafeInteger(setBytes) && setBytes > 0 && setBytes <= LIMITS.total) releasedBytes.set(`${new URL(facilitator).origin} ${tools.sumsSha256}`, setBytes);
   return release;
 }
 function expectedProofTools(facilitator, trust, pins = PINNED_PROOF_TOOLS) {
@@ -104810,8 +104821,16 @@ function verifyToolsFolder(folder, sumsSha256) {
     return false;
   }
 }
-async function installProofTools({ facilitator, toolsRoot, expected, fetchImpl = fetch, onProgress = () => {
-} }) {
+async function installProofTools({
+  facilitator,
+  toolsRoot,
+  expected,
+  fetchImpl = fetch,
+  onProgress = () => {
+  },
+  progressLine = (text3) => process.stderr.write(text3),
+  progressEveryMs = PROGRESS_EVERY_MS
+}) {
   const { dir, sumsSha256 } = expected;
   if (!HEX643.test(String(sumsSha256)) || dir !== sumsSha256.slice(0, 8)) throw fail26("setup_release_invalid", "the expected proof-tool set is not a 64-hex list hash");
   const folder = join21(toolsRoot, dir);
@@ -104870,12 +104889,45 @@ async function installProofTools({ facilitator, toolsRoot, expected, fetchImpl =
     budget.left -= bytes2.length;
   }
   const keptPaths = new Set(kept.map(({ entry }) => entry.path));
-  await downloadSet({ fetchImpl, base, entries: entries.filter((entry) => !keptPaths.has(entry.path)), budget, onFile: (entry, bytes2) => {
-    write(entry, bytes2);
-    bytesDone += bytes2.length;
-    downloaded += 1;
-    onProgress({ filesDone: kept.length + downloaded, filesTotal: entries.length, bytesDone });
-  } });
+  const missing = entries.filter((entry) => !keptPaths.has(entry.path));
+  const keptBytes = kept.reduce((sum2, { bytes: bytes2 }) => sum2 + bytes2.length, 0);
+  const named = releasedBytes.get(`${new URL(facilitator).origin} ${sumsSha256}`);
+  const totalBytes = named !== void 0 && named >= keptBytes ? named : void 0;
+  const torNote = inTorRun() ? "over Tor this takes a few minutes" : void 0;
+  let arrived = 0;
+  const say6 = (text3, notes) => {
+    const shown = notes.filter(Boolean);
+    try {
+      progressLine(`downloading the proof tools: ${text3}${shown.length ? ` (${shown.join("; ")})` : ""}
+`);
+    } catch {
+    }
+  };
+  let ticker;
+  if (missing.length > 0) {
+    say6(
+      `${totalBytes === void 0 ? "" : `${megabytes(totalBytes)} MB in `}${entries.length} files`,
+      [kept.length ? `${kept.length} files, ${megabytes(keptBytes)} MB, already here from a stopped run` : void 0, torNote]
+    );
+    ticker = setInterval(() => {
+      const done = keptBytes + arrived;
+      const files = `${kept.length + downloaded} of ${entries.length} files`;
+      say6(totalBytes !== void 0 ? `${megabytes(Math.min(done, totalBytes))} of ${megabytes(totalBytes)} MB, ${files}` : `${megabytes(done)} MB so far, ${files}`, [torNote]);
+    }, progressEveryMs);
+    ticker.unref?.();
+  }
+  try {
+    await downloadSet({ fetchImpl, base, entries: missing, budget, onBytes: (count2) => {
+      arrived += count2;
+    }, onFile: (entry, bytes2) => {
+      write(entry, bytes2);
+      bytesDone += bytes2.length;
+      downloaded += 1;
+      onProgress({ filesDone: kept.length + downloaded, filesTotal: entries.length, bytesDone });
+    } });
+  } finally {
+    clearInterval(ticker);
+  }
   writeFileSync(join21(partial, "SHA256SUMS"), sums, { flag: "wx", mode: 384 });
   if (!verifyToolsFolder(partial, sumsSha256)) throw fail26("setup_file_hash_mismatch", "the downloaded proof-tools folder did not check out on disk; rerun setup");
   if (existsSync(folder)) rmSync(folder, { recursive: true, force: true });
@@ -104946,7 +104998,7 @@ async function refreshTrustedProofTools({ home, facilitator, pool: pool2, fetchI
   });
   return Object.freeze({ changed: true, dir: tools.dir, sumsSha256: tools.sumsSha256, downloaded: tools.downloaded });
 }
-var PINNED_PROOF_TOOLS, UPDATE_NEXT, HEX643, DIR2, SUMS_LINE, MAX_FILES, LIMITS, RELEASE_TIMEOUT_MS, FILE_TIMEOUT_MS, DOWNLOAD_LANES, RANGE_BYTES, RANGE_TIMEOUT_MS, RANGE_STALL_MS, RANGE_FLOOR_BYTES, RANGE_ATTEMPTS, HEDGE_AFTER_MS, CONTENT_RANGE, REQUIRED_FILES, sha2569, fail26, SMALL_HEDGE_MS, SMALL_LANES, LOST, passing, localPath, executable, toolPaths;
+var PINNED_PROOF_TOOLS, UPDATE_NEXT, HEX643, DIR2, SUMS_LINE, MAX_FILES, LIMITS, RELEASE_TIMEOUT_MS, FILE_TIMEOUT_MS, DOWNLOAD_LANES, RANGE_BYTES, RANGE_TIMEOUT_MS, RANGE_STALL_MS, RANGE_FLOOR_BYTES, RANGE_ATTEMPTS, HEDGE_AFTER_MS, CONTENT_RANGE, PROGRESS_EVERY_MS, releasedBytes, megabytes, REQUIRED_FILES, sha2569, fail26, SMALL_HEDGE_MS, SMALL_LANES, LOST, passing, localPath, executable, toolPaths;
 var init_proofTools = __esm({
   "wallet/src/setup/proofTools.mjs"() {
     "use strict";
@@ -104977,6 +105029,9 @@ var init_proofTools = __esm({
     RANGE_ATTEMPTS = 8;
     HEDGE_AFTER_MS = 3e3;
     CONTENT_RANGE = /^bytes (\d+)-(\d+)\/(\d+)$/;
+    PROGRESS_EVERY_MS = 1e4;
+    releasedBytes = /* @__PURE__ */ new Map();
+    megabytes = (bytes2) => Math.round(bytes2 / 1e6);
     REQUIRED_FILES = Object.freeze(["proof-tools.json", "exit-proof-tools.json", "public-profile.json"]);
     sha2569 = (bytes2) => createHash26("sha256").update(bytes2).digest("hex");
     fail26 = (code2, detail) => new Error(`${code2}: ${detail}`);
@@ -107669,6 +107724,7 @@ function addFundsHeldSay(entries, have = "") {
   let startMinutes = null;
   for (const entry of entries) {
     if (!entry || typeof entry !== "object") continue;
+    if (entry.landed === true) continue;
     const amount = ATOMIC3.test(String(entry.heldAtomic ?? "")) ? BigInt(entry.heldAtomic) : 0n;
     const left = Number.isSafeInteger(entry.privateInMinutes) ? entry.privateInMinutes : null;
     if (entry.state === "shielding" && entry.startsAtNextRequest === true) {
@@ -107705,9 +107761,10 @@ function addFundsHeldSay(entries, have = "") {
   const lead = (text3) => have ? `${have}; ${text3}` : `${text3[0].toUpperCase()}${text3.slice(1)}`;
   const now = !nowUnknown ? `${usdcText(nowHeld)} USDC is becoming private now` : nowHeld > 0n ? `${usdcText(nowHeld)} USDC and an amount still being read are becoming private now` : "an amount still being read is becoming private now";
   const later = startMinutes !== null ? `within about 1 minute of your next wallet request${startMinutes > 0 ? ` after about ${minutesText(startMinutes)}` : ""}` : minutesKnown && minutes !== null ? `in about ${minutesText(minutes)}` : "in a few minutes";
-  if (nowAny && waiting > 0n) return `${lead(`${now}, and ${usdcText(waiting)} USDC more ${later}`)}.`;
+  const askLater = startMinutes !== null && startMinutes > 0 ? `ask again in about ${minutesText(startMinutes)}, and it becomes private within about 1 minute of that request` : null;
+  if (nowAny && waiting > 0n) return askLater ? `${lead(`${now}; ${usdcText(waiting)} USDC more arrived: ask again in about ${minutesText(startMinutes)} for it`)}.` : `${lead(`${now}, and ${usdcText(waiting)} USDC more ${later}`)}.`;
   if (nowAny) return `${lead(now)}. Nothing to do.`;
-  const arrived = `${usdcText(waiting)} USDC arrived and becomes private ${later === "in a few minutes" ? "within a few minutes of your next wallet request" : later}`;
+  const arrived = askLater ? `${usdcText(waiting)} USDC arrived: ${askLater}` : `${usdcText(waiting)} USDC arrived and becomes private ${later === "in a few minutes" ? "within a few minutes of your next wallet request" : later}`;
   if (startMinutes !== null) return `${lead(arrived)}.`;
   if (!minutesKnown || minutes === null) {
     return have ? `${lead(arrived)}. Nothing to do.` : `${lead(arrived)}. A random wait hides the link to your deposit. Nothing to do.`;
@@ -107757,6 +107814,11 @@ function refreshErrorWords(code2) {
 function balanceSay(a) {
   const balance = usdcText(a.balanceAtomic);
   const pub = usdcText(a.unshieldedAtomic);
+  const landing = usdcText(a.landingAtomic);
+  if (positive(landing) && !a.refreshError) {
+    const line = `${landing} USDC you added landed and is being counted. Ask again in about 30 seconds.`;
+    return balance !== void 0 && a.refreshing !== true ? `You have ${balance} USDC private; ${line}` : line;
+  }
   const arriving = addFundsHeldSay(a.addFunds);
   if (arriving) {
     const both = balance !== void 0 && a.refreshing !== true ? addFundsHeldSay(a.addFunds, `You have ${balance} USDC private`) : "";
@@ -107845,13 +107907,15 @@ function transferSay(a) {
   const about = usdcText(a.quote?.outAtomic);
   const usdc8 = sold ? `${sold} USDC` : about ? `about ${about} USDC` : "USDC";
   const to = str(a.to) || "the address";
+  const later = "If this chat ends first, it continues at your next request.";
   switch (a.stage) {
     case "selling":
-      return `Selling the token for ${usdc8}. Then it becomes private and goes to ${to} by itself.`;
+      return `Selling the token for ${usdc8}; then it goes privately to ${to}. ${later}`;
+    // J-3: a shield that already landed is not "making it private now" (the resumed run is about to plan the send).
     case "shielding":
-      return `Sold for ${usdc8}. Making it private now; then it goes to ${to} by itself.`;
+      return a.shield?.landed === true ? `Sold for ${usdc8} and made private; the send to ${to} starts now. ${later}` : `Sold for ${usdc8}. Making it private now; then it goes to ${to}. ${later}`;
     case "sending":
-      return `Sending ${usdc8} privately to ${to}. The address gets USDC, not the token.`;
+      return `Sending ${usdc8} privately to ${to}. It gets USDC, not the token. ${later}`;
     case "sold_waiting_room":
       return `Sold for ${usdc8}, but it does not fit the 5 USDC private balance limit yet. Read next for what to do.`;
     case "done":
@@ -114048,8 +114112,11 @@ function transferTokenView(plan) {
     parts: plan.parts,
     maxDelayMinutes: plan.maxDelayMinutes,
     delivers: "USDC",
-    limit: "B receives USDC, not the token. Swap it at B yourself; the automatic swap at B is not built yet.",
-    privacy: "the total B receives equals the deposit, and the pool's crowd is small today: a longer max_delay_minutes hides better",
+    // Real-user pass J-1 (2026-10-21): "B" is an internal name; the answer names the address the user gave.
+    limit: "the address in to receives USDC, not the token. Swap it there yourself; an automatic swap there is not built yet.",
+    // J-4: a plan exists only after the address's USDC account was read (tools.mjs beginTransfer refuses mcp_unshield_to_invalid before the sell).
+    receiving: "the address in to already has a USDC account (checked before the sell), so it can receive this USDC",
+    privacy: "the total the address in to receives equals the deposit, and the pool's crowd is small today: a longer max_delay_minutes hides better",
     ...plan.stopCode ? { stopCode: plan.stopCode, stopReason: plan.stopReason } : {},
     ...plan.state === "sold_waiting_room" && plan.waitCode ? { waitCode: plan.waitCode, waitReason: plan.waitReason } : {},
     ...plan.cancelRequested ? { cancelRequested: true } : {}
@@ -114496,7 +114563,7 @@ function safeHttpUrl(value) {
   }
 }
 function clip(text3, max) {
-  return text3.length > max ? `${text3.slice(0, max - 1)}\u2026` : text3;
+  return text3.length > max ? `${text3.slice(0, max - 3)}...` : text3;
 }
 function cachePath(key, cacheDir) {
   return join27(cacheDir, `x402-discover-${createHash29("sha256").update(key).digest("hex").slice(0, 24)}.json`);
@@ -115470,7 +115537,7 @@ async function waitWithProgress(ms, progress3, message) {
     await sleep2(Math.min(1e4, left));
   }
 }
-function waitOrProgress(promises, ms, { progress: progress3, message, everyMs = PROGRESS_EVERY_MS } = {}) {
+function waitOrProgress(promises, ms, { progress: progress3, message, everyMs = PROGRESS_EVERY_MS2 } = {}) {
   return new Promise((resolve38, reject) => {
     let timer;
     let beat;
@@ -116438,7 +116505,7 @@ function createWalletTools({
       return { ok: false, why: error?.timedOut === true ? "timeout" : "error" };
     }
   }
-  const progressEveryMs = Number.isSafeInteger(ops.progressEveryMs) && ops.progressEveryMs > 0 ? ops.progressEveryMs : PROGRESS_EVERY_MS;
+  const progressEveryMs = Number.isSafeInteger(ops.progressEveryMs) && ops.progressEveryMs > 0 ? ops.progressEveryMs : PROGRESS_EVERY_MS2;
   const statusWait = (promises, ms, progress3, message) => waitOrProgress(promises, ms, { progress: progress3, message, everyMs: progressEveryMs });
   const notAllowedNext = (why, requestId, numbers, words2) => why === "timeout" ? `No answer yet. Ask again with request_id ${requestId} to ask the user again.` : `${limitNext(numbers, words2)} The user did not allow it once${why === "not_ticked" ? " (the box was not ticked)" : ""}.`;
   const cancels = /* @__PURE__ */ new Map();
@@ -117303,6 +117370,7 @@ function createWalletTools({
         status: 402,
         accepts,
         rail,
+        ...networkFields(),
         caps: shownCaps({ ...limits, sessionLeftAtomic: sessionLeftShown(policy, (() => {
           try {
             return session.openStore();
@@ -117745,6 +117813,16 @@ ${canonical5}`;
     const line = `${say6} Its request_id is ${id}.`;
     return line.trim().split(/\s+/).length <= SAY_MAX_WORDS ? line : say6;
   };
+  function networkFields() {
+    const mode = runNetworkMode();
+    let onion = false;
+    try {
+      onion = mode === "tor" && Boolean(session.memoServiceUrl) && routesOverOnion(new URL(session.memoServiceUrl).origin);
+    } catch {
+      onion = false;
+    }
+    return { network: mode === "tor" ? { mode: "tor", detail: `every request of this wallet goes through Tor (checked at start)${onion ? "; the facilitator is reached over its onion service, so no Tor exit sees those requests" : ""}` } : mode === "proxy" ? { mode: "proxy", detail: "every request of this wallet goes through the proxy in its launch line (--proxy); it is not checked as Tor" } : { mode: "direct", detail: "no Tor: the facilitator, the RPC provider and each seller see this computer's IP address; start the MCP with --tor (or run setup --prefer-tor) to hide it" } };
+  }
   function sayFirst(fields, tool, autoId) {
     let say6 = sayFor(fields, { tool });
     if (autoId) say6 = withIdSentence(say6, autoId);
@@ -117993,11 +118071,13 @@ ${canonical5}`;
       const startAt = record.state === "open" ? watcher?.startAtOf(linkKindOf(record.id), record.id) ?? null : null;
       let shieldingAtomic = null;
       let depositSent = false;
+      let landed = false;
       if (record.state === "shielding") {
         try {
           const deposit = store.readWal(`deposit-${record.depositId ?? payMeRoundDepositId(record.id, record.round ?? 1)}`);
           if (/^[1-9][0-9]*$/.test(String(deposit?.amountAtomic ?? ""))) shieldingAtomic = String(deposit.amountAtomic);
-          depositSent = DEPOSIT_SENT_STATES.has(deposit?.state);
+          landed = depositLanded(deposit);
+          depositSent = landed || DEPOSIT_SENT_STATES.has(deposit?.state);
         } catch {
           shieldingAtomic = null;
         }
@@ -118009,6 +118089,7 @@ ${canonical5}`;
         state: record.state,
         heldAtomic: held,
         ...record.state === "shielding" ? { shieldingAtomic } : {},
+        ...landed ? { landed: true } : {},
         // The one number say and next name (real-user pass D1: say 6, privateInMinutes 5): the random wait left, plus
         // about a minute for the deposit itself; 0 once the wait is over (the deposit starts at the next request).
         ...startAt !== null ? { privateInMinutes: startAt <= Date.now() ? 0 : Math.ceil((startAt - Date.now()) / 6e4) + 1 } : {},
@@ -118019,10 +118100,58 @@ ${canonical5}`;
       };
     });
   }
+  function finishSentDeposits(store) {
+    if (!elsewhereEnabled || paysInFlight > 0 || moneyCallsInFlight > 0) return [];
+    const passes = [];
+    for (const record of listPayMe(store)) {
+      if (record.state !== "shielding") continue;
+      let deposit;
+      try {
+        deposit = store.readWal(`deposit-${record.depositId ?? payMeRoundDepositId(record.id, record.round ?? 1)}`);
+      } catch {
+        continue;
+      }
+      if (deposit?.schema !== DEPOSIT_WAL_SCHEMA || !DEPOSIT_FINISH_STATES.has(deposit.state)) continue;
+      passes.push(payMePass(record.id).then((outcome) => {
+        const round = outcome?.record?.round ?? 1;
+        if ((outcome?.stage === "done" || outcome?.stage === "partly_shielded") && outcome.record?.doneAt && !payMeRefreshed.has(`${record.id}:${round}`)) {
+          payMeRefreshed.add(`${record.id}:${round}`);
+          afterShield({ requestId: record.id });
+          log(`MCP_PAY_ME_DONE requestId=${record.id} by=balance`);
+        }
+        return outcome;
+      }));
+    }
+    return passes;
+  }
+  function landedNotCounted(store) {
+    let snapshot;
+    try {
+      snapshot = readBalanceSnapshot(store)?.snapshot;
+    } catch {
+      snapshot = void 0;
+    }
+    const walkedDigests = new Set((snapshot?.outputs ?? []).map((output2) => output2.digest));
+    const finishedHere = new Set(listPayMe(store).filter((record) => record.state === "shielding").map((record) => `deposit-${record.depositId ?? payMeRoundDepositId(record.id, record.round ?? 1)}`));
+    let total = 0n;
+    for (const name of store.listWal()) {
+      if (!name.startsWith("deposit-")) continue;
+      let deposit;
+      try {
+        deposit = store.readWal(name);
+      } catch {
+        continue;
+      }
+      if (!depositLanded(deposit) || !/^[1-9][0-9]*$/.test(String(deposit.amountAtomic ?? ""))) continue;
+      const landing = deposit.state === "submitted" ? finishedHere.has(name) && !walkedDigests.has(String(deposit.memoDigest ?? "").replace(/^0x/i, "").toLowerCase()) : snapshot !== void 0 && !["finalized", "published"].includes(snapshot.walStates?.[name]);
+      if (landing) total += BigInt(deposit.amountAtomic);
+    }
+    return total;
+  }
   const balance = {
     name: "wallet_balance",
     title: "Balance",
-    description: `Use this when the user asks "what is my balance" or "how much USDC do I have": it answers ONE balance (balanceAtomic, what x402_pay can spend) and the public (unshielded) USDC. Pays nothing and signs nothing. balanceAtomic is one number; breakdown names its parts (breakdown.shieldedAtomic is what wallet_unshield can send; privateSendPendingAtomic is the part of a running private send (wallet_unshield with parts or max_delay_minutes) not sent yet, already taken off shieldedAtomic; refundsInFlightAtomic is a Shinjuku refund on its way back; setAsideAtomic (only when not 0) is value an older version of this wallet set aside to pay sellers; during a pool move, pools lists each pool's part and movingAtomic is value on its way from the old pool to the new one; the move field shows the move, poolSwitches each switch). UNSHIELDED (unshieldedAtomic) is the plain public USDC on the wallet's own Solana key (ownAddress), the USDC wallet_shield makes private; unshieldedSolLamports is that key's SOL, information only: wallet_shield needs none (the facilitator's relayer pays every fee and rent). When the local balance is stale (a new deposit, a received payment), it reads the chain by itself first; when that takes longer than about 20 s it answers the last balance with refreshing: true and finishes in the background (call wallet_balance again in 30 s). A balance with refreshing: true and refreshReason is exact (payment_settling: a payment settles and the number counts it; account_join: the wallet joins its own balance parts and the number counts them; pool_move: value from the old pool arrives and the number counts it; first_check: a new wallet's first history check, the number is its own landed deposits). status reading (balanceAtomic null): the first balance read of a wallet that may hold money is not done; call wallet_balance again in 30 s. If the public read fails, unshieldedAtomic is null with unshieldedReason; the rest still answers. earlierDeposits (only when there are any): USDC found at a one-time deposit address of an earlier pool, each with a notice line to tell the user; the wallet moves it into the current pool by itself. addFunds (only when there are any): each wallet_add_funds address still open, with its state and the USDC known to wait there (heldAtomic; null with heldNote when the address was not checked yet). session shows the spending limits (null or "none": no limit), what is left, where the limits come from, and how to change them (session.summary). verbose: true adds \`internal\` (accounts, notes, and other engineering numbers); the default answer leaves them out. To add money, use wallet_add_funds. Amounts are atomic units (USDC: 1000000 = 1 USDC); say and usdc give them in USDC.`,
+    description: `Use this when the user asks "what is my balance" or "how much USDC do I have": it answers ONE balance (balanceAtomic, what x402_pay can spend) and the public (unshielded) USDC. Pays nothing and signs nothing. balanceAtomic is one number; breakdown names its parts (breakdown.shieldedAtomic is what wallet_unshield can send; privateSendPendingAtomic is the part of a running private send (wallet_unshield with parts or max_delay_minutes) not sent yet, already taken off shieldedAtomic; refundsInFlightAtomic is a Shinjuku refund on its way back; setAsideAtomic (only when not 0) is value an older version of this wallet set aside to pay sellers; during a pool move, pools lists each pool's part and movingAtomic is value on its way from the old pool to the new one; the move field shows the move, poolSwitches each switch). UNSHIELDED (unshieldedAtomic) is the plain public USDC on the wallet's own Solana key (ownAddress), the USDC wallet_shield makes private; unshieldedSolLamports is that key's SOL, information only: wallet_shield needs none (the facilitator's relayer pays every fee and rent). When the local balance is stale (a new deposit, a received payment), it reads the chain by itself first; when that takes longer than about 20 s it answers the last balance with refreshing: true and finishes in the background (call wallet_balance again in 30 s). A balance with refreshing: true and refreshReason is exact (payment_settling: a payment settles and the number counts it; account_join: the wallet joins its own balance parts and the number counts them; pool_move: value from the old pool arrives and the number counts it; first_check: a new wallet's first history check, the number is its own landed deposits). status reading (balanceAtomic null): the first balance read of a wallet that may hold money is not done; call wallet_balance again in 30 s. If the public read fails, unshieldedAtomic is null with unshieldedReason; the rest still answers. earlierDeposits (only when there are any): USDC found at a one-time deposit address of an earlier pool, each with a notice line to tell the user; the wallet moves it into the current pool by itself. addFunds (only when there are any): each wallet_add_funds address still open, with its state and the USDC known to wait there (heldAtomic; null with heldNote when the address was not checked yet). landingAtomic (only when not 0): USDC you added whose deposit landed on chain and that balanceAtomic does not count yet; this call finishes it and waits about 20 s for it, past that it is being counted: call wallet_balance again in 30 s. session shows the spending limits (null or "none": no limit), what is left, where the limits come from, and how to change them (session.summary). verbose: true adds \`internal\` (accounts, notes, and other engineering numbers); the default answer leaves them out. To add money, use wallet_add_funds. Amounts are atomic units (USDC: 1000000 = 1 USDC); say and usdc give them in USDC.`,
     inputSchema: { type: "object", properties: {
       verbose: { type: "boolean", description: "Optional. true adds `internal`: the engineering numbers (funded accounts, notes, payments without waiting, a 0 set-aside value). Default false." }
     }, additionalProperties: false },
@@ -118047,6 +118176,24 @@ ${canonical5}`;
       const balanceStartedAt = Date.now();
       const publicRead = withTimeout((ops.readPublicBalance ?? readOwnPublicBalance)({ session, store }), PUBLIC_READ_TIMEOUT_MS).then((read2) => ({ read: read2 }), (error2) => ({ error: error2 }));
       const linkReads = readOpenLinkHeld(store);
+      const finishing = finishSentDeposits(store);
+      const finishDeadline = finishing.length ? balanceStartedAt + balanceRefreshWaitMs : void 0;
+      if (finishing.length) {
+        const finished = Promise.all(finishing).then((outcomes) => outcomes.some((outcome2) => outcome2?.stage === "done" || outcome2?.stage === "partly_shielded") ? refreshShared().then(() => "done") : "passed").catch(() => "failed");
+        const outcome = await Promise.race([
+          finished,
+          new Promise((resolve38) => {
+            const timer = setTimeout(() => resolve38("waiting"), Math.max(0, finishDeadline - Date.now()));
+            timer.unref?.();
+          })
+        ]);
+        if (outcome !== "waiting") {
+          try {
+            store = session.openStore();
+          } catch {
+          }
+        }
+      }
       let report = computeBalance({ store, snapshotRead: readBalanceSnapshot(store), source: "local", firstDepositEstimate: true });
       let refresh = {};
       const recentlyFailed = refreshFailedAt && Date.now() - refreshFailedAt < REFRESH_RETRY_MS && !refreshRun;
@@ -118067,7 +118214,7 @@ ${canonical5}`;
           const timer = setTimeout(() => resolve38("waiting"), ms);
           timer.unref?.();
         })]);
-        let outcome = await waitFor(longRead ? 0 : balanceRefreshWaitMs);
+        let outcome = await waitFor(longRead ? 0 : finishDeadline === void 0 ? balanceRefreshWaitMs : Math.max(0, finishDeadline - Date.now()));
         if (outcome === "waiting" && !longRead) outcome = await waitFor(BALANCE_REFRESH_GRACE_MS);
         if (outcome === "done") {
           try {
@@ -118156,6 +118303,14 @@ ${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";
+      let landingAtomic = 0n;
+      try {
+        landingAtomic = landedNotCounted(store);
+      } catch {
+        landingAtomic = 0n;
+      }
+      const landedNext = landingAtomic > 0n && !refresh.refreshError ? `${usdcText2(landingAtomic)} USDC you added landed on chain and is being counted (landingAtomic, not in balanceAtomic yet): call wallet_balance again in ${POLL_SECONDS3} s; that call waits up to ${waitSeconds} s for it. Tell the user it needs no step from them` : void 0;
+      if (landedNext) next = landedNext;
       const stalled = [...resumeRefusals].map(([requestId, error2]) => `"${requestId}" (${error2})`);
       if (stalled.length && one.breakdown?.privateSendPendingAtomic !== "0") {
         next = `${next}. A private send did not continue after this server started: ${stalled.join(", ")}. Its unsent parts (breakdown.privateSendPendingAtomic) stay off balanceAtomic: call wallet_unshield with its request_id and the same arguments to see why and run it, or stop them with wallet_cancel and its request_id`;
@@ -118213,16 +118368,16 @@ ${canonical5}`;
       } catch {
         sendWaiting = void 0;
       }
-      const arrivingAll = addFundsOpen.filter((link2) => link2.state === "shielding" || /^[1-9][0-9]*$/.test(String(link2.heldAtomic ?? "")));
+      const arrivingAll = addFundsOpen.filter((link2) => link2.landed !== true && (link2.state === "shielding" || /^[1-9][0-9]*$/.test(String(link2.heldAtomic ?? ""))));
       const arrivingLine = (arriving) => {
         const amount = /^[1-9][0-9]*$/.test(String(arriving.shieldingAtomic ?? "")) ? `${usdcText2(arriving.shieldingAtomic)} USDC` : /^[1-9][0-9]*$/.test(String(arriving.heldAtomic ?? "")) ? `${usdcText2(arriving.heldAtomic)} USDC` : "USDC (an amount still being read)";
-        const when = arriving.state === "shielding" && !arriving.startsAtNextRequest ? "is becoming private now (its deposit transaction was sent; about 1 minute)" : arriving.startsInMinutes > 0 ? `becomes private within about 1 minute of the user's next wallet request after about ${minutesText2(arriving.startsInMinutes)} (a random wait hides the link to the deposit); no step for the user` : "becomes private: its deposit starts after this answer and takes about 1 minute; if this wallet process ends first, the next wallet request continues it";
+        const when = arriving.state === "shielding" && !arriving.startsAtNextRequest ? "is becoming private now (its deposit transaction was sent; about 1 minute)" : arriving.startsInMinutes > 0 ? `waits about ${minutesText2(arriving.startsInMinutes)} (a random wait hides the link to the deposit); call wallet_balance again after that, and it becomes private within about 1 minute of that request; no step for the user` : "becomes private: its deposit starts after this answer and takes about 1 minute; if this wallet process ends first, the next wallet request continues it";
         return `${amount} arrived at add-funds address "${arriving.requestId}" and ${when}`;
       };
       if (arrivingAll.length === 1) {
-        next = `${arrivingLine(arrivingAll[0])}. Tell the user it needs no step from them; do not hurry it. If balanceAtomic does not show it 10 minutes after that, call wallet_add_funds with request_id "${arrivingAll[0].requestId}": it finishes it now. Do not ask for a new address`;
+        next = `${landedNext ? `${landedNext}. ` : ""}${arrivingLine(arrivingAll[0])}. Tell the user it needs no step from them; do not hurry it. If balanceAtomic does not show it 10 minutes after that, call wallet_add_funds with request_id "${arrivingAll[0].requestId}": it finishes it now. Do not ask for a new address`;
       } else if (arrivingAll.length > 1) {
-        next = `${arrivingAll.map(arrivingLine).join("; ")}. Tell the user the total and that it needs no step from them; do not hurry it. If balanceAtomic does not show one 10 minutes after its time, call wallet_add_funds with its request_id: it finishes it now. Do not ask for a new address`;
+        next = `${landedNext ? `${landedNext}. ` : ""}${arrivingAll.map(arrivingLine).join("; ")}. Tell the user the total and that it needs no step from them; do not hurry it. If balanceAtomic does not show one 10 minutes after its time, call wallet_add_funds with its request_id: it finishes it now. Do not ask for a new address`;
       }
       const earlierDeposits = (ops.oneTimeAdopt === false ? [] : adopter.outcomes()).map((outcome) => ({
         pool: outcome.pool,
@@ -118304,8 +118459,10 @@ ${canonical5}`;
         ...move ? { move } : {},
         ...openSwitches.length ? { poolSwitches: openSwitches } : {},
         ...addFundsOpen.length ? { addFunds: addFundsOpen } : {},
+        ...landingAtomic > 0n ? { landingAtomic: landingAtomic.toString() } : {},
         ...sendWaiting ? { sendWaiting } : {},
         ...notices,
+        ...networkFields(),
         session: {
           ...shownCaps({ ...policy.limits, sessionLeftAtomic: sessionLeft }),
           sessionSpentAtomic: policy.sessionSpentAtomic,
@@ -120851,6 +121008,7 @@ ${canonical5}`;
         id,
         canShield: elsewhereEnabled,
         allowance: async ({ record }) => payMeRoom(record),
+        ...ops.payMeSteps ?? {},
         // Counted against --max-shield once per round, when it is proved and about to be submitted (as a deposit from elsewhere is).
         onShield: ({ amountAtomic, round }) => {
           const key = `${id}:${round}`;
@@ -121502,10 +121660,23 @@ ${canonical5}`;
     }
     const code2 = transferCodes.get(plan.id);
     const poll = `call wallet_transfer_token_status with request_id "${plan.id}"`;
+    let landed = false;
+    if (view2.stage === "shielding") {
+      try {
+        landed = ["finalized", "published"].includes(session.openStore().readWal(`deposit-${plan.depositId}`)?.state);
+      } catch {
+        landed = false;
+      }
+      if (landed) view2.shield = { ...view2.shield, landed: true };
+    }
+    const kept = "; if the host ends this server first, the next start of the wallet continues it (nothing runs twice)";
     const next = {
-      selling: `${poll} in ${POLL_SECONDS3} s: the sell lands in about 15 s and then the shield starts at the next poll`,
-      shielding: `${poll} in ${POLL_SECONDS3} s: the deposit takes a few minutes, then the private send starts at the next poll`,
-      sending: `${poll} in ${POLL_SECONDS3} s; the parts leave after random waits of up to ${plan.maxDelayMinutes} min each. Tell the user the address receives USDC, not the token`,
+      selling: `${poll} in ${POLL_SECONDS3} s: the sell lands in about 15 s and then the shield starts at the next poll${kept}`,
+      shielding: landed ? `${poll} in 10 s: the deposit landed and the private send starts now${kept}` : `${poll} in ${POLL_SECONDS3} s: the deposit takes a few minutes, then the private send starts at the next poll${kept}`,
+      // J-5 (2026-10-21): a part whose time passed while no wallet server ran draws a new wait of up to the delay from the next
+      // start (privateSend.mjs runPrivateSend late redraw: its leave time never shows when the wallet came back), so the
+      // "up to N min" counts from the last start, not from the call.
+      sending: `${poll} in ${POLL_SECONDS3} s; the parts leave after random waits of up to ${plan.maxDelayMinutes} min each${kept}. A part whose time passed while the wallet did not run waits again, up to ${plan.maxDelayMinutes} min from the next start, so its leave time does not show when the wallet came back: tell the user the time counts while the wallet runs. Tell the user the address receives USDC, not the token`,
       sold_waiting_room: `the sold USDC (${/^\d+$/.test(String(plan.sell?.usdcAtomic ?? "")) ? usdcText2(plan.sell.usdcAtomic) : "an unknown amount of"} USDC) no longer fits the 5 USDC shielded balance cap, so it waits on the wallet's own key and nothing was shielded. Spend some with x402_pay or send some out with wallet_unshield, then ${poll}; or cancel with action "cancel" and keep the USDC on the own key`,
       done: "the transfer is done: tell the user the address received USDC, not the token (swap it there); wallet_balance shows the shielded balance",
       cancelled: (() => {
@@ -122912,7 +123083,7 @@ function createSetupTools({
   };
   return { tools: [setupTool, statusTool, ...MCP_TOOL_NAMES.map((name) => name === "x402_discover" ? discoverTool(discoverCacheDir) : notSetUp(name))], doneTool };
 }
-var import_web3132, 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, 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, JOIN_CALL_MAX_MS, JOIN_STEP_MS, sleep2, PROGRESS_EVERY_MS, READ_BUDGET_MS, UNPAID_TOR_TRY_MS, UNPAID_CLEAR_MS, READ_BUDGET_TOOLS, FLOAT_BUSY_CODES, RETRY_MARGIN_MS, ASK_PAY_CODES, limitNext, SAFE_TEXT, MCP_TOOL_ALIASES, POOL_SWITCH_WHY, POOL_SWITCH_NEXT, SWITCH_STATES, quietSwitch, switchKey, ATOMIC_TEXT, switchAmount, switchEta, switchRows, OWNER_CAP_CODES, JOIN_END_MCP, JOIN_END_TERMINAL_LIBRARY, JOIN_RETRY_BACKOFF_MS, WALLET_CAP_FIX, capFix, ownerOnlyNext, mcpNext, CONFIDENTIAL_RETIRED, json2, answerResult, discoverTool, refuse11, publicOffer, FLOAT_PAID_CODES, 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, elsewhereId, AGENT_ID_SCHEMA, agentIdName, minutesText2, DEPOSIT_SENT_STATES, 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, TEMP_CLEAN_DELAY_MS, KEPT_ON_DISK, MAX_SHIELDED_BALANCE_ATOMIC, receiveGenerator, MCP_TOOL_NAMES, MCP_HIDDEN_TOOL_NAMES, SETUP_TERMINAL_NEXT, SETUP_POLL_NEXT, PRIVATE_INFERENCE_WHY, PRIVATE_INFERENCE_NEXT;
+var import_web3132, 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, 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, JOIN_CALL_MAX_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, limitNext, SAFE_TEXT, MCP_TOOL_ALIASES, POOL_SWITCH_WHY, POOL_SWITCH_NEXT, SWITCH_STATES, quietSwitch, switchKey, ATOMIC_TEXT, switchAmount, switchEta, switchRows, OWNER_CAP_CODES, JOIN_END_MCP, JOIN_END_TERMINAL_LIBRARY, JOIN_RETRY_BACKOFF_MS, WALLET_CAP_FIX, capFix, ownerOnlyNext, mcpNext, CONFIDENTIAL_RETIRED, json2, answerResult, discoverTool, refuse11, publicOffer, FLOAT_PAID_CODES, 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, elsewhereId, AGENT_ID_SCHEMA, agentIdName, minutesText2, DEPOSIT_SENT_STATES, depositLanded, DEPOSIT_FINISH_STATES, 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, TEMP_CLEAN_DELAY_MS, KEPT_ON_DISK, MAX_SHIELDED_BALANCE_ATOMIC, receiveGenerator, MCP_TOOL_NAMES, MCP_HIDDEN_TOOL_NAMES, SETUP_TERMINAL_NEXT, SETUP_POLL_NEXT, PRIVATE_INFERENCE_WHY, PRIVATE_INFERENCE_NEXT;
 var init_tools = __esm({
   "wallet/src/mcp/tools.mjs"() {
     "use strict";
@@ -122936,6 +123107,7 @@ var init_tools = __esm({
     init_processLease();
     init_store();
     init_proxy();
+    init_facilitatorOnion();
     init_book();
     init_errorLine();
     init_spendPolicy();
@@ -123024,7 +123196,7 @@ var init_tools = __esm({
       const timer = setTimeout(resolve38, Math.max(0, ms));
       timer.unref?.();
     });
-    PROGRESS_EVERY_MS = 1e4;
+    PROGRESS_EVERY_MS2 = 1e4;
     READ_BUDGET_MS = 3e4;
     UNPAID_TOR_TRY_MS = 12e3;
     UNPAID_CLEAR_MS = 25e3;
@@ -123218,6 +123390,8 @@ var init_tools = __esm({
     agentIdName = (kind, recordId2) => `mcp-agent-id-${kind}-${recordId2}`;
     minutesText2 = (n) => `${n} minute${Number(n) === 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);
+    DEPOSIT_FINISH_STATES = /* @__PURE__ */ new Set(["signed", "submitted", "finalized", "published"]);
     usdcText2 = (atomic4, decimals = 6) => {
       const text3 = formatAtomic(BigInt(atomic4), decimals);
       return text3.includes(".") ? text3.replace(/0+$/, "").replace(/\.$/, "") : text3;
@@ -150706,9 +150880,11 @@ async function runSetupCommand(values, deps) {
   }
   const home = setupHome(deps.env);
   const interactive = !values.has("--yes");
+  const torRunRecords = !values.has("--prefer-tor") && !values.has("--no-tor") && childRunProxy(deps.env).args[0] === "--tor";
   if (interactive && !deps.stdinIsTTY()) {
+    const line = ["setup", "--yes", ...setupArgvOf(values), ...childRunProxy(deps.env).args].map(shellWord).join(" ");
     throw new UsageError(
-      "setup asks its questions in a terminal; in a script or a pipe pass --yes (with any of --max-payment, --max-session, --max-cumulative, --prefer-tor, --private-inference)",
+      `setup asks its questions in a terminal; in a script or a pipe pass --yes: npx -y shinjuku-shielded ${line} (add any of --max-payment, --max-session, --max-cumulative, --prefer-tor, --private-inference)`,
       COMMAND_BY_NAME.get("setup")
     );
   }
@@ -150736,7 +150912,7 @@ async function runSetupCommand(values, deps) {
     ...values.has("--max-cumulative") ? { maxTotal: values.get("--max-cumulative") } : {},
     ...values.has("--max-shield") ? { maxShield: values.get("--max-shield") } : {},
     ...values.has("--max-unshield") ? { maxUnshield: values.get("--max-unshield") } : {},
-    ...values.has("--prefer-tor") ? { tor: true } : {},
+    ...values.has("--prefer-tor") || torRunRecords ? { tor: true } : {},
     ...values.has("--passphrase-file") ? { passphraseFile: values.get("--passphrase-file") } : {},
     ...values.has("--facilitator") ? { facilitator: values.get("--facilitator") } : {},
     ...values.has("--trust-proof-tools") ? { trustProofTools: values.get("--trust-proof-tools") } : {}
@@ -150747,7 +150923,7 @@ async function runSetupCommand(values, deps) {
       io.out(`No spending limit is set. To add one later: ${CLI2} limits --max-payment <usdc> --max-cumulative <usdc> (in USDC, like 0.05; --max-payment caps one payment, --max-cumulative all payments together). A limit for any 24 hours: --max-session <usdc> in the MCP entry of your agent app.
 `);
     }
-    if (!values.has("--prefer-tor")) {
+    if (!values.has("--prefer-tor") && !torRunRecords) {
       const tor = String(await deps.ask("Send every request through Tor (needs Tor running with HTTPTunnelPort 127.0.0.1:9080)? [y/N] ")).trim();
       options.tor = /^y(es)?$/i.test(tor);
     }
@@ -150757,8 +150933,10 @@ async function runSetupCommand(values, deps) {
     }
   }
   const inference = inferenceRecordOf(old, privateInference);
-  if (privateInference === true && options.tor !== true && old?.tor !== true) {
+  if (privateInference === true && (options.tor !== true || torRunRecords) && old?.tor !== true) {
     io.out('Private inference needs Tor, so setup records Tor for mcp (Tor must run with HTTPTunnelPort 127.0.0.1:9080), and the commands below use --tor. To turn both off later: set "tor": false and "inference": { "enabled": false } in config.json (mcp --no-tor skips Tor for one run).\n\n');
+  } else if (torRunRecords && old?.tor !== true) {
+    io.out('Tor is recorded for mcp: this setup runs with --tor, so config.json gets "tor": true and the MCP runs behind Tor too (Tor must run with HTTPTunnelPort 127.0.0.1:9080; mcp --no-tor skips it for one run).\n\n');
   }
   if (behindTor(options.tor === true || privateInference === true || options.tor === void 0 && old?.tor === true)) {
     io.out("Setup continues behind Tor: the release, the proof tools, and the RPC requests go over Tor.\n");
@@ -151535,8 +151713,8 @@ var COMMANDS = [
       flag2("--max-total", "<usdc>", "the older name of --max-cumulative", { check: "atomic", usdc: true, hidden: true }),
       flag2("--max-shield", "<usdc>", "optional: the mcp --max-shield cap, in USDC (one wallet_shield deposit, and this wallet in any 24 hours)", { check: "atomic", usdc: true }),
       flag2("--max-unshield", "<usdc>", "optional: the mcp --max-unshield cap, in USDC (one wallet_unshield send, and this wallet in any 24 hours)", { check: "atomic", usdc: true }),
-      bool2("--prefer-tor", "record Tor for mcp: it then runs behind Tor (needs Tor with HTTPTunnelPort 127.0.0.1:9080); mcp --no-tor skips it for one run. Setup itself then runs behind Tor too"),
-      bool2("--no-tor", "run this setup without Tor although Tor is recorded or asked for (the facilitator then sees this machine's IP address download the release and the proof tools); config.json still records Tor"),
+      bool2("--prefer-tor", "record Tor for mcp: it then runs behind Tor (needs Tor with HTTPTunnelPort 127.0.0.1:9080); mcp --no-tor skips it for one run. Setup itself then runs behind Tor too. setup --tor does the same: it runs setup behind Tor and records Tor for mcp"),
+      bool2("--no-tor", "run this setup without Tor although Tor is recorded or asked for (the facilitator then sees this machine's IP address download the release and the proof tools); config.json still records Tor. With --tor it only stops --tor from recording Tor (the run itself still goes over Tor)"),
       bool2("--private-inference", 'answer yes to "Set your LLM to private inference now?": your agent buys AI answers from usePod, paid from your shielded balance over Tor. Records inference.enabled and Tor (as --prefer-tor) in config.json, and prints the path to the first private call. Without it, --yes keeps what config.json records'),
       flag2("--passphrase-file", "<file>", "your own passphrase file (8 or more characters); default: setup writes a new random passphrase to <home>/passphrase.txt, readable by you alone. Needed for a wallet that exists already"),
       flag2("--facilitator", "<https origin>", `the facilitator whose release, pool, and proof tools setup uses; default ${GUIDE.facilitator}`, { check: "origin" }),
@@ -151551,7 +151729,7 @@ var COMMANDS = [
     ],
     notes: [
       "npx -y shinjuku-shielded setup runs the same command. Without --yes it asks in the terminal: the caps (Enter keeps the default), Tor, and private inference.",
-      "When Tor is recorded or asked for (a yes, --prefer-tor, or --private-inference), setup itself runs behind Tor: the release, the proof-tool downloads, and the RPC requests go over Tor, so the facilitator never sees this machine's IP address make the wallet. Tor must run first (torrc: HTTPTunnelPort 127.0.0.1:9080); --no-tor runs it without Tor.",
+      `When Tor is recorded or asked for (a yes, --tor, --prefer-tor, or --private-inference), setup itself runs behind Tor: the release, the proof-tool downloads, and the RPC requests go over Tor, so the facilitator never sees this machine's IP address make the wallet. config.json then records Tor for mcp ("tor": true), so the MCP runs behind Tor too. Tor must run first (torrc: HTTPTunnelPort 127.0.0.1:9080); --no-tor runs it without Tor.`,
       `Private inference (a yes, or --private-inference): ${PRIVATE_INFERENCE_WHY} Setup records Tor, then prints five steps with real commands: add-funds (it shields the USDC), the first call (${CLI2} infer - --model qwen3-8-flash ... --tor, about 0.0011 USDC = 1100 atomic; its --max-payment must cover the 10000 = 0.01 USDC ceiling plus the fee), infer serve for an OpenAI client, and an MCP restart for inference_chat. In a terminal it then offers to run add-funds; it never pays an inference call.`,
       "The wallet home is SHIELDED_WALLET_HOME, default ~/.carbon-shielded-wallet (every command of this CLI uses it). setup writes there: config.json, passphrase.txt (mode 0600; on Windows an access list of your account alone), the wallet (<pool>/wallet.json, made by init with the production pool, program, network, and USDC), a recovery file recovery-<time>.txt, and proof-tools/<dir>/.",
       "The passphrase is never printed and no MCP tool takes or returns it. The recovery file holds the seed and the key: copy it to two offline places, then delete it from this machine.",