PR Sweep

Walk every open pull request you authored and move it toward a terminal state — merged, or fixed and waiting on a human LGTM — so the queue drains without you babysitting each one. Joe opens a lot of PRs from joestump-agent; this is how they get shepherded to green and merged.

The one rule that governs everything: no self-merge

An account must not merge its own pull requests. That separation of duties is the whole point of review — the author gets a PR ready, a different identity provides the final LGTM and the merge. So this skill decides what it may do by comparing the acting account (whoever the tokens are authenticated as) to the PR's author:

• self mode — acting account is the author. Never merge. The job is to get the PR ready: push fixes for failing CI and review findings, reply to the threads, and report it as "ready, awaiting merge by another identity."
• merge mode — acting account is not the author. The ready PRs (green + approved + mergeable, not draft) get merged. Not-ready ones get reported, and you may leave a review, but don't push commits onto someone else's branch unless you clearly have write access and it's obviously wanted.

The practical shape of this: run it plainly on your laptop (whoami=joestump, gh authed as joestump) and it sweeps your own PRs in self mode — fixes and replies, never merges. Run it with --username joestump-agent while authed as joestump and it sweeps the agent's PRs in merge mode — merging the ones the agent already got green. That's Joe merging the agent's work from his own account, exactly as a second reviewer would.

Step 1 — Resolve identity and mode

Run the bundled script. It resolves the target author, reports the acting GitHub login, computes the mode, and lists the target's open GitHub PRs. Pass through --username if the user gave one:

scripts/list-open-prs.sh [--username <login>]

Line 1 is a JSON header — {host, target_user, acting_user, mode} — and the rest is the gh search prs array. Read the header: it tells you whether GitHub is in self or merge mode for this run.

For Gitea, every call goes through tea with the login passed explicitly (tea logins list names it; below it is gitea.stump.rocks). Never curl with $GITEA_TOKEN — agent shells don't carry it — and never a Gitea MCP. tea api exits 0 on an HTTP error, so read the body.

Determine the acting identity and compare it to target_user the same way (equal → self, different → merge):

tea api --login gitea.stump.rocks user | jq -r .login

Find the target's open Gitea PRs. In self mode one search covers every repo; otherwise list the handful of repos the target opens PRs against (stumpcloud/*, joestump/*, stump.wtf/*) filtered to the target as poster:

tea api --login gitea.stump.rocks 'repos/issues/search?type=pulls&state=open&created=true&limit=50'
tea api --login gitea.stump.rocks 'repos/<owner>/<repo>/pulls?state=open&poster=<target>&limit=50'

The two hosts can legitimately be in different modes if the tea login and the gh login are different accounts — evaluate each host on its own.

If a host has no credentials configured, say so and sweep the other host rather than failing the whole run.

Step 2 — Gather each PR's state

For every open PR in the target set, collect enough to decide:

• CI / checks — passing, failing, pending, or none. GitHub: gh pr checks <n> -R <owner/repo> or gh pr view <n> -R <repo> --json statusCheckRollup. Gitea: tea api --login gitea.stump.rocks repos/<owner>/<repo>/commits/<head-sha>/status and read .state (Gitea Actions can be flaky to query — if you can't get status, say "CI unknown" rather than guessing).
• Mergeability — clean, or conflicts / behind base. GitHub: --json mergeable,mergeStateStatus. Gitea: .mergeable from tea api --login gitea.stump.rocks repos/<owner>/<repo>/pulls/<n>.
• Review state — approved, changes requested, or no review yet. GitHub: --json reviewDecision,reviews. Gitea: tea api --login gitea.stump.rocks repos/<owner>/<repo>/pulls/<n>/reviews.
• Open threads / findings — unresolved review comments or review-bot findings that ask for a change. These are what self mode acts on.

Step 3 — Decide and act, one PR at a time

Work them individually — finish one before starting the next — so a failure on one PR never strands another half-done. Apply this table:

Bringing a behind PR current

Let the forge rebase it; don't rewrite the branch yourself. Both major forges do this server-side, replaying only that PR's own commits onto the new base:

The merge style adds a Merge branch 'main' commit that buries the real diff. A local rebase-and-push rewrites a published branch, which drops commits from anyone who already fetched it. Expect the approval to be dismissed afterwards if the repo dismisses stale approvals — the tree changed, so that is correct.

Only on a PR you authored. A PR someone else owns is theirs to bring current.

Two things this skill never does: merge its own PRs, and close anyone's PRs. Both are deliberate — the first is the safety invariant, the second keeps this tool focused on advancing PRs (grooming/closing stale ones lives in the weekly-issue-pr-grooming skill).

Pushing fixes (self mode)

When a PR you authored has failing CI or requested changes, actually fix it:

1. Check out the PR branch (gh pr checkout <n> -R <repo>; for Gitea, fetch the head branch).
2. Reproduce the failure locally where you can, make the change, and keep the fix scoped to what the CI failure or review comment asked for.
3. Commit and push to the PR branch.
4. Reply to each thread you addressed — quote or reference the specific finding and say what you changed, so the reviewer can see it was handled. Then post a short top-level comment summarizing the push if several threads moved.

This is the same motion as responding to review feedback on a single PR, applied across all of them.

Attribution when you comment

If the acting account is joestump (you're posting as Joe), end each comment and reply with Joe's attribution footer, per his global CLAUDE.md — a blank line, then exactly:

🤖 Posted on behalf of `@joestump` by [Claude](https://claude.ai).

Keep @joestump in backticks (so it doesn't fire a live mention) and use no horizontal rule before it. If the acting account is joestump-agent, it's the agent's own account — post normally, no footer.

Merging (merge mode)

Merge only when all of these hold: checks green (or none required), review decision approved (or the repo requires none), mergeable is clean, and the PR isn't a draft. Respect the repo's merge style — if unsure, a plain merge commit is the safe default.

• GitHub: gh pr merge <n> -R <owner/repo> --merge (or the repo's preferred --squash/--rebase).
• Gitea: tea pulls merge --login gitea.stump.rocks --repo <owner/repo> --style <merge|squash|rebase> <n>, then re-read the PR and confirm .merged — the exit code does not prove it.

If a PR looks ready but something's off (branch protection, a required check still pending), don't force it — report the blocker.

Output — end with a summary

Close every run with a compact table so Joe sees the whole sweep at a glance:

PR Sweep — target: <user>  ·  github: <mode>  ·  gitea: <mode>

MERGED
  ✅ joestump-agent/crush#175 — retry transient Windows rename failures

FIXED & PUSHED (awaiting merge)
  🔧 joestump/msgbrowse#216 — fixed hermetic config test, replied on thread

READY — needs external LGTM
  🟢 joestump/reduit#42 — green + approved (self mode: won't self-merge)

BLOCKED / REPORTED
  ⚠️ joestump/spotter#88 — CI failing (flaky integration test), pushed retry
  🧷 joestump/foo#12 — conflicts with base, rebased and pushed

SKIPPED
  📝 joestump/bar#9 — draft

Link every PR by URL (Joe's rule: never name something linkable without its link). If this was run from a scheduled task, also send the Signal Note-to-Self summary his scheduled-task convention requires.

Safety and scope

• Dry run: if Joe says "dry run" (or "just show me"), do Steps 1–2 and print the decision table with what you would do — take no writes.
• One at a time, and stop to ask if something's ambiguous (a merge conflict you can't cleanly resolve, a review finding you don't understand). Better to report it than guess.
• Never merge your own PRs; never close PRs. Restated because they're the two lines this skill must not cross.