claude-dev-env 1.83.0 → 1.85.0

package/skills/autoconverge/SKILL.md

@@ -83,31 +83,16 @@ PR's owner.
    example, `claude-code-config` while the PR lives in `llm-settings`) or in no
    git checkout at all cannot continue.
 
-4. **Grant project permissions.**
-   `python "$HOME/.claude/skills/bugteam/scripts/grant_project_claude_permissions.py"`
-
-   In auto-mode the classifier blocks this grant as an unrequested change to the
-   permission allowlist: the `/autoconverge` invocation alone does not meet its
-   bar for an explicitly requested permission change. When it is blocked, keep
-   the run alive — surface the grant to the user through `AskUserQuestion` with
-   the exact command and ask them to approve it or run it themselves with the `!`
-   prefix:
-   `! python "$HOME/.claude/skills/bugteam/scripts/grant_project_claude_permissions.py"`.
-   Continue once the grant lands. A user who wants future runs to skip this
-   prompt can add a standing Bash permission allow-rule for that script in their
-   settings.
-
-5. **Copilot quota pre-check.** Before the `Workflow` call, run once:
-   `python "$HOME/.claude/_shared/pr-loop/scripts/copilot_quota.py"`
-   It reads the account's remaining Copilot premium-request quota via
-   `gh api copilot_internal/user` and prints one line — log that line. Exit 0
-   means Copilot has quota to run, so pass `copilotDisabled: false`. Any non-zero
-   exit means skip Copilot for this run — the account is out of quota, the quota
-   API or account access is down, or no account is set — so pass
-   `copilotDisabled: true`; the workflow then skips the Copilot gate with no agent
-   spawned. The account comes from the `COPILOT_QUOTA_ACCOUNT` environment
-   variable or a git-ignored `.env` file, and the no-account line names the exact
-   `.env` path and key to set.
+4. **Grant project permissions.** Apply the `pr-loop-lifecycle` skill's Open
+   section (`../pr-loop-lifecycle/SKILL.md`) — the grant command
+   (`grant_project_claude_permissions.py`) and the auto-mode `AskUserQuestion`
+   escalation for a blocked grant both live there.
+
+5. **Copilot quota pre-check.** Before the `Workflow` call, apply the
+   `reviewer-gates` skill's Copilot quota gate (`../reviewer-gates/SKILL.md`)
+   once. Exit 0 maps to `copilotDisabled: false` in the Workflow call; any
+   non-zero exit maps to `copilotDisabled: true`, and the workflow then skips
+   the Copilot gate with no agent spawned.
 
 ## Run the workflow
 
@@ -130,6 +115,19 @@ and `false` when it exits 0; on `true` the workflow skips the Copilot gate with
 no agent spawned. The workflow runs in the background and notifies this session
 on completion. Watch live progress with `/workflows`.
 
+The moment the `Workflow` call returns its run id, write the durable handoff so a
+fresh session can resume the same run:
+
+```
+python "$HOME/.claude/skills/_shared/pr-loop/scripts/write_handoff.py" \
+  --pr-number <N> --head-ref <branch> --phase workflow \
+  --resume-command "Workflow({scriptPath, resumeFromRunId: '<runId>'})" \
+  --run-id <runId>
+```
+
+Write it again when the result lands, so the handoff carries the final run id and
+names the teardown phase the fresh session picks up from.
+
 The workflow returns
 `{ converged, rounds, finalSha, blocker, standardsNote, copilotNote, reuseNote, deferredPrs }`.
 `deferredPrs` is the list of draft environment-hardening PRs the standards-deferral
@@ -149,13 +147,37 @@ returns `blocker: "budget"` with the run id; resume with
 the journal. Never start a round the budget cannot finish: a half-run
 round records nothing resumable and replays dirty.
 
+On a `blocker: "budget"` return, write the durable handoff with the run id and the
+`Workflow({scriptPath, resumeFromRunId})` resume command before stopping, so a
+fresh session resumes the paced run without the stopped session's transcript.
+
 ## Teardown (on workflow completion)
 
+Teardown runs as an ordered checkpoint list. After each checkpoint finishes,
+re-write the durable handoff with `--phase teardown`, the run id, and the
+checkpoints done so far, so a fresh session that resumes reads `handoff.json`
+`completed_steps` and skips the checkpoints already done:
+
+```
+python "$HOME/.claude/skills/_shared/pr-loop/scripts/write_handoff.py" \
+  --pr-number <N> --head-ref <branch> --phase teardown \
+  --resume-command "/autoconverge <PR URL>" \
+  --run-id <runId> \
+  --completed-steps "<checkpoints done so far>"
+```
+
+The checkpoints run in this order: `report`, `close`. Write the
+handoff after each one finishes.
+
+On teardown entry, when `~/.claude/runtime/pr-loop/bugteam-pr-<N>/handoff.json`
+exists, read its `completed_steps` and skip any checkpoint the list already
+names, so a resumed run performs only the checkpoints left.
+
 1. **When `converged` is true — build and publish the closing report.**
-   Skip this entire step (report, gist, comment, Chrome open) when the workflow
-   returned a non-null `blocker`. Per-round live-dashboard refresh is out of scope
-   here; this step builds the one-shot closing report and the seam (marker comment +
-   gist URL) a future live-dashboard reuses.
+   Skip this entire step (report, artifact publish, comment, Chrome open) when the
+   workflow returned a non-null `blocker`. Per-round live-dashboard refresh is out of
+   scope here; this step builds the one-shot closing report and the seam (marker
+   comment + artifact URL) a future live-dashboard reuses.
 
    a. **Resolve a seed journal path.** Glob
       `~/.claude/projects/**/workflows/wf_<runId>.json` (where `runId` is the run id
@@ -194,21 +216,16 @@ round records nothing resumable and replays dirty.
       Use the `combinedJournal`, `finalSha`, and `roundCount` from step b. Capture the
       output path from stdout.
 
-   e. **Publish as a secret gist** by reusing `doc-gist` (do not reimplement gist
-      creation):
-      ```
-      python "$HOME/.claude/skills/doc-gist/scripts/gist_upload.py" \
-        --input "<html path>" \
-        --no-open \
-        --description "autoconverge report PR #<n>"
-      ```
-      Capture the htmlpreview URL from stdout. The gist is secret by default; pass
-      no public flag.
+   e. **Publish via the Artifact tool.** Load the `artifact-design` skill first, then
+      call `Artifact` with `file_path` set to the report path from step d, `favicon`
+      set to the fixed autoconverge favicon `✅` (keep this favicon stable across
+      every autoconverge report — never swap it per run), and `description` set to
+      a one-sentence subtitle naming the PR. Capture the returned URL.
 
    f. **Post one idempotent PR comment.** List the PR's issue comments; if one
       carries the marker `<!-- autoconverge-report -->`, edit it in place, otherwise
       create a new one. The body begins with `<!-- autoconverge-report -->`, then
-      the htmlpreview link, then a plain-language summary that mirrors the report:
+      the artifact URL, then a plain-language summary that mirrors the report:
       lead with the one-sentence `verdictLine`; then the plain Problem and Fix
       sentences (`prProblem`, `prFix`); then the issue-class list — one bullet per
       class as `plainName (×count, status)`. Place the raw finding list as
@@ -219,21 +236,25 @@ round records nothing resumable and replays dirty.
       GitHub MCP `add_issue_comment` tool (body as a structured parameter, no
       `--body` flag).
 
-   g. **Open the report in Chrome.**
+   g. **Open the published report in Chrome.** Use the artifact URL captured in
+      step e.
       ```
-      Start-Process chrome -ArgumentList '--new-window', '<report path>'
+      Start-Process chrome -ArgumentList '--new-window', '<artifact URL>'
       ```
-      Tolerate a missing Chrome without aborting the rest of teardown.
+      Skip a missing Chrome without aborting the rest of teardown.
 
-2. **When `converged` is true:** rewrite the PR description and clean the
-   working tree — see
-   [`bugteam/reference/teardown-publish-permissions.md` § Step 4 and § Step 4.5](../bugteam/reference/teardown-publish-permissions.md).
-   The workflow already marked the PR ready.
+   After the report is published, write the handoff with
+   `--completed-steps "report"`.
 
-3. **Always revoke project permissions** (including on a blocker exit):
-   `python "$HOME/.claude/skills/bugteam/scripts/revoke_project_claude_permissions.py"`
+2. **Close the run.** Apply the `pr-loop-lifecycle` skill's Close section
+   (`../pr-loop-lifecycle/SKILL.md`): when `converged` is true, rewrite the PR
+   description and clean the working tree — see
+   [`pr-loop-lifecycle/reference/teardown-publish-permissions.md` § Clean working tree and § Publish the final PR description](../pr-loop-lifecycle/reference/teardown-publish-permissions.md);
+   the workflow already marked the PR ready. The permission revoke always runs,
+   including on a blocker exit. Write the handoff with
+   `--completed-steps "report,close"`.
 
-4. **Print the final report:**
+3. **Print the final report:**
 
    ```
    /autoconverge exit: <converged | blocked>
@@ -304,13 +325,14 @@ matches.
 
 - **Converge:** `parallel([Bugbot lens, code-review lens, bug-audit lens])` on
   the current HEAD, full `origin/main...HEAD` diff. Dedup findings; one
-  `clean-coder` applies all fixes in a single commit, pushes, replies to and
-  resolves any bot threads; re-verify next round on the new HEAD. Every edit
-  step ends with a pre-commit gate check: before its turn ends, the fixer
-  dry-runs the CODE_RULES commit gate (`code_rules_gate.py --staged`) and keeps
-  fixing until that gate would accept the commit — it makes no commit itself.
-  When all three are clean on a stable HEAD, post the CLEAN bugteam audit
-  artifact.
+  `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
+  round on the new HEAD. Every edit step ends with a pre-commit gate check:
+  before its turn ends, the fixer dry-runs the CODE_RULES commit gate
+  (`code_rules_gate.py --staged`) and keeps fixing until that gate would accept
+  the commit — it makes no commit itself. When all three are clean on a stable
+  HEAD, post the CLEAN bugteam audit artifact.
   A round whose findings are ALL code-standard violations (pure CODE_RULES/style,
   no behavioral impact) passes for convergence purposes: the workflow files a
   follow-up issue listing the findings, opens a draft environment-hardening PR
@@ -404,7 +426,9 @@ top-level `converged` is true only when every PR converged.
 
 Run the single-PR [Teardown](#teardown-on-workflow-completion) once per entry in
 `results`, using that PR's `owner`, `repo`, `prNumber`, and `finalSha`, and its
-own worktree as the working directory. Build and publish a PR's closing report
+own worktree as the working directory. Write one durable handoff per PR entry —
+each with that PR's own `--pr-number` — so a fresh session can resume any PR on
+its own. Build and publish a PR's closing report
 only for a PR whose `converged` is true; for a PR that returned a blocker, skip
 its report and carry the blocker into the final summary. Revoke project
 permissions once per repository after every PR's teardown. Then print one summary

package/skills/autoconverge/reference/closing-report.md

@@ -1,6 +1,6 @@
 # Closing Report
 
-When an autoconverge run converges (the workflow returns `converged: true`), the main session generates a convergence insights HTML report and publishes it as a secret gist with an idempotent PR comment linking to it.
+When an autoconverge run converges (the workflow returns `converged: true`), the main session generates a convergence insights HTML report and publishes it with the `Artifact` tool, with an idempotent PR comment linking to it.
 
 ## Data source
 
@@ -73,14 +73,14 @@ Counting is deterministic: `generated_date` comes from the journal `timestamp`,
 
 After rendering, the main session:
 
-1. **Uploads the HTML as a secret gist** using `doc-gist/scripts/gist_upload.py --no-open`. Captures the htmlpreview URL from stdout.
-2. **Posts one idempotent PR comment** marked with `<!-- autoconverge-report -->`. If a comment with that marker already exists on the PR, it is edited in place; otherwise a new comment is created. The body leads with the gist URL, then the one-sentence `verdictLine`, then the plain Problem and Fix sentences (`prProblem`, `prFix`), then the issue-class list — one bullet per class as `plainName (×count, status)` — and closes with the full finding list (`file:line — P# — title`) inside a collapsed `<details>` block. Write the body to a BOM-free temp file and pass `--body-file` to `gh issue comment` (never `--body`), or use the GitHub MCP `add_issue_comment` tool.
-3. **Opens the report** with `Start-Process chrome -ArgumentList '--new-window', '<report path>'`. A missing Chrome does not abort teardown.
+1. **Publishes the HTML with the Artifact tool.** Loads the `artifact-design` skill first, then calls `Artifact` with `file_path` set to the rendered report, `favicon` set to the fixed autoconverge favicon `✅` (kept stable across every autoconverge report), and `description` naming the PR. Captures the returned URL.
+2. **Posts one idempotent PR comment** marked with `<!-- autoconverge-report -->`. If a comment with that marker already exists on the PR, it is edited in place; otherwise a new comment is created. The body leads with the artifact URL, then the one-sentence `verdictLine`, then the plain Problem and Fix sentences (`prProblem`, `prFix`), then the issue-class list — one bullet per class as `plainName (×count, status)` — and closes with the full finding list (`file:line — P# — title`) inside a collapsed `<details>` block. Write the body to a BOM-free temp file and pass `--body-file` to `gh issue comment` (never `--body`), or use the GitHub MCP `add_issue_comment` tool.
+3. **Opens the published report** with `Start-Process chrome -ArgumentList '--new-window', '<artifact URL>'`, using the artifact URL captured in step 1. A missing Chrome does not abort teardown.
 
 ## Live-dashboard seam
 
-The marker comment and gist together form a seam for future per-round dashboard refreshes: a live-dashboard step re-renders with the same `render_report_html` function (pure, no side effects), runs `gh gist edit` on the same gist, and edits the same marker comment. That per-round refresh path is out of scope here; this document describes the one-shot closing report only.
+The marker comment and artifact together form a seam for future per-round dashboard refreshes: a live-dashboard step re-renders with the same `render_report_html` function (pure, no side effects), calls `Artifact` again on the same `file_path` to redeploy to the same URL, and edits the same marker comment. That per-round refresh path is out of scope here; this document describes the one-shot closing report only.
 
 ## Scope
 
-The closing report runs only when `converged === true`. On a blocker exit (`blocker: "budget"` or similar), the report, gist, comment, and Chrome open are all skipped.
+The closing report runs only when `converged === true`. On a blocker exit (`blocker: "budget"` or similar), the report, artifact publish, comment, and Chrome open are all skipped.

package/skills/autoconverge/reference/convergence.md

@@ -55,24 +55,25 @@ tracks CONVERGE passes only and is never the cap.
    - **Code-review lens** — a correctness-focused review pass (`code-quality-agent`)
      that reports findings without editing.
    - **Bug-audit lens** — the bug-audit (`code-quality-agent`) applying the
-     shared A–P rubric from `bugteam/reference/audit-contract.md`, reporting
+     shared A–P rubric from `_shared/pr-loop/audit-contract.md`, reporting
      findings without editing.
 3. Dedup findings across the three lenses by file, line, and title. A collision
    keeps the most severe duplicate's severity (P0 > P1 > P2), unions the detail
    text, and collects every distinct bot thread id so the fix lens resolves all
    colliding threads.
-4. **Any findings** → one `clean-coder` applies every fix in a single test-first
-   commit, pushes, then replies to and resolves each finding that carries a
-   GitHub review thread. Before its turn ends, the edit step dry-runs the
-   CODE_RULES commit gate (`code_rules_gate.py --staged`) over its staged
+4. **Any findings** → one `clean-coder` applies every fix per the
+   `pr-fix-protocol` skill (`../../pr-fix-protocol/SKILL.md`): a single
+   test-first commit, a push, then a reply and resolve on each finding that
+   carries a GitHub review thread. Before its turn ends, the edit step dry-runs
+   the CODE_RULES commit gate (`code_rules_gate.py --staged`) over its staged
    changes and keeps fixing until that gate would accept the commit, so the
-   later commit step never hits a gate rejection. A round progresses when the fix lens lands a push that
-   moves HEAD, or when every finding was already addressed so no code change is
-   needed yet each finding thread is still resolved (the fix lens reports
-   `resolvedWithoutCommit` and the run re-converges on the unchanged HEAD). A
-   round whose fix lens reports neither a moved-HEAD push nor a full
-   thread-resolution ends the run with a fix-stalled blocker. The next round
-   re-verifies on the current HEAD.
+   later commit step never hits a gate rejection. A round progresses when the
+   fix lens lands a push that moves HEAD, or when every finding was already
+   addressed so no code change is needed yet each finding thread is still
+   resolved (the fix lens reports `resolvedWithoutCommit` and the run
+   re-converges on the unchanged HEAD). A round whose fix lens reports neither
+   a moved-HEAD push nor a full thread-resolution ends the run with a
+   fix-stalled blocker. The next round re-verifies on the current HEAD.
 5. **Zero findings on a stable HEAD** → post the CLEAN bugteam audit artifact
    for that HEAD, then move to the Copilot gate.
 
@@ -112,9 +113,10 @@ the current HEAD:
 4. The Copilot review on HEAD is clean or approved (bypassed when Copilot is down
    or out of quota this run).
 5. Zero unresolved bot review threads anywhere on the PR — counting Cursor,
-   Claude, and Copilot authored threads where `isResolved` is false (`isOutdated`
-   threads are excluded by the gate, but the fix lens still verifies and resolves
-   them during the round).
+   Claude, and Copilot authored threads. The filter is purely
+   `isResolved == false`; `isOutdated` is informational, and the fix lens
+   verifies each outdated thread against current HEAD like any other (the
+   `pr-fix-protocol` skill's unresolved-thread sweep).
 6. The PR is mergeable (`mergeable` true and `mergeable_state` clean).
 7. No requested reviewers are still pending (bypassed when Copilot is down or out
    of quota this run).

package/skills/autoconverge/reference/gotchas.md

@@ -21,9 +21,12 @@ fails in a new way.
 - **Fetch origin/main once before the parallel lenses.** The code-review and
   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` (the `prefetch-main` step) at the
-  start of each round and the parallel lenses run no git fetch of their own —
-  they diff against the already-current ref.
+  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
+  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.
 
 - **The CLEAN bugteam artifact is HEAD-specific.** `check_convergence.py` reads
   the bugteam review on the current HEAD. Any push moves HEAD and invalidates a

package/skills/autoconverge/workflow/autoconverge_report_constants/render_report_constants.py

@@ -154,16 +154,9 @@ Write so a non-programmer understands every line. The reader has never seen the
 
 Return strictly a JSON object with keys prProblem, prFix, problemScenes, fixScenes, verdictLine, and issueClasses."""
 
-HTML_DOCTYPE = "<!DOCTYPE html>"
-
-HTML_HEAD_TEMPLATE = """\
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
+HTML_TITLE_AND_STYLE_TEMPLATE = """\
 <title>PR #{pr_number} Convergence Summary</title>
-<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
-{style_block}
-</head>"""
+{style_block}"""
 
 HTML_STYLE_BLOCK = """\
 <style>

package/skills/autoconverge/workflow/converge.contract.test.mjs

@@ -44,26 +44,37 @@ test('bug-audit lens prompt no longer instructs a per-lens git fetch', () => {
   assert.doesNotMatch(lensPromptBody('runAuditLens'), /git fetch origin main/);
 });
 
-test('a single round-level prefetch step fetches origin/main before the parallel lenses', () => {
-  assert.ok(convergeSource.includes("runGitTask('prefetch-main')"));
-  const prefetchCallIndex = convergeSource.indexOf("runGitTask('prefetch-main')");
+test('the merged preflight-git task fetches origin/main once before the parallel lenses', () => {
+  assert.ok(convergeSource.includes("runGitTask('preflight-git')"));
+  const preflightCallIndex = convergeSource.indexOf("runGitTask('preflight-git')");
   const parallelLensIndex = convergeSource.indexOf('const lenses = await parallel(');
-  assert.notEqual(prefetchCallIndex, -1, 'expected prefetch to be invoked');
+  assert.notEqual(preflightCallIndex, -1, 'expected the merged preflight to be invoked');
   assert.notEqual(parallelLensIndex, -1, 'expected the parallel lens block to exist');
   assert.ok(
-    prefetchCallIndex < parallelLensIndex,
-    'expected the round prefetch to run before the parallel lenses spawn',
+    preflightCallIndex < parallelLensIndex,
+    'expected the merged preflight to run before the parallel lenses spawn',
   );
+  const gitTaskBody = functionSource('runGitTask');
+  assert.match(gitTaskBody, /git fetch origin main/, 'expected the merged task to carry the base-ref fetch');
+  assert.match(gitTaskBody, /--jq \.head\.sha/, 'expected the merged task to resolve the PR HEAD SHA');
+  assert.match(gitTaskBody, /PREFLIGHT_GIT_SCHEMA/, 'expected the merged task to return the {sha, conflicting, fetched} schema');
+});
+
+test('the merged preflight-git agent runs on haiku at low effort', () => {
+  const gitTaskBody = functionSource('runGitTask');
+  assert.match(gitTaskBody, /model: 'haiku'/, 'expected the git-utility agent to run on the cheapest model');
+  assert.match(gitTaskBody, /effort: 'low'/, 'expected the git-utility agent to run at low effort');
 });
 
 test('the CONVERGE round spawns a single shared reviewer-availability probe before the parallel lenses', () => {
-  const prefetchCallIndex = convergeSource.indexOf("runGitTask('prefetch-main')");
+  const convergeBranchStart = convergeSource.indexOf("if (phase === 'CONVERGE')");
+  const refreshCallIndex = convergeSource.indexOf("runGitTask('preflight-git')", convergeBranchStart);
   const probeCallIndex = convergeSource.indexOf('reviewerAvailability = await runReviewerAvailabilityCheck()');
   const parallelLensIndex = convergeSource.indexOf('const lenses = await parallel(');
   assert.notEqual(probeCallIndex, -1, 'expected the CONVERGE round to spawn the shared reviewer-availability probe');
   assert.ok(
-    prefetchCallIndex < probeCallIndex && probeCallIndex < parallelLensIndex,
-    'expected the probe to run after the round prefetch and before the parallel lenses spawn',
+    refreshCallIndex < probeCallIndex && probeCallIndex < parallelLensIndex,
+    'expected the probe to run after the round head refresh and before the parallel lenses spawn',
   );
   const probeBody = functionSource('runReviewerAvailabilityCheck');
   assert.match(probeBody, /reviewer_availability\.py/);
@@ -247,11 +258,74 @@ test('the COPILOT fix branch does not re-assign head from the fix before re-conv
   );
 });
 
-test('the CONVERGE branch re-resolves HEAD from GitHub on every entry', () => {
+test('the CONVERGE branch refreshes HEAD via the merged preflight-git task only when the threaded head is invalidated', () => {
   const convergeBranchStart = convergeSource.indexOf("if (phase === 'CONVERGE')");
   assert.notEqual(convergeBranchStart, -1, 'expected the CONVERGE branch to exist');
-  const headResolveCallIndex = convergeSource.indexOf("runGitTask('resolve-head')", convergeBranchStart);
-  assert.notEqual(headResolveCallIndex, -1, 'expected CONVERGE to re-resolve HEAD via runGitTask');
+  const invalidGuardIndex = convergeSource.indexOf('if (!isResolvedHeadUsable(head))', convergeBranchStart);
+  const headRefreshCallIndex = convergeSource.indexOf("runGitTask('preflight-git')", convergeBranchStart);
+  assert.notEqual(invalidGuardIndex, -1, 'expected CONVERGE to gate the refresh on an invalidated head');
+  assert.notEqual(headRefreshCallIndex, -1, 'expected CONVERGE to refresh HEAD via the merged preflight-git task');
+  assert.ok(
+    invalidGuardIndex < headRefreshCallIndex,
+    'expected the invalidated-head guard to precede the merged refresh so a valid threaded head spawns no git agent',
+  );
+});
+
+test('each fix push, each lens-retry, and the convergence repair invalidate the threaded head so the next CONVERGE entry refreshes it', () => {
+  const invalidationMatches = convergeSource.match(/^ +head = null$/gm) || [];
+  assert.equal(
+    invalidationMatches.length,
+    5,
+    'expected head invalidation after the CONVERGE fix push, the COPILOT fix push, the convergence repair, the all-lenses-dead retry, and the not-clean-no-findings retry',
+  );
+});
+
+function convergeRetryBranch(guardMarker) {
+  const guardIndex = convergeSource.indexOf(guardMarker);
+  assert.notEqual(guardIndex, -1, `expected the ${guardMarker} retry branch to exist`);
+  const continueIndex = convergeSource.indexOf('continue', guardIndex);
+  assert.notEqual(continueIndex, -1, `expected a continue statement to close the ${guardMarker} branch`);
+  return convergeSource.slice(guardIndex, continueIndex + 'continue'.length);
+}
+
+test('the all-lenses-dead retry invalidates the threaded head so the next round re-fetches origin/main before spawning lenses', () => {
+  const branch = convergeRetryBranch('if (roundOutcome.allLensesDead) {');
+  const headNullIndex = branch.indexOf('head = null');
+  assert.notEqual(
+    headNullIndex,
+    -1,
+    'expected the all-lenses-dead retry to null head so the next round re-enters preflight-git — otherwise the lenses are told origin/main was fetched this round when no fetch ran',
+  );
+  assert.ok(
+    headNullIndex < branch.indexOf('continue'),
+    'expected head to be invalidated before the retry continues to the next round',
+  );
+});
+
+test('the not-clean-no-findings retry invalidates the threaded head so the next round re-fetches origin/main before spawning lenses', () => {
+  const branch = convergeRetryBranch('if (!roundOutcome.roundClean) {');
+  const headNullIndex = branch.indexOf('head = null');
+  assert.notEqual(
+    headNullIndex,
+    -1,
+    'expected the not-clean-no-findings retry to null head so the next round re-enters preflight-git — otherwise the lenses are told origin/main was fetched this round when no fetch ran',
+  );
+  assert.ok(
+    headNullIndex < branch.indexOf('continue'),
+    'expected head to be invalidated before the retry continues to the next round',
+  );
+});
+
+test('the preflight consumes the head returned by resolveMergeConflicts without an immediate re-resolve', () => {
+  const consumedHeadIndex = convergeSource.indexOf('head = await resolveMergeConflicts(');
+  assert.notEqual(consumedHeadIndex, -1, 'expected the post-rebase head from resolveMergeConflicts to be captured');
+  const whileLoopIndex = convergeSource.indexOf('while (iterations < CONFIG.maxIterations)');
+  const betweenPreflightAndLoop = convergeSource.slice(consumedHeadIndex, whileLoopIndex);
+  assert.doesNotMatch(
+    betweenPreflightAndLoop,
+    /runGitTask\(/,
+    'expected the reuse pass to reuse the threaded head with no git-utility agent spawn',
+  );
 });
 
 test('fix edit prompt resolves threads by PRRT thread node id looked up from the comment databaseId', () => {
@@ -553,7 +627,7 @@ test('the reuse pass applies its findings through applyFixes, not the standards-
   const reuseBlock = convergeSource.slice(reuseCallIndex, loopIndex);
   assert.match(
     reuseBlock,
-    /applyFixes\(reuseHead, reuseFindings, 'reuse-pass'\)/,
+    /applyFixes\(head, reuseFindings, 'reuse-pass'\)/,
     'expected the reuse pass to apply its findings via applyFixes',
   );
   assert.doesNotMatch(

package/skills/autoconverge/workflow/converge.copilot-gate.test.mjs

@@ -73,7 +73,7 @@ test('Copilot findings route to a fix when Copilot is reachable and not down', (
 
 test('COPILOT_SCHEMA carries a required down field', () => {
   const schemaStart = convergeSource.indexOf('const COPILOT_SCHEMA =');
-  const schemaEnd = convergeSource.indexOf('const HEAD_SCHEMA =');
+  const schemaEnd = convergeSource.indexOf('const REVIEWER_AVAILABILITY_SCHEMA =');
   assert.notEqual(schemaStart, -1, 'expected COPILOT_SCHEMA to exist');
   const schemaSource = convergeSource.slice(schemaStart, schemaEnd);
   assert.match(schemaSource, /down:\s*\{\s*type:\s*'boolean'/);

package/skills/autoconverge/workflow/converge.merge-conflict.test.mjs

@@ -39,7 +39,7 @@ test('the git agent handles merge-conflict checks with a Monitor-based poll', ()
     /do not edit, commit, push, or rebase|read only/i,
     'expected the git agent merge check to be read-only',
   );
-  assert.match(gitBody, /MERGE_CONFLICT_SCHEMA/, 'expected the git agent to return MERGE_CONFLICT_SCHEMA');
+  assert.match(gitBody, /PREFLIGHT_GIT_SCHEMA/, 'expected the git agent to return PREFLIGHT_GIT_SCHEMA');
   assert.match(gitBody, /Monitor tool/, 'expected a Monitor-based poll delay, not a foreground sleep');
 });
 
@@ -53,31 +53,38 @@ test('runCodeEditorTask conflict-edit path rebases onto origin/main and makes no
   );
 });
 
-test('resolveMergeConflicts runs check -> edit -> verify -> commit and gates the push on the verdict', () => {
+test('resolveMergeConflicts runs edit -> verify -> commit and gates the push on the verdict', () => {
   const body = functionBody('resolveMergeConflicts');
-  const checkIndex = body.indexOf("runGitTask('check-merge-conflicts'");
   const editIndex = body.indexOf("runCodeEditorTask('conflict-edit'");
   const verifyIndex = body.indexOf('runVerifierTask(');
   const commitIndex = body.indexOf('commitWithRecovery(');
-  assert.notEqual(checkIndex, -1, 'expected the conflict check to run');
   assert.notEqual(editIndex, -1, 'expected the edit step to run');
   assert.notEqual(verifyIndex, -1, 'expected the verify step to run');
   assert.notEqual(commitIndex, -1, 'expected the commit step to run');
   assert.ok(
-    checkIndex < editIndex && editIndex < verifyIndex && verifyIndex < commitIndex,
-    'expected the order check -> edit -> verify -> commit',
+    editIndex < verifyIndex && verifyIndex < commitIndex,
+    'expected the order edit -> verify -> commit',
   );
   assert.match(body, /verdictPassed\(/, 'expected the verifier verdict to gate the force-push');
+  assert.doesNotMatch(
+    body,
+    /runGitTask\(/,
+    'expected the conflict decision to come from the merged preflight-git probe, with no mergeability agent spawned here',
+  );
 });
 
-test('resolveMergeConflicts rebases only when the check reports a conflict', () => {
+test('resolveMergeConflicts rebases only when the caller-supplied preflight decision reports a conflict', () => {
   const body = functionBody('resolveMergeConflicts');
-  assert.match(body, /isMergeConflicting\(/, 'expected the orchestrator to branch on the conflict decision');
   assert.match(
     body,
-    /if \(!isMergeConflicting\([^)]*\)\) return head/,
+    /if \(!isConflicting\) return head/,
     'expected a clean PR to return the unchanged HEAD without rebasing',
   );
+  assert.match(
+    convergeSource,
+    /resolveMergeConflicts\(preflight\.sha, isMergeConflicting\(preflight\)\)/,
+    'expected the call site to derive the conflict decision from the merged preflight-git result',
+  );
 });
 
 test('the merge-conflict pre-flight runs once before the round loop, ahead of the parallel bug-check lenses', () => {