pr-ping-pong

Files (4)

• MERGE.md
• SKILL.md
• WORKTREE.md
• openai.yaml · agents/

SKILL.md (first lines)

# PR Ping Pong

Alternate an implementation agent against two reviewers from other model
providers plus the bonus roster until the change is review-clean or the rally
budget runs out.

**A reviewer must never share a session with the agent that wrote the code under
review.** Agents catch defects in code they did not write far more reliably than
in their own. When the same provider implements and reviews, the reviewer runs in
a separate session that never saw the implementation transcript.

Invocation authorizes running the agent CLIs, committing, and pushing to the PR
branch. It does not authorize merging, force pushes, edits outside the change, or
unrelated external actions.

## Parameters

Resolve from the request, then state the resolved set before starting.

| Parameter | Default |
|---|---|
| target | required — issue or PR number, or URL |
| implementer | `native subagent` |
| reviewers | the default pair and bonus roster below |
| max rallies | `3` |
| merge on pass | `false` |
| new PR worktree | `REPO_ROOT/worktrees/[branch]` |

Honor explicit reviewer overrides. Never let a reviewer share the implementation
session.


## Preflight

Require authenticated `gh`. Resolve the target to a PR on a branch and set
`checkout` — the directory every agent and repository check uses. Run all Git,
diff, test, commit, and push steps from `checkout`; use the repository root only
to create or inspect worktrees.

- **PR given** — check out its branch, confirm it is not merged or closed;
  that checkout is `checkout`.
- **Issue given** — read [WORKTREE.md](WORKTREE.md) and follow it to create the
  branch, linked worktree (which becomes `checkout`), and draft PR.

## The rally

One rally is one implementation pass, a push, all reviews, and adjudication. Run at
most the budgeted number. The implementer keeps **one session across rallies** —
resume it, never concurrently — so it carries its decisions forward. Reviewers
get **fresh sessions every rally**.

### 1. Implement

- **Native subagent (default):** dispatch one implementation worker through the
  current harness's native agent interface. Record its agent/session ID and
  resume that same worker on later rallies; if the harness cannot resume it,
  start a replacement with the prior rallies' accepted findings and say so.
- **Provider override:** dispatch through `/cross-provider-agent` with the least
  write authority that permits the implementation, and resume that session on
  later rallies.

Give the implementer the absolute `checkout`, the objective, the permitted scope,
the required verification, and — from rally 2 on — the accepted findings. Never
let it push, merge, or spawn further agents. A missing successful terminal
result is a failed rally.

### 2. Push and pin

Verify the work yourself first: inspect the diff, confirm the commits are scoped,
run the repo's checks. Reviewing an unpushed or unverified state wastes a full
rally. Push, then pin the exact base and head — the pinned head must be the
`HEAD` you just pushed, so poll until the API reflects it:

```bash
local_head="$(git -C "$checkout" rev-parse HEAD)" || exit 1
for attempt in 1 2 3 4 5; do
  meta="$(gh pr view N --json baseRefName,baseRefOid,headRefOid \
    --jq '[.baseRefName, .baseRefOid, .headRefOid] | @tsv')" || exit 1
  read -r base_ref base_oid head_oid <<<"$meta"
  test "$head_oid" = "$local_head" && break
  test "$attempt" -lt 5 || exit 1
  sleep 3
done
git -C "$checkout" fetch origin "$base_ref" || exit 1
git -C "$checkout" cat-file -e "${base_oid}^{commit}" || exit 1
```

Stop if the block fails. Substitute the recorded OIDs into every reviewer
prompt as `git diff BASE_OID...HEAD_OID`.

### 3. Review

Each selected reviewer model runs **a fresh review coordinator per rally**,
dispatched through `/cross-provider-agent` under the `github-pr-reviewer`
profile with the absolute `checkout`. The coordinator invokes `/code-review`which spawns its two
context-isolated native children (Standards, Spec) inside the profile's
authority. On top of that, each coordinator's prompt includes:

- the tagged issue or PR as the spec source, fetched through the profile's
  `gh` reads;
- publication: aggregate both axis reports into one top-level PR comment
  whose first line is `<model> / rally <n> / <head OID>`.
- path to local checkout/worktree

Before every reviewer dispatch, apply the data-sharing restrictions under
review agent defaults below. Then record the current PR comment IDs using
`gh api repos/{owner}/{repo}/issues/N/comments --paginate`. After its run,
read the comments again. Count the review as complete only if a new comment
ID identifies a comment whose body first line exactly matches that reviewer's
model, rally number, and pinned head. A successful agent exit without that
comment is a failed review.
Dispatch duplicate model entries sequentially so each has its own before and
after snapshot. Do not count a failed review toward Pass.

Wrap every reviewer dispatch in `timeout` (45 minutes is ample). Reviewer CLIs
can hang without output, and a timed-out review is a failed review.

A failed review blocks only that reviewer slot. Correct its dispatch or
publication and retry, or choose a permitted replacement consistent with explicit

From ejarmand/skills, MIT.

More from ejarmand/skills