fix(skills): flip PR to ready before waiting on CodeRabbit to avoid a draft deadlock

CodeRabbit never reviews a draft PR. The pull-request skill's monitor loop
could enter (or continue) the CodeRabbit/threads wait while the PR was still
draft, deadlocking silently — observed 2026-07-16: a converging PR sat in
draft with CI green and the CodeRabbit check pending indefinitely, until
manually un-drafted.

- SKILL.md §5: emphasize the ordering invariant — `gh pr ready` MUST run as
  soon as draft CI is green, before section 6 starts waiting on any review
  signal.
- SKILL.md §6 / monitor-loop.md: add a belt-and-braces draft guard at the top
  of every poll pass — if `isDraft: true` and CI is green, flip to ready
  immediately. Covers a loop started before the flip, or a rebase/force-push
  that reverted the PR back to draft.

Closes #3956

Claude-Session: https://claude.ai/code/session_01WfNC8bt1TgL4AsiYgCEGup

Author: PierreBrisorgueil

.claude/skills/pull-request/SKILL.md

@@ -97,13 +97,15 @@ PR title must follow `type(scope): description` (conventional commits). Link the
 - Checkbox sections (Validation, Guardrails): check each box that applies (`- [x]`), leave unchecked only what genuinely does not apply
 - Follow any instructions in the template (e.g. "Delete this section if not applicable")
 
-Once **draft CI passes** and the PR is ready for human review, convert to ready:
+**Ordering invariant — as soon as draft CI is green, flip to ready before doing anything else:**
 
 ```bash
 gh pr ready <number>
 ```
 
-> Some bots (e.g. CodeRabbit) trigger on ready, not on CI completion. After converting, do a **preliminary review pass** before entering the main loop:
+CodeRabbit (and some other review bots) never review a draft PR — they trigger on ready, not on CI completion. Entering or continuing the CodeRabbit/threads wait while the PR is still draft is a guaranteed silent deadlock (observed 2026-07-16: a converging PR sat in draft, CI green, CodeRabbit check pending indefinitely, until manually un-drafted). `gh pr ready` MUST run before section 6 starts waiting on any review signal — never after.
+
+> After converting, do a **preliminary review pass** before entering the main loop:
 >
 > ```bash
 > sleep 180
@@ -126,6 +128,10 @@ PR=<number>
 ```
 
 Per pass:
+0. Draft guard — if `isDraft: true` AND CI green, `gh pr ready` immediately,
+   then continue the pass. CodeRabbit never reviews a draft; this catches a
+   loop that started before the flip, or a rebase/force-push that reverted
+   the PR to draft.
 1. Wait CI → fix + /verify + commit + push if red, else continue
 2. Check mergeable — `CONFLICTING` stops, `UNKNOWN` retries
 3. Grace `sleep 180` + adaptive recheck of pending review checks

.claude/skills/pull-request/references/monitor-loop.md

@@ -19,6 +19,7 @@ After `gh pr ready`, run this loop yourself — do not wait for the user.
 consecutive_zero = 0
 
 REPEAT:
+  0. Draft guard                        → if PR is still draft AND CI is green, flip to ready now (see 6-guard)
   1. Wait for CI                        → sleep 30 then gh pr checks $PR --watch
   2. If CI fails                        → fix, /verify, commit, push, consecutive_zero=0, GOTO 1
   2b. Check mergeable status            → STATUS=$(gh pr view $PR --json mergeable --jq .mergeable)
@@ -34,6 +35,25 @@ REPEAT:
                                            else GOTO 3
 ```
 
+## 6-guard. Draft ordering guard (belt-and-braces)
+
+CodeRabbit never reviews a draft PR. Section 5 already flips the PR to ready
+before this loop starts, but run this check at the top of **every** pass
+anyway — it covers a loop entered before that flip, or a rebase/force-push
+that reverted the PR back to draft:
+
+```bash
+STATUS=$(gh pr view "$PR" --json isDraft,statusCheckRollup)
+IS_DRAFT=$(echo "$STATUS" | jq -r '.isDraft')
+CI_GREEN=$(echo "$STATUS" | jq -r '[.statusCheckRollup[] | (.conclusion // .state)] | all(. == "SUCCESS")')
+
+if [ "$IS_DRAFT" = "true" ] && [ "$CI_GREEN" = "true" ]; then
+  gh pr ready "$PR"
+fi
+```
+
+If still draft with CI red, do nothing — wait for CI to go green first (step 1), then this check flips it on the next pass.
+
 ## 6a. Wait for CI
 
 After any push, wait 30s then watch: