shinjuku-shield 0.3.111 → 0.3.113

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.111. The npm packages `shinjuku-shield` and
+This is version 0.3.113. 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.111
+npm install -g shinjuku@0.3.113
 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.111 setup`.
+installing, type `npx shinjuku@0.3.113 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.111 mcp
+claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.113 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.111", "mcp"] } } }
+{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.113", "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": "ca9504f8356a05d2a1fc36428f6443419e6943406d11e201d4fa2ff9d6c84814",
-  "bytes": 8333810,
-  "sourceCommit": "b7bf7b1d3617d779db6012f60c35e34f7e8363da",
+  "sha256": "bfaedd12d120b4b5421cdf6c9c06b07b7e338fd6d4e74b7225f2a0d3aa150cf4",
+  "bytes": 8339853,
+  "sourceCommit": "0c37c0dea055d3c28bab9939cd5527fc290668f8",
   "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-27T14:51:57.097Z"
+  "publishedAt": "2026-10-27T16:17:32.089Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shield",
-  "version": "0.3.111",
+  "version": "0.3.113",
   "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": "ca9504f8",
-  "shinjukuSha256": "ca9504f8356a05d2a1fc36428f6443419e6943406d11e201d4fa2ff9d6c84814",
+  "shinjukuRelease": "bfaedd12",
+  "shinjukuSha256": "bfaedd12d120b4b5421cdf6c9c06b07b7e338fd6d4e74b7225f2a0d3aa150cf4",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-shield#readme",

package/shinjuku-wallet.mjs

@@ -67087,6 +67087,7 @@ var init_errorCodes = __esm({
       "p03_float_pool_unreadable_retry_same_request",
       "p03_float_body_too_large",
       "p03_float_busy_retry_later",
+      "p03_float_fee_account_low",
       "p03_float_not_ready_retry_later",
       "p03_float_payment_in_flight_retry_later",
       "p03_float_already_paid",
@@ -81130,7 +81131,7 @@ function privateSendHold(store, { accounts, notes, selfProofWalName } = {}) {
   const self2 = typeof selfProofWalName === "string" ? (part) => selfProofWalName === `resource-proof-${sha256Hex2(Buffer.from(selfPayRequestId(part.unshieldId), "utf8"))}` : void 0;
   const unsent = unsentParts(store, self2);
   if (unsent === null) return null;
-  const hold = { accounts: /* @__PURE__ */ new Set(), notes: /* @__PURE__ */ new Set(), sends: [], unpacked: [], spareAtomic: "0" };
+  const hold = { accounts: /* @__PURE__ */ new Map(), notes: /* @__PURE__ */ new Set(), sends: [], unpacked: [] };
   if (unsent.length === 0) return hold;
   try {
     unsent.sort(bySendPart);
@@ -81148,22 +81149,27 @@ function privateSendHold(store, { accounts, notes, selfProofWalName } = {}) {
     const { bins } = packed;
     const unpacked = unsent.filter(({ plan }) => short.has(plan.sendId));
     const holding = /* @__PURE__ */ new Set();
-    let spare = 0n;
+    const owed = /* @__PURE__ */ new Map();
+    for (const bin of bins) for (const entry of bin.parts) owed.set(entry.plan.sendId, (owed.get(entry.plan.sendId) ?? 0n) + BigInt(entry.part.amountAtomic));
     for (const bin of bins) {
       if (bin.parts.length === 0 || bin.parts.some((entry) => entry.self)) continue;
-      hold.accounts.add(BigInt(bin.entry.commitment).toString());
+      const need = [...new Set(bin.parts.map((entry) => entry.plan.sendId))].reduce((sum2, sendId) => sum2 + owed.get(sendId), 0n);
+      const account = BigInt(bin.entry.account.b);
+      hold.accounts.set(BigInt(bin.entry.commitment).toString(), (bin.notes.length > 0 || need > account ? account : need).toString());
       for (const note of bin.notes) hold.notes.add(BigInt(note.commitment).toString());
       for (const entry of bin.parts) holding.add(entry.plan.sendId);
-      spare += bin.value - bin.used;
     }
     for (const { plan } of unsent) if (holding.delete(plan.sendId)) hold.sends.push(namedSend(plan));
     hold.unpacked = unpacked.map(({ plan, part }) => ({ sendId: plan.sendId, index: part.index, amountAtomic: String(part.amountAtomic) }));
-    hold.spareAtomic = spare.toString();
   } catch {
     return null;
   }
   return hold;
 }
+function heldSpareAtomic(hold, entry) {
+  const need = hold.accounts.get(BigInt(entry.commitment).toString());
+  return need === void 0 ? void 0 : BigInt(entry.account.b) - BigInt(need);
+}
 function privateSendPartsFit(store, { accounts, notes, partAmounts: partAmounts2 }) {
   const unsent = unsentParts(store);
   if (unsent === null) return false;
@@ -81373,7 +81379,11 @@ var init_privateSend = __esm({
     DIRECT_EXIT_MODE = "direct-exit";
     noteFitsAccount = (account, note) => account.account?.i === void 0 || note.leafIndex === void 0 || note.leafIndex === null || BigInt(note.leafIndex) >= BigInt(account.account.i);
     bySendPart = (left, right) => left.plan.sendId < right.plan.sendId ? -1 : left.plan.sendId > right.plan.sendId ? 1 : left.part.index - right.part.index;
-    namedSend = (plan) => typeof plan.transferTokenId === "string" ? { sendId: plan.sendId, requestId: plan.transferTokenId, tool: "wallet_transfer_token" } : typeof plan.mcpTo !== "string" ? { sendId: plan.sendId, requestId: plan.sendId, tool: "cli" } : { sendId: plan.sendId, requestId: typeof plan.mcpRequestId === "string" ? plan.mcpRequestId : String(plan.sendId).replace(/^mcp-/, ""), tool: "wallet_unshield" };
+    namedSend = (plan) => ({
+      ...typeof plan.transferTokenId === "string" ? { sendId: plan.sendId, requestId: plan.transferTokenId, tool: "wallet_transfer_token" } : typeof plan.mcpTo !== "string" ? { sendId: plan.sendId, requestId: plan.sendId, tool: "cli" } : { sendId: plan.sendId, requestId: typeof plan.mcpRequestId === "string" ? plan.mcpRequestId : String(plan.sendId).replace(/^mcp-/, ""), tool: "wallet_unshield" },
+      to: typeof plan.mcpTo === "string" ? plan.mcpTo : plan.to,
+      amountAtomic: String(plan.amountAtomic)
+    });
     cancelledPart = (store, plan, part) => plan.state === "cancelled" && !partMayHaveSigned(store, part);
     partCancelled = (store, sendId, part) => {
       const plan = store.readWal(privateSendPlanName(sendId));
@@ -81714,7 +81724,9 @@ async function everyAccountHeld({ store, connection, programId, serviceUrl: serv
   if (freeAccounts.length === 0) return anyHeld;
   const largest = freeAccounts.reduce((max, entry) => BigInt(entry.account.b) > BigInt(max.account.b) ? entry : max);
   if (!anyHeld) {
-    assertAccountsNotSplit({ accounts: freeAccounts, account: largest, notes: freeNotes.filter(free), amountAtomic });
+    if (!unheldAccounts.some((entry) => (heldSpareAtomic(sendHold, entry) ?? 0n) >= BigInt(amountAtomic))) {
+      assertAccountsNotSplit({ accounts: freeAccounts, account: largest, notes: freeNotes.filter(free), amountAtomic });
+    }
     return false;
   }
   const notesValue = freeNotes.reduce((sum2, entry) => sum2 + BigInt(entry.note.b), 0n);
@@ -81872,10 +81884,15 @@ async function prepareRecoveredPayment({
   };
   const unheldNotes = unspentNotes.filter((entry) => !heldByPending(entry) && !exitReserved.has(BigInt(entry.commitment).toString()) && !keptNote(entry));
   const held = unheldAccounts.length !== unspentAccounts.length || unspentNotes.filter((entry) => !exitReserved.has(BigInt(entry.commitment).toString()) && !keptNote(entry)).length !== unheldNotes.length;
-  const sendHold = deps.poolMove === true ? { accounts: /* @__PURE__ */ new Set(), notes: /* @__PURE__ */ new Set(), sends: [], unpacked: [], spareAtomic: "0" } : privateSendHold(store, { accounts: unheldAccounts, notes: unheldNotes, selfProofWalName: requestedWalName });
+  const sendHold = deps.poolMove === true ? { accounts: /* @__PURE__ */ new Map(), notes: /* @__PURE__ */ new Set(), sends: [], unpacked: [] } : privateSendHold(store, { accounts: unheldAccounts, notes: unheldNotes, selfProofWalName: requestedWalName });
   if (sendHold === null) heldByPrivateSend([]);
   const sendHeld = (entry) => (entry.kind === "account" ? sendHold.accounts : sendHold.notes).has(BigInt(entry.commitment).toString());
   const accounts = sendHold.accounts.size === 0 ? unheldAccounts : unheldAccounts.filter((entry) => !sendHeld(entry));
+  const heldAccounts = sendHold.accounts.size === 0 ? [] : unheldAccounts.filter(sendHeld);
+  const spareSpend = (outputIndex) => {
+    const fits = heldAccounts.filter((entry) => heldSpareAtomic(sendHold, entry) >= BigInt(witnessQuote.amountAtomic));
+    return fits.length === 0 ? void 0 : selectSpendAccount({ accounts: fits, notes: [], outputIndex, amountAtomic: witnessQuote.amountAtomic }).account;
+  };
   const freeNotes = sendHold.notes.size === 0 ? unheldNotes : unheldNotes.filter((entry) => !sendHeld(entry));
   const notes = sendHold.accounts.size === 0 && sendHold.notes.size === 0 ? unheldNotes : freeNotes.filter((entry) => accounts.some((account2) => noteFitsAccount(account2, entry)));
   let refusedValues;
@@ -81887,7 +81904,7 @@ async function prepareRecoveredPayment({
       return false;
     }
   };
-  const wantedNotes = selection?.noteCommitments !== void 0 ? selection.noteCommitments.map((commitment) => {
+  let wantedNotes = selection?.noteCommitments !== void 0 ? selection.noteCommitments.map((commitment) => {
     const wanted = BigInt(commitment);
     const found = notes.find((entry) => BigInt(entry.commitment) === wanted);
     if (!found && exitReserved.has(wanted.toString())) fail20("requested_note_reserved_by_exit");
@@ -81982,14 +81999,21 @@ async function prepareRecoveredPayment({
       if (largest && finalizedLargest !== void 0 && (underAnchor === void 0 || BigInt(finalizedLargest.account.b) > BigInt(underAnchor.account.b))) {
         throw new Error("p03_quote_anchor_older_than_note_wait_next_epoch");
       }
-      account = underAnchor ?? accounts[0];
-      sendShort = (sendHold.accounts.size > 0 || sendHold.notes.size > 0) && !pays(underAnchor);
+      const spareAllowed = !pays(underAnchor) && !largest && selection?.noteCommitments === void 0;
+      const spare = spareAllowed ? spareSpend(anchor.index) : void 0;
+      if (spareAllowed && spare === void 0 && spareSpend(history.finalizedPoolSnapshot.currentIndex) !== void 0) {
+        throw new Error("p03_quote_anchor_older_than_note_wait_next_epoch");
+      }
+      if (spare !== void 0) wantedNotes = [];
+      account = spare ?? underAnchor ?? accounts[0];
+      sendShort = spare === void 0 && (sendHold.accounts.size > 0 || sendHold.notes.size > 0) && !pays(underAnchor);
     }
     if (account) assertAccountsNotSplit({ accounts, account, notes: wantedNotes, allNotes: notes, amountAtomic: witnessQuote.amountAtomic });
-    if (sendShort && (accounts.length === 0 || [...accounts.map((entry) => entry.account.b), ...freeNotes.map((entry) => entry.note.b)].reduce((sum2, value2) => sum2 + BigInt(value2), BigInt(sendHold.spareAtomic)) >= BigInt(witnessQuote.amountAtomic))) {
+    if (sendShort && (accounts.length === 0 || [...accounts.map((entry) => entry.account.b), ...freeNotes.map((entry) => entry.note.b)].reduce((sum2, value2) => sum2 + BigInt(value2), heldAccounts.reduce((sum2, entry) => sum2 + heldSpareAtomic(sendHold, entry), 0n)) >= BigInt(witnessQuote.amountAtomic))) {
       heldByPrivateSend(sendHold.sends);
     }
     if (!account) fail20("no_spendable_account");
+    if (sendHeld(account) && heldSpareAtomic(sendHold, account) + wantedNotes.reduce((sum2, note) => sum2 + BigInt(note.note.b), 0n) < BigInt(witnessQuote.amountAtomic)) heldByPrivateSend(sendHold.sends);
     await prepareFold(deps.buildRecoveryPath);
     accountPath = buildRecoveryPath({
       history,
@@ -100854,6 +100878,14 @@ function floatOutcomeWords(code2, error, t) {
       return [code2, "Shinjuku's shared float is busy right now; nothing was paid", t.againIn(error?.retryAfterSeconds ?? 30)];
     case "p03_float_not_ready_retry_later":
       return [code2, "Shinjuku's shared float is not ready yet (it is being filled); nothing was paid", t.againIn(error?.retryAfterSeconds ?? 60)];
+    // The fee payer of Shinjuku's shared pockets is low on SOL (floatPay.mjs floatRefusalError, 0.3.113): only its operator
+    // refills it, so the words name no time and ask for no retry soon (mcp6 0.3.112 gate: "retry in a minute" failed again).
+    case "p03_float_fee_account_low":
+      return [
+        code2,
+        "the Shinjuku account that pays the network fee of this payment is low on SOL, and its operator was alerted; nothing was paid and the balance did not change",
+        `This is not a fault of the wallet: the payment can go after the operator adds SOL to that account, and no time is known. ${t.rerun} later`
+      ];
     case "p03_float_payment_in_flight_retry_later":
       return [code2, "an earlier quote for this payment is still open at Shinjuku; nothing was paid", t.againIn(error?.retryAfterSeconds ?? 60)];
     case "p03_float_price_above_capacity":
@@ -101870,6 +101902,8 @@ function computeBalance({ store, snapshotRead, source = "local", now = Date.now(
   let spendInputs;
   let sendHold;
   let heldAtomic;
+  let heldWholeAtomic;
+  let spareMost = 0n;
   const report = (status, gross, next2, cause, largest2, change) => {
     const atomic4 = gross === null || privateSendPending === null ? null : gross > privateSendPending ? gross - privateSendPending : 0n;
     const built = {
@@ -101899,7 +101933,11 @@ function computeBalance({ store, snapshotRead, source = "local", now = Date.now(
     if (spendInputs !== void 0) SPEND_INPUTS.set(built, spendInputs);
     if (atomic4 !== null && sendHold && heldAtomic !== void 0) {
       const aside = heldAtomic > privateSendPending ? heldAtomic : privateSendPending;
-      SEND_HOLDS.set(built, { ...sendHold, freeAtomic: (gross > aside ? gross - aside : 0n).toString(), heldAtomic: aside.toString() });
+      const whole = heldWholeAtomic > privateSendPending ? heldWholeAtomic : privateSendPending;
+      const outside = gross > whole ? gross - whole : 0n;
+      const most = outside > spareMost ? outside : spareMost;
+      const cap = gross > aside ? gross - aside : 0n;
+      SEND_HOLDS.set(built, { ...sendHold, freeAtomic: (most < cap ? most : cap).toString(), heldAtomic: aside.toString() });
     }
     if (largest2 !== void 0 && atomic4 !== null) {
       const cap = atomic4 - BigInt(detail.successionMovableAtomic ?? "0");
@@ -102158,14 +102196,18 @@ It asks the amount, then gives a one-time address and its QR code: send USDC to
   const entries = free.map(spendEntry);
   const freeInputs = { accounts: entries.filter((entry) => entry.kind === "account"), notes: entries.filter((entry) => entry.kind === "note") };
   if (!unknownInputs) spendInputs = freeInputs;
-  sendHold = privateSendPending === 0n ? { accounts: /* @__PURE__ */ new Set(), notes: /* @__PURE__ */ new Set(), sends: [], unpacked: [] } : privateSendPending === null ? null : privateSendHold(store, freeInputs);
+  sendHold = privateSendPending === 0n ? { accounts: /* @__PURE__ */ new Map(), notes: /* @__PURE__ */ new Set(), sends: [], unpacked: [] } : privateSendPending === null ? null : privateSendHold(store, freeInputs);
   const isHeld = (output2) => sendHold.accounts.has(output2.commitment) || sendHold.notes.has(output2.commitment);
   const notHeld = sendHold === null ? [] : free.filter((output2) => !isHeld(output2));
   const open4 = sendHold === null || sendHold.accounts.size === 0 && sendHold.notes.size === 0 ? notHeld : notHeld.filter((output2) => output2.kind !== "note" || notHeld.some((other) => other.kind === "account" && noteFitsAccount(spendEntry(other), spendEntry(output2))));
+  const spares = sendHold === null ? [] : free.filter((output2) => output2.kind === "account" && sendHold.accounts.has(output2.commitment)).map((output2) => ({ output: output2, spareAtomic: heldSpareAtomic(sendHold, spendEntry(output2)) }));
   if (sendHold !== null) {
-    heldAtomic = sum2(free.filter(isHeld).map((output2) => output2.valueAtomic)) + sum2(sendHold.unpacked.map((part) => part.amountAtomic));
+    heldWholeAtomic = sum2(free.filter(isHeld).map((output2) => output2.valueAtomic)) + sum2(sendHold.unpacked.map((part) => part.amountAtomic));
+    heldAtomic = heldWholeAtomic - sum2(spares.map((spare) => spare.spareAtomic));
+    spareMost = spares.reduce((most, spare) => spare.spareAtomic > most ? spare.spareAtomic : most, 0n);
   }
-  const largest = sendHold === null ? void 0 : largestOneSpend(open4);
+  const openLargest = sendHold === null ? void 0 : largestOneSpend(open4);
+  const largest = openLargest === void 0 || openLargest >= spareMost ? openLargest : spareMost;
   if (settling.some((payment) => payment.inputs.some((commitment) => reserved.has(commitment) || joining.has(commitment))) || unknownInputs && settling.length) {
     reasons.push(...settlingReasons);
     return report("stale", null, refreshCommand(state, snapshot.programId));
@@ -102176,7 +102218,10 @@ It asks the amount, then gives a one-time address and its QR code: send USDC to
     return report("stale", null, refreshCommand(state, snapshot.programId));
   }
   const anchorIndex = canonicalAtomic(snapshot.anchorIndex) ? BigInt(snapshot.anchorIndex) : void 0;
-  detail.fundedAccounts = unknownInputs ? 0 : sendHold === null ? null : open4.filter((output2) => output2.kind === "account" && BigInt(output2.valueAtomic) > 0n && (anchorIndex === void 0 || BigInt(output2.leafIndex) < anchorIndex)).length;
+  detail.fundedAccounts = unknownInputs ? 0 : sendHold === null ? null : [
+    ...open4.filter((output2) => output2.kind === "account" && BigInt(output2.valueAtomic) > 0n),
+    ...spares.filter((spare) => spare.spareAtomic > 0n).map((spare) => spare.output)
+  ].filter((output2) => anchorIndex === void 0 || BigInt(output2.leafIndex) < anchorIndex).length;
   const answeredOnly = detail.inFlight.length > 0 && detail.inFlight.every((item) => item.answered === true);
   const next = answeredOnly ? detail.inFlight.find((item) => item.next.startsWith("rerun"))?.next ?? "nothing to do: an answered unshield finishes its check by itself" : detail.inFlight.length ? "finish or cancel the work in detail.inFlight; the wallet runs one payment at a time" : pendingDeposits.length ? byAddFunds(pendingDeposits[0].depositId) ? `deposit ${pendingDeposits[0].depositId} of add-funds is not finished. ${continueAddFunds}` : `deposit ${pendingDeposits[0].depositId} is not finished: rerun the same deposit command with --submit --service <facilitator URL>` : pocketsUnscanned ? scanPockets2 : unspentAtomic === 0n && successionMovableAtomic > 0n ? "this pool was succeeded by a new pool: its value moves there (one move per funded deposit, the facilitator pays the fee) and counts in this balance until then" : unspentAtomic === 0n ? `nothing to spend. To add money, run:
   ${commandLine("add-funds")}
@@ -102188,9 +102233,11 @@ If a payment to this wallet settled, read the chain again with:
   if (settling.length || movedInAtomic > 0n) {
     reasons.push(...settlingReasons);
     const [only] = settling;
-    const sendHeldAtomic = sendHold === null || sendHold.unpacked.length > 0 || sendHold.notes.size > 0 ? null : sum2(free.filter(isHeld).map((output2) => output2.valueAtomic));
+    const sendHeldAtomic = sendHold === null || sendHold.notes.size > 0 ? null : sum2(free.filter(isHeld).map((output2) => output2.valueAtomic));
     const inputsAtomic = settling.length === 1 ? sum2(only.inputs.map((commitment) => unspent.get(commitment).valueAtomic)) : 0n;
-    const changeOnly = settling.length === 1 && only.join !== true && only.exit !== true && reservedAtomic === 0n && detail.joiningAtomic === "0" && successionMovableAtomic === 0n && sendHeldAtomic !== null && unspentAtomic - sendHeldAtomic === inputsAtomic && inputsAtomic > only.amountAtomic;
+    const changeAtomic = inputsAtomic - (settling.length === 1 ? only.amountAtomic : 0n);
+    const changeFreeAtomic = sendHold === null || sendHold.unpacked.length === 0 ? changeAtomic : changeAtomic > privateSendPending ? changeAtomic - privateSendPending : 0n;
+    const changeOnly = settling.length === 1 && only.join !== true && only.exit !== true && reservedAtomic === 0n && detail.joiningAtomic === "0" && successionMovableAtomic === 0n && sendHeldAtomic !== null && unspentAtomic - sendHeldAtomic === inputsAtomic && inputsAtomic > only.amountAtomic && changeFreeAtomic > 0n;
     return report(
       "stale",
       spendable + successionMovableAtomic,
@@ -102199,7 +102246,7 @@ If a payment to this wallet settled, read the chain again with:
       // still settling" while the only answered item was a join).
       settlingRecent ? movedInAtomic === 0n && settling.length > 0 && settling.every((payment) => payment.join) ? "account_join" : "payment_settling" : movedInAtomic > 0n ? "pool_move" : void 0,
       largest,
-      changeOnly ? inputsAtomic - only.amountAtomic : void 0
+      changeOnly ? changeFreeAtomic : void 0
     );
   }
   return report("current", spendable + successionMovableAtomic, next, void 0, largest);
@@ -102214,7 +102261,7 @@ function savedSpendInputs({ store, snapshotRead }) {
 }
 function savedSendHold({ store, snapshotRead }) {
   try {
-    if (privateSendPendingAtomic(store) === 0n) return { accounts: /* @__PURE__ */ new Set(), notes: /* @__PURE__ */ new Set(), sends: [], unpacked: [] };
+    if (privateSendPendingAtomic(store) === 0n) return { accounts: /* @__PURE__ */ new Map(), notes: /* @__PURE__ */ new Set(), sends: [], unpacked: [] };
     const report = computeBalance({ store, snapshotRead: snapshotRead ?? readBalanceSnapshot(store) });
     return report.status === "current" && SPEND_INPUTS.has(report) ? sendHoldOf(report) ?? null : null;
   } catch {
@@ -103214,6 +103261,7 @@ function floatFetch(base, seen) {
       code: code2,
       ...Number.isFinite(retryAfter) && retryAfter > 0 ? { retryAfterSeconds: Math.min(Math.ceil(retryAfter), 3600) } : {},
       ...DECIMAL3.test(String(answer.largestAtomic ?? "")) ? { largestAtomic: String(answer.largestAtomic) } : {},
+      ...typeof answer.reason === "string" && /^[a-z_]{1,60}$/.test(answer.reason) ? { reason: answer.reason } : {},
       ...typeof answer.message === "string" ? { message: plainText(answer.message) } : {}
     };
     return new Response(null, { status: 400 });
@@ -103232,8 +103280,9 @@ function floatRefusalError(refusal3, record) {
       return Object.assign(new Error("p03_float_busy_retry_later"), { retryAfterSeconds: 30, ...extra });
     case "float_price_above_capacity":
       return Object.assign(new Error("p03_float_price_above_capacity"), extra);
+    // fee_payer_underfunded (0.3.113): the fee payer of the shared pockets needs the operator's SOL, so no retry soon helps.
     case "float_not_ready":
-      return Object.assign(new Error("p03_float_not_ready_retry_later"), { retryAfterSeconds: 60, ...extra });
+      return refusal3.reason === "fee_payer_underfunded" ? Object.assign(new Error("p03_float_fee_account_low"), extra) : Object.assign(new Error("p03_float_not_ready_retry_later"), { retryAfterSeconds: 60, ...extra });
     case "float_payment_in_flight":
       return Object.assign(new Error("p03_float_payment_in_flight_retry_later"), { retryAfterSeconds: 60, ...extra });
     case "float_already_paid":
@@ -103523,7 +103572,7 @@ async function payViaFloat({
   };
   store.writeWal(walName2, record);
   mark("seller-sent");
-  const sentAtMs = Date.now();
+  const sentAtMs2 = Date.now();
   const stopWaiting = new AbortController();
   const watch = watchFloatTransfer({ record, fetchImpl, sleep: deps.floatStatusSleep, abort: () => stopWaiting.abort() });
   const resendDispatchers = [];
@@ -103538,7 +103587,7 @@ async function payViaFloat({
     if (wasKept) keptAgain();
     const verdict = watch.verdict();
     if (verdict?.state === "dead") {
-      const sellerUnansweredSeconds = Math.round((Date.now() - sentAtMs) / 1e3);
+      const sellerUnansweredSeconds = Math.round((Date.now() - sentAtMs2) / 1e3);
       const { ambiguous: _settled, ...rest } = record;
       record = {
         ...rest,
@@ -103680,7 +103729,7 @@ async function payViaFloat({
         ...state?.state === "landed" ? { transferLanded: true } : {}
       });
     }
-    const late2 = x402Header(response, "payment-response")?.success === false ? { sellerChargeFailed: true, sellerAnswerSeconds: Math.round((answeredAtMs - sentAtMs) / 1e3) } : {};
+    const late2 = x402Header(response, "payment-response")?.success === false ? { sellerChargeFailed: true, sellerAnswerSeconds: Math.round((answeredAtMs - sentAtMs2) / 1e3) } : {};
     const fixable = floatSellerCanBeFixed({ httpStatus: response.status, ...sellerReason ? { sellerReason } : {}, ...late2 }) ? { sellerFixable: true } : {};
     byVerdict(
       await floatVerdict(record, fetchImpl, statusSleep, verdictUntil(answeredAtMs), watch.verdict()),
@@ -106348,28 +106397,31 @@ function promisedShortfall(store, amountAtomic) {
   }
   return void 0;
 }
-function heldByPrivateSendText(sends) {
+function heldByPrivateSendText(sends, freeAtomic) {
   const named = Array.isArray(sends) ? sends.filter((send3) => typeof send3?.requestId === "string") : [];
+  const most = /^\d+$/.test(String(freeAtomic ?? "")) ? `One payment can use at most ${usdcWords(freeAtomic)} now, and this payment needs more. ` : "One payment cannot use this much now. ";
+  const frees = "keeps nothing after its last part goes; an earlier part may free some money, and wallet_balance shows the most one payment can use (largestPaymentAtomic).";
   if (named.length === 0) {
-    return "This payment needs money that is not free now: a private send in progress has set this money aside; wallet_balance names it and its cancel call. The wallet frees it when the next part of that send goes. To pay now, stop the send, or add money with wallet_add_funds.";
+    return `${most}A private send in progress keeps part of this money for its unsent parts; wallet_balance names it and its cancel call. The send ${frees} To pay now, stop the send, or add money with wallet_add_funds.`;
   }
   if (named.length === 1) {
-    return `This payment needs money that the private send "${named[0].requestId}" has set aside for its next part. The wallet frees it when that part goes. To pay now, stop the send with ${cancelCall(named[0])}, or add money with wallet_add_funds.`;
+    const send3 = sendWords(named[0]);
+    return `${most}${send3[0].toUpperCase()}${send3.slice(1)} keeps part of this money for its unsent parts. It ${frees} To pay now, stop the send with ${cancelCall(named[0])}, or add money with wallet_add_funds.`;
   }
-  return `This payment needs money that the private sends ${named.map((send3) => `"${send3.requestId}"`).join(" and ")} have set aside for their next parts. The wallet frees it when those parts go. To pay now, stop a send with ${named.map(cancelCall).join(", or ")}, or add money with wallet_add_funds.`;
+  return `${most}${named.map(sendWords).join(" and ").replace(/^t/, "T")} keep part of this money for their unsent parts. Each ${frees} To pay now, stop a send with ${named.map(cancelCall).join(", or ")}, or add money with wallet_add_funds.`;
 }
 function promisedShortfallText(shortfall, amountAtomic) {
   if (shortfall.error === "spend_private_send_unknown") {
     return "spend_private_send_unknown: a private send of this wallet cannot be read, so the value it still owes is unknown; nothing was sent";
   }
-  if (shortfall.error === HELD_BY_PRIVATE_SEND) return `${HELD_BY_PRIVATE_SEND}: ${heldByPrivateSendText(shortfall.privateSends)} Nothing was sent.`;
+  if (shortfall.error === HELD_BY_PRIVATE_SEND) return `${HELD_BY_PRIVATE_SEND}: ${heldByPrivateSendText(shortfall.privateSends, shortfall.freeAtomic)} Nothing was sent.`;
   return `spend_private_send_reserved: ${usdcWords(shortfall.pendingAtomic)} of the private balance is promised to the unsent smaller payments of a private send; ${usdcWords(shortfall.freeAtomic)} is free and this unshield needs ${usdcWords(amountAtomic)}; nothing was sent`;
 }
 function assertUnshieldNotPromised(store, amountAtomic) {
   const shortfall = promisedShortfall(store, amountAtomic);
   if (shortfall) throw Object.assign(new Error(promisedShortfallText(shortfall, amountAtomic)), shortfall.privateSends ? { privateSends: shortfall.privateSends } : {});
 }
-var HELD_BY_PRIVATE_SEND, cancelCall;
+var HELD_BY_PRIVATE_SEND, cancelCall, sendWords;
 var init_promised = __esm({
   "wallet/src/unshield/promised.mjs"() {
     "use strict";
@@ -106378,6 +106430,11 @@ var init_promised = __esm({
     init_usdcWords();
     HELD_BY_PRIVATE_SEND = "p03_merchant_respend_value_held_by_private_send";
     cancelCall = (send3) => send3.tool === "wallet_transfer_token" ? `wallet_transfer_token_status with request_id "${send3.requestId}" and action "cancel"` : send3.tool === "cli" ? `the command line: unshield-cancel --unshield-id ${send3.sendId}` : `wallet_cancel with request_id "${send3.requestId}"`;
+    sendWords = (send3) => {
+      const amount = /^[1-9][0-9]*$/.test(String(send3?.amountAtomic ?? "")) ? ` of ${usdcWords(send3.amountAtomic)}` : "";
+      const to = typeof send3?.to === "string" && send3.to.length > 10 ? ` to ${send3.to.slice(0, 4)}...${send3.to.slice(-4)}` : "";
+      return `the private send${amount}${to}`;
+    };
   }
 });
 
@@ -106767,7 +106824,7 @@ async function assertNotPromised({ session, store, amountAtomic, leasedAt, mark,
       ok: false,
       error: "spend_private_send_reserved",
       detail: `${usdcWords(pending)} of the private balance is promised to the unsent smaller payments of a private send; ${usdcWords(free)} is free and this payment needs ${usdcWords(amountAtomic)}; nothing was paid`,
-      next: wait2
+      next: "Tell the user why nothing was paid and what they can do. This payment needs more than the money the private send does not keep, and the money it keeps leaves the wallet as its parts go, so a wait frees nothing. Stop its unsent parts with the cancel call wallet_balance names for it (that money stays in the wallet), or add money with wallet_add_funds, then pay again with the same request_id"
     });
   }
   const hold = sendHoldOf(report);
@@ -106775,8 +106832,8 @@ async function assertNotPromised({ session, store, amountAtomic, leasedAt, mark,
     throw Object.assign(new SpendRefusalError({
       ok: false,
       error: HELD_BY_PRIVATE_SEND,
-      detail: `${heldByPrivateSendText(hold.sends)} Nothing was paid.`,
-      next: "Tell the user why nothing was paid and what they can do. After the next part of the send goes, after a stop of the send, or after new money arrives, pay again with the same request_id",
+      detail: `${heldByPrivateSendText(hold.sends, hold.freeAtomic)} Nothing was paid.`,
+      next: "Tell the user why nothing was paid and what they can do. One payment cannot use this much now beside what the private send keeps for its unsent parts. The send keeps nothing after its last part goes, and an earlier part may free some money: pay again with the same request_id when wallet_balance largestPaymentAtomic covers this payment, after a stop of the send, or after new money is private",
       privateSends: hold.sends
     }), { privateSends: hold.sends });
   }
@@ -108801,12 +108858,14 @@ function heldBySendLine(error) {
   for (let link2 = error, depth = 0; link2 instanceof Error && depth < 8; link2 = link2.cause, depth += 1) {
     if (!String(link2.message).startsWith(HELD_BY_PRIVATE_SEND)) continue;
     const sends = Array.isArray(link2.privateSends) ? link2.privateSends.filter((one) => typeof one?.requestId === "string" && typeof one.sendId === "string") : [];
+    const frees = "It keeps nothing after its last part goes; an earlier part may free some money (shinjuku balance shows it).";
     if (sends.length === 0) {
-      return "Nothing was sent. This send needs money that a private send in progress has set aside. The wallet frees it when that send's next part goes. To send now, stop that send (shinjuku unshield-cancel --unshield-id <its id>; a token transfer: shinjuku transfer-token --id <its id> --cancel), or add money with shinjuku add-funds.";
+      return `Nothing was sent. One payment cannot use this much now. A private send in progress keeps part of this money for its unsent parts. ${frees} To send now, stop that send (shinjuku unshield-cancel --unshield-id <its id>; a token transfer: shinjuku transfer-token --id <its id> --cancel), or add money with shinjuku add-funds.`;
     }
     const many = sends.length > 1;
-    const stops = sends.map((one) => one.tool === "wallet_transfer_token" ? `shinjuku transfer-token --id ${one.requestId} --cancel` : `shinjuku unshield-cancel --unshield-id ${one.sendId}`);
-    return `Nothing was sent. This send needs money that the private send${many ? "s" : ""} ${sends.map((one) => `"${one.requestId}"`).join(" and ")} ${many ? "have" : "has"} set aside for ${many ? "their next parts" : "its next part"}. The wallet frees it when ${many ? "those parts go" : "that part goes"}. To send now, stop the send with ${stops.join(", or ")}, or add money with shinjuku add-funds.`;
+    const stops = sends.map((one) => `${one.tool === "wallet_transfer_token" ? `shinjuku transfer-token --id ${one.requestId} --cancel` : `shinjuku unshield-cancel --unshield-id ${one.sendId}`} (${sendWords(one)})`);
+    const named = sends.map(sendWords).join(" and ");
+    return `Nothing was sent. One payment cannot use this much now. ${named[0].toUpperCase()}${named.slice(1)} ${many ? "keep" : "keeps"} part of this money for ${many ? "their" : "its"} unsent parts. ${many ? frees.replace(/^It keeps/, "Each keeps") : frees} To send now, stop the send with ${stops.join(", or ")}, or add money with shinjuku add-funds.`;
   }
   return void 0;
 }
@@ -119435,16 +119494,15 @@ function plainSentence(next, room) {
   }
   return "";
 }
-function heldBySendSay(sends, verb) {
-  const send3 = Array.isArray(sends) ? sends.find((one) => typeof one?.requestId === "string") : void 0;
-  return send3 ? `Nothing was ${verb}. Your private send ${send3.requestId} set this money aside for its next payment; stop that send to pay now, or add money.` : `Nothing was ${verb}. A private send in progress set this money aside. Stop that send to pay now, or add money.`;
+function heldBySendSay(verb) {
+  return `Nothing was ${verb}. A private send in progress set this money aside. Stop that send to pay now, or add money.`;
 }
 function refusalSay(a, tool, again, npmVersion) {
   const code2 = str(a.error);
   const detail = str(a.detail);
   const next = str(a.next);
   const moneyVerb = MOVE_CAP_CODES.has(code2) || tool === "wallet_shield" || tool === "wallet_unshield" ? "moved" : "paid";
-  const ask = typeof a.requestId === "string" && a.requestId ? `Ask again with request_id ${a.requestId}` : "Ask again with the same request_id";
+  const ask = "Ask again";
   if (/_refund_pending$/.test(code2)) {
     const total2 = usdcText2(a.refundAtomic ?? a.paidAtomic);
     const when = Number.isSafeInteger(a.refundEtaSeconds) && a.refundEtaSeconds > 0 ? ` within about ${minutesText(Math.ceil(a.refundEtaSeconds / 60))}` : "";
@@ -119461,14 +119519,13 @@ function refusalSay(a, tool, again, npmVersion) {
     if (a.refundArrived === true) return `The seller did not take it. ${yours} is back in your private balance. ${other}`;
     return `The seller did not take it; ${total2 ? `${total2} USDC` : "your money"} comes back by itself${when}. ${other}`;
   }
-  const askAgain = typeof a.newRequestId === "string" && a.newRequestId ? `To ask again, use request_id ${a.newRequestId}; it pays again.` : "A new request_id pays again.";
+  const askAgain = "Asking again pays again.";
   if (code2 === "p03_float_receipt_pruned" && a.conversationNotKept === true) {
     return `Paid once, not again: the wallet keeps no copy of a private conversation. ${askAgain}`;
   }
   if (code2 === "p03_float_receipt_pruned") return `This request was paid more than 10 minutes ago. ${askAgain}`;
   if (/^p03_(float|resource_payment)_request_(id_conflict|data_mismatch)$/.test(code2)) {
-    const fresh = typeof a.newRequestId === "string" && a.newRequestId ? `request_id ${a.newRequestId}` : "a new request_id";
-    return `Nothing was paid: this request_id belongs to an earlier payment. For this request, ask again with ${fresh}.`;
+    return "Nothing was paid: this request matched an earlier payment with other details. Ask again to pay for this one.";
   }
   if (code2 === "p03_resource_payment_memory_only_needs_float") {
     return "Nothing was paid: this seller now asks a payment whose record would keep your words, and a private call never pays that way. Ask again.";
@@ -119530,6 +119587,7 @@ function refusalSay(a, tool, again, npmVersion) {
   if (/_retry_same_request$/.test(code2)) {
     return a.paid === true ? `Paid, but the seller has not answered yet. ${again}` : `The result is not known yet. ${again}`;
   }
+  if (code2 === "p03_float_fee_account_low") return "Nothing was paid. The payment service's network fee account is low; its operator was alerted. Try again later.";
   if (BUSY.test(code2)) {
     const said = /in about ([0-9]{1,4}) s\b/.exec(next);
     const seconds2 = Number.isFinite(a.readyInSeconds) && a.readyInSeconds > 0 ? Math.ceil(a.readyInSeconds) : said ? Number(said[1]) : 30;
@@ -119568,7 +119626,7 @@ function refusalSay(a, tool, again, npmVersion) {
   if (code2 === "mcp_setup_restart_needed") return "The wallet is set up, but it must reconnect once. Follow the steps below, then try again. Nothing was paid.";
   if (code2 === "mcp_restart_needed") return "Nothing was paid. Restart this app, then try again.";
   if (code2 === "p03_merchant_respend_value_held_by_private_send") {
-    return heldBySendSay(a.privateSends, tool === "wallet_unshield" || tool === "wallet_transfer_token" || tool === "wallet_transfer_token_status" ? "sent" : "paid");
+    return heldBySendSay(tool === "wallet_unshield" || tool === "wallet_transfer_token" || tool === "wallet_transfer_token_status" ? "sent" : "paid");
   }
   if (/accounts_split/.test(code2) || /accounts_split/.test(detail) || typeof a.joining === "boolean") {
     const verb = tool === "wallet_unshield" ? "sent" : "paid";
@@ -119837,8 +119895,7 @@ function heldByPaymentSay(detail) {
   if (!items.length) return "";
   const held = usdcText2(detail.unspentAtomic);
   const what = positive(held) ? `${held} USDC is` : "Your USDC is";
-  const id = items.find((item) => typeof item.requestId === "string" && item.requestId)?.requestId;
-  return id ? `${what} held by an unfinished payment (request_id ${id}). Ask me to finish it, or to close it with wallet_cancel.` : `${what} held by an unfinished payment. Ask me to finish it, or to close it with wallet_cancel.`;
+  return `${what} held by an unfinished payment. Ask me to finish it, or to close it with wallet_cancel.`;
 }
 function ownWorkWords(lockedBy) {
   return typeof lockedBy === "string" && Object.hasOwn(OWN_WORK_WORDS, lockedBy) ? OWN_WORK_WORDS[lockedBy] : void 0;
@@ -119914,25 +119971,29 @@ function balanceLine(a, room = SAY_MAX_WORDS) {
   const going = sends.find((send3) => Number.isSafeInteger(send3.failedTries) && send3.failedTries > 0) ?? sends[0];
   if (going && !moving) {
     const left = usdcText2(going.leftAtomic) ?? "";
+    const total = usdcText2(going.amountAtomic);
+    const to = typeof going.to === "string" && going.to.length > 10 ? ` to ${going.to.slice(0, 4)}...${going.to.slice(-4)}` : "";
+    const named = `your private send${total ? ` of ${total} USDC` : ""}${to}`;
+    const short = `your private send${to}`;
     if (Number.isSafeInteger(going.failedTries) && going.failedTries > 0) {
       const tries = `${going.failedTries} ${going.failedTries === 1 ? "try" : "tries"}`;
       return have(
-        `; your private send "${going.requestId}" has ${left} USDC not sent: its next payment did not go through (${tries}).`,
-        `; private send "${going.requestId}": next payment did not go through (${tries}).`,
+        `; ${named} has ${left} USDC not sent: its next payment did not go through (${tries}).`,
+        `; ${short}: next payment did not go through (${tries}).`,
         "; a private send's next payment did not go through yet."
       );
     }
     if (!(Number.isSafeInteger(going.nextPaymentInMinutes) && going.nextPaymentInMinutes > 0)) {
       return have(
-        `; your private send "${going.requestId}" has ${left} USDC not sent yet, and the wallet tries its next payment again by itself.`,
-        `; private send "${going.requestId}": ${left} USDC not sent yet.`,
+        `; ${named} has ${left} USDC not sent yet, and the wallet tries its next payment again by itself.`,
+        `; ${short}: ${left} USDC not sent yet.`,
         "; a private send is not all sent yet."
       );
     }
     const when = `in about ${minutesText(going.nextPaymentInMinutes)}`;
     return have(
-      `; your private send "${going.requestId}" has ${left} USDC left to go, and its next payment goes ${when}.`,
-      `; private send "${going.requestId}": next payment ${when}.`,
+      `; ${named} has ${left} USDC left to go, and its next payment goes ${when}.`,
+      `; ${short}: next payment ${when}.`,
       `; a private send's next payment goes ${when}.`
     );
   }
@@ -119986,6 +120047,7 @@ function previewReason(a, npmVersion) {
     return raiseLine("--max-session", npmVersion, `over your 24-hour limit of ${usdcText2(a.capAtomic)} USDC.`, SAY_MAX_WORDS - 3);
   }
   if (OWNER_LIMIT_CODES.has(code2)) return "it is above a spending limit set for this wallet.";
+  if (code2 === "p03_float_fee_account_low") return "the payment service's network fee account is low; try again later.";
   if (BUSY.test(code2)) return "the payment service is busy; try again in a minute.";
   if (code2 === "mcp_wallet_unreadable" || code2 === "p03_float_config_unreadable") return "the price could not be checked just now; try again in a minute.";
   const sentence2 = plainSentence(a.detail, SAY_MAX_WORDS - 4);
@@ -120034,8 +120096,7 @@ function transferSay(a) {
   const kept2 = a.send?.keptPrivateAtomic && a.send.keptPrivateAtomic !== "0" ? usdcText2(a.send.keptPrivateAtomic) : null;
   const later = "If this chat ends first, it continues at your next request.";
   if (a.replayed === true) {
-    const fresh = typeof a.newRequestId === "string" && a.newRequestId ? `request_id ${a.newRequestId}` : "a new request_id";
-    return `This request_id belongs to an earlier transfer to ${to}; this call moved nothing. To transfer again, ask with ${fresh}.`;
+    return `This request matched an earlier transfer to ${to}; this call moved nothing. Ask again to transfer again.`;
   }
   switch (a.stage) {
     case "selling":
@@ -120046,7 +120107,7 @@ function transferSay(a) {
     // At most 24 words with the kept part (SAY_MAX_WORDS 25). A send step that stopped (tools.mjs transferAnswer sendStop,
     // 0.3.109 fault 5) says why first: money another send set aside, or money the wallet gets ready by itself.
     case "sending":
-      if (Array.isArray(a.privateSends)) return heldBySendSay(a.privateSends, "sent");
+      if (Array.isArray(a.privateSends)) return heldBySendSay("sent");
       if (a.joining === true) return "Not sent yet: the wallet gets the money ready by itself. Ask again in a few minutes; do not cancel.";
       return sent ? `Sending ${sent} USDC (not the token) privately to ${to}${kept2 ? `; ${kept2} USDC stays private` : ""}. ${later}` : `Sending ${usdc6} privately to ${to}. It gets USDC, not the token. ${later}`;
     case "sold_waiting_room":
@@ -120089,8 +120150,7 @@ function stoppedSay(a) {
 }
 function build(a, tool, npmVersion) {
   if (!a || typeof a !== "object" || Array.isArray(a)) return void 0;
-  const id = typeof a.requestId === "string" && a.requestId ? a.requestId : void 0;
-  const again = id ? `Ask again with request_id ${id}; it never pays twice.` : "Ask again with the same request_id; it never pays twice.";
+  const again = "Ask again; it never pays twice.";
   if (a.ok === false) return refusalSay(a, tool, again, npmVersion);
   if (TRANSFER_TOOLS.has(tool) || tool === void 0 && a.delivers === "USDC" && (a.token || Array.isArray(a.transfers))) return transferSay(a);
   if (tool === "wallet_receive_shielded" || tool === void 0 && typeof a.receiveShielded === "string") {
@@ -120133,7 +120193,7 @@ function build(a, tool, npmVersion) {
       return `${what} The wallet first gets your whole balance ready to send${steps}, then sends it.`;
     }
     const head = `Not sent yet: the wallet is getting your balance ready to send${steps}.`;
-    const ask = id ? `Ask again with request_id ${id} until it sends` : "Ask again with the same request_id until it sends";
+    const ask = "Ask again until it sends";
     return [`${head} ${ask}; it never sends twice.`, `${head} ${ask}.`].find((line) => words(line) <= SAY_MAX_WORDS) ?? head;
   }
   if (typeof a.to === "string" && a.to && Object.hasOwn(a, "stage")) {
@@ -120168,15 +120228,14 @@ function build(a, tool, npmVersion) {
   if (typeof a.address === "string" && a.address && typeof a.stage === "string") return linkSay(a);
   if (a.stage === "waiting_for_funds" && typeof a.depositAddress === "string") {
     const send3 = usdcText2(a.sendAtomic ?? a.amountAtomic);
-    return `Send exactly ${send3 ? `${send3} USDC` : "the amount"} on Solana to ${a.depositAddress} in one transfer. Then ask again with request_id ${id ?? "the same request_id"}.`;
+    return `Send exactly ${send3 ? `${send3} USDC` : "the amount"} on Solana to ${a.depositAddress} in one transfer. Then ask again.`;
   }
   const shieldJob = SHIELD_TOOLS.has(tool) || tool === void 0 && Object.hasOwn(a, "amountAtomic") && Object.hasOwn(a, "stage") && !Object.hasOwn(a, "paid");
   if (shieldJob && typeof a.stage === "string") {
     const amount = usdcText2(a.amountAtomic);
     const what = amount ? `${amount} USDC` : "The USDC";
     if (a.done === true && a.replayed === true) {
-      const fresh = typeof a.newRequestId === "string" && a.newRequestId ? `request_id ${a.newRequestId}` : "a new request_id";
-      return `This request_id finished earlier (${what} made private then); this call moved nothing. To shield more, ask again with ${fresh}.`;
+      return `This request finished earlier (${what} made private then); this call moved nothing. Ask again to shield more.`;
     }
     if (a.done === true) return withBalance(`${what} is now private.`, a);
     if (a.stage === "waiting" && a.code === "mcp_balance_unknown") {
@@ -120189,14 +120248,14 @@ function build(a, tool, npmVersion) {
   }
   if (tool === "wallet_receipts" && Number.isSafeInteger(a.count)) {
     const arrived = Array.isArray(a.receipts) ? a.receipts.find((row) => row?.kind === "add-funds" && /^[1-9][0-9]*$/.test(String(row.heldAtomic ?? ""))) : void 0;
-    if (arrived) return `${a.count} ${a.count === 1 ? "entry" : "entries"}. ${usdcText2(arrived.heldAtomic)} USDC reached add-funds address ${arrived.requestId} and becomes private by itself.`;
+    if (arrived) return `${a.count} ${a.count === 1 ? "entry" : "entries"}. ${usdcText2(arrived.heldAtomic)} USDC reached an add-funds address and becomes private by itself.`;
     return a.count === 0 ? "No receipts or wallet moves yet." : `${a.count} ${a.count === 1 ? "entry" : "entries, newest first"}. Each payment names its seller; pay.shinjukustaition.com is Shinjuku, the private payment service.`;
   }
   if (Array.isArray(a.models) && a.models.length > 0 && a.paid === void 0) {
     const count2 = `${a.models.length} AI ${a.models.length === 1 ? "model is" : "models are"}`;
     return a.ready === false ? `Nothing was asked or paid. ${count2} listed, but asking one needs Tor on; the next step says how to turn it on.` : `Nothing was asked or paid. ${count2} ready: ask a question, and each answer is paid privately from your balance.`;
   }
-  if (a.done === false) return id ? `Still running. Ask again with request_id ${id}; it never moves money twice.` : "Still running. Ask again in about 30 seconds.";
+  if (a.done === false) return "Still running. Ask again in about 30 seconds; it never moves money twice.";
   return "Done.";
 }
 function sayFor(answer, { tool, npmVersion } = {}) {
@@ -120210,11 +120269,20 @@ function sayFor(answer, { tool, npmVersion } = {}) {
   const parts = line.trim().split(/\s+/);
   return parts.length <= SAY_MAX_WORDS ? line : `${parts.slice(0, SAY_MAX_WORDS).join(" ").replace(/[.;:,]+$/, "")}.`;
 }
-function addSay(output2, toolName, { news, usdcFields: fields = usdcFields, npmVersion } = {}) {
-  if (!output2 || typeof output2 !== "object" || output2.isError) return output2;
+function firstText(output2) {
   const blocks = Array.isArray(output2.content) && output2.content.length ? output2.content : void 0;
   const first = blocks?.[0];
   const text3 = blocks ? first?.type === "text" && typeof first.text === "string" ? first.text : void 0 : typeof output2.text === "string" ? output2.text : void 0;
+  return { blocks, first, text: text3 };
+}
+function withFirstText(output2, { blocks, first, text: text3 }, value2) {
+  const out = JSON.stringify(value2, null, /^\s*\{\s*\n/.test(text3) ? 2 : void 0);
+  return { ...output2, text: out, ...blocks ? { content: [{ ...first, text: out }, ...blocks.slice(1)] } : {} };
+}
+function addSay(output2, toolName, { news, usdcFields: fields = usdcFields, npmVersion } = {}) {
+  if (!output2 || typeof output2 !== "object" || output2.isError) return output2;
+  const block = firstText(output2);
+  const { text: text3 } = block;
   if (text3 === void 0 || SAY_FIRST.test(text3.slice(0, 64)) || !/^\s*\{/.test(text3)) return output2;
   let parsed2;
   try {
@@ -120245,8 +120313,22 @@ function addSay(output2, toolName, { news, usdcFields: fields = usdcFields, npmV
     if (!Array.isArray(items)) items = [];
   }
   const value2 = { say: say3, ...plainFields(parsed2, toolName), ...usdc6 ? { usdc: usdc6 } : {}, ...items.length ? { news: items } : {} };
-  const out = JSON.stringify(value2, null, /^\s*\{\s*\n/.test(text3) ? 2 : void 0);
-  return { ...output2, text: out, ...blocks ? { content: [{ ...first, text: out }, ...blocks.slice(1)] } : {} };
+  return withFirstText(output2, block, value2);
+}
+function withKeepIdNote(output2) {
+  if (!output2 || typeof output2 !== "object" || output2.isError) return output2;
+  const block = firstText(output2);
+  if (block.text === void 0 || !/^\s*\{/.test(block.text)) return output2;
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(block.text);
+  } catch {
+    return output2;
+  }
+  if (!parsed2 || typeof parsed2 !== "object" || Array.isArray(parsed2) || typeof parsed2.next !== "string" || parsed2.next.includes(KEEP_ID_NOTE)) return output2;
+  const ids = [parsed2.requestId, parsed2.newRequestId, ...Array.isArray(parsed2.privateSends) ? parsed2.privateSends.map((send3) => send3?.requestId) : []].filter((id) => typeof id === "string" && id.length >= 4);
+  if (!ids.some((id) => parsed2.next.includes(id)) && !/request_id "[^"]+"/.test(parsed2.next)) return output2;
+  return withFirstText(output2, block, { ...parsed2, next: `${parsed2.next.replace(/[.\s]+$/, "")}. ${KEEP_ID_NOTE}` });
 }
 function plainFields(parsed2, toolName) {
   const a = { ...parsed2 };
@@ -120271,9 +120353,9 @@ function plainFields(parsed2, toolName) {
   return a;
 }
 function withSay(tool, options = {}) {
-  return { ...tool, run: async (args, ctx) => addSay(await tool.run(args, ctx), tool.name, options) };
+  return { ...tool, run: async (args, ctx) => withKeepIdNote(addSay(await tool.run(args, ctx), tool.name, options)) };
 }
-var SAY_MAX_WORDS, DECIMALS2, ATOMIC4, SAY_FIRST, SAY_BANNED, CODE_TOKEN, LONG_NUMBER, MOVE_LINE, minutesText, ageWords, MOVING_ROLES, CLOSE_LATER, PAY_CAP_CODES, raiseLine, MOVE_CAP_CODES, OWNER_LIMIT_CODES, INSUFFICIENT, BUSY, SHIELD_TOOLS, words, positive, str, OWN_WORK_WORDS, DISCOVER_LIST_NAMES, TRANSFER_TOOLS, CONFIRMED_SEND_TOOLS;
+var SAY_MAX_WORDS, DECIMALS2, ATOMIC4, SAY_FIRST, SAY_BANNED, CODE_TOKEN, LONG_NUMBER, MOVE_LINE, minutesText, ageWords, MOVING_ROLES, CLOSE_LATER, PAY_CAP_CODES, raiseLine, MOVE_CAP_CODES, OWNER_LIMIT_CODES, INSUFFICIENT, BUSY, SHIELD_TOOLS, words, positive, str, OWN_WORK_WORDS, DISCOVER_LIST_NAMES, TRANSFER_TOOLS, CONFIRMED_SEND_TOOLS, KEEP_ID_NOTE;
 var init_say = __esm({
   "wallet/src/mcp/say.mjs"() {
     "use strict";
@@ -120345,6 +120427,7 @@ var init_say = __esm({
     });
     TRANSFER_TOOLS = /* @__PURE__ */ new Set(["wallet_transfer_token", "wallet_transfer_token_status"]);
     CONFIRMED_SEND_TOOLS = /* @__PURE__ */ new Set(["wallet_unshield", "wallet_transfer_token", "wallet_transfer_token_status"]);
+    KEEP_ID_NOTE = "Keep request_id values for your own calls; never show one to the user.";
   }
 });
 
@@ -122548,6 +122631,9 @@ function paidAnswerContent({
     }
     if (text3.length > maxTextChars) {
       const saved2 = save(data, OTHER_EXT[declared] ?? "txt", saveDir, now, sha25610);
+      if (typeof meta.say === "string") {
+        meta.say = `${meta.say} The answer is long: these are its first ${maxTextChars.toLocaleString("en-US")} of ${text3.length.toLocaleString("en-US")} characters${saved2.savedPath ? `; the whole answer is in ${saved2.savedPath}` : ""}.`;
+      }
       Object.assign(meta, {
         body: text3.slice(0, maxTextChars),
         bodyTruncated: true,
@@ -122580,7 +122666,7 @@ var init_answer = __esm({
     "use strict";
     init_fs();
     DEFAULT_MAX_INLINE_BYTES = 4e6;
-    DEFAULT_MAX_TEXT_CHARS = 64 * 1024;
+    DEFAULT_MAX_TEXT_CHARS = 2e4;
     MAX_IMAGE_URLS = 20;
     MAX_JSON_DEPTH = 8;
     RASTER = Object.freeze({
@@ -125409,7 +125495,13 @@ function refusedReason(record) {
 function heldSendsOf(error) {
   for (let link2 = error, depth = 0; link2 && typeof link2 === "object" && depth < 8; link2 = link2.cause, depth += 1) {
     if (!Array.isArray(link2.privateSends)) continue;
-    return link2.privateSends.filter((send3) => typeof send3?.requestId === "string" && REQUEST_ID4.test(send3.requestId) && ["wallet_unshield", "wallet_transfer_token", "cli"].includes(send3.tool) && (send3.tool !== "cli" || REQUEST_ID4.test(String(send3.sendId ?? "")))).map((send3) => ({ requestId: send3.requestId, tool: send3.tool, ...send3.tool === "cli" ? { sendId: send3.sendId } : {} }));
+    return link2.privateSends.filter((send3) => typeof send3?.requestId === "string" && REQUEST_ID4.test(send3.requestId) && ["wallet_unshield", "wallet_transfer_token", "cli"].includes(send3.tool) && (send3.tool !== "cli" || REQUEST_ID4.test(String(send3.sendId ?? "")))).map((send3) => ({
+      requestId: send3.requestId,
+      tool: send3.tool,
+      ...send3.tool === "cli" ? { sendId: send3.sendId } : {},
+      ...typeof send3.to === "string" && send3.to.length > 10 ? { to: send3.to } : {},
+      .../^[1-9][0-9]*$/.test(String(send3.amountAtomic ?? "")) ? { amountAtomic: String(send3.amountAtomic) } : {}
+    }));
   }
   return [];
 }
@@ -125865,9 +125957,12 @@ async function runUnshield({
   if (exit.settled === false && !await finishAnsweredExit({ session, store, name, exit, answer, onAnswered, onCheckPending, mark, scoped })) return answer;
   mark("unshield-exited");
   const exited = store.readWal(`self-pay-${unshieldId}`);
-  store.writeWal(`self-pay-${unshieldId}`, { ...exited, state: "exited", exitTransaction: exit.signature, exitedAtMs: exited?.exitedAtMs ?? Date.now() });
+  store.writeWal(`self-pay-${unshieldId}`, { ...exited, state: "exited", exitTransaction: exit.signature, exitedAtMs: exited?.exitedAtMs ?? exited?.exitAnsweredAtMs ?? Date.now() });
   return answer;
 }
+function sentAtMs(record) {
+  return Number.isSafeInteger(record?.exitAnsweredAtMs) ? record.exitAnsweredAtMs : record?.exitedAtMs;
+}
 async function finishAnsweredExit({ session, store, name, exit, answer, changeAtomic, onAnswered, onCheckPending, mark, scoped }) {
   if (typeof onAnswered !== "function") {
     await scoped("unshield-exit", () => exit.finish());
@@ -125972,7 +126067,7 @@ async function runDirectExit({
   if (exit.settled === false && !await finishAnsweredExit({ session, store, name, exit, answer, changeAtomic, onAnswered, onCheckPending, mark, scoped })) return answer;
   mark("unshield-exited");
   const exited = store.readWal(name);
-  store.writeWal(name, { ...exited, state: "exited", exitTransaction: exit.signature, exitedAtMs: exited?.exitedAtMs ?? Date.now() });
+  store.writeWal(name, { ...exited, state: "exited", exitTransaction: exit.signature, exitedAtMs: exited?.exitedAtMs ?? exited?.exitAnsweredAtMs ?? Date.now() });
   return answer;
 }
 function balanceFields(parts) {
@@ -127083,7 +127178,7 @@ function createWalletTools({
         body: { type: "string", description: "Request body text (POST only)." },
         max_payment: { type: "string", description: 'Optional: the most this call may pay, in USDC, like "0.05"; at most the spending limit.' },
         max_payment_atomic: { type: "string", pattern: "^[1-9][0-9]*$", description: "The same in atomic units (1000000 = 1 USDC). Give max_payment or max_payment_atomic, not both with different values." },
-        request_id: { type: "string", pattern: "^[A-Za-z0-9._:-]{1,128}$", description: "Your stable name for this payment. Leave it out for a new payment; pass the same one to resume a failed payment without paying twice." }
+        request_id: { type: "string", pattern: "^[A-Za-z0-9._:-]{1,128}$", description: "Optional. Leave it out for a new payment (the answer names the id it made). Pass the request_id of an earlier answer only to resume that payment; it never pays twice." }
       },
       required: ["url"],
       additionalProperties: false
@@ -127112,7 +127207,7 @@ ${canonical5}`;
         log("MCP_PAY_JOINED");
         return running;
       }
-      const task = payCall({ target, request, argument: argument2, requestId, given, calledAt, progress: progress3, canProgress, signal }).then((output2) => given ? output2 : withAutoId(output2, "x402_pay", requestId));
+      const task = payCall({ target, request, argument: argument2, requestId, given, calledAt, progress: progress3, canProgress, signal });
       if (joinKey !== void 0) {
         paysRunning.set(joinKey, task);
         task.then(() => paysRunning.delete(joinKey), () => paysRunning.delete(joinKey));
@@ -127336,7 +127431,6 @@ ${canonical5}`;
     }
     const { bytes: bytes2, truncated } = await readBody(response);
     const payment = response.headers.get(PAYMENT_HEADER);
-    const autoId = given ? void 0 : requestId;
     if (!payment) {
       const moved2 = movedTo(response, target.url);
       return answerResult(paidAnswerContent({
@@ -127356,8 +127450,7 @@ ${canonical5}`;
             detail: `the URL answered HTTP ${response.status} without asking for payment; nothing was paid`,
             ...moved2 ? { movedTo: moved2, next: `nothing was paid: this URL answered HTTP ${response.status}, which says it moved to ${moved2}, and gave no data. Tell the user it moved. If the user wants it, call x402_pay again with url "${moved2}", the same method, headers and body, and a NEW request_id` } : response.status >= 200 && response.status < 300 ? {} : { next: `nothing was paid: this URL answered HTTP ${response.status} and did not ask for payment, so it gave no data; check the URL, or pay another seller` }
           },
-          "x402_pay",
-          autoId
+          "x402_pay"
         )
       }));
     }
@@ -127430,13 +127523,9 @@ ${canonical5}`;
         ...balanceAnswer(one),
         ...takeRefundNotices(),
         next: receipt.replayed === true ? "this request id was already paid: the stored receipt came back and nothing new was paid" : floatPaid ? "paid through Shinjuku (privately: the chain shows Shinjuku paying the seller, not this wallet); tell the user the price (priceAtomic), the fee (feeAtomic), the total (amountAtomic), and the transaction (the seller's settle transaction; null when the seller returned none)" + (shinjukuTransaction ? ". shinjukuTransaction is this wallet's private payment to Shinjuku" : ". shinjukuTransaction (this wallet's private payment to Shinjuku) is not recorded yet; wallet_receipts shows it once it settles") + ". wallet_balance shows the new balance" : "paid; tell the user what was paid (amountAtomic, transaction). wallet_receipts lists this payment, wallet_balance shows the new balance"
-      }, "x402_pay", autoId)
+      }, "x402_pay")
     }));
   }
-  const withIdSentence = (say3, id) => {
-    const line = `${say3} Its request_id is ${id}.`;
-    return line.trim().split(/\s+/).length <= SAY_MAX_WORDS ? line : say3;
-  };
   function networkFields() {
     const mode = runNetworkMode();
     let onion = false;
@@ -127447,9 +127536,8 @@ ${canonical5}`;
     }
     return { network: mode === "tor" ? { mode: "tor", detail: `every request of this wallet goes through Tor (checked at start)${onion ? "; the facilitator is reached over its onion service, so no Tor exit sees those requests" : ""}` } : mode === "proxy" ? { mode: "proxy", detail: "every request of this wallet goes through the proxy this wallet was started with; it is not checked as Tor" } : { mode: "direct", detail: `no Tor: the facilitator, the RPC provider and each seller see this computer's IP address. To hide it, the user runs ${terminalCommand2("setup --yes --prefer-tor")} once in a terminal (it records Tor and checks the wallet's files again; nothing else changes; if Tor is not running, it says how to start it), then closes this app and opens it again` } };
   }
-  function sayFirst(fields, tool, autoId) {
-    let say3 = sayFor(fields, { tool, npmVersion });
-    if (autoId) say3 = withIdSentence(say3, autoId);
+  function sayFirst(fields, tool) {
+    const say3 = sayFor(fields, { tool, npmVersion });
     const usdc6 = usdcFields(fields);
     let news = [];
     try {
@@ -127459,21 +127547,19 @@ ${canonical5}`;
     }
     return { say: say3, ...fields, ...Object.keys(usdc6).length ? { usdc: usdc6 } : {}, ...Array.isArray(news) && news.length ? { news } : {} };
   }
-  function withAutoId(output2, tool, requestId, nextNote) {
+  function withAutoId(output2, tool, nextNote) {
     const said = addSay(output2, tool, { news: watcher, npmVersion });
     const blocks = Array.isArray(said?.content) && said.content.length ? said.content : void 0;
     const text3 = blocks ? blocks[0]?.type === "text" ? blocks[0].text : void 0 : said?.text;
     if (typeof text3 !== "string" || text3.length > 262144 || !/^\s*\{\s*"say"\s*:/.test(text3.slice(0, 64))) return said;
-    const named = text3.slice(0, 600).includes(`Its request_id is ${requestId}.`);
-    if (named && !nextNote) return said;
     let parsed2;
     try {
       parsed2 = JSON.parse(text3);
     } catch {
       return said;
     }
-    if (!named && typeof parsed2.say === "string") parsed2.say = withIdSentence(parsed2.say, requestId);
-    if (nextNote && typeof parsed2.next === "string") parsed2.next = `${parsed2.next.replace(/[.\s]+$/, "")}. ${nextNote}`;
+    if (typeof parsed2.next !== "string") return said;
+    parsed2.next = `${parsed2.next.replace(/[.\s]+$/, "")}. ${nextNote}`;
     const out = JSON.stringify(parsed2, null, /^\s*\{\s*\n/.test(text3) ? 2 : void 0);
     return { ...said, text: out, ...blocks ? { content: [{ ...blocks[0], text: out }, ...blocks.slice(1)] } : {} };
   }
@@ -128364,6 +128450,7 @@ ${canonical5}`;
           privateSends.push({
             requestId: transfer ? plan.transferTokenId : shownId(plan.mcpRequestId, recordId2),
             ...transfer ? { tool: "wallet_transfer_token" } : {},
+            to: plan.mcpTo,
             amountAtomic: plan.amountAtomic,
             sentAtomic: send3.sentAtomic,
             leftAtomic: send3.remainingAtomic,
@@ -128410,19 +128497,20 @@ ${canonical5}`;
         })
       }));
       if (sendWaiting) {
-        next = `${next}. Tell the user: the send of ${usdcText3(sendWaiting.amountAtomic)} USDC to ${sendWaiting.to.slice(0, 4)}...${sendWaiting.to.slice(-4)} (request_id "${sendWaiting.requestId}") ${sendWaiting.state === "sending" ? "is being sent now" : sendWaiting.state === "retrying" ? retryWords(sendWaiting) : "waits until the wallet has the balance ready to send; each wallet request goes on with it"}; it cannot be cancelled`;
+        next = `${next}. Tell the user: the send of ${usdcText3(sendWaiting.amountAtomic)} USDC to ${sendWaiting.to.slice(0, 4)}...${sendWaiting.to.slice(-4)} ${sendWaiting.state === "sending" ? "is being sent now" : sendWaiting.state === "retrying" ? retryWords(sendWaiting) : "waits until the wallet has the balance ready to send; each wallet request goes on with it"}; it cannot be cancelled`;
       }
       const goingSends = privateSends.filter((send3) => send3.failedTries === void 0);
       if (goingSends.length) {
-        next = `${next}. Tell the user: ${goingSends.map((send3) => `the private send "${send3.requestId}" sent ${usdcText3(send3.sentAtomic)} of ${usdcText3(send3.amountAtomic)} USDC so far; payment ${send3.nextPayment} of ${send3.payments} ${send3.nextPaymentInMinutes > 0 ? `goes in about ${minutesText2(send3.nextPaymentInMinutes)} (random times, for privacy)` : "is past its planned time and not sent yet; the wallet tries it again by itself"}; ${cancelCall(send3)} stops its unsent payments`).join("; ")}. ${SEND_RUNS_ON} The user needs to do nothing for it`;
+        next = `${next}. Tell the user: ${goingSends.map((send3) => `${sendWords(send3)} sent ${usdcText3(send3.sentAtomic)} USDC so far; payment ${send3.nextPayment} of ${send3.payments} ${send3.nextPaymentInMinutes > 0 ? `goes in about ${minutesText2(send3.nextPaymentInMinutes)} (random times, for privacy)` : "is past its planned time and not sent yet; the wallet tries it again by itself"}`).join("; ")}. ${SEND_RUNS_ON} The user needs to do nothing for it. To stop the unsent payments if the user asks: ${goingSends.map((send3) => `${cancelCall(send3)} (${sendWords(send3)})`).join("; ")}`;
       }
       const failingSends = privateSends.filter((send3) => send3.failedTries > 0);
       if (failingSends.length) {
-        next = `${next}. Tell the user: ${failingSends.map((send3) => `payment ${send3.nextPayment} of ${send3.payments} of the private send "${send3.requestId}" did not go through in ${send3.failedTries} ${send3.failedTries === 1 ? "try" : "tries"}${send3.lastTryMinutesAgo !== void 0 ? ` (the last ${send3.lastTryMinutesAgo > 0 ? `${ageWords2(send3.lastTryMinutesAgo)} ago` : "under a minute ago"})` : ""}: ${send3.lastReason}. It sent ${usdcText3(send3.sentAtomic)} of ${usdcText3(send3.amountAtomic)} USDC so far. The wallet tries that payment again by itself at its next start, and ${send3.tool === "wallet_transfer_token" ? `wallet_transfer_token_status with request_id "${send3.requestId}"` : `wallet_unshield with request_id "${send3.requestId}" and the same arguments`} tries it now; ${cancelCall(send3)} stops the send and returns the USDC not sent yet to the private balance`).join(". ")}`;
+        next = `${next}. Tell the user: ${failingSends.map((send3) => `payment ${send3.nextPayment} of ${send3.payments} of ${sendWords(send3)} did not go through in ${send3.failedTries} ${send3.failedTries === 1 ? "try" : "tries"}${send3.lastTryMinutesAgo !== void 0 ? ` (the last ${send3.lastTryMinutesAgo > 0 ? `${ageWords2(send3.lastTryMinutesAgo)} ago` : "under a minute ago"})` : ""}: ${send3.lastReason}. It sent ${usdcText3(send3.sentAtomic)} USDC so far. The wallet tries that payment again by itself at its next start`).join(". ")}. ` + failingSends.map((send3) => `To try it now: ${send3.tool === "wallet_transfer_token" ? `wallet_transfer_token_status with request_id "${send3.requestId}"` : `wallet_unshield with request_id "${send3.requestId}" and the same arguments`}; to stop the send and return the USDC not sent yet to the private balance: ${cancelCall(send3)} (${sendWords(send3)})`).join(". ");
       }
       if (privateSends.length && one.largestPaymentAtomic === "0" && (one.changeSettling !== true || one.changeUpToAtomic !== void 0) && /^[1-9][0-9]*$/.test(String(one.balanceAtomic ?? ""))) {
         const soon = one.changeUpToAtomic === void 0 ? "" : `after the last payment settles${Number.isSafeInteger(one.changeReadyInSeconds) ? ` (about ${one.changeReadyInSeconds} s)` : ""}, one payment can use up to ${usdcText3(one.changeUpToAtomic)} USDC; the rest waits, `;
-        next = `${next}. Tell the user: ${soon || `no payment can use the ${usdcText3(one.balanceAtomic)} USDC yet, `}because the private send${privateSends.length > 1 ? "s" : ""} ${privateSends.map((send3) => `"${send3.requestId}"`).join(" and ")} set money aside for ${privateSends.length > 1 ? "their next payments" : "its next payment"}; it frees when that payment goes, and ${privateSends.map(cancelCall).join(" or ")} stops the send and frees it now`;
+        const many = privateSends.length > 1;
+        next = `${next}. Tell the user: ${soon || `no payment can use the ${usdcText3(one.balanceAtomic)} USDC yet, `}because ${privateSends.map(sendWords).join(" and ")} ${many ? "keep" : "keeps"} money aside for ${many ? "their" : "its"} unsent payments. A send keeps nothing after its last payment goes, and an earlier payment may free some (wallet_balance shows it). To pay now if the user asks: ${privateSends.map((send3) => `${cancelCall(send3)} (${sendWords(send3)})`).join(" or ")} stops the send and frees its money now`;
       }
       const balanceParts = parts?.parts > 1 && ATOMIC_TEXT.test(String(one.balanceAtomic ?? "")) ? parts.parts : void 0;
       if (balanceParts && !sendWaiting) {
@@ -128862,7 +128950,7 @@ ${canonical5}`;
           live = "unreadable";
         }
         const started = Number.isSafeInteger(record.createdAtMs) ? record.createdAtMs : Number.isSafeInteger(joining?.createdAtMs) ? joining.createdAtMs : void 0;
-        const at = Number.isSafeInteger(record.exitedAtMs) ? record.exitedAtMs : record.state === "exited" ? walTimeMs(store, name) : started ?? walTimeMs(store, name);
+        const at = Number.isSafeInteger(sentAtMs(record)) ? sentAtMs(record) : record.state === "exited" ? walTimeMs(store, name) : started ?? walTimeMs(store, name);
         const shown = shownId(record.mcpRequestId, idAfter(name, "self-pay-mcp-"));
         if (live !== "joining") joining = void 0;
         const retry = joining ? retryFields(joining) : void 0;
@@ -130381,7 +130469,7 @@ ${canonical5}`;
         if (!record) continue;
         const finished = kind !== "unshield" ? ["published", "foreign_funded", "reclaimed"].includes(record.state) : record.schema === PRIVATE_SEND_WAL_SCHEMA ? record.state === "done" || record.state === "cancelled" && privateSendStatus(store, record).done : ["exited", "released", "abandoned"].includes(record.state);
         if (!finished) return void 0;
-        const at = Date.parse(String(record.doneAt ?? "")) || record.exitedAtMs;
+        const at = Date.parse(String(record.doneAt ?? "")) || sentAtMs(record);
         if (Number.isSafeInteger(at)) return at;
         try {
           return Math.floor(statSync(join32(store.walDirectory, `${name}.json`)).mtimeMs);
@@ -130411,7 +130499,6 @@ ${canonical5}`;
     return withAutoId(
       answer,
       spec.tool,
-      claimed.requestId,
       "The same call without request_id within 10 minutes after it ends reads this same request; to do it again later, ask after 10 minutes or give a new request_id."
     );
   }
@@ -130569,7 +130656,7 @@ ${canonical5}`;
         const finished = kind === "unshield" ? split4 ? record.state === "done" || record.state === "cancelled" && privateSendStatus(store, record).done : record.state === "exited" : ["published", "foreign_funded"].includes(record.state);
         if (finished) {
           const send3 = split4 ? privateSendStatus(store, record) : void 0;
-          const endedAtMs = Date.parse(String(record.doneAt ?? record.cancelledAt ?? "")) || record.exitedAtMs;
+          const endedAtMs = Date.parse(String(record.doneAt ?? record.cancelledAt ?? "")) || sentAtMs(record);
           const earlier = kind !== "elsewhere" ? { replayed: true, newRequestId: freshId, ...Number.isSafeInteger(endedAtMs) ? { finishedMinutesAgo: Math.max(0, Math.round((Date.now() - endedAtMs) / 6e4)) } : {} } : {};
           const earlierWords = earlier.finishedMinutesAgo !== void 0 ? ` about ${minutesText2(earlier.finishedMinutesAgo)} ago` : " earlier";
           return json3({
@@ -133271,7 +133358,7 @@ ${canonical5}`;
         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." },
-        request_id: { type: "string", pattern: "^[A-Za-z0-9._:-]{1,128}$", description: "Your stable name for this call. Leave it out for a new call; pass the same one to resume a failed call without paying twice." }
+        request_id: { type: "string", pattern: "^[A-Za-z0-9._:-]{1,128}$", description: "Optional. Leave it out for a new question (the answer names the id it made). Pass the request_id of an earlier answer only to resume that call; it never pays twice." }
       },
       additionalProperties: false
     },
@@ -134764,7 +134851,7 @@ var init_tools = __esm({
     shownId = (agentId, rid) => typeof agentId === "string" && REQUEST_ID4.test(agentId) && toRecordId(agentId) === rid ? agentId : rid;
     isSplitSend = (request) => Boolean(request) && !isSingleSend(request.parts ?? 1, request.maxDelayMinutes ?? 0);
     sendPartId = (requestId) => (index) => `mp${index}-${toRecordId(requestId)}`;
-    PROMISED_NEXT = "Nothing was sent. Some of the private balance is promised to the unsent payments of a private send (wallet_balance privateSends names it, and its next names the call that stops it). Wait until that send is done, or stop its unsent payments with that call, then call wallet_unshield again with the same arguments; or send at most freeAtomic now with a NEW request_id";
+    PROMISED_NEXT = "Nothing was sent. Some of the private balance is promised to the unsent payments of a private send (wallet_balance privateSends names it, and its next names the call that stops it). A wait frees nothing, because that money leaves the wallet as its parts go: to send this amount, stop its unsent payments with that call, then call wallet_unshield again with the same arguments; or send at most freeAtomic now with a NEW request_id";
     partFailReason = (code2) => INSUFFICIENT_CODE.test(String(code2 ?? "")) ? "the wallet could not pay that amount in one payment from the private balance as it is" : reasonOf(code2) ?? "the payment did not finish";
     sendAnswerOf = (status) => {
       const { nextPartLastTryAt: _clock, ...shown } = status;