shinjuku-shield 0.3.121 → 0.3.122

package/README.md

@@ -6,19 +6,19 @@ answers privately, in a terminal chat or for your agent app. Its `mcp`
 command runs a local MCP server (stdio) for your agent. Your keys never
 leave your machine.
 
-This is version 0.3.121. The npm packages `shinjuku-shield` and
+This is version 0.3.122. The npm packages `shinjuku-shield` and
 `shinjuku-shielded` hold the same files. The command is `shinjuku`.
 
 ## Set up
 
 ```sh
-npm install -g shinjuku@0.3.121
+npm install -g shinjuku@0.3.122
 shinjuku setup
 ```
 
 Type the two lines as they are. `npx install shinjuku` does not work: npx
 reads `install` as the name of another npm package. To set up without
-installing, type `npx shinjuku@0.3.121 setup`.
+installing, type `npx shinjuku@0.3.122 setup`.
 
 Setup makes the wallet on this machine, a private passphrase file, and the
 checked proof tools (about 191 MB), and writes `config.json`. It also writes
@@ -36,13 +36,13 @@ Every wallet command works after `shinjuku`, for example `shinjuku balance`,
 Claude Code:
 
 ```sh
-claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.121 mcp
+claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.122 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.121", "mcp"] } } }
+{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.122", "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": "b2d6f4507136f85fea6e6305a0a958a98b95c3ba2b82a060cc182b4a6d6f26bd",
-  "bytes": 8471165,
-  "sourceCommit": "9337bf3eaa4a9ac34e6d850cc800b8951dc657cd",
+  "sha256": "67cedf24617c4cd78d268b549ad4b346101b6de7338a5a3889df8f81a29c78a3",
+  "bytes": 8472739,
+  "sourceCommit": "31eb1a0d3a0f1a9d380e2b1bf046d8abcc5420cc",
   "sourceDirty": false,
   "installRecordMatchesLockfile": true,
   "releaseRule": "valid only when two fresh npm ci --ignore-scripts builds on different OSes give the same sha256; installRecordMatchesLockfile true means every entry npm installed equals its package-lock.json entry and every entry not marked optional, devOptional included, is installed: an optional entry (a package for another platform) may be absent",
@@ -1037,5 +1037,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-10-28T18:56:33.630Z"
+  "publishedAt": "2026-10-28T19:36:37.026Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shield",
-  "version": "0.3.121",
+  "version": "0.3.122",
   "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": "b2d6f450",
-  "shinjukuSha256": "b2d6f4507136f85fea6e6305a0a958a98b95c3ba2b82a060cc182b4a6d6f26bd",
+  "shinjukuRelease": "67cedf24",
+  "shinjukuSha256": "67cedf24617c4cd78d268b549ad4b346101b6de7338a5a3889df8f81a29c78a3",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-shield#readme",

package/shinjuku-wallet.mjs

@@ -127422,7 +127422,15 @@ ${canonical5}`;
       { requestId, paid: false, balanceEmpty: true, ...publicAtomic ? { publicAtomic } : {} }
     );
   }
-  const zeroBeforeAsk = (tool, requestId) => knownZeroBalance({ maxAgeMs: INBOUND_REFRESH_AGE_MS }).empty ? zeroBalanceStop({ tool, requestId, same: tool === "x402_pay" ? "the same url, method, headers, and body" : "the same arguments" }) : void 0;
+  async function knownZeroFresh() {
+    if (knownZeroBalance({ maxAgeMs: INBOUND_REFRESH_AGE_MS }).empty) return true;
+    if (!knownZeroBalance().empty || refreshFailedAt && Date.now() - refreshFailedAt < REFRESH_RETRY_MS) return false;
+    const outcome = await Promise.race([refreshShared().then(() => "done", () => "failed"), sleep2(balanceRefreshWaitMs).then(() => "waiting")]);
+    return outcome === "done" && knownZeroBalance({ maxAgeMs: INBOUND_REFRESH_AGE_MS }).empty;
+  }
+  const zeroBeforeAsk = async (tool, requestId) => await knownZeroFresh() ? zeroBalanceStop({ tool, requestId, same: tool === "x402_pay" ? "the same url, method, headers, and body" : "the same arguments" }) : void 0;
+  const floatSplitOf = (error) => ATOMIC_TEXT.test(String(error?.priceAtomic ?? "")) && ATOMIC_TEXT.test(String(error?.feeAtomic ?? "")) ? { priceAtomic: String(error.priceAtomic), feeAtomic: String(error.feeAtomic) } : void 0;
+  const splitWords = (split4, price) => split4 ? ` (${price} ${usdcText3(split4.priceAtomic)} USDC plus Shinjuku's fee ${usdcText3(split4.feeAtomic)} USDC)` : "";
   async function askLimit2({ requestId, url, numbers, calledAt, message }) {
     const answer = await confirmOnce({ message, waitMs: budgetLeft(calledAt) });
     if (!answer.ok) {
@@ -127485,7 +127493,7 @@ ${canonical5}`;
   async function payCall({ target, request, argument: argument2, requestId, given, calledAt, progress: progress3, canProgress, signal }) {
     let cap = policy.resolvePaymentCap(argument2, { requestId });
     if (!cap.ok && cap.error === "mcp_cap_argument_above_launch_cap") {
-      const zero = zeroBeforeAsk("x402_pay", requestId);
+      const zero = await zeroBeforeAsk("x402_pay", requestId);
       if (zero) return zero;
       const numbers = { totalAtomic: String(argument2), capAtomic: policy.limits.maxPaymentAtomic };
       const asked = await askLimit2({
@@ -127595,21 +127603,22 @@ ${canonical5}`;
           const launch = policy.limits.maxPaymentAtomic;
           const total = code2 === "p03_float_over_maximum" ? ATOMIC_TEXT.test(String(error?.paidAtomic ?? "")) ? String(error.paidAtomic) : void 0 : capNumbers(error?.refusal).totalAtomic;
           if (total !== void 0 && BigInt(total) > BigInt(launch) && BigInt(maxNow) === BigInt(launch)) {
-            const zero = zeroBeforeAsk("x402_pay", requestId);
+            const zero = await zeroBeforeAsk("x402_pay", requestId);
             if (zero) return zero;
             const numbers = { totalAtomic: total, capAtomic: launch };
+            const split4 = code2 === "p03_float_over_maximum" ? floatSplitOf(error) : void 0;
             const asked = await askLimit2({
               requestId,
               url: target.url,
               numbers,
               calledAt,
-              message: `This costs ${usdcText3(total)} USDC. Your ${payCapName(launch)} is ${usdcText3(launch)} USDC. Allow it once?`
+              message: `This costs ${usdcText3(total)} USDC${splitWords(split4, "the price")}. Your ${payCapName(launch)} is ${usdcText3(launch)} USDC. Allow it once?`
             });
             if (asked.ok) {
               maxNow = total;
               continue;
             }
-            if (asked.why !== "unsupported") return notAllowed(asked.why, { tool: "x402_pay", requestId, numbers });
+            if (asked.why !== "unsupported") return notAllowed(asked.why, { tool: "x402_pay", requestId, numbers }, split4 ?? {});
             askUnshown = true;
           }
         }
@@ -128426,6 +128435,7 @@ ${canonical5}`;
       };
       const positive2 = (atomic4) => /^[1-9][0-9]*$/.test(String(atomic4 ?? ""));
       let refresh = {};
+      let backgroundWalked = false;
       const recentlyFailed = refreshFailedAt && Date.now() - refreshFailedAt < REFRESH_RETRY_MS && !refreshRun;
       if (report.split?.shieldedAtomic != null && report.status === "stale") {
         if (!recentlyFailed && (!finalityWait || refreshDeferred)) refreshShared().catch(() => {
@@ -128443,7 +128453,9 @@ ${canonical5}`;
           refresh = { refreshed: true };
         } else refresh = { refreshing: true, refreshReason: "refund_check" };
       } else if (report.split?.shieldedAtomic != null && !recentlyFailed && !finalityWait && !refreshRun && (report.detail?.lastRefresh?.ageSeconds ?? 0) * 1e3 >= INBOUND_REFRESH_AGE_MS) {
-        refreshShared({ background: true }).catch(() => {
+        refreshShared({ background: true }).then(() => {
+          backgroundWalked = true;
+        }, () => {
         });
       } else if (report.split?.shieldedAtomic == null && recentlyFailed) {
         refresh = { refreshed: false, refreshError: refreshFailedCode ?? "mcp_refresh_failed" };
@@ -128505,6 +128517,13 @@ ${canonical5}`;
       });
       const answered2 = await Promise.race([publicRead, answerWindow]);
       if (tokensAnswered.reading) await Promise.race([tokensRead, answerWindow]);
+      if (backgroundWalked) {
+        try {
+          store = session.openStore();
+        } catch {
+        }
+        reread("refresh");
+      }
       mark("balance-public-read", answered2.reading ? "missed" : answered2.read ? "answered" : "failed");
       mark("balance-tokens-read", tokensAnswered.reading ? "missed" : tokensAnswered.rows ? "answered" : "failed");
       let ownTokens;
@@ -131143,7 +131162,7 @@ ${canonical5}`;
         const capNext = (detail) => `Nothing was moved. Tell your owner: ${detail}. ${capRaiseText(spec.capFlag)} Then call ${spec.tool} again.`;
         if (max !== void 0 && amount > max) {
           const detail = `${record ? `the recorded ${spec.noun} of request_id "${request.requestId}" is not finished; its ` : ""}amount_atomic ${amount} (${usdcText3(amount)} USDC) is above the ${capName(spec.capFlag)} of ${usdcFlagText(max)} USDC`;
-          const empty = kind === "unshield" && !record && knownZeroBalance({ maxAgeMs: INBOUND_REFRESH_AGE_MS }).empty ? zeroBalanceFacts() : void 0;
+          const empty = kind === "unshield" && !record && await knownZeroFresh() ? zeroBalanceFacts() : void 0;
           if (empty && !empty.depositInFlight && !empty.heldUnknown) {
             return refuse12(
               "mcp_unshield_balance_empty",
@@ -133876,7 +133895,7 @@ ${canonical5}`;
       const facts = { model: args.model, maxTokens: args.max_tokens, ceilingAtomic: ceiling.toString(), ceiling: usd(ceiling) };
       let cap = policy.resolvePaymentCap(argument2, { requestId });
       if (!cap.ok && cap.error === "mcp_cap_argument_above_launch_cap") {
-        const zero = zeroBeforeAsk("inference_chat", requestId);
+        const zero = await zeroBeforeAsk("inference_chat", requestId);
         if (zero) return zero;
         const numbers = { totalAtomic: String(argument2), capAtomic: launch };
         const asked2 = await askLimit2({
@@ -133926,7 +133945,7 @@ ${canonical5}`;
             }
           );
         }
-        const zero = zeroBeforeAsk("inference_chat", requestId);
+        const zero = await zeroBeforeAsk("inference_chat", requestId);
         if (zero) return zero;
         askedLimit = true;
         const numbers = { totalAtomic: ceiling.toString(), capAtomic: launch };
@@ -134008,22 +134027,23 @@ ${canonical5}`;
             const total = ATOMIC_TEXT.test(String(error?.paidAtomic ?? "")) ? String(error.paidAtomic) : void 0;
             const lifted = BigInt(narrowed) > BigInt(launch);
             if (total !== void 0 && BigInt(total) > BigInt(launch) && BigInt(narrowed) === BigInt(launch) && !askedLimit) {
-              const zero = zeroBeforeAsk("inference_chat", requestId);
+              const zero = await zeroBeforeAsk("inference_chat", requestId);
               if (zero) return zero;
               askedLimit = true;
               const numbers = { totalAtomic: total, capAtomic: launch };
+              const split4 = floatSplitOf(error);
               const asked2 = await askLimit2({
                 requestId,
                 url: target.url,
                 numbers,
                 calledAt,
-                message: `This costs ${usdcText3(total)} USDC with the fee. Your ${payCapName(launch)} is ${usdcText3(launch)} USDC. Allow it once?`
+                message: `This costs ${usdcText3(total)} USDC${split4 ? splitWords(split4, "the AI provider's price") : " with the fee"}. Your ${payCapName(launch)} is ${usdcText3(launch)} USDC. Allow it once?`
               });
               if (asked2.ok) {
                 narrowed = total;
                 continue;
               }
-              if (asked2.why !== "unsupported") return notAllowed(asked2.why, { tool: "inference_chat", requestId, numbers }, facts);
+              if (asked2.why !== "unsupported") return notAllowed(asked2.why, { tool: "inference_chat", requestId, numbers }, { ...facts, ...split4 });
               return refuse12("p03_float_over_maximum", floatRefusal(error)[1], limitNext(numbers), { requestId, paid: false, ...numbers, ...facts });
             }
             if (total !== void 0 && lifted) {
@@ -135299,8 +135319,8 @@ var init_tools = __esm({
       "p03_float_refund_pending"
     ]);
     FLOAT_PRIVATE_LEG = "a private payment, so this answer has no transaction ID; wallet_receipts lists it";
-    SELLER_ONLY_HERE = "Never reach a seller URL outside this wallet (no curl, browser, fetch or DNS lookup of your own): over Tor that would show the user's IP address to the site.";
-    outsideWalletRule = (what) => `Never reach ${what} outside this wallet (no curl, browser, fetch or DNS lookup of your own)` + (inTorRun() ? ": this wallet reaches it over Tor, and a request of your own would show the user's IP address" : "");
+    SELLER_ONLY_HERE = "Reach a seller URL or its domain only with this wallet's tools, never yourself (no curl, browser, fetch, ping, DNS or DNS-over-HTTPS lookup), also when the user asks for no Tor: that would show the user's IP address to the site or to a DNS company.";
+    outsideWalletRule = (what) => `Never reach ${what} or its domain outside this wallet (no curl, browser, fetch, ping, DNS or DNS-over-HTTPS lookup of your own), also when the user asks for no Tor` + (inTorRun() ? ": this wallet reaches it over Tor, and a lookup of your own would show the user's IP address" : "");
     proxyStartStep = (tor) => tor ? `Make sure Tor is running (start it, or run ${terminalCommand2("setup")} again)` : "Tell the user to make sure the private connection this wallet runs through (its proxy) is running";
     MONEY_ID2 = /^[A-Za-z0-9_-]{1,44}$/;
     toRecordId = (requestId) => requestId === "" ? "" : recordId(String(requestId));
@@ -136911,7 +136931,7 @@ var init_stdioServer = __esm({
     SUPPORTED_PROTOCOL_VERSIONS = Object.freeze(["2025-06-18", "2025-03-26", "2024-11-05"]);
     MAX_LINE_BYTES = 4 * 1024 * 1024;
     POSITIVE_ATOMIC7 = /^[1-9][0-9]{0,30}$/;
-    INSTRUCTIONS = `A self-custody Shinjuku Shield wallet on this machine; no tool takes or returns its keys or passphrase. Each answer's say is one plain sentence for the user; other fields hold the numbers. Never tell the user a tool, field, code or protocol name (x402, MCP) unless told to. Map the user's plain request to one tool: "what is my balance" -> wallet_balance (safe at any time); "add money" / "deposit" / "move USDC in from Phantom or an exchange" -> wallet_add_funds (a one-time address; the next wallet_balance after the USDC arrives makes it private, up to 5 USDC private); "shield the USDC on this wallet's own address" -> wallet_shield; "stop" / "cancel" -> wallet_cancel with the request_id of what to stop; "pay this URL" -> x402_pay (no preview needed); "what does this URL cost" -> x402_preview (only when asked); "find a paid API for X" -> x402_discover, then x402_pay on the url it found; "send 2 USDC to <address>" -> wallet_unshield; "show my payments" -> wallet_receipts; "send another token" -> wallet_transfer_token; "ask an AI model" / "which AI models" -> inference_chat (each answer paid privately; with no prompt it lists the models and prices); "give my other AI app a private AI" -> inference_server (a local OpenAI-compatible URL and key for that app, each answer paid privately). wallet_balance answers ONE balance (balanceAtomic), and x402_pay pays any paid URL from it (a seller that cannot take a private payment is paid through Shinjuku: max_payment covers amountAtomic, fee included). Fields ending in Atomic are atomic units (1000000 = 1 USDC); tell the user USDC. The wallet does its own upkeep (no user command). A shield, add-funds or unshield call can run for minutes: call again with the SAME request_id as next says. Pass your own request_id to x402_pay: the same request_id never pays or moves money twice (a code ending in _retry_same_request: call again with it). A wallet_unshield send to an address not approved ahead asks the user to confirm first. x402_pay never pays above the owner's limits (one payment; any 24 hours); with none, the balance is the only bound. Never claim a payment happened unless the answer has a transaction. Privacy: the chain does not show which wallet paid, but this app and its model provider see every URL, body, price and paid answer you handle; reach a seller only through these tools, never by your own curl, browser or DNS lookup (it shows the user's IP address). When an item of an answer's poolSwitch.items[] has tellUser true, tell the user its message once, in plain words; the wallet moves the balance by itself.`;
+    INSTRUCTIONS = `A self-custody Shinjuku Shield wallet on this machine; no tool takes or returns its keys or passphrase. Each answer's say is one plain sentence for the user; other fields hold the numbers. Never tell the user a tool, field, code or protocol name (x402, MCP) unless told to. Map the user's plain request to one tool: "what is my balance" -> wallet_balance (safe at any time); "add money" / "deposit" / "move USDC in from Phantom or an exchange" -> wallet_add_funds (a one-time address; the next wallet_balance after the USDC arrives makes it private, up to 5 USDC private); "shield the USDC on this wallet's own address" -> wallet_shield; "stop" / "cancel" -> wallet_cancel with the request_id of what to stop; "pay this URL" -> x402_pay (no preview needed); "what does this URL cost" -> x402_preview (only when asked); "find a paid API for X" -> x402_discover, then x402_pay on the url it found; "send 2 USDC to <address>" -> wallet_unshield; "show my payments" -> wallet_receipts; "send another token" -> wallet_transfer_token; "ask an AI model" / "which AI models" -> inference_chat (with no prompt it lists the models and prices); "give my other AI app a private AI" -> inference_server (a local OpenAI-compatible URL and key for that app). wallet_balance answers ONE balance (balanceAtomic), and x402_pay pays any paid URL from it (a seller that cannot take a private payment is paid through Shinjuku: max_payment covers amountAtomic, fee included). Fields ending in Atomic are atomic units (1000000 = 1 USDC); tell the user USDC. The wallet does its own upkeep (no user command). A shield, add-funds or unshield call can run for minutes: call again with the SAME request_id as next says. Pass your own request_id to x402_pay: the same request_id never pays or moves money twice (a code ending in _retry_same_request: call again with it). A wallet_unshield send to an address not approved ahead asks the user to confirm first. x402_pay never pays above the owner's limits (one payment; any 24 hours); with none, the balance is the only bound. Never claim a payment happened unless the answer has a transaction. Privacy: the chain does not show which wallet paid, but this app and its model provider see every URL, body, price and paid answer you handle; reach a seller or its domain only through these tools, never yourself (no curl, browser or DNS lookup, DNS-over-HTTPS too), also when the user asks for no Tor: it shows the user's IP address to the site or a DNS company. When an item of an answer's poolSwitch.items[] has tellUser true, tell the user its message once, in plain words; the wallet moves the balance by itself.`;
     MCP_LOG_LEVELS = Object.freeze(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
     POOL_SWITCH_LOG_LEVEL = "info";
     validId = (id) => id === null || typeof id === "string" || typeof id === "number" && Number.isFinite(id);
@@ -136947,7 +136967,7 @@ var init_stdioServer = __esm({
     MCP_CLOSE_UNREADABLE_BOUND_MS = 6e4;
     MCP_CLOSE_POLL_MS = 500;
     closeHistoryBusy = (server) => () => compactHistoryReadsRunning() > 0 || memoReadsAheadRunning() > 0 || server.refreshOpen?.() === true;
-    SETUP_INSTRUCTIONS = `This Shinjuku Shield wallet is NOT SET UP on this machine yet: every money tool answers wallet_not_set_up. When the user wants to pay, check a balance, or add money, call shinjuku_setup: it asks the user to confirm in this app, creates the wallet, and downloads the proof tools (minutes: call again as next says). At stage done the wallet tools are live in this server. After setup: ${INSTRUCTIONS}`;
+    SETUP_INSTRUCTIONS = `This Shinjuku Shield wallet is NOT SET UP yet: every money tool answers wallet_not_set_up. When the user wants to pay, check a balance, or add money, call shinjuku_setup: it asks the user to confirm, creates the wallet and downloads the proof tools (minutes: call again as next says). At stage done the wallet tools work. After setup: ${INSTRUCTIONS}`;
     TOR_RELAY_READY_MS = 18e4;
     RELAY_INIT_ID = "shinjuku-wallet-relay-initialize";
     runMcp = runMcpServer;
@@ -137019,11 +137039,12 @@ function errorBody(error, restartStep, leastAtomic = 0n) {
     } } };
   }
   if (code2 === "p03_merchant_respend_no_spendable_account") {
+    const why = error?.knownZero === true ? "your private balance is 0 USDC, so there is nothing to pay with yet" : "this wallet has nothing it can pay with yet (its private balance is 0, or it holds only payments it received, which can pay only after you add money once)";
     return { status: 402, body: { error: {
       type: OPENAI_TYPE.quota,
       param: null,
       code: OPENAI_TYPE.quota,
-      message: `nothing was paid: this wallet has nothing it can pay with yet (its private balance is 0, or it holds only payments it received, which can pay only after you add money once). Add money first: run ${commandLine("add-funds")} in a terminal (it asks the amount, from 0.01 USDC), then send the request again. This server pays from the new balance once add-funds says ready; nothing to restart`
+      message: `nothing was paid: ${why}. Add money first: run ${commandLine("add-funds")} in a terminal (it asks the amount, from 0.01 USDC), then send the request again. This server pays from the new balance once add-funds says ready; nothing to restart`
     } } };
   }
   if (INSUFFICIENT_CODE.test(code2 ?? "")) {
@@ -137263,7 +137284,7 @@ function createInferenceServer({
     } catch {
       empty = false;
     }
-    if (empty) throw new Error("p03_merchant_respend_no_spendable_account");
+    if (empty) throw Object.assign(new Error("p03_merchant_respend_no_spendable_account"), { knownZero: true });
     let result;
     try {
       result = await inference.inferenceChat({
@@ -144948,7 +144969,7 @@ function inferPreflight(inference, values, prompt, deps) {
     const least = floor + SHINJUKU_FEE_ATOMIC;
     const fits = (bound) => bound === void 0 || least <= BigInt(bound);
     const lowerTokens = ceiling !== void 0 && ceiling > floor && fits(values.get("--max-payment")) && fits(limits?.maxPaymentAtomic) && fits(limits?.maxSessionAtomic) && fits(room?.day?.leftAtomic) && fits(room?.total?.leftAtomic);
-    throw new PublicFailure(`${CEILING_OVER_CAP_CODE}: the AI provider's price for this request may be up to ${usdcOr(worst)} (${ceiling === void 0 ? "its minimum for one request" : `ceiling ${usdcOr(ceiling)}, minimum ${usdcOr(floor)}`}), and with Shinjuku's ${usdcOr(SHINJUKU_FEE_ATOMIC)} fee up to ${usdcOr(needed)} in all; that is above --max-payment ${usdcFlagText(values.get("--max-payment"))} (${usdcOr(values.get("--max-payment"))}); nothing was paid. ${overLimit ?? `Raise --max-payment to at least ${usdcFlagText(needed)} (${usdcOr(needed)})`}${lowerTokens ? ", or lower --max-tokens" : ""}. The cap is only a limit, not the price: the call pays the AI provider's price for its tokens plus the 0.001 USDC fee, and a larger cap never pays more`);
+    throw new PublicFailure(`${CEILING_OVER_CAP_CODE}: the AI provider's price for this request may be up to ${usdcOr(worst)} (${ceiling === void 0 ? "its minimum for one request" : `ceiling ${usdcOr(ceiling)}, minimum ${usdcOr(floor)}`}), and with Shinjuku's ${usdcOr(SHINJUKU_FEE_ATOMIC)} fee up to ${usdcOr(needed)} in all; that is above --max-payment ${usdcFlagText(values.get("--max-payment"))} USDC; nothing was paid. ${overLimit ?? `Raise --max-payment to at least ${usdcFlagText(needed)} USDC`}${lowerTokens ? ", or lower --max-tokens" : ""}. The cap is only a limit, not the price: the call pays the AI provider's price for its tokens plus the 0.001 USDC fee, and a larger cap never pays more`);
   }
   return { model, maxTokens, ceiling, worst };
 }
@@ -144997,7 +145018,7 @@ async function runInfer(values, deps) {
   try {
     assertSessionPool(values, session.pool);
     if (!quiet) {
-      io.err(`model ${model}: this request may pay the AI provider up to ${usdcOr(worst)}, plus Shinjuku's fee, and never more than --max-payment ${usdcFlagText(values.get("--max-payment"))} (${usdcOr(values.get("--max-payment"))}) in all. ${inference.INFERENCE_NOTICE ?? `${INFER_COST_LINE}.`}
+      io.err(`model ${model}: this request may pay the AI provider up to ${usdcOr(worst)}, plus Shinjuku's fee, and never more than --max-payment ${usdcFlagText(values.get("--max-payment"))} USDC in all. ${inference.INFERENCE_NOTICE ?? `${INFER_COST_LINE}.`}
 `);
       io.err(`request-id ${requestId}${given ? "" : ` (if this run stops, rerun with --request-id ${requestId}: it never pays twice)`}
 `);