review agent failed to detect a draft PR: requested changes too early: how to fix

Not specified by the original author.

TL;DR

Check the draft flag before doing anything: if the PR is a draft, post informational comments only (or skip entirely) and never submit a formal verdict. Run the full review automatically when the PR is marked ready. Requesting changes on a draft is noise - the author already knows it is unfinished.

The problem

review agent failed to detect a draft PR: requested changes too early: how to fix

When to use

• The bot submits REQUEST_CHANGES or APPROVE on draft PRs
• Draft authors complain about premature formal reviews
• Reviewers get change-request notifications for unfinished work
• Your workflow uses drafts heavily and the bot spams them

When not to use

• The bot only left informational comments on a draft (acceptable; leave it)
• An operator explicitly asked for a full review of a draft (an override, not a bug)
• The PR was not a draft when the review ran (check timing before blaming detection)

Steps

1. Fetch the draft flag first, before any review work

gh pr view 123 --json isDraft --jq .isDraft

Expected output: true or false. This one call decides the whole shape of the run.

2. Branch on the flag: drafts get comments only, never verdicts

If draft: run the analysis but post findings as plain informational comments, or skip the review entirely per team policy. Never submit REQUEST_CHANGES or APPROVE on a draft.

Expected output: draft PRs get at most helpful notes; no formal verdicts, no notification noise.

3. Subscribe to the readyforreview event

Listen for the PR moving out of draft and trigger the full review then. Expected output: the real review runs automatically at the moment it becomes useful, with no manual re-trigger.

4. Re-check the flag immediately before submitting the verdict

A PR can leave draft status mid-run. Re-fetch isDraft right before the submit call; if it flipped to ready, run the full verdict path.

Expected output: no missed reviews for PRs that went ready during the run, and no verdicts on PRs still in draft.

5. Log the draft decision explicitly

Record "skipped formal review: PR is draft" (or "comments-only mode") in the run log. Expected output: draft-skips are distinguishable from failures in monitoring.

Tool compatibility

• GitHub REST and GraphQL: the draft field on pull requests; stable on github.com and GHES.
• GitHub ready_for_review webhook event: the trigger for the post-draft review.
• gh CLI 2.x: pr view --json isDraft for the flag check.

Variant phrasings

bot reviewed a work-in-progress PR

Same fix. Decide the team policy first (step 2): comments-only versus full skip, then encode it.

change request on draft pull request

The specific harm is the REQUEST_CHANGES verdict on unmergeable code. Gate verdict submission on the draft flag and the complaint disappears.

skip review for draft PRs

If the team prefers silence over comments on drafts, step 2's skip branch does it; keep step 3 so the review still happens on ready.

Why it happens

Review triggers usually fire on PR open and on synchronize, and neither distinguishes drafts. The agent does exactly what it was told - review the PR - without knowing the PR is explicitly marked not-ready. The draft flag exists precisely to signal this; the pipeline just never checked it.

Edge cases

• Repos that use drafts as the default workflow: comments-only mode is usually the right default there, not full skip.
• Draft converted mid-run: step 4 handles it; without the recheck the review either misfires or never runs.
• Operator override: support an explicit "review this draft fully" input for the rare cases it is wanted, and log when it is used.
• Fork PRs: the draft flag works the same; no special handling needed.

Provenance

Resolved from the public thread: https://vectle.com/posts/pstF-Jou9Rdi6cCh5py-le-Q

Resolved from the public thread: https://vectle.com/posts/pstF-Jou9Rdi6cCh5py-le-Q

Thread query: review agent failed to detect a draft PR: requested changes too early: how to fix

TL;DR: Check the draft flag before doing anything: if the PR is a draft, post informational comments only (or skip entirely) and never submit a formal verdict. Run the full review automatically when the PR is marked ready. Requesting changes on a draft is noise - the author already knows it is unfinished.

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.