PR Cycle

PR Cycle

Run one full iteration of the review → fix → push → re-request loop. This is the orchestrator: it produces findings, addresses them with fixes, and updates the PR (commit, push, resolve threads, re-request review).

The review half is owned by the separate pr-review skill, which spawns the two read-only review sub-agents and reports their findings. pr-cycle does not duplicate that logic — step 2 below delegates to pr-review. Reach for pr-review directly when you only want a read-only review (no fixes, no push, no GitHub-conversation changes); reach for pr-cycle when you want those findings actually addressed and the PR updated.

The helper script is .agents/skills/pr-cycle/pr.py. Run it outside the sandbox (GitHub API requires network). Multiple commands can be passed in one call so only one permission prompt is needed:

.agents/skills/pr-cycle/pr.py [PR_NUMBER] COMMAND [COMMAND ...]

The leading PR_NUMBER is optional — it is required only for the GitHub commands (comments, threads, resolve, rerequest, minimize, codspeed). The local commands (ci, readme, pushpreview, diff) take no PR number, so e.g. pr.py ci works directly (no placeholder needed).

Available commands: comments, threads, resolve, rerequest, minimize, codspeed, ci, readme, pushpreview, diff.

Modes

This skill runs in one of three modes. The mode is taken from the input (see Input):

• full (default) — the complete review → fix → push → resolve → re-request loop. Runs every step below.
• local — only the local review and fix loop. Runs the pr-review skill (the local code-review and consumer sub-agents), evaluates their findings, applies fixes, runs CI, regenerates the README, and commits/pushes. Does not interact with the PR conversation on GitHub: it does not read PR comments or threads, does not edit the PR body, and does not resolve, minimize/hide, or re-request Copilot review.
• remote — only the GitHub PR feedback loop. Fetches and evaluates open PR comments/threads, applies fixes, runs CI, regenerates the README, commits/pushes, then resolves threads, minimizes prior comments, re-requests Copilot review, and audits the PR body. Does not run the local review (pr-review).

Both local and remote still commit and push the fixes they make (a code change has to land to be useful), and both follow the push protocol (show the push preamble before pushing). "Does not interact with GitHub" for local means the PR-conversation operations — comment/thread reads and mutations, Copilot re-request, PR-body edits — not the git push itself.

Step-by-step applicability (✓ = runs in that mode):

When a step is not applicable to the active mode, skip it entirely — do not run its pr.py command or gh call. In local mode you must not invoke any of comments, threads, resolve, rerequest, minimize, or gh pr edit/gh pr view --json body.

Model tiers

This skill is designed to keep expensive Opus reasoning concentrated in the judgment core and push everything else to cheaper models or to no model at all.

A Sonnet session can drive the whole cycle; only Tier-2 actually needs strong reasoning, so consider switching the session to a cheaper model once the judgment core is done.

Input

Optional PR number, an optional mode keyword (full, local, or remote), and an optional review-agent model override, in any order.

• Mode: if one of local / remote is present in the input, use it; otherwise default to full. Phrasings map as: "local review" / "just the local reviewers" / "local pr cycle" → local; "remote" / "address the pr comments" / "resolve and re-request" / "remote pr cycle" → remote; anything else (or "run the pr cycle") → full.
• Review-agent model: the model used by the local review sub-agents (pr-code-reviewer, pr-consumer-reviewer) defaults to sonnet, but can be overridden. If the input names a model (e.g. "use opus for the reviewers", "review with opus", "opus reviewers", "model=opus"), pass that model through to the pr-review delegation in step 2 (which forwards it to the Agent tool's model parameter on both sub-agent spawns). Only the review sub-agents are affected — this does not change the session model or the model used by pr-fix-implementer. This override is only meaningful in modes that run the local review (full, local); ignore it in remote mode.
• PR number: if omitted, infer it from the current branch using gh pr view --json number. In local mode no PR number is needed at all — the pr.py wrapper commands used there (ci, readme, pushpreview, diff) take no PR argument, so call them directly (e.g. pr.py ci). This also means local mode works without gh installed.

Announce the resolved mode (and, when the reviewers will run, the review-agent model) at the start — e.g. "Running pr-cycle in local mode with opus reviewers" — before executing any step.

Steps

1. Fetch ALL open comments and unresolved threads

Modes: full, remote. Skip entirely in local mode.

Run outside the sandbox:

.agents/skills/pr-cycle/pr.py PR_NUMBER comments threads

comments fetches all inline review comments, separates them into new (post-last-push) vs pre-existing unresolved, and prints each with its ID, created_at, file:line, author, and body. Record every comment for evaluation in step 3 — do not filter by timestamp.

threads lists all review thread node IDs with their resolution status. Unresolved threads will all be resolved in step 10.

2. Run the local review (delegate to pr-review)

Modes: full, local. Skip entirely in remote mode (no local review runs).

The review itself lives in the pr-review skill — do not re-implement it here. Run that skill against this PR/branch to obtain the local findings, passing through the review-agent model override from the Input if one was given. pr-review will:

• acquire the diff (.agents/skills/pr-cycle/pr.py PR_NUMBER diff, equivalent to git diff origin/master),
• shard the changed material into appropriately sized, randomized chunks and spawn one pr-code-reviewer and one pr-consumer-reviewer per shard in parallel (read-only, each carrying its own rubric; Sonnet by default, or the overridden model on all spawns), and
• return a consolidated findings report with severity and a per-finding verdict.

Carry pr-review's findings forward into step 3, where they are evaluated alongside any GitHub PR comments (in full mode). Do not act on fixes inside pr-review — it is read-only; addressing findings is step 4 here.

3. Evaluate all findings

Modes: all. The set of findings depends on the mode:

• full — all open inline PR comments (from step 1) plus both sub-agent reports (from step 2).
• local — only the two sub-agent reports. Do not reference PR comments.
• remote — only the open inline PR comments. There are no sub-agent reports.

Present all in-scope findings together. For each finding:

• Valid: the concern is real and the code should change
• Already fixed: the concern was valid but the code has already been corrected (the comment is stale) — mark for resolution only
• Invalid: the finding is incorrect or environment-specific (e.g. rustc version mismatch on trybuild golden files)

Explain your reasoning for each verdict. Do not apply any fix silently — call out what you are doing and why.

4. Apply fixes for valid findings

Modes: all.

4a. Write a fix spec for each valid finding (Opus / judgment core)

For each valid finding, produce an explicit fix spec before touching any file:

Finding: <one-line summary>
Target:  <file path>
Location: <file:line or unique surrounding snippet>
Change:  <exact new text, or precise add/remove/replace description — never "improve the wording">
Test:    <exact function name + exact assertions that would fail on unfixed code>
         OR "no test needed (doc-only)"

The spec must be precise enough for Sonnet to apply without judgment calls. Test design always stays here — this repo requires tests that fail on the unfixed code and pass on the fixed code; a trivially-passing test defeats the rule.

Common fix types:

• Documentation/comment updates: src/stores/, src/lib.rs, cached_proc_macro/src/lib.rs
• Test additions/corrections: tests/cached.rs
• Trybuild golden file regeneration: TRYBUILD=overwrite cargo test --no-default-features --features "proc_macro,time_stores" compile_fail_macro_arg_validation
• Macro code changes: cached_proc_macro/src/