shinjuku-shield 0.3.99 → 0.3.101

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.99. The npm packages `shinjuku-shield` and
+This is version 0.3.101. The npm packages `shinjuku-shield` and
 `shinjuku-shielded` hold the same files. The command is `shinjuku`.
 
 ## Set up
 
 ```sh
-npx -y --no-audit --no-fund shinjuku-shield@0.3.99 setup
+npx -y --no-audit --no-fund shinjuku-shield@0.3.101 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 --no-audit --no-fund shinjuku@0.3.99
+npm install -g --no-audit --no-fund shinjuku@0.3.101
 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 -- npx -y --no-audit --no-fund shinjuku-shield@0.3.99 mcp
+claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.101 mcp
 ```
 
 Claude Desktop (`claude_desktop_config.json`) or Cursor (`~/.cursor/mcp.json`):
 
 ```json
-{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.99", "mcp"] } } }
+{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.101", "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": "5023a2917ba9f9f802a955c0782826c061664754b9b463c59aca590154c1539e",
-  "bytes": 12786716,
-  "sourceCommit": "03d2c6ac920ba3cdec72d0223ec26516d467edc2",
+  "sha256": "1c3d204e7ba114b9d80654035efb4a244ac607f038e1961f23663b7af9b45dc5",
+  "bytes": 12794106,
+  "sourceCommit": "9e761632116ec38e2adb92828c85cc1793b45c90",
   "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",
@@ -1297,5 +1297,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-10-24T11:39:09.768Z"
+  "publishedAt": "2026-10-24T13:59:01.418Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shield",
-  "version": "0.3.99",
+  "version": "0.3.101",
   "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": "5023a291",
-  "shinjukuSha256": "5023a2917ba9f9f802a955c0782826c061664754b9b463c59aca590154c1539e",
+  "shinjukuRelease": "1c3d204e",
+  "shinjukuSha256": "1c3d204e7ba114b9d80654035efb4a244ac607f038e1961f23663b7af9b45dc5",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-shield#readme",

package/shinjuku-wallet.mjs

@@ -50934,7 +50934,7 @@ function historyRpcUrl(value) {
 }
 function historyRpcHint(reason, { signsNothing: signsNothing2 = false } = {}) {
   if (/\bhistory_rpc_failed\b/.test(reason)) {
-    return `the pool's public history from the history source (--history-rpc, or the history proxy this wallet pins for this pool: its onion in a --tor run, else its https origin) could not be used: the source did not answer, answered an error (for example JSON-RPC -32016: it stayed behind the chain for ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s), or served history that does not match the pool account your own RPC reads, a transaction whose Ed25519 signatures do not verify, or a transaction that differs from the copy your own RPC holds (a code after history_rpc_failed names the check). The wallet never falls back to your own RPC by itself. ` + (signsNothing2 ? "This run signs nothing, so nothing changed on chain. " : "A rerun of the same command continues where it stopped and never pays twice. ") + "Rerun later, or use --history-rpc own (your RPC provider then sees that you read this pool)";
+    return `the pool's public history from the history source (--history-rpc, or the history proxy this wallet pins for this pool: its onion in a --tor run, else its https origin) could not be used: the source did not answer, answered an error (for example JSON-RPC -32016: it stayed behind the chain for ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s), or served history that does not match the pool state your own RPC reads, a transaction whose Ed25519 signatures do not verify, or a transaction that differs from the copy your own RPC holds (a code after history_rpc_failed names the check). The wallet never falls back to your own RPC by itself. ` + (signsNothing2 ? "This run signs nothing, so nothing changed on chain. " : "A rerun of the same command continues where it stopped and never pays twice. ") + "Rerun later, or use --history-rpc own (your RPC provider then sees that you read this pool)";
   }
   if (/\bhistory_rpc_invalid\b/.test(reason)) {
     return "--history-rpc takes own, an https URL, or an http://<v3 onion>/ origin with --tor (outside a Tor run an onion is refused before any lookup); nothing was read or signed";
@@ -51157,8 +51157,8 @@ function connectSplit(own, historyUrl, commitment = "finalized", { pause: pause3
     const now = Date.now();
     if (behindSince === void 0) {
       behindSince = now;
-      notice(strictAfterSlot === void 0 ? `history: the history source is behind the chain (JSON-RPC -32016: it has not reached the slot your own RPC read the pool account at); asking again every 0.15 s for about 2 s, then after 0.5 s, 1 s, 2 s, then every 5 s, for at most ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s
-` : `history: the pool account changed after slot ${strictAfterSlot}, the newest slot the history source had reached (its history did not rebuild the pool account your own RPC reads); asking it again every 0.15 s for about 2 s, then after 0.5 s, 1 s, 2 s, then every 5 s, for at most ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s
+      notice(strictAfterSlot === void 0 ? `history: the history source is behind the chain (JSON-RPC -32016: it has not reached the slot your own RPC read the pool state at); asking again every 0.15 s for about 2 s, then after 0.5 s, 1 s, 2 s, then every 5 s, for at most ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s
+` : `history: the pool state changed after slot ${strictAfterSlot}, the newest slot the history source had reached (its history did not rebuild the pool state your own RPC reads); asking it again every 0.15 s for about 2 s, then after 0.5 s, 1 s, 2 s, then every 5 s, for at most ${HISTORY_RPC_BEHIND_WAIT_MS / 1e3} s
 `);
     }
     const delay3 = behindWaits < HISTORY_RPC_BEHIND_FAST_TRIES ? HISTORY_RPC_BEHIND_FAST_MS : HISTORY_RPC_BEHIND_RETRY_STEPS_MS[Math.min(behindWaits - HISTORY_RPC_BEHIND_FAST_TRIES, HISTORY_RPC_BEHIND_RETRY_STEPS_MS.length - 1)];
@@ -107668,12 +107668,19 @@ var init_family = __esm({
 });
 
 // wallet/src/inference/models.mjs
-var DEFAULT_MODEL, DEFAULT_MAX_TOKENS, MIN_MAX_TOKENS, MODELS;
+function defaultMaxTokens(model) {
+  const entry = MODELS.find((item) => item.id === model);
+  return entry && entry.priceOutPerMAtomic * BigInt(DEFAULT_MAX_TOKENS) > FLOOR_ATOMIC * 1000000n ? SHORT_DEFAULT_MAX_TOKENS : DEFAULT_MAX_TOKENS;
+}
+var DEFAULT_MODEL, DEFAULT_MODEL_PAID_WORDS, DEFAULT_MAX_TOKENS, SHORT_DEFAULT_MAX_TOKENS, FLOOR_ATOMIC, MIN_MAX_TOKENS, MODELS;
 var init_models = __esm({
   "wallet/src/inference/models.mjs"() {
     "use strict";
-    DEFAULT_MODEL = "deepseek-v4-1-flash";
-    DEFAULT_MAX_TOKENS = 512;
+    DEFAULT_MODEL = "qwen3-8-flash";
+    DEFAULT_MODEL_PAID_WORDS = "0.00312 USDC";
+    DEFAULT_MAX_TOKENS = 4096;
+    SHORT_DEFAULT_MAX_TOKENS = 512;
+    FLOOR_ATOMIC = 10000n;
     MIN_MAX_TOKENS = 256;
     MODELS = Object.freeze([
       Object.freeze({ id: "claude-opus-5", priceInPerMAtomic: 5000000n, priceOutPerMAtomic: 25000000n, note: "strongest; pays at most $5 in / $25 out per 1M tokens" }),
@@ -109359,7 +109366,7 @@ async function reshieldPocket({ store, connection, options }) {
     held = 0n;
   }
   if (!open4 && held === 0n) {
-    return { success: true, pocket: chosen.index, reshieldedAtomic: "0", note: "this pocket's USDC account holds nothing; nothing was sent" };
+    return { success: true, pocket: chosen.index, reshieldedAtomic: "0", note: "this pocket holds no USDC; nothing was sent" };
   }
   const depositId = open4?.depositId ?? `${prefix}${records.length + 1}`;
   const proofTools = loadP03PublicPaymentProofTools(resolve20(options["proof-tools"]));
@@ -112174,7 +112181,7 @@ var init_job = __esm({
         "a pocket of the old pool is returning its remainder into your private balance (a relayed deposit); it is then moved with your notes",
         `run ${terminalCommand("move")} again in a minute; it resumes the same deposit and never sends twice`
       ],
-      wallet_move_stuck_notes: ["some notes of the old pool sit before every account of the wallet, so no payment can take them", "tell the operator; an unshield of those notes takes them out"],
+      wallet_move_stuck_notes: ["some notes of the old pool are where no payment of this wallet can take them", "tell the operator; an unshield of those notes takes them out"],
       // Pool succession (succession/scheduler.mjs, WALLET-MCP-SPEC §3.3): the old pool was upgraded to a new pool.
       wallet_move_pool_succeeded: [
         "the facilitator upgraded this old pool to a new pool, so it takes no payment and this kind of move cannot run there; your money there is safe",
@@ -114071,16 +114078,16 @@ function pocketCarryReason(carry) {
   if (carry && CARRY_DONE.has(carry.state)) return { done: true, waits: false, code: null, reason: "" };
   if (carry?.state !== "refused") return { done: false, waits: true, code: null, reason: "the wallet has not finished its check of the pool switch" };
   const code2 = String(carry.code ?? "");
-  const reason = code2 === "p03_pocket_carry_source_fill_pending" || code2 === "p03_pocket_carry_source_payment_pending" ? "a pocket top-up or a pocket payment is not final yet" : code2 === "wallet_locked" ? "another wallet command uses the old pool's wallet now" : CARRY_WAIT_CODES.has(code2) ? "the wallet has not finished its check of the pool switch" : code2 === "p03_pocket_carry_target_not_empty" ? "the new pool's wallet already has pocket accounts of its own" : "the pocket records of the two wallets do not match";
+  const reason = code2 === "p03_pocket_carry_source_fill_pending" || code2 === "p03_pocket_carry_source_payment_pending" ? "a pocket top-up or a pocket payment is not final yet" : code2 === "wallet_locked" ? "another wallet command uses the old pool's wallet now" : CARRY_WAIT_CODES.has(code2) ? "the wallet has not finished its check of the pool switch" : code2 === "p03_pocket_carry_target_not_empty" ? "the new pool's wallet already has pockets of its own" : "the pocket records of the two wallets do not match";
   return { done: false, waits: CARRY_WAIT_CODES.has(code2), code: code2, reason };
 }
 function pocketCarryText(carry) {
   if (carry?.state !== "refused") return "";
   const { code: code2, reason } = pocketCarryReason(carry);
   if (CARRY_WAIT_CODES.has(code2)) {
-    return ` Your pocket accounts stay in the old pool's records for now (${reason}). The money in them is safe. The wallet tries again by itself in a minute.`;
+    return ` Your pockets stay in the old pool's records for now (${reason}). The money in them is safe. The wallet tries again by itself in a minute.`;
   }
-  return ` Your pocket accounts stay in the old pool's records (${reason}). The money in them is safe. Tell the operator this code: ${code2}. The wallet tries again by itself every 6 hours.`;
+  return ` Your pockets stay in the old pool's records (${reason}). The money in them is safe. Tell the operator this code: ${code2}. The wallet tries again by itself every 6 hours.`;
 }
 function isPermanentSuccessionCode(code2) {
   const text3 = String(code2 ?? "");
@@ -120461,7 +120468,7 @@ async function readJson3(req) {
     if (value && typeof value === "object" && !Array.isArray(value)) return value;
   } catch {
   }
-  throw refusal2("inference_messages_invalid", 'the request body must be one JSON object, like {"model":"deepseek-v4-1-flash","max_tokens":512,"messages":[{"role":"user","content":"hi"}]}');
+  throw refusal2("inference_messages_invalid", `the request body must be one JSON object, like {"model":"${DEFAULT_MODEL}","max_tokens":${DEFAULT_MAX_TOKENS},"messages":[{"role":"user","content":"hi"}]}`);
 }
 function usageOf(usage2) {
   if (!usage2 || typeof usage2 !== "object") return void 0;
@@ -120472,8 +120479,9 @@ function usageOf(usage2) {
 function defaultMaxTokensLine({ inference, maxPaymentAtomic }) {
   const floor = BigInt(inference.USEPOD_MIN_PAYMENT_ATOMIC ?? 0n);
   const prices = inference.listModels().map((model) => {
-    const output2 = (BigInt(model.priceOutPerMAtomic) * BigInt(DEFAULT_MAX_TOKENS) + 999999n) / 1000000n;
-    return `${usdcWords(output2 > floor ? output2 : floor)} on ${model.id}`;
+    const tokens = defaultMaxTokens(model.id);
+    const output2 = (BigInt(model.priceOutPerMAtomic) * BigInt(tokens) + 999999n) / 1000000n;
+    return `${usdcWords(output2 > floor ? output2 : floor)} on ${model.id}${tokens === DEFAULT_MAX_TOKENS ? "" : ` (max_tokens ${tokens})`}`;
   });
   return `a request without max_tokens gets max_tokens ${DEFAULT_MAX_TOKENS}: the AI provider's price for it is at most ${prices.join(", ")}, plus the prompt at the model's input price and the Shinjuku fee, and never more than this server's limit per request (${usdcWords(maxPaymentAtomic)})`;
 }
@@ -120555,10 +120563,10 @@ function createInferenceServer({
     const given = body.max_tokens ?? body.max_completion_tokens;
     const maxTokensDefault = given === void 0 || given === null;
     if (!maxTokensDefault && (!Number.isSafeInteger(given) || given < 1)) {
-      throw refusal2("inference_max_tokens_required", `max_tokens must be a whole number of at least 1, or left out for the default ${DEFAULT_MAX_TOKENS}: it sets the ceiling price this request may pay; nothing was paid. Example: "max_tokens": 512`, "max_tokens");
+      throw refusal2("inference_max_tokens_required", `max_tokens must be a whole number of at least 1, or left out for the default ${defaultMaxTokens(body.model)}: it sets the ceiling price this request may pay; nothing was paid. Example: "max_tokens": 512`, "max_tokens");
     }
     const raisedFrom = !maxTokensDefault && given < MIN_MAX_TOKENS ? given : void 0;
-    const maxTokens = maxTokensDefault ? DEFAULT_MAX_TOKENS : raisedFrom === void 0 ? given : MIN_MAX_TOKENS;
+    const maxTokens = maxTokensDefault ? defaultMaxTokens(body.model) : raisedFrom === void 0 ? given : MIN_MAX_TOKENS;
     if (typeof body.model !== "string" || !body.model) {
       const ids = inference.listModels().map((model) => model.id).join(", ");
       throw refusal2("inference_model_unknown", `model is required; pick one of: ${ids} (GET /v1/models lists them with prices)`, "model");
@@ -121409,7 +121417,7 @@ function capsLine(caps) {
 }
 function costLine(caps) {
   const payment = usdc2(caps?.maxPaymentAtomic);
-  return `Each answer the app asks for is paid from the private balance: the AI provider's price for the request's max_tokens, up front, plus the 0.001 USDC Shinjuku fee${payment === void 0 ? "" : `, never more than ${payment} USDC a call`}. What the answer does not use is not refunded when it is shorter. A request without max_tokens gets ${DEFAULT_MAX_TOKENS}; one under ${MIN_MAX_TOKENS} is raised to ${MIN_MAX_TOKENS}, so no answer is paid and empty. A request with stream: true works: the answer is paid whole, then arrives at once, at the end.`;
+  return `Each answer the app asks for is paid from the private balance: the AI provider's price for the request's max_tokens, up front, plus the 0.001 USDC Shinjuku fee${payment === void 0 ? "" : `, never more than ${payment} USDC a call`}. What the answer does not use is not refunded when it is shorter. A request without max_tokens gets ${DEFAULT_MAX_TOKENS} (512 for claude-opus-5); one under ${MIN_MAX_TOKENS} is raised to ${MIN_MAX_TOKENS}, so no answer is paid and empty. A request with stream: true works: the answer is paid whole, then arrives at once, at the end.`;
 }
 function planCaps(planned, launch, given) {
   const caps = { source: {} };
@@ -121694,7 +121702,7 @@ function createLocalAiTool({
   return {
     name: LOCAL_AI_TOOL_NAME,
     title: "Private local AI address for agent apps",
-    description: `Use this when the user wants a private AI address for another agent app: an OpenAI-compatible base_url and api key on this machine (${localAiBaseUrl()}). action "start" (the default) runs it in the background and answers the lines to paste into the app: OPENAI_BASE_URL, OPENAI_API_KEY and the model. It keeps running after this app or terminal closes, until action "stop" (or ${terminalCommand3(STOP_WORDS)} in a terminal) or a computer restart. action "status" says whether it runs, its caps, and what it paid. COST: each answer the app asks for is paid from the private balance: the AI provider's price for the request's max_tokens, up front (${DEFAULT_MAX_TOKENS} when the request names none), plus the 0.001 USDC Shinjuku fee; the unused rest is NOT refunded. Caps: the lowest of setup's caps (else 0.05 USDC a call and 1 USDC per server run) and this app's own spending limit; max_payment and max_session (USDC, like "0.02") can only lower them. PRIVACY: it answers only on 127.0.0.1 with its api key, keeps no prompt or answer on disk, and reaches the AI provider through Tor: the AI provider and the company that runs the model see the words, not this machine's IP. This call pays nothing itself. For one answer inside this chat, use inference_chat instead.`,
+    description: `Use this when the user wants a private AI address for another agent app: an OpenAI-compatible base_url and api key on this machine (${localAiBaseUrl()}). action "start" (the default) runs it in the background and answers the lines to paste into the app: OPENAI_BASE_URL, OPENAI_API_KEY and the model. It keeps running after this app or terminal closes, until action "stop" (or ${terminalCommand3(STOP_WORDS)} in a terminal) or a computer restart. action "status" says whether it runs, its caps, and what it paid. COST: each answer the app asks for is paid from the private balance: the AI provider's price for the request's max_tokens, up front (${DEFAULT_MAX_TOKENS} when the request names none, 512 for claude-opus-5), plus the 0.001 USDC Shinjuku fee; the unused rest is NOT refunded. Caps: the lowest of setup's caps (else 0.05 USDC a call and 1 USDC per server run) and this app's own spending limit; max_payment and max_session (USDC, like "0.02") can only lower them. PRIVACY: it answers only on 127.0.0.1 with its api key, keeps no prompt or answer on disk, and reaches the AI provider through Tor: the AI provider and the company that runs the model see the words, not this machine's IP. This call pays nothing itself. For one answer inside this chat, use inference_chat instead.`,
     inputSchema: {
       type: "object",
       properties: {
@@ -124763,13 +124771,13 @@ function checkMessages(messages) {
     return { role: message.role, content: message.content };
   });
 }
-function checkMaxTokens(maxTokens) {
-  if (maxTokens === void 0 || maxTokens === null) return BigInt(DEFAULT_MAX_TOKENS);
+function checkMaxTokens(maxTokens, model) {
+  if (maxTokens === void 0 || maxTokens === null) return BigInt(defaultMaxTokens(model));
   if (!Number.isSafeInteger(maxTokens) || maxTokens < 1) {
     fail39(
       "inference_max_tokens_required",
-      `max_tokens must be a whole number of at least 1, or left out for the default ${DEFAULT_MAX_TOKENS}: it sets the most the call can cost; nothing was paid`,
-      { next: `pass max_tokens 512 for a short answer or 1024 for a long one (256 or more: a reasoning model thinks first), or leave it out for ${DEFAULT_MAX_TOKENS}` }
+      `max_tokens must be a whole number of at least 1, or left out for the default ${defaultMaxTokens(model)}: it sets the most the call can cost; nothing was paid`,
+      { next: `pass max_tokens 512 for a short answer or ${DEFAULT_MAX_TOKENS} for a long one (256 or more: a reasoning model thinks first), or leave it out for ${defaultMaxTokens(model)}` }
     );
   }
   return BigInt(maxTokens);
@@ -124787,7 +124795,7 @@ function ceilingOf(entry, messages, maxTokens) {
 }
 function ceilingAtomic({ model, messages, maxTokens }) {
   const entry = findModel(model);
-  return ceilingOf(entry, checkMessages(messages), checkMaxTokens(maxTokens));
+  return ceilingOf(entry, checkMessages(messages), checkMaxTokens(maxTokens, entry.id));
 }
 function buildChatRequest({ model, messages, maxTokens, temperature, stream }) {
   if (stream === true) {
@@ -124799,7 +124807,7 @@ function buildChatRequest({ model, messages, maxTokens, temperature, stream }) {
   }
   const entry = findModel(model);
   const clean5 = checkMessages(messages);
-  const tokens = checkMaxTokens(maxTokens);
+  const tokens = checkMaxTokens(maxTokens, entry.id);
   if (temperature !== void 0 && (typeof temperature !== "number" || !Number.isFinite(temperature) || temperature < 0 || temperature > 2)) {
     fail39("inference_temperature_invalid", "temperature must be a number from 0 to 2; nothing was paid", { next: "pass temperature 0.7, or leave it out" });
   }
@@ -124902,7 +124910,7 @@ async function inferenceChat({ payFetch, model, messages, maxTokens, temperature
   const { url, init } = buildChatRequest({ model, messages, maxTokens, temperature });
   const entry = findModel(model);
   const clean5 = checkMessages(messages);
-  const tokens = checkMaxTokens(maxTokens);
+  const tokens = checkMaxTokens(maxTokens, entry.id);
   const ceiling = ceilingOf(entry, clean5, tokens);
   const cap = parseCap(maxPaymentAtomic);
   if (ceiling > cap) {
@@ -130907,7 +130915,7 @@ ${canonical5}`;
       store: { readWal: (name) => store.readWal(name), writeWal: (name, value) => store.writeWal(name, value) },
       plan,
       // No time in the stage: it reaches the host's log, and a part's time would point at its exit on chain. The answer has it.
-      onWait: ({ part }) => onStage(`part ${part.index}/${plan.parts.length}: waiting`),
+      onWait: ({ part }) => onStage(`payment ${part.index}/${plan.parts.length}: waiting`),
       // A late part's new time is a plan write: under the lease, so a cancel written meanwhile is kept.
       reschedule: (part, notBefore) => underLease((opened) => {
         store = opened;
@@ -130920,7 +130928,7 @@ ${canonical5}`;
         store = opened;
         if (partCancelled(opened, sendId, part)) return { cancelled: true };
         if (partState(opened, part).state === "exited") return {};
-        const result = await unshieldPart(opened, job, part.unshieldId, part.amountAtomic, (stage) => onStage(`part ${index}/${total}: ${stage}`));
+        const result = await unshieldPart(opened, job, part.unshieldId, part.amountAtomic, (stage) => onStage(`payment ${index}/${total}: ${stage}`));
         if (result.backupPath !== void 0) backup = { backupPath: result.backupPath };
         if (result.backupError !== void 0) backup = { ...backup, backupError: result.backupError };
         store = session.openStore();
@@ -132906,7 +132914,7 @@ ${canonical5}`;
   const inferenceModule = async () => ops.inference ?? await Promise.resolve().then(() => (init_inference(), inference_exports));
   const proxied = () => typeof ops.proxied === "function" ? ops.proxied() : proxyProvenAt() !== void 0;
   const usd = (atomic4) => `$${formatAtomic(atomic4, 6)}`;
-  const INFERENCE_COST_WORDS = "A short deepseek-v4-1-flash answer (the default) paid 0.001047 USDC live: the AI provider's price (often 0.00001-0.0001 USDC) plus the Shinjuku fee (0.001 USDC). The call's cap (max_payment, else the per-payment limit) must still cover the call's ceiling: max_tokens at the model's output price plus the prompt, and at least 0.01 USDC";
+  const INFERENCE_COST_WORDS = "A qwen3-8-flash answer (the default, 4096 tokens) paid 0.00312 USDC live: the AI provider's price plus the Shinjuku fee (0.001 USDC). The call's cap (max_payment, else the per-payment limit) must still cover the call's ceiling: max_tokens at the model's output price plus the prompt, and at least 0.01 USDC";
   const paysUpToAtomic = (inference, asked) => {
     try {
       const extra = inference.listModels().find((model) => model.id === asked.model).priceOutPerMAtomic * 100n;
@@ -132960,7 +132968,7 @@ ${canonical5}`;
     ],
     inference_model_unknown: [
       "that model id is not one the AI provider serves through this wallet",
-      "call inference_chat with no prompt or messages (it lists the model ids, free), then pass one of its ids, for example deepseek-v4-1-flash or claude-opus-5"
+      "call inference_chat with no prompt or messages (it lists the model ids, free), then pass one of its ids, for example qwen3-8-flash or claude-opus-5"
     ],
     inference_messages_invalid: [
       "messages must be a non-empty list of { role, content } with role system, user, or assistant and content text",
@@ -133005,11 +133013,11 @@ ${canonical5}`;
   const inferenceChat2 = {
     name: "inference_chat",
     title: "Ask an AI model, paid privately",
-    description: `Use this when the user wants an AI model's answer paid from the PRIVATE balance: it calls the AI provider's x402 chat endpoint (the AI provider picks the model's provider) and pays it privately (the chain does not show which wallet paid); use this tool, not x402_pay, for AI answers. Only prompt (or messages) is needed: model defaults to deepseek-v4-1-flash and max_tokens to 512. Called with neither prompt nor messages, it lists the models and their prices and pays nothing (for example deepseek-v4-1-flash, qwen3-8-flash, claude-opus-5). COST: a short deepseek-v4-1-flash answer paid 0.001047 USDC live (the AI provider's price, often 0.00001-0.0001 USDC, plus the Shinjuku fee 0.001 USDC). The call's cap (max_payment, in USDC like "0.05", or max_payment_atomic; else the per-payment limit) must still cover the call's ceiling: max_tokens of output plus the prompt at the model's prices, and at least 0.01 USDC (the AI provider's floor for its standard offer). The total paid is never above the cap, and the cap is only a limit: a larger cap never pays more. What max_tokens does not use is NOT refunded when the answer is shorter. max_tokens must be at least ${INFERENCE_MIN_MAX_TOKENS} (a reasoning model spends its first tokens thinking). Example: { "prompt": "Name three prime numbers" }. PRIVACY: the AI provider and the company that runs the model see the prompt and the answer; never put keys, passphrases, or secrets in it. It runs only when this wallet runs over Tor or its own proxy (else inference_tor_required, nothing paid), so they never see this machine's IP. The same caps as x402_pay apply (max_payment can only lower the per-payment limit). When the call can cost more than that limit and the MCP client can ask the user, the wallet asks the user once to allow this one call; else the answer says the cost and the limit. On an error code that ends in _retry_same_request, call inference_chat again with the SAME request_id and arguments: it never pays twice. No streaming.`,
+    description: `Use this when the user wants an AI model's answer paid from the PRIVATE balance: it calls the AI provider's x402 chat endpoint (the AI provider picks the model's provider) and pays it privately (the chain does not show which wallet paid); use this tool, not x402_pay, for AI answers. Only prompt (or messages) is needed: model defaults to qwen3-8-flash and max_tokens to 4096 (512 for claude-opus-5). Called with neither prompt nor messages, it lists the models and their prices and pays nothing (for example qwen3-8-flash, deepseek-v4-1-flash, claude-opus-5). COST: a qwen3-8-flash answer at 4096 tokens paid 0.00312 USDC live (the AI provider's price plus the Shinjuku fee 0.001 USDC). The call's cap (max_payment, in USDC like "0.05", or max_payment_atomic; else the per-payment limit) must still cover the call's ceiling: max_tokens of output plus the prompt at the model's prices, and at least 0.01 USDC (the AI provider's floor for its standard offer). The total paid is never above the cap, and the cap is only a limit: a larger cap never pays more. What max_tokens does not use is NOT refunded when the answer is shorter. max_tokens must be at least ${INFERENCE_MIN_MAX_TOKENS} (a reasoning model spends its first tokens thinking). Example: { "prompt": "Name three prime numbers" }. PRIVACY: the AI provider and the company that runs the model see the prompt and the answer; never put keys, passphrases, or secrets in it. It runs only when this wallet runs over Tor or its own proxy (else inference_tor_required, nothing paid), so they never see this machine's IP. The same caps as x402_pay apply (max_payment can only lower the per-payment limit). When the call can cost more than that limit and the MCP client can ask the user, the wallet asks the user once to allow this one call; else the answer says the cost and the limit. On an error code that ends in _retry_same_request, call inference_chat again with the SAME request_id and arguments: it never pays twice. No streaming.`,
     inputSchema: {
       type: "object",
       properties: {
-        model: { type: "string", description: "Optional, default deepseek-v4-1-flash. A model id (inference_chat with no prompt lists them)." },
+        model: { type: "string", description: "Optional, default qwen3-8-flash. A model id (inference_chat with no prompt lists them)." },
         messages: { type: "array", items: {
           type: "object",
           properties: { role: { type: "string", enum: ["system", "user", "assistant"] }, content: { type: "string" } },
@@ -133017,7 +133025,7 @@ ${canonical5}`;
           additionalProperties: false
         }, description: "The conversation, oldest first. Or pass prompt instead." },
         prompt: { type: "string", description: "One user message (instead of messages)." },
-        max_tokens: { type: "integer", minimum: 1, description: `Optional, default 512, at least ${INFERENCE_MIN_MAX_TOKENS}. The most output tokens; the call pays for all of them up front. A reasoning model spends its first tokens thinking, so fewer can end with no answer.` },
+        max_tokens: { type: "integer", minimum: 1, description: `Optional, default 4096 (512 for claude-opus-5), at least ${INFERENCE_MIN_MAX_TOKENS}. The most output tokens; the call pays for all of them up front. A reasoning model spends its first tokens thinking, so fewer can end with no answer.` },
         temperature: { type: "number", minimum: 0, maximum: 2, description: "Sampling temperature; leave it out for the model's default." },
         max_payment: { type: "string", description: 'Optional: the most this call may pay, in USDC, like "0.05"; at most the spending limit.' },
         max_payment_atomic: { type: "string", pattern: "^[1-9][0-9]*$", description: "The most this call may pay, in atomic units; at most the spending limit." },
@@ -133040,10 +133048,11 @@ ${canonical5}`;
           ...body,
           paid: false,
           detail: "no prompt or messages were given, so nothing was sent or paid; these are the models and prices",
-          next: body.ready ? "call inference_chat with prompt (model defaults to deepseek-v4-1-flash, max_tokens to 512)" : body.next
+          next: body.ready ? "call inference_chat with prompt (model defaults to qwen3-8-flash, max_tokens to 4096)" : body.next
         });
       }
-      const args = { ...rawArgs, model: rawArgs.model ?? DEFAULT_MODEL, max_tokens: rawArgs.max_tokens ?? 512 };
+      const model = rawArgs.model ?? DEFAULT_MODEL;
+      const args = { ...rawArgs, model, max_tokens: rawArgs.max_tokens ?? defaultMaxTokens(model) };
       if (!proxied()) return torRefusal();
       const inference = await inferenceModule();
       if (args.prompt !== void 0 && args.messages !== void 0) {
@@ -133053,7 +133062,7 @@ ${canonical5}`;
         return refuse12(
           "inference_max_tokens_too_low",
           `max_tokens ${args.max_tokens} is below ${INFERENCE_MIN_MAX_TOKENS}: a reasoning model (qwen3-8-flash) spends its first tokens thinking, and with max_tokens 32 or 80 it was paid and gave no answer; nothing was paid`,
-          `call inference_chat again with max_tokens ${INFERENCE_MIN_MAX_TOKENS} or more (512, the default, answers a short question), or leave max_tokens out; a larger max_tokens costs little more: a short deepseek-v4-1-flash answer paid 0.001047 USDC`,
+          `call inference_chat again with max_tokens ${INFERENCE_MIN_MAX_TOKENS} or more (512 answers a short question), or leave max_tokens out; a larger max_tokens costs little more: a qwen3-8-flash answer at 4096 tokens paid 0.00312 USDC`,
           { paid: false, maxTokens: args.max_tokens, minMaxTokens: INFERENCE_MIN_MAX_TOKENS }
         );
       }
@@ -136046,7 +136055,8 @@ __export(chat_exports, {
   isProgressLine: () => isProgressLine,
   knownPrivateBalance: () => knownPrivateBalance,
   leastAnswerAtomic: () => leastAnswerAtomic,
-  runChat: () => runChat
+  runChat: () => runChat,
+  savedBalance: () => savedBalance
 });
 import { randomBytes as randomBytes27 } from "node:crypto";
 import { createInterface } from "node:readline";
@@ -136067,16 +136077,20 @@ function answerCostWords(entry, maxTokens) {
   const most = leastAnswerAtomic(entry, maxTokens);
   return `up to about ${usdcWords((most + 99n) / 100n * 100n)}`;
 }
-function balanceLine2(store) {
+function savedBalance(store) {
   try {
     const report = computeBalance({ store, snapshotRead: readBalanceSnapshot(store), source: "local" });
     const value = report.split?.shieldedAtomic;
     if (typeof value === "string" && /^[0-9]{1,31}$/.test(value)) {
-      return report.status === "current" || report.status === "empty" ? `Your private balance is ${usdcWords(value)}.` : `Your private balance was ${usdcWords(value)} at its last read; a payment or a deposit since then is not in this number. ${commandLine("balance")} in another terminal reads it again.`;
+      return {
+        atomic: BigInt(value),
+        current: (report.status === "current" || report.status === "empty") && !report.detail?.pendingDeposits?.length,
+        atMs: Date.parse(report.detail?.lastRefresh?.at ?? "")
+      };
     }
   } catch {
   }
-  return `The private balance is not known in this chat yet. ${commandLine("balance")} in another terminal shows it.`;
+  return void 0;
 }
 function httpStatusOf(error) {
   for (let item = error, depth = 0; item && depth < 4; item = item.cause, depth += 1) {
@@ -136221,6 +136235,20 @@ async function runChat({ io, values, deps = {} }) {
   const state = { model, history: [], spent: 0n, answers: 0, empty: 0, pending: void 0, busy: false, interrupts: 0 };
   const say6 = (line) => io.err(`${line}
 `);
+  const inPlace = deps.statusInPlace ?? Boolean(process.stderr.isTTY);
+  let lastKnown;
+  const readBalance = () => {
+    let saved;
+    try {
+      saved = (deps.savedBalance ?? savedBalance)(session.openStore());
+    } catch {
+      saved = void 0;
+    }
+    if (saved && (saved.current || lastKnown && saved.atMs > lastKnown.atMs)) {
+      lastKnown = { atomic: saved.atomic, spentThen: state.spent, atMs: saved.atMs };
+    }
+    return saved;
+  };
   const entryOf = (id) => models.find((entry) => entry.id === id);
   const tokensFor = (id, messages, limit) => {
     try {
@@ -136229,17 +136257,21 @@ async function runChat({ io, values, deps = {} }) {
       return CHAT_SHORT_TOKENS;
     }
   };
+  const costWords = (id) => {
+    const tokens = tokensFor(id, [{ role: "user", content: "hi" }], caps.answer);
+    if (id === DEFAULT_MODEL && tokens === CHAT_MAX_TOKENS) return `about ${DEFAULT_MODEL_PAID_WORDS}, as paid in a live test`;
+    return answerCostWords(entryOf(id), tokens);
+  };
   const costLine2 = (id) => {
     try {
-      const tokens = tokensFor(id, [{ role: "user", content: "hi" }], caps.answer);
-      return `A short answer costs ${answerCostWords(entryOf(id), tokens)}`;
+      return `An answer costs ${costWords(id)}`;
     } catch {
       return "Each answer is paid";
     }
   };
   const questionsWords = () => {
     const asked = state.answers + state.empty;
-    return `${asked} question${asked === 1 ? "" : "s"}${state.empty ? ` (${state.empty} came back empty)` : ""}`;
+    return `${asked} question${asked === 1 ? "" : "s"}${state.empty ? ` (${state.empty} paid, no answer)` : ""}`;
   };
   const left = () => caps.chat > state.spent ? caps.chat - state.spent : 0n;
   const capsLine2 = () => `Caps: ${usdcWords(caps.answer)} an answer and ${usdcWords(caps.chat)} for this chat (${usdcWords(left())} left).`;
@@ -136249,7 +136281,7 @@ async function runChat({ io, values, deps = {} }) {
     "Memory only: the chat writes no chat file and no log, and the wallet writes no copy of the conversation, not even encrypted: its payment records keep only the amounts. The conversation is gone when the chat ends. Let an answer arrive before you end the chat: if the chat ends while an answer is on its way, that answer is gone, and a payment already sent may not come back.",
     `Cost: each answer pays the AI provider's price for up to ${CHAT_MAX_TOKENS} tokens (${CHAT_SHORT_TOKENS} for a model whose longer answer is above your cap) plus the 0.001 USDC Shinjuku fee, up front; what an answer does not use is not refunded. ${costLine2(state.model)} with ${state.model}. Each question sends the whole conversation, so a long chat costs more (/new starts again).`,
     `Caps: ${usdcWords(caps.answer)} an answer and ${usdcWords(caps.chat)} for this chat${capsSourceText(caps)}`,
-    `Commands: /new starts a new conversation, /cost shows what this chat paid, /balance shows your private balance, /model <id> changes the model (${modelIds2}), /help shows this, /exit (or Ctrl+D) ends the chat${state.pending ? ", /retry finishes the unfinished answer" : ""}.`
+    `Commands: /new starts a new conversation, /cost shows what this chat paid, /balance shows your private balance, /model <id> changes the model (${modelIds2}), /help shows this, /exit (or /quit, Ctrl+D) ends the chat${state.pending ? ", /retry finishes the unfinished answer" : ""}.`
   ].join("\n");
   let reader;
   const onInterrupt = () => {
@@ -136276,7 +136308,8 @@ async function runChat({ io, values, deps = {} }) {
     let held;
     try {
       least = leastAnswerAtomic(entryOf(state.model), CHAT_SHORT_TOKENS);
-      held = knownPrivateBalance(session.openStore());
+      const saved = readBalance();
+      held = saved?.current ? saved.atomic : void 0;
     } catch {
       held = void 0;
     }
@@ -136286,11 +136319,8 @@ async function runChat({ io, values, deps = {} }) {
     const runTurn = async (turn) => {
       if (turn.capAtomic === void 0) {
         let limit = caps.answer < left() ? caps.answer : left();
-        try {
-          const held2 = knownPrivateBalance(session.openStore());
-          if (held2 !== void 0 && held2 < limit) limit = held2;
-        } catch {
-        }
+        const saved = readBalance();
+        if (saved?.current && saved.atomic < limit) limit = saved.atomic;
         turn.maxTokens = tokensFor(turn.model, turn.messages, limit);
         let ceiling;
         try {
@@ -136310,17 +136340,33 @@ async function runChat({ io, values, deps = {} }) {
         }
         turn.capAtomic = caps.answer < room ? caps.answer : room;
       }
-      say6(`(asking ${turn.model} privately over Tor; this takes a few seconds)`);
       state.busy = true;
       const startedAt = Date.now();
       let lastLineAt = startedAt;
+      let resent = false;
       const seconds2 = () => Math.round((Date.now() - startedAt) / 1e3);
+      const status = () => {
+        const text3 = `(asking ${turn.model} privately over Tor: ${seconds2()} s)`;
+        io.err(`\r\x1B[K${text3.slice(0, Math.max(20, (process.stderr.columns ?? 80) - 1))}`);
+      };
+      const clearStatus = () => {
+        if (inPlace) io.err("\r\x1B[K");
+      };
+      if (inPlace) status();
+      else say6(`(asking ${turn.model} privately over Tor)`);
       onPhase = (phase) => {
-        if (phase !== "seller-resend-unanswered") return;
+        if (phase !== "seller-resend-unanswered" || resent) return;
+        resent = true;
         lastLineAt = Date.now();
-        say6(`(the AI provider has not answered yet; asking it again with the same payment, ${seconds2()} s so far: it never pays twice)`);
+        clearStatus();
+        say6("(the AI provider is slow to answer: the wallet asks it again with the same payment, which never pays twice)");
+        if (inPlace) status();
       };
       const waiting = setInterval(() => {
+        if (inPlace) {
+          status();
+          return;
+        }
         if (Date.now() - lastLineAt < STILL_WAITING_MS) return;
         lastLineAt = Date.now();
         say6(`(still waiting for the answer, ${seconds2()} s so far)`);
@@ -136337,10 +136383,13 @@ async function runChat({ io, values, deps = {} }) {
           requestId: turn.requestId
         });
       } catch (error) {
+        clearInterval(waiting);
+        clearStatus();
         failed(error, turn);
         return;
       } finally {
         clearInterval(waiting);
+        clearStatus();
         onPhase = void 0;
         state.busy = false;
         state.interrupts = 0;
@@ -136385,17 +136434,29 @@ async function runChat({ io, values, deps = {} }) {
         say6("Nothing was paid. The AI provider now asks a kind of payment whose record would keep your words, and a private chat never pays that way. Ask again; if this repeats, the AI provider changed how it takes payment.");
         return;
       }
+      const status = httpStatusOf(error);
+      if (providerKept(code2, status)) {
+        const kept2 = /^[1-9][0-9]{0,30}$/.test(String(error?.paidAtomic ?? "")) ? BigInt(error.paidAtomic) : void 0;
+        if (kept2 !== void 0) state.spent += kept2;
+        state.empty += 1;
+        const what = `answered with an error (HTTP ${status})`;
+        const others = models.filter((entry) => entry.id !== turn.model).map((entry) => entry.id).join(", ");
+        say6(`Your payment${kept2 === void 0 ? "" : ` (${usdcWords(kept2)})`} went to the AI provider, but it ${what} and sent no answer. That payment does not come back. Ask again (a new question pays again), or pick another model with /model (${others}). This chat paid ${usdcWords(state.spent)} so far.`);
+        return;
+      }
+      if (INSUFFICIENT2.test(code2 ?? "")) {
+        state.pending = turn;
+        say6(`Your private balance is too low for this answer. Nothing was paid. Add funds in another terminal: ${commandLine("add-funds")} (it asks the amount, from 0.01 USDC), or ask your agent to add funds. When it says ready, type /retry: it asks the same question again.`);
+        return;
+      }
       const again = surelyNothing ? "ask again" : "type /retry (it finishes the same payment and never pays twice)";
       if (!surelyNothing) state.pending = turn;
       const paidWords = surelyNothing ? "Nothing was paid." : "It may be paid already.";
       if (/seller_unanswered_paid/.test(code2 ?? "")) {
-        const status = httpStatusOf(error);
-        const what = status >= 400 ? `answered with an error (HTTP ${status}) and no answer` : status === 202 ? "has not sent the answer yet" : "did not answer";
+        const what = status === 202 ? "has not sent the answer yet" : "did not answer";
         say6(`Your payment reached the AI provider, but it ${what}. Type /retry: it asks again with the same payment and never pays twice.`);
       } else if (code2 === "inference_tor_required" || code2 === "ECONNREFUSED" || proxyRefusedConnection(error)) {
         say6(`Your private connection (Tor) stopped answering, so the question could not go out. ${paidWords} Start Tor again, then ${again}.`);
-      } else if (INSUFFICIENT2.test(code2 ?? "")) {
-        say6(`Your private balance is too low for this answer. ${paidWords} Add funds in another terminal: ${commandLine("add-funds")} (it asks the amount, from 0.01 USDC), or ask your agent to add funds. Then ${again}.`);
       } else if (CAP_CODES.test(code2 ?? "")) {
         say6(`This answer costs more than the chat's caps allow. ${paidWords} ${capsLine2()} End the chat (/exit) and start it again with higher caps when you want more: ${commandLine(`chat --max-payment ${higherCap(caps.answer)} --max-session ${higherCap(caps.chat)}`)}`);
       } else if (code2 === "inference_no_provider") {
@@ -136411,7 +136472,7 @@ async function runChat({ io, values, deps = {} }) {
     const command2 = async (text3) => {
       const [name, ...rest] = text3.split(/\s+/);
       const arg = rest.join(" ").trim();
-      if (name === "/exit") return true;
+      if (name === "/exit" || name === "/quit" || name === "/q") return true;
       if (name === "/new") {
         state.history = [];
         state.pending = void 0;
@@ -136420,13 +136481,24 @@ async function runChat({ io, values, deps = {} }) {
       } else if (name === "/cost") {
         say6(`This chat paid ${usdcWords(state.spent)} for ${questionsWords()}. ${capsLine2()}`);
       } else if (name === "/balance") {
-        let line;
-        try {
-          line = balanceLine2(session.openStore());
-        } catch {
-          line = void 0;
+        const saved = readBalance();
+        const again = `A deposit since then is not in this number: ${commandLine("balance")} in another terminal reads it again.`;
+        if (saved?.current) {
+          say6(`Your private balance is ${usdcWords(saved.atomic)}.`);
+        } else if (lastKnown) {
+          const since = state.spent - lastKnown.spentThen;
+          if (since === 0n) {
+            say6(`Your private balance is about ${usdcWords(lastKnown.atomic)} at its last read. ${again}`);
+          } else if (since > lastKnown.atomic) {
+            say6(`This chat paid ${usdcWords(since)} since the last read of your private balance (${usdcWords(lastKnown.atomic)}), so a deposit came in since then. ${commandLine("balance")} in another terminal reads the balance again.`);
+          } else {
+            say6(`Your private balance is about ${usdcWords(lastKnown.atomic - since)}: ${usdcWords(lastKnown.atomic)} at its last read, less the ${usdcWords(since)} this chat paid since then. ${again}`);
+          }
+        } else if (saved) {
+          say6(`Your private balance was ${usdcWords(saved.atomic)} at its last read; this chat paid ${usdcWords(state.spent)} since it started. ${again}`);
+        } else {
+          say6(`The private balance is not known in this chat yet. ${commandLine("balance")} in another terminal shows it.`);
         }
-        say6(line ?? `The private balance is not known in this chat yet. ${commandLine("balance")} in another terminal shows it.`);
       } else if (name === "/model") {
         const found = models.find((entry) => entry.id === arg);
         if (found) {
@@ -136435,7 +136507,7 @@ async function runChat({ io, values, deps = {} }) {
         } else {
           say6([
             `${arg ? `There is no model ${JSON.stringify(arg).slice(0, 80)}. ` : ""}Model now: ${state.model}. Pick one with /model <id>:`,
-            ...models.map((entry) => `  ${entry.id}${entry.note ? `  ${entry.note}` : ""}  (${costLine2(entry.id).replace(/^A short answer costs /, "a short answer ")})`)
+            ...models.map((entry) => `  ${entry.id}${entry.note ? `  ${entry.note}` : ""}  (${costLine2(entry.id).replace(/^An answer costs /, "an answer ")})`)
           ].join("\n"));
         }
       } else if (name === "/retry") {
@@ -136476,7 +136548,7 @@ async function runChat({ io, values, deps = {} }) {
     await session.close();
   }
 }
-var DEFAULT_MODEL2, CHAT_DEFAULT_MODEL, CHAT_MAX_TOKENS, CHAT_SHORT_TOKENS, DEFAULT_ANSWER_CAP_ATOMIC, DEFAULT_CHAT_CAP_ATOMIC, CHEAPEST_MODEL, STILL_WAITING_MS, higherCap, POSITIVE_ATOMIC9, SHINJUKU_FEE_ATOMIC, SHORT_QUESTION_TOKENS, PASTE_JOIN_MS, INSUFFICIENT2, CAP_CODES, WAIT_CODES, NO_ANSWER_CODES, NOTHING_PAID, CAP_FROM, PROGRESS_LINE, SHOWN_PROGRESS, isProgressLine, fail46, nothingPaid;
+var DEFAULT_MODEL2, CHAT_DEFAULT_MODEL, CHAT_MAX_TOKENS, CHAT_SHORT_TOKENS, DEFAULT_ANSWER_CAP_ATOMIC, DEFAULT_CHAT_CAP_ATOMIC, CHEAPEST_MODEL, STILL_WAITING_MS, providerKept, higherCap, POSITIVE_ATOMIC9, SHINJUKU_FEE_ATOMIC, SHORT_QUESTION_TOKENS, PASTE_JOIN_MS, INSUFFICIENT2, CAP_CODES, WAIT_CODES, NO_ANSWER_CODES, NOTHING_PAID, CAP_FROM, PROGRESS_LINE, SHOWN_PROGRESS, SELF_PAY_LINE, isProgressLine, fail46, nothingPaid;
 var init_chat = __esm({
   "wallet/src/inference/chat.mjs"() {
     "use strict";
@@ -136493,12 +136565,13 @@ var init_chat = __esm({
     init_models();
     DEFAULT_MODEL2 = DEFAULT_MODEL;
     CHAT_DEFAULT_MODEL = DEFAULT_MODEL;
-    CHAT_MAX_TOKENS = 2048;
+    CHAT_MAX_TOKENS = DEFAULT_MAX_TOKENS;
     CHAT_SHORT_TOKENS = 512;
     DEFAULT_ANSWER_CAP_ATOMIC = 50000n;
     DEFAULT_CHAT_CAP_ATOMIC = 1000000n;
     CHEAPEST_MODEL = "deepseek-v4-1-flash";
     STILL_WAITING_MS = 2e4;
+    providerKept = (code2, status) => code2 === "p03_float_seller_kept_payment" || /seller_unanswered_paid/.test(code2 ?? "") && Number.isInteger(status) && status >= 500;
     higherCap = (atomic4) => usdcFlagText((BigInt(atomic4) * 2n + 9999n) / 10000n * 10000n);
     POSITIVE_ATOMIC9 = /^[1-9][0-9]{0,30}$/;
     SHINJUKU_FEE_ATOMIC = 1000n;
@@ -136510,9 +136583,10 @@ var init_chat = __esm({
     NO_ANSWER_CODES = /^inference_(upstream_failed|response_invalid)$/;
     NOTHING_PAID = /\bnothing was (?:sent or )?paid\b|\bnothing was paid or signed\b/i;
     CAP_FROM = { line: "from this command line", setup: "set in setup", default: "the default" };
-    PROGRESS_LINE = /^(?:tor|rpc|history|memo service): |^reading \d+ memos? from the memo service|^reading your private balance again\b|^merge \S+: self-paying\b/;
+    PROGRESS_LINE = /^(?:tor|rpc|history|memo service): |^reading \d+ memos? from the memo service|^reading your private balance again\b|^getting your balance ready: moving \S+ USDC of one deposit\b/;
     SHOWN_PROGRESS = new RegExp(`\\bWARNING\\b|\\bminutes?\\b|${TOR_NOTICE_LINE.source}`);
-    isProgressLine = (line) => PROGRESS_LINE.test(line) && !SHOWN_PROGRESS.test(line) && !TOR_TROUBLE_LINE.test(line);
+    SELF_PAY_LINE = /^getting your balance ready: moving \S+ USDC of one deposit\b/;
+    isProgressLine = (line) => PROGRESS_LINE.test(line) && (SELF_PAY_LINE.test(line) || !SHOWN_PROGRESS.test(line) && !TOR_TROUBLE_LINE.test(line));
     fail46 = (deps, message) => typeof deps.publicFailure === "function" ? deps.publicFailure(message) : new Error(message);
     nothingPaid = (error) => error?.name === "InferenceError" && !error.details?.receipt || error?.name === "SpendRefusalError" || NOTHING_PAID.test(String(error?.message ?? ""));
   }
@@ -157682,7 +157756,7 @@ async function main5(args = process.argv.slice(2), { output: output2 = (result)
           timing: createTimingLog(`${walletPath2}.timing.log`, { component: "payer" })
         };
       }
-      progress2(`merge ${id}: self-paying ${usdc9(amountAtomic)} USDC of one deposit into a note of this wallet (about 2 minutes; it waits for finality)`);
+      progress2(`getting your balance ready: moving ${usdc9(amountAtomic)} USDC of one deposit inside your private balance (about 2 minutes; it waits for finality)`);
       try {
         const paid = await selfPay({
           store,
@@ -157714,7 +157788,7 @@ async function main5(args = process.argv.slice(2), { output: output2 = (result)
       } catch (error) {
         if (!DEAD.test(String(error?.message))) throw error;
         store.writeWal(`self-pay-${id}`, { ...store.readWal(`self-pay-${id}`), state: "abandoned" });
-        progress2(`step ${id} never landed (nothing was spent); run ${commandLine("balance --refresh")}, then ${commandLine("prepare")} again: it moves that deposit under a new id`);
+        progress2(`that step never landed (nothing was spent); run ${commandLine("balance --refresh")}, then ${commandLine("prepare")} again: it moves that deposit in a new step`);
         return { amountAtomic, state: "abandoned" };
       }
     };
@@ -160734,11 +160808,16 @@ var ROUTE_LABEL = Object.freeze({
   changenow: "a ChangeNOW swap",
   "privacy-cash": "your own wallet through the Privacy Cash crowd"
 });
+var SETUP_LINES_BELOW = "the setup lines below";
 function privacyCost(plan) {
   const route = plan.route === "exchange" ? "the wallet or exchange you send from sees the amount and the one-time address, so it can link you to this deposit (an exchange knows who you are); the chain shows only that sender paying a new address" : plan.route === "changenow" ? "ChangeNOW sees the amount, the one-time address, and what you paid with (Monero hides the sender; BTC or ETH can be traced to you); the chain shows only ChangeNOW paying a new address" : `the chain shows your --from-key-file wallet paying into Privacy Cash and, at least a day and 10 deposits later, Privacy Cash paying a new address; ${plan.crowd?.via === "local" ? "Privacy Cash's server sees neither step (--via local), and the chain can pair the two only by amount and time among the deposits between them" : "Privacy Cash's server sees both steps and can link them (--via sdk; --via local avoids that)"}`;
   const split5 = splitOf(plan) > 1 ? `. ${plan.parts ? "With --split auto" : `With --split ${splitOf(plan)}`}: ${partsText(plan)}, each amount public; the RPC reads the ${splitOf(plan)} one-time addresses one after another, and the deposits land close together, so both can show they are one depositor's (about what one deposit of the total shows); the facilitator pays the fee and rent of each, and each takes one of the pool's deposit places. Your payments still prove under the same per-epoch anchor as every other payment` : "";
   return `${route}. The amount and time of every deposit are public, and Shinjuku's server sees them too; while few other people add money, the time can still link this deposit to your later payments${split5}`;
 }
+function privacyShort(plan) {
+  if (plan.route !== "exchange" || splitOf(plan) > 1) return privacyCost(plan);
+  return "the wallet or exchange you send from sees the amount and this address (an exchange knows who you are). The amount and time are public, and Shinjuku's server sees them; while few people add money, the time can link this deposit to your later payments";
+}
 function fundsView(store, plan, { now = Date.now(), running } = {}) {
   const decimals = Number(store.state.decimals ?? 6);
   const stage = currentStage(store, plan);
@@ -160796,7 +160875,7 @@ function fundsView(store, plan, { now = Date.now(), running } = {}) {
     view2.balance = balance ?? null;
     const pockets = balance?.pocketsAtomic && balance.pocketsAtomic !== "0" ? `, pockets ${usdc5(balance.pocketsAtomic, decimals)}` : "";
     view2.status = `ready since ${plan.done?.ready ?? iso2(now)}: ` + (balance?.total ? `total ${balance.total} USDC (shielded ${balance.shinjukuShielded}${pockets})` : `balance ${balance?.status ?? "unknown"} (${cli()} balance --pool ${store.state.pool} says why)`) + (split5 > 1 && Number.isSafeInteger(balance?.fundedAccounts) ? `; payments without waiting this epoch: up to ${balance.fundedAccounts} (one per funded deposit; ${cli()} balance says why)` : "");
-    view2.next = process.env.SHINJUKU_WALLET_SETUP_NEXT_BY_PARENT === "1" ? "the setup lines below" : `
+    view2.next = process.env.SHINJUKU_WALLET_SETUP_NEXT_BY_PARENT === "1" ? SETUP_LINES_BELOW : `
   Chat privately in this terminal: ${commandLine("chat")}
   Use private AI from other apps: ${commandLine("infer start")}
   In your agent app, ask "what is my balance" or ask it to pay an x402 URL.
@@ -160821,14 +160900,16 @@ function fundsView(store, plan, { now = Date.now(), running } = {}) {
   view2.status += `. Privacy: ${view2.privacy}`;
   return view2;
 }
-function fundsSummary(view2) {
+function fundsSummary(view2, { named = false } = {}) {
   const privacy = `. Privacy: ${view2.privacy}`;
   const status = view2.status.endsWith(privacy) ? view2.status.slice(0, -privacy.length) : view2.status;
   const total = view2.balance?.total ? ` (your balance now: ${plainUsdc(String(view2.balance.total))} USDC)` : "";
+  const run5 = named ? `add-funds ${view2.fundsId}` : "add-funds";
   return [
-    view2.ready ? `add-funds ${view2.fundsId} is ready: ${view2.amount} was added to your private balance${total}.` : `add-funds ${view2.fundsId} is not ready yet: ${status}.`,
+    view2.ready ? `${run5} is ready: ${view2.amount} was added to your private balance${total}.` : `${run5} is not ready yet: ${status}.`,
     // 0.3.97 T6: a next step that ends with a command line gets no "." after it. A block of lines starts on its own line.
-    `Next:${view2.next.startsWith("\n") ? "" : " "}${sentence(view2.next)}`
+    // S3 (mcp56, published 0.3.99): inside setup, setup's own Next line follows, so this one is not printed.
+    ...view2.next === SETUP_LINES_BELOW ? [] : [`Next:${view2.next.startsWith("\n") ? "" : " "}${sentence(view2.next)}`]
   ].join("\n");
 }
 function fundsOutput(values, deps) {
@@ -160841,7 +160922,7 @@ function printEnd(deps, view2, terminal) {
 `);
 }
 function fundsStatusSummary(view2) {
-  const [first, ...next] = fundsSummary(view2).split("\n");
+  const [first, ...next] = fundsSummary(view2, { named: true }).split("\n");
   const said = view2.stages?.find((entry) => entry.said?.length)?.said ?? [];
   const rests = view2.leftoverAtOneTimeAddresses ?? (view2.leftoverAtOneTimeAddress ? [view2.leftoverAtOneTimeAddress] : []);
   return [
@@ -160857,7 +160938,7 @@ function fundsStatusSummary(view2) {
     "For the whole status as JSON, add --json (or send this command's output to a file or a program)."
   ].join("\n");
 }
-var HELD = /^(shinjuku(?:-wallet)?\b.*\bfailed: |shinjuku(?:-wallet)?\b.*: waiting for funds, nothing failed \(|hint: |Help: |next: |Examples?:|Every flag: |  shinjuku(?:-wallet)? |  npx -y --no-audit --no-fund shinjuku-shield(?:@\S+)? )/;
+var HELD = /^(shinjuku(?:-wallet)?\b.*\bfailed: |shinjuku(?:-wallet)?\b.*: waiting for funds, nothing failed \(|hint: |Help: |[Nn]ext: |Examples?:|Every flag: |  shinjuku(?:-wallet)? |  npx -y --no-audit --no-fund shinjuku-shield(?:@\S+)? )/;
 var STEP_TOR_LINE = /^(?:tor|proxy): /;
 var DENOMINATION_WARNING = /^warning: no pool denomination is configured\b/;
 async function runStep(ctx, argv2) {
@@ -161547,7 +161628,9 @@ async function addFunds(values, deps) {
       plan,
       proxyArgs: proxy.args,
       childEnv: { ...proxy.env, [PASSPHRASE_ENV]: passphrase2, [RPC_ENV2]: rpcUrl },
-      say: (stage, text3) => io.err(`add-funds ${plan.fundsId} [${stage}] ${ctx.quiet ? text3.replace(STEP_WORDS, "") : text3}
+      // A1: a quiet terminal run names no plan id and no stage (funds-status and --verbose do).
+      say: (stage, text3) => io.err(ctx.quiet ? `add-funds: ${text3.replace(STEP_WORDS, "")}
+` : `add-funds ${plan.fundsId} [${stage}] ${text3}
 `),
       mark: (stage) => {
         if (plan.done?.[stage]) return;
@@ -161556,12 +161639,12 @@ async function addFunds(values, deps) {
       }
     });
     const parts = splitOf(plan) > 1 ? ` in ${partsText(plan)}, each from its own one-time address (${splitOf(plan)} payments in a row without waiting for a pool anchor)` : "";
-    ctx.say("start", `${resolved.created ? "new" : "continues"}: ${usdc5(plan.amountAtomic)} USDC${parts} from ${ROUTE_LABEL[plan.route]}; stages ${stagesOf(plan).join(" > ")}. Ctrl-C is safe at any point: run the same command again to continue.`);
+    ctx.say("start", ctx.quiet ? `${resolved.created ? "adds" : "continues to add"} ${usdc5(plan.amountAtomic)} USDC${parts} from ${ROUTE_LABEL[plan.route]}. Ctrl-C is safe at any point: run the same command again to continue.` : `${resolved.created ? "new" : "continues"}: ${usdc5(plan.amountAtomic)} USDC${parts} from ${ROUTE_LABEL[plan.route]}; stages ${stagesOf(plan).join(" > ")}. Ctrl-C is safe at any point: run the same command again to continue.`);
     if (resolved.routeChanged) {
       const address5 = relayedDeposit2(store, plan)?.relay?.owner;
       ctx.say("start", `the route changes from ${resolved.routeChanged.from} to ${resolved.routeChanged.to}${address5 ? `; the one-time address stays ${address5}` : ""}${address5 && resolved.routeChanged.to === "privacy-cash" ? " (it was read when it was recorded: an RPC operator can pair that read with a Privacy Cash deposit made soon after it)" : ""}`);
     }
-    ctx.say("start", `privacy: ${privacyCost(plan)}`);
+    ctx.say("start", `privacy: ${ctx.quiet ? privacyShort(plan) : privacyCost(plan)}`);
     const markDone = () => {
       const stage = currentStage(store, plan);
       for (const done of stagesOf(plan)) {
@@ -161598,7 +161681,7 @@ async function addFunds(values, deps) {
       }
       const label = outcome.label ?? next ?? stage;
       if (outcome.kind === "stop") {
-        const said = outcome.tries ? [] : (outcome.run?.held ?? []).filter((text3) => !/^(Help|next): /.test(text3));
+        const said = outcome.tries ? [] : (outcome.run?.held ?? []).filter((text3) => !/^(Help|[Nn]ext): /.test(text3));
         if (!said.length && outcome.run?.last && !outcome.tries) said.push(outcome.run.last);
         for (const text3 of said) io.err(`  ${text3}
 `);
@@ -161632,7 +161715,7 @@ async function addFunds(values, deps) {
     plan.status = { ...plan.status ?? { stage: currentStage(store, plan) }, ended: iso2(deps.now()) };
     save2();
     const view2 = fundsView(store, plan, { now: deps.now(), running: false });
-    io.err(`add-funds ${plan.fundsId} stopped at ${view2.stage}: nothing is lost. Run the same command again to continue.
+    io.err(`${ctx.quiet ? "add-funds stopped" : `add-funds ${plan.fundsId} stopped at ${view2.stage}`}: nothing is lost. Run the same command again to continue.
 `);
     printEnd(deps, view2, ctx.terminal);
   } finally {
@@ -162045,8 +162128,9 @@ var GUIDE = Object.freeze({
 });
 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 SETUP_NEXT = `open your agent app and ask "what is my balance". In this terminal, run:
-  ${CLI_WORD} balance`;
+var SETUP_NEXT = `chat privately with an AI in this terminal:
+  ${CLI_WORD} chat
+Or open your agent app and ask "what is my balance".`;
 var UNSHIELD_EXAMPLE = `${CLI_WORD} unshield --amount 0.5 --to <your wallet address>`;
 function hintForThisRun(text3, values) {
   let hint = String(text3);
@@ -162092,6 +162176,12 @@ var UsageError = class extends Error {
 };
 var PublicFailure = class extends Error {
 };
+var QuestionCancelled = class extends PublicFailure {
+  // Every terminal question comes before a payment or a send, so this is true at each one.
+  constructor(interrupted) {
+    super(`stopped: ${interrupted ? "you pressed Ctrl-C at a question" : "the input ended before an answer to the question"}, so the command stopped there; nothing was sent or paid. Run the same command again when you are ready.`);
+  }
+};
 var NOT_SET_UP_CODE = "wallet_not_set_up";
 var flag2 = (name, value, about, options = {}) => ({ name, value, about, ...options });
 var bool2 = (name, about, options = {}) => ({ name, boolean: true, about, ...options });
@@ -162531,6 +162621,10 @@ var INFER_COST_LINE = "the AI provider charges its quoted cap for --max-tokens a
 var INFER_STDIN_MAX_BYTES = 1024 * 1024;
 var INFER_STDIN_EXAMPLE = `echo "Summarize x402 in one line" | ${CLI_WORD} infer - --model qwen3-8-flash`;
 var CURL_USEPOD_NEXT = `use \`${CLI_WORD} infer\` for the AI provider: it sends the prompt only through --tor or --proxy`;
+function unshieldArgs(command2, args) {
+  if (args.length === 0 || args.includes("--amount") || !/^(all|[0-9]+(\.[0-9]+)?)$/i.test(args[0])) return args;
+  return ["--amount", /^all$/i.test(args[0]) ? "all" : args[0], ...args.slice(1)];
+}
 function inferArgs(command2, args) {
   const known = new Map(command2.flags.map((entry) => [entry.name, entry]));
   const out = [];
@@ -163953,7 +164047,8 @@ async function runSetupCommand(values, deps) {
   const asksOwnFirst = interactive && Boolean(old) && terminal && !ownAddress;
   io.out([
     ...introduced ? [] : [
-      "Shinjuku Shield: a self-custody wallet that pays x402 URLs privately from your USDC balance.",
+      // S2 (mcp56 on the published 0.3.99): the help's words (shortHelpText), not "x402 URLs".
+      "Shinjuku Shield: your private wallet on this computer. It pays for AI answers and paid web services from your private balance.",
       "Setup makes the wallet on this machine (your keys never leave it), downloads and checks the proof tools, and writes config.json.",
       // 0.3.97 T4, live proof 2026-10-24: the command on its own line.
       "An agent app then starts it with this command:",
@@ -163987,10 +164082,6 @@ async function runSetupCommand(values, deps) {
       const tor = String(await deps.ask("Send every request through Tor? It hides your IP address; if Tor is not running, setup gives the one command that starts it. [Y/n] ")).trim();
       options.tor = !/^n(o)?$/i.test(tor);
     }
-    if (privateInference === void 0) {
-      const answer = String(await deps.ask(`Set your LLM to private inference now? ${PRIVATE_INFERENCE_WHY} [y/N] `)).trim();
-      privateInference = /^y(es)?$/i.test(answer);
-    }
     if (!ownAddress && terminal) ownAddress = await askOwnAddress(deps);
   } else if (asksOwnFirst) {
     ownAddress = await askOwnAddress(deps, old.unshieldTo ?? []);
@@ -164171,7 +164262,7 @@ async function fillAddFunds(values, deps) {
   const kept2 = /^[1-9][0-9]{0,19}$/.test(String(plan?.amountAtomic ?? "")) ? plan.amountAtomic : void 0;
   if (!plan && !values.has("--route")) values.set("--route", "exchange");
   if (!values.has("--amount")) {
-    if (kept2) deps.io.err(`This continues ${plan.fundsId}, the add-funds run of ${usdcText3(kept2)} USDC that is not ready yet.
+    if (kept2) deps.io.err(`This continues the add-funds run of ${usdcText3(kept2)} USDC that is not ready yet.
 `);
     if (!kept2 && !terminal) {
       throw new UsageError("add-funds needs the amount of USDC (--amount, from 0.01) when it runs without a terminal; in a terminal it asks", command2);
@@ -164821,8 +164912,8 @@ var COMMANDS = [
     flags: [
       flag2("--prompt", "<text>", 'what to ask; write - to read it from stdin (the private form), or write it alone, in quotes (shinjuku infer "Summarize x402 in one line" ...)', { required: true }),
       flag2("--model", "<id>", `the model (default ${DEFAULT_MODEL2}): ${INFER_MODEL_IDS.join(", ")} (${CLI_WORD} infer models lists their prices)`),
-      flag2("--max-tokens", "<n>", "the longest answer to pay for, in tokens; default 512 (give 256 or more; 512 answers a short question: a reasoning model like qwen3-8-flash thinks first, and with fewer tokens it can stop before it answers, still paid); it sets the most this request can cost", { check: "count" }),
-      flag2("--max-payment", "<usdc>", "the most this request may pay in all, in USDC (0.02 = 2 cents). It must be at least 0.01: the wallet never sets a call's ceiling below the AI provider's 0.01 USDC floor on its standard offer, and a call on that offer also pays Shinjuku's fee, so 0.02 covers it. What a call pays is the AI provider's quote for --max-tokens plus Shinjuku's fee: a short deepseek-v4-1-flash answer (the default) paid 0.001047 USDC live (the AI provider's price plus the 0.001 USDC fee) on the offer the wallet pays, 0.01 USDC plus the fee when the AI provider offers only its standard payment. A higher ceiling is refused before anything is paid. Default: the cap setup recorded, else 0.05", { check: "atomic", usdc: true }),
+      flag2("--max-tokens", "<n>", "the longest answer to pay for, in tokens; default 4096, 512 for claude-opus-5 (give 256 or more; 512 answers a short question: a reasoning model like qwen3-8-flash thinks first, and with fewer tokens it can stop before it answers, still paid); it sets the most this request can cost", { check: "count" }),
+      flag2("--max-payment", "<usdc>", `the most this request may pay in all, in USDC (0.02 = 2 cents). It must be at least 0.01: the wallet never sets a call's ceiling below the AI provider's 0.01 USDC floor on its standard offer, and a call on that offer also pays Shinjuku's fee, so 0.02 covers it. What a call pays is the AI provider's quote for --max-tokens plus Shinjuku's fee: a ${DEFAULT_MODEL2} answer (the default, ${DEFAULT_MAX_TOKENS} tokens) paid ${DEFAULT_MODEL_PAID_WORDS} live (the AI provider's price plus the 0.001 USDC fee) on the offer the wallet pays, 0.01 USDC plus the fee when the AI provider offers only its standard payment. A higher ceiling is refused before anything is paid. Default: the cap setup recorded, else 0.05`, { check: "atomic", usdc: true }),
       flag2("--max-session", "<usdc>", "the most this run may pay in total, in USDC; at least --max-payment. Default: the cap setup recorded, else 1", { check: "atomic", usdc: true }),
       flag2("--request-id", "<id>", "your stable name for this request; default infer-<random>, printed on stderr before any payment. Rerun with the same id to resume a stopped run: it never pays twice"),
       bool2("--json", "print one JSON line (answer, model, usage, paidAtomic, requestId, receipt) instead of the answer text"),
@@ -164861,7 +164952,7 @@ var COMMANDS = [
     flags: [bool2("--json", "print the list as one JSON line (prices in atomic USDC per 1M tokens)")],
     examples: [`${CLI_WORD} infer models`, `${CLI_WORD} infer models --json`],
     notes: [`${INFER_COST_LINE}.`],
-    next: `ask one: echo "Summarize x402 in one line" | ${CLI_WORD} infer - --model deepseek-v4-1-flash`,
+    next: `ask one: echo "Summarize x402 in one line" | ${CLI_WORD} infer - --model ${DEFAULT_MODEL2}`,
     run: (args, values, deps, io) => deps.inferModelsMain(values, { ...deps, io })
   },
   {
@@ -164876,12 +164967,12 @@ var COMMANDS = [
     ],
     examples: [
       `${CLI_WORD} infer serve --max-payment 0.02 --max-session 0.2 ${PAYER_SESSION_BASE} --tor`,
-      `curl http://127.0.0.1:11402/v1/chat/completions -H "Authorization: Bearer <api key it printed>" -H "Content-Type: application/json" -d '{"model":"deepseek-v4-1-flash","max_tokens":512,"messages":[{"role":"user","content":"Say hello"}]}'`
+      `curl http://127.0.0.1:11402/v1/chat/completions -H "Authorization: Bearer <api key it printed>" -H "Content-Type: application/json" -d '{"model":"${DEFAULT_MODEL2}","max_tokens":${DEFAULT_MAX_TOKENS},"messages":[{"role":"user","content":"Say hello"}]}'`
     ],
     notes: [
       "Any OpenAI client works: set base_url http://127.0.0.1:11402/v1 and the api key it prints at start (required: a request without it gets 401). GET /v1/models lists the models with prices.",
       "Send an Idempotency-Key header to make a resend of the same request resume the same payment instead of paying again.",
-      `A request without max_tokens gets max_tokens 512 (max_tokens sets the most a request can cost), and stream: true is answered as a stream of the paid whole answer (the text comes at the end). Models: ${INFER_MODEL_IDS.join(", ")}.`,
+      `A request without max_tokens gets max_tokens ${DEFAULT_MAX_TOKENS}, 512 for claude-opus-5 (max_tokens sets the most a request can cost), and stream: true is answered as a stream of the paid whole answer (the text comes at the end). Models: ${INFER_MODEL_IDS.join(", ")}.`,
       "It runs only with --tor (or --proxy <url>), so the AI provider never sees your IP address. Web pages cannot call it: a request with an Origin header is refused.",
       `${INFER_COST_LINE}. Each answer carries a shinjuku field with the amount paid and what this server has spent.`,
       "Ctrl+C stops it; stderr then says what it paid in all.",
@@ -164961,7 +165052,7 @@ var COMMANDS = [
     summary: "Chat privately with an AI model in this terminal: each answer is paid from your private balance, behind Tor.",
     env: [],
     flags: [
-      flag2("--model", "<id>", `the model to start with (default deepseek-v4-1-flash): ${INFER_MODEL_IDS.join(", ")}`),
+      flag2("--model", "<id>", `the model to start with (default ${DEFAULT_MODEL2}): ${INFER_MODEL_IDS.join(", ")}`),
       flag2("--max-payment", "<usdc>", "the most one answer may pay, in USDC; default: the cap setup recorded, else 0.05", { check: "atomic", usdc: true }),
       flag2("--max-session", "<usdc>", "the most this chat may pay in all, in USDC; default: the cap setup recorded, else 1", { check: "atomic", usdc: true }),
       bool2("--verbose", "also show the wallet's own progress lines between the answers (Tor, the RPC relay, the pool history, the memo reads); without it the chat shows only the conversation, what each answer paid, and every refusal or failure"),
@@ -165048,7 +165139,7 @@ var COMMANDS = [
       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. 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 the AI provider, paid from your private 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'),
+      bool2("--private-inference", "records that your agent buys AI answers from the AI provider, paid from your private 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("--own-address", "<address>", `optional, in your own terminal only (the same as the answer to setup's address question): your own wallet address (Phantom, Solflare, an exchange's deposit address), for sending money back to yourself: the MCP sends to it without asking each time (as mcp --unshield-to), also in an agent app that cannot show a question. Not this wallet's own address. Refused in a script, a pipe, or an agent's tool (no terminal), also with --yes: an agent must never approve an address. A rerun adds it to the ones config.json records (at most ${MAX_OWN_ADDRESSES})`),
       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" }),
@@ -165063,9 +165154,9 @@ var COMMANDS = [
       `${CLI_WORD} setup --yes --private-inference`
     ],
     notes: [
-      `npx -y --no-audit --no-fund ${COMMAND_AT_VERSION} setup runs the same command. Without --yes a first setup asks in the terminal: Tor, private inference, and your own wallet address (Enter skips it). A rerun in a terminal asks only for your own wallet address: on a complete setup an address given there is saved and nothing else runs; Enter checks every piece again.`,
-      `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 (if it does not, setup gives the one command that starts it); --no-tor runs it without Tor.`,
-      `Private inference (a yes, or --private-inference): ${PRIVATE_INFERENCE_WHY} Setup records Tor. At the end, a terminal setup first offers to run add-funds (a --yes run prints ${CLI_WORD} add-funds), then prints ${CLI_WORD} chat (a private AI chat in this terminal), ${CLI_WORD} infer start (the local AI server in the background; it prints base_url and the api key when it starts), and the lines that add the wallet to an agent app. Setup never pays an inference call.`,
+      `npx -y --no-audit --no-fund ${COMMAND_AT_VERSION} setup runs the same command. Without --yes a first setup asks in the terminal: Tor and your own wallet address (Enter skips it). A rerun in a terminal asks only for your own wallet address: on a complete setup an address given there is saved and nothing else runs; Enter checks every piece again.`,
+      `When Tor is recorded or asked for (a yes to the Tor question, --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 (if it does not, setup gives the one command that starts it); --no-tor runs it without Tor.`,
+      `Private inference (--private-inference): ${PRIVATE_INFERENCE_WHY} Setup records Tor. At the end, a terminal setup first offers to run add-funds (a --yes run prints ${CLI_WORD} add-funds), then prints ${CLI_WORD} chat (a private AI chat in this terminal), ${CLI_WORD} infer start (the local AI server in the background; it prints base_url and the api key when it starts), and the lines that add the wallet to an agent app. Setup 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 for only you on this computer), 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.",
       `The proof tools are the set this wallet build PINS (its SHA256SUMS hash is in the wallet; --trust-proof-tools replaces it). A facilitator whose /api/wallet/release names another set is refused (setup_proof_tools_pin_mismatch: update the wallet, npx -y --no-audit --no-fund ${NPX_PACKAGE}@latest setup). SHA256SUMS must have the pinned SHA-256, and every file must have the SHA-256 its line names, as /skill.md section 7b; bin/ and house/bin/ get the execute bit. A file that does not match is not kept. Each download has a hard size limit.`,
@@ -165183,6 +165274,7 @@ var COMMANDS = [
     name: "unshield",
     summary: "Send some or all of your private balance to a Solana wallet address, privately.",
     env: [],
+    normalizeArgs: unshieldArgs,
     flags: [
       // 0.3.97, live proof 2026-10-24: --amount and --to are optional in a terminal (unshield asks both, then a y);
       // a script, a pipe, or an agent's tool must give both (askUnshield).
@@ -165833,7 +165925,8 @@ function parseFlags(command2, args) {
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index];
     if (!token.startsWith("--")) {
-      throw new UsageError(`unexpected argument ${index + 1} (it has no flag in front of it): every value follows its flag, like --pool ${GUIDE.pool}`, command2);
+      const example = known.has("--amount") ? "--amount 0.5" : `--pool ${GUIDE.pool}`;
+      throw new UsageError(`unexpected argument ${index + 1} (it has no flag in front of it): every value follows its flag, like ${example}`, command2);
     }
     if (token.includes("=")) {
       const spec2 = known.get(token.slice(0, token.indexOf("=")));
@@ -166114,12 +166207,13 @@ async function askUnshield(args, values, deps) {
   let whole;
   if (values.get("--amount") === "all") {
     try {
-      whole = knownPrivateBalance((deps.openWalletStore ?? openWalletStore)(resolve39(values.get("--wallet")), payerPassphrase(values, deps)));
+      whole = savedBalance((deps.openWalletStore ?? openWalletStore)(resolve39(values.get("--wallet")), payerPassphrase(values, deps)));
     } catch {
       whole = void 0;
     }
   }
-  const what = values.get("--amount") === "all" ? `your whole private balance${whole !== void 0 ? ` (${usdcOr(whole.toString())})` : ""}` : `${usdcText3(values.get("--amount"))} USDC`;
+  const wholeWords = !whole ? "" : whole.current ? ` (${usdcOr(whole.atomic.toString())})` : ` (about ${usdcOr(whole.atomic.toString())} at its last read)`;
+  const what = values.get("--amount") === "all" ? `your whole private balance${wholeWords}` : `${usdcText3(values.get("--amount"))} USDC`;
   const answer = String(await deps.ask(`Send ${what} to ${values.get("--to")}? [y/N] `)).trim();
   if (!/^y(es)?$/i.test(answer)) throw new PublicFailure(`unshield_declined: you did not answer y, so nothing was sent. To send, run:
   ${cli2()} unshield`);
@@ -167233,7 +167327,7 @@ function failureHint(command2, reason, deps, values, floatError) {
   if (/inference_tor_required/.test(reason)) return "rerun the same command with --tor added (or --proxy <http://host:port>); nothing was paid";
   if (/inference_ceiling_over_cap/.test(reason)) return "raise --max-payment to the ceiling it names plus Shinjuku's fee, or lower --max-tokens; nothing was paid";
   if (/inference_model_unknown/.test(reason)) return `pass --model with one of: ${INFER_MODEL_IDS.join(", ")} (${cli2()} infer models lists the prices)`;
-  if (/inference_max_tokens_required/.test(reason)) return "add --max-tokens <n> (256 or more; 512 answers a short question), or leave --max-tokens out for 512: it sets the most the request can cost";
+  if (/inference_max_tokens_required/.test(reason)) return "add --max-tokens <n> (256 or more; 512 answers a short question), or leave --max-tokens out for 4096 (512 for claude-opus-5): it sets the most the request can cost";
   if (/mcp_session_cap_exceeded/.test(reason)) return "nothing was paid: this process reached --max-session. Restart it with a higher --max-session to pay more";
   if (/mcp_cap_invalid/.test(reason)) {
     return `start it with --max-session at least as high as --max-payment, for example: ${cli2()} mcp --max-payment 0.05 --max-session 0.2 ${PAYER_SESSION_BASE}`;
@@ -167740,10 +167834,25 @@ function defaultDependencies() {
     stdinIsTTY: () => Boolean(process.stdin.isTTY),
     /** True when stdout is a terminal: add-funds then ends with a short summary instead of the status as JSON. */
     stdoutIsTTY: () => Boolean(process.stdout.isTTY),
-    /** One terminal question on stderr (stdout stays for output); the answer text. */
-    ask: (question) => new Promise((resolveAnswer) => {
+    /**
+     * One terminal question on stderr (stdout stays for output); the answer text. U7 (mcp56, published 0.3.100): Ctrl-C
+     * at a question paused stdin with no answer, Node then printed "Detected unsettled top-level await" and nothing said
+     * what happened. Ctrl-C, or an input that ends, now stops the command with QuestionCancelled (one plain line).
+     */
+    ask: (question) => new Promise((resolveAnswer, rejectAnswer) => {
       const prompt = createInterface2({ input: process.stdin, output: process.stderr, terminal: true });
+      let answered2 = false;
+      let interrupted = false;
+      prompt.on("SIGINT", () => {
+        interrupted = true;
+        process.stderr.write("\n");
+        prompt.close();
+      });
+      prompt.on("close", () => {
+        if (!answered2) rejectAnswer(new QuestionCancelled(interrupted));
+      });
       prompt.question(question, (answer) => {
+        answered2 = true;
         prompt.close();
         resolveAnswer(answer);
       });
@@ -167827,7 +167936,24 @@ function isHelpRequest(argv2) {
       args = rest.slice(1);
     }
   }
-  return command2 !== void 0 && helpFlagIn(command2, args);
+  if (command2 === void 0) return false;
+  if (!command2.normalizeArgs || command2.normalizeArgs === unshieldArgs) {
+    if (strayWordIn(command2, command2.normalizeArgs ? command2.normalizeArgs(command2, args) : args)) return true;
+  }
+  return helpFlagIn(command2, args);
+}
+function strayWordIn(command2, args) {
+  const known = new Map(command2.flags.map((entry) => [entry.name, entry]));
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("--")) return true;
+    const spec = known.get(token);
+    if (!spec || token.includes("=")) return false;
+    if (spec.boolean) continue;
+    if (args[index + 1] === void 0 || args[index + 1].startsWith("--")) return false;
+    index += 1;
+  }
+  return false;
 }
 async function runShinjukuWallet(argv2, overrides = {}) {
   const deps = { ...defaultDependencies(), ...overrides };
@@ -167877,11 +168003,13 @@ This copy: ${walletVersionLine(deps.walletVersion())}
 `);
         return 0;
       }
-      const threeWords = FAMILIES.has(args[0]) && COMMAND_BY_NAME.has(args.slice(0, 3).join(" "));
-      const topicWords = threeWords ? [args.slice(0, 3).join(" "), ...args.slice(3)] : FAMILIES.has(args[0]) ? [`${args[0]} ${args[1]}`, ...args.slice(2)] : args;
+      const full = args.length > 1 && args.at(-1) === "--verbose";
+      const words2 = full ? args.slice(0, -1) : args;
+      const threeWords = FAMILIES.has(words2[0]) && COMMAND_BY_NAME.has(words2.slice(0, 3).join(" "));
+      const twoWords = FAMILIES.has(words2[0]) && words2.length > 1;
+      const topicWords = threeWords ? [words2.slice(0, 3).join(" "), ...words2.slice(3)] : twoWords ? [`${words2[0]} ${words2[1]}`, ...words2.slice(2)] : words2;
       const topic = COMMAND_BY_NAME.get(topicWords[0]);
-      const full = topicWords.length === 2 && topicWords[1] === "--verbose";
-      if (!topic || topicWords.length > 1 && !full) {
+      if (!topic || topicWords.length > 1) {
         const near = suggestion(args[0], COMMAND_NAMES);
         throw new UsageError(`There is no such command to explain.${near ? ` Did you mean ${near}? Run: ${cli2()} help ${near}` : ""}`);
       }
@@ -167975,6 +168103,11 @@ This copy: ${walletVersionLine(deps.walletVersion())}
     if (reason.startsWith(`${NOT_SET_UP_CODE}: `)) {
       const plain = reason.slice(NOT_SET_UP_CODE.length + 2);
       io.err(`${plain[0].toUpperCase()}${plain.slice(1)}
+`);
+      return 1;
+    }
+    if (error instanceof QuestionCancelled) {
+      io.err(`${CLI} ${command2.name} ${error.message}
 `);
       return 1;
     }