pullfrog 0.1.75 → 0.1.77

package/dist/agents/opencodeShared.d.ts

@@ -42,6 +42,26 @@ interface AzureProviderEntry {
  * guaranteed present by `validateOpenAICompatibleSetup`.
  */
 export declare function openAICompatibleProvider(model: string | undefined): Record<string, OpenAICompatibleProviderEntry>;
+/**
+ * Customer-gateway block for OPENCODE_CONFIG_CONTENT. opencode resolves a
+ * provider's endpoint as `options.baseURL ?? model.api.url` (`getSDK`), and
+ * models.dev declares no base-URL env var for any provider we catalog — so a
+ * config override is the ONLY lever that re-points one. Unlike
+ * `openAICompatibleProvider` this declares no `npm` and no models: the native
+ * provider and its catalog metadata (including token limits) stay exactly as
+ * they are, and only the host changes. `{}` when unset so the caller can spread
+ * it unconditionally.
+ *
+ * `anthropic/*` normally never reaches here — `resolveAgent` routes it to
+ * claude-code, which reads ANTHROPIC_BASE_URL natively — but keying off the
+ * resolved specifier rather than the harness means it still holds on the paths
+ * that do send a Claude model through opencode (`PULLFROG_AGENT=opencode`).
+ */
+export declare function providerGatewayOverride(model: string | undefined): Record<string, {
+    options: {
+        baseURL: string;
+    };
+}>;
 /**
  * Azure model block for OPENCODE_CONFIG_CONTENT. Unlike openai-compatible this
  * does NOT declare a provider — opencode has a native `azure` one and the env

package/dist/cli.mjs

@@ -123000,7 +123000,7 @@ var import_picocolors = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "pullfrog",
-  version: "0.1.75",
+  version: "0.1.77",
   cliContractVersion: "1",
   type: "module",
   bin: {
@@ -124108,6 +124108,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",
@@ -126058,6 +126072,71 @@ var AUTO_TIER_TARGET = {
 function isAutoTier(slug2) {
   return slug2 === AUTO_EFFICIENT || slug2 === AUTO_INTELLIGENT;
 }
+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_PREFIX = "auto/";
+function autoLadder(slug2) {
+  if (!slug2 || !slug2.startsWith(AUTO_PREFIX) || isAutoTier(slug2)) return void 0;
+  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: providers[key].displayName }));
 function isCardGatedModel(slug2) {
   return resolveOpenRouterModel(slug2) !== void 0;
 }
@@ -126066,7 +126145,7 @@ function resolveModelSlug(slug2) {
 }
 var MAX_FALLBACK_DEPTH = 10;
 function resolveDisplayAlias(slug2) {
-  let current = isAutoTier(slug2) ? AUTO_TIER_TARGET[slug2] : slug2;
+  let current = isAutoTier(slug2) ? AUTO_TIER_TARGET[slug2] : autoLadder(slug2)?.standard ?? slug2;
   const visited = /* @__PURE__ */ new Set();
   for (let i2 = 0; i2 < MAX_FALLBACK_DEPTH; i2++) {
     if (visited.has(current)) return void 0;
@@ -126101,6 +126180,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 slug2 of Object.values(ladder)) {
+    if (!resolveDisplayAlias(slug2)) throw new Error(`${name} ladder names unknown alias ${slug2}`);
+  }
+}
 var OSS_MODEL_ALLOWLIST = [
   "deepseek/deepseek-flash",
   "deepseek/deepseek-pro",
@@ -126138,6 +126222,17 @@ var OPENAI_COMPATIBLE_API_KEY_ENV = "OPENAI_COMPATIBLE_API_KEY";
 var OPENAI_COMPATIBLE_MODEL_ENV = "OPENAI_COMPATIBLE_MODEL";
 var OPENAI_COMPATIBLE_CONTEXT_ENV = "OPENAI_COMPATIBLE_CONTEXT";
 var OPENAI_COMPATIBLE_MAX_OUTPUT_ENV = "OPENAI_COMPATIBLE_MAX_OUTPUT";
+var PROVIDER_GATEWAY_URL_ENV = {
+  anthropic: "ANTHROPIC_BASE_URL",
+  openai: "OPENAI_BASE_URL"
+};
+function getProviderGatewayUrl(specifier) {
+  const slashIndex = specifier?.indexOf("/") ?? -1;
+  if (!specifier || slashIndex <= 0) return void 0;
+  const envVar = PROVIDER_GATEWAY_URL_ENV[specifier.slice(0, slashIndex)];
+  if (!envVar) return void 0;
+  return process.env[envVar]?.trim().replace(/\/$/, "") || void 0;
+}
 function isBedrockAnthropicId(bedrockModelId) {
   return bedrockModelId.toLowerCase().split(/[./:]/).includes("anthropic");
 }
@@ -127644,26 +127739,24 @@ For simple, well-defined tasks, skip the plan phase and go straight to build.`
 
 2. Checkout the PR branch via \`${t2("checkout_pr")}\`.
 
-3. Fetch review comments via \`${t2("get_review_comments")}\`.
+3. Fetch review comments via \`${t2("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 \`${t2("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 \`${t2("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 \`${t2("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 \`${t2("reply_to_review_comment")}\`. The \`comment_id\` parameter takes the root comment's numeric \`id=\` (from the first \`comment author=...\` tag in the \`${t2("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 \`${t2("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 \`${t2("reply_to_review_comment")}\`, including when no code changed. The \`comment_id\` is the root comment's numeric \`id=\`, NOT the \`thread=\` value from \`${t2("get_review_comments")}\`. The runtime dedupes identical bodies within a session.
+   - resolve a thread via \`${t2("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 \`${t2("report_progress")}\` with a brief summary. If your last \`${t2("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
@@ -129640,6 +129733,19 @@ function warnIfNativeEditsUnavailable(ctx) {
     "\xBB this run cannot change files: codex's native write tool depends on bubblewrap, which Ubuntu 24.04 blocks (https://github.com/openai/codex/issues/29908), and the MCP shell is disabled for this repo. read-only work is unaffected \u2014 set `shell: restricted` if the agent needs to edit anything."
   );
 }
+var CODEX_GATEWAY_PROVIDER = "pullfrog-gateway";
+function gatewayProvider(gatewayUrl) {
+  if (!gatewayUrl) return [];
+  return [
+    `[model_providers.${CODEX_GATEWAY_PROVIDER}]`,
+    'name = "OpenAI gateway"',
+    `base_url = ${JSON.stringify(gatewayUrl)}`,
+    'wire_api = "responses"',
+    // where the harness puts the run's OPENAI_API_KEY
+    'env_key = "CODEX_API_KEY"',
+    ""
+  ];
+}
 function writeCodexConfig(params) {
   const shellEnabled = params.ctx.payload.shell === "enabled";
   const sandboxMode = params.ctx.payload.push === "disabled" ? "read-only" : "workspace-write";
@@ -129656,6 +129762,7 @@ function writeCodexConfig(params) {
     'web_search = "live"',
     ...params.model ? [`model = ${JSON.stringify(params.model)}`] : [],
     ...params.effortRung ? [`model_reasoning_effort = ${JSON.stringify(params.effortRung)}`] : [],
+    ...params.gatewayUrl ? [`model_provider = ${JSON.stringify(CODEX_GATEWAY_PROVIDER)}`] : [],
     "",
     "[features]",
     tomlBool(CODEX_DISABLED_FEATURES, false),
@@ -129685,6 +129792,7 @@ function writeCodexConfig(params) {
     "tool_timeout_sec = 660",
     "",
     ...repoMcpApprovals(repoDir),
+    ...gatewayProvider(params.gatewayUrl),
     // UNTRUSTED, deliberately, and this one line is the whole config-precedence
     // boundary. Codex loads `<repo>/.codex/config.toml` as a layer that
     // OUTRANKS ours (project 25 vs user 20), and its denylist strips none of
@@ -129953,7 +130061,11 @@ var codex = agent({
       ctx,
       codexHome,
       model: resolveCodexModel(ctx),
-      effortRung: effort.rung && CODEX_EFFORTS.includes(effort.rung) ? effort.rung : void 0
+      effortRung: effort.rung && CODEX_EFFORTS.includes(effort.rung) ? effort.rung : void 0,
+      // keyed off OpenAI, not the resolved model: codex serves nothing else, an
+      // auto-selected run has no model, and a ChatGPT-subscription token is
+      // valid only at ChatGPT's own backend
+      gatewayUrl: codexHomeAuth ? void 0 : getProviderGatewayUrl("openai/")
     });
     if (codexHomeAuth) {
       core3.saveState(
@@ -135720,6 +135832,14 @@ function openAICompatibleProvider(model) {
     }
   };
 }
+var OPENCODE_GATEWAY_PATH = { anthropic: "/v1" };
+function providerGatewayOverride(model) {
+  const gatewayUrl = getProviderGatewayUrl(model);
+  if (!model || !gatewayUrl) return {};
+  const provider2 = model.slice(0, model.indexOf("/"));
+  const baseURL = `${gatewayUrl}${OPENCODE_GATEWAY_PATH[provider2] ?? ""}`;
+  return { [provider2]: { options: { baseURL } } };
+}
 function azureProvider(model) {
   const prefix = `${AZURE_PROVIDER}/`;
   if (!model?.startsWith(prefix)) return {};
@@ -135835,7 +135955,8 @@ function buildSecurityConfig(ctx, model) {
     provider: {
       openrouter: { models: kimiOpenRouterProviderOverrides() },
       ...openAICompatibleProvider(model),
-      ...azureProvider(model)
+      ...azureProvider(model),
+      ...providerGatewayOverride(model)
     }
   };
   if (model) {
@@ -214306,7 +214427,7 @@ function GetReviewCommentsTool(ctx) {
         threadCount: threadBlocks.length,
         commentsPath,
         toc: formatted.toc,
-        instructions: `the file at commentsPath contains ${threadBlocks.length} review threads with full conversation history. comments marked with * are from the target review (${params.review_id}); any other thread is open feedback on this PR that is also yours to address, including comments that landed after this run started. the TOC shows each thread's file:line and the line number where it appears in the file. to read a specific thread, use: grep -A 50 "^## <file:line>" ${commentsPath} (replace <file:line> with the path from the TOC, e.g. "^## action/utils/foo.ts:42"). address each thread in order, working through one file at a time.`
+        instructions: `the file at commentsPath contains ${threadBlocks.length} review threads with full conversation history. comments marked with * are from the target review (${params.review_id}); any other thread is open feedback on this PR, including comments that landed after this run started. Being returned does not authorize a code change; follow the task's scope and each thread's latest request. the TOC shows each thread's file:line and the line number where it appears in the file. to read a specific thread, use: grep -A 50 "^## <file:line>" ${commentsPath} (replace <file:line> with the path from the TOC, e.g. "^## action/utils/foo.ts:42"). read each full thread before deciding whether it calls for a reply or a code change.`
       };
     })
   });
@@ -214429,8 +214550,7 @@ An existing plan comment was found for this issue. Update that comment with the
   };
 }
 var modeInstructionParent = {
-  IncrementalReview: "Review",
-  Fix: "Build"
+  IncrementalReview: "Review"
 };
 function buildOrchestratorGuidance(ctx, mode, overrideGuidance) {
   const hardcoded = overrideGuidance ?? mode.prompt ?? "";
@@ -215642,18 +215762,13 @@ function hasEnvVar4(name) {
   const value2 = process.env[name];
   return typeof value2 === "string" && value2.length > 0;
 }
-var HOST_OVERRIDES = {
-  ANTHROPIC_API_KEY: "ANTHROPIC_BASE_URL",
-  CLAUDE_CODE_OAUTH_TOKEN: "ANTHROPIC_BASE_URL"
-};
 function envVarsFor(model) {
   return model.includes("/") ? getModelEnvVars(model) : [];
 }
 async function checkOne(params) {
   const value2 = process.env[params.envVar];
   if (!value2) return null;
-  const hostOverride = HOST_OVERRIDES[params.envVar];
-  if (hostOverride && hasEnvVar4(hostOverride)) return null;
+  if (getProviderGatewayUrl(params.model)) return null;
   if (params.envVar === "CLAUDE_CODE_OAUTH_TOKEN") {
     const preflight = await preflightClaudeSubscription({
       token: value2,
@@ -216571,6 +216686,15 @@ var JsonPayload = type({
   "type?": "string | undefined",
   "model?": "string | undefined",
   "modelExplicit?": "boolean | undefined",
+  // optional so a payload from a pre-router server build still parses against a
+  // newer action across a rolling deploy.
+  "routing?": type({
+    tier: "'minimal' | 'light' | 'standard' | 'deep'",
+    stakes: "number",
+    workload: "number",
+    source: "'scorer' | 'heuristic' | 'fixed'",
+    rationale: "string"
+  }).or("undefined"),
   "effort?": "number | string | undefined",
   "debug?": "boolean | undefined",
   prompt: "string",
@@ -216752,6 +216876,7 @@ function resolvePayload(resolvedPromptInput, repoSettings) {
     // explicit only when the model came from a per-run override flag (carried on
     // the JSON payload). a GHA `model` input or the repo default is not explicit.
     modelExplicit: jsonPayload?.modelExplicit ?? false,
+    routing: jsonPayload?.routing,
     effort,
     debug: debug4 || void 0,
     prompt,
@@ -217438,9 +217563,12 @@ async function fetchRunContext(params) {
     if (params.oidcToken) {
       headers["X-GitHub-OIDC-Token"] = params.oidcToken;
     }
-    const query = params.runType ? `?type=${encodeURIComponent(params.runType)}` : "";
+    const query = new URLSearchParams();
+    if (params.runType) query.set("type", params.runType);
+    if (params.routedTier) query.set("tier", params.routedTier);
+    const search2 = query.toString();
     const response = await apiFetch({
-      path: `/api/repo/${params.repoContext.owner}/${params.repoContext.name}/run-context${query}`,
+      path: `/api/repo/${params.repoContext.owner}/${params.repoContext.name}/run-context${search2 ? `?${search2}` : ""}`,
       headers,
       signal: controller.signal
     });
@@ -217507,7 +217635,13 @@ async function resolveRunContextData(params) {
       retries: [100, 500],
       bail: (error109) => !isTransientOctokitError(error109)
     })(),
-    fetchRunContext({ token: params.token, repoContext, oidcToken, runType: params.runType })
+    fetchRunContext({
+      token: params.token,
+      repoContext,
+      oidcToken,
+      runType: params.runType,
+      routedTier: params.routedTier
+    })
   ]);
   return {
     repo: {
@@ -218415,6 +218549,12 @@ function logRunStartup(ctx) {
   log2.info(
     `\xBB effort:  ${resolveEffortForLog({ payload: ctx.payload, resolvedModel: ctx.resolvedModel })}`
   );
+  const routing = ctx.payload.routing;
+  if (routing) {
+    log2.info(
+      `\xBB routed:  ${routing.tier} (${routing.source}: stakes ${routing.stakes}, workload ${routing.workload}) \u2014 ${routing.rationale}`
+    );
+  }
   log2.info(
     `\xBB agent:   ${resolveAgentForLog({ agentName: ctx.agentName, resolvedModel: ctx.resolvedModel })}`
   );
@@ -218609,7 +218749,8 @@ async function main() {
     const runContext = await resolveRunContextData({
       octokit: initialOctokit,
       token: jobToken,
-      runType: typeof resolvedPromptInput === "string" ? void 0 : resolvedPromptInput.type
+      runType: typeof resolvedPromptInput === "string" ? void 0 : resolvedPromptInput.type,
+      routedTier: typeof resolvedPromptInput === "string" ? void 0 : resolvedPromptInput.routing?.tier
     });
     timer.checkpoint("runContextData");
     const payload = resolvePayload(resolvedPromptInput, runContext.repoSettings);
@@ -219730,7 +219871,7 @@ function resolveTarget2(repo) {
   return { owner: match3[1], repo: match3[2] };
 }
 function cliVersion() {
-  const parts = /^(\d+)\.(\d+)\.(\d+)$/.exec("0.1.75");
+  const parts = /^(\d+)\.(\d+)\.(\d+)$/.exec("0.1.77");
   if (!parts) return "0.0.0";
   return `${Number(parts[1])}.${Number(parts[2])}.${Number(parts[3])}`;
 }
@@ -219897,7 +220038,7 @@ async function runCli8(input2) {
 }
 
 // cli.ts
-var VERSION10 = "0.1.75";
+var VERSION10 = "0.1.77";
 var bin = basename2(process.argv[1] || "");
 var PROG = bin === "pf" || bin === "pullfrog" ? bin : "pullfrog";
 var rawArgs = process.argv.slice(2);

package/dist/external.d.ts

@@ -4,6 +4,7 @@
  * Other files in action/ re-export from this file for backward compatibility.
  */
 import type { EffortPosition } from "./effort.ts";
+import type { RouterTier } from "./models.ts";
 export declare const pullfrogMcpName = "pullfrog";
 /** @see {@link file://./agents/shared.ts} Agent interface that uses this type */
 export type AgentId = "claude" | "codex" | "opencode";
@@ -51,8 +52,8 @@ export declare function findDanglingPromptToolRefs(params: {
 }): string[];
 export type { EffortPosition } from "./effort.ts";
 export { DEFAULT_EFFORT_POSITION, EFFORT_ALIASES, isEffortPosition, offeredRungs, parseEffortPosition, resolveRung, rungLabel, rungPosition, SUBSIDY_RUNG, } from "./effort.ts";
-export type { AutoTier, ModelAlias, ModelProvider, ProviderConfig } from "./models.ts";
-export { AUTO_EFFICIENT, AUTO_INTELLIGENT, DEFAULT_PROXY_MODEL, defaultAutoTier, getAutoSelectHintModel, getModelEffortLevels, getModelEnvVars, getModelManagedCredentials, getModelProvider, getProviderDisplayName, isAutoTier, isCardGatedModel, isOssAllowedModel, modelAliases, modelHasStoredAuth, OSS_MODEL_ALLOWLIST, OSS_RECOMMENDED_MODEL, ossFundedModelNames, parseModel, providers, resolveAutoTier, resolveCliModel, resolveDisplayAlias, resolveModelRung, resolveModelSlug, resolveOpenRouterModel, } from "./models.ts";
+export type { AutoTier, ModelAlias, ModelProvider, ProviderConfig, RouterTier, } from "./models.ts";
+export { AUTO_EFFICIENT, AUTO_INTELLIGENT, AUTO_ROUTER, autoLadder, autoRoutedSlug, DEFAULT_PROXY_MODEL, defaultAutoTier, getAutoSelectHintModel, getModelEffortLevels, getModelEnvVars, getModelManagedCredentials, getModelProvider, getProviderDisplayName, isAutoRouted, isAutoSlug, isAutoTier, isCardGatedModel, isOssAllowedModel, isRouterTier, ladderRungs, modelAliases, modelHasStoredAuth, OSS_MODEL_ALLOWLIST, OSS_RECOMMENDED_MODEL, ossFundedModelNames, PROVIDER_GATEWAY_URL_ENV, parseModel, providers, ROUTED_PROVIDERS, ROUTER_LADDER, ROUTER_TIERS, resolveAutoTier, resolveCliModel, resolveDisplayAlias, resolveModelRung, resolveModelSlug, resolveOpenRouterModel, resolveRoutedModel, } from "./models.ts";
 export type ToolPermission = "disabled" | "enabled";
 export type ShellPermission = "disabled" | "restricted" | "enabled";
 export type PushPermission = "disabled" | "restricted" | "enabled";
@@ -262,6 +263,21 @@ export interface XrepoConfig {
      */
     unavailable?: string[] | undefined;
 }
+/**
+ * the model router's decision, carried so the runner can log it and forward the
+ * tier to run-context as `?tier=` — the Router proxy mint happens there and
+ * never sees `model` below. see wiki/router.md.
+ */
+export interface PayloadRouting {
+    tier: RouterTier;
+    stakes: number;
+    workload: number;
+    /** who decided: the scorer, the heuristic it falls back to, or the fixed tier a non-review kind of work carries. mirrors the `RouterSource` enum. */
+    source: RouterSource;
+    /** the scorer's own sentence or two on what a reviewer must reconstruct */
+    rationale: string;
+}
+export type RouterSource = "scorer" | "heuristic" | "fixed";
 export interface WriteablePayload {
     "~pullfrog": true;
     /** semantic version of the payload to ensure compatibility */
@@ -283,6 +299,8 @@ export interface WriteablePayload {
      * baseInstructions flag) keeps the soft-fallback safety net. see modelAccess.ts.
      */
     modelExplicit?: boolean | undefined;
+    /** the model router's decision, when it made one; `model` above already reflects it */
+    routing?: PayloadRouting | undefined;
     /** reasoning-effort position on [0,1]; 0 is the model's cheapest rung, 1 its priciest */
     effort?: EffortPosition | undefined;
     /**