claude-dev-env 1.92.0 → 1.93.0

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

@@ -1,9 +1,10 @@
 # Convergence gates
 
-Run **only** when Step 2 BUGTEAM reports `convergence (zero findings)` AND
-`bugbot_clean_at == current_head` AND no push during bugteam tick. Gates run
-in order; first failure determines next-tick behavior. Mark PR ready only
-when all six pass.
+Run **only** after the terminal Bugbot gate confirms the HEAD
+(`bugbot_clean_at == current_head` OR `bugbot_down`), which runs just before
+these gates once Step 2 BUGTEAM reports `convergence (zero findings)` with no
+push during the bugteam tick. Gates run in order; first failure determines
+next-tick behavior. Mark PR ready only when all six pass.
 
 **Mandatory evidence rule:** Every gate that fetches data MUST produce a
 summary of its findings before proceeding to the next gate. Gate (f) MUST
@@ -36,19 +37,20 @@ 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 the `pr-fix-protocol` skill
-  (`../../pr-fix-protocol/SKILL.md`) → Step 3 in same tick.
-  Reset `bugbot_clean_at = null` AND `copilot_clean_at = null`, `phase =
-  BUGBOT`, schedule next wakeup, return. Full back-to-back-clean cycle
-  plus all six gates must hold again on new HEAD.
+  (`../../pr-fix-protocol/SKILL.md`) in the same tick.
+  Reset `bugbot_clean_at = null`, `code_review_clean_at = null`, AND
+  `copilot_clean_at = null`, `phase = CODE_REVIEW`, schedule next wakeup,
+  return. Full back-to-back-clean cycle plus all six 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 the
   `pr-fix-protocol` skill (`../../pr-fix-protocol/SKILL.md`), whose reply
   step for body-only findings posts a top-level review reply citing the
-  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,
+  new HEAD SHA. Reset
+  `bugbot_clean_at = null`, `code_review_clean_at = null`, AND
+  `copilot_clean_at = null`, `phase = CODE_REVIEW`,
   schedule next wakeup, return. Convergence needs full
   back-to-back-clean on new HEAD.
 - **`classification == "clean"` (state `APPROVED`):** Set
@@ -78,14 +80,14 @@ Decide (four branches; match first whose predicate holds):
   `pull_request_review_id`:** Treat identically to gate (a) dirty+inline
   path — apply the `pr-fix-protocol` skill
   (`../../pr-fix-protocol/SKILL.md`). Reset
-  `bugbot_clean_at = null` AND `copilot_clean_at = null`, `phase = BUGBOT`,
+  `bugbot_clean_at = null` AND `copilot_clean_at = null`, `phase = CODE_REVIEW`,
   schedule next wakeup, return.
 - **`classification == "dirty"` with empty inline comments matching
   `pull_request_review_id`:** Claude posted findings only in review body
   (`CHANGES_REQUESTED` or `COMMENTED` with non-empty body, no inline
   threads). Treat identically to gate (a) dirty+body path — apply the
   `pr-fix-protocol` skill (`../../pr-fix-protocol/SKILL.md`). Reset
-  `bugbot_clean_at = null` AND `copilot_clean_at = null`, `phase = BUGBOT`,
+  `bugbot_clean_at = null` AND `copilot_clean_at = null`, `phase = CODE_REVIEW`,
   schedule next wakeup, return.
 - **`classification == "clean"` (state `APPROVED`):** Record evidence:
   "Claude APPROVED at <SHA>". Continue to gate (c).
@@ -111,8 +113,9 @@ Persist `mergeable_state` into `merge_state_status`. Decide:
   ([`../../rebase/SKILL.md`](../../rebase/SKILL.md)) Phase 1–4 against PR's
   base ref. After rebase + force-with-lease push, new HEAD invalidates
   every prior clean state — reset `bugbot_clean_at = null`,
-  `copilot_clean_at = null`, `merge_state_status = null`, `phase = BUGBOT`,
-  Step 3 on new HEAD, schedule next wakeup, return. Loop re-runs from
+  `code_review_clean_at = null`, `copilot_clean_at = null`,
+  `merge_state_status = null`, `phase = CODE_REVIEW`,
+  schedule next wakeup, return. Loop re-runs from
   scratch on new HEAD.
 - **`mergeable_state` is `"blocked"`, `"behind"`, `"unknown"`, or `"unstable"` for
   non-conflict reasons** (required checks pending/failing for "unstable",
@@ -157,7 +160,7 @@ against `current_head`. Decide:
   - `state: CHANGES_REQUESTED` or `COMMENTED` with non-empty body → dirty.
     Treat identically to gate (a) dirty path — spawn Agent (subagent_type: clean-coder) to fix,
     reset `bugbot_clean_at = null` AND `copilot_clean_at = null`,
-    `phase = BUGBOT`, schedule next wakeup, return.
+    `phase = CODE_REVIEW`, schedule next wakeup, return.
 - **No Copilot review at `current_head` yet:** Record evidence: "No Copilot
   review at <SHA> (wait count: <N>)". Increment `copilot_wait_count`
   (init 0 on first COPILOT_WAIT entry; reset to 0 on every push and on every
@@ -187,7 +190,7 @@ Decide:
   `pr-fix-protocol` skill's unresolved-thread sweep
   (`../../pr-fix-protocol/SKILL.md`). Push if any code changed → reset
   `bugbot_clean_at = null` AND `copilot_clean_at = null`,
-  `phase = BUGBOT`, schedule next wakeup, return. If only resolutions
+  `phase = CODE_REVIEW`, schedule next wakeup, return. If only resolutions
   (no code changes), re-check this gate without resetting.
 
 ## (f) Mark ready and report

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

@@ -4,40 +4,60 @@ Worked examples for `pr-converge`. Read on demand when a tick's
 classification is novel or ambiguous against the in-skill rules. Cross-refs
 into `SKILL.md` use `§Section name` notation.
 
-<example> User: `/pr-converge` Claude: [PR context + one tick bugbot/bugteam
-work; Step 4 per `workflows/schedule-wakeup-loop.md` — default loop until
-convergence or stop]
+<example> User: `/pr-converge` Claude: [PR context + one tick of internal
+code-review/bugteam work, then the terminal Bugbot and Copilot gates; Step 4
+per `workflows/schedule-wakeup-loop.md` — default loop until convergence or
+stop]
 </example>
 
-<example> BUGBOT tick, latest bugbot review against older commit. Claude:
-[posts `bugbot run`, sets `bugbot_clean_at = null`, Step 4 per
-`workflows/schedule-wakeup-loop.md` (e.g. 270s wakeup), returns]
+<example> CODE_REVIEW tick (the entry phase), the static sweep raises a
+`ruff` failure on a changed file. Claude: [fixes it TDD, one commit, pushes,
+resets `bugbot_clean_at = null` and `code_review_clean_at = null`, stays
+`phase = CODE_REVIEW`, Step 4 at 270s, re-runs the sweep next tick]
 </example>
 
-<example> BUGBOT tick, bugbot has 2 unaddressed findings on HEAD. Claude:
-[TDD-fixes both, one commit, pushes, replies inline on both threads, posts
-`bugbot run`, Step 4 at 270s, returns]
+<example> CODE_REVIEW tick, static sweep clean, `/code-review high --fix`
+applies fixes to the working tree. Claude: [commits the applied fixes in one
+commit, pushes, resets `bugbot_clean_at = null` and `code_review_clean_at =
+null`, stays `phase = CODE_REVIEW`, Step 4 at 270s, returns]
 </example>
 
-<example> BUGBOT tick, bugbot clean against HEAD. Claude: [sets
-`bugbot_clean_at = HEAD`, `phase = CODE_REVIEW`, runs `/code-review --fix`
-in same tick]
+<example> CODE_REVIEW tick, static sweep clean and `/code-review high --fix`
+clean (no changes applied). Claude: [sets `code_review_clean_at = HEAD`,
+`phase = BUGTEAM`, runs `Skill({skill: "bugteam", ...})` in same tick]
 </example>
 
-<example> CODE_REVIEW tick, `/code-review --fix` applies fixes to the
-working tree. Claude: [commits the applied fixes in one commit, pushes,
-resets `bugbot_clean_at = null` and `code_review_clean_at = null`, posts
-`bugbot run`, `phase = BUGBOT`, Step 4 at 270s, returns]
+<example> BUGTEAM phase, bugteam pushed a fix commit during its run. Claude:
+[re-resolves HEAD, resets `bugbot_clean_at = null` and `code_review_clean_at =
+null`, `phase = CODE_REVIEW`, Step 4 at 270s, re-enters the internal passes on
+the new HEAD]
 </example>
 
-<example> CODE_REVIEW tick, `/code-review --fix` clean (no changes
-applied). Claude: [sets `code_review_clean_at = HEAD`, `phase = BUGTEAM`,
-runs `Skill({skill: "bugteam", ...})` in same tick]
+<example> BUGTEAM phase, bugteam reports convergence with no push. Claude:
+[the internal passes are clean on `current_head`; `phase = BUGBOT` — routes into
+the terminal Bugbot gate in the same tick]
 </example>
 
-<example> BUGTEAM phase, bugteam reports convergence and `bugbot_clean_at
-== current_head` (no push). Claude: [back-to-back clean — necessary, not
-sufficient. Runs `convergence-gates.md` gates in order:
+<example> Terminal BUGBOT gate, Bugbot disabled for the run (the default).
+Claude: [availability gate exits 0, sets `bugbot_down = true`, advances to the
+`convergence-gates.md` gates with the Bugbot gate bypassed — no trigger, no
+wait, no agent]
+</example>
+
+<example> Terminal BUGBOT gate, Bugbot enabled and clean on HEAD. Claude:
+[sets `bugbot_clean_at = HEAD`, advances to the `convergence-gates.md` gates in
+the same tick]
+</example>
+
+<example> Terminal BUGBOT gate, Bugbot has 2 unaddressed findings on HEAD.
+Claude: [TDD-fixes both, one commit, pushes, replies inline on both threads,
+resets `bugbot_clean_at = null` and `code_review_clean_at = null`, `phase =
+CODE_REVIEW`, Step 4 at 270s, re-enters the internal passes on the new HEAD]
+</example>
+
+<example> Convergence gates after the terminal Bugbot gate confirms
+(`bugbot_clean_at == current_head`). Claude: [runs `convergence-gates.md` gates
+in order:
   Gate (a): two calls — `pull_request_read(method="get_reviews")` +
     `pull_request_read(method="get_review_comments")`
     → filter Copilot → APPROVED at `current_head`
@@ -53,7 +73,7 @@ sufficient. Runs `convergence-gates.md` gates in order:
     → schedule next wakeup, return.
     Next tick: re-run gate (a) fetch → Copilot `APPROVED` at `current_head`
     → set `copilot_clean_at = current_head`, record evidence: "Copilot
-    APPROVED at <SHA>", set `phase = BUGTEAM`, re-validate gates (b) and (c).
+    APPROVED at <SHA>", re-validate gates (b) and (c).
   Gate (e): the `pr-fix-protocol` unresolved-thread sweep
     (`../../pr-fix-protocol/SKILL.md`) → zero across PR → record evidence.
   Gate (f): all six gates pass → `update_pull_request(pullNumber=NUMBER,
@@ -64,40 +84,35 @@ mergeable_state clean, copilot CLEAN at <SHA>, claude absent at <SHA>,
 applies **Convergence** from `workflows/schedule-wakeup-loop.md`]
 </example>
 
-<example> BUGTEAM phase, bugteam pushed fix commit during run. Claude:
-[re-resolves HEAD, sets `bugbot_clean_at = null`, posts `bugbot run` in
-same tick, `phase = BUGBOT`, Step 4 at 270s]
-</example>
-
-<example> BUGBOT tick, review body says "found 3 potential issues" against
-HEAD but inline API returns zero matching for `current_head`. Claude:
-[increments `inline_lag_streak` to 1, Step 4 inline-lag rules (90s
-`ScheduleWakeup`), returns]
+<example> CODE_REVIEW tick, review body says "found 3 potential issues"
+against HEAD (a stale prior finding) but the diff is clean. Claude: [the static
+sweep and `/code-review high --fix` both pass, sets `code_review_clean_at =
+HEAD`, `phase = BUGTEAM`]
 </example>
 
-<example> Back-to-back clean reached, but `mergeStateStatus: DIRTY` (base
+<example> Convergence gates reached, but `mergeStateStatus: DIRTY` (base
 advanced, merge conflicts). Claude: [runs §Convergence gate (c); does NOT
 mark ready; invokes `rebase` skill per `../../rebase/SKILL.md` Phase 1–4;
 after force-with-lease push, resets `bugbot_clean_at = null`,
-`copilot_clean_at = null`, `merge_state_status = null`, `phase = BUGBOT`,
-posts `bugbot run` on new HEAD, schedules next wakeup]
+`code_review_clean_at = null`, `copilot_clean_at = null`, `merge_state_status
+= null`, `phase = CODE_REVIEW`, schedules next wakeup]
 </example>
 
-<example> Back-to-back clean, mergeability CLEAN, Copilot review at
+<example> Convergence gates reached, mergeability CLEAN, Copilot review at
 `current_head` `state == "CHANGES_REQUESTED"` with two unaddressed inline
 findings. Claude: [runs §Convergence gates (a); applies Fix protocol (TDD
-test → fix → push → reply inline both threads), resets `bugbot_clean_at`
-and `copilot_clean_at` null, `phase = BUGBOT`, posts `bugbot run` on new
-HEAD, schedules next wakeup]
+test → fix → push → reply inline both threads), resets `bugbot_clean_at`,
+`code_review_clean_at`, and `copilot_clean_at` null, `phase = CODE_REVIEW`,
+schedules next wakeup, re-enters the internal passes on the new HEAD]
 </example>
 
-<example> Back-to-back clean, mergeability CLEAN, no Copilot review on
+<example> Convergence gates reached, mergeability CLEAN, no Copilot review on
 `current_head`. Claude sets `phase = COPILOT_WAIT`, runs gate (d):
 `request_copilot_review(owner=OWNER, repo=REPO, pullNumber=NUMBER)`,
 schedules next wakeup, returns. Next tick:
 Copilot review `state: APPROVED` at `current_head`. Claude: [re-runs
 gate (a) fetch → APPROVED → sets `copilot_clean_at = current_head`,
-records evidence: "Copilot APPROVED at <SHA>", sets `phase = BUGTEAM`;
+records evidence: "Copilot APPROVED at <SHA>";
 re-validates gates (b) Claude absent and (c) mergeability clean,
 records evidence for both; gate (e) — the `pr-fix-protocol`
 unresolved-thread sweep — passes trivially, record evidence:
@@ -108,12 +123,13 @@ at <SHA>, bugteam CLEAN at <SHA>, mergeable_state clean, copilot CLEAN at
 <SHA>, claude absent at <SHA>, 0 unresolved threads across PR; marked ready for review"]
 </example>
 
-<example> Back-to-back clean, mergeability CLEAN, post-convergence Copilot
-review returned `state: CHANGES_REQUESTED` with inline findings on
+<example> Convergence gates reached, mergeability CLEAN, post-convergence
+Copilot review returned `state: CHANGES_REQUESTED` with inline findings on
 `current_head`. Claude: [does NOT mark PR ready — gate (d) failed;
 applies Fix protocol on every confirmed Copilot finding (TDD test → fix →
-push → reply inline on each thread); resets `bugbot_clean_at = null` and
-`copilot_clean_at = null`; `phase = BUGBOT`; posts `bugbot run` on new
-HEAD; schedules next wakeup. Full back-to-back-clean cycle plus all six
-gates must hold again on new HEAD.]
+push → reply inline on each thread); resets `bugbot_clean_at = null`,
+`code_review_clean_at = null`, and `copilot_clean_at = null`; `phase =
+CODE_REVIEW`; schedules next wakeup, re-enters the internal passes on the new
+HEAD. Full back-to-back-clean cycle plus all six gates must hold again on new
+HEAD.]
 </example>

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

@@ -8,7 +8,7 @@ sequence in `../../../_shared/pr-loop/fix-protocol.md`. Hook handling
 per [ground-rules.md](ground-rules.md).
 
 This file holds only the pr-converge deltas: the multi-PR teammate
-obligations and the same-tick re-trigger rule.
+obligations and the same-tick re-entry rule.
 
 **Multi-PR (`state.json`) teammate obligations** (plus TDD, commit, push):
 
@@ -17,21 +17,21 @@ obligations and the same-tick re-trigger rule.
   (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`, `bugbot_down: false`, `phase: "BUGBOT"`,
-  `status: "awaiting_bugbot"`, `last_updated` (ISO-8601 UTC) to
-  `state.json` (per §Concurrency).
-- Goes idle. Orchestrator spawns follow-up `general-purpose` agent for
-  bugbot trigger and monitoring.
+  `bugbot_clean_at: null`, `code_review_clean_at: null`, `bugbot_down: false`,
+  `phase: "CODE_REVIEW"`, `status: "awaiting_code_review"`, `last_updated`
+  (ISO-8601 UTC) to `state.json` (per §Concurrency).
+- Goes idle. Orchestrator spawns a follow-up `general-purpose` agent for the
+  CODE_REVIEW re-entry on the new HEAD.
 
-Orchestrator does not reply inline, trigger bugbot, or read repo source
+Orchestrator does not reply inline, re-enter code-review, or read repo source
 files during fix phase in multi-PR mode.
 
-### Same-tick re-trigger rule
+### Same-tick re-entry rule
 
-**After pushing a fix, always run Step 3 (`bugbot run`) in the same
-tick** regardless of phase. A new commit **resets the full convergence
-cycle**: a bugbot clean and a bugteam clean on an older SHA do **not**
-count toward convergence on the new `HEAD`. Re-obtain bugbot CLEAN on
-`current_head`, then bugteam CLEAN on the same `HEAD` with no
-intervening push. Re-triggering in the same tick saves a wakeup cycle
-vs deferring Step 3.
+**After pushing a fix, re-enter the CODE_REVIEW phase in the same tick**
+regardless of phase. A new commit **resets the full convergence cycle**: a
+code-review clean, a bugteam clean, and a Bugbot clean on an older SHA do
+**not** count toward convergence on the new `HEAD`. Re-run the static sweep and
+`/code-review high --fix` on `current_head`, then bugteam, then the terminal
+Bugbot gate, all on the same `HEAD` with no intervening push. Re-entering in the
+same tick saves a wakeup cycle.

package/skills/pr-converge/reference/ground-rules.md

@@ -1,24 +1,28 @@
 # Ground rules
 
+- **Internal-first.** The internal code-review and bugteam passes drive the code
+  to clean each tick; Cursor Bugbot and Copilot run only after that, as terminal
+  confirmation gates.
 - **Append commits.** Each tick adds at most one fix commit.
-- **Bugbot findings on current SHA mean fix-then-push-then-`bugbot run`,
-  not another naked `bugbot run`.**
+- **Bugbot findings on the current SHA mean fix-then-push-then-re-enter
+  CODE_REVIEW,** so the internal passes re-clear the new HEAD before the terminal
+  Bugbot gate runs again.
 - **All `*_clean_at`, `merge_state_status`, and `bugbot_down` reset on every push.**
 - **`bugbot run` comment is load-bearing.** Literal phrase exactly —
   empirically the only re-trigger Cursor Bugbot recognizes.
-- **Production edits go through `clean-coder`, except `/code-review --fix`.**
+- **Production edits go through `clean-coder`, except `/code-review high --fix`.**
   The lead never hand-edits production files. Every bugbot, bugteam,
   Copilot, or Claude finding spawns `Agent(subagent_type="clean-coder")` to
-  implement the fix. The CODE_REVIEW phase is the one exception: `/code-review
-  --fix` applies its own findings to the working tree, which the next
-  BUGBOT/BUGTEAM cycle re-reviews after the loop resets.
+  apply the fix. The CODE_REVIEW phase is the one exception: `/code-review
+  high --fix` applies its own findings to the working tree, which the next
+  CODE_REVIEW/BUGTEAM cycle re-reviews after the loop resets.
 - **Adapt when reality contradicts on-disk state.** If `state.json`,
   `git`, or `gh` disagree with live PR, escalate as hard blocker per
   [stop-conditions.md](stop-conditions.md).
 - **Cross-repo cwd routing is routine, not a fork.** When the PR under
   convergence lives in a different repo than the session is rooted in, route
   the working directory into a checkout of the PR's repo automatically —
-  `/code-review --fix`, `git`, and every `clean-coder` fix spawn act on the
+  `/code-review high --fix`, `git`, and every `clean-coder` fix spawn act on the
   repo of the current working directory. The resolution is fixed
   ([per-tick.md § Step 1.5](per-tick.md)): resolve the PR worktree, `cd` into
   it, run local work there. Do not pause, ask, or raise it as a material fork.

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

@@ -36,7 +36,7 @@ Create once at session start. Each teammate writes result before going idle.
   "prs": {
     "289": {
       "owner": "jl-cmd",
-      "repo": "claude-code-config",
+      "repo": "claude-dev-env",
       "branch": "feat/shared-pr-loop-extraction",
       "phase": "BUGBOT",
       "current_head": "f9a7d49e",
@@ -85,10 +85,11 @@ file contents, or subagent-owned fields except two exceptions. Uses same
    refresh `last_updated`. Observability only — no ceiling; loop ends on
    convergence or **Stop conditions**.
 2. **`phase` when only orchestrator decides:** Orchestrator applies a
-   Step 2 phase transition (including BUGTEAM §(d) `phase = BUGBOT`
-   without immediate subagent write) and no subagent merge occurs that
-   tick → orchestrator performs one locked merge setting only
-   `prs[<pr_number>].phase` and `last_updated`.
+   Step 2 phase transition (including BUGTEAM §(d) — `phase = BUGBOT` on
+   convergence with no push, routing into the terminal Bugbot gate, or
+   `phase = CODE_REVIEW` on a fix push — without a subagent write) and no
+   subagent merge occurs that tick → orchestrator performs one locked merge
+   setting only `prs[<pr_number>].phase` and `last_updated`.
 
 Orchestrator reads file at start of every tick for cross-PR state, not
 conversation context.