fix: paginate on the API page size, not on how many PRs survive curation

Second run got as far as fetching PRs and reported:

    Found 0 open pull requests (curation selects 160)
    ⚠️  160 selected PR(s) are no longer open and will be skipped

All 160 are open. The walk over /pulls decided it had reached the last page by
testing `len(prs) < 100` *after* filtering. A page of 100 open PRs almost never
contains 100 that a curator selected, so the loop stopped on page 1 — and since
the API returns newest first while this profile's PRs are older, page 1 held
none of them. Zero.

Pagination now tests the count the API returned; filtering happens after and
cannot end the walk. Simulated against the real shape (20 selected PRs spread
across 80 pages): 0 found before, 20 after.

The bug was latent in the original code, which filtered by USERNAMES before the
same check — it only ever ran with USERNAMES empty, so nothing was filtered and
the count was the raw page size. Making curation unconditional is what exposed
it.

Also fixes the crash that followed. The "no open PRs" path prints "creating
branch with just main branch updates" and then pushes that branch, but nothing
creates it — apply_prs_to_branch() normally does, and that path skips it. The
push failed with "src refspec build-... does not match any", which says nothing
about the actual problem. It now creates the branch, so an empty curation
produces an empty build and a report rather than a misleading git error.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: theoryshaw

automation/scripts/00_clone_merge_and_create_branch.py

@@ -338,23 +338,28 @@ def get_open_prs():
             print(f"Error fetching PRs: {response.status_code}")
             break
 
-        prs = response.json()
-        if not prs:
+        page_items = response.json()
+        if not page_items:
             break
 
+        # Pagination is decided by how many items the API returned, NOT by how
+        # many survive curation. Testing the filtered count ends the walk on the
+        # first page for any selective profile — a page of 100 open PRs rarely
+        # contains 100 that a curator selected — and silently yields a fraction
+        # of the curation, or nothing at all.
+        is_last_page = len(page_items) < params["per_page"]
+
         # Apply the active curation. For the legacy/`everything` case this is
         # exactly the old author filter; for an `allowlist` profile it is also
         # what narrows 847 open PRs down to the ones the curator chose.
-        prs = [
+        all_prs.extend(
             pr
-            for pr in prs
+            for pr in page_items
             if CURATION.selects(pr["number"], (pr.get("user") or {}).get("login"))
-        ]
-
-        all_prs.extend(prs)
+        )
         page += 1
 
-        if len(prs) < 100:  # Last page
+        if is_last_page:
             break
 
     if CURATION.mode == bonsaipr_profile.MODE_ALLOWLIST:
@@ -1489,6 +1494,18 @@ def main():
         applied, failed, skipped = [], [], []
         failed_pr_test_results = {}
         pr_conflict_data = {}
+        # Actually create the branch before pushing it. apply_prs_to_branch()
+        # normally does this, but it is skipped entirely on this path, so the
+        # push below used to fail with "src refspec does not match any" — an
+        # error that says nothing about the real problem, which is that the
+        # curation matched no open PRs.
+        original_dir = os.getcwd()
+        try:
+            os.chdir(work_dir)
+            subprocess.run(["git", "branch", "-D", branch_name], capture_output=True)
+            subprocess.run(["git", "checkout", "-b", branch_name], check=True)
+        finally:
+            os.chdir(original_dir)
         # Push branch to fork (even if empty)
         push_branch_to_fork(branch_name)
         # Print current branch for verification