claude-dev-env 1.37.0 → 1.38.0

package/skills/pr-converge/reference/convergence-gates.md

@@ -11,32 +11,36 @@ Fetch latest Copilot reviewer (`copilot-pull-request-reviewer[bot]`) review
 plus inline comments anchored to most recent Copilot review on
 `current_head`:
 
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/fetch_copilot_reviews.py" \
---owner <OWNER> --repo <REPO> --number <NUMBER>
+```
+pull_request_read(owner=OWNER, repo=REPO, pullNumber=NUMBER, method="get_reviews")
+  → filter `.user.login` for copilot (case-insensitive substring "copilot")
+  → sort by `.submitted_at` descending
 
-python "${CLAUDE_SKILL_DIR}/scripts/fetch_copilot_inline_comments.py" \
---owner <OWNER> --repo <REPO> --number <NUMBER> --commit "$current_head"
+pull_request_read(owner=OWNER, repo=REPO, pullNumber=NUMBER, method="get_review_comments")
+  → filter threads where `is_outdated == false` AND any comment has `.author` matching Copilot (case-insensitive substring "copilot")
 ```
 
 Decide (four branches; match first whose predicate holds):
 
 - **`classification == "dirty"` with non-empty inline comments matching
   `pull_request_review_id`:** Fix protocol input (same shape as bugbot
-  dirty). Apply Fix protocol on every inline finding (TDD test →
-  production fix → push → reply inline on each thread), reset
-  `bugbot_clean_at = null` AND `copilot_clean_at = null`, `phase = BUGBOT`,
-  Step 3 on new HEAD, schedule next wakeup, return. Full
-  back-to-back-clean cycle plus all four gates must hold again on new HEAD.
+  dirty). Spawn Agent (subagent_type: clean-coder) to implement → push → reply inline on each thread via
+  `add_reply_to_pull_request_comment` MCP → Step 3 in same tick (see
+  [Single-PR fix workflow](fix-protocol.md#single-pr-fix-workflow) for
+  full contract).
+  Reset `bugbot_clean_at = null` AND `copilot_clean_at = null`, `phase =
+  BUGBOT`, schedule next wakeup, return. Full back-to-back-clean cycle
+  plus all four gates must hold again on new HEAD.
 - **`classification == "dirty"` with empty inline comments matching
   `pull_request_review_id`:** Copilot posted findings only in review body
   (`CHANGES_REQUESTED` or `COMMENTED` with non-empty body, no inline
-  threads). Parse body for actionable findings, apply Fix protocol using
-  body excerpts (TDD test → production fix → push). Post top-level review
-  reply acknowledging fixes and citing new HEAD SHA. Reset
-  `bugbot_clean_at = null` AND `copilot_clean_at = null`, `phase =
-  BUGBOT`, Step 3 on new HEAD, schedule next wakeup, return. Convergence
-  requires full back-to-back-clean on new HEAD.
+  threads). Parse body for actionable findings. Spawn Agent (subagent_type: clean-coder) to implement → push → post
+  top-level review reply using `pull_request_review_write(method="create", event="COMMENT", body)` citing new HEAD SHA → Step 3 in same tick.
+  Reset
+  `bugbot_clean_at = null` AND
+  `copilot_clean_at = null`, `phase = BUGBOT`, Step 3 on new HEAD,
+  schedule next wakeup, return. Convergence requires full
+  back-to-back-clean on new HEAD.
 - **`classification == "clean"` (state `APPROVED`):** Set
   `copilot_clean_at = current_head`. Continue to gate (b).
 - **No Copilot review on `current_head` yet:** Skip — gate (c) issues
@@ -46,16 +50,16 @@ Decide (four branches; match first whose predicate holds):
 
 Resolve PR's mergeability state:
 
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/check_pr_mergeability.py" \
---owner <OWNER> --repo <REPO> --number <NUMBER>
+```
+pull_request_read(owner=OWNER, repo=REPO, pullNumber=NUMBER, method="get")
+  → `.mergeable_state`, `.mergeable`
 ```
 
-Persist `mergeStateStatus` into `merge_state_status`. Decide:
+Persist `mergeable_state` into `merge_state_status`. Decide:
 
-- **`mergeStateStatus == "CLEAN"` AND `mergeable == "MERGEABLE"`:**
+- **`mergeable_state == "clean"` AND `mergeable == true`:**
   Continue to gate (c).
-- **`mergeStateStatus == "DIRTY"` (or `mergeable == "CONFLICTING"`):** Do
+- **`mergeable_state == "dirty"` (or `mergeable == false`):** Do
   **not** mark ready. Invoke **`rebase`** skill
   ([`../../rebase/SKILL.md`](../../rebase/SKILL.md)) Phase 1–4 against PR's
   base ref. After rebase + force-with-lease push, new HEAD invalidates
@@ -63,39 +67,39 @@ Persist `mergeStateStatus` into `merge_state_status`. Decide:
   `copilot_clean_at = null`, `merge_state_status = null`, `phase = BUGBOT`,
   Step 3 on new HEAD, schedule next wakeup, return. Loop re-runs from
   scratch on new HEAD.
-- **`mergeStateStatus` is `BLOCKED`, `BEHIND`, or `UNKNOWN` for
+- **`mergeable_state` is `"blocked"`, `"behind"`, or `"unknown"` for
   non-conflict reasons** (required checks pending, branch behind base
   without conflicts GitHub cannot auto-resolve): **hard blocker** per
   [stop-conditions.md](stop-conditions.md) — do not invent a fix. Report specific
-  `mergeStateStatus`, omit loop pacing.
+  `mergeable_state`, omit loop pacing.
 
 ## (c) Post-convergence Copilot review request
 
 Once gates (a) and (b) both pass (Copilot clean at `current_head` *or* no
-Copilot review yet, AND `mergeStateStatus == "CLEAN"`), request Copilot
+Copilot review yet, AND `mergeable_state == "clean"`), request Copilot
 review:
 
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/request_copilot_review.py" \
---owner <OWNER> --repo <REPO> --number <NUMBER>
+```
+request_copilot_review(owner=OWNER, repo=REPO, pullNumber=NUMBER)
 ```
 
+When the `request_copilot_review` MCP tool is unavailable, use `add_issue_comment` as fallback: `add_issue_comment(owner=OWNER, repo=REPO, issueNumber=NUMBER, body="@copilot review")`.
+
 After request, schedule next wakeup and return — next tick checks response.
 
 Next tick with `phase == BUGTEAM` and prior state preserved → re-run gate
 (a) first. Decide:
 
 - **Copilot review `clean` (state `APPROVED`):** Set `copilot_clean_at =
-  current_head`. Mark PR ready (`mark_pr_ready.py`), report convergence
+  current_head`. Mark PR ready (`update_pull_request(pullNumber=NUMBER, owner=OWNER, repo=REPO, draft=false)`), report convergence
   per §(d), terminate per [stop-conditions.md](stop-conditions.md) / Convergence.
 - **Copilot review `dirty`:** Treat identically to gate (a) dirty path —
-  fix in same PR, restart convergence from BUGBOT. Apply Fix protocol on
-  every confirmed Copilot finding (TDD test → production fix → push →
-  reply inline on each thread; for body-only findings with empty inline,
-  parse body excerpts and post top-level review reply citing new HEAD).
-  Reset `bugbot_clean_at = null` AND `copilot_clean_at = null`, `phase =
-  BUGBOT`, Step 3 on new HEAD, schedule next wakeup, return. Full
-  back-to-back-clean cycle plus all four gates must hold again on new HEAD.
+  spawn Agent (subagent_type: clean-coder) to fix in same PR, restart convergence from BUGBOT. Follow [Single-PR fix workflow](fix-protocol.md#single-pr-fix-workflow).
+  For body-only findings with empty inline, spawn Agent (subagent_type: clean-coder) to implement, then post top-level review reply
+  citing new HEAD SHA. Reset `bugbot_clean_at = null` AND
+  `copilot_clean_at = null`, `phase = BUGBOT`, schedule next wakeup,
+  return. Full back-to-back-clean cycle plus all four gates must hold
+  again on new HEAD.
 - **No Copilot review at `current_head` yet (still propagating):**
   Schedule one more wakeup (270s), re-check next tick. After three consecutive empty waits,
   escalate as hard blocker per [stop-conditions.md](stop-conditions.md).
@@ -103,16 +107,14 @@ Next tick with `phase == BUGTEAM` and prior state preserved → re-run gate
 ## (d) Mark ready and report
 
 Only when all four gates pass — bugbot CLEAN ∧ bugteam CLEAN ∧
-`mergeStateStatus == "CLEAN"` ∧ Copilot CLEAN at HEAD — run:
+`mergeable_state == "clean"` ∧ Copilot CLEAN at HEAD — run:
 
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/mark_pr_ready.py" \
---owner <OWNER> --repo <REPO> --number <NUMBER>
-```
+Use the `update_pull_request` MCP tool:
+
+    update_pull_request(pullNumber=NUMBER, owner=OWNER, repo=REPO, draft=false)
 
-When scripts unavailable, `gh pr ready <NUMBER> --repo <OWNER>/<REPO>` is
-equivalent. With `state.json`, append convergence row to
+With `state.json`, append convergence row to
 `<TMPDIR>/pr-converge-<session_id>/converged.log` per `multi-pr-orchestration.md` §Memory; else skip.
 Report: `PR #<NUMBER> converged: bugbot CLEAN at <SHA>, bugteam CLEAN at
-<SHA>, mergeStateStatus CLEAN, copilot CLEAN at <SHA>; marked ready for
+<SHA>, mergeable_state CLEAN, copilot CLEAN at <SHA>; marked ready for
 review`. **Omit loop pacing** per **Convergence** of active pacing workflow.

package/skills/pr-converge/reference/examples.md

@@ -25,7 +25,7 @@ convergence or stop]
 </example>
 
 <example> BUGTEAM phase, bugteam reports convergence and `bugbot_clean_at
-== current_head`. Claude: [runs `gh pr ready <NUMBER>`, reports "PR
+== current_head`. Claude: [runs `update_pull_request(pullNumber=NUMBER, owner=OWNER, repo=REPO, draft=false)`, reports "PR
 converged: bugbot CLEAN at <SHA>, bugteam CLEAN at <SHA>; marked ready for
 review", applies **Convergence** from `workflows/schedule-wakeup-loop.md`]
 </example>
@@ -58,11 +58,11 @@ HEAD, schedules next wakeup]
 </example>
 
 <example> Back-to-back clean, mergeability CLEAN, no Copilot review on
-`current_head`. Claude requests Copilot via `request_copilot_review.py`,
+`current_head`. Claude requests Copilot via `add_issue_comment(owner=OWNER, repo=REPO, issueNumber=NUMBER, body="@copilot review")`,
 waits one tick. Next tick: Copilot review `state: APPROVED`. Claude: [sets
-`copilot_clean_at = current_head`; runs `mark_pr_ready.py`; reports "PR
+`copilot_clean_at = current_head`; runs `update_pull_request(pullNumber=NUMBER, owner=OWNER, repo=REPO, draft=false)`; reports "PR
 #N converged: bugbot CLEAN at <SHA>, bugteam CLEAN at <SHA>,
-mergeStateStatus CLEAN, copilot CLEAN; marked ready for review"]
+mergeable_state clean, copilot CLEAN; marked ready for review"]
 </example>
 
 <example> Back-to-back clean, mergeability CLEAN, post-convergence Copilot

package/skills/pr-converge/reference/fix-protocol.md

@@ -8,8 +8,8 @@ per [ground-rules.md](ground-rules.md).
 **Multi-PR (`state.json`) teammate obligations** (plus TDD, commit, push):
 
 - Replies inline on each addressed finding via
-  `reply_to_inline_comment.py` (what changed + commit identifier),
-  matching §Audit result → fix worker step 4 — **before** writing
+  `add_reply_to_pull_request_comment(owner, repo, pullNumber, commentId, body)`
+  (what changed + commit identifier), matching §Audit result → fix worker step 4 — **before** writing
   `state.json` and going idle.
 - Writes `last_action: "fix_pushed"`, `current_head: <new SHA>`,
   `bugbot_clean_at: null`, `phase: "BUGBOT"`, `status: "awaiting_bugbot"`,
@@ -20,6 +20,8 @@ per [ground-rules.md](ground-rules.md).
 Orchestrator does not reply inline, trigger bugbot, or read repo source
 files during fix phase in multi-PR mode.
 
+### Single-PR fix workflow
+
 **Single-PR (no `state.json`) — same gates, main session executor:**
 
 - Read each referenced file:line.
@@ -38,12 +40,10 @@ git push origin <BRANCH>
   ```
 **Pre-push gate:** honor hooks; full-stop on bypass. Capture new HEAD
 only after both gates pass; set `current_head`, `bugbot_clean_at = null`.
-- Reply inline on each addressed comment thread using `--body-file` (per
-  gh-body-file rule):
-  ```bash
-python "${CLAUDE_SKILL_DIR}/scripts/reply_to_inline_comment.py" \
---owner <OWNER> --repo <REPO> --number <NUMBER> \
---comment-id <COMMENT_ID> --body-file <path/to/reply.md>
+- Reply inline on each addressed comment thread using the `add_reply_to_pull_request_comment` MCP tool:
+
+  ```
+  add_reply_to_pull_request_comment(owner=OWNER, repo=REPO, pullNumber=NUMBER, commentId=COMMENT_ID, body="Fixed in <SHA> — <what changed>")
   ```
 - **After pushing a fix, always run Step 3 (`bugbot run`) in the same
   tick** regardless of phase. New commit **resets full convergence cycle**:

package/skills/pr-converge/reference/multi-pr-orchestration.md

@@ -25,7 +25,7 @@ Create once at session start. Each teammate writes result before going idle.
 
 **Directory lifecycle:** Keep `<TMPDIR>/pr-converge-<session_id>/` until every
 `prs[...]` is `converged` or `blocked`, or user stops. Then delete folder.
-`mark_pr_ready.py` / `gh pr ready` on GitHub is canonical record. See
+`update_pull_request(draft=false)` on GitHub is canonical record. See
 [Memory](#memory) for optional append-only log.
 
 **Barebones schema:**
@@ -107,7 +107,7 @@ Bugfind subagent completes (findings or clean):
   2. Applies TDD fixes (test first, then production).
   3. Commits, pushes one fix commit.
   4. Replies inline on each addressed finding via
-     `reply_to_inline_comment.py`.
+     `add_reply_to_pull_request_comment(owner, repo, pullNumber, commentId, body)`.
   5. Writes `state.json` (per §Concurrency): `last_action: "fix_pushed"`,
      `current_head: <new SHA>`, `bugbot_clean_at: null`, `phase:
      "BUGBOT"`, `status: "awaiting_bugbot"`, `last_updated` ISO-8601 UTC.
@@ -116,7 +116,7 @@ Bugfind subagent completes (findings or clean):
 - **PRs with zero findings:** spawn one `general-purpose` subagent per PR via
   `Agent(subagent_type="general-purpose", run_in_background=true)`. Subagent:
   1. `bugbot_clean_at == current_head` (back-to-back clean): run
-     `mark_pr_ready.py`, append convergence row to
+     `update_pull_request(pullNumber=PR_NUMBER, owner=OWNER, repo=REPO, draft=false)`, append convergence row to
      `<TMPDIR>/pr-converge-<session_id>/converged.log` per §Memory, then
      write `state.json` (per §Concurrency) with `status: "converged"`,
      `last_action: "converged"` (or `marked_ready`), `phase: "BUGBOT"`,
@@ -125,7 +125,7 @@ Bugfind subagent completes (findings or clean):
      duplicate work.
   2. Else: update `state.json` (per §Concurrency) with `last_action:
      "audit_clean"`, `status: "awaiting_bugbot"`, `phase: "BUGBOT"`, then
-     trigger bugbot via `trigger_bugbot.py`.
+     trigger bugbot via `add_issue_comment(owner, repo, issueNumber, body="bugbot run")`.
   3. Goes idle.
 
 ### Fix result → general-purpose per PR
@@ -135,11 +135,11 @@ When bugfix (clean-coder) subagent completes after push:
 - Spawn one `general-purpose` subagent per PR via
   `Agent(subagent_type="general-purpose", run_in_background=true)`. Subagent:
   1. Reads `state.json` for its PR.
-  2. Triggers bugbot via `trigger_bugbot.py`.
-  3. Polls `fetch_bugbot_reviews.py` every 60s (up to 10 polls) until review
-     anchored to `current_head` appears.
+  2. Triggers bugbot via `add_issue_comment(owner, repo, issueNumber, body="bugbot run")`.
+  3. Polls `pull_request_read(method="get_reviews")` every 60s (up to 10 polls) until review
+     anchored to `current_head` appears with `commit_id == current_head`.
   4. **Poll / classify loop** (repeat from 4a whenever 4c retries):
-     - **4a.** Fetch inline comments via `fetch_bugbot_inline_comments.py`.
+     - **4a.** Fetch inline comments via `pull_request_read(method="get_review_comments")` filtered by review ID and `commit_id == current_head`.
      - **4b.** Classify — three outcomes (same as `SKILL.md` Step 2 BUGBOT):
        - **`clean`:** review body clean, zero unaddressed inline findings.
        - **`dirty`:** ≥1 unaddressed inline finding for `current_head`
@@ -186,7 +186,7 @@ When bugfix (clean-coder) subagent completes after push:
 Run directory `<TMPDIR>/pr-converge-<session_id>/` holds `state.json` and
 optional `converged.log`. Keep from first create until every PR under `prs`
 is `converged` or `blocked`, or **Stop conditions** ends loop. Safe to
-delete folder after — `mark_pr_ready.py` / `gh pr ready` on GitHub is
+delete folder after — `update_pull_request(draft=false)` on GitHub is
 canonical record. Folder skill, not a plugin package; do **not** rely
 on `${CLAUDE_PLUGIN_DATA}`. OS/disk cleanup of `<TMPDIR>` (reboot, policy)
 can remove files mid-run — environmental risk.
@@ -196,7 +196,7 @@ can remove files mid-run — environmental risk.
 - **Path:** sibling of `state.json`.
 - **Format:** one tab-separated row per converged PR: ISO8601 UTC,
   owner/repo#number, bugbot SHA, bugteam SHA.
-- **Append site:** agent running `mark_pr_ready.py`. Append **before**
+- **Append site:** agent running `update_pull_request(pullNumber=PR_NUMBER, owner=OWNER, repo=REPO, draft=false)`. Append **before**
   locked `state.json` publish so log row survives failed merge.
 - **Never read inside loop.** User / follow-up tooling only.
 

package/skills/pr-converge/reference/per-tick.md

@@ -37,10 +37,12 @@ state line when **no** `state.json` (single-PR only). With `state.json`, do
 **not** increment here — orchestrator's per-tick bump is sole increment.
 
 ```bash
-python "${CLAUDE_SKILL_DIR}/scripts/view_pr_context.py"
+pull_request_read(owner=OWNER, repo=REPO, pullNumber=NUMBER, method="get") → `.head.sha`
 ```
 
-Capture `number`, `headRefOid` (= `current_head`), owner/repo, branch.
+If owner/repo/number are not yet known, extract them from the PR URL.
+
+Capture `number`, `head.sha` (= `current_head`), owner/repo, branch.
 
 ## Step 2: Branch on `phase`
 
@@ -48,15 +50,14 @@ Capture `number`, `headRefOid` (= `current_head`), owner/repo, branch.
 
 a. Fetch Cursor Bugbot reviews newest-first, walk back until first clean:
 
-   ```bash
-python "${CLAUDE_SKILL_DIR}/scripts/fetch_bugbot_reviews.py" \
---owner <OWNER> --repo <REPO> --number <NUMBER>
+   ```
+pull_request_read(owner=OWNER, repo=REPO, pullNumber=NUMBER, method="get_reviews")
+   → filter `.user.login` for cursor/bugbot, sort by `.submitted_at` descending
    ```
 
-Track dirty entries in a temp file; Fix protocol reads it back later
-this tick.
+   Track dirty entries (review body contains `BUGBOT_REVIEW` markers with finding content); Fix protocol reads them back later this tick.
 
-Iterate from index 0 (most recent) toward older:
+   Iterate from index 0 (most recent) toward older:
 
    - Dirty review → append JSON line with `{review_id, commit_id,
      submitted_at, body}`.
@@ -69,14 +70,12 @@ review for decisions below. When branch routes to **Fix protocol**, address
 **every** entry in `$dirty_reviews_path` — not just index 0.
 
 b. Fetch unaddressed inline comments from `cursor[bot]` for newest Bugbot
-review on `current_head`. Script uses same `--paginate --slurp` pattern,
-resolves review via reviews list, returns only inline rows whose
-`pull_request_review_id` matches that review (excludes stale threads from
-older reviews on same SHA).
+review on `current_head`:
 
-   ```bash
-python "${CLAUDE_SKILL_DIR}/scripts/fetch_bugbot_inline_comments.py" \
---owner <OWNER> --repo <REPO> --number <NUMBER> --commit "$current_head"
+   ```
+pull_request_read(owner=OWNER, repo=REPO, pullNumber=NUMBER, method="get_review_comments")
+   → filter threads where `is_outdated == false` AND `is_resolved == false`
+     AND any comment has `.author` matching cursor/bugbot (case-insensitive substring)
    ```
 
 c. Decide (four branches; match first whose predicate holds):
@@ -93,9 +92,11 @@ c. Decide (four branches; match first whose predicate holds):
      `state.json`: clean-coder teammate pushes, replies inline, writes
      `state.json`, goes idle; Step 3 on new HEAD runs after via
      orchestrator-spawned follow-up agent (§Fix result → general-purpose).
-     No `state.json` (single-PR): implement → push → inline replies
-     → Step 3 in same tick per loaded pacing workflow. Schedule next
-     wakeup, return.
+     No `state.json` (single-PR): spawn Agent (subagent_type: clean-coder) to implement → push → reply inline on each thread
+     via `add_reply_to_pull_request_comment` MCP → Step 3 in same tick (see
+     [Single-PR fix workflow](fix-protocol.md#single-pr-fix-workflow) for
+     full contract).
+     Schedule next wakeup, return.
    - **`commit_id == current_head` AND review body findings AND inline
      API zero matching for `current_head`:** Transient API lag. Increment
      `inline_lag_streak`. `>= 3` → hard blocker; report and terminate with
@@ -121,8 +122,7 @@ Skill({skill: "bugteam", args:
 b. **Re-resolve current HEAD** — bugteam may have pushed commits during
 its run. `current_head` from Step 1 is potentially stale:
    ```bash
-new_head=$(python "${CLAUDE_SKILL_DIR}/scripts/resolve_pr_head.py" \
---owner <OWNER> --repo <REPO> --number <NUMBER>)
+pull_request_read(owner=OWNER, repo=REPO, pullNumber=NUMBER, method="get") → `.head.sha`
    ```
 If `new_head != current_head`, set `current_head = new_head` AND
 `bugbot_clean_at = null`. New commits invalidate bugbot's prior clean.
@@ -142,26 +142,14 @@ never falsely terminates:
      **omit loop pacing** per **Convergence** of active pacing workflow.
    - **Convergence BUT `bugbot_clean_at != current_head` (no push):**
      `phase = BUGBOT`, schedule next wakeup, return.
-   - **Findings without committed fixes:** apply **[fix-protocol.md](fix-protocol.md)**; Step 3
-     on new HEAD runs after fix handoff per `multi-pr-orchestration.md` or in-tick for
-     single-PR. `phase = BUGBOT`, schedule next wakeup, return.
+   - **Findings without committed fixes:** spawn Agent (subagent_type: clean-coder) to implement fixes and push, then reply inline via `add_reply_to_pull_request_comment` MCP, following [Single-PR fix workflow](fix-protocol.md#single-pr-fix-workflow).
+     `phase = BUGBOT`, schedule next wakeup, return.
 
 ## Step 3: Re-trigger bugbot
 
-Prefer portable script (temp body file, `gh pr comment --body-file`):
+Use the `add_issue_comment` MCP tool:
 
-```bash
-python "${CLAUDE_SKILL_DIR}/scripts/trigger_bugbot.py" \
---owner <OWNER> --repo <REPO> --number <NUMBER>
-```
-
-**Bundled PowerShell alternative** (same gh-body-file contract):
-
-```bash
-POST_BUGBOT_RUN="$HOME/.claude/skills/pr-converge/scripts/post-bugbot-run.ps1"
-pwsh -NoProfile -ExecutionPolicy Bypass -File "$POST_BUGBOT_RUN" \
-"https://github.com/<OWNER>/<REPO>/pull/<NUMBER>"
-```
+    add_issue_comment(owner="OWNER", repo="REPO", issueNumber=NUMBER, body="bugbot run")
 
 `bugbot run` is empirically the only re-trigger Cursor Bugbot recognizes;
 alternative phrasings (`re-review`, `bugbot please`, etc.) silently no-op.

package/skills/pr-converge/reference/stop-conditions.md

@@ -1,9 +1,9 @@
 # Stop conditions
 
 - **Convergence** (back-to-back clean ∧ no outstanding Copilot findings
-  on `current_head` ∧ `mergeStateStatus == "CLEAN"` with `mergeable ==
-  "MERGEABLE"` ∧ post-convergence Copilot request returned `clean` at
-  `current_head`): prefer `mark_pr_ready.py`; else `gh pr ready`. With
+  on `current_head` ∧ `mergeable_state == "clean"` with `mergeable ==
+  true` ∧ post-convergence Copilot request returned `clean` at
+  `current_head`): use `update_pull_request(pullNumber=NUMBER, owner=OWNER, repo=REPO, draft=false)`. With
   `state.json`, append convergence row to
   `<TMPDIR>/pr-converge-<session_id>/converged.log` per `multi-pr-orchestration.md` §Memory; else
   skip. Report [convergence-gates.md](convergence-gates.md) (d) summary, then **omit loop pacing**
@@ -16,11 +16,11 @@
   `current_head` after three consecutive wakeups. Report specific
   blocker and diagnosis, **omit loop pacing** per
   `../workflows/schedule-wakeup-loop.md`.
-- **Hard blocker (`mergeStateStatus` non-CLEAN non-DIRTY):**
-  `mergeStateStatus` is `BLOCKED`, `UNKNOWN`, or `BEHIND` (required
+- **Hard blocker (`mergeable_state` non-clean non-dirty):**
+  `mergeable_state` is `"blocked"`, `"unknown"`, or `"behind"` (required
   checks pending, branch behind base without textual conflicts, or
   GitHub indeterminate). Investigate before retrying; `rebase` skill
-  handles `DIRTY` (textual conflicts) only. Report specific
-  `mergeStateStatus`, **omit loop pacing**.
+  handles `"dirty"` (textual conflicts) only. Report specific
+  `mergeable_state`, **omit loop pacing**.
 - **User stops loop:** "stop the converge loop" → **omit loop pacing**
   per `../workflows/schedule-wakeup-loop.md`.