pullfrog 0.1.64 → 0.1.66

package/dist/internal/index.d.ts

@@ -22,3 +22,5 @@ export { createLeapingProgressComment, deleteProgressCommentApi, getProgressComm
 export type { RunStatusCheckConclusion, RunStatusCheckOctokit, } from "../utils/runStatusCheck.ts";
 export { APPROVAL_CHECK_NAME, createRunStatusCheck, finalizeRunStatusCheck, RUN_STATUS_CHECK_NAME, runStatusCheckNeedsFinalizing, } from "../utils/runStatusCheck.ts";
 export { isValidTimeString, parseTimeString, TIMEOUT_DISABLED, } from "../utils/time.ts";
+export type { XaiAuthBody } from "../utils/xaiOAuth.ts";
+export { parseXaiAuthBody, refreshXaiAuthBody, stringifyXaiAuthBody, } from "../utils/xaiOAuth.ts";

package/dist/internal.js

@@ -185,7 +185,12 @@ var providers = {
         displayName: "O3",
         resolve: "openai/o3",
         effort: ["low", "medium", "high"],
-        openRouterResolve: "openrouter/openai/o3"
+        openRouterResolve: "openrouter/openai/o3",
+        // OpenRouter publishes a reasoning TOGGLE for o3 where direct OpenAI
+        // publishes a ladder, so the route genuinely has no rungs. `[]` rather
+        // than omitting the field: an absent openRouterEffort falls through to
+        // `effort` and would send a rung this route rejects.
+        openRouterEffort: []
       }
     }
   }),
@@ -216,6 +221,11 @@ var providers = {
   xai: provider({
     displayName: "xAI",
     envVars: ["XAI_API_KEY"],
+    // CLI-only, like CODEX_AUTH_JSON: a Grok subscription chain minted by
+    // `pullfrog auth grok`. Excluded from every paste/prompt surface because
+    // the refresh token rotates on every use, so a hand-pasted blob is stale
+    // the moment it is saved. See wiki/grok-auth.md.
+    managedCredentials: ["GROK_AUTH_JSON"],
     models: {
       grok: {
         displayName: "Grok",
@@ -350,14 +360,19 @@ var providers = {
         effort: ["low", "medium", "high", "xhigh", "max"],
         openRouterResolve: "openrouter/anthropic/claude-opus-5",
         subagentModel: "claude-sonnet",
-        // TEMPORARY — clear this when Zen serves opus again. Zen still LISTS
-        // claude-opus-5 in /zen/v1/models, so the catalog test passes, but the
-        // endpoint answers 503 `Upstream request failed: Endpoint is
-        // unavailable.` (measured 5/5; claude-sonnet-5, claude-opus-4-8,
-        // claude-haiku-4-5 and claude-fable-5 all 200 on the same key). opencode
-        // retries the 503 above the AI SDK emitting no part.updated, so a run
-        // just produces nothing until it is killed — metaideas/init logged six
-        // zero-output failures from 2026-08-23. see wiki/opencode-silent-stall.md
+        // TEMPORARY — clear this ONLY when opus completes a run through opencode,
+        // never when the endpoint merely answers. Zen LISTS claude-opus-5 in
+        // /zen/v1/models, so the catalog test passes; on 2026-08-25 the endpoint
+        // itself answered 503 `Upstream request failed: Endpoint is unavailable.`
+        // (measured 5/5; claude-sonnet-5, claude-opus-4-8, claude-haiku-4-5 and
+        // claude-fable-5 all 200 on the same key). opencode retries above the AI
+        // SDK emitting no part.updated, so a run just produces nothing until it is
+        // killed — metaideas/init logged six zero-output failures from 2026-08-23.
+        // The 503 has since cleared and the model is STILL unusable: re-measured
+        // 2026-08-26, direct POST /zen/v1/messages is 10/10 200 at 1.3-4.1s while
+        // `opencode run --model opencode/claude-opus-5` on the same trivial prompt
+        // emitted nothing for 240s in CI. A raw-endpoint 200 is not runtime
+        // availability. see wiki/opencode-silent-stall.md
         fallback: "opencode/claude-sonnet"
       },
       "claude-sonnet": {
@@ -454,7 +469,13 @@ var providers = {
       },
       "kimi-k2": {
         displayName: "Kimi K2",
-        resolve: "opencode/kimi-k2.7-code",
+        // k2.7-code is UNDEPLOYED on Zen — still listed in /zen/v1/models, but
+        // the endpoint answers 400 `[NOT_FOUND] Model not found, inaccessible,
+        // and/or not deployed` (measured 2026-08-28; k2.6 200 on the same key).
+        // opencode-go is no escape: its own kimi-k2 resolves to the SAME model
+        // 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"
       },
       // slug pins the m2 line for DB stability; resolve tracks the current m2.7.
@@ -488,22 +509,139 @@ var providers = {
       }
     }
   }),
+  // OpenCode Go is a separate $10/mo subscription from Zen, served on its own
+  // base URL (`https://opencode.ai/zen/go/v1`) but authenticated with the SAME
+  // `OPENCODE_API_KEY`. it carries the open-weight coding models plus a couple
+  // of frontier ones, and 14 of the ids below are served ONLY here — Zen's
+  // `/v1/models` does not list glm-5.3*, qwen3.7/3.8-*, mimo-*, longcat-2.0,
+  // hy3 or muse-spark. so for a Go subscriber this provider is not a duplicate
+  // route to Zen, it is the only route to most of what they pay for.
+  // like `opencode` and `openrouter` this is a ROUTER, not a vendor: slugs and
+  // display names mirror the upstream brand tier, and the picker groups them
+  // under the upstream vendor.
   "opencode-go": provider({
     displayName: "OpenCode Go",
     envVars: ["OPENCODE_API_KEY"],
     models: {
+      // Z.ai — the plan's flagship coding family, and the only route the
+      // catalog offers to GLM at all.
+      glm: {
+        displayName: "GLM",
+        resolve: "opencode-go/glm-5.3",
+        effort: ["low", "high", "max"],
+        openRouterResolve: "openrouter/z-ai/glm-5.3",
+        preferred: true,
+        subagentModel: "glm-flash"
+      },
+      "glm-flash": {
+        displayName: "GLM Flash",
+        resolve: "opencode-go/glm-5.3-flash",
+        effort: ["low", "high", "max"],
+        openRouterResolve: "openrouter/z-ai/glm-5.3-flash"
+      },
+      // legacy alias — the slug pinned a version instead of a brand tier and
+      // was already resolving to 5.2 under a "GLM 5.2" label. folds forward to
+      // the tier slug; 16 repos and 9 accounts still hold it.
       "glm-5.1": {
         displayName: "GLM 5.2",
         resolve: "opencode-go/glm-5.2",
         effort: ["high", "max"],
         openRouterEffort: ["high", "xhigh"],
         openRouterResolve: "openrouter/z-ai/glm-5.2",
-        preferred: true
+        fallback: "opencode-go/glm"
+      },
+      // Moonshot — parity with moonshotai/* and openrouter/*.
+      "kimi-k3": {
+        displayName: "Kimi K3",
+        resolve: "opencode-go/kimi-k3",
+        // Go publishes a single rung for K3 where the OpenRouter route
+        // publishes three, so every position lands on `max` here.
+        effort: ["max"],
+        openRouterEffort: ["low", "high", "max"],
+        openRouterResolve: "openrouter/moonshotai/kimi-k3",
+        subagentModel: "kimi-k2"
       },
       "kimi-k2": {
         displayName: "Kimi K2",
         resolve: "opencode-go/kimi-k2.7-code",
         openRouterResolve: "openrouter/moonshotai/kimi-k2.7-code"
+      },
+      // DeepSeek and Muse Spark are deliberately ABSENT even though Go serves
+      // them and prices DeepSeek Pro below Zen. each sits behind a per-workspace
+      // opt-in that is off by default — measured, the run dies with
+      // `RegionError` ("only available hosted in China") and `DataPolicyError`
+      // ("collects data used to improve its quality"). that toggle lives on the
+      // CUSTOMER's OpenCode workspace, so no change here can satisfy it, and a
+      // picker row that fails for almost everyone is worse than none. DeepSeek
+      // stays reachable ungated via `deepseek/*`, `opencode/*` and
+      // `openrouter/*`; both remain runnable by full specifier once opted in.
+      // Alibaba — new vendor family for the catalog; Zen serves neither tier.
+      "qwen-max": {
+        displayName: "Qwen Max",
+        resolve: "opencode-go/qwen3.8-max",
+        // both routes publish rungs, and they are different sets rather than
+        // different spellings of one — OpenRouter carries a `minimal` and a
+        // `high` the Go route does not.
+        effort: ["low", "medium", "xhigh"],
+        openRouterEffort: ["minimal", "low", "medium", "high", "xhigh"],
+        openRouterResolve: "openrouter/qwen/qwen3.8-max"
+      },
+      "qwen-plus": {
+        displayName: "Qwen Plus",
+        resolve: "opencode-go/qwen3.7-plus",
+        openRouterResolve: "openrouter/qwen/qwen3.7-plus"
+      },
+      // MiniMax — parity with opencode/* and openrouter/*; the m2 slug pins the
+      // line for DB stability while the resolve tracks the current m2.7.
+      "minimax-m3": {
+        displayName: "MiniMax M3",
+        resolve: "opencode-go/minimax-m3",
+        openRouterResolve: "openrouter/minimax/minimax-m3"
+      },
+      "minimax-m2.5": {
+        displayName: "MiniMax M2",
+        resolve: "opencode-go/minimax-m2.7",
+        openRouterResolve: "openrouter/minimax/minimax-m2.7"
+      },
+      // Xiaomi — Go-only; Zen serves the free `mimo-v2-pro-free` promo instead.
+      "mimo-pro": {
+        displayName: "MiMo Pro",
+        resolve: "opencode-go/mimo-v2.5-pro",
+        openRouterResolve: "openrouter/xiaomi/mimo-v2.5-pro"
+      },
+      // Meituan — Go-only.
+      longcat: {
+        displayName: "LongCat",
+        resolve: "opencode-go/longcat-2.0",
+        openRouterResolve: "openrouter/meituan/longcat-2.0"
+      },
+      // Tencent — Go-only, and the cheapest model on the plan by an order of
+      // magnitude (0.0175/0.0725). Hy3 succeeds the Hunyuan 2.0 line, so the
+      // generation is part of the product name the way Kimi K2/K3 is.
+      hy3: {
+        displayName: "Hy3",
+        resolve: "opencode-go/hy3",
+        effort: ["none", "low", "high"],
+        openRouterResolve: "openrouter/tencent/hy3"
+      },
+      // xAI and OpenAI — the two non-open models on the plan. same list price as
+      // Zen, but a Go subscription covers them where Zen meters them.
+      // Go is the only route that has retired grok-4.5 (models.dev marks
+      // `opencode-go/grok-4.5` deprecated while every other provider still
+      // serves it), so this alias LEADS `xai/grok` by a generation. a mirror
+      // that leads is safe; it is the trailing case that rots — see
+      // wiki/models-catalog.md on `opencode/kimi-k2`.
+      grok: {
+        displayName: "Grok",
+        resolve: "opencode-go/grok-4.6",
+        effort: ["low", "medium", "high", "xhigh"],
+        openRouterResolve: "openrouter/x-ai/grok-4.6"
+      },
+      "gpt-luna": {
+        displayName: "GPT Luna",
+        resolve: "opencode-go/gpt-5.6-luna",
+        effort: ["none", "low", "medium", "high", "xhigh", "max"],
+        openRouterResolve: "openrouter/openai/gpt-5.6-luna"
       }
     }
   }),
@@ -680,7 +818,6 @@ var providers = {
       "o4-mini": {
         displayName: "O4 Mini",
         resolve: "openrouter/openai/o4-mini",
-        effort: ["low", "medium", "high"],
         openRouterResolve: "openrouter/openai/o4-mini"
       },
       "gemini-pro": {
@@ -1415,17 +1552,48 @@ function stripExistingFooter(body) {
   return body.substring(0, dividerIndex).trimEnd();
 }
 
-// utils/codexOAuth.ts
-var CODEX_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
-var CODEX_OAUTH_TOKEN_URL = "https://auth.openai.com/oauth/token";
+// utils/oauthShared.ts
 var OAuthInvalidGrantError = class extends Error {
   status;
-  constructor(status, body) {
-    super(`Codex token refresh failed: ${status} ${body}`);
+  /** whether the provider said this refresh chain is permanently unusable, so
+   * the rotation core may latch it out of use until the user re-mints. */
+  chainIsDead;
+  constructor(provider2, status, body, chainIsDead) {
+    super(`${provider2} token refresh failed: ${status} ${body}`);
     this.name = "OAuthInvalidGrantError";
     this.status = status;
+    this.chainIsDead = chainIsDead;
   }
 };
+function parseOAuthErrorBody(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed && typeof parsed === "object") return parsed;
+  } catch {
+  }
+  return null;
+}
+function decodeJwtExpMs(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) return null;
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof payload.exp !== "number" || !Number.isFinite(payload.exp)) return null;
+  return payload.exp * 1e3;
+}
+
+// utils/codexOAuth.ts
+var CODEX_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var CODEX_OAUTH_TOKEN_URL = "https://auth.openai.com/oauth/token";
+function codexChainIsDead(body) {
+  const err = parseOAuthErrorBody(body)?.error;
+  if (!err || typeof err !== "object") return false;
+  return "code" in err && err.code === "token_expired";
+}
 async function refreshCodexAuthBody(body) {
   const response = await fetch(CODEX_OAUTH_TOKEN_URL, {
     method: "POST",
@@ -1440,7 +1608,7 @@ async function refreshCodexAuthBody(body) {
   if (!response.ok) {
     const text = await response.text().catch(() => "");
     if (response.status >= 400 && response.status < 500) {
-      throw new OAuthInvalidGrantError(response.status, text);
+      throw new OAuthInvalidGrantError("Codex", response.status, text, codexChainIsDead(text));
     }
     throw new Error(`Codex token refresh failed: ${response.status} ${text}`);
   }
@@ -1458,18 +1626,6 @@ async function refreshCodexAuthBody(body) {
     last_refresh: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function decodeJwtExpMs(token) {
-  const parts = token.split(".");
-  if (parts.length !== 3) return null;
-  let payload;
-  try {
-    payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
-  } catch {
-    return null;
-  }
-  if (typeof payload.exp !== "number" || !Number.isFinite(payload.exp)) return null;
-  return payload.exp * 1e3;
-}
 function parseCodexAuthBody(raw) {
   let parsed;
   try {
@@ -1743,7 +1899,12 @@ function disableCheckLine(owner, repo) {
   const url = `https://pullfrog.com/console/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}#auto-review-prs`;
   return `
 
-[Turn off this check \u2192](${url}) \u2014 it reports run status only and gates nothing unless you required it in branch protection.`;
+This check reports run status only and gates nothing unless you required it in branch protection. [Turn off the run status check \u2192](${url})`;
+}
+function logsLine(detailsUrl) {
+  return detailsUrl ? `
+
+[View the run logs \u2192](${detailsUrl})` : "";
 }
 var TERMINAL_OUTPUT = {
   success: {
@@ -1752,7 +1913,7 @@ var TERMINAL_OUTPUT = {
   },
   failure: {
     title: "Pullfrog run failed",
-    summary: "The Pullfrog run failed. See the run logs for details."
+    summary: "The Pullfrog run failed."
   },
   cancelled: {
     title: "Pullfrog run cancelled",
@@ -1760,11 +1921,11 @@ var TERMINAL_OUTPUT = {
   },
   timed_out: {
     title: "Pullfrog run timed out",
-    summary: "The Pullfrog run exceeded its timeout. See the run logs for details."
+    summary: "The Pullfrog run exceeded its timeout."
   },
   action_required: {
     title: "Pullfrog run needs attention",
-    summary: "The Pullfrog run stopped and needs attention. See the run logs for details."
+    summary: "The Pullfrog run stopped and needs attention."
   },
   neutral: {
     title: "Pullfrog run finished",
@@ -1780,8 +1941,11 @@ function terminalOutput(params) {
   const review = params.reviewUrl ? `
 
 [View the review Pullfrog posted \u2192](${params.reviewUrl})` : "";
-  const disable = params.conclusion === "success" ? "" : disableCheckLine(params.owner, params.repo);
-  return { title: base.title, summary: base.summary + review + disable };
+  if (params.conclusion === "success") return { title: base.title, summary: base.summary + review };
+  return {
+    title: base.title,
+    summary: base.summary + logsLine(params.detailsUrl) + review + disableCheckLine(params.owner, params.repo)
+  };
 }
 async function createRunStatusCheck(params) {
   const existing = await params.octokit.rest.checks.listForRef({
@@ -1818,6 +1982,7 @@ async function finalizeRunStatusCheck(params) {
       conclusion: params.conclusion,
       owner: params.owner,
       repo: params.repo,
+      detailsUrl: params.detailsUrl,
       reviewUrl: params.reviewUrl
     })
   };
@@ -1851,6 +2016,69 @@ function parseTimeString(input) {
 function isValidTimeString(input) {
   return parseTimeString(input) !== null;
 }
+
+// utils/xaiOAuth.ts
+var XAI_OAUTH_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+var XAI_OAUTH_TOKEN_URL = "https://auth.x.ai/oauth2/token";
+function xaiChainIsDead(body) {
+  return parseOAuthErrorBody(body)?.error === "invalid_grant";
+}
+async function refreshXaiAuthBody(body) {
+  const response = await fetch(XAI_OAUTH_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: body.tokens.refresh_token,
+      client_id: XAI_OAUTH_CLIENT_ID
+    }).toString(),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    if (response.status >= 400 && response.status < 500) {
+      throw new OAuthInvalidGrantError("Grok", response.status, text, xaiChainIsDead(text));
+    }
+    throw new Error(`Grok token refresh failed: ${response.status} ${text}`);
+  }
+  const tokens = await response.json();
+  return {
+    auth_mode: "grok",
+    tokens: {
+      access_token: tokens.access_token,
+      // xAI rotates on every use, but tolerate a server that echoes nothing
+      // rather than writing an empty refresh token that bricks the chain.
+      refresh_token: tokens.refresh_token || body.tokens.refresh_token
+    },
+    last_refresh: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function parseXaiAuthBody(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const v = parsed;
+  if (v.auth_mode !== "grok") return null;
+  const tokens = v.tokens;
+  if (!tokens || typeof tokens !== "object") return null;
+  const t = tokens;
+  if (typeof t.access_token !== "string" || t.access_token.length === 0) return null;
+  if (typeof t.refresh_token !== "string" || t.refresh_token.length === 0) return null;
+  return {
+    auth_mode: "grok",
+    ...typeof v.refresh_rejected_at === "string" ? { refresh_rejected_at: v.refresh_rejected_at } : {},
+    tokens: { access_token: t.access_token, refresh_token: t.refresh_token },
+    ...typeof v.last_refresh === "string" ? { last_refresh: v.last_refresh } : {}
+  };
+}
+function stringifyXaiAuthBody(body) {
+  return `${JSON.stringify(body, null, 2)}
+`;
+}
 export {
   APPROVAL_CHECK_NAME,
   AUTO_EFFICIENT,
@@ -1898,9 +2126,11 @@ export {
   parseEffortPosition,
   parseModel,
   parseTimeString,
+  parseXaiAuthBody,
   providers,
   pullfrogMcpName,
   refreshCodexAuthBody,
+  refreshXaiAuthBody,
   resolveAutoTier,
   resolveCliModel,
   resolveDisplayAlias,
@@ -1912,6 +2142,7 @@ export {
   rungLabel,
   rungPosition,
   stringifyCodexAuthBody,
+  stringifyXaiAuthBody,
   stripExistingFooter,
   truncateAtLineBoundary,
   updateProgressComment,

package/dist/models.d.ts

@@ -68,7 +68,8 @@ export interface ModelAlias {
     effort: readonly string[] | undefined;
     /** effort rungs on the OpenRouter route, when they differ from `effort` (the
      * DeepSeek/GLM top rung is `max` natively but `xhigh` via OpenRouter).
-     * undefined falls back to `effort`. */
+     * undefined falls back to `effort`; `[]` says the OpenRouter route publishes
+     * no rungs at all, which undefined cannot express. */
     openRouterEffort: readonly string[] | undefined;
     /** hide from selectable lists (UI dropdowns, CLI pickers). does NOT affect
      * resolution — for that use `fallback`. used to keep a redundant alias out of

package/dist/toolState.d.ts

@@ -26,7 +26,7 @@ export type StoredPushDest = {
  * Lives here (not in `mcp/review.ts`) so `ToolState` — which caches
  * `Map<path, CommentableLines>` per checkout — does not pull the MCP server
  * graph into every consumer of run state (the action's main loop, agent
- * harnesses, cf-worker indexing).
+ * harnesses).
  */
 export type CommentableLines = {
     RIGHT: Set<number>;

package/dist/utils/apiKeys.d.ts

@@ -1,3 +1,25 @@
+/** shared sentence in the four `resolveSlug` routing-slug throws. */
+export declare const BYOK_SLUG_MARKER = "env var is required when the model is set to";
+/** shared sentence in the four `validate*Setup` throws. */
+export declare const BYOK_CONFIG_MARKER = "selected but required configuration is missing:";
+/**
+ * A BYOK provider setup is incomplete, at either of the two points that catch it:
+ * `resolveSlug` refusing a routing slug whose backing env var is unset, and the
+ * per-provider `validate*Setup` check that runs once the slug resolves. All eight
+ * messages already name what is missing, the remedy and a docs page, so the
+ * renderer passes them through rather than rewriting them. Before this they
+ * matched no branch at all, and `renderRunError` writes `errorMessage` to the job
+ * summary but not to the comment — so the answer existed on every one of these
+ * runs and the customer's PR comment read `Run failed.`
+ *
+ * Matched from character zero rather than searched anywhere in the text, because
+ * a match publishes the WHOLE message verbatim to a customer's PR and
+ * `errorMessage` is not always ours: `postRun` builds one out of a repo's own
+ * stop-hook output, which is arbitrary text the customer's script printed. A
+ * message that merely CONTAINS one of these errors is something quoting us, and
+ * passing it through would republish everything around it.
+ */
+export declare function isByokSetupError(text: string): boolean;
 /**
  * marker for the distinct "run-context couldn't hand over your stored secrets"
  * body. surfaced verbatim by `runErrorRenderer` (same contract as
@@ -73,6 +95,14 @@ export declare function validateAgentApiKey(params: {
  *   - org-disabled Claude subscription (#1072): `Your organization has
  *     disabled Claude subscription access for Claude Code`, an entitlement
  *     denial with its own remedy — see isClaudeSubscriptionDisabledError.
+ *   - OpenAI rejected key: `Incorrect API key provided: sk-proj-***`, OpenAI's
+ *     own wording for a revoked, rotated or wrong-project key. Absent from this
+ *     list every such run rendered the generic one-line "Run failed." with no
+ *     cause at all — measured on two accounts sitting at 100% failure, one of
+ *     them for a week. Matched on the full phrase rather than "Incorrect API
+ *     key" alone for the reason the markers above are phrased distinctively:
+ *     this predicate short-circuits the whole rendering pipeline on a substring
+ *     of arbitrary agent output.
  */
 export declare function isApiKeyAuthError(text: string): boolean;
 /**

package/dist/utils/codexHome.d.ts

@@ -33,6 +33,27 @@ export interface InstalledCodexAuth {
  * `process.env.XDG_DATA_HOME` so every opencode subprocess discovers the
  * auth.json; no refresh, no DB interaction. */
 export declare function installCodexAuth(): InstalledCodexAuth | null;
+export interface InstalledXaiAuth {
+    /** absolute path of the auth.json we wrote — the post-hook diffs it. */
+    authPath: string;
+    /** value to set as XDG_DATA_HOME for the OpenCode subprocess. */
+    xdgDataHome: string;
+    /** refresh_token at materialization time. opencode's XaiAuthPlugin rotates
+     * in-process on a long run, so the post-hook compares against this to decide
+     * whether anything needs writing back. */
+    originalRefresh: string;
+}
+/** materialize GROK_AUTH_JSON from env into opencode's auth.json.
+ *
+ * opencode ships xAI Grok OAuth natively (`XaiAuthPlugin`, added upstream
+ * 2026-05-21, present in our pinned 1.18.5) against the same public
+ * Grok-CLI OAuth client we mint with, so the stored chain drops straight in.
+ * The plugin sends the token to `api.x.ai/v1` — it deliberately sets no
+ * baseURL — so there is no CLI proxy and no client-version header in play.
+ *
+ * returns null when the env var is absent or malformed; caller treats null as
+ * "no grok subscription auth, fall through to XAI_API_KEY". */
+export declare function installXaiAuth(): InstalledXaiAuth | null;
 export interface InstalledCodexHome {
     /** value to set as CODEX_HOME for the codex subprocess. holds auth.json,
      * config.toml and the session rollouts the resume path reads. */

package/dist/utils/codexOAuth.d.ts

@@ -1,5 +1,5 @@
 /**
- * Pure-stdlib (fetch + Buffer) Codex OAuth refresh + JWT exp decoding.
+ * Pure-stdlib (fetch) Codex OAuth refresh.
  *
  * Lives here (not in codexAuth.ts) so the Next.js server side can import it
  * via pullfrog/internal without dragging in node:child_process / spawn /
@@ -9,6 +9,8 @@
  *
  * See wiki/codex-auth.md for the end-to-end refresh lifecycle.
  */
+import { decodeJwtExpMs, OAuthInvalidGrantError } from "./oauthShared.ts";
+export { decodeJwtExpMs, OAuthInvalidGrantError };
 export interface CodexAuthBody {
     auth_mode: "chatgpt";
     tokens: {
@@ -19,8 +21,10 @@ export interface CodexAuthBody {
     };
     last_refresh?: string;
     /**
-     * ISO timestamp of an `invalid_grant` rejection. OpenAI rotates the refresh
-     * token on every use, so a rejection is PERMANENT — without a latch the
+     * ISO timestamp of a rejection OpenAI attributed to the token itself
+     * (`error.code: "token_expired"` — it does not emit RFC 6749's
+     * `invalid_grant` here). OpenAI rotates the refresh
+     * token on every use, so such a rejection is PERMANENT — without a latch the
      * server re-issued the identical doomed refresh on every run (455 futile
      * round trips in 7 days, one per run, each holding a Postgres row lock across
      * a 10s external call). Cleared implicitly: `pullfrog auth codex` and
@@ -35,13 +39,6 @@ export interface CodexAuthBody {
  * refreshed against this client_id. */
 export declare const CODEX_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 export declare const CODEX_OAUTH_TOKEN_URL = "https://auth.openai.com/oauth/token";
-/** thrown when the OAuth provider rejects the refresh token (4xx). callers
- * can distinguish "race-lost / token revoked" from network errors via
- * `instanceof OAuthInvalidGrantError`. */
-export declare class OAuthInvalidGrantError extends Error {
-    readonly status: number;
-    constructor(status: number, body: string);
-}
 /** force one refresh round-trip against the OAuth provider. returns the
  * rotated Codex-shaped blob (the auth.json body verbatim). does NOT persist
  * — caller is responsible for writing back to wherever the token lives.
@@ -54,16 +51,6 @@ export declare class OAuthInvalidGrantError extends Error {
  * always releases and queued callers get a turn instead of timing out on
  * the tx wrapper. Real OAuth latency is sub-second; 10s is generous. */
 export declare function refreshCodexAuthBody(body: CodexAuthBody): Promise<CodexAuthBody>;
-/** decode the access_token's JWT payload and return its `exp` claim in ms
- * since epoch. returns null if the token isn't a parseable JWT or has no
- * `exp` claim — caller falls back to "treat as expired".
- *
- * We don't verify the JWT signature (we'd need OpenAI's JWKS); we're only
- * using the claim as a freshness hint. The actual auth check happens
- * server-side at OpenAI when the token is used — trusting a fake JWT here
- * would just delay the inevitable 401 from OpenAI. No security boundary
- * at this decode step. */
-export declare function decodeJwtExpMs(token: string): number | null;
 /** parse + validate a Codex auth.json body from its JSON-string form.
  * returns null on any shape mismatch — caller treats as "no codex auth". */
 export declare function parseCodexAuthBody(raw: string): CodexAuthBody | null;

package/dist/utils/codexRefreshDetect.d.ts

@@ -0,0 +1,44 @@
+/** One provider's post-run writeback plan, handed from the opencode harness to
+ * `entryPost.ts` via `core.saveState`. Type-only across that boundary, so it
+ * does not violate entryPost's stdlib-only import rule. */
+export interface OAuthWriteback {
+    /** Pullfrog secret to PUT the rotated chain back into. */
+    secretName: "CODEX_AUTH_JSON" | "GROK_AUTH_JSON";
+    /** opencode auth.json provider key this chain lives under. */
+    provider: "openai" | "xai";
+    authPath: string;
+    originalRefresh: string;
+    /** codex only — opencode's auth entry has no slot for it. see below. */
+    originalIdToken?: string | undefined;
+}
+/** Detect a mid-run Codex OAuth rotation from an on-disk auth.json and render
+ * it in the Codex CLI shape the Pullfrog secret store holds. Returns null when
+ * the file carries no usable OAuth entry or the refresh token is unchanged from
+ * `originalRefresh`. Lives in its own module so `entryPost.ts` can import it
+ * without pulling in `codexHome.ts` (which imports `./cli.ts` and node fs
+ * helpers).
+ *
+ * Two on-disk shapes reach here, one per harness:
+ *   - codex CLI  — `{auth_mode, tokens: {id_token, access_token, refresh_token}}`,
+ *     already the storage shape, so it round-trips verbatim.
+ *   - opencode   — `{openai: {type: "oauth", access, refresh, accountId}}`, which
+ *     has no slot for `id_token`. The caller passes the pre-run value through
+ *     `originalIdToken` so the rotated blob keeps it: the codex CLI REFUSES an
+ *     auth.json without `tokens.id_token` (`missing field 'id_token'`), so
+ *     dropping it here would silently disqualify the account from ever running
+ *     on the codex harness. `id_token` is an identity claim that a refresh does
+ *     not rotate — the server-side `refreshCodexAuthBody` carries the old one
+ *     forward the same way. */
+export declare function detectCodexRefresh(params: {
+    authFileContent: string;
+    originalRefresh: string;
+    originalIdToken?: string | undefined;
+}): string | null;
+/** Detect a mid-run Grok OAuth rotation and render it in the storage shape.
+ * Simpler than the Codex twin: opencode's `xai` entry carries the whole chain,
+ * there is no second on-disk shape to reconcile and no identity claim to
+ * re-attach. Returns null when the entry is missing or unrotated. */
+export declare function detectXaiRefresh(params: {
+    authFileContent: string;
+    originalRefresh: string;
+}): string | null;

package/dist/utils/github.d.ts

@@ -42,6 +42,12 @@ export type GitHubAppPermissions = {
 };
 type AcquireTokenOptions = {
     repos?: string[] | undefined;
+    /**
+     * handle to the server-persisted cross-repo grant, required whenever `repos`
+     * names anything beyond the primary. the server bounds the request against
+     * the sets IT stored, so this cannot widen the token by itself.
+     */
+    xrepoGrant?: string | undefined;
     permissions?: GitHubAppPermissions;
     /**
      * stashed OIDC credentials for minting after restricted mode deletes

package/dist/utils/globals.d.ts

@@ -1,3 +1,2 @@
-export declare const isCloudflareSandbox: boolean;
 export declare const isGitHubActions: boolean;
 export declare const isInsideDocker: boolean;