Merge train: land all 44 open PRs

README.md

@@ -66,6 +66,14 @@ Works for same-repo and fork PRs: the PR's head (`refs/pull/<N>/head`) is fetche
 pr-split split '#42' --base main
 ```
 
+A bare number (with or without `#`) is always treated as a PR number, even if a
+local branch or abbreviated commit hash with the same digits exists. To split a
+local branch literally named like a number, pass its full ref:
+
+```bash
+pr-split split refs/heads/1006 --base main
+```
+
 ### Split a fork PR by user:branch
 
 ```bash
@@ -101,7 +109,7 @@ pr-split split feature-branch --base main --dry-run
 pr-split split feature-branch --base main --stack
 ```
 
-A group with a single parent has its branch cut from the parent group's branch, carries the parent's hunks for shared files, and targets the parent's branch, with or without `--stack`. Its PR shows only its own diff, compiles standalone, and GitHub retargets it automatically as the parent merges. A group with several parents is cut from the merge base, carries every ancestor's changes, and targets the base branch, so its diff also includes those ancestors' changes (its PR description lists them). Groups with no dependencies are cut from the merge base and target the base branch. `--stack` additionally registers the chains as native GitHub stacks.
+A group with a single parent has its branch cut from the parent group's branch, carries the parent's hunks for shared files, and targets the parent's branch, with or without `--stack`. Its PR shows only its own diff and compiles standalone. When `pr-split merge` reaches such a child it retargets the PR at the base branch (`gh pr edit --base`) right before merging it, since GitHub only does that itself for native stacks or when the parent's head branch is deleted (which `gh pr merge --auto` skips). A group with several parents is cut from the merge base, carries every ancestor's changes, and targets the base branch, so its diff also includes those ancestors' changes (its PR description lists them). Groups with no dependencies are cut from the merge base and target the base branch. `--stack` additionally registers the chains as native GitHub stacks.
 
 A new file larger than `--max-loc` cannot fit in any one sub-PR. With `--stack` it is cut into pieces between top-level definitions: Python files at top-level statements, and other languages at unindented lines after a blank line, outside brackets, strings and comments. Each piece is appended by a PR stacked on the one holding the piece before it. Every layer holds a valid prefix of the file, and the top of the chain holds the whole file. Without `--stack` a new file is never cut.
 
@@ -121,17 +129,17 @@ Shows a table with each sub-PR's ID, title, branch, PR number, live state (OPEN/
 pr-split merge
 ```
 
-Walks the dependency DAG and merges each PR in topological order. Skips already-merged, closed, draft, review-required, or changes-requested PRs, and every PR whose dependency was not merged in this run (independent subtrees still proceed). Stops if a merge fails. Exits 1 whenever a merge failed or any PR was left blocked, so re-run once the blocking PRs are ready.
+Walks the dependency DAG and merges each PR in topological order. Each child PR that targets its parent's branch is retargeted at the base branch right before it is merged (native-stack PRs are left to GitHub). Skips already-merged, closed, draft, review-required, or changes-requested PRs, and every PR whose dependency was not merged in this run (independent subtrees still proceed). Stops if a merge fails. Exits 1 whenever a merge failed, any PR was left blocked, or a PR's state could not be fetched from GitHub (check `gh auth status`), so re-run once the cause is resolved.
 
 Use `--auto` to queue merges behind CI checks (uses `gh pr merge --auto`):
 
 ```bash
 pr-split merge --auto
 ```
 
-`--auto` is not fire-and-forget: after queueing a batch, `merge` waits for every PR in it to reach `MERGED` before moving on to the dependent batch, polling GitHub every 10 seconds for up to 10 minutes per batch. If a PR is still unmerged when the timeout expires, or gets closed while waiting, the command stops before the dependent batch and exits 1 (webhook `exit_reason: incomplete_batch`); re-run `pr-split merge --auto` once CI has caught up to continue from where it left off.
+`--auto` is not fire-and-forget: after queueing a batch, `merge` waits for every PR in it to reach `MERGED` before moving on to the dependent batch, polling GitHub every 10 seconds for up to 10 minutes per batch. If a PR is still unmerged when the timeout expires, the command stops before the dependent batch and exits 1 (webhook `exit_reason: incomplete_batch`). A PR closed while waiting is listed as `<id> (CLOSED)` among the skipped PRs, its dependants are skipped as blocked, and the run exits 1 (webhook `exit_reason: pr_closed`). Either way, re-run `pr-split merge --auto` once CI has caught up to continue from where it left off.
 
-Use `--notify` to POST merge results to a webhook URL (e.g. Slack, Discord):
+Use `--notify` to POST merge results to an http(s) webhook URL (e.g. Slack, Discord); other schemes are rejected up front, and a delivery failure (timeout, non-2xx) is logged as a warning without changing the exit code:
 
 ```bash
 pr-split merge --notify https://hooks.slack.com/...
@@ -253,7 +261,7 @@ commit_message = "chore: release notes for {title}"   # {id}, {title}, {index}
 
 ### Re-split with different parameters
 
-Running `split` again when a plan already exists will prompt you to clean up existing branches and PRs before re-planning. Dry-run plans are silently overwritten.
+Running `split` again when a plan already exists will prompt you to clean up existing branches and PRs before re-planning. Dry-run plans are silently overwritten. With `--dry-run`, `split` never closes PRs or deletes branches: if the saved plan has already been executed it exits 1 and asks you to run `pr-split clean` first.
 
 ### Clean up
 
@@ -302,6 +310,7 @@ on:
     branches: [main]
 
 permissions:
+  contents: read
   pull-requests: write
 
 jobs:
@@ -337,7 +346,7 @@ jobs:
 |--------|-------------|
 | `total-loc` | Total lines of code in the PR diff |
 | `total-groups` | Number of suggested groups |
-| `objective` | Plan objective score (lower is better) |
+| `objective` | Simplified plan score, `overflow × 1000 + file_scatter × 50 + groups` (lower is better; `0` when no split plan was scored; not the full `score_plan` objective described in METHODOLOGY.md) |
 | `should-split` | Whether the PR should be split (`true`/`false`) |
 
 ## Planning backends

action.yml

@@ -35,7 +35,7 @@ outputs:
     description: "Number of suggested groups"
     value: ${{ steps.score.outputs.total_groups }}
   objective:
-    description: "Plan objective score (lower is better)"
+    description: "Simplified plan score: overflow*1000 + file_scatter*50 + groups (lower is better; 0 when no split plan was scored)"
     value: ${{ steps.score.outputs.objective }}
   should-split:
     description: "Whether the PR should be split (true/false)"
@@ -79,11 +79,17 @@ runs:
       run: python "${{ github.action_path }}/scripts/score_pr.py"
 
     - name: Post comment
-      if: inputs.post-comment == 'true' && steps.score.outputs.should_split == 'true'
+      if: inputs.post-comment == 'true' && steps.score.outputs.comment_path != ''
       uses: actions/github-script@v7
+      env:
+        SHOULD_SPLIT: ${{ steps.score.outputs.should_split }}
       with:
         script: |
           const fs = require('fs');
+          if (!context.payload.pull_request) {
+            core.info('Not a pull_request event; no comment to post.');
+            return;
+          }
           const body = fs.readFileSync('${{ steps.score.outputs.comment_path }}', 'utf8');
           const { data: comments } = await github.rest.issues.listComments({
             owner: context.repo.owner,
@@ -92,13 +98,15 @@ runs:
           });
           const existing = comments.find(c => c.body.includes('<!-- pr-split-score -->'));
           if (existing) {
+            // Always refresh an existing comment so a PR that shrank below
+            // the threshold no longer shows a stale split plan.
             await github.rest.issues.updateComment({
               owner: context.repo.owner,
               repo: context.repo.repo,
               comment_id: existing.id,
               body,
             });
-          } else {
+          } else if (process.env.SHOULD_SPLIT === 'true') {
             await github.rest.issues.createComment({
               owner: context.repo.owner,
               repo: context.repo.repo,