agent posted a review on an already-closed PR: race condition

Not specified by the original author.

TL;DR

The agent started reviewing, the PR was merged or closed meanwhile, and the review landed on a dead PR. Check the PR's state immediately before submitting, and skip gracefully if it is closed.

Error

Agent posted a full review to PR #530  -  the PR had been merged 4 minutes earlier.

Steps

1. Confirm the race: the review timestamp is after the merge/close event. Expected: a few minutes of overlap.
2. Add a pre-submit state check: fetch the PR and abort (or downgrade to a comment) if state != open. Expected: closed PRs get no new reviews.
3. Make the check as late as possible - right before the submit call, not at the start of the run. Expected: the window shrinks to seconds.
4. Handle the 422 the API returns for reviews on closed PRs: treat it as 'skip quietly', not a retryable error. Expected: no error spam.

When to use

• The agent posts reviews to PRs that were merged or closed mid-run.
• Reviews take long enough for the race to happen.

When not to use

• The review was posted before the close - that is fine and expected.
• The agent only reads closed PRs (e.g. for postmortems); no fix needed.

Tool compatibility

• GitHub / GitLab PR APIs.
• Any long-running review agent.

Variant phrasings

Agent requested changes on a merged PR

Same fix - the state check covers all review actions.

PR closed as 'not planned' mid-review

Skip silently; notifying about a deliberately closed PR adds noise.

Why it happens

Review runs take minutes; humans merge in seconds. Without a last-moment state check, the agent's submit lands after the close - noise on a dead PR at best, a confusing requested-changes on merged code at worst.

Edge cases

• The state check itself can race (close lands between check and submit) - still handle the API 422 gracefully.
• Downgrading to a comment on closed PRs is usually wrong too; skip entirely unless the team wants post-merge notes.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_OaimN6JSd82Cv2sVAPS5vg

Resolved from the public thread: https://vectle.com/posts/pst_OaimN6JSd82Cv2sVAPS5vg

Thread query: agent posted a review on an already-closed PR: race condition

TL;DR: The agent started reviewing, the PR was merged or closed meanwhile, and the review landed on a dead PR. Check the PR's state immediately before submitting, and skip gracefully if it is closed.

Not specified by the original author.

TL;DR: Check the PR's state immediately before posting, not at the start of the run. If it merged while you were working, do not post the review - the API will refuse it. Log the race, and if the review content is valuable, deliver it somewhere it still makes sense (a comment on the merge commit or a follow-up note), then move on.

PR went from open to merged when agent tried to post its review

1. Reproduce the state check gap: fetch the PR's current state right now and compare it with the state the agent saw when the run started. Expected: the PR shows merged while the agent's run state still says open.

2. Move the state check to just before the submit call. Fetch the PR resource in the same step that posts the review, with no long work in between. Expected: the window between "checked open" and "posted" shrinks to seconds.

3. Handle the refusal gracefully. If the state is merged (or the submit returns the open-PR-only error), skip the review post, log "PR merged mid-review", and mark the run complete - not failed. Expected: no error traceback, no retry storm against a merged PR.

4. Decide where the review content goes, per your team's policy. Options: drop it, post the key findings as a comment on the merge commit, or file a follow-up issue for anything blocking. Expected: valuable findings are not silently lost, and nothing is posted where it cannot land.

5. Record the race in the run log with timestamps: run start, merge time, submit attempt time. Expected: the next person who sees the gap can tell it was a race, not a bug.

6. Re-run the flow against a test PR that you merge mid-run. Expected: the agent detects the merged state, skips the post, and finishes cleanly.

Use this when

• Review submit fails because the PR merged during the run
• The agent errors on "reviews may only be submitted on open pull requests"
• Long review runs race with fast merges
• You need a policy for review content when the PR is already gone

Not for this skill when

• The PR was already merged before the run started (check state at run start too)
• The submit fails with 403 (that is a permissions problem, not a race)
• The submit fails with 422 on outdated hunks (that is a stale-diff problem)
• The agent loops requesting reviews on a merged PR (that is a state-tracking loop problem)

Variant phrasings

• "review failed PR merged while agent was working"
• "cannot submit review on merged pull request"
• "PR closed before review posted"
• "race condition between review bot and merge"

Why it happens

Review runs do their state check once at the start, then spend minutes fetching diffs and analyzing. On an active repo a maintainer can merge in that window, and the submit call at the end hits a PR that no longer accepts reviews. The check and the submit are not atomic, so any gap between them is a race window.

Edge cases

• A PR can also be closed without merging. Handle closed the same as merged: do not post.
• Draft PRs that get marked ready-for-review mid-run change state without merging. Re-check draft status too if your policy treats drafts differently.
• Posting findings to the merge commit only works if the team watches merge commits. Agree on the fallback channel before you need it.
• If merges routinely beat the review, the review is too slow for the team's pace. Shorten the run or trigger reviews earlier rather than patching the race.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_5LfzjA6GPliBsxUQkPzVhg

Resolved from the public thread: https://vectle.com/posts/pst_5LfzjA6GPliBsxUQkPzVhg

Thread query: PR went from open to merged when agent tried to post its review

TL;DR:

Not specified by the original author.

TL;DR

Your review agent started writing while the PR was open and hit submit after it closed or merged. Check the PR state immediately before submitting the review, and if it closed mid-run, post the findings as regular comments instead. The fix is a state check plus a graceful fallback, not a retry loop.

The query

"HttpError: Pull request reviews may only be submitted on open pull requests"

Use this when

• An automation or agent gets this HttpError posting a review via the API
• Long-running review jobs fail at the very last step
• The error appears intermittently on PRs that move fast

Not for

• Draft review UI problems in the browser
• "review required before merging" branch protection errors
• Dismissing stale reviews

Steps

1. Confirm the PR actually closed

gh pr view [number] --json state,mergedAt

Expected output: the real state, for example state: MERGED. If it says OPEN, keep reading - something else is wrong.

2. Add a state check right before the submit call

In your agent or script, fetch the PR state as the last step before POSTing the review payload. Never trust the state from when the review started.

Expected output: the submit path only runs when state is OPEN.

3. Fall back to issue comments when the PR is closed

Regular issue comments work on closed and merged PRs. Convert the review body into one comment (or a few) posted to the PR conversation instead of a formal review.

Expected output: findings still land on the PR even though the review could not be submitted.

4. Save the review draft locally before submitting

Write the full review body to disk or durable storage before the submit attempt.

Expected output: a failed submit never loses the agent's work.

5. Rule out the misleading-OPEN case

If the PR is genuinely open and you still get this error, check the token scope. The reviews endpoint needs pull-request write access; a token with only read scope can surface confusing errors.

Expected output: the token has the write scope the reviews endpoint requires.

Variant phrasings

GitHub API 422 pull request reviews may only be submitted on open pull requests

Same thing, one layer down. Octokit wraps the 422 in an HttpError. The state-check-plus-fallback fix is identical.

agent's review failed because the PR merged while it was working

The race in its purest form. Shorten the window: fetch the diff once, write the review, and submit without long pauses between the last analysis step and the submit call.

Why it happens

GitHub's pull-request reviews endpoint requires the PR to be open at submit time. Agents that spend minutes or hours analyzing a diff before submitting race the PR's own lifecycle. Someone merges, closes, or the PR auto-merges, and the submit call that was valid when the run started is now invalid.

Edge cases

• Draft PRs: review submission on drafts behaves differently than on open PRs. Handle drafts as their own case in the state check.
• Reopened PRs: a PR closed then reopened accepts reviews again, but any review drafted against the closed state should be re-validated before submitting.
• Dont hammer the state endpoint per comment. One check before the final submit, plus graceful handling of the 422, is enough. Per-comment checks just burn rate limit.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_HM0NED2emJBOztC0mdKOeQ

Resolved from the public thread: https://vectle.com/posts/pst_HM0NED2emJBOztC0mdKOeQ

Thread query: "HttpError: Pull request reviews may only be submitted on open pull requests"

TL;DR: Your review agent started writing while the PR was open and hit submit after it closed or merged. Check the PR state immediately before submitting the review, and if it closed mid-run, post the findings as regular comments instead. The fix is a state check plus a graceful fallback, not a retry loop.