fix: auto-request Copilot reviews and handle existing PRs in pipeline

- Add `request_copilot_reviews` to make_helpers.sh; `run-review-forever`
  now auto-requests Copilot review on waiting PRs before each poll cycle
- Add `worktree-for-issue` command to pipeline_worktree.py that checks
  for an existing open PR and checks out its branch instead of creating
  a fresh worktree from main
- Fix `fetch_existing_prs` search string ("Fixes #N" → "Fix #N") to
  match actual PR title convention
- Update project-pipeline skill to use `worktree-for-issue` and request
  Copilot review after moving to Review pool
- Update CLAUDE.md and review-pipeline skill docs

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: GiggleLiu

.claude/CLAUDE.md

@@ -62,8 +62,8 @@ make run-pipeline N=97 # Process a specific issue from the project board
 make run-pipeline-forever # Poll Ready column, run-pipeline when new issues appear
 make run-review    # Pick next PR from Review pool column, fix Copilot comments, fix CI, run agentic tests
 make run-review N=570 # Process a specific PR from the Review pool column
-make run-review-forever # Poll Review pool for Copilot-reviewed PRs, run-review when new ones appear
-make copilot-review # Request Copilot code review on current PR
+make run-review-forever # Poll Review pool, auto-request Copilot reviews, dispatch run-review when reviewed
+make copilot-review # Request Copilot code review on current PR (requires: gh extension install ChrisCarini/gh-copilot-review)
 make release V=x.y.z  # Tag and push a new release (CI publishes to crates.io)
 # Set RUNNER=claude to use Claude instead of Codex (default: codex)
 # Default Codex model: CODEX_MODEL=gpt-5.4

.claude/skills/project-pipeline/SKILL.md

@@ -136,15 +136,19 @@ TITLE=$(printf '%s\n' "$CLAIM" | python3 -c "import sys,json; print(json.load(sy
 
 ### 1. Create Worktree
 
-Create an isolated git worktree for this issue so the main working directory stays clean:
+Create an isolated git worktree for this issue. The script automatically checks for an existing open PR — if one exists, it checks out that PR branch (treating it as an incomplete implementation); otherwise it creates a fresh worktree from `origin/main`:
 
 ```bash
-WORKTREE=$(python3 scripts/pipeline_worktree.py create-issue --issue "$ISSUE" --slug <slug> --base origin/main --format json)
-BRANCH=$(printf '%s\n' "$WORKTREE" | python3 -c "import sys,json; print(json.load(sys.stdin)['branch'])")
+WORKTREE=$(python3 scripts/pipeline_worktree.py worktree-for-issue \
+  --repo "$REPO" --issue "$ISSUE" --slug <slug> --format json)
+ACTION=$(printf '%s\n' "$WORKTREE" | python3 -c "import sys,json; print(json.load(sys.stdin)['action'])")
 WORKTREE_DIR=$(printf '%s\n' "$WORKTREE" | python3 -c "import sys,json; print(json.load(sys.stdin)['worktree_dir'])")
 cd "$WORKTREE_DIR"
 ```
 
+- `action == "resume-pr"`: existing PR checked out — `issue-to-pr` will skip plan creation and jump to execution
+- `action == "create-worktree"`: fresh branch from `origin/main`
+
 All subsequent steps run inside the worktree. This ensures the user's main checkout is never modified.
 
 ### 2. Claim Result
@@ -159,18 +163,21 @@ Invoke the `issue-to-pr` skill with `--execute` (working directory is the worktr
 /issue-to-pr "$ISSUE" --execute
 ```
 
-This handles the full pipeline: fetch issue, verify Good label, research, write plan, create PR, implement, review, fix CI.
+This handles the full pipeline: fetch issue, verify Good label, research, write plan, create PR, implement, review, fix CI. If an existing PR was detected in Step 1, `issue-to-pr` will resume it (skip plan creation, jump to execution).
 
 **If `issue-to-pr` fails after creating a PR:** record the failure, but still move the issue to "Final review" so it's visible for human triage. Report the failure to the user.
 
 ### 4. Move to "Review pool"
 
-After `issue-to-pr` succeeds, move the issue to the `Review pool` column for the second-stage review pipeline:
+After `issue-to-pr` succeeds, move the issue to the `Review pool` column and request a Copilot review so the review pipeline can pick it up:
 
 ```bash
 python3 scripts/pipeline_board.py move <ITEM_ID> review-pool
+gh copilot-review <PR_NUMBER>
 ```
 
+The Copilot review request is required — without it, `run-review-forever` will not detect the PR as eligible.
+
 **If `issue-to-pr` failed after creating a PR:** move the issue to `Final review` instead so a human can take over:
 
 ```bash
@@ -237,3 +244,4 @@ Completed: 2/4 | Review pool: 3 | Returned to Ready: 1
 | Worktree left behind on failure | Always clean up with `git worktree remove` in Step 5 |
 | Working in main checkout | All work happens in `.worktrees/` — never modify the main checkout |
 | Missing items from project board | `gh project item-list` defaults to 30 items — always use `--limit 500` |
+| Creating a fresh branch when PR exists | Check `issue-context` action field first — use `checkout-pr` for existing PRs instead of `create-issue` |

.claude/skills/review-pipeline/SKILL.md

@@ -288,7 +288,7 @@ Completed: 2/2 | All moved to Final review
 | PR not in Review pool column | Verify status before processing; STOP if not Review pool |
 | Processing a closed PR from a stale issue card | Require PR state `OPEN`; skip stale closed PRs |
 | Guessing on an issue card with multiple linked repo PRs | Stop, show options to the user, and recommend the most likely correct OPEN PR |
-| Picking a PR before Copilot has reviewed | Check `pulls/$PR/reviews` for copilot-pull-request-reviewer[bot]; skip if absent |
+| Picking a PR before Copilot has reviewed | Check `pulls/$PR/reviews` for copilot-pull-request-reviewer[bot]; if absent, request with `gh copilot-review <PR>` and wait |
 | Missing project scopes | Run `gh auth refresh -s read:project,project` |
 | Skipping review-implementation | Always run structural completeness check in Step 2b — it catches gaps Copilot misses (paper entries, CLI registration, trait_consistency) |
 | Skipping agentic tests | Always run test-feature even if CI is green |

Makefile

@@ -577,8 +577,8 @@ run-review:
 	PROMPT=$$(skill_prompt_with_context review-pipeline "$$slash_cmd" "$$codex_desc" "Review pipeline context" "$$selection"); \
 	run_agent "review-output.log" "$$PROMPT"
 
-# Poll Review pool column for Copilot-reviewed PRs and run-review when new ones appear
-# Checks every 10 minutes; triggers make run-review when the eligible PR set gains new members
+# Poll Review pool column for PRs and run-review when Copilot-reviewed ones appear
+# Auto-requests Copilot review on PRs that don't have one yet before each poll cycle
 run-review-forever:
 	@. scripts/make_helpers.sh; \
 	REPO=$$(gh repo view --json nameWithOwner --jq .nameWithOwner); \

scripts/make_helpers.sh

@@ -204,6 +204,24 @@ cleanup_pipeline_worktree() {
     python3 scripts/pipeline_worktree.py cleanup --worktree "$worktree" --format json
 }
 
+# Request Copilot review on all Review pool PRs that don't have one yet.
+#   request_copilot_reviews <repo>
+request_copilot_reviews() {
+    repo=$1
+    prs=$(python3 scripts/pipeline_board.py list review --repo "$repo" --format json \
+        | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+for item in data.get('items', []):
+    if item.get('eligibility') == 'waiting-for-copilot' and item.get('pr_number'):
+        print(item['pr_number'])
+")
+    for pr in $prs; do
+        echo "$(date '+%Y-%m-%d %H:%M:%S') Requesting Copilot review on PR #${pr}..."
+        gh copilot-review "$pr" 2>&1 || true
+    done
+}
+
 # Poll a board column and dispatch a make target when new items appear.
 #   watch_and_dispatch <mode> <make-target> <label> [repo]
 # Example:
@@ -221,6 +239,11 @@ watch_and_dispatch() {
 
     echo "Watching for new ${label} (polling every $((interval / 60))m)..."
     while true; do
+        # For review mode, request Copilot reviews on PRs that don't have one yet
+        if [ "$mode" = "review" ] && [ -n "$repo" ]; then
+            request_copilot_reviews "$repo"
+        fi
+
         next_item=$(poll_project_items "$mode" "$state_file" "$repo")
         status=$?
         if [ "$status" -eq 0 ]; then

scripts/pipeline_checks.py

@@ -596,7 +596,7 @@ def fetch_existing_prs(repo: str, issue_number: int) -> list[dict]:
         "--state",
         "open",
         "--search",
-        f"Fixes #{issue_number}",
+        f"Fix #{issue_number}",
         "--json",
         "number,headRefName,url",
     )

scripts/pipeline_worktree.py

@@ -259,6 +259,51 @@ def prepare_review(
     }
 
 
+def worktree_for_issue(
+    *,
+    repo: str,
+    issue_number: int,
+    slug: str,
+    base_ref: str = "origin/main",
+    repo_root: str | Path | None = None,
+) -> dict:
+    """Create or checkout a worktree for an issue.
+
+    If the issue already has an open PR, checkout the PR branch.
+    Otherwise, create a fresh worktree from base_ref.
+    """
+    import pipeline_checks
+
+    existing_prs = pipeline_checks.fetch_existing_prs(repo, issue_number)
+    if existing_prs:
+        pr = existing_prs[0]
+        pr_number = int(pr["number"])
+        result = checkout_pr_worktree(
+            repo=repo,
+            pr_number=pr_number,
+            repo_root=repo_root,
+        )
+        return {
+            **result,
+            "action": "resume-pr",
+            "issue_number": issue_number,
+            "pr_number": pr_number,
+        }
+
+    result = create_issue_worktree(
+        issue_number=issue_number,
+        slug=slug,
+        base_ref=base_ref,
+        repo_root=repo_root,
+    )
+    return {
+        **result,
+        "action": "create-worktree",
+        "issue_number": issue_number,
+        "pr_number": None,
+    }
+
+
 def cleanup_worktree(*, worktree: str | Path) -> dict:
     worktree = Path(worktree).resolve()
     repo_root = repo_root_from(worktree)
@@ -302,6 +347,14 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     checkout_pr.add_argument("--repo-root")
     checkout_pr.add_argument("--format", choices=["json", "text"], default="json")
 
+    for_issue = subparsers.add_parser("worktree-for-issue")
+    for_issue.add_argument("--repo", required=True)
+    for_issue.add_argument("--issue", required=True, type=int)
+    for_issue.add_argument("--slug", required=True)
+    for_issue.add_argument("--base", default="origin/main")
+    for_issue.add_argument("--repo-root")
+    for_issue.add_argument("--format", choices=["json", "text"], default="json")
+
     prepare_review = subparsers.add_parser("prepare-review")
     prepare_review.add_argument("--repo", required=True)
     prepare_review.add_argument("--pr", required=True, type=int)
@@ -346,6 +399,19 @@ def main(argv: list[str] | None = None) -> int:
         )
         return 0
 
+    if args.command == "worktree-for-issue":
+        emit_result(
+            worktree_for_issue(
+                repo=args.repo,
+                issue_number=args.issue,
+                slug=args.slug,
+                base_ref=args.base,
+                repo_root=args.repo_root,
+            ),
+            args.format,
+        )
+        return 0
+
     if args.command == "checkout-pr":
         emit_result(
             checkout_pr_worktree(