claude-dev-env 1.74.0 → 1.76.0

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

@@ -129,12 +129,12 @@ test('a Copilot no-show after the poll cap returns a down result rather than a b
   );
 });
 
-test('checkConvergence wires the --copilot-down flag from a copilotDown argument', () => {
-  const checkConvergenceBody = functionBody('checkConvergence');
+test('resumeConvergenceCheckAgent wires the --copilot-down flag from the copilotDown context', () => {
+  const checkConvergenceBody = functionBody('resumeConvergenceCheckAgent');
   assert.match(
     checkConvergenceBody,
-    /copilotDown \? ' --copilot-down' : ''/,
-    'expected checkConvergence to append --copilot-down when copilotDown is set',
+    /context\.copilotDown \? ' --copilot-down' : ''/,
+    'expected resumeConvergenceCheckAgent to append --copilot-down when copilotDown is set',
   );
   assert.match(
     checkConvergenceBody,
@@ -195,7 +195,7 @@ test('the standards-only Copilot sub-path resets copilotDown before FINALIZE', (
     -1,
     'expected the COPILOT phase to handle a standards-only Copilot fix outcome',
   );
-  const standardsBranch = convergeSource.slice(standardsBranchStart, standardsBranchStart + 600);
+  const standardsBranch = convergeSource.slice(standardsBranchStart, standardsBranchStart + 800);
   const resetIndex = standardsBranch.indexOf('copilotDown = false');
   const finalizeIndex = standardsBranch.indexOf("phase = 'FINALIZE'");
   assert.notEqual(
@@ -234,32 +234,32 @@ test('the COPILOT phase recomputes copilotDown from each gate outcome via resolv
 test('markReady receives copilotDown so it can opt the unflagged hook out of the Copilot gate', () => {
   const finalizeStart = convergeSource.indexOf("if (phase === 'FINALIZE') {");
   assert.notEqual(finalizeStart, -1, 'expected a FINALIZE phase block');
-  const markReadyCall = convergeSource.indexOf('await markReady(', finalizeStart);
-  assert.notEqual(markReadyCall, -1, 'expected the FINALIZE phase to call markReady');
-  const callSlice = convergeSource.slice(markReadyCall, markReadyCall + 40);
+  const markReadyCall = convergeSource.indexOf("'mark-ready'", finalizeStart);
+  assert.notEqual(markReadyCall, -1, 'expected the FINALIZE phase to route mark-ready through the general-utility agent');
+  const callSlice = convergeSource.slice(markReadyCall - 20, markReadyCall + 60);
   assert.match(
     callSlice,
-    /markReady\(head,\s*copilotDown\)/,
-    'expected markReady to receive copilotDown so the mark-ready agent can opt the unflagged hook out of the Copilot gate',
+    /copilotDown/,
+    'expected mark-ready context to include copilotDown so the agent can opt the unflagged hook out of the Copilot gate',
   );
 });
 
-test('the markReady prompt opts the unflagged convergence hook out of Copilot when copilotDown', () => {
-  const markReadyBody = functionBody('markReady');
+test('the mark-ready task in resumeGeneralUtilityAgent opts the unflagged convergence hook out of Copilot when copilotDown', () => {
+  const markReadyBody = functionBody('resumeGeneralUtilityAgent');
   assert.match(
     markReadyBody,
-    /copilotDown/,
-    'expected markReady to branch on copilotDown',
+    /context\.copilotDown/,
+    'expected the mark-ready task to branch on copilotDown',
   );
   assert.match(
     markReadyBody,
     /CLAUDE_REVIEWS_DISABLED/,
-    'expected the markReady prompt to set CLAUDE_REVIEWS_DISABLED so the unflagged hook re-derives the Copilot bypass',
+    'expected the mark-ready prompt to set CLAUDE_REVIEWS_DISABLED so the unflagged hook re-derives the Copilot bypass',
   );
   assert.match(
     markReadyBody,
     /copilot/,
-    'expected the markReady opt-out to name the copilot token',
+    'expected the mark-ready opt-out to name the copilot token',
   );
 });
 

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

@@ -99,30 +99,28 @@ test('FIX_RECOVERY_MAX_ATTEMPTS is declared and bounds the recovery loop at 2',
   assert.match(constantLine('FIX_RECOVERY_MAX_ATTEMPTS'), /=\s*2\s*$/);
 });
 
-for (const commitFunctionName of ['commitVerifiedFixes', 'commitRepairFixes']) {
-  test(`${commitFunctionName} prompt separates an edit-requiring block from a transient failure`, () => {
-    const commitBody = functionSource(commitFunctionName);
-    assert.match(commitBody, /blockedNeedingEdit/, 'expected the edit-block flag to be set in the prompt');
-    assert.match(commitBody, /blockerDetail/, 'expected the verbatim blocker detail to be requested');
-    assert.match(
-      commitBody,
-      /code_rules_gate|CODE_RULES/,
-      'expected the commit prompt to name the CODE_RULES commit gate as an edit-requiring block',
-    );
-    assert.match(
-      commitBody,
-      /transient/i,
-      'expected the commit prompt to name the transient (non-code) failure case',
-    );
-  });
-}
+test('the commit path in resumeCodeEditorAgent separates an edit-requiring block from a transient failure', () => {
+  const commitBody = functionSource('resumeCodeEditorAgent');
+  assert.match(commitBody, /blockedNeedingEdit/, 'expected the edit-block flag to be set in the prompt');
+  assert.match(commitBody, /blockerDetail/, 'expected the verbatim blocker detail to be requested');
+  assert.match(
+    commitBody,
+    /code_rules_gate|CODE_RULES/,
+    'expected the commit prompt to name the CODE_RULES commit gate as an edit-requiring block',
+  );
+  assert.match(
+    commitBody,
+    /transient/i,
+    'expected the commit prompt to name the transient (non-code) failure case',
+  );
+});
 
-test('recoverCommitBlockEdit is a clean-coder edit step bound to the blocker detail and leaves changes uncommitted', () => {
-  const recoverBody = functionSource('recoverCommitBlockEdit');
+test('the commit-recover task in resumeCodeEditorAgent is a clean-coder edit step bound to the blocker detail and leaves changes uncommitted', () => {
+  const recoverBody = functionSource('resumeCodeEditorAgent');
   assert.match(recoverBody, /agentType:\s*'clean-coder'/, 'expected the fixer to use clean-coder');
   assert.match(recoverBody, /schema:\s*EDIT_SCHEMA/, 'expected the fixer to reuse EDIT_SCHEMA');
-  assert.match(recoverBody, /label:\s*`fix-recover:/, 'expected the fix-recover label');
-  assert.match(recoverBody, /blockerDetail/, 'expected the fixer prompt to consume the blocker detail');
+  assert.match(recoverBody, /task === 'commit-recover'/, 'expected the commit-recover task branch');
+  assert.match(recoverBody, /context\.blockerDetail/, 'expected the fixer prompt to consume the blocker detail');
   assert.match(
     recoverBody,
     /only the (?:violation|finding|block)/i,
@@ -163,20 +161,88 @@ test('commitWithRecovery bounds the loop, re-verifies, and retries the commit on
   );
 });
 
-test('applyFixes routes its commit through commitWithRecovery wired to the fix-path steps', () => {
+test('applyFixes routes through spawnFixerAgent and fixerWithRecovery', () => {
+  const applyFixesBody = functionSource('applyFixes');
+  assert.match(applyFixesBody, /spawnFixerAgent\(/, 'expected applyFixes to call spawnFixerAgent');
+  assert.match(applyFixesBody, /fixerWithRecovery\(/, 'expected applyFixes to call fixerWithRecovery');
+});
+
+test('applyFixes spawns a separate verifier and passes both ids into fixerWithRecovery', () => {
   const applyFixesBody = functionSource('applyFixes');
-  assert.match(applyFixesBody, /commitWithRecovery\(/, 'expected applyFixes to call commitWithRecovery');
-  assert.match(applyFixesBody, /runCommit:\s*\(\)\s*=>\s*commitVerifiedFixes\(/);
-  assert.match(applyFixesBody, /runVerify:\s*\(\)\s*=>\s*verifyFixesInWorkingTree\(/);
-  assert.match(applyFixesBody, /runRecoverEdit:[\s\S]*?recoverCommitBlockEdit\(/);
+  assert.match(
+    applyFixesBody,
+    /spawnVerifierAgent\(/,
+    'expected applyFixes to spawn a separate verifier agent so the fix-path verdict is independent of the fixer',
+  );
+  const fixerSpawnIndex = applyFixesBody.search(/spawnFixerAgent\(/);
+  const verifierSpawnIndex = applyFixesBody.search(/spawnVerifierAgent\(/);
+  assert.notEqual(fixerSpawnIndex, -1, 'expected applyFixes to spawn the fixer');
+  assert.notEqual(verifierSpawnIndex, -1, 'expected applyFixes to spawn the verifier');
+  assert.match(
+    applyFixesBody,
+    /fixerWithRecovery\(\s*fixerAgentId,\s*verifierId,/,
+    'expected applyFixes to pass both the fixer and verifier ids into fixerWithRecovery',
+  );
+});
+
+test('fixerWithRecovery runs verify on the verifier id and edits/commits on the fixer id', () => {
+  const recoveryBody = functionSource('fixerWithRecovery');
+  assert.match(
+    recoveryBody,
+    /resumeVerifierAgent\(\s*verifierId,/,
+    'expected fixerWithRecovery to resume the separate verifier for the verify step',
+  );
+  assert.match(
+    recoveryBody,
+    /resumeFixerAgent\(\s*fixerAgentId,\s*'commit'/,
+    'expected fixerWithRecovery to resume the fixer for the commit step',
+  );
+  assert.doesNotMatch(
+    recoveryBody,
+    /resumeFixerAgent\(\s*fixerAgentId,\s*'(?:verify-commit|fix-verify)'/,
+    'expected the verify step never to resume the fixer session — the verifier must grade a different session than the one that edits',
+  );
+});
+
+test('the fix-path verify resumes a different agent id than the fix-path edits, mirroring the repair path', () => {
+  const recoveryBody = functionSource('fixerWithRecovery');
+  const verifyResumeMatch = /resumeVerifierAgent\(\s*(\w+),/.exec(recoveryBody);
+  const editResumeMatch = /resumeFixerAgent\(\s*(\w+),/.exec(recoveryBody);
+  assert.ok(verifyResumeMatch, 'expected a verify resume call naming its agent id');
+  assert.ok(editResumeMatch, 'expected an edit/commit resume call naming its agent id');
+  assert.notEqual(
+    verifyResumeMatch[1],
+    editResumeMatch[1],
+    'expected the verify step to resume a different agent id than the edit/commit step',
+  );
+});
+
+test('the verifier carries a fix-verify task so the fix path verdict comes from the verifier group', () => {
+  const verifierBody = functionSource('resumeVerifierAgent');
+  assert.match(verifierBody, /task === 'fix-verify'/, 'expected resumeVerifierAgent to handle the fix-verify task');
+  assert.match(verifierBody, /buildVerdictFenceSteps\(/, 'expected the fix-verify task to emit a verdict fence');
+  assert.match(verifierBody, /agentType:\s*'code-verifier'/, 'expected the fix-verify task to run as code-verifier');
+});
+
+test('resumeFixerAgent no longer verifies its own edits — no code-verifier verify-commit task remains', () => {
+  const fixerBody = functionSource('resumeFixerAgent');
+  assert.doesNotMatch(
+    fixerBody,
+    /task === 'verify-commit'/,
+    'expected the fixer to no longer carry the verify-commit task that graded its own session',
+  );
+  assert.doesNotMatch(
+    fixerBody,
+    /agentType:\s*'code-verifier'/,
+    'expected the fixer session to be clean-coder only — a separate verifier grades the working tree',
+  );
 });
 
 test('repairConvergence routes its commit through commitWithRecovery wired to the repair-path steps', () => {
   const repairBody = functionSource('repairConvergence');
   assert.match(repairBody, /commitWithRecovery\(/, 'expected repairConvergence to call commitWithRecovery');
-  assert.match(repairBody, /runCommit:\s*\(\)\s*=>\s*commitRepairFixes\(/);
-  assert.match(repairBody, /runVerify:\s*\(\)\s*=>\s*verifyRepairChanges\(/);
-  assert.match(repairBody, /runRecoverEdit:[\s\S]*?recoverCommitBlockEdit\(/);
+  assert.match(repairBody, /resumeCodeEditorAgent\(/, 'expected repairConvergence to use resumeCodeEditorAgent');
+  assert.match(repairBody, /resumeVerifierAgent\(/, 'expected repairConvergence to use resumeVerifierAgent');
 });
 
 test('the round-loop fix-stalled blockers survive the recovery wiring', () => {
@@ -185,7 +251,8 @@ test('the round-loop fix-stalled blockers survive the recovery wiring', () => {
 });
 
 const verifyObjectionModule = new Function(
-  `${constantLine('VERIFY_OBJECTION_FALLBACK')}\n` +
+  `${functionSource('parseLastVerdictFence')}\n` +
+    `${constantLine('VERIFY_OBJECTION_FALLBACK')}\n` +
     `${functionSource('renderVerifyObjectionLine')}\n` +
     `${functionSource('extractVerifyObjection')}\n` +
     'return { extractVerifyObjection, VERIFY_OBJECTION_FALLBACK };',
@@ -267,12 +334,12 @@ test('extractVerifyObjection falls back when no finding yields usable text', ()
   assert.equal(extractVerifyObjection(transcript), VERIFY_OBJECTION_FALLBACK);
 });
 
-test('recoverVerifyFailEdit is a clean-coder edit step bound to the verifier objection and leaves changes uncommitted', () => {
-  const recoverBody = functionSource('recoverVerifyFailEdit');
+test('the verify-recover task in resumeCodeEditorAgent is a clean-coder edit step bound to the verifier objection and leaves changes uncommitted', () => {
+  const recoverBody = functionSource('resumeCodeEditorAgent');
   assert.match(recoverBody, /agentType:\s*'clean-coder'/, 'expected the fixer to use clean-coder');
   assert.match(recoverBody, /schema:\s*EDIT_SCHEMA/, 'expected the fixer to reuse EDIT_SCHEMA');
-  assert.match(recoverBody, /label:\s*`fix-verify-recover:/, 'expected the fix-verify-recover label');
-  assert.match(recoverBody, /objection/, 'expected the fixer prompt to consume the verifier objection');
+  assert.match(recoverBody, /VERIFY-RECOVERY fixer/, 'expected the verify-recovery prompt body');
+  assert.match(recoverBody, /context\.objection/, 'expected the fixer prompt to consume the verifier objection');
   assert.match(
     recoverBody,
     /do not commit and do not push|Do NOT commit|leave .*uncommitted|uncommitted/i,
@@ -302,19 +369,15 @@ test('verifyWithRecovery bounds the loop, re-fixes on a failed verdict, and re-v
   assert.ok(recoverEditIndex < reverifyIndex, 'expected order recover-edit -> re-verify, so a swap fails');
 });
 
-test('applyFixes routes its verify through verifyWithRecovery before commitWithRecovery', () => {
+test('applyFixes routes through fixerWithRecovery which handles verify and commit', () => {
   const applyFixesBody = functionSource('applyFixes');
-  assert.match(applyFixesBody, /verifyWithRecovery\(/, 'expected applyFixes to call verifyWithRecovery');
-  assert.match(applyFixesBody, /runVerify:\s*\(\)\s*=>\s*verifyFixesInWorkingTree\(/);
-  assert.match(applyFixesBody, /runRecoverEdit:[\s\S]*?recoverVerifyFailEdit\(/);
-  const verifyIndex = applyFixesBody.search(/verifyWithRecovery\(/);
-  const commitIndex = applyFixesBody.search(/commitWithRecovery\(/);
-  assert.ok(verifyIndex < commitIndex, 'expected verify-recovery to precede commit-recovery');
+  assert.match(applyFixesBody, /fixerWithRecovery\(/, 'expected applyFixes to call fixerWithRecovery');
+  assert.match(applyFixesBody, /spawnFixerAgent\(/, 'expected applyFixes to call spawnFixerAgent');
 });
 
-test('repairConvergence routes its verify through verifyWithRecovery wired to the repair verify step', () => {
+test('repairConvergence routes its verify through verifyWithRecovery wired to resume helpers', () => {
   const repairBody = functionSource('repairConvergence');
   assert.match(repairBody, /verifyWithRecovery\(/, 'expected repairConvergence to call verifyWithRecovery');
-  assert.match(repairBody, /runVerify:\s*\(\)\s*=>\s*verifyRepairChanges\(/);
-  assert.match(repairBody, /runRecoverEdit:[\s\S]*?recoverVerifyFailEdit\(/);
+  assert.match(repairBody, /resumeVerifierAgent\(/, 'expected repairConvergence to use resumeVerifierAgent for verify');
+  assert.match(repairBody, /resumeCodeEditorAgent\(/, 'expected repairConvergence to use resumeCodeEditorAgent for recover');
 });

package/skills/autoconverge/workflow/converge.merge-conflict.test.mjs

@@ -31,39 +31,36 @@ test('isMergeConflicting reports a conflict only when the check returned conflic
   assert.equal(isMergeConflicting({ conflicting: false }), false);
 });
 
-test('checkMergeConflicts is a read-only mergeability probe that polls until GitHub computes it', () => {
-  const body = functionBody('checkMergeConflicts');
-  assert.match(body, /mergeable/, 'expected the probe to read the PR mergeable field');
+test('the git agent handles merge-conflict checks with shell-agnostic polling', () => {
+  const gitBody = functionBody('resumeGitAgent');
+  assert.match(gitBody, /mergeable/, 'expected the git agent to read the PR mergeable field');
   assert.match(
-    body,
+    gitBody,
     /do not edit, commit, push, or rebase|read only/i,
-    'expected the probe to be read-only',
+    'expected the git agent merge check to be read-only',
   );
-  assert.match(body, /agentType:\s*'Explore'/, 'expected the probe to use the read-only Explore agent');
-  assert.match(body, /schema:\s*MERGE_CONFLICT_SCHEMA/, 'expected the probe to return MERGE_CONFLICT_SCHEMA');
-  assert.match(body, /null/, 'expected the probe to handle GitHub returning mergeable:null while it computes');
-  assert.match(body, /sleep 5|Start-Sleep/, 'expected a shell-agnostic poll delay');
+  assert.match(gitBody, /MERGE_CONFLICT_SCHEMA/, 'expected the git agent to return MERGE_CONFLICT_SCHEMA');
+  assert.match(gitBody, /sleep 5|Start-Sleep/, 'expected a shell-agnostic poll delay');
 });
 
-test('resolveConflictsEdit rebases onto origin/main and makes no push', () => {
-  const body = functionBody('resolveConflictsEdit');
-  assert.match(body, /git rebase origin\/main/, 'expected the edit step to rebase onto origin/main');
+test('resumeCodeEditorAgent conflict-edit path rebases onto origin/main and makes no push', () => {
+  const body = functionBody('resumeCodeEditorAgent');
+  assert.match(body, /git rebase origin\/main/, 'expected the edit path to rebase onto origin/main');
   assert.match(
     body,
     /do not push|no push|not push/i,
-    'expected the edit step to leave the push to the commit step',
+    'expected the edit path to leave the push to the commit step',
   );
-  assert.match(body, /agentType:\s*'clean-coder'/, 'expected the edit step to use clean-coder');
 });
 
 test('resolveMergeConflicts runs check -> edit -> verify -> commit and gates the push on the verdict', () => {
   const body = functionBody('resolveMergeConflicts');
-  const checkIndex = body.indexOf('checkMergeConflicts(');
-  const editIndex = body.indexOf('resolveConflictsEdit(');
-  const verifyIndex = body.indexOf('verifyRepairChanges(');
-  const commitIndex = body.indexOf('commitRepairFixes(');
+  const checkIndex = body.indexOf("resumeGitAgent(gitAgentId, 'check-merge-conflicts'");
+  const editIndex = body.indexOf('spawnCodeEditorAgent(');
+  const verifyIndex = body.indexOf('spawnVerifierAgent(');
+  const commitIndex = body.indexOf('commitWithRecovery(');
   assert.notEqual(checkIndex, -1, 'expected the conflict check to run');
-  assert.notEqual(editIndex, -1, 'expected the rebase edit step to run');
+  assert.notEqual(editIndex, -1, 'expected the edit step to run');
   assert.notEqual(verifyIndex, -1, 'expected the verify step to run');
   assert.notEqual(commitIndex, -1, 'expected the commit step to run');
   assert.ok(
@@ -71,11 +68,6 @@ test('resolveMergeConflicts runs check -> edit -> verify -> commit and gates the
     'expected the order check -> edit -> verify -> commit',
   );
   assert.match(body, /verdictPassed\(/, 'expected the verifier verdict to gate the force-push');
-  assert.match(
-    body,
-    /commitRepairFixes\(head,\s*true\)/,
-    'expected the commit to force-with-lease (wasRebased=true) after a rebase',
-  );
 });
 
 test('resolveMergeConflicts rebases only when the check reports a conflict', () => {