pullfrog 0.1.105 → 0.1.107

package/dist/cli.mjs

@@ -78971,8 +78971,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize3) {
-      if (normalize3 !== false)
+    function getFullPath(resolver, id = "", normalize4) {
+      if (normalize4 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -80601,7 +80601,7 @@ var require_fast_uri = __commonJS({
       }
       return stringScheme;
     }
-    function normalize3(uri, options) {
+    function normalize4(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         normalizeString(uri, options);
@@ -81001,7 +81001,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize: normalize3,
+      normalize: normalize4,
       resolve: resolve3,
       resolveComponent,
       equal,
@@ -112919,7 +112919,7 @@ var import_picocolors = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "pullfrog",
-  version: "0.1.105",
+  version: "0.1.107",
   cliContractVersion: "1",
   type: "module",
   bin: {
@@ -116293,7 +116293,7 @@ function rungPosition(params) {
 function provider(config3) {
   return config3;
 }
-var providers2 = {
+var bundledProviders = {
   anthropic: provider({
     displayName: "Anthropic",
     envVars: ["ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN"],
@@ -116313,7 +116313,8 @@ var providers2 = {
         // versions (claude-fable-5 was missing there when this was added), so track ~…-latest to
         // stay catalog-valid and auto-follow version bumps.
         openRouterResolve: "openrouter/~anthropic/claude-fable-latest",
-        subagentModel: "claude-sonnet"
+        subagentModel: "claude-sonnet",
+        pinned: true
       },
       "claude-opus": {
         displayName: "Claude Opus",
@@ -116371,7 +116372,8 @@ var providers2 = {
         resolve: "openai/gpt-6.1-sol",
         effort: ["low", "medium", "high", "xhigh", "max"],
         openRouterResolve: "openrouter/openai/gpt-6.1-sol-pro",
-        subagentModel: "gpt-sol"
+        subagentModel: "gpt-sol",
+        pinned: true
       },
       // gpt-5.6's balanced mid-tier. selectable on its own and doubles as Sol's
       // cheaper lens-fanout subagent — replaces the old hidden gpt-5.4 target.
@@ -116559,7 +116561,8 @@ var providers2 = {
         resolve: "deepseek/deepseek-flash",
         effort: ["low", "high", "max"],
         openRouterEffort: ["none", "low", "high", "max"],
-        openRouterResolve: "openrouter/deepseek/deepseek-v4.1-flash"
+        openRouterResolve: "openrouter/deepseek/deepseek-v4.1-flash",
+        pinned: true
       },
       // legacy aliases — deepseek retires these on 2026-07-24; transparently
       // upgrade existing users to the v4 family via the fallback chain.
@@ -116734,7 +116737,8 @@ var providers2 = {
         resolve: "opencode/claude-fable-5-1",
         effort: ["low", "medium", "high", "xhigh", "max"],
         openRouterResolve: "openrouter/~anthropic/claude-fable-latest",
-        subagentModel: "claude-sonnet"
+        subagentModel: "claude-sonnet",
+        pinned: true
       },
       "claude-opus": {
         displayName: "Claude Opus",
@@ -116782,7 +116786,8 @@ var providers2 = {
         resolve: "opencode/gpt-6.1-sol",
         effort: ["low", "medium", "high", "xhigh", "max"],
         openRouterResolve: "openrouter/openai/gpt-6.1-sol-pro",
-        subagentModel: "gpt-sol"
+        subagentModel: "gpt-sol",
+        pinned: true
       },
       // gpt-5.6 balanced mid-tier — selectable + Sol's subagent. see openai above.
       "gpt-terra": {
@@ -116869,7 +116874,8 @@ var providers2 = {
         // id. k2.6 is the newest build Zen will actually serve, and the mirror
         // guard permits the step down because k2.7-code is in ZEN_UNDEPLOYED.
         resolve: "opencode/kimi-k2.6",
-        openRouterResolve: "openrouter/moonshotai/kimi-k2.7-code"
+        openRouterResolve: "openrouter/moonshotai/kimi-k2.7-code",
+        pinned: true
       },
       // M3 is its own line beside M2, not a bump of it — same reason `kimi-k3`
       // sits beside `kimi-k2` rather than replacing it.
@@ -117338,13 +117344,15 @@ var providers2 = {
         effort: ["low", "medium", "high", "xhigh", "max"],
         openRouterResolve: "openrouter/~anthropic/claude-opus-latest",
         preferred: true,
-        subagentModel: "claude-sonnet"
+        subagentModel: "claude-sonnet",
+        pinned: true
       },
       "claude-sonnet": {
         displayName: "Claude Sonnet",
         resolve: "openrouter/~anthropic/claude-sonnet-latest",
         effort: ["low", "medium", "high", "xhigh", "max"],
-        openRouterResolve: "openrouter/~anthropic/claude-sonnet-latest"
+        openRouterResolve: "openrouter/~anthropic/claude-sonnet-latest",
+        pinned: true
       },
       "claude-haiku": {
         displayName: "Claude Haiku",
@@ -117352,7 +117360,8 @@ var providers2 = {
         // the rolling alias moved to Haiku 5.5 on 2026-10-07, which publishes
         // the ladder Haiku 4.5 did not.
         effort: ["none", "low", "medium", "high", "xhigh", "max"],
-        openRouterResolve: "openrouter/~anthropic/claude-haiku-latest"
+        openRouterResolve: "openrouter/~anthropic/claude-haiku-latest",
+        pinned: true
       },
       // pinned to the explicit Sol/Terra/Luna tiers (not the ~openai/gpt-latest
       // rolling alias): after that rename, ~gpt-mini-latest no longer maps
@@ -117379,7 +117388,8 @@ var providers2 = {
         resolve: "openrouter/openai/gpt-6.1-sol-pro",
         effort: ["low", "medium", "high", "xhigh", "max"],
         openRouterResolve: "openrouter/openai/gpt-6.1-sol-pro",
-        subagentModel: "gpt-sol"
+        subagentModel: "gpt-sol",
+        pinned: true
       },
       // gpt-5.6 balanced mid-tier — selectable + Sol's subagent. see openai above.
       "gpt-terra": {
@@ -117444,8 +117454,9 @@ var providers2 = {
         displayName: "Gemini Pro",
         resolve: "openrouter/~google/gemini-pro-latest",
         effort: ["low", "medium", "high"],
-        openRouterResolve: "openrouter/~google/gemini-pro-latest"
+        openRouterResolve: "openrouter/~google/gemini-pro-latest",
         // Inherit — see google/gemini-pro for rationale.
+        pinned: true
       },
       "gemini-flash": {
         displayName: "Gemini Flash",
@@ -117454,7 +117465,8 @@ var providers2 = {
         // entry tracks its siblings' generation bumps for free. the ladder still
         // mirrors exactly: claude-code hard-errors on an out-of-range `--effort`.
         effort: ["low", "medium", "high"],
-        openRouterResolve: "openrouter/~google/gemini-flash-latest"
+        openRouterResolve: "openrouter/~google/gemini-flash-latest",
+        pinned: true
       },
       grok: {
         displayName: "Grok",
@@ -117477,7 +117489,8 @@ var providers2 = {
         displayName: "DeepSeek Flash",
         resolve: "openrouter/deepseek/deepseek-v4.1-flash",
         effort: ["none", "low", "high", "max"],
-        openRouterResolve: "openrouter/deepseek/deepseek-v4.1-flash"
+        openRouterResolve: "openrouter/deepseek/deepseek-v4.1-flash",
+        pinned: true
       },
       // legacy alias — deepseek retires this on 2026-07-24; transparently
       // upgrade existing users to the v4 family via the fallback chain.
@@ -117634,6 +117647,7 @@ var providers2 = {
     }
   })
 };
+var providers2 = bundledProviders;
 function parseModel(slug2) {
   const slashIdx = slug2.indexOf("/");
   if (slashIdx === -1) {
@@ -117672,27 +117686,30 @@ var CLAUDE_CODE_ONLY_CREDENTIALS = ["ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_T
 function getOpenCodeEnvVars(slug2) {
   return getModelEnvVars(slug2).filter((v) => !CLAUDE_CODE_ONLY_CREDENTIALS.includes(v));
 }
-var modelAliases = Object.entries(providers2).flatMap(
-  ([providerKey, config3]) => Object.entries(config3.models).map(([modelId, def]) => ({
-    slug: `${providerKey}/${modelId}`,
-    provider: providerKey,
-    displayName: def.displayName,
-    description: def.description,
-    resolve: def.resolve,
-    openRouterResolve: def.openRouterResolve,
-    preferred: def.preferred ?? false,
-    isFree: def.isFree ?? false,
-    fallback: def.fallback,
-    routing: def.routing,
-    // subagentModel is stored as an alias key local to the provider; expand
-    // here to a fully-qualified slug so callers can look up the target alias
-    // directly without re-deriving the provider.
-    subagentModel: def.subagentModel ? `${providerKey}/${def.subagentModel}` : void 0,
-    effort: def.effort,
-    openRouterEffort: def.openRouterEffort,
-    hidden: def.hidden ?? false
-  }))
-);
+function flattenAliases(source) {
+  return Object.entries(source).flatMap(
+    ([providerKey, config3]) => Object.entries(config3.models).map(([modelId, def]) => ({
+      slug: `${providerKey}/${modelId}`,
+      provider: providerKey,
+      displayName: def.displayName,
+      description: def.description,
+      resolve: def.resolve,
+      openRouterResolve: def.openRouterResolve,
+      preferred: def.preferred ?? false,
+      isFree: def.isFree ?? false,
+      fallback: def.fallback,
+      routing: def.routing,
+      // subagentModel is stored as an alias key local to the provider; expand
+      // here to a fully-qualified slug so callers can look up the target alias
+      // directly without re-deriving the provider.
+      subagentModel: def.subagentModel ? `${providerKey}/${def.subagentModel}` : void 0,
+      effort: def.effort,
+      openRouterEffort: def.openRouterEffort,
+      hidden: def.hidden ?? false
+    }))
+  );
+}
+var modelAliases = flattenAliases(providers2);
 var AUTO_EFFICIENT = "auto/efficient";
 var AUTO_INTELLIGENT = "auto/intelligent";
 var AUTO_TIER_TARGET = {
@@ -117764,9 +117781,7 @@ function autoLadder(slug2) {
   const target = slug2.slice(AUTO_PREFIX.length);
   return target === "router" ? ROUTER_LADDER : PROVIDER_LADDERS[target];
 }
-var ROUTED_PROVIDERS = Object.keys(
-  PROVIDER_LADDERS
-).map((key) => ({ key, displayName: providers2[key].displayName }));
+var ROUTED_PROVIDERS;
 function isCardGatedModel(slug2) {
   return resolveOpenRouterModel(slug2) !== void 0;
 }
@@ -117804,27 +117819,21 @@ function resolveModelRung(params) {
   if (!published) return void 0;
   return resolveRung({ position: params.position, published });
 }
-var defaultProxyAlias = resolveDisplayAlias(AUTO_EFFICIENT);
-if (!defaultProxyAlias?.openRouterResolve) {
-  throw new Error(`DEFAULT_PROXY_MODEL: ${AUTO_EFFICIENT} has no openRouterResolve`);
-}
-var DEFAULT_PROXY_MODEL = defaultProxyAlias.openRouterResolve;
-var defaultProxyDisplayName = defaultProxyAlias.displayName;
-var trialProxyAlias = resolveDisplayAlias("openai/gpt-luna");
-if (!trialProxyAlias?.openRouterResolve) {
-  throw new Error("TRIAL_PROXY_MODEL: openai/gpt-luna has no openRouterResolve");
-}
-var TRIAL_PROXY_MODEL = trialProxyAlias.openRouterResolve;
-var TRIAL_PROXY_DISPLAY_NAME = trialProxyAlias.displayName;
+var DEFAULT_PROXY_MODEL;
+var defaultProxyDisplayName;
+var TRIAL_PROXY_MODEL;
+var TRIAL_PROXY_DISPLAY_NAME;
 var TRIAL_FUNDED_USD_LIMIT = 10;
-for (const [name, ladder] of Object.entries({ ...PROVIDER_LADDERS, router: ROUTER_LADDER })) {
-  const terminal = /* @__PURE__ */ new Set();
-  for (const slug2 of Object.values(ladder)) {
-    const alias = resolveDisplayAlias(slug2);
-    if (!alias) throw new Error(`${name} ladder names unknown alias ${slug2}`);
-    terminal.add(alias.slug);
+function checkLadders() {
+  for (const [name, ladder] of Object.entries({ ...PROVIDER_LADDERS, router: ROUTER_LADDER })) {
+    const terminal = /* @__PURE__ */ new Set();
+    for (const slug2 of Object.values(ladder)) {
+      const alias = resolveDisplayAlias(slug2);
+      if (!alias) throw new Error(`${name} ladder names unknown alias ${slug2}`);
+      terminal.add(alias.slug);
+    }
+    if (terminal.size < 2) throw new Error(`${name} ladder runs every tier on ${[...terminal][0]}`);
   }
-  if (terminal.size < 2) throw new Error(`${name} ladder runs every tier on ${[...terminal][0]}`);
 }
 var OSS_MODEL_ALLOWLIST = [
   // opt-in: 0.86x the old default on the measured mix, and Meta trains on the
@@ -117839,13 +117848,46 @@ var OSS_RECOMMENDED_MODEL = AUTO_TIER_TARGET[AUTO_EFFICIENT];
 function ossFundedModelNames() {
   return OSS_MODEL_ALLOWLIST.map((slug2) => resolveDisplayAlias(slug2)?.displayName ?? slug2);
 }
-var ossAllowedTargets = new Set(
-  OSS_MODEL_ALLOWLIST.map((slug2) => {
+var ossAllowedTargets;
+function deriveFromProviders() {
+  const efficient = resolveDisplayAlias(AUTO_EFFICIENT);
+  if (!efficient?.openRouterResolve) {
+    throw new Error(`DEFAULT_PROXY_MODEL: ${AUTO_EFFICIENT} has no openRouterResolve`);
+  }
+  const trial = resolveDisplayAlias("openai/gpt-luna");
+  if (!trial?.openRouterResolve) {
+    throw new Error("TRIAL_PROXY_MODEL: openai/gpt-luna has no openRouterResolve");
+  }
+  checkLadders();
+  const allowed = OSS_MODEL_ALLOWLIST.map((slug2) => {
     const target = resolveOpenRouterModel(slug2);
     if (!target) throw new Error(`OSS_MODEL_ALLOWLIST: ${slug2} has no openRouterResolve`);
     return target;
-  })
-);
+  });
+  DEFAULT_PROXY_MODEL = efficient.openRouterResolve;
+  defaultProxyDisplayName = efficient.displayName;
+  TRIAL_PROXY_MODEL = trial.openRouterResolve;
+  TRIAL_PROXY_DISPLAY_NAME = trial.displayName;
+  ossAllowedTargets = new Set(allowed);
+  ROUTED_PROVIDERS = Object.keys(PROVIDER_LADDERS).map((key) => ({
+    key,
+    displayName: providers2[key]?.displayName ?? key
+  }));
+}
+deriveFromProviders();
+function installProviders(next2) {
+  const previous = providers2;
+  try {
+    providers2 = next2;
+    modelAliases = flattenAliases(next2);
+    deriveFromProviders();
+  } catch (error63) {
+    providers2 = previous;
+    modelAliases = flattenAliases(previous);
+    deriveFromProviders();
+    throw error63;
+  }
+}
 function isOssAllowedModel(slug2) {
   if (!slug2) return false;
   const target = resolveOpenRouterModel(slug2);
@@ -118054,12 +118096,15 @@ function createProcessOutputActivityTimeout(ctx) {
 
 // utils/claudeSubscription.ts
 var CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
-var fallbackResolve = resolveModelSlug("anthropic/claude-haiku");
-if (!fallbackResolve) {
-  throw new Error("claudeSubscription preflight: anthropic/claude-haiku missing from registry");
+function fallbackProbeModel() {
+  const resolve3 = resolveModelSlug("anthropic/claude-haiku");
+  if (!resolve3) {
+    throw new Error("claudeSubscription preflight: anthropic/claude-haiku missing from registry");
+  }
+  return resolve3.slice(resolve3.indexOf("/") + 1);
 }
-var FALLBACK_PROBE_MODEL = fallbackResolve.slice(fallbackResolve.indexOf("/") + 1);
 async function preflightClaudeSubscription(params) {
+  const model = params.model ?? fallbackProbeModel();
   let res;
   try {
     res = await fetch("https://api.anthropic.com/v1/messages", {
@@ -118072,7 +118117,7 @@ async function preflightClaudeSubscription(params) {
         "x-app": "cli"
       },
       body: JSON.stringify({
-        model: params.model ?? FALLBACK_PROBE_MODEL,
+        model,
         max_tokens: 1,
         system: CLAUDE_CODE_IDENTITY,
         messages: [{ role: "user", content: "ok" }]
@@ -118421,7 +118466,7 @@ import { chmodSync, createWriteStream, existsSync as existsSync4, mkdirSync } fr
 import { join as join2 } from "node:path";
 import { pipeline } from "node:stream/promises";
 function resolveNpm() {
-  const npmCli = process.env.npm_execpath;
+  const npmCli = process.env.NPM_EXECPATH;
   if (npmCli?.endsWith("npm-cli.js")) return { command: process.execPath, args: [npmCli] };
   return { command: "npm", args: [] };
 }
@@ -118756,6 +118801,10 @@ function getDevDependencyVersion(name) {
   }
   return version3;
 }
+var HARNESS_PACKAGES = ["@anthropic-ai/claude-code", "@openai/codex", "opencode-ai"];
+function getHarnessPins() {
+  return Object.fromEntries(HARNESS_PACKAGES.map((name) => [name, getDevDependencyVersion(name)]));
+}
 
 // utils/skills.ts
 var skillsVersion = getDevDependencyVersion("skills");
@@ -119424,8 +119473,12 @@ Every body \`### \` section carries one; an inline comment carries one when its
 The 4-backtick fence lets the block hold its own 3-backtick fences and stay one-click copyable. Skip the optional sections when they'd add nothing.
 
 Backtick-wrap identifiers and file names. Don't repeat diff content, don't include raw \`+123 / -45\` stats, no changelog, no horizontal rules, and no \`### Key changes\` / \`### Issues found\` / \`<b>TL;DR</b>\` heading \u2014 each \`### \` heading IS the issue.`;
-function computeModes(agentId, signedCommits = false) {
+function computeModes(params) {
+  const agentId = params.agentId;
+  const signedCommits = params.signedCommits ?? false;
+  const botLogin = params.botLogin ?? "pullfrog[bot]";
   const t2 = (toolName) => formatMcpToolRef(agentId, toolName);
+  const selfAuthor = botLogin === "pullfrog[bot]" ? "`author=pullfrog[bot]`" : `\`author=${botLogin}\` or \`author=pullfrog[bot]\``;
   const commitStep = signedCommits ? `commit via \`${t2("commit_changes")}\` \u2014 it lands a GitHub-signed commit directly on the remote branch (no push step)` : `commit locally via shell (\`git add . && git commit -m "..."\`)`;
   const finalizeStep = signedCommits ? `confirm a clean working tree (\`git status\`) \u2014 your \`${t2("commit_changes")}\` calls already landed the work on the remote` : `confirm a clean working tree, then push via \`${t2("push_branch")}\``;
   return [
@@ -119599,7 +119652,7 @@ ${PR_SUMMARY_FORMAT}`
 
 4. **prior feedback \u2014 read AND retire it**: fetch previous reviews via \`${t2("list_pull_request_reviews")}\`, then call \`${t2("get_review_comments")}\` on each prior Pullfrog review. Each thread renders as a section whose first line is a fenced tag \`comment author=<login> id=<fullDatabaseId> review=<reviewId> thread=<graphqlId>\`; section headers carry \`[RESOLVED]\` / \`[OUTDATED]\` when relevant. For every **open, Pullfrog-originated** thread, decide and act:
 
-   - **Pullfrog-originated** means the FIRST \`comment author=...\` tag in the section is \`author=pullfrog[bot]\`. The \`*\` marker on individual comments is unrelated \u2014 it flags whether a comment belongs to the queried review, not whether it is the thread root.
+   - **Pullfrog-originated** means the FIRST \`comment author=...\` tag in the section is ${selfAuthor}. The \`*\` marker on individual comments is unrelated \u2014 it flags whether a comment belongs to the queried review, not whether it is the thread root.
    - **addressed?** read the file at the thread's anchor and judge whether the substantive concern is now resolved by the new commits. Lines being modified isn't enough: reformatting, renaming, or moving the same code elsewhere doesn't address a concern. If the comment raised multiple distinct concerns, ALL must be addressed. The \`[OUTDATED]\` tag means GitHub moved the anchor (line shift, force-push, rename) \u2014 it does NOT mean the concern was addressed; re-read the code at its new location before deciding.
    - **if addressed**: call \`${t2("reply_to_review_comment")}\` with the root tag's numeric \`id=\` as \`comment_id\` (NOT the \`thread=\` value \u2014 that's a separate GraphQL ID used only by resolve) and a one-line body (e.g. \`Addressed in <short-sha>.\`), then call \`${t2("resolve_review_thread")}\` with the root tag's \`thread=\` value as \`thread_id\`. Do this BEFORE drafting the new review so the GitHub thread state aligns with the new review by the time it lands.
    - **if uncertain or partially addressed**: leave open. False-positive resolutions erode trust faster than false negatives.
@@ -119740,7 +119793,7 @@ ${PR_SUMMARY_FORMAT}`
     }
   ];
 }
-var modes = computeModes("opencode");
+var modes = computeModes({ agentId: "opencode" });
 var NON_COMMITTING_MODES = /* @__PURE__ */ new Set([
   "Review",
   "IncrementalReview",
@@ -121960,7 +122013,7 @@ var codex = agent({
 
 // agents/opencode.ts
 import { spawn as nodeSpawn2 } from "node:child_process";
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "node:fs";
 import { totalmem } from "node:os";
 import { join as join9 } from "node:path";
 import { performance as performance7 } from "node:perf_hooks";
@@ -127373,10 +127426,770 @@ var import_undici2 = __toESM(require_undici2(), 1);
 
 // utils/openCodeModels.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
 import { join as join8 } from "node:path";
+
+// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/cache/adapter.js
+var AdapterError = class extends Error {
+  /** the adapter method that failed */
+  method;
+  /** the full store key, or the op's prefix when the call covered many keys. never the raw input. */
+  key;
+  constructor(method, key, cause) {
+    super(`cache ${method} failed for ${key}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.name = "AdapterError";
+    this.method = method;
+    this.key = key;
+  }
+};
+
+// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/cache/memory.js
+function memory({ maxItems = 1e3 } = {}) {
+  const store = /* @__PURE__ */ new Map();
+  const peek = (key) => {
+    const slot = store.get(key);
+    if (slot === void 0)
+      return;
+    if (slot.until > Date.now())
+      return slot;
+    store.delete(key);
+  };
+  const evict = () => {
+    for (const [key, slot] of store) {
+      store.delete(key);
+      if (!slot.used)
+        return;
+      slot.used = false;
+      store.set(key, slot);
+    }
+  };
+  return {
+    get: (key) => {
+      const slot = peek(key);
+      if (slot === void 0)
+        return;
+      slot.used = true;
+      return slot.entry;
+    },
+    peek: (key) => peek(key)?.entry,
+    // the TTL rides on each entry, so ops with different lifetimes can share one store
+    // evicted before the new slot goes in, so the entry being written is never the one dropped: after it, a full store
+    // whose every slot was read would pass each over and drop the new, unread one
+    set: (key, entry, ttlMs) => {
+      store.delete(key);
+      if (store.size >= maxItems)
+        evict();
+      store.set(key, { entry, until: Date.now() + ttlMs, used: false });
+    },
+    delete: (keys) => {
+      for (const key of keys)
+        store.delete(key);
+    },
+    // a snapshot, so deleting while iterating is safe
+    list: (prefix) => {
+      const now = Date.now();
+      const listed = [];
+      for (const [key, slot] of store)
+        if (slot.until > now && key.startsWith(prefix))
+          listed.push([key, slot.entry]);
+      return listed;
+    }
+  };
+}
+
+// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/issues.js
+function issueJSON(issue4) {
+  const segments = issue4.path ?? [];
+  const path4 = [];
+  for (let i2 = 0; i2 < segments.length; i2++) {
+    const segment = segments[i2];
+    const wrapped = typeof segment === "object" && segment !== null;
+    const key = wrapped ? segment.key : segment;
+    if (typeof key === "string" || typeof key === "number" && Number.isFinite(key))
+      path4.push(key);
+    else if (typeof key === "symbol")
+      path4.push(String(key));
+    else if (!(wrapped && key === null && segment.type === "set"))
+      break;
+  }
+  const { keyword } = issue4;
+  return typeof keyword === "string" ? { message: issue4.message, path: path4, keyword } : { message: issue4.message, path: path4 };
+}
+function issuesJSON(issues) {
+  const out = [];
+  for (let i2 = 0; i2 < issues.length; i2++)
+    if (issues[i2])
+      out.push(issueJSON(issues[i2]));
+  return out;
+}
+var identifier = /^[A-Za-z_$][\w$]*$/;
+var longestKey = 40;
+function renderPath(path4) {
+  let out = "";
+  for (const key of path4) {
+    if (typeof key === "number")
+      out += `[${key}]`;
+    else if (key.length <= longestKey && identifier.test(key))
+      out += out ? `.${key}` : key;
+    else
+      out += `[${JSON.stringify(key.length <= longestKey ? key : `${key.slice(0, longestKey)}\u2026`)}]`;
+  }
+  return out;
+}
+var shown = 10;
+function summary2(issues, truncated2) {
+  const lines = [];
+  let i2 = 0;
+  for (; i2 < issues.length && lines.length < shown; i2++) {
+    const issue4 = issues[i2];
+    if (!issue4)
+      continue;
+    const { message: message2, path: path4 } = issueJSON(issue4);
+    lines.push(path4.length ? `${renderPath(path4)}: ${message2}` : message2);
+  }
+  let more = 0;
+  for (; i2 < issues.length; i2++)
+    if (issues[i2])
+      more++;
+  if (more > 0)
+    lines.push(truncated2 ? `and over ${more} more` : `and ${more} more`);
+  else if (truncated2)
+    lines.push("and more");
+  return `validation failed: ${lines.join("; ")}`;
+}
+var ValidationError = class extends Error {
+  name = "ValidationError";
+  constructor(result) {
+    super(message(result));
+    Object.defineProperty(this, "result", { value: result });
+    Object.assign(this, { issues: result.issues });
+  }
+  /**
+   * The error as plain data, each issue projected to its message, path and keyword, so what else a validator keeps on
+   * one (Valibot's and Zod's `input`) is left out. The messages are the validator's own, and some quote the value.
+   */
+  toJSON() {
+    const json4 = { name: "ValidationError", message: this.message, issues: issuesJSON(this.issues) };
+    return truncated(this.result) ? { ...json4, truncated: true } : json4;
+  }
+};
+function message(result) {
+  try {
+    return ownSummary(result) ?? summary2(result.issues, truncated(result));
+  } catch {
+    return "validation failed";
+  }
+}
+function ownSummary(result) {
+  const own2 = result;
+  return typeof own2.message === "string" ? own2.message : typeof own2.summary === "string" ? own2.summary : void 0;
+}
+var truncated = (result) => result.truncated === true;
+
+// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/env.js
+var debugging = () => debug2 ??= read();
+var read = () => {
+  try {
+    return globalThis.process?.env?.LOG_LEVEL === "debug";
+  } catch {
+    return false;
+  }
+};
+var debug2;
+
+// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/hash-node.js
+import { createRequire } from "node:module";
+var sha1 = (text) => {
+  crypto3 ??= load();
+  return crypto3.hash("sha1", text);
+};
+var crypto3;
+var load = () => globalThis.process?.getBuiltinModule?.("node:crypto") ?? createRequire("/")("node:crypto");
+
+// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/key.js
+function cacheKey(value2) {
+  if (value2 === null)
+    throw new Error("null cannot be part of a cache key");
+  if (value2 === void 0)
+    return "~void";
+  const json4 = canonical(value2);
+  return json4.length > longKey ? `#${sha1(json4)}` : json4;
+}
+var longKey = 4096;
+function hashKey(key) {
+  if (key === "~void")
+    return key;
+  return key[0] === "#" ? key.slice(1) : sha1(key);
+}
+function canonical(value2) {
+  return serialize(value2, 0);
+}
+function serialize(value2, depth) {
+  switch (typeof value2) {
+    case "number":
+      if (Number.isFinite(value2))
+        return String(value2);
+      throw new Error(`${value2} cannot be part of a cache key`);
+    case "string":
+    case "boolean":
+      return JSON.stringify(value2);
+    case "undefined":
+      throw new Error("undefined cannot be part of a cache key, except as an object property");
+    case "object":
+      break;
+    default:
+      throw new Error(`a ${typeof value2} cannot be part of a cache key`);
+  }
+  if (value2 === null)
+    return "null";
+  if (depth++ === 64)
+    throw new Error("an input nested more than 64 levels deep, or circular");
+  if (Array.isArray(value2)) {
+    let out2 = "[";
+    for (let i2 = 0; i2 < value2.length; i2++)
+      out2 += `${i2 ? "," : ""}${serialize(value2[i2], depth)}`;
+    return `${out2}]`;
+  }
+  const proto = Object.getPrototypeOf(value2);
+  if (proto !== Object.prototype && proto !== null) {
+    const name = proto.constructor?.name || "class instance";
+    throw new Error(`a ${name} cannot be part of a cache key: only JSON data can`);
+  }
+  let out = "";
+  for (const key of Object.keys(value2).sort()) {
+    const v = value2[key];
+    if (v !== void 0)
+      out += `${out ? "," : ""}${JSON.stringify(key)}:${serialize(v, depth)}`;
+  }
+  return `{${out}}`;
+}
+
+// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/plain.js
+var isPlain = (value2) => {
+  if (typeof value2 !== "object" || value2 === null)
+    return false;
+  const proto = Object.getPrototypeOf(value2);
+  return proto === Object.prototype || proto === null;
+};
+
+// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/sleep.js
+function sleep(ms, signal) {
+  return new Promise((resolve3) => {
+    if (signal?.aborted)
+      return resolve3();
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve3();
+    };
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+
+// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/api.js
+function backoff(schedule, attempt) {
+  const d = schedule[attempt - 1];
+  return d === void 0 ? -1 : Math.round(d / 2 + Math.random() * d / 2);
+}
+async function assertSchema(schema2, value2) {
+  const result = await schema2["~standard"].validate(value2);
+  if (result.issues)
+    throw new ValidationError(result);
+  return result.value;
+}
+var TimeoutError = class extends Error {
+  name = "TimeoutError";
+  /** the op's `timeout`, in ms */
+  timeout;
+  constructor(timeout) {
+    super(`attempt timed out after ${timeout}ms`);
+    this.timeout = timeout;
+  }
+};
+var gates = /* @__PURE__ */ new WeakMap();
+function semaphore(size) {
+  let free = size;
+  const line = [];
+  return {
+    acquire: (signal) => free > 0 ? void free-- : wait(line, signal),
+    release: () => {
+      const next2 = line.shift();
+      if (next2)
+        next2();
+      else
+        free++;
+    }
+  };
+}
+function wait(line, signal, left) {
+  return new Promise((resolve3, reject) => {
+    const abort = () => {
+      line.splice(line.indexOf(next2), 1);
+      left?.();
+      reject(signal.reason);
+    };
+    const next2 = () => {
+      signal?.removeEventListener("abort", abort);
+      resolve3();
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    line.push(next2);
+  });
+}
+function op(options) {
+  return build(options, true);
+}
+function build(options, cacheMethods) {
+  const { name, input: inputSchema, output: outputSchema, run: run4, dedupe, ttl, cache: adapter, timeout } = options;
+  const { retry, concurrency } = options;
+  const delayFor = Array.isArray(retry) ? (_, attempt) => backoff(retry, attempt) : retry;
+  if (ttl !== void 0 && typeof ttl !== "function" && !isLifetime(ttl)) {
+    throw new TypeError(`yes.op: ttl must be a positive number of milliseconds, got ${ttl}`);
+  }
+  if (timeout !== void 0 && !(isLifetime(timeout) && timeout <= maxDelay)) {
+    throw new TypeError(`yes.op: timeout must be a positive number of milliseconds up to ${maxDelay}, got ${timeout}`);
+  }
+  if (concurrency !== void 0 && !(Number.isInteger(concurrency) && concurrency > 0)) {
+    throw new TypeError(`yes.op: concurrency must be a positive integer, got ${concurrency}`);
+  }
+  const lifetime = typeof ttl === "function" ? ttl : (result) => result == null || result instanceof Error ? 0 : ttl;
+  if (adapter && (!name || name.includes(":"))) {
+    throw new TypeError(`yes.op: an op with a cache adapter needs a name without ":", got ${JSON.stringify(name)}`);
+  }
+  if (adapter && ttl === void 0)
+    throw new TypeError(`yes.op: a cache adapter does nothing without a ttl`);
+  const store = ttl === void 0 ? void 0 : adapter ?? memory({ maxItems: options.maxItems });
+  const keepsErrors = !!store && "peek" in store;
+  const prefix = adapter ? `yes:${name}:` : "";
+  const storeKey = adapter ? (key) => prefix + hashedKey(key) : (key) => key.local;
+  const reported = adapter ? void 0 : hashKey;
+  const label = name ? `[${name}] ` : "";
+  const slots = concurrency === void 0 ? void 0 : semaphore(concurrency);
+  const gate = options.rateLimit === void 0 ? void 0 : gates.get(options.rateLimit);
+  if (options.rateLimit !== void 0 && !gate)
+    throw new TypeError(`yes.op: rateLimit takes a yes.rateLimiter`);
+  const take = gate?.take;
+  const admit = slots || take ? async (signal, limitKey) => {
+    await slots?.acquire(signal);
+    try {
+      await take?.(signal, limitKey);
+    } catch (error63) {
+      slots?.release();
+      throw error63;
+    }
+  } : void 0;
+  const keyOf = (input2) => {
+    try {
+      return { local: cacheKey(input2), hashed: void 0 };
+    } catch (error63) {
+      throw new Error(`${label}${error63.message}. dedupe and ttl key the input, and a query always dedupes; a write is yes.mutation, which never keys.`, { cause: error63 });
+    }
+  };
+  const report = (attempt, message2, error63, key) => {
+    console.log(`${label}attempt ${attempt} ${message2}`);
+    const data = key === void 0 ? { error: error63, attempt } : { key, error: error63, attempt };
+    console.log(...label ? [label, data] : [data]);
+  };
+  const on = options.on ?? {};
+  const onHit = on.hit ?? void 0;
+  const onRun = on.run ?? void 0;
+  const onAttempt = on.attempt ?? void 0;
+  const onRetry = hookOr(on.retry, delayFor && ((event) => report(event.attempt, `failed, retrying in ${event.wait}ms`, event.error, event.key)));
+  const onSuccess = on.success ?? void 0;
+  const onFailure = hookOr(on.failure, delayFor && ((event) => report(event.attempts, "failed, not retrying", event.error, event.key)));
+  const failureLine = on.failure === void 0;
+  const runOnce = (input2, ctx, signal) => {
+    if (timeout === void 0)
+      return run4(input2, ctx);
+    const controller = timeout !== void 0 && ownsSignal(ctx) ? new AbortController() : void 0;
+    const follow = controller && signal && (() => controller.abort(signal.reason));
+    return new Promise((resolve3, reject) => {
+      let settled = false;
+      let pending;
+      const settle2 = (done) => (value2) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(pending);
+        if (follow)
+          signal.removeEventListener("abort", follow);
+        done(value2);
+      };
+      if (timeout !== void 0) {
+        pending = setTimeout(() => {
+          const error63 = new TimeoutError(timeout);
+          settle2(reject)(error63);
+          controller?.abort(error63);
+        }, timeout);
+      }
+      if (follow) {
+        if (signal.aborted)
+          follow();
+        else
+          signal.addEventListener("abort", follow, { once: true });
+      }
+      try {
+        const own2 = controller ? { ...ctx, signal: controller.signal } : ctx;
+        Promise.resolve(run4(input2, own2)).then(settle2(resolve3), settle2(reject));
+      } catch (error63) {
+        settle2(reject)(error63);
+      }
+    });
+  };
+  const attempts = async (input2, ctx, key, trace, signal, tally) => {
+    const limitKey = gate?.by?.(input2, ctx);
+    const own2 = inject(ctx);
+    for (let attempt = 1; ; attempt++) {
+      signal?.throwIfAborted();
+      if (admit)
+        await admit(signal, limitKey);
+      if (tally)
+        tally.started = attempt;
+      try {
+        let returned;
+        try {
+          if (onAttempt) {
+            const awaited = onAttempt({ name, input: input2, ctx, key: hashedKey(key), attempt });
+            if (isThenable(awaited))
+              await awaited;
+          }
+          returned = await runOnce(input2, own2, signal);
+        } finally {
+          slots?.release();
+        }
+        const result = outputSchema ? await assertSchema(outputSchema, returned) : returned;
+        trace?.(`run resolved on attempt ${attempt}`);
+        return result;
+      } catch (thrown) {
+        let error63 = thrown;
+        let wait2 = -1;
+        let stopped = false;
+        if (gate && !(error63 instanceof ValidationError)) {
+          try {
+            const paused = gate.failed(error63, limitKey);
+            if (paused)
+              trace?.(`rate limit paused for ${paused}ms`);
+          } catch (stop2) {
+            error63 = stop2;
+            stopped = true;
+          }
+        }
+        if (delayFor && !stopped && !(error63 instanceof ValidationError) && !signal?.aborted) {
+          try {
+            wait2 = delayFor(error63, attempt);
+          } catch (stop2) {
+            error63 = stop2;
+          }
+          if (typeof wait2 !== "number") {
+            error63 = new TypeError(`yes.op: a retry waits a number of ms, got ${typeof wait2}`, { cause: error63 });
+            wait2 = -1;
+          } else if (wait2 > maxDelay) {
+            error63 = new RangeError(`yes.op: a retry waits at most ${maxDelay}ms, got ${wait2}`, { cause: error63 });
+            wait2 = -1;
+          }
+        }
+        if (wait2 >= 0 && onRetry) {
+          try {
+            const returned = onRetry({ name, input: input2, ctx, key: hashedKey(key), error: error63, attempt, wait: wait2 });
+            if (isThenable(returned))
+              await returned;
+          } catch (stop2) {
+            error63 = stop2;
+            wait2 = -1;
+          }
+        }
+        if (wait2 >= 0) {
+          await sleep(wait2, signal);
+          continue;
+        }
+        trace?.(`run failed on attempt ${attempt}`, { error: error63 });
+        throw error63;
+      }
+    }
+  };
+  const execution = onRun || onSuccess || onFailure ? async (input2, ctx, key, trace, signal, write2) => {
+    const tally = { started: 0 };
+    let result;
+    try {
+      if (onRun) {
+        const awaited = onRun({ name, input: input2, ctx, key: hashedKey(key) });
+        if (isThenable(awaited))
+          await awaited;
+      }
+      result = await attempts(input2, ctx, key, trace, signal, tally);
+      if (write2)
+        result = await write2(result);
+    } catch (error63) {
+      if (onFailure && !signal?.aborted && !(failureLine && tally.started <= 1)) {
+        const awaited = onFailure({ name, input: input2, ctx, key: hashedKey(key), error: error63, attempts: tally.started });
+        if (isThenable(awaited))
+          await awaited;
+      }
+      throw error63;
+    }
+    if (onSuccess) {
+      const awaited = onSuccess({ name, input: input2, ctx, key: hashedKey(key), result, attempts: tally.started });
+      if (isThenable(awaited))
+        await awaited;
+    }
+    return result;
+  } : (input2, ctx, key, trace, signal, write2) => {
+    const running = attempts(input2, ctx, key, trace, signal);
+    return write2 ? running.then(write2) : running;
+  };
+  const hit = (input2, ctx, key, trace, from, value2) => {
+    trace?.(`cache hit (${from})`);
+    const awaited = onHit?.({ name, input: input2, ctx, key: hashedKey(key), from });
+    if (!isThenable(awaited))
+      return value2;
+    if (isThenable(value2))
+      value2.then(void 0, () => {
+      });
+    return awaited.then(() => value2);
+  };
+  const inFlight = /* @__PURE__ */ new Map();
+  const writers = /* @__PURE__ */ new Map();
+  let executions = 0;
+  const execute2 = async (rawInput, ctx, refresh) => {
+    const input2 = inputSchema ? await assertSchema(inputSchema, rawInput) : rawInput;
+    const signal = signalOf(ctx);
+    if (!dedupe && !store)
+      return execution(input2, ctx, void 0, debugTrace(label), signal);
+    const key = keyOf(input2);
+    const trace = debugTrace(label, key);
+    const shared = inFlight.get(key.local);
+    if (shared && !refresh) {
+      const [execution2, leader] = shared;
+      return hit(input2, ctx, key, trace, "in-flight", leader ? execution2.catch((error63) => {
+        if (!leader.aborted)
+          throw error63;
+        signal?.throwIfAborted();
+        return execute2(rawInput, ctx, false);
+      }) : execution2);
+    }
+    const fullKey = storeKey(key);
+    const read3 = store && !refresh ? callAdapter("get", fullKey, () => store.get(fullKey), reported) : void 0;
+    const entry = freshEntry(read3);
+    if (entry)
+      return hit(input2, ctx, key, trace, "store", entry.value);
+    const number6 = ++executions;
+    let writer;
+    if (store) {
+      writer = writers.get(key.local);
+      if (!writer) {
+        writer = { running: 0, refreshed: 0 };
+        writers.set(key.local, writer);
+      }
+      writer.running++;
+      if (refresh)
+        writer.refreshed = number6;
+    }
+    const write2 = store && (async (result) => {
+      const ms = lifetime(result);
+      if (!(isLifetime(ms) && writer.refreshed <= number6 && (keepsErrors || !(result instanceof Error)))) {
+        return result;
+      }
+      const created = Date.now();
+      try {
+        await store.set(fullKey, { value: result, created, expires: created + ms, input: input2 }, ms);
+      } catch (error63) {
+        console.error(`${label}cache write failed, returning the result uncached`, new AdapterError("set", reported ? reported(fullKey) : fullKey, error63));
+      }
+      return result;
+    });
+    const promise2 = (async () => {
+      const stored = isThenable(read3) ? freshEntry(await read3) : void 0;
+      if (stored)
+        return hit(input2, ctx, key, trace, "store", stored.value);
+      trace?.(refresh ? "refreshing, running" : "cache miss, running");
+      return execution(input2, ctx, key, trace, signal, write2);
+    })();
+    const settled = writer ? promise2.finally(() => --writer.running || writers.delete(key.local)) : promise2;
+    if (!dedupe)
+      return settled;
+    const flight = [settled, signal];
+    inFlight.set(key.local, flight);
+    return settled.finally(() => inFlight.get(key.local) === flight && inFlight.delete(key.local));
+  };
+  const call = (rawInput, ctx) => execute2(rawInput, ctx, false);
+  const jsonSchema2 = inputSchema?.["~standard"].jsonSchema;
+  if (jsonSchema2) {
+    call["~standard"] = {
+      version: 1,
+      vendor: "yes",
+      name: name ?? "",
+      description: options.description ?? "",
+      jsonSchema: {
+        input: (params) => jsonSchema2.input(params),
+        // what the op returns is what its output schema returns; without one that can say so, any value
+        output: (params) => outputSchema?.["~standard"].jsonSchema?.output(params) ?? {}
+      },
+      ...run4.length < 2 && {
+        execute: (input2, options2) => call(input2, options2?.signal ? { signal: options2.signal } : void 0)
+      }
+    };
+  }
+  if (!cacheMethods)
+    return call;
+  const withKey = (input2, use) => {
+    const toKey = (result2) => use(storeKey(keyOf(result2 && !result2.issues ? result2.value : input2)));
+    const result = inputSchema?.["~standard"].validate(input2);
+    return result instanceof Promise ? result.then(toKey) : toKey(result);
+  };
+  return Object.assign(call, {
+    clear: async (input2) => {
+      if (!store)
+        return;
+      if (input2 === void 0)
+        await sweep(store, prefix, () => true);
+      else
+        await withKey(input2, (key) => callAdapter("delete", key, () => store.delete([key]), reported));
+    },
+    // the memory store peeks, so asking whether a key is cached does not change which key is evicted next
+    has: async (input2) => !!store && !!freshEntry(await withKey(input2, (key) => callAdapter("get", key, () => "peek" in store ? store.peek(key) : store.get(key), reported))),
+    // not `async`: on the memory store a predicate that throws throws here, not in a promise nobody awaits
+    invalidate: (match3) => {
+      const accepts = typeof match3 === "function" ? match3 : fieldsMatch(match3);
+      return Promise.resolve(store ? sweep(store, prefix, accepts) : 0);
+    },
+    refresh: (rawInput, ctx) => execute2(rawInput, ctx, true)
+  });
+}
+function query(options) {
+  return op({ ...options, dedupe: true });
+}
+function mutation({ dedupe: _dedupe, ttl: _ttl, cache: _cache, ...options }) {
+  return build(options, false);
+}
+var hookOr = (given, line) => given === void 0 ? line || void 0 : given ?? void 0;
+var ownsSignal = (ctx) => {
+  if (ctx === void 0)
+    return true;
+  if (!isPlain(ctx))
+    return false;
+  const signal = ctx.signal;
+  return signal === void 0 || isSignal(signal);
+};
+var inject = (ctx) => {
+  if (ctx === void 0)
+    return { signal: idleSignal() };
+  return isPlain(ctx) && ctx.signal === void 0 ? { ...ctx, signal: idleSignal() } : ctx;
+};
+var idle;
+var idleSignal = () => {
+  if (idle === void 0 && typeof AbortController === "function")
+    idle = new AbortController().signal;
+  return idle;
+};
+var signalOf = (ctx) => {
+  const signal = ctx?.signal;
+  return isSignal(signal) ? signal : void 0;
+};
+var isSignal = (value2) => typeof AbortSignal === "function" && value2 instanceof AbortSignal;
+function debugTrace(label, callKey) {
+  if (!debugging())
+    return;
+  const prefix = `${label}[${(/* @__PURE__ */ new Date()).toISOString()}]`;
+  const start = performance.now();
+  const key = hashedKey(callKey);
+  return (message2, data) => console.log(`${prefix} ${message2} +${Math.round(performance.now() - start)}ms`, { ...key && { key }, ...data });
+}
+function hashedKey(key) {
+  if (key)
+    key.hashed ??= hashKey(key.local);
+  return key?.hashed;
+}
+var maxDelay = 2 ** 31 - 1;
+var isLifetime = (ms) => typeof ms === "number" && ms > 0 && Number.isFinite(ms);
+function fieldsMatch(partial3) {
+  const fields = Object.entries(partial3).map(([field, value2]) => [
+    field,
+    value2 === void 0 ? void 0 : canonical(value2)
+  ]);
+  return (input2) => typeof input2 === "object" && input2 !== null && fields.every(([field, value2]) => {
+    const actual = input2[field];
+    return actual === void 0 ? value2 === void 0 : value2 !== void 0 && canonical(actual) === value2;
+  });
+}
+var isThenable = (value2) => typeof value2?.then === "function";
+function freshEntry(value2) {
+  return typeof value2?.expires === "number" && value2.expires > Date.now() && "value" in value2 ? value2 : void 0;
+}
+function callAdapter(method, key, run4, reported) {
+  try {
+    const result = run4();
+    if (!isThenable(result))
+      return result;
+    return result.then(void 0, (error63) => {
+      throw new AdapterError(method, reported ? reported(key) : key, error63);
+    });
+  } catch (error63) {
+    throw new AdapterError(method, reported ? reported(key) : key, error63);
+  }
+}
+function sweep(store, prefix, match3) {
+  const purge = (listed2) => {
+    const now = Date.now();
+    const keys = [];
+    let count = 0;
+    for (const [key, { input: input2, expires }] of listed2) {
+      if (!(expires > now))
+        keys.push(key);
+      else if (match3(input2)) {
+        keys.push(key);
+        count++;
+      }
+    }
+    const remove = (from) => {
+      if (from >= keys.length)
+        return count;
+      const deleted = callAdapter("delete", prefix, () => store.delete(keys.slice(from, from + 1e3)));
+      return isThenable(deleted) ? Promise.resolve(deleted).then(() => remove(from + 1e3)) : remove(from + 1e3);
+    };
+    return remove(0);
+  };
+  const listed = callAdapter("list", prefix, () => {
+    const listed2 = store.list(prefix);
+    if (Array.isArray(listed2))
+      return listed2;
+    return (async () => {
+      const items = [];
+      for await (const item of await listed2)
+        items.push(item);
+      return items;
+    })();
+  });
+  return Array.isArray(listed) ? purge(listed) : listed.then(purge);
+}
+
+// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/try.js
+function asError(value2) {
+  if (value2 instanceof Error)
+    return value2;
+  let message2;
+  try {
+    message2 = String(value2);
+  } catch {
+    message2 = "a value that is not an Error";
+  }
+  return new Error(message2, { cause: value2 });
+}
+var tryCall = async (call) => {
+  try {
+    return await (typeof call === "function" ? call() : call);
+  } catch (error63) {
+    return asError(error63);
+  }
+};
+
+// utils/openCodeModels.ts
 var baseline;
 var authorized;
 var failure2;
+var catalogFailure;
+var DEFAULT_MODELS_URL = "https://models.opencode.ai";
 var ANSI_PATTERN = /\[[0-9;]*m/g;
 function openCodeHomeEnv(tmpdir5) {
   return {
@@ -127387,6 +128200,36 @@ function openCodeHomeEnv(tmpdir5) {
     XDG_STATE_HOME: join8(tmpdir5, ".local", "state")
   };
 }
+var fetchCatalog = query({
+  run: async (url4, ctx) => {
+    const response = await fetch(url4, { signal: ctx.signal });
+    if (!response.ok) throw new Error(`${url4} answered ${response.status}`);
+    const text = await response.text();
+    JSON.parse(text);
+    return text;
+  },
+  name: "models catalog",
+  timeout: 1e4,
+  retry: [1e3]
+});
+async function seedModelsCatalog(tmpdir5) {
+  const source = process.env.OPENCODE_MODELS_URL || DEFAULT_MODELS_URL;
+  const name = source === DEFAULT_MODELS_URL ? "models.json" : `models-${createHash2("sha1").update(source).digest("hex")}.json`;
+  const result = await tryCall(fetchCatalog(`${source}/api.json`));
+  if (result instanceof Error) {
+    catalogFailure = result.cause instanceof Error ? `${result.message}: ${result.cause.message}` : result.message;
+    log2.warning(
+      `\xBB could not download opencode's model catalog (${catalogFailure}). opencode falls back to the snapshot built into it, which lacks models released since that build.`
+    );
+    return;
+  }
+  const dir = join8(openCodeHomeEnv(tmpdir5).XDG_CACHE_HOME, "opencode");
+  mkdirSync7(dir, { recursive: true });
+  writeFileSync7(join8(dir, name), result);
+}
+function getModelsCatalogFailure() {
+  return catalogFailure;
+}
 function readModels(params) {
   const result = spawnSync4(params.cliPath, ["models"], {
     encoding: "utf-8",
@@ -128387,8 +129230,8 @@ var opencode = agent({
     const xaiAuth = installXaiAuth();
     const homeEnv = openCodeHomeEnv(ctx.tmpdir);
     const opencodePluginDir = join9(homeEnv.XDG_CONFIG_HOME, "opencode", "plugin");
-    mkdirSync7(opencodePluginDir, { recursive: true });
-    writeFileSync7(
+    mkdirSync8(opencodePluginDir, { recursive: true });
+    writeFileSync8(
       join9(opencodePluginDir, PULLFROG_OPENCODE_GATE_PLUGIN_FILENAME),
       buildOpencodeSubagentGateSource(ctx)
     );
@@ -136496,7 +137339,7 @@ var Hono3 = class extends Hono {
 };
 
 // node_modules/.pnpm/mcp-proxy@6.7.21/node_modules/mcp-proxy/dist/startStdioServer-SHdEnYLY.mjs
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import { randomUUID as randomUUID3, timingSafeEqual } from "node:crypto";
 
 // node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
@@ -138899,7 +139742,7 @@ var rev2025Codec = {
   encodeErrorCode: (code) => code === -32002 ? -32602 : code,
   checkInboundEnvelope: (_material) => void 0
 };
-function build() {
+function build2() {
   const JSONValueSchema$1 = lazy(() => union([
     string2(),
     number2(),
@@ -139774,7 +140617,7 @@ function build() {
 }
 var memo2;
 function buildSchemas2026() {
-  return memo2 ??= build();
+  return memo2 ??= build2();
 }
 var CACHEABLE_RESULT_METHODS = [
   "tools/list",
@@ -141204,7 +142047,7 @@ var REQUEST_STATE_ONLY_LEG_PACING_MS = 250;
 function inputRequiredRoundsExceededMessage(method, maxRounds) {
   return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
 }
-function sleep(ms, signal) {
+function sleep2(ms, signal) {
   return new Promise((resolve3, reject) => {
     if (signal?.aborted) {
       reject(signal.reason instanceof SdkError ? signal.reason : new SdkError(SdkErrorCode.RequestTimeout, String(signal.reason)));
@@ -144363,8 +145206,8 @@ var require_resolve2 = /* @__PURE__ */ __commonJSMin(((exports) => {
     }
     return count;
   }
-  function getFullPath(resolver, id = "", normalize3) {
-    if (normalize3 !== false) id = normalizeId(id);
+  function getFullPath(resolver, id = "", normalize4) {
+    if (normalize4 !== false) id = normalizeId(id);
     return _getFullPath(resolver, resolver.parse(id));
   }
   exports.getFullPath = getFullPath;
@@ -145459,7 +146302,7 @@ var require_schemes2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_fast_uri2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils5();
   const { SCHEMES, getSchemeHandler } = require_schemes2();
-  function normalize3(uri, options) {
+  function normalize4(uri, options) {
     if (typeof uri === "string") uri = serialize2(parse6(uri, options), options);
     else if (typeof uri === "object") uri = parse6(serialize2(uri, options), options);
     return uri;
@@ -145637,7 +146480,7 @@ var require_fast_uri2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   }
   const fastUri = {
     SCHEMES,
-    normalize: normalize3,
+    normalize: normalize4,
     resolve: resolve3,
     resolveComponent,
     equal,
@@ -149836,7 +150679,7 @@ var LegacyInputRequiredShim = class {
         } finally {
           roundAbort.dispose();
         }
-      } else await sleep(REQUEST_STATE_ONLY_LEG_PACING_MS, outerSignal);
+      } else await sleep2(REQUEST_STATE_ONLY_LEG_PACING_MS, outerSignal);
       let ctxNext = {
         ...ctx,
         mcpReq: {
@@ -152425,7 +153268,7 @@ function createMcpHandler(factory, options = {}) {
 import http2 from "http";
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 import { TLSSocket } from "node:tls";
 import fs4 from "fs";
 import https2 from "https";
@@ -153805,7 +154648,7 @@ var rev2025Codec2 = {
   encodeErrorCode: (code) => code === -32002 ? -32602 : code,
   checkInboundEnvelope: (_material) => void 0
 };
-function build2() {
+function build3() {
   const JSONValueSchema$1 = lazy(() => union([
     string2(),
     number2(),
@@ -154680,7 +155523,7 @@ function build2() {
 }
 var memo3;
 function buildSchemas20262() {
-  return memo3 ??= build2();
+  return memo3 ??= build3();
 }
 var CACHEABLE_RESULT_METHODS2 = [
   "tools/list",
@@ -158700,8 +159543,8 @@ var require_resolve3 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     }
     return count;
   }
-  function getFullPath(resolver, id = "", normalize3) {
-    if (normalize3 !== false) id = normalizeId(id);
+  function getFullPath(resolver, id = "", normalize4) {
+    if (normalize4 !== false) id = normalizeId(id);
     return _getFullPath(resolver, resolver.parse(id));
   }
   exports.getFullPath = getFullPath;
@@ -159796,7 +160639,7 @@ var require_schemes3 = /* @__PURE__ */ __commonJSMin2(((exports, module) => {
 var require_fast_uri3 = /* @__PURE__ */ __commonJSMin2(((exports, module) => {
   const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils6();
   const { SCHEMES, getSchemeHandler } = require_schemes3();
-  function normalize3(uri, options) {
+  function normalize4(uri, options) {
     if (typeof uri === "string") uri = serialize2(parse6(uri, options), options);
     else if (typeof uri === "object") uri = parse6(serialize2(uri, options), options);
     return uri;
@@ -159974,7 +160817,7 @@ var require_fast_uri3 = /* @__PURE__ */ __commonJSMin2(((exports, module) => {
   }
   const fastUri = {
     SCHEMES,
-    normalize: normalize3,
+    normalize: normalize4,
     resolve: resolve3,
     resolveComponent,
     equal,
@@ -163697,8 +164540,8 @@ var addFormats2 = import_dist2.default;
 var Ajv3 = import_ajv3.Ajv;
 
 // node_modules/.pnpm/pkce-challenge@5.0.1/node_modules/pkce-challenge/dist/index.node.js
-var crypto3;
-crypto3 = globalThis.crypto?.webcrypto ?? // Node.js [18-16] REPL
+var crypto4;
+crypto4 = globalThis.crypto?.webcrypto ?? // Node.js [18-16] REPL
 globalThis.crypto ?? // Node.js >18
 import("node:crypto").then((m) => m.webcrypto);
 
@@ -163885,7 +164728,7 @@ var __toESM4 = (mod, isNodeMode, target) => (target = mod != null ? __create4(__
   value: mod,
   enumerable: true
 }) : target, mod));
-var __require2 = /* @__PURE__ */ createRequire(import.meta.url);
+var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
 var getProtectedResourceMetadataUrl = (resource) => {
   let metadataUrl;
   try {
@@ -169672,13 +170515,13 @@ var newRequest = (incoming, defaultHostname) => {
 };
 var responseCache = Symbol("responseCache");
 var getResponseCache = Symbol("getResponseCache");
-var cacheKey = Symbol("cache");
+var cacheKey2 = Symbol("cache");
 var GlobalResponse = global.Response;
 var Response2 = class _Response {
   #body;
   #init;
   [getResponseCache]() {
-    delete this[cacheKey];
+    delete this[cacheKey2];
     return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
   }
   constructor(body, init) {
@@ -169695,14 +170538,14 @@ var Response2 = class _Response {
         headers = new Headers(init.#init.headers);
       }
     } else this.#init = init;
-    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
+    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey2] = [
       init?.status || 200,
       body,
       headers || init?.headers
     ];
   }
   get headers() {
-    const cache = this[cacheKey];
+    const cache = this[cacheKey2];
     if (cache) {
       if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || { "content-type": "text/plain; charset=UTF-8" });
       return cache[2];
@@ -169710,7 +170553,7 @@ var Response2 = class _Response {
     return this[getResponseCache]().headers;
   }
   get status() {
-    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+    return this[cacheKey2]?.[0] ?? this[getResponseCache]().status;
   }
   get ok() {
     const status$1 = this.status;
@@ -169791,7 +170634,7 @@ var buildOutgoingHttpHeaders = (headers) => {
   return res;
 };
 var X_ALREADY_SENT = "x-hono-already-sent";
-if (typeof global.crypto === "undefined") global.crypto = crypto4;
+if (typeof global.crypto === "undefined") global.crypto = crypto5;
 var outgoingEnded = Symbol("outgoingEnded");
 var handleRequestError = () => new Response(null, { status: 400 });
 var handleFetchError = (e) => new Response(null, { status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500 });
@@ -169809,7 +170652,7 @@ var flushHeaders = (outgoing) => {
   if ("flushHeaders" in outgoing && outgoing.writable) outgoing.flushHeaders();
 };
 var responseViaCache = async (res, outgoing) => {
-  let [status$1, body, header] = res[cacheKey];
+  let [status$1, body, header] = res[cacheKey2];
   let hasContentLength = false;
   if (!header) header = { "content-type": "text/plain; charset=UTF-8" };
   else if (header instanceof Headers) {
@@ -169847,7 +170690,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     res = errRes;
   }
   else res = await res.catch(handleFetchError);
-  if (cacheKey in res) return responseViaCache(res, outgoing);
+  if (cacheKey2 in res) return responseViaCache(res, outgoing);
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   if (res.body) {
     const reader = res.body.getReader();
@@ -169935,7 +170778,7 @@ var getRequestListener = (fetchCallback, options = {}) => {
         incoming,
         outgoing
       });
-      if (cacheKey in res) return responseViaCache(res, outgoing);
+      if (cacheKey2 in res) return responseViaCache(res, outgoing);
     } catch (e) {
       if (!res) if (options.errorHandler) {
         res = await options.errorHandler(req ? e : toRequestError(e));
@@ -183522,8 +184365,8 @@ function closeBrowserDaemon(toolState) {
 }
 
 // mcp/checkout.ts
-import { createHash as createHash3 } from "node:crypto";
-import { statSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync11 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { statSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync12 } from "node:fs";
 import { join as join17 } from "node:path";
 
 // node_modules/.pnpm/@ark+schema@0.56.0/node_modules/@ark/schema/out/shared/errors.js
@@ -190852,740 +191695,6 @@ var schema = ark.schema;
 var define2 = ark.define;
 var declare = ark.declare;
 
-// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/cache/adapter.js
-var AdapterError = class extends Error {
-  /** the adapter method that failed */
-  method;
-  /** the full store key, or the op's prefix when the call covered many keys. never the raw input. */
-  key;
-  constructor(method, key, cause) {
-    super(`cache ${method} failed for ${key}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
-    this.name = "AdapterError";
-    this.method = method;
-    this.key = key;
-  }
-};
-
-// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/cache/memory.js
-function memory({ maxItems = 1e3 } = {}) {
-  const store = /* @__PURE__ */ new Map();
-  const peek = (key) => {
-    const slot = store.get(key);
-    if (slot === void 0)
-      return;
-    if (slot.until > Date.now())
-      return slot;
-    store.delete(key);
-  };
-  const evict = () => {
-    for (const [key, slot] of store) {
-      store.delete(key);
-      if (!slot.used)
-        return;
-      slot.used = false;
-      store.set(key, slot);
-    }
-  };
-  return {
-    get: (key) => {
-      const slot = peek(key);
-      if (slot === void 0)
-        return;
-      slot.used = true;
-      return slot.entry;
-    },
-    peek: (key) => peek(key)?.entry,
-    // the TTL rides on each entry, so ops with different lifetimes can share one store
-    // evicted before the new slot goes in, so the entry being written is never the one dropped: after it, a full store
-    // whose every slot was read would pass each over and drop the new, unread one
-    set: (key, entry, ttlMs) => {
-      store.delete(key);
-      if (store.size >= maxItems)
-        evict();
-      store.set(key, { entry, until: Date.now() + ttlMs, used: false });
-    },
-    delete: (keys) => {
-      for (const key of keys)
-        store.delete(key);
-    },
-    // a snapshot, so deleting while iterating is safe
-    list: (prefix) => {
-      const now = Date.now();
-      const listed = [];
-      for (const [key, slot] of store)
-        if (slot.until > now && key.startsWith(prefix))
-          listed.push([key, slot.entry]);
-      return listed;
-    }
-  };
-}
-
-// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/issues.js
-function issueJSON(issue4) {
-  const segments = issue4.path ?? [];
-  const path4 = [];
-  for (let i2 = 0; i2 < segments.length; i2++) {
-    const segment = segments[i2];
-    const wrapped = typeof segment === "object" && segment !== null;
-    const key = wrapped ? segment.key : segment;
-    if (typeof key === "string" || typeof key === "number" && Number.isFinite(key))
-      path4.push(key);
-    else if (typeof key === "symbol")
-      path4.push(String(key));
-    else if (!(wrapped && key === null && segment.type === "set"))
-      break;
-  }
-  const { keyword } = issue4;
-  return typeof keyword === "string" ? { message: issue4.message, path: path4, keyword } : { message: issue4.message, path: path4 };
-}
-function issuesJSON(issues) {
-  const out = [];
-  for (let i2 = 0; i2 < issues.length; i2++)
-    if (issues[i2])
-      out.push(issueJSON(issues[i2]));
-  return out;
-}
-var identifier = /^[A-Za-z_$][\w$]*$/;
-var longestKey = 40;
-function renderPath(path4) {
-  let out = "";
-  for (const key of path4) {
-    if (typeof key === "number")
-      out += `[${key}]`;
-    else if (key.length <= longestKey && identifier.test(key))
-      out += out ? `.${key}` : key;
-    else
-      out += `[${JSON.stringify(key.length <= longestKey ? key : `${key.slice(0, longestKey)}\u2026`)}]`;
-  }
-  return out;
-}
-var shown = 10;
-function summary2(issues, truncated2) {
-  const lines = [];
-  let i2 = 0;
-  for (; i2 < issues.length && lines.length < shown; i2++) {
-    const issue4 = issues[i2];
-    if (!issue4)
-      continue;
-    const { message: message2, path: path4 } = issueJSON(issue4);
-    lines.push(path4.length ? `${renderPath(path4)}: ${message2}` : message2);
-  }
-  let more = 0;
-  for (; i2 < issues.length; i2++)
-    if (issues[i2])
-      more++;
-  if (more > 0)
-    lines.push(truncated2 ? `and over ${more} more` : `and ${more} more`);
-  else if (truncated2)
-    lines.push("and more");
-  return `validation failed: ${lines.join("; ")}`;
-}
-var ValidationError = class extends Error {
-  name = "ValidationError";
-  constructor(result) {
-    super(message(result));
-    Object.defineProperty(this, "result", { value: result });
-    Object.assign(this, { issues: result.issues });
-  }
-  /**
-   * The error as plain data, each issue projected to its message, path and keyword, so what else a validator keeps on
-   * one (Valibot's and Zod's `input`) is left out. The messages are the validator's own, and some quote the value.
-   */
-  toJSON() {
-    const json4 = { name: "ValidationError", message: this.message, issues: issuesJSON(this.issues) };
-    return truncated(this.result) ? { ...json4, truncated: true } : json4;
-  }
-};
-function message(result) {
-  try {
-    return ownSummary(result) ?? summary2(result.issues, truncated(result));
-  } catch {
-    return "validation failed";
-  }
-}
-function ownSummary(result) {
-  const own2 = result;
-  return typeof own2.message === "string" ? own2.message : typeof own2.summary === "string" ? own2.summary : void 0;
-}
-var truncated = (result) => result.truncated === true;
-
-// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/env.js
-var debugging = () => debug2 ??= read();
-var read = () => {
-  try {
-    return globalThis.process?.env?.LOG_LEVEL === "debug";
-  } catch {
-    return false;
-  }
-};
-var debug2;
-
-// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/hash-node.js
-import { createRequire as createRequire2 } from "node:module";
-var sha1 = (text) => {
-  crypto5 ??= load();
-  return crypto5.hash("sha1", text);
-};
-var crypto5;
-var load = () => globalThis.process?.getBuiltinModule?.("node:crypto") ?? createRequire2("/")("node:crypto");
-
-// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/key.js
-function cacheKey2(value2) {
-  if (value2 === null)
-    throw new Error("null cannot be part of a cache key");
-  if (value2 === void 0)
-    return "~void";
-  const json4 = canonical(value2);
-  return json4.length > longKey ? `#${sha1(json4)}` : json4;
-}
-var longKey = 4096;
-function hashKey(key) {
-  if (key === "~void")
-    return key;
-  return key[0] === "#" ? key.slice(1) : sha1(key);
-}
-function canonical(value2) {
-  return serialize(value2, 0);
-}
-function serialize(value2, depth) {
-  switch (typeof value2) {
-    case "number":
-      if (Number.isFinite(value2))
-        return String(value2);
-      throw new Error(`${value2} cannot be part of a cache key`);
-    case "string":
-    case "boolean":
-      return JSON.stringify(value2);
-    case "undefined":
-      throw new Error("undefined cannot be part of a cache key, except as an object property");
-    case "object":
-      break;
-    default:
-      throw new Error(`a ${typeof value2} cannot be part of a cache key`);
-  }
-  if (value2 === null)
-    return "null";
-  if (depth++ === 64)
-    throw new Error("an input nested more than 64 levels deep, or circular");
-  if (Array.isArray(value2)) {
-    let out2 = "[";
-    for (let i2 = 0; i2 < value2.length; i2++)
-      out2 += `${i2 ? "," : ""}${serialize(value2[i2], depth)}`;
-    return `${out2}]`;
-  }
-  const proto = Object.getPrototypeOf(value2);
-  if (proto !== Object.prototype && proto !== null) {
-    const name = proto.constructor?.name || "class instance";
-    throw new Error(`a ${name} cannot be part of a cache key: only JSON data can`);
-  }
-  let out = "";
-  for (const key of Object.keys(value2).sort()) {
-    const v = value2[key];
-    if (v !== void 0)
-      out += `${out ? "," : ""}${JSON.stringify(key)}:${serialize(v, depth)}`;
-  }
-  return `{${out}}`;
-}
-
-// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/plain.js
-var isPlain = (value2) => {
-  if (typeof value2 !== "object" || value2 === null)
-    return false;
-  const proto = Object.getPrototypeOf(value2);
-  return proto === Object.prototype || proto === null;
-};
-
-// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/sleep.js
-function sleep2(ms, signal) {
-  return new Promise((resolve3) => {
-    if (signal?.aborted)
-      return resolve3();
-    const done = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", done);
-      resolve3();
-    };
-    const timer = setTimeout(done, ms);
-    signal?.addEventListener("abort", done, { once: true });
-  });
-}
-
-// node_modules/.pnpm/yes@0.2.7_typescript@5.9.3/node_modules/yes/dist/ops/api.js
-function backoff(schedule, attempt) {
-  const d = schedule[attempt - 1];
-  return d === void 0 ? -1 : Math.round(d / 2 + Math.random() * d / 2);
-}
-async function assertSchema(schema2, value2) {
-  const result = await schema2["~standard"].validate(value2);
-  if (result.issues)
-    throw new ValidationError(result);
-  return result.value;
-}
-var TimeoutError = class extends Error {
-  name = "TimeoutError";
-  /** the op's `timeout`, in ms */
-  timeout;
-  constructor(timeout) {
-    super(`attempt timed out after ${timeout}ms`);
-    this.timeout = timeout;
-  }
-};
-var gates = /* @__PURE__ */ new WeakMap();
-function semaphore(size) {
-  let free = size;
-  const line = [];
-  return {
-    acquire: (signal) => free > 0 ? void free-- : wait(line, signal),
-    release: () => {
-      const next2 = line.shift();
-      if (next2)
-        next2();
-      else
-        free++;
-    }
-  };
-}
-function wait(line, signal, left) {
-  return new Promise((resolve3, reject) => {
-    const abort = () => {
-      line.splice(line.indexOf(next2), 1);
-      left?.();
-      reject(signal.reason);
-    };
-    const next2 = () => {
-      signal?.removeEventListener("abort", abort);
-      resolve3();
-    };
-    signal?.addEventListener("abort", abort, { once: true });
-    line.push(next2);
-  });
-}
-function op(options) {
-  return build3(options, true);
-}
-function build3(options, cacheMethods) {
-  const { name, input: inputSchema, output: outputSchema, run: run4, dedupe, ttl, cache: adapter, timeout } = options;
-  const { retry, concurrency } = options;
-  const delayFor = Array.isArray(retry) ? (_, attempt) => backoff(retry, attempt) : retry;
-  if (ttl !== void 0 && typeof ttl !== "function" && !isLifetime(ttl)) {
-    throw new TypeError(`yes.op: ttl must be a positive number of milliseconds, got ${ttl}`);
-  }
-  if (timeout !== void 0 && !(isLifetime(timeout) && timeout <= maxDelay)) {
-    throw new TypeError(`yes.op: timeout must be a positive number of milliseconds up to ${maxDelay}, got ${timeout}`);
-  }
-  if (concurrency !== void 0 && !(Number.isInteger(concurrency) && concurrency > 0)) {
-    throw new TypeError(`yes.op: concurrency must be a positive integer, got ${concurrency}`);
-  }
-  const lifetime = typeof ttl === "function" ? ttl : (result) => result == null || result instanceof Error ? 0 : ttl;
-  if (adapter && (!name || name.includes(":"))) {
-    throw new TypeError(`yes.op: an op with a cache adapter needs a name without ":", got ${JSON.stringify(name)}`);
-  }
-  if (adapter && ttl === void 0)
-    throw new TypeError(`yes.op: a cache adapter does nothing without a ttl`);
-  const store = ttl === void 0 ? void 0 : adapter ?? memory({ maxItems: options.maxItems });
-  const keepsErrors = !!store && "peek" in store;
-  const prefix = adapter ? `yes:${name}:` : "";
-  const storeKey = adapter ? (key) => prefix + hashedKey(key) : (key) => key.local;
-  const reported = adapter ? void 0 : hashKey;
-  const label = name ? `[${name}] ` : "";
-  const slots = concurrency === void 0 ? void 0 : semaphore(concurrency);
-  const gate = options.rateLimit === void 0 ? void 0 : gates.get(options.rateLimit);
-  if (options.rateLimit !== void 0 && !gate)
-    throw new TypeError(`yes.op: rateLimit takes a yes.rateLimiter`);
-  const take = gate?.take;
-  const admit = slots || take ? async (signal, limitKey) => {
-    await slots?.acquire(signal);
-    try {
-      await take?.(signal, limitKey);
-    } catch (error63) {
-      slots?.release();
-      throw error63;
-    }
-  } : void 0;
-  const keyOf = (input2) => {
-    try {
-      return { local: cacheKey2(input2), hashed: void 0 };
-    } catch (error63) {
-      throw new Error(`${label}${error63.message}. dedupe and ttl key the input, and a query always dedupes; a write is yes.mutation, which never keys.`, { cause: error63 });
-    }
-  };
-  const report = (attempt, message2, error63, key) => {
-    console.log(`${label}attempt ${attempt} ${message2}`);
-    const data = key === void 0 ? { error: error63, attempt } : { key, error: error63, attempt };
-    console.log(...label ? [label, data] : [data]);
-  };
-  const on = options.on ?? {};
-  const onHit = on.hit ?? void 0;
-  const onRun = on.run ?? void 0;
-  const onAttempt = on.attempt ?? void 0;
-  const onRetry = hookOr(on.retry, delayFor && ((event) => report(event.attempt, `failed, retrying in ${event.wait}ms`, event.error, event.key)));
-  const onSuccess = on.success ?? void 0;
-  const onFailure = hookOr(on.failure, delayFor && ((event) => report(event.attempts, "failed, not retrying", event.error, event.key)));
-  const failureLine = on.failure === void 0;
-  const runOnce = (input2, ctx, signal) => {
-    if (timeout === void 0)
-      return run4(input2, ctx);
-    const controller = timeout !== void 0 && ownsSignal(ctx) ? new AbortController() : void 0;
-    const follow = controller && signal && (() => controller.abort(signal.reason));
-    return new Promise((resolve3, reject) => {
-      let settled = false;
-      let pending;
-      const settle2 = (done) => (value2) => {
-        if (settled)
-          return;
-        settled = true;
-        clearTimeout(pending);
-        if (follow)
-          signal.removeEventListener("abort", follow);
-        done(value2);
-      };
-      if (timeout !== void 0) {
-        pending = setTimeout(() => {
-          const error63 = new TimeoutError(timeout);
-          settle2(reject)(error63);
-          controller?.abort(error63);
-        }, timeout);
-      }
-      if (follow) {
-        if (signal.aborted)
-          follow();
-        else
-          signal.addEventListener("abort", follow, { once: true });
-      }
-      try {
-        const own2 = controller ? { ...ctx, signal: controller.signal } : ctx;
-        Promise.resolve(run4(input2, own2)).then(settle2(resolve3), settle2(reject));
-      } catch (error63) {
-        settle2(reject)(error63);
-      }
-    });
-  };
-  const attempts = async (input2, ctx, key, trace, signal, tally) => {
-    const limitKey = gate?.by?.(input2, ctx);
-    const own2 = inject(ctx);
-    for (let attempt = 1; ; attempt++) {
-      signal?.throwIfAborted();
-      if (admit)
-        await admit(signal, limitKey);
-      if (tally)
-        tally.started = attempt;
-      try {
-        let returned;
-        try {
-          if (onAttempt) {
-            const awaited = onAttempt({ name, input: input2, ctx, key: hashedKey(key), attempt });
-            if (isThenable(awaited))
-              await awaited;
-          }
-          returned = await runOnce(input2, own2, signal);
-        } finally {
-          slots?.release();
-        }
-        const result = outputSchema ? await assertSchema(outputSchema, returned) : returned;
-        trace?.(`run resolved on attempt ${attempt}`);
-        return result;
-      } catch (thrown) {
-        let error63 = thrown;
-        let wait2 = -1;
-        let stopped = false;
-        if (gate && !(error63 instanceof ValidationError)) {
-          try {
-            const paused = gate.failed(error63, limitKey);
-            if (paused)
-              trace?.(`rate limit paused for ${paused}ms`);
-          } catch (stop2) {
-            error63 = stop2;
-            stopped = true;
-          }
-        }
-        if (delayFor && !stopped && !(error63 instanceof ValidationError) && !signal?.aborted) {
-          try {
-            wait2 = delayFor(error63, attempt);
-          } catch (stop2) {
-            error63 = stop2;
-          }
-          if (typeof wait2 !== "number") {
-            error63 = new TypeError(`yes.op: a retry waits a number of ms, got ${typeof wait2}`, { cause: error63 });
-            wait2 = -1;
-          } else if (wait2 > maxDelay) {
-            error63 = new RangeError(`yes.op: a retry waits at most ${maxDelay}ms, got ${wait2}`, { cause: error63 });
-            wait2 = -1;
-          }
-        }
-        if (wait2 >= 0 && onRetry) {
-          try {
-            const returned = onRetry({ name, input: input2, ctx, key: hashedKey(key), error: error63, attempt, wait: wait2 });
-            if (isThenable(returned))
-              await returned;
-          } catch (stop2) {
-            error63 = stop2;
-            wait2 = -1;
-          }
-        }
-        if (wait2 >= 0) {
-          await sleep2(wait2, signal);
-          continue;
-        }
-        trace?.(`run failed on attempt ${attempt}`, { error: error63 });
-        throw error63;
-      }
-    }
-  };
-  const execution = onRun || onSuccess || onFailure ? async (input2, ctx, key, trace, signal, write2) => {
-    const tally = { started: 0 };
-    let result;
-    try {
-      if (onRun) {
-        const awaited = onRun({ name, input: input2, ctx, key: hashedKey(key) });
-        if (isThenable(awaited))
-          await awaited;
-      }
-      result = await attempts(input2, ctx, key, trace, signal, tally);
-      if (write2)
-        result = await write2(result);
-    } catch (error63) {
-      if (onFailure && !signal?.aborted && !(failureLine && tally.started <= 1)) {
-        const awaited = onFailure({ name, input: input2, ctx, key: hashedKey(key), error: error63, attempts: tally.started });
-        if (isThenable(awaited))
-          await awaited;
-      }
-      throw error63;
-    }
-    if (onSuccess) {
-      const awaited = onSuccess({ name, input: input2, ctx, key: hashedKey(key), result, attempts: tally.started });
-      if (isThenable(awaited))
-        await awaited;
-    }
-    return result;
-  } : (input2, ctx, key, trace, signal, write2) => {
-    const running = attempts(input2, ctx, key, trace, signal);
-    return write2 ? running.then(write2) : running;
-  };
-  const hit = (input2, ctx, key, trace, from, value2) => {
-    trace?.(`cache hit (${from})`);
-    const awaited = onHit?.({ name, input: input2, ctx, key: hashedKey(key), from });
-    if (!isThenable(awaited))
-      return value2;
-    if (isThenable(value2))
-      value2.then(void 0, () => {
-      });
-    return awaited.then(() => value2);
-  };
-  const inFlight = /* @__PURE__ */ new Map();
-  const writers = /* @__PURE__ */ new Map();
-  let executions = 0;
-  const execute2 = async (rawInput, ctx, refresh) => {
-    const input2 = inputSchema ? await assertSchema(inputSchema, rawInput) : rawInput;
-    const signal = signalOf(ctx);
-    if (!dedupe && !store)
-      return execution(input2, ctx, void 0, debugTrace(label), signal);
-    const key = keyOf(input2);
-    const trace = debugTrace(label, key);
-    const shared = inFlight.get(key.local);
-    if (shared && !refresh) {
-      const [execution2, leader] = shared;
-      return hit(input2, ctx, key, trace, "in-flight", leader ? execution2.catch((error63) => {
-        if (!leader.aborted)
-          throw error63;
-        signal?.throwIfAborted();
-        return execute2(rawInput, ctx, false);
-      }) : execution2);
-    }
-    const fullKey = storeKey(key);
-    const read3 = store && !refresh ? callAdapter("get", fullKey, () => store.get(fullKey), reported) : void 0;
-    const entry = freshEntry(read3);
-    if (entry)
-      return hit(input2, ctx, key, trace, "store", entry.value);
-    const number6 = ++executions;
-    let writer;
-    if (store) {
-      writer = writers.get(key.local);
-      if (!writer) {
-        writer = { running: 0, refreshed: 0 };
-        writers.set(key.local, writer);
-      }
-      writer.running++;
-      if (refresh)
-        writer.refreshed = number6;
-    }
-    const write2 = store && (async (result) => {
-      const ms = lifetime(result);
-      if (!(isLifetime(ms) && writer.refreshed <= number6 && (keepsErrors || !(result instanceof Error)))) {
-        return result;
-      }
-      const created = Date.now();
-      try {
-        await store.set(fullKey, { value: result, created, expires: created + ms, input: input2 }, ms);
-      } catch (error63) {
-        console.error(`${label}cache write failed, returning the result uncached`, new AdapterError("set", reported ? reported(fullKey) : fullKey, error63));
-      }
-      return result;
-    });
-    const promise2 = (async () => {
-      const stored = isThenable(read3) ? freshEntry(await read3) : void 0;
-      if (stored)
-        return hit(input2, ctx, key, trace, "store", stored.value);
-      trace?.(refresh ? "refreshing, running" : "cache miss, running");
-      return execution(input2, ctx, key, trace, signal, write2);
-    })();
-    const settled = writer ? promise2.finally(() => --writer.running || writers.delete(key.local)) : promise2;
-    if (!dedupe)
-      return settled;
-    const flight = [settled, signal];
-    inFlight.set(key.local, flight);
-    return settled.finally(() => inFlight.get(key.local) === flight && inFlight.delete(key.local));
-  };
-  const call = (rawInput, ctx) => execute2(rawInput, ctx, false);
-  const jsonSchema2 = inputSchema?.["~standard"].jsonSchema;
-  if (jsonSchema2) {
-    call["~standard"] = {
-      version: 1,
-      vendor: "yes",
-      name: name ?? "",
-      description: options.description ?? "",
-      jsonSchema: {
-        input: (params) => jsonSchema2.input(params),
-        // what the op returns is what its output schema returns; without one that can say so, any value
-        output: (params) => outputSchema?.["~standard"].jsonSchema?.output(params) ?? {}
-      },
-      ...run4.length < 2 && {
-        execute: (input2, options2) => call(input2, options2?.signal ? { signal: options2.signal } : void 0)
-      }
-    };
-  }
-  if (!cacheMethods)
-    return call;
-  const withKey = (input2, use) => {
-    const toKey = (result2) => use(storeKey(keyOf(result2 && !result2.issues ? result2.value : input2)));
-    const result = inputSchema?.["~standard"].validate(input2);
-    return result instanceof Promise ? result.then(toKey) : toKey(result);
-  };
-  return Object.assign(call, {
-    clear: async (input2) => {
-      if (!store)
-        return;
-      if (input2 === void 0)
-        await sweep(store, prefix, () => true);
-      else
-        await withKey(input2, (key) => callAdapter("delete", key, () => store.delete([key]), reported));
-    },
-    // the memory store peeks, so asking whether a key is cached does not change which key is evicted next
-    has: async (input2) => !!store && !!freshEntry(await withKey(input2, (key) => callAdapter("get", key, () => "peek" in store ? store.peek(key) : store.get(key), reported))),
-    // not `async`: on the memory store a predicate that throws throws here, not in a promise nobody awaits
-    invalidate: (match3) => {
-      const accepts = typeof match3 === "function" ? match3 : fieldsMatch(match3);
-      return Promise.resolve(store ? sweep(store, prefix, accepts) : 0);
-    },
-    refresh: (rawInput, ctx) => execute2(rawInput, ctx, true)
-  });
-}
-function query(options) {
-  return op({ ...options, dedupe: true });
-}
-function mutation({ dedupe: _dedupe, ttl: _ttl, cache: _cache, ...options }) {
-  return build3(options, false);
-}
-var hookOr = (given, line) => given === void 0 ? line || void 0 : given ?? void 0;
-var ownsSignal = (ctx) => {
-  if (ctx === void 0)
-    return true;
-  if (!isPlain(ctx))
-    return false;
-  const signal = ctx.signal;
-  return signal === void 0 || isSignal(signal);
-};
-var inject = (ctx) => {
-  if (ctx === void 0)
-    return { signal: idleSignal() };
-  return isPlain(ctx) && ctx.signal === void 0 ? { ...ctx, signal: idleSignal() } : ctx;
-};
-var idle;
-var idleSignal = () => {
-  if (idle === void 0 && typeof AbortController === "function")
-    idle = new AbortController().signal;
-  return idle;
-};
-var signalOf = (ctx) => {
-  const signal = ctx?.signal;
-  return isSignal(signal) ? signal : void 0;
-};
-var isSignal = (value2) => typeof AbortSignal === "function" && value2 instanceof AbortSignal;
-function debugTrace(label, callKey) {
-  if (!debugging())
-    return;
-  const prefix = `${label}[${(/* @__PURE__ */ new Date()).toISOString()}]`;
-  const start = performance.now();
-  const key = hashedKey(callKey);
-  return (message2, data) => console.log(`${prefix} ${message2} +${Math.round(performance.now() - start)}ms`, { ...key && { key }, ...data });
-}
-function hashedKey(key) {
-  if (key)
-    key.hashed ??= hashKey(key.local);
-  return key?.hashed;
-}
-var maxDelay = 2 ** 31 - 1;
-var isLifetime = (ms) => typeof ms === "number" && ms > 0 && Number.isFinite(ms);
-function fieldsMatch(partial3) {
-  const fields = Object.entries(partial3).map(([field, value2]) => [
-    field,
-    value2 === void 0 ? void 0 : canonical(value2)
-  ]);
-  return (input2) => typeof input2 === "object" && input2 !== null && fields.every(([field, value2]) => {
-    const actual = input2[field];
-    return actual === void 0 ? value2 === void 0 : value2 !== void 0 && canonical(actual) === value2;
-  });
-}
-var isThenable = (value2) => typeof value2?.then === "function";
-function freshEntry(value2) {
-  return typeof value2?.expires === "number" && value2.expires > Date.now() && "value" in value2 ? value2 : void 0;
-}
-function callAdapter(method, key, run4, reported) {
-  try {
-    const result = run4();
-    if (!isThenable(result))
-      return result;
-    return result.then(void 0, (error63) => {
-      throw new AdapterError(method, reported ? reported(key) : key, error63);
-    });
-  } catch (error63) {
-    throw new AdapterError(method, reported ? reported(key) : key, error63);
-  }
-}
-function sweep(store, prefix, match3) {
-  const purge = (listed2) => {
-    const now = Date.now();
-    const keys = [];
-    let count = 0;
-    for (const [key, { input: input2, expires }] of listed2) {
-      if (!(expires > now))
-        keys.push(key);
-      else if (match3(input2)) {
-        keys.push(key);
-        count++;
-      }
-    }
-    const remove = (from) => {
-      if (from >= keys.length)
-        return count;
-      const deleted = callAdapter("delete", prefix, () => store.delete(keys.slice(from, from + 1e3)));
-      return isThenable(deleted) ? Promise.resolve(deleted).then(() => remove(from + 1e3)) : remove(from + 1e3);
-    };
-    return remove(0);
-  };
-  const listed = callAdapter("list", prefix, () => {
-    const listed2 = store.list(prefix);
-    if (Array.isArray(listed2))
-      return listed2;
-    return (async () => {
-      const items = [];
-      for await (const item of await listed2)
-        items.push(item);
-      return items;
-    })();
-  });
-  return Array.isArray(listed) ? purge(listed) : listed.then(purge);
-}
-
 // utils/progressComment.ts
 function parseProgressComment(raw2) {
   if (!raw2?.id) return void 0;
@@ -191730,7 +191839,7 @@ function ensureRepoState(toolState, init) {
 
 // utils/changeImpact.ts
 import { spawn as spawn4 } from "node:child_process";
-import { writeFileSync as writeFileSync8 } from "node:fs";
+import { writeFileSync as writeFileSync9 } from "node:fs";
 import { join as join10 } from "node:path";
 var MAX_CANDIDATES = 24;
 var MAX_ATOM_LENGTH = 128;
@@ -192083,7 +192192,7 @@ async function createChangeImpactArtifact(ctx, params) {
     lookupError: lookup2.error
   });
   const path4 = join10(ctx.tmpdir, `pr-${params.pullNumber}-${params.headSha.slice(0, 7)}-impact.md`);
-  writeFileSync8(path4, artifact.content);
+  writeFileSync9(path4, artifact.content);
   return {
     path: path4,
     candidateCount: candidates.selected.length,
@@ -192352,7 +192461,7 @@ var GENERATED = /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb
 
 // utils/gitAuth.ts
 import { execSync } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { readFileSync as readFileSync6, realpathSync, unlinkSync } from "node:fs";
 import { join as join11 } from "node:path";
 
@@ -192415,7 +192524,7 @@ var TRANSIENT_AUTH_PATTERNS = [
 ];
 var gitBinary;
 function hashFile(path4) {
-  return createHash2("sha256").update(readFileSync6(path4)).digest("hex");
+  return createHash3("sha256").update(readFileSync6(path4)).digest("hex");
 }
 function resolveGit() {
   const whichPath = execSync("which git", { encoding: "utf-8" }).trim();
@@ -192560,7 +192669,7 @@ import { spawnSync as spawnSync8 } from "node:child_process";
 import { spawn as spawn5, spawnSync as spawnSync7 } from "node:child_process";
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { once } from "node:events";
-import { closeSync, existsSync as existsSync10, openSync, writeFileSync as writeFileSync9 } from "node:fs";
+import { closeSync, existsSync as existsSync10, openSync, writeFileSync as writeFileSync10 } from "node:fs";
 import { userInfo as userInfo2 } from "node:os";
 import { join as join12 } from "node:path";
 import { setTimeout as sleep3 } from "node:timers/promises";
@@ -193447,7 +193556,7 @@ ${spawnError}` : spawnError;
 function capOutput(output2) {
   if (output2.length <= MAX_OUTPUT_CHARS) return output2;
   const fullPath = join12(getTempDir(), `shell-${randomUUID4().slice(0, 8)}.log`);
-  writeFileSync9(fullPath, output2);
+  writeFileSync10(fullPath, output2);
   const elided = output2.length - MAX_OUTPUT_CHARS;
   return `... [${elided} chars truncated; output saved to ${fullPath}] ...
 ${output2.slice(-MAX_OUTPUT_CHARS)}`;
@@ -193523,7 +193632,7 @@ Do NOT use this tool for git commands \u2014 use the dedicated git tools instead
           throw new Error(`failed to start background process: ${error63.message}`);
         }
         proc.unref();
-        writeFileSync9(pidPath, `${proc.pid}
+        writeFileSync10(pidPath, `${proc.pid}
 `);
         ctx.toolState.backgroundProcesses.set(handle, { pid: proc.pid, outputPath, pidPath });
         return {
@@ -193695,14 +193804,15 @@ function computeIncrementalDiff(params) {
     const tips = [`origin/${params.baseBranch}`, ...params.formerBaseTips];
     const oldBase = versionBase({ sha: params.beforeSha, tips });
     const newBase = versionBase({ sha: params.headSha, tips });
+    const replayed = oldBase === newBase ? null : replay({ sha: params.beforeSha, from: oldBase, onto: newBase });
     const raw2 = $(
       "sh",
       [
         "-c",
         'git range-diff --no-color --creation-factor=1000 "$1..$(git commit-tree "$2^{tree}" -p "$1" -m x)" "$3..$(git commit-tree "$4^{tree}" -p "$3" -m x)"',
         "--",
-        oldBase,
-        params.beforeSha,
+        replayed ? newBase : oldBase,
+        replayed ?? params.beforeSha,
         newBase,
         params.headSha
       ],
@@ -193737,6 +193847,22 @@ function versionBase(params) {
   }
   return best.sha;
 }
+function replay(params) {
+  try {
+    return git([
+      "merge-tree",
+      "--write-tree",
+      `--merge-base=${params.from}`,
+      params.onto,
+      params.sha
+    ]);
+  } catch {
+    log2.info(
+      `\xBB incremental diff: ${params.sha.slice(0, 7)} does not replay onto the new base; comparing each on its own`
+    );
+    return null;
+  }
+}
 function isDiffPrefix(ch) {
   return ch === " " || ch === "+" || ch === "-";
 }
@@ -193851,7 +193977,7 @@ function postProcessRangeDiff(raw2, contextLines = 3) {
 
 // mcp/git.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { writeFileSync as writeFileSync10 } from "node:fs";
+import { writeFileSync as writeFileSync11 } from "node:fs";
 import { join as join15 } from "node:path";
 
 // utils/apiCommit.ts
@@ -199304,7 +199430,7 @@ function spillGitOutput(params) {
   const tempDir = process.env.PULLFROG_TEMP_DIR;
   if (!tempDir) throw new Error("PULLFROG_TEMP_DIR not set");
   const outputPath = join15(tempDir, `git-${params.command}-${randomUUID5().slice(0, 8)}.txt`);
-  writeFileSync10(outputPath, params.output);
+  writeFileSync11(outputPath, params.output);
   const previewByLines = params.output.split("\n").slice(0, OVERFLOW_PREVIEW_LINES).join("\n");
   const preview = previewByLines.length <= OVERFLOW_PREVIEW_MAX_CHARS ? previewByLines : `${previewByLines.slice(0, OVERFLOW_PREVIEW_MAX_CHARS)}\u2026`;
   log2.info(
@@ -199649,9 +199775,21 @@ function fixDoubleEscapedString(str) {
 }
 
 // utils/isPullfrog.ts
+var BUILT_IN = /* @__PURE__ */ new Set(["pullfrog", "pullfrogdev"]);
+var runBotLogin = "pullfrog";
+function setBotLogin(login) {
+  runBotLogin = normalize3(login);
+}
 function isPullfrog(actor) {
-  actor = actor?.toLowerCase().replace("[bot]", "");
-  return !!actor && (actor === "pullfrog" || actor === "pullfrogdev");
+  if (!actor) return false;
+  const login = normalize3(actor);
+  return login === runBotLogin || BUILT_IN.has(login);
+}
+function mentionHandles() {
+  return [.../* @__PURE__ */ new Set(["@pullfrog", `@${runBotLogin}`])];
+}
+function normalize3(login) {
+  return login.toLowerCase().replace("[bot]", "");
 }
 
 // utils/outstandingThreads.ts
@@ -199671,6 +199809,7 @@ query ($owner: String!, $name: String!, $prNumber: Int!, $cursor: String) {
 }
 `;
 async function countOutstandingPullfrogThreads(ctx, pullNumber) {
+  const isOwn = ctx.isPullfrog ?? isPullfrog;
   let count = 0;
   let cursor3 = null;
   for (let page = 0; page < 50; page += 1) {
@@ -199682,7 +199821,7 @@ async function countOutstandingPullfrogThreads(ctx, pullNumber) {
     for (const thread of conn?.nodes ?? []) {
       if (!thread || thread.isResolved) continue;
       const root = thread.comments?.nodes?.find((c2) => c2 != null);
-      if (root && isPullfrog(root.author?.login)) count += 1;
+      if (root && isOwn(root.author?.login)) count += 1;
     }
     if (!conn?.pageInfo.hasNextPage) break;
     cursor3 = conn.pageInfo.endCursor;
@@ -199723,6 +199862,8 @@ var defaultSettings = {
   codexAgent: false,
   signedCommits: false,
   repoIntelligence: false,
+  botLogin: "pullfrog[bot]",
+  botUserId: "226033991",
   progressComments: true,
   statusChecks: true,
   approvalCheck: false,
@@ -199803,7 +199944,8 @@ async function fetchRunContext(params) {
       secretsUnavailable: data.secretsUnavailable,
       routerUnfunded: data.routerUnfunded,
       trialFallback: data.trialFallback,
-      trialCreditsLeftUsd: data.trialCreditsLeftUsd
+      trialCreditsLeftUsd: data.trialCreditsLeftUsd,
+      modelRegistry: data.modelRegistry
     };
   } catch {
     clearTimeout(timeoutId);
@@ -200996,11 +201138,25 @@ import { execFileSync as execFileSync7, execSync as execSync2 } from "node:child
 import { mkdtempSync as mkdtempSync3, readdirSync, realpathSync as realpathSync2, rmSync as rmSync4, unlinkSync as unlinkSync2 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join16 } from "node:path";
+var TEMP_DIR_STATE = "temp_dir";
 function createTempDirectory() {
   const path4 = mkdtempSync3(join16(tmpdir3(), "pullfrog-"));
   process.env.PULLFROG_TEMP_DIR = path4;
   log2.info(`\xBB created temp dir at ${path4}`);
-  return { path: path4, [Symbol.dispose]: () => removeTempDirectory(path4) };
+  const tracked = process.env.RUNNER_ENVIRONMENT !== "github-hosted";
+  if (tracked) saveSecretState(TEMP_DIR_STATE, path4);
+  return {
+    path: path4,
+    [Symbol.dispose]: () => {
+      if (removeTempDirectory(path4) && tracked) saveSecretState(TEMP_DIR_STATE, "");
+    }
+  };
+}
+function removeAbandonedTempDirectory() {
+  const path4 = getState(TEMP_DIR_STATE);
+  if (!path4) return;
+  log2.info(`\xBB removing temp dir left by an interrupted run at ${path4}`);
+  removeTempDirectory(path4);
 }
 function removeTempDirectory(path4) {
   try {
@@ -201011,10 +201167,12 @@ function removeTempDirectory(path4) {
       rmSync4(path4, { recursive: true, force: true });
     }
     log2.debug(`\xBB removed temp dir at ${path4}`);
+    return true;
   } catch (err) {
     log2.warning(
       `\xBB could not remove temp dir at ${path4}: ${err instanceof Error ? err.message : String(err)}`
     );
+    return false;
   }
 }
 function wipeRunnerLeakSurface() {
@@ -201136,11 +201294,12 @@ async function configureRepoGit(params) {
     }
     const shouldSetDefaults = !currentEmail || currentEmail === "github-actions[bot]@users.noreply.github.com";
     if (shouldSetDefaults) {
-      execSync2('git config --local user.email "226033991+pullfrog[bot]@users.noreply.github.com"', {
+      const email5 = `${params.botUserId}+${params.botLogin}@users.noreply.github.com`;
+      execFileSync7("git", ["config", "--local", "user.email", email5], {
         cwd: repoDir,
         stdio: "pipe"
       });
-      execSync2('git config --local user.name "pullfrog[bot]"', {
+      execFileSync7("git", ["config", "--local", "user.name", params.botLogin], {
         cwd: repoDir,
         stdio: "pipe"
       });
@@ -201257,7 +201416,7 @@ function formatFilesWithLineNumbers(files) {
   }
   const tocLines = [`## Files (${files.length})`];
   for (const entry of tocEntries) {
-    const anchor2 = createHash3("sha256").update(entry.filename).digest("hex");
+    const anchor2 = createHash4("sha256").update(entry.filename).digest("hex");
     const generated = GENERATED.test(entry.filename) ? " \xB7 generated" : "";
     tocLines.push(
       `- ${entry.filename} \u2192 lines ${entry.startLine}-${entry.endLine} \xB7 diff-${anchor2}${generated}`
@@ -201640,6 +201799,8 @@ function CheckoutPrTool(ctx) {
       toolState: ctx.toolState,
       shell: ctx.payload.shell,
       postCheckoutScript: ctx.postCheckoutScript,
+      botLogin: ctx.botLogin,
+      botUserId: ctx.botUserId,
       beforeSha: primary.beforeSha,
       signal
     });
@@ -201670,7 +201831,7 @@ function CheckoutPrTool(ctx) {
           tempDir,
           `pr-${pull_number}-${beforeShort}-${headShort}-incremental.diff`
         );
-        writeFileSync11(incrementalDiffPath, incremental.diff);
+        writeFileSync12(incrementalDiffPath, incremental.diff);
         incrementalDiff = incremental.diff;
         log2.info(
           `\xBB incremental diff computed (${incremental.diff.length} bytes) \u2192 ${incrementalDiffPath}`
@@ -201687,7 +201848,7 @@ function CheckoutPrTool(ctx) {
     log2.debug(`formatted diff preview (first 100 lines):
 ${diffPreview}`);
     const diffPath = join17(tempDir, `pr-${pull_number}-${headShort}.diff`);
-    writeFileSync11(diffPath, formatResult.content);
+    writeFileSync12(diffPath, formatResult.content);
     log2.debug(`wrote diff to ${diffPath} (${formatResult.content.length} bytes)`);
     const coverageEntries = incrementalDiff ? parseIncrementalDiffEntries({ content: incrementalDiff }) : parseDiffTocEntries({ toc: formatResult.toc });
     primary.diffCoverage = incrementalEmpty ? void 0 : createDiffCoverageState({
@@ -201850,7 +202011,7 @@ ${dirty}`
 }
 
 // mcp/checkSuite.ts
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync12 } from "node:fs";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync13 } from "node:fs";
 import { join as join18 } from "node:path";
 var GetCheckSuiteLogs = type({
   check_suite_id: type.number.describe("the id from check_suite.id")
@@ -201948,7 +202109,7 @@ function GetCheckSuiteLogsTool(ctx) {
         throw new Error("PULLFROG_TEMP_DIR not set");
       }
       const logsDir = join18(tempDir, "ci-logs");
-      mkdirSync8(logsDir, { recursive: true });
+      mkdirSync9(logsDir, { recursive: true });
       const jobResults = [];
       for (const run4 of failedRuns) {
         const jobs = await ctx.octokit.paginate(ctx.octokit.rest.actions.listJobsForWorkflowRun, {
@@ -201975,7 +202136,7 @@ function GetCheckSuiteLogsTool(ctx) {
             }
             const logsText = await logsResult.text();
             const logPath = join18(logsDir, `job-${job.id}.log`);
-            writeFileSync12(logPath, logsText);
+            writeFileSync13(logPath, logsText);
             const analysis = analyzeLog(logsText, 80);
             const failedSteps = job.steps?.filter((s) => s.conclusion === "failure").map((s) => `Step ${s.number}: ${s.name}`) ?? [];
             jobResults.push({
@@ -202023,7 +202184,7 @@ function GetCheckSuiteLogsTool(ctx) {
 }
 
 // mcp/commitInfo.ts
-import { writeFileSync as writeFileSync13 } from "node:fs";
+import { writeFileSync as writeFileSync14 } from "node:fs";
 import { join as join19 } from "node:path";
 var CommitInfo = type({
   sha: type.string.describe("the commit SHA (full or abbreviated) to fetch")
@@ -202049,7 +202210,7 @@ function CommitInfoTool(ctx) {
         );
       }
       const diffFile = join19(tempDir, `commit-${sha.slice(0, 7)}.diff`);
-      writeFileSync13(diffFile, formatResult.content);
+      writeFileSync14(diffFile, formatResult.content);
       log2.debug(`wrote commit diff to ${diffFile} (${formatResult.content.length} bytes)`);
       return {
         sha: data.sha,
@@ -202808,7 +202969,7 @@ function AwaitDependencyInstallationTool(ctx) {
 }
 
 // mcp/gh.ts
-import { mkdirSync as mkdirSync9 } from "node:fs";
+import { mkdirSync as mkdirSync10 } from "node:fs";
 import { join as join23 } from "node:path";
 var GH_TIMEOUT_MS = 12e4;
 var GhParams = type({
@@ -202832,7 +202993,7 @@ function GhTool(ctx) {
     parameters: GhParams,
     execute: execute(async (params) => {
       const configDir = join23(ctx.tmpdir, "gh-config");
-      mkdirSync9(configDir, { recursive: true });
+      mkdirSync10(configDir, { recursive: true });
       const command = ["gh", ...params.args.map(shellQuote)].join(" ");
       const result = await runSandboxed({
         command,
@@ -203556,7 +203717,7 @@ function PullRequestInfoTool(ctx) {
 }
 
 // mcp/reviewComments.ts
-import { writeFileSync as writeFileSync14 } from "node:fs";
+import { writeFileSync as writeFileSync15 } from "node:fs";
 import { join as join24 } from "node:path";
 
 // utils/payload.ts
@@ -204244,7 +204405,8 @@ function concurrentThreads(allThreads, threadsForReview, input2) {
 }
 function mentionsPullfrog(body) {
   if (!body) return false;
-  return body.split(/\r?\n/).filter((line) => !line.trim().startsWith(">")).join("\n").toLowerCase().includes("@pullfrog");
+  const text = body.split(/\r?\n/).filter((line) => !line.trim().startsWith(">")).join("\n").toLowerCase();
+  return mentionHandles().some((handle) => text.includes(handle));
 }
 function formatReviewData(input2) {
   const rawReviewBody = input2.review.body;
@@ -204374,7 +204536,7 @@ function GetReviewCommentsTool(ctx) {
       }
       const filename = `review-${params.review_id}-threads.md`;
       const commentsPath = join24(tempDir, filename);
-      writeFileSync14(commentsPath, formatted.content);
+      writeFileSync15(commentsPath, formatted.content);
       log2.debug(`wrote ${threadBlocks.length} threads to ${commentsPath}`);
       return {
         review_id: params.review_id,
@@ -204778,7 +204940,7 @@ function UploadFileTool(ctx) {
 }
 
 // mcp/xrepo.ts
-import { mkdirSync as mkdirSync10, rmSync as rmSync5 } from "node:fs";
+import { mkdirSync as mkdirSync11, rmSync as rmSync5 } from "node:fs";
 import { join as join25 } from "node:path";
 function assertValidRepoName(name) {
   if (!/^[A-Za-z0-9._-]+$/.test(name) || name.startsWith("-") || name.includes("..")) {
@@ -204860,7 +205022,7 @@ function CheckoutRepoTool(ctx) {
       }
       const access2 = accessFor(ctx, repo);
       const dir = join25(ctx.tmpdir, "xrepo", repo);
-      mkdirSync10(dir, { recursive: true });
+      mkdirSync11(dir, { recursive: true });
       const state = ensureRepoState(ctx.toolState, { owner, name: repo, dir, access: access2 });
       const rc = resolveRepoCtx(ctx, repo);
       try {
@@ -204884,7 +205046,9 @@ function CheckoutRepoTool(ctx) {
           octokit: rc.octokit,
           toolState: ctx.toolState,
           shell: ctx.payload.shell,
-          postCheckoutScript: null
+          postCheckoutScript: null,
+          botLogin: ctx.botLogin,
+          botUserId: ctx.botUserId
         });
         log2.info(`\xBB checked out secondary repo ${owner}/${repo} (${access2}) \u2192 ${dir}`);
         return { path: dir, access: access2, defaultBranch };
@@ -206457,7 +206621,7 @@ function activate(input2) {
 
 // utils/gitAuthServer.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { writeFileSync as writeFileSync15 } from "node:fs";
+import { writeFileSync as writeFileSync16 } from "node:fs";
 import { createServer as createServer4 } from "node:http";
 import { join as join26 } from "node:path";
 var REVOKED_TRAP_MS = 6e4;
@@ -206544,7 +206708,7 @@ async function startGitAuthServer(tmpdir5) {
       `r.on("end",function(){process.stdout.write(d+"\\n")})`,
       `}).on("error",function(){process.exit(1)})}`
     ].join("\n");
-    writeFileSync15(scriptPath, content, { mode: 448 });
+    writeFileSync16(scriptPath, content, { mode: 448 });
     return scriptPath;
   }
   async function close() {
@@ -207788,6 +207952,22 @@ ${collapsible}` : output2;
 }
 
 // utils/runContextData.ts
+function installServedRegistry(served) {
+  const pins = getHarnessPins();
+  const moved = Object.keys(pins).filter((name) => served.harnessPins[name] !== pins[name]);
+  if (moved.length > 0) {
+    const theirs = moved.map((name) => `${name}@${served.harnessPins[name]}`).join(", ");
+    log2.info(`\xBB kept the bundled model registry: the server's is written for ${theirs}`);
+    return;
+  }
+  try {
+    installProviders(served.providers);
+  } catch (error63) {
+    log2.warning(
+      `\xBB kept the bundled model registry: the server's ${error63 instanceof Error ? error63.message : error63}`
+    );
+  }
+}
 async function resolveRunContextData(params) {
   const actionRef = process.env.GITHUB_ACTION_REF;
   log2.info(
@@ -207819,6 +207999,7 @@ async function resolveRunContextData(params) {
     })
   ]);
   if (runContext.apiToken) maskSecret(runContext.apiToken);
+  if (runContext.modelRegistry) installServedRegistry(runContext.modelRegistry);
   return {
     repo: {
       owner: repoContext.owner,
@@ -208039,6 +208220,19 @@ function formatProviderModelNotFound(ctx) {
   const model = /Model not found: (\S+?)\.?(?:\s|$)/.exec(ctx.errorMessage)?.[1];
   const suggestions = /Did you mean: ([^?\n]+)\?/.exec(ctx.errorMessage)?.[1]?.split(",").map((id) => `\`${id.trim()}\``);
   const suggested = suggestions?.length ? ` OpenCode suggests ${suggestions.slice(0, -1).join(", ")}${suggestions.length > 1 ? " or " : ""}${suggestions.at(-1)}.` : "";
+  if (ctx.modelsCatalogFailure) {
+    return renderFailure({
+      headline: model ? `OpenCode couldn't download its model list, so it didn't recognize \`${model}\`.` : "OpenCode couldn't download its model list, so it didn't recognize this repo's model.",
+      detail: `It fell back to the copy built into it, which lacks models released since that build. Re-run once the runner can reach OpenCode's model catalog, or pick an older model.${suggested}`,
+      details: {
+        summary: "Why the download failed",
+        text: `${ctx.modelsCatalogFailure}
+
+${ctx.errorMessage}`
+      },
+      links: [pickModelLink(ctx.repo)]
+    });
+  }
   return renderFailure({
     headline: model ? `\`${model}\` isn't in OpenCode's catalog.` : "This repo's model isn't in OpenCode's catalog.",
     detail: `Pick another model wherever this repo sets it: the Pullfrog console, the workflow's \`model\` input or the \`PULLFROG_MODEL\` variable.${suggested}`,
@@ -208920,6 +209114,7 @@ async function main() {
       routedTier: typeof resolvedPromptInput === "string" ? void 0 : resolvedPromptInput.routing?.tier
     });
     timer.checkpoint("runContextData");
+    setBotLogin(runContext.repoSettings.botLogin);
     const payload = resolvePayload(resolvedPromptInput, runContext.repoSettings);
     const toolState = initToolState({
       progressComment: typeof resolvedPromptInput !== "string" ? resolvedPromptInput.progressComment : void 0,
@@ -208971,6 +209166,7 @@ async function main() {
     const repoDir = payload.cwd;
     const preIntrospectionDirty = repoDir ? await dirtyTrackedPaths({ cwd: repoDir }) : null;
     const opencodeCliPath = await agents.opencode.install();
+    await seedModelsCatalog(tmpdir5);
     captureBaselineModels({ cliPath: opencodeCliPath, tmpdir: tmpdir5 });
     const injected = [];
     if (runContext.dbSecrets) {
@@ -209166,7 +209362,9 @@ async function main() {
           octokit,
           toolState,
           shell: payload.shell,
-          postCheckoutScript: runContext.repoSettings.postCheckoutScript
+          postCheckoutScript: runContext.repoSettings.postCheckoutScript,
+          botLogin: runContext.repoSettings.botLogin,
+          botUserId: runContext.repoSettings.botUserId
         });
         timer.checkpoint("git");
         const pmSpec = await resolvePackageManagerSpec(process.cwd());
@@ -209193,7 +209391,11 @@ async function main() {
         timer.checkpoint("lifecycleHooks::setup");
         const agentId = agent2.name;
         const modes2 = [
-          ...computeModes(agentId, runContext.repoSettings.signedCommits),
+          ...computeModes({
+            agentId,
+            signedCommits: runContext.repoSettings.signedCommits,
+            botLogin: runContext.repoSettings.botLogin
+          }),
           ...runContext.repoSettings.modes
         ];
         const outputSchema = resolveOutputSchema();
@@ -209219,6 +209421,8 @@ async function main() {
           apiToken: runContext.apiToken,
           modes: modes2,
           postCheckoutScript: runContext.repoSettings.postCheckoutScript,
+          botLogin: runContext.repoSettings.botLogin,
+          botUserId: runContext.repoSettings.botUserId,
           prepushScript: runContext.repoSettings.prepushScript,
           prApproveEnabled: runContext.repoSettings.prApproveEnabled,
           reviewDrafts: runContext.repoSettings.reviewDrafts,
@@ -209484,7 +209688,8 @@ ${instructions.user}` : null,
         routerActive: !!payload.proxyModel,
         model: toolState.model,
         credential: toolState.credential,
-        trial: toolState.modelClamped?.reason === "trial"
+        trial: toolState.modelClamped?.reason === "trial",
+        modelsCatalogFailure: getModelsCatalogFailure()
       });
       await writeRunErrorOutputs({ rendered, toolState });
       if (toolContext) {
@@ -209665,6 +209870,7 @@ async function runCli5(params) {
 async function run(args2) {
   if (args2.includes("--post") && !args2.includes("token")) {
     await runOAuthWriteback().catch((error63) => warning(`oauth post-hook: ${error63}`));
+    removeAbandonedTempDirectory();
     return;
   }
   try {
@@ -209943,7 +210149,7 @@ async function run2() {
 }
 
 // commands/_prEvents.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync16 } from "node:fs";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync17 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join30 } from "node:path";
 var REQUEST_TIMEOUT_MS = 35e3;
@@ -210011,8 +210217,8 @@ function readCursor(target) {
 function writeCursor(target, cursor3) {
   try {
     const path4 = cursorPath(target);
-    mkdirSync11(join30(stateDir(), "watch"), { recursive: true });
-    writeFileSync16(path4, cursor3, "utf-8");
+    mkdirSync12(join30(stateDir(), "watch"), { recursive: true });
+    writeFileSync17(path4, cursor3, "utf-8");
   } catch {
   }
 }
@@ -210066,7 +210272,7 @@ function resolveTarget2(repo) {
   return { owner: match3[1], repo: match3[2] };
 }
 function cliVersion() {
-  const parts = /^(\d+)\.(\d+)\.(\d+)$/.exec("0.1.105");
+  const parts = /^(\d+)\.(\d+)\.(\d+)$/.exec("0.1.107");
   if (!parts) return "0.0.0";
   return `${Number(parts[1])}.${Number(parts[2])}.${Number(parts[3])}`;
 }
@@ -210263,7 +210469,7 @@ async function runCli9(input2) {
 }
 
 // cli.ts
-var VERSION10 = "0.1.105";
+var VERSION10 = "0.1.107";
 var bin = basename2(process.argv[1] || "");
 var PROG = bin === "pf" || bin === "pullfrog" ? bin : "pullfrog";
 var rawArgs = process.argv.slice(2);