shinjuku-shielded 0.3.183 → 0.3.185

package/README.md

@@ -6,13 +6,13 @@ answers privately, in a terminal chat or for your agent app. Its `mcp`
 command runs a local MCP server (stdio) for your agent. Your keys never
 leave your machine.
 
-This is version 0.3.183. The npm packages `shinjuku-shield` and
+This is version 0.3.185. The npm packages `shinjuku-shield` and
 `shinjuku-shielded` hold the same files. The command is `shinjuku`.
 
 ## Set up
 
 ```sh
-npx -y shinjuku@0.3.183 setup
+npx -y shinjuku@0.3.185 setup
 ```
 
 Setup offers to install the `shinjuku` command and, on Windows, adds npm's
@@ -35,13 +35,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.183 mcp
+claude mcp add --scope user shinjuku -- npx -y --no-audit --no-fund shinjuku-shield@0.3.185 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.183", "mcp"] } } }
+{ "mcpServers": { "shinjuku": { "command": "npx", "args": ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.185", "mcp"] } } }
 ```
 
 On native Windows, if the host cannot find `npx`, use `"command": "cmd"` and
@@ -54,7 +54,7 @@ Codex (the Codex app and Codex CLI read the same file, `~/.codex/config.toml`):
 ```toml
 [mcp_servers.shinjuku]
 command = "npx"
-args = ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.183", "mcp"]
+args = ["-y", "--no-audit", "--no-fund", "shinjuku-shield@0.3.185", "mcp"]
 startup_timeout_sec = 120
 tool_timeout_sec = 300
 ```

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "d67bcc6c4e3910c2c10af366bc4f0dfab14e7023805cd9b15ebe92f68ba41098",
-  "bytes": 9344406,
-  "sourceCommit": "d57192d0800307fede3af52d006b6fb758fd0362",
+  "sha256": "cab378d1d911f907711de448e5c6525febcd0e73ff8988efcb4ae7d1fa82e961",
+  "bytes": 9351549,
+  "sourceCommit": "0e77401ed1e90cd6fa9035028ac5098ae6abbb6e",
   "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",
@@ -1038,5 +1038,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-11-06T15:11:02.328Z"
+  "publishedAt": "2026-11-06T17:17:10.158Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.183",
+  "version": "0.3.185",
   "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": "d67bcc6c",
-  "shinjukuSha256": "d67bcc6c4e3910c2c10af366bc4f0dfab14e7023805cd9b15ebe92f68ba41098",
+  "shinjukuRelease": "cab378d1",
+  "shinjukuSha256": "cab378d1d911f907711de448e5c6525febcd0e73ff8988efcb4ae7d1fa82e961",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-shield#readme",

package/shinjuku-wallet.mjs

@@ -588,6 +588,16 @@ function processLockAddress(name, platform = process.platform) {
   if (platform === "linux") return `\0shinjuku-lock-${hash12}`;
   return join2(tmpdir2(), `shinjuku-lock-${hash12.slice(0, 32)}.sock`);
 }
+async function processLockFree(name) {
+  const address4 = processLockAddress(name);
+  try {
+    (await listen(address4)).close();
+    return true;
+  } catch (error) {
+    if (!["EADDRINUSE", "EACCES"].includes(error?.code)) throw error;
+  }
+  return process.platform === "darwin" ? deadSocketFile(address4) : false;
+}
 async function takeProcessLock(name, {
   onWait = () => {
   },
@@ -43143,9 +43153,19 @@ function facilitatorRpcUrl(origin) {
     url = void 0;
   }
   const base = url && (url.protocol === "https:" || url.protocol === "http:") ? payHostOf(url.origin) : DEFAULT_FACILITATOR_ORIGIN;
-  relayOrigins.add(base);
+  if (!relayOrigins.has(base)) {
+    relayOrigins.add(base);
+    builtRelayOrigins.add(base);
+    try {
+      process.env[RELAY_ORIGINS_ENV] = [...builtRelayOrigins].join(" ");
+    } catch {
+    }
+  }
   return `${base}${FACILITATOR_RPC_PATH}`;
 }
+function relayOriginsEnv() {
+  return builtRelayOrigins.size ? { [RELAY_ORIGINS_ENV]: [...builtRelayOrigins].join(" ") } : {};
+}
 function isShinjukuRelayUrl(input) {
   try {
     const url = new URL(typeof input === "string" || input instanceof URL ? input : input?.url);
@@ -43189,7 +43209,7 @@ function resolveRpcUrl2({ rpcFile, rpc, env = process.env, origin, readFile: rea
   }
   return { url, source: "relay" };
 }
-var DEFAULT_FACILITATOR_ORIGIN, PAY_HOSTS, FACILITATOR_RPC_PATH, RPC_ENV, relayOrigins;
+var DEFAULT_FACILITATOR_ORIGIN, PAY_HOSTS, FACILITATOR_RPC_PATH, RPC_ENV, RELAY_ORIGINS_ENV, builtRelayOrigins, relayOrigins;
 var init_rpcDefault = __esm({
   "wallet/src/rpcDefault.mjs"() {
     "use strict";
@@ -43201,7 +43221,16 @@ var init_rpcDefault = __esm({
     });
     FACILITATOR_RPC_PATH = "/api/solana-rpc";
     RPC_ENV = "UNDERMARKET_SOLANA_RPC_URL";
-    relayOrigins = /* @__PURE__ */ new Set([DEFAULT_FACILITATOR_ORIGIN, ...Object.keys(PAY_HOSTS), ...Object.values(PAY_HOSTS)]);
+    RELAY_ORIGINS_ENV = "SHINJUKU_RELAY_ORIGINS";
+    builtRelayOrigins = new Set(String(process.env[RELAY_ORIGINS_ENV] ?? "").split(/\s+/).flatMap((value2) => {
+      try {
+        const url = new URL(value2);
+        return (url.protocol === "https:" || url.protocol === "http:") && url.origin === value2 ? [value2] : [];
+      } catch {
+        return [];
+      }
+    }));
+    relayOrigins = /* @__PURE__ */ new Set([DEFAULT_FACILITATOR_ORIGIN, ...Object.keys(PAY_HOSTS), ...Object.values(PAY_HOSTS), ...builtRelayOrigins]);
   }
 });
 
@@ -43832,6 +43861,16 @@ async function onOwnTagDispatcher(dispatcher, task) {
     }
   }
 }
+function routeDispatcherOf(url) {
+  let origin;
+  try {
+    origin = new URL(String(url)).origin;
+  } catch {
+    origin = void 0;
+  }
+  if (origin !== void 0 && routedOrigins.has(origin)) return onionInit({}).dispatcher;
+  return ownTag.getStore()?.dispatcher;
+}
 function onionInit(init = {}) {
   if (runEnded()) return init;
   const own = ownTagInit(init);
@@ -48313,6 +48352,40 @@ var init_relayLimit = __esm({
   }
 });
 
+// wallet/src/cli/homeJob.mjs
+function stepWords(lead, words2, line, { env = process.env, first, inline = false } = {}) {
+  const key = homeKeyOf(words2);
+  const comma = /\bor$/.test(lead) ? "" : ",";
+  if (inHomeJob(env) && key) return `${lead}${comma} ${first ? `${first}, then ` : ""}press [${key}] on the home screen.`;
+  return inline ? `${lead}: ${line}` : `${lead}${comma} run:
+  ${line}`;
+}
+function stepName(words2, line, { env = process.env } = {}) {
+  const key = homeKeyOf(words2);
+  return inHomeJob(env) && key ? `press [${key}] on the home screen` : line;
+}
+var HOME_JOB_ENV, LAUNCHER_PID_ENV, inHomeJob, HOME_KEY, JOB_NAME, jobLabel, homeKeyOf;
+var init_homeJob = __esm({
+  "wallet/src/cli/homeJob.mjs"() {
+    "use strict";
+    HOME_JOB_ENV = "SHINJUKU_WALLET_HOME_JOB";
+    LAUNCHER_PID_ENV = "SHINJUKU_WALLET_LAUNCHER_PID";
+    inHomeJob = (env = process.env) => env?.[HOME_JOB_ENV] === "1";
+    HOME_KEY = { "add-funds": "a", unshield: "u", curl: "p", chat: "t", setup: "s", restore: "r", limits: "l" };
+    JOB_NAME = {
+      "add-funds": "add funds",
+      unshield: "send money out",
+      curl: "pay a link",
+      chat: "private AI chat",
+      setup: "setup",
+      restore: "restore",
+      limits: "spending limits"
+    };
+    jobLabel = (name, typed, env = process.env) => inHomeJob(env) && JOB_NAME[name] ? JOB_NAME[name] : typed;
+    homeKeyOf = (words2) => HOME_KEY[String(words2 ?? "").trim().split(/\s+/)[0]];
+  }
+});
+
 // wallet/src/net/proxy.mjs
 import { spawn } from "node:child_process";
 import { randomBytes as randomBytes5 } from "node:crypto";
@@ -48825,7 +48898,8 @@ function proxiedChild(args, plainProxy, stdio) {
     NODE_USE_ENV_PROXY: "1",
     NODE_OPTIONS: proxiedNodeOptions(process.env.NODE_OPTIONS),
     ...proxyEnv(proxy),
-    [MARK]: `tor ${proxy}`
+    [MARK]: `tor ${proxy}`,
+    [LAUNCHER_PID_ENV]: launcherPid()
   };
   delete env[QUIET_RUN_MARK];
   const quiet = quietRun(args);
@@ -48836,7 +48910,7 @@ function reexec(args, plainProxy) {
   return waitForChild(proxiedChild(args, plainProxy, "inherit"));
 }
 function directChild(args) {
-  const env = { ...process.env, [DIRECT_RUN_MARK]: "1" };
+  const env = { ...process.env, [DIRECT_RUN_MARK]: "1", [LAUNCHER_PID_ENV]: launcherPid() };
   delete env.NODE_USE_ENV_PROXY;
   if (env.NODE_OPTIONS !== void 0) env.NODE_OPTIONS = withoutEnvProxyFlag(env.NODE_OPTIONS);
   return spawn(
@@ -48981,7 +49055,7 @@ function torChild(argv2, stdio) {
   if (!options.mode) throw new ProxyUsageError("torChild needs --tor");
   return proxiedChild(options.args, options.proxy, stdio);
 }
-var relayKeyOf, READ_ONLY_METHOD, readOnlyPost, TOR_HTTP_TUNNEL, TOR_CHECK, PROOF_TIMEOUT_MS, LOCAL_PROOF_TIMEOUT_MS, LOCAL_PROOF_MAX_BYTES, torProvenAt, proxyProvenAt, MARK, TOR_RUN_STARTED_ENV, ownProxyRefused, ONION_V3, RETRY_AFTER_CAP_MS, RETRY_AFTER_FLOOR_MS, RETRY_AFTER_DEFAULT_MS, RPC_NO_ANSWER_LIMIT_MS, RPC_PACING_CAP_MS, PACING_NOTICE_EVERY_MS, PACING_RATE_WINDOW_MS, TOR_MAX_ROTATIONS, runStartedAt, rpcNotBefore, pacingWaiters, pacingSince, pacedMs, rpcAnswered, lastAnswerAt, readSteps, pacingNoticeAt, pacingSamples, torMoves, torCircuitId, torMovesRefused, pendingMove, inTorRunOf, inTorRun, runNetworkMode, isOnionOrigin, ProxyUsageError, isOnionHost, PROXY_REMOVED, ENV_PROXY_NAMES, OUTER_PROXY_ENV, DIRECT_RUN_MARK, USE_ENV_PROXY_FLAG, withoutEnvProxyFlag, TOR_MIN_VERSION, localTorProof, TOR_EXPERT_BUNDLE, TOR_EXPERT_BUNDLE_SHA256, TOR_EXPERT_BUNDLE_URL, TUNNEL_LINE, TOR_DEB_KEY, TOR_DEB_KEYRING, TOR_INSTALL, torStart, LOCAL_TUNNEL, torStartText, TOR_WINDOW, torNotRunningMessage, torUpdateHow, TOR_STOP_OLD_WINDOWS, torTooOldWhy, torTooOldMessage, NOTICE, TOR_NOTICE_LINE, ONION_DETAIL_LINE, withoutOnionDetail, QUIET_RUN_MARK, QUIET_RUNS, QUIET_TERMINAL_COMMANDS, INFER_SUBCOMMANDS, quietRun, TOR_TROUBLE_LINE, TOR_WAIT_PLAIN, TOR_TROUBLE_PLAIN, promptRedraw, TOR_TROUBLE_SAID, quietTorErr, withRunTag, proxyEnv, pacedSoFar, RESENDABLE_METHOD, torCircuit, GLOBAL_DISPATCHER4, laneDispatchers, laneOfDispatcher, PROXY_WARNING_FLAG, proxiedExecArgv, proxiedNodeOptions, TOR_FROM_CONFIG_ENV, TOR_FROM_CONFIG_HINT, TOR_FROM_CONFIG_SENTENCE, torStarter;
+var relayKeyOf, READ_ONLY_METHOD, readOnlyPost, TOR_HTTP_TUNNEL, TOR_CHECK, PROOF_TIMEOUT_MS, LOCAL_PROOF_TIMEOUT_MS, LOCAL_PROOF_MAX_BYTES, torProvenAt, proxyProvenAt, MARK, TOR_RUN_STARTED_ENV, ownProxyRefused, ONION_V3, RETRY_AFTER_CAP_MS, RETRY_AFTER_FLOOR_MS, RETRY_AFTER_DEFAULT_MS, RPC_NO_ANSWER_LIMIT_MS, RPC_PACING_CAP_MS, PACING_NOTICE_EVERY_MS, PACING_RATE_WINDOW_MS, TOR_MAX_ROTATIONS, runStartedAt, rpcNotBefore, pacingWaiters, pacingSince, pacedMs, rpcAnswered, lastAnswerAt, readSteps, pacingNoticeAt, pacingSamples, torMoves, torCircuitId, torMovesRefused, pendingMove, inTorRunOf, inTorRun, runNetworkMode, isOnionOrigin, ProxyUsageError, isOnionHost, PROXY_REMOVED, ENV_PROXY_NAMES, OUTER_PROXY_ENV, DIRECT_RUN_MARK, USE_ENV_PROXY_FLAG, withoutEnvProxyFlag, TOR_MIN_VERSION, localTorProof, TOR_EXPERT_BUNDLE, TOR_EXPERT_BUNDLE_SHA256, TOR_EXPERT_BUNDLE_URL, TUNNEL_LINE, TOR_DEB_KEY, TOR_DEB_KEYRING, TOR_INSTALL, torStart, LOCAL_TUNNEL, torStartText, TOR_WINDOW, torNotRunningMessage, torUpdateHow, TOR_STOP_OLD_WINDOWS, torTooOldWhy, torTooOldMessage, NOTICE, TOR_NOTICE_LINE, ONION_DETAIL_LINE, withoutOnionDetail, QUIET_RUN_MARK, QUIET_RUNS, QUIET_TERMINAL_COMMANDS, INFER_SUBCOMMANDS, quietRun, TOR_TROUBLE_LINE, TOR_WAIT_PLAIN, TOR_TROUBLE_PLAIN, promptRedraw, TOR_TROUBLE_SAID, quietTorErr, withRunTag, proxyEnv, pacedSoFar, RESENDABLE_METHOD, torCircuit, GLOBAL_DISPATCHER4, laneDispatchers, laneOfDispatcher, PROXY_WARNING_FLAG, proxiedExecArgv, proxiedNodeOptions, TOR_FROM_CONFIG_ENV, TOR_FROM_CONFIG_HINT, TOR_FROM_CONFIG_SENTENCE, launcherPid, torStarter;
 var init_proxy = __esm({
   "wallet/src/net/proxy.mjs"() {
     "use strict";
@@ -48993,6 +49067,7 @@ var init_proxy = __esm({
     init_relayLimit();
     init_rpcDefault();
     init_phaseTiming();
+    init_homeJob();
     relayKeyOf = (input) => {
       if (!isShinjukuRelayUrl(input)) return void 0;
       return `${new URL(typeof input === "string" || input instanceof URL ? input : input.url).origin}${FACILITATOR_RPC_PATH}`;
@@ -49181,6 +49256,7 @@ ${command}`;
     TOR_FROM_CONFIG_ENV = "SHINJUKU_WALLET_TOR_FROM_CONFIG";
     TOR_FROM_CONFIG_HINT = '. Tor is on for every command because setup recorded it (config.json "tor": true); to run this one command without Tor, add --no-tor (the servers then see your IP address)';
     TOR_FROM_CONFIG_SENTENCE = " Tor is on for every command because you chose it in setup.";
+    launcherPid = () => process.env[LAUNCHER_PID_ENV] ?? String(process.ppid);
   }
 });
 
@@ -83575,7 +83651,7 @@ var init_p03LoopLag = __esm({
 });
 
 // src/server/payments/shielded/p03IndexedReplay.ts
-var import_web3110, ERROR_KINDS, P03_E1_MOVE_INPUTS, MOVE_VALUE_INDICES, MOVE_HEAD_BYTES3, UPGRADEABLE_LOADER, TOKEN_PROGRAM, E1_CHANGELOG_BYTES2, P03_E1_TREE_READ_BYTES, rpcHttpFetch;
+var import_web3110, P03_E1_BEHIND_RETRY_MS, P03_E1_BEHIND_RETRIES, P03_E1_BEHIND_POLL_MS, P03_E1_BEHIND_KEEPS, ERROR_KINDS, P03_E1_MOVE_INPUTS, MOVE_VALUE_INDICES, MOVE_HEAD_BYTES3, UPGRADEABLE_LOADER, TOKEN_PROGRAM, E1_CHANGELOG_BYTES2, P03_E1_TREE_READ_BYTES, rpcHttpFetch;
 var init_p03IndexedReplay = __esm({
   "src/server/payments/shielded/p03IndexedReplay.ts"() {
     "use strict";
@@ -83587,6 +83663,10 @@ var init_p03IndexedReplay = __esm({
     init_p03MinContextSlotRetry();
     init_p03LoopLag();
     init_ShieldedSolanaP03Types();
+    P03_E1_BEHIND_RETRY_MS = 1e3;
+    P03_E1_BEHIND_RETRIES = 2;
+    P03_E1_BEHIND_POLL_MS = 200;
+    P03_E1_BEHIND_KEEPS = P03_E1_BEHIND_RETRIES * (1 + Math.floor((P03_E1_BEHIND_RETRY_MS - 1) / P03_E1_BEHIND_POLL_MS));
     ERROR_KINDS = /* @__PURE__ */ new Map([
       [E1_ERROR_CODES2.E1NotInGap, "not-in-gap"],
       [E1_ERROR_CODES2.E1LeafModified, "leaf-modified"],
@@ -106022,6 +106102,16 @@ function refundEtaLeft(dueAtMs, now = Date.now()) {
 function floatRefundReadDue(record, now = Date.now()) {
   return Number.isSafeInteger(record?.refundDueAtMs) && now >= record.refundDueAtMs - REFUND_READ_EARLY_MS;
 }
+function sellerWaitMs(record) {
+  const seconds2 = (record?.sellerRequirement ?? record?.requirement)?.maxTimeoutSeconds;
+  if (!Number.isSafeInteger(seconds2) || seconds2 <= 0 || seconds2 > SELLER_TIMEOUT_ABSURD_SECONDS) return SELLER_TIMEOUT_MS;
+  return Math.min(Math.max(seconds2 * 1e3, SELLER_TIMEOUT_MS), FLOAT_KEEP_BYTES_MS);
+}
+function sellerAnswerInit(url, init, ms) {
+  const target = () => init.dispatcher ?? routeDispatcherOf(url) ?? globalThis[GLOBAL_DISPATCHER5];
+  if (target() === void 0) return init;
+  return { ...init, dispatcher: { dispatch: (options, handler) => target().dispatch({ ...options, headersTimeout: ms, bodyTimeout: ms }, handler) } };
+}
 async function sellerRefusalText(response) {
   let text3 = "";
   let reader;
@@ -107488,7 +107578,8 @@ async function payViaFloat({
     let resendUntilMs;
     let answeredAtMs;
     let dispatcher;
-    const sellerTimeout = AbortSignal.timeout(SELLER_TIMEOUT_MS);
+    const waitMs = sellerWaitMs(record);
+    const sellerTimeout = AbortSignal.timeout(waitMs);
     const stopResends = () => Date.now() > resendUntilMs || ["landed", "dead", "final", "cancelled"].includes(watch.verdict()?.state);
     for (let resend = 0; ; resend += 1) {
       const init = {
@@ -107500,7 +107591,7 @@ async function payViaFloat({
       };
       const socketWatch = resend === 0 ? watchRequestSocket(record.url) : void 0;
       try {
-        response = await fetchImpl(record.url, dispatcher === void 0 ? keepAliveInit(init) : { ...init, dispatcher });
+        response = await fetchImpl(record.url, sellerAnswerInit(record.url, dispatcher === void 0 ? keepAliveInit(init) : { ...init, dispatcher }, waitMs));
       } catch (error) {
         unanswered2(error);
       } finally {
@@ -107802,13 +107893,13 @@ async function selfBroadcastLeg({ store, walName: walName2, record, sendRequest,
     mark("seller-sent");
     let response;
     try {
-      response = await fetchImpl(record.url, keepAliveInit({
+      response = await fetchImpl(record.url, sellerAnswerInit(record.url, keepAliveInit({
         method: sendRequest.method,
         headers: { ...Object.fromEntries(sendRequest.headers), "PAYMENT-SIGNATURE": header },
         ...sendRequest.method === "POST" ? { body: Buffer.from(sendRequest.bodyBase64, "base64") } : {},
         redirect: "error",
-        signal: AbortSignal.timeout(SELLER_TIMEOUT_MS)
-      }));
+        signal: AbortSignal.timeout(sellerWaitMs(record))
+      }), sellerWaitMs(record)));
     } catch (error) {
       const timedOut = error?.name === "TimeoutError" || error?.cause?.name === "TimeoutError";
       if (!timedOut && !proxyRefusedConnection(error) && await resendUnanswered()) {
@@ -107939,7 +108030,7 @@ function paidResult(record, replayed) {
     float: { floatId: record.floatId }
   };
 }
-var import_web3115, FLOAT_PAYMENT_SCHEMA2, REGENERATE_CODES, FLOAT_PAYMENT_WAL_PREFIX2, FLOAT_CONFIG_SCHEMA, FLOAT_PAY_PATH, FLOAT_MEMO_PATH, FLOAT_STATUS_PATH, MAX_BODY_BYTES, FLOAT_REFUND_ETA_SECONDS, REFUND_READ_EARLY_MS, REFUND_ETA_MAX_SECONDS, refundDueOf, REFUND_SETTLED_AFTER_MS, REFUND_OUTCOME_NEWS_MS, FINISHING_POLL_MS, FINISHING_LIMIT_MS, SELLER_TIMEOUT_MS, FLOAT_STATUS_START_MS, FLOAT_STATUS_POLL_MS, FLOAT_STATUS_TIMEOUT_MS, FLOAT_TRANSFER_DEAD, FLOAT_PAYMENT_REVERTED, VERDICT_POLL_MS, SELLER_ANSWER_VERDICT_MS, TRANSFER_MIN_BLOCKS_LEFT, TRANSFER_FRESH_MS, BLOCK_HEIGHT_TIMEOUT_MS, CONFIG_TIMEOUT_MS, MEMO_UPLOAD_TIMEOUT_MS, CONFIG_CACHE_MS, FLOAT_POOL_WARM_MS, DECIMAL3, POSITIVE, PENDING_CODES, FLOAT_FRONT_HEADER, hash7, fail22, GENERIC_REASON, SELLER_REASON_MAX, SELLER_REASON_READ_BYTES, FEE_PAYER_RESENDS, FEE_PAYER_RESEND_MS, GLOBAL_DISPATCHER5, sortedJson, MODEL_ID, floatPaymentWalName, floatRecordName, FLOAT_KEEP_BYTES_MS, memoryOnlyNeedsScrub, FLOAT_KEEP_OPEN_REQUEST_MS, configCache, configGeneration, configReadSequence, configReads, configRefreshes, SPECULATED_MAX_AGE_MS, speculatedQuotes, poolDomains, FLOAT_FACTS_SCHEMA, floatFacts, floatFactsKey, floatFactsMac, poolDomainReads, poolDomainWarmFailedAt, WARM_RETRY_MS, payerGenerator, etaEntry, loadPayerGenerator, plainText, BROADCAST_REFUSED, BROADCAST_REFUSED_STANDARD, BROADCAST_DEAD, TRANSFER_LANDING_WINDOW_MS, PROOF_DELIVERY_MS, SELF_BROADCAST_LEG1_LEFT_MS, BROADCAST_UNSIGNED, BROADCAST_NO_LOOKUP, BROADCAST_LANDED, BROADCAST_LIMIT_MS, BROADCAST_QUOTE_MARGIN_MS, SELF_BROADCAST_RESEND_MS, SELF_BROADCAST_UNANSWERED_RESEND_MS, SELLER_HEADERS_MAX_COUNT, SELLER_HEADERS_MAX_BYTES, FINAL_AFTER_202_MS, SELLER_HEADERS_KEPT;
+var import_web3115, FLOAT_PAYMENT_SCHEMA2, REGENERATE_CODES, FLOAT_PAYMENT_WAL_PREFIX2, FLOAT_CONFIG_SCHEMA, FLOAT_PAY_PATH, FLOAT_MEMO_PATH, FLOAT_STATUS_PATH, MAX_BODY_BYTES, FLOAT_REFUND_ETA_SECONDS, REFUND_READ_EARLY_MS, REFUND_ETA_MAX_SECONDS, refundDueOf, REFUND_SETTLED_AFTER_MS, REFUND_OUTCOME_NEWS_MS, FINISHING_POLL_MS, FINISHING_LIMIT_MS, SELLER_TIMEOUT_MS, SELLER_TIMEOUT_ABSURD_SECONDS, FLOAT_STATUS_START_MS, FLOAT_STATUS_POLL_MS, FLOAT_STATUS_TIMEOUT_MS, FLOAT_TRANSFER_DEAD, FLOAT_PAYMENT_REVERTED, VERDICT_POLL_MS, SELLER_ANSWER_VERDICT_MS, TRANSFER_MIN_BLOCKS_LEFT, TRANSFER_FRESH_MS, BLOCK_HEIGHT_TIMEOUT_MS, CONFIG_TIMEOUT_MS, MEMO_UPLOAD_TIMEOUT_MS, CONFIG_CACHE_MS, FLOAT_POOL_WARM_MS, DECIMAL3, POSITIVE, PENDING_CODES, FLOAT_FRONT_HEADER, hash7, fail22, GENERIC_REASON, SELLER_REASON_MAX, SELLER_REASON_READ_BYTES, FEE_PAYER_RESENDS, FEE_PAYER_RESEND_MS, GLOBAL_DISPATCHER5, sortedJson, MODEL_ID, floatPaymentWalName, floatRecordName, FLOAT_KEEP_BYTES_MS, memoryOnlyNeedsScrub, FLOAT_KEEP_OPEN_REQUEST_MS, configCache, configGeneration, configReadSequence, configReads, configRefreshes, SPECULATED_MAX_AGE_MS, speculatedQuotes, poolDomains, FLOAT_FACTS_SCHEMA, floatFacts, floatFactsKey, floatFactsMac, poolDomainReads, poolDomainWarmFailedAt, WARM_RETRY_MS, payerGenerator, etaEntry, loadPayerGenerator, plainText, BROADCAST_REFUSED, BROADCAST_REFUSED_STANDARD, BROADCAST_DEAD, TRANSFER_LANDING_WINDOW_MS, PROOF_DELIVERY_MS, SELF_BROADCAST_LEG1_LEFT_MS, BROADCAST_UNSIGNED, BROADCAST_NO_LOOKUP, BROADCAST_LANDED, BROADCAST_LIMIT_MS, BROADCAST_QUOTE_MARGIN_MS, SELF_BROADCAST_RESEND_MS, SELF_BROADCAST_UNANSWERED_RESEND_MS, SELLER_HEADERS_MAX_COUNT, SELLER_HEADERS_MAX_BYTES, FINAL_AFTER_202_MS, SELLER_HEADERS_KEPT;
 var init_floatPay = __esm({
   "wallet/src/pay/floatPay.mjs"() {
     "use strict";
@@ -107986,6 +108077,7 @@ var init_floatPay = __esm({
     FINISHING_POLL_MS = 2e3;
     FINISHING_LIMIT_MS = 6e4;
     SELLER_TIMEOUT_MS = 12e4;
+    SELLER_TIMEOUT_ABSURD_SECONDS = 86400;
     FLOAT_STATUS_START_MS = 45e3;
     FLOAT_STATUS_POLL_MS = 5e3;
     FLOAT_STATUS_TIMEOUT_MS = 5e3;
@@ -135533,7 +135625,7 @@ ${canonical5}`;
   const balance = {
     name: "wallet_balance",
     title: "Balance",
-    description: `Use this when the user asks "what is my balance" or "how much USDC do I have": it answers ONE balance (balanceAtomic, what a payment can spend) and the public (unshielded) USDC. Always safe: it ${BALANCE_READ_DOES}. On "show my wallet", print \`card\` as it is (at most 8 lines). largestPaymentAtomic: the most ONE payment can spend now; a payment above it is not refused: pay_for_service gets the balance ready first (a tell-first answer, then doneInMinutesLow to doneInMinutesHigh minutes) (changeSettling: 0 only while the last payment's change settles, about changeReadyInSeconds; then one payment can use it all, or up to changeUpToAtomic). balanceParts (above 1): never tell the user about parts, accounts or a merge; say only that a large payment or send first gets the balance ready. balanceAtomic is one number; breakdown names the rest (shieldedAtomic is the same value; privateSendPendingAtomic is what a running private send has not sent yet, already taken off; refundsInFlightAtomic is a refund Shinjuku proved, on its way, not in balanceAtomic; refundsNotCertainAtomic a refund the seller may have kept, in no number; openPaymentsAtomic: paid, waiting on its seller (same request_id finishes it, else refunded); setAsideAtomic (when not 0): value an older version set aside; totalAtomic adds these; during a pool move, pools lists each pool's share and movingAtomic is value on its way to the new pool; the move field shows the move, poolSwitches each switch). unshieldedAtomic is the public USDC on the wallet's own Solana key (ownAddress), which wallet_shield makes private; unshieldedSolLamports is that key's SOL (Shinjuku pays every fee and rent). A stale balance (a new deposit, a received payment) reads the chain first; past about 20 s it answers the last balance with refreshing: true and finishes in the background (call again in 30 s); with a refreshReason that balance is exact and counts what the reason names (payment_settling: a payment that settles; account_join: all of it, while the wallet gets it ready to send; pool_move: value that arrives from the old pool; refund_check: a refund counted from an old read, which the wallet checks now (never tell the user it is still on its way); first_check: a new wallet's own landed deposits (its first history check)). status reading (balanceAtomic null): the first read of a wallet that may hold money is not done; call again in 30 s. If the public read fails, unshieldedAtomic is null with unshieldedReason. ownKeyTokens: the other tokens on ownAddress (not its USDC; [] when none; null when not read now: say nothing of other tokens), each { mint, amountAtomic, decimals, amount }, at most 10 (ownKeyTokensMore counts the rest); a token is its mint, never a name or symbol; this wallet has no tool that sells, swaps, or sends them: they stay on ownAddress. earlierDeposits (when any): USDC at an earlier pool's one-time deposit address, each with a notice line to tell the user; the wallet moves it itself. addFunds (when any): each wallet_add_funds address still open, with its state and the USDC known to wait there (heldAtomic; null with heldNote when not read in time). startsAtNextRequest true (old name): its deposit starts by itself once USDC is seen there (startsInMinutes; 0: at once). landingAtomic (when not 0): added USDC whose deposit landed on chain but is not in balanceAtomic yet; this call finishes it (up to about 20 s), else call again when next says. session: the spending limits (null or "none": no limit), what is left, and how to change them (session.summary, only when a limit is set). With no limit set, say nothing about limits or the session counters. To add money, use wallet_add_funds. version: this wallet's version. Amounts are atomic (1000000 = 1 USDC); say and usdc give USDC.`,
+    description: `Use this for "what is my balance" or "how much USDC do I have": it answers ONE balance (balanceAtomic, what a payment can spend) and the public (unshielded) USDC. Always safe: it ${BALANCE_READ_DOES}. On "show my wallet", print \`card\` as it is (at most 8 lines). largestPaymentAtomic: the most ONE payment can spend now; a payment above it is not refused: pay_for_service gets the balance ready first (a tell-first answer, then doneInMinutesLow to doneInMinutesHigh minutes) (changeSettling: 0 only while the last payment's change settles, about changeReadyInSeconds; then one payment can use it all, or up to changeUpToAtomic). balanceParts (above 1): never mention parts, accounts or a merge; say only that a large payment or send first gets the balance ready. balanceAtomic is one number; breakdown names the rest (shieldedAtomic is the same value; privateSendPendingAtomic is what a running private send has not sent yet, already taken off; refundsInFlightAtomic is a refund Shinjuku proved, on its way, not in balanceAtomic; refundsNotCertainAtomic a refund the seller may have kept, in no number; openPaymentsAtomic: paid, waiting on its seller (same request_id finishes it, else refunded); setAsideAtomic (when not 0): value an older version set aside; totalAtomic adds these; during a pool move, pools lists each pool's share, movingAtomic is value on its way to the new pool, and move and poolSwitches show the move). unshieldedAtomic is the public USDC on the wallet's own Solana key (ownAddress), which wallet_shield makes private; unshieldedSolLamports is that key's SOL (Shinjuku pays every fee and rent). A stale balance (a new deposit, a received payment) reads the chain first; past about 20 s it answers the last balance with refreshing: true and finishes in the background (call again in 30 s); with a refreshReason that balance is exact and counts what the reason names (payment_settling: a payment that settles; account_join: all of it, while the wallet gets it ready to send; pool_move: value that arrives from the old pool; refund_check: a refund counted from an old read, which the wallet checks now (never say it is still on its way); first_check: a new wallet's own landed deposits (its first history check)). status reading (balanceAtomic null): the first read of a wallet that may hold money is not done; call again in 30 s. If the public read fails, unshieldedAtomic is null with unshieldedReason. ownKeyTokens: the other tokens on ownAddress (not its USDC; [] when none; null when not read now: say nothing of other tokens), each { mint, amountAtomic, decimals, amount }, at most 10 (ownKeyTokensMore counts the rest); a token is its mint, never a name or symbol; no wallet tool sells, swaps or sends them: they stay on ownAddress. earlierDeposits (when any): USDC at an earlier pool's one-time deposit address, each with a notice line to tell the user; the wallet moves it itself. addFunds (when any): each open wallet_add_funds address, its state and the USDC known to wait there (heldAtomic; null with heldNote when not read in time). startsAtNextRequest true (old name): it starts by itself once USDC is seen there (startsInMinutes; 0: at once). landingAtomic (when not 0): added USDC that landed on chain, not in balanceAtomic yet; this call finishes it (up to about 20 s), else call again when next says. session: the spending limits (null or "none": no limit), what is left, and how to change them (session.summary, only when a limit is set). With no limit set, say nothing about limits or counters. To add money, use wallet_add_funds. version: this wallet's version. Amounts are atomic (1000000 = 1 USDC); say and usdc give USDC.`,
     inputSchema: { type: "object", properties: {
       verbose: { type: "boolean", description: "Optional. true adds `internal`: the engineering numbers (funded balance records, notes, payments without waiting, a 0 set-aside value). Default false." }
     }, additionalProperties: false },
@@ -140459,7 +140551,7 @@ ${canonical5}`;
     name: "wallet_unshield",
     // UX130-13: a host that defers tools may show only the title: it says where a send goes by default.
     title: "Send USDC privately",
-    description: `Use this when the user says "send 2 USDC to <address>" or "withdraw to my wallet" (for "my wallet" leave \`to\` out: it uses the address saved at setup, or says how to set one; never ask the user first): it sends amount (USDC, like "2"; or amount_atomic) from the PRIVATE balance as plain USDC to \`to\`, a public Solana address. BEFORE you call it to send all of the balance when wallet_balance showed balanceParts above 1, write to the user that the wallet first gets the balance ready to send (do not tell the user how the wallet stores the balance; some apps show nothing until this call ends). Privately: the chain shows the pool paying the address, not which wallet paid. This wallet's own public address (ownAddress in wallet_balance: it holds the public USDC, wallet_shield deposits from it) is refused as \`to\`: an exit there would show on chain that the private balance is this wallet's, even if that address never deposited (wallet_add_funds deposits come from one-time addresses, not from it; never tell the user they came from it). Shinjuku pays every network fee; no SOL is needed. The user's saved own addresses (setup or this app's wallet entry) send at once. Any other address needs the user's yes in a dialog of this app; a client that cannot ask is refused (mcp_unshield_to_not_allowed) and a decline sends nothing (mcp_unshield_declined). \`to\` must already be able to receive USDC: an address that cannot is refused before any dialog (mcp_unshield_to_invalid). It runs in steps and may wait for the pool's next anchor. Each call answers within about 20 s (at once when the send ends; a dialog may take longer) with ok: true and stage: confirming, queued, refreshing, self-pay = preparing, exit = sending, done; joining = the wallet first gets the balance ready to send, then sends, and each call goes on with it (joinSteps: its steps, in order; doneInMinutesLow to doneInMinutesHigh: the time to say). For the status, call wallet_unshield again with the SAME request_id, amount and to. When the wallet must first get the balance ready to send, the FIRST call answers at once with stage joining and joinTellFirst: true; write its say to the user, then call again with the same request_id at once. One exception: when this app sends a progress token with that next call, the call gets the balance ready and then sends, with a progress line every ${JOIN_STEP_MS / 1e3} s ("getting your balance ready to send"; some apps show none, so the line is said before the call, as above). It answers when the send is done, or after about ${joinAnswerSeconds(JOIN_CALL_MAX_MS)} s with how far it got (joinsDone; sendState sending: the USDC is leaving, never say nothing moved); then call again with the same request_id. Without a progress token it answers within about 20 s with stage joining: call again until it sends. The same request_id never sends twice, also after a restart. request_id is optional: without it the answer names the id it made, and the same call again within 10 minutes after it ends reads that same send. An optional unshield limit the user sets may bound each call and what this wallet sends in any 24 hours, from every app (mcp_unshield_cap_exceeded: tell the user). Other refusals: mcp_argument_invalid, mcp_request_id_reused, wallet_locked, mcp_tool_disabled, mcp_unshield_failed, and the unshield's own p03_* codes. A call the app stopped or calls rejected or interrupted, or one that failed, may still send: call wallet_cancel (no request_id) before you tell the user anything about that send; never say nothing was sent without it. A send is one payment to \`to\`. ${HOST_BLOCKED_LINE}`,
+    description: `Use this for "send 2 USDC to <address>" or "withdraw to my wallet" (for "my wallet" leave \`to\` out: it uses the address saved at setup, or says how to set one; never ask the user first): it sends amount (USDC, like "2"; or amount_atomic) from the PRIVATE balance as plain USDC to \`to\`, a public Solana address. BEFORE you call it to send all of the balance when wallet_balance showed balanceParts above 1, write to the user that the wallet first gets the balance ready to send (never say how the wallet stores the balance; some apps show nothing until this call ends). Privately: the chain shows the pool paying the address, not which wallet paid. This wallet's own public address (ownAddress in wallet_balance: it holds the public USDC, wallet_shield deposits from it) is refused as \`to\`: an exit there would show on chain that the private balance is this wallet's, even if that address never deposited (wallet_add_funds deposits come from one-time addresses, not from it; never tell the user they came from it). Shinjuku pays every network fee; no SOL is needed. The user's saved own addresses (setup or this app's wallet entry) send at once. Any other address needs the user's yes in a dialog of this app; a client that cannot ask is refused (mcp_unshield_to_not_allowed) and a decline sends nothing (mcp_unshield_declined). \`to\` must already be able to receive USDC: an address that cannot is refused before any dialog (mcp_unshield_to_invalid). It runs in steps and may wait for the pool's next anchor. Each call answers within about 20 s (at once when the send ends; a dialog may take longer) with ok: true and stage: confirming, queued, refreshing, self-pay = preparing, exit = sending, done; joining = the wallet first gets the balance ready, then sends; each call goes on with it (joinSteps: its steps, in order; doneInMinutesLow to doneInMinutesHigh: the time to say). For the status, call wallet_unshield again with the SAME request_id, amount and to. When the balance must first be made ready, the FIRST call answers at once with stage joining and joinTellFirst: true; write its say to the user, then call again with the same request_id at once. One exception: when this app sends a progress token with that next call, the call gets the balance ready and then sends, with a progress line every ${JOIN_STEP_MS / 1e3} s ("getting your balance ready to send"; some apps show none, so the line is said before the call, as above). It answers when the send is done, or after about ${joinAnswerSeconds(JOIN_CALL_MAX_MS)} s with how far it got (joinsDone; sendState sending: the USDC is leaving, never say nothing moved); then call again with the same request_id. Without a progress token it answers within about 20 s with stage joining: call again until it sends. The same request_id never sends twice, also after a restart. request_id is optional: without it the answer names the id it made, and the same call again within 10 minutes after it ends reads that same send. An optional unshield limit the user sets may bound each call and what this wallet sends in any 24 hours, from every app (mcp_unshield_cap_exceeded: tell the user). Other refusals: mcp_argument_invalid, mcp_request_id_reused, wallet_locked, mcp_tool_disabled, mcp_unshield_failed, and the unshield's own p03_* codes. A call the app stopped, rejected or interrupted, or one that failed, may still send: call wallet_cancel (no request_id) before you tell the user anything about that send; never say nothing was sent without it. A send is one payment to \`to\`. ${HOST_BLOCKED_LINE}`,
     inputSchema: {
       type: "object",
       properties: {
@@ -146898,39 +146990,6 @@ var init_consolePaste = __esm({
   }
 });
 
-// wallet/src/cli/homeJob.mjs
-function stepWords(lead, words2, line, { env = process.env, first, inline = false } = {}) {
-  const key = homeKeyOf(words2);
-  const comma = /\bor$/.test(lead) ? "" : ",";
-  if (inHomeJob(env) && key) return `${lead}${comma} ${first ? `${first}, then ` : ""}press [${key}] on the home screen.`;
-  return inline ? `${lead}: ${line}` : `${lead}${comma} run:
-  ${line}`;
-}
-function stepName(words2, line, { env = process.env } = {}) {
-  const key = homeKeyOf(words2);
-  return inHomeJob(env) && key ? `press [${key}] on the home screen` : line;
-}
-var HOME_JOB_ENV, inHomeJob, HOME_KEY, JOB_NAME, jobLabel, homeKeyOf;
-var init_homeJob = __esm({
-  "wallet/src/cli/homeJob.mjs"() {
-    "use strict";
-    HOME_JOB_ENV = "SHINJUKU_WALLET_HOME_JOB";
-    inHomeJob = (env = process.env) => env?.[HOME_JOB_ENV] === "1";
-    HOME_KEY = { "add-funds": "a", unshield: "u", curl: "p", chat: "t", setup: "s", restore: "r", limits: "l" };
-    JOB_NAME = {
-      "add-funds": "add funds",
-      unshield: "send money out",
-      curl: "pay a link",
-      chat: "private AI chat",
-      setup: "setup",
-      restore: "restore",
-      limits: "spending limits"
-    };
-    jobLabel = (name, typed, env = process.env) => inHomeJob(env) && JOB_NAME[name] ? JOB_NAME[name] : typed;
-    homeKeyOf = (words2) => HOME_KEY[String(words2 ?? "").trim().split(/\s+/)[0]];
-  }
-});
-
 // wallet/src/cli/homeMark.mjs
 var MARK_WIDTH, MARK2, MARK_CLASS, EYE, COMPACT_MARK;
 var init_homeMark = __esm({
@@ -147789,7 +147848,15 @@ function homeScreenNeeds() {
   }
   return { columns: MIN_COLUMNS, rows: 80 };
 }
-async function runJobView({ title, run: run2, stdout = process.stdout, stdin = process.stdin, env = process.env } = {}) {
+async function runJobView({
+  title,
+  run: run2,
+  stdout = process.stdout,
+  stdin = process.stdin,
+  env = process.env,
+  launcherGone = launcherWatch(),
+  platform = process.platform
+} = {}) {
   const codes = paletteFor(screenColor(stdout, env));
   const paint2 = (parts) => parts.map(([text3, cls]) => codes && cls ? `${codes[cls]}${text3}${RESET2}` : text3).join("");
   const write = (text3) => {
@@ -147811,6 +147878,22 @@ ${rule}
     code2 = 1;
   }
   const end2 = code2 === 0 ? [["\u25C6 ", "crim"], [`${clean4(title)}: done`, "bone"]] : code2 === 130 ? [["\u25C6 ", "crim"], [`${clean4(title)}: stopped (Ctrl+C)`, "bone"]] : [["\u25CB ", "mute"], [`${clean4(title)}: it stopped; its message is above`, "bone"]];
+  const gone = () => {
+    try {
+      return launcherGone();
+    } catch {
+      return false;
+    }
+  };
+  const shellAgain = (first) => write(`${first ? `
+${"\u2500".repeat(width)}
+${end2.map(([text3]) => text3).join("")}
+` : ""}The wallet screen has closed: the command that started it ended with the Ctrl+C.
+` + (platform === "win32" ? 'If this window asks "Terminate batch job (Y/N)?", type Y and press Enter. ' : "") + "To open the wallet again, run the same command.\n");
+  if (gone()) {
+    shellAgain(true);
+    return { code: code2, next: "quit", launcherGone: true };
+  }
   write(`
 ${rule}
 ${paint2(end2)}
@@ -147820,15 +147903,24 @@ ${paint2([["any other key, [q] too, goes back to the home screen", "mute"]])}
   if (!stdin?.isTTY || typeof stdin.setRawMode !== "function") return { code: code2, next: "quit" };
   const rawBefore = Boolean(stdin.isRaw);
   let key;
+  let ended2 = false;
+  let poll;
   try {
     stdin.setRawMode(true);
     key = await new Promise((done) => {
       stdin.once("data", (chunk) => done(String(chunk)));
+      poll = setInterval(() => {
+        if (gone()) {
+          ended2 = true;
+          done(void 0);
+        }
+      }, LAUNCHER_POLL_MS);
       stdin.resume();
     });
   } catch {
     key = void 0;
   } finally {
+    clearInterval(poll);
     stdin.pause();
     await stopReading(stdin);
     try {
@@ -147836,8 +147928,24 @@ ${paint2([["any other key, [q] too, goes back to the home screen", "mute"]])}
     } catch {
     }
   }
+  if (ended2) {
+    shellAgain(false);
+    return { code: code2, next: "quit", launcherGone: true };
+  }
   return key === void 0 ? { code: code2, next: "quit" } : { code: code2, next: "back", key };
 }
+function launcherWatch(launcher = LAUNCHER_AT_LOAD, parent = PARENT_AT_LOAD) {
+  return () => {
+    if (!Number.isSafeInteger(launcher) || launcher <= 1) return false;
+    if (process.ppid !== parent) return true;
+    try {
+      process.kill(launcher, 0);
+      return false;
+    } catch (error) {
+      return error?.code !== "EPERM";
+    }
+  };
+}
 async function waitForRoom({ stdout = process.stdout, stdin = process.stdin, env = process.env } = {}) {
   if (!stdin?.isTTY || typeof stdin.setRawMode !== "function") return "off";
   const needs = homeScreenNeeds();
@@ -147892,11 +148000,12 @@ async function waitForRoom({ stdout = process.stdout, stdin = process.stdin, env
     }
   }
 }
-var MIN_COLUMNS, WIDE_COLUMNS, WIDE_WIDTH, LEFT_X, LEFT_WIDTH, PANEL_X, PANEL_WIDTH, TOP, BAND_MS, BAND_CHANCE, KATAKANA, FONT, AGENT_KEY, HELP_KEY, QUIT_KEY, KEY_HELP, lettersOf, PANELS, ALL_PIECES, KEYS_LINE, FIRST_LINES, SETUP_KEY, RESTORE_KEY, END_KEYS, RESTORE_STEP, HINT, tooSmallLines, COLORS, COLORS_16, RESET2, DATA_SYMBOLS, HOME_SHAPE, FIRST_SHAPE, WIDE, WORD_TOP, WORD_BOTTOM, WORD_WIDTH, ROMAJI, BIG_MARK, SMALL_MARK, LOCKUP_GAP, LOCKUP_WIDTH, Screen, setupLine, randomKatakana, MARK_TONES, PUBLIC_STEP, stackHeight;
+var MIN_COLUMNS, WIDE_COLUMNS, WIDE_WIDTH, LEFT_X, LEFT_WIDTH, PANEL_X, PANEL_WIDTH, TOP, BAND_MS, BAND_CHANCE, KATAKANA, FONT, AGENT_KEY, HELP_KEY, QUIT_KEY, KEY_HELP, lettersOf, PANELS, ALL_PIECES, KEYS_LINE, FIRST_LINES, SETUP_KEY, RESTORE_KEY, END_KEYS, RESTORE_STEP, HINT, tooSmallLines, COLORS, COLORS_16, RESET2, DATA_SYMBOLS, HOME_SHAPE, FIRST_SHAPE, WIDE, WORD_TOP, WORD_BOTTOM, WORD_WIDTH, ROMAJI, BIG_MARK, SMALL_MARK, LOCKUP_GAP, LOCKUP_WIDTH, Screen, setupLine, randomKatakana, MARK_TONES, PUBLIC_STEP, stackHeight, LAUNCHER_POLL_MS, LAUNCHER_AT_LOAD, PARENT_AT_LOAD;
 var init_homeScreen = __esm({
   "wallet/src/cli/homeScreen.mjs"() {
     "use strict";
     init_homeMark();
+    init_homeJob();
     MIN_COLUMNS = 80;
     WIDE_COLUMNS = 120;
     WIDE_WIDTH = 119;
@@ -148057,6 +148166,9 @@ var init_homeScreen = __esm({
       "at-most": "your private balance is at its most (5 USDC)."
     };
     stackHeight = (blocks) => blocks.reduce((sum2, block) => sum2 + block.height, 0) + blocks.length - 1;
+    LAUNCHER_POLL_MS = 250;
+    LAUNCHER_AT_LOAD = /^[0-9]+$/.test(process.env[LAUNCHER_PID_ENV] ?? "") ? Number(process.env[LAUNCHER_PID_ENV]) : process.ppid;
+    PARENT_AT_LOAD = process.ppid;
   }
 });
 
@@ -148767,9 +148879,11 @@ async function runChat({ io, values, deps = {} }) {
     return typeof deps.balanceLine === "function" ? deps.balanceLine(parts) : `${balanceWords(parts)}.`;
   };
   const entryOf = (id) => catalog.models.find((entry) => entry.id === id) ?? models.find((entry) => entry.id === id);
+  const fullTokensOf = (id) => defaultMaxTokens(id, liveOf(id) ?? models.find((entry) => entry.id === id));
   const tokensFor = (id, messages, limit) => {
     try {
-      return BigInt(inference.ceilingAtomic({ model: id, messages, maxTokens: CHAT_MAX_TOKENS, liveEntry: liveOf(id) })) <= limit ? CHAT_MAX_TOKENS : CHAT_SHORT_TOKENS;
+      const full = fullTokensOf(id);
+      return BigInt(inference.ceilingAtomic({ model: id, messages, maxTokens: full, liveEntry: liveOf(id) })) <= limit ? full : CHAT_SHORT_TOKENS;
     } catch {
       return CHAT_SHORT_TOKENS;
     }
@@ -148778,7 +148892,7 @@ async function runChat({ io, values, deps = {} }) {
     let maxTokens = tokensFor(id, [{ role: "user", content: "x" }], turnLimit());
     const messages = SHORT_QUESTION;
     const ceilingAtomic2 = BigInt(inference.ceilingAtomic({ model: id, messages, maxTokens, liveEntry: liveOf(id) }));
-    if (ceilingAtomic2 > caps.answer && maxTokens !== CHAT_MAX_TOKENS) maxTokens = CHAT_MAX_TOKENS;
+    if (ceilingAtomic2 > caps.answer && maxTokens !== fullTokensOf(id)) maxTokens = fullTokensOf(id);
     return priceOf2({ model: id, messages, maxTokens });
   };
   const priceText = answerPriceWords;
@@ -148874,7 +148988,7 @@ async function runChat({ io, values, deps = {} }) {
     "Private: each answer is paid from your private balance, and the chain does not show which wallet paid. Your words go out only through Tor, so the AI provider and the company that runs the model never see your IP address. They do see your words and the answers.",
     // payAndFetch opts.memoryOnly (floatPay.mjs MEMORY ONLY): the payment record holds amounts, ids and hashes only.
     "Memory only: the chat writes no chat file and no log, and the wallet writes no copy of the conversation, not even encrypted: its payment records keep only the amounts. The conversation is gone when the chat ends. Let an answer arrive before you end the chat: if the chat ends while an answer is on its way, that answer is gone, and a payment already sent may not come back.",
-    `Cost: each answer pays the AI provider's price for up to ${CHAT_MAX_TOKENS} tokens (${CHAT_SHORT_TOKENS} for a model whose longer answer is above your limit) plus the 0.001 USDC Shinjuku fee, up front, so a short answer costs as much as a long one; what an answer does not use is not refunded. With ${state2.model}, ${lowFirst(costLine2(state2.model))}. ` + (state2.mode === "talk" ? "Each question sends the whole conversation, so a long chat costs more (/new starts again)." : "In this mode each question goes alone, so each costs about the same."),
+    `Cost: each answer pays the AI provider's price for up to ${CHAT_MAX_TOKENS} tokens (${CHAT_SHORT_TOKENS} for a costly model, or one whose longer answer is above your limit) plus the 0.001 USDC Shinjuku fee, up front, so a short answer costs as much as a long one; what an answer does not use is not refunded. With ${state2.model}, ${lowFirst(costLine2(state2.model))}. ` + (state2.mode === "talk" ? "Each question sends the whole conversation, so a long chat costs more (/new starts again)." : "In this mode each question goes alone, so each costs about the same."),
     `Mode: ${modeName()}. One question at a time sends each question alone and names each payment; a conversation lets the AI remember the chat and shows the running total. /mode 1 or /mode 2 changes it.`,
     caps.answer >= NO_CAP && caps.chat >= NO_CAP ? `Limits: none${capsSourceText(caps)}` : `Limits: ${capWords(caps.answer)} an answer and ${capWords(caps.chat)} for this chat${capsSourceText(caps)}` + (caps.limits.maxSessionAtomic === void 0 ? "" : ` Your limit of ${usdcWords(caps.limits.maxSessionAtomic)} in any 24 hours counts every payment from this wallet.`),
     `Commands: /new starts a new conversation, /mode changes the mode, /cost shows what this chat paid, /balance shows your private balance, /model picks another model of the same AI company (/model <id> names one), /provider picks another AI company and then its model (${now.models.length ? `${now.models.length} models served now` : "none served right now"}), /help shows this, /exit (or /quit, Ctrl+D) ends the chat${state2.pending ? ", /retry finishes the unfinished answer" : ""}.`
@@ -156037,7 +156151,7 @@ async function addFunds(values, deps) {
       plan,
       save: save2,
       proxyArgs: proxy.args,
-      childEnv: { ...proxy.env, [PASSPHRASE_ENV]: passphrase2, [RPC_ENV2]: rpcUrl, [STEP_VERBOSE_ENV]: ctx.verbose ? "1" : "0" },
+      childEnv: { ...proxy.env, [PASSPHRASE_ENV]: passphrase2, [RPC_ENV2]: rpcUrl, ...relayOriginsEnv(), [STEP_VERBOSE_ENV]: ctx.verbose ? "1" : "0" },
       // A1: a quiet terminal run names no plan id and no stage (funds-status and --verbose do).
       say: (stage, text3) => io.err(ctx.quiet ? `add-funds: ${text3.replace(STEP_WORDS, "")}
 ` : `add-funds ${plan.fundsId} [${stage}] ${text3}
@@ -156363,15 +156477,18 @@ function freePort() {
 var failure2 = (plain, detail, extra = {}) => Object.assign(new Error(detail ?? plain), { plain, ...extra });
 var sleep4 = (ms) => new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
 var tunnelOf = (port) => `http://127.0.0.1:${port}`;
-function takeLock(home, say2) {
-  mkdirSync(managedTorDir(home), { recursive: true, mode: 448 });
+function lockName(home) {
   let real = home;
   try {
     real = realpathSync.native(home);
   } catch {
   }
   if (process.platform === "win32" || process.platform === "darwin") real = real.toLowerCase();
-  return takeProcessLock(`tor-start ${real}`, {
+  return `tor-start ${real}`;
+}
+function takeLock(home, say2) {
+  mkdirSync(managedTorDir(home), { recursive: true, mode: 448 });
+  return takeProcessLock(lockName(home), {
     waitEveryMs: Infinity,
     onWait: () => say2("Waiting for Tor, which is starting in the background."),
     lostError: () => failure2("another start took over. Ask again", "the start lock was taken over")
@@ -156432,6 +156549,13 @@ async function installBundle(home, say2) {
 `);
   renameSync(unpacking, target);
 }
+function bootstrappedSince(home, from) {
+  try {
+    return /Bootstrapped 100%/.test(readFileSync(logFile(home), "utf8").slice(Number.isInteger(from) ? from : 0));
+  } catch {
+    return false;
+  }
+}
 async function waitBootstrapped(home, alive2, from) {
   const until = Date.now() + BOOTSTRAP_TIMEOUT_MS;
   for (; ; ) {
@@ -156511,9 +156635,27 @@ async function startTor(home, port, say2, assertHeld = () => {
   child.once("exit", () => {
     ended2 = true;
   });
+  let stopped = false;
+  const endStart = () => {
+    if (!ended2) child.kill();
+    try {
+      rmSync(stateFile(home), { force: true });
+    } catch {
+    }
+  };
+  const onStop = (signal) => {
+    stopped = true;
+    if (!bootstrappedSince(home, from)) endStart();
+    if (process.listenerCount(signal) === 1) process.exit(signal === "SIGINT" ? 130 : 143);
+  };
+  const stopSignals = ["SIGINT", "SIGTERM"];
+  for (const signal of stopSignals) process.on(signal, onStop);
   await new Promise((resolvePromise, reject) => {
     child.once("error", (error) => reject(blocked(error)));
     child.once("spawn", resolvePromise);
+  }).catch((error) => {
+    for (const signal of stopSignals) process.off(signal, onStop);
+    throw error;
   });
   child.unref();
   try {
@@ -156528,14 +156670,13 @@ async function startTor(home, port, say2, assertHeld = () => {
       );
     }
     say2("Starting Tor in the background (a few seconds; up to a minute the first time).");
-    await waitBootstrapped(home, () => !ended2, from);
+    await waitBootstrapped(home, () => !ended2 && !stopped, from);
   } catch (error) {
-    if (!ended2) child.kill();
-    try {
-      rmSync(stateFile(home), { force: true });
-    } catch {
-    }
+    if (!stopped || !bootstrappedSince(home, from)) endStart();
+    if (stopped) throw failure2("you stopped the start with Ctrl+C, so Tor was stopped too. Ask again to start it", "the Tor start was stopped (Ctrl+C)");
     throw error;
+  } finally {
+    for (const signal of stopSignals) process.off(signal, onStop);
   }
 }
 async function recordTunnel(home, tunnel) {
@@ -156544,7 +156685,7 @@ async function recordTunnel(home, tunnel) {
   } catch {
   }
 }
-async function ownTorReady(home, state2) {
+async function ownTorReady(home, state2, { wait: wait2 = true } = {}) {
   if (!state2 || !pidAlive4(state2.pid)) return void 0;
   let now;
   try {
@@ -156556,6 +156697,7 @@ async function ownTorReady(home, state2) {
   let own = await controlCheck(home, state2);
   if (own?.tunnelPort !== state2.port) return void 0;
   if (own.progress < 100) {
+    if (!wait2) return void 0;
     await waitBootstrapped(home, () => pidAlive4(state2.pid), Number.isInteger(state2.logFrom) ? state2.logFrom : 0);
     own = await controlCheck(home, state2);
     if (own?.tunnelPort !== state2.port || own.progress < 100) return void 0;
@@ -156619,8 +156761,9 @@ async function ensureWalletTor(proxy, { env = process.env, platform = process.pl
   const ownPort = ownPortOf(home);
   if (explicit && Number(url.port) !== ownPort) return proxy;
   try {
-    const ready = await ownTorReady(home, managedTorState(home));
-    if (ready) {
+    const known = managedTorState(home);
+    const ready = await ownTorReady(home, known, { wait: false });
+    if (ready && await processLockFree(lockName(home)) && pidAlive4(known.pid)) {
       await recordTunnel(home, ready);
       return ready;
     }
@@ -158434,16 +158577,21 @@ var CURL_SHORT_FLAGS = Object.freeze({ "-X": "--method", "-H": "--header", "-d":
 function curlArgs(command, args) {
   const known = new Map(command.flags.map((entry) => [entry.name, entry]));
   const out = [];
+  let afterJsonData = false;
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index];
     const name = CURL_SHORT_FLAGS[token] ?? token;
     if (!name.startsWith("-")) {
+      if (afterJsonData && out.includes("--url")) throw new PublicFailure(CURL_JSON_ARGUMENT_REFUSAL);
+      afterJsonData = false;
       out.push("--url", token);
       continue;
     }
+    afterJsonData = false;
     out.push(name);
     if (known.has(name) && !known.get(name).boolean && index + 1 < args.length) {
       out.push(args[index + 1]);
+      afterJsonData = name === "--data" && /^\s*[[{]/.test(args[index + 1]);
       index += 1;
     }
   }
@@ -158481,13 +158629,34 @@ function validateCurl(values, env) {
 }
 function curlBody(values) {
   const file = values.get("--data-file") ?? (values.get("--data")?.startsWith("@") ? values.get("--data").slice(1) : void 0);
-  if (file === void 0) return values.get("--data");
+  let body;
+  if (file === void 0) body = values.get("--data");
+  else {
+    try {
+      body = readFileSync(resolve41(file));
+    } catch {
+      throw new PublicFailure("fetch_options_invalid: the body file (--data-file, or -d @file) could not be read; pass a file you can read. Nothing was sent");
+    }
+  }
+  curlJsonBody(values, body, file !== void 0);
+  return body;
+}
+function curlJsonBody(values, body, fromFile) {
+  if (body === void 0) return;
+  const type = (values.get("--header") ?? []).find((line) => line.slice(0, line.indexOf(":")).trim().toLowerCase() === "content-type");
+  const typeValue = type === void 0 ? void 0 : type.slice(type.indexOf(":") + 1).trim().toLowerCase();
+  const jsonType = typeValue !== void 0 && /^application\/(?:[\w.+-]+\+)?json\b/.test(typeValue);
+  const text3 = Buffer.isBuffer(body) ? body.toString("utf8") : String(body);
+  const asJson = fromFile ? jsonType : typeValue === void 0 ? /^\s*[[{]/.test(text3) : jsonType;
+  if (!asJson) return;
   try {
-    return readFileSync(resolve41(file));
+    JSON.parse(text3.replace(/^/, ""));
+    return;
   } catch {
-    throw new PublicFailure("fetch_options_invalid: the body file (--data-file, or -d @file) could not be read; pass a file you can read. Nothing was sent");
   }
+  throw new PublicFailure(fromFile ? "fetch_options_invalid: the body file is not valid JSON, so it was not sent; nothing was paid. Fix the file (every name and text in double quotes) and run the same command again" : CURL_JSON_ARGUMENT_REFUSAL);
 }
+var CURL_JSON_ARGUMENT_REFUSAL = "fetch_options_invalid: the body is not valid JSON, so it was not sent; nothing was paid. PowerShell removes the double quotes inside a JSON argument: save the JSON in a file and pass it as -d @<file> (or --data-file <file>), then run the command again";
 function curlFailure(error) {
   if (error instanceof SpendRefusalError && knownErrorCode(error.error)) {
     return new PublicFailure(`${error.error}: ${error.detail}`, { cause: error });
@@ -160264,7 +160433,7 @@ function startKeepWarm(options, env = process.env) {
       ...proxy.env,
       [PASSPHRASE_ENV3]: options.passphrase,
       [KEEP_WARM_PARENT_ENV]: "1",
-      ...options.rpcUrl ? { [RPC_ENV3]: options.rpcUrl } : {}
+      ...options.rpcUrl ? { [RPC_ENV3]: options.rpcUrl, ...relayOriginsEnv() } : {}
     },
     stdio: ["pipe", "ignore", "pipe"],
     windowsHide: true