pullfrog 0.1.56 → 0.1.59

package/dist/cli.mjs

@@ -3955,7 +3955,7 @@ var require_util2 = __commonJS({
     "use strict";
     var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants2();
     var { getGlobalOrigin } = require_global();
-    var { performance: performance9 } = __require("perf_hooks");
+    var { performance: performance10 } = __require("perf_hooks");
     var { isBlobLike, toUSVString, ReadableStreamFrom } = require_util();
     var assert3 = __require("assert");
     var { isUint8Array } = __require("util/types");
@@ -4118,7 +4118,7 @@ var require_util2 = __commonJS({
       }
     }
     function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
-      return performance9.now();
+      return performance10.now();
     }
     function createOpaqueTimingInfo(timingInfo) {
       return {
@@ -20099,14 +20099,14 @@ Support boolean input list: \`true | True | TRUE | false | False | FALSE\``);
       });
     }
     exports.group = group2;
-    function saveState3(name, value2) {
+    function saveState4(name, value2) {
       const filePath = process.env["GITHUB_STATE"] || "";
       if (filePath) {
         return (0, file_command_1.issueFileCommand)("STATE", (0, file_command_1.prepareKeyValueMessage)(name, value2));
       }
       (0, command_1.issueCommand)("save-state", { name }, (0, utils_1.toCommandValue)(value2));
     }
-    exports.saveState = saveState3;
+    exports.saveState = saveState4;
     function getState2(name) {
       return process.env[`STATE_${name}`] || "";
     }
@@ -27894,11 +27894,11 @@ var require_mode = __commonJS({
 var require_isexe = __commonJS({
   "node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module) {
     var fs5 = __require("fs");
-    var core11;
+    var core12;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
-      core11 = require_windows();
+      core12 = require_windows();
     } else {
-      core11 = require_mode();
+      core12 = require_mode();
     }
     module.exports = isexe;
     isexe.sync = sync;
@@ -27921,7 +27921,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core11(path4, options || {}, function(er, is) {
+      core12(path4, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -27933,7 +27933,7 @@ var require_isexe = __commonJS({
     }
     function sync(path4, options) {
       try {
-        return core11.sync(path4, options || {});
+        return core12.sync(path4, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -33299,7 +33299,7 @@ var require_util9 = __commonJS({
     var { redirectStatusSet, referrerPolicyTokens, badPortsSet } = require_constants9();
     var { getGlobalOrigin } = require_global3();
     var { collectAnHTTPQuotedString, parseMIMEType } = require_data_url();
-    var { performance: performance9 } = __require("node:perf_hooks");
+    var { performance: performance10 } = __require("node:perf_hooks");
     var { ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = require_util8();
     var assert3 = __require("node:assert");
     var { isUint8Array } = __require("node:util/types");
@@ -33454,7 +33454,7 @@ var require_util9 = __commonJS({
       };
     }
     function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
-      return coarsenTime(performance9.now(), crossOriginIsolatedCapability);
+      return coarsenTime(performance10.now(), crossOriginIsolatedCapability);
     }
     function createOpaqueTimingInfo(timingInfo) {
       return {
@@ -76726,7 +76726,7 @@ var require_core3 = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     var id_1 = require_id();
     var ref_1 = require_ref();
-    var core11 = [
+    var core12 = [
       "$schema",
       "$id",
       "$defs",
@@ -76736,7 +76736,7 @@ var require_core3 = __commonJS({
       id_1.default,
       ref_1.default
     ];
-    exports.default = core11;
+    exports.default = core12;
   }
 });
 
@@ -98607,14 +98607,14 @@ var require_turndown_cjs = __commonJS({
         } else if (node2.nodeType === 1) {
           replacement = replacementForNode.call(self2, node2);
         }
-        return join28(output, replacement);
+        return join29(output, replacement);
       }, "");
     }
     function postProcess(output) {
       var self2 = this;
       this.rules.forEach(function(rule) {
         if (typeof rule.append === "function") {
-          output = join28(output, rule.append(self2.options));
+          output = join29(output, rule.append(self2.options));
         }
       });
       return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -98626,7 +98626,7 @@ var require_turndown_cjs = __commonJS({
       if (whitespace.leading || whitespace.trailing) content = content.trim();
       return whitespace.leading + rule.replacement(content, node2, this.options) + whitespace.trailing;
     }
-    function join28(output, replacement) {
+    function join29(output, replacement) {
       var s1 = trimTrailingNewlines(output);
       var s2 = trimLeadingNewlines(replacement);
       var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
@@ -105306,14 +105306,14 @@ async function runClaudeAuth() {
 }
 
 // commands/gha.ts
-var core10 = __toESM(require_core(), 1);
+var core11 = __toESM(require_core(), 1);
 var import_arg2 = __toESM(require_arg(), 1);
 import { dirname as dirname6 } from "node:path";
 
 // main.ts
-import { existsSync as existsSync8, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync2 } from "node:fs";
 import { readFile as readFile5 } from "node:fs/promises";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 
 // node_modules/.pnpm/package-manager-detector@1.8.0/node_modules/package-manager-detector/dist/commands.mjs
 function splitRunArgs(args2, valueFlags = []) {
@@ -106186,6 +106186,22 @@ var providers = {
       }
     }
   }),
+  azure: provider({
+    displayName: "Azure OpenAI",
+    // the resource name is half the endpoint URL and the deployment is the model
+    // id, so both are as load-bearing as the key. only the key is sensitive.
+    envVars: ["AZURE_API_KEY", "AZURE_RESOURCE_NAME", "AZURE_DEPLOYMENT"],
+    models: {
+      // single routing entry — the real model is the customer's deployment name,
+      // read from AZURE_DEPLOYMENT at run time. see ModelRouting docs for why
+      // Azure can't be cataloged even though models.dev lists it.
+      byok: {
+        displayName: "Azure OpenAI",
+        resolve: "azure",
+        routing: "azure"
+      }
+    }
+  }),
   "openai-compatible": provider({
     // "Custom" is the picker group, "OpenAI-compatible" the entry under it, so the
     // menu reads `Custom › OpenAI-compatible` and a second custom backend (a
@@ -106411,6 +106427,11 @@ function getModelEnvVars(slug2) {
   }
   return providerConfig.envVars.slice();
 }
+function getModelManagedCredentials(slug2) {
+  const parsed2 = parseModel(slug2);
+  const providerConfig = providers[parsed2.provider];
+  return providerConfig?.managedCredentials?.slice() ?? [];
+}
 var modelAliases = Object.entries(providers).flatMap(
   ([providerKey, config3]) => Object.entries(config3.models).map(([modelId, def]) => ({
     slug: `${providerKey}/${modelId}`,
@@ -106508,6 +106529,13 @@ function isOssAllowedModel(slug2) {
 }
 var BEDROCK_MODEL_ID_ENV = "BEDROCK_MODEL_ID";
 var VERTEX_MODEL_ID_ENV = "VERTEX_MODEL_ID";
+var AZURE_PROVIDER = "azure";
+var AZURE_RESOURCE_NAME_ENV = "AZURE_RESOURCE_NAME";
+var AZURE_API_KEY_ENV = "AZURE_API_KEY";
+var AZURE_DEPLOYMENT_ENV = "AZURE_DEPLOYMENT";
+var AZURE_CONTEXT_ENV = "AZURE_CONTEXT";
+var AZURE_MAX_OUTPUT_ENV = "AZURE_MAX_OUTPUT";
+var AZURE_USE_CHAT_COMPLETIONS_ENV = "AZURE_USE_CHAT_COMPLETIONS";
 var OPENAI_COMPATIBLE_PROVIDER = "openai-compatible";
 var OPENAI_COMPATIBLE_BASE_URL_ENV = "OPENAI_COMPATIBLE_BASE_URL";
 var OPENAI_COMPATIBLE_API_KEY_ENV = "OPENAI_COMPATIBLE_API_KEY";
@@ -106527,6 +106555,8 @@ function formatMcpToolRef(agentId, toolName) {
   switch (agentId) {
     case "claude":
       return `mcp__${pullfrogMcpName}__${toolName}`;
+    case "codex":
+      return `${pullfrogMcpName}__${toolName}`;
     case "opencode":
       return `${pullfrogMcpName}_${toolName}`;
     default:
@@ -106536,15 +106566,13 @@ function formatMcpToolRef(agentId, toolName) {
 function extractMcpToolRefs(agentId, text) {
   const prefix = formatMcpToolRef(agentId, "");
   const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return [...text.matchAll(new RegExp(`${escaped}([a-z0-9_]+)`, "g"))].map((match3) => match3[1]);
+  return [...text.matchAll(new RegExp(`(?<![A-Za-z0-9_])${escaped}([a-z0-9_]+)`, "g"))].map(
+    (match3) => match3[1]
+  );
 }
-function assertPromptToolRefs(params) {
+function findDanglingPromptToolRefs(params) {
   const registered = new Set(params.toolNames);
-  const dangling = [...new Set(extractMcpToolRefs(params.agentId, params.prompt))].filter((name) => !registered.has(name)).sort();
-  if (dangling.length === 0) return;
-  throw new Error(
-    `prompt advertises ${dangling.length} tool(s) the MCP server did not register: ${dangling.join(", ")}. registered: ${[...registered].sort().join(", ")}`
-  );
+  return [...new Set(extractMcpToolRefs(params.agentId, params.prompt))].filter((name) => !registered.has(name)).sort();
 }
 function hasSimilarIssues(params) {
   return params.repoIntelligence && !!params.event.issue_number && !params.event.is_pr;
@@ -107030,7 +107058,8 @@ import { pipeline } from "node:stream/promises";
 async function installFromNpmTarball(params) {
   const tempDir = process.env.PULLFROG_TEMP_DIR;
   if (!tempDir) throw new Error("PULLFROG_TEMP_DIR is not set");
-  const extractedDir = join2(tempDir, "package");
+  const packageRoot = join2(tempDir, `npm-${params.packageName.replace(/[^a-z0-9]+/gi, "-")}`);
+  const extractedDir = join2(packageRoot, "package");
   const cliPath = join2(extractedDir, params.executablePath);
   if (existsSync2(cliPath)) {
     log2.debug(`\xBB using cached binary at ${cliPath}`);
@@ -107056,7 +107085,8 @@ async function installFromNpmTarball(params) {
     }
   }
   log2.debug(`\xBB installing ${params.packageName}@${resolvedVersion}...`);
-  const tarballPath = join2(tempDir, "package.tgz");
+  mkdirSync(packageRoot, { recursive: true });
+  const tarballPath = join2(packageRoot, "package.tgz");
   const npmRegistry = process.env.NPM_REGISTRY || "https://registry.npmjs.org";
   let tarballUrl;
   if (params.packageName.startsWith("@")) {
@@ -107076,7 +107106,7 @@ async function installFromNpmTarball(params) {
   await pipeline(response.body, fileStream);
   log2.debug(`\xBB downloaded tarball to ${tarballPath}`);
   log2.debug(`\xBB extracting tarball...`);
-  const extractResult = spawnSync("tar", ["-xzf", tarballPath, "-C", tempDir], {
+  const extractResult = spawnSync("tar", ["-xzf", tarballPath, "-C", packageRoot], {
     stdio: "pipe",
     encoding: "utf-8"
   });
@@ -107085,9 +107115,6 @@ async function installFromNpmTarball(params) {
       `Failed to extract tarball: ${extractResult.stderr || extractResult.stdout || "Unknown error"}`
     );
   }
-  if (!existsSync2(cliPath)) {
-    throw new Error(`Executable not found in extracted package at ${cliPath}`);
-  }
   if (params.installDependencies) {
     log2.debug(`\xBB installing dependencies for ${params.packageName}...`);
     const installResult = spawnSync("npm", ["install", "--production"], {
@@ -107108,6 +107135,9 @@ async function installFromNpmTarball(params) {
     }
     log2.debug(`\xBB dependencies installed`);
   }
+  if (!existsSync2(cliPath)) {
+    throw new Error(`Executable not found in extracted package at ${cliPath}`);
+  }
   chmodSync(cliPath, 493);
   log2.debug(`\xBB ${params.packageName} installed at ${cliPath}`);
   return cliPath;
@@ -107281,6 +107311,7 @@ function resolveRunAlias(ctx) {
   }
   const model = ctx.resolvedModel;
   if (!model) return void 0;
+  if (model.startsWith(`${AZURE_PROVIDER}/`)) return void 0;
   return modelAliases.find((a2) => !a2.fallback && a2.resolve === model) ?? matchHostedAnthropicAlias(model);
 }
 function ossEffortFloor(ctx) {
@@ -107319,7 +107350,7 @@ var import_semver = __toESM(require_semver2(), 1);
 // package.json
 var package_default = {
   name: "pullfrog",
-  version: "0.1.56",
+  version: "0.1.59",
   type: "module",
   bin: {
     pullfrog: "dist/cli.mjs",
@@ -107351,6 +107382,8 @@ var package_default = {
     "@clack/prompts": "^1.2.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@opencode-ai/sdk": "1.18.5",
+    "@openai/codex": "0.147.0",
+    "@openai/codex-sdk": "0.147.0",
     "@octokit/plugin-throttling": "^11.0.3",
     "@octokit/rest": "^22.0.0",
     "@octokit/webhooks-types": "^7.6.1",
@@ -109472,13 +109505,735 @@ var claude = agent({
   }
 });
 
-// agents/opencode.ts
+// agents/codex.ts
 var core2 = __toESM(require_core(), 1);
-import { spawn as nodeSpawn2 } from "node:child_process";
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join7 } from "node:path";
 import { performance as performance6 } from "node:perf_hooks";
 
+// utils/codexHome.ts
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir2, userInfo } from "node:os";
+import { join as join6 } from "node:path";
+var CODEX_AUTH_ENV = "CODEX_AUTH_JSON";
+var PULLFROG_DATA_DIR = "/var/lib/pullfrog";
+function isRejectedChain(body) {
+  if (!body.refresh_rejected_at) return false;
+  log2.warning(
+    `\xBB ${CODEX_AUTH_ENV} was rejected by OpenAI at ${body.refresh_rejected_at} and cannot be refreshed \u2014 re-run \`npx pullfrog auth codex\`. skipping it for this run.`
+  );
+  return true;
+}
+function installCodexAuth() {
+  const raw2 = process.env[CODEX_AUTH_ENV];
+  if (!raw2) return null;
+  const body = parseCodexAuthBody(raw2);
+  if (!body) {
+    log2.warning(`\xBB ${CODEX_AUTH_ENV} present but malformed; ignoring`);
+    return null;
+  }
+  if (isRejectedChain(body)) return null;
+  const expiresMs = decodeJwtExpMs(body.tokens.access_token) ?? 0;
+  const xdgDataHome = resolveDataHome();
+  const opencodeDir = join6(xdgDataHome, "opencode");
+  const authPath = join6(opencodeDir, "auth.json");
+  const opencodeAuth = {
+    openai: {
+      type: "oauth",
+      refresh: body.tokens.refresh_token,
+      access: body.tokens.access_token,
+      expires: expiresMs,
+      ...body.tokens.account_id ? { accountId: body.tokens.account_id } : {}
+    }
+  };
+  mkdirSync5(opencodeDir, { recursive: true });
+  writeFileSync5(authPath, `${JSON.stringify(opencodeAuth, null, 2)}
+`, { mode: 384 });
+  process.env.XDG_DATA_HOME = xdgDataHome;
+  log2.info(`\xBB installed Codex auth at ${authPath}`);
+  return {
+    authPath,
+    xdgDataHome,
+    originalRefresh: body.tokens.refresh_token,
+    originalIdToken: body.tokens.id_token
+  };
+}
+function installCodexHome() {
+  const raw2 = process.env[CODEX_AUTH_ENV];
+  if (!raw2) return null;
+  const body = parseCodexAuthBody(raw2);
+  if (!body) {
+    log2.warning(`\xBB ${CODEX_AUTH_ENV} present but malformed; ignoring`);
+    return null;
+  }
+  if (isRejectedChain(body)) return null;
+  if (!body.tokens.id_token) {
+    log2.warning(
+      `\xBB ${CODEX_AUTH_ENV} carries no id_token \u2014 the codex CLI cannot load it. re-run \`npx pullfrog auth codex\` to mint a complete credential.`
+    );
+    return null;
+  }
+  const codexHome = join6(resolveDataHome(), "codex");
+  const authPath = join6(codexHome, "auth.json");
+  mkdirSync5(codexHome, { recursive: true });
+  writeFileSync5(authPath, stringifyCodexAuthBody(body), { mode: 384 });
+  log2.info(`\xBB installed Codex auth at ${authPath}`);
+  return { codexHome, authPath, originalRefresh: body.tokens.refresh_token };
+}
+function resolveDataHome() {
+  if (process.env.CI !== "true") return join6(homedir2(), ".local", "share");
+  bootstrapPullfrogDataDir();
+  return PULLFROG_DATA_DIR;
+}
+function bootstrapPullfrogDataDir() {
+  const user = userInfo().username;
+  let primaryGroup;
+  try {
+    primaryGroup = execFileSync4("id", ["-gn", user], { stdio: "pipe", encoding: "utf-8" }).trim();
+  } catch {
+    primaryGroup = user;
+  }
+  try {
+    execFileSync4("sudo", ["-n", "mkdir", "-p", PULLFROG_DATA_DIR], { stdio: "pipe" });
+    execFileSync4("sudo", ["-n", "chown", `${user}:${primaryGroup}`, PULLFROG_DATA_DIR], {
+      stdio: "pipe"
+    });
+    execFileSync4("sudo", ["-n", "chmod", "700", PULLFROG_DATA_DIR], { stdio: "pipe" });
+  } catch (err) {
+    throw new Error(
+      `failed to bootstrap ${PULLFROG_DATA_DIR} (required for codex auth in CI): ${err instanceof Error ? err.message : String(err)}. the MCP shell's mount-namespace sandbox cannot protect the auth file when it lives under $HOME, and silently falling back would contradict the "three independent layers" claim in wiki/codex-auth.md. passwordless sudo is required for codex auth on this runner \u2014 either configure it, or remove CODEX_AUTH_JSON from the run.`
+    );
+  }
+}
+
+// utils/secrets.ts
+var SENSITIVE_PATTERNS = [
+  /_KEY$/i,
+  /_SECRET$/i,
+  /_TOKEN$/i,
+  /_PASSWORD$/i,
+  /_CREDENTIAL$/i
+];
+function isSensitiveEnvName(key) {
+  return SENSITIVE_PATTERNS.some((p) => p.test(key));
+}
+var SAFE_ENV_PREFIXES = ["GITHUB_", "RUNNER_", "JAVA_HOME_", "GOROOT_"];
+var SAFE_ENV_NAMES = /* @__PURE__ */ new Set([
+  // system
+  "CI",
+  "HOME",
+  "LANG",
+  "LOGNAME",
+  "PATH",
+  "SHELL",
+  "SHLVL",
+  "TERM",
+  "TMPDIR",
+  "TZ",
+  "USER",
+  "XDG_CONFIG_HOME",
+  "XDG_RUNTIME_DIR",
+  "DEBIAN_FRONTEND",
+  // runner image toolchain
+  "ACCEPT_EULA",
+  "AGENT_TOOLSDIRECTORY",
+  "ANDROID_HOME",
+  "ANDROID_NDK",
+  "ANDROID_NDK_HOME",
+  "ANDROID_NDK_LATEST_HOME",
+  "ANDROID_NDK_ROOT",
+  "ANDROID_SDK_ROOT",
+  "ANT_HOME",
+  "AZURE_EXTENSION_DIR",
+  "BOOTSTRAP_HASKELL_NONINTERACTIVE",
+  "CHROME_BIN",
+  "CHROMEWEBDRIVER",
+  "CONDA",
+  "DOTNET_MULTILEVEL_LOOKUP",
+  "DOTNET_NOLOGO",
+  "DOTNET_SKIP_FIRST_TIME_EXPERIENCE",
+  "EDGEWEBDRIVER",
+  "GECKOWEBDRIVER",
+  "GHCUP_INSTALL_BASE_PREFIX",
+  "GRADLE_HOME",
+  "JAVA_HOME",
+  "HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS",
+  "HOMEBREW_NO_AUTO_UPDATE",
+  "ImageOS",
+  "ImageVersion",
+  "NVM_DIR",
+  "PIPX_BIN_DIR",
+  "PIPX_HOME",
+  "PSModulePath",
+  "SELENIUM_JAR_PATH",
+  "SGX_AESM_ADDR",
+  "SWIFT_PATH",
+  "VCPKG_INSTALLATION_ROOT"
+]);
+var _userAllowlist = null;
+function setEnvAllowlist(raw2) {
+  const names = raw2.split("\n").map((line) => line.trim()).filter(Boolean);
+  _userAllowlist = new Set(names);
+}
+function isSafeEnvVar(key) {
+  if (SAFE_ENV_NAMES.has(key)) return true;
+  return SAFE_ENV_PREFIXES.some((p) => key.startsWith(p));
+}
+var WORKFLOW_COMMAND_ENV_NAMES = [
+  "GITHUB_ENV",
+  "GITHUB_PATH",
+  "GITHUB_OUTPUT",
+  "GITHUB_STATE",
+  "GITHUB_STEP_SUMMARY",
+  // dropping the five paths above but keeping RUNNER_TEMP would be theatre:
+  // the file-command files live in `$RUNNER_TEMP/_runner_file_commands/`, so the
+  // directory is one `ls` away. nothing in the install path reads it (only our
+  // own leak-surface wipe in `setup.ts`, which runs in the parent), and package
+  // managers use TMPDIR.
+  "RUNNER_TEMP"
+];
+function filterEnvForUntrustedCode() {
+  const env2 = filterEnv();
+  for (const name of WORKFLOW_COMMAND_ENV_NAMES) delete env2[name];
+  return env2;
+}
+function filterEnv() {
+  const filtered = {};
+  for (const [key, value2] of Object.entries(process.env)) {
+    if (value2 === void 0) continue;
+    const userAllowed = _userAllowlist?.has(key) ?? false;
+    if (isSensitiveEnvName(key) && !userAllowed) continue;
+    if (isSafeEnvVar(key) || userAllowed) {
+      filtered[key] = value2;
+    }
+  }
+  return filtered;
+}
+function resolveEnv(mode) {
+  if (mode === "inherit") {
+    return process.env;
+  }
+  if (mode === "restricted" || mode === void 0) {
+    return filterEnv();
+  }
+  return { ...filterEnv(), ...mode };
+}
+
+// agents/codex.ts
+var CODEX_TARGETS = {
+  "linux-x64": "x86_64-unknown-linux-musl",
+  "linux-arm64": "aarch64-unknown-linux-musl",
+  "darwin-x64": "x86_64-apple-darwin",
+  "darwin-arm64": "aarch64-apple-darwin",
+  "win32-x64": "x86_64-pc-windows-msvc",
+  "win32-arm64": "aarch64-pc-windows-msvc"
+};
+async function installCodexCli() {
+  const target = CODEX_TARGETS[`${process.platform}-${process.arch}`];
+  if (!target) {
+    throw new Error(`the codex CLI ships no binary for ${process.platform}-${process.arch}`);
+  }
+  const binary = process.platform === "win32" ? "codex.exe" : "codex";
+  return await installFromNpmTarball({
+    packageName: "@openai/codex",
+    version: getDevDependencyVersion("@openai/codex"),
+    executablePath: `node_modules/@openai/codex-${process.platform}-${process.arch}/vendor/${target}/bin/${binary}`,
+    installDependencies: true
+  });
+}
+var CODEX_DISABLED_FEATURES = [
+  // browser / desktop control — network reach and arbitrary JS
+  "browser_use",
+  "browser_use_external",
+  "browser_use_full_cdp_access",
+  "computer_use",
+  "in_app_browser",
+  // third-party code loaded into the agent process
+  "plugins",
+  "remote_plugin",
+  "plugin_sharing",
+  "skill_mcp_dependency_install",
+  // lifecycle hooks run commands sourced from repo config, which a PR can edit
+  "hooks",
+  // connectors
+  "apps",
+  // ungated subagent fan-out (see the file header)
+  "multi_agent",
+  "multi_agent_v2"
+];
+var CODEX_SHELL_FEATURES = ["shell_tool", "unified_exec"];
+function tomlBool(entries, value2) {
+  return entries.map((name) => `${name} = ${value2}`).join("\n");
+}
+function securityOverrideFlags(params) {
+  const shellEnabled = params.ctx.payload.shell === "enabled";
+  const features = [
+    ...CODEX_DISABLED_FEATURES.map((name) => `${name}=false`),
+    ...CODEX_SHELL_FEATURES.map((name) => `${name}=${shellEnabled}`)
+  ];
+  return [
+    "-c",
+    `approval_policy=${JSON.stringify("never")}`,
+    "-c",
+    `sandbox_mode=${JSON.stringify(params.sandboxMode)}`,
+    // the sandbox's EXTENT has to be locked too, not just its mode: a repo
+    // setting `writable_roots = ["/"]` walked straight out of the checkout with
+    // `sandbox_mode` already flag-locked (measured — apply_patch wrote a file
+    // under $HOME).
+    "-c",
+    `sandbox_workspace_write.writable_roots=[${JSON.stringify(params.repoDir)}]`,
+    "-c",
+    "sandbox_workspace_write.network_access=true",
+    // our own MCP server, for a third time in the same class: a repo pointing
+    // `mcp_servers.pullfrog.url` at its own endpoint (measured — `codex mcp get`
+    // reported the repo's URL) turns every pullfrog tool call into an
+    // exfiltration channel, carrying diffs, file contents and cross-repo
+    // learnings to whoever it names.
+    "-c",
+    `mcp_servers.${pullfrogMcpName}.url=${JSON.stringify(params.mcpServerUrl)}`,
+    "-c",
+    `mcp_servers.${pullfrogMcpName}.${APPROVAL_MODE_KEY}=${JSON.stringify("approve")}`,
+    "-c",
+    `mcp_servers.${pullfrogMcpName}.required=true`,
+    "-c",
+    `mcp_servers.${pullfrogMcpName}.tool_timeout_sec=660`,
+    // `enabled` closes the silent-DoS variant: a repo setting it false would
+    // otherwise strip every GitHub tool and leave the agent narrating failure.
+    "-c",
+    `mcp_servers.${pullfrogMcpName}.enabled=true`,
+    // not a boundary, but the same override: a repo silently re-pointing the
+    // model spends the account's money on a pick it never made, and makes the
+    // "Using `…`" run footer a lie about what actually ran.
+    ...params.model ? ["-c", `model=${JSON.stringify(params.model)}`] : [],
+    ...params.effortRung ? ["-c", `model_reasoning_effort=${JSON.stringify(params.effortRung)}`] : [],
+    ...features.flatMap((entry) => ["-c", `features.${entry}`])
+  ];
+}
+var CODEX_EFFORTS = ["minimal", "low", "medium", "high", "xhigh"];
+function resolveCodexModel(ctx) {
+  const specifier = ctx.payload.proxyModel ?? ctx.resolvedModel;
+  if (!specifier) return void 0;
+  try {
+    if (getModelProvider(specifier) === "openai") return stripProviderPrefix(specifier);
+  } catch {
+  }
+  log2.warning(`\xBB ${specifier} isn't an OpenAI model \u2014 running codex on its own default instead`);
+  return void 0;
+}
+var APPROVAL_MODE_KEY = "default_tools_approval_mode";
+var APPROVE_TOOLS = `${APPROVAL_MODE_KEY} = "approve"`;
+function repoMcpApprovals(repoDir) {
+  const path4 = join7(repoDir, ".codex", "config.toml");
+  if (!existsSync4(path4)) return [];
+  const out = [];
+  let section = [];
+  let isServerTable = false;
+  function flush() {
+    if (section.length === 0) return;
+    const declared = section.some((line) => line.trimStart().startsWith(APPROVAL_MODE_KEY));
+    if (isServerTable && !declared) section.splice(1, 0, APPROVE_TOOLS);
+    out.push(...section, "");
+    section = [];
+  }
+  for (const line of readFileSync3(path4, "utf8").split("\n")) {
+    const header = line.trim().match(/^\[(?<key>[^\]]+)\]$/);
+    if (!header?.groups) {
+      if (section.length > 0) section.push(line);
+      continue;
+    }
+    flush();
+    const key = header.groups.key.trim();
+    if (!key.startsWith("mcp_servers.")) continue;
+    const name = key.slice("mcp_servers.".length).replace(/^"([^"]*)"/, "$1");
+    if (name === pullfrogMcpName || name.startsWith(`${pullfrogMcpName}.`)) continue;
+    isServerTable = !name.includes(".");
+    section = [line.trim()];
+  }
+  flush();
+  return out;
+}
+function warnIfNativeEditsUnavailable(ctx) {
+  if (process.platform !== "linux" || ctx.payload.shell !== "disabled") return;
+  log2.warning(
+    "\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."
+  );
+}
+function writeCodexConfig(params) {
+  const shellEnabled = params.ctx.payload.shell === "enabled";
+  const sandboxMode = params.ctx.payload.push === "disabled" ? "read-only" : "workspace-write";
+  const repoDir = process.cwd();
+  const config3 = [
+    "# written by pullfrog",
+    // "never" keeps the run non-interactive WITHOUT
+    // --dangerously-bypass-approvals-and-sandbox, which would also switch the
+    // sandbox off and let the native apply_patch tool write anywhere.
+    'approval_policy = "never"',
+    `sandbox_mode = ${JSON.stringify(sandboxMode)}`,
+    // matches opencode's `webfetch: "allow"` — research is part of the job and
+    // neither harness gates it on a permission.
+    'web_search = "live"',
+    ...params.model ? [`model = ${JSON.stringify(params.model)}`] : [],
+    ...params.effortRung ? [`model_reasoning_effort = ${JSON.stringify(params.effortRung)}`] : [],
+    "",
+    "[features]",
+    tomlBool(CODEX_DISABLED_FEATURES, false),
+    tomlBool(CODEX_SHELL_FEATURES, shellEnabled),
+    "",
+    "[sandbox_workspace_write]",
+    "network_access = true",
+    // the checkout, named explicitly rather than left to `workspace-write` to
+    // imply. does NOT fix the Linux native-write failure — nothing here does;
+    // see wiki/codex-agent.md "The Linux native-write blocker".
+    `writable_roots = [${JSON.stringify(repoDir)}]`,
+    "",
+    `[mcp_servers.${pullfrogMcpName}]`,
+    `url = ${JSON.stringify(params.ctx.mcpServerUrl)}`,
+    // codex's default MCP approval mode PROMPTS for anything it can't read as
+    // read-only, and a `codex exec` run has nobody to answer — the call comes
+    // back "user cancelled MCP tool call" and the agent silently accomplishes
+    // nothing. our own server is the trusted one; the boundary is what we
+    // register, not a second confirmation.
+    APPROVE_TOOLS,
+    // a run whose GitHub tools never registered can't do its job, so fail loudly
+    // rather than let the agent improvise without them.
+    "required = true",
+    // mirrors the opencode harness's 660s: `checkout_pr` runs a multi-minute
+    // fetch on large repos and enforces its own 600s deadline, so a shorter
+    // client abort turns a working checkout into a spurious tool error.
+    "tool_timeout_sec = 660",
+    "",
+    ...repoMcpApprovals(repoDir),
+    // 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
+    // `sandbox_mode`, `approval_policy`, `features` or `mcp_servers` — so a
+    // fork PR could ship a config re-enabling the native shell. Marking the
+    // checkout untrusted makes that layer load `disabled`, closing the class
+    // outright rather than key by key: `RawMcpServerConfig` alone has ~26
+    // fields and enumeration can never finish.
+    //
+    // It costs nothing. `codex exec`'s only startup gate is a GIT-REPO check
+    // (`exec/src/lib.rs:796` — `get_git_repo_root(...).is_none()`, whose error
+    // text unhelpfully says "Not inside a trusted directory"), so an untrusted
+    // checkout still runs. And the repo's own MCP servers survive, because
+    // `repoMcpApprovals` above copies them into OUR layer — which is why that
+    // copying exists at all.
+    //
+    // Measured both ways at 0.147.0: `trusted` → the repo's `model` won;
+    // `untrusted` → it did not, and the run proceeded normally.
+    `[projects.${JSON.stringify(repoDir)}]`,
+    'trust_level = "untrusted"',
+    ""
+  ].join("\n");
+  writeFileSync6(join7(params.codexHome, "config.toml"), config3, { mode: 384 });
+  log2.info(`\xBB codex config: sandbox=${sandboxMode}, nativeShell=${shellEnabled}`);
+}
+function toTodoWriteInput(item) {
+  return {
+    todos: item.items.map((todo, index) => ({
+      id: String(index),
+      content: todo.text,
+      status: todo.completed ? "completed" : "pending"
+    }))
+  };
+}
+async function runCodex2(params) {
+  const startTime = performance6.now();
+  const thinkingTimer = new ThinkingTimer();
+  const output = new TailBuffer(DEFAULT_MAX_RETAINED_BYTES);
+  const recentStderr = [];
+  let eventCount = 0;
+  let finalOutput = "";
+  let threadId;
+  let turnError = null;
+  let lastProviderError = null;
+  let stdoutBuffer = "";
+  const tokens = { input: 0, cacheRead: 0, output: 0 };
+  function buildUsage2() {
+    if (tokens.input === 0 && tokens.output === 0) return void 0;
+    return {
+      agent: "codex",
+      inputTokens: tokens.input,
+      outputTokens: tokens.output,
+      cacheReadTokens: tokens.cacheRead || void 0
+    };
+  }
+  function onItem(item, phase) {
+    switch (item.type) {
+      case "agent_message":
+        if (phase === "completed" && item.text.trim()) {
+          finalOutput = item.text.trim();
+          log2.box(finalOutput, { title: "Pullfrog" });
+        }
+        return;
+      case "reasoning":
+        if (phase === "completed" && item.text.trim()) {
+          log2.box(item.text.trim(), { title: "Pullfrog" });
+        }
+        return;
+      case "command_execution":
+        if (phase === "started") {
+          thinkingTimer.markToolCall();
+          log2.toolCall({ toolName: "shell", input: { command: item.command } });
+          return;
+        }
+        thinkingTimer.markToolResult();
+        log2.startGroup("shell output");
+        log2.info(item.aggregated_output || "");
+        log2.endGroup();
+        return;
+      case "mcp_tool_call":
+        if (phase === "started") {
+          thinkingTimer.markToolCall();
+          params.onToolUse?.({ toolName: item.tool, input: item.arguments });
+          log2.toolCall({ toolName: `${item.server}__${item.tool}`, input: item.arguments });
+          if (item.tool.includes("report_progress")) params.todoTracker?.cancel();
+          return;
+        }
+        thinkingTimer.markToolResult();
+        if (item.error) log2.info(`\xBB tool error: ${item.error.message}`);
+        return;
+      case "file_change":
+        if (phase === "completed") {
+          const paths = item.changes.map((c2) => `${c2.kind} ${c2.path}`).join(", ");
+          log2.info(`\xBB apply_patch (${item.status}): ${paths}`);
+        }
+        return;
+      case "web_search":
+        if (phase === "started") log2.toolCall({ toolName: "web_search", input: item.query });
+        return;
+      case "todo_list":
+        if (params.todoTracker?.enabled) params.todoTracker.update(toTodoWriteInput(item));
+        return;
+      case "error":
+        log2.info(`\xBB ${item.message}`);
+        return;
+      default:
+        item;
+    }
+  }
+  function onEvent(event) {
+    switch (event.type) {
+      case "thread.started":
+        threadId = event.thread_id;
+        return;
+      case "turn.completed":
+        tokens.input += event.usage.input_tokens ?? 0;
+        tokens.cacheRead += event.usage.cached_input_tokens ?? 0;
+        tokens.output += event.usage.output_tokens ?? 0;
+        return;
+      case "turn.failed":
+        turnError = event.error.message;
+        log2.info(`\xBB turn failed: ${turnError}`);
+        return;
+      case "error":
+        turnError = event.message;
+        log2.info(`\xBB codex error: ${event.message}`);
+        return;
+      case "item.started":
+        onItem(event.item, "started");
+        return;
+      case "item.completed":
+        onItem(event.item, "completed");
+        return;
+      case "item.updated":
+        if (event.item.type === "todo_list") onItem(event.item, "started");
+        return;
+      case "turn.started":
+        return;
+      default:
+        event;
+    }
+  }
+  try {
+    const result = await spawn3({
+      cmd: params.cliPath,
+      args: params.args,
+      cwd: params.cwd,
+      env: params.env,
+      activityTimeout: AGENT_ACTIVITY_TIMEOUT_MS,
+      onActivityTimeout: params.onActivityTimeout,
+      // stdin MUST be `ignore`: codex reads a piped stdin as an extra `<stdin>`
+      // prompt block and blocks on EOF, so an inherited pipe hangs the run
+      // before the first model call.
+      stdio: ["ignore", "pipe", "pipe"],
+      killGroup: true,
+      retain: "none",
+      onStdout: (chunk) => {
+        output.append(chunk);
+        markActivity();
+        stdoutBuffer += chunk;
+        const lines = stdoutBuffer.split("\n");
+        stdoutBuffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          let event;
+          try {
+            event = JSON.parse(trimmed);
+          } catch {
+            log2.debug(`\xBB non-JSON stdout line: ${trimmed.substring(0, 200)}`);
+            continue;
+          }
+          eventCount++;
+          log2.debug(JSON.stringify(event, null, 2));
+          const idleMs = getIdleMs();
+          if (idleMs > 1e4) {
+            log2.info(
+              `\xBB no activity for ${(idleMs / 1e3).toFixed(1)}s (${eventCount} events processed so far)`
+            );
+          }
+          markActivity();
+          onEvent(event);
+        }
+      },
+      onStderr: (chunk) => {
+        const trimmed = chunk.trim();
+        if (!trimmed) return;
+        recentStderr.push(trimmed);
+        if (recentStderr.length > MAX_STDERR_LINES) recentStderr.shift();
+        const match3 = findProviderErrorMatch(trimmed);
+        if (match3) {
+          lastProviderError = match3.label;
+          log2.info(`\xBB provider error detected (${match3.label}): ${match3.excerpt}`);
+        } else {
+          log2.debug(trimmed);
+        }
+      }
+    });
+    const duration4 = performance6.now() - startTime;
+    log2.info(`\xBB codex completed in ${Math.round(duration4)}ms with exit code ${result.exitCode}`);
+    const usage = buildUsage2();
+    if (usage) {
+      logTokenTable({
+        input: tokens.input - tokens.cacheRead,
+        cacheRead: tokens.cacheRead,
+        cacheWrite: 0,
+        output: tokens.output
+      });
+    }
+    if (result.exitCode !== 0 || turnError) {
+      const stderrSnapshot = recentStderr.join("\n");
+      const error52 = turnError || stderrSnapshot || lastProviderError && `provider error: ${lastProviderError}` || `unknown error - no output from Codex CLI (exit ${result.exitCode})`;
+      log2.error(`codex exited with code ${result.exitCode}: ${error52}`);
+      return { success: false, output: finalOutput || output.toString(), error: error52, usage, threadId };
+    }
+    return { success: true, output: finalOutput || output.toString(), usage, threadId };
+  } catch (error52) {
+    const duration4 = performance6.now() - startTime;
+    const message = error52 instanceof Error ? error52.message : String(error52);
+    const isActivityTimeout = error52 instanceof SpawnTimeoutError && error52.code === SPAWN_ACTIVITY_TIMEOUT_CODE;
+    const diagnosis = lastProviderError ? `likely cause: ${lastProviderError}` : eventCount === 0 ? "codex produced 0 stdout events - check if the API is reachable" : `${eventCount} events were processed before the hang`;
+    log2.info(
+      `\xBB codex ${isActivityTimeout ? "hung" : "failed"} after ${(duration4 / 1e3).toFixed(1)}s: ${message}`
+    );
+    log2.info(`\xBB diagnosis: ${diagnosis}`);
+    if (recentStderr.length > 0) log2.info(`\xBB recent stderr:
+${recentStderr.join("\n")}`);
+    return {
+      success: false,
+      output: finalOutput || output.toString(),
+      error: `${message} [${diagnosis}]`,
+      usage: buildUsage2(),
+      threadId
+    };
+  }
+}
+var codex = agent({
+  name: "codex",
+  install: installCodexCli,
+  run: async (ctx) => {
+    const cliPath = await installCodexCli();
+    warnIfNativeEditsUnavailable(ctx);
+    const codexHomeAuth = installCodexHome();
+    const codexHome = codexHomeAuth?.codexHome ?? join7(ctx.tmpdir, ".codex");
+    mkdirSync6(codexHome, { recursive: true });
+    const effort = resolveRunEffort(ctx);
+    if (effort.rung && !CODEX_EFFORTS.includes(effort.rung)) {
+      log2.warning(`\xBB effort ${effort.rung} not sent \u2014 codex doesn't accept that level`);
+    }
+    writeCodexConfig({
+      ctx,
+      codexHome,
+      model: resolveCodexModel(ctx),
+      effortRung: effort.rung && CODEX_EFFORTS.includes(effort.rung) ? effort.rung : void 0
+    });
+    if (codexHomeAuth) {
+      core2.saveState(
+        "codex_writeback",
+        JSON.stringify({
+          apiToken: ctx.apiToken,
+          authPath: codexHomeAuth.authPath,
+          originalRefresh: codexHomeAuth.originalRefresh
+        })
+      );
+    }
+    const baseEnv = ctx.payload.shell === "enabled" ? process.env : filterEnv();
+    const env2 = {
+      ...baseEnv,
+      CODEX_HOME: codexHome,
+      PWD: process.cwd()
+    };
+    delete env2.CODEX_API_KEY;
+    if (codexHomeAuth) {
+      delete env2.OPENAI_API_KEY;
+    } else if (process.env.OPENAI_API_KEY) {
+      env2.CODEX_API_KEY = process.env.OPENAI_API_KEY;
+    }
+    const securityFlags = securityOverrideFlags({
+      ctx,
+      sandboxMode: ctx.payload.push === "disabled" ? "read-only" : "workspace-write",
+      repoDir: process.cwd(),
+      mcpServerUrl: ctx.mcpServerUrl,
+      model: resolveCodexModel(ctx),
+      effortRung: effort.rung && CODEX_EFFORTS.includes(effort.rung) ? effort.rung : void 0
+    });
+    const runnerArgs = { cliPath, cwd: process.cwd(), env: env2, todoTracker: ctx.todoTracker };
+    const initial = await runCodex2({
+      ...runnerArgs,
+      args: [...securityFlags, "exec", "--json", ctx.instructions.full],
+      onActivityTimeout: ctx.onActivityTimeout,
+      onToolUse: ctx.onToolUse
+    });
+    const result = await runPostRunRetryLoop({
+      ctx,
+      initialResult: initial,
+      initialUsage: initial.usage,
+      reflectionPrompt: buildReflectionPrompt(ctx.toolState),
+      // a resume needs the thread codex recorded. without one there is nothing
+      // to continue, and `resume --last` would be worse than not resuming: it
+      // picks the newest recorded session in this cwd, which on a self-hosted
+      // runner with a shared CODEX_HOME is somebody else's run.
+      canResume: (r2) => r2.threadId !== void 0,
+      resume: async (c2) => runCodex2({
+        ...runnerArgs,
+        args: [
+          ...securityFlags,
+          "exec",
+          "resume",
+          "--json",
+          c2.previousResult.threadId ?? "",
+          c2.prompt
+        ]
+      })
+    });
+    if (result.success) {
+      await ctx.todoTracker?.flush();
+    } else {
+      ctx.todoTracker?.cancel();
+    }
+    return result;
+  }
+});
+
+// agents/opencode.ts
+var core3 = __toESM(require_core(), 1);
+import { spawn as nodeSpawn2 } from "node:child_process";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join8 } from "node:path";
+import { performance as performance7 } from "node:perf_hooks";
+
 // node_modules/.pnpm/@opencode-ai+sdk@1.18.5/node_modules/@opencode-ai/sdk/dist/v2/gen/core/serverSentEvents.gen.js
 var createSseClient = ({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url: url4, ...options }) => {
   let lastEventId;
@@ -114885,71 +115640,6 @@ var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 // agents/opencode.ts
 var import_undici = __toESM(require_undici2(), 1);
 
-// utils/codexHome.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir2, userInfo } from "node:os";
-import { join as join6 } from "node:path";
-var CODEX_AUTH_ENV = "CODEX_AUTH_JSON";
-var PULLFROG_DATA_DIR = "/var/lib/pullfrog";
-function installCodexAuth() {
-  const raw2 = process.env[CODEX_AUTH_ENV];
-  if (!raw2) return null;
-  const body = parseCodexAuthBody(raw2);
-  if (!body) {
-    log2.warning(`\xBB ${CODEX_AUTH_ENV} present but malformed; ignoring`);
-    return null;
-  }
-  const expiresMs = decodeJwtExpMs(body.tokens.access_token) ?? 0;
-  const xdgDataHome = resolveDataHome();
-  const opencodeDir = join6(xdgDataHome, "opencode");
-  const authPath = join6(opencodeDir, "auth.json");
-  const opencodeAuth = {
-    openai: {
-      type: "oauth",
-      refresh: body.tokens.refresh_token,
-      access: body.tokens.access_token,
-      expires: expiresMs,
-      ...body.tokens.account_id ? { accountId: body.tokens.account_id } : {}
-    }
-  };
-  mkdirSync5(opencodeDir, { recursive: true });
-  writeFileSync5(authPath, `${JSON.stringify(opencodeAuth, null, 2)}
-`, { mode: 384 });
-  process.env.XDG_DATA_HOME = xdgDataHome;
-  log2.info(`\xBB installed Codex auth at ${authPath}`);
-  return {
-    authPath,
-    xdgDataHome,
-    originalRefresh: body.tokens.refresh_token
-  };
-}
-function resolveDataHome() {
-  if (process.env.CI !== "true") return join6(homedir2(), ".local", "share");
-  bootstrapPullfrogDataDir();
-  return PULLFROG_DATA_DIR;
-}
-function bootstrapPullfrogDataDir() {
-  const user = userInfo().username;
-  let primaryGroup;
-  try {
-    primaryGroup = execFileSync4("id", ["-gn", user], { stdio: "pipe", encoding: "utf-8" }).trim();
-  } catch {
-    primaryGroup = user;
-  }
-  try {
-    execFileSync4("sudo", ["-n", "mkdir", "-p", PULLFROG_DATA_DIR], { stdio: "pipe" });
-    execFileSync4("sudo", ["-n", "chown", `${user}:${primaryGroup}`, PULLFROG_DATA_DIR], {
-      stdio: "pipe"
-    });
-    execFileSync4("sudo", ["-n", "chmod", "700", PULLFROG_DATA_DIR], { stdio: "pipe" });
-  } catch (err) {
-    throw new Error(
-      `failed to bootstrap ${PULLFROG_DATA_DIR} (required for codex auth in CI): ${err instanceof Error ? err.message : String(err)}. the MCP shell's mount-namespace sandbox cannot protect the auth file when it lives under $HOME, and silently falling back would contradict the "three independent layers" claim in wiki/codex-auth.md. passwordless sudo is required for codex auth on this runner \u2014 either configure it, or remove CODEX_AUTH_JSON from the run.`
-    );
-  }
-}
-
 // utils/worktree.ts
 async function dirtyTrackedPaths(params = {}) {
   const result = await spawn3({
@@ -115217,6 +115907,30 @@ function openAICompatibleProvider(model) {
     }
   };
 }
+function azureProvider(model) {
+  const prefix = `${AZURE_PROVIDER}/`;
+  if (!model?.startsWith(prefix)) return {};
+  const deployment = model.slice(prefix.length);
+  return {
+    [AZURE_PROVIDER]: {
+      // always sent: opencode reads it as `Boolean(options?.useCompletionUrls)`,
+      // so `false` and absent are the same, and the deep merge keeps the native
+      // loader's `resourceName` either way.
+      options: {
+        useCompletionUrls: process.env[AZURE_USE_CHAT_COMPLETIONS_ENV]?.trim() === "true"
+      },
+      models: {
+        [deployment]: {
+          name: deployment,
+          limit: {
+            context: Number(process.env[AZURE_CONTEXT_ENV]),
+            output: Number(process.env[AZURE_MAX_OUTPUT_ENV])
+          }
+        }
+      }
+    }
+  };
+}
 var KIMI_ENFORCERLESS_PROVIDERS = ["siliconflow", "together"];
 function kimiOpenRouterProviderOverrides() {
   return Object.fromEntries(
@@ -115308,7 +116022,8 @@ function buildSecurityConfig(ctx, model) {
     // see opencodeShared.ts.
     provider: {
       openrouter: { models: kimiOpenRouterProviderOverrides() },
-      ...openAICompatibleProvider(model)
+      ...openAICompatibleProvider(model),
+      ...azureProvider(model)
     }
   };
   if (model) {
@@ -115476,7 +116191,7 @@ function isModelOutput(ctx, part) {
 }
 async function dispatchEvent(ctx, event) {
   if (event.type === "message.part.updated") {
-    ctx.lastEventAt = performance6.now();
+    ctx.lastEventAt = performance7.now();
     if (isModelOutput(ctx, event.properties.part)) ctx.sawModelOutput = true;
     await onPartUpdated(ctx, event.properties.part);
     return;
@@ -115543,7 +116258,7 @@ async function onToolPart(ctx, part, label, isOrchestrator) {
   if (toolName === "task" && status === "running" && isOrchestrator && !ctx.taskDispatchByCallID.has(toolId)) {
     const input = part.state.input ?? {};
     const dispatched = ctx.labeler.recordTaskDispatch(input);
-    ctx.taskDispatchByCallID.set(toolId, { label: dispatched, startedAt: performance6.now() });
+    ctx.taskDispatchByCallID.set(toolId, { label: dispatched, startedAt: performance7.now() });
     log2.info(
       `\xBB dispatching subagent: ${dispatched}` + (input.subagent_type ? ` (subagent_type=${input.subagent_type})` : "")
     );
@@ -115573,7 +116288,7 @@ function processTerminalToolPart(ctx, part, label, isOrchestrator) {
   if (toolName === "task") {
     const dispatch = ctx.taskDispatchByCallID.get(toolId);
     if (dispatch) {
-      const dur = ((performance6.now() - dispatch.startedAt) / 1e3).toFixed(1);
+      const dur = ((performance7.now() - dispatch.startedAt) / 1e3).toFixed(1);
       const outputStr = state.status === "completed" ? state.output : "";
       const preview = typeof outputStr === "string" && outputStr.length > 120 ? `${outputStr.slice(0, 120)}\u2026` : outputStr;
       log2.info(
@@ -115616,7 +116331,7 @@ function withLabel(label, message) {
   return label === ORCHESTRATOR_LABEL ? message : formatWithLabel(label, message);
 }
 async function runPromptTurn(ctx, params) {
-  const start = performance6.now();
+  const start = performance7.now();
   const turnStartMs = Date.now();
   ctx.currentTurn = newTurn();
   const turn = ctx.currentTurn;
@@ -115650,7 +116365,7 @@ async function runPromptTurn(ctx, params) {
   } catch (err) {
     networkError = err instanceof Error ? err.message : String(err);
   }
-  const durationMs = performance6.now() - start;
+  const durationMs = performance7.now() - start;
   const aggregatedUsage = await aggregateTurnUsage(ctx, turnStartMs);
   const usage = aggregatedUsage ?? buildUsage(turn, assistant);
   const finalText = turn.finalText || extractTextFromParts(returnedParts) || "";
@@ -115804,7 +116519,7 @@ function startInnerActivityWatchdog(params) {
   let fired = false;
   const id = setInterval(() => {
     if (fired) return;
-    const idleMs = performance6.now() - params.ctx.lastEventAt;
+    const idleMs = performance7.now() - params.ctx.lastEventAt;
     const budgetMs = params.ctx.sawModelOutput ? params.timeoutMs : AGENT_FIRST_EVENT_TIMEOUT_MS;
     if (idleMs <= budgetMs) return;
     fired = true;
@@ -115843,12 +116558,12 @@ var opencode = agent({
     const model = vertexModel ?? (isBedrockRoute ? `amazon-bedrock/${rawModel}` : rawModel);
     const homeEnv = {
       HOME: ctx.tmpdir,
-      XDG_CONFIG_HOME: join7(ctx.tmpdir, ".config")
+      XDG_CONFIG_HOME: join8(ctx.tmpdir, ".config")
     };
-    const opencodePluginDir = join7(homeEnv.XDG_CONFIG_HOME, "opencode", "plugin");
-    mkdirSync6(opencodePluginDir, { recursive: true });
-    writeFileSync6(
-      join7(opencodePluginDir, PULLFROG_OPENCODE_GATE_PLUGIN_FILENAME),
+    const opencodePluginDir = join8(homeEnv.XDG_CONFIG_HOME, "opencode", "plugin");
+    mkdirSync7(opencodePluginDir, { recursive: true });
+    writeFileSync7(
+      join8(opencodePluginDir, PULLFROG_OPENCODE_GATE_PLUGIN_FILENAME),
       buildOpencodeSubagentGateSource(ctx.subagentDeniedTools)
     );
     const agentBrowserVersion = getDevDependencyVersion("agent-browser");
@@ -115879,12 +116594,13 @@ var opencode = agent({
     if (codexAuth) {
       env2.XDG_DATA_HOME = codexAuth.xdgDataHome;
       delete env2.OPENAI_API_KEY;
-      core2.saveState(
+      core3.saveState(
         "codex_writeback",
         JSON.stringify({
           apiToken: ctx.apiToken,
           authPath: codexAuth.authPath,
-          originalRefresh: codexAuth.originalRefresh
+          originalRefresh: codexAuth.originalRefresh,
+          originalIdToken: codexAuth.originalIdToken
         })
       );
     }
@@ -115938,7 +116654,7 @@ var opencode = agent({
         onToolUse: ctx.onToolUse,
         currentTurn: null,
         eventCount: 0,
-        lastEventAt: performance6.now(),
+        lastEventAt: performance7.now(),
         sawModelOutput: false,
         promptMessageID: void 0,
         taskDispatchByCallID: /* @__PURE__ */ new Map(),
@@ -116048,7 +116764,7 @@ async function runTurnGuarded(ctx, fn2) {
 }
 
 // agents/index.ts
-var agents = { claude, opencode };
+var agents = { claude, codex, opencode };
 
 // node_modules/.pnpm/@ark+util@0.56.0/node_modules/@ark/util/out/arrays.js
 var liftArray = (data) => Array.isArray(data) ? data : [data];
@@ -136380,7 +137096,7 @@ var require_core$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   const id_1 = require_id2();
   const ref_1 = require_ref2();
-  const core11 = [
+  const core12 = [
     "$schema",
     "$id",
     "$defs",
@@ -136390,7 +137106,7 @@ var require_core$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
     id_1.default,
     ref_1.default
   ];
-  exports.default = core11;
+  exports.default = core12;
 }));
 var require_limitNumber2 = /* @__PURE__ */ __commonJSMin(((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -138528,7 +139244,7 @@ var require_json_schema_2019_09 = /* @__PURE__ */ __commonJSMin(((exports) => {
   const metaSchema = require_schema$1();
   const applicator = require_applicator$1();
   const content = require_content$1();
-  const core11 = require_core$1();
+  const core12 = require_core$1();
   const format2 = require_format3();
   const metadata = require_meta_data$1();
   const validation = require_validation$1();
@@ -138538,7 +139254,7 @@ var require_json_schema_2019_09 = /* @__PURE__ */ __commonJSMin(((exports) => {
       metaSchema,
       applicator,
       content,
-      core11,
+      core12,
       with$data(this, format2),
       metadata,
       with$data(this, validation)
@@ -138978,7 +139694,7 @@ var require_json_schema_2020_12 = /* @__PURE__ */ __commonJSMin(((exports) => {
   const applicator = require_applicator2();
   const unevaluated = require_unevaluated();
   const content = require_content();
-  const core11 = require_core4();
+  const core12 = require_core4();
   const format2 = require_format_annotation();
   const metadata = require_meta_data();
   const validation = require_validation2();
@@ -138989,7 +139705,7 @@ var require_json_schema_2020_12 = /* @__PURE__ */ __commonJSMin(((exports) => {
       applicator,
       unevaluated,
       content,
-      core11,
+      core12,
       with$data(this, format2),
       metadata,
       with$data(this, validation)
@@ -150431,7 +151147,7 @@ var require_core$22 = /* @__PURE__ */ __commonJSMin2(((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   const id_1 = require_id3();
   const ref_1 = require_ref3();
-  const core11 = [
+  const core12 = [
     "$schema",
     "$id",
     "$defs",
@@ -150441,7 +151157,7 @@ var require_core$22 = /* @__PURE__ */ __commonJSMin2(((exports) => {
     id_1.default,
     ref_1.default
   ];
-  exports.default = core11;
+  exports.default = core12;
 }));
 var require_limitNumber3 = /* @__PURE__ */ __commonJSMin2(((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -152579,7 +153295,7 @@ var require_json_schema_2019_092 = /* @__PURE__ */ __commonJSMin2(((exports) =>
   const metaSchema = require_schema$12();
   const applicator = require_applicator$12();
   const content = require_content$12();
-  const core11 = require_core$12();
+  const core12 = require_core$12();
   const format2 = require_format4();
   const metadata = require_meta_data$12();
   const validation = require_validation$12();
@@ -152589,7 +153305,7 @@ var require_json_schema_2019_092 = /* @__PURE__ */ __commonJSMin2(((exports) =>
       metaSchema,
       applicator,
       content,
-      core11,
+      core12,
       with$data(this, format2),
       metadata,
       with$data(this, validation)
@@ -153029,7 +153745,7 @@ var require_json_schema_2020_122 = /* @__PURE__ */ __commonJSMin2(((exports) =>
   const applicator = require_applicator3();
   const unevaluated = require_unevaluated2();
   const content = require_content2();
-  const core11 = require_core5();
+  const core12 = require_core5();
   const format2 = require_format_annotation2();
   const metadata = require_meta_data2();
   const validation = require_validation3();
@@ -153040,7 +153756,7 @@ var require_json_schema_2020_122 = /* @__PURE__ */ __commonJSMin2(((exports) =>
       applicator,
       unevaluated,
       content,
-      core11,
+      core12,
       with$data(this, format2),
       metadata,
       with$data(this, validation)
@@ -173001,123 +173717,8 @@ var pbkdf2Async = promisify(pbkdf2);
 
 // utils/browser.ts
 import { execFileSync as execFileSync5, spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
-
-// utils/secrets.ts
-var SENSITIVE_PATTERNS = [
-  /_KEY$/i,
-  /_SECRET$/i,
-  /_TOKEN$/i,
-  /_PASSWORD$/i,
-  /_CREDENTIAL$/i
-];
-function isSensitiveEnvName(key) {
-  return SENSITIVE_PATTERNS.some((p) => p.test(key));
-}
-var SAFE_ENV_PREFIXES = ["GITHUB_", "RUNNER_", "JAVA_HOME_", "GOROOT_"];
-var SAFE_ENV_NAMES = /* @__PURE__ */ new Set([
-  // system
-  "CI",
-  "HOME",
-  "LANG",
-  "LOGNAME",
-  "PATH",
-  "SHELL",
-  "SHLVL",
-  "TERM",
-  "TMPDIR",
-  "TZ",
-  "USER",
-  "XDG_CONFIG_HOME",
-  "XDG_RUNTIME_DIR",
-  "DEBIAN_FRONTEND",
-  // runner image toolchain
-  "ACCEPT_EULA",
-  "AGENT_TOOLSDIRECTORY",
-  "ANDROID_HOME",
-  "ANDROID_NDK",
-  "ANDROID_NDK_HOME",
-  "ANDROID_NDK_LATEST_HOME",
-  "ANDROID_NDK_ROOT",
-  "ANDROID_SDK_ROOT",
-  "ANT_HOME",
-  "AZURE_EXTENSION_DIR",
-  "BOOTSTRAP_HASKELL_NONINTERACTIVE",
-  "CHROME_BIN",
-  "CHROMEWEBDRIVER",
-  "CONDA",
-  "DOTNET_MULTILEVEL_LOOKUP",
-  "DOTNET_NOLOGO",
-  "DOTNET_SKIP_FIRST_TIME_EXPERIENCE",
-  "EDGEWEBDRIVER",
-  "GECKOWEBDRIVER",
-  "GHCUP_INSTALL_BASE_PREFIX",
-  "GRADLE_HOME",
-  "JAVA_HOME",
-  "HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS",
-  "HOMEBREW_NO_AUTO_UPDATE",
-  "ImageOS",
-  "ImageVersion",
-  "NVM_DIR",
-  "PIPX_BIN_DIR",
-  "PIPX_HOME",
-  "PSModulePath",
-  "SELENIUM_JAR_PATH",
-  "SGX_AESM_ADDR",
-  "SWIFT_PATH",
-  "VCPKG_INSTALLATION_ROOT"
-]);
-var _userAllowlist = null;
-function setEnvAllowlist(raw2) {
-  const names = raw2.split("\n").map((line) => line.trim()).filter(Boolean);
-  _userAllowlist = new Set(names);
-}
-function isSafeEnvVar(key) {
-  if (SAFE_ENV_NAMES.has(key)) return true;
-  return SAFE_ENV_PREFIXES.some((p) => key.startsWith(p));
-}
-var WORKFLOW_COMMAND_ENV_NAMES = [
-  "GITHUB_ENV",
-  "GITHUB_PATH",
-  "GITHUB_OUTPUT",
-  "GITHUB_STATE",
-  "GITHUB_STEP_SUMMARY",
-  // dropping the five paths above but keeping RUNNER_TEMP would be theatre:
-  // the file-command files live in `$RUNNER_TEMP/_runner_file_commands/`, so the
-  // directory is one `ls` away. nothing in the install path reads it (only our
-  // own leak-surface wipe in `setup.ts`, which runs in the parent), and package
-  // managers use TMPDIR.
-  "RUNNER_TEMP"
-];
-function filterEnvForUntrustedCode() {
-  const env2 = filterEnv();
-  for (const name of WORKFLOW_COMMAND_ENV_NAMES) delete env2[name];
-  return env2;
-}
-function filterEnv() {
-  const filtered = {};
-  for (const [key, value2] of Object.entries(process.env)) {
-    if (value2 === void 0) continue;
-    const userAllowed = _userAllowlist?.has(key) ?? false;
-    if (isSensitiveEnvName(key) && !userAllowed) continue;
-    if (isSafeEnvVar(key) || userAllowed) {
-      filtered[key] = value2;
-    }
-  }
-  return filtered;
-}
-function resolveEnv(mode) {
-  if (mode === "inherit") {
-    return process.env;
-  }
-  if (mode === "restricted" || mode === void 0) {
-    return filterEnv();
-  }
-  return { ...filterEnv(), ...mode };
-}
-
-// utils/browser.ts
 var CHROME_PATHS = ["/usr/bin/google-chrome-stable"];
 var systemChromePath;
 function findSystemChromePath() {
@@ -173125,7 +173726,7 @@ function findSystemChromePath() {
     return systemChromePath || void 0;
   }
   for (const p of CHROME_PATHS) {
-    if (existsSync4(p)) {
+    if (existsSync5(p)) {
       systemChromePath = p;
       log2.info(`found system chrome: ${p}`);
       return p;
@@ -173209,8 +173810,8 @@ function closeBrowserDaemon(toolState) {
 
 // mcp/checkout.ts
 import { createHash as createHash2 } from "node:crypto";
-import { statSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join14 } from "node:path";
+import { statSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join15 } from "node:path";
 
 // node_modules/.pnpm/@ark+schema@0.56.0/node_modules/@ark/schema/out/shared/errors.js
 var ArkError = class _ArkError extends CastableBase {
@@ -180682,8 +181283,8 @@ function ensureRepoState(toolState, init) {
 
 // utils/changeImpact.ts
 import { spawn as spawn4 } from "node:child_process";
-import { writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join8 } from "node:path";
+import { writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join9 } from "node:path";
 var MAX_CANDIDATES = 24;
 var MAX_ATOM_LENGTH = 128;
 var MAX_ATOMS = 12;
@@ -181030,8 +181631,8 @@ async function createChangeImpactArtifact(ctx, params) {
     headSha: params.headSha,
     lookupError: lookup2.error
   });
-  const path4 = join8(ctx.tmpdir, `pr-${params.pullNumber}-${params.headSha.slice(0, 7)}-impact.md`);
-  writeFileSync7(path4, artifact.content);
+  const path4 = join9(ctx.tmpdir, `pr-${params.pullNumber}-${params.headSha.slice(0, 7)}-impact.md`);
+  writeFileSync8(path4, artifact.content);
   return {
     path: path4,
     candidateCount: candidates.selected.length,
@@ -181283,8 +181884,8 @@ function readNumber(params) {
 // utils/gitAuth.ts
 import { execSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { readFileSync as readFileSync3, realpathSync, unlinkSync } from "node:fs";
-import { join as join9 } from "node:path";
+import { readFileSync as readFileSync4, realpathSync, unlinkSync } from "node:fs";
+import { join as join10 } from "node:path";
 
 // utils/shell.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
@@ -181345,7 +181946,7 @@ var TRANSIENT_AUTH_PATTERNS = [
 ];
 var gitBinary;
 function hashFile(path4) {
-  return createHash("sha256").update(readFileSync3(path4)).digest("hex");
+  return createHash("sha256").update(readFileSync4(path4)).digest("hex");
 }
 function resolveGit() {
   const whichPath = execSync("which git", { encoding: "utf-8" }).trim();
@@ -181374,7 +181975,7 @@ function resolveHooksDir(cwd, gitPath) {
     cwd,
     log: false
   }).trim();
-  const hooksDir = join9(commonDir, "hooks");
+  const hooksDir = join10(commonDir, "hooks");
   hooksDirCache.set(cwd, hooksDir);
   return hooksDir;
 }
@@ -181681,7 +182282,7 @@ function postProcessRangeDiff(raw2, contextLines = 3) {
 }
 
 // yes/index.ts
-import { performance as performance7 } from "node:perf_hooks";
+import { performance as performance8 } from "node:perf_hooks";
 import { setTimeout as sleep2 } from "node:timers/promises";
 
 // node_modules/.pnpm/lru-cache@11.5.2/node_modules/lru-cache/dist/esm/node/index.min.js
@@ -182396,14 +182997,14 @@ function _op(fn2, options) {
         `failed to create cache key${namePrefix ? ` for ${options.name}` : ""}: ${errorMessage}`
       );
     }
-    const startTime = performance7.now();
+    const startTime = performance8.now();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     log3.debug(`${namePrefix}[${timestamp}] cache lookup started`, { key });
     if (shouldCache && lruCache) {
       const cached4 = lruCache.get(key);
       if (cached4 !== void 0) {
         if (keyMap?.get(key) === void 0) keyMap?.set(key, input);
-        const runtime = performance7.now() - startTime;
+        const runtime = performance8.now() - startTime;
         log3.debug(`${namePrefix}[${timestamp}] cache hit (from lru)`, {
           key,
           runtime: `${Math.round(runtime)}ms`
@@ -182422,12 +183023,12 @@ function _op(fn2, options) {
     defaultCacheMiss(key);
     const retries = options.retries ?? [];
     let lastError;
-    const execStartTime = performance7.now();
+    const execStartTime = performance8.now();
     const promise2 = (async () => {
       for (let attempt = 0; attempt <= retries.length; attempt++) {
         try {
           const result = acceptsCtx ? await fn2(input, ctx) : await fn2(input);
-          const execRuntime2 = performance7.now() - execStartTime;
+          const execRuntime2 = performance8.now() - execStartTime;
           const skip = options.skipCache ? options.skipCache(result) : false;
           if (shouldCache && lruCache && result !== null && result !== void 0 && !skip) {
             lruCache.set(key, result);
@@ -182480,7 +183081,7 @@ function _op(fn2, options) {
           }
         }
       }
-      const execRuntime = performance7.now() - execStartTime;
+      const execRuntime = performance8.now() - execStartTime;
       log3.debug(`${namePrefix}[${timestamp}] function failed after all retries`, {
         key,
         runtime: `${Math.round(execRuntime)}ms`,
@@ -182545,13 +183146,13 @@ function _op(fn2, options) {
 
 // mcp/git.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join12 } from "node:path";
+import { writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join13 } from "node:path";
 
 // utils/apiCommit.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { lstat, readlink } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 var GITHUB_API = "https://api.github.com";
 var MAX_BLOB_BYTES = 30 * 1024 * 1024;
 var BLOB_UPLOAD_CONCURRENCY = 8;
@@ -182616,7 +183217,7 @@ async function assertApiCommittable(files) {
   const root = getRepoRoot();
   const attrs = $(
     "git",
-    ["check-attr", "filter", "-z", "--", ...present.map((p) => join10(root, p))],
+    ["check-attr", "filter", "-z", "--", ...present.map((p) => join11(root, p))],
     { log: false }
   );
   const parts = attrs.split("\0");
@@ -182628,7 +183229,7 @@ async function assertApiCommittable(files) {
     }
   }
   for (const path4 of present) {
-    const stat = await lstat(join10(root, path4));
+    const stat = await lstat(join11(root, path4));
     if (stat.isDirectory()) {
       throw new Error(
         `'${path4}' is a directory (nested repository or submodule?) \u2014 signed commits only support files and symlinks.`
@@ -182637,7 +183238,7 @@ async function assertApiCommittable(files) {
   }
 }
 async function createBlobEntry(params) {
-  const absPath = join10(params.repoRoot, params.path);
+  const absPath = join11(params.repoRoot, params.path);
   const stat = await lstat(absPath);
   if (stat.size > MAX_BLOB_BYTES) {
     throw new Error(
@@ -182814,10 +183415,10 @@ this usually means your local branch has commits that were never pushed \u2014 s
 }
 
 // utils/github.ts
-var core3 = __toESM(require_core(), 1);
+var core4 = __toESM(require_core(), 1);
 import { createSign } from "node:crypto";
 import { rename, writeFile } from "node:fs/promises";
-import { dirname as dirname3, join as join11 } from "node:path";
+import { dirname as dirname3, join as join12 } from "node:path";
 
 // node_modules/.pnpm/@octokit+plugin-throttling@11.0.5_@octokit+core@7.0.7/node_modules/@octokit/plugin-throttling/dist-bundle/index.js
 var import_light = __toESM(require_light(), 1);
@@ -187015,7 +187616,7 @@ async function fetchIdTokenFromStash(creds) {
     throw new Error("ID token response has no value field");
   }
   if (isGitHubActions) {
-    core3.setSecret(body.value);
+    core4.setSecret(body.value);
   }
   return body.value;
 }
@@ -187028,7 +187629,7 @@ function translateIdTokenError(error52) {
 var mintIdToken = op(
   async () => {
     try {
-      return await core3.getIDToken(OIDC_AUDIENCE);
+      return await core4.getIDToken(OIDC_AUDIENCE);
     } catch (error52) {
       throw translateIdTokenError(error52);
     }
@@ -187237,7 +187838,7 @@ function getGitHubUsageSummary() {
 }
 async function writeGitHubUsageSummaryToFile(path4) {
   const summary2 = getGitHubUsageSummary();
-  const tmpPath = join11(dirname3(path4), `.usage-summary-${process.pid}.tmp`);
+  const tmpPath = join12(dirname3(path4), `.usage-summary-${process.pid}.tmp`);
   await writeFile(tmpPath, JSON.stringify(summary2));
   await rename(tmpPath, path4);
 }
@@ -188389,8 +188990,8 @@ function countAhead(head, base, cwd) {
 function spillGitOutput(params) {
   const tempDir = process.env.PULLFROG_TEMP_DIR;
   if (!tempDir) throw new Error("PULLFROG_TEMP_DIR not set");
-  const outputPath = join12(tempDir, `git-${params.command}-${randomUUID3().slice(0, 8)}.txt`);
-  writeFileSync8(outputPath, params.output);
+  const outputPath = join13(tempDir, `git-${params.command}-${randomUUID3().slice(0, 8)}.txt`);
+  writeFileSync9(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(
@@ -189904,9 +190505,9 @@ async function reportReviewNodeId(ctx, params) {
 import { execFileSync as execFileSync7, execSync as execSync2 } from "node:child_process";
 import { mkdtempSync as mkdtempSync2, readdirSync, realpathSync as realpathSync2, unlinkSync as unlinkSync2 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function createTempDirectory() {
-  const sharedTempDir = mkdtempSync2(join13(tmpdir3(), "pullfrog-"));
+  const sharedTempDir = mkdtempSync2(join14(tmpdir3(), "pullfrog-"));
   process.env.PULLFROG_TEMP_DIR = sharedTempDir;
   log2.info(`\xBB created temp dir at ${sharedTempDir}`);
   return sharedTempDir;
@@ -189951,13 +190552,13 @@ function wipeRunnerLeakSurface() {
       return [];
     }
   };
-  const fileCommandsDir = join13(runnerTemp, "_runner_file_commands");
+  const fileCommandsDir = join14(runnerTemp, "_runner_file_commands");
   for (const entry of listDir(fileCommandsDir)) {
-    tryUnlink(join13(fileCommandsDir, entry));
+    tryUnlink(join14(fileCommandsDir, entry));
   }
   for (const entry of listDir(runnerTemp)) {
     if (entry.endsWith(".sh") || /^git-credentials-.*\.config$/.test(entry)) {
-      tryUnlink(join13(runnerTemp, entry));
+      tryUnlink(join14(runnerTemp, entry));
     }
   }
   if (wiped.length > 0) {
@@ -190507,11 +191108,11 @@ function CheckoutPrTool(ctx) {
         headSha: checkoutSha
       });
       if (incremental.status === "ok") {
-        incrementalDiffPath = join14(
+        incrementalDiffPath = join15(
           tempDir,
           `pr-${pull_number}-${beforeShort}-${headShort}-incremental.diff`
         );
-        writeFileSync9(incrementalDiffPath, incremental.diff);
+        writeFileSync10(incrementalDiffPath, incremental.diff);
         log2.info(
           `\xBB incremental diff computed (${incremental.diff.length} bytes) \u2192 ${incrementalDiffPath}`
         );
@@ -190524,8 +191125,8 @@ function CheckoutPrTool(ctx) {
     const diffPreview = formatResult.content.split("\n").slice(0, 100).join("\n");
     log2.debug(`formatted diff preview (first 100 lines):
 ${diffPreview}`);
-    const diffPath = join14(tempDir, `pr-${pull_number}-${headShort}.diff`);
-    writeFileSync9(diffPath, formatResult.content);
+    const diffPath = join15(tempDir, `pr-${pull_number}-${headShort}.diff`);
+    writeFileSync10(diffPath, formatResult.content);
     log2.debug(`wrote diff to ${diffPath} (${formatResult.content.length} bytes)`);
     primary.diffCoverage = createDiffCoverageState({
       diffPath,
@@ -190682,8 +191283,8 @@ ${dirty}`
 }
 
 // mcp/checkSuite.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join15 } from "node:path";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join16 } from "node:path";
 var GetCheckSuiteLogs = type({
   check_suite_id: type.number.describe("the id from check_suite.id")
 });
@@ -190779,8 +191380,8 @@ function GetCheckSuiteLogsTool(ctx) {
       if (!tempDir) {
         throw new Error("PULLFROG_TEMP_DIR not set");
       }
-      const logsDir = join15(tempDir, "ci-logs");
-      mkdirSync7(logsDir, { recursive: true });
+      const logsDir = join16(tempDir, "ci-logs");
+      mkdirSync8(logsDir, { recursive: true });
       const jobResults = [];
       for (const run4 of failedRuns) {
         const jobs = await ctx.octokit.paginate(ctx.octokit.rest.actions.listJobsForWorkflowRun, {
@@ -190806,8 +191407,8 @@ function GetCheckSuiteLogsTool(ctx) {
               );
             }
             const logsText = await logsResult.text();
-            const logPath = join15(logsDir, `job-${job.id}.log`);
-            writeFileSync10(logPath, logsText);
+            const logPath = join16(logsDir, `job-${job.id}.log`);
+            writeFileSync11(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({
@@ -190855,8 +191456,8 @@ function GetCheckSuiteLogsTool(ctx) {
 }
 
 // mcp/commitInfo.ts
-import { writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join16 } from "node:path";
+import { writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join17 } from "node:path";
 var CommitInfo = type({
   sha: type.string.describe("the commit SHA (full or abbreviated) to fetch")
 });
@@ -190880,8 +191481,8 @@ function CommitInfoTool(ctx) {
           "PULLFROG_TEMP_DIR not set - get_commit_info must run in pullfrog action context"
         );
       }
-      const diffFile = join16(tempDir, `commit-${sha.slice(0, 7)}.diff`);
-      writeFileSync11(diffFile, formatResult.content);
+      const diffFile = join17(tempDir, `commit-${sha.slice(0, 7)}.diff`);
+      writeFileSync12(diffFile, formatResult.content);
       log2.debug(`wrote commit diff to ${diffFile} (${formatResult.content.length} bytes)`);
       return {
         sha: data.sha,
@@ -191014,17 +191615,17 @@ function ReopenCurrentTool(ctx) {
 }
 
 // prep/index.ts
-import { performance as performance8 } from "node:perf_hooks";
+import { performance as performance9 } from "node:perf_hooks";
 
 // prep/installNodeDependencies.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join19 } from "node:path";
 
 // utils/packageManager.ts
 var import_semver2 = __toESM(require_semver2(), 1);
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { mkdir, readFile as readFile2 } from "node:fs/promises";
-import { delimiter, join as join17 } from "node:path";
+import { delimiter, join as join18 } from "node:path";
 var SUPPORTED_NAMES = ["npm", "pnpm", "yarn", "bun"];
 var COREPACK_MANAGED = ["pnpm", "yarn"];
 function isSupported(name) {
@@ -191062,8 +191663,8 @@ function parseDevEnginesField(field) {
   };
 }
 async function resolvePackageManagerSpec(cwd) {
-  const pkgPath = join17(cwd, "package.json");
-  if (!existsSync5(pkgPath)) return null;
+  const pkgPath = join18(cwd, "package.json");
+  if (!existsSync6(pkgPath)) return null;
   let pkg;
   try {
     pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
@@ -191121,7 +191722,7 @@ async function currentVersion(name) {
   return result.stdout.trim();
 }
 function packageManagerBinDir(tmpdir4) {
-  return join17(tmpdir4, "pm-bin");
+  return join18(tmpdir4, "pm-bin");
 }
 async function ensurePackageManager(params) {
   const spec = params.spec;
@@ -191184,7 +191785,7 @@ async function installFallback(name, installSpec) {
   });
   if (result.exitCode !== 0) return result.stderr || `failed to install ${name}`;
   if (name === "deno") {
-    const denoPath = join17(process.env.HOME || "", ".deno", "bin");
+    const denoPath = join18(process.env.HOME || "", ".deno", "bin");
     process.env.PATH = `${denoPath}:${process.env.PATH}`;
   }
   log2.info(`\xBB installed ${name}`);
@@ -191217,8 +191818,8 @@ async function isCommandAvailable2(command) {
 var installNodeDependencies = {
   name: "installNodeDependencies",
   shouldRun: () => {
-    const packageJsonPath = join18(process.cwd(), "package.json");
-    return existsSync6(packageJsonPath);
+    const packageJsonPath = join19(process.cwd(), "package.json");
+    return existsSync7(packageJsonPath);
   },
   run: async (options) => {
     const declared = await resolvePackageManagerSpec(process.cwd());
@@ -191312,14 +191913,14 @@ ${errorMessage}`]
 };
 
 // prep/installPythonDependencies.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
+import { join as join20 } from "node:path";
 function declaresBuildSystem(path4) {
-  return /^\s*\[\s*build-system\s*\]/m.test(readFileSync4(path4, "utf8"));
+  return /^\s*\[\s*build-system\s*\]/m.test(readFileSync5(path4, "utf8"));
 }
 function configApplies(config3, cwd) {
-  const path4 = join19(cwd, config3.file);
-  return existsSync7(path4) && (config3.applies?.(path4) ?? true);
+  const path4 = join20(cwd, config3.file);
+  return existsSync8(path4) && (config3.applies?.(path4) ?? true);
 }
 var PYTHON_CONFIGS = [
   {
@@ -191473,7 +192074,7 @@ var installPythonDependencies = {
 var prepSteps = [installNodeDependencies, installPythonDependencies];
 async function runPrepPhase(options) {
   log2.debug("\xBB starting prep phase...");
-  const startTime = performance8.now();
+  const startTime = performance9.now();
   const results = [];
   const preDirty = await dirtyTrackedPaths();
   try {
@@ -191495,7 +192096,7 @@ async function runPrepPhase(options) {
   } finally {
     await restoreDirtiedSince({ before: preDirty, actor: "prep" });
   }
-  const totalDurationMs = performance8.now() - startTime;
+  const totalDurationMs = performance9.now() - startTime;
   log2.debug(`\xBB prep phase completed (${Math.round(totalDurationMs)}ms)`);
   return results;
 }
@@ -191640,15 +192241,15 @@ function AwaitDependencyInstallationTool(ctx) {
 }
 
 // mcp/gh.ts
-import { mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join21 } from "node:path";
+import { mkdirSync as mkdirSync9 } from "node:fs";
+import { join as join22 } from "node:path";
 
 // mcp/shell.ts
 import { spawn as spawn5, spawnSync as spawnSync6 } from "node:child_process";
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { closeSync, openSync, writeFileSync as writeFileSync12 } from "node:fs";
+import { closeSync, openSync, writeFileSync as writeFileSync13 } from "node:fs";
 import { userInfo as userInfo2 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 import { setTimeout as sleep3 } from "node:timers/promises";
 var ShellParams = type({
   command: "string",
@@ -191911,8 +192512,8 @@ ${spawnError}` : spawnError;
 }
 function capOutput(output) {
   if (output.length <= MAX_OUTPUT_CHARS) return output;
-  const fullPath = join20(getTempDir(), `shell-${randomUUID4().slice(0, 8)}.log`);
-  writeFileSync12(fullPath, output);
+  const fullPath = join21(getTempDir(), `shell-${randomUUID4().slice(0, 8)}.log`);
+  writeFileSync13(fullPath, output);
   const elided = output.length - MAX_OUTPUT_CHARS;
   return `... [${elided} chars truncated; full output saved to ${fullPath}] ...
 ${output.slice(-MAX_OUTPUT_CHARS)}`;
@@ -191966,8 +192567,8 @@ Do NOT use this tool for git commands \u2014 use the dedicated git tools instead
       if (params.background) {
         const tempDir = getTempDir();
         const handle = `bg-${randomUUID4().slice(0, 8)}`;
-        const outputPath = join20(tempDir, `${handle}.log`);
-        const pidPath = join20(tempDir, `${handle}.pid`);
+        const outputPath = join21(tempDir, `${handle}.log`);
+        const pidPath = join21(tempDir, `${handle}.pid`);
         const logFd = openSync(outputPath, "a");
         let proc;
         try {
@@ -191984,7 +192585,7 @@ Do NOT use this tool for git commands \u2014 use the dedicated git tools instead
           throw new Error("failed to start background process");
         }
         proc.unref();
-        writeFileSync12(pidPath, `${proc.pid}
+        writeFileSync13(pidPath, `${proc.pid}
 `);
         ctx.toolState.backgroundProcesses.set(handle, { pid: proc.pid, outputPath, pidPath });
         return {
@@ -192064,8 +192665,8 @@ function GhTool(ctx) {
     description: `Run the GitHub CLI against ${ctx.repo.owner}/${ctx.repo.name}. Pass argv as an array \u2014 there is no shell, so pipes, redirects and \`&&\` do not work; use gh's own \`--json\`/\`--jq\` flags instead. \`gh api graphql\` is available. Authenticated with ${permissions ? formatPermissions(permissions) : "no permissions"} on this repo only; anything else 403s. Pushing, merging and ref writes are not available \u2014 use the git tools.`,
     parameters: GhParams,
     execute: execute(async (params) => {
-      const configDir = join21(ctx.tmpdir, "gh-config");
-      mkdirSync8(configDir, { recursive: true });
+      const configDir = join22(ctx.tmpdir, "gh-config");
+      mkdirSync9(configDir, { recursive: true });
       const command = ["gh", ...params.args.map(shellQuote)].join(" ");
       const result = await runSandboxed({
         command,
@@ -192788,8 +193389,8 @@ function PullRequestInfoTool(ctx) {
 }
 
 // mcp/reviewComments.ts
-import { writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join22 } from "node:path";
+import { writeFileSync as writeFileSync14 } from "node:fs";
+import { join as join23 } from "node:path";
 var COMMENTS_PER_THREAD = 50;
 var REVIEW_THREADS_QUERY = `
 query ($owner: String!, $name: String!, $prNumber: Int!, $cursor: String) {
@@ -193262,8 +193863,8 @@ function GetReviewCommentsTool(ctx) {
         throw new Error("PULLFROG_TEMP_DIR not set");
       }
       const filename = `review-${params.review_id}-threads.md`;
-      const commentsPath = join22(tempDir, filename);
-      writeFileSync13(commentsPath, formatted.content);
+      const commentsPath = join23(tempDir, filename);
+      writeFileSync14(commentsPath, formatted.content);
       log2.debug(`wrote ${threadBlocks.length} threads to ${commentsPath}`);
       return {
         review_id: params.review_id,
@@ -193596,8 +194197,8 @@ function UploadFileTool(ctx) {
 }
 
 // mcp/xrepo.ts
-import { mkdirSync as mkdirSync9, rmSync as rmSync3 } from "node:fs";
-import { join as join23 } from "node:path";
+import { mkdirSync as mkdirSync10, rmSync as rmSync3 } from "node:fs";
+import { join as join24 } from "node:path";
 function assertValidRepoName(name) {
   if (!/^[A-Za-z0-9._-]+$/.test(name) || name.startsWith("-") || name.includes("..")) {
     throw new Error(
@@ -193677,8 +194278,8 @@ function CheckoutRepoTool(ctx) {
         return { path: existing.dir, access: existing.access, note: "already checked out." };
       }
       const access = accessFor(ctx, repo);
-      const dir = join23(ctx.tmpdir, "xrepo", repo);
-      mkdirSync9(dir, { recursive: true });
+      const dir = join24(ctx.tmpdir, "xrepo", repo);
+      mkdirSync10(dir, { recursive: true });
       const state = ensureRepoState(ctx.toolState, { owner, name: repo, dir, access });
       const rc = resolveRepoCtx(ctx, repo);
       try {
@@ -193926,6 +194527,9 @@ function hasEnvVar2(name) {
 function hasClaudeCodeAuth() {
   return hasEnvVar2("CLAUDE_CODE_OAUTH_TOKEN") || hasEnvVar2("ANTHROPIC_API_KEY");
 }
+function hasCodexAuth() {
+  return hasEnvVar2("CODEX_AUTH_JSON") || hasEnvVar2("OPENAI_API_KEY");
+}
 function hasBedrockAuth() {
   return hasEnvVar2("AWS_BEARER_TOKEN_BEDROCK") || hasEnvVar2("AWS_ACCESS_KEY_ID") && hasEnvVar2("AWS_SECRET_ACCESS_KEY");
 }
@@ -193952,6 +194556,15 @@ function resolveSlug(slug2) {
     }
     return vertexId;
   }
+  if (alias?.routing === "azure") {
+    const deployment = process.env[AZURE_DEPLOYMENT_ENV]?.trim();
+    if (!deployment) {
+      throw new Error(
+        `${AZURE_DEPLOYMENT_ENV} env var is required when the model is set to "${slug2}". set it to the name of your Azure OpenAI deployment (not the model it serves \u2014 Azure routes on the deployment name). see https://docs.pullfrog.com/azure for setup.`
+      );
+    }
+    return `${AZURE_PROVIDER}/${deployment}`;
+  }
   if (alias?.routing === "openai-compatible") {
     const modelId = process.env[OPENAI_COMPATIBLE_MODEL_ENV]?.trim();
     if (!modelId) {
@@ -193990,6 +194603,7 @@ function resolveAgent(ctx) {
     }
     log2.warning(`\xBB unknown PULLFROG_AGENT="${envAgent}" \u2014 falling through to auto-select`);
   }
+  if (ctx.proxyModel) return agents.opencode;
   if (ctx.model && hasBedrockAuth() && process.env[BEDROCK_MODEL_ID_ENV]?.trim() === ctx.model) {
     return isBedrockAnthropicId(ctx.model) ? agents.claude : agents.opencode;
   }
@@ -193999,12 +194613,14 @@ function resolveAgent(ctx) {
   if (ctx.model) {
     try {
       const provider2 = getModelProvider(ctx.model);
-      if (provider2 === "anthropic" && hasClaudeCodeAuth()) {
-        return agents.claude;
-      }
+      if (provider2 === "anthropic" && hasClaudeCodeAuth()) return agents.claude;
+      if (provider2 === "openai" && ctx.codexAgent && hasCodexAuth()) return agents.codex;
     } catch {
     }
   }
+  if (!ctx.model && ctx.codexAgent && hasCodexAuth() && !hasClaudeCodeAuth()) {
+    return agents.codex;
+  }
   return agents.opencode;
 }
 
@@ -194102,10 +194718,37 @@ auto-compaction is disabled, so long runs grow until your endpoint refuses them.
 
 for full setup instructions, see https://docs.pullfrog.com/openai-compatible`;
 }
+function buildAzureSetupError(params) {
+  const githubSecretsUrl = `https://github.com/${params.owner}/${params.name}/settings/secrets/actions`;
+  return `Azure OpenAI selected but required configuration is missing: ${params.missing.join(", ")}.
+
+only the API key is sensitive \u2014 add it as a secret at ${githubSecretsUrl}. the rest is plain workflow \`env:\`:
+
+  ${AZURE_RESOURCE_NAME_ENV}: <name>
+  ${AZURE_API_KEY_ENV}: \${{ secrets.${AZURE_API_KEY_ENV} }}
+  ${AZURE_DEPLOYMENT_ENV}: <deployment-name>
+  ${AZURE_CONTEXT_ENV}: "400000"
+  ${AZURE_MAX_OUTPUT_ENV}: "128000"
+
+${AZURE_RESOURCE_NAME_ENV} is the \`<name>\` in your endpoint https://<name>.openai.azure.com.
+${AZURE_DEPLOYMENT_ENV} is the name of the deployment, which is not necessarily the name of
+the model it serves \u2014 Azure routes on the deployment name.
+
+set the last two to the real limits of whichever model your deployment serves. Pullfrog can't
+discover them \u2014 a deployment name carries no catalog metadata \u2014 and without them completions
+are capped at 32000 tokens (rejected outright by models with a smaller cap) and auto-compaction
+is disabled, so long runs grow until Azure refuses them.
+
+for full setup instructions, see https://docs.pullfrog.com/azure`;
+}
 function hasEnvVar3(name) {
   const value2 = process.env[name];
   return typeof value2 === "string" && value2.length > 0;
 }
+function modelHasRuntimeAuth(model) {
+  const authVars = [...getModelEnvVars(model), ...getModelManagedCredentials(model)];
+  return authVars.length === 0 || authVars.some(hasEnvVar3);
+}
 function hasPositiveNumberEnvVar(name) {
   return Number(process.env[name]) > 0;
 }
@@ -194124,6 +194767,17 @@ function validateOpenAICompatibleSetup(params) {
     );
   }
 }
+function validateAzureSetup(params) {
+  const missing = [];
+  if (!hasEnvVar3(AZURE_API_KEY_ENV)) missing.push(AZURE_API_KEY_ENV);
+  if (!hasEnvVar3(AZURE_RESOURCE_NAME_ENV)) missing.push(AZURE_RESOURCE_NAME_ENV);
+  if (!hasEnvVar3(AZURE_DEPLOYMENT_ENV)) missing.push(AZURE_DEPLOYMENT_ENV);
+  if (!hasPositiveNumberEnvVar(AZURE_CONTEXT_ENV)) missing.push(AZURE_CONTEXT_ENV);
+  if (!hasPositiveNumberEnvVar(AZURE_MAX_OUTPUT_ENV)) missing.push(AZURE_MAX_OUTPUT_ENV);
+  if (missing.length > 0) {
+    throw new Error(buildAzureSetupError({ owner: params.owner, name: params.name, missing }));
+  }
+}
 function validateBedrockSetup(params) {
   const hasAuth = hasEnvVar3("AWS_BEARER_TOKEN_BEDROCK") || hasEnvVar3("AWS_ACCESS_KEY_ID") && hasEnvVar3("AWS_SECRET_ACCESS_KEY");
   const missing = [];
@@ -194147,6 +194801,12 @@ function validateVertexSetup(params) {
     throw new Error(buildVertexSetupError({ owner: params.owner, name: params.name, missing }));
   }
 }
+function hasSingleProviderAuth(agentName) {
+  if (agentName === "codex") {
+    return hasEnvVar3("OPENAI_API_KEY") || hasEnvVar3("CODEX_AUTH_JSON");
+  }
+  return hasEnvVar3("ANTHROPIC_API_KEY") || hasEnvVar3("CLAUDE_CODE_OAUTH_TOKEN");
+}
 function validateAgentApiKey(params) {
   if (params.model) {
     const alias = resolveDisplayAlias(params.model);
@@ -194162,6 +194822,10 @@ function validateAgentApiKey(params) {
       validateOpenAICompatibleSetup({ owner: params.owner, name: params.name });
       return;
     }
+    if (params.model.startsWith(`${AZURE_PROVIDER}/`)) {
+      validateAzureSetup({ owner: params.owner, name: params.name });
+      return;
+    }
     if (!params.model.includes("/")) {
       if (process.env[VERTEX_MODEL_ID_ENV]?.trim() === params.model) {
         validateVertexSetup({ owner: params.owner, name: params.name });
@@ -194185,7 +194849,7 @@ function validateAgentApiKey(params) {
         })
       );
     }
-    if (hasEnvVar3("ANTHROPIC_API_KEY") || hasEnvVar3("CLAUDE_CODE_OAUTH_TOKEN")) return;
+    if (hasSingleProviderAuth(params.agent.name)) return;
     throw new Error(
       buildKeyError({
         owner: params.owner,
@@ -194197,7 +194861,7 @@ function validateAgentApiKey(params) {
     );
   }
   if (params.agent.name === "opencode") {
-    if (params.authorized.size > 0) return;
+    if ([...params.authorized].some(modelHasRuntimeAuth)) return;
     const reason = getModelsFailure();
     if (reason) throw new Error(reason);
     throw new Error(
@@ -194209,7 +194873,7 @@ function validateAgentApiKey(params) {
       })
     );
   }
-  if (hasEnvVar3("ANTHROPIC_API_KEY") || hasEnvVar3("CLAUDE_CODE_OAUTH_TOKEN")) return;
+  if (hasSingleProviderAuth(params.agent.name)) return;
   throw new Error(
     buildKeyError({
       owner: params.owner,
@@ -194582,9 +195246,9 @@ async function checkConfiguredCredentials(params) {
 
 // utils/gitAuthServer.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { writeFileSync as writeFileSync14 } from "node:fs";
+import { writeFileSync as writeFileSync15 } from "node:fs";
 import { createServer as createServer3 } from "node:http";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 var REVOKED_TRAP_MS = 6e4;
 function revokeGitHubToken(token) {
   fetch("https://api.github.com/installation/token", {
@@ -194653,7 +195317,7 @@ async function startGitAuthServer(tmpdir4) {
   function writeAskpassScript(code) {
     const scriptId = randomUUID5();
     const scriptName = `askpass-${scriptId}.js`;
-    const scriptPath = join24(tmpdir4, scriptName);
+    const scriptPath = join25(tmpdir4, scriptName);
     const content = [
       `#!/usr/bin/env node`,
       `var a=process.argv[2]||"";`,
@@ -194666,7 +195330,7 @@ async function startGitAuthServer(tmpdir4) {
       `r.on("end",function(){process.stdout.write(d+"\\n")})`,
       `}).on("error",function(){process.exit(1)})}`
     ].join("\n");
-    writeFileSync14(scriptPath, content, { mode: 448 });
+    writeFileSync15(scriptPath, content, { mode: 448 });
     return scriptPath;
   }
   async function close() {
@@ -195105,7 +195769,7 @@ function resolveInstructions(ctx) {
 
 // utils/learnings.ts
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname4, join as join25 } from "node:path";
+import { dirname as dirname4, join as join26 } from "node:path";
 
 // utils/learningsTruncate.ts
 var MAX_LEARNINGS_LENGTH = 1e5;
@@ -195123,10 +195787,10 @@ function truncateAtLineBoundary(body, cap) {
 var LEARNINGS_FILE_NAME = "pullfrog-learnings.md";
 var XREPO_LEARNINGS_FILE_NAME = "pullfrog-xrepo-learnings.md";
 function learningsFilePath(tmpdir4) {
-  return join25(tmpdir4, LEARNINGS_FILE_NAME);
+  return join26(tmpdir4, LEARNINGS_FILE_NAME);
 }
 function xrepoLearningsFilePath(tmpdir4) {
-  return join25(tmpdir4, XREPO_LEARNINGS_FILE_NAME);
+  return join26(tmpdir4, XREPO_LEARNINGS_FILE_NAME);
 }
 async function seedLearningsFile(params) {
   const path4 = learningsFilePath(params.tmpdir);
@@ -195242,7 +195906,7 @@ async function persistXrepoLearnings(ctx) {
 // utils/modelAccess.ts
 function decideModelAccess(input) {
   if (!input.modelExplicit || !input.model) return { kind: "ok" };
-  const byokAuthorized = !!input.resolvedModel && (input.authorized.has(input.resolvedModel) || !input.resolvedModel.includes("/") || input.resolvedModel.startsWith(`${OPENAI_COMPATIBLE_PROVIDER}/`));
+  const byokAuthorized = !!input.resolvedModel && (input.authorized.has(input.resolvedModel) || !input.resolvedModel.includes("/") || input.resolvedModel.startsWith(`${OPENAI_COMPATIBLE_PROVIDER}/`) || input.resolvedModel.startsWith(`${AZURE_PROVIDER}/`));
   if (input.proxyActive) {
     const target = resolveOpenRouterModel(input.model);
     if (input.oss) {
@@ -195287,7 +195951,7 @@ function buildModelAccessError(input) {
 }
 
 // utils/normalizeEnv.ts
-var core4 = __toESM(require_core(), 1);
+var core5 = __toESM(require_core(), 1);
 function hasControlCharacter(value2) {
   return [...value2].some((ch) => {
     const code = ch.charCodeAt(0);
@@ -195313,7 +195977,7 @@ function sanitizeSecret(key, value2) {
       `\xBB stripped whitespace from ${key} (whitespace in secret values breaks GitHub Actions log masking)`
     );
   }
-  core4.setSecret(trimmed);
+  core5.setSecret(trimmed);
   return trimmed;
 }
 function normalizeEnv() {
@@ -195357,7 +196021,7 @@ function normalizeEnv() {
 }
 
 // utils/overrides.ts
-var core5 = __toESM(require_core(), 1);
+var core6 = __toESM(require_core(), 1);
 var DENIED_OVERRIDE_NAMES = /* @__PURE__ */ new Set([
   "GITHUB_TOKEN",
   "GH_TOKEN",
@@ -195403,7 +196067,7 @@ function applyOverrides(params) {
       denied.push(key);
       continue;
     }
-    if (value2.length > 0) core5.setSecret(value2);
+    if (value2.length > 0) core6.setSecret(value2);
     params.env[key] = value2;
     applied.push(key);
   }
@@ -195412,8 +196076,8 @@ function applyOverrides(params) {
 }
 
 // utils/payload.ts
-var core6 = __toESM(require_core(), 1);
-import { readFileSync as readFileSync6 } from "node:fs";
+var core7 = __toESM(require_core(), 1);
+import { readFileSync as readFileSync7 } from "node:fs";
 import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
 
 // utils/versioning.ts
@@ -195500,8 +196164,8 @@ function resolveCwd(cwd) {
   return workspace ? resolve2(workspace, cwd) : cwd;
 }
 function resolvePromptInput() {
-  const promptInput = core6.getInput("prompt");
-  const promptFile = core6.getInput("prompt_file");
+  const promptInput = core7.getInput("prompt");
+  const promptFile = core7.getInput("prompt_file");
   if (promptInput && promptFile) {
     throw new Error("set exactly one of 'prompt' or 'prompt_file' inputs, not both.");
   }
@@ -195527,7 +196191,7 @@ function resolvePromptInput() {
 function resolvePromptFile(input) {
   const workspace = process.env.GITHUB_WORKSPACE;
   const path4 = isAbsolute2(input) ? input : workspace ? resolve2(workspace, input) : resolve2(input);
-  const content = readFileSync6(path4, "utf-8");
+  const content = readFileSync7(path4, "utf-8");
   if (!content.trim()) {
     throw new Error(`prompt_file ${JSON.stringify(input)} is empty.`);
   }
@@ -195535,7 +196199,7 @@ function resolvePromptFile(input) {
 }
 function warnIfDeprecatedStatusChecks(value2) {
   if (value2 !== void 0) {
-    core6.warning(
+    core7.warning(
       "`status_checks` is deprecated. Both checks are now repository settings \u2014 open the Pullfrog console for this repo (Automations \u2192 Review PRs) and set them there, then remove `status_checks` from your workflow. It keeps working until you do."
     );
   }
@@ -195543,15 +196207,15 @@ function warnIfDeprecatedStatusChecks(value2) {
 }
 function resolveNonPromptInputs() {
   return Inputs.omit("prompt", "prompt_file").assert({
-    model: core6.getInput("model") || void 0,
-    effort: core6.getInput("effort") || void 0,
-    debug: core6.getInput("debug") || void 0,
-    timeout: core6.getInput("timeout") || void 0,
-    cwd: core6.getInput("cwd") || void 0,
-    push: core6.getInput("push") || void 0,
-    shell: core6.getInput("shell") || void 0,
-    status_checks: warnIfDeprecatedStatusChecks(core6.getInput("status_checks") || void 0),
-    progress_comments: core6.getInput("progress_comments") || void 0
+    model: core7.getInput("model") || void 0,
+    effort: core7.getInput("effort") || void 0,
+    debug: core7.getInput("debug") || void 0,
+    timeout: core7.getInput("timeout") || void 0,
+    cwd: core7.getInput("cwd") || void 0,
+    push: core7.getInput("push") || void 0,
+    shell: core7.getInput("shell") || void 0,
+    status_checks: warnIfDeprecatedStatusChecks(core7.getInput("status_checks") || void 0),
+    progress_comments: core7.getInput("progress_comments") || void 0
   });
 }
 function resolvePayload(resolvedPromptInput, repoSettings) {
@@ -195619,7 +196283,7 @@ function resolvePayload(resolvedPromptInput, repoSettings) {
   };
 }
 function resolveOutputSchema() {
-  const raw2 = core6.getInput("output_schema");
+  const raw2 = core7.getInput("output_schema");
   if (!raw2) return void 0;
   let parsed2;
   try {
@@ -195635,10 +196299,10 @@ function resolveOutputSchema() {
 }
 
 // utils/proxy.ts
-var core8 = __toESM(require_core(), 1);
+var core9 = __toESM(require_core(), 1);
 
 // utils/token.ts
-var core7 = __toESM(require_core(), 1);
+var core8 = __toESM(require_core(), 1);
 import assert2 from "node:assert/strict";
 var mcpTokenValue;
 var refreshMcpTokenFn;
@@ -195646,7 +196310,7 @@ function getMcpTokenRefresh() {
   return refreshMcpTokenFn;
 }
 function getJobToken() {
-  const inputToken = core7.getInput("token");
+  const inputToken = core8.getInput("token");
   if (inputToken) {
     return inputToken;
   }
@@ -195662,7 +196326,7 @@ async function resolveTokens(params) {
   if (externalToken) {
     mcpTokenValue = externalToken;
     if (isGitHubActions) {
-      core7.setSecret(externalToken);
+      core8.setSecret(externalToken);
     }
     log2.info("\xBB using external GH_TOKEN for both git and MCP");
     return {
@@ -195682,7 +196346,7 @@ async function resolveTokens(params) {
   const gitPermissions = params.push === "disabled" ? { contents: "read" } : { contents: "write", workflows: "write" };
   const gitToken = await acquireNewToken({ repos: writeRepos, permissions: gitPermissions });
   if (isGitHubActions) {
-    core7.setSecret(gitToken);
+    core8.setSecret(gitToken);
   }
   log2.info(
     `\xBB acquired git token (${Object.entries(gitPermissions).map((e) => e.join(":")).join(", ")})`
@@ -195699,7 +196363,7 @@ async function resolveTokens(params) {
   };
   const mcpToken = await acquireNewToken({ repos: writeRepos, permissions: mcpPermissions });
   if (isGitHubActions) {
-    core7.setSecret(mcpToken);
+    core8.setSecret(mcpToken);
   }
   log2.info(
     `\xBB acquired scoped MCP token (${Object.entries(mcpPermissions).map((e) => e.join(":")).join(", ")})`
@@ -195708,7 +196372,7 @@ async function resolveTokens(params) {
   let ghToken;
   if (ghPermissions) {
     ghToken = await acquireNewToken({ permissions: ghPermissions });
-    if (isGitHubActions) core7.setSecret(ghToken);
+    if (isGitHubActions) core8.setSecret(ghToken);
     log2.info(
       `\xBB acquired gh token mirroring ${params.authorPermission} (${formatPermissions(ghPermissions)})`
     );
@@ -195719,7 +196383,7 @@ async function resolveTokens(params) {
       repos: params.xrepo.read,
       permissions: { contents: "read" }
     });
-    if (isGitHubActions) core7.setSecret(readToken);
+    if (isGitHubActions) core8.setSecret(readToken);
     log2.info(`\xBB acquired cross-repo read token (contents:read, ${params.xrepo.read.length} repos)`);
   }
   mcpTokenValue = mcpToken;
@@ -195738,7 +196402,7 @@ async function resolveTokens(params) {
       oidc: params.oidc ?? void 0
     }).then((fresh) => {
       if (isGitHubActions) {
-        core7.setSecret(fresh);
+        core8.setSecret(fresh);
       }
       mcpTokenValue = fresh;
       currentMcpToken = fresh;
@@ -195759,7 +196423,7 @@ async function resolveTokens(params) {
         permissions: gitPermissions,
         oidc: params.oidc ?? void 0
       }).then((fresh) => {
-        if (isGitHubActions) core7.setSecret(fresh);
+        if (isGitHubActions) core8.setSecret(fresh);
         void revokeGitHubInstallationToken(currentGitToken);
         currentGitToken = fresh;
         log2.warning("\xBB GitHub rejected the git token; re-acquired a fresh git token");
@@ -195776,7 +196440,7 @@ async function resolveTokens(params) {
         permissions: { contents: "read" },
         oidc: params.oidc ?? void 0
       }).then((fresh) => {
-        if (isGitHubActions) core7.setSecret(fresh);
+        if (isGitHubActions) core8.setSecret(fresh);
         void revokeGitHubInstallationToken(read2);
         currentReadToken = fresh;
         log2.warning("\xBB GitHub rejected the read token; re-acquired a fresh read token");
@@ -195990,7 +196654,7 @@ async function resolveProxyModel(ctx) {
   });
   if (!key) return;
   process.env.OPENROUTER_API_KEY = key;
-  core8.setSecret(key);
+  core9.setSecret(key);
   ctx.payload.proxyModel = ctx.proxyModel;
   ctx.toolState.model = ctx.proxyModel;
   const label = ctx.oss ? "oss" : "router";
@@ -196061,7 +196725,7 @@ async function runProxyResolution(ctx) {
 
 // utils/prSummary.ts
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname5, join as join26 } from "node:path";
+import { dirname as dirname5, join as join27 } from "node:path";
 var SUMMARY_FILE_NAME = "pullfrog-summary.md";
 var SUMMARY_SCAFFOLD = `# PR summary
 
@@ -196071,7 +196735,7 @@ var SUMMARY_SCAFFOLD = `# PR summary
 var MIN_SNAPSHOT_LENGTH = 60;
 var MAX_SNAPSHOT_LENGTH = 32768;
 function summaryFilePath(tmpdir4) {
-  return join26(tmpdir4, SUMMARY_FILE_NAME);
+  return join27(tmpdir4, SUMMARY_FILE_NAME);
 }
 async function seedSummaryFile(params) {
   const path4 = summaryFilePath(params.tmpdir);
@@ -196200,6 +196864,7 @@ var defaultSettings = {
   shell: "restricted",
   prApproveEnabled: false,
   autoMergeEnabled: false,
+  codexAgent: false,
   signedCommits: false,
   repoIntelligence: false,
   progressComments: true,
@@ -196688,7 +197353,7 @@ ${genericBody}`,
 }
 
 // utils/runLifecycle.ts
-var core9 = __toESM(require_core(), 1);
+var core10 = __toESM(require_core(), 1);
 
 // utils/autoMerge.ts
 function hasBlockingHumanReview(reviews) {
@@ -197074,7 +197739,7 @@ async function finalizeSuccessRun(input) {
   }
   if (input.toolState.output) {
     log2.info(`::pullfrog-output::${Buffer.from(input.toolState.output).toString("base64")}`);
-    core9.setOutput("result", input.toolState.output);
+    core10.setOutput("result", input.toolState.output);
   }
   if (input.result.success) {
     await approveAfterFix(input.toolContext).catch((error52) => {
@@ -197538,7 +198203,11 @@ async function main() {
         }
         const resolvedModel = credentials.kind === "fellBack" ? credentials.replacement : configuredModel;
         vertexCredentials = materializeVertexCredentials({ model: resolvedModel });
-        const agent2 = resolveAgent({ model: resolvedModel });
+        const agent2 = resolveAgent({
+          model: resolvedModel,
+          proxyModel: payload.proxyModel,
+          codexAgent: runContext.repoSettings.codexAgent
+        });
         const effectiveModel = payload.proxyModel ?? resolvedModel ?? payload.model;
         toolState.model = effectiveModel;
         if (!payload.proxyModel) {
@@ -197698,11 +198367,16 @@ async function main() {
           xrepoLearningsFilePath: toolState.xrepoLearningsFilePath ?? null,
           xrepoLearningsHeadings: runContext.repoSettings.xrepoLearningsHeadings
         });
-        assertPromptToolRefs({
+        const danglingToolRefs = findDanglingPromptToolRefs({
           agentId,
           prompt: instructions.full,
           toolNames: mcpHttpServer.toolNames
         });
+        if (danglingToolRefs.length > 0) {
+          log2.warning(
+            `\xBB prompt advertises ${danglingToolRefs.length} tool(s) the MCP server did not register: ${danglingToolRefs.join(", ")}`
+          );
+        }
         const logParts = [
           instructions.eventInstructions ? `EVENT-LEVEL INSTRUCTIONS:
 ${instructions.eventInstructions}` : null,
@@ -197717,8 +198391,8 @@ ${instructions.user}` : null,
           log2.info(instructions.full);
         });
         if (agentId === "opencode") {
-          const pluginDir = join27(process.cwd(), ".opencode", "plugin");
-          const hasPlugins = existsSync8(pluginDir) && readdirSync2(pluginDir).some((f) => /\.[jt]sx?$/.test(f));
+          const pluginDir = join28(process.cwd(), ".opencode", "plugin");
+          const hasPlugins = existsSync9(pluginDir) && readdirSync2(pluginDir).some((f) => /\.[jt]sx?$/.test(f));
           if (hasPlugins && toolState.dependencyInstallation?.promise) {
             log2.info(
               "\xBB .opencode/plugin/ detected \u2014 awaiting dependency installation before agent start"
@@ -197910,27 +198584,27 @@ async function runMain() {
     }
   } catch (error52) {
     const errorMessage = error52 instanceof Error ? error52.message : "unknown error occurred";
-    core10.setFailed(`action failed: ${errorMessage}`);
+    core11.setFailed(`action failed: ${errorMessage}`);
   }
 }
 async function tokenMain() {
-  const reposInput = core10.getInput("repos");
+  const reposInput = core11.getInput("repos");
   const additionalRepos = reposInput ? reposInput.split(",").map((r2) => r2.trim()).filter(Boolean) : [];
   const token = await acquireNewToken({ repos: additionalRepos });
-  core10.setSecret(token);
-  core10.saveState(STATE_TOKEN, token);
-  core10.setOutput("token", token);
+  core11.setSecret(token);
+  core11.saveState(STATE_TOKEN, token);
+  core11.setOutput("token", token);
   const scope2 = additionalRepos.length ? `current repo + ${additionalRepos.join(", ")}` : "current repo only";
-  core10.info(`\xBB installation token acquired (${scope2})`);
+  core11.info(`\xBB installation token acquired (${scope2})`);
 }
 async function tokenPost() {
-  const token = core10.getState(STATE_TOKEN);
+  const token = core11.getState(STATE_TOKEN);
   if (!token) {
-    core10.debug("no token found in state, skipping revocation");
+    core11.debug("no token found in state, skipping revocation");
     return;
   }
   await revokeGitHubInstallationToken(token);
-  core10.info("\xBB installation token revoked");
+  core11.info("\xBB installation token revoked");
 }
 function printGhaUsage(params) {
   params.stream(`usage: ${params.prog} gha [subcommand]
@@ -198046,7 +198720,7 @@ async function run(args2) {
     }
   } catch (error52) {
     const message = error52 instanceof Error ? error52.message : String(error52);
-    core10.setFailed(message);
+    core11.setFailed(message);
   }
 }
 
@@ -198893,7 +199567,7 @@ async function runCli4(input) {
 }
 
 // cli.ts
-var VERSION10 = "0.1.56";
+var VERSION10 = "0.1.59";
 var bin = basename2(process.argv[1] || "");
 var PROG = bin === "pf" || bin === "pullfrog" ? bin : "pullfrog";
 var rawArgs = process.argv.slice(2);