claude-dev-env 2.12.0 → 2.13.0

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

@@ -1,1388 +1,53 @@
-import { test } from 'node:test';
-import { strict as assert } from 'node:assert';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const workflowDirectory = dirname(fileURLToPath(import.meta.url));
-const convergeSource = readFileSync(join(workflowDirectory, 'converge.mjs'), 'utf8');
-const gotchasSource = readFileSync(
-  join(workflowDirectory, '..', 'reference', 'gotchas.md'),
-  'utf8',
-);
-const skillSource = readFileSync(
-  join(workflowDirectory, '..', 'SKILL.md'),
-  'utf8',
-);
-const headlessSafetySource = readFileSync(
-  join(workflowDirectory, '..', 'reference', 'headless-safety.md'),
-  'utf8',
-);
-
-function lensPromptBody(builderName) {
-  let builderStart = convergeSource.indexOf(`function ${builderName}(`);
-  if (builderStart === -1) {
-    builderStart = convergeSource.indexOf(`const ${builderName} =`);
-    assert.notEqual(builderStart, -1, `expected ${builderName} to exist as a function or const`);
-  }
-  const nextBuilderMatch = /\n(?:async )?function /.exec(convergeSource.slice(builderStart + 1));
-  const builderEnd =
-    nextBuilderMatch === null ? convergeSource.length : builderStart + 1 + nextBuilderMatch.index;
-  return convergeSource.slice(builderStart, builderEnd);
-}
-
-function functionSource(functionName) {
-  const functionStart = convergeSource.indexOf(`function ${functionName}(`);
-  assert.notEqual(functionStart, -1, `expected ${functionName} to exist`);
-  const nextMatch = /\n(?:async )?function /.exec(convergeSource.slice(functionStart + 1));
-  const functionEnd =
-    nextMatch === null ? convergeSource.length : functionStart + 1 + nextMatch.index;
-  return convergeSource.slice(functionStart, functionEnd);
-}
-
-function docstringBefore(functionName) {
-  const functionStart = convergeSource.indexOf(`function ${functionName}(`);
-  assert.notEqual(functionStart, -1, `expected ${functionName} to exist`);
-  const docStart = convergeSource.lastIndexOf('/**', functionStart);
-  assert.notEqual(docStart, -1, `expected a JSDoc block before ${functionName}`);
-  return convergeSource.slice(docStart, functionStart);
-}
-
-test('code-review lens prompt no longer instructs a per-lens git fetch', () => {
-  assert.doesNotMatch(lensPromptBody('runCodeReviewLens'), /git fetch origin main/);
-});
-
-test('bug-audit lens prompt no longer instructs a per-lens git fetch', () => {
-  assert.doesNotMatch(lensPromptBody('runAuditLens'), /git fetch origin 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(preflightCallIndex, -1, 'expected the merged preflight to be invoked');
-  assert.notEqual(parallelLensIndex, -1, 'expected the parallel lens block to exist');
-  assert.ok(
-    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, copilot, bugbot} schema');
-});
-
-test('the merged preflight-git agent spreads the haikuLow tier', () => {
-  const gitTaskBody = functionSource('runGitTask');
-  assert.match(
-    gitTaskBody,
-    /\.\.\.TIERS\.haikuLow/,
-    'expected the git-utility agent to spread the single-sourced haikuLow tier rather than inline model/effort literals',
-  );
-  assert.doesNotMatch(
-    gitTaskBody,
-    /model: 'haiku', effort: 'low'/,
-    'expected no inline haikuLow literals duplicating the TIERS definition',
-  );
-});
-
-test('the preflight-git prompt states the correct number of read-only steps it enumerates', () => {
-  const body = functionSource('runGitTask');
-  assert.match(
-    body,
-    /Run five read-only preflight steps/,
-    'expected the stated step count to match the five enumerated STEP blocks',
-  );
-  assert.match(body, /STEP 5 —/, 'expected the fifth step to be enumerated');
-  assert.doesNotMatch(body, /Run four read-only preflight steps/);
-});
-
-test('the runGitTask docstring names the diff enumeration and its changedFiles/diffstat return fields', () => {
-  const doc = docstringBefore('runGitTask');
-  assert.match(doc, /diff|changed-file|enumerat/i, 'expected the docstring to name the diff enumeration operation');
-  assert.match(doc, /changedFiles/, 'expected the docstring return shape to name changedFiles');
-  assert.match(doc, /diffstat/, 'expected the docstring return shape to name diffstat');
-});
-
-test('the reviewer-availability probe rides the merged preflight-git spawn, not a separate agent', () => {
-  assert.equal(
-    convergeSource.indexOf('runReviewerAvailabilityCheck'),
-    -1,
-    'expected no separate reviewer-availability agent — the probe rides the preflight-git git-utility spawn',
-  );
-  const gitTaskBody = functionSource('runGitTask');
-  assert.match(gitTaskBody, /reviewer_availability\.py/, 'expected the merged preflight to run the reviewer-availability probe');
-  assert.match(gitTaskBody, /--reviewer copilot/);
-  assert.match(gitTaskBody, /--reviewer bugbot/);
-  const preflightAssignIndex = convergeSource.indexOf('reviewerAvailability = preflight');
-  const parallelLensIndex = convergeSource.indexOf('const lenses = await parallel(');
-  assert.notEqual(preflightAssignIndex, -1, 'expected reviewerAvailability to be read from the preflight-git result');
-  assert.ok(
-    preflightAssignIndex < parallelLensIndex,
-    'expected reviewer availability to be carried from preflight before the parallel lenses spawn',
-  );
-});
-
-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 lensArrayEnd = convergeSource.indexOf('])', parallelLensIndex);
-  const lensArray = convergeSource.slice(parallelLensIndex, lensArrayEnd);
-  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', () => {
-  assert.match(
-    convergeSource,
-    /const REVIEWER_GATE_SENTINEL = 'CLAUDE_REVIEWER_GATE=autoconverge '/,
-    'expected the shared sentinel constant to exist',
-  );
-  const copilotPrompt = lensPromptBody('runCopilotGate');
-  assert.match(
-    copilotPrompt,
-    /\$\{REVIEWER_GATE_SENTINEL\}gh api --method POST[^\n]*requested_reviewers/,
-    'expected the Copilot requested_reviewers trigger to carry the sentinel prefix',
-  );
-  const bugbotPrompt = lensPromptBody('runBugbotLens');
-  assert.match(
-    bugbotPrompt,
-    /\$\{REVIEWER_GATE_SENTINEL\}python "\$\{CONFIG\.sharedScripts\}\/post_fix_reply\.py"[^\n]*--body "bugbot run"/,
-    'expected the Bugbot rerun-comment trigger to carry the sentinel prefix',
-  );
-});
-
-test('bugbot lens preamble does not blanket-instruct passing --owner/--repo to every script', () => {
-  const bugbotPrompt = lensPromptBody('runBugbotLens');
-  assert.doesNotMatch(
-    bugbotPrompt,
-    /use the existing scripts; pass --owner/,
-    'the blanket clause breaks reviews_disabled.py, which accepts only --reviewer',
-  );
-});
-
-test('bugbot lens invokes reviews_disabled.py with only --reviewer', () => {
-  const bugbotPrompt = lensPromptBody('runBugbotLens');
-  const reviewsDisabledIndex = bugbotPrompt.indexOf('reviews_disabled.py');
-  assert.notEqual(reviewsDisabledIndex, -1, 'expected reviews_disabled.py invocation');
-  const invocationLineEnd = bugbotPrompt.indexOf('\\n', reviewsDisabledIndex);
-  const invocationLine = bugbotPrompt.slice(reviewsDisabledIndex, invocationLineEnd);
-  assert.match(invocationLine, /--reviewer bugbot/);
-  assert.doesNotMatch(
-    invocationLine,
-    /--owner|--repo/,
-    'reviews_disabled.py argparse rejects --owner/--repo with SystemExit(2)',
-  );
-});
-
-test('gotchas doc states parallel lenses must avoid concurrent git operations', () => {
-  assert.doesNotMatch(gotchasSource, /cannot race on git state/);
-  assert.match(gotchasSource, /fetch.*once.*before/i);
-});
-
-test('repair-convergence edit step filters unresolved threads to bot authors and skips human threads', () => {
-  const repairPrompt = functionSource('runCodeEditorTask');
-  assert.match(
-    repairPrompt,
-    /cursor.*claude.*copilot|copilot.*cursor.*claude|claude.*cursor.*copilot/is,
-    'expected the bot-author allowlist (Cursor/Claude/Copilot) to be named',
-  );
-  assert.match(
-    repairPrompt,
-    /skip.*human|human.*skip/is,
-    'expected an explicit instruction to skip human reviewer threads',
-  );
-});
-
-test('repair-convergence edit step no longer instructs resolving every unresolved thread without an author filter', () => {
-  const repairPrompt = functionSource('runCodeEditorTask');
-  assert.doesNotMatch(
-    repairPrompt,
-    /fetch every thread where isResolved is false/,
-    'the unfiltered instruction could resolve human reviewer threads',
-  );
-});
-
-test('the bugbot lens waits through the Monitor tool, not a foreground sleep', () => {
-  const bugbotPrompt = lensPromptBody('runBugbotLens');
-  assert.match(bugbotPrompt, /Monitor tool/, 'expected the bugbot poll to wait via the Monitor tool');
-  assert.doesNotMatch(
-    bugbotPrompt,
-    /sleep 60|sleep 8|Start-Sleep/,
-    'expected no foreground sleep in the bugbot poll delays',
-  );
-});
-
-test('the copilot gate waits through the Monitor tool, not a foreground sleep', () => {
-  const copilotPrompt = lensPromptBody('runCopilotGate');
-  assert.match(copilotPrompt, /Monitor tool/, 'expected the copilot poll to wait via the Monitor tool');
-  assert.doesNotMatch(copilotPrompt, /sleep 360|Start-Sleep/, 'expected no foreground sleep in the copilot poll delay');
-});
-
-test('gotchas doc describes the reviewer wait as a Monitor poll, not a foreground sleep', () => {
-  assert.match(gotchasSource, /Monitor tool/, 'expected the gotcha to name the Monitor-based reviewer wait');
-  assert.doesNotMatch(
-    gotchasSource,
-    /shell-agnostic/i,
-    'the reviewer wait is a Monitor poll, not a shell-agnostic sleep loop',
-  );
-});
-
-function finalizeRepairBranch() {
-  const repairCallIndex = convergeSource.indexOf('await repairConvergence(');
-  assert.notEqual(repairCallIndex, -1, 'expected the FINALIZE repair call to exist');
-  const transitionIndex = convergeSource.indexOf("phase = 'CONVERGE'", repairCallIndex);
-  assert.notEqual(transitionIndex, -1, 'expected a CONVERGE transition after the repair call');
-  const continueIndex = convergeSource.indexOf('continue', transitionIndex);
-  assert.notEqual(continueIndex, -1, 'expected a continue statement to close the FINALIZE repair branch');
-  const branchEnd = continueIndex + 'continue'.length;
-  return convergeSource.slice(repairCallIndex, branchEnd);
-}
-
-test('the FINALIZE repair branch does not re-assign head from the repair before re-converging', () => {
-  assert.doesNotMatch(
-    finalizeRepairBranch(),
-    /head\s*=\s*repair/,
-    'the next CONVERGE pass re-resolves HEAD from GitHub, so assigning the repair SHA here is dead',
-  );
-});
-
-function fixBranchAfter(branchLabel) {
-  const labelIndex = convergeSource.indexOf(branchLabel);
-  assert.notEqual(labelIndex, -1, `expected the ${branchLabel} marker to exist`);
-  const applyFixesIndex = convergeSource.indexOf('await applyFixes(', labelIndex);
-  assert.notEqual(applyFixesIndex, -1, `expected an applyFixes call after ${branchLabel}`);
-  const continueIndex = convergeSource.indexOf('continue', applyFixesIndex);
-  assert.notEqual(continueIndex, -1, `expected a continue statement to close the ${branchLabel} branch`);
-  const branchEnd = continueIndex + 'continue'.length;
-  return convergeSource.slice(applyFixesIndex, branchEnd);
-}
-
-test('the CONVERGE fix branch does not re-assign head from the fix before re-converging', () => {
-  assert.doesNotMatch(
-    fixBranchAfter('${findings.length} finding(s) — applying fixes'),
-    /head\s*=\s*fixProgress/,
-    'the next CONVERGE pass re-resolves HEAD from GitHub, so assigning the fix SHA here is dead',
-  );
-});
-
-test('the COPILOT fix branch does not re-assign head from the fix before re-converging', () => {
-  assert.doesNotMatch(
-    fixBranchAfter('${roundFindings.length} finding(s) — fixing and re-converging'),
-    /head\s*=\s*fixProgress/,
-    'the CONVERGE pass it transitions to re-resolves HEAD from GitHub, so assigning the fix SHA here is dead',
-  );
-});
-
-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 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('the CONVERGE branch refreshes preflight when the availability enumeration was computed against a different SHA than the head under review', () => {
-  const convergeBranchStart = convergeSource.indexOf("if (phase === 'CONVERGE')");
-  assert.notEqual(convergeBranchStart, -1, 'expected the CONVERGE branch to exist');
-  const guardIndex = convergeSource.indexOf('if (!isResolvedHeadUsable(head)', convergeBranchStart);
-  assert.notEqual(guardIndex, -1, 'expected the refresh guard to exist');
-  const guardLine = convergeSource.slice(guardIndex, convergeSource.indexOf('\n', guardIndex));
-  assert.match(
-    guardLine,
-    /reviewerAvailability\?\.sha !== head/,
-    'expected the refresh guard to fire when the reviewerAvailability changed-file enumeration was computed against a SHA other than the current head, so a rebase or reuse push that advances HEAD before round 1 hands the lenses the diff for the head they actually review',
-  );
-});
-
-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,
-    9,
-    'expected head invalidation after the static-sweep fix push, the CONVERGE fix push, the terminal-Bugbot fix push, the COPILOT fix push, the CODEX 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',
-  );
-});
-
-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', () => {
-  const editPrompt = functionSource('runCodeEditorTask');
-  assert.match(editPrompt, /PRRT/, 'expected the thread node id form (PRRT_...) to be named');
-  assert.match(
-    editPrompt,
-    /databaseId/,
-    'expected the GraphQL lookup matching comment databaseId to be named',
-  );
-  assert.match(
-    editPrompt,
-    /not the numeric comment id/,
-    'expected an explicit guard against passing the numeric comment id to resolve_thread',
-  );
-});
-
-test('fix edit prompt does not pass the numeric comment id straight to resolve_thread', () => {
-  assert.doesNotMatch(
-    functionSource('runCodeEditorTask'),
-    /then resolve that thread \(use the github MCP pull_request_review_write/,
-    'resolve_thread and resolveReviewThread require a PRRT_... thread node id, not the comment id',
-  );
-});
-
-test('the fix flow runs the edit task then fixerWithRecovery after the edit step', () => {
-  const applyFixesBody = lensPromptBody('applyFixes');
-  assert.match(applyFixesBody, /runCodeEditorTask\('fix-edit'/, "expected applyFixes to call runCodeEditorTask('fix-edit')");
-  assert.match(applyFixesBody, /fixerWithRecovery\(/, 'expected applyFixes to call fixerWithRecovery');
-});
-
-test('the shared verdict-fence builder names the binding-hash command and the verdict fence', () => {
-  const fenceBuilder = lensPromptBody('buildVerdictFenceSteps');
-  assert.match(
-    fenceBuilder,
-    /--manifest-hash-for-branch/,
-    'expected the binding-hash command to use --manifest-hash-for-branch (cwd-immune)',
-  );
-  assert.doesNotMatch(
-    fenceBuilder,
-    /--manifest-hash(?!-for-branch)/,
-    'expected the old --manifest-hash <REPO> form to be removed in favour of --manifest-hash-for-branch',
-  );
-  assert.match(
-    fenceBuilder,
-    /verification_verdict_store\.py/,
-    'expected the verdict-store script that computes the binding hash to be named',
-  );
-  assert.match(fenceBuilder, /buildVerdictFenceTail\(/, 'expected the fence builder to close with the shared fence tail');
-  const renderedFenceTail = loadVerdictFenceTailBuilder()('');
-  assert.match(renderedFenceTail, /```verdict/, 'expected the verdict fence to be specified');
-  assert.ok(
-    renderedFenceTail.includes(VERDICT_FENCE_JSON_LINE),
-    'expected the verdict fence to carry manifest_sha256',
-  );
-  assert.match(
-    fenceBuilder,
-    /gh pr view/,
-    'expected buildVerdictFenceSteps to resolve the head branch via gh pr view (cwd-immune)',
-  );
-  assert.match(
-    fenceBuilder,
-    /headRefName/,
-    'expected buildVerdictFenceSteps to extract the headRefName from gh pr view output',
-  );
-});
-
-test('the incomplete-verdict contract sentence is written once and used by both verify paths', () => {
-  const sentenceOccurrences = convergeSource.split(
-    'name that check in prose directly above the fence rather than in findings',
-  ).length - 1;
-  assert.equal(
-    sentenceOccurrences,
-    1,
-    'expected the incomplete-verdict contract sentence to be written exactly once so the two verify paths cannot drift',
-  );
-  assert.match(
-    lensPromptBody('buildVerdictFenceTail'),
-    /VERDICT_FENCE_CONTRACT_SENTENCE/,
-    'expected the shared fence tail to use the one contract sentence',
-  );
-  assert.match(
-    lensPromptBody('buildVerdictFenceSteps'),
-    /buildVerdictFenceTail\(/,
-    'expected the gh-lookup fence builder to reach the contract sentence through the shared fence tail',
-  );
-  assert.match(
-    lensPromptBody('runVerifierTask'),
-    /buildVerdictFenceTail\(/,
-    'expected the hardening-verify prompt to reach the contract sentence through the shared fence tail',
-  );
-});
-
-const VERDICT_FENCE_JSON_LINE = '{"all_pass": true, "findings": [], "manifest_sha256": "<that hash>"}';
-const VERDICT_FENCE_LEAD_IN = 'END your message with a fenced verdict block exactly in this shape';
-
-function countOccurrences(haystack, needle) {
-  return haystack.split(needle).length - 1;
-}
-
-function loadVerdictFenceTailBuilder() {
-  const sentenceMatch = /const VERDICT_FENCE_CONTRACT_SENTENCE =\s*\n?\s*'[^']*'/.exec(convergeSource);
-  assert.notEqual(sentenceMatch, null, 'expected VERDICT_FENCE_CONTRACT_SENTENCE to be declared as one string literal');
-  const builderSource = lensPromptBody('buildVerdictFenceTail');
-  return new Function(
-    `${sentenceMatch[0]}\n${builderSource}\nreturn buildVerdictFenceTail;`,
-  )();
-}
-
-test('the verdict fence recipe is written once — no verify path re-inlines its own copy', () => {
-  assert.equal(
-    countOccurrences(convergeSource, VERDICT_FENCE_JSON_LINE),
-    1,
-    'expected the verdict fence JSON skeleton to be written exactly once so no verify path can drift from the shared recipe',
-  );
-  assert.equal(
-    countOccurrences(convergeSource, VERDICT_FENCE_LEAD_IN),
-    1,
-    'expected the fence lead-in sentence to be written exactly once so no verify path can drift from the shared recipe',
-  );
-  assert.match(
-    lensPromptBody('buildVerdictFenceSteps'),
-    /buildVerdictFenceTail\(/,
-    'expected the gh-lookup binding path to render its fence through the shared tail builder',
-  );
-  assert.match(
-    lensPromptBody('runVerifierTask'),
-    /buildVerdictFenceTail\(/,
-    'expected the hardening-verify path to render its fence through the shared tail builder',
-  );
-});
-
-test('the shared fence tail renders the same fence JSON and contract sentence at every indent', () => {
-  const buildVerdictFenceTail = loadVerdictFenceTailBuilder();
-  const topLevelTail = buildVerdictFenceTail('');
-  const nestedTail = buildVerdictFenceTail('   ');
-  for (const [siteName, renderedTail] of [['top-level', topLevelTail], ['nested', nestedTail]]) {
-    assert.ok(
-      renderedTail.includes(VERDICT_FENCE_JSON_LINE),
-      `expected the ${siteName} fence tail to carry the verdict JSON skeleton`,
-    );
-    assert.ok(
-      renderedTail.includes(VERDICT_FENCE_LEAD_IN),
-      `expected the ${siteName} fence tail to carry the fence lead-in sentence`,
-    );
-    assert.ok(
-      renderedTail.includes('```verdict'),
-      `expected the ${siteName} fence tail to open a verdict fence`,
-    );
-    assert.ok(
-      renderedTail.includes('name that check in prose directly above the fence rather than in findings'),
-      `expected the ${siteName} fence tail to carry the one incomplete-verdict contract sentence`,
-    );
-  }
-  assert.equal(
-    nestedTail,
-    topLevelTail.split('\n').map((eachLine) => `   ${eachLine}`).join('\n'),
-    'expected indent to be the only difference between the two rendered fence tails',
-  );
-});
-
-test('the verdict-fence binding does not self-resolve a cwd via git rev-parse for the manifest hash', () => {
-  const fenceBuilder = lensPromptBody('buildVerdictFenceSteps');
-  assert.doesNotMatch(
-    fenceBuilder,
-    /git rev-parse --show-toplevel/,
-    'expected the binding hash to be cwd-immune (no git rev-parse in the binding step)',
-  );
-});
-
-test('every verify step calls buildVerdictFenceSteps, uses code-verifier, and forbids editing the tree under verification', () => {
-  for (const verifyFunctionName of ['runVerifierTask']) {
-    const verifyBody = lensPromptBody(verifyFunctionName);
-    assert.match(
-      verifyBody,
-      /buildVerdictFenceSteps\(/,
-      `expected ${verifyFunctionName} to call buildVerdictFenceSteps (cwd-immune branch binding)`,
-    );
-    assert.match(
-      verifyBody,
-      /agentType:\s*'code-verifier'/,
-      `expected ${verifyFunctionName} to spawn the code-verifier agent type`,
-    );
-    assert.doesNotMatch(
-      verifyBody,
-      /schema:/,
-      `expected ${verifyFunctionName} to pass no schema so its verdict fence stays as assistant text`,
-    );
-    assert.match(
-      verifyBody,
-      /(?:no|not|never)[^.\n]{0,30}edit[^.\n]{0,40}tree[^.\n]{0,30}(?:under|being)\s+verif/i,
-      `expected ${verifyFunctionName} to forbid editing the tree under verification (a deliberate break off that tree stays allowed)`,
-    );
-  }
-});
-
-test('runFixerTask never verifies — verification belongs to the separate verifier', () => {
-  const fixerBody = lensPromptBody('runFixerTask');
-  assert.doesNotMatch(fixerBody, /buildVerdictFenceSteps\(/, 'expected the fixer to not emit a verdict fence — the separate verifier does');
-  assert.doesNotMatch(fixerBody, /agentType:\s*'code-verifier'/, 'expected the fixer to be clean-coder only');
-  assert.match(fixerBody, /agentType:\s*'clean-coder'/, 'expected the fixer to use clean-coder for its commit and recovery edits');
-});
-
-test('runVerifierTask uses --manifest-hash-for-branch with the hardening branch and forbids editing the tree under verification', () => {
-  const verifyBody = lensPromptBody('runVerifierTask');
-  assert.match(
-    verifyBody,
-    /--manifest-hash-for-branch/,
-    'expected the verifier to bind by hardening branch (cwd-immune)',
-  );
-  assert.match(
-    verifyBody,
-    /(?:no|not|never)[^.\n]{0,30}edit[^.\n]{0,40}tree[^.\n]{0,30}(?:under|being)\s+verif/i,
-    'expected the verifier to forbid editing the tree under verification (a deliberate break off that tree stays allowed)',
-  );
-});
-
-test('runVerifierTask passes PR coordinates to buildVerdictFenceSteps for the fix-verify and repair-verify tasks', () => {
-  const verifyBody = lensPromptBody('runVerifierTask');
-  assert.match(verifyBody, /task === 'fix-verify'/, 'expected runVerifierTask to carry the fix-path verify task');
-  assert.match(
-    verifyBody,
-    /buildVerdictFenceSteps\(input\.owner, input\.repo, input\.prNumber\)/,
-    'expected runVerifierTask to pass PR coordinates to buildVerdictFenceSteps',
-  );
-});
-
-test('the commit path in runFixerTask forbids further edits and uses clean-coder', () => {
-  const fixerBody = lensPromptBody('runFixerTask');
-  assert.match(
-    fixerBody,
-    /no (?:further |additional )?(?:file )?edits|do not edit|make no edits/i,
-    'expected the commit path to forbid further edits',
-  );
-  assert.match(
-    fixerBody,
-    /agentType:\s*'clean-coder'/,
-    'expected the commit path to use clean-coder',
-  );
-});
-
-test('the repair flow uses the direct-spawn task helpers for edit, verify, and commit', () => {
-  const repairBody = lensPromptBody('repairConvergence');
-  assert.match(repairBody, /runCodeEditorTask\(/, 'expected repairConvergence to call runCodeEditorTask');
-  assert.match(repairBody, /runVerifierTask\(/, 'expected repairConvergence to call runVerifierTask');
-  assert.match(repairBody, /verdictPassed\(/, 'expected the verify verdict to gate the repair commit step');
-});
-
-test('the standards-deferral flow uses the direct-spawn task helpers for edit, verify, and commit', () => {
-  const standardsBody = lensPromptBody('spawnStandardsFollowUp');
-  assert.match(standardsBody, /runCodeEditorTask\(/, 'expected spawnStandardsFollowUp to call runCodeEditorTask');
-  assert.match(standardsBody, /runVerifierTask\(/, 'expected spawnStandardsFollowUp to call runVerifierTask');
-  assert.match(standardsBody, /verdictPassed\(/, 'expected the verify verdict to gate the hardening commit step');
-});
-
-test('repair-commit and hardening-commit paths use clean-coder and forbid edits', () => {
-  const codeEditorBody = lensPromptBody('runCodeEditorTask');
-  assert.match(
-    codeEditorBody,
-    /no (?:further |additional )?(?:file )?edits|do not edit|make no edits/i,
-    'expected the commit paths to forbid further edits',
-  );
-  assert.match(
-    codeEditorBody,
-    /agentType:\s*'clean-coder'/,
-    'expected the commit paths to use clean-coder',
-  );
-});
-
-test('the code-editor standards-edit path stages hardening without committing and uses clean-coder', () => {
-  const editBody = lensPromptBody('runCodeEditorTask');
-  assert.match(
-    editBody,
-    /do not commit and do not push|NO commit and NO push|Do NOT commit/i,
-    'expected the standards edit path to leave the hardening change uncommitted',
-  );
-  assert.match(
-    editBody,
-    /agentType:\s*'clean-coder'/,
-    'expected the edit paths to use clean-coder',
-  );
-});
-
-test('spawnStandardsFollowUp reports whether a hardening PR opened on every path', () => {
-  const body = lensPromptBody('spawnStandardsFollowUp');
-  const falseReturns = body.match(/hardeningPrOpened:\s*false/g) || [];
-  assert.ok(
-    falseReturns.length >= 3,
-    'expected every skip path (hardening PR already opened, no hardening staged, verify failed) to return hardeningPrOpened:false',
-  );
-  assert.match(
-    body,
-    /const hardeningPrOpened =\s*typeof commitResult\?\.hardeningPrUrl === 'string' && commitResult\.hardeningPrUrl\.length > 0/,
-    'expected the commit path to derive hardeningPrOpened from a non-empty hardeningPrUrl, so a PR that opened with an unparseable URL still latches the guard while an empty URL (no PR opened) leaves it clear to retry',
-  );
-});
-
-test('spawnStandardsFollowUp reports the deferred PR identity on every path', () => {
-  const body = lensPromptBody('spawnStandardsFollowUp');
-  const nullDeferred = body.match(/deferredPr:\s*null/g) || [];
-  assert.ok(
-    nullDeferred.length >= 2,
-    'expected both skip paths (no hardening staged, verify failed) to return deferredPr:null',
-  );
-  assert.match(
-    body,
-    /parseDeferredPr\(commitResult\?\.hardeningPrUrl\)/,
-    'expected the commit path to parse the deferred PR identity from the commit step hardeningPrUrl',
-  );
-  assert.doesNotMatch(
-    body,
-    /hardeningPrOpened:\s*deferredPr !== null/,
-    'expected the commit path to keep hardeningPrOpened separate from the parsed deferredPr so an unparseable URL still latches the guard',
-  );
-});
-
-test('the workflow return objects carry the accumulated deferredPrs list', () => {
-  const converged = convergeSource.match(/deferredPrs/g) || [];
-  assert.ok(
-    converged.length >= 4,
-    'expected deferredPrs to be declared, pushed at both deferral call sites, and returned',
-  );
-  assert.match(
-    convergeSource,
-    /if \(standardsOutcome\?\.deferredPr\) deferredPrs\.push\(standardsOutcome\.deferredPr\)/,
-    'expected each deferral call site to accumulate the deferred PR into deferredPrs',
-  );
-});
-
-test('the standards-deferral surfaces disclose the hardening-PR state unconditionally, present or absent', () => {
-  const clauseBody = functionSource('standardsHardeningClause');
-  assert.match(
-    clauseBody,
-    /environment-hardening PR/,
-    'expected the opened-PR branch to name the hardening PR',
-  );
-  assert.match(
-    clauseBody,
-    /no environment-hardening PR/i,
-    'expected the absent-PR branch to disclose that no hardening PR was opened',
-  );
-  const coreBody = functionSource('standardsDeferralCore');
-  assert.match(
-    coreBody,
-    /remain untracked/,
-    'expected an untracked core that makes no hardening-PR claim',
-  );
-});
-
-test('every standards-deferral call site builds standardsNote from the spawnStandardsFollowUp outcome', () => {
-  const callSiteUses = convergeSource.match(/standardsNote = standardsDeferralNote\(/g) || [];
-  assert.equal(
-    callSiteUses.length,
-    4,
-    'expected the converge-round, terminal-Bugbot, Copilot, and Codex standards call sites to each build standardsNote via standardsDeferralNote(...)',
-  );
-  assert.doesNotMatch(
-    convergeSource,
-    /standardsNote = `\$\{[^}]+\} code-standard finding\(s\) deferred to a follow-up fix issue plus an environment-hardening PR/,
-    'expected no unconditional hardening-PR claim in standardsNote',
-  );
-});
-
-test('a reuse-audit lens builder exists', () => {
-  assert.match(convergeSource, /function runReuseAuditPass\(/);
-});
-
-test('the reuse pass runs once before the convergence loop', () => {
-  const reuseCallIndex = convergeSource.indexOf('await runReuseAuditPass(');
-  const loopIndex = convergeSource.indexOf('while (iterations < CONFIG.maxIterations)');
-  assert.notEqual(reuseCallIndex, -1, 'expected the reuse pass to be invoked');
-  assert.notEqual(loopIndex, -1, 'expected the convergence loop to exist');
-  assert.ok(
-    reuseCallIndex < loopIndex,
-    'expected the reuse pass to run before the convergence loop starts',
-  );
-});
-
-test('the reuse lens prompt enumerates all three qualifying criteria and an omit rule', () => {
-  const reusePrompt = lensPromptBody('runReuseAuditPass');
-  assert.match(reusePrompt, /CERTAIN/);
-  assert.match(reusePrompt, /BEHAVIORALLY IDENTICAL/);
-  assert.match(reusePrompt, /AUTONOMOUSLY IMPLEMENTABLE/);
-  assert.match(
-    reusePrompt,
-    /when any one is in doubt, omit the finding/i,
-    'expected the reuse lens to drop any finding that fails a criterion',
-  );
-});
-
-test('the reuse lens reviews the full diff and does not edit', () => {
-  const reusePrompt = lensPromptBody('runReuseAuditPass');
-  assert.match(reusePrompt, /origin\/main\.\.\.HEAD/);
-  assert.match(
-    reusePrompt,
-    /Do NOT edit, commit, or push/,
-    'expected the reuse lens to report findings without editing',
-  );
-});
-
-test('the reuse pass applies its findings through applyFixes, not the standards-deferral path', () => {
-  const reuseCallIndex = convergeSource.indexOf('await runReuseAuditPass(');
-  const loopIndex = convergeSource.indexOf('while (iterations < CONFIG.maxIterations)');
-  const reuseBlock = convergeSource.slice(reuseCallIndex, loopIndex);
-  assert.match(
-    reuseBlock,
-    /applyFixes\(head, reuseFindings, 'reuse-pass'\)/,
-    'expected the reuse pass to apply its findings via applyFixes',
-  );
-  assert.doesNotMatch(
-    reuseBlock,
-    /spawnStandardsFollowUp/,
-    'expected the reuse pass to apply improvements, not defer them',
-  );
-});
-
-test('the reuse lens runs under the Reuse phase', () => {
-  const reusePrompt = lensPromptBody('runReuseAuditPass');
-  assert.match(reusePrompt, /phase: 'Reuse'/);
-});
-
-test('the pre-commit gate step is a shared constant that dry-runs the CODE_RULES commit gate', () => {
-  assert.match(convergeSource, /const PRE_COMMIT_GATE_STEP =/);
-  const stepStart = convergeSource.indexOf('const PRE_COMMIT_GATE_STEP =');
-  const stepEnd = convergeSource.indexOf('\n\n', stepStart);
-  const stepBody = convergeSource.slice(stepStart, stepEnd);
-  assert.match(stepBody, /code_rules_gate\.py/);
-  assert.match(stepBody, /--staged/);
-  assert.match(
-    stepBody,
-    /do NOT commit/i,
-    'expected the gate step to forbid committing — it is a dry committability check',
-  );
-});
-
-const editStepTaskDispatchers = ['runCodeEditorTask', 'runFixerTask'];
-
-for (const helperName of editStepTaskDispatchers) {
-  test(`${helperName} appends the pre-commit gate step to its edit prompts`, () => {
-    assert.match(
-      functionSource(helperName),
-      /\+\s*PRE_COMMIT_GATE_STEP/,
-      `expected ${helperName} to append PRE_COMMIT_GATE_STEP to its edit-task prompts`,
-    );
-  });
-}
-
-const editStepTasks = [
-  ['runCodeEditorTask', 'fix-edit'],
-  ['runCodeEditorTask', 'repair-edit'],
-  ['runCodeEditorTask', 'standards-edit'],
-  ['runCodeEditorTask', 'commit-recover'],
-];
-
-for (const [helperName, taskName] of editStepTasks) {
-  test(`${helperName} routes the ${taskName} task to a pre-commit-gated edit prompt`, () => {
-    assert.match(
-      functionSource(helperName),
-      new RegExp(`task === '${taskName}'`),
-      `expected ${helperName} to handle the ${taskName} task`,
-    );
-  });
-}
-
-function preambleText() {
-  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);
-}
-
-test('preamble prescribes authoring a Python helper for variable-built or multi-step sandboxes', () => {
-  assert.match(
-    preambleText(),
-    /python\s+<file>\.py|python\s+<.*>\.py|author.*python.*helper|python.*helper.*sandbox|sandbox.*python.*helper/i,
-    'expected the preamble to prescribe running a Python helper file for multi-step sandbox teardown',
-  );
-});
-
-test('preamble does not claim the standalone or both rm auto-allow paths fail closed on any $', () => {
-  const text = preambleText().replace(/\$\(\.\.\.\)/g, 'SUBSHELL').replace(/\s+/g, ' ');
-  const overstatesStandalone =
-    /\b(?:both|standalone|neither)\b[^.]*fail closed[^.]*any \$/i.test(text) ||
-    /\b(?:both|standalone|neither)\b[^.]*any \$[^.]*fail closed/i.test(text);
-  assert.equal(
-    overstatesStandalone,
-    false,
-    'only the compound path fails closed on any $ in the target; the standalone path accepts a $-bearing target whose literal path already sits under an ephemeral root',
-  );
-});
-
-test('preamble does not claim $CLAUDE_JOB_DIR/tmp is blocked', () => {
-  assert.doesNotMatch(
-    preambleText(),
-    /CLAUDE_JOB_DIR\/tmp is NOT auto-allowed/i,
-    'under an ephemeral cwd the hook auto-allows rm targeting $CLAUDE_JOB_DIR/tmp',
-  );
-});
-
-test('preamble scopes its rm-shape claim to the narrowest auto-allow path, not the full set', () => {
-  assert.doesNotMatch(
-    preambleText(),
-    /auto-allows rm only when ALL of these hold/i,
-    'the hook has three rm auto-allow paths, so the preamble must not assert one narrow shape is the complete set',
-  );
-});
-
-test('SKILL.md does not claim the standalone or both rm auto-allow paths fail closed on any $', () => {
-  const text = skillSource.replace(/`/g, '').replace(/\$\(\.\.\.\)/g, 'SUBSHELL').replace(/\s+/g, ' ');
-  const overstatesStandalone =
-    /\b(?:both|standalone|neither)\b[^.]*fail closed[^.]*any \$/i.test(text) ||
-    /\b(?:both|standalone|neither)\b[^.]*any \$[^.]*fail closed/i.test(text);
-  assert.equal(
-    overstatesStandalone,
-    false,
-    'only the compound path fails closed on any $ in the target; the standalone path accepts a $-bearing target whose literal path already sits under an ephemeral root',
-  );
-});
-
-test('SKILL.md does not claim it enforces the exact rm shape the hook auto-allows', () => {
-  assert.doesNotMatch(
-    skillSource,
-    /exact rm shape the hook auto-allows/i,
-    'the hook has multiple rm auto-allow paths, so SKILL.md must not assert one narrow shape is the exact set',
-  );
-});
-
-test('preamble does not attribute the known-temp-var resolution to the standalone or compound paths', () => {
-  assert.doesNotMatch(
-    preambleText().replace(/\s+/g, ' '),
-    /Across these paths[\s\S]*?CLAUDE_JOB_DIR/i,
-    'the temp-var resolution lives only in the broad cwd-scoped path; the standalone and compound paths do not resolve known temp variables',
-  );
-});
-
-test('preamble attributes the known-temp-var resolution to a third cwd-scoped auto-allow path', () => {
-  const text = preambleText().replace(/\s+/g, ' ');
-  const tempVarSentenceMatch =
-    /[^.]*\bTMPDIR\b[^.]*CLAUDE_JOB_DIR[^.]*\./i.exec(text);
-  assert.notEqual(
-    tempVarSentenceMatch,
-    null,
-    'expected a sentence describing the TEMP/TMP/TMPDIR/CLAUDE_JOB_DIR resolution',
-  );
-  assert.match(
-    tempVarSentenceMatch[0],
-    /declares? an ephemeral cwd|declared ephemeral cwd|ephemeral-cwd path|third (?:auto-allow )?path|cwd-scoped path/i,
-    'expected the temp-var resolution to be tied to the cwd-scoped path that declares an ephemeral working directory, not the standalone or compound paths',
-  );
-});
-
-test('preamble forbids bash rm on a repo-path build cache and points cleanup at Remove-Item', () => {
-  const text = preambleText().replace(/\s+/g, ' ');
-  assert.match(
-    text,
-    /\.mypy_cache|\.pytest_cache|__pycache__/,
-    'expected the preamble to name a gitignored build cache agents must not rm',
-  );
-  assert.match(
-    text,
-    /never delete it|leave it in place/i,
-    'expected the preamble to tell agents to leave a gitignored cache rather than rm it',
-  );
-  assert.match(
-    text,
-    /Remove-Item -Recurse -Force -Confirm:\$false/,
-    'expected the preamble to point a genuine delete at the PowerShell Remove-Item form',
-  );
-});
-
-test('SKILL.md does not attribute the known-temp-var resolution to the standalone or compound paths', () => {
-  assert.doesNotMatch(
-    skillSource.replace(/\s+/g, ' '),
-    /Across those paths[\s\S]*?CLAUDE_JOB_DIR/i,
-    'the temp-var resolution lives only in the broad cwd-scoped path; the standalone and compound paths do not resolve known temp variables',
-  );
-});
-
-test('headless-safety.md attributes the known-temp-var resolution to the cwd-scoped auto-allow path', () => {
-  const standaloneSectionMatch =
-    /1\.\s*\*\*Standalone path\*\*[\s\S]*?(?=2\.\s*\*\*Compound path\*\*)/i.exec(
-      headlessSafetySource,
-    );
-  assert.notEqual(standaloneSectionMatch, null, 'expected numbered standalone path section');
-  assert.doesNotMatch(
-    standaloneSectionMatch[0],
-    /resolves the known temporary variables/i,
-    'standalone path must not claim the known-temp-var resolution',
-  );
-
-  const compoundSectionMatch =
-    /2\.\s*\*\*Compound path\*\*[\s\S]*?(?=3\.\s*\*\*Cwd-scoped path\*\*)/i.exec(
-      headlessSafetySource,
-    );
-  assert.notEqual(compoundSectionMatch, null, 'expected numbered compound path section');
-  assert.doesNotMatch(
-    compoundSectionMatch[0],
-    /resolves the known temporary variables/i,
-    'compound path must not claim the known-temp-var resolution',
-  );
-
-  const cwdScopedSectionMatch =
-    /3\.\s*\*\*Cwd-scoped path\*\*[\s\S]*?(?=\n\nEven so|\n## |$)/i.exec(
-      headlessSafetySource,
-    );
-  assert.notEqual(cwdScopedSectionMatch, null, 'expected numbered cwd-scoped path section');
-  const cwdScopedSection = cwdScopedSectionMatch[0].replace(/\s+/g, ' ');
-  assert.match(
-    cwdScopedSection,
-    /resolves the known temporary variables[\s\S]{0,80}\bTEMP\b[\s\S]{0,40}\bTMP\b[\s\S]{0,40}\bTMPDIR\b[\s\S]{0,40}\bCLAUDE_JOB_DIR\b/i,
-    'expected a sentence describing the TEMP/TMP/TMPDIR/CLAUDE_JOB_DIR resolution',
-  );
-  assert.match(
-    cwdScopedSection,
-    /declares an ephemeral working directory|declared ephemeral cwd|cwd-scoped path/i,
-    'expected the temp-var resolution to be tied to the cwd-scoped path that declares an ephemeral working directory, not the standalone or compound paths',
-  );
-});
-
-test('convergeAgent prepends HEADLESS_EDIT_PREAMBLE and the worktree directive to every prompt', () => {
-  const convergeAgentBody = lensPromptBody('convergeAgent');
-  assert.match(
-    convergeAgentBody,
-    /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',
-  );
-});
-
-test('the read-only destructive pointer scopes its no-edit clause to the tree it reads', () => {
-  const destructivePointer = convergeSource
-    .split('\n')
-    .find((eachLine) => eachLine.includes('Never run a destructive command'));
-  assert.ok(destructivePointer, 'expected the read-only destructive pointer to be declared');
-  assert.match(
-    destructivePointer,
-    /Never run a destructive command/,
-    'expected the destructive-command prohibition to stay absolute',
-  );
-  assert.match(
-    destructivePointer,
-    /no edit to the tree it reads/,
-    'expected the no-edit clause to be scoped to the tree under verification',
-  );
-  assert.doesNotMatch(
-    destructivePointer,
-    /edits nothing/,
-    'expected no blanket edits-nothing wording, which forbids the deliberate break off that tree',
-  );
-});
-
-const taskDispatchers = [
-  { name: 'runGitTask', isAsync: false },
-  { name: 'runFixerTask', isAsync: false },
-  { name: 'fixerWithRecovery', isAsync: true },
-  { name: 'runCodeEditorTask', isAsync: false },
-  { name: 'runVerifierTask', isAsync: false },
-  { name: 'runGeneralUtilityTask', isAsync: false },
-  { name: 'runConvergenceCheck', isAsync: false },
-];
-
-for (const { name, isAsync } of taskDispatchers) {
-  const prefix = isAsync ? 'async ' : '';
-  test(`function ${prefix}${name} exists in converge.mjs`, () => {
-    const needle = isAsync ? `async function ${name}(` : `function ${name}(`;
-    assert.ok(convergeSource.includes(needle), `expected ${name} to exist`);
-  });
-}
-
-test('runGeneralUtilityTask only handles the post-clean-audit task it is called with', () => {
-  const generalBody = functionSource('runGeneralUtilityTask');
-  assert.match(
-    generalBody,
-    /task === 'post-clean-audit'/,
-    'expected runGeneralUtilityTask to handle the post-clean-audit task',
-  );
-  assert.doesNotMatch(
-    generalBody,
-    /task === 'mark-ready'/,
-    'the mark-ready step is merged into the FINALIZE convergence check (runConvergenceCheck), so its branch must be removed here',
-  );
-  assert.doesNotMatch(
-    generalBody,
-    /task === 'bugbot-lens'/,
-    'the live Bugbot lens is runBugbotLens; the dead bugbot-lens branch must be removed',
-  );
-  assert.doesNotMatch(
-    generalBody,
-    /Copilot can run out of usage/,
-    'the live Copilot gate is runCopilotGate; the dead copilot-gate branch must be removed',
-  );
-  assert.doesNotMatch(
-    generalBody,
-    /convergence summary/,
-    'the convergence-summary producer was removed; the dead branch must not return',
-  );
-});
-
-const orphanedHelperNames = [
-  'applyFixesEdit',
-  'recoverCommitBlockEdit',
-  'recoverVerifyFailEdit',
-  'checkConvergence',
-  'markReady',
-  'repairConvergenceEdit',
-  'verifyRepairChanges',
-  'commitRepairFixes',
-  'resolveConflictsEdit',
-  'standardsFollowUpEdit',
-  'verifyHardeningChanges',
-  'commitHardeningPr',
-  'postCleanAudit',
-  'spawnConvergenceSummary',
-];
-
-for (const orphanName of orphanedHelperNames) {
-  test(`${orphanName} is removed — its behavior lives in a direct-spawn task dispatcher`, () => {
-    assert.ok(
-      !convergeSource.includes(`function ${orphanName}(`),
-      `expected the orphaned ${orphanName} definition to be deleted (CODE_RULES 9.8)`,
-    );
-  });
-}
-
-test('the whole priming spawn-agent family is removed — every dispatcher spawns fresh', () => {
-  assert.doesNotMatch(
-    convergeSource,
-    /function\s+spawn\w+Agent\s*\(/,
-    'expected no spawn<Role>Agent priming function to survive — each task dispatcher spawns a fresh agent',
-  );
-});
-
-test('parseLastVerdictFence returns non-null for a verdict fence with valid JSON', () => {
-  const parseModule = new Function(
-    `${functionSource('findLastVerdictFence')}\n` +
-    `${functionSource('parseLastVerdictFence')}\n` +
-    'return { parseLastVerdictFence };',
-  )();
-  const result = parseModule.parseLastVerdictFence('```verdict\n{"all_pass":true,"findings":[],"manifest_sha256":"abc"}\n```');
-  assert.notEqual(result, null);
-  assert.equal(result.all_pass, true);
-});
-
-test('parseLastVerdictFence returns null for non-string input', () => {
-  const parseModule = new Function(
-    `${functionSource('findLastVerdictFence')}\n` +
-    `${functionSource('parseLastVerdictFence')}\n` +
-    'return { parseLastVerdictFence };',
-  )();
-  assert.equal(parseModule.parseLastVerdictFence(null), null);
-  assert.equal(parseModule.parseLastVerdictFence(undefined), null);
-});
-
-test('parseLastVerdictFence returns null when no verdict fence is present', () => {
-  const parseModule = new Function(
-    `${functionSource('findLastVerdictFence')}\n` +
-    `${functionSource('parseLastVerdictFence')}\n` +
-    'return { parseLastVerdictFence };',
-  )();
-  assert.equal(parseModule.parseLastVerdictFence('plain text with no fence'), null);
-});
-
-test('parseLastVerdictFence returns null for malformed JSON in the fence', () => {
-  const parseModule = new Function(
-    `${functionSource('findLastVerdictFence')}\n` +
-    `${functionSource('parseLastVerdictFence')}\n` +
-    'return { parseLastVerdictFence };',
-  )();
-  assert.equal(parseModule.parseLastVerdictFence('```verdict\nnot json\n```'), null);
-});
-
-test('verdictPassed calls parseLastVerdictFence', () => {
-  const verdictBody = lensPromptBody('verdictPassed');
-  assert.match(verdictBody, /parseLastVerdictFence\(/, 'expected verdictPassed to call the shared parser');
-});
-
-test('extractVerifyObjection calls parseLastVerdictFence', () => {
-  const objectionBody = lensPromptBody('extractVerifyObjection');
-  assert.match(objectionBody, /parseLastVerdictFence\(/, 'expected extractVerifyObjection to call the shared parser');
-});
-
-test('the headless preamble routes waits through the Monitor tool and forbids ending a turn to await work', () => {
-  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);
-  assert.match(preamble, /foreground sleep is blocked/i, 'expected the preamble to state foreground sleep is blocked');
-  assert.match(preamble, /Monitor tool/, 'expected the preamble to route waits through the Monitor tool');
-  assert.match(preamble, /StructuredOutput/, 'expected the preamble to require a schema agent to always call StructuredOutput');
-  assert.match(preamble, /never end your turn to wait/i, 'expected the preamble to forbid ending a turn to await background work');
-});
-
-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_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');
-  const preamble = convergeSource.slice(blockStart, blockEnd);
-  assert.doesNotMatch(
-    preamble,
-    /never move a wait to a background process/i,
-    'the Monitor tool is itself a background monitor, so the preamble must avoid forbidding a wait that moves to a background process',
-  );
-  assert.doesNotMatch(
-    preamble,
-    /return to you when the condition holds/i,
-    'the Monitor tool streams notifications across turns rather than returning in-turn, so the preamble must avoid describing an in-turn synchronous return',
-  );
-  assert.match(
-    preamble,
-    /until-loop/i,
-    'expected the preamble to describe the wait as a bounded until-loop paired with the Monitor tool',
-  );
-  assert.match(
-    preamble,
-    /notifications? as they arrive/i,
-    'expected the preamble to say Monitor notifications are consumed as they arrive',
-  );
-});
-
-test('the background-wait clause gives "await" an explicit object, not a dangling "await never resumes"', () => {
-  const text = preambleText();
-  assert.doesNotMatch(
-    text,
-    /end your turn to await never resumes/i,
-    'expected the background-wait clause to name what is awaited, not read as "await never resumes" with no object',
-  );
-  assert.match(
-    text,
-    /end your turn to await it/i,
-    'expected the background-wait clause to name the wait as the object of "await"',
-  );
-});
-
-test('the wait guidance names the full down-result schema, not a bare down flag', () => {
-  const text = preambleText();
-  assert.doesNotMatch(
-    text,
-    /Copilot gate, down: true\)/,
-    'expected the down signal to name the full schema, not a bare down flag that reads as a partial object',
-  );
-  assert.match(
-    text,
-    /down:true, findings:\[\]/,
-    'expected the wait guidance to name the full down-result fields',
-  );
-});
-
-test('no agent prompt instructs a foreground sleep as the poll delay', () => {
-  assert.doesNotMatch(
-    convergeSource,
-    /delay each (?:attempt|iteration|retry) with "sleep/,
-    'expected no poll directive to instruct a foreground sleep as the between-attempt delay',
-  );
-  assert.doesNotMatch(
-    convergeSource,
-    /Start-Sleep -Seconds/,
-    'expected no agent prompt to instruct a foreground PowerShell Start-Sleep',
-  );
-});
-
-test('the wait guidance sizes the Monitor timeout_ms above the 300s default', () => {
-  const text = preambleText();
-  assert.match(text, /timeout_ms/, 'names the timeout_ms parameter the wait rule tells the agent to set');
-  assert.match(text, /persistent/, 'offers persistent as an alternative to a sized timeout_ms');
-  assert.match(text, /300000|300 second/, 'names the 300000 default that truncates a long wait');
-  assert.match(
-    text,
-    /interval[\s\S]{0,60}attempt|interval-times-attempts/i,
-    'sizes timeout_ms to the interval-times-attempts span the step names',
-  );
-});
-
-test('the Monitor ceiling the guidance names covers the longest interval-times-attempts wait the steps prescribe', () => {
-  const cap = /(\d{7})\s*(?:ms|millisecond)/i.exec(preambleText());
-  assert.ok(cap !== null, 'the guidance names a seven-digit Monitor ceiling in milliseconds');
-  const ceiling = Number(cap[1]);
-
-  const copilot = lensPromptBody('runCopilotGate');
-  const bugbot = lensPromptBody('runBugbotLens');
-  const apart = Number(/(\d+)\s*seconds apart/.exec(copilot)[1]);
-  const polls = Number(/copilotMaxPolls:\s*(\d+)/.exec(convergeSource)[1]);
-  const seconds = Number(/every\s*(\d+)\s*seconds/.exec(bugbot)[1]);
-  const iterations = Number(/up to\s*(\d+)\s*iterations/.exec(bugbot)[1]);
-  const spans = [apart * polls * 1000, seconds * iterations * 1000];
-
-  for (const span of spans) {
-    assert.ok(
-      span <= ceiling,
-      `a ${span}ms wait span exceeds the ${ceiling}ms Monitor ceiling the guidance names`,
-    );
-  }
-});
-
-function optionsLineForLabel(label) {
-  const labelIndex = convergeSource.indexOf(`label: '${label}'`);
-  assert.notEqual(labelIndex, -1, `expected an agent options object labeled ${label}`);
-  const lineStart = convergeSource.lastIndexOf('\n', labelIndex);
-  const lineEnd = convergeSource.indexOf('\n', labelIndex);
-  return convergeSource.slice(lineStart, lineEnd);
-}
-
-test('the TIERS map defines the opus/sonnet/haiku model-effort tiers', () => {
-  assert.match(convergeSource, /opusMedium:\s*\{ model: 'opus', effort: 'medium' \}/);
-  assert.match(convergeSource, /sonnetMedium:\s*\{ model: 'sonnet', effort: 'medium' \}/);
-  assert.match(convergeSource, /haikuLow:\s*\{ model: 'haiku', effort: 'low' \}/);
-});
-
-test('every convergeAgent spawn options object carries a model and effort tier', () => {
-  const optionObjects = convergeSource.match(/\{ label[^\n]*\}/g) || [];
-  assert.ok(
-    optionObjects.length >= 20,
-    `expected to find the per-spawn options objects, found ${optionObjects.length}`,
-  );
-  for (const optionObject of optionObjects) {
-    const hasTier = optionObject.includes('...TIERS.');
-    const hasInlineModelEffort = /model:\s*'/.test(optionObject) && /effort:\s*'/.test(optionObject);
-    assert.ok(
-      hasTier || hasInlineModelEffort,
-      `expected the spawn options to carry a model and effort tier: ${optionObject}`,
-    );
-  }
-});
-
-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/,
-      `expected ${label} to 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/);
-});
-
-test('the merged finalize convergence check runs on the haikuLow tier', () => {
-  assert.match(functionSource('runConvergenceCheck'), /\.\.\.TIERS\.haikuLow/);
-});
-
-test('the preflight-git task returns the changed-file list and diffstat for the lenses', () => {
-  const body = functionSource('runGitTask');
-  assert.match(body, /git diff --name-status origin\/main\.\.\.HEAD/);
-  assert.match(body, /git diff --stat origin\/main\.\.\.HEAD/);
-  assert.match(body, /changedFiles/);
-  assert.match(body, /diffstat/);
-  const schemaStart = convergeSource.indexOf('const PREFLIGHT_GIT_SCHEMA =');
-  const schemaEnd = convergeSource.indexOf('\n}', schemaStart);
-  const schema = convergeSource.slice(schemaStart, schemaEnd);
-  assert.match(schema, /changedFiles:/);
-  assert.match(schema, /diffstat:/);
-  assert.match(schema, /required:[^\n]*'changedFiles'[^\n]*'diffstat'/);
-});
-
-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\)/,
-      `expected ${builder} to inject the changed-file context from the preflight result`,
-    );
-  }
-});
-
-test('renderLensDiffContext reuses the changed-file list when present and falls back to self-enumeration otherwise', () => {
-  const renderLensDiffContext = new Function(
-    `${functionSource('renderLensDiffContext')}\nreturn renderLensDiffContext;`,
-  )();
-  const withList = renderLensDiffContext({ changedFiles: 'M\ta.py', diffstat: ' a.py | 2 +-' });
-  assert.match(withList, /Changed files/);
-  assert.match(withList, /a\.py/);
-  const fallback = renderLensDiffContext(null);
-  assert.match(fallback, /git diff --name-only/, 'expected a missing file list to fall back to self-enumeration');
-});
-
-test('the merged FINALIZE check runs check_convergence then marks the PR ready on pass in one agent', () => {
-  const body = functionSource('runConvergenceCheck');
-  assert.match(body, /check_convergence\.py/, 'expected the merged check to run check_convergence.py');
-  assert.match(body, /gh pr ready/, 'expected the merged check to mark the PR ready on the passing path');
-  assert.match(body, /schema: FINALIZE_SCHEMA/, 'expected the merged check to return the {pass, failures, ready} schema');
-  assert.match(body, /context\.copilotDown/, 'expected the merged check to carry the copilotDown opt-out context');
-});
-
-test('FINALIZE_SCHEMA carries pass, failures, and ready', () => {
-  const schemaStart = convergeSource.indexOf('const FINALIZE_SCHEMA =');
-  assert.notEqual(schemaStart, -1, 'expected FINALIZE_SCHEMA to exist');
-  const schema = convergeSource.slice(schemaStart, convergeSource.indexOf('\n}', schemaStart));
-  for (const field of ['pass', 'failures', 'ready']) {
-    assert.match(schema, new RegExp(`${field}:`), `expected FINALIZE_SCHEMA to carry ${field}`);
-  }
-});
-
-test('the FINALIZE phase drives the merged check and reads ready from its result without a separate mark-ready spawn', () => {
-  const finalizeStart = convergeSource.indexOf("if (phase === 'FINALIZE') {");
-  assert.notEqual(finalizeStart, -1, 'expected a FINALIZE phase block');
-  const finalizeBody = convergeSource.slice(finalizeStart, finalizeStart + 1000);
-  assert.match(finalizeBody, /runConvergenceCheck\(\{ head, bugbotDown, copilotDown, codexDown, codexCleanAt, bugteamPostBlocked: cleanAuditNote !== null \}\)/);
-  assert.match(finalizeBody, /classifyReadyOutcome\(finalizeResult\)/);
-  assert.doesNotMatch(
-    finalizeBody,
-    /runGeneralUtilityTask\('mark-ready'/,
-    'the separate mark-ready spawn is merged into the FINALIZE convergence check',
-  );
-});
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import test from 'node:test'
+import vm from 'node:vm'
+
+const sourcePath = new URL('./converge.mjs', import.meta.url)
+const workflowSource = readFileSync(sourcePath, 'utf8')
+
+function loadReviewResultParser() {
+  const passMarker = workflowSource.match(/const REVIEW_RESULT_PASS_MARKER = .+/)[0]
+  const findingsMarker = workflowSource.match(/const REVIEW_RESULT_FINDINGS_MARKER = .+/)[0]
+  const parserStart = workflowSource.indexOf('function parseReviewResult')
+  const parserEnd = workflowSource.indexOf('\n}\n', parserStart) + 2
+  const parserSource = `${passMarker}\n${findingsMarker}\n${workflowSource.slice(parserStart, parserEnd)}`
+  const parserContext = {}
+  vm.runInNewContext(`${parserSource}\nglobalThis.parseReviewResult = parseReviewResult`, parserContext)
+  return parserContext.parseReviewResult
+}
+
+test('review tasks apply the canonical review guide and return a review result', () => {
+  assert.match(workflowSource, /function runReviewTask\(task, context\)/)
+  assert.match(workflowSource, /skills\/reviews\/SKILL\.md#review-workflow/)
+  assert.match(workflowSource, /REVIEW_RESULT: PASS/)
+  assert.match(workflowSource, /REVIEW_RESULT: FINDINGS/)
+})
+
+test('review tasks use code-quality-agent and keep the working tree read-only', () => {
+  const reviewTaskStart = workflowSource.indexOf('function runReviewTask')
+  const reviewTaskEnd = workflowSource.indexOf('function serializeOneLineJson', reviewTaskStart)
+  const reviewTaskSource = workflowSource.slice(reviewTaskStart, reviewTaskEnd)
+  assert.match(reviewTaskSource, /agentType: 'code-quality-agent'/)
+  assert.match(reviewTaskSource, /Make no edit to the tree under verification/)
+})
+
+test('review result parser accepts one standalone terminal disposition only', () => {
+  const parseReviewResult = loadReviewResultParser()
+
+  assert.equal(parseReviewResult('review complete\nREVIEW_RESULT: PASS'), 'PASS')
+  assert.equal(parseReviewResult('finding: missing test\nREVIEW_RESULT: FINDINGS'), 'FINDINGS')
+  assert.equal(parseReviewResult('REVIEW_RESULT: PASSING'), null)
+  assert.equal(parseReviewResult('REVIEW_RESULT: PASS\nREVIEW_RESULT: FINDINGS'), null)
+  assert.equal(parseReviewResult('REVIEW_RESULT: PASS\n> REVIEW_RESULT: FINDINGS'), null)
+  assert.equal(parseReviewResult('review complete'), null)
+})
+
+test('the fix flow keeps edit, review, and commit as distinct operational steps', () => {
+  const fixerStart = workflowSource.indexOf('async function fixerWithRecovery')
+  const fixerEnd = workflowSource.indexOf('function runCodeEditorTask', fixerStart)
+  const fixerSource = workflowSource.slice(fixerStart, fixerEnd)
+  assert.match(fixerSource, /runReviewTask\('fix-verify'/)
+  assert.match(fixerSource, /runFixerTask\('commit'/)
+  assert.match(fixerSource, /reviewPassed\(verifyTranscript\)/)
+})