review-prs

name	review-prs
description	Assess open PRs and generate a parallel review script — produces manifest.json and let-it-rip.sh for team-review-request execution.
argument-hint	[#47 #46] [--max=20] [--concurrency=3] [--include-drafts]

Context

• Project root: !git rev-parse --show-toplevel 2>/dev/null
• Current branch: !git branch --show-current 2>/dev/null
• Remote: !git remote get-url origin 2>/dev/null

Sweep Review PRs

Assess open PRs, then generate let-it-rip.sh — a bash script that launches parallel claude -p sessions, each invoking /git:team-review-request.

1. Assessment (this skill, run once) — produces manifest + let-it-rip.sh + per-PR prompts
2. Execution (rerunnable) — operator runs bash let-it-rip.sh from terminal, repeatedly if needed

let-it-rip.sh is the loop target, not this skill. Each claude -p session invokes team-review-request, which has re-review and quick-exit detection built in — if no changes since the last review, the session exits cleanly with status=skipped.

Usage

• /sweep:review-prs — all open PRs (up to 20)
• /sweep:review-prs #47 #46 — specific PRs
• /sweep:review-prs --max=10 --concurrency=2 --include-drafts

Prerequisites (hard gate)

claude -p sessions are top-level and cannot prompt for permissions. All patterns below must exist in ~/.claude/settings.json permissions.allow. Stop immediately if any are missing.

Detect platform first (see Phase 2), then check the matching CLI patterns:

GitHub patterns:

"Bash(gh pr view:*)", "Bash(gh pr diff:*)", "Bash(gh pr list:*)",
"Bash(gh api:*)", "Bash(gh pr review:*)"

GitLab patterns:

"Bash(glab mr view:*)", "Bash(glab mr diff:*)", "Bash(glab mr list:*)",
"Bash(glab api:*)", "Bash(glab mr note:*)"

Shared patterns (both platforms):

"Bash(git status:*)", "Bash(git diff:*)", "Bash(git log:*)", "Bash(mkdir:*)",
"Bash(jq *)",
"Bash(cp ~/.claude/skill-references/**)",
"Bash(bash ~/.claude/skill-references/**)",
"Read(~/.claude/commands/**)", "Read(~/.claude/learnings*/**)",
"Read(~/.claude/learnings-providers.json)", "Read(~/.claude/skill-references/**)",
"Read(~/.claude/commands/set-persona/**)",
"Read(~/**/tmp/claude-artifacts/**)",
"Read(tmp/claude-artifacts/**)",
"Write(~/**/tmp/claude-artifacts/**)",
"Edit(~/**/tmp/claude-artifacts/**)"

If missing, report with BLOCKED: prefix listing each missing pattern. Do not continue until resolved.

Reference Files

• ~/.claude/skill-references/parallel-claude-runner-template.sh — Bash template for let-it-rip.sh generation
• ~/.claude/skill-references/fill-template.sh — Bash assembly for prompt generation (replaces LLM string substitution)
• @~/.claude/skill-references/sweep-scaffold.md — Shared artifact structure, watermark logic, result/learnings patterns, announce/progress/retro formats
• reviewer-prompt.md — Prompt template for review agents (assembled by fill-template.sh)

Instructions

Phase 0: Verify Prerequisites

Read ~/.claude/settings.json, check every required pattern is present (exact string match). Also verify Write/Edit parity: every Write(...) pattern in the prerequisites that targets files the claude -p session will update (not just create) must have a matching Edit(...) pattern. Stop if any missing.

Phase 1: Parse Arguments

• PR numbers: regex #(\d+) → PR_NUMBERS[]
• --max=<N> → MAX_PRS (default 20)
• --concurrency=<N> → CONCURRENCY (default 3)
• --include-drafts → INCLUDE_DRAFTS (default false)

Phase 2: PR Fetch

Fetch open PRs — platform-specific commands are inlined below via ! preprocessing:

• Specific numbers (adapt to include isDraft,reviews,comments fields):

  !`cat ~/.claude/platform-commands/fetch-review-details.sh 2>/dev/null || echo "UNCONFIGURED: run setup-claude.sh to set up platform-commands"`
  

• All open (adapt to include isDraft field):

  !`cat ~/.claude/platform-commands/list-open-prs.sh 2>/dev/null || echo "UNCONFIGURED: run setup-claude.sh to set up platform-commands"`
  

  Then fetch reviews,comments per PR separately.

Phase 3: Filter and Skip Detection

Explicit selection bypasses skip filtering — all specified PRs are eligible (still detect review mode for prompt generation).

When no specific PRs are given (all-open mode), apply skip filtering per PR:

a. isDraft && !INCLUDE_DRAFTS → SKIP(Draft)

b. Scan reviews for Role:.*Team-Reviewer. If found, store LAST_REVIEW_TS. Check for activity since:

• Commits after LAST_REVIEW_TS
• Non-self reviews or comments after LAST_REVIEW_TS

No activity → SKIP(Reviewed, no activity since <ts>) New activity → RE-REVIEW (eligible)

c. No prior team review → FIRST-REVIEW (eligible)

Phase 4: Stacked PR Detection

Check if any PR's baseRefName matches another's headRefName. Record stacked_on / stacked_by in manifest. All stacked PRs are still reviewed independently.

Phase 5: Present Summary

Assessed N PRs. M eligible, K skipped:

| # | Title | Mode | Stack | Skip Reason |
|---|-------|------|-------|-------------|
| 47 | Add auth middleware | First review | -- | -- |
| 46 | Fix race condition | Re-review | -- | -- |
| 45 | Update deps | Skip | -- | No activity since review |
| 43 | Auth tokens | First review | -> #47 | -- |

Generating let-it-rip.sh for M PRs (concurrency: CONCURRENCY)...

Proceed directly to artifact generation — do not wait for confirmation.

Phase 6: Generate Artifacts

Create run directory: tmp/claude-artifacts/sweep-reviews/<YYYY-MM-DD-HHMM> with a pr-<N>/ subdirectory per eligible PR. Compute the timestamp in a separate Bash call first (date +%Y-%m-%d-%H%M), then use the literal value — $() subshells in Bash commands break permission pattern matching. Initialize the run dir + per-PR subdirs + copy shared preflight in a single call:

bash ~/.claude/skill-references/init-sweep-pr-dir.sh <RUN_DIR> <pr-numbers...>

This matches the Bash(bash ~/.claude/skill-references/**) allow pattern — no per-invocation permission prompt. Follow Artifact Structure in sweep-scaffold.md.

manifest.json

{
  "created_at": "<ISO>",
  "run_dir": "<RUN_DIR>",
  "concurrency": <N>,
  "owner_repo": "<owner/repo>",
  "eligible": [
    {"number": 47, "title": "...", "mode": "first-review", "url": "...", "stacked_on": null, "stacked_by": [43]}
  ],
  "skipped": [
    {"number": 45, "reason": "Reviewed, no activity since 2026-03-27T10:00:00Z"}
  ]
}

Data files & prompt assembly

Write data files for template assembly, then call fill-template.sh:

1. Per-PR files in pr-<N>/:

   • metadata.json:

     {
       "PR_NUMBER": "<number>",
       "PR_TITLE": "<title>",
       "PR_URL": "<url>",
       "OWNER_REPO": "<owner/repo>",
       "MODE": "first-review or re-review",
       "RUN_DIR": "<absolute path>",
       "PR_DIR": "<absolute path>",
       "STACKING_CONTEXT": "<stacking description or 'This PR is not part of a stack.'>",
       "LAST_SHA_FIELD": "last_reviewed_sha",
       "FETCH_LATEST_INLINE_COMMENT_ID_CMD": "<literal command — see below>",
       "FETCH_PR_WATERMARK_CMD": "<literal command — see below>"
     }
     

     Platform command injection: The following keys inject literal platform commands into runtime templates via fill-template.sh:

     • FETCH_LATEST_INLINE_COMMENT_ID_CMD — literal value of:

       !`cat ~/.claude/platform-commands/fetch-latest-inline-comment-id.sh 2>/dev/null || echo "UNCONFIGURED: run setup-claude.sh to set up platform-commands"`
       

     • FETCH_PR_WATERMARK_CMD — literal value of:

       !`cat ~/.claude/platform-commands/fetch-pr-watermark.sh 2>/dev/null || echo "UNCONFIGURED: run setup-claude.sh to set up platform-commands"`
       

2. Assemble prompt:

   bash ~/.claude/skill-references/fill-template.sh reviewer-prompt.md <RUN_DIR>/pr-<N> > <RUN_DIR>/pr-<N>/prompt.txt
   

let-it-rip.sh

Follow let-it-rip.sh Generation in sweep-scaffold.md. Write <RUN_DIR>/metadata.json using the runner schema from sweep-scaffold.md with these review-mode overrides:

• MODE → "review", MODE_LABEL → "Review"
• MODEL → "claude-sonnet-4-6" (orchestrator — heavy work is in git:team-review-request's subagents)
• BRANCHES → "", WORKTREES → "" (review mode doesn't use worktrees)

Entity type keys for PRs:

{"ENTITY_PREFIX": "pr", "ENTITY_LABEL": "PR", "STATE_FIELD": "pr_state",
 "TERMINAL_STATES": "MERGED CLOSED"}

FETCH_ITEM_STATE_CMD is set separately from platform detection (see sweep-scaffold.md → "FETCH_ITEM_STATE_CMD" examples for GitHub gh pr view ... and GitLab glab api ... | jq ... | tr ... forms).

All other keys (CONCURRENCY, RUN_DIR, TIMESTAMP) follow the schema defaults. Then assemble via fill-template.sh.

Phase 7: Announce, Progress Check, Retro

Follow the corresponding sections in sweep-scaffold.md. Retro table includes stacked PR relationships. Mode-specific retro table columns:

PR	Title	Rounds	Latest Mode	Personas	Findings	Status

Phase 8: Auto-Launch Runner

Follow Auto-Launch in sweep-scaffold.md. Use the relative path bash tmp/claude-artifacts/sweep-reviews/<TIMESTAMP>/let-it-rip.sh so the existing Bash(bash tmp/claude-artifacts/**) permission matches. Skip if 0 eligible or --no-launch was passed.

Important Notes

• Concurrency depth. Default 3 x up to 3 reviewer subagents = 9 concurrent API sessions. Lower if hitting rate limits.
• No auto-approve. Reviews post as COMMENT. Operator decides the verdict.
• Stacked PRs. Reviewed independently against their base branch. No ordering needed.
• See Shared Important Notes in sweep-scaffold.md for rerunnable, rate limits, crash recovery, and cleanup.