claude-dev-env 1.95.0 → 2.0.0

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

@@ -0,0 +1,300 @@
+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 phase stamps codexCleanAt on clean and clears it on skip/down', () => {
+  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 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 = \(process\.env\.HOME \|\| process\.env\.USERPROFILE/,
+    'expected home to be resolved from process.env before CONFIG path use',
+  );
+  assert.match(
+    convergeSource,
+    /codexScripts:\s*`\$\{homeDirectory\}\/\.claude\/skills\/codex-review\/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('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('stop-conditions.md documents the Codex gate skip paths as non-blockers', () => {
+  assert.match(stopConditionsSource, /Codex/i);
+  assert.match(stopConditionsSource, /codex/i);
+});

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

@@ -312,8 +312,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,
-    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',
+    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',
   );
 });
 
@@ -617,8 +617,8 @@ test('every standards-deferral call site builds standardsNote from the spawnStan
   const callSiteUses = convergeSource.match(/standardsNote = standardsDeferralNote\(/g) || [];
   assert.equal(
     callSiteUses.length,
-    3,
-    'expected the converge-round, terminal-Bugbot, and Copilot standards call sites to each build standardsNote via standardsDeferralNote(...)',
+    4,
+    'expected the converge-round, terminal-Bugbot, Copilot, and Codex standards call sites to each build standardsNote via standardsDeferralNote(...)',
   );
   assert.doesNotMatch(
     convergeSource,
@@ -1234,7 +1234,7 @@ test('the FINALIZE phase drives the merged check and reads ready from its result
   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, bugteamPostBlocked: cleanAuditNote !== null \}\)/);
+  assert.match(finalizeBody, /runConvergenceCheck\(\{ head, bugbotDown, copilotDown, codexDown, codexCleanAt, bugteamPostBlocked: cleanAuditNote !== null \}\)/);
   assert.match(finalizeBody, /classifyReadyOutcome\(finalizeResult\)/);
   assert.doesNotMatch(
     finalizeBody,

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

@@ -276,8 +276,8 @@ test('the Copilot gate prompt tiers each finding and returns the review URL', ()
 
 test('the COPILOT phase returns blocker user-review only when inconclusive findings remain after verification, carrying the verifier-noted payload with no auto-fix in the branch', () => {
   const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
-  const finalizePhaseStart = convergeSource.indexOf("if (phase === 'FINALIZE') {", copilotPhaseStart);
-  const copilotPhase = convergeSource.slice(copilotPhaseStart, finalizePhaseStart);
+  const codexPhaseStart = convergeSource.indexOf("if (phase === 'CODEX') {", copilotPhaseStart);
+  const copilotPhase = convergeSource.slice(copilotPhaseStart, codexPhaseStart);
   const userReviewGuardStart = copilotPhase.indexOf('inconclusive.length > 0');
   assert.notEqual(userReviewGuardStart, -1, 'expected the user-review return to be guarded by inconclusive.length > 0');
   const userReviewBranch = copilotPhase.slice(userReviewGuardStart, userReviewGuardStart + 600);
@@ -296,8 +296,8 @@ test('the COPILOT phase returns blocker user-review only when inconclusive findi
 
 test('the COPILOT phase awaits verifyCodeConcernFindings exactly once, inside the code-concern guard', () => {
   const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
-  const finalizePhaseStart = convergeSource.indexOf("if (phase === 'FINALIZE') {", copilotPhaseStart);
-  const copilotPhase = convergeSource.slice(copilotPhaseStart, finalizePhaseStart);
+  const codexPhaseStart = convergeSource.indexOf("if (phase === 'CODEX') {", copilotPhaseStart);
+  const copilotPhase = convergeSource.slice(copilotPhaseStart, codexPhaseStart);
   const guardStart = copilotPhase.indexOf('if (codeConcern.length > 0)');
   assert.notEqual(guardStart, -1, 'expected the verification to sit behind a codeConcern.length > 0 guard');
   const verifyCalls = convergeSource.match(/await verifyCodeConcernFindings\(/g) || [];
@@ -306,21 +306,21 @@ test('the COPILOT phase awaits verifyCodeConcernFindings exactly once, inside th
   assert.ok(verifyCallIndex > guardStart, 'expected the verifyCodeConcernFindings call to sit inside the code-concern guard');
 });
 
-test('the all-refuted / empty-roundFindings COPILOT path advances to FINALIZE with the gate passed', () => {
+test('the all-refuted / empty-roundFindings COPILOT path advances to CODEX with the gate passed', () => {
   const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
-  const finalizePhaseStart = convergeSource.indexOf("if (phase === 'FINALIZE') {", copilotPhaseStart);
-  const copilotPhase = convergeSource.slice(copilotPhaseStart, finalizePhaseStart);
+  const codexPhaseStart = convergeSource.indexOf("if (phase === 'CODEX') {", copilotPhaseStart);
+  const copilotPhase = convergeSource.slice(copilotPhaseStart, codexPhaseStart);
   const emptyRoundStart = copilotPhase.indexOf('roundFindings.length === 0');
   assert.notEqual(emptyRoundStart, -1, 'expected the COPILOT phase to handle an empty roundFindings set after verification');
   const emptyRoundBranch = copilotPhase.slice(emptyRoundStart, emptyRoundStart + 300);
   assert.match(emptyRoundBranch, /copilotDown = false/, 'expected the empty-roundFindings path to clear copilotDown');
-  assert.match(emptyRoundBranch, /phase = 'FINALIZE'/, 'expected the empty-roundFindings path to advance to FINALIZE');
+  assert.match(emptyRoundBranch, /phase = 'CODEX'/, 'expected the empty-roundFindings path to advance to CODEX');
 });
 
 test('the COPILOT phase folds confirmed findings through attachVerifiedRepro into the round fix list', () => {
   const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
-  const finalizePhaseStart = convergeSource.indexOf("if (phase === 'FINALIZE') {", copilotPhaseStart);
-  const copilotPhase = convergeSource.slice(copilotPhaseStart, finalizePhaseStart);
+  const codexPhaseStart = convergeSource.indexOf("if (phase === 'CODEX') {", copilotPhaseStart);
+  const copilotPhase = convergeSource.slice(copilotPhaseStart, codexPhaseStart);
   assert.match(
     copilotPhase,
     /roundFindings = \[\.\.\.selfHealing, \.\.\.confirmed\.map\(\(each\) => attachVerifiedRepro\(each\)\)\]/,
@@ -405,15 +405,15 @@ test('runConvergenceCheck wires the --copilot-down flag from the copilotDown con
   );
 });
 
-test('the COPILOT phase routes a down outcome to FINALIZE with the gate bypassed', () => {
+test('the COPILOT phase routes a down outcome to CODEX with the gate bypassed', () => {
   const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
   assert.notEqual(copilotPhaseStart, -1, 'expected a COPILOT phase block');
   const downBranchStart = convergeSource.indexOf("copilotOutcome.kind === 'down'", copilotPhaseStart);
   assert.notEqual(downBranchStart, -1, 'expected the COPILOT phase to handle a down outcome');
-  const downBranch = convergeSource.slice(downBranchStart, downBranchStart + 400);
+  const downBranch = convergeSource.slice(downBranchStart, downBranchStart + 700);
   assert.match(downBranch, /copilotDown = true/);
   assert.match(downBranch, /copilotNote =/);
-  assert.match(downBranch, /phase = 'FINALIZE'/);
+  assert.match(downBranch, /phase = 'CODEX'/);
 });
 
 test('resolveCopilotDown reports down only for a down outcome', () => {
@@ -448,7 +448,7 @@ test('resolveCopilotDown clears the bypass for a retry outcome', () => {
   assert.equal(resolveCopilotDown({ kind: 'retry' }), false);
 });
 
-test('the standards-only Copilot sub-path resets copilotDown before FINALIZE', () => {
+test('the standards-only Copilot sub-path resets copilotDown before CODEX', () => {
   const standardsBranchStart = convergeSource.indexOf(
     'isStandardsOnlyRound(roundFindings)',
   );
@@ -459,19 +459,19 @@ test('the standards-only Copilot sub-path resets copilotDown before FINALIZE', (
   );
   const standardsBranch = convergeSource.slice(standardsBranchStart, standardsBranchStart + 800);
   const resetIndex = standardsBranch.indexOf('copilotDown = false');
-  const finalizeIndex = standardsBranch.indexOf("phase = 'FINALIZE'");
+  const codexIndex = standardsBranch.indexOf("phase = 'CODEX'");
   assert.notEqual(
     resetIndex,
     -1,
     'expected the standards-only sub-path to reset copilotDown so a recovered Copilot is not bypassed',
   );
-  assert.notEqual(finalizeIndex, -1, 'expected the standards-only sub-path to reach FINALIZE');
+  assert.notEqual(codexIndex, -1, 'expected the standards-only sub-path to reach CODEX');
   assert.ok(
-    resetIndex < finalizeIndex,
-    'expected copilotDown to be cleared before the transition to FINALIZE',
+    resetIndex < codexIndex,
+    'expected copilotDown to be cleared before the transition to CODEX',
   );
   assert.match(
-    standardsBranch.slice(0, finalizeIndex),
+    standardsBranch.slice(0, codexIndex),
     /copilotNote = null/,
     'expected the standards-only sub-path to clear the stale copilotNote alongside copilotDown',
   );
@@ -480,12 +480,12 @@ test('the standards-only Copilot sub-path resets copilotDown before FINALIZE', (
 test('the COPILOT phase recomputes copilotDown from each gate outcome via resolveCopilotDown', () => {
   const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
   assert.notEqual(copilotPhaseStart, -1, 'expected a COPILOT phase block');
-  const finalizePhaseStart = convergeSource.indexOf(
-    "if (phase === 'FINALIZE') {",
+  const codexPhaseStart = convergeSource.indexOf(
+    "if (phase === 'CODEX') {",
     copilotPhaseStart,
   );
-  assert.notEqual(finalizePhaseStart, -1, 'expected a FINALIZE phase block after COPILOT');
-  const copilotPhase = convergeSource.slice(copilotPhaseStart, finalizePhaseStart);
+  assert.notEqual(codexPhaseStart, -1, 'expected a CODEX phase block after COPILOT');
+  const copilotPhase = convergeSource.slice(copilotPhaseStart, codexPhaseStart);
   assert.match(
     copilotPhase,
     /copilotDown = resolveCopilotDown\(copilotOutcome\)/,
@@ -552,7 +552,7 @@ test('the COPILOT phase short-circuits on the unified reviewer-down gate before
   );
   assert.match(beforeGate, /copilotDown = true/, 'expected the bypass to mark copilotDown');
   assert.match(beforeGate, /copilotNote =/, 'expected the bypass to set a copilotNote');
-  assert.match(beforeGate, /phase = 'FINALIZE'/, 'expected the bypass to advance to FINALIZE');
+  assert.match(beforeGate, /phase = 'CODEX'/, 'expected the bypass to advance to CODEX');
   assert.match(beforeGate, /continue/, 'expected the bypass to continue without spawning the gate agent');
 });
 
@@ -574,7 +574,7 @@ test('copilotDown initializes from input.copilotDisabled so the pre-check decisi
   );
 });
 
-test('a copilotDisabled run reaches FINALIZE with --copilot-down', () => {
+test('a copilotDisabled run reaches CODEX with --copilot-down', () => {
   const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
   const bypassStart = convergeSource.indexOf(
     'if (resolveReviewerDown(reviewerAvailability?.copilot, input.copilotDisabled || false))',
@@ -583,12 +583,12 @@ test('a copilotDisabled run reaches FINALIZE with --copilot-down', () => {
   assert.notEqual(bypassStart, -1, 'expected the unified resolveReviewerDown bypass in the COPILOT phase');
   const bypassBlock = convergeSource.slice(bypassStart, bypassStart + 800);
   assert.match(bypassBlock, /copilotDown = true/, 'expected the bypass to set copilotDown');
-  assert.match(bypassBlock, /phase = 'FINALIZE'/, 'expected the bypass to advance to FINALIZE');
+  assert.match(bypassBlock, /phase = 'CODEX'/, 'expected the bypass to advance to CODEX');
   const convergenceCheckBody = functionBody('runConvergenceCheck');
   assert.match(
     convergenceCheckBody,
     /context\.copilotDown \? ' --copilot-down' : ''/,
-    'expected the convergence check to pass --copilot-down when the bypassed copilotDown reaches FINALIZE',
+    'expected the convergence check to pass --copilot-down when the bypassed copilotDown reaches FINALIZE via CODEX',
   );
 });
 
@@ -673,8 +673,8 @@ test('every standards-deferral call site routes the create through openStandards
   const onceCalls = convergeSource.match(/await openStandardsFollowUpOnce\(/g) || [];
   assert.equal(
     onceCalls.length,
-    3,
-    'expected the converge-round, terminal-Bugbot, and Copilot standards call sites to all defer to openStandardsFollowUpOnce',
+    4,
+    'expected the converge-round, terminal-Bugbot, Copilot, and Codex standards call sites to all defer to openStandardsFollowUpOnce',
   );
   const directCreates = convergeSource.match(/await spawnStandardsFollowUp\(/g) || [];
   assert.equal(

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

@@ -100,7 +100,7 @@ test('the converge call site sets a fix-stalled blocker when an all-null-thread
 test('the copilot call site sets a fix-stalled blocker when an all-null-thread resolvedWithoutCommit round cannot progress', () => {
   const copilotBranch = convergeSource.slice(
     convergeSource.indexOf("const fixResult = await applyFixes(head, roundFindings, 'copilot')"),
-    convergeSource.indexOf("phase = 'CONVERGE'\n      continue\n    }\n    phase = 'FINALIZE'"),
+    convergeSource.indexOf("phase = 'CONVERGE'\n      continue\n    }\n    phase = 'CODEX'"),
   );
   assert.match(copilotBranch, /collectFindingThreadIds/);
   assert.match(copilotBranch, /fix stalled/i);