feat: Improving the plan revisions (#465)

* feat(plans): Suggested plan for plan revisions.

* fix: add planCommentId to reduce GitHub API calls.

* Revert "fix: add planCommentId to reduce GitHub API calls."

This reverts commit ef9c24811fa291b12ac3601cc4cd3edb7c9a0fca.

* Improving plan revision: the implementation draft.

* fix schema composition order.

* fix: reusing existing retry helper (action) for reportPlanCommentToRun.

* mv: updatePlanCommentId.

* fix: higher severity for logging error.

* fix: add error handling when calling findExistingPlanCommentIdForIssue.

* feat: improving the revisit plan request detection by adding PLAN_REVISION_VERBS.

* Updating the plan with alternative non-determenistic solution.

* add more verbs to PLAN_REVISION_VERBS.

* fix: supply the previous plan in the event context as previousPlanBody, updating Plan mode instructions.

* fix: adjusting the way PLAN_REVISION_VERBS are used in sentences.

* fix: using GraphQL approach with NodeId to find commentId in findExistingPlanCommentIdForIssue.

* fix: use double word boundaries (both sides).

* fix condition in findExistingPlanCommentIdForIssue.

* fix: rm unused args from findExistingPlanCommentIdForIssue.

* bump the action version.

* fix(plan): rm everything related to approach A.

* fix(plan): No limit for progress comments.

* feat(plan): the new plan.

* Revert: changed to webhook (no longer involved).

* feat: mv plan comment lookup into a new API endpoint.

* Revert: changes to select_mode tool.

* FEAT: The new implementation.

* fix arktype issues.

* fix plan diagram.

* fix(selectMode): e2e type constraints for fetchExistingPlanComment.

* Revert "fix(selectMode): e2e type constraints for fetchExistingPlanComment."

This reverts commit 53f3b6650a9928e3080700faa9eead0052e94333.

* fix(selectMode): type constraints (copy) for fetchExistingPlanComment.

* feat: improving isHttpError helper and reusing it consistently instead of casting.

* address review: remove unconditional retry, add plan comment warning, dedupe type, remove dead guard, fix GraphQL types

* Fix: tightening the PlanEdit guidance.

* fix(select_mode): Providing the agent with existingPlanCommentId as well.

* fix(instructions): Adjusting the primary guidance to prefer Plan mode for issue-related ambiguous requests.

* fix(wiki): updating the delegation docs according to the current instructions.

* fix(instructions): rm implication to call for issue details.

* fix(select_mode): tweak for PlanEdit.

* fix(select_mode): more tweaks to PlanEdit.

* fix(select_mode): tweaks for the order of instructions and context.

* revert: to the state of 5c400efce1f1fec0a0855eeacad2bc3b721fd1bf.

* fix(select_mode): Correcting the guideline.

* rm the plan from the branch (impletemented).

---------

Co-authored-by: pullfrog[bot] <226033991+pullfrog[bot]@users.noreply.github.com>

.github/workflows/test.yml

@@ -39,6 +39,8 @@ jobs:
       GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
       GEMINI_MODEL: ${{ vars.GEMINI_MODEL }}
       OPENCODE_MODEL: ${{ vars.OPENCODE_MODEL }}
+      OPENCODE_MODEL_MINI: ${{ vars.OPENCODE_MODEL_MINI }}
+      OPENCODE_MODEL_MAX: ${{ vars.OPENCODE_MODEL_MAX }}
     steps:
       - uses: actions/checkout@v4
       - uses: pnpm/action-setup@v4

README.md

@@ -1,5 +1,5 @@
-<!-- test preview system --> <!-- test bypass 2 -->
-<p align="center">  
+<!-- test preview system -->
+<p align="center">
   <h1 align="center">
     <picture>
       <source media="(prefers-color-scheme: dark)" srcset="https://pullfrog.com/frog-white-200px.png">
@@ -24,27 +24,26 @@ Pullfrog is a GitHub bot that brings the full power of your favorite coding agen
 
 - **Tag `@pullfrog`** — Tag `@pullfrog` in a comment anywhere in your repo. It will pull in any relevant context using the action's internal MCP server and perform the appropriate task.
 - **Prompt from the web** — Trigger arbitrary tasks from the Pullfrog dashboard
-- **Automated triggers** — Configure Pullfrog to trigger agent runs in response to specific events. Each of these triggers can be associated with custom prompt instructions. 
+- **Automated triggers** — Configure Pullfrog to trigger agent runs in response to specific events. Each of these triggers can be associated with custom prompt instructions.
   - issue created
   - issue labeled
   - PR created
-  - PR review created 
+  - PR review created
   - PR review requested
   - and more...
 
 Pullfrog is the bridge between your preferred coding agents and GitHub. Use it for:
- 
+
 - **🤖 Coding tasks** — Tell `@pullfrog` to implement something and it'll spin up a PR. If CI fails, it'll read the logs and attempt a fix automatically. It'll automatically address any PR reviews too.
 - **🔍 PR review** — Coding agents are great at reviewing PRs. Using the "PR created" trigger, you can configure Pullfrog to auto-review new PRs.
 - **🤙 Issue management** — Via the "issue created" trigger, Pullfrog can automatically respond to common questions, create implementation plans, and link to related issues/PRs. Or (if you're feeling lucky) you can prompt it to immediately attempt a PR addressing new issues.
 - **Literally whatever** — Want to have the agent automatically add docs to all new PRs? Cut a new release with agent-written notes on every commit to `main`? Pullfrog lets you do it.
 
-
 <!-- Features
 - **Agent-agnostic** — Switch between agents with the click of a radio button.
 - ** -->
 
-<!-- 
+<!--
 ## Get started
 
 Install the Pullfrog GitHub App on your personal or organization account. During installation you can choose to limit access to a specific repo or repos. After installation, you'll be redirected to the Pullfrog dashboard where you'll see an onboarding flow. This flow will create your `pullfrog.yml` workflow and prompt you to set up API keys. Once you finish those steps (2 minutes) you're ready to rock.
@@ -124,14 +123,14 @@ on:
   pull_request_review:
     types: [submitted]
   # add other triggers as needed
-  
+
 
 jobs:
   pullfrog:
-    
+
     # trigger conditions (e.g. only run if @pullfrog is mentioned)
     if: contains(github.event.comment.body, '@pullfrog') || contains(github.event.issue.body, '@pullfrog')
-    
+
     permissions:
       id-token: write
       contents: write
@@ -148,3 +147,104 @@ jobs:
 
 </details>
 -->
+
+## Standalone Usage
+
+You can also use `pullfrog/pullfrog` as a step in your own workflows. The action exposes a `result` output that can be consumed by subsequent steps.
+
+### Example: Auto-generate release notes on new tags
+
+```yaml
+name: Release
+on:
+  push:
+    tags: ['v*']
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Generate release notes
+        id: notes
+        uses: pullfrog/pullfrog@v0
+        with:
+          prompt: |
+            Generate release notes for ${{ github.ref_name }}.
+            Compare commits between this tag and the previous tag.
+            Format as markdown: summary paragraph, then ### Features, ### Fixes, ### Breaking Changes sections.
+            Omit empty sections. Be concise.
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+
+      # write to file to avoid shell escaping issues with special characters
+      - name: Create GitHub release
+        run: |
+          notesfile="$RUNNER_TEMP/release-notes-$GITHUB_RUN_ID.md"
+          printf '%s' "$NOTES" > "$notesfile"
+          gh release create ${{ github.ref_name }} --title "${{ github.ref_name }}" --notes-file "$notesfile"
+        env:
+          GH_TOKEN: ${{ github.token }}
+          NOTES: ${{ steps.notes.outputs.result }}
+```
+
+### Example: Structured Output with Zod Schema
+
+You can force the agent to return structured JSON output by providing a JSON schema. This allows you to reliably parse and use the agent's response in subsequent workflow steps.
+
+You can define your JSON schema directly or uou can use any validation library that converts to JSON Schema. Here's an example using [Zod](https://zod.dev):
+
+```yaml
+name: Release Check
+on:
+  pull_request:
+    types: [closed]
+
+jobs:
+  check-release:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: npm install --no-save --no-package-lock zod @actions/core
+
+      - name: Generate Schema
+        id: schema
+        run: |
+          node -e '
+            import { z } from "zod";
+            import { setOutput } from "@actions/core";
+            const schema = z.object({
+              version: z.string().describe("Semantic version number (e.g. 1.0.0)"),
+              isBreaking: z.boolean().describe("Whether this release contains breaking changes"),
+              changelog: z.array(z.string()).describe("List of changes in this release"),
+            });
+            setOutput("schema", JSON.stringify(z.toJSONSchema(schema)));
+          '
+
+      - name: Analyze PR
+        id: analysis
+        uses: pullfrog/pullfrog@v0
+        with:
+          prompt: |
+            Analyze this PR and determine semantic versioning impact.
+            Return a JSON object matching the provided schema.
+          output_schema: ${{ steps.schema.outputs.schema }}
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+
+      - name: Process Result
+        run: |
+          # Parse the JSON result using fromJSON()
+          echo "Version: ${{ fromJSON(steps.analysis.outputs.result).version }}"
+          echo "Breaking: ${{ fromJSON(steps.analysis.outputs.result).isBreaking }}"
+```

action.yml

@@ -30,6 +30,9 @@ inputs:
   shell:
     description: "Shell permission: disabled, restricted (filters secrets from env vars), or enabled. Public repos default to restricted for security; private repos default to enabled."
     required: false
+  output_schema:
+    description: "JSON Schema (draft-07) for structured output validation. When provided, the action output becomes required and must conform to this schema."
+    required: false
   token:
     description: "GitHub-provided token with job-scoped permissions. Do not set this unless you know what you are doing."
     required: false
@@ -37,7 +40,7 @@ inputs:
 
 outputs:
   result:
-    description: "It's set when the prompt explicitly requests it. It can be used to capture an actionable output for the next step in the workflow."
+    description: "It's set when the prompt explicitly requests it and is required when output_schema is provided; use it to capture actionable output for the next workflow step."
 
 runs:
   using: "node24"

agents/opencode.ts

@@ -1,7 +1,7 @@
 // changes to effort level configuration should be reflected in wiki/effort.md and docs/effort.mdx
 // changes to tool permissions should be reflected in wiki/granular-tools.md
 // changes to web search configuration should be reflected in wiki/websearch.md
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { performance } from "node:perf_hooks";
 import { ghPullfrogMcpName } from "../external.ts";
@@ -38,6 +38,159 @@ function detectProviderError(text: string): string | null {
   return null;
 }
 
+type OpenCodeConfig = {
+  mcp?: Record<string, unknown>;
+  permission?: Record<string, unknown>;
+  provider?: Record<string, unknown>;
+  model?: string;
+  enabled_providers?: string[];
+  [key: string]: unknown;
+};
+
+type RecordPropertyContext = {
+  value: unknown;
+  key: string;
+};
+
+type RepoConfigLoadContext = {
+  repoConfigPath: string;
+};
+
+type ProviderFromModelContext = {
+  model: string;
+};
+
+type InlineConfigOverrideContext = {
+  model: string;
+};
+
+type InlineConfigOverride = {
+  providerId: string;
+  content: string;
+};
+
+type ModelOverrideResolutionContext = {
+  effort: AgentRunContext["payload"]["effort"];
+  env: NodeJS.ProcessEnv;
+};
+
+type ModelOverrideResolution = {
+  model: string;
+  source: "OPENCODE_MODEL_MINI" | "OPENCODE_MODEL_MAX" | "OPENCODE_MODEL";
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function getRecordProperty(ctx: RecordPropertyContext): Record<string, unknown> | undefined {
+  if (!isRecord(ctx.value)) {
+    return undefined;
+  }
+  const propertyValue = ctx.value[ctx.key];
+  if (!isRecord(propertyValue)) {
+    return undefined;
+  }
+  return propertyValue;
+}
+
+function loadRepoOpenCodeConfig(ctx: RepoConfigLoadContext): OpenCodeConfig | undefined {
+  if (!existsSync(ctx.repoConfigPath)) {
+    log.info(`» repo opencode.json not found at ${ctx.repoConfigPath}`);
+    return undefined;
+  }
+
+  try {
+    const rawConfig = readFileSync(ctx.repoConfigPath, "utf-8");
+    const parsedConfig = JSON.parse(rawConfig);
+    if (!isRecord(parsedConfig)) {
+      log.warning(`» repo opencode.json is not an object: ${ctx.repoConfigPath}`);
+      return undefined;
+    }
+
+    const providerConfig = getRecordProperty({ value: parsedConfig, key: "provider" });
+    if (providerConfig) {
+      const providerNames = Object.keys(providerConfig);
+      log.info(`» repo opencode provider config detected: ${providerNames.join(", ")}`);
+    }
+
+    const result: OpenCodeConfig = parsedConfig;
+    log.info(`» loaded repo opencode.json from ${ctx.repoConfigPath}`);
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log.warning(`» failed to parse repo opencode.json at ${ctx.repoConfigPath}: ${errorMessage}`);
+    return undefined;
+  }
+}
+
+function parseProviderFromModel(ctx: ProviderFromModelContext): string | undefined {
+  const trimmedModel = ctx.model.trim();
+  const slashIndex = trimmedModel.indexOf("/");
+  if (slashIndex <= 0) {
+    return undefined;
+  }
+  const providerId = trimmedModel.slice(0, slashIndex).trim().toLowerCase();
+  if (!providerId) {
+    return undefined;
+  }
+  return providerId;
+}
+
+function buildInlineConfigOverride(
+  ctx: InlineConfigOverrideContext
+): InlineConfigOverride | undefined {
+  const providerId = parseProviderFromModel({ model: ctx.model });
+  if (!providerId) {
+    return undefined;
+  }
+  const inlineConfig: OpenCodeConfig = {
+    model: ctx.model,
+    enabled_providers: [providerId],
+  };
+  return {
+    providerId,
+    content: JSON.stringify(inlineConfig),
+  };
+}
+
+function readNonEmptyEnvVar(ctx: { env: NodeJS.ProcessEnv; name: string }): string | undefined {
+  const value = ctx.env[ctx.name];
+  if (!value) {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  return trimmed;
+}
+
+function resolveModelOverride(
+  ctx: ModelOverrideResolutionContext
+): ModelOverrideResolution | undefined {
+  if (ctx.effort === "mini") {
+    const miniModel = readNonEmptyEnvVar({ env: ctx.env, name: "OPENCODE_MODEL_MINI" });
+    if (miniModel) {
+      return { model: miniModel, source: "OPENCODE_MODEL_MINI" };
+    }
+  }
+
+  if (ctx.effort === "max") {
+    const maxModel = readNonEmptyEnvVar({ env: ctx.env, name: "OPENCODE_MODEL_MAX" });
+    if (maxModel) {
+      return { model: maxModel, source: "OPENCODE_MODEL_MAX" };
+    }
+  }
+
+  const baseModel = readNonEmptyEnvVar({ env: ctx.env, name: "OPENCODE_MODEL" });
+  if (!baseModel) {
+    return undefined;
+  }
+
+  return { model: baseModel, source: "OPENCODE_MODEL" };
+}
+
 async function installOpencode(): Promise<string> {
   return await installFromNpmTarball({
     packageName: "opencode-ai",
@@ -66,13 +219,18 @@ export const opencode = agent({
     // this is critical for debugging since opencode run suppresses errors by default (Issue #752).
     const args = ["run", ctx.instructions.full, "--format", "json", "--print-logs"];
 
-    // only override model when OPENCODE_MODEL is set (e.g., test environments with
-    // restricted API quotas). in production, OpenCode auto-selects the best available
-    // model based on which provider API keys are present.
-    const modelOverride = process.env.OPENCODE_MODEL;
+    // resolve model override from environment.
+    // precedence:
+    // 1) effort-specific overrides (OPENCODE_MODEL_MINI / OPENCODE_MODEL_MAX)
+    // 2) OPENCODE_MODEL fallback
+    // 3) OpenCode auto-select
+    const modelOverride = resolveModelOverride({
+      effort: ctx.payload.effort,
+      env: process.env,
+    });
     if (modelOverride) {
-      args.push("--model", modelOverride);
-      log.info(`» model: ${modelOverride} (override)`);
+      args.push("--model", modelOverride.model);
+      log.info(`» model: ${modelOverride.model} (override via ${modelOverride.source})`);
     } else {
       log.info(`» model: auto-selected by OpenCode`);
     }
@@ -89,6 +247,31 @@ export const opencode = agent({
       GOOGLE_GENERATIVE_AI_API_KEY:
         process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GEMINI_API_KEY,
     };
+
+    if (modelOverride) {
+      const inlineOverride = buildInlineConfigOverride({ model: modelOverride.model });
+      if (inlineOverride) {
+        env.OPENCODE_CONFIG_CONTENT = inlineOverride.content;
+        log.info(
+          `» OpenCode inline config override enabled: provider=${inlineOverride.providerId}, model=${modelOverride.model}`
+        );
+      } else {
+        log.warning(
+          `» skipping OpenCode inline config override: unable to parse provider from model "${modelOverride.model}"`
+        );
+      }
+    }
+
+    const hasOpenRouterKey = Boolean(env.OPENROUTER_API_KEY);
+    const hasAnthropicKey = Boolean(env.ANTHROPIC_API_KEY);
+    const hasOpenAiKey = Boolean(env.OPENAI_API_KEY);
+    const hasGoogleKey = Boolean(
+      env.GOOGLE_API_KEY || env.GEMINI_API_KEY || env.GOOGLE_GENERATIVE_AI_API_KEY
+    );
+    log.info(
+      `» provider key presence: OPENROUTER=${hasOpenRouterKey ? "set" : "unset"}, ANTHROPIC=${hasAnthropicKey ? "set" : "unset"}, OPENAI=${hasOpenAiKey ? "set" : "unset"}, GOOGLE=${hasGoogleKey ? "set" : "unset"}`
+    );
+
     // OpenCode doesn't support GitHub App installation tokens
     delete env.GITHUB_TOKEN;
 
@@ -194,7 +377,7 @@ export const opencode = agent({
             lastProviderError = providerError;
             log.info(`» provider error detected (${providerError}): ${trimmed.substring(0, 500)}`);
           } else {
-            // OpenCode's --print-logs output goes to stderr. demote internal
+            //agent OpenCode's --print-logs output goes to stderr. demote internal
             // INFO/DEBUG bus traffic to debug so it doesn't drown out tool
             // call logs in the GitHub Actions step output.
             log.debug(trimmed);
@@ -254,6 +437,15 @@ export const opencode = agent({
         };
       }
 
+      if (eventCount === 0 && lastProviderError) {
+        return {
+          success: false,
+          output: finalOutput || output,
+          error: `provider error: ${lastProviderError}`,
+          usage,
+        };
+      }
+
       return {
         success: true,
         output: finalOutput || output,
@@ -301,28 +493,41 @@ function configureOpenCode(ctx: AgentRunContext): void {
   const configDir = join(ctx.tmpdir, ".config", "opencode");
   mkdirSync(configDir, { recursive: true });
   const configPath = join(configDir, "opencode.json");
+  const repoConfigPath = join(process.cwd(), "opencode.json");
+  const repoConfig = loadRepoOpenCodeConfig({ repoConfigPath });
+  if (repoConfig?.model) {
+    log.info(`» repo opencode model configured: ${repoConfig.model}`);
+  }
 
   // build MCP servers config
-  const opencodeMcpServers = {
-    [ghPullfrogMcpName]: { type: "remote" as const, url: ctx.mcpServerUrl },
-  };
+  const opencodeMcpServers: Record<string, unknown> = {};
+  const repoMcpServers = getRecordProperty({ value: repoConfig, key: "mcp" });
+  if (repoMcpServers) {
+    Object.assign(opencodeMcpServers, repoMcpServers);
+  }
+  opencodeMcpServers[ghPullfrogMcpName] = { type: "remote" as const, url: ctx.mcpServerUrl };
 
   // build permission object based on tool permissions
   // note: OpenCode has no built-in web search tool
   const shell = ctx.payload.shell;
-  const permission = {
-    edit: "deny",
-    read: "deny",
-    bash: shell !== "enabled" ? "deny" : "allow",
-    webfetch: ctx.payload.web === "disabled" ? "deny" : "allow",
-    external_directory: "deny",
-  };
+  const permission: Record<string, unknown> = {};
+  const repoPermission = getRecordProperty({ value: repoConfig, key: "permission" });
+  if (repoPermission) {
+    Object.assign(permission, repoPermission);
+  }
+  permission.edit = "deny";
+  permission.read = "deny";
+  permission.bash = shell !== "enabled" ? "deny" : "allow";
+  permission.webfetch = ctx.payload.web === "disabled" ? "deny" : "allow";
+  permission.external_directory = "deny";
 
   // build complete config in one object
-  const config = {
-    mcp: opencodeMcpServers,
-    permission,
-  };
+  const config: OpenCodeConfig = {};
+  if (repoConfig) {
+    Object.assign(config, repoConfig);
+  }
+  config.mcp = opencodeMcpServers;
+  config.permission = permission;
 
   const configJson = JSON.stringify(config, null, 2);
   try {

entry.ts

@@ -4,9 +4,15 @@
  * entry point for pullfrog/pullfrog - unified action
  */
 
+import { dirname } from "node:path";
 import * as core from "@actions/core";
 import { main } from "./main.ts";
 
+// GitHub Actions runs the action entry point with the node24 binary specified
+// in action.yml, but doesn't add that binary's directory to PATH. Without this,
+// spawned processes (pnpm, npm, etc.) resolve to the runner's default node (v20).
+process.env.PATH = `${dirname(process.execPath)}:${process.env.PATH}`;
+
 async function run(): Promise<void> {
   try {
     const result = await main();
@@ -14,10 +20,6 @@ async function run(): Promise<void> {
     if (!result.success) {
       throw new Error(result.error || "Agent execution failed");
     }
-
-    if (result.result) {
-      core.setOutput("result", result.result);
-    }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
     core.setFailed(`Action failed: ${errorMessage}`);

external.ts

@@ -229,8 +229,8 @@ interface FixReviewEvent extends BasePayloadEvent {
   issue_number: number;
   is_pr: true;
   review_id: number;
-  /** username of the person who triggered this action - use with get_review_comments approved_by */
-  triggerer: string;
+  /** when true, only address comments the triggerer approved with 👍 (vs all comments) */
+  approved_only?: boolean | undefined;
 }
 
 interface ImplementPlanEvent extends BasePayloadEvent {
@@ -241,6 +241,17 @@ interface ImplementPlanEvent extends BasePayloadEvent {
   body: string | null;
 }
 
+interface PullRequestSynchronizeEvent extends BasePayloadEvent {
+  trigger: "pull_request_synchronize";
+  issue_number: number;
+  is_pr: true;
+  title: string;
+  body: string | null;
+  branch: string;
+  /** SHA before the push -- used to compute incremental diff via `git diff before_sha...HEAD` */
+  before_sha: string;
+}
+
 interface UnknownEvent extends BasePayloadEvent {
   trigger: "unknown";
 }
@@ -250,6 +261,7 @@ interface UnknownEvent extends BasePayloadEvent {
 export type PayloadEvent =
   | PullRequestOpenedEvent
   | PullRequestReadyForReviewEvent
+  | PullRequestSynchronizeEvent
   | PullRequestReviewRequestedEvent
   | PullRequestReviewSubmittedEvent
   | PullRequestReviewCommentCreatedEvent
@@ -273,7 +285,7 @@ export interface WriteablePayload {
   /** the user's actual request (body if @pullfrog tagged) */
   prompt: string;
   /** github username of the human who triggered this workflow run */
-  triggeringUser?: string | undefined;
+  triggerer?: string | undefined;
   /** event-level instructions for this trigger type (flag-expanded server-side) */
   eventInstructions?: string | undefined;
   /** repo-level instructions (flag-expanded server-side) */

get-installation-token/entry

@@ -25507,6 +25507,7 @@ var core3 = __toESM(require_core(), 1);
 // utils/log.ts
 var core = __toESM(require_core(), 1);
 var import_table = __toESM(require_src(), 1);
+import { AsyncLocalStorage } from "node:async_hooks";
 
 // utils/globals.ts
 import { existsSync } from "node:fs";
@@ -25515,6 +25516,20 @@ var isGitHubActions = !!process.env.GITHUB_ACTIONS;
 var isInsideDocker = existsSync("/.dockerenv");
 
 // utils/log.ts
+var logContext = new AsyncLocalStorage();
+var MAGENTA = "\x1B[35m";
+var RESET = "\x1B[0m";
+function prefixLines(message) {
+  const ctx = logContext.getStore();
+  if (!ctx) return message;
+  const colored = `${MAGENTA}${ctx.prefix}${RESET} `;
+  return message.split("\n").map((line) => `${colored}${line}`).join("\n");
+}
+function prefixPlain(name) {
+  const ctx = logContext.getStore();
+  if (!ctx) return name;
+  return `${ctx.prefix} ${name}`;
+}
 var isRunnerDebugEnabled = () => core.isDebug();
 var isLocalDebugEnabled = () => process.env.LOG_LEVEL === "debug" || process.env.ACTIONS_STEP_DEBUG === "true";
 var isDebugEnabled = () => isLocalDebugEnabled() || isRunnerDebugEnabled();
@@ -25530,10 +25545,11 @@ ${arg.stack}`;
   }).join(" ");
 }
 function startGroup2(name) {
+  const prefixed = prefixPlain(name);
   if (isGitHubActions) {
-    core.startGroup(name);
+    core.startGroup(prefixed);
   } else {
-    console.group(name);
+    console.group(prefixed);
   }
 }
 function endGroup2() {
@@ -25606,7 +25622,7 @@ function boxString(text, options) {
 }
 function box(text, options) {
   const boxContent = boxString(text, options);
-  core.info(boxContent);
+  core.info(prefixLines(boxContent));
 }
 function printTable(rows, options) {
   const { title } = options || {};
@@ -25620,42 +25636,42 @@ function printTable(rows, options) {
   );
   const formatted = (0, import_table.table)(tableData);
   if (title) {
-    core.info(`
-${title}`);
+    core.info(prefixLines(`
+${title}`));
   }
-  core.info(`
+  core.info(prefixLines(`
 ${formatted}
-`);
+`));
 }
 function separator(length = 50) {
   const separatorText = "\u2500".repeat(length);
-  core.info(separatorText);
+  core.info(prefixLines(separatorText));
 }
 var log = {
   /** Print info message */
   info: (...args) => {
-    core.info(`${ts()}${formatArgs(args)}`);
+    core.info(prefixLines(`${ts()}${formatArgs(args)}`));
   },
   /** Print a warning message. Use only for warnings that should be displayed in the job summary. */
   warning: (...args) => {
-    core.warning(`${ts()}${formatArgs(args)}`);
+    core.warning(prefixLines(`${ts()}${formatArgs(args)}`));
   },
   /** Print an error message. Use only for errors that should be displayed in the job summary. */
   error: (...args) => {
-    core.error(`${ts()}${formatArgs(args)}`);
+    core.error(prefixLines(`${ts()}${formatArgs(args)}`));
   },
   /** Print success message */
   success: (...args) => {
-    core.info(`${ts()}\xBB ${formatArgs(args)}`);
+    core.info(prefixLines(`${ts()}\xBB ${formatArgs(args)}`));
   },
   /** Print debug message (only when debug mode is enabled) */
   debug: (...args) => {
     if (isRunnerDebugEnabled()) {
-      core.debug(formatArgs(args));
+      core.debug(prefixLines(formatArgs(args)));
       return;
     }
     if (isLocalDebugEnabled()) {
-      core.info(`${ts()}[DEBUG] ${formatArgs(args)}`);
+      core.info(prefixLines(`${ts()}[DEBUG] ${formatArgs(args)}`));
     }
   },
   /** Print a formatted box with text */
@@ -25683,8 +25699,8 @@ function formatJsonValue(value) {
 }
 
 // utils/github.ts
-var core2 = __toESM(require_core(), 1);
 import { createSign } from "node:crypto";
+var core2 = __toESM(require_core(), 1);
 
 // utils/apiUrl.ts
 function isLocalUrl(url) {
@@ -25914,6 +25930,17 @@ function parseRepoContext() {
   }
   return { owner, name };
 }
+function emptyResourceUsage() {
+  return {
+    requestCount: 0,
+    rateLimitRemaining: null,
+    rateLimitResetMs: null
+  };
+}
+var usageByResource = {
+  core: emptyResourceUsage(),
+  graphql: emptyResourceUsage()
+};
 
 // utils/token.ts
 async function revokeGitHubInstallationToken(token) {

internal/index.ts

@@ -20,6 +20,8 @@ export {
   Effort,
   ghPullfrogMcpName,
 } from "../external.ts";
+export type { Mode } from "../modes.ts";
+export { modes } from "../modes.ts";
 export type {
   AgentInfo,
   BuildPullfrogFooterParams,
@@ -30,7 +32,7 @@ export {
   PULLFROG_DIVIDER,
   stripExistingFooter,
 } from "../utils/buildPullfrogFooter.ts";
-
+export type { ResourceUsage, UsageSummary } from "../utils/github.ts";
 export {
   isValidTimeString,
   parseTimeString,

main.ts

@@ -1,4 +1,6 @@
 // changes to tool permissions should be reflected in wiki/granular-tools.md
+
+import * as core from "@actions/core";
 import { initToolState, startMcpHttpServer, type ToolState } from "./mcp/server.ts";
 import { computeModes } from "./modes.ts";
 import {
@@ -12,8 +14,9 @@ import { validateAgentApiKey } from "./utils/apiKeys.ts";
 import { resolveBody } from "./utils/body.ts";
 import { formatUsageSummary, log, writeSummary } from "./utils/cli.ts";
 import { reportErrorToComment } from "./utils/errorReport.ts";
+import { onExitSignal } from "./utils/exitHandler.ts";
 import { resolveGit } from "./utils/gitAuth.ts";
-import { createOctokit } from "./utils/github.ts";
+import { createOctokit, writeGitHubUsageSummaryToFile } from "./utils/github.ts";
 import { resolveInstructions } from "./utils/instructions.ts";
 import { executeLifecycleHook } from "./utils/lifecycle.ts";
 import { normalizeEnv } from "./utils/normalizeEnv.ts";
@@ -36,6 +39,23 @@ export interface MainResult {
   result?: string | undefined;
 }
 
+function resolveOutputSchema(): Record<string, unknown> | undefined {
+  const raw = core.getInput("output_schema");
+  if (!raw) return undefined;
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`invalid output_schema: not valid JSON`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`invalid output_schema: must be a JSON object`);
+  }
+  log.info("» structured output schema provided — output will be required");
+  return parsed as Record<string, unknown>;
+}
+
 async function writeJobSummary(toolState: ToolState): Promise<void> {
   const usageSummary = formatUsageSummary(toolState.usageEntries);
   const summaryParts = [toolState.lastProgressBody, usageSummary].filter(Boolean);
@@ -48,6 +68,12 @@ export async function main(): Promise<MainResult> {
   // normalize env var names to uppercase (handles case-insensitive workflow files)
   normalizeEnv();
 
+  // write usage summary on SIGINT/SIGTERM so the worker can read it after sandbox.exec
+  const usageSummaryPath = process.env.PULLFROG_USAGE_SUMMARY_PATH;
+  if (usageSummaryPath) {
+    onExitSignal(() => writeGitHubUsageSummaryToFile(usageSummaryPath));
+  }
+
   const timer = new Timer();
   let activityTimeout: ActivityTimeout | null = null;
 
@@ -144,6 +170,8 @@ export async function main(): Promise<MainResult> {
 
     const modes = [...computeModes(), ...runContext.repoSettings.modes];
 
+    const outputSchema = resolveOutputSchema();
+
     // mcpServerUrl and tmpdir are set after server starts — delegate tool reads them at call time
     const toolContext = {
       repo: runContext.repo,
@@ -155,13 +183,14 @@ export async function main(): Promise<MainResult> {
       agent,
       modes,
       postCheckoutScript: runContext.repoSettings.postCheckoutScript,
+      prApproveEnabled: runContext.repoSettings.prApproveEnabled,
       toolState,
       runId: runInfo.runId,
       jobId: runInfo.jobId,
       mcpServerUrl: "",
       tmpdir,
     };
-    await using mcpHttpServer = await startMcpHttpServer(toolContext);
+    await using mcpHttpServer = await startMcpHttpServer(toolContext, { outputSchema });
     toolContext.mcpServerUrl = mcpHttpServer.url;
     log.info(`» MCP server started at ${mcpHttpServer.url}`);
     timer.checkpoint("mcpServer");
@@ -170,6 +199,7 @@ export async function main(): Promise<MainResult> {
       payload,
       repo: runContext.repo,
       modes,
+      outputSchema,
     });
     // log instructions as soon as they are fully resolved
     const logParts = [
@@ -228,17 +258,24 @@ export async function main(): Promise<MainResult> {
       toolState.usageEntries.push(result.usage);
     }
 
-    await writeJobSummary(toolState);
-
-    // emit structured output marker for test validation
-    if (toolState.output) {
-      log.info(`::pullfrog-output::${Buffer.from(toolState.output).toString("base64")}`);
+    // validate this before writing job summary to avoid masking the error
+    if (outputSchema && !toolState.output) {
+      throw new Error(
+        "output_schema was provided but agent did not call set_output — structured output is required"
+      );
     }
 
-    return {
-      ...handleAgentResult(result),
-      result: toolState.output,
-    };
+    await writeJobSummary(toolState);
+
+    if (toolState.output) {
+      core.setOutput("result", toolState.output);
+    }
+
+    return await handleAgentResult({
+      result,
+      toolState,
+      silent: payload.event.silent ?? false,
+    });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "unknown error occurred";
     killTrackedChildren();
@@ -260,5 +297,8 @@ export async function main(): Promise<MainResult> {
     };
   } finally {
     activityTimeout?.stop();
+    if (usageSummaryPath) {
+      await writeGitHubUsageSummaryToFile(usageSummaryPath);
+    }
   }
 }

mcp/__snapshots__/reviewComments.test.ts.snap

@@ -1,11 +1,40 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
-exports[`formatReviewThreads > formats thread blocks with TOC and correct line numbers > content 1`] = `
-"# Review Threads (1) for PR #49 - Review 3485940013 by cursor
+exports[`getFormattedReviewThreads > formats body-only review > content 1`] = `
+"# Review Threads (0) for PR #64 - Review 3531000326 by pullfrog[bot]
+
+## Review Body
+
+This PR looks great. The retry logic is well-implemented and the tests are comprehensive.
+
+---
+"
+`;
+
+exports[`getFormattedReviewThreads > formats body-only review > toc 1`] = `""`;
+
+exports[`getFormattedReviewThreads > formats thread blocks with TOC and correct line numbers > content 1`] = `
+"# Review Threads (1) for PR #49 - Review 3485940013 by cursor[bot]
 
 ## TOC
 
-- .github/workflows/test.yml:7 → lines 9-36
+- .github/workflows/test.yml:7 → lines 25-52
+
+## Review Body
+
+### This is the final PR Bugbot will review for you during this billing cycle
+
+Your free Bugbot reviews will reset on November 30
+
+<details>
+<summary>Details</summary>
+
+Your team is on the Bugbot Free tier. On this plan, Bugbot will review limited PRs each billing cycle for each member of your team.
+
+To receive Bugbot reviews on all of your PRs, visit the [Cursor dashboard](https://www.cursor.com/dashboard?tab=bugbot) to activate Pro and start your 14-day free trial.
+</details>
+
+
 
 ---
 
@@ -39,4 +68,4 @@ LOCATIONS END -->
 "
 `;
 
-exports[`formatReviewThreads > formats thread blocks with TOC and correct line numbers > toc 1`] = `"- .github/workflows/test.yml:7 → lines 9-36"`;
+exports[`getFormattedReviewThreads > formats thread blocks with TOC and correct line numbers > toc 1`] = `"- .github/workflows/test.yml:7 → lines 25-52"`;

mcp/checkout.ts

@@ -206,6 +206,31 @@ export async function checkoutPrBranch(
   // this avoids naming conflicts and makes push config simpler
   const localBranch = `pr-${pullNumber}`;
 
+  // compute deepen depth for shallow clones. actions/checkout uses depth=1
+  // by default, which breaks rebase/log because git can't find the merge base.
+  // use the GitHub compare API to fetch exactly enough history.
+  const isShallow =
+    $("git", ["rev-parse", "--is-shallow-repository"], { log: false }).trim() === "true";
+  let deepenArgs: string[] = [];
+  if (isShallow) {
+    let depth = 1000; // fallback
+    try {
+      const comparison = await octokit.rest.repos.compareCommits({
+        owner,
+        repo: name,
+        base: baseBranch,
+        head: `pull/${pullNumber}/head`,
+      });
+      depth = comparison.data.behind_by + 10;
+      log.debug(
+        `» PR is ${comparison.data.behind_by} commits behind ${baseBranch}, deepening by ${depth}`
+      );
+    } catch {
+      log.debug(`» compare API failed, falling back to --deepen=${depth}`);
+    }
+    deepenArgs = [`--deepen=${depth}`];
+  }
+
   // check if we're already on the correct commit (not just branch name)
   // this handles fork PRs where head branch name might match base branch name
   const currentSha = $("git", ["rev-parse", "HEAD"], { log: false }).trim();
@@ -216,7 +241,7 @@ export async function checkoutPrBranch(
   } else {
     // fetch base branch so origin/<base> exists for diff operations
     log.debug(`» fetching base branch (${baseBranch})...`);
-    $git("fetch", ["--no-tags", "origin", baseBranch], {
+    $git("fetch", [...deepenArgs, "--no-tags", "origin", baseBranch], {
       token: gitToken,
       restricted: shell !== "enabled",
     });
@@ -241,7 +266,7 @@ export async function checkoutPrBranch(
   // fetch if we skipped checkout (already on branch) - otherwise already fetched above
   if (alreadyOnBranch) {
     log.debug(`» fetching base branch (${baseBranch})...`);
-    $git("fetch", ["--no-tags", "origin", baseBranch], {
+    $git("fetch", [...deepenArgs, "--no-tags", "origin", baseBranch], {
       token: gitToken,
       restricted: shell !== "enabled",
     });

mcp/comment.ts

@@ -1,11 +1,43 @@
 import { type } from "arktype";
 import type { Agent } from "../agents/index.ts";
+import { apiFetch } from "../utils/apiFetch.ts";
 import { getApiUrl } from "../utils/apiUrl.ts";
 import { buildPullfrogFooter, stripExistingFooter } from "../utils/buildPullfrogFooter.ts";
+import { log } from "../utils/cli.ts";
 import { type OctokitWithPlugins, parseRepoContext } from "../utils/github.ts";
+import { retry } from "../utils/retry.ts";
 import type { ToolContext } from "./server.ts";
 import { execute, tool } from "./shared.ts";
 
+/** PATCH workflow-run with plan comment node_id so plan revisions can update that comment in place. */
+async function updatePlanCommentId(ctx: ToolContext, planCommentNodeId: string): Promise<void> {
+  if (ctx.runId === undefined || !ctx.apiToken) return;
+  try {
+    await retry(
+      async () => {
+        const response = await apiFetch({
+          path: `/api/workflow-run/${ctx.runId}`,
+          method: "PATCH",
+          headers: {
+            authorization: `Bearer ${ctx.apiToken}`,
+            "content-type": "application/json",
+          },
+          body: JSON.stringify({ planCommentNodeId }),
+          signal: AbortSignal.timeout(10_000),
+        });
+        if (!response.ok) throw new Error(`PATCH workflow-run: ${response.status}`);
+      },
+      {
+        maxAttempts: 3,
+        delayMs: 2000,
+        label: "updatePlanCommentId",
+      }
+    );
+  } catch (error) {
+    log.warning(`updatePlanCommentId exhausted retries: ${error}`);
+  }
+}
+
 /**
  * The prefix text for the initial "leaping into action" comment.
  * This is used to identify if a comment is still in its initial state
@@ -25,7 +57,9 @@ async function buildCommentFooter({
   customParts,
 }: BuildCommentFooterParams): Promise<string> {
   const repoContext = parseRepoContext();
-  const runId = process.env.GITHUB_RUN_ID;
+  const runId = process.env.GITHUB_RUN_ID
+    ? Number.parseInt(process.env.GITHUB_RUN_ID, 10)
+    : undefined;
 
   let jobId: string | undefined;
   if (runId && octokit) {
@@ -34,7 +68,7 @@ async function buildCommentFooter({
       const { data: jobs } = await octokit.rest.actions.listJobsForWorkflowRun({
         owner: repoContext.owner,
         repo: repoContext.name,
-        run_id: parseInt(runId, 10),
+        run_id: runId,
       });
       // use the first job's ID available
       jobId = jobs.jobs[0]?.id.toString();
@@ -84,15 +118,21 @@ export async function addFooter(ctx: AddFooterCtx, body: string): Promise<string
 export const Comment = type({
   issueNumber: type.number.describe("the issue number to comment on"),
   body: type.string.describe("the comment body content"),
+  type: type
+    .enumerated("Plan", "Comment")
+    .describe(
+      "Plan: record this comment as the plan for this run (use report_progress for progress/plan updates on the current run). Comment: regular comment (default)."
+    )
+    .optional(),
 });
 
 export function CreateCommentTool(ctx: ToolContext) {
   return tool({
     name: "create_issue_comment",
     description:
-      "Create a comment on a GitHub issue. NOTE: Do NOT use this for progress updates or status summaries - use report_progress instead, which updates the existing progress comment.",
+      "Create a comment on a GitHub issue. For progress/plan updates on the current run use report_progress instead. Use type: 'Plan' only when creating a standalone plan comment to record as this run's plan.",
     parameters: Comment,
-    execute: execute(async ({ issueNumber, body }) => {
+    execute: execute(async ({ issueNumber, body, type: commentType }) => {
       const bodyWithFooter = await addFooter(ctx, body);
 
       const result = await ctx.octokit.rest.issues.createComment({
@@ -102,6 +142,10 @@ export function CreateCommentTool(ctx: ToolContext) {
         body: bodyWithFooter,
       });
 
+      if (commentType === "Plan" && result.data.node_id) {
+        await updatePlanCommentId(ctx, result.data.node_id);
+      }
+
       return {
         success: true,
         commentId: result.data.id,
@@ -145,6 +189,9 @@ export function EditCommentTool(ctx: ToolContext) {
 
 export const ReportProgress = type({
   body: type.string.describe("the progress update content to share"),
+  "target_plan_comment?": type("boolean").describe(
+    "when true, update the existing plan comment (from select_mode lookup) instead of the progress comment; use when editing an existing plan"
+  ),
 });
 
 /**
@@ -159,13 +206,14 @@ export const ReportProgress = type({
  */
 export async function reportProgress(
   ctx: ToolContext,
-  { body }: { body: string }
+  params: { body: string; target_plan_comment?: boolean }
 ): Promise<{
   commentId?: number;
   url?: string;
   body: string;
   action: "created" | "updated" | "skipped";
 }> {
+  const { body, target_plan_comment } = params;
   // always track the body for job summary
   ctx.toolState.lastProgressBody = body;
 
@@ -175,10 +223,50 @@ export async function reportProgress(
     return { body, action: "skipped" };
   }
 
-  const existingCommentId = ctx.toolState.progressCommentId;
-  const issueNumber = ctx.toolState.issueNumber ?? ctx.payload.event.issue_number;
+  const issueNumber = ctx.payload.event.issue_number ?? ctx.toolState.issueNumber;
   const isPlanMode = ctx.toolState.selectedMode === "Plan";
 
+  // when editing existing plan: update the plan comment from tool state (set by select_mode)
+  if (target_plan_comment === true && ctx.toolState.existingPlanCommentId === undefined) {
+    log.warning("target_plan_comment requested but no existingPlanCommentId in tool state");
+  }
+  if (target_plan_comment === true && ctx.toolState.existingPlanCommentId !== undefined) {
+    const commentId = ctx.toolState.existingPlanCommentId;
+    const customParts =
+      isPlanMode && issueNumber !== undefined
+        ? [buildImplementPlanLink(ctx.repo.owner, ctx.repo.name, issueNumber, commentId)]
+        : undefined;
+    const bodyWithoutFooter = stripExistingFooter(body);
+    const footer = await buildCommentFooter({
+      agent: ctx.agent,
+      octokit: ctx.octokit,
+      customParts,
+    });
+    const bodyWithFooter = `${bodyWithoutFooter}${footer}`;
+
+    const result = await ctx.octokit.rest.issues.updateComment({
+      owner: ctx.repo.owner,
+      repo: ctx.repo.name,
+      comment_id: commentId,
+      body: bodyWithFooter,
+    });
+
+    ctx.toolState.wasUpdated = true;
+
+    if (isPlanMode && result.data.node_id) {
+      await updatePlanCommentId(ctx, result.data.node_id);
+    }
+
+    return {
+      commentId: result.data.id,
+      url: result.data.html_url,
+      body: result.data.body || "",
+      action: "updated",
+    };
+  }
+
+  const existingCommentId = ctx.toolState.progressCommentId;
+
   // if we already have a progress comment, update it
   if (existingCommentId) {
     const customParts =
@@ -203,6 +291,10 @@ export async function reportProgress(
 
     ctx.toolState.wasUpdated = true;
 
+    if (isPlanMode && result.data.node_id) {
+      await updatePlanCommentId(ctx, result.data.node_id);
+    }
+
     return {
       commentId: result.data.id,
       url: result.data.html_url,
@@ -258,6 +350,10 @@ export async function reportProgress(
       body: bodyWithPlanLink,
     });
 
+    if (updateResult.data.node_id) {
+      await updatePlanCommentId(ctx, updateResult.data.node_id);
+    }
+
     return {
       commentId: updateResult.data.id,
       url: updateResult.data.html_url,
@@ -280,8 +376,12 @@ export function ReportProgressTool(ctx: ToolContext) {
     description:
       "Share progress on the associated GitHub issue/PR. Call this to post updates as you work. The first call creates a comment, subsequent calls update it. Use this throughout your work to keep stakeholders informed.",
     parameters: ReportProgress,
-    execute: execute(async ({ body }) => {
-      const result = await reportProgress(ctx, { body });
+    execute: execute(async (params) => {
+      const reportParams: { body: string; target_plan_comment?: boolean } = { body: params.body };
+      if (params.target_plan_comment !== undefined) {
+        reportParams.target_plan_comment = params.target_plan_comment;
+      }
+      const result = await reportProgress(ctx, reportParams);
 
       if (result.action === "skipped") {
         // no-op: no comment target, but progress is still tracked for job summary

mcp/delegate.ts

@@ -77,7 +77,10 @@ export function DelegateTool(ctx: ToolContext) {
       }
 
       // matched by delegate test validators — update tests if changed
-      log.info(`» delegating ${params.tasks.length} task(s) in parallel (mode=${mode})`);
+      const n = params.tasks.length;
+      log.info(
+        `» delegating ${n} task${n === 1 ? "" : "s"}${n > 1 ? " in parallel" : ""} (mode=${mode})`
+      );
 
       const taskEntries = params.tasks.map((task) => {
         const effort = task.effort ?? "auto";
@@ -100,10 +103,10 @@ export function DelegateTool(ctx: ToolContext) {
       const results: DelegateTaskResult[] = taskEntries.map((entry, i) => {
         const outcome = settled[i];
         const error = outcome.status === "rejected" ? String(outcome.reason) : outcome.value.error;
-        log.debug(
-          `» task "${entry.task.label}" result: output=${entry.subagent.output !== undefined}, status=${entry.subagent.status}`
-        );
-        return buildTaskResult(entry.task.label, entry.effort, entry.subagent, error);
+        const result = buildTaskResult(entry.task.label, entry.effort, entry.subagent, error);
+        const status = result.success ? "succeeded" : "failed";
+        log.box(result.summary, { title: `task "${entry.task.label}" ${status}` });
+        return result;
       });
 
       const succeeded = results.filter((r) => r.success).length;

mcp/git.ts

@@ -108,6 +108,15 @@ export function PushBranchTool(ctx: ToolContext) {
 
       const branch = branchName || $("git", ["rev-parse", "--abbrev-ref", "HEAD"], { log: false });
 
+      // reject push if working tree is dirty — forces agent to commit or discard before pushing
+      const status = $("git", ["status", "--porcelain"], { log: false });
+      if (status) {
+        throw new Error(
+          `push blocked: working tree has uncommitted changes. commit or discard them before pushing.\n\n` +
+            `git status:\n${status}`
+        );
+      }
+
       // validate push destination matches expected URL
       const pushUrl = ctx.toolState.pushUrl;
       if (!pushUrl) {
@@ -138,10 +147,26 @@ export function PushBranchTool(ctx: ToolContext) {
       if (force) {
         log.warning(`force pushing - this will overwrite remote history`);
       }
-      $git("push", pushArgs, {
-        token: ctx.gitToken,
-        restricted: ctx.payload.shell !== "enabled",
-      });
+
+      try {
+        $git("push", pushArgs, {
+          token: ctx.gitToken,
+          restricted: ctx.payload.shell !== "enabled",
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("fetch first") || msg.includes("non-fast-forward")) {
+          throw new Error(
+            `push rejected: the remote branch '${pushDest.remoteBranch}' has new commits you don't have locally.\n\n` +
+              `to resolve this:\n` +
+              `1. use git_fetch to fetch the remote branch: git_fetch({ ref: "${pushDest.remoteBranch}" })\n` +
+              `2. use the git tool to rebase your changes: git({ subcommand: "rebase", args: ["origin/${pushDest.remoteBranch}"] })\n` +
+              `3. resolve any merge conflicts if needed\n` +
+              `4. retry push_branch`
+          );
+        }
+        throw err;
+      }
 
       return {
         success: true,
@@ -157,10 +182,10 @@ export function PushBranchTool(ctx: ToolContext) {
 
 // commands that require authentication - redirect to dedicated tools
 const AUTH_REQUIRED_REDIRECT: Record<string, string> = {
-  push: "Use push_branch tool instead.",
-  fetch: "Use git_fetch tool instead.",
-  pull: "Use git_fetch + git merge instead.",
-  clone: "Repository already cloned. Use checkout_pr for PR branches.",
+  push: "use the push_branch tool instead — it handles authentication and permission checks.",
+  fetch: "use the git_fetch tool instead — it handles authentication.",
+  pull: "use git_fetch to fetch the remote ref, then use this git tool with subcommand 'merge' or 'rebase' locally.",
+  clone: "the repository is already cloned. use checkout_pr for PR branches.",
 };
 
 // SECURITY: subcommands blocked when shell is disabled.
@@ -219,7 +244,7 @@ export function GitTool(ctx: ToolContext) {
 
       const redirect = AUTH_REQUIRED_REDIRECT[subcommand];
       if (redirect) {
-        throw new Error(`git ${subcommand} requires authentication. ${redirect}`);
+        throw new Error(`git ${subcommand} is not available through this tool — ${redirect}`);
       }
 
       // SECURITY: block dangerous subcommands when shell is disabled.

mcp/output.ts

@@ -1,3 +1,5 @@
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+import { Ajv } from "ajv";
 import { type } from "arktype";
 import { log } from "../utils/cli.ts";
 import type { ToolContext } from "./server.ts";
@@ -7,29 +9,75 @@ export const SetOutputParams = type({
   value: type.string.describe("the output value to expose as a GitHub Action output"),
 });
 
-export function SetOutputTool(ctx: ToolContext) {
+type JsonSchema = Record<string, unknown>;
+
+function jsonSchemaToStandardSchema({
+  $schema: _,
+  ...jsonSchema
+}: JsonSchema): StandardJSONSchemaV1<any> & StandardSchemaV1<any> {
+  const ajv = new Ajv();
+  const validate = ajv.compile(jsonSchema);
+
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "json-schema",
+      jsonSchema: {
+        input: () => jsonSchema,
+        output: () => jsonSchema,
+      },
+      validate(input: unknown) {
+        if (validate(input)) {
+          return { value: input };
+        }
+        return {
+          issues: (validate.errors ?? []).map((err) => ({
+            message: `${err.instancePath || "/"}: ${err.message ?? "validation error"}`,
+            path: err.instancePath ? err.instancePath.split("/").filter(Boolean) : [],
+          })),
+        };
+      },
+    },
+  };
+}
+
+function storeOutput(ctx: ToolContext, value: string) {
+  const selfId = ctx.toolState.selfSubagentId;
+  if (selfId) {
+    const subagent = ctx.toolState.subagents.get(selfId);
+    if (subagent) {
+      subagent.output = value;
+      log.debug(`set_output: routed to subagent ${selfId} (value=${value.slice(0, 80)})`);
+      return { success: true, routed: "subagent" as const };
+    }
+    log.warning(
+      `set_output: selfSubagentId=${selfId} but subagent not found in map — routing to action output`
+    );
+  }
+  ctx.toolState.output = value;
+  return { success: true, routed: "action_output" as const };
+}
+
+export function SetOutputTool(ctx: ToolContext, outputSchema?: JsonSchema) {
+  if (outputSchema) {
+    return tool({
+      name: "set_output",
+      description:
+        "Set the structured action output. You MUST call this tool before finishing — the output is required. Pass the output object directly as the tool arguments (no wrapping needed).",
+      parameters: jsonSchemaToStandardSchema(outputSchema),
+      execute: execute(async (params) => {
+        return storeOutput(ctx, JSON.stringify(params));
+      }),
+    });
+  }
+
   return tool({
     name: "set_output",
     description:
-      "Set the action output. When called by a subagent, returns a summary result to the orchestrator. When called in standalone mode, exposes the value as the 'result' GitHub Action output.",
+      "Set the action output. When called by a subagent, returns a summary result to the orchestrator — this is the ONLY way to pass results back. When called by the orchestrator in standalone mode (trigger: unknown), exposes the value as the 'result' GitHub Action output for downstream workflow steps. Do NOT use this for progress reporting — use report_progress instead.",
     parameters: SetOutputParams,
     execute: execute(async (params) => {
-      const selfId = ctx.toolState.selfSubagentId;
-      if (selfId) {
-        const subagent = ctx.toolState.subagents.get(selfId);
-        if (subagent) {
-          subagent.output = params.value;
-          log.debug(
-            `set_output: routed to subagent ${selfId} (value=${params.value.slice(0, 80)})`
-          );
-          return { success: true, routed: "subagent" };
-        }
-        log.warning(
-          `set_output: selfSubagentId=${selfId} but subagent not found in map — routing to action output`
-        );
-      }
-      ctx.toolState.output = params.value;
-      return { success: true, routed: "action_output" };
+      return storeOutput(ctx, params.value);
     }),
   });
 }

mcp/pr.ts

@@ -9,6 +9,9 @@ export const PullRequest = type({
   title: type.string.describe("the title of the pull request"),
   body: type.string.describe("the body content of the pull request"),
   base: type.string.describe("the base branch to merge into (e.g., 'main')"),
+  "draft?": type.boolean.describe(
+    "if true, create the pull request as a draft. use when the user explicitly asks for a draft PR."
+  ),
 });
 
 function buildPrBodyWithFooter(ctx: ToolContext, body: string): string {
@@ -71,10 +74,11 @@ export function CreatePullRequestTool(ctx: ToolContext) {
         body: bodyWithFooter,
         head: currentBranch,
         base: params.base,
+        draft: params.draft ?? false,
       });
 
       // best-effort: request review from the user who triggered the workflow
-      const reviewer = ctx.payload.triggeringUser;
+      const reviewer = ctx.payload.triggerer;
       if (reviewer) {
         try {
           log.debug(`requesting review from ${reviewer} on PR #${result.data.number}`);

mcp/review.ts

@@ -1,5 +1,6 @@
 import type { RestEndpointMethodTypes } from "@octokit/rest";
 import { type } from "arktype";
+import { apiFetch } from "../utils/apiFetch.ts";
 import { getApiUrl } from "../utils/apiUrl.ts";
 import { buildPullfrogFooter } from "../utils/buildPullfrogFooter.ts";
 import { log } from "../utils/cli.ts";
@@ -15,11 +16,18 @@ export const CreatePullRequestReview = type({
       "1-2 sentence high-level summary with urgency level, critical callouts, and feedback about code outside the diff. Specific feedback on diff lines goes in 'comments' array."
     )
     .optional(),
+  approved: type.boolean
+    .describe(
+      "Set to true to submit as an approval. ONLY when the review contains no actionable feedback — neither inline comments nor actionable content in the body. Defaults to false (comment-only review). Rejections are not supported."
+    )
+    .optional(),
   commit_id: type.string
     .describe("Optional SHA of the commit being reviewed. Defaults to latest.")
     .optional(),
   comments: type({
-    path: type.string.describe("The file path to comment on (relative to repo root)"),
+    path: type.string.describe(
+      "The file path to comment on (relative to repo root). Must be a file that appears in the PR diff."
+    ),
     line: type.number.describe(
       "End line of the comment range. For single-line comments, set equal to 'start_line'. Use NEW column from diff format."
     ),
@@ -57,18 +65,28 @@ export function CreatePullRequestReviewTool(ctx: ToolContext) {
       "Only use 'body' for a 1-2 sentence summary with urgency and critical callouts. " +
       "Use 'suggestion' to propose replacement code - MUST preserve exact indentation of original code. " +
       "Example replacing lines 42-44 (3 lines) with 5 lines: " +
-      `{ path: 'src/api.ts', start_line: 42, line: 44, suggestion: '    const result = await fetch(url);\\n    if (!result.ok) {\\n      log.error(result.status);\\n      throw new Error("request failed");\\n    }' }`,
+      `{ path: 'src/api.ts', start_line: 42, line: 44, suggestion: '    const result = await fetch(url);\\n    if (!result.ok) {\\n      log.error(result.status);\\n      throw new Error("request failed");\\n    }' }` +
+      " CONSTRAINT: Inline comments can ONLY target files and lines that appear in the PR diff." +
+      " Commenting on files or lines outside the diff will cause GitHub API errors." +
+      " Put feedback about code outside the diff in 'body' instead.",
     parameters: CreatePullRequestReview,
-    execute: execute(async ({ pull_number, body, commit_id, comments = [] }) => {
+    execute: execute(async ({ pull_number, body, approved, commit_id, comments = [] }) => {
       // set issue context (PRs are issues)
       ctx.toolState.issueNumber = pull_number;
 
+      // enforce prApproveEnabled: downgrade APPROVE to COMMENT if disabled
+      let event: "APPROVE" | "COMMENT" = approved ? "APPROVE" : "COMMENT";
+      if (event === "APPROVE" && !ctx.prApproveEnabled) {
+        log.info("prApproveEnabled is disabled — downgrading APPROVE to COMMENT");
+        event = "COMMENT";
+      }
+
       // compose the request
       const params: RestEndpointMethodTypes["pulls"]["createReview"]["parameters"] = {
         owner: ctx.repo.owner,
         repo: ctx.repo.name,
         pull_number,
-        event: "COMMENT",
+        event,
       };
       if (body) params.body = body;
       if (commit_id) {
@@ -105,30 +123,46 @@ export function CreatePullRequestReviewTool(ctx: ToolContext) {
           return reviewComment;
         });
       }
+
       const result = await ctx.octokit.rest.pulls.createReview(params);
       log.debug(`createReview response: ${JSON.stringify(result.data)}`);
       if (!result.data.id) {
         throw new Error(`createReview returned invalid data: ${JSON.stringify(result.data)}`);
       }
       const reviewId = result.data.id;
+      const reviewNodeId = result.data.node_id;
+
+      // report review node ID to server so the in-flight dedup check
+      // in the synchronize webhook handler sees this run as "review submitted."
+      // awaited (not fire-and-forget) to guarantee the signal lands before
+      // any subsequent push's webhook checks for in-flight runs.
+      await reportReviewNodeId(ctx, reviewNodeId);
 
       // build quick links footer and update the review body
       // only include "Fix all" and "Fix 👍s" links if there are actual review comments
       const customParts: string[] = [];
-      if (comments.length > 0) {
-        const apiUrl = getApiUrl();
-        const fixAllUrl = `${apiUrl}/trigger/${ctx.repo.owner}/${ctx.repo.name}/${pull_number}?action=fix&review_id=${reviewId}`;
-        const fixApprovedUrl = `${apiUrl}/trigger/${ctx.repo.owner}/${ctx.repo.name}/${pull_number}?action=fix-approved&review_id=${reviewId}`;
-        customParts.push(`[Fix all ➔](${fixAllUrl})`, `[Fix 👍s ➔](${fixApprovedUrl})`);
+      if (!approved) {
+        if (comments.length > 0) {
+          const apiUrl = getApiUrl();
+          const fixAllUrl = `${apiUrl}/trigger/${ctx.repo.owner}/${ctx.repo.name}/${pull_number}?action=fix&review_id=${reviewId}`;
+          const fixApprovedUrl = `${apiUrl}/trigger/${ctx.repo.owner}/${ctx.repo.name}/${pull_number}?action=fix-approved&review_id=${reviewId}`;
+          customParts.push(`[Fix all ➔](${fixAllUrl})`, `[Fix 👍s ➔](${fixApprovedUrl})`);
+        } else if (body) {
+          const apiUrl = getApiUrl();
+          const fixUrl = `${apiUrl}/trigger/${ctx.repo.owner}/${ctx.repo.name}/${pull_number}?action=fix&review_id=${reviewId}`;
+          customParts.push(`[Fix it ➔](${fixUrl})`);
+        }
       }
 
       const footer = buildPullfrogFooter({
-        workflowRun: {
-          owner: ctx.repo.owner,
-          repo: ctx.repo.name,
-          runId: ctx.runId,
-          jobId: ctx.jobId,
-        },
+        workflowRun: ctx.runId
+          ? {
+              owner: ctx.repo.owner,
+              repo: ctx.repo.name,
+              runId: ctx.runId,
+              jobId: ctx.jobId,
+            }
+          : undefined,
         customParts,
       });
 
@@ -157,6 +191,35 @@ export function CreatePullRequestReviewTool(ctx: ToolContext) {
   });
 }
 
+async function reportReviewNodeId(ctx: ToolContext, reviewNodeId: string): Promise<void> {
+  for (let remaining = 2; remaining >= 0; remaining--) {
+    try {
+      const response = await apiFetch({
+        path: `/api/workflow-run/${ctx.runId}`,
+        method: "PATCH",
+        headers: {
+          authorization: `Bearer ${ctx.apiToken}`,
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ reviewNodeId }),
+        signal: AbortSignal.timeout(10_000),
+      });
+      if (response.ok) return;
+      if (remaining > 0) {
+        log.debug(`reportReviewNodeId got ${response.status}, retrying (${remaining} left)`);
+        await new Promise((r) => setTimeout(r, 2000));
+      }
+    } catch (error) {
+      if (remaining > 0) {
+        log.debug(`reportReviewNodeId failed, retrying (${remaining} left): ${error}`);
+        await new Promise((r) => setTimeout(r, 2000));
+      } else {
+        log.debug(`reportReviewNodeId exhausted retries: ${error}`);
+      }
+    }
+  }
+}
+
 // =============================================================================
 // COMMENTED OUT: Three-step review flow (start_review, add_review_comment, submit_review)
 // This approach used GraphQL to add comments to a pending review one-by-one,

mcp/reviewComments.test.ts

@@ -1,60 +1,43 @@
 import { Octokit } from "@octokit/rest";
 import { describe, expect, it } from "vitest";
 import { acquireNewToken } from "../utils/github.ts";
-import {
-  buildThreadBlocks,
-  formatReviewThreads,
-  type ParsedHunk,
-  parseFilePatches,
-  REVIEW_THREADS_QUERY,
-  type ReviewThread,
-  type ReviewThreadsQueryResponse,
-} from "./reviewComments.ts";
+import { getReviewData } from "./reviewComments.ts";
 
 async function getToken(): Promise<string> {
-  // prefer explicit GH_TOKEN, fall back to acquiring one via GitHub App credentials
   if (process.env.GH_TOKEN) return process.env.GH_TOKEN;
   return await acquireNewToken();
 }
 
-describe("formatReviewThreads", () => {
+describe("getFormattedReviewThreads", () => {
   it("formats thread blocks with TOC and correct line numbers", { timeout: 30000 }, async () => {
     const token = await getToken();
     const octokit = new Octokit({ auth: token });
-    const pullNumber = 49;
-    const reviewId = 3485940013;
 
-    // fetch review threads via GraphQL
-    const response = await octokit.graphql<ReviewThreadsQueryResponse>(REVIEW_THREADS_QUERY, {
+    const { formatted } = (await getReviewData({
+      octokit,
       owner: "pullfrog",
       name: "scratch",
-      prNumber: pullNumber,
-    });
+      pullNumber: 49,
+      reviewId: 3485940013,
+    }))!;
 
-    const allThreads = response.repository?.pullRequest?.reviewThreads?.nodes ?? [];
-    const threadsForReview = allThreads.filter((thread): thread is ReviewThread => {
-      if (!thread?.comments?.nodes) return false;
-      return thread.comments.nodes.some((c) => c?.pullRequestReview?.databaseId === reviewId);
-    });
+    expect(formatted.toc).toMatchSnapshot("toc");
+    expect(formatted.content).toMatchSnapshot("content");
+  });
 
-    // fetch file patches
-    const prFilesResponse = await octokit.rest.pulls.listFiles({
+  it("formats body-only review", { timeout: 30000 }, async () => {
+    const token = await getToken();
+    const octokit = new Octokit({ auth: token });
+
+    const { formatted } = (await getReviewData({
+      octokit,
       owner: "pullfrog",
-      repo: "scratch",
-      pull_number: pullNumber,
-    });
-    const filePatchMap = new Map<string, ParsedHunk[]>();
-    for (const file of prFilesResponse.data) {
-      if (file.patch) {
-        filePatchMap.set(file.filename, parseFilePatches(file.patch));
-      }
-    }
+      name: "scratch",
+      pullNumber: 64,
+      reviewId: 3531000326,
+    }))!;
 
-    // build and format
-    const { threadBlocks, reviewer } = buildThreadBlocks(threadsForReview, filePatchMap, reviewId);
-    const result = formatReviewThreads(threadBlocks, { pullNumber, reviewId, reviewer });
-
-    expect(result.toc).toMatchSnapshot("toc");
-    expect(result.content).toMatchSnapshot("content");
+    expect(formatted.toc).toMatchSnapshot("toc");
+    expect(formatted.content).toMatchSnapshot("content");
   });
 });

mcp/reviewComments.ts

@@ -1,6 +1,8 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
+import type { Octokit } from "@octokit/rest";
 import { type } from "arktype";
+import { stripExistingFooter } from "../utils/buildPullfrogFooter.ts";
 import { log } from "../utils/log.ts";
 import type { ToolContext } from "./server.ts";
 import { execute, tool } from "./shared.ts";
@@ -94,6 +96,16 @@ export type ReviewThreadsQueryResponse = {
   } | null;
 };
 
+export function countLines(str: string): number {
+  let count = 1;
+  let index = -1;
+  // biome-ignore lint/suspicious/noAssignInExpressions: assignment in while condition is intentional for indexOf loop pattern
+  while ((index = str.indexOf("\n", index + 1)) !== -1) {
+    count++;
+  }
+  return count;
+}
+
 // extract exactly the commented line range from diffHunk, plus context
 const CONTEXT_PADDING = 3;
 
@@ -279,19 +291,14 @@ function extractFromFilePatches(
 export const GetReviewComments = type({
   pull_number: type.number.describe("The pull request number"),
   review_id: type.number.describe("The review ID to get comments for"),
-  approved_by: type.string
-    .describe(
-      "Optional GitHub username - only return threads where this user gave a 👍 to at least one comment"
-    )
-    .optional(),
 });
 
 function hasThumbsUpFrom(comment: ReviewThreadComment, username: string): boolean {
   if (!comment.reactionGroups) return false;
   const thumbsUp = comment.reactionGroups.find((g) => g.content === "THUMBS_UP");
   if (!thumbsUp?.reactors?.nodes) return false;
-  const usernameNeedle = username.toLowerCase();
-  return thumbsUp.reactors.nodes.some((r) => r?.login?.toLowerCase() === usernameNeedle);
+  const needle = username.toLowerCase();
+  return thumbsUp.reactors.nodes.some((r) => r?.login?.toLowerCase() === needle);
 }
 
 function threadHasThumbsUpFrom(thread: ReviewThread, username: string): boolean {
@@ -305,19 +312,26 @@ function threadHasThumbsUpFrom(thread: ReviewThread, username: string): boolean
  */
 export function formatReviewThreads(
   threadBlocks: Array<{ path: string; lineRange: string; content: string[] }>,
-  header: { pullNumber: number; reviewId: number; reviewer: string }
+  header: { pullNumber: number; reviewId: number; reviewer: string; reviewBody?: string }
 ) {
   // header section takes: title (1) + blank (1) + "## TOC" (1) + blank (1) + N TOC entries + blank (1) + "---" (1) + blank (1)
   const tocHeaderLines = 4;
   const tocFooterLines = 3;
   let currentLine = tocHeaderLines + threadBlocks.length + tocFooterLines + 1;
 
+  // account for review body section if present
+  const reviewBodyLines: string[] = [];
+  if (header.reviewBody) {
+    reviewBodyLines.push("## Review Body", "", header.reviewBody, "");
+    currentLine += reviewBodyLines.reduce((sum, line) => sum + countLines(line), 0);
+  }
+
   const tocEntries: string[] = [];
   const threadLines: string[] = [];
 
   for (const block of threadBlocks) {
     const startLine = currentLine;
-    const actualLineCount = block.content.reduce((sum, line) => sum + line.split("\n").length, 0);
+    const actualLineCount = block.content.reduce((sum, line) => sum + countLines(line), 0);
     const endLine = currentLine + actualLineCount - 1;
     tocEntries.push(`- ${block.path}:${block.lineRange} → lines ${startLine}-${endLine}`);
     threadLines.push(...block.content);
@@ -329,10 +343,13 @@ export function formatReviewThreads(
     `# Review Threads (${threadBlocks.length}) for PR #${header.pullNumber} - Review ${header.reviewId} by ${header.reviewer}`
   );
   lines.push("");
-  lines.push("## TOC");
-  lines.push("");
-  lines.push(...tocEntries);
-  lines.push("");
+  if (threadBlocks.length > 0) {
+    lines.push("## TOC");
+    lines.push("");
+    lines.push(...tocEntries);
+    lines.push("");
+  }
+  lines.push(...reviewBodyLines);
   lines.push("---");
   lines.push("");
   lines.push(...threadLines);
@@ -352,12 +369,6 @@ export function buildThreadBlocks(
   filePatchMap: Map<string, ParsedHunk[]>,
   reviewId: number
 ) {
-  // get reviewer from first matching comment
-  const firstMatchingComment = threads[0]?.comments?.nodes?.find(
-    (c) => c?.pullRequestReview?.databaseId === reviewId
-  );
-  const reviewer = firstMatchingComment?.pullRequestReview?.author?.login ?? "unknown";
-
   // sort threads by file path, then by line number
   threads.sort((a, b) => {
     const pathCmp = a.path.localeCompare(b.path);
@@ -439,7 +450,89 @@ export function buildThreadBlocks(
     threadBlocks.push({ path: thread.path, lineRange, content: block });
   }
 
-  return { threadBlocks, reviewer };
+  return threadBlocks;
+}
+
+async function getReviewThreads(input: GetReviewDataInput) {
+  const response = await input.octokit.graphql<ReviewThreadsQueryResponse>(REVIEW_THREADS_QUERY, {
+    owner: input.owner,
+    name: input.name,
+    prNumber: input.pullNumber,
+  });
+
+  const allThreads = response.repository?.pullRequest?.reviewThreads?.nodes ?? [];
+
+  const threadsForReview = allThreads.filter((thread): thread is ReviewThread => {
+    if (!thread?.comments?.nodes) return false;
+    return thread.comments.nodes.some((c) => c?.pullRequestReview?.databaseId === input.reviewId);
+  });
+
+  if (!input.approvedBy) {
+    return threadsForReview;
+  }
+
+  const username = input.approvedBy;
+  return threadsForReview.filter((thread) => threadHasThumbsUpFrom(thread, username));
+}
+
+interface GetReviewDataInput {
+  octokit: Octokit;
+  owner: string;
+  name: string;
+  pullNumber: number;
+  reviewId: number;
+  approvedBy?: string | undefined;
+}
+
+export async function getReviewData(input: GetReviewDataInput): Promise<
+  | {
+      threadBlocks: Array<{ path: string; lineRange: string; content: string[] }>;
+      reviewer: string;
+      formatted: { toc: string; content: string };
+    }
+  | undefined
+> {
+  const [review, threads] = await Promise.all([
+    input.octokit.rest.pulls.getReview({
+      owner: input.owner,
+      repo: input.name,
+      pull_number: input.pullNumber,
+      review_id: input.reviewId,
+    }),
+    getReviewThreads(input),
+  ]);
+
+  const rawReviewBody = review.data.body;
+  const reviewBody = rawReviewBody ? stripExistingFooter(rawReviewBody) : "";
+  const reviewer = review.data.user?.login ?? "unknown";
+
+  if (threads.length === 0 && !reviewBody) return undefined;
+
+  let threadBlocks: Array<{ path: string; lineRange: string; content: string[] }> = [];
+
+  if (threads.length > 0) {
+    const prFilesResponse = await input.octokit.rest.pulls.listFiles({
+      owner: input.owner,
+      repo: input.name,
+      pull_number: input.pullNumber,
+    });
+    const filePatchMap = new Map<string, ParsedHunk[]>();
+    for (const file of prFilesResponse.data) {
+      if (file.patch) {
+        filePatchMap.set(file.filename, parseFilePatches(file.patch));
+      }
+    }
+    threadBlocks = buildThreadBlocks(threads, filePatchMap, input.reviewId);
+  }
+
+  const formatted = formatReviewThreads(threadBlocks, {
+    pullNumber: input.pullNumber,
+    reviewId: input.reviewId,
+    reviewer,
+    reviewBody,
+  });
+
+  return { threadBlocks, reviewer, formatted };
 }
 
 export function GetReviewCommentsTool(ctx: ToolContext) {
@@ -447,35 +540,26 @@ export function GetReviewCommentsTool(ctx: ToolContext) {
     name: "get_review_comments",
     description:
       "Get review comments for a pull request review with full thread context. " +
-      "When approved_by is provided, only returns threads where that user gave a 👍 to at least one comment. " +
+      "Automatically filters to approved comments when applicable. " +
       "Returns a TOC and commentsPath pointing to a markdown file with full comment details.",
     parameters: GetReviewComments,
     execute: execute(async (params) => {
-      // fetch all review threads for the PR via GraphQL
-      const response = await ctx.octokit.graphql<ReviewThreadsQueryResponse>(REVIEW_THREADS_QUERY, {
+      // auto-filter to approved comments when the event has approved_only set
+      const approvedBy =
+        ctx.payload.event.trigger === "fix_review" && ctx.payload.event.approved_only
+          ? ctx.payload.triggerer
+          : undefined;
+
+      const result = await getReviewData({
+        octokit: ctx.octokit,
         owner: ctx.repo.owner,
         name: ctx.repo.name,
-        prNumber: params.pull_number,
+        pullNumber: params.pull_number,
+        reviewId: params.review_id,
+        approvedBy,
       });
 
-      const allThreads = response.repository?.pullRequest?.reviewThreads?.nodes ?? [];
-
-      // filter to threads where at least one comment belongs to the target review
-      let threadsForReview = allThreads.filter((thread): thread is ReviewThread => {
-        if (!thread?.comments?.nodes) return false;
-        return thread.comments.nodes.some(
-          (c) => c?.pullRequestReview?.databaseId === params.review_id
-        );
-      });
-
-      // filter by approved_by if specified
-      if (params.approved_by) {
-        threadsForReview = threadsForReview.filter((thread) =>
-          threadHasThumbsUpFrom(thread, params.approved_by as string)
-        );
-      }
-
-      if (threadsForReview.length === 0) {
+      if (!result) {
         return {
           review_id: params.review_id,
           pull_number: params.pull_number,
@@ -483,40 +567,14 @@ export function GetReviewCommentsTool(ctx: ToolContext) {
           threadCount: 0,
           commentsPath: null,
           toc: null,
-          instructions: params.approved_by
-            ? `no threads with 👍 from ${params.approved_by}`
+          instructions: approvedBy
+            ? `no threads with 👍 from ${approvedBy}`
             : "no threads found for this review",
         };
       }
 
-      // fetch full file patches for better multi-hunk context
-      const prFilesResponse = await ctx.octokit.rest.pulls.listFiles({
-        owner: ctx.repo.owner,
-        repo: ctx.repo.name,
-        pull_number: params.pull_number,
-      });
-      const filePatchMap = new Map<string, ParsedHunk[]>();
-      for (const file of prFilesResponse.data) {
-        if (file.patch) {
-          filePatchMap.set(file.filename, parseFilePatches(file.patch));
-        }
-      }
+      const { threadBlocks, reviewer, formatted } = result;
 
-      // build thread blocks
-      const { threadBlocks, reviewer } = buildThreadBlocks(
-        threadsForReview,
-        filePatchMap,
-        params.review_id
-      );
-
-      // format thread blocks into markdown with TOC
-      const formatted = formatReviewThreads(threadBlocks, {
-        pullNumber: params.pull_number,
-        reviewId: params.review_id,
-        reviewer,
-      });
-
-      // write to temp file
       const tempDir = process.env.PULLFROG_TEMP_DIR;
       if (!tempDir) {
         throw new Error("PULLFROG_TEMP_DIR not set");

mcp/selectMode.ts

@@ -1,12 +1,16 @@
 import { type } from "arktype";
 import { ghPullfrogMcpName } from "../external.ts";
 import type { Mode } from "../modes.ts";
+import { apiFetch } from "../utils/apiFetch.ts";
 import type { ToolContext } from "./server.ts";
 import { execute, tool } from "./shared.ts";
 
 export const SelectModeParams = type({
   mode: type.string.describe(
-    "the name of the mode to select (e.g., 'Build', 'Plan', 'Review', 'Fix', 'AddressReviews', 'Task')"
+    "the name of the mode to select (e.g., 'Build', 'Plan', 'Review', 'IncrementalReview', 'Fix', 'AddressReviews', 'Task', 'ResolveConflicts')"
+  ),
+  "issue_number?": type("number").describe(
+    "optional issue number; when provided with Plan mode, used to look up an existing plan comment for this issue (edit vs create)"
   ),
 });
 
@@ -46,6 +50,37 @@ For simple, well-defined tasks, a single build subagent is sufficient — skip t
 
 Your subagent receives ONLY what you write. Include file paths, constraints, conventions, and any context from AGENTS.md or the codebase directly in the prompt. Subagents have file ops, shell, and read-only GitHub tools — but NO git/checkout, dependency, GitHub-write, or remote-mutating tools.`,
 
+  ResolveConflicts: `### Checklist
+
+1. **Setup**:
+   - Call \${ghPullfrogMcpName}/checkout_pr to get the PR branch.
+   - Call \${ghPullfrogMcpName}/get_pull_request to identify the base branch (e.g., 'main').
+   - Call \${ghPullfrogMcpName}/git_fetch to fetch the base branch.
+
+2. **Merge Attempt**:
+   - Run \`git merge origin/<base_branch>\` via shell.
+   - If it succeeds automatically: Great! Push via \${ghPullfrogMcpName}/push_branch and report success.
+   - If it fails (conflicts): You must resolve them.
+
+3. **Delegation (if conflicts exist)**:
+   - Run \`git status\` or parse the merge output to find the list of conflicting files.
+   - Delegate to a subagent (or multiple in parallel if many files) to resolve the conflicts.
+   - **Instructions for subagent**:
+     - "You are resolving merge conflicts in these files: [list]."
+     - "For each file: read it, find the conflict markers (<<<<<<<, =======, >>>>>>>), understand the code context, and rewrite the file with the correct resolution. Remove all markers."
+     - "After resolving, verify the file syntax is correct."
+     - "Call \${ghPullfrogMcpName}/set_output with a summary of what you resolved."
+   - Note: Subagents cannot run git commands. They only edit the files.
+
+4. **Finalize**:
+   - After subagents return:
+   - Run a final verification (build/test) to ensure the resolution works.
+   - \`git add .\`
+   - \`git commit -m "Resolve merge conflicts"\`
+   - \${ghPullfrogMcpName}/push_branch
+   - \${ghPullfrogMcpName}/report_progress
+`,
+
   AddressReviews: `### Checklist
 
 1. Before delegating, checkout the PR branch yourself via \`${ghPullfrogMcpName}/checkout_pr\` — subagents have no git/checkout tools.
@@ -89,9 +124,38 @@ Each task in the \`tasks\` array should include:
 
 After all tasks complete, consolidate into a **single** review:
 - merge the \`comments\` arrays from all subagent outputs
-- submit one \`${ghPullfrogMcpName}/create_pull_request_review\` with the merged comments and a unified summary body
+- if subagents found actionable issues: submit one \`${ghPullfrogMcpName}/create_pull_request_review\` with \`approved: false\`, the merged comments, and a unified summary body
+- if no subagent found actionable issues: submit with \`approved: true\` and a brief positive summary (no inline comments)
+- call \`${ghPullfrogMcpName}/report_progress\` with the summary
+
+Use max effort for thorough reviews.`,
+
+  IncrementalReview: `### Checklist
+
+1. Checkout the PR via \`${ghPullfrogMcpName}/checkout_pr\` — this returns PR metadata and a \`diffPath\`. Read the diff to identify the major areas of change.
+2. Generate the incremental diff using the \`before_sha\` from EVENT DATA: \`git diff <before_sha>...HEAD\`. This isolates only the new commits. If the command fails (e.g., force-push rewrote history), fall back to reviewing the full PR diff.
+3. Fetch previous reviews via \`${ghPullfrogMcpName}/list_pull_request_reviews\`. For the most recent Pullfrog review, call \`${ghPullfrogMcpName}/get_review_comments\` with the review ID to retrieve specific prior line-level feedback. Include the prior review summary and comment details when crafting subagent tasks.
+4. Delegate multiple subagents in a single \`${ghPullfrogMcpName}/delegate\` call, each focused on a specific area of the new changes. Provide both the full diff path and the incremental diff.
+5. After all subagents return, consolidate their findings into a single review.
+
+### Crafting each task
+
+Each task in the \`tasks\` array should include:
+- the full diff file path AND the incremental diff (so the subagent can see both new changes and full context)
+- what specific area/aspect to focus on
+- instruct it to prioritize reviewing code in the incremental diff while using the full diff for context and to catch any changes not covered by the incremental diff
+- include the prior review comments (from step 3) so the subagent knows what feedback was already given — instruct it to avoid repeating prior issues and to note whether prior feedback was addressed by the new commits
+- instruct it to actively hunt for problems: trace data flow, check boundaries, explore failure modes, verify assumptions, consider lifecycle, spot performance issues
+- draft inline comments with NEW line numbers from the full PR diff — every comment must be actionable (2-3 sentences max)
+- call \`${ghPullfrogMcpName}/set_output\` with a JSON object: \`{ "summary": "...", "comments": [{ "path": "file.ts", "line": 42, "body": "..." }, ...] }\`
+
+### Post-delegation
+
+After all tasks complete, consolidate into a **single** review:
+- merge the \`comments\` arrays from all subagent outputs
+- if subagents found actionable issues: submit one \`${ghPullfrogMcpName}/create_pull_request_review\` with \`approved: false\`, the merged comments, and a unified summary body
+- if no subagent found actionable issues: submit with \`approved: true\` and a brief positive summary (no inline comments)
 - call \`${ghPullfrogMcpName}/report_progress\` with the summary
-- if no subagent found actionable issues, skip the review — just call \`report_progress\` noting the PR was reviewed
 
 Use max effort for thorough reviews.`,
 
@@ -101,12 +165,28 @@ Use max effort for thorough reviews.`,
    - the task to plan for
    - relevant codebase context (file paths, architecture notes from AGENTS.md)
    - instruct it to produce a structured, actionable plan with clear milestones
-   - call \`${ghPullfrogMcpName}/set_output\` with the plan (this is how results get back to you — you'll need the plan to craft the next subagent's prompt)
-2. After the subagent completes, call \`${ghPullfrogMcpName}/report_progress\` with the plan.
+   - IMPORTANT: instruct it to return the full plan text via \`${ghPullfrogMcpName}/set_output\` as well-structured markdown — do NOT create plan files, do NOT save to disk
+2. After the subagent completes, call \`${ghPullfrogMcpName}/report_progress\` with the full plan text from the subagent's output. The progress comment must contain the complete plan — not a file path or summary.
 
 ### Effort
 
-Use mini or auto effort. After receiving the plan, you may delegate a Build subagent to implement it.`,
+Use mini or auto effort.`,
+
+  PlanEdit: `### Checklist (editing existing plan)
+
+An existing plan comment was found for this issue. Update that comment with the revised plan — do not create a new plan comment.
+
+1. Use \`previousPlanBody\` from this response as the plan to revise; do not call \`get_issue\` or \`get_issue_comments\`.
+2. When delegating, the subagent prompt must contain:
+   - the current plan (\`previousPlanBody\`) and the user's revision request
+   - relevant codebase context (file paths, architecture notes from AGENTS.md)
+   - instructions to produce a structured plan with clear milestones and to return the full plan via \`${ghPullfrogMcpName}/set_output\` as markdown (do not create plan files or save to disk)
+3. After the subagent completes, call \`${ghPullfrogMcpName}/report_progress\` with the full plan text and \`{ target_plan_comment: true }\` so the revised plan updates the existing plan comment (not the progress comment).
+4. Then post a short note to the progress comment (e.g. "Plan has been updated in the comment above.") via \`${ghPullfrogMcpName}/report_progress\` so it is not left as "Leaping...".
+
+### Effort
+
+Use mini or auto effort.`,
 
   Fix: `### Checklist
 
@@ -154,8 +234,8 @@ type OrchestratorGuidance = {
   orchestratorGuidance: string;
 };
 
-function buildOrchestratorGuidance(mode: Mode): OrchestratorGuidance {
-  const guidance = modeGuidance[mode.name] ?? "";
+function buildOrchestratorGuidance(mode: Mode, overrideGuidance?: string): OrchestratorGuidance {
+  const guidance = overrideGuidance ?? modeGuidance[mode.name] ?? "";
   return {
     modeName: mode.name,
     description: mode.description,
@@ -163,19 +243,49 @@ function buildOrchestratorGuidance(mode: Mode): OrchestratorGuidance {
   };
 }
 
+// matches the API response for /repo/[owner]/[repo]/issue/[issueNumber]/plan-comment
+export type PlanCommentResponsePayload = { error: string } | { commentId: number; body: string };
+
+async function fetchExistingPlanComment(
+  ctx: ToolContext,
+  issueNumber: number
+): Promise<Extract<PlanCommentResponsePayload, { commentId: number }> | null> {
+  if (!ctx.apiToken) return null;
+  try {
+    const response = await apiFetch({
+      path: `/api/repo/${ctx.repo.owner}/${ctx.repo.name}/issue/${issueNumber}/plan-comment`,
+      method: "GET",
+      headers: { authorization: `Bearer ${ctx.apiToken}` },
+      signal: AbortSignal.timeout(10_000),
+    });
+    const data = (await response.json()) as PlanCommentResponsePayload;
+    return response.ok && "commentId" in data ? data : null;
+  } catch {
+    return null;
+  }
+}
+
 export function SelectModeTool(ctx: ToolContext) {
   return tool({
     name: "select_mode",
     description:
-      "Select a mode and receive orchestrator-level guidance on how to handle it, including suggested delegation flows and prompt-crafting tips. Call this before delegating to understand the best approach for the task.",
+      "Select a mode and receive orchestrator-level guidance on how to handle it, including suggested delegation flows and prompt-crafting tips. Call this ONCE before delegating. Mode selection is final — you cannot switch modes after selecting.",
     parameters: SelectModeParams,
     execute: execute(async (params) => {
-      const selectedMode = resolveMode(ctx.modes, params.mode);
+      if (ctx.toolState.selectedMode) {
+        return {
+          error: `mode already selected: "${ctx.toolState.selectedMode}". mode selection is final and cannot be changed. complete your current workflow within this mode.`,
+        };
+      }
+
+      const modeName = params.mode;
+
+      const selectedMode = resolveMode(ctx.modes, modeName);
 
       if (!selectedMode) {
         const availableModes = ctx.modes.map((m) => m.name).join(", ");
         return {
-          error: `mode "${params.mode}" not found. available modes: ${availableModes}`,
+          error: `mode "${modeName}" not found. available modes: ${availableModes}`,
           availableModes: ctx.modes.map((m) => ({
             name: m.name,
             description: m.description,
@@ -184,6 +294,22 @@ export function SelectModeTool(ctx: ToolContext) {
       }
 
       ctx.toolState.selectedMode = selectedMode.name;
+
+      if (selectedMode.name === "Plan") {
+        const issueNumber = params.issue_number ?? ctx.payload.event.issue_number;
+        if (issueNumber !== undefined) {
+          const existing = await fetchExistingPlanComment(ctx, issueNumber);
+          if (existing !== null) {
+            ctx.toolState.existingPlanCommentId = existing.commentId;
+            ctx.toolState.previousPlanBody = existing.body;
+            return {
+              ...buildOrchestratorGuidance(selectedMode, modeGuidance.PlanEdit),
+              previousPlanBody: existing.body,
+            };
+          }
+        }
+      }
+
       return buildOrchestratorGuidance(selectedMode);
     }),
   });

mcp/server.ts

@@ -64,6 +64,9 @@ export interface ToolState {
   progressCommentId: number | null | undefined;
   lastProgressBody?: string;
   wasUpdated?: boolean;
+  // set by select_mode when Plan + issue_number and plan-comment API returns existing plan (for report_progress target_plan_comment)
+  existingPlanCommentId?: number;
+  previousPlanBody?: string;
   output?: string;
   usageEntries: AgentUsage[];
 }
@@ -99,8 +102,9 @@ export interface ToolContext {
   agent: Agent;
   modes: Mode[];
   postCheckoutScript: string | null;
+  prApproveEnabled: boolean;
   toolState: ToolState;
-  runId: string;
+  runId: number | undefined;
   jobId: string | undefined;
   // set after MCP server starts — used by delegate tool to pass URL to subagents
   mcpServerUrl: string;
@@ -188,75 +192,38 @@ function isAddressInUse(error: unknown): boolean {
   return message.includes("eaddrinuse") || message.includes("address already in use");
 }
 
-// subagent tools: file ops, shell, read-only GitHub, upload, set_output.
-// no git/checkout (mutates shared state), no dependencies (shared state),
-// no GitHub-write (user-facing side effects), no delegation/remote-mutating.
-function buildSubagentTools(ctx: ToolContext): Tool<any, any>[] {
-  const tools: Tool<any, any>[] = [
-    IssueInfoTool(ctx),
-    GetIssueCommentsTool(ctx),
-    GetIssueEventsTool(ctx),
-    PullRequestInfoTool(ctx),
-    CommitInfoTool(ctx),
-    GetReviewCommentsTool(ctx),
-    ListPullRequestReviewsTool(ctx),
-    GetCheckSuiteLogsTool(ctx),
-    UploadFileTool(ctx),
-    SetOutputTool(ctx),
-    FileReadTool(ctx),
-    FileWriteTool(ctx),
-    FileEditTool(ctx),
-    FileDeleteTool(ctx),
-    ListDirectoryTool(ctx),
-  ];
+type JsonSchema = Record<string, unknown>;
 
-  if (ctx.payload.shell === "restricted") {
-    tools.push(ShellTool(ctx));
-    tools.push(KillBackgroundTool(ctx));
-  }
-
-  return tools;
-}
-
-// orchestrator gets everything: file ops, shell, git, GitHub, delegation, remote-mutating
-function buildOrchestratorTools(ctx: ToolContext): Tool<any, any>[] {
+// tools shared by both orchestrator and subagent servers
+function buildCommonTools(ctx: ToolContext, outputSchema?: JsonSchema): Tool<any, any>[] {
   const tools: Tool<any, any>[] = [
     StartDependencyInstallationTool(ctx),
     AwaitDependencyInstallationTool(ctx),
+    CreateCommentTool(ctx),
+    EditCommentTool(ctx),
+    ReplyToReviewCommentTool(ctx),
+    IssueTool(ctx),
     IssueInfoTool(ctx),
     GetIssueCommentsTool(ctx),
     GetIssueEventsTool(ctx),
+    CreatePullRequestReviewTool(ctx),
     PullRequestInfoTool(ctx),
     CommitInfoTool(ctx),
     CheckoutPrTool(ctx),
     GetReviewCommentsTool(ctx),
     ListPullRequestReviewsTool(ctx),
+    ResolveReviewThreadTool(ctx),
     GetCheckSuiteLogsTool(ctx),
+    AddLabelsTool(ctx),
     GitTool(ctx),
     GitFetchTool(ctx),
     UploadFileTool(ctx),
-    SetOutputTool(ctx),
+    SetOutputTool(ctx, outputSchema),
     FileReadTool(ctx),
     FileWriteTool(ctx),
     FileEditTool(ctx),
     FileDeleteTool(ctx),
     ListDirectoryTool(ctx),
-    CreateCommentTool(ctx),
-    EditCommentTool(ctx),
-    ReplyToReviewCommentTool(ctx),
-    CreatePullRequestReviewTool(ctx),
-    ResolveReviewThreadTool(ctx),
-    IssueTool(ctx),
-    AddLabelsTool(ctx),
-    ReportProgressTool(ctx),
-    SelectModeTool(ctx),
-    DelegateTool(ctx),
-    AskQuestionTool(ctx),
-    PushBranchTool(ctx),
-    PushTagsTool(ctx),
-    DeleteBranchTool(ctx),
-    CreatePullRequestTool(ctx),
-    UpdatePullRequestBodyTool(ctx),
   ];
 
   // only add ShellTool when shell is "restricted"
@@ -271,6 +238,27 @@ function buildOrchestratorTools(ctx: ToolContext): Tool<any, any>[] {
   return tools;
 }
 
+// orchestrator gets common tools + delegation + remote-mutating tools
+function buildOrchestratorTools(ctx: ToolContext, outputSchema?: JsonSchema): Tool<any, any>[] {
+  return [
+    ...buildCommonTools(ctx, outputSchema),
+    ReportProgressTool(ctx),
+    SelectModeTool(ctx),
+    DelegateTool(ctx),
+    AskQuestionTool(ctx),
+    PushBranchTool(ctx),
+    PushTagsTool(ctx),
+    DeleteBranchTool(ctx),
+    CreatePullRequestTool(ctx),
+    UpdatePullRequestBodyTool(ctx),
+  ];
+}
+
+// subagent gets only common tools (no delegation, no remote mutation)
+function buildSubagentTools(ctx: ToolContext): Tool<any, any>[] {
+  return buildCommonTools(ctx);
+}
+
 type McpStartResult = {
   server: FastMCP;
   url: string;
@@ -370,13 +358,18 @@ async function killBackgroundProcesses(toolState: ToolState): Promise<void> {
   backgroundProcesses.clear();
 }
 
+type McpHttpServerOptions = {
+  outputSchema?: JsonSchema | undefined;
+};
+
 /**
  * Start the orchestrator MCP HTTP server (has all tools including push/PR/delegation).
  */
 export async function startMcpHttpServer(
-  ctx: ToolContext
+  ctx: ToolContext,
+  options?: McpHttpServerOptions
 ): Promise<{ url: string; [Symbol.asyncDispose]: () => Promise<void> }> {
-  const tools = buildOrchestratorTools(ctx);
+  const tools = buildOrchestratorTools(ctx, options?.outputSchema);
   const startResult = await selectMcpPort(ctx, tools);
 
   return {

mcp/shared.ts

@@ -1,4 +1,4 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
 import { encode as toonEncode } from "@toon-format/toon";
 import type { FastMCP, Tool } from "fastmcp";
 import { formatJsonValue, log } from "../utils/cli.ts";
@@ -141,27 +141,34 @@ function sanitizeSchema(schema: any): any {
 }
 
 /**
- * Wrap a StandardSchemaV1 to intercept toJsonSchema() calls and sanitize the output
+ * Wrap a schema to sanitize its JSON Schema output for Gemini/OpenCode compatibility.
+ * xsschema calls ~standard.jsonSchema.input() for schemas that implement StandardJSONSchemaV1
+ * (i.e. have ~standard.jsonSchema), which includes arktype and our AJV-backed JSON schema wrapper.
+ * Schemas without ~standard.jsonSchema are returned unchanged (sanitization skipped).
  */
-function wrapSchema(schema: StandardSchemaV1<any>): StandardSchemaV1<any> {
-  const originalToJsonSchema = (schema as any).toJsonSchema?.bind(schema);
+function wrapSchema(
+  schema: StandardSchemaV1<any> & {
+    "~standard": Partial<StandardJSONSchemaV1<any>["~standard"]>;
+  }
+): StandardSchemaV1<any> {
+  const standardProps = schema["~standard"];
 
-  if (!originalToJsonSchema) {
+  if (!("jsonSchema" in standardProps)) {
     return schema;
   }
 
-  // create a proxy that intercepts toJsonSchema calls
-  return new Proxy(schema, {
-    get(target, prop) {
-      if (prop === "toJsonSchema") {
-        return () => {
-          const originalSchema = originalToJsonSchema();
-          return sanitizeSchema(originalSchema);
-        };
-      }
-      return (target as any)[prop];
+  const jsonSchema = standardProps.jsonSchema;
+  const wrapped: StandardSchemaV1<any> & StandardJSONSchemaV1<any> = {
+    ...schema,
+    "~standard": {
+      ...standardProps,
+      jsonSchema: {
+        input: (options) => sanitizeSchema(jsonSchema.input(options)),
+        output: (options) => sanitizeSchema(jsonSchema.output(options)),
+      },
     },
-  }) as StandardSchemaV1<any>;
+  };
+  return wrapped;
 }
 
 /**
@@ -172,7 +179,6 @@ function sanitizeTool<T extends Tool<any, any>>(tool: T): T {
     return tool;
   }
 
-  // wrap the schema object to intercept toJsonSchema() calls
   const wrappedSchema = wrapSchema(tool.parameters);
 
   // create a new tool with wrapped schema

mcp/shell.ts

@@ -2,6 +2,7 @@
 import { type ChildProcess, type StdioOptions, spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { closeSync, openSync, writeFileSync } from "node:fs";
+import { userInfo } from "node:os";
 import { join } from "node:path";
 import { type } from "arktype";
 import { log } from "../utils/log.ts";
@@ -82,33 +83,39 @@ function detectSandboxMethod(): SandboxMethod {
   return "none";
 }
 
+// strip inherited proc mount that sits underneath --mount-proc's overlay.
+// --mount-proc mounts fresh proc on top, but `umount /proc` peels it off and exposes the
+// host's proc with all host PIDs — allowing /proc/<pid>/environ exfiltration.
+// double-umount removes both layers, then a clean mount gives only sandbox PIDs.
+// on unprivileged systems where umount fails, --mount-proc still provides isolation
+// (the agent also can't umount in that case).
+const PROC_CLEANUP =
+  "umount /proc 2>/dev/null; umount /proc 2>/dev/null; mount -t proc proc /proc 2>/dev/null;";
+
 function spawnShell(params: SpawnParams): ChildProcess {
   const spawnOpts = { env: params.env, cwd: params.cwd, stdio: params.stdio, detached: true };
   const sandboxMethod = detectSandboxMethod();
 
   if (sandboxMethod === "unshare") {
-    // use PID namespace isolation to prevent reading /proc/$PPID/environ
-    // this creates a new PID namespace where:
-    // 1. the subprocess becomes PID 1 in its namespace
-    // 2. parent PIDs are not visible (PPID = 0)
-    // 3. fresh /proc is mounted showing only sandbox PIDs
-    // combined with resolveEnv("restricted"), this prevents all /proc-based secret theft
     return spawn(
       "unshare",
-      ["--pid", "--fork", "--mount-proc", "bash", "-c", params.command],
+      ["--pid", "--fork", "--mount-proc", "bash", "-c", `${PROC_CLEANUP} ${params.command}`],
       spawnOpts
     );
   }
 
   if (sandboxMethod === "sudo-unshare") {
-    // on GHA runners, unprivileged namespaces are blocked but sudo works
-    // pass filtered env via sudo env command since sudo clears environment
     const envArgs: string[] = [];
     for (const [k, v] of Object.entries(params.env)) {
       if (v !== undefined) {
         envArgs.push(`${k}=${v}`);
       }
     }
+    // drop back to original user after PROC_CLEANUP so files aren't owned by root.
+    // sudo is only needed for unshare; the actual command should run as the normal user
+    // to avoid ownership mismatches with file_write/file_edit (which run in the Node.js parent).
+    const username = userInfo().username;
+    const escaped = params.command.replace(/'/g, "'\\''");
     return spawn(
       "sudo",
       [
@@ -120,9 +127,9 @@ function spawnShell(params: SpawnParams): ChildProcess {
         "--mount-proc",
         "bash",
         "-c",
-        params.command,
+        `${PROC_CLEANUP} exec su -p -s /bin/bash ${username} -c '${escaped}'`,
       ],
-      { ...spawnOpts, env: {} } // empty env since we pass via sudo env
+      { ...spawnOpts, env: {} }
     );
   }
 
@@ -153,6 +160,14 @@ function getTempDir(): string {
   return tempDir;
 }
 
+/** detect git as a command invocation (not as part of another word like .gitignore) */
+function isGitCommand(command: string): boolean {
+  const trimmed = command.trim();
+  if (trimmed === "git" || trimmed.startsWith("git ")) return true;
+  if (trimmed.startsWith("sudo git")) return true;
+  return /[;&|]\s*(?:sudo\s+)?git(?:\s|$)/.test(trimmed);
+}
+
 export function ShellTool(ctx: ToolContext) {
   return tool({
     name: "shell",
@@ -162,9 +177,20 @@ Use this tool to:
 - Run shell commands (ls, cat, grep, find, etc.)
 - Execute build tools (npm, pnpm, cargo, make, etc.)
 - Run tests and linters
-- Perform git operations`,
+
+Do NOT use this tool for git commands — use the dedicated git tools instead.`,
     parameters: ShellParams,
     execute: execute(async (params) => {
+      if (isGitCommand(params.command)) {
+        throw new Error(
+          "git commands are not allowed in the shell tool. use the dedicated git tools instead:\n" +
+            "- git: local operations (status, log, diff, add, commit, checkout, merge, rebase, etc.)\n" +
+            "- push_branch: push to remote (handles authentication)\n" +
+            "- git_fetch: fetch from remote (handles authentication)\n" +
+            "- checkout_pr: check out PR branches"
+        );
+      }
+
       const timeout = Math.min(params.timeout ?? 30000, 120000);
       const cwd = params.working_directory ?? process.cwd();
       const env = resolveEnv(ctx.payload.shell === "enabled" ? "inherit" : "restricted");

mcp/subagent.ts

@@ -6,6 +6,7 @@ import type { Effort } from "../external.ts";
 import { ghPullfrogMcpName } from "../external.ts";
 import { markActivity } from "../utils/activity.ts";
 import type { ResolvedInstructions } from "../utils/instructions.ts";
+import { withLogPrefix } from "../utils/log.ts";
 import { type SubagentState, startSubagentMcpServer, type ToolContext } from "./server.ts";
 
 type CreateSubagentParams = {
@@ -132,41 +133,43 @@ type RunSubagentResult = {
 };
 
 export async function runSubagent(params: RunSubagentParams): Promise<RunSubagentResult> {
-  params.subagent.keepAliveInterval = setInterval(markActivity, 30_000);
-  const mcpServer = await startSubagentMcpServer({
-    ctx: params.ctx,
-    subagentId: params.subagent.id,
-  });
-  // each subagent gets its own tmpdir so parallel agents don't clobber config files
-  const subagentTmpdir = join(params.ctx.tmpdir, params.subagent.id);
-  mkdirSync(subagentTmpdir, { recursive: true });
-  try {
-    const subagentPayload = { ...params.ctx.payload, effort: params.effort };
-    const subagentInstructions = buildSubagentInstructions({
+  return withLogPrefix(`[${params.subagent.label}]`, async () => {
+    params.subagent.keepAliveInterval = setInterval(markActivity, 30_000);
+    const mcpServer = await startSubagentMcpServer({
       ctx: params.ctx,
-      label: params.subagent.label,
-      instructions: params.instructions,
+      subagentId: params.subagent.id,
     });
-    const result = await params.ctx.agent.run({
-      payload: subagentPayload,
-      mcpServerUrl: mcpServer.url,
-      tmpdir: subagentTmpdir,
-      instructions: subagentInstructions,
-    });
-    params.subagent.usage = result.usage;
-    writeFileSync(params.subagent.stdoutFilePath, result.output ?? "", "utf-8");
-    completeSubagent({ ctx: params.ctx, subagent: params.subagent, success: result.success });
-    return { success: result.success, error: result.error };
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
+    // each subagent gets its own tmpdir so parallel agents don't clobber config files
+    const subagentTmpdir = join(params.ctx.tmpdir, params.subagent.id);
+    mkdirSync(subagentTmpdir, { recursive: true });
     try {
-      writeFileSync(params.subagent.stdoutFilePath, "", "utf-8");
-    } catch {
-      // best-effort
+      const subagentPayload = { ...params.ctx.payload, effort: params.effort };
+      const subagentInstructions = buildSubagentInstructions({
+        ctx: params.ctx,
+        label: params.subagent.label,
+        instructions: params.instructions,
+      });
+      const result = await params.ctx.agent.run({
+        payload: subagentPayload,
+        mcpServerUrl: mcpServer.url,
+        tmpdir: subagentTmpdir,
+        instructions: subagentInstructions,
+      });
+      params.subagent.usage = result.usage;
+      writeFileSync(params.subagent.stdoutFilePath, result.output ?? "", "utf-8");
+      completeSubagent({ ctx: params.ctx, subagent: params.subagent, success: result.success });
+      return { success: result.success, error: result.error };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      try {
+        writeFileSync(params.subagent.stdoutFilePath, "", "utf-8");
+      } catch {
+        // best-effort
+      }
+      completeSubagent({ ctx: params.ctx, subagent: params.subagent, success: false });
+      return { success: false, error: errorMessage };
+    } finally {
+      await mcpServer.stop();
     }
-    completeSubagent({ ctx: params.ctx, subagent: params.subagent, success: false });
-    return { success: false, error: errorMessage };
-  } finally {
-    await mcpServer.stop();
-  }
+  });
 }

modes.ts

@@ -32,7 +32,7 @@ export function computeModes(): Mode[] {
 1. **CHECKOUT** - Determine whether to checkout the existing PR branch or create a new one:
    - **PR event, modifying the existing PR**: Call \`${ghPullfrogMcpName}/checkout_pr\` with the PR number to checkout the PR branch.
    - **PR event, but user wants a NEW branch/PR**: Create a new branch with \`git checkout -b pullfrog/branch-name\` via the \`${ghPullfrogMcpName}/git\` tool.
-   
+
    Branch names must be prefixed with "pullfrog/" and be specific enough to avoid collisions. Never commit directly to main/master/production.
 
 2. **DEPENDENCIES** - ${dependencyInstallationStep}
@@ -51,12 +51,13 @@ export function computeModes(): Mode[] {
 
 9. **PR** - Determine whether to create a PR (if not already on a PR branch):
    - **Default behavior**: Create a PR using ${ghPullfrogMcpName}/create_pull_request with an informative title and body. If you are working in the context of an issue (check EVENT DATA for \`issue_number\` where \`is_pr\` is not true), include "Closes #<issue_number>" in the PR body to auto-close the issue when merged.
+   - **Draft PR request**: If the user explicitly asks for a draft PR (e.g. "draft PR", "create as draft", "WIP"), create a PR with \`draft: true\`.
    - **Branch-only request**: If the user explicitly asks for a branch without a PR (e.g. "don't create a PR", "branch only", "just create a branch"), do NOT create a PR. Simply push the branch and report the branch link.
 
 10. **FINAL REPORT** - Call report_progress one final time ONLY if you haven't already included all the important information (PR links, branch links, summary) in a previous report_progress call. If you already called report_progress with complete information including PR links after creating the PR, you do NOT need to call it again. Only make a final call if you need to add missing information. When making the final call, ensure it includes:
    - A summary of what was accomplished
    - Links to any artifacts created (PRs, branches, issues)
-   - If you created a PR, ALWAYS include the PR link. e.g.: 
+   - If you created a PR, ALWAYS include the PR link. e.g.:
      \`\`\`md
      [View PR ➔](https://github.com/org/repo/pull/123)
      \`\`\`
@@ -78,7 +79,7 @@ export function computeModes(): Mode[] {
 
 2. **DEPENDENCIES** - ${dependencyInstallationStep}
 
-3. **FETCH COMMENTS** - Fetch review comments using ${ghPullfrogMcpName}/get_review_comments with \`pull_number\` and \`review_id\` from EVENT DATA. This returns \`commentsPath\` - read that file for full comment details with diff context. If EVENT DATA contains a \`triggerer\` field (indicating who requested fixes), you can pass \`approved_by\` to filter to only comments they approved with 👍.
+3. **FETCH COMMENTS** - Fetch review comments using ${ghPullfrogMcpName}/get_review_comments with \`pull_number\` and \`review_id\` from EVENT DATA. This returns \`commentsPath\` - read that file for full comment details with diff context. When \`approved_only\` is set in EVENT DATA, only approved comments are returned automatically.
 
 4. **UNDERSTAND** - Review the feedback provided. Understand each review comment and what changes are being requested.
 
@@ -100,7 +101,7 @@ Keep the progress comment extremely brief. The summary should be 1-2 sentences m
       name: "Review",
       description:
         "Review code, PRs, or implementations; provide feedback or suggestions; identify issues; or check code quality, style, and correctness",
-      prompt: `Follow these steps to review the PR. Your job is to find problems—assume they exist until you've proven otherwise. Do not submit a clean review without thorough investigation. **If you have nothing interesting to say, do NOT submit a review at all—use \`report_progress\` instead.**
+      prompt: `Follow these steps to review the PR. Your job is to find problems—assume they exist until you've proven otherwise. Do not submit a clean review without thorough investigation.
 
 1. **CHECKOUT** - Call ${ghPullfrogMcpName}/checkout_pr with the PR number. This should give you all PR metadata you need, including a \`diffPath\`: a path to a temp file containing the PR diff.
 
@@ -118,13 +119,50 @@ Keep the progress comment extremely brief. The summary should be 1-2 sentences m
    - **Check PR consistency**: Does the PR title/description match the actual code changes? Flag significant discrepancies.
    - Do NOT stop at "this looks reasonable." Dig until you either find a problem or have concrete evidence there isn't one.
 
-4. **DRAFT LINE-BY-LINE COMMENTS** - Every comment must be actionable: the author should need to change something in response. 2-3 sentences max. Use the NEW line number from the diff (second column: \`| OLD | NEW | TYPE | CODE\`). If no issues found, skip to step 5. NO COMPLIMENTS. NO NITPICKING ABOUT CHANGES UNRELATED TO THE MAIN CHANGE. Non-actionable comments (praise, style preferences, minor optimizatfixons, documentation nits) must not be drafted. If no comments survive and you have no significant concerns, **do not submit a review**. Use \`${ghPullfrogMcpName}/report_progress\` to note the PR was reviewed and no issues were found.
+4. **DRAFT LINE-BY-LINE COMMENTS** - Every comment must be actionable: the author should need to change something in response. 2-3 sentences max. Use the NEW line number from the diff (second column: \`| OLD | NEW | TYPE | CODE\`). If no issues found, skip to step 5. NO COMPLIMENTS. NO NITPICKING ABOUT CHANGES UNRELATED TO THE MAIN CHANGE. Non-actionable comments (praise, style preferences, minor optimizatfixons, documentation nits) must not be drafted.
 
-5. **WRITE SUMMARY** - Draft a 1-3 sentence summary for the review body. Include urgency level and any concerns about code outside the diff.
+5. **WRITE SUMMARY** - Draft a 1-3 sentence summary for the review body. If issues were found, include urgency level and any concerns about code outside the diff. If no issues were found, write a brief approval summary (e.g., "Changes look good. No issues found.").
 
-6. **SUBMIT** — Use ${ghPullfrogMcpName}/create_pull_request_review:
+6. **SUBMIT** — Always submit a review via ${ghPullfrogMcpName}/create_pull_request_review:
    - \`body\`: The summary from step 5
    - \`comments\`: The inline comments from step 4
+   - \`approved\`: Set to \`true\` ONLY if the review contains no actionable feedback — neither inline comments nor actionable content in the body. An approval signals "no changes needed."
+
+${permalinkTip}
+`,
+    },
+    {
+      name: "IncrementalReview",
+      description:
+        "Re-review a PR after new commits are pushed; focus on new changes since the last review",
+      prompt: `Follow these steps to incrementally re-review the PR after new commits were pushed. Focus on what changed since the last review.
+
+1. **CHECKOUT** - Call ${ghPullfrogMcpName}/checkout_pr with the PR number. This gives you the full PR diff via \`diffPath\`.
+
+2. **INCREMENTAL DIFF** - EVENT DATA contains \`before_sha\` (the HEAD before this push). Generate the incremental diff:
+   \`git diff <before_sha>...HEAD\`
+   This shows the changes introduced by this push. Cross-reference with previous reviews (step 3) to confirm coverage of all unreviewed changes — the full PR diff fills any gaps.
+   **If the diff command fails** (e.g., force-push rewrote history), fall back to reviewing the full PR diff from step 1.
+
+3. **FETCH PREVIOUS REVIEWS** - Use ${ghPullfrogMcpName}/list_pull_request_reviews to find previous Pullfrog reviews. For the most recent one, call ${ghPullfrogMcpName}/get_review_comments with the review ID to see specific line-level feedback. This lets you avoid repeating issues and assess whether prior feedback was addressed by the new commits.
+
+4. **ANALYZE** - Read the incremental diff to understand the new changes. Use the full PR diff for surrounding context and to catch any changes not covered by the incremental diff.
+   - **Understand the change**: What is new or modified since the last review?
+   - **Evaluate the approach**: Are the new changes sound? Do they address prior feedback?
+
+5. **INVESTIGATE** - Hunt for problems in the new code using the same techniques as a full review:
+   - Trace data flow, check boundaries, explore failure modes, verify assumptions, consider lifecycle, spot performance issues.
+   - Focus investigation on code that changed in the incremental diff, but trace its effects through the broader codebase.
+   - Do NOT repeat feedback already given in previous reviews unless it was not addressed.
+
+6. **DRAFT LINE-BY-LINE COMMENTS** - Every comment must be actionable. 2-3 sentences max. Use the NEW line number from the full PR diff. NO COMPLIMENTS. NO NITPICKING.
+
+7. **WRITE SUMMARY** - Draft a 1-3 sentence summary for the review body. Focus on what changed since the last review and whether the new changes are sound. If issues were found, include urgency level. If no issues were found, write a brief approval summary.
+
+8. **SUBMIT** — Use ${ghPullfrogMcpName}/create_pull_request_review:
+   - \`body\`: The summary from step 7
+   - \`comments\`: The inline comments from step 6
+   - \`approved\`: Set to \`true\` ONLY if the review contains no actionable feedback — neither inline comments nor actionable content in the body. An approval signals "no changes needed."
 
 ${permalinkTip}
 `,
@@ -162,23 +200,23 @@ ${permalinkTip}`,
    - \`failed_steps\`: which CI steps failed (e.g., "Step 6: Run tests")
 
 2. **CHECKOUT AND ASSESS CAUSATION** - Use ${ghPullfrogMcpName}/checkout_pr to get the PR diff. BEFORE attempting any fix, you MUST determine if this PR caused the failure:
-   
+
    **Ask yourself**: "Could the changes in this PR have caused this failure?"
-   
+
    - Read the PR diff carefully - what files were modified?
    - What is failing? (test file, module, assertion)
    - Is there a PLAUSIBLE CONNECTION between the PR changes and the failure?
-   
+
    **ABORT immediately if any of these are true:**
    - The failing test/file was NOT touched by this PR AND doesn't depend on changed code
    - The error is infrastructure-related (network timeout, runner OOM, service unavailable)
    - The error is a flaky test that passes/fails randomly
    - The error existed before this PR (pre-existing bug in main branch)
    - The error is in a dependency update not introduced by this PR
-   
+
    **When aborting**, use ${ghPullfrogMcpName}/report_progress to explain:
    "This CI failure appears unrelated to the PR's changes. [Describe the failure]. [Explain why it's not caused by the PR]. No changes made."
-   
+
    **Only proceed** if there's a clear, logical connection between the PR changes and the failure.
 
 3. **UNDERSTAND HOW CI RUNS** - Read the workflow file to understand exactly what commands CI runs:
@@ -212,6 +250,38 @@ ${permalinkTip}`,
 10. **PROGRESS** - ${reportProgressInstruction}
 
 Your job is to fix issues THIS PR introduced, not to fix all CI failures. If in doubt about causation, abort and explain rather than making speculative changes.`,
+    },
+    {
+      name: "ResolveConflicts",
+      description: "Resolve merge conflicts in a PR branch against the base branch",
+      prompt: `Follow these steps to resolve merge conflicts.
+
+1. **CHECKOUT** - Call ${ghPullfrogMcpName}/checkout_pr with the PR number. This fetches the PR branch.
+
+2. **FETCH BASE** - Identify the base branch (usually main or master) and fetch it using ${ghPullfrogMcpName}/git_fetch (e.g., ref: "main").
+
+3. **ATTEMPT MERGE** - Use ${ghPullfrogMcpName}/shell to run \`git merge origin/<base_branch>\`.
+   - If the merge succeeds (exit code 0), the branch is up to date. Push it and you're done.
+   - If the merge fails, you have conflicts to resolve.
+
+4. **IDENTIFY CONFLICTS** - Run \`git status\` to see which files are conflicting (modified by both).
+
+5. **RESOLVE** - For each conflicting file:
+   - Read the file to see the conflict markers (\`<<<<<<<\`, \`=======\`, \`>>>>>>>\`).
+   - Determine the correct content. You may need to keep changes from both sides, or choose one.
+   - Edit the file to apply the resolution and remove the markers.
+
+6. **VERIFY** - ${dependencyInstallationStep}
+   - Run tests/builds to ensure the resolution is correct.
+
+7. **COMMIT** - Once all conflicts are resolved:
+   - \`git add .\`
+   - \`git commit -m "Merge branch <base_branch> into <pr_branch>"\` (or similar).
+
+8. **PUSH** - Call ${ghPullfrogMcpName}/push_branch.
+
+9. **PROGRESS** - ${reportProgressInstruction}
+`,
     },
     {
       name: "Task",
@@ -233,6 +303,7 @@ Your job is to fix issues THIS PR introduced, not to fix all CI failures. If in
    - Commit your changes with \`${ghPullfrogMcpName}/git\` (\`git add .\` then \`git commit -m "message"\`), then push with \`${ghPullfrogMcpName}/push_branch\`. Do NOT use \`git push\` directly - it requires credentials that only the MCP tool provides.
    - Determine whether to create a PR:
      - **Default behavior**: Create a PR using ${ghPullfrogMcpName}/create_pull_request with an informative title and body. If you are working in the context of an issue (check EVENT DATA for \`issue_number\` where \`is_pr\` is not true), include "Closes #<issue_number>" in the PR body to auto-close the issue when merged.
+     - **Draft PR request**: If the user explicitly asks for a draft PR (e.g. "draft PR", "create as draft", "WIP"), create a PR with \`draft: true\`.
      - **Branch-only request**: If the user explicitly asks for a branch without a PR (e.g. "don't create a PR", "branch only", "just create a branch"), do NOT create a PR. Simply push the branch and report the branch link.
 
 5. **PROGRESS** - ${reportProgressInstruction}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pullfrog/pullfrog",
-  "version": "0.0.171",
+  "version": "0.0.178",
   "type": "module",
   "files": [
     "index.js",
@@ -34,13 +34,14 @@
     "@octokit/webhooks-types": "^7.6.1",
     "@openai/codex-sdk": "0.98.0",
     "@opencode-ai/sdk": "^1.0.143",
-    "@standard-schema/spec": "1.0.0",
+    "@standard-schema/spec": "1.1.0",
     "@toon-format/toon": "^1.0.0",
+    "ajv": "^8.18.0",
     "arkregex": "0.0.5",
-    "arktype": "2.1.29",
+    "arktype": "2.2.0",
     "dotenv": "^17.2.3",
     "execa": "^9.6.0",
-    "fastmcp": "^3.26.8",
+    "fastmcp": "^3.34.0",
     "file-type": "^21.3.0",
     "package-manager-detector": "^1.6.0",
     "semver": "^7.7.3",

post

@@ -24695,7 +24695,7 @@ var require_lodash = __commonJS({
     var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
     var symbolToString = symbolProto ? symbolProto.toString : void 0;
     function baseIsRegExp(value2) {
-      return isObject(value2) && objectToString.call(value2) == regexpTag;
+      return isObject2(value2) && objectToString.call(value2) == regexpTag;
     }
     function baseSlice(array, start, end) {
       var index = -1, length = array.length;
@@ -24729,7 +24729,7 @@ var require_lodash = __commonJS({
       end = end === void 0 ? length : end;
       return !start && end >= length ? array : baseSlice(array, start, end);
     }
-    function isObject(value2) {
+    function isObject2(value2) {
       var type2 = typeof value2;
       return !!value2 && (type2 == "object" || type2 == "function");
     }
@@ -24762,9 +24762,9 @@ var require_lodash = __commonJS({
       if (isSymbol(value2)) {
         return NAN;
       }
-      if (isObject(value2)) {
+      if (isObject2(value2)) {
         var other = typeof value2.valueOf == "function" ? value2.valueOf() : value2;
-        value2 = isObject(other) ? other + "" : other;
+        value2 = isObject2(other) ? other + "" : other;
       }
       if (typeof value2 != "string") {
         return value2 === 0 ? value2 : +value2;
@@ -24778,7 +24778,7 @@ var require_lodash = __commonJS({
     }
     function truncate(string2, options) {
       var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;
-      if (isObject(options)) {
+      if (isObject2(options)) {
         var separator2 = "separator" in options ? options.separator : separator2;
         length = "length" in options ? toInteger(options.length) : length;
         omission = "omission" in options ? baseToString(options.omission) : omission;
@@ -28846,6 +28846,7 @@ var require_semver2 = __commonJS({
 // utils/log.ts
 var core = __toESM(require_core(), 1);
 var import_table = __toESM(require_src(), 1);
+import { AsyncLocalStorage } from "node:async_hooks";
 
 // utils/globals.ts
 import { existsSync } from "node:fs";
@@ -28854,6 +28855,20 @@ var isGitHubActions = !!process.env.GITHUB_ACTIONS;
 var isInsideDocker = existsSync("/.dockerenv");
 
 // utils/log.ts
+var logContext = new AsyncLocalStorage();
+var MAGENTA = "\x1B[35m";
+var RESET = "\x1B[0m";
+function prefixLines(message) {
+  const ctx = logContext.getStore();
+  if (!ctx) return message;
+  const colored = `${MAGENTA}${ctx.prefix}${RESET} `;
+  return message.split("\n").map((line) => `${colored}${line}`).join("\n");
+}
+function prefixPlain(name) {
+  const ctx = logContext.getStore();
+  if (!ctx) return name;
+  return `${ctx.prefix} ${name}`;
+}
 var isRunnerDebugEnabled = () => core.isDebug();
 var isLocalDebugEnabled = () => process.env.LOG_LEVEL === "debug" || process.env.ACTIONS_STEP_DEBUG === "true";
 var isDebugEnabled = () => isLocalDebugEnabled() || isRunnerDebugEnabled();
@@ -28869,10 +28884,11 @@ ${arg.stack}`;
   }).join(" ");
 }
 function startGroup2(name) {
+  const prefixed = prefixPlain(name);
   if (isGitHubActions) {
-    core.startGroup(name);
+    core.startGroup(prefixed);
   } else {
-    console.group(name);
+    console.group(prefixed);
   }
 }
 function endGroup2() {
@@ -28945,7 +28961,7 @@ function boxString(text, options) {
 }
 function box(text, options) {
   const boxContent = boxString(text, options);
-  core.info(boxContent);
+  core.info(prefixLines(boxContent));
 }
 function printTable(rows, options) {
   const { title } = options || {};
@@ -28959,42 +28975,42 @@ function printTable(rows, options) {
   );
   const formatted = (0, import_table.table)(tableData);
   if (title) {
-    core.info(`
-${title}`);
+    core.info(prefixLines(`
+${title}`));
   }
-  core.info(`
+  core.info(prefixLines(`
 ${formatted}
-`);
+`));
 }
 function separator(length = 50) {
   const separatorText = "\u2500".repeat(length);
-  core.info(separatorText);
+  core.info(prefixLines(separatorText));
 }
 var log = {
   /** Print info message */
   info: (...args2) => {
-    core.info(`${ts()}${formatArgs(args2)}`);
+    core.info(prefixLines(`${ts()}${formatArgs(args2)}`));
   },
   /** Print a warning message. Use only for warnings that should be displayed in the job summary. */
   warning: (...args2) => {
-    core.warning(`${ts()}${formatArgs(args2)}`);
+    core.warning(prefixLines(`${ts()}${formatArgs(args2)}`));
   },
   /** Print an error message. Use only for errors that should be displayed in the job summary. */
   error: (...args2) => {
-    core.error(`${ts()}${formatArgs(args2)}`);
+    core.error(prefixLines(`${ts()}${formatArgs(args2)}`));
   },
   /** Print success message */
   success: (...args2) => {
-    core.info(`${ts()}\xBB ${formatArgs(args2)}`);
+    core.info(prefixLines(`${ts()}\xBB ${formatArgs(args2)}`));
   },
   /** Print debug message (only when debug mode is enabled) */
   debug: (...args2) => {
     if (isRunnerDebugEnabled()) {
-      core.debug(formatArgs(args2));
+      core.debug(prefixLines(formatArgs(args2)));
       return;
     }
     if (isLocalDebugEnabled()) {
-      core.info(`${ts()}[DEBUG] ${formatArgs(args2)}`);
+      core.info(prefixLines(`${ts()}[DEBUG] ${formatArgs(args2)}`));
     }
   },
   /** Print a formatted box with text */
@@ -35663,7 +35679,7 @@ $ark.intrinsic = { ...intrinsic };
 var regex = ((src, flags) => new RegExp(src, flags));
 Object.assign(regex, { as: regex });
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/operand/date.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/operand/date.js
 var isDateLiteral = (value2) => typeof value2 === "string" && value2[0] === "d" && (value2[1] === "'" || value2[1] === '"') && value2[value2.length - 1] === value2[1];
 var isValidDate = (d) => d.toString() !== "Invalid Date";
 var extractDateLiteralSource = (literal) => literal.slice(2, -1);
@@ -35682,7 +35698,7 @@ var maybeParseDate = (source, errorOnFail) => {
   return errorOnFail ? throwParseError(errorOnFail === true ? writeInvalidDateMessage(source) : errorOnFail) : void 0;
 };
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/operand/enclosed.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/operand/enclosed.js
 var regexExecArray = rootSchema({
   proto: "Array",
   sequence: "string",
@@ -35756,12 +35772,12 @@ var enclosingCharDescriptions = {
 };
 var writeUnterminatedEnclosedMessage = (fragment, enclosingStart) => `${enclosingStart}${fragment} requires a closing ${enclosingCharDescriptions[enclosingTokens[enclosingStart]]}`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/ast/validate.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/ast/validate.js
 var writePrefixedPrivateReferenceMessage = (name) => `Private type references should not include '#'. Use '${name}' instead.`;
 var shallowOptionalMessage = "Optional definitions like 'string?' are only valid as properties in an object or tuple";
 var shallowDefaultableMessage = "Defaultable definitions like 'number = 0' are only valid as properties in an object or tuple";
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/tokens.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/tokens.js
 var terminatingChars = {
   "<": 1,
   ">": 1,
@@ -35783,7 +35799,7 @@ var lookaheadIsFinalizing = (lookahead, unscanned) => lookahead === ">" ? unscan
   unscanned[1] === "="
 ) : unscanned.trimStart() === "" || isKeyOf(unscanned.trimStart()[0], terminatingChars) : lookahead === "=" ? unscanned[0] !== "=" : lookahead === "," || lookahead === "?";
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/operand/genericArgs.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/operand/genericArgs.js
 var parseGenericArgs = (name, g, s) => _parseGenericArgs(name, g, s, []);
 var _parseGenericArgs = (name, g, s, argNodes) => {
   const argState = s.parseUntilFinalizer();
@@ -35800,7 +35816,7 @@ var _parseGenericArgs = (name, g, s, argNodes) => {
 };
 var writeInvalidGenericArgCountMessage = (name, params, argDefs) => `${name}<${params.join(", ")}> requires exactly ${params.length} args (got ${argDefs.length}${argDefs.length === 0 ? "" : `: ${argDefs.join(", ")}`})`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/operand/unenclosed.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/operand/unenclosed.js
 var parseUnenclosed = (s) => {
   const token = s.scanner.shiftUntilLookahead(terminatingChars);
   if (token === "keyof")
@@ -35848,10 +35864,10 @@ var writeMissingOperandMessage = (s) => {
 var writeMissingRightOperandMessage = (token, unscanned = "") => `Token '${token}' requires a right operand${unscanned ? ` before '${unscanned}'` : ""}`;
 var writeExpressionExpectedMessage = (unscanned) => `Expected an expression${unscanned ? ` before '${unscanned}'` : ""}`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/operand/operand.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/operand/operand.js
 var parseOperand = (s) => s.scanner.lookahead === "" ? s.error(writeMissingOperandMessage(s)) : s.scanner.lookahead === "(" ? s.shiftedBy(1).reduceGroupOpen() : s.scanner.lookaheadIsIn(enclosingChar) ? parseEnclosed(s, s.scanner.shift()) : s.scanner.lookaheadIsIn(whitespaceChars) ? parseOperand(s.shiftedBy(1)) : s.scanner.lookahead === "d" ? s.scanner.nextLookahead in enclosingQuote ? parseEnclosed(s, `${s.scanner.shift()}${s.scanner.shift()}`) : parseUnenclosed(s) : s.scanner.lookahead === "x" ? s.scanner.nextLookahead === "/" ? s.shiftedBy(2) && parseEnclosed(s, "x/") : parseUnenclosed(s) : parseUnenclosed(s);
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/reduce/shared.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/reduce/shared.js
 var minComparators = {
   ">": true,
   ">=": true
@@ -35871,7 +35887,7 @@ var writeOpenRangeMessage = (min, comparator) => `Left bounds are only valid whe
 var writeUnpairableComparatorMessage = (comparator) => `Left-bounded expressions must specify their limits using < or <= (was ${comparator})`;
 var writeMultipleLeftBoundsMessage = (openLimit, openComparator, limit, comparator) => `An expression may have at most one left bound (parsed ${openLimit}${invertedComparators[openComparator]}, ${limit}${invertedComparators[comparator]})`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/operator/bounds.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/operator/bounds.js
 var parseBound = (s, start) => {
   const comparator = shiftComparator(s, start);
   if (s.root.hasKind("unit")) {
@@ -35942,14 +35958,14 @@ var parseRightBound = (s, comparator) => {
 };
 var writeInvalidLimitMessage = (comparator, limit, boundKind) => `Comparator ${boundKind === "left" ? invertedComparators[comparator] : comparator} must be ${boundKind === "left" ? "preceded" : "followed"} by a corresponding literal (was ${limit})`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/operator/brand.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/operator/brand.js
 var parseBrand = (s) => {
   s.scanner.shiftUntilNonWhitespace();
   const brandName = s.scanner.shiftUntilLookahead(terminatingChars);
   s.root = s.root.brand(brandName);
 };
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/operator/divisor.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/operator/divisor.js
 var parseDivisor = (s) => {
   s.scanner.shiftUntilNonWhitespace();
   const divisorToken = s.scanner.shiftUntilLookahead(terminatingChars);
@@ -35962,7 +35978,7 @@ var parseDivisor = (s) => {
 };
 var writeInvalidDivisorMessage = (divisor) => `% operator must be followed by a non-zero integer literal (was ${divisor})`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/operator/operator.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/operator/operator.js
 var parseOperator = (s) => {
   const lookahead = s.scanner.shift();
   return lookahead === "" ? s.finalize("") : lookahead === "[" ? s.scanner.shift() === "]" ? s.setRoot(s.root.array()) : s.error(incompleteArrayTokenMessage) : lookahead === "|" ? s.scanner.lookahead === ">" ? s.shiftedBy(1).pushRootToBranch("|>") : s.pushRootToBranch(lookahead) : lookahead === "&" ? s.pushRootToBranch(lookahead) : lookahead === ")" ? s.finalizeGroup() : lookaheadIsFinalizing(lookahead, s.scanner.unscanned) ? s.finalize(lookahead) : isKeyOf(lookahead, comparatorStartChars) ? parseBound(s, lookahead) : lookahead === "%" ? parseDivisor(s) : lookahead === "#" ? parseBrand(s) : lookahead in whitespaceChars ? parseOperator(s) : s.error(writeUnexpectedCharacterMessage(lookahead));
@@ -35970,7 +35986,7 @@ var parseOperator = (s) => {
 var writeUnexpectedCharacterMessage = (char, shouldBe = "") => `'${char}' is not allowed here${shouldBe && ` (should be ${shouldBe})`}`;
 var incompleteArrayTokenMessage = `Missing expected ']'`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/shift/operator/default.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/shift/operator/default.js
 var parseDefault = (s) => {
   const baseNode = s.unsetRoot();
   s.parseOperand();
@@ -35982,7 +35998,7 @@ var parseDefault = (s) => {
 };
 var writeNonLiteralDefaultMessage = (defaultDef) => `Default value '${defaultDef}' must be a literal value`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/string.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/string.js
 var parseString = (def, ctx) => {
   const aliasResolution = ctx.$.maybeResolveRoot(def);
   if (aliasResolution)
@@ -36021,7 +36037,7 @@ var parseUntilFinalizer = (s) => {
 };
 var next = (s) => s.hasRoot() ? s.parseOperator() : s.parseOperand();
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/reduce/dynamic.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/reduce/dynamic.js
 var RuntimeState = class _RuntimeState {
   root;
   branches = {
@@ -36158,7 +36174,7 @@ var RuntimeState = class _RuntimeState {
   }
 };
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/generic.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/generic.js
 var emptyGenericParameterMessage = "An empty string is not a valid generic parameter name";
 var parseGenericParamName = (scanner, result, ctx) => {
   scanner.shiftUntilNonWhitespace();
@@ -36187,7 +36203,7 @@ var _parseOptionalConstraint = (scanner, name, result, ctx) => {
   return parseGenericParamName(scanner, result, ctx);
 };
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/fn.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/fn.js
 var InternalFnParser = class extends Callable {
   constructor($) {
     const attach = {
@@ -36239,7 +36255,7 @@ var InternalTypedFn = class extends Callable {
 var badFnReturnTypeMessage = `":" must be followed by exactly one return type e.g:
 fn("string", ":", "number")(s => s.length)`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/match.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/match.js
 var InternalMatchParser = class extends Callable {
   $;
   constructor($) {
@@ -36332,7 +36348,7 @@ var throwOnDefault = (errors) => errors.throw();
 var chainedAtMessage = `A key matcher must be specified before the first case i.e. match.at('foo') or match.in<object>().at('bar')`;
 var doubleAtMessage = `At most one key matcher may be specified per expression`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/property.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/property.js
 var parseProperty = (def, ctx) => {
   if (isArray(def)) {
     if (def[1] === "=")
@@ -36345,7 +36361,7 @@ var parseProperty = (def, ctx) => {
 var invalidOptionalKeyKindMessage = `Only required keys may make their values optional, e.g. { [mySymbol]: ['number', '?'] }`;
 var invalidDefaultableKeyKindMessage = `Only required keys may specify default values, e.g. { value: 'number = 0' }`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/objectLiteral.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/objectLiteral.js
 var parseObjectLiteral = (def, ctx) => {
   let spread;
   const structure = {};
@@ -36435,7 +36451,7 @@ var preparseKey = (key) => typeof key === "symbol" ? { kind: "required", normali
 };
 var writeInvalidSpreadTypeMessage = (def) => `Spread operand must resolve to an object literal type (was ${def})`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/tupleExpressions.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/tupleExpressions.js
 var maybeParseTupleExpression = (def, ctx) => isIndexZeroExpression(def) ? indexZeroParsers[def[0]](def, ctx) : isIndexOneExpression(def) ? indexOneParsers[def[1]](def, ctx) : null;
 var parseKeyOfTuple = (def, ctx) => ctx.$.parseOwnDefinitionFormat(def[1], ctx).keyof();
 var parseBranchTuple = (def, ctx) => {
@@ -36498,7 +36514,7 @@ var indexZeroParsers = defineIndexZeroParsers({
 var isIndexZeroExpression = (def) => indexZeroParsers[def[0]] !== void 0;
 var writeInvalidConstructorMessage = (actual) => `Expected a constructor following 'instanceof' operator (was ${actual})`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/tupleLiteral.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/tupleLiteral.js
 var parseTupleLiteral = (def, ctx) => {
   let sequences = [{}];
   let i = 0;
@@ -36600,7 +36616,7 @@ var requiredPostOptionalMessage = "A required element may not follow an optional
 var optionalOrDefaultableAfterVariadicMessage = "An optional element may not follow a variadic element";
 var defaultablePostOptionalMessage = "A defaultable element may not follow an optional element without a default";
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/parser/definition.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/parser/definition.js
 var parseCache = {};
 var parseInnerDefinition = (def, ctx) => {
   if (typeof def === "string") {
@@ -36664,7 +36680,7 @@ var parseStandardSchema = (def, ctx) => ctx.$.intrinsic.unknown.pipe((v, ctx2) =
 var parseTuple = (def, ctx) => maybeParseTupleExpression(def, ctx) ?? parseTupleLiteral(def, ctx);
 var writeBadDefinitionTypeMessage = (actual) => `Type definitions must be strings or objects (was ${actual})`;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/type.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/type.js
 var InternalTypeParser = class extends Callable {
   constructor($) {
     const attach = Object.assign(
@@ -36711,7 +36727,7 @@ var InternalTypeParser = class extends Callable {
   }
 };
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/scope.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/scope.js
 var $arkTypeRegistry = $ark;
 var InternalScope = class _InternalScope extends BaseScope {
   get ambientAttachments() {
@@ -36806,7 +36822,7 @@ var scope = Object.assign(InternalScope.scope, {
 });
 var Scope = InternalScope;
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/keywords/builtins.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/keywords/builtins.js
 var MergeHkt = class extends Hkt {
   description = 'merge an object\'s properties onto another like `Merge(User, { isAdmin: "true" })`';
 };
@@ -36816,7 +36832,7 @@ var arkBuiltins = Scope.module({
   Merge
 });
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/keywords/Array.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/keywords/Array.js
 var liftFromHkt = class extends Hkt {
 };
 var liftFrom = genericNode("element")((args2) => {
@@ -36833,7 +36849,7 @@ var arkArray = Scope.module({
   name: "Array"
 });
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/keywords/FormData.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/keywords/FormData.js
 var value = rootSchema(["string", registry.FileConstructor]);
 var parsedFormDataValue = value.rawOr(value.array());
 var parsed = rootSchema({
@@ -36870,7 +36886,7 @@ var arkFormData = Scope.module({
   name: "FormData"
 });
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/keywords/TypedArray.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/keywords/TypedArray.js
 var TypedArray = Scope.module({
   Int8: ["instanceof", Int8Array],
   Uint8: ["instanceof", Uint8Array],
@@ -36887,7 +36903,7 @@ var TypedArray = Scope.module({
   name: "TypedArray"
 });
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/keywords/constructors.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/keywords/constructors.js
 var omittedPrototypes = {
   Boolean: 1,
   Number: 1,
@@ -36900,7 +36916,7 @@ var arkPrototypes = Scope.module({
   FormData: arkFormData
 });
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/keywords/number.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/keywords/number.js
 var epoch = rootSchema({
   domain: {
     domain: "number",
@@ -36943,7 +36959,7 @@ var number = Scope.module({
   name: "number"
 });
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/keywords/string.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/keywords/string.js
 var regexStringNode = (regex4, description, jsonSchemaFormat) => {
   const schema2 = {
     domain: "string",
@@ -37350,7 +37366,7 @@ var string = Scope.module({
   name: "string"
 });
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/keywords/ts.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/keywords/ts.js
 var arkTsKeywords = Scope.module({
   bigint: intrinsic.bigint,
   boolean: intrinsic.boolean,
@@ -37431,7 +37447,7 @@ var arkTsGenerics = Scope.module({
   Required: Required2
 });
 
-// node_modules/.pnpm/arktype@2.1.29/node_modules/arktype/out/keywords/keywords.js
+// node_modules/.pnpm/arktype@2.2.0/node_modules/arktype/out/keywords/keywords.js
 var ark = scope({
   ...arkTsKeywords,
   ...arkTsGenerics,
@@ -37477,6 +37493,22 @@ var schema = ark.schema;
 var define2 = ark.define;
 var declare = ark.declare;
 
+// utils/apiUrl.ts
+function isLocalUrl(url2) {
+  return url2.hostname === "localhost" || url2.hostname === "127.0.0.1";
+}
+function getApiUrl() {
+  const raw = process.env.API_URL || "https://pullfrog.com";
+  const parsed2 = new URL(raw);
+  if (parsed2.protocol !== "https:" && !isLocalUrl(parsed2)) {
+    throw new Error(
+      `API_URL must use https:// (got ${parsed2.protocol}). only localhost is exempt.`
+    );
+  }
+  log.debug(`resolved API_URL: ${raw}`);
+  return raw;
+}
+
 // utils/buildPullfrogFooter.ts
 var PULLFROG_DIVIDER = "<!-- PULLFROG_DIVIDER_DO_NOT_REMOVE_PLZ -->";
 var FROG_LOGO = `<a href="https://pullfrog.com"><picture><source media="(prefers-color-scheme: dark)" srcset="https://pullfrog.com/logos/frog-white-full-18px.png"><img src="https://pullfrog.com/logos/frog-green-full-18px.png" width="9px" height="9px" style="vertical-align: middle; " alt="Pullfrog"></picture></a>`;
@@ -41151,6 +41183,9 @@ var Octokit2 = Octokit.plugin(requestLog, legacyRestEndpointMethods, paginateRes
 );
 
 // utils/github.ts
+function isObject(value2) {
+  return typeof value2 === "object" && value2 !== null;
+}
 function parseRepoContext() {
   const githubRepo = process.env.GITHUB_REPOSITORY;
   if (!githubRepo) {
@@ -41162,9 +41197,20 @@ function parseRepoContext() {
   }
   return { owner, name };
 }
+function emptyResourceUsage() {
+  return {
+    requestCount: 0,
+    rateLimitRemaining: null,
+    rateLimitResetMs: null
+  };
+}
+var usageByResource = {
+  core: emptyResourceUsage(),
+  graphql: emptyResourceUsage()
+};
 function createOctokit(token) {
   const OctokitWithPlugins = Octokit2.plugin(throttling);
-  return new OctokitWithPlugins({
+  const octokit = new OctokitWithPlugins({
     auth: token,
     throttle: {
       onRateLimit: (_retryAfter, _options, _octokit, retryCount) => {
@@ -41175,20 +41221,57 @@ function createOctokit(token) {
       }
     }
   });
+  const onResponse = (response) => {
+    const resource = response.headers["x-ratelimit-resource"];
+    if (!resource) {
+      return response;
+    }
+    usageByResource[resource] ??= emptyResourceUsage();
+    const usage = usageByResource[resource];
+    usage.requestCount++;
+    const remaining = response.headers["x-ratelimit-remaining"];
+    const reset = response.headers["x-ratelimit-reset"];
+    if (remaining !== void 0) {
+      usage.rateLimitRemaining = Number(remaining);
+    }
+    if (reset !== void 0) {
+      usage.rateLimitResetMs = Number(reset) * 1e3;
+    }
+    return response;
+  };
+  octokit.hook.wrap("request", async (request2, options) => {
+    try {
+      const response = await request2(options);
+      onResponse(response);
+      return response;
+    } catch (error2) {
+      if (isObject(error2) && "response" in error2 && isObject(error2.response) && "headers" in error2.response && isObject(error2.response.headers)) {
+        onResponse(error2.response);
+      }
+      throw error2;
+    }
+  });
+  return octokit;
 }
 
 // mcp/comment.ts
 var LEAPING_INTO_ACTION_PREFIX = "Leaping into action";
 var Comment = type({
   issueNumber: type.number.describe("the issue number to comment on"),
-  body: type.string.describe("the comment body content")
+  body: type.string.describe("the comment body content"),
+  type: type.enumerated("Plan", "Comment").describe(
+    "Plan: record this comment as the plan for this run (use report_progress for progress/plan updates on the current run). Comment: regular comment (default)."
+  ).optional()
 });
 var EditComment = type({
   commentId: type.number.describe("the ID of the comment to edit"),
   body: type.string.describe("the new comment body content")
 });
 var ReportProgress = type({
-  body: type.string.describe("the progress update content to share")
+  body: type.string.describe("the progress update content to share"),
+  "target_plan_comment?": type("boolean").describe(
+    "when true, update the existing plan comment (from select_mode lookup) instead of the progress comment; use when editing an existing plan"
+  )
 });
 var ReplyToReviewComment = type({
   pull_number: type.number.describe("the pull request number"),
@@ -41235,7 +41318,7 @@ var Effort = type.enumerated("mini", "auto", "max");
 // package.json
 var package_default = {
   name: "@pullfrog/pullfrog",
-  version: "0.0.171",
+  version: "0.0.178",
   type: "module",
   files: [
     "index.js",
@@ -41269,13 +41352,14 @@ var package_default = {
     "@octokit/webhooks-types": "^7.6.1",
     "@openai/codex-sdk": "0.98.0",
     "@opencode-ai/sdk": "^1.0.143",
-    "@standard-schema/spec": "1.0.0",
+    "@standard-schema/spec": "1.1.0",
     "@toon-format/toon": "^1.0.0",
+    ajv: "^8.18.0",
     arkregex: "0.0.5",
-    arktype: "2.1.29",
+    arktype: "2.2.0",
     dotenv: "^17.2.3",
     execa: "^9.6.0",
-    fastmcp: "^3.26.8",
+    fastmcp: "^3.34.0",
     "file-type": "^21.3.0",
     "package-manager-detector": "^1.6.0",
     semver: "^7.7.3",
@@ -41350,7 +41434,7 @@ var JsonPayload = type({
   version: "string",
   "agent?": AgentName.or("undefined"),
   prompt: "string",
-  "triggeringUser?": "string | undefined",
+  "triggerer?": "string | undefined",
   "eventInstructions?": "string",
   "repoInstructions?": "string",
   "event?": "object",
@@ -41368,7 +41452,8 @@ var Inputs = type({
   "search?": ToolPermissionInput.or("undefined"),
   "push?": PushPermissionInput.or("undefined"),
   "shell?": ShellPermissionInput.or("undefined"),
-  "cwd?": type.string.or("undefined")
+  "cwd?": type.string.or("undefined"),
+  "output_schema?": type.string.or("undefined")
 });
 function resolvePromptInput() {
   const prompt = core3.getInput("prompt", { required: true });
@@ -41403,15 +41488,25 @@ function getJobToken() {
 // utils/postCleanup.ts
 var SHOULD_CHECK_REASON = true;
 function buildErrorCommentBody(params) {
-  const workflowRunLink = params.runId ? `[workflow run logs](https://github.com/${params.owner}/${params.repo}/actions/runs/${params.runId})` : "workflow run logs";
-  const errorMessage = params.isCancellation ? `This run was cancelled \u{1F6D1}
+  let errorMessage = params.isCancellation ? `This run was cancelled \u{1F6D1}
 
-The workflow was cancelled before completion. Please check the ${workflowRunLink} for details.` : `This run croaked \u{1F635}
+The workflow was cancelled before completion.` : `This run croaked \u{1F635}
 
-The workflow encountered an error before any progress could be reported. Please check the ${workflowRunLink} for details.`;
+The workflow encountered an error before any progress could be reported.`;
+  if (params.runId) {
+    errorMessage += " Please check the link below for details.";
+  }
+  const customParts = [];
+  if (!params.isCancellation && params.runId) {
+    const apiUrl = getApiUrl();
+    customParts.push(
+      `[Rerun failed job \u2794](${apiUrl}/trigger/${params.owner}/${params.repo}/${params.runId}?action=rerun)`
+    );
+  }
   const footer = buildPullfrogFooter({
     triggeredBy: true,
-    workflowRun: params.runId ? { owner: params.owner, repo: params.repo, runId: params.runId } : void 0
+    workflowRun: params.runId ? { owner: params.owner, repo: params.repo, runId: params.runId } : void 0,
+    customParts
   });
   return `${errorMessage}${footer}`;
 }
@@ -41441,12 +41536,12 @@ async function validateStuckProgressComment(params) {
   }
 }
 async function getIsCancelled(params) {
-  if (!params.runIdStr) return false;
+  if (!params.runId) return false;
   try {
     const jobsResult = await params.octokit.rest.actions.listJobsForWorkflowRun({
       owner: params.repoContext.owner,
       repo: params.repoContext.name,
-      run_id: Number.parseInt(params.runIdStr, 10)
+      run_id: params.runId
     });
     const currentJobName = process.env.GITHUB_JOB;
     const currentJob = currentJobName ? jobsResult.data.jobs.find(
@@ -41473,7 +41568,7 @@ async function getIsCancelled(params) {
 }
 async function runPostCleanup() {
   log.info("\xBB [post] starting post cleanup");
-  const runIdStr = process.env.GITHUB_RUN_ID;
+  const runId = process.env.GITHUB_RUN_ID ? Number.parseInt(process.env.GITHUB_RUN_ID, 10) : void 0;
   let promptInput = null;
   try {
     const resolved = resolvePromptInput();
@@ -41498,8 +41593,8 @@ async function runPostCleanup() {
     const body = buildErrorCommentBody({
       owner: repoContext.owner,
       repo: repoContext.name,
-      runId: runIdStr,
-      isCancellation: SHOULD_CHECK_REASON ? await getIsCancelled({ octokit, repoContext, runIdStr }) : false
+      runId,
+      isCancellation: SHOULD_CHECK_REASON ? await getIsCancelled({ octokit, repoContext, runId }) : false
     });
     await octokit.rest.issues.updateComment({
       owner: repoContext.owner,

prep/installNodeDependencies.ts

@@ -159,13 +159,16 @@ export const installNodeDependencies: PrepDefinition = {
       cmd: resolved.command,
       args: resolved.args,
       env: { PATH: process.env.PATH || "", HOME: process.env.HOME || "" },
-      onStdout: (chunk) => process.stdout.write(chunk),
-      onStderr: (chunk) => process.stderr.write(chunk),
     });
 
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+    if (output) {
+      log.startGroup(`${fullCommand} output`);
+      log.info(output);
+      log.endGroup();
+    }
+
     if (result.exitCode !== 0) {
-      // combine stdout and stderr for better error context (pnpm often outputs errors to stdout)
-      const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
       const errorMessage = output || `exited with code ${result.exitCode}`;
       return {
         language: "node",

prep/installPythonDependencies.ts

@@ -162,21 +162,28 @@ export const installPythonDependencies: PrepDefinition = {
 
     // run the install command
     const [cmd, ...args] = config.installCmd;
-    log.info(`» running: ${cmd} ${args.join(" ")}`);
+    const fullCommand = `${cmd} ${args.join(" ")}`;
+    log.info(`» running: ${fullCommand}`);
     const result = await spawn({
       cmd,
       args,
       env: { PATH: process.env.PATH || "", HOME: process.env.HOME || "" },
-      onStderr: (chunk) => process.stderr.write(chunk),
     });
 
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+    if (output) {
+      log.startGroup(`${fullCommand} output`);
+      log.info(output);
+      log.endGroup();
+    }
+
     if (result.exitCode !== 0) {
       return {
         language: "python",
         packageManager: config.tool,
         configFile: config.file,
         dependenciesInstalled: false,
-        issues: [result.stderr || `${cmd} exited with code ${result.exitCode}`],
+        issues: [output || `${cmd} exited with code ${result.exitCode}`],
       };
     }
 

test/adhoc/delegateAskQuestion.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * delegate-ask-question — orchestrator uses ask_question to gather codebase
@@ -34,7 +34,7 @@ IMPORTANT: You MUST use ask_question BEFORE delegating. The subagent prompt must
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
 
   const setOutputCalled = output !== null;

test/adhoc/delegateContextIsolation.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * delegate-context-isolation — verifies that the subagent's "clean room"
@@ -39,7 +39,7 @@ CRITICAL: Your final output MUST contain "SECRET=${SECRET}" exactly.`,
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
 
   const setOutputCalled = output !== null;

test/adhoc/delegateErrorHandling.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * delegate-error-handling — orchestrator delegates a task that will fail,
@@ -33,7 +33,7 @@ The point of this test is that you handle the error gracefully and report it —
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
 
   const setOutputCalled = output !== null;

test/adhoc/delegateFileRead.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * delegate-file-read — orchestrator delegates a subagent to read a real file
@@ -33,7 +33,7 @@ IMPORTANT: Your subagent prompt must include the exact MCP tool names (gh_pullfr
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
 
   const setOutputCalled = output !== null;

test/adhoc/delegateSynthesis.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * delegate-synthesis — orchestrator delegates two research tasks to separate
@@ -40,7 +40,7 @@ Both pieces must come from the respective subagent results. Do NOT read the file
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
 
   const setOutputCalled = output !== null;

test/adhoc/delegateTimeout.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * delegateTimeout test - validates that the activity timeout does NOT fire
@@ -32,7 +32,7 @@ After the delegation completes, call set_output yourself with the subagent's res
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
 
   const setOutputCalled = output !== null;

test/adhoc/delegateTwoPhase.ts

@@ -1,10 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import {
-  defineFixture,
-  generateTestMarker,
-  getAgentOutput,
-  getStructuredOutput,
-} from "../utils.ts";
+import { defineFixture, generateTestMarker, getAgentOutput } from "../utils.ts";
 
 /**
  * delegate-two-phase — orchestrator runs two sequential delegations where
@@ -44,7 +39,7 @@ After both phases complete, call set_output with: "WRITTEN=<marker>,READ=<what_p
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
   const secret = marker.value;
 

test/adhoc/fileWriteNobash.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * Adversarial sandbox escape test. Agent has no shell — only MCP file_read,
@@ -61,7 +61,7 @@ const repoSetup = [
 ].join(" && ");
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
 
   // marker must be read correctly (proves file_read works inside repo)

test/adhoc/gitConfigAttack.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * git config attack test - validates:
@@ -65,7 +65,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
   const setOutputCalled = output !== null;
 

test/adhoc/gitExecBypass.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * git --exec bypass test - validates:
@@ -61,7 +61,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
   const setOutputCalled = output !== null;
 

test/adhoc/gitFlagInjection.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * git flag injection test - validates:
@@ -53,7 +53,7 @@ Call the git tool with:
 Call set_output with:
 {
   "approach1_result": "exact output or error",
-  "approach2_result": "exact output or error", 
+  "approach2_result": "exact output or error",
   "approach3_result": "exact output or error",
   "approach4_result": "exact output or error",
   "approach5_result": "exact output or error",
@@ -71,7 +71,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
   const setOutputCalled = output !== null;
 

test/adhoc/gitattributesAttack.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getStructuredOutput } from "../utils.ts";
+import { defineFixture } from "../utils.ts";
 
 /**
  * .gitattributes write blocking test - validates:
@@ -59,7 +59,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
 
   let parsed: Record<string, unknown> = {};

test/adhoc/nobashEscapeComprehensive.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * comprehensive nobash escape test - validates:
@@ -80,7 +80,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
   const setOutputCalled = output !== null;
 

test/adhoc/nobashcreative.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, generateAgentUuids, getStructuredOutput } from "../utils.ts";
+import { defineFixture, generateAgentUuids } from "../utils.ts";
 
 /**
  * nobashcreative test - exploratory test to see if agents can creatively bypass shell=disabled.
@@ -40,7 +40,7 @@ function validator(result: AgentResult): ValidationCheck[] {
   const marker = getUuid(result.agent, "PULLFROG_NOBASH_TEST");
 
   // require structured output from set_output tool
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
 
   // shell should NOT have executed - unique marker value should NOT appear in output

test/adhoc/requirementsTxtAttack.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * requirements.txt local path attack test - validates:
@@ -59,7 +59,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
   const setOutputCalled = output !== null;
 

test/agnostic/delegate.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * delegate test - validates core end-to-end delegation flow.
@@ -12,7 +12,9 @@ import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts"
 const fixture = defineFixture(
   {
     prompt: `Select the Plan mode via select_mode, then delegate with mini effort. Your subagent instructions should be:
-"This is a delegation test. Your only task is to call set_output with the value 'DELEGATE_BASIC_PASSED'. Do not create plans, branches, or PRs. Just call set_output."`,
+"This is a delegation test. Your only task is to call set_output with the value 'DELEGATE_BASIC_PASSED'. Do not create plans, branches, or PRs. Just call set_output."
+
+When all delegations are complete, call set_output with the final result. This makes it available as the GitHub Action output.`,
     effort: "mini",
     timeout: "5m",
   },
@@ -20,7 +22,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
 
   const setOutputCalled = output !== null;

test/agnostic/delegateEffort.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * delegateEffort test - validates effort selection for delegation.
@@ -16,7 +16,9 @@ const fixture = defineFixture(
   {
     prompt: `This is a simple task. Select the Plan mode via select_mode, then delegate with MINI effort (this is a trivial task).
 Your subagent instructions should be:
-"Call set_output with the value 'EFFORT_TEST_PASSED'. Do not create plans or PRs. Just call set_output."`,
+"Call set_output with the value 'EFFORT_TEST_PASSED'. Do not create plans or PRs. Just call set_output."
+
+When all delegations are complete, call set_output with the final result. This makes it available as the GitHub Action output.`,
     effort: "auto",
     timeout: "5m",
   },
@@ -24,7 +26,7 @@ Your subagent instructions should be:
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
 
   const setOutputCalled = output !== null;

test/agnostic/delegateMulti.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * delegateMulti test - validates multi-phase delegation with context passing.
@@ -19,7 +19,9 @@ Phase 1: Select Plan mode via select_mode, then delegate with tasks: [{ label: "
 
 Phase 2: After Phase 1 completes, select Plan mode again and delegate with tasks: [{ label: "phase-2", instructions: "Your task is to call set_output with the value 'MULTI_DELEGATE_PASSED'. Do not create plans or PRs.", effort: "mini" }]. Include the result from Phase 1 in the instructions if you want.
 
-Both delegations must complete successfully.`,
+Both delegations must complete successfully.
+
+When all delegations are complete, call set_output with the final result. This makes it available as the GitHub Action output.`,
     effort: "mini",
     timeout: "8m",
   },
@@ -27,7 +29,7 @@ Both delegations must complete successfully.`,
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
 
   const setOutputCalled = output !== null;

test/agnostic/fileTraversal.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getStructuredOutput } from "../utils.ts";
+import { defineFixture } from "../utils.ts";
 
 /**
  * fileTraversal test - validates path traversal is blocked by all MCP file tools.
@@ -31,7 +31,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
   const traversalBlocked = setOutputCalled && /TRAVERSAL_BLOCKED=true/i.test(output);
   // extra safety: structured output should not be exactly a hostname (leaked from /etc/hostname)

test/agnostic/gitHooks.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getAgentOutput, getStructuredOutput } from "../utils.ts";
+import { defineFixture, getAgentOutput } from "../utils.ts";
 
 /**
  * git hooks isolation test - validates:
@@ -52,7 +52,7 @@ Call set_output with:
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
   const setOutputCalled = output !== null;
 

test/agnostic/gitPerms.ts

@@ -1,10 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import {
-  defineFixture,
-  generateTestMarker,
-  getAgentOutput,
-  getStructuredOutput,
-} from "../utils.ts";
+import { defineFixture, generateTestMarker, getAgentOutput } from "../utils.ts";
 
 /**
  * git permissions test - validates:
@@ -57,7 +52,7 @@ Call set_output with a JSON object containing:
 const { value: testToken, agentEnv } = generateTestMarker("GIT_PERMS_TEST_TOKEN");
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const agentOutput = getAgentOutput(result);
   const setOutputCalled = output !== null;
 

test/agnostic/packageJsonScripts.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getStructuredOutput } from "../utils.ts";
+import { defineFixture } from "../utils.ts";
 
 /**
  * package.json script injection test - validates:
@@ -56,7 +56,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
 
   let parsed: Record<string, unknown> = {};

test/agnostic/procSandbox.ts

@@ -1,10 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import {
-  defineFixture,
-  generateAgentUuids,
-  getAgentOutput,
-  getStructuredOutput,
-} from "../utils.ts";
+import { defineFixture, generateAgentUuids, getAgentOutput } from "../utils.ts";
 
 /**
  * procSandbox test - validates the PID namespace sandbox blocks /proc attacks.
@@ -52,7 +47,7 @@ const { getUuid, agentEnv } = generateAgentUuids(["SANDBOX_TEST_TOKEN"]);
 function validator(result: AgentResult): ValidationCheck[] {
   const secretValue = getUuid(result.agent, "SANDBOX_TEST_TOKEN");
   const agentOutput = getAgentOutput(result);
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
 
   // the secret should NOT appear anywhere in the output

test/agnostic/pushDisabled.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, generateAgentUuids, getStructuredOutput } from "../utils.ts";
+import { defineFixture, generateAgentUuids } from "../utils.ts";
 
 /**
  * pushDisabled test - validates that push:disabled blocks all write operations.
@@ -31,7 +31,7 @@ Call set_output with a JSON object:
 const { agentEnv } = generateAgentUuids(["PUSH_TEST_MARKER"]);
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
 
   let parsed: Record<string, unknown> = {};

test/agnostic/pushEnabled.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getStructuredOutput } from "../utils.ts";
+import { defineFixture } from "../utils.ts";
 
 /**
  * push enabled test - validates full push access.
@@ -44,7 +44,7 @@ Call set_output with a JSON object containing:
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
 
   let parsed: Record<string, unknown> = {};

test/agnostic/pushRestricted.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getStructuredOutput } from "../utils.ts";
+import { defineFixture } from "../utils.ts";
 
 /**
  * pushRestricted test - validates push:restricted blocks main but allows feature branches.
@@ -40,7 +40,7 @@ Call set_output with a JSON object:
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
 
   let parsed: Record<string, unknown> = {};

test/agnostic/symlinkTraversal.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getStructuredOutput } from "../utils.ts";
+import { defineFixture } from "../utils.ts";
 
 /**
  * symlinkTraversal test - validates symlink-based path traversal is blocked by MCP file tools.
@@ -35,7 +35,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
   const symlinkBlocked = setOutputCalled && /SYMLINK_BLOCKED=true/i.test(output);
 

test/ci.test.ts

@@ -65,6 +65,8 @@ const expectedAgentEnvVars = [
   "GITHUB_TOKEN",
   ...new Set(Object.values(agentsManifest).flatMap((a) => a.apiKeyNames)),
   "GEMINI_MODEL",
+  "OPENCODE_MODEL_MAX",
+  "OPENCODE_MODEL_MINI",
   "OPENCODE_MODEL",
 ].sort();
 

test/crossagent/fileReadWrite.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, generateAgentUuids, getStructuredOutput } from "../utils.ts";
+import { defineFixture, generateAgentUuids } from "../utils.ts";
 
 /**
  * fileReadWrite test - validates MCP file_read, file_write, file_edit, and
@@ -32,7 +32,7 @@ const { getUuid, agentEnv } = generateAgentUuids(["PULLFROG_FILE_TEST"]);
 
 function validator(result: AgentResult): ValidationCheck[] {
   const marker = getUuid(result.agent, "PULLFROG_FILE_TEST");
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
   // file_edit should have replaced BEFORE: with AFTER:
   const editWorked = setOutputCalled && output.includes(`AFTER:${marker}`);

test/crossagent/mcpmerge.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getStructuredOutput } from "../utils.ts";
+import { defineFixture } from "../utils.ts";
 
 /**
  * MCP merge test - validates repo-level MCP servers merge correctly with gh_pullfrog.
@@ -23,7 +23,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
   const correctValue = setOutputCalled && output === secret;
 

test/crossagent/noNativeFile.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, generateAgentUuids, getStructuredOutput } from "../utils.ts";
+import { defineFixture, generateAgentUuids } from "../utils.ts";
 
 /**
  * noNativeFile test - validates native file read/write tools are disabled.
@@ -32,7 +32,7 @@ const fixture = defineFixture(
 const { agentEnv } = generateAgentUuids(["PULLFROG_NOFILE_TEST"]);
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const fullOutput = result.output;
   const setOutputCalled = output !== null;
 

test/crossagent/nobash.ts

@@ -1,10 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import {
-  buildShellToolPrompt,
-  defineFixture,
-  generateAgentUuids,
-  getStructuredOutput,
-} from "../utils.ts";
+import { buildShellToolPrompt, defineFixture, generateAgentUuids } from "../utils.ts";
 
 /**
  * nobash test - validates agents respect shell=disabled setting.
@@ -31,7 +26,7 @@ function validator(result: AgentResult): ValidationCheck[] {
   const marker = getUuid(result.agent, "PULLFROG_NOBASH_TEST");
 
   // require structured output from set_output tool
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
 
   // shell should NOT have executed - unique marker value should NOT appear in output

test/crossagent/restricted.ts

@@ -1,10 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import {
-  buildShellToolPrompt,
-  defineFixture,
-  generateAgentUuids,
-  getStructuredOutput,
-} from "../utils.ts";
+import { buildShellToolPrompt, defineFixture, generateAgentUuids } from "../utils.ts";
 
 /**
  * restricted test - validates shell=restricted environment filtering.
@@ -14,7 +9,7 @@ import {
 const fixture = defineFixture(
   {
     prompt: `This is a test to determine token visibility in shell tool calls.
-    
+
 ${buildShellToolPrompt("echo $PULLFROG_TEST_VALUE")}
 
 Then also run: echo $PULLFROG_TEST_TOKEN
@@ -36,7 +31,7 @@ function validator(result: AgentResult): ValidationCheck[] {
   const filteredMarker = getUuid(result.agent, "PULLFROG_TEST_TOKEN");
 
   // require structured output from set_output tool
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
 
   // non-sensitive env var SHOULD appear in output (agent can read it via shell)

test/crossagent/smoke.ts

@@ -1,5 +1,5 @@
 import type { AgentResult, TestRunnerOptions, ValidationCheck } from "../utils.ts";
-import { defineFixture, getStructuredOutput } from "../utils.ts";
+import { defineFixture } from "../utils.ts";
 
 /**
  * smoke test - validates agent can connect to API and call MCP tools.
@@ -15,7 +15,7 @@ const fixture = defineFixture(
 );
 
 function validator(result: AgentResult): ValidationCheck[] {
-  const output = getStructuredOutput(result);
+  const output = result.structuredOutput;
   const setOutputCalled = output !== null;
   const correctValue = setOutputCalled && /SMOKE TEST PASSED/i.test(output);
 

test/utils.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { agentsManifest } from "../external.ts";
@@ -112,6 +112,7 @@ export interface AgentResult {
   agent: string;
   success: boolean;
   output: string;
+  structuredOutput: string | null;
 }
 
 // get agent output with GitHub Actions masking commands filtered out
@@ -123,12 +124,19 @@ export function getAgentOutput(result: AgentResult): string {
     .join("\n");
 }
 
-// get structured output from set_output tool (via ::pullfrog-output:: marker)
-// returns null if no structured output was set by the agent
-export function getStructuredOutput(result: AgentResult): string | null {
-  const match = result.output.match(/::pullfrog-output::([A-Za-z0-9+/=]+)/);
+// parse GITHUB_OUTPUT file format to extract a key's value.
+// format: key<<ghadelimiter_<uuid>\n<value>\nghadelimiter_<uuid>
+function parseGitHubOutputFile(filePath: string, key: string): string | null {
+  let content: string;
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  const pattern = new RegExp(`${key}<<(ghadelimiter_[\\w-]+)\\n([\\s\\S]*?)\\n\\1`);
+  const match = content.match(pattern);
   if (!match) return null;
-  return Buffer.from(match[1], "base64").toString();
+  return match[2];
 }
 
 export interface ValidationCheck {
@@ -184,6 +192,9 @@ export async function runAgentStreaming(options: RunStreamingOptions): Promise<A
     const testHome = `/tmp/home-${mcpPort}-${Date.now()}`;
     mkdirSync(testHome, { recursive: true });
 
+    const githubOutputFile = join(testHome, "github-output");
+    writeFileSync(githubOutputFile, "");
+
     // write file-based env vars for MCP servers that don't inherit parent env vars
     // (e.g., Cursor CLI doesn't pass env vars to repo-level MCP servers).
     // only explicitly opted-in vars go here -- never secrets.
@@ -203,6 +214,7 @@ export async function runAgentStreaming(options: RunStreamingOptions): Promise<A
         AGENT_OVERRIDE: options.agent,
         ...options.env,
         HOME: testHome,
+        GITHUB_OUTPUT: githubOutputFile,
       },
       stdio: "pipe",
       detached: true,
@@ -217,6 +229,7 @@ export async function runAgentStreaming(options: RunStreamingOptions): Promise<A
         agent: options.agent,
         success: false,
         output: `spawn error: ${err.message}`,
+        structuredOutput: null,
       });
     });
 
@@ -253,6 +266,7 @@ export async function runAgentStreaming(options: RunStreamingOptions): Promise<A
         agent: options.agent,
         success: code === 0,
         output: Buffer.concat(chunks).toString(),
+        structuredOutput: parseGitHubOutputFile(githubOutputFile, "result"),
       });
     });
   });

utils/body.ts

@@ -72,6 +72,7 @@ async function fetchBodyHtml(ctx: ResolveBodyContext): Promise<string | undefine
 
     case "pull_request_opened":
     case "pull_request_ready_for_review":
+    case "pull_request_synchronize":
     case "pull_request_review_requested":
       // PRs are also issues - use issues.get which returns body_html
       if (!event.issue_number) return;

utils/buildPullfrogFooter.ts

@@ -10,7 +10,7 @@ export interface AgentInfo {
 export interface WorkflowRunFooterInfo {
   owner: string;
   repo: string;
-  runId: string;
+  runId: number;
   /** optional job ID - if provided, will append /job/{jobId} to the workflow run URL */
   jobId?: string | undefined;
 }

utils/docker.ts

@@ -120,6 +120,8 @@ const testEnvAllowList = new Set([
   "GOOGLE_GENERATIVE_AI_API_KEY",
   "CURSOR_API_KEY",
   "OPENCODE_MODEL", // override OpenCode model (e.g. google/gemini-3-flash-preview) for tests or user preference
+  "OPENCODE_MODEL_MINI", // effort-specific OpenCode model override for mini effort
+  "OPENCODE_MODEL_MAX", // effort-specific OpenCode model override for max effort
   "GEMINI_MODEL", // override Gemini model (e.g. gemini-3-pro-preview) for tests or user preference
   "LOG_LEVEL",
   "DEBUG",
@@ -133,6 +135,7 @@ const testEnvAllowList = new Set([
   "GITHUB_API_URL",
   "GITHUB_SERVER_URL",
   "GITHUB_GRAPHQL_URL",
+  "GITHUB_OUTPUT",
 ]);
 
 export type EnvFilterMode = "allowlist" | "passthrough";

utils/errorReport.ts

@@ -1,4 +1,5 @@
 import type { ToolState } from "../mcp/server.ts";
+import { getApiUrl } from "./apiUrl.ts";
 import { buildPullfrogFooter } from "./buildPullfrogFooter.ts";
 import { createOctokit, parseRepoContext } from "./github.ts";
 import { getGitHubInstallationToken } from "./token.ts";
@@ -19,12 +20,22 @@ export async function reportErrorToComment(ctx: ReportErrorParams): Promise<void
 
   const repoContext = parseRepoContext();
   const octokit = createOctokit(getGitHubInstallationToken());
-  const runId = process.env.GITHUB_RUN_ID;
+  const runId = process.env.GITHUB_RUN_ID
+    ? Number.parseInt(process.env.GITHUB_RUN_ID, 10)
+    : undefined;
+
+  const customParts: string[] = [];
+  if (runId) {
+    const apiUrl = getApiUrl();
+    customParts.push(
+      `[Rerun failed job ➔](${apiUrl}/trigger/${repoContext.owner}/${repoContext.name}/${runId}?action=rerun)`
+    );
+  }
 
-  // build footer with workflow run link
   const footer = buildPullfrogFooter({
     triggeredBy: true,
     workflowRun: runId ? { owner: repoContext.owner, repo: repoContext.name, runId } : undefined,
+    customParts,
   });
 
   await octokit.rest.issues.updateComment({

utils/github.ts

@@ -1,10 +1,24 @@
 import { createSign } from "node:crypto";
+import { rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import * as core from "@actions/core";
 import { throttling } from "@octokit/plugin-throttling";
 import { Octokit } from "@octokit/rest";
 import { apiFetch } from "./apiFetch.ts";
 import { retry } from "./retry.ts";
 
+function isObject(value: unknown) {
+  return typeof value === "object" && value !== null;
+}
+
+// we don't get access to the actual class from @octokit/rest
+// it's reachable from @octokit/request-error but we'd have to add a dependency on it
+// and it would pose a risk of accidentally pulling a different version of that class (node_modules dep graphs ❤️)
+// so it's safer to ducktype this
+interface OctokitResponseShim {
+  headers: Record<string, string | number | undefined>;
+}
+
 export interface InstallationToken {
   token: string;
   expires_at: string;
@@ -339,11 +353,55 @@ export type OctokitWithPlugins = InstanceType<
   ReturnType<typeof Octokit.plugin<typeof Octokit, [typeof throttling]>>
 >;
 
+export interface ResourceUsage {
+  requestCount: number;
+  rateLimitRemaining: number | null;
+  rateLimitResetMs: number | null;
+}
+
+function emptyResourceUsage(): ResourceUsage {
+  return {
+    requestCount: 0,
+    rateLimitRemaining: null,
+    rateLimitResetMs: null,
+  };
+}
+
+const usageByResource: Record<string, ResourceUsage> = {
+  core: emptyResourceUsage(),
+  graphql: emptyResourceUsage(),
+};
+
+export interface UsageSummary {
+  version: 1;
+  github: {
+    core: ResourceUsage;
+    graphql: ResourceUsage;
+  };
+}
+
+function getGitHubUsageSummary(): UsageSummary {
+  return {
+    version: 1,
+    github: {
+      core: usageByResource.core,
+      graphql: usageByResource.graphql,
+    },
+  };
+}
+
+export async function writeGitHubUsageSummaryToFile(path: string): Promise<void> {
+  const summary = getGitHubUsageSummary();
+  const tmpPath = join(dirname(path), `.usage-summary-${process.pid}.tmp`);
+  await writeFile(tmpPath, JSON.stringify(summary));
+  await rename(tmpPath, path);
+}
+
 export function createOctokit(token: string): OctokitWithPlugins {
   // `OctokitWithPlugins` initialization based on https://github.com/actions/toolkit/blob/2506e78e82fbd2f9e94d63e75f5309118c8de1b1/packages/github/src/github.ts#L15-L22
   // we can't use it directly because it's stuck on `@octokit/core@v5` and we use the hottest `@octokit/core@v7`
   const OctokitWithPlugins = Octokit.plugin(throttling);
-  return new OctokitWithPlugins({
+  const octokit = new OctokitWithPlugins({
     auth: token,
     throttle: {
       onRateLimit: (_retryAfter, _options, _octokit, retryCount) => {
@@ -354,4 +412,44 @@ export function createOctokit(token: string): OctokitWithPlugins {
       },
     },
   });
+
+  const onResponse = (response: OctokitResponseShim) => {
+    const resource = response.headers["x-ratelimit-resource"];
+    if (!resource) {
+      return response;
+    }
+    usageByResource[resource] ??= emptyResourceUsage();
+    const usage = usageByResource[resource];
+    usage.requestCount++;
+    const remaining = response.headers["x-ratelimit-remaining"];
+    const reset = response.headers["x-ratelimit-reset"];
+    if (remaining !== undefined) {
+      usage.rateLimitRemaining = Number(remaining);
+    }
+    if (reset !== undefined) {
+      usage.rateLimitResetMs = Number(reset) * 1000;
+    }
+    return response;
+  };
+
+  octokit.hook.wrap("request", async (request, options) => {
+    try {
+      const response = await request(options);
+      onResponse(response);
+      return response;
+    } catch (error) {
+      if (
+        isObject(error) &&
+        "response" in error &&
+        isObject(error.response) &&
+        "headers" in error.response &&
+        isObject(error.response.headers)
+      ) {
+        onResponse(error.response as OctokitResponseShim);
+      }
+      throw error;
+    }
+  });
+
+  return octokit;
 }

utils/instructions.ts

@@ -10,6 +10,7 @@ interface InstructionsContext {
   payload: ResolvedPayload;
   repo: RunContextData["repo"];
   modes: Mode[];
+  outputSchema?: Record<string, unknown> | undefined;
 }
 
 function buildRuntimeContext(ctx: InstructionsContext): string {
@@ -118,13 +119,21 @@ Use the \`${ghPullfrogMcpName}\` MCP file tools for all file operations. Do NOT
 All file tools enforce repository-scoped access and prevent modifications to .git/.`;
 }
 
-function getStandaloneModeInstructions(trigger: string): string {
+function getStandaloneModeInstructions(
+  trigger: string,
+  outputSchema?: Record<string, unknown> | undefined
+): string {
   if (trigger !== "unknown") {
     return "";
   }
+
+  const outputRequirement = outputSchema
+    ? `**REQUIRED structured output:** You MUST call \`${ghPullfrogMcpName}/set_output\` before finishing. The tool expects a structured object matching a JSON Schema — inspect its parameter schema to see the exact shape. Omitting this call or providing non-conforming output will fail the action.`
+    : `When you complete your task, call \`${ghPullfrogMcpName}/set_output\` with the main result of your work (generated content, summary of changes, analysis results, etc.). This makes it available as a GitHub Action output named \`result\` for subsequent workflow steps to consume. When in doubt, prefer calling \`set_output\`—unused outputs are harmless, but missing outputs may break downstream steps.`;
+
   return `### Standalone mode
 
-You are running as a step in a user-defined CI workflow. When you complete your task, call \`${ghPullfrogMcpName}/set_output\` with the main result of your work (generated content, summary of changes, analysis results, etc.). This makes it available as a GitHub Action output named \`result\` for subsequent workflow steps to consume.`;
+You are running as a step in a user-defined CI workflow. ${outputRequirement}`;
 }
 
 // shared system prompt body used by both orchestrator and subagent instructions.
@@ -134,6 +143,7 @@ interface SystemPromptContext {
   trigger: string;
   priorityOrder: string;
   taskSection: string;
+  outputSchema?: Record<string, unknown> | undefined;
 }
 
 function buildSystemPrompt(ctx: SystemPromptContext): string {
@@ -192,7 +202,7 @@ ${getShellInstructions(ctx.shell)}
 
 ${getFileInstructions()}
 
-${getStandaloneModeInstructions(ctx.trigger)}
+${getStandaloneModeInstructions(ctx.trigger, ctx.outputSchema)}
 
 ## Workflow
 
@@ -384,8 +394,6 @@ To investigate questions, prefer \`${ghPullfrogMcpName}/ask_question\` over \`${
 
 After each \`delegate\` call, you receive a \`results\` array — one entry per task with \`label\`, \`success\`, \`summary\` (from set_output), and \`stdoutFile\` (inspectable via \`${ghPullfrogMcpName}/file_read\`). Follow the post-delegation steps from the select_mode guidance.
 
-When all delegations are complete, call \`${ghPullfrogMcpName}/set_output\` with the final result. This makes it available as the GitHub Action output.
-
 ### Subagent capabilities
 
 Subagents have: file operations, shell (for local git, tests, builds), read-only GitHub queries, and upload_file. They do NOT have: \`git\`, \`checkout_pr\`, \`push_branch\`, \`create_pull_request\`, \`create_pull_request_review\`, \`report_progress\`, \`create_issue_comment\`, \`reply_to_review_comment\`, \`resolve_review_thread\`, \`delegate\`, \`ask_question\`, or any dependency/remote-mutating tools. All GitHub-write and state-mutating operations are your responsibility.
@@ -408,6 +416,7 @@ If the task clearly requires no work, skip delegation. Call \`${ghPullfrogMcpNam
     trigger: ctx.payload.event.trigger,
     priorityOrder: orchestratorPriorityOrder,
     taskSection: orchestratorTaskSection,
+    outputSchema: ctx.outputSchema,
   });
 
   const contextSections = buildContextSections({

utils/log.ts

@@ -2,11 +2,43 @@
  * Logging utilities that work well in both local and GitHub Actions environments
  */
 
+import { AsyncLocalStorage } from "node:async_hooks";
 import * as core from "@actions/core";
 import { table } from "table";
 import type { AgentUsage } from "../agents/shared.ts";
 import { isGitHubActions, isInsideDocker } from "./globals.ts";
 
+// --- subagent log prefix via AsyncLocalStorage ---
+
+type LogContext = { prefix: string };
+
+const logContext = new AsyncLocalStorage<LogContext>();
+
+const MAGENTA = "\x1b[35m";
+const RESET = "\x1b[0m";
+
+/** run `fn` with every log line prefixed by `prefix` (e.g. "[task-label]") in magenta */
+export function withLogPrefix<T>(prefix: string, fn: () => Promise<T>): Promise<T> {
+  return logContext.run({ prefix }, fn);
+}
+
+function prefixLines(message: string): string {
+  const ctx = logContext.getStore();
+  if (!ctx) return message;
+  const colored = `${MAGENTA}${ctx.prefix}${RESET} `;
+  return message
+    .split("\n")
+    .map((line) => `${colored}${line}`)
+    .join("\n");
+}
+
+/** plain-text prefix (no ANSI) for GitHub Actions group names */
+function prefixPlain(name: string): string {
+  const ctx = logContext.getStore();
+  if (!ctx) return name;
+  return `${ctx.prefix} ${name}`;
+}
+
 const isRunnerDebugEnabled = () => core.isDebug();
 
 const isLocalDebugEnabled = () =>
@@ -36,10 +68,11 @@ function formatArgs(args: unknown[]): string {
  * Start a collapsed group (GitHub Actions) or regular group (local)
  */
 function startGroup(name: string): void {
+  const prefixed = prefixPlain(name);
   if (isGitHubActions) {
-    core.startGroup(name);
+    core.startGroup(prefixed);
   } else {
-    console.group(name);
+    console.group(prefixed);
   }
 }
 
@@ -153,7 +186,7 @@ function box(
   }
 ): void {
   const boxContent = boxString(text, options);
-  core.info(boxContent);
+  core.info(prefixLines(boxContent));
 }
 
 /**
@@ -200,9 +233,9 @@ function printTable(
   const formatted = table(tableData);
 
   if (title) {
-    core.info(`\n${title}`);
+    core.info(prefixLines(`\n${title}`));
   }
-  core.info(`\n${formatted}\n`);
+  core.info(prefixLines(`\n${formatted}\n`));
 }
 
 /**
@@ -210,7 +243,7 @@ function printTable(
  */
 function separator(length: number = 50): void {
   const separatorText = "─".repeat(length);
-  core.info(separatorText);
+  core.info(prefixLines(separatorText));
 }
 
 /**
@@ -219,32 +252,32 @@ function separator(length: number = 50): void {
 export const log = {
   /** Print info message */
   info: (...args: unknown[]): void => {
-    core.info(`${ts()}${formatArgs(args)}`);
+    core.info(prefixLines(`${ts()}${formatArgs(args)}`));
   },
 
   /** Print a warning message. Use only for warnings that should be displayed in the job summary. */
   warning: (...args: unknown[]): void => {
-    core.warning(`${ts()}${formatArgs(args)}`);
+    core.warning(prefixLines(`${ts()}${formatArgs(args)}`));
   },
 
   /** Print an error message. Use only for errors that should be displayed in the job summary. */
   error: (...args: unknown[]): void => {
-    core.error(`${ts()}${formatArgs(args)}`);
+    core.error(prefixLines(`${ts()}${formatArgs(args)}`));
   },
 
   /** Print success message */
   success: (...args: unknown[]): void => {
-    core.info(`${ts()}» ${formatArgs(args)}`);
+    core.info(prefixLines(`${ts()}» ${formatArgs(args)}`));
   },
 
   /** Print debug message (only when debug mode is enabled) */
   debug: (...args: unknown[]): void => {
     if (isRunnerDebugEnabled()) {
-      core.debug(formatArgs(args));
+      core.debug(prefixLines(formatArgs(args)));
       return;
     }
     if (isLocalDebugEnabled()) {
-      core.info(`${ts()}[DEBUG] ${formatArgs(args)}`);
+      core.info(prefixLines(`${ts()}[DEBUG] ${formatArgs(args)}`));
     }
   },
 

utils/payload.ts

@@ -19,7 +19,8 @@ export const JsonPayload = type({
   version: "string",
   "agent?": AgentName.or("undefined"),
   prompt: "string",
-  "triggeringUser?": "string | undefined",
+  "triggerer?": "string | undefined",
+
   "eventInstructions?": "string",
   "repoInstructions?": "string",
   "event?": "object",
@@ -53,6 +54,7 @@ export const Inputs = type({
   "push?": PushPermissionInput.or("undefined"),
   "shell?": ShellPermissionInput.or("undefined"),
   "cwd?": type.string.or("undefined"),
+  "output_schema?": type.string.or("undefined"),
 });
 
 export type Inputs = typeof Inputs.infer;
@@ -167,8 +169,8 @@ export function resolvePayload(
     version: jsonPayload?.version ?? packageJson.version,
     agent: resolvedAgent,
     prompt,
-    triggeringUser:
-      jsonPayload?.triggeringUser ??
+    triggerer:
+      jsonPayload?.triggerer ??
       // it's not a common use case but GITHUB_ACTOR can be a user when the workflow is manually triggered by a user through GitHub Actions UI
       (!isPullfrog(process.env.GITHUB_ACTOR) ? process.env.GITHUB_ACTOR : undefined),
     eventInstructions: jsonPayload?.eventInstructions,
@@ -177,6 +179,7 @@ export function resolvePayload(
     effort: inputs.effort ?? jsonPayload?.effort ?? "auto",
     timeout: inputs.timeout ?? jsonPayload?.timeout,
     cwd: resolveCwd(inputs.cwd),
+    progressCommentId: jsonPayload?.progressCommentId,
     debug: jsonPayload?.debug,
 
     // permissions: inputs > repoSettings > fallbacks

utils/postCleanup.ts

@@ -1,4 +1,5 @@
 import { LEAPING_INTO_ACTION_PREFIX } from "../mcp/comment.ts";
+import { getApiUrl } from "./apiUrl.ts";
 import { buildPullfrogFooter } from "./buildPullfrogFooter.ts";
 import { log } from "./cli.ts";
 import { createOctokit, parseRepoContext } from "./github.ts";
@@ -15,22 +16,32 @@ const SHOULD_CHECK_REASON = true;
 type BuildErrorCommentBodyParams = {
   owner: string;
   repo: string;
-  runId: string | undefined;
+  runId: number | undefined;
   isCancellation: boolean;
 };
 
 function buildErrorCommentBody(params: BuildErrorCommentBodyParams): string {
-  const workflowRunLink = params.runId
-    ? `[workflow run logs](https://github.com/${params.owner}/${params.repo}/actions/runs/${params.runId})`
-    : "workflow run logs";
-  const errorMessage = params.isCancellation
-    ? `This run was cancelled 🛑\n\nThe workflow was cancelled before completion. Please check the ${workflowRunLink} for details.`
-    : `This run croaked 😵\n\nThe workflow encountered an error before any progress could be reported. Please check the ${workflowRunLink} for details.`;
+  let errorMessage = params.isCancellation
+    ? `This run was cancelled 🛑\n\nThe workflow was cancelled before completion.`
+    : `This run croaked 😵\n\nThe workflow encountered an error before any progress could be reported.`;
+
+  if (params.runId) {
+    errorMessage += " Please check the link below for details.";
+  }
+
+  const customParts: string[] = [];
+  if (!params.isCancellation && params.runId) {
+    const apiUrl = getApiUrl();
+    customParts.push(
+      `[Rerun failed job ➔](${apiUrl}/trigger/${params.owner}/${params.repo}/${params.runId}?action=rerun)`
+    );
+  }
   const footer = buildPullfrogFooter({
     triggeredBy: true,
     workflowRun: params.runId
       ? { owner: params.owner, repo: params.repo, runId: params.runId }
       : undefined,
+    customParts,
   });
   return `${errorMessage}${footer}`;
 }
@@ -76,16 +87,16 @@ async function validateStuckProgressComment(
 type GetIsCancelledParams = {
   repoContext: ReturnType<typeof parseRepoContext>;
   octokit: ReturnType<typeof createOctokit>;
-  runIdStr: string | undefined;
+  runId: number | undefined;
 };
 
 async function getIsCancelled(params: GetIsCancelledParams): Promise<boolean> {
-  if (!params.runIdStr) return false; // can't check without a run ID — assume failure
+  if (!params.runId) return false; // can't check without a run ID — assume failure
   try {
     const jobsResult = await params.octokit.rest.actions.listJobsForWorkflowRun({
       owner: params.repoContext.owner,
       repo: params.repoContext.name,
-      run_id: Number.parseInt(params.runIdStr, 10),
+      run_id: params.runId,
     });
 
     // find current job by matching GITHUB_JOB env var.
@@ -125,7 +136,9 @@ async function getIsCancelled(params: GetIsCancelledParams): Promise<boolean> {
 export async function runPostCleanup(): Promise<void> {
   log.info("» [post] starting post cleanup");
 
-  const runIdStr = process.env.GITHUB_RUN_ID;
+  const runId = process.env.GITHUB_RUN_ID
+    ? Number.parseInt(process.env.GITHUB_RUN_ID, 10)
+    : undefined;
 
   // resolve prompt input once and use it for both issue number and comment ID extraction
   // only use the object form (JSON payload), not plain string prompts
@@ -159,9 +172,9 @@ export async function runPostCleanup(): Promise<void> {
     const body = buildErrorCommentBody({
       owner: repoContext.owner,
       repo: repoContext.name,
-      runId: runIdStr,
+      runId,
       isCancellation: SHOULD_CHECK_REASON
-        ? await getIsCancelled({ octokit, repoContext, runIdStr })
+        ? await getIsCancelled({ octokit, repoContext, runId })
         : false,
     });
 

utils/run.ts

@@ -1,13 +1,37 @@
 import type { AgentResult } from "../agents/shared.ts";
 import type { MainResult } from "../main.ts";
+import type { ToolState } from "../mcp/server.ts";
 import { log } from "./cli.ts";
+import { reportErrorToComment } from "./errorReport.ts";
 
-export function handleAgentResult(result: AgentResult): MainResult {
-  if (!result.success) {
+export interface HandleAgentResultParams {
+  result: AgentResult;
+  toolState: ToolState;
+  silent: boolean | undefined;
+}
+
+export async function handleAgentResult(ctx: HandleAgentResultParams): Promise<MainResult> {
+  if (!ctx.result.success) {
     return {
       success: false,
-      error: result.error || "Agent execution failed",
-      output: result.output!,
+      error: ctx.result.error || "Agent execution failed",
+      output: ctx.result.output!,
+    };
+  }
+
+  if (!ctx.toolState.wasUpdated && ctx.toolState.progressCommentId && !ctx.silent) {
+    const error = ctx.result.error || "agent completed without reporting progress";
+    try {
+      await reportErrorToComment({
+        toolState: ctx.toolState,
+        error,
+        title: "Error",
+      });
+    } catch {}
+    return {
+      success: false,
+      error,
+      output: ctx.result.output || "",
     };
   }
 
@@ -15,6 +39,6 @@ export function handleAgentResult(result: AgentResult): MainResult {
 
   return {
     success: true,
-    output: result.output || "",
+    output: ctx.result.output || "",
   };
 }

utils/runContext.ts

@@ -19,6 +19,7 @@ export interface RepoSettings {
   search: ToolPermission;
   push: PushPermission;
   shell: ShellPermission;
+  prApproveEnabled: boolean;
 }
 
 export interface RunContext {
@@ -36,6 +37,7 @@ const defaultSettings: RepoSettings = {
   search: "enabled",
   push: "restricted",
   shell: "restricted",
+  prApproveEnabled: false,
 };
 
 const defaultRunContext: RunContext = {

utils/workflow.ts

@@ -6,7 +6,7 @@ interface ResolveRunParams {
 }
 
 export interface ResolveRunResult {
-  runId: string;
+  runId: number | undefined;
   jobId: string | undefined;
 }
 
@@ -15,7 +15,9 @@ export interface ResolveRunResult {
  * Uses GITHUB_REPOSITORY and GITHUB_RUN_ID env vars.
  */
 export async function resolveRun(params: ResolveRunParams): Promise<ResolveRunResult> {
-  const runId = process.env.GITHUB_RUN_ID || "";
+  const runId = process.env.GITHUB_RUN_ID
+    ? Number.parseInt(process.env.GITHUB_RUN_ID, 10)
+    : undefined;
   const githubRepo = process.env.GITHUB_REPOSITORY;
   if (!githubRepo || !githubRepo.includes("/")) {
     throw new Error(`GITHUB_REPOSITORY env var must be set to "owner/repo", got: ${githubRepo}`);
@@ -28,7 +30,7 @@ export async function resolveRun(params: ResolveRunParams): Promise<ResolveRunRe
     const jobs = await params.octokit.rest.actions.listJobsForWorkflowRun({
       owner,
       repo,
-      run_id: parseInt(runId, 10),
+      run_id: runId,
     });
     const matchingJob = jobs.data.jobs.find((job) => job.name === jobName);
     if (matchingJob) {