claude-dev-env 4.3.0 → 7.0.0

package/.agents/skills/autoconverge/workflow/converge.codex-gate.test.mjs

@@ -1,472 +0,0 @@
-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 skillSource = readFileSync(join(workflowDirectory, '..', 'SKILL.md'), 'utf8');
-const stopConditionsSource = readFileSync(
-  join(workflowDirectory, '..', 'reference', 'stop-conditions.md'),
-  'utf8',
-);
-
-function functionBody(functionName) {
-  const functionStart = convergeSource.indexOf(`function ${functionName}(`);
-  assert.notEqual(functionStart, -1, `expected ${functionName} to exist`);
-  const nextFunctionStart = convergeSource.indexOf('\nfunction ', functionStart + 1);
-  const functionEnd = nextFunctionStart === -1 ? convergeSource.length : nextFunctionStart;
-  return convergeSource.slice(functionStart, functionEnd);
-}
-
-const productionModule = new Function(
-  `${functionBody('classifyCodexGateOutcome')}\n` +
-    'return { classifyCodexGateOutcome };',
-)();
-const { classifyCodexGateOutcome } = productionModule;
-
-function codexResult(overrides) {
-  return {
-    sha: 'abcdef0',
-    clean: false,
-    down: false,
-    skipped: false,
-    skipReason: '',
-    findings: [],
-    ...overrides,
-  };
-}
-
-function codexFinding(overrides) {
-  return {
-    file: 'a.py',
-    line: 1,
-    severity: 'P1',
-    category: 'bug',
-    title: 't',
-    detail: 'd',
-    replyToCommentId: null,
-    ...overrides,
-  };
-}
-
-test('a required clean Codex result routes to clean so the run stamps codex-clean HEAD', () => {
-  const outcome = classifyCodexGateOutcome(codexResult({ clean: true }));
-  assert.equal(outcome.kind, 'clean');
-});
-
-test('an opt-out token skip routes to skip-token', () => {
-  const outcome = classifyCodexGateOutcome(
-    codexResult({ clean: true, down: true, skipped: true, skipReason: 'token' }),
-  );
-  assert.equal(outcome.kind, 'skip-token');
-});
-
-test('a usage-threshold skip routes to skip-usage', () => {
-  const outcome = classifyCodexGateOutcome(
-    codexResult({ clean: true, down: false, skipped: true, skipReason: 'usage' }),
-  );
-  assert.equal(outcome.kind, 'skip-usage');
-});
-
-test('a codex_down result routes to down', () => {
-  const outcome = classifyCodexGateOutcome(codexResult({ clean: false, down: true }));
-  assert.equal(outcome.kind, 'down');
-});
-
-test('Codex findings route to a fix when the review completed with findings', () => {
-  const outcome = classifyCodexGateOutcome(
-    codexResult({
-      findings: [codexFinding()],
-    }),
-  );
-  assert.equal(outcome.kind, 'fix');
-  assert.equal(outcome.findings.length, 1);
-});
-
-test('a dead Codex gate agent retries rather than passing', () => {
-  assert.equal(classifyCodexGateOutcome(null).kind, 'retry');
-});
-
-test('a reachable Codex gate with no findings and no clean verdict retries', () => {
-  const outcome = classifyCodexGateOutcome(codexResult({ clean: false, down: false }));
-  assert.equal(outcome.kind, 'retry');
-});
-
-test('skipped with an unknown skipReason retries rather than silently advancing', () => {
-  const outcome = classifyCodexGateOutcome(
-    codexResult({ skipped: true, skipReason: 'mystery' }),
-  );
-  assert.equal(outcome.kind, 'retry');
-});
-
-test('CODEX_SCHEMA requires skipped and skipReason drawn from the skip-reason constant', () => {
-  const schemaStart = convergeSource.indexOf('const CODEX_SCHEMA =');
-  const schemaEnd = convergeSource.indexOf('const COPILOT_VERIFY_VERDICTS =');
-  assert.notEqual(schemaStart, -1, 'expected CODEX_SCHEMA to exist');
-  const schemaSource = convergeSource.slice(schemaStart, schemaEnd);
-  assert.match(schemaSource, /skipped:\s*\{\s*type:\s*'boolean'/);
-  assert.match(schemaSource, /enum:\s*CODEX_SKIP_REASONS/);
-  assert.match(schemaSource, /required:\s*\[[^\]]*'skipped'[^\]]*\]/);
-  assert.match(schemaSource, /required:\s*\[[^\]]*'skipReason'[^\]]*\]/);
-});
-
-test('the Codex gate prompt honors reviews_disabled.py with only --reviewer codex', () => {
-  const codexPrompt = functionBody('runCodexGate');
-  const reviewsDisabledIndex = codexPrompt.indexOf('reviews_disabled.py');
-  assert.notEqual(reviewsDisabledIndex, -1, 'expected reviews_disabled.py invocation');
-  const invocationLineEnd = codexPrompt.indexOf('\\n', reviewsDisabledIndex);
-  const invocationLine = codexPrompt.slice(reviewsDisabledIndex, invocationLineEnd);
-  assert.match(invocationLine, /--reviewer codex/);
-  assert.doesNotMatch(invocationLine, /--owner|--repo/);
-});
-
-test('the Codex gate prompt decides required vs skip only through is_codex_review_required', () => {
-  const codexPrompt = functionBody('runCodexGate');
-  assert.match(codexPrompt, /codex_usage_probe\.py/, 'expected the usage probe CLI');
-  assert.match(
-    codexPrompt,
-    /is_codex_review_required/,
-    'expected the shared probe helper rather than an inline percent threshold',
-  );
-  assert.doesNotMatch(
-    codexPrompt,
-    /WEEKLY_USAGE_GATE_THRESHOLD_PERCENT|\b10\s*%|\bpercent_left\s*[><=]/,
-    'expected no duplicate threshold literal or inline comparison in the gate prompt',
-  );
-});
-
-test('the Codex gate prompt treats a non-zero usage-probe exit as codex_down not usage skip', () => {
-  const codexPrompt = functionBody('runCodexGate');
-  assert.match(
-    codexPrompt,
-    /Non-zero exit means the Codex CLI or probe is broken/,
-    'expected an explicit non-zero probe exit branch',
-  );
-  assert.match(
-    codexPrompt,
-    /Never map a failed probe to skipReason:'usage'/,
-    'expected failed probe to be barred from the usage-skip path',
-  );
-  assert.match(
-    codexPrompt,
-    /clean:false, down:true, skipped:false, skipReason:''/,
-    'expected failed probe to return the codex_down schema shape',
-  );
-});
-
-test('the Codex gate prompt sys.path insert uses CONFIG.codexScripts not a literal $HOME token', () => {
-  const codexPrompt = functionBody('runCodexGate');
-  assert.match(
-    codexPrompt,
-    /sys\.path\.insert\(0, r'\$\{CONFIG\.codexScripts\}'\)/,
-    'expected sys.path.insert to interpolate CONFIG.codexScripts (home-expanded at CONFIG build)',
-  );
-  assert.doesNotMatch(
-    codexPrompt,
-    /sys\.path\.insert\(0, r'\$HOME/,
-    'expected no unexpanded $HOME inside the Python raw-string path',
-  );
-});
-
-test('the Codex gate prompt runs the review wrapper against the PR base branch', () => {
-  const codexPrompt = functionBody('runCodexGate');
-  assert.match(codexPrompt, /run_codex_review/, 'expected the codex-review wrapper');
-  assert.match(codexPrompt, /base_branch/, 'expected the wrapper to receive the PR base');
-  assert.match(codexPrompt, /\.base\.ref/, 'expected the agent to resolve the PR base ref');
-  assert.match(codexPrompt, /parse_codex_findings/, 'expected findings to come from the shared parser');
-});
-
-test('the Codex gate prompt passes an explicit generous timeout so a slow-but-healthy review is not cut short', () => {
-  const codexPrompt = functionBody('runCodexGate');
-  assert.match(
-    codexPrompt,
-    /timeout_seconds=\$\{CONFIG\.codexReviewTimeoutSeconds\}/,
-    'expected the driver to pass CONFIG.codexReviewTimeoutSeconds, overriding the too-small wrapper default',
-  );
-});
-
-test('CONFIG.codexReviewTimeoutSeconds exceeds the observed real Codex runtime', () => {
-  const match = convergeSource.match(/codexReviewTimeoutSeconds:\s*(\d+)/);
-  assert.notEqual(match, null, 'expected CONFIG.codexReviewTimeoutSeconds to be defined');
-  const budgetSeconds = Number(match[1]);
-  assert.ok(
-    budgetSeconds >= 900,
-    `expected a budget comfortably above the ~683s measured Codex runtime, got ${budgetSeconds}`,
-  );
-});
-
-test('the Codex gate prompt runs the review in the background rather than the default foreground timeout', () => {
-  const codexPrompt = functionBody('runCodexGate');
-  assert.match(
-    codexPrompt,
-    /run_in_background/i,
-    'expected the review driver to run in the background — the foreground tool timeout caps below the review runtime and would kill a healthy review',
-  );
-  assert.match(
-    codexPrompt,
-    /result file/i,
-    'expected the driver to persist its outcome to a result file the agent reads once the background run finishes',
-  );
-});
-
-test('the Codex gate prompt waits for the background review inside the same turn with a bounded Monitor loop', () => {
-  const codexPrompt = functionBody('runCodexGate');
-  assert.match(codexPrompt, /Monitor tool/, 'expected a same-turn Monitor wait for the background review');
-  assert.match(codexPrompt, /until-loop/, 'expected a bounded until-loop that re-checks the result file');
-  assert.match(codexPrompt, /codexReviewPollIntervalSeconds/, 'expected a named poll interval in the wait protocol');
-  assert.match(codexPrompt, /codexReviewMaxPolls/, 'expected a named attempt budget in the wait protocol');
-  assert.match(
-    codexPrompt,
-    /Do NOT end this turn/i,
-    'expected an explicit instruction against ending the schema-bearing turn to await the background run',
-  );
-});
-
-test('the Codex background-review poll budget covers the review timeout', () => {
-  const intervalMatch = convergeSource.match(/codexReviewPollIntervalSeconds:\s*(\d+)/);
-  const pollsMatch = convergeSource.match(/codexReviewMaxPolls:\s*(\d+)/);
-  const timeoutMatch = convergeSource.match(/codexReviewTimeoutSeconds:\s*(\d+)/);
-  assert.notEqual(intervalMatch, null, 'expected codexReviewPollIntervalSeconds in CONFIG');
-  assert.notEqual(pollsMatch, null, 'expected codexReviewMaxPolls in CONFIG');
-  assert.notEqual(timeoutMatch, null, 'expected codexReviewTimeoutSeconds in CONFIG');
-  const intervalSeconds = Number(intervalMatch[1]);
-  const maxPolls = Number(pollsMatch[1]);
-  const timeoutSeconds = Number(timeoutMatch[1]);
-  assert.ok(
-    intervalSeconds * maxPolls >= timeoutSeconds,
-    `expected the poll budget ${intervalSeconds * maxPolls}s to cover the ${timeoutSeconds}s review timeout`,
-  );
-});
-
-test('the Codex gate prompt returns codex_down when the background poll budget is spent', () => {
-  const codexPrompt = functionBody('runCodexGate');
-  assert.match(
-    codexPrompt,
-    /full poll budget is spent with no result file[\s\S]*?down:true/,
-    'expected a spent-budget branch that returns the codex_down schema shape',
-  );
-});
-
-test('meta Codex gate phase describes codex_down as a non-blocking skip that logs a note', () => {
-  const phaseStart = convergeSource.indexOf("title: 'Codex gate'");
-  const phaseEnd = convergeSource.indexOf("title: 'Finalize'");
-  assert.notEqual(phaseStart, -1, 'expected a Codex gate phase in meta');
-  const codexPhaseDetail = convergeSource.slice(phaseStart, phaseEnd);
-  assert.match(codexPhaseDetail, /codex_down/, 'expected the phase detail to name codex_down');
-  assert.match(
-    codexPhaseDetail,
-    /codex_down, the gate skips without blocking/,
-    'expected codex_down to be described as a non-blocking skip',
-  );
-  assert.match(
-    codexPhaseDetail,
-    /logged as a note/,
-    'expected the codex_down skip to be logged as a note so the bypass stays visible',
-  );
-  assert.doesNotMatch(
-    codexPhaseDetail,
-    /holds the PR as a draft with a codex-down blocker/,
-    'codex_down must not be described as holding the PR draft with a blocker',
-  );
-});
-
-test('CODEX_SCHEMA down.description describes codex_down as a skipped, bypassed gate recorded as a note', () => {
-  const schemaStart = convergeSource.indexOf('const CODEX_SCHEMA =');
-  const schemaEnd = convergeSource.indexOf('const COPILOT_VERIFY_VERDICTS =');
-  assert.notEqual(schemaStart, -1, 'expected CODEX_SCHEMA to exist');
-  const schemaSource = convergeSource.slice(schemaStart, schemaEnd);
-  const downLineStart = schemaSource.indexOf('down: {');
-  const downLine = schemaSource.slice(downLineStart, schemaSource.indexOf('\n', downLineStart));
-  assert.match(downLine, /codex_down/, 'expected the down description to name codex_down');
-  assert.match(downLine, /skipped and bypassed/, 'expected codex_down to be described as a skipped, bypassed gate');
-  assert.match(downLine, /recorded as a note/, 'expected codex_down to be recorded as a note');
-  assert.doesNotMatch(
-    downLine,
-    /holds the PR as a draft with a codex-down blocker/,
-    'the down description must not claim codex_down holds the PR draft as a blocker',
-  );
-});
-
-test('the CODEX phase stamps codexCleanAt on clean and clears it on an opt-out, usage, or down skip', () => {
-  const codexPhaseStart = convergeSource.indexOf("if (phase === 'CODEX') {");
-  const finalizePhaseStart = convergeSource.indexOf("if (phase === 'FINALIZE') {", codexPhaseStart);
-  assert.notEqual(codexPhaseStart, -1, 'expected a CODEX phase block');
-  assert.notEqual(finalizePhaseStart, -1, 'expected FINALIZE after CODEX');
-  const codexPhase = convergeSource.slice(codexPhaseStart, finalizePhaseStart);
-  assert.match(codexPhase, /await runCodexGate\(head\)/);
-  assert.match(codexPhase, /classifyCodexGateOutcome\(codex\)/);
-  assert.match(codexPhase, /codexCleanAt = head/, 'expected a clean pass to stamp the HEAD');
-  assert.match(codexPhase, /skip-token[\s\S]*codexDown = true[\s\S]*codexCleanAt = null/);
-  assert.match(codexPhase, /skip-usage[\s\S]*codexDown = false[\s\S]*codexCleanAt = null/);
-  assert.match(codexPhase, /kind === 'down'[\s\S]*codexDown = true[\s\S]*codexCleanAt = null/);
-});
-
-test('the CODEX phase skips a genuine codex_down gracefully, recording a note and advancing to mark-ready', () => {
-  const codexPhaseStart = convergeSource.indexOf("if (phase === 'CODEX') {");
-  const finalizePhaseStart = convergeSource.indexOf("if (phase === 'FINALIZE') {", codexPhaseStart);
-  const codexPhase = convergeSource.slice(codexPhaseStart, finalizePhaseStart);
-  const downBranchStart = codexPhase.indexOf("codexOutcome.kind === 'down'");
-  const downBranchEnd = codexPhase.indexOf("codexOutcome.kind === 'fix'", downBranchStart);
-  assert.notEqual(downBranchStart, -1, 'expected a codex_down branch in the CODEX phase');
-  assert.notEqual(downBranchEnd, -1, 'expected a fix branch after the down branch');
-  const downBranch = codexPhase.slice(downBranchStart, downBranchEnd);
-  assert.match(downBranch, /codexNote =/, 'a genuine codex_down records a transparent note');
-  assert.match(downBranch, /codexDown = true/, 'the down branch sets the bypass flag so mark-ready skips the required Codex gate');
-  assert.match(downBranch, /codexCleanAt = null/, 'the down branch clears any codex-clean stamp');
-  assert.match(
-    downBranch,
-    /phase = 'FINALIZE'/,
-    'a genuine codex_down advances to mark-ready with the gate bypassed rather than blocking the run',
-  );
-  assert.doesNotMatch(downBranch, /blocker =/, 'a genuine codex_down must not record a blocker');
-  assert.doesNotMatch(downBranch, /\bbreak\b/, 'the down branch continues rather than breaking the loop');
-});
-
-test('the workflow return object includes codexNote so the final report surfaces the Codex skip', () => {
-  const assembleStart = convergeSource.indexOf('const assembleResult =');
-  assert.notEqual(assembleStart, -1, 'expected assembleResult to exist');
-  const assembleEnd = convergeSource.indexOf('})', assembleStart);
-  assert.notEqual(assembleEnd, -1, 'expected the assembleResult object to close');
-  const assembleSource = convergeSource.slice(assembleStart, assembleEnd);
-  assert.match(assembleSource, /codexNote,/, 'expected codexNote among the returned notes');
-});
-
-test('the CODEX phase routes findings through applyFixes and re-enters CONVERGE', () => {
-  const codexPhaseStart = convergeSource.indexOf("if (phase === 'CODEX') {");
-  const finalizePhaseStart = convergeSource.indexOf("if (phase === 'FINALIZE') {", codexPhaseStart);
-  const codexPhase = convergeSource.slice(codexPhaseStart, finalizePhaseStart);
-  assert.match(codexPhase, /applyFixes\(head, codexOutcome\.findings, 'codex'\)/);
-  assert.match(codexPhase, /phase = 'CONVERGE'/);
-  assert.match(codexPhase, /head = null/);
-});
-
-test('the COPILOT phase advances to CODEX rather than FINALIZE on a clean or bypass path', () => {
-  const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
-  const codexPhaseStart = convergeSource.indexOf("if (phase === 'CODEX') {", copilotPhaseStart);
-  assert.notEqual(copilotPhaseStart, -1, 'expected a COPILOT phase block');
-  assert.notEqual(codexPhaseStart, -1, 'expected a CODEX phase after COPILOT');
-  const copilotPhase = convergeSource.slice(copilotPhaseStart, codexPhaseStart);
-  assert.match(copilotPhase, /phase = 'CODEX'/);
-  assert.doesNotMatch(copilotPhase, /phase = 'FINALIZE'/);
-});
-
-test('the merged FINALIZE check receives codexDown and codexCleanAt and passes matching flags', () => {
-  const finalizeStart = convergeSource.indexOf("if (phase === 'FINALIZE') {");
-  assert.notEqual(finalizeStart, -1, 'expected a FINALIZE phase block');
-  const checkCall = convergeSource.indexOf('runConvergenceCheck(', finalizeStart);
-  assert.notEqual(checkCall, -1, 'expected the FINALIZE phase to call runConvergenceCheck');
-  const checkLine = convergeSource.slice(checkCall, convergeSource.indexOf('\n', checkCall));
-  assert.match(checkLine, /codexDown/);
-  assert.match(checkLine, /codexCleanAt/);
-  const checkBody = functionBody('runConvergenceCheck');
-  assert.match(checkBody, /context\.codexDown \? ' --codex-down' : ''/);
-  assert.match(checkBody, /context\.codexCleanAt \? ` --codex-clean-at \$\{context\.codexCleanAt\}` : ''/);
-  assert.match(checkBody, /if \(context\.codexDown\) reviewerOptOutTokens\.push\('codex'\)/);
-});
-
-test('runConvergenceCheck tells the finalize agent to persist codex_clean_at for the flagless mark-ready re-check', () => {
-  const checkBody = functionBody('runConvergenceCheck');
-  assert.match(
-    checkBody,
-    /codexCleanAtNote/,
-    'expected a dedicated note when the Codex gate stamped clean on HEAD',
-  );
-  assert.match(
-    checkBody,
-    /pr-converge-state\.json/,
-    'expected the note to name the job-dir state file the mark-ready blocker re-reads',
-  );
-  assert.match(
-    checkBody,
-    /codex_clean_at/,
-    'expected the note to write the codex_clean_at key the flagless re-check resolves',
-  );
-  assert.match(
-    checkBody,
-    /CLAUDE_JOB_DIR/,
-    'expected the note to locate the state file under CLAUDE_JOB_DIR',
-  );
-  assert.match(
-    checkBody,
-    /needsCodexCleanExportFallback/,
-    'expected a single-export fallback path when CLAUDE_JOB_DIR is unset',
-  );
-  assert.match(
-    checkBody,
-    /Emit exactly one export/,
-    'expected the opt-out instruction to forbid a second overwriting export',
-  );
-  assert.doesNotMatch(
-    checkBody,
-    /export CLAUDE_REVIEWS_DISABLED="codex"/,
-    'expected no second solo codex export that would overwrite other tokens',
-  );
-});
-
-test('CONFIG expands home for the codex-review scripts directory', () => {
-  assert.match(
-    convergeSource,
-    /const homeDirectory = \([\s\S]*?homeDirectoryPayload\.homeDirectory/,
-    'expected home to be sourced from the workflow args payload (the sandbox exposes no process)',
-  );
-  assert.match(
-    convergeSource,
-    /codexScripts:\s*`\$\{homeDirectory\}\/\.claude\/_shared\/pr-loop\/scripts`/,
-    'expected codexScripts to expand homeDirectory rather than embed $HOME',
-  );
-  assert.doesNotMatch(
-    convergeSource,
-    /codexScripts:\s*'\$HOME\//,
-    'expected no literal $HOME token in codexScripts (Python raw strings do not expand it)',
-  );
-});
-
-test('no process global is read unguarded (the workflow sandbox exposes no process)', () => {
-  const unguardedProcessLines = convergeSource
-    .split('\n')
-    .filter((sourceLine) => sourceLine.includes('process.') && !sourceLine.includes('typeof process'));
-  assert.deepEqual(
-    unguardedProcessLines,
-    [],
-    'every process.* read must sit on a line guarded by typeof process; the Bun workflow sandbox has no process global',
-  );
-});
-
-test('the home directory is sourced from the workflow args payload', () => {
-  assert.match(
-    convergeSource,
-    /const homeDirectoryPayload = normalizeRunInput\(args\)/,
-    'expected homeDirectory to read args (the only channel into the process-less sandbox), parsed via normalizeRunInput',
-  );
-});
-
-test('meta lists the Codex gate phase between Copilot and Finalize', () => {
-  const copilotPhaseIndex = convergeSource.indexOf("title: 'Copilot gate'");
-  const codexPhaseIndex = convergeSource.indexOf("title: 'Codex gate'");
-  const finalizePhaseIndex = convergeSource.indexOf("title: 'Finalize'");
-  assert.notEqual(codexPhaseIndex, -1, 'expected a Codex gate phase in meta');
-  assert.ok(copilotPhaseIndex < codexPhaseIndex && codexPhaseIndex < finalizePhaseIndex);
-});
-
-test('SKILL.md names Codex among the terminal confirmation gates', () => {
-  assert.match(skillSource, /Codex/i);
-});
-
-test('SKILL.md documents codexNote in the workflow return shape', () => {
-  const returnShapeMatch = skillSource.match(/`\{ converged, rounds, finalSha, blocker,[^`]*\}`/);
-  assert.ok(returnShapeMatch, 'expected the documented return shape literal in SKILL.md');
-  assert.match(returnShapeMatch[0], /codexNote/);
-});
-
-test('SKILL.md final-report template surfaces the codexNote so a bypassed Codex gate stays visible', () => {
-  const reportBlockMatch = skillSource.match(/\/autoconverge exit:[\s\S]*?```/);
-  assert.ok(reportBlockMatch, 'expected the final-report template block in SKILL.md');
-  assert.match(reportBlockMatch[0], /Codex: <codexNote>/);
-});
-
-test('stop-conditions.md documents the Codex gate skip paths as non-blockers', () => {
-  assert.match(stopConditionsSource, /Codex/i);
-  assert.match(stopConditionsSource, /codex/i);
-});

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

@@ -1,64 +0,0 @@
-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, /_shared\/pr-loop\/precatch-rubric\.md/)
-  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('workflow agents receive the selected GitHub transport before role instructions', () => {
-  assert.match(
-    workflowSource,
-    /HEADLESS_EDIT_PREAMBLE\}\$\{githubTransportDirective\(activeGithubTransport\)\}\$\{worktreeDirective/,
-  )
-  assert.match(
-    workflowSource,
-    /HEADLESS_READONLY_PREAMBLE\}\$\{githubTransportDirective\(activeGithubTransport\)\}\$\{worktreeDirective/,
-  )
-})
-
-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\)/)
-})