shinjuku-shield 0.3.112 → 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.112. 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.112
+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.112 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.112 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.112", "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": "1406c0d44399772d43e33dc6b4cfb7428f9f24215e13389ac46f5dd6dc28d224",
-  "bytes": 8331849,
-  "sourceCommit": "c46e085c7ef73488d9a62c58b19f13891a4724b5",
+  "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-27T15:32:15.515Z"
+  "publishedAt": "2026-10-27T16:17:32.089Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shield",
-  "version": "0.3.112",
+  "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": "1406c0d4",
-  "shinjukuSha256": "1406c0d44399772d43e33dc6b4cfb7428f9f24215e13389ac46f5dd6dc28d224",
+  "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;
 }
@@ -119528,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;
@@ -119987,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);
@@ -120208,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 {
@@ -120243,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 };
@@ -120269,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";
@@ -120343,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.";
   }
 });
 
@@ -122546,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,
@@ -122578,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({
@@ -125407,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 [];
 }
@@ -125863,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());
@@ -125970,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) {
@@ -128400,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) {
@@ -128852,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;
@@ -130371,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);
@@ -130558,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({
@@ -134753,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;