pullfrog 0.1.75 → 0.1.77

package/dist/internal.js

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 // package.json
 var package_default = {
   name: "pullfrog",
-  version: "0.1.75",
+  version: "0.1.77",
   cliContractVersion: "1",
   type: "module",
   bin: {
@@ -628,7 +628,7 @@ __export(core_exports2, {
   parse: () => parse,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
-  process: () => process,
+  process: () => process2,
   regexes: () => regexes_exports,
   registry: () => registry,
   safeDecode: () => safeDecode,
@@ -11029,7 +11029,7 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a2;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
@@ -11066,7 +11066,7 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process(parent, ctx, params);
+      process2(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -11347,14 +11347,14 @@ function isTransforming(_schema, _ctx) {
 }
 var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
 var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
@@ -11611,7 +11611,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
   if (typeof maximum === "number")
     json2.maxItems = maximum;
   json2.type = "array";
-  json2.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
+  json2.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
 };
 var objectProcessor = (schema, ctx, _json, params) => {
   const json2 = _json;
@@ -11620,7 +11620,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json2.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json2.properties[key] = process(shape[key], ctx, {
+    json2.properties[key] = process2(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -11643,7 +11643,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
     if (ctx.io === "output")
       json2.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = process(def.catchall, ctx, {
+    json2.additionalProperties = process2(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -11652,7 +11652,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
-  const options = def.options.map((x, i) => process(x, ctx, {
+  const options = def.options.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
@@ -11664,11 +11664,11 @@ var unionProcessor = (schema, ctx, json2, params) => {
 };
 var intersectionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  const a = process(def.left, ctx, {
+  const a = process2(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
   });
-  const b = process(def.right, ctx, {
+  const b = process2(def.right, ctx, {
     ...params,
     path: [...params.path, "allOf", 1]
   });
@@ -11685,11 +11685,11 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   json2.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-  const prefixItems = def.items.map((x, i) => process(x, ctx, {
+  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, prefixPath, i]
   }));
-  const rest = def.rest ? process(def.rest, ctx, {
+  const rest = def.rest ? process2(def.rest, ctx, {
     ...params,
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
@@ -11729,7 +11729,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
-    const valueSchema = process(def.valueType, ctx, {
+    const valueSchema = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
@@ -11739,12 +11739,12 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = process(def.keyType, ctx, {
+      json2.propertyNames = process2(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json2.additionalProperties = process(def.valueType, ctx, {
+    json2.additionalProperties = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -11759,7 +11759,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 };
 var nullableProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  const inner = process(def.innerType, ctx, params);
+  const inner = process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -11770,20 +11770,20 @@ var nullableProcessor = (schema, ctx, json2, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json2.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
@@ -11791,7 +11791,7 @@ var prefaultProcessor = (schema, ctx, json2, params) => {
 };
 var catchProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   let catchValue;
@@ -11805,32 +11805,32 @@ var catchProcessor = (schema, ctx, json2, params) => {
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json2.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var lazyProcessor = (schema, ctx, _json, params) => {
   const innerType = schema._zod.innerType;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
@@ -11882,7 +11882,7 @@ function toJSONSchema(input, params) {
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
       const [_, schema] = entry;
-      process(schema, ctx2);
+      process2(schema, ctx2);
     }
     const schemas = {};
     const external = {
@@ -11905,7 +11905,7 @@ function toJSONSchema(input, params) {
     return { schemas };
   }
   const ctx = initializeContext({ ...params, processors: allProcessors });
-  process(input, ctx);
+  process2(input, ctx);
   extractDefs(ctx, input);
   return finalize(ctx, input);
 }
@@ -11963,7 +11963,7 @@ var JSONSchemaGenerator = class {
    * This must be called before emit().
    */
   process(schema, _params = { path: [], schemaPath: [] }) {
-    return process(schema, this.ctx, _params);
+    return process2(schema, this.ctx, _params);
   }
   /**
    * Emit the final JSON Schema after processing.
@@ -14023,6 +14023,20 @@ var repoConfigFields = [
     nullable: true,
     description: "additional instructions for planning"
   },
+  {
+    key: "prompts.address-reviews",
+    field: "AddressReviews",
+    kind: "prompt",
+    nullable: true,
+    description: "additional instructions for addressing review feedback"
+  },
+  {
+    key: "prompts.fix-ci",
+    field: "Fix",
+    kind: "prompt",
+    nullable: true,
+    description: "additional instructions for fixing CI failures"
+  },
   { key: "mention.enabled", field: "mention", kind: "toggle", description: "respond to mentions" },
   {
     key: "mention.instructions",
@@ -15461,6 +15475,97 @@ function resolveAutoTier(params) {
   if (!params.hasCard) return AUTO_EFFICIENT;
   return isAutoTier(params.model) ? params.model : defaultAutoTier(params.hasCard);
 }
+var ROUTER_TIERS = ["minimal", "light", "standard", "deep"];
+function isRouterTier(value) {
+  return typeof value === "string" && ROUTER_TIERS.some((tier) => tier === value);
+}
+var PROVIDER_LADDERS = {
+  anthropic: {
+    minimal: "anthropic/claude-haiku",
+    light: "anthropic/claude-sonnet",
+    standard: "anthropic/claude-opus",
+    deep: "anthropic/claude-opus"
+  },
+  openai: {
+    minimal: "openai/gpt-luna",
+    light: "openai/gpt-terra",
+    standard: "openai/gpt-sol",
+    deep: "openai/gpt-astra"
+  },
+  google: {
+    minimal: "google/gemini-flash",
+    light: "google/gemini-flash",
+    standard: "google/gemini-pro",
+    deep: "google/gemini-pro"
+  },
+  deepseek: {
+    minimal: "deepseek/deepseek-flash",
+    light: "deepseek/deepseek-flash",
+    standard: "deepseek/deepseek-pro",
+    deep: "deepseek/deepseek-pro"
+  },
+  xai: {
+    minimal: "xai/grok-fast",
+    light: "xai/grok-fast",
+    standard: "xai/grok",
+    deep: "xai/grok"
+  },
+  moonshotai: {
+    minimal: "moonshotai/kimi-k2",
+    light: "moonshotai/kimi-k2",
+    standard: "moonshotai/kimi-k3",
+    deep: "moonshotai/kimi-k3"
+  },
+  openrouter: {
+    minimal: "openrouter/deepseek-flash",
+    light: "openrouter/gpt-luna",
+    standard: "openrouter/gpt-sol",
+    deep: "openrouter/claude-opus"
+  },
+  opencode: {
+    minimal: "opencode/gpt-luna",
+    light: "opencode/gpt-luna",
+    standard: "opencode/gpt-sol",
+    deep: "opencode/claude-opus"
+  }
+};
+var ROUTER_LADDER = {
+  minimal: "deepseek/deepseek-flash",
+  light: "openai/gpt-luna",
+  standard: "openai/gpt-sol",
+  deep: "anthropic/claude-opus"
+};
+var AUTO_ROUTER = "auto/router";
+var AUTO_PREFIX = "auto/";
+function autoLadder(slug) {
+  if (!slug || !slug.startsWith(AUTO_PREFIX) || isAutoTier(slug)) return void 0;
+  const target = slug.slice(AUTO_PREFIX.length);
+  return target === "router" ? ROUTER_LADDER : PROVIDER_LADDERS[target];
+}
+function isAutoRouted(slug) {
+  return autoLadder(slug) !== void 0;
+}
+function isAutoSlug(slug) {
+  return isAutoTier(slug) || isAutoRouted(slug);
+}
+function autoRoutedSlug(provider2) {
+  return `${AUTO_PREFIX}${provider2}`;
+}
+var ROUTED_PROVIDERS = Object.keys(
+  PROVIDER_LADDERS
+).map((key) => ({ key, displayName: providers[key].displayName }));
+function ladderRungs(ladder) {
+  const rungs = [];
+  for (const tier of ROUTER_TIERS) {
+    const last = rungs[rungs.length - 1];
+    if (last?.slug === ladder[tier]) last.tiers.push(tier);
+    else rungs.push({ slug: ladder[tier], tiers: [tier] });
+  }
+  return rungs;
+}
+function resolveRoutedModel(params) {
+  return autoLadder(params.configured)?.[params.tier];
+}
 function isCardGatedModel(slug) {
   return resolveOpenRouterModel(slug) !== void 0;
 }
@@ -15469,7 +15574,7 @@ function resolveModelSlug(slug) {
 }
 var MAX_FALLBACK_DEPTH = 10;
 function resolveDisplayAlias(slug) {
-  let current = isAutoTier(slug) ? AUTO_TIER_TARGET[slug] : slug;
+  let current = isAutoTier(slug) ? AUTO_TIER_TARGET[slug] : autoLadder(slug)?.standard ?? slug;
   const visited = /* @__PURE__ */ new Set();
   for (let i = 0; i < MAX_FALLBACK_DEPTH; i++) {
     if (visited.has(current)) return void 0;
@@ -15504,6 +15609,11 @@ if (!defaultProxyAlias?.openRouterResolve) {
 }
 var DEFAULT_PROXY_MODEL = defaultProxyAlias.openRouterResolve;
 var defaultProxyDisplayName = defaultProxyAlias.displayName;
+for (const [name, ladder] of Object.entries({ ...PROVIDER_LADDERS, router: ROUTER_LADDER })) {
+  for (const slug of Object.values(ladder)) {
+    if (!resolveDisplayAlias(slug)) throw new Error(`${name} ladder names unknown alias ${slug}`);
+  }
+}
 var OSS_MODEL_ALLOWLIST = [
   "deepseek/deepseek-flash",
   "deepseek/deepseek-pro",
@@ -15529,6 +15639,10 @@ function isOssAllowedModel(slug) {
 function getAutoSelectHintModel() {
   return defaultProxyDisplayName;
 }
+var PROVIDER_GATEWAY_URL_ENV = {
+  anthropic: "ANTHROPIC_BASE_URL",
+  openai: "OPENAI_BASE_URL"
+};
 
 // external.ts
 var pullfrogMcpName = "pullfrog";
@@ -15661,26 +15775,24 @@ For simple, well-defined tasks, skip the plan phase and go straight to build.`
 
 2. Checkout the PR branch via \`${t("checkout_pr")}\`.
 
-3. Fetch review comments via \`${t("get_review_comments")}\`.
+3. Fetch review comments via \`${t("get_review_comments")}\` and read the full conversation in each relevant thread.
 
-4. For each comment:
-   - understand the feedback
+4. For each thread:
+   - **check intent first**: questions, explanations, and disagreement call for a reply, not a code change. Change code only when explicitly requested. Automatic review feedback on Pullfrog-authored PRs (\`address_scope: all\`) remains actionable without a separate request; later replies can narrow or withdraw that permission.
+   - under \`address_scope: mentions\`, unmentioned threads are context only unless the user's review-body request explicitly includes them
    - **verify the finding yourself** against the actual code before deciding whether to apply \u2014 every comment (human or agent) is a hypothesis, not a directive. agent reviewers especially are fallible.
-   - you are searching for a solution that is **complete, minimal, and elegant** \u2014 you may need to think hard to find it. do not over-engineer, do not be over-defensive, **do not write AI slop**. reviewers bias toward *recommending additions*, and that bias has a recognizable slop texture: defensive checks for impossible cases, extra abstractions used once, comments restating obvious code, tests asserting tautologies, "just-in-case" guards, error handlers for cases the type system already rules out. reject those. evaluate whether applying the finding would leave the code more **sound, correct, AND elegant**; two-out-of-three is a signal to look harder for a fix that gets all three. if a request would add bloat \u2014 ceremony without commensurate correctness benefit \u2014 push back in your reply rather than mechanically applying it.
-   - if the request stands, make the code change using your native tools; otherwise reply explaining why
+   - keep requested changes **sound, minimal, and elegant**. Reject defensive checks for impossible cases, single-use abstractions, redundant comments, and tautological tests rather than mechanically applying reviewer suggestions.
+   - if intent permits a code change and the finding stands, implement it using your native tools; otherwise reply without editing
    - record what was done (or why nothing was done)
 
 5. Quality check:
-   - re-call \`${t("get_review_comments")}\` with \`fresh: true\` before committing: reviewers keep commenting while you work, and any thread it now returns that you have not addressed is in scope for this run.
-   - test changes, then review the diff before committing \u2014 verify only intended changes are present, no debug artifacts remain, no fix turned out to be bloat in context (revert any that did), and the changes are clean enough that a senior engineer would approve without hesitation
-   - ${commitStep}
+   - re-call \`${t("get_review_comments")}\` with \`fresh: true\` before finishing, even when only replying. Apply the same scope and intent checks to new comments; respect requests to stop or change direction before committing.
+   - if code changed, test and review the diff, remove unintended changes or bloat, then ${commitStep}
 
-6. Finalize. Reply + resolve are paired write actions: do BOTH or NEITHER for each thread.
-   - ${finalizeStep} (same push/prepush guidance as Build mode in *SYSTEM*)
-   - **if the push/commit fails**, call \`${t("report_progress")}\` with the exact error and STOP \u2014 do NOT reply or resolve any thread until the fix is live on the remote. Resolving a thread without the fix landing misleads the reviewer.
-   - **once the fix is live on the remote**, for each thread you acted on:
-     - reply ONCE via \`${t("reply_to_review_comment")}\`. The \`comment_id\` parameter takes the root comment's numeric \`id=\` (from the first \`comment author=...\` tag in the \`${t("get_review_comments")}\` output) \u2014 NOT the \`thread=\` value; that's a separate GraphQL ID used by resolve. The runtime dedupes identical bodies within a session.
-     - **immediately** call \`${t("resolve_review_thread")}\` with that thread's \`thread=\` value as \`thread_id\`. Resolve every thread where you (a) made the requested code change in full \u2014 partial fixes leave the thread open \u2014 OR (b) replied with a substantive answer the user explicitly asked for. Do NOT resolve threads where you pushed back on the request and the disagreement is unresolved; leave those open for the human to mediate.
+6. Finalize:
+   - **only if code changed**, ${finalizeStep} (same push/prepush guidance as Build mode in *SYSTEM*). If push/commit fails, report the exact error and STOP without claiming a fix or resolving its threads.
+   - reply ONCE per relevant thread via \`${t("reply_to_review_comment")}\`, including when no code changed. The \`comment_id\` is the root comment's numeric \`id=\`, NOT the \`thread=\` value from \`${t("get_review_comments")}\`. The runtime dedupes identical bodies within a session.
+   - resolve a thread via \`${t("resolve_review_thread")}\` (using \`thread=\` as \`thread_id\`) only after its requested fix is fully on the remote, or the user explicitly asks to resolve it. Leave discussion-only replies, partial fixes, and disagreements open.
    - call \`${t("report_progress")}\` with a brief summary. If your last \`${t("get_review_comments")}\` turned up threads you did not address, name them there \u2014 a review arriving this late is suppressed as a duplicate and nothing else will pick it up.`
     },
     // Review and IncrementalReview route the minimum reviewfrog specialists
@@ -16583,6 +16695,7 @@ export {
   APPROVAL_CHECK_NAME,
   AUTO_EFFICIENT,
   AUTO_INTELLIGENT,
+  AUTO_ROUTER,
   CLI_CONTRACT_HEADER,
   CLI_CONTRACT_VERSION,
   CLI_UPGRADE_MESSAGE,
@@ -16594,10 +16707,16 @@ export {
   OAuthInvalidGrantError,
   OSS_MODEL_ALLOWLIST,
   OSS_RECOMMENDED_MODEL,
+  PROVIDER_GATEWAY_URL_ENV,
   PULLFROG_DIVIDER,
+  ROUTED_PROVIDERS,
+  ROUTER_LADDER,
+  ROUTER_TIERS,
   RUN_STATUS_CHECK_NAME,
   SUBSIDY_RUNG,
   TIMEOUT_DISABLED,
+  autoLadder,
+  autoRoutedSlug,
   buildPullfrogFooter,
   commercialPaywallBody,
   configEntrySchema,
@@ -16617,6 +16736,8 @@ export {
   getModelProvider,
   getProgressComment,
   getProviderDisplayName,
+  isAutoRouted,
+  isAutoSlug,
   isAutoTier,
   isCardGatedModel,
   isCredentialProbeable,
@@ -16624,7 +16745,9 @@ export {
   isLeapingIntoActionCommentBody,
   isOssAllowedModel,
   isPullfrog,
+  isRouterTier,
   isValidTimeString,
+  ladderRungs,
   modelAliases,
   modelHasStoredAuth,
   modes,
@@ -16645,6 +16768,7 @@ export {
   resolveModelRung,
   resolveModelSlug,
   resolveOpenRouterModel,
+  resolveRoutedModel,
   resolveRung,
   runStatusCheckNeedsFinalizing,
   rungLabel,

package/dist/models.d.ts

@@ -218,6 +218,58 @@ export declare function resolveAutoTier(params: {
     model: string | null;
     hasCard: boolean;
 }): AutoTier;
+/**
+ * the four rungs the model router scores a review into, ascending. `minimal` is
+ * a PR with no behavioural surface, `deep` one whose defects are absences the
+ * diff does not show. see wiki/router.md for how a tier is earned.
+ */
+export declare const ROUTER_TIERS: readonly ["minimal", "light", "standard", "deep"];
+export type RouterTier = (typeof ROUTER_TIERS)[number];
+export declare function isRouterTier(value: unknown): value is RouterTier;
+type Ladder = Record<RouterTier, string>;
+/**
+ * the Router's own ladder for an account on `auto/router` with a card on
+ * file. an account without a card is never routed onto this:
+ * `resolveAutoTier` clamps it to the efficient default at every tier, exactly
+ * as before the router existed.
+ */
+export declare const ROUTER_LADDER: Ladder;
+/**
+ * the `repo.model` sentinel that turns the router on: `auto/<provider>` runs
+ * each piece of work on that provider's ladder, `auto/router` on the Pullfrog
+ * Router's. distinct from the two managed tiers above, which each name ONE
+ * model. a Pro feature — outside Pro the sentinel simply runs its ladder's
+ * `standard` rung, which is what `resolveDisplayAlias` resolves it to.
+ */
+export declare const AUTO_ROUTER = "auto/router";
+/** the ladder an Auto sentinel routes on; undefined for a tier or a pin */
+export declare function autoLadder(slug: string | null | undefined): Ladder | undefined;
+export declare function isAutoRouted(slug: string | null | undefined): boolean;
+/** any `auto/*` sentinel — a managed tier or the router — as opposed to a concrete pin */
+export declare function isAutoSlug(slug: string | null | undefined): boolean;
+export declare function autoRoutedSlug(provider: string): string;
+/** the providers a BYOK repo can put on Auto — exactly the ones with a ladder */
+export declare const ROUTED_PROVIDERS: readonly {
+    key: string;
+    displayName: string;
+}[];
+/**
+ * a ladder's distinct models in ascending order, each with the tiers it
+ * serves — the console's "what Auto runs on" list, where a model that covers
+ * two tiers is one row.
+ */
+export declare function ladderRungs(ladder: Ladder): {
+    slug: string;
+    tiers: RouterTier[];
+}[];
+/**
+ * the model a routed run takes: the tier's rung on the ladder the configured
+ * Auto sentinel names. undefined for a pin — a pin opts out of routing.
+ */
+export declare function resolveRoutedModel(params: {
+    configured: string | null | undefined;
+    tier: RouterTier;
+}): string | undefined;
 /**
  * Router-resolvable — the set a card on file unlocks. custom (non-Auto) picks
  * are card-gated wholesale on the Router: the console locks the Custom tab
@@ -376,6 +428,27 @@ export declare const OPENAI_COMPATIBLE_CONTEXT_ENV = "OPENAI_COMPATIBLE_CONTEXT"
  * `context` + `output` together, so the pair is validated and emitted as a unit.
  */
 export declare const OPENAI_COMPATIBLE_MAX_OUTPUT_ENV = "OPENAI_COMPATIBLE_MAX_OUTPUT";
+/**
+ * Providers whose endpoint can be re-pointed at a customer gateway, and the env
+ * var that does it. Deliberately a short explicit map rather than a derived
+ * `<PROVIDER>_BASE_URL` rule: only a provider we have confirmed reachable
+ * through a proxy belongs here, and three of them must never be.
+ * `openai-compatible` already owns its endpoint via OPENAI_COMPATIBLE_BASE_URL,
+ * `azure` derives one from AZURE_RESOURCE_NAME, and bedrock/vertex authenticate
+ * against a cloud SDK rather than a URL.
+ *
+ * models.dev declares no base-URL env var for any catalogued provider (2 of 213
+ * do, and neither is one of these), so nothing reads these names on its own —
+ * `providerGatewayOverride` is what makes them mean anything to opencode and
+ * `gatewayProvider` to codex, while claude-code reads ANTHROPIC_BASE_URL itself.
+ *
+ * Adding a provider that ALREADY has a block in `buildSecurityConfig` needs a
+ * merge, not an entry here: that spread replaces the whole key, so listing
+ * `openrouter` would silently drop `kimiOpenRouterProviderOverrides()`.
+ */
+export declare const PROVIDER_GATEWAY_URL_ENV: Record<string, string>;
+/** the customer gateway a model's provider is re-pointed at, if any. */
+export declare function getProviderGatewayUrl(specifier: string | undefined): string | undefined;
 /**
  * the Bedrock model ID passed to claude-code or opencode is whatever the
  * user set in `BEDROCK_MODEL_ID` — Pullfrog never resolves or upgrades it.

package/dist/utils/payload.d.ts

@@ -7,6 +7,13 @@ export declare const JsonPayload: import("arktype/internal/variants/object.ts").
     type?: string | undefined;
     model?: string | undefined;
     modelExplicit?: boolean | undefined;
+    routing?: {
+        tier: "minimal" | "light" | "standard" | "deep";
+        stakes: number;
+        workload: number;
+        source: "scorer" | "heuristic" | "fixed";
+        rationale: string;
+    } | undefined;
     effort?: string | number | undefined;
     debug?: boolean | undefined;
     triggerer?: string | undefined;
@@ -54,6 +61,13 @@ export declare function resolvePayload(resolvedPromptInput: ResolvedPromptInput,
     version: string;
     model: string | undefined;
     modelExplicit: boolean;
+    routing: {
+        tier: "minimal" | "light" | "standard" | "deep";
+        stakes: number;
+        workload: number;
+        source: "scorer" | "heuristic" | "fixed";
+        rationale: string;
+    } | undefined;
     effort: number | undefined;
     debug: true | undefined;
     prompt: string;

package/dist/utils/runContext.d.ts

@@ -1,4 +1,5 @@
 import type { PushPermission, ShellPermission } from "../external.ts";
+import type { RouterTier } from "../models.ts";
 import type { RepoContext } from "./github.ts";
 export interface Mode {
     id: string;
@@ -104,4 +105,7 @@ export declare function fetchRunContext(params: {
     /** `payload.type` — lets the server apply this repo's per-trigger model
      * override, which it cannot derive from owner/repo alone. */
     runType?: string | undefined;
+    /** `payload.routing.tier` — the model router's tier, which run-context
+     * applies to the Router proxy mint the same way it applies `runType`. */
+    routedTier?: RouterTier | undefined;
 }): Promise<RunContext>;

package/dist/utils/runContextData.d.ts

@@ -1,4 +1,5 @@
 import type { Octokit } from "@octokit/rest";
+import type { RouterTier } from "../models.ts";
 import { type OctokitWithPlugins } from "./github.ts";
 import { type AccountPlan, type CommercialRefusal, type RepoSettings } from "./runContext.ts";
 export interface RunContextData {
@@ -33,6 +34,8 @@ interface ResolveRunContextDataParams {
      * because run-context is fetched first and needs it to pick this trigger's
      * model override. */
     runType?: string | undefined;
+    /** the model router's tier from the payload, forwarded so run-context applies it to the proxy mint. */
+    routedTier?: RouterTier | undefined;
 }
 /**
  * initialize run context data: parse context, fetch repo info and settings

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pullfrog",
-  "version": "0.1.75",
+  "version": "0.1.77",
   "cliContractVersion": "1",
   "type": "module",
   "bin": {