shinjuku-shield 0.3.113 → 0.3.115

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.113. The npm packages `shinjuku-shield` and
+This is version 0.3.115. 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.113
+npm install -g shinjuku@0.3.115
 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.113 setup`.
+installing, type `npx shinjuku@0.3.115 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.113 mcp
+claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.115 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.113", "mcp"] } } }
+{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.115", "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": "bfaedd12d120b4b5421cdf6c9c06b07b7e338fd6d4e74b7225f2a0d3aa150cf4",
-  "bytes": 8339853,
-  "sourceCommit": "0c37c0dea055d3c28bab9939cd5527fc290668f8",
+  "sha256": "148b3f5279bf4b0914aa076c617b9fd51956480a57058dfee4492c208fd72e7a",
+  "bytes": 8348544,
+  "sourceCommit": "8b4f9050d3ae61ecdd0082ee931761cc2b812f62",
   "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-27T16:17:32.089Z"
+  "publishedAt": "2026-10-27T18:51:07.036Z"
 }

package/package.json

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

package/shinjuku-wallet.mjs

@@ -67216,7 +67216,7 @@ var init_errorCodes = __esm({
       "float_paid_finishing",
       "refund_pending",
       // Float record field values, not errors (floatPay.mjs): broadcastRefusal "answer_invalid" (leg 1's answer could not be
-      // used) and the refund outcomes returnArrivedFloatRefundBudgets writes and takeFloatRefundOutcomes returns.
+      // used) and the refund outcomes returnArrivedFloatRefundBudgets writes and readFloatRefundOutcomes returns.
       "answer_invalid",
       "refund_arrived",
       "refund_not_seen",
@@ -102584,7 +102584,14 @@ function returnArrivedFloatRefundBudgets(store, snapshot) {
     }
   }
 }
-function takeFloatRefundOutcomes(store) {
+function floatSellerHost(record) {
+  try {
+    return new URL(String(record?.url)).hostname || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readFloatRefundOutcomes(store) {
   const outcomes = [];
   let names;
   try {
@@ -102598,13 +102605,32 @@ function takeFloatRefundOutcomes(store) {
       const record = store.readWal(name);
       if (record?.schema !== FLOAT_PAYMENT_SCHEMA2 || floatRecordState(record) !== "refund_pending") continue;
       if (record.refundOutcome === void 0 || record.refundOutcomeShown !== false) continue;
-      store.writeWal(name, { ...record, refundOutcomeShown: true });
-      outcomes.push({ floatId: record.floatId, paidAtomic: record.paidAtomic, outcome: record.refundOutcome, atMs: record.refundOutcomeAtMs });
+      outcomes.push({ floatId: record.floatId, paidAtomic: record.paidAtomic, host: floatSellerHost(record), outcome: record.refundOutcome, atMs: record.refundOutcomeAtMs });
     } catch {
     }
   }
   return outcomes;
 }
+function markFloatRefundOutcomesShown(store, shown) {
+  const wanted = new Map(shown.map(({ floatId, outcome }) => [floatId, outcome]));
+  if (!wanted.size) return;
+  let names;
+  try {
+    names = store.listWal();
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (!name.startsWith(FLOAT_PAYMENT_WAL_PREFIX)) continue;
+    try {
+      const record = store.readWal(name);
+      if (record?.schema !== FLOAT_PAYMENT_SCHEMA2 || record.refundOutcomeShown !== false) continue;
+      if (!wanted.has(record.floatId) || wanted.get(record.floatId) !== record.refundOutcome) continue;
+      store.writeWal(name, { ...record, refundOutcomeShown: true });
+    } catch {
+    }
+  }
+}
 function dropOldMemoryAnswers(now) {
   for (const [key, entry] of memoryAnswers) if (now >= entry.atMs + FLOAT_KEEP_BYTES_MS) memoryAnswers.delete(key);
 }
@@ -105922,8 +105948,10 @@ function fillsOnTheWayAtomic(store) {
 }
 function refundOf(record) {
   const inner = String(record.innerRequestId ?? "");
+  const seller = floatSellerHost(record);
   return {
     ...inner.endsWith(":float") ? { requestId: inner.slice(0, -":float".length) } : { floatId: record.floatId ?? null },
+    ...seller ? { seller } : {},
     refundAtomic: String(record.paidAtomic)
   };
 }
@@ -119360,7 +119388,7 @@ function withEarlyAnswer(tool, {
       if (open4) {
         log(`MCP_PAY_SECOND_REFUSED requestId=${requestId} open=${open4[0]}`);
         return { text: JSON.stringify({
-          say: `Not paid: a payment for this ${words2 === PAY_WORDS ? "URL" : "call"} is still open (request_id ${open4[0]}). Call ${tool.name} with that request_id for the result.`,
+          say: `Nothing was paid for this request: a payment for this ${words2 === PAY_WORDS ? "URL" : "call"} is still open with ${words2.who}. Do not pay again; asking for its result pays nothing more.`,
           ok: false,
           error: "mcp_payment_still_open",
           requestId,
@@ -119423,7 +119451,7 @@ function withEarlyAnswer(tool, {
     log(`MCP_PAY_EARLY_ANSWER requestId=${requestId} waited=${secondsWaited}s`);
     entry.toldWaiting = true;
     const next = `The payment was sent to ${words2.who} (price + fee left the balance), and ${words2.who} ${words2.busyNext}. Do not pay again: call ${tool.name} again with request_id "${requestId}" and ${words2.same} for the result (that call waits up to ${Math.round(earlyAnswerMs / 1e3)} s for it); it never pays twice. A new request_id for the same request is refused while this one is open. The later call's answer says how it ended: ${words2.who}'s answer, or what happened to the payment.`;
-    const say3 = sellerWorkingSeconds < JUST_REACHED_SECONDS ? `Sent to ${words2.who}; the request just reached it. Do not pay again: call ${tool.name} with request_id ${requestId} for the result.` : `Sent to ${words2.who}; it has not answered yet. Do not pay again: call ${tool.name} with request_id ${requestId} for the result.`;
+    const say3 = sellerWorkingSeconds < JUST_REACHED_SECONDS ? `Sent to ${words2.who}; the request just reached it. Do not pay again; asking for the result pays nothing more.` : `Sent to ${words2.who}; it has not answered yet. Do not pay again; asking for the result pays nothing more.`;
     return { text: JSON.stringify({ say: say3, ok: true, paid: false, pending: true, stage: "seller_working", requestId, secondsWaited, sellerWorkingSeconds, next }, null, 2) };
   } };
 }
@@ -119622,7 +119650,7 @@ function refusalSay(a, tool, again, npmVersion) {
     return `Nothing changed: this address was made for ${amount ? `${amount} USDC` : "a fixed amount"}, and its amount never changes. Read next for what to do.`;
   }
   if (code2 === "mcp_balance_unknown") return "Nothing was moved yet: the wallet is still reading its private balance. Try again in a minute.";
-  if (code2 === "mcp_payment_still_open") return "Not paid: a payment for this request is still open. Ask with its request_id for the result.";
+  if (code2 === "mcp_payment_still_open") return "Nothing was paid for this request: a payment for it is still open. Do not pay again; asking for its result pays nothing more.";
   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") {
@@ -120326,8 +120354,7 @@ function withKeepIdNote(output2) {
     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;
+  if (!/"(?:requestId|newRequestId)"\s*:\s*"[^"]{4,}"/.test(block.text) && !/request_id "[^"]+"/.test(parsed2.next)) return output2;
   return withFirstText(output2, block, { ...parsed2, next: `${parsed2.next.replace(/[.\s]+$/, "")}. ${KEEP_ID_NOTE}` });
 }
 function plainFields(parsed2, toolName) {
@@ -125398,8 +125425,9 @@ async function sellerTokenAccountExists(connection, asset, payTo) {
 }
 function refundOutcomeText(outcome) {
   const amount = ATOMIC_TEXT.test(String(outcome?.paidAtomic ?? "")) ? `${usdcText3(outcome.paidAtomic)} USDC` : "a Shinjuku payment";
-  if (outcome?.outcome === "refund_arrived") return `The refund of ${amount} arrived.`;
-  return `The refund of ${amount} could not be matched in your balance (this balance read cannot tell refunds apart); if it came back, balanceAtomic counts it already.`;
+  const payment = typeof outcome?.host === "string" && /^[a-z0-9.-]{1,253}$/i.test(outcome.host) ? ` for the payment to ${outcome.host}` : "";
+  if (outcome?.outcome === "refund_arrived") return `The refund of ${amount}${payment} arrived.`;
+  return `The refund of ${amount}${payment} could not be matched in your balance (this balance read cannot tell refunds apart); if it came back, balanceAtomic counts it already.`;
 }
 function floatRefusal(error) {
   const code2 = String(error?.message ?? "").split(/[\s:;(]/, 1)[0];
@@ -125836,9 +125864,35 @@ async function checkUnshieldRecipient({ connection, mint, owner }) {
     throw new Error("mcp_unshield_to_invalid: the USDC holder at this address is for another token or another owner, so it cannot take this payment; nothing was paid");
   }
 }
+async function walkBeforeLease(session, exitProofTools) {
+  try {
+    const store = session.openStore();
+    let marks = walletHistoryHomeMarks(store);
+    if (marks === void 0) {
+      await new Promise((resolve35) => {
+        setTimeout(resolve35, HOME_MARKS_SETTLED_MS2 + 10);
+      });
+      marks = walletHistoryHomeMarks(store);
+    }
+    if (marks === void 0) return void 0;
+    const history = await loadWalletP03History({
+      store,
+      connection: connectSplit(session.connection, session.historyUrl),
+      programId: session.programId,
+      pool: store.state.pool,
+      deploymentIdentity: exitProofTools.deploymentIdentity,
+      share: { notBeforeMs: Date.now(), marks }
+    });
+    return { marks, pool: String(store.state.pool), history };
+  } catch {
+    return void 0;
+  }
+}
 async function runUnshield({
   session,
-  store,
+  lease,
+  before = () => void 0,
+  prepare = (store) => store,
   unshieldId,
   amountAtomic,
   recipientOwner,
@@ -125848,11 +125902,13 @@ async function runUnshield({
   onStage,
   selfPayStep = selfPay,
   onAnswered,
-  onCheckPending
+  onCheckPending,
+  onExited = () => {
+  },
+  walked,
+  finalityWaits = 0
 }) {
   const owner = new import_web3132.PublicKey(recipientOwner);
-  const mint = new import_web3132.PublicKey(store.state.asset);
-  const recipient = getAssociatedTokenAddressSync(mint, owner, true, TOKEN_PROGRAM_ID);
   let timing;
   try {
     timing = typeof session.timing === "function" ? session.timing() : void 0;
@@ -125866,141 +125922,226 @@ async function runUnshield({
     }
   };
   const scoped = (prefix, fn) => phaseScopeActive() || timing === void 0 ? fn() : withPhaseScope(mark, prefix, fn);
-  const walk = (deploymentIdentity) => () => scoped("unshield-walk", () => loadWalletP03History({
-    store,
-    connection: connectSplit(session.connection, session.historyUrl),
-    programId: session.programId,
-    pool: store.state.pool,
-    deploymentIdentity
-  }));
+  let current;
+  const use = (store) => {
+    current = store;
+  };
+  let nextWalk = walked;
+  const walkNext = (report) => {
+    nextWalk = report;
+  };
+  const walk = (deploymentIdentity) => () => {
+    if (nextWalk !== void 0) {
+      const report = nextWalk;
+      nextWalk = void 0;
+      mark("unshield-walk-before-lease");
+      return Promise.resolve(report);
+    }
+    return scoped("unshield-walk", () => loadWalletP03History({
+      store: current,
+      connection: connectSplit(session.connection, session.historyUrl),
+      programId: session.programId,
+      pool: current.state.pool,
+      deploymentIdentity
+    }));
+  };
   const name = `self-pay-${unshieldId}`;
-  let record = store.readWal(name);
-  if (record && record.mode === void 0 && !selfPayMayHaveSigned(store, unshieldId)) {
-    const note = chooseDirectExitNote(store, amountAtomic, unshieldId);
-    if (note) {
-      record = {
-        ...record,
-        mode: DIRECT_EXIT_MODE,
-        noteCommitment: BigInt(note.commitment).toString(),
-        memoDigest: note.digest,
-        noteValueAtomic: String(note.valueAtomic),
-        exitAmountAtomic: String(amountAtomic),
-        exitRecipient: recipient.toBase58()
-      };
-      store.writeWal(name, record);
+  const start = await lease(async (opened) => {
+    mark("unshield-lease-self-pay");
+    const stop3 = await before(opened);
+    if (stop3 !== void 0) return { stop: stop3 };
+    const store = await prepare(opened);
+    use(store);
+    const mint = new import_web3132.PublicKey(store.state.asset);
+    const recipient = getAssociatedTokenAddressSync(mint, owner, true, TOKEN_PROGRAM_ID);
+    let record = store.readWal(name);
+    if (record && record.mode === void 0 && !selfPayMayHaveSigned(store, unshieldId)) {
+      const note = chooseDirectExitNote(store, amountAtomic, unshieldId);
+      if (note) {
+        record = {
+          ...record,
+          mode: DIRECT_EXIT_MODE,
+          noteCommitment: BigInt(note.commitment).toString(),
+          memoDigest: note.digest,
+          noteValueAtomic: String(note.valueAtomic),
+          exitAmountAtomic: String(amountAtomic),
+          exitRecipient: recipient.toBase58()
+        };
+        store.writeWal(name, record);
+      }
     }
-  }
-  if (record?.mode === DIRECT_EXIT_MODE) {
-    return runDirectExit({
-      session,
+    if (record?.mode === DIRECT_EXIT_MODE) {
+      return runDirectExit({
+        session,
+        store,
+        name,
+        pool: store.state.pool,
+        unshieldId,
+        amountAtomic,
+        record,
+        owner,
+        mint,
+        recipient,
+        exitProofTools,
+        facilitatorOrigin: facilitatorOrigin2,
+        onStage,
+        walk,
+        use,
+        mark,
+        scoped,
+        onAnswered
+      });
+    }
+    if (record?.mode !== void 0) throw new Error("mcp_unshield_failed: this unshield's record names an exit mode this version does not know; nothing new was signed. Update the wallet");
+    if (!selfPayMayHaveSigned(store, unshieldId)) {
+      await checkUnshieldRecipient({ connection: session.connection, mint, owner });
+    }
+    const payerTools = session.proofTools;
+    onStage("self-pay");
+    mark("unshield-self-pay");
+    const paid = await selfPayStep({
       store,
-      unshieldId,
+      connection: session.connection,
+      programId: session.programId,
+      proofTools: payerTools,
+      profile,
       amountAtomic,
-      record,
-      owner,
-      mint,
-      recipient,
-      exitProofTools,
-      facilitatorOrigin: facilitatorOrigin2,
-      onStage,
-      walk,
-      mark,
-      scoped,
-      onAnswered,
-      onCheckPending
+      unshieldId,
+      facilitatorBaseUrl: serviceUrl(facilitatorOrigin2, "/api/x402").href,
+      memoServiceUrl: serviceBase(facilitatorOrigin2),
+      // An owner unshield: the self-payment pays this wallet itself, so it does not use the wallet-file payment budget.
+      ownerUnshield: true,
+      // The self-payment waits for the next anchor itself (bounded, like x402_pay), instead of refusing.
+      deps: { payDeps: { timing: session.timing(), walkHistory: walk(payerTools.deploymentIdentity), waitForAnchor: true } }
+    });
+    const payment = store.readWal(`${RESOURCE_PAYMENT_WAL_PREFIX2}${sha256Hex2(Buffer.from(selfPayRequestId(unshieldId), "utf8"))}`);
+    if (!payment?.memoDigest || !paid.noteCommitment) throw new Error("mcp_unshield_failed: the self-payment record is incomplete; call wallet_unshield again with the same request_id");
+    mark("unshield-paid");
+    return { paid, memoDigest: payment.memoDigest, recipient, pool: store.state.pool };
+  });
+  if (start.stop !== void 0) return start.stop;
+  let { tried, exitOf } = start;
+  if (tried === void 0) {
+    const { paid, memoDigest, recipient } = start;
+    exitOf = (store) => runRecoveredP03NoteExit({
+      store,
+      connection: session.connection,
+      programId: session.programId,
+      serviceUrl: facilitatorOrigin2,
+      digests: [memoDigest],
+      recipientTokenAccount: recipient.toBase58(),
+      proofTools: exitProofTools,
+      noteCommitment: paid.noteCommitment,
+      recipientOwner: owner.toBase58(),
+      allowForeignRecipient: true,
+      relaySubmit: facilitatorExitRelay(facilitatorOrigin2),
+      requestAnchor: markedAnchorRequest(facilitatorAnchor(facilitatorOrigin2)),
+      answerAtRelay: true,
+      deps: { walkHistory: walk(exitProofTools.deploymentIdentity) }
     });
+    onStage("exit");
+    mark("unshield-exit");
+    tried = await exitTries({ session, lease, name, pool: start.pool, use, mark, scoped, exitOf, answer: { selfPayTransaction: paid.transaction ?? null }, onAnswered });
   }
-  if (record?.mode !== void 0) throw new Error("mcp_unshield_failed: this unshield's record names an exit mode this version does not know; nothing new was signed. Update the wallet");
-  if (!selfPayMayHaveSigned(store, unshieldId)) {
-    await checkUnshieldRecipient({ connection: session.connection, mint, owner });
-  }
-  const payerTools = session.proofTools;
-  onStage("self-pay");
-  mark("unshield-self-pay");
-  const paid = await selfPayStep({
-    store,
-    connection: session.connection,
-    programId: session.programId,
-    proofTools: payerTools,
-    profile,
-    amountAtomic,
-    unshieldId,
-    facilitatorBaseUrl: serviceUrl(facilitatorOrigin2, "/api/x402").href,
-    memoServiceUrl: serviceBase(facilitatorOrigin2),
-    // An owner unshield: the self-payment pays this wallet itself, so it does not use the wallet-file payment budget.
-    ownerUnshield: true,
-    // The self-payment waits for the next anchor itself (bounded, like x402_pay), instead of refusing.
-    deps: { payDeps: { timing: session.timing(), walkHistory: walk(payerTools.deploymentIdentity), waitForAnchor: true } }
-  });
-  const payment = store.readWal(`${RESOURCE_PAYMENT_WAL_PREFIX2}${sha256Hex2(Buffer.from(selfPayRequestId(unshieldId), "utf8"))}`);
-  if (!payment?.memoDigest || !paid.noteCommitment) throw new Error("mcp_unshield_failed: the self-payment record is incomplete; call wallet_unshield again with the same request_id");
-  mark("unshield-paid");
-  onStage("exit");
-  mark("unshield-exit");
-  const exit = await scoped("unshield-exit", () => exitWhenAnchored(() => runRecoveredP03NoteExit({
-    store,
-    connection: session.connection,
-    programId: session.programId,
-    serviceUrl: facilitatorOrigin2,
-    digests: [payment.memoDigest],
-    recipientTokenAccount: recipient.toBase58(),
-    proofTools: exitProofTools,
-    noteCommitment: paid.noteCommitment,
-    recipientOwner: owner.toBase58(),
-    allowForeignRecipient: true,
-    relaySubmit: facilitatorExitRelay(facilitatorOrigin2),
-    requestAnchor: markedAnchorRequest(facilitatorAnchor(facilitatorOrigin2)),
-    answerAtRelay: true,
-    deps: { walkHistory: walk(exitProofTools.deploymentIdentity) }
-  }), { ring: { connection: session.connection, pool: store.state.pool } }));
-  const answer = { selfPayTransaction: paid.transaction ?? null, exitTransaction: exit.signature ?? null };
-  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 ?? exited?.exitAnsweredAtMs ?? Date.now() });
-  return answer;
+  return exitFinish({
+    lease,
+    name,
+    use,
+    mark,
+    scoped,
+    exitOf,
+    tried,
+    onCheckPending,
+    onExited,
+    finalityWaits,
+    walkNext,
+    ...finalityWaits > 0 ? { preWalk: () => walkBeforeLease(session, exitProofTools) } : {}
+  });
 }
 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());
-    return true;
-  }
-  const record = store.readWal(name);
-  store.writeWal(name, {
-    ...record,
-    exitTransaction: exit.signature,
-    exitAnsweredAtMs: record?.exitAnsweredAtMs ?? Date.now(),
-    ...changeAtomic !== void 0 ? { changeAtomic } : {}
-  });
-  try {
-    await scoped("unshield-exit", () => refreshWallet({ session, store, history: exit.preExitHistory }));
-  } catch {
-    mark("unshield-exit-snapshot-failed");
-  }
-  mark("unshield-exit-answered");
-  try {
-    onAnswered(answer);
-  } catch {
-  }
-  try {
-    await scoped("unshield-exit", () => exit.finish());
-    return true;
-  } catch (error) {
+async function exitTries({ session, lease, name, pool: pool2, use, mark, scoped, exitOf, answer: shown, changeAtomic, onAnswered }) {
+  const answers = typeof onAnswered === "function";
+  return scoped("unshield-exit", () => exitWhenAnchored(() => lease(async (store) => {
+    mark("unshield-lease-exit");
+    use(store);
+    const exit = await exitOf(store);
+    const answer = { ...shown, exitTransaction: exit.signature ?? null };
+    const early = exit.settled === false && answers;
+    if (early) {
+      const record = store.readWal(name);
+      store.writeWal(name, {
+        ...record,
+        exitTransaction: exit.signature,
+        exitAnsweredAtMs: record?.exitAnsweredAtMs ?? Date.now(),
+        ...changeAtomic !== void 0 ? { changeAtomic } : {}
+      });
+      try {
+        await refreshWallet({ session, store, history: exit.preExitHistory });
+      } catch {
+        mark("unshield-exit-snapshot-failed");
+      }
+      mark("unshield-exit-answered");
+      try {
+        onAnswered(answer);
+      } catch {
+      }
+    }
+    return { answer, signature: exit.signature, settled: exit.settled !== false, early };
+  }), { ring: { connection: session.connection, pool: pool2 } }));
+}
+async function exitFinish({ lease, name, use, mark, scoped, exitOf, tried, onCheckPending, onExited, finalityWaits = 0, preWalk, walkNext }) {
+  const checkPending = (store, error) => {
     mark("unshield-exit-check-pending");
-    store.writeWal(name, { ...store.readWal(name), exitCheckPendingAtMs: Date.now() });
+    if (store) store.writeWal(name, { ...store.readWal(name), exitCheckPendingAtMs: Date.now() });
     try {
       onCheckPending?.(error);
     } catch {
     }
-    return false;
+  };
+  try {
+    for (let waits = 0; ; waits += 1) {
+      const early = !tried.settled && typeof preWalk === "function" ? await preWalk() : void 0;
+      const notFinal = await lease(async (store) => {
+        mark("unshield-lease-finish");
+        use(store);
+        if (!tried.settled) {
+          walkNext?.(walkStillCurrent(store, early));
+          try {
+            await scoped("unshield-exit", () => exitOf(store));
+          } catch (error) {
+            if (waits < finalityWaits && NOT_FINAL_YET.test(String(error?.message ?? ""))) return true;
+            if (!tried.early) throw error;
+            checkPending(store, error);
+            return false;
+          } finally {
+            walkNext?.(void 0);
+          }
+        }
+        mark("unshield-exited");
+        const exited = store.readWal(name);
+        store.writeWal(name, { ...exited, state: "exited", exitTransaction: tried.signature, exitedAtMs: exited?.exitedAtMs ?? exited?.exitAnsweredAtMs ?? Date.now() });
+        onExited();
+        return false;
+      });
+      if (!notFinal) break;
+      mark("unshield-finish-finality-wait");
+      await new Promise((resolve35) => {
+        setTimeout(resolve35, FINISH_FINALITY_WAIT_MS);
+      });
+    }
+  } catch (error) {
+    if (!tried.early) throw error;
+    checkPending(void 0, error);
   }
+  return tried.answer;
 }
 async function runDirectExit({
   session,
   store,
+  name,
+  pool: pool2,
   unshieldId,
   amountAtomic,
   record,
@@ -126011,13 +126152,11 @@ async function runDirectExit({
   facilitatorOrigin: facilitatorOrigin2,
   onStage,
   walk,
-  mark = () => {
-  },
-  scoped = (_prefix, fn) => fn(),
-  onAnswered,
-  onCheckPending
+  use,
+  mark,
+  scoped,
+  onAnswered
 }) {
-  const name = `self-pay-${unshieldId}`;
   if (record.amountAtomic !== String(amountAtomic) || record.exitAmountAtomic !== String(amountAtomic)) {
     throw new Error("mcp_request_id_reused: this unshield's direct exit is bound to another amount; nothing new was signed");
   }
@@ -126030,45 +126169,54 @@ async function runDirectExit({
   if (!selfPayMayHaveSigned(store, unshieldId)) await checkUnshieldRecipient({ connection: session.connection, mint, owner });
   onStage("exit");
   mark("unshield-exit");
-  const proveExit = async (request) => {
-    const proved = await proveRecoveredP03NoteExit({ request, tools: exitProofTools });
-    const now = store.readWal(name);
-    if (now?.mode === DIRECT_EXIT_MODE && now.state === "started") store.writeWal(name, { ...now, state: "paid" });
-    return proved;
-  };
   const exitAmountAtomic = record.exitAmountAtomic === record.noteValueAtomic ? void 0 : record.exitAmountAtomic;
-  let exit;
-  try {
-    exit = await scoped("unshield-exit", () => exitWhenAnchored(() => runRecoveredP03NoteExit({
-      store,
-      connection: session.connection,
-      programId: session.programId,
-      serviceUrl: facilitatorOrigin2,
-      digests: [record.memoDigest],
-      recipientTokenAccount: recipient.toBase58(),
-      proofTools: exitProofTools,
-      noteCommitment: record.noteCommitment,
-      exitAmountAtomic,
-      recipientOwner: owner.toBase58(),
-      allowForeignRecipient: true,
-      relaySubmit: facilitatorExitRelay(facilitatorOrigin2),
-      requestAnchor: markedAnchorRequest(facilitatorAnchor(facilitatorOrigin2)),
-      answerAtRelay: true,
-      deps: { walkHistory: walk(exitProofTools.deploymentIdentity), proveExit }
-    }), { ring: { connection: session.connection, pool: store.state.pool } }));
-  } catch (error) {
-    if (/requested recovered note is not uniquely spendable/.test(String(error?.message)) && store.readWal(name)?.state === "started" && !store.readWal(directExitWalName(record)) && !selfPayMayHaveSigned(store, unshieldId)) {
+  const changeAtomic = exitAmountAtomic === void 0 ? void 0 : (BigInt(record.noteValueAtomic) - BigInt(record.exitAmountAtomic)).toString();
+  const exitOf = (opened) => runRecoveredP03NoteExit({
+    store: opened,
+    connection: session.connection,
+    programId: session.programId,
+    serviceUrl: facilitatorOrigin2,
+    digests: [record.memoDigest],
+    recipientTokenAccount: recipient.toBase58(),
+    proofTools: exitProofTools,
+    noteCommitment: record.noteCommitment,
+    exitAmountAtomic,
+    recipientOwner: owner.toBase58(),
+    allowForeignRecipient: true,
+    relaySubmit: facilitatorExitRelay(facilitatorOrigin2),
+    requestAnchor: markedAnchorRequest(facilitatorAnchor(facilitatorOrigin2)),
+    answerAtRelay: true,
+    deps: {
+      walkHistory: walk(exitProofTools.deploymentIdentity),
+      // The record reads "paid" once the proof exists, before the library stores it and before any relay call: from then
+      // on the part may have reached the relay (cancel and the private send's own records see that), and the note is held.
+      proveExit: async (request) => {
+        const proved = await proveRecoveredP03NoteExit({ request, tools: exitProofTools });
+        const now = opened.readWal(name);
+        if (now?.mode === DIRECT_EXIT_MODE && now.state === "started") opened.writeWal(name, { ...now, state: "paid" });
+        return proved;
+      }
+    }
+  }).catch((error) => {
+    if (/requested recovered note is not uniquely spendable/.test(String(error?.message)) && opened.readWal(name)?.state === "started" && !opened.readWal(directExitWalName(record)) && !selfPayMayHaveSigned(opened, unshieldId)) {
       throw new Error("mcp_unshield_received_payment_gone: the received payment this unshield chose is no longer spendable (another spend took it, or the wallet's last chain read was old); nothing was signed, and this request_id cannot pass");
     }
     throw error;
-  }
-  const answer = { selfPayTransaction: null, exitTransaction: exit.signature ?? null };
-  const changeAtomic = exitAmountAtomic === void 0 ? void 0 : (BigInt(record.noteValueAtomic) - BigInt(record.exitAmountAtomic)).toString();
-  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 ?? exited?.exitAnsweredAtMs ?? Date.now() });
-  return answer;
+  });
+  const tried = await exitTries({
+    session,
+    lease: (task) => task(store),
+    name,
+    pool: pool2,
+    use,
+    mark,
+    scoped,
+    exitOf,
+    answer: { selfPayTransaction: null },
+    changeAtomic,
+    onAnswered
+  });
+  return { tried, exitOf };
 }
 function balanceFields(parts) {
   if (!parts) return null;
@@ -126389,8 +126537,37 @@ function createWalletTools({
     ...history ? { history } : {},
     ...share ? { share } : {}
   });
-  const refundNotices = [];
-  const takeRefundNotices = () => refundNotices.length ? { refundNotices: refundNotices.splice(0) } : {};
+  const shownRefunds = /* @__PURE__ */ new Set();
+  const takeRefundNotices = (store) => {
+    let outcomes;
+    try {
+      outcomes = readFloatRefundOutcomes(store ?? session.openStore());
+    } catch {
+      return {};
+    }
+    const fresh = outcomes.filter(({ floatId, outcome }) => !shownRefunds.has(`${floatId}:${outcome}`));
+    if (!fresh.length) return {};
+    for (const { floatId, outcome } of fresh) shownRefunds.add(`${floatId}:${outcome}`);
+    underLease((leased) => markFloatRefundOutcomesShown(leased, fresh)).catch(() => {
+    });
+    return { refundNotices: fresh.map(refundOutcomeText) };
+  };
+  const withRefundNotices = (answer, store) => {
+    let value2;
+    try {
+      value2 = JSON.parse(answer.text);
+    } catch {
+      return answer;
+    }
+    if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return answer;
+    const notices = takeRefundNotices(store);
+    if (!notices.refundNotices) return answer;
+    return json3({
+      ...value2,
+      ...notices,
+      ...typeof value2.next === "string" ? { next: `${value2.next.replace(/[.\s]+$/, "")}. Tell the user each refundNotices line` } : {}
+    });
+  };
   let lastWriterEndedAt = 0;
   let paysInFlight = 0;
   let payJoinWaiting = 0;
@@ -126829,7 +127006,6 @@ function createWalletTools({
             if (early !== void 0 && !same2) log("MCP_REFRESH_WALK_AGAIN");
             const share = early !== void 0 && !same2 ? { notBeforeMs: Date.now() } : void 0;
             let result2 = await refreshStep(store, same2 ? early.history : void 0, share);
-            refundNotices.push(...takeFloatRefundOutcomes(store).map(refundOutcomeText));
             let marksAfter = walletHomeMarks(session.walletPath);
             const settled = (marks) => marks !== void 0 && marks.readAtMs - marks.newestMs >= HOME_MARKS_SETTLED_MS2;
             if (background && settled(marksBefore) && marksAfter !== void 0 && marksAfter.marks !== marksBefore.marks && paysInFlight === 0) {
@@ -127311,8 +127487,12 @@ ${canonical5}`;
     };
     for (const [phase, at, outcome] of gateTimes) mark(phase, at, outcome);
     let earlyBalance;
+    let earlyCorrection;
     const payTiming = (phase, outcome, at) => {
-      if (phase === "seller-sent") sellerSentAt.set(requestId, Date.now());
+      if (phase === "seller-sent") {
+        sellerSentAt.set(requestId, Date.now());
+        earlyCorrection ??= startFloatCorrection();
+      }
       if (timing === void 0) return;
       timing(phase, outcome, at);
       if (phase === "seller-sent" && earlyBalance === void 0) earlyBalance = earlyResultBalance(requestId);
@@ -127422,11 +127602,10 @@ ${canonical5}`;
           await waitWithProgress(retry.waitMs, progress3, "waiting to try the payment again; nothing was paid");
           continue;
         }
-        await correctFloatRecordsNow();
+        await correctFloatRecordsNow(void 0, earlyCorrection);
         const failed = payFailure(error, requestId, "x402_pay", join39);
         const ready = readyInSecondsOf(error, code2);
-        const extra = { ...takeRefundNotices(), ...ready !== void 0 ? { readyInSeconds: ready } : {} };
-        return Object.keys(extra).length ? json3({ ...JSON.parse(failed.text), ...extra }) : failed;
+        return withRefundNotices(ready !== void 0 ? json3({ ...JSON.parse(failed.text), readyInSeconds: ready }) : failed);
       }
     }
     const { bytes: bytes2, truncated } = await readBody(response);
@@ -127478,7 +127657,7 @@ ${canonical5}`;
     mark("mcp-result-float");
     const floatPaid = float?.state === "receipt";
     const amounts = floatPaid ? { priceAtomic: float.priceAtomic, feeAtomic: float.feeAtomic, amountAtomic: float.paidAtomic } : { priceAtomic: receipt.amountAtomic ?? null, feeAtomic: "0", amountAtomic: receipt.amountAtomic ?? null };
-    if (paidStore && await correctFloatRecordsNow(paidStore) > 0) {
+    if (paidStore && await correctFloatRecordsNow(paidStore, earlyCorrection) > 0) {
       earlyBalance = void 0;
       try {
         paidStore = session.openStore();
@@ -127503,6 +127682,7 @@ ${canonical5}`;
     }
     mark("mcp-result");
     const shinjukuTransaction = floatPaid ? leg1Transaction(paidStore, float, requestId) : null;
+    const notices = takeRefundNotices(paidStore);
     return answerResult(paidAnswerContent({
       status: response.status,
       headers: response.headers,
@@ -127521,8 +127701,8 @@ ${canonical5}`;
         // Leg 1 (this wallet's private payment to Shinjuku, a pool transaction): the seller may return no settle signature.
         ...floatPaid ? { via: "shinjuku", shinjukuTransaction } : {},
         ...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"
+        ...notices,
+        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") + (notices.refundNotices ? ". Tell the user each refundNotices line" : "")
       }, "x402_pay")
     }));
   }
@@ -128669,7 +128849,21 @@ ${canonical5}`;
     }
     return names;
   }
-  async function correctFloatRecords(store, names, untilMs) {
+  async function correctFloatRecords(store, names, untilMs, started = floatCorrectionReads(store, names)) {
+    const { states, proven, settled } = started;
+    if (settled === void 0) return { states, written: 0 };
+    const until = (ms) => new Promise((resolve35) => {
+      const timer = setTimeout(resolve35, Math.max(0, ms - Date.now()));
+      timer.unref?.();
+    });
+    await Promise.race([settled, until(untilMs)]);
+    if (!proven.length) return { states, written: 0 };
+    const writing = underLease((leased) => Date.now() >= untilMs ? 0 : writeProven(leased, proven));
+    const written = await Promise.race([writing.catch(() => 0), until(untilMs).then(() => 0)]);
+    if (written > 0) log(`MCP_FLOAT_RECORDS_CORRECTED records=${written}`);
+    return { states, written };
+  }
+  function floatCorrectionReads(store, names) {
     const now = Date.now();
     const due = [];
     const transfers = [];
@@ -128695,11 +128889,11 @@ ${canonical5}`;
     }
     const states = new Map(finalRefundStates);
     for (const [floatId, transaction] of finalTransfers) states.set(floatId, { floatState: "final", transaction });
-    if (!due.length && !transfers.length) return { states, written: 0 };
+    const proven = [];
+    if (!due.length && !transfers.length) return { states, proven, settled: void 0 };
     due.sort((left, right) => floatEndedAtMs(right.record) - floatEndedAtMs(left.record));
     transfers.sort((left, right) => floatAnsweredAtMs(right.record) - floatAnsweredAtMs(left.record));
     const fetchImpl = ops.fetch ?? fetch;
-    const proven = [];
     const reads = due.slice(0, REFUND_STATUS_READS).map(({ name, record }) => readFloatTransferState(record, fetchImpl).then((read) => {
       const state = floatRecordState(record);
       if (state === "submitted" && read?.state === "landed" || read?.state === "final") {
@@ -128727,26 +128921,24 @@ ${canonical5}`;
         proven.push({ name, from: record.state, transaction: read.transaction, fill: true });
       }));
     }
-    const until = (ms) => new Promise((resolve35) => {
-      const timer = setTimeout(resolve35, Math.max(0, ms - Date.now()));
-      timer.unref?.();
-    });
-    await Promise.race([Promise.all(reads).catch(() => {
-    }), until(untilMs)]);
-    if (!proven.length) return { states, written: 0 };
-    const writing = underLease((leased) => Date.now() >= untilMs ? 0 : writeProven(leased, proven));
-    const written = await Promise.race([writing.catch(() => 0), until(untilMs).then(() => 0)]);
-    if (written > 0) log(`MCP_FLOAT_RECORDS_CORRECTED records=${written}`);
-    return { states, written };
+    return { states, proven, settled: Promise.all(reads).then(() => void 0, () => void 0) };
   }
-  async function correctFloatRecordsNow(store) {
+  async function correctFloatRecordsNow(store, started) {
     try {
       const open4 = store ?? session.openStore();
-      return (await correctFloatRecords(open4, staleRefundNames(open4), Date.now() + FLOAT_CORRECT_WAIT_MS)).written;
+      return (await correctFloatRecords(open4, void 0, Date.now() + FLOAT_CORRECT_WAIT_MS, started ?? floatCorrectionReads(open4, staleRefundNames(open4)))).written;
     } catch {
       return 0;
     }
   }
+  function startFloatCorrection() {
+    try {
+      const open4 = session.openStore();
+      return floatCorrectionReads(open4, staleRefundNames(open4));
+    } catch {
+      return void 0;
+    }
+  }
   function writeProven(store, proven) {
     let written = 0;
     for (const { name, from, verdict, transaction, refundDueAtMs, fill } of proven) {
@@ -131113,13 +131305,13 @@ ${canonical5}`;
     }
     return session.openStore();
   }
-  async function unshieldPart(opened, job, unshieldId, amountAtomic, onStage, onAnswered) {
-    const store = await refreshStaleBeforeUnshield(opened, onStage);
-    bindUnshieldRecipient(store, unshieldId, amountAtomic, job.to, unshieldId === moneyId(job.requestId) ? job.requestId : void 0);
+  async function unshieldPart(job, unshieldId, amountAtomic, onStage, { before, onAnswered, firstLease = underLease, yieldMs = UNSHIELD_WINDOW_YIELD_MS } = {}) {
+    const name = `self-pay-${unshieldId}`;
+    let windows = 0;
     let backup;
+    const finishing = { running: true, atMs: Date.now() };
     const result = await (ops.unshield ?? runUnshield)({
       session,
-      store,
       unshieldId,
       amountAtomic,
       recipientOwner: job.to,
@@ -131127,24 +131319,44 @@ ${canonical5}`;
       profile: money.profile,
       facilitatorOrigin: money.facilitatorOrigin,
       onStage,
+      finalityWaits: FINISH_FINALITY_WAITS,
+      lease: (task) => windows++ === 0 ? firstLease(task) : new Promise((resolve35) => {
+        setTimeout(resolve35, yieldMs);
+      }).then(() => withLockRetry(() => underLease(task))),
+      before,
+      prepare: async (opened) => {
+        const store = await refreshStaleBeforeUnshield(opened, onStage);
+        bindUnshieldRecipient(store, unshieldId, amountAtomic, job.to, unshieldId === moneyId(job.requestId) ? job.requestId : void 0);
+        return store;
+      },
       ...ops.selfPay ? { selfPayStep: ops.selfPay } : {},
       ...typeof onAnswered === "function" ? { onAnswered: (answer) => {
+        answeredExitTries.set(name, finishing);
         backup = backupNow(session.openStore());
         onAnswered({ ...answer, ...backup });
       } } : {},
       onCheckPending: (error) => {
         log(`MCP_UNSHIELD_CHECK_PENDING requestId=${job.requestId} cause=${JSON.stringify(String(error?.message ?? error ?? "").split("\n", 1)[0].slice(0, 240))}`);
-        answeredExitTries.set(`self-pay-${unshieldId}`, { running: false, atMs: Date.now() });
+        answeredExitTries.set(name, { running: false, atMs: Date.now() });
         armAnsweredExitRetry();
+      },
+      onExited: () => {
+        backup ??= backupNow(session.openStore());
       }
+    }).finally(() => {
+      if (answeredExitTries.get(name) === finishing) answeredExitTries.delete(name);
     });
-    return { ...result, ...backup ?? backupNow(session.openStore()) };
+    return backup === void 0 ? result : { ...result, ...backup };
   }
   function runUnshieldJob(job, onStage) {
     if (isSplitSend(job)) return runPrivateSendJob(job, onStage);
-    return onOwnTorTag(() => underLease(async (opened) => {
-      if (!opened.readWal(`self-pay-${moneyId(job.requestId)}`)) await assertNotPromisedFresh(opened, job.amountAtomic);
-      return unshieldPart(opened, job, moneyId(job.requestId), job.amountAtomic, onStage, (answer) => answerUnshieldEarly(job, answer));
+    return onOwnTorTag(() => unshieldPart(job, moneyId(job.requestId), job.amountAtomic, onStage, {
+      // A new one (no self-payment yet) never takes value an open private send still owes; a started one continues.
+      before: async (opened) => {
+        if (!opened.readWal(`self-pay-${moneyId(job.requestId)}`)) await assertNotPromisedFresh(opened, job.amountAtomic);
+      },
+      onAnswered: (answer) => answerUnshieldEarly(job, answer),
+      yieldMs: 0
     }));
   }
   function answerUnshieldEarly(job, answer) {
@@ -131201,17 +131413,21 @@ ${canonical5}`;
       // A wait never keeps this server alive by itself: at stdin end the send runner takes the send (handOffSends).
       sleep: sendSleep,
       stopped: () => sendsHandedOff,
-      // Each part on one tag of its own (runShieldJob).
-      runPart: ({ part, index, total }) => onOwnTorTag(() => underLease(async (opened) => {
-        store = opened;
-        if (partCancelled(opened, sendId, part)) return { cancelled: true };
-        if (partState(opened, part).state === "exited") return {};
-        const result = await unshieldPart(opened, job, part.unshieldId, part.amountAtomic, (stage) => onStage(`payment ${index}/${total}: ${stage}`));
+      // Each part on one tag of its own (runShieldJob), in lease windows (unshieldPart).
+      runPart: ({ part, index, total }) => onOwnTorTag(async () => {
+        const result = await unshieldPart(job, part.unshieldId, part.amountAtomic, (stage) => onStage(`payment ${index}/${total}: ${stage}`), {
+          before: (opened) => {
+            store = opened;
+            if (partCancelled(opened, sendId, part)) return { cancelled: true };
+            if (partState(opened, part).state === "exited") return {};
+            return void 0;
+          }
+        });
         if (result.backupPath !== void 0) backup = { backupPath: result.backupPath };
         if (result.backupError !== void 0) backup = { ...backup, backupError: result.backupError };
         store = session.openStore();
         return result;
-      })),
+      }),
       // The plan's last write, under the lease like every other.
       finish: () => underLease((opened) => {
         store = opened;
@@ -131665,12 +131881,14 @@ ${canonical5}`;
       answeredExitTries.set(name, attempt);
       const unshieldId = name.slice("self-pay-".length);
       log(`MCP_UNSHIELD_CHECK_RESUME unshieldId=${unshieldId}`);
-      onOwnTorTag(() => underLease((opened) => {
+      const tryFinish = (waits) => walkBeforeLease(session, money.exitProofTools).then((early) => underLease((opened) => {
         const current = opened.readWal(name);
         if (current?.state === "exited" || current?.exitUnconfirmed === true || typeof current?.exitTransaction !== "string") return void 0;
+        const walked = walkStillCurrent(opened, early);
+        if (early !== void 0 && walked === void 0) log(`MCP_UNSHIELD_CHECK_WALK_UNDER_LEASE unshieldId=${unshieldId}`);
         return (ops.unshield ?? runUnshield)({
           session,
-          store: opened,
+          lease: (task) => task(opened),
           unshieldId,
           amountAtomic: current.amountAtomic,
           recipientOwner: current.mcpTo,
@@ -131679,16 +131897,31 @@ ${canonical5}`;
           facilitatorOrigin: money.facilitatorOrigin,
           onStage: () => {
           },
-          ...ops.selfPay ? { selfPayStep: ops.selfPay } : {}
+          ...ops.selfPay ? { selfPayStep: ops.selfPay } : {},
+          ...walked !== void 0 ? { walked } : {}
+        });
+      }, { orClosed: ANSWERED_EXIT_CLOSED })).catch(async (error) => {
+        let answeredAt;
+        try {
+          answeredAt = session.openStore().readWal(name)?.exitAnsweredAtMs;
+        } catch {
+          answeredAt = void 0;
+        }
+        if (waits >= FINISH_FINALITY_WAITS || finalityClosed || session.closed === true || !NOT_FINAL_YET.test(String(error?.message ?? "")) || !Number.isSafeInteger(answeredAt) || Date.now() - answeredAt > FINISH_FINALITY_RECENT_MS) throw error;
+        log(`MCP_UNSHIELD_CHECK_FINALITY_WAIT unshieldId=${unshieldId} wait=${waits + 1}`);
+        await new Promise((resolve35) => {
+          setTimeout(resolve35, FINISH_FINALITY_WAIT_MS);
         });
-      }, { orClosed: ANSWERED_EXIT_CLOSED })).then((result) => {
+        return tryFinish(waits + 1);
+      });
+      onOwnTorTag(() => tryFinish(0)).then((result) => {
         if (result === ANSWERED_EXIT_CLOSED) return;
         const now = session.openStore().readWal(name);
         log(now?.state === "exited" ? `MCP_UNSHIELD_CHECK_DONE unshieldId=${unshieldId}` : `MCP_UNSHIELD_CHECK_PENDING unshieldId=${unshieldId}`);
         if (now?.state === "exited") refreshAtFinality();
       }, (error) => {
         const cause = String(error?.message ?? error ?? "").split("\n", 1)[0];
-        attempt.provenUnspent = /confirmed note-exit is not finalized spent/.test(cause);
+        attempt.provenUnspent = NOT_FINAL_YET.test(cause);
         log(`MCP_UNSHIELD_CHECK_PENDING unshieldId=${unshieldId} cause=${JSON.stringify(cause.slice(0, 240))}`);
       }).then(() => underLease((opened) => {
         const now = opened.readWal(name);
@@ -132598,21 +132831,27 @@ ${canonical5}`;
         }),
         sleep: sendSleep,
         stopped: () => sendsHandedOff,
-        // Each part on one tag of its own (runShieldJob).
-        runPart: ({ part, index, total }) => onOwnTorTag(() => withLockRetry(() => underLease(async (opened) => {
-          store = opened;
-          if (partCancelled(opened, plan.sendId, part)) return { cancelled: true };
-          if (partState(opened, part).state === "exited") return {};
+        // Each part on one tag of its own (runShieldJob), in lease windows (unshieldPart); window 1 waits for this server's
+        // own lease holders, as before.
+        runPart: ({ part, index, total }) => onOwnTorTag(async () => {
           const result = await unshieldPart(
-            opened,
             job,
             part.unshieldId,
             part.amountAtomic,
-            (stage) => log(`MCP_TRANSFER_SEND_STAGE requestId=${plan.id} part=${index}/${total} stage=${stage}`)
+            (stage) => log(`MCP_TRANSFER_SEND_STAGE requestId=${plan.id} part=${index}/${total} stage=${stage}`),
+            {
+              firstLease: (task) => withLockRetry(() => underLease(task)),
+              before: (opened) => {
+                store = opened;
+                if (partCancelled(opened, plan.sendId, part)) return { cancelled: true };
+                if (partState(opened, part).state === "exited") return {};
+                return void 0;
+              }
+            }
           );
           store = session.openStore();
           return result;
-        }))),
+        }),
         finish: () => underLease((opened) => {
           store = opened;
           return finishPrivateSend(opened, plan.sendId);
@@ -133580,7 +133819,7 @@ ${canonical5}`;
               { requestId, paid: false, ...facts }
             );
           }
-          return inferenceRefusal(error, { requestId, ...facts }) ?? payFailure(error, requestId, "inference_chat");
+          return withRefundNotices(inferenceRefusal(error, { requestId, ...facts }) ?? payFailure(error, requestId, "inference_chat"));
         }
       }
       const receipt = result.receipt ?? {};
@@ -133629,7 +133868,7 @@ ${canonical5}`;
         const larger = moreTokens(args.max_tokens);
         const paidText = usdcText3(paidAtomic ?? "");
         log(`MCP_INFERENCE_OUT_OF_TOKENS requestId=${requestId} maxTokens=${args.max_tokens}`);
-        return json3(sayFirst(
+        return withRefundNotices(json3(sayFirst(
           {
             ok: false,
             error: "inference_out_of_tokens",
@@ -133639,13 +133878,13 @@ ${canonical5}`;
             next: receipt.replayed === true ? `this request id was already paid and its stored answer is empty; nothing new was paid. For an answer, call inference_chat with a NEW request_id and max_tokens ${larger}; it pays again` : `Tell the user: the model ran out of tokens before it answered, and this call paid ${paidText ? `${paidText} USDC` : "(see paidAtomic)"}. For an answer, call inference_chat again with a NEW request_id and max_tokens ${larger}; it pays again. The same request_id returns this same empty answer`
           },
           "inference_chat"
-        ));
+        )), paidStore);
       }
-      return json3(sayFirst({
+      return withRefundNotices(json3(sayFirst({
         ok: true,
         ...paidFields,
         next: receipt.replayed === true ? "this request id was already paid: the stored answer came back and nothing new was paid" : "answered; give the user content, and tell them what was paid: paidAtomic (the AI provider's price, at most ceilingAtomic, plus Shinjuku's fee feeAtomic when via is shinjuku; what is not used is not refunded). wallet_balance shows the new balance"
-      }, "inference_chat"));
+      }, "inference_chat")), paidStore);
     }
   };
   const addFunds2 = createAddFundsTool({
@@ -134477,7 +134716,7 @@ function createSetupTools({
     doneTool: sayOnRefusal(doneTool)
   };
 }
-var import_web3132, shownCaps, RELEASE_RETRY_MS, STAGE_WORDS, stageWords, INTERNAL_BALANCE_DETAIL, shownBreakdown, sessionLeftShown, TOKEN_UNIT_TOOLS, RESOURCE_PAYMENT_WAL_PREFIX2, POOL_LAYOUT_CODE, POOL_LAYOUT_UPDATE, USEPOD_VIA_INFERENCE_CHAT, SEND_RUNS_ON, DEPOSIT_RUNS_ON, CLI_FUNDS_PLAN_PREFIX, CLI_FUNDS_SCHEMA, SELF_PAY_ORIGIN3, REQUEST_ID4, POSITIVE_ATOMIC6, PRIVATE_HOST3, FORBIDDEN_HEADERS3, MAX_BODY_BYTES2, PREVIEW_TIMEOUT_MS, PREVIEW_SELLER_READ_MS, CALL_BUDGET_MS, budgetLeft, PAY_ANSWER_MARGIN_MS, MONEY_FIRST_ANSWER_MS, BALANCE_AFTER_LANDING_MS, JOIN_CALL_MAX_MS, JOIN_NUDGE_QUIET_MS, JOIN_STEP_MS, sleep2, PROGRESS_EVERY_MS2, READ_BUDGET_MS, UNPAID_TOR_TRY_MS, UNPAID_CLEAR_MS, READ_BUDGET_TOOLS, FLOAT_BUSY_CODES, RETRY_MARGIN_MS, ASK_PAY_CODES, runningNpmVersion, terminalCommand2, capPlaceWords, CAP_NAMES, capName, capRaiseText, runningLimits, payCapFlag, cheaperSellerText, limitNext, SAFE_TEXT, MCP_TOOL_ALIASES, POOL_SWITCH_WHY, POOL_SWITCH_NEXT, SWITCH_STATES, quietSwitch, switchKey, ATOMIC_TEXT, movedTo, FLOAT_ID, ANSWERED_EXIT_RETRY_MS, ANSWERED_EXIT_UNCONFIRMED_MS, ANSWERED_EXIT_RETRY_WINDOW_MS, ANSWERED_EXIT_CLOSED, switchAmount, switchEta, switchRows, OWNER_CAP_CODES, JOIN_END_MCP, JOIN_END_TERMINAL_LIBRARY, JOIN_RETRY_BACKOFF_MS, WALLET_CAP_FIX, MCP_CAP_FIX, capFix, ownerOnlyNext, mcpNext, CONFIDENTIAL_RETIRED, json3, answerResult, discoverTool, LAUNCH_CAP_CODES, dayCapKind, refuse12, newRequestIdFor, payCapName, publicOffer, FLOAT_PAID_CODES, FLOAT_PRIVATE_LEG, MONEY_ID2, toRecordId, linkKindOf, moneyId, REFUSED_CODES, refusedCodeOf, PLAIN_REASONS, INSUFFICIENT_CODE, insufficientCause, INSUFFICIENT_REASONS, reasonOf, plainReason, KEPT_SEND_TRIES, shownId, isSplitSend, sendPartId, PROMISED_NEXT, partFailReason, sendAnswerOf, PUBLIC_READ_TIMEOUT_MS, RECIPIENT_CHECK_TIMEOUT_MS, withTimeout, ownKey, readFailure, OWN_KEY_TOKENS_MAX, tokenAmountText, elsewhereId, AGENT_ID_SCHEMA, agentIdName, minutesText2, ageWords2, DEPOSIT_SENT_STATES, depositLanded, usdcText3, walkWalletHistory, REFRESH_LEASE_WALK_MS, HOME_MARKS_SETTLED_MS2, AUTO_BACKUPS_KEPT, AUTO_BACKUP_NAME, AUTO_BACKUP_VERIFIED, FRONTED_SETTLE_MARGIN_SLOTS, BALANCE_REFRESH_WAIT_MS, BALANCE_REFRESH_GRACE_MS, BALANCE_REFRESH_LONG_MS, INBOUND_REFRESH_AGE_MS, changeFields, balanceAnswer, CAP_BALANCE_WAIT_MS, CAP_BALANCE_RETRY_MS, REFRESH_RETRY_MS, FINALITY_POLL_MS, FINALITY_WAIT_MS, FINALITY_REFRESH_LIMIT_MS, POOL_WATCH_MS, POOL_WATCH_POLL_MS, EARLY_BALANCE_DELAY_MS, FINALITY_SETTLE_WINDOW_SLOTS, PUBLIC_READ_ANSWER_MS, LINK_READ_ANSWER_MS, OWN_READS_AHEAD_MS, FLOAT_CORRECT_WAIT_MS, SWITCH_WAIT_MS, UNSHIELD_TO_NO_USDC_DETAIL, UNSHIELD_TO_INVALID_NEXT, INFERENCE_MIN_MAX_TOKENS, ELICIT_TIMEOUT_MS, ELICIT_UNSHOWN_MS, elicitUnshown, POLL_SECONDS2, TRANSFER_CHANGE_READ_MS, TEMP_CLEAN_DELAY_MS, KEPT_ON_DISK, MAX_SHIELDED_BALANCE_ATOMIC, receiveGenerator, MCP_TOOL_NAMES, MCP_HIDDEN_TOOL_NAMES, setupTerminalNext, SETUP_RUNNING_SAY, ACCEPTED_NEXT, SETUP_RUNNING_NEXT, SETUP_ANSWER_WAIT_MS, SETUP_CONFIRMING_SAY, SETUP_CONFIRMING_NEXT, PRIVATE_INFERENCE_WHY, RESTART_STEPS, TOR_BROWSER_PORT, SETUP_TOR_TITLE, SETUP_TOR_WHY;
+var import_web3132, shownCaps, RELEASE_RETRY_MS, STAGE_WORDS, stageWords, INTERNAL_BALANCE_DETAIL, shownBreakdown, sessionLeftShown, TOKEN_UNIT_TOOLS, RESOURCE_PAYMENT_WAL_PREFIX2, POOL_LAYOUT_CODE, POOL_LAYOUT_UPDATE, USEPOD_VIA_INFERENCE_CHAT, SEND_RUNS_ON, DEPOSIT_RUNS_ON, CLI_FUNDS_PLAN_PREFIX, CLI_FUNDS_SCHEMA, SELF_PAY_ORIGIN3, REQUEST_ID4, POSITIVE_ATOMIC6, PRIVATE_HOST3, FORBIDDEN_HEADERS3, MAX_BODY_BYTES2, PREVIEW_TIMEOUT_MS, PREVIEW_SELLER_READ_MS, CALL_BUDGET_MS, budgetLeft, PAY_ANSWER_MARGIN_MS, MONEY_FIRST_ANSWER_MS, BALANCE_AFTER_LANDING_MS, JOIN_CALL_MAX_MS, JOIN_NUDGE_QUIET_MS, JOIN_STEP_MS, sleep2, PROGRESS_EVERY_MS2, READ_BUDGET_MS, UNPAID_TOR_TRY_MS, UNPAID_CLEAR_MS, READ_BUDGET_TOOLS, FLOAT_BUSY_CODES, RETRY_MARGIN_MS, ASK_PAY_CODES, runningNpmVersion, terminalCommand2, capPlaceWords, CAP_NAMES, capName, capRaiseText, runningLimits, payCapFlag, cheaperSellerText, limitNext, SAFE_TEXT, MCP_TOOL_ALIASES, POOL_SWITCH_WHY, POOL_SWITCH_NEXT, SWITCH_STATES, quietSwitch, switchKey, ATOMIC_TEXT, movedTo, FLOAT_ID, ANSWERED_EXIT_RETRY_MS, ANSWERED_EXIT_UNCONFIRMED_MS, ANSWERED_EXIT_RETRY_WINDOW_MS, ANSWERED_EXIT_CLOSED, switchAmount, switchEta, switchRows, OWNER_CAP_CODES, JOIN_END_MCP, JOIN_END_TERMINAL_LIBRARY, JOIN_RETRY_BACKOFF_MS, WALLET_CAP_FIX, MCP_CAP_FIX, capFix, ownerOnlyNext, mcpNext, CONFIDENTIAL_RETIRED, json3, answerResult, discoverTool, LAUNCH_CAP_CODES, dayCapKind, refuse12, newRequestIdFor, payCapName, publicOffer, FLOAT_PAID_CODES, FLOAT_PRIVATE_LEG, MONEY_ID2, toRecordId, linkKindOf, moneyId, REFUSED_CODES, refusedCodeOf, PLAIN_REASONS, INSUFFICIENT_CODE, insufficientCause, INSUFFICIENT_REASONS, reasonOf, plainReason, KEPT_SEND_TRIES, shownId, isSplitSend, sendPartId, PROMISED_NEXT, partFailReason, sendAnswerOf, PUBLIC_READ_TIMEOUT_MS, RECIPIENT_CHECK_TIMEOUT_MS, withTimeout, ownKey, readFailure, OWN_KEY_TOKENS_MAX, tokenAmountText, elsewhereId, AGENT_ID_SCHEMA, agentIdName, minutesText2, ageWords2, DEPOSIT_SENT_STATES, depositLanded, usdcText3, walkWalletHistory, REFRESH_LEASE_WALK_MS, HOME_MARKS_SETTLED_MS2, AUTO_BACKUPS_KEPT, AUTO_BACKUP_NAME, AUTO_BACKUP_VERIFIED, FRONTED_SETTLE_MARGIN_SLOTS, UNSHIELD_WINDOW_YIELD_MS, NOT_FINAL_YET, FINISH_FINALITY_WAIT_MS, FINISH_FINALITY_WAITS, FINISH_FINALITY_RECENT_MS, walkStillCurrent, BALANCE_REFRESH_WAIT_MS, BALANCE_REFRESH_GRACE_MS, BALANCE_REFRESH_LONG_MS, INBOUND_REFRESH_AGE_MS, changeFields, balanceAnswer, CAP_BALANCE_WAIT_MS, CAP_BALANCE_RETRY_MS, REFRESH_RETRY_MS, FINALITY_POLL_MS, FINALITY_WAIT_MS, FINALITY_REFRESH_LIMIT_MS, POOL_WATCH_MS, POOL_WATCH_POLL_MS, EARLY_BALANCE_DELAY_MS, FINALITY_SETTLE_WINDOW_SLOTS, PUBLIC_READ_ANSWER_MS, LINK_READ_ANSWER_MS, OWN_READS_AHEAD_MS, FLOAT_CORRECT_WAIT_MS, SWITCH_WAIT_MS, UNSHIELD_TO_NO_USDC_DETAIL, UNSHIELD_TO_INVALID_NEXT, INFERENCE_MIN_MAX_TOKENS, ELICIT_TIMEOUT_MS, ELICIT_UNSHOWN_MS, elicitUnshown, POLL_SECONDS2, TRANSFER_CHANGE_READ_MS, TEMP_CLEAN_DELAY_MS, KEPT_ON_DISK, MAX_SHIELDED_BALANCE_ATOMIC, receiveGenerator, MCP_TOOL_NAMES, MCP_HIDDEN_TOOL_NAMES, setupTerminalNext, SETUP_RUNNING_SAY, ACCEPTED_NEXT, SETUP_RUNNING_NEXT, SETUP_ANSWER_WAIT_MS, SETUP_CONFIRMING_SAY, SETUP_CONFIRMING_NEXT, PRIVATE_INFERENCE_WHY, RESTART_STEPS, TOR_BROWSER_PORT, SETUP_TOR_TITLE, SETUP_TOR_WHY;
 var init_tools = __esm({
   "wallet/src/mcp/tools.mjs"() {
     "use strict";
@@ -134904,6 +135143,12 @@ var init_tools = __esm({
     AUTO_BACKUP_NAME = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z(-\d+)?$/;
     AUTO_BACKUP_VERIFIED = ".verified";
     FRONTED_SETTLE_MARGIN_SLOTS = 20;
+    UNSHIELD_WINDOW_YIELD_MS = 1500;
+    NOT_FINAL_YET = /confirmed note-exit is not finalized spent/;
+    FINISH_FINALITY_WAIT_MS = 4e3;
+    FINISH_FINALITY_WAITS = 8;
+    FINISH_FINALITY_RECENT_MS = 6e4;
+    walkStillCurrent = (store, early) => early !== void 0 && early.pool === String(store.state.pool) && walletHistoryHomeMarks(store) === early.marks ? early.history : void 0;
     BALANCE_REFRESH_WAIT_MS = 2e4;
     BALANCE_REFRESH_GRACE_MS = 2e3;
     BALANCE_REFRESH_LONG_MS = 6e4;