claude-dev-env 4.2.0 → 7.0.0

package/.agents/skills/autoconverge/workflow/converge.p2-advance.test.mjs

@@ -1,202 +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');
-
-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(
-  `const SHA_COMPARISON_PREFIX_LENGTH = 7;\n` +
-    `${functionBody('normalizeShaForComparison')}\n` +
-    `${functionBody('isP2OnlyFindings')}\n` +
-    `${functionBody('nextPhaseAfterP2OnlyFix')}\n` +
-    `${functionBody('routeAfterP2OnlyFix')}\n` +
-    'return { isP2OnlyFindings, nextPhaseAfterP2OnlyFix, routeAfterP2OnlyFix };',
-)();
-
-const { isP2OnlyFindings, nextPhaseAfterP2OnlyFix, routeAfterP2OnlyFix } = productionModule;
-
-function finding(overrides) {
-  return {
-    file: 'a.py',
-    line: 1,
-    severity: 'P2',
-    category: 'bug',
-    title: 't',
-    detail: 'd',
-    replyToCommentId: null,
-    ...overrides,
-  };
-}
-
-function phaseBranch(phaseMarker) {
-  const phaseStart = convergeSource.indexOf(phaseMarker);
-  assert.notEqual(phaseStart, -1, `expected ${phaseMarker} to exist`);
-  const nextPhaseStart = convergeSource.indexOf('\n  if (phase === ', phaseStart + 1);
-  const phaseEnd = nextPhaseStart === -1 ? convergeSource.length : nextPhaseStart;
-  return convergeSource.slice(phaseStart, phaseEnd);
-}
-
-test('isP2OnlyFindings is false for an empty findings list', () => {
-  assert.equal(isP2OnlyFindings([]), false);
-});
-
-test('isP2OnlyFindings is true when every finding is severity P2', () => {
-  assert.equal(isP2OnlyFindings([finding(), finding({ file: 'b.py', line: 2 })]), true);
-});
-
-test('isP2OnlyFindings is false when a P1 is mixed in with P2 findings', () => {
-  assert.equal(isP2OnlyFindings([finding(), finding({ severity: 'P1' })]), false);
-});
-
-test('isP2OnlyFindings is false when every finding is severity P1', () => {
-  assert.equal(isP2OnlyFindings([finding({ severity: 'P1' })]), false);
-});
-
-test('isP2OnlyFindings is false when a finding is missing severity', () => {
-  assert.equal(isP2OnlyFindings([{ file: 'a.py', line: 1, category: 'bug' }]), false);
-});
-
-test('nextPhaseAfterP2OnlyFix advances CONVERGE to BUGBOT', () => {
-  assert.equal(nextPhaseAfterP2OnlyFix('CONVERGE'), 'BUGBOT');
-});
-
-test('nextPhaseAfterP2OnlyFix advances BUGBOT to COPILOT', () => {
-  assert.equal(nextPhaseAfterP2OnlyFix('BUGBOT'), 'COPILOT');
-});
-
-test('nextPhaseAfterP2OnlyFix advances COPILOT to CODEX', () => {
-  assert.equal(nextPhaseAfterP2OnlyFix('COPILOT'), 'CODEX');
-});
-
-test('nextPhaseAfterP2OnlyFix advances CODEX to FINALIZE', () => {
-  assert.equal(nextPhaseAfterP2OnlyFix('CODEX'), 'FINALIZE');
-});
-
-test('routeAfterP2OnlyFix re-converges when the fix moved HEAD', () => {
-  const route = routeAfterP2OnlyFix('aaa111', { newSha: 'bbb222' }, 'COPILOT');
-  assert.equal(route.didMoveHead, true);
-  assert.equal(route.fixedHead, 'bbb222');
-  assert.equal(route.nextPhase, 'CONVERGE');
-});
-
-test('routeAfterP2OnlyFix advances when HEAD is unchanged', () => {
-  const route = routeAfterP2OnlyFix('aaa111', { newSha: 'aaa111' }, 'COPILOT');
-  assert.equal(route.didMoveHead, false);
-  assert.equal(route.fixedHead, 'aaa111');
-  assert.equal(route.nextPhase, 'COPILOT');
-});
-
-test('nextPhaseAfterP2OnlyFix uses an in-function lookup map', () => {
-  const body = functionBody('nextPhaseAfterP2OnlyFix');
-  assert.match(body, /nextPhaseByCurrent/);
-  assert.match(body, /CONVERGE:\s*'BUGBOT'/);
-  assert.match(body, /BUGBOT:\s*'COPILOT'/);
-  assert.match(body, /COPILOT:\s*'CODEX'/);
-});
-
-test('applyP2OnlyFix runs applyFixes then detectFixProgress in order', () => {
-  const body = functionBody('applyP2OnlyFix');
-  const applyIndex = body.indexOf('applyFixes(head, findings, sourceLabel)');
-  const detectIndex = body.indexOf('detectFixProgress(fixResult, head, hadThreadBearingFinding)');
-  assert.notEqual(applyIndex, -1, 'expected applyFixes in applyP2OnlyFix');
-  assert.notEqual(detectIndex, -1, 'expected detectFixProgress in applyP2OnlyFix');
-  assert.ok(applyIndex < detectIndex, 'applyFixes must precede detectFixProgress');
-  assert.match(body, /collectFindingThreadIds/);
-});
-
-test('CONVERGE places the P2-only branch between standards-only and generic fix', () => {
-  const convergeBranch = phaseBranch("if (phase === 'CONVERGE')");
-  const standardsIndex = convergeBranch.indexOf('isStandardsOnlyRound(findings)');
-  const p2OnlyIndex = convergeBranch.indexOf('isP2OnlyFindings(findings)');
-  const genericFixIndex = convergeBranch.indexOf("finding(s) — applying fixes");
-  assert.notEqual(standardsIndex, -1, 'expected the standards-only branch');
-  assert.notEqual(p2OnlyIndex, -1, 'expected the P2-only branch');
-  assert.notEqual(genericFixIndex, -1, 'expected the generic fix branch');
-  assert.ok(standardsIndex < p2OnlyIndex, 'standards-only must precede P2-only');
-  assert.ok(p2OnlyIndex < genericFixIndex, 'P2-only must precede generic fix');
-});
-
-test('CONVERGE P2-only branch fixes once and routes via routeAfterP2OnlyFix', () => {
-  const convergeBranch = phaseBranch("if (phase === 'CONVERGE')");
-  const p2Start = convergeBranch.indexOf('isP2OnlyFindings(findings)');
-  const genericFixStart = convergeBranch.indexOf("finding(s) — applying fixes");
-  const p2Branch = convergeBranch.slice(p2Start, genericFixStart);
-  assert.match(p2Branch, /P2-only/);
-  assert.match(p2Branch, /applyP2OnlyFix\(head, findings, 'converge-round'/);
-  assert.match(p2Branch, /routeAfterP2OnlyFix\(head, p2Fix, advancePhase\)/);
-  assert.match(p2Branch, /nextPhaseAfterP2OnlyFix\('CONVERGE'\)/);
-  assert.match(p2Branch, /head = p2Route\.fixedHead/);
-  assert.match(p2Branch, /phase = p2Route\.nextPhase/);
-  assert.doesNotMatch(p2Branch, /head = null/);
-});
-
-test('BUGBOT P2-only branch routes through routeAfterP2OnlyFix', () => {
-  const bugbotBranch = phaseBranch("if (phase === 'BUGBOT')");
-  const standardsIndex = bugbotBranch.indexOf('isStandardsOnlyRound(bugbotOutcome.findings)');
-  const p2OnlyIndex = bugbotBranch.indexOf('isP2OnlyFindings(bugbotOutcome.findings)');
-  const genericFixIndex = bugbotBranch.indexOf('fixing and re-converging');
-  assert.ok(standardsIndex < p2OnlyIndex, 'standards-only must precede P2-only on BUGBOT');
-  assert.ok(p2OnlyIndex < genericFixIndex, 'P2-only must precede generic re-converge on BUGBOT');
-  const p2Branch = bugbotBranch.slice(p2OnlyIndex, genericFixIndex);
-  assert.match(p2Branch, /P2-only/);
-  assert.match(p2Branch, /nextPhaseAfterP2OnlyFix\('BUGBOT'\)/);
-  assert.match(p2Branch, /applyP2OnlyFix\(head, bugbotOutcome\.findings, 'bugbot'/);
-  assert.match(p2Branch, /routeAfterP2OnlyFix\(head, p2Fix, advancePhase\)/);
-  assert.match(p2Branch, /phase = p2Route\.nextPhase/);
-});
-
-test('COPILOT P2-only branch routes through routeAfterP2OnlyFix', () => {
-  const copilotBranch = phaseBranch("if (phase === 'COPILOT')");
-  const standardsIndex = copilotBranch.indexOf('isStandardsOnlyRound(roundFindings)');
-  const p2OnlyIndex = copilotBranch.indexOf('isP2OnlyFindings(roundFindings)');
-  const genericFixIndex = copilotBranch.indexOf('fixing and re-converging');
-  assert.ok(standardsIndex < p2OnlyIndex, 'standards-only must precede P2-only on COPILOT');
-  assert.ok(p2OnlyIndex < genericFixIndex, 'P2-only must precede generic re-converge on COPILOT');
-  const p2Branch = copilotBranch.slice(p2OnlyIndex, genericFixIndex);
-  assert.match(p2Branch, /P2-only/);
-  assert.match(p2Branch, /nextPhaseAfterP2OnlyFix\('COPILOT'\)/);
-  assert.match(p2Branch, /applyP2OnlyFix\(head, roundFindings, 'copilot'/);
-  assert.match(p2Branch, /routeAfterP2OnlyFix\(head, p2Fix, advancePhase\)/);
-  assert.match(p2Branch, /phase = p2Route\.nextPhase/);
-});
-
-test('CODEX P2-only branch routes through routeAfterP2OnlyFix and stamps codexCleanAt only when HEAD is stable', () => {
-  const codexBranch = phaseBranch("if (phase === 'CODEX')");
-  const standardsIndex = codexBranch.indexOf('isStandardsOnlyRound(codexOutcome.findings)');
-  const p2OnlyIndex = codexBranch.indexOf('isP2OnlyFindings(codexOutcome.findings)');
-  const genericFixIndex = codexBranch.indexOf('fixing and re-converging');
-  assert.ok(standardsIndex < p2OnlyIndex, 'standards-only must precede P2-only on CODEX');
-  assert.ok(p2OnlyIndex < genericFixIndex, 'P2-only must precede generic re-converge on CODEX');
-  const p2Branch = codexBranch.slice(p2OnlyIndex, genericFixIndex);
-  assert.match(p2Branch, /P2-only/);
-  assert.match(p2Branch, /nextPhaseAfterP2OnlyFix\('CODEX'\)/);
-  assert.match(p2Branch, /applyP2OnlyFix\(head, codexOutcome\.findings, 'codex'/);
-  assert.match(p2Branch, /routeAfterP2OnlyFix\(head, p2Fix, advancePhase\)/);
-  assert.match(p2Branch, /codexCleanAt = head/);
-  assert.match(p2Branch, /didMoveHead/);
-});
-
-test('generic fix branches still re-converge for mixed or P0/P1 findings', () => {
-  const bugbotBranch = phaseBranch("if (phase === 'BUGBOT')");
-  const genericStart = bugbotBranch.indexOf('fixing and re-converging');
-  const genericBranch = bugbotBranch.slice(genericStart);
-  assert.match(genericBranch, /phase = 'CONVERGE'/);
-  assert.match(genericBranch, /head = null/);
-
-  const copilotBranch = phaseBranch("if (phase === 'COPILOT')");
-  const copilotGenericStart = copilotBranch.indexOf('fixing and re-converging');
-  const copilotGeneric = copilotBranch.slice(copilotGenericStart);
-  assert.match(copilotGeneric, /phase = 'CONVERGE'/);
-  assert.match(copilotGeneric, /head = null/);
-});

package/.agents/skills/autoconverge/workflow/converge.path-aware.test.mjs

@@ -1,47 +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');
-
-function sliceBetween(startNeedle, endNeedle) {
-  const sliceStart = convergeSource.indexOf(startNeedle);
-  assert.notEqual(sliceStart, -1, `expected ${startNeedle} to exist`);
-  const sliceEnd = convergeSource.indexOf(endNeedle, sliceStart + startNeedle.length);
-  assert.notEqual(sliceEnd, -1, `expected ${endNeedle} to exist after ${startNeedle}`);
-  return convergeSource.slice(sliceStart, sliceEnd);
-}
-
-const productionModule = new Function(
-  `${sliceBetween('const worktreeDirective =', '\nconst convergeAgent =')}\n` +
-    'return { worktreeDirective };',
-)();
-const { worktreeDirective } = productionModule;
-
-test('a single-PR run (no repoPath) produces an empty worktree directive', () => {
-  assert.equal(worktreeDirective(null), '');
-});
-
-test('a path-scoped run pins every agent to the PR worktree by absolute path', () => {
-  const directive = worktreeDirective('/worktrees/pr-398');
-  assert.match(directive, /\/worktrees\/pr-398/);
-  assert.match(directive, /cd /);
-  assert.match(directive, /git, gh, diff, edit, commit, push, and test/);
-});
-
-test('a path-scoped run defers to a step that names a different repository directory', () => {
-  assert.match(worktreeDirective('/worktrees/pr-398'), /different repository directory/i);
-});
-
-test('convergeAgent prepends the worktree directive for the active repo path', () => {
-  const agentDefinition = sliceBetween('const convergeAgent =', '\nconst PRE_COMMIT_GATE_STEP');
-  assert.match(agentDefinition, /worktreeDirective\(activeRepoPath\)/);
-  assert.match(agentDefinition, /HEADLESS_EDIT_PREAMBLE/);
-});
-
-test('the run binds activeRepoPath from input.repoPath after the input is parsed', () => {
-  assert.match(convergeSource, /activeRepoPath = typeof input\.repoPath === 'string'/);
-});

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

@@ -1,152 +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');
-
-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 sliceBetween(startNeedle, endNeedle) {
-  const sliceStart = convergeSource.indexOf(startNeedle);
-  assert.notEqual(sliceStart, -1, `expected ${startNeedle} to exist`);
-  const sliceEnd = convergeSource.indexOf(endNeedle, sliceStart + startNeedle.length);
-  assert.notEqual(sliceEnd, -1, `expected ${endNeedle} to exist after ${startNeedle}`);
-  return convergeSource.slice(sliceStart, sliceEnd);
-}
-
-test('runStaticSweep exists and runs after the preflight-git no-SHA guard and before the parallel lenses', () => {
-  assert.match(convergeSource, /function runStaticSweep\(/, 'expected the static-sweep lens builder to exist');
-  const sweepCallIndex = convergeSource.indexOf('await runStaticSweep(');
-  assert.notEqual(sweepCallIndex, -1, 'expected the CONVERGE round to invoke runStaticSweep');
-  const noShaGuardIndex = convergeSource.indexOf('preflight-git agent returned no SHA');
-  const parallelIndex = convergeSource.indexOf('const lenses = await parallel(');
-  assert.ok(
-    noShaGuardIndex !== -1 && noShaGuardIndex < sweepCallIndex,
-    'expected the static sweep to run after the no-SHA guard',
-  );
-  assert.ok(
-    sweepCallIndex < parallelIndex,
-    'expected the static sweep to run before the opus reading lenses so they review sweep-clean code',
-  );
-});
-
-test('the static-sweep prompt names the deterministic gates and never invokes the gh CLI', () => {
-  const body = functionSource('runStaticSweep');
-  assert.match(body, /code_rules_gate\.py/, 'expected the CODE_RULES gate to be named');
-  assert.match(body, /--base/, 'expected the gate to run against the origin/main base');
-  assert.match(body, /\bruff\b/, 'expected ruff to be named');
-  assert.match(body, /\bmypy\b/, 'expected mypy to be named');
-  assert.match(body, /\bpytest\b/, 'expected stem-matched pytest to be named');
-  assert.doesNotMatch(body, /\bgh\b/, 'expected the sweep to use only local commands so it runs in a cloud session');
-});
-
-test('the static-sweep runs on the sonnetMedium tier via convergeReadOnlyAgent with the Explore agent type', () => {
-  const body = functionSource('runStaticSweep');
-  assert.match(body, /convergeReadOnlyAgent\(/, 'expected the sweep to spawn through the read-only preamble');
-  assert.match(body, /renderLensDiffContext\(preflightResult\)/, 'expected the sweep to inject the preflight changed-file context');
-  assert.match(body, /label: 'lens:static-sweep'/);
-  assert.match(body, /agentType: 'Explore'/);
-  assert.match(body, /\.\.\.TIERS\.sonnetMedium/, 'expected the deterministic sweep to run on the cheaper sonnet tier');
-});
-
-test('a static-sweep finding routes through applyFixes with the static-sweep label and nulls head before continue', () => {
-  const sweepBranch = sliceBetween('await runStaticSweep(', "const lenses = await parallel(");
-  assert.match(sweepBranch, /applyFixes\(head, sweep\.findings, 'static-sweep'\)/, 'expected sweep findings to route through applyFixes');
-  assert.match(sweepBranch, /detectFixProgress\(sweepFix, head, false\)/, 'expected the sweep fix to check fix progress with no thread-bearing finding');
-  const headNullIndex = sweepBranch.indexOf('head = null');
-  const continueIndex = sweepBranch.indexOf('continue');
-  assert.notEqual(headNullIndex, -1, 'expected the sweep-findings branch to null head so the next round reviews the fixed code');
-  assert.ok(headNullIndex < continueIndex, 'expected head to be invalidated before the sweep branch continues');
-});
-
-test('runAuditLens carries the adversarial second pass and points at the pre-catch rubric', () => {
-  const body = functionSource('runAuditLens');
-  assert.match(body, /missed at least 3 P1/, 'expected the mandatory adversarial second pass');
-  assert.match(body, /CONFIG\.precatchRubric/, 'expected the audit lens to point at the pre-catch rubric for the doc-parity/test/PR-description lanes');
-  assert.doesNotMatch(body, /nothing new is an acceptable/i, 'expected a bare "nothing new" to be rejected');
-});
-
-test('runSelfReviewLens exists on opusMedium via convergeReadOnlyAgent and covers the three semantic lanes', () => {
-  const body = functionSource('runSelfReviewLens');
-  assert.match(body, /convergeReadOnlyAgent\(/, 'expected the self-review lens to spawn through the read-only preamble');
-  assert.match(body, /renderLensDiffContext\(preflightResult\)/, 'expected the self-review lens to inject the preflight changed-file context');
-  assert.match(body, /CONFIG\.precatchRubric/, 'expected the self-review lens to read the pre-catch rubric');
-  assert.match(body, /pr-consistency-audit/, 'expected the self-review lens to reuse the pr-consistency-audit method');
-  assert.match(body, /category-o-docstring-vs-impl-drift/, 'expected the self-review lens to cite the category-o drift rubric');
-  assert.match(body, /parity/i, 'expected the doc-vs-code parity lane');
-  assert.match(body, /Test-assertion completeness/i, 'expected the test-assertion completeness lane');
-  assert.match(body, /PR-description-vs-diff/i, 'expected the PR-description parity lane');
-  assert.match(body, /label: 'lens:self-review'/);
-  assert.match(body, /\.\.\.TIERS\.opusMedium/, 'expected the semantic lens to stay on opus');
-});
-
-test('the round parallel array holds exactly the three internal lenses and no Bugbot slot', () => {
-  const parallelArray = sliceBetween('const lenses = await parallel([', '])');
-  assert.match(parallelArray, /runCodeReviewLens\(head, reviewerAvailability\)/);
-  assert.match(parallelArray, /runAuditLens\(head, reviewerAvailability\)/);
-  assert.match(parallelArray, /runSelfReviewLens\(head, reviewerAvailability\)/);
-  assert.doesNotMatch(parallelArray, /runBugbotLens/, 'expected Bugbot to leave the per-round parallel and become a terminal gate');
-  assert.doesNotMatch(parallelArray, /isBugbotDownPreSpawn/, 'expected the pre-spawn Bugbot-down decision to be gone from the round');
-  assert.doesNotMatch(convergeSource, /const isBugbotDownPreSpawn/, 'expected no pre-spawn Bugbot-down decision anywhere in the round');
-});
-
-test('both the CONVERGE clean branch and the standards-only branch route to the terminal BUGBOT phase', () => {
-  const convergeBranch = sliceBetween("if (phase === 'CONVERGE') {", "if (phase === 'BUGBOT') {");
-  const toBugbot = convergeBranch.match(/phase = 'BUGBOT'/g) || [];
-  assert.equal(toBugbot.length, 2, 'expected the standards-only and all-clean branches to both set phase = BUGBOT');
-  assert.doesNotMatch(convergeBranch, /phase = 'COPILOT'/, 'expected the CONVERGE block to route to BUGBOT, not straight to COPILOT');
-});
-
-test('the terminal BUGBOT phase skips runBugbotLens when the reviewer-availability gate reports Bugbot down', () => {
-  const bugbotPhase = sliceBetween("if (phase === 'BUGBOT') {", "if (phase === 'COPILOT') {");
-  const availabilityGateIndex = bugbotPhase.indexOf('resolveReviewerDown(reviewerAvailability?.bugbot, input.bugbotDisabled || false)');
-  const gateCallIndex = bugbotPhase.indexOf('await runBugbotLens(head, reviewerAvailability)');
-  assert.notEqual(availabilityGateIndex, -1, 'expected the terminal gate to consult resolveReviewerDown before spawning the Bugbot lens');
-  assert.notEqual(gateCallIndex, -1, 'expected the terminal gate to call runBugbotLens when Bugbot is enabled');
-  assert.ok(availabilityGateIndex < gateCallIndex, 'expected the availability gate to short-circuit before any Bugbot agent spawns');
-  const beforeGate = bugbotPhase.slice(availabilityGateIndex, gateCallIndex);
-  assert.match(beforeGate, /bugbotDown = true/, 'expected the availability-down path to mark bugbotDown');
-  assert.match(beforeGate, /phase = 'COPILOT'/, 'expected the availability-down path to advance to the Copilot gate with no agent');
-});
-
-test('the terminal BUGBOT phase classifies via the shared reviewer-gate classifier and routes each outcome', () => {
-  const bugbotPhase = sliceBetween("if (phase === 'BUGBOT') {", "if (phase === 'COPILOT') {");
-  assert.match(bugbotPhase, /classifyReviewerGateOutcome\(bugbot\)/, 'expected the terminal gate to reuse the shared reviewer-gate classifier');
-  assert.match(bugbotPhase, /applyFixes\(head, bugbotOutcome\.findings, 'bugbot'\)/, 'expected a Bugbot fix outcome to route through applyFixes');
-  assert.match(bugbotPhase, /head = null\n\s*phase = 'CONVERGE'/, 'expected a Bugbot fix to invalidate head and re-enter CONVERGE');
-  assert.match(bugbotPhase, /phase = 'COPILOT'/, 'expected a clean or down Bugbot verdict to advance to the Copilot gate');
-});
-
-test('convergeReadOnlyAgent exists and the read-only preamble omits the rm-shape paragraph the edit preamble keeps', () => {
-  assert.match(convergeSource, /const convergeReadOnlyAgent = \(prompt, options\) =>/, 'expected the read-only agent spawner to exist');
-  const preambleRegion = convergeSource.slice(
-    convergeSource.indexOf('const HEADLESS_EDIT_PREAMBLE ='),
-    convergeSource.indexOf('\nlet activeRepoPath'),
-  );
-  const preambleModule = new Function(
-    `${preambleRegion}\nreturn { HEADLESS_EDIT_PREAMBLE, HEADLESS_READONLY_PREAMBLE };`,
-  )();
-  assert.match(preambleModule.HEADLESS_EDIT_PREAMBLE, /rm shape rules/, 'expected the edit preamble to retain the rm-shape rules');
-  assert.doesNotMatch(preambleModule.HEADLESS_READONLY_PREAMBLE, /rm shape rules/, 'expected the read-only preamble to drop the rm-shape paragraph');
-  assert.ok(
-    preambleModule.HEADLESS_READONLY_PREAMBLE.length < preambleModule.HEADLESS_EDIT_PREAMBLE.length,
-    'expected the read-only preamble to be shorter than the edit preamble',
-  );
-});
-
-test('COMMIT_RECOVERY_MAX_ATTEMPTS is one and bounds the commitWithRecovery loop', () => {
-  assert.match(convergeSource, /const COMMIT_RECOVERY_MAX_ATTEMPTS = 1/, 'expected a dedicated commit-recovery cap of one');
-  assert.match(convergeSource, /const FIX_RECOVERY_MAX_ATTEMPTS = 2/, 'expected the wider verify-recovery cap to stay at two');
-  const commitBody = functionSource('commitWithRecovery');
-  assert.match(commitBody, /attempt <= COMMIT_RECOVERY_MAX_ATTEMPTS/, 'expected commitWithRecovery to bound its loop by the dedicated cap');
-});

package/.agents/skills/autoconverge/workflow/converge.run-input.test.mjs

@@ -1,116 +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');
-
-function sourceSliceBetween(startNeedle, endNeedle) {
-  const sliceStart = convergeSource.indexOf(startNeedle);
-  assert.notEqual(sliceStart, -1, `expected ${startNeedle} to exist`);
-  const sliceEnd = convergeSource.indexOf(endNeedle, sliceStart + startNeedle.length);
-  assert.notEqual(sliceEnd, -1, `expected ${endNeedle} to exist after ${startNeedle}`);
-  return convergeSource.slice(sliceStart, sliceEnd);
-}
-
-const productionModule = new Function(
-  `${sourceSliceBetween('function normalizeRunInput(', '\nconst runInput =')}\n` +
-    'return { normalizeRunInput, classifyRunInput, githubTransportDirective };',
-)();
-
-const { normalizeRunInput, classifyRunInput, githubTransportDirective } = productionModule;
-
-const VALID_COORDINATES = { owner: 'jl-cmd', repo: 'claude-dev-env', prNumber: 543 };
-
-test('an object payload passes through unchanged', () => {
-  assert.deepEqual(normalizeRunInput(VALID_COORDINATES), VALID_COORDINATES);
-});
-
-test('a JSON-encoded string payload is parsed into coordinates', () => {
-  assert.deepEqual(normalizeRunInput(JSON.stringify(VALID_COORDINATES)), VALID_COORDINATES);
-});
-
-test('a non-JSON string returns null rather than throwing', () => {
-  assert.equal(normalizeRunInput('not json at all'), null);
-});
-
-test('an empty string returns null rather than throwing', () => {
-  assert.equal(normalizeRunInput(''), null);
-});
-
-test('classifyRunInput accepts coordinates carrying owner, repo, and prNumber', () => {
-  const classified = classifyRunInput(VALID_COORDINATES);
-  assert.deepEqual(classified.input, VALID_COORDINATES);
-  assert.equal(classified.blocker, null);
-});
-
-test('classifyRunInput accepts the cloud transport without changing the input shape', () => {
-  const cloudInput = { ...VALID_COORDINATES, transport: 'cloud' };
-  const classified = classifyRunInput(cloudInput);
-  assert.deepEqual(classified.input, cloudInput);
-  assert.equal(classified.blocker, null);
-});
-
-test('classifyRunInput blocks an unknown transport before any GitHub work starts', () => {
-  const classified = classifyRunInput({ ...VALID_COORDINATES, transport: 'proxy' });
-  assert.equal(classified.input, null);
-  assert.match(classified.blocker, /transport/i);
-});
-
-test('classifyRunInput blocks a failed parse with a structured blocker and no input', () => {
-  const classified = classifyRunInput('not json at all');
-  assert.equal(classified.input, null);
-  assert.match(classified.blocker, /coordinates/i);
-});
-
-test('classifyRunInput blocks a null payload with a structured blocker', () => {
-  const classified = classifyRunInput(null);
-  assert.equal(classified.input, null);
-  assert.match(classified.blocker, /coordinates/i);
-});
-
-test('classifyRunInput blocks a payload missing owner', () => {
-  const classified = classifyRunInput({ repo: 'claude-dev-env', prNumber: 543 });
-  assert.equal(classified.input, null);
-  assert.match(classified.blocker, /coordinates/i);
-});
-
-test('classifyRunInput blocks a payload missing prNumber', () => {
-  const classified = classifyRunInput({ owner: 'jl-cmd', repo: 'claude-dev-env' });
-  assert.equal(classified.input, null);
-  assert.match(classified.blocker, /coordinates/i);
-});
-
-test('the top-level run guards an unusable input into a structured blocker before reading input.owner', () => {
-  const guardBlock = convergeSource.slice(
-    convergeSource.indexOf('const runInput = classifyRunInput('),
-    convergeSource.indexOf('const prCoordinates ='),
-  );
-  assert.match(guardBlock, /runInput\.blocker/);
-  assert.match(guardBlock, /converged: false/);
-  assert.match(guardBlock, /return/);
-});
-
-test('classifyRunInput passes copilotDisabled through alongside the coordinates', () => {
-  const classified = classifyRunInput({ ...VALID_COORDINATES, copilotDisabled: true });
-  assert.equal(classified.blocker, null);
-  assert.equal(classified.input.copilotDisabled, true);
-});
-
-test('classifyRunInput leaves copilotDisabled undefined when the input omits it', () => {
-  const classified = classifyRunInput(VALID_COORDINATES);
-  assert.equal(classified.input.copilotDisabled, undefined);
-});
-
-test('the cloud transport directive selects MCP and contains no local CLI auth command', () => {
-  const cloudDirective = githubTransportDirective('cloud');
-  assert.match(cloudDirective, /mcp__github__/);
-  assert.match(cloudDirective, /credentialed push path/);
-  assert.doesNotMatch(cloudDirective, /gh auth/);
-});
-
-test('the local transport directive keeps the local CLI path', () => {
-  assert.match(githubTransportDirective('local'), /authenticated local GitHub CLI/);
-});