pullfrog 0.1.59 → 0.1.61

package/dist/external.d.ts

@@ -322,6 +322,13 @@ export interface WriteablePayload {
     } | undefined;
     /** when true, seed the PR summary tmpfile + persist edits at run end */
     generateSummary?: boolean | undefined;
+    /**
+     * the codex canary assigned this run to the EXPERIMENTAL codex harness. rolled
+     * once server-side at reservation and stamped on the run row, so the row and the
+     * run always agree on which arm this was. ORed with the account opt-in in
+     * `resolveAgent` — it widens who reaches codex, never narrows it.
+     */
+    codexArm?: boolean | undefined;
 }
 export type Payload = Readonly<WriteablePayload>;
 /**

package/dist/index.js

@@ -104420,6 +104420,11 @@ var DEFAULT_ACTIVITY_TIMEOUT_MS = 3e5;
 var AGENT_ACTIVITY_TIMEOUT_MS = 9e5;
 var AGENT_FIRST_EVENT_TIMEOUT_MS = 12e4;
 var DEFAULT_ACTIVITY_CHECK_INTERVAL_MS = 5e3;
+function watchdogBudgetMs(compiled, envVar) {
+  const raw2 = Number(process.env[envVar]);
+  if (!Number.isFinite(raw2) || raw2 <= 0) return compiled;
+  return Math.min(compiled, raw2);
+}
 var DEBUG_TS_PREFIX = /^(?:\[\d{4}-\d{2}-\d{2}T[^\]]+\]\s+)?/.source;
 var ACTIVITY_NOISE_PATTERNS = [
   new RegExp(`${DEBUG_TS_PREFIX}\\[mcp-proxy\\]`),
@@ -105183,7 +105188,7 @@ var import_semver = __toESM(require_semver2(), 1);
 // package.json
 var package_default = {
   name: "pullfrog",
-  version: "0.1.59",
+  version: "0.1.61",
   type: "module",
   bin: {
     pullfrog: "dist/cli.mjs",
@@ -107292,7 +107297,7 @@ var claude = agent({
       if ((isBedrockRoute || isVertexRoute2) && specifier && effort.alias?.effort) {
         applyHostedEffortCapabilities({ env: env2, modelId: specifier, levels: effort.alias.effort });
       }
-      if (env2.CLAUDE_CODE_OAUTH_TOKEN && !isBedrockRoute && env2.ANTHROPIC_API_KEY) {
+      if (env2.CLAUDE_CODE_OAUTH_TOKEN && !isBedrockRoute && !isVertexRoute2 && !env2.ANTHROPIC_BASE_URL && !env2.ANTHROPIC_AUTH_TOKEN && env2.ANTHROPIC_API_KEY) {
         const preflight = await preflightClaudeSubscription({
           token: env2.CLAUDE_CODE_OAUTH_TOKEN,
           model
@@ -107309,6 +107314,19 @@ var claude = agent({
           delete env2.CLAUDE_CODE_OAUTH_TOKEN;
         }
       }
+      if (env2.CLAUDE_CODE_USE_BEDROCK) {
+        ctx.toolState.credential = "bedrock";
+      } else if (env2.CLAUDE_CODE_USE_VERTEX) {
+        ctx.toolState.credential = "vertex";
+      } else if (env2.CLAUDE_CODE_USE_FOUNDRY) {
+        ctx.toolState.credential = "foundry";
+      } else if (env2.ANTHROPIC_AUTH_TOKEN) {
+        ctx.toolState.credential = "gateway";
+      } else if (env2.ANTHROPIC_API_KEY) {
+        ctx.toolState.credential = "api_key";
+      } else if (env2.CLAUDE_CODE_OAUTH_TOKEN) {
+        ctx.toolState.credential = "subscription";
+      }
       const effortEnvOverride = env2[CLAUDE_EFFORT_ENV]?.trim();
       if (effortEnvOverride) {
         log.warning(
@@ -107818,6 +107836,18 @@ function toTodoWriteInput(item) {
     }))
   };
 }
+var CODEX_MODEL_PRICING = {
+  "gpt-5.6-sol": { input: 5, cacheRead: 0.5, cacheWrite: 6.25, output: 30 },
+  "gpt-5.6-luna": { input: 0.2, cacheRead: 0.02, cacheWrite: 0.25, output: 1.2 },
+  "gpt-5.6-terra": { input: 2, cacheRead: 0.2, cacheWrite: 2.5, output: 12 }
+};
+function codexCostUsd(params) {
+  const price = params.model ? CODEX_MODEL_PRICING[params.model] : void 0;
+  if (!price) return void 0;
+  const fresh = Math.max(0, params.input - params.cacheRead - params.cacheWrite);
+  const usd = (fresh * price.input + params.cacheRead * price.cacheRead + params.cacheWrite * price.cacheWrite + params.output * price.output) / 1e6;
+  return usd > 0 ? usd : void 0;
+}
 async function runCodex(params) {
   const startTime = performance6.now();
   const thinkingTimer = new ThinkingTimer();
@@ -107829,14 +107859,15 @@ async function runCodex(params) {
   let turnError = null;
   let lastProviderError = null;
   let stdoutBuffer = "";
-  const tokens = { input: 0, cacheRead: 0, output: 0 };
+  const tokens = { input: 0, cacheRead: 0, cacheWrite: 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
+      cacheReadTokens: tokens.cacheRead || void 0,
+      costUsd: codexCostUsd({ model: params.model, ...tokens })
     };
   }
   function onItem(item, phase) {
@@ -107901,6 +107932,7 @@ async function runCodex(params) {
       case "turn.completed":
         tokens.input += event.usage.input_tokens ?? 0;
         tokens.cacheRead += event.usage.cached_input_tokens ?? 0;
+        tokens.cacheWrite += event.usage.cache_write_input_tokens ?? 0;
         tokens.output += event.usage.output_tokens ?? 0;
         return;
       case "turn.failed":
@@ -108061,6 +108093,11 @@ var codex = agent({
     } else if (process.env.OPENAI_API_KEY) {
       env2.CODEX_API_KEY = process.env.OPENAI_API_KEY;
     }
+    if (codexHomeAuth) {
+      ctx.toolState.credential = "subscription";
+    } else if (env2.CODEX_API_KEY) {
+      ctx.toolState.credential = "api_key";
+    }
     const securityFlags = securityOverrideFlags({
       ctx,
       sandboxMode: ctx.payload.push === "disabled" ? "read-only" : "workspace-write",
@@ -108069,7 +108106,13 @@ var codex = agent({
       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 runnerArgs = {
+      cliPath,
+      cwd: process.cwd(),
+      env: env2,
+      todoTracker: ctx.todoTracker,
+      model: resolveCodexModel(ctx)
+    };
     const initial = await runCodex({
       ...runnerArgs,
       args: [...securityFlags, "exec", "--json", ctx.instructions.full],
@@ -114157,6 +114200,7 @@ function processTerminalToolPart(ctx, part, label, isOrchestrator) {
   const callLine = inputFormatted !== "{}" ? `\xBB ${toolName}(${inputFormatted})` : `\xBB ${toolName}()`;
   log.info(withLabel(label, callLine));
   if (isOrchestrator) ctx.loggedToolCallIDs.add(toolId);
+  if (isOrchestrator && toolName.startsWith("pullfrog_")) ctx.mcpToolCalls++;
   if (state.status === "completed") {
     log.debug(withLabel(label, `  output: ${state.output}`));
   } else {
@@ -114395,21 +114439,28 @@ function formatConfigError(name, data) {
   ).join("");
   return `${name}${detail}${bullets}`;
 }
+var WATCHDOG_SALVAGE_PROMPT = "Your previous turn was cut off mid-response by a provider stall. Nothing you had not already submitted through a tool was saved. Continue from where you stopped and submit your work now \u2014 do not restart your analysis.";
 function startInnerActivityWatchdog(params) {
   let fired = false;
+  let everFired = false;
   const id = setInterval(() => {
     if (fired) return;
     const idleMs = performance7.now() - params.ctx.lastEventAt;
-    const budgetMs = params.ctx.sawModelOutput ? params.timeoutMs : AGENT_FIRST_EVENT_TIMEOUT_MS;
+    const compiledMs = params.ctx.sawModelOutput ? params.timeoutMs : AGENT_FIRST_EVENT_TIMEOUT_MS;
+    const budgetMs = everFired ? compiledMs : watchdogBudgetMs(
+      compiledMs,
+      params.ctx.sawModelOutput ? "PULLFROG_E2E_ACTIVITY_TIMEOUT_MS" : "PULLFROG_E2E_FIRST_EVENT_TIMEOUT_MS"
+    );
     if (idleMs <= budgetMs) return;
     fired = true;
+    everFired = true;
     const idleSec = Math.round(idleMs / 1e3);
     params.ctx.diagnostic.idleSec = idleSec;
     params.ctx.diagnostic.sawModelOutput = params.ctx.sawModelOutput;
     log.info(
       params.ctx.sawModelOutput ? `\xBB no opencode events for ${idleSec}s \u2014 aborting in-flight prompt and notifying harness` : `\xBB no opencode events for ${idleSec}s \u2014 the provider never returned a first token; aborting in-flight prompt and notifying harness`
     );
-    params.abortController.abort();
+    params.abortTurn();
     try {
       params.ctx.onActivityTimeout?.();
     } catch (err) {
@@ -114419,7 +114470,22 @@ function startInnerActivityWatchdog(params) {
     }
   }, 5e3);
   id.unref?.();
-  return { stop: () => clearInterval(id) };
+  return {
+    stop: () => clearInterval(id),
+    /**
+     * Start a turn's idle budget from now. The clock must be reset with the
+     * latch: `lastEventAt` only advances on model output, so a turn following a
+     * stall would inherit the full stalled interval and be aborted on the very
+     * next 5s tick — killing the salvage before the provider could answer. It
+     * is the right semantics for an ordinary resume too, whose budget should
+     * not be pre-spent by the post-run gate checks that ran between turns.
+     */
+    armForTurn: () => {
+      fired = false;
+      params.ctx.lastEventAt = performance7.now();
+    },
+    firedThisTurn: () => fired
+  };
 }
 var opencode = agent({
   name: "opencode",
@@ -114531,6 +114597,7 @@ var opencode = agent({
         variant: effort.rung,
         todoTracker: ctx.todoTracker,
         onActivityTimeout: ctx.onActivityTimeout,
+        onTurnRecovered: ctx.onTurnRecovered,
         onToolUse: ctx.onToolUse,
         currentTurn: null,
         eventCount: 0,
@@ -114539,6 +114606,7 @@ var opencode = agent({
         promptMessageID: void 0,
         taskDispatchByCallID: /* @__PURE__ */ new Map(),
         loggedToolCallIDs: /* @__PURE__ */ new Set(),
+        mcpToolCalls: 0,
         recentStderr: server.recentStderr,
         diagnostic: {
           label: "Pullfrog",
@@ -114562,9 +114630,14 @@ var opencode = agent({
           }
         }
       });
-      const abortController = new AbortController();
-      const eventLoopPromise = consumeEvents(runnerCtx, abortController.signal).catch((err) => {
-        if (!abortController.signal.aborted) {
+      const runController = new AbortController();
+      let turnController = new AbortController();
+      const nextTurnSignal = () => {
+        turnController = new AbortController();
+        return AbortSignal.any([runController.signal, turnController.signal]);
+      };
+      const eventLoopPromise = consumeEvents(runnerCtx, runController.signal).catch((err) => {
+        if (!runController.signal.aborted) {
           log.warning(
             `\xBB opencode event subscription ended: ${err instanceof Error ? err.message : String(err)}`
           );
@@ -114580,31 +114653,48 @@ var opencode = agent({
         // a long synchronous tool call (no part.updated while it runs) can't
         // false-positive it.
         timeoutMs: AGENT_ACTIVITY_TIMEOUT_MS,
-        abortController
+        abortTurn: () => turnController.abort()
       });
       const sdkModel = parseModel2(model);
+      let salvagesLeft = 1;
+      const runTurn = async (text) => {
+        const attempt = (prompt) => {
+          watchdog.armForTurn();
+          return runTurnGuarded(
+            runnerCtx,
+            () => runPromptTurn(runnerCtx, { text: prompt, model: sdkModel, signal: nextTurnSignal() })
+          );
+        };
+        const standDownIfRecovered = (turn) => {
+          if (watchdog.firedThisTurn() && turn.success) ctx.onTurnRecovered?.();
+          return turn;
+        };
+        const result = await attempt(text);
+        if (!watchdog.firedThisTurn()) return result;
+        if (result.success) return standDownIfRecovered(result);
+        if (salvagesLeft <= 0) return result;
+        salvagesLeft--;
+        ctx.onTurnRecovered?.();
+        log.info("\xBB activity watchdog cut the turn off \u2014 re-prompting once on the same session");
+        const mcpCallsBefore = runnerCtx.mcpToolCalls;
+        const salvaged = await attempt(WATCHDOG_SALVAGE_PROMPT);
+        const usage = mergeAgentUsage(result.usage, salvaged.usage);
+        if (runnerCtx.mcpToolCalls === mcpCallsBefore) {
+          log.info(
+            "\xBB salvage turn reached no Pullfrog tool \u2014 keeping the activity-timeout failure"
+          );
+          return { ...result, usage };
+        }
+        return standDownIfRecovered({ ...salvaged, usage });
+      };
       try {
-        const initial = await runTurnGuarded(
-          runnerCtx,
-          () => runPromptTurn(runnerCtx, {
-            text: ctx.instructions.full,
-            model: sdkModel,
-            signal: abortController.signal
-          })
-        );
+        const initial = await runTurn(ctx.instructions.full);
         const result = await runPostRunRetryLoop({
           ctx,
           initialResult: initial,
           initialUsage: initial.usage,
           reflectionPrompt: buildReflectionPrompt(ctx.toolState),
-          resume: async (c) => runTurnGuarded(
-            runnerCtx,
-            () => runPromptTurn(runnerCtx, {
-              text: c.prompt,
-              model: sdkModel,
-              signal: abortController.signal
-            })
-          )
+          resume: async (c) => runTurn(c.prompt)
         });
         if (result.success) {
           await ctx.todoTracker?.flush();
@@ -114614,7 +114704,7 @@ var opencode = agent({
         return result;
       } finally {
         watchdog.stop();
-        abortController.abort();
+        runController.abort();
         await eventLoopPromise.catch(() => {
         });
       }
@@ -187244,7 +187334,9 @@ var STRING_KEYS = [
   "reviewNodeId",
   "planCommentNodeId",
   "summarySnapshot",
-  "model"
+  "model",
+  "agent",
+  "credential"
 ];
 var NUMBER_KEYS = [
   "inputTokens",
@@ -192405,7 +192497,7 @@ function hasEnvVar2(name) {
   return typeof val === "string" && val.length > 0;
 }
 function hasClaudeCodeAuth() {
-  return hasEnvVar2("CLAUDE_CODE_OAUTH_TOKEN") || hasEnvVar2("ANTHROPIC_API_KEY");
+  return hasEnvVar2("CLAUDE_CODE_OAUTH_TOKEN") || hasEnvVar2("ANTHROPIC_API_KEY") || hasEnvVar2("ANTHROPIC_AUTH_TOKEN");
 }
 function hasCodexAuth() {
   return hasEnvVar2("CODEX_AUTH_JSON") || hasEnvVar2("OPENAI_API_KEY");
@@ -192498,8 +192590,11 @@ function resolveAgent(ctx) {
     } catch {
     }
   }
-  if (!ctx.model && ctx.codexAgent && hasCodexAuth() && !hasClaudeCodeAuth()) {
-    return agents.codex;
+  if (!ctx.model) {
+    if (hasEnvVar2("ANTHROPIC_AUTH_TOKEN") && !hasEnvVar2("ANTHROPIC_API_KEY") && !hasEnvVar2("CLAUDE_CODE_OAUTH_TOKEN")) {
+      return agents.claude;
+    }
+    if (ctx.codexAgent && hasCodexAuth() && !hasClaudeCodeAuth()) return agents.codex;
   }
   return agents.opencode;
 }
@@ -192685,7 +192780,7 @@ 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");
+  return hasEnvVar3("ANTHROPIC_API_KEY") || hasEnvVar3("ANTHROPIC_AUTH_TOKEN") || hasEnvVar3("CLAUDE_CODE_OAUTH_TOKEN");
 }
 function validateAgentApiKey(params) {
   if (params.model) {
@@ -193017,7 +193112,8 @@ var PROBES = {
     request: (value2) => ({
       url: "https://api.anthropic.com/v1/models",
       headers: { "x-api-key": value2, "anthropic-version": "2023-06-01" }
-    })
+    }),
+    hostConfigurable: true
   },
   OPENROUTER_API_KEY: {
     request: (value2) => ({
@@ -193066,12 +193162,18 @@ function hasEnvVar4(name) {
   const value2 = process.env[name];
   return typeof value2 === "string" && value2.length > 0;
 }
+var HOST_OVERRIDES = {
+  ANTHROPIC_API_KEY: "ANTHROPIC_BASE_URL",
+  CLAUDE_CODE_OAUTH_TOKEN: "ANTHROPIC_BASE_URL"
+};
 function envVarsFor(model) {
   return model.includes("/") ? getModelEnvVars(model) : [];
 }
 async function checkOne(params) {
   const value2 = process.env[params.envVar];
   if (!value2) return null;
+  const hostOverride = HOST_OVERRIDES[params.envVar];
+  if (hostOverride && hasEnvVar4(hostOverride)) return null;
   if (params.envVar === "CLAUDE_CODE_OAUTH_TOKEN") {
     const preflight = await preflightClaudeSubscription({
       token: value2,
@@ -194013,7 +194115,10 @@ var JsonPayload = type({
   // optional so a payload from an older server build (pre-`checkRun`) still parses
   // against a newer action across a rolling deploy.
   "checkRun?": type({ id: "string" }).or("undefined"),
-  "generateSummary?": "boolean | undefined"
+  "generateSummary?": "boolean | undefined",
+  // optional so a payload from a pre-canary server build still parses against a
+  // newer action across a rolling deploy.
+  "codexArm?": "boolean | undefined"
 });
 var COLLABORATOR_PERMISSIONS = ["admin", "maintain", "write"];
 function isCollaborator(event) {
@@ -194142,6 +194247,7 @@ function resolvePayload(resolvedPromptInput, repoSettings) {
     progressComment: jsonPayload?.progressComment,
     checkRun: jsonPayload?.checkRun,
     generateSummary: jsonPayload?.generateSummary,
+    codexArm: jsonPayload?.codexArm,
     // permissions: inputs > repoSettings > fallbacks
     push: inputs.push ?? repoSettings.push ?? "restricted",
     shell: resolvedShell,
@@ -196086,8 +196192,12 @@ async function main() {
         const agent2 = resolveAgent({
           model: resolvedModel,
           proxyModel: payload.proxyModel,
-          codexAgent: runContext.repoSettings.codexAgent
+          // the account opt-in and the canary arm are both admissions to codex, so
+          // they OR: an account that opted in explicitly always gets it, and the
+          // canary widens the pool without ever demoting a run that already had it.
+          codexAgent: runContext.repoSettings.codexAgent || payload.codexArm === true
         });
+        toolState.agent = agent2.name;
         const effectiveModel = payload.proxyModel ?? resolvedModel ?? payload.model;
         toolState.model = effectiveModel;
         if (!payload.proxyModel) {
@@ -196304,16 +196414,14 @@ ${instructions.user}` : null,
         const onInnerActivityTimeout = () => {
           if (innerTimeoutFired) return;
           innerTimeoutFired = true;
-          log.info(
-            "\xBB inner activity timeout fired \u2014 stopping MCP server and starting 5min safety-net timer"
-          );
-          mcpHttpServer[Symbol.asyncDispose]().catch((err) => {
-            log.debug(
-              `mcp server stop after inner kill failed: ${err instanceof Error ? err.message : String(err)}`
-            );
-          });
+          log.info("\xBB inner activity timeout fired \u2014 starting 5min safety-net timer");
           safetyNetTimer = setTimeout(
             () => {
+              mcpHttpServer[Symbol.asyncDispose]().catch((err) => {
+                log.debug(
+                  `mcp server stop after inner kill failed: ${err instanceof Error ? err.message : String(err)}`
+                );
+              });
               activityTimeout?.forceReject(
                 "agent still pending 5min after inner activity kill \u2014 forcing exit"
               );
@@ -196322,6 +196430,13 @@ ${instructions.user}` : null,
           );
           safetyNetTimer.unref?.();
         };
+        const onTurnRecovered = () => {
+          if (!innerTimeoutFired) return;
+          innerTimeoutFired = false;
+          if (safetyNetTimer) clearTimeout(safetyNetTimer);
+          safetyNetTimer = void 0;
+          log.info("\xBB inner activity safety net stood down \u2014 turn recovered");
+        };
         const agentPromise = agent2.run({
           payload,
           resolvedModel,
@@ -196342,6 +196457,7 @@ ${instructions.user}` : null,
           toolState,
           apiToken: runContext.apiToken,
           onActivityTimeout: onInnerActivityTimeout,
+          onTurnRecovered,
           onToolUse: (event) => {
             const wasTracked = recordDiffReadFromToolUse({
               state: primaryRepoState(toolState).diffCoverage,
@@ -196439,6 +196555,8 @@ ${instructions.user}` : null,
       if (toolContext) {
         const patch = aggregateUsage(toolState.usageEntries);
         if (toolState.model) patch.model = toolState.model;
+        if (toolState.agent) patch.agent = toolState.agent;
+        if (toolState.credential) patch.credential = toolState.credential;
         if (Object.keys(patch).length > 0) {
           await patchWorkflowRunFields(toolContext, patch);
         }

package/dist/internal.js

@@ -777,9 +777,16 @@ function getModelManagedCredentials(slug) {
   const providerConfig = providers[parsed.provider];
   return providerConfig?.managedCredentials?.slice() ?? [];
 }
+var HARNESS_ONLY_CREDENTIALS = {
+  anthropic: ["ANTHROPIC_AUTH_TOKEN"]
+};
 function modelHasStoredAuth(params) {
   const slug = resolveDisplayAlias(params.model)?.slug ?? params.model;
-  const authVars = [...getModelEnvVars(slug), ...getModelManagedCredentials(slug)];
+  const authVars = [
+    ...getModelEnvVars(slug),
+    ...getModelManagedCredentials(slug),
+    ...HARNESS_ONLY_CREDENTIALS[getModelProvider(slug)] ?? []
+  ];
   return authVars.some((v) => params.secretNames.includes(v));
 }
 var modelAliases = Object.entries(providers).flatMap(
@@ -1542,7 +1549,8 @@ var PROBES = {
     request: (value) => ({
       url: "https://api.anthropic.com/v1/models",
       headers: { "x-api-key": value, "anthropic-version": "2023-06-01" }
-    })
+    }),
+    hostConfigurable: true
   },
   OPENROUTER_API_KEY: {
     request: (value) => ({
@@ -1565,7 +1573,9 @@ async function verifyClaudeSubscription(value) {
   return preflight.status === 401 ? "dead" : "alive";
 }
 function isCredentialProbeable(envVar) {
-  return envVar === "CLAUDE_CODE_OAUTH_TOKEN" || envVar in PROBES;
+  if (envVar === "CLAUDE_CODE_OAUTH_TOKEN") return true;
+  const probe = PROBES[envVar];
+  return probe !== void 0 && !probe.hostConfigurable;
 }
 async function verifyCredential(params) {
   const value = params.value.trim();

package/dist/toolState.d.ts

@@ -1,4 +1,4 @@
-import type { AgentUsage } from "./agents/shared.ts";
+import type { AgentCredential, AgentUsage } from "./agents/shared.ts";
 import type { PrepResult } from "./prep/types.ts";
 import type { AgentDiagnostic } from "./utils/agentHangReport.ts";
 import type { DiffCoverageState } from "./utils/diffCoverage.ts";
@@ -136,6 +136,8 @@ export interface ToolState {
     output?: string | undefined;
     usageEntries: AgentUsage[];
     model?: string | undefined;
+    agent?: string | undefined;
+    credential?: AgentCredential | undefined;
     modelFallback?: {
         from: string;
     } | undefined;

package/dist/utils/activity.d.ts

@@ -50,6 +50,18 @@ export declare const AGENT_ACTIVITY_TIMEOUT_MS = 900000;
  */
 export declare const AGENT_FIRST_EVENT_TIMEOUT_MS = 120000;
 export declare const DEFAULT_ACTIVITY_CHECK_INTERVAL_MS = 5000;
+/**
+ * E2E affordance: shorten a watchdog budget for one dispatch, so the stall path
+ * can be exercised on demand. A real provider stall is not provocable, which is
+ * how #1085 shipped three escalations deep with its salvage branch never once
+ * run end to end.
+ *
+ * **Shorten-only, deliberately.** The value is clamped to the compiled budget,
+ * so an override can make the watchdog stricter but can never relax or disable
+ * it. That keeps this unable to manufacture the zombie run the watchdog exists
+ * to prevent, even if a customer sets it in their own workflow env.
+ */
+export declare function watchdogBudgetMs(compiled: number, envVar: string): number;
 export declare const ACTIVITY_NOISE_PATTERNS: readonly RegExp[];
 export declare function isActivityNoise(chunk: string | Uint8Array): boolean;
 type ActivityTimeoutContext = {

package/dist/utils/credentialCheck.d.ts

@@ -7,7 +7,13 @@
  * provider outage rewrite a working account's configuration.
  */
 export type CredentialVerdict = "alive" | "dead" | "unknown";
-/** whether asking the provider about this credential would tell us anything. */
+/**
+ * Whether asking the provider about this credential would tell us anything —
+ * the paste-time gate, where the caller stores a secret and cannot see the run
+ * env. A `hostConfigurable` credential is excluded here and stays probeable at
+ * run time, because only the runner knows whether a gateway is in play: the
+ * base URL usually lives in the workflow file, which the console never reads.
+ */
 export declare function isCredentialProbeable(envVar: string): boolean;
 /**
  * Ask the provider whether it still accepts this credential. Used at the two

package/dist/utils/patchWorkflowRunFields.d.ts

@@ -10,7 +10,7 @@ import type { ToolContext } from "../mcp/server.ts";
  *    don't parse the audit-only `payload`.
  * Keep in sync with `STRING_FIELDS` in `app/api/workflow-run/[runId]/route.ts`.
  */
-declare const STRING_KEYS: readonly ["prNodeId", "issueNodeId", "reviewNodeId", "planCommentNodeId", "summarySnapshot", "model"];
+declare const STRING_KEYS: readonly ["prNodeId", "issueNodeId", "reviewNodeId", "planCommentNodeId", "summarySnapshot", "model", "agent", "credential"];
 /**
  * Number-valued usage fields — aggregated across all agent calls and PATCHed
  * once at end-of-run. Token counts are Int4 on the DB side (ample for any

package/dist/utils/payload.d.ts

@@ -28,6 +28,7 @@ export declare const JsonPayload: import("arktype/internal/variants/object.ts").
         id: string;
     } | undefined;
     generateSummary?: boolean | undefined;
+    codexArm?: boolean | undefined;
 }, {}>;
 export declare const Inputs: import("arktype/internal/variants/object.ts").ObjectType<{
     prompt?: string | undefined;
@@ -75,6 +76,7 @@ export declare function resolvePayload(resolvedPromptInput: ResolvedPromptInput,
         id: string;
     } | undefined;
     generateSummary: boolean | undefined;
+    codexArm: boolean | undefined;
     push: import("../external.ts").PushPermission;
     shell: import("../external.ts").ShellPermission;
     runStatusCheck: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pullfrog",
-  "version": "0.1.59",
+  "version": "0.1.61",
   "type": "module",
   "bin": {
     "pullfrog": "dist/cli.mjs",