@tempoxyz/patron 0.0.28 → 0.0.30

package/dist/chunks/{-5Q7V7W7W.js → -WRUP4P4C.js}

@@ -1,12 +1,14 @@
 import { createRequire as __patronCreateRequire } from 'node:module'
 const require = __patronCreateRequire(import.meta.url)
 import {
+  CLAUDE_HOOK_STATUS,
   FileTokenStore,
   LINK_TOKEN_STEP,
   STARTER_TOKENS,
   budgetTokens,
   buyTokens,
   codexHome,
+  codexNotifyCommand,
   codexPaths,
   hasPatronHandler,
   installCodex,
@@ -15,10 +17,13 @@ import {
   loadIssuer,
   needsRefill,
   parseUsd,
+  patronCommands,
   purchasableTokens,
   readJsonObject,
   redeem,
+  refillSize,
   removeCodex,
+  storedIssuer,
   tipTokens,
   upgradeCodex,
   withHooksKey,
@@ -26,41 +31,44 @@ import {
   withPatronStatus,
   withoutPatronHandlers,
   writeJsonObject
-} from "./chunk-EKFENOVR.js";
+} from "./chunk-4SXIRXUL.js";
 import {
+  awaitRedemptions,
+  gatewayTurn,
   startRefill
-} from "./chunk-TV5VLFTD.js";
+} from "./chunk-TC2WEQ25.js";
 import {
+  inferHome,
   resolveSettings,
   settingsFor
-} from "./chunk-OQXACACU.js";
+} from "./chunk-NDBTADXZ.js";
 import {
-  AGENT_IDS,
   LeaderboardResponse,
   PatronInfo,
-  ensureHome,
-  profileMessage,
-  readConfig,
-  readJson,
-  readUsage,
-  statePaths,
-  updateUsage,
-  writeConfig,
-  writePrivateFile
-} from "./chunk-EV7OA6GK.js";
+  profileMessage
+} from "./chunk-ROVOCDKE.js";
 import {
+  AGENT_IDS,
   DEFAULT_MONTHLY_BUDGET_USD,
   MAX_TOKENS_PER_PAGE,
   MIN_TOKENS_PER_PAGE,
   PACK_SIZE,
   TOKEN_PRICE_UNITS,
   clampTokensPerPage,
+  ensureHome,
   formatUsd,
   normalizePayee,
+  readConfig,
+  readJson,
+  readUsage,
+  statePaths,
   tokensToUnits,
   tryLock,
-  withLock
-} from "./chunk-EISHX7Q3.js";
+  updateUsage,
+  withLock,
+  writeConfig,
+  writePrivateFile
+} from "./chunk-AKOXBXV3.js";
 import "./chunk-GTMLTZRN.js";
 
 // src/index.ts
@@ -70,9 +78,9 @@ import { homedir as homedir2 } from "node:os";
 
 // src/agents.ts
 import { constants } from "node:fs";
-import { access as access2, realpath as realpath2 } from "node:fs/promises";
+import { access as access2, readFile as readFile4, realpath as realpath2 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { delimiter, join as join5 } from "node:path";
+import { delimiter, join as join5, resolve } from "node:path";
 
 // src/amp.ts
 import { mkdir, readFile, rm } from "node:fs/promises";
@@ -134,13 +142,17 @@ async function installAmpPlugin(path, command) {
   return "installed";
 }
 async function upgradeAmpPlugin(path) {
+  const command = await ampPluginCommand(path);
+  if (command === void 0) return false;
+  return await installAmpPlugin(path, command) === "installed";
+}
+async function ampPluginCommand(path) {
   const current = await readText(path);
-  if (current === void 0 || !current.startsWith(AMP_PLUGIN_MARKER)) return false;
+  if (current === void 0 || !current.startsWith(AMP_PLUGIN_MARKER)) return void 0;
   const literal = /^const COMMAND = (".*")$/m.exec(current)?.[1];
-  if (!literal) return false;
+  if (!literal) return void 0;
   const command = JSON.parse(literal);
-  if (typeof command !== "string") return false;
-  return await installAmpPlugin(path, command) === "installed";
+  return typeof command === "string" ? command : void 0;
 }
 async function removeAmpPlugin(path) {
   const current = await readText(path);
@@ -161,7 +173,6 @@ async function readText(path) {
 var CLAUDE_MATCHER = "WebFetch|WebSearch";
 var HOOK_TIMEOUT_SECONDS = 30;
 var EVENT = "PostToolUse";
-var CLAUDE_HOOK_STATUS = "Patron: pay the site this read";
 function patronGroup(command) {
   return {
     hooks: [
@@ -176,8 +187,8 @@ function patronGroup(command) {
     matcher: CLAUDE_MATCHER
   };
 }
-function withPatronHook(settings, command) {
-  return withPatronGroup(settings, EVENT, patronGroup(command));
+function withPatronHook(settings, command, known) {
+  return withPatronGroup(settings, EVENT, patronGroup(command), known);
 }
 async function upgradeClaudeHook(path) {
   const settings = await readJsonObject(path);
@@ -186,8 +197,8 @@ async function upgradeClaudeHook(path) {
   await writeJsonObject(path, next);
   return true;
 }
-function withoutPatronHook(settings) {
-  return withoutPatronHandlers(settings, EVENT);
+function withoutPatronHook(settings, known) {
+  return withoutPatronHandlers(settings, EVENT, known);
 }
 function hasPatronHook(settings, command) {
   return hasPatronHandler(settings, EVENT, {
@@ -195,16 +206,17 @@ function hasPatronHook(settings, command) {
     ...command === void 0 ? {} : { command }
   });
 }
-async function installClaudeHook(path, command) {
+async function installClaudeHook(path, command, known) {
   const settings = await readJsonObject(path);
-  if (hasPatronHook(settings, command)) return "unchanged";
-  await writeJsonObject(path, withPatronHook(settings, command));
+  if (hasPatronHook(settings, command) && patronCommands(settings, EVENT).length === 1)
+    return "unchanged";
+  await writeJsonObject(path, withPatronHook(settings, command, known));
   return "installed";
 }
-async function removeClaudeHook(path) {
+async function removeClaudeHook(path, known) {
   const settings = await readJsonObject(path);
-  if (!hasPatronHandler(settings, EVENT)) return "missing";
-  await writeJsonObject(path, withoutPatronHook(settings));
+  if (!hasPatronHandler(settings, EVENT, known ? { known } : {})) return "missing";
+  await writeJsonObject(path, withoutPatronHook(settings, known));
   return "removed";
 }
 
@@ -216,42 +228,46 @@ var EVENT2 = "postToolUse";
 function cursorHooksPath(home) {
   return join2(home, ".cursor", "hooks.json");
 }
-function withCursorHook(config, command) {
-  const stripped = withoutCursorHook(config);
+function withCursorHook(config, command, known) {
+  const stripped = withoutCursorHook(config, known);
   const next = typeof stripped.version === "number" ? stripped : { version: 1, ...stripped };
   const hooks = isObject(next.hooks) ? next.hooks : {};
   const entries = Array.isArray(hooks[EVENT2]) ? hooks[EVENT2] : [];
   return withHooksKey(next, EVENT2, [...entries, cursorEntry(command)]);
 }
-function withoutCursorHook(config) {
+function withoutCursorHook(config, known) {
   const entries = isObject(config.hooks) ? config.hooks[EVENT2] : void 0;
-  if (!Array.isArray(entries) || !entries.some(isPatronHandler)) return { ...config };
+  const patron = (entry) => isPatronHandler(entry, known);
+  if (!Array.isArray(entries) || !entries.some(patron)) return { ...config };
   return withHooksKey(
     config,
     EVENT2,
-    entries.filter((entry) => !isPatronHandler(entry))
+    entries.filter((entry) => !patron(entry))
   );
 }
 function cursorEntry(command) {
   return { command, matcher: CURSOR_MATCHER, timeout: HOOK_TIMEOUT_SECONDS2 };
 }
-function hasCursorHook(config, command) {
+function hasCursorHook(config, command, known) {
   const entries = isObject(config.hooks) ? config.hooks[EVENT2] : void 0;
   if (!Array.isArray(entries)) return false;
-  if (command === void 0) return entries.some(isPatronHandler);
+  if (command === void 0) return entries.some((entry) => isPatronHandler(entry, known));
   const wanted = JSON.stringify(cursorEntry(command));
-  return entries.some((entry) => JSON.stringify(entry) === wanted);
+  const patron = entries.filter(
+    (entry) => isPatronHandler(entry, known) || JSON.stringify(entry) === wanted
+  );
+  return patron.length === 1 && JSON.stringify(patron[0]) === wanted;
 }
-async function installCursorHook(path, command) {
+async function installCursorHook(path, command, known) {
   const config = await readJsonObject(path);
-  if (hasCursorHook(config, command)) return "unchanged";
-  await writeJsonObject(path, withCursorHook(config, command));
+  if (hasCursorHook(config, command, known)) return "unchanged";
+  await writeJsonObject(path, withCursorHook(config, command, known));
   return "installed";
 }
-async function removeCursorHook(path) {
+async function removeCursorHook(path, known) {
   const config = await readJsonObject(path);
-  if (!hasCursorHook(config)) return "missing";
-  await writeJsonObject(path, withoutCursorHook(config));
+  if (!hasCursorHook(config, void 0, known)) return "missing";
+  await writeJsonObject(path, withoutCursorHook(config, known));
   return "removed";
 }
 
@@ -351,9 +367,9 @@ import { basename, dirname as dirname3, join as join4 } from "node:path";
 function stableBin(home) {
   return join4(home, "cli", "current", "dist", "bin.js");
 }
-async function installStableCli(home, script = process.argv[1]) {
+async function installStableCli(home, script = process.argv[1], anySource = process.platform === "win32" && Boolean(process.env.PATRON_HOME)) {
   const resolved = script ? await realpath(script).catch(() => void 0) : void 0;
-  if (!resolved || !/[/\\]_npx[/\\]/.test(resolved) || basename(resolved) !== "bin.js")
+  if (!resolved || !anySource && !/[/\\]_npx[/\\]/.test(resolved) || basename(resolved) !== "bin.js")
     return void 0;
   const packageDir = dirname3(dirname3(resolved));
   const { version } = JSON.parse(await readFile3(join4(packageDir, "package.json"), "utf8"));
@@ -408,32 +424,33 @@ var ADAPTERS = {
     install: async (command, { env, home }) => ({
       state: await installAmpPlugin(ampPluginPath(env, home), command)
     }),
+    // The plugin file starts with Patron's marker, so it needs no known commands.
     remove: ({ env, home }) => removeAmpPlugin(ampPluginPath(env, home)),
     upgrade: ({ env, home }) => upgradeAmpPlugin(ampPluginPath(env, home))
   },
   "claude-code": {
     files: (environment) => [claudeSettingsPath(environment)],
     detect: async (environment) => await exists(claudeDirectory(environment)) || await onPath(["claude"], environment.env.PATH ?? ""),
-    install: async (command, environment) => ({
-      state: await installClaudeHook(claudeSettingsPath(environment), command)
+    install: async (command, environment, known) => ({
+      state: await installClaudeHook(claudeSettingsPath(environment), command, known)
     }),
-    remove: (environment) => removeClaudeHook(claudeSettingsPath(environment)),
+    remove: (environment, known) => removeClaudeHook(claudeSettingsPath(environment), known),
     upgrade: (environment) => upgradeClaudeHook(claudeSettingsPath(environment))
   },
   codex: {
     files: ({ env, home }) => Object.values(codexPaths(env, home)),
     detect: async ({ env, home }) => await exists(codexHome(env, home)) || await onPath(["codex"], env.PATH ?? ""),
-    install: (command, { env, home }) => installCodex(codexPaths(env, home), command),
-    remove: ({ env, home }) => removeCodex(codexPaths(env, home)),
+    install: (command, { env, home }, known) => installCodex(codexPaths(env, home), command, process.platform, known),
+    remove: ({ env, home }, known) => removeCodex(codexPaths(env, home), known),
     upgrade: ({ env, home }) => upgradeCodex(codexPaths(env, home))
   },
   cursor: {
     files: ({ home }) => [cursorHooksPath(home)],
     detect: async ({ env, home }) => await exists(join5(home, ".cursor")) || await onPath(["cursor-agent", "cursor"], env.PATH ?? ""),
-    install: async (command, { home }) => ({
-      state: await installCursorHook(cursorHooksPath(home), command)
+    install: async (command, { home }, known) => ({
+      state: await installCursorHook(cursorHooksPath(home), command, known)
     }),
-    remove: ({ home }) => removeCursorHook(cursorHooksPath(home))
+    remove: ({ home }, known) => removeCursorHook(cursorHooksPath(home), known)
   }
 };
 function claudeDirectory({ env, home }) {
@@ -452,12 +469,13 @@ async function detectAgents(environment) {
 }
 async function installAgents(agents, command, environment) {
   const store = originalsStore(environment);
+  const known = await knownCommands(environment, [command]);
   return Promise.all(
     agents.map(async (agent) => {
       let recorded = [];
       try {
         recorded = await rememberOriginals(store, ADAPTERS[agent].files(environment));
-        const { note, state } = await ADAPTERS[agent].install(command, environment);
+        const { note, state } = await ADAPTERS[agent].install(command, environment, known);
         if (state !== "installed") await forgetOriginals(store, recorded);
         return { agent, label: AGENT_LABELS[agent], state, ...note ? { note } : {} };
       } catch (error) {
@@ -477,10 +495,17 @@ async function upgradeAgents(agents, environment) {
 }
 async function removeAgents(environment) {
   const store = originalsStore(environment);
+  const patronHome = environment.env.PATRON_HOME || join5(environment.home, ".patron");
+  const stable = `${quote(process.execPath)} ${quote(stableBin(patronHome))} hook`;
+  const known = await knownCommands(environment, [
+    await hookCommand(environment.env, process.argv[1], process.execPath, patronHome),
+    stable,
+    withPatronHome(stable, environment.env.PATRON_HOME)
+  ]);
   return Promise.all(
     AGENT_IDS.map(async (agent) => {
       try {
-        const state = await ADAPTERS[agent].remove(environment);
+        const state = await ADAPTERS[agent].remove(environment, known);
         if (state === "removed")
           await restoreOriginals(store, ADAPTERS[agent].files(environment)).catch(
             () => void 0
@@ -492,6 +517,32 @@ async function removeAgents(environment) {
     })
   );
 }
+async function knownCommands({ env, home }, extra) {
+  const paths = codexPaths(env, home);
+  const found = await Promise.all([
+    readJsonObject(claudeSettingsPath({ env, home })).then(
+      (settings) => patronCommands(settings, "PostToolUse"),
+      () => []
+    ),
+    readJsonObject(paths.hooks).then(
+      (settings) => patronCommands(settings, "Stop"),
+      () => []
+    ),
+    readFile4(paths.config, "utf8").then(
+      (toml) => [codexNotifyCommand(toml)],
+      () => []
+    ),
+    ampPluginCommand(ampPluginPath(env, home)).then(
+      (command) => [command],
+      () => []
+    )
+  ]);
+  return new Set(
+    [...found.flat(), ...extra].filter(
+      (command) => typeof command === "string" && command !== ""
+    )
+  );
+}
 function originalsStore({ env, home }) {
   return originalsPath(env.PATRON_HOME || join5(home, ".patron"));
 }
@@ -503,17 +554,45 @@ function failure(agent, error) {
     state: "failed"
   };
 }
-async function hookCommand(env = process.env, script = process.argv[1], node = process.execPath, patronHome = env.PATRON_HOME || join5(homedir(), ".patron")) {
+async function hookCommand(env = process.env, script = process.argv[1], node = process.execPath, patronHome = env.PATRON_HOME || join5(homedir(), ".patron"), platform = process.platform) {
   if (env.PATRON_HOOK_COMMAND) return env.PATRON_HOOK_COMMAND;
+  const windows = platform === "win32";
+  const run2 = await runCommand(
+    script,
+    node,
+    patronHome,
+    windows && Boolean(env.PATRON_HOME),
+    platform
+  );
+  if (!env.PATRON_HOME || windows || await runsFromHome(run2.bin, patronHome))
+    return run2.command;
+  return withPatronHome(run2.command, env.PATRON_HOME);
+}
+async function runCommand(script, node, patronHome, preferCopy, platform) {
+  const run2 = (bin) => ({
+    bin,
+    command: `${quote(node, platform)} ${quote(bin, platform)} hook`
+  });
+  const stable = stableBin(patronHome);
+  if (preferCopy && await exists(stable)) return run2(stable);
   const resolved = script ? await realpath2(script).catch(() => void 0) : void 0;
   if (resolved && /[/\\]bin\.js$/.test(resolved) && !/[/\\]_npx[/\\]/.test(resolved))
-    return `${quote(node)} ${quote(resolved)} hook`;
-  if (await exists(stableBin(patronHome)))
-    return `${quote(node)} ${quote(stableBin(patronHome))} hook`;
-  return "npx -y @tempoxyz/patron hook";
+    return run2(resolved);
+  if (await exists(stable)) return run2(stable);
+  return { command: "npx -y @tempoxyz/patron hook" };
 }
-function quote(value) {
-  return /^[\w./:@-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+async function runsFromHome(bin, patronHome) {
+  const inferred = inferHome(bin);
+  if (!inferred) return false;
+  const real = (path) => realpath2(path).catch(() => resolve(path));
+  return await real(inferred) === await real(patronHome);
+}
+function withPatronHome(command, patronHome) {
+  return patronHome ? `PATRON_HOME=${quote(resolve(patronHome))} ${command}` : command;
+}
+function quote(value, platform = process.platform) {
+  if (/^[\w./:@-]+$/.test(value)) return value;
+  return platform === "win32" ? `"${value}"` : `'${value.replaceAll("'", "'\\''")}'`;
 }
 async function exists(path) {
   return access2(path).then(
@@ -697,16 +776,24 @@ async function linkRefillFailedAt(home) {
   const value = await readJson(statePaths(home).linkRefill).catch(() => void 0);
   return typeof value?.failedAt === "number" ? value.failedAt : void 0;
 }
-var REFILL_LOCK_STALE_MS = 5 * 60 * 1e3;
 var defaultOpenWallet = async (settings, config, issuer, maxUnits) => {
   if (config.wallet === "link") {
-    const { openLinkWallet } = await import("./wallet-6TDMXRWW.js");
+    const { openLinkWallet } = await import("./wallet-OTFEEKIG.js");
     return openLinkWallet(config, maxUnits);
   }
-  const { openWallet } = await import("./wallet-6TDMXRWW.js");
+  const { openWallet } = await import("./wallet-OTFEEKIG.js");
   return openWallet(settings, config.wallet, issuer, maxUnits);
 };
+var REFILL_LOCK_STALE_MS = 5 * 60 * 1e3;
 async function buyWithinBudget(settings, config, wanted, openWallet = defaultOpenWallet) {
+  await ensureHome(settings.home);
+  return withLock(
+    statePaths(settings.home).purchaseLock,
+    () => buyLocked(settings, config, wanted, openWallet),
+    { staleMs: REFILL_LOCK_STALE_MS, timeoutMs: REFILL_LOCK_STALE_MS }
+  );
+}
+async function buyLocked(settings, config, wanted, openWallet) {
   const usage = await readUsage(settings.home);
   const count = purchasableTokens(config, usage, wanted);
   if (count === 0) return 0;
@@ -729,10 +816,46 @@ async function buyWithinBudget(settings, config, wanted, openWallet = defaultOpe
   });
   return tokens.length;
 }
-async function refill(base, openWallet = defaultOpenWallet, now = Date.now) {
+var REFILL_DELAY_MS = { max: 10 * 60 * 1e3, min: 60 * 1e3 };
+async function delayedRefill(base, openWallet = defaultOpenWallet, sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)), random = Math.random) {
+  if (!await readConfig(base.home)) return 0;
+  const release = await tryLock(
+    statePaths(base.home).refillWait,
+    REFILL_DELAY_MS.max + REFILL_GATEWAY_WAIT_MS + REFILL_LOCK_STALE_MS
+  );
+  if (!release) return 0;
+  try {
+    await sleep(
+      REFILL_DELAY_MS.min + random() * (REFILL_DELAY_MS.max - REFILL_DELAY_MS.min)
+    );
+    return await refill(base, openWallet, Date.now, sleep);
+  } finally {
+    await release();
+  }
+}
+var REFILL_GATEWAY_WAIT_MS = 15 * 60 * 1e3;
+async function refill(base, openWallet = defaultOpenWallet, now = Date.now, sleep) {
   const config = await readConfig(base.home);
   if (!config || config.paused) return 0;
   const settings = settingsFor(base, config);
+  const stale = (await storedIssuer(settings.home, settings.gatewayUrl))?.stale ?? true;
+  const low = needsRefill(await new FileTokenStore(settings.home).count()) && await linkBackedOff(settings.home, config, now()) === false && await readUsage(settings.home).then(
+    (usage) => refillSize(config, usage) > 0,
+    () => true
+  );
+  if (!stale && !low) return 0;
+  const bought = await gatewayTurn(
+    settings.home,
+    async () => {
+      if (stale)
+        await loadIssuer(settings.home, settings.gatewayUrl).catch(() => void 0);
+      return low ? refillLocked(settings, config, openWallet, now) : 0;
+    },
+    { maxWaitMs: REFILL_GATEWAY_WAIT_MS, ...sleep ? { sleep } : {} }
+  );
+  return bought ?? 0;
+}
+async function refillLocked(settings, config, openWallet, now) {
   const release = await tryLock(
     statePaths(settings.home).refillLock,
     REFILL_LOCK_STALE_MS
@@ -742,8 +865,7 @@ async function refill(base, openWallet = defaultOpenWallet, now = Date.now) {
     if (!needsRefill(await new FileTokenStore(settings.home).count())) return 0;
     if (config.wallet !== "link")
       return await buyWithinBudget(settings, config, PACK_SIZE, openWallet);
-    const failedAt = await linkRefillFailedAt(settings.home);
-    if (failedAt !== void 0 && now() - failedAt < LINK_REFILL_BACKOFF_MS) return 0;
+    if (await linkBackedOff(settings.home, config, now())) return 0;
     const path = statePaths(settings.home).linkRefill;
     try {
       const bought = await buyWithinBudget(settings, config, PACK_SIZE, openWallet);
@@ -757,6 +879,11 @@ async function refill(base, openWallet = defaultOpenWallet, now = Date.now) {
     await release();
   }
 }
+async function linkBackedOff(home, config, now) {
+  if (config.wallet !== "link") return false;
+  const failedAt = await linkRefillFailedAt(home);
+  return failedAt !== void 0 && now - failedAt < LINK_REFILL_BACKOFF_MS;
+}
 
 // src/render.ts
 function tokensUsd(tokens) {
@@ -846,6 +973,34 @@ PATRON_PRIVATE_KEY (testnet automation), PATRON_BUDGET_USD (non-interactive setu
 PATRON_WALLET=link (pay with Link through link-cli), PATRON_LINK_CLI (its path).`;
 var UsageError = class extends Error {
 };
+var TIP_BATCH = 8;
+var TIP_REDEEM_TIMEOUT_MS = 3e4;
+var TIP_BATCH_LEASE_MS = 6e4;
+async function inGatewayTurn(deps, fn) {
+  const result = await gatewayTurn(
+    deps.settings.home,
+    async () => ({ value: await fn() }),
+    {
+      ...waiting(deps),
+      onWait: (ms) => say(
+        deps,
+        styleText(
+          `  Waiting ${minutes(ms)} after your agents' last payment, so Patron can't link the two.`,
+          "dim",
+          deps.color
+        )
+      )
+    }
+  );
+  return result.value;
+}
+function waiting(deps) {
+  return deps.sleep ? { sleep: deps.sleep } : {};
+}
+function minutes(ms) {
+  const count = Math.max(1, Math.ceil(ms / 6e4));
+  return count === 1 ? "about a minute" : `about ${count} minutes`;
+}
 function defaults() {
   const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
   const color = supportsColor(process.stdout);
@@ -915,7 +1070,7 @@ async function run(argv, overrides = {}) {
         await uninstall(deps);
         return 0;
       case "refill":
-        await refill(deps.settings, deps.openWallet).catch(() => 0);
+        await (args[0] === "--delay" ? delayedRefill(deps.settings, deps.openWallet) : refill(deps.settings, deps.openWallet)).catch(() => 0);
         return 0;
       case "help":
       case "--help":
@@ -1007,10 +1162,13 @@ async function setup(deps) {
   const settings = deps.settings;
   say(deps, scrollBanner(VERSION, deps.color));
   say(deps);
-  const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
-    fetch: deps.fetch,
-    fresh: true
-  }).catch((error) => {
+  const issuer = await inGatewayTurn(
+    deps,
+    () => loadIssuer(settings.home, settings.gatewayUrl, {
+      fetch: deps.fetch,
+      fresh: true
+    })
+  ).catch((error) => {
     throw new Error(`Cannot reach Patron at ${settings.gatewayUrl}: ${error.message}`);
   });
   const budget = await askBudget(deps, DEFAULT_MONTHLY_BUDGET_USD);
@@ -1035,7 +1193,10 @@ async function setup(deps) {
   const starter = config.wallet === "link" ? PACK_SIZE : STARTER_TOKENS;
   const first = purchasableTokens(config, await readUsage(settings.home), starter);
   step(deps, `Adding ${tokensUsd(first)} to your balance`);
-  const bought = await buyWithinBudget(settings, config, starter, deps.openWallet);
+  const bought = await inGatewayTurn(
+    deps,
+    () => buyWithinBudget(settings, config, starter, deps.openWallet)
+  );
   done(deps, `${tokensUsd(bought)} ready to pay sites`);
   deps.startRefill();
   await installStableCli(settings.home).catch(() => void 0);
@@ -1084,7 +1245,7 @@ async function tempoSignIn(deps, budgetUnits, issuer) {
     deps,
     deps.settings.privateKey ? "Using PATRON_PRIVATE_KEY" : "Signing in with Tempo Wallet"
   );
-  const { signIn } = await import("./wallet-6TDMXRWW.js");
+  const { signIn } = await import("./wallet-OTFEEKIG.js");
   const account = await signIn(deps.settings, {
     budgetUnits,
     issuer,
@@ -1124,8 +1285,8 @@ async function askBudget(deps, fallback) {
   const preset = process.env.PATRON_BUDGET_USD;
   if (!deps.interactive) {
     const value = preset ? parseUsd(preset) : fallback;
-    if (value === void 0 || value <= 0)
-      throw new UsageError("PATRON_BUDGET_USD must be a positive amount.");
+    if (value === void 0 || value < 1e-3)
+      throw new UsageError("PATRON_BUDGET_USD must be at least 0.001.");
     return value;
   }
   const prompter = deps.prompter();
@@ -1198,7 +1359,7 @@ async function changeBudget(deps, input) {
   } else budget = await askBudget(deps, config.monthlyBudgetUsd);
   if (config.wallet === "tempo" && budget >= config.monthlyBudgetUsd) {
     step(deps, "Approve the new spending limit in Tempo Wallet");
-    const { authorizeBudget } = await import("./wallet-6TDMXRWW.js");
+    const { authorizeBudget } = await import("./wallet-OTFEEKIG.js");
     const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
       fetch: deps.fetch
     });
@@ -1254,42 +1415,100 @@ async function tip(deps, url, amount = "0.10") {
       );
     const amount2 = Math.max(missing, purchasableTokens(config, usage, PACK_SIZE));
     step(deps, `Adding ${tokensUsd(amount2)} to your balance`);
-    await buyWithinBudget(settings, config, amount2, deps.openWallet);
+    await inGatewayTurn(
+      deps,
+      () => buyWithinBudget(settings, config, amount2, deps.openWallet)
+    );
   }
-  const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
-    fetch: deps.fetch
+  const issuer = (await storedIssuer(settings.home, settings.gatewayUrl))?.issuer ?? await inGatewayTurn(
+    deps,
+    () => loadIssuer(settings.home, settings.gatewayUrl, { fetch: deps.fetch, fresh: true })
+  );
+  const redeemFetch = (input, init) => deps.fetch(input, { ...init, signal: AbortSignal.timeout(TIP_REDEEM_TIMEOUT_MS) });
+  let told = false;
+  const claimBatch = (cancelled) => awaitRedemptions(settings.home, TIP_BATCH_LEASE_MS, {
+    ...waiting(deps),
+    ...cancelled ? { cancelled } : {},
+    onWait: (ms) => {
+      if (told) return;
+      told = true;
+      say(
+        deps,
+        styleText(
+          `  Waiting ${minutes(ms)} after a recent purchase, so Patron can't link it to this tip. Ctrl-C keeps your balance.`,
+          "dim",
+          deps.color
+        )
+      );
+    }
   });
-  const tokens = await store.takeMany(count);
+  await claimBatch();
+  let stopped = false;
+  const stop = () => {
+    stopped = true;
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
   let paid = 0;
+  let sent = 0;
   let rejection;
-  const unsent = [];
-  for (let index = 0; index < tokens.length; index += 8) {
-    const batch = tokens.slice(index, index + 8);
-    const results = await Promise.all(
-      batch.map(
-        (token) => redeem({
-          domain,
-          fetch: deps.fetch,
-          issuer,
-          relayUrl: settings.relayUrl,
-          token
-        }).catch(() => {
-          unsent.push(token);
-          return void 0;
-        })
-      )
-    );
-    for (const result of results) {
-      if (result?.ok) paid += 1;
-      else if (result) rejection = result.error ?? "rejected";
+  try {
+    while (sent < count && !stopped) {
+      if (sent > 0 && !await claimBatch(() => stopped)) break;
+      const batch = await store.takeMany(Math.min(TIP_BATCH, count - sent));
+      if (batch.length === 0) break;
+      sent += batch.length;
+      const unsent = [];
+      let rejected = 0;
+      const results = await Promise.all(
+        batch.map(
+          (token) => redeem({
+            domain,
+            fetch: redeemFetch,
+            issuer,
+            relayUrl: settings.relayUrl,
+            token
+          }).catch(() => {
+            unsent.push(token);
+            return void 0;
+          })
+        )
+      );
+      const ok = results.filter((result) => result?.ok).length;
+      for (const result of results)
+        if (result && !result.ok) {
+          rejected += 1;
+          rejection = result.error ?? "rejected";
+        }
+      sent -= unsent.length;
+      await store.add(unsent);
+      if (ok > 0)
+        await updateUsage(settings.home, (usage) => {
+          usage.domains[domain] = (usage.domains[domain] ?? 0) + ok;
+          usage.tippedTokens += ok;
+        });
+      paid += ok;
+      if (count > TIP_BATCH && ok > 0)
+        say(
+          deps,
+          styleText(
+            `  ${tokensUsd(paid)} of ${tokensUsd(count)} sent`,
+            "dim",
+            deps.color
+          )
+        );
+      if (ok === 0 && (rejected > 0 || unsent.length > 0)) break;
     }
+  } finally {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
   }
-  await store.add(unsent);
-  if (paid > 0)
-    await updateUsage(settings.home, (usage) => {
-      usage.domains[domain] = (usage.domains[domain] ?? 0) + paid;
-      usage.tippedTokens += paid;
-    });
+  if (stopped && sent < count)
+    throw new Error(
+      `Tip stopped: tipped ${domain} ${tokensUsd(paid)} of ${tokensUsd(count)}; the rest stays in your balance.`
+    );
   if (paid === 0)
     throw new Error(
       rejection ? `Patron rejected the tip to ${domain}: ${rejection}.` : `Could not reach Patron to tip ${domain}; your balance was kept.`
@@ -1316,7 +1535,7 @@ async function setName(deps, name) {
   const issuer = await loadIssuer(settings.home, settings.gatewayUrl, {
     fetch: deps.fetch
   });
-  const open = deps.openWallet ?? (async (s, c, i, max) => (await import("./wallet-6TDMXRWW.js")).openWallet(s, c.wallet, i, max));
+  const open = deps.openWallet ?? (async (s, c, i, max) => (await import("./wallet-OTFEEKIG.js")).openWallet(s, c.wallet, i, max));
   const wallet = await open(settings, config, issuer, 0n);
   await setProfile(settings.gatewayUrl, wallet, name, deps.fetch);
   await writeConfig(settings.home, { ...config, name });
@@ -1324,9 +1543,11 @@ async function setName(deps, name) {
 }
 async function uninstall(deps) {
   const config = await readConfig(deps.settings.home);
-  const results = (await removeAgents(deps.agents)).filter(
-    (result) => result.state !== "missing"
-  );
+  const removed = await removeAgents(deps.agents);
+  const results = removed.filter((result) => result.state !== "missing");
+  const notFound = removed.filter(
+    (result) => result.state === "missing" && config?.agents.includes(result.agent)
+  ).map((result) => result.label);
   say(deps, styleText("Patron uninstall", "bold", deps.color));
   for (const line of formatAgentResults(results, deps.color)) say(deps, line);
   if (results.length === 0)
@@ -1358,6 +1579,10 @@ async function uninstall(deps) {
         deps.color
       )
     );
+  if (notFound.length > 0)
+    throw new Error(
+      `Found no Patron hook to remove for ${notFound.join(", ")}. If a hook running "patron hook" is still in its settings, delete it by hand.`
+    );
 }
 function readVersion() {
   for (const path of ["../package.json", "../../package.json"]) {