claude-dev-env 1.86.0 → 1.87.0

package/agents/code-quality-agent.md

@@ -1,7 +1,7 @@
 ---
 name: code-quality-agent
 description: Use this agent for comprehensive code quality reviews across multiple files.
-model: inherit
+model: opus
 color: red
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "1.86.0",
+    "version": "1.87.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/skills/autoconverge/SKILL.md

@@ -324,7 +324,10 @@ out of a Bash command string entirely and independent of which auto-allow path
 matches.
 
 - **Converge:** `parallel([Bugbot lens, code-review lens, bug-audit lens])` on
-  the current HEAD, full `origin/main...HEAD` diff. Dedup findings; one
+  the current HEAD, full `origin/main...HEAD` diff. The preflight step fetches
+  `origin/main` once for the round and enumerates the diff (changed-file list plus
+  diffstat); each lens receives that list and reads only the files it needs rather
+  than re-deriving the diff, forming its own review judgment. Dedup findings; one
   `clean-coder` applies the round's fixes per the `pr-fix-protocol` skill
   (`../pr-fix-protocol/SKILL.md`) — fix, reply, resolve — landing every fix in
   one commit per round, which the workflow journal records; re-verify next
@@ -344,8 +347,12 @@ matches.
   out-of-usage notice (the requester hit their quota) on the HEAD, or surfaces no
   review at all after the configured cap — the gate logs a notice and the run marks the PR
   ready with the Copilot gate bypassed. `copilotNote` records the bypass.
-- **Convergence check:** `check_convergence.py` is the authoritative gate; on a
-  full pass the workflow marks `draft=false`.
+- **Convergence check:** `check_convergence.py` is the authoritative gate; one
+  agent runs it and, on a full pass, marks `draft=false` in the same turn. Each
+  spawned agent runs on the model tier its role needs — opus/medium for the review
+  lenses and the code-editing fix steps, sonnet/medium for the verify, commit, and
+  recovery steps, haiku/low for the mechanical probes (preflight, Copilot gate,
+  CLEAN-audit post, convergence check).
 
 ## Multiple PRs
 
@@ -476,10 +483,10 @@ and `jl-cmd/claude-code-config` for rules and skills both appear):
 2. **Converge the generation.** Launch `workflow/converge_multi.mjs` with one
    entry per checked-out deferred PR, exactly as the
    [multi-PR launch](#launch-the-multi-pr-workflow) describes. Each child run
-   re-checks Copilot and Bugbot availability every round through the workflow's own
-   pre-spawn probe, so a reviewer that is down or out of quota is never spawned in any
-   generation; the `copilotDisabled`/`bugbotDisabled` flags each deferred PR carries
-   seed that check for the first round.
+   checks Copilot and Bugbot availability through the workflow's own preflight-git
+   probe, carried across rounds, so a reviewer that is down or out of quota is never
+   spawned in any generation; the `copilotDisabled`/`bugbotDisabled` flags each
+   deferred PR carries seed that check for the first round.
 3. **Tear down.** Run the [multi-PR teardown](#multi-pr-teardown-on-workflow-completion)
    over the generation's `results`, and revoke project permissions once per
    repository.

package/skills/autoconverge/reference/convergence.md

@@ -46,9 +46,14 @@ tracks CONVERGE passes only and is never the cap.
 
 **CONVERGE** (one round = one parallel sweep):
 
-1. Resolve the current PR HEAD SHA.
+1. Resolve the current PR HEAD SHA. The same preflight step also fetches
+   `origin/main` once for the round and enumerates the diff — the
+   `git diff --name-status origin/main...HEAD` changed-file list and the
+   `git diff --stat` diffstat — and carries both into the round.
 2. Run three lenses in parallel on that HEAD, each over the full
-   `origin/main...HEAD` diff:
+   `origin/main...HEAD` diff. Each lens receives the preflight's changed-file
+   list and diffstat and reads only the files it needs from that list rather than
+   re-deriving the diff; each lens forms its own review judgment.
    - **Bugbot lens** — drive Cursor Bugbot to a verdict on HEAD (trigger and
      poll its CI check run when needed) and return its findings, or mark itself
      down when Bugbot is opted out or unreachable.
@@ -89,9 +94,24 @@ tracks CONVERGE passes only and is never the cap.
 
 **Convergence check**:
 
-- Run `check_convergence.py`. A full pass marks the PR ready (`draft=false`) and
-  ends the run. A failure returns to CONVERGE so the next round addresses the
-  failing gate.
+- One agent runs `check_convergence.py` and, on a full pass, marks the PR ready
+  (`draft=false`) in the same turn, ending the run. A failure returns to CONVERGE
+  so the next round addresses the failing gate; the repair path re-runs this same
+  check, and only a passing check marks the PR ready.
+
+## Model tiers
+
+Each spawned agent runs on the model and effort its role needs, so the run spends
+the strongest model only where judgment is dense:
+
+- **opus / medium** — the review lenses (Bugbot, code-review, bug-audit, reuse)
+  and the code-editing steps that fix findings (fix-edit, conflict-edit,
+  repair-edit, standards-edit).
+- **sonnet / medium** — the verify steps, the commit steps, and the recovery
+  edits that clear a commit-gate or verdict rejection.
+- **haiku / low** — the mechanical steps: the preflight git-and-availability
+  probe, the Copilot gate, the CLEAN-audit post, and the convergence check that
+  marks the PR ready.
 
 ## Full-diff rule
 

package/skills/autoconverge/reference/gotchas.md

@@ -22,8 +22,9 @@ fails in a new way.
   bug-audit lenses both diff against `origin/main`. Concurrent `git fetch` calls
   contend on the worktree `.git` lock and fail intermittently, so the workflow
   runs a single serial `git fetch origin main` inside the merged `preflight-git`
-  step — the one git-utility agent that also resolves the PR HEAD SHA and probes
-  mergeability — and the parallel lenses run no git fetch of their own; they
+  step — the one git-utility agent that also resolves the PR HEAD SHA, probes
+  mergeability, and checks Copilot and Bugbot availability — and the parallel
+  lenses run no git fetch of their own; they
   diff against the already-current ref. The workflow threads the resolved HEAD
   through the rounds and re-runs `preflight-git` only after a push or rebase
   invalidates it, so a round on an unchanged HEAD spawns no git agent at all.

package/skills/autoconverge/reference/stop-conditions.md

@@ -36,8 +36,22 @@ skill still runs teardown (revoke permissions, final report).
   denied, errors, or its agent dies). The convergence gate's bugteam-review
   check can never pass without that CLEAN review, so the run stops rather than
   re-converge to the iteration cap. The `blocker` names the post failure and the
-  HEAD. Unblock by allowing `post_audit_thread.py` with a Bash permission rule,
-  or post the CLEAN review by hand, then re-run.
+  HEAD. Unblock a permission denial by allowing `post_audit_thread.py` with a
+  Bash permission rule. Unblock any other failure by creating a fresh temporary
+  file whose exact content is an empty JSON array (`[]`) and re-running the run's
+  own `post_audit_thread.py --skill bugteam --state CLEAN` command for the
+  lens-verified HEAD with that file as `--findings-json`; then re-run the
+  workflow. A CLEAN post carries an empty findings array by construction, so this
+  re-issues the run's own command for the outcome the lenses already established
+  for that HEAD.
+- **No review lens reviewed HEAD** — a round can end with no lens having reviewed
+  the HEAD three ways: the preflight resolves no SHA, every lens agent dies, or
+  every lens is down or disabled. A single such round retries on the next round.
+  Three consecutive no-lens-reviewed rounds (any mix of the three causes) reach
+  `CONFIG.maxConsecutiveNoLensRounds` and stop the run with a `blocker` that names
+  the consecutive count and only the causes that actually occurred, rather than
+  looping to the iteration cap. Any round in which at least one lens reviews the
+  HEAD resets the consecutive count.
 
 ## Not a blocker (the run continues)
 
@@ -58,10 +72,12 @@ skill still runs teardown (revoke permissions, final report).
   Bugbot lens (null result) counts as down for that HEAD, so the convergence
   check runs with `--bugbot-down` rather than demanding a Bugbot verdict the
   dead agent never produced.
-- **Every lens agent dies** — when all three parallel lenses return null in the
-  same round, the round is a failure, not a clean: the workflow posts no CLEAN
-  bugteam artifact and does not advance to the Copilot gate. It re-resolves HEAD
-  and retries on the next round, still bounded by the iteration cap.
+- **Every lens agent dies (a single round)** — when all three parallel lenses
+  return null in the same round, the round is a failure, not a clean: the
+  workflow posts no CLEAN bugteam artifact and does not advance to the Copilot
+  gate. It re-resolves HEAD and retries on the next round. This is a
+  no-lens-reviewed round, so consecutive occurrences are bounded by the
+  no-review-lens cap in the blockers above, not just the iteration cap.
 
 ## User stop