claude-dev-env 1.92.1 → 1.93.0

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

@@ -119,37 +119,21 @@ test('the reviewer-availability probe rides the merged preflight-git spawn, not
   );
 });
 
-test('the Bugbot lens is not spawned pre-spawn when the shared gate reports Bugbot down', () => {
+test('the round parallel array holds exactly the three internal lenses in order and no Bugbot slot', () => {
   const parallelLensIndex = convergeSource.indexOf('const lenses = await parallel(');
   assert.notEqual(parallelLensIndex, -1, 'expected the parallel lens block to exist');
-  const isBugbotDownPreSpawnIndex = convergeSource.indexOf('const isBugbotDownPreSpawn = resolveReviewerDown(');
-  assert.notEqual(isBugbotDownPreSpawnIndex, -1, 'expected a pre-spawn Bugbot-down decision computed before the lens array');
-  assert.ok(
-    isBugbotDownPreSpawnIndex < parallelLensIndex,
-    'expected the pre-spawn Bugbot-down decision to be computed before the parallel lens array',
-  );
   const lensArrayEnd = convergeSource.indexOf('])', parallelLensIndex);
   const lensArray = convergeSource.slice(parallelLensIndex, lensArrayEnd);
-  assert.match(
-    lensArray,
-    /isBugbotDownPreSpawn \? Promise\.resolve\(\{ sha: head, clean: true, down: true, notSpawned: true, findings: \[\] \}\) : runBugbotLens\(head, reviewerAvailability\)/,
-    'expected the Bugbot lens slot to substitute a resolved down placeholder instead of spawning runBugbotLens when isBugbotDownPreSpawn is true',
-  );
-});
-
-test('the post-round bugbotDown verdict treats a dead Bugbot lens as down, not fail-open', () => {
-  const parallelLensIndex = convergeSource.indexOf('const lenses = await parallel(');
-  assert.notEqual(parallelLensIndex, -1, 'expected the parallel lens block to exist');
-  const lensArrayEnd = convergeSource.indexOf('])', parallelLensIndex);
-  const bugbotDownAssignIndex = convergeSource.indexOf('bugbotDown = ', lensArrayEnd);
-  assert.notEqual(bugbotDownAssignIndex, -1, 'expected the post-round bugbotDown assignment after the lens array');
-  const bugbotDownAssignLineEnd = convergeSource.indexOf('\n', bugbotDownAssignIndex);
-  const bugbotDownAssignLine = convergeSource.slice(bugbotDownAssignIndex, bugbotDownAssignLineEnd);
-  assert.match(
-    bugbotDownAssignLine,
-    /bugbotDown = lenses\[0\] == null \? true : resolveReviewerDown\(lenses\[0\], input\.bugbotDisabled \|\| false\)/,
-    'expected a dead (null) Bugbot lens result to report bugbotDown:true — resolveReviewerDown alone is fail-open on null, which would wrongly report bugbotDown:false for a lens agent that actually spawned and died, leaving check_convergence.py to look for a bugbot review that was never posted',
+  const codeReviewIndex = lensArray.indexOf('runCodeReviewLens(head, reviewerAvailability)');
+  const auditIndex = lensArray.indexOf('runAuditLens(head, reviewerAvailability)');
+  const selfReviewIndex = lensArray.indexOf('runSelfReviewLens(head, reviewerAvailability)');
+  assert.ok(codeReviewIndex !== -1 && auditIndex !== -1 && selfReviewIndex !== -1, 'expected the three internal lenses in the parallel array');
+  assert.ok(
+    codeReviewIndex < auditIndex && auditIndex < selfReviewIndex,
+    'expected the code-review, bug-audit, self-review order to match LENS_NAMES',
   );
+  assert.doesNotMatch(lensArray, /runBugbotLens/, 'expected Bugbot to leave the per-round parallel and become a terminal gate');
+  assert.doesNotMatch(convergeSource, /isBugbotDownPreSpawn/, 'expected the pre-spawn Bugbot-down decision to be gone from the round');
 });
 
 test('both reviewer trigger commands carry the CLAUDE_REVIEWER_GATE=autoconverge sentinel', () => {
@@ -324,8 +308,8 @@ test('each fix push, each lens-retry, and the convergence repair invalidate the
   const invalidationMatches = convergeSource.match(/^ +head = null$/gm) || [];
   assert.equal(
     invalidationMatches.length,
-    6,
-    'expected head invalidation after the CONVERGE fix push, the COPILOT fix push, the convergence repair, the all-lenses-dead retry, the not-clean-no-findings retry, and the all-clean no-lens-ran clean-audit refusal',
+    8,
+    'expected head invalidation after the static-sweep fix push, the CONVERGE fix push, the terminal-Bugbot fix push, the COPILOT fix push, the convergence repair, the all-lenses-dead retry, the not-clean-no-findings retry, and the all-clean no-lens-ran clean-audit refusal',
   );
 });
 
@@ -625,12 +609,12 @@ test('the standards-deferral surfaces disclose the hardening-PR state unconditio
   );
 });
 
-test('both standards-deferral call sites build standardsNote from the spawnStandardsFollowUp outcome', () => {
+test('every standards-deferral call site builds standardsNote from the spawnStandardsFollowUp outcome', () => {
   const callSiteUses = convergeSource.match(/standardsNote = standardsDeferralNote\(/g) || [];
   assert.equal(
     callSiteUses.length,
-    2,
-    'expected both standards-deferral call sites to build standardsNote via standardsDeferralNote(...)',
+    3,
+    'expected the converge-round, terminal-Bugbot, and Copilot standards call sites to each build standardsNote via standardsDeferralNote(...)',
   );
   assert.doesNotMatch(
     convergeSource,
@@ -741,8 +725,8 @@ for (const [helperName, taskName] of editStepTasks) {
 }
 
 function preambleText() {
-  const preambleStart = convergeSource.indexOf('const HEADLESS_SAFETY_PREAMBLE =');
-  assert.notEqual(preambleStart, -1, 'expected HEADLESS_SAFETY_PREAMBLE to exist');
+  const preambleStart = convergeSource.indexOf('const HEADLESS_EDIT_PREAMBLE =');
+  assert.notEqual(preambleStart, -1, 'expected HEADLESS_EDIT_PREAMBLE to exist');
   const preambleEnd = convergeSource.indexOf('\n\nlet ', preambleStart);
   return convergeSource.slice(preambleStart, preambleEnd === -1 ? undefined : preambleEnd);
 }
@@ -850,15 +834,24 @@ test('SKILL.md attributes the known-temp-var resolution to the cwd-scoped auto-a
   );
 });
 
-test('convergeAgent prepends HEADLESS_SAFETY_PREAMBLE and the worktree directive to every prompt', () => {
+test('convergeAgent prepends HEADLESS_EDIT_PREAMBLE and the worktree directive to every prompt', () => {
   const convergeAgentBody = lensPromptBody('convergeAgent');
   assert.match(
     convergeAgentBody,
-    /HEADLESS_SAFETY_PREAMBLE.*worktreeDirective/,
+    /HEADLESS_EDIT_PREAMBLE.*worktreeDirective/,
     'expected convergeAgent to prepend both preamble and worktree directive',
   );
 });
 
+test('convergeReadOnlyAgent prepends HEADLESS_READONLY_PREAMBLE and the worktree directive to every read-only prompt', () => {
+  const readOnlyAgentBody = lensPromptBody('convergeReadOnlyAgent');
+  assert.match(
+    readOnlyAgentBody,
+    /HEADLESS_READONLY_PREAMBLE.*worktreeDirective/,
+    'expected convergeReadOnlyAgent to prepend the trimmed read-only preamble and the worktree directive',
+  );
+});
+
 const taskDispatchers = [
   { name: 'runGitTask', isAsync: false },
   { name: 'runFixerTask', isAsync: false },
@@ -986,8 +979,8 @@ test('extractVerifyObjection calls parseLastVerdictFence', () => {
 });
 
 test('the headless preamble routes waits through the Monitor tool and forbids ending a turn to await work', () => {
-  const preambleStart = convergeSource.indexOf('const HEADLESS_SAFETY_PREAMBLE =');
-  assert.notEqual(preambleStart, -1, 'expected a HEADLESS_SAFETY_PREAMBLE definition');
+  const preambleStart = convergeSource.indexOf('const HEADLESS_EDIT_PREAMBLE =');
+  assert.notEqual(preambleStart, -1, 'expected a HEADLESS_EDIT_PREAMBLE definition');
   const preambleEnd = convergeSource.indexOf('\n\nlet activeRepoPath', preambleStart);
   assert.notEqual(preambleEnd, -1, 'expected the preamble to end before activeRepoPath');
   const preamble = convergeSource.slice(preambleStart, preambleEnd);
@@ -998,7 +991,7 @@ test('the headless preamble routes waits through the Monitor tool and forbids en
 });
 
 test('the preamble describes the Monitor wait by its real contract: a bounded until-loop consuming notifications as they arrive, rather than an in-turn synchronous return', () => {
-  const blockStart = convergeSource.indexOf('const HEADLESS_SAFETY_PREAMBLE =');
+  const blockStart = convergeSource.indexOf('const HEADLESS_EDIT_PREAMBLE =');
   assert.ok(blockStart !== -1, 'expected a wait-safety preamble to exist');
   const blockEnd = convergeSource.indexOf('\n\nlet activeRepoPath', blockStart);
   assert.ok(blockEnd !== -1, 'expected the preamble to end before activeRepoPath');
@@ -1129,8 +1122,8 @@ test('every convergeAgent spawn options object carries a model and effort tier',
   }
 });
 
-test('the four review lenses run on the opusMedium tier', () => {
-  for (const label of ['lens:bugbot', 'lens:code-review', 'lens:bug-audit', 'lens:reuse']) {
+test('the semantic review lenses and the terminal Bugbot gate run on the opusMedium tier', () => {
+  for (const label of ['lens:bugbot', 'lens:code-review', 'lens:bug-audit', 'lens:self-review', 'lens:reuse']) {
     assert.match(
       optionsLineForLabel(label),
       /\.\.\.TIERS\.opusMedium/,
@@ -1139,6 +1132,14 @@ test('the four review lenses run on the opusMedium tier', () => {
   }
 });
 
+test('the deterministic static sweep runs on the cheaper sonnetMedium tier', () => {
+  assert.match(
+    optionsLineForLabel('lens:static-sweep'),
+    /\.\.\.TIERS\.sonnetMedium/,
+    'expected the deterministic static sweep to run on the sonnet tier, not opus',
+  );
+});
+
 test('the copilot gate runs on the haikuLow tier', () => {
   assert.match(optionsLineForLabel('copilot-gate'), /\.\.\.TIERS\.haikuLow/);
 });
@@ -1161,8 +1162,8 @@ test('the preflight-git task returns the changed-file list and diffstat for the
   assert.match(schema, /required:[^\n]*'changedFiles'[^\n]*'diffstat'/);
 });
 
-test('each per-round lens and the reuse lens inject the preflight changed-file context', () => {
-  for (const builder of ['runBugbotLens', 'runCodeReviewLens', 'runAuditLens', 'runReuseAuditPass']) {
+test('each per-round lens, the static sweep, the reuse lens, and the terminal Bugbot gate inject the preflight changed-file context', () => {
+  for (const builder of ['runStaticSweep', 'runCodeReviewLens', 'runAuditLens', 'runSelfReviewLens', 'runReuseAuditPass', 'runBugbotLens']) {
     assert.match(
       lensPromptBody(builder),
       /renderLensDiffContext\(preflightResult\)/,

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

@@ -16,12 +16,36 @@ function functionBody(functionName) {
 }
 
 const productionModule = new Function(
-  `${functionBody('classifyCopilotOutcome')}\n` +
+  `${functionBody('classifyReviewerGateOutcome')}\n` +
+    `${functionBody('classifyCopilotOutcome')}\n` +
+    `${functionBody('hasCodeConcernFinding')}\n` +
+    `${functionBody('buildUserReview')}\n` +
     `${functionBody('resolveCopilotDown')}\n` +
     `${functionBody('resolveReviewerDown')}\n` +
-    'return { classifyCopilotOutcome, resolveCopilotDown, resolveReviewerDown };',
+    'return { classifyReviewerGateOutcome, classifyCopilotOutcome, hasCodeConcernFinding, buildUserReview, resolveCopilotDown, resolveReviewerDown };',
 )();
-const { classifyCopilotOutcome, resolveCopilotDown, resolveReviewerDown } = productionModule;
+const {
+  classifyReviewerGateOutcome,
+  classifyCopilotOutcome,
+  hasCodeConcernFinding,
+  buildUserReview,
+  resolveCopilotDown,
+  resolveReviewerDown,
+} = productionModule;
+
+function copilotFinding(overrides) {
+  return {
+    file: 'a.py',
+    line: 1,
+    severity: 'P1',
+    category: 'bug',
+    tier: 'self-healing',
+    title: 't',
+    detail: 'd',
+    replyToCommentId: null,
+    ...overrides,
+  };
+}
 
 function copilotResult(overrides) {
   return {
@@ -34,26 +58,26 @@ function copilotResult(overrides) {
 }
 
 test('an out-of-usage Copilot result (down) routes to the down kind', () => {
-  const outcome = classifyCopilotOutcome(copilotResult({ clean: true, down: true }));
+  const outcome = classifyReviewerGateOutcome(copilotResult({ clean: true, down: true }));
   assert.equal(outcome.kind, 'down');
 });
 
 test('a down Copilot result routes to down even when clean is false', () => {
-  const outcome = classifyCopilotOutcome(copilotResult({ clean: false, down: true }));
+  const outcome = classifyReviewerGateOutcome(copilotResult({ clean: false, down: true }));
   assert.equal(outcome.kind, 'down');
 });
 
 test('a dead Copilot gate agent retries rather than passing', () => {
-  assert.equal(classifyCopilotOutcome(null).kind, 'retry');
+  assert.equal(classifyReviewerGateOutcome(null).kind, 'retry');
 });
 
 test('a reachable Copilot gate with no findings and no clean verdict retries', () => {
-  const outcome = classifyCopilotOutcome(copilotResult({ clean: false, down: false }));
+  const outcome = classifyReviewerGateOutcome(copilotResult({ clean: false, down: false }));
   assert.equal(outcome.kind, 'retry');
 });
 
 test('Copilot findings route to a fix when Copilot is reachable and not down', () => {
-  const outcome = classifyCopilotOutcome(
+  const outcome = classifyReviewerGateOutcome(
     copilotResult({
       findings: [
         {
@@ -71,6 +95,61 @@ test('Copilot findings route to a fix when Copilot is reachable and not down', (
   assert.equal(outcome.kind, 'fix');
 });
 
+test('self-healing-only Copilot findings route to a fix when Copilot is reachable and not down', () => {
+  const outcome = classifyCopilotOutcome(
+    copilotResult({
+      findings: [copilotFinding({ tier: 'self-healing' })],
+    }),
+  );
+  assert.equal(outcome.kind, 'fix');
+});
+
+test('a code-concern Copilot finding routes to user-review rather than an auto-fix', () => {
+  const outcome = classifyCopilotOutcome(
+    copilotResult({
+      reviewUrl: 'https://github.com/o/r/pull/1#pullrequestreview-9',
+      findings: [copilotFinding({ tier: 'code-concern', severity: 'P0' })],
+    }),
+  );
+  assert.equal(outcome.kind, 'user-review');
+  assert.equal(outcome.findings.length, 1);
+});
+
+test('a mixed round with one code-concern finding routes the whole round to user-review', () => {
+  const outcome = classifyCopilotOutcome(
+    copilotResult({
+      findings: [
+        copilotFinding({ tier: 'self-healing' }),
+        copilotFinding({ tier: 'code-concern', file: 'b.py', line: 2 }),
+      ],
+    }),
+  );
+  assert.equal(outcome.kind, 'user-review');
+});
+
+test('hasCodeConcernFinding treats a missing or unexpected tier as a code concern', () => {
+  assert.equal(hasCodeConcernFinding([copilotFinding({ tier: 'self-healing' })]), false);
+  assert.equal(hasCodeConcernFinding([copilotFinding({ tier: 'code-concern' })]), true);
+  assert.equal(hasCodeConcernFinding([{ file: 'a.py', line: 1 }]), true);
+});
+
+test('buildUserReview carries the review URL and pares findings to the triage fields', () => {
+  const reviewUrl = 'https://github.com/o/r/pull/1#pullrequestreview-9';
+  const userReview = buildUserReview(
+    copilotResult({ reviewUrl }),
+    [copilotFinding({ tier: 'code-concern', severity: 'P0', title: 'unsafe eval', detail: 'ignored' })],
+  );
+  assert.equal(userReview.reviewUrl, reviewUrl);
+  assert.deepEqual(userReview.findings, [
+    { file: 'a.py', line: 1, severity: 'P0', tier: 'code-concern', title: 'unsafe eval' },
+  ]);
+});
+
+test('buildUserReview defaults a missing review URL to an empty string', () => {
+  const userReview = buildUserReview(copilotResult({}), [copilotFinding({ tier: 'code-concern' })]);
+  assert.equal(userReview.reviewUrl, '');
+});
+
 test('COPILOT_SCHEMA carries a required down field', () => {
   const schemaStart = convergeSource.indexOf('const COPILOT_SCHEMA =');
   const schemaEnd = convergeSource.indexOf('const REVIEWER_AVAILABILITY_SCHEMA =');
@@ -85,6 +164,52 @@ test('COPILOT_SCHEMA carries a required down field', () => {
   );
 });
 
+test('the tier enum constant names both routing tiers', () => {
+  const tiersMatch = convergeSource.match(/const COPILOT_FINDING_TIERS = \[([^\]]*)\]/);
+  assert.notEqual(tiersMatch, null, 'expected a COPILOT_FINDING_TIERS constant');
+  assert.match(tiersMatch[1], /'self-healing'/, 'expected the tier enum to name self-healing');
+  assert.match(tiersMatch[1], /'code-concern'/, 'expected the tier enum to name code-concern');
+});
+
+test('COPILOT_SCHEMA findings carry a required tier enum drawn from the tier constant', () => {
+  const schemaStart = convergeSource.indexOf('const COPILOT_FINDINGS_SCHEMA =');
+  const schemaEnd = convergeSource.indexOf('const COPILOT_SCHEMA =');
+  assert.notEqual(schemaStart, -1, 'expected COPILOT_FINDINGS_SCHEMA to exist');
+  const schemaSource = convergeSource.slice(schemaStart, schemaEnd);
+  assert.match(schemaSource, /tier:\s*\{/, 'expected a tier property on the Copilot finding schema');
+  assert.match(schemaSource, /enum:\s*COPILOT_FINDING_TIERS/, 'expected the tier enum to draw from the tier constant');
+  assert.match(schemaSource, /required:\s*\[[^\]]*'tier'[^\]]*\]/, 'expected tier to be a required finding field');
+});
+
+test('COPILOT_SCHEMA carries a reviewUrl the user-review payload links to', () => {
+  const schemaStart = convergeSource.indexOf('const COPILOT_SCHEMA =');
+  const schemaEnd = convergeSource.indexOf('const REVIEWER_AVAILABILITY_SCHEMA =');
+  const schemaSource = convergeSource.slice(schemaStart, schemaEnd);
+  assert.match(schemaSource, /reviewUrl:\s*\{\s*type:\s*'string'/, 'expected a reviewUrl string field on COPILOT_SCHEMA');
+});
+
+test('the Copilot gate prompt tiers each finding and returns the review URL', () => {
+  const copilotPrompt = functionBody('runCopilotGate');
+  assert.match(copilotPrompt, /tier 'self-healing'/, 'expected the prompt to define the self-healing tier');
+  assert.match(copilotPrompt, /tier 'code-concern'/, 'expected the prompt to define the code-concern tier');
+  assert.match(copilotPrompt, /in doubt/i, 'expected the prompt to default to code-concern in doubt');
+  assert.match(copilotPrompt, /reviewUrl set to the Copilot review html_url/, 'expected the findings branch to return the review URL');
+});
+
+test('the COPILOT phase returns blocker user-review with the findings carried through on a code-concern outcome', () => {
+  const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
+  const finalizePhaseStart = convergeSource.indexOf("if (phase === 'FINALIZE') {", copilotPhaseStart);
+  const copilotPhase = convergeSource.slice(copilotPhaseStart, finalizePhaseStart);
+  const userReviewBranchStart = copilotPhase.indexOf("copilotOutcome.kind === 'user-review'");
+  assert.notEqual(userReviewBranchStart, -1, 'expected the COPILOT phase to handle a user-review outcome');
+  const userReviewBranch = copilotPhase.slice(userReviewBranchStart, userReviewBranchStart + 500);
+  assert.match(userReviewBranch, /blocker:\s*'user-review'/, 'expected the branch to return blocker user-review');
+  assert.match(userReviewBranch, /converged:\s*false/, 'expected the branch to return converged false');
+  assert.match(userReviewBranch, /userReview:\s*buildUserReview\(copilot, copilotOutcome\.findings\)/, 'expected the branch to carry the user-review payload');
+  const autoFixIndex = userReviewBranch.indexOf('applyFixes');
+  assert.equal(autoFixIndex, -1, 'expected the user-review branch to not auto-fix the code-concern findings');
+});
+
 test('the Copilot gate prompt detects an out-of-usage notice and returns a down result', () => {
   const copilotPrompt = functionBody('runCopilotGate');
   assert.match(
@@ -412,12 +537,12 @@ test('openStandardsFollowUpOnce gates spawnStandardsFollowUp behind the run-once
   );
 });
 
-test('both standards-deferral call sites route the create through openStandardsFollowUpOnce', () => {
+test('every standards-deferral call site routes the create through openStandardsFollowUpOnce', () => {
   const onceCalls = convergeSource.match(/await openStandardsFollowUpOnce\(/g) || [];
   assert.equal(
     onceCalls.length,
-    2,
-    'expected the converge-round and copilot standards call sites to both defer to openStandardsFollowUpOnce',
+    3,
+    'expected the converge-round, terminal-Bugbot, and Copilot standards call sites to all defer to openStandardsFollowUpOnce',
   );
   const directCreates = convergeSource.match(/await spawnStandardsFollowUp\(/g) || [];
   assert.equal(
@@ -497,8 +622,8 @@ function loadParseDeferredPr() {
 test('parseDeferredPr parses a full canonical hardening PR URL into its coordinates', () => {
   const parseDeferredPr = loadParseDeferredPr();
   assert.deepEqual(
-    parseDeferredPr('https://github.com/jl-cmd/claude-code-config/pull/824'),
-    { owner: 'jl-cmd', repo: 'claude-code-config', prNumber: 824 },
+    parseDeferredPr('https://github.com/jl-cmd/claude-dev-env/pull/824'),
+    { owner: 'jl-cmd', repo: 'claude-dev-env', prNumber: 824 },
   );
 });
 
@@ -679,7 +804,7 @@ test('a hardening-commit that opens no PR (empty hardeningPrUrl) leaves the run-
 test('a later standards-only round resolves its own review threads after the follow-up issue was already filed', async () => {
   const recordedCalls = [];
   const issueFiledNoHardening = {
-    issueUrl: 'https://github.com/jl-cmd/claude-code-config/issues/900',
+    issueUrl: 'https://github.com/jl-cmd/claude-dev-env/issues/900',
     hardeningEdited: false,
     hardeningRepoPath: '',
     hardeningBranch: '',
@@ -701,7 +826,7 @@ test('a later standards-only round resolves its own review threads after the fol
   );
   assert.equal(
     resolveCalls[0].context.issueUrl,
-    'https://github.com/jl-cmd/claude-code-config/issues/900',
+    'https://github.com/jl-cmd/claude-dev-env/issues/900',
     'expected the resolve step to reference the already-filed follow-up issue in its inline reply',
   );
 });
@@ -709,7 +834,7 @@ test('a later standards-only round resolves its own review threads after the fol
 test('a reuse-path standards round carrying no review threads spawns no thread-resolution agent', async () => {
   const recordedCalls = [];
   const issueFiledNoHardening = {
-    issueUrl: 'https://github.com/jl-cmd/claude-code-config/issues/901',
+    issueUrl: 'https://github.com/jl-cmd/claude-dev-env/issues/901',
     hardeningEdited: false,
     hardeningRepoPath: '',
     hardeningBranch: '',

package/skills/autoconverge/workflow/converge.fix-recovery.test.mjs

@@ -138,8 +138,8 @@ test('commitWithRecovery bounds the loop, re-verifies, and retries the commit on
   assert.match(recoveryBody, /commitNeedsCodeRecovery\(/, 'expected the loop guard to call commitNeedsCodeRecovery');
   assert.match(
     recoveryBody,
-    /attempt\s*<\s*FIX_RECOVERY_MAX_ATTEMPTS/,
-    'expected the loop to be bounded by FIX_RECOVERY_MAX_ATTEMPTS',
+    /attempt\s*<\s*COMMIT_RECOVERY_MAX_ATTEMPTS/,
+    'expected the commit-recovery loop to be bounded by the dedicated COMMIT_RECOVERY_MAX_ATTEMPTS cap of one',
   );
   assert.match(recoveryBody, /runRecoverEdit\(/, 'expected the loop to spawn the recover-edit fixer');
   assert.match(recoveryBody, /runVerify\(/, 'expected the loop to re-verify after the fixer edit');