claude-dev-env 1.78.0 → 1.80.0

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

@@ -45,8 +45,8 @@ test('bug-audit lens prompt no longer instructs a per-lens git fetch', () => {
 });
 
 test('a single round-level prefetch step fetches origin/main before the parallel lenses', () => {
-  assert.ok(convergeSource.includes("resumeGitAgent(gitAgentId, 'prefetch-main')"));
-  const prefetchCallIndex = convergeSource.indexOf("resumeGitAgent(gitAgentId, 'prefetch-main')");
+  assert.ok(convergeSource.includes("runGitTask('prefetch-main')"));
+  const prefetchCallIndex = convergeSource.indexOf("runGitTask('prefetch-main')");
   const parallelLensIndex = convergeSource.indexOf('const lenses = await parallel(');
   assert.notEqual(prefetchCallIndex, -1, 'expected prefetch to be invoked');
   assert.notEqual(parallelLensIndex, -1, 'expected the parallel lens block to exist');
@@ -85,7 +85,7 @@ test('gotchas doc states parallel lenses must avoid concurrent git operations',
 });
 
 test('repair-convergence edit step filters unresolved threads to bot authors and skips human threads', () => {
-  const repairPrompt = functionSource('resumeCodeEditorAgent');
+  const repairPrompt = functionSource('runCodeEditorTask');
   assert.match(
     repairPrompt,
     /cursor.*claude.*copilot|copilot.*cursor.*claude|claude.*cursor.*copilot/is,
@@ -99,7 +99,7 @@ test('repair-convergence edit step filters unresolved threads to bot authors and
 });
 
 test('repair-convergence edit step no longer instructs resolving every unresolved thread without an author filter', () => {
-  const repairPrompt = functionSource('resumeCodeEditorAgent');
+  const repairPrompt = functionSource('runCodeEditorTask');
   assert.doesNotMatch(
     repairPrompt,
     /fetch every thread where isResolved is false/,
@@ -195,12 +195,12 @@ test('the COPILOT fix branch does not re-assign head from the fix before re-conv
 test('the CONVERGE branch re-resolves HEAD from GitHub on every entry', () => {
   const convergeBranchStart = convergeSource.indexOf("if (phase === 'CONVERGE')");
   assert.notEqual(convergeBranchStart, -1, 'expected the CONVERGE branch to exist');
-  const headResolveCallIndex = convergeSource.indexOf("resumeGitAgent(gitAgentId, 'resolve-head')", convergeBranchStart);
-  assert.notEqual(headResolveCallIndex, -1, 'expected CONVERGE to re-resolve HEAD via resumeGitAgent');
+  const headResolveCallIndex = convergeSource.indexOf("runGitTask('resolve-head')", convergeBranchStart);
+  assert.notEqual(headResolveCallIndex, -1, 'expected CONVERGE to re-resolve HEAD via runGitTask');
 });
 
 test('fix edit prompt resolves threads by PRRT thread node id looked up from the comment databaseId', () => {
-  const editPrompt = functionSource('resumeCodeEditorAgent');
+  const editPrompt = functionSource('runCodeEditorTask');
   assert.match(editPrompt, /PRRT/, 'expected the thread node id form (PRRT_...) to be named');
   assert.match(
     editPrompt,
@@ -216,15 +216,15 @@ test('fix edit prompt resolves threads by PRRT thread node id looked up from the
 
 test('fix edit prompt does not pass the numeric comment id straight to resolve_thread', () => {
   assert.doesNotMatch(
-    functionSource('resumeCodeEditorAgent'),
+    functionSource('runCodeEditorTask'),
     /then resolve that thread \(use the github MCP pull_request_review_write/,
     'resolve_thread and resolveReviewThread require a PRRT_... thread node id, not the comment id',
   );
 });
 
-test('the fix flow spawns a fixer agent and runs fixerWithRecovery after the edit step', () => {
+test('the fix flow runs the edit task then fixerWithRecovery after the edit step', () => {
   const applyFixesBody = lensPromptBody('applyFixes');
-  assert.match(applyFixesBody, /spawnFixerAgent\(/, 'expected applyFixes to call spawnFixerAgent');
+  assert.match(applyFixesBody, /runCodeEditorTask\('fix-edit'/, "expected applyFixes to call runCodeEditorTask('fix-edit')");
   assert.match(applyFixesBody, /fixerWithRecovery\(/, 'expected applyFixes to call fixerWithRecovery');
 });
 
@@ -269,7 +269,7 @@ test('the verdict-fence binding does not self-resolve a cwd via git rev-parse fo
 });
 
 test('every verify step calls buildVerdictFenceSteps, uses code-verifier, and forbids edits', () => {
-  for (const verifyFunctionName of ['resumeVerifierAgent']) {
+  for (const verifyFunctionName of ['runVerifierTask']) {
     const verifyBody = lensPromptBody(verifyFunctionName);
     assert.match(
       verifyBody,
@@ -294,15 +294,15 @@ test('every verify step calls buildVerdictFenceSteps, uses code-verifier, and fo
   }
 });
 
-test('resumeFixerAgent never verifies its own session — verification belongs to the separate verifier', () => {
-  const fixerBody = lensPromptBody('resumeFixerAgent');
+test('runFixerTask never verifies — verification belongs to the separate verifier', () => {
+  const fixerBody = lensPromptBody('runFixerTask');
   assert.doesNotMatch(fixerBody, /buildVerdictFenceSteps\(/, 'expected the fixer to not emit a verdict fence — the separate verifier does');
-  assert.doesNotMatch(fixerBody, /agentType:\s*'code-verifier'/, 'expected the fixer session to be clean-coder only');
+  assert.doesNotMatch(fixerBody, /agentType:\s*'code-verifier'/, 'expected the fixer to be clean-coder only');
   assert.match(fixerBody, /agentType:\s*'clean-coder'/, 'expected the fixer to use clean-coder for its commit and recovery edits');
 });
 
-test('resumeVerifierAgent uses --manifest-hash-for-branch with the hardening branch and forbids edits', () => {
-  const verifyBody = lensPromptBody('resumeVerifierAgent');
+test('runVerifierTask uses --manifest-hash-for-branch with the hardening branch and forbids edits', () => {
+  const verifyBody = lensPromptBody('runVerifierTask');
   assert.match(
     verifyBody,
     /--manifest-hash-for-branch/,
@@ -315,18 +315,18 @@ test('resumeVerifierAgent uses --manifest-hash-for-branch with the hardening bra
   );
 });
 
-test('resumeVerifierAgent passes PR coordinates to buildVerdictFenceSteps for the fix-verify and repair-verify tasks', () => {
-  const verifyBody = lensPromptBody('resumeVerifierAgent');
-  assert.match(verifyBody, /task === 'fix-verify'/, 'expected resumeVerifierAgent to carry the fix-path verify task');
+test('runVerifierTask passes PR coordinates to buildVerdictFenceSteps for the fix-verify and repair-verify tasks', () => {
+  const verifyBody = lensPromptBody('runVerifierTask');
+  assert.match(verifyBody, /task === 'fix-verify'/, 'expected runVerifierTask to carry the fix-path verify task');
   assert.match(
     verifyBody,
     /buildVerdictFenceSteps\(input\.owner, input\.repo, input\.prNumber\)/,
-    'expected resumeVerifierAgent to pass PR coordinates to buildVerdictFenceSteps',
+    'expected runVerifierTask to pass PR coordinates to buildVerdictFenceSteps',
   );
 });
 
-test('the commit path in resumeFixerAgent forbids further edits and uses clean-coder', () => {
-  const fixerBody = lensPromptBody('resumeFixerAgent');
+test('the commit path in runFixerTask forbids further edits and uses clean-coder', () => {
+  const fixerBody = lensPromptBody('runFixerTask');
   assert.match(
     fixerBody,
     /no (?:further |additional )?(?:file )?edits|do not edit|make no edits/i,
@@ -339,22 +339,22 @@ test('the commit path in resumeFixerAgent forbids further edits and uses clean-c
   );
 });
 
-test('the repair flow uses resume helpers for edit, verify, and commit', () => {
+test('the repair flow uses the direct-spawn task helpers for edit, verify, and commit', () => {
   const repairBody = lensPromptBody('repairConvergence');
-  assert.match(repairBody, /spawnCodeEditorAgent\(/, 'expected repairConvergence to spawn a code-editor');
-  assert.match(repairBody, /spawnVerifierAgent\(/, 'expected repairConvergence to spawn a verifier');
+  assert.match(repairBody, /runCodeEditorTask\(/, 'expected repairConvergence to call runCodeEditorTask');
+  assert.match(repairBody, /runVerifierTask\(/, 'expected repairConvergence to call runVerifierTask');
   assert.match(repairBody, /verdictPassed\(/, 'expected the verify verdict to gate the repair commit step');
 });
 
-test('the standards-deferral flow uses resume helpers for edit, verify, and commit', () => {
+test('the standards-deferral flow uses the direct-spawn task helpers for edit, verify, and commit', () => {
   const standardsBody = lensPromptBody('spawnStandardsFollowUp');
-  assert.match(standardsBody, /spawnCodeEditorAgent\(/, 'expected spawnStandardsFollowUp to spawn a code-editor');
-  assert.match(standardsBody, /spawnVerifierAgent\(/, 'expected spawnStandardsFollowUp to spawn a verifier');
+  assert.match(standardsBody, /runCodeEditorTask\(/, 'expected spawnStandardsFollowUp to call runCodeEditorTask');
+  assert.match(standardsBody, /runVerifierTask\(/, 'expected spawnStandardsFollowUp to call runVerifierTask');
   assert.match(standardsBody, /verdictPassed\(/, 'expected the verify verdict to gate the hardening commit step');
 });
 
 test('repair-commit and hardening-commit paths use clean-coder and forbid edits', () => {
-  const codeEditorBody = lensPromptBody('resumeCodeEditorAgent');
+  const codeEditorBody = lensPromptBody('runCodeEditorTask');
   assert.match(
     codeEditorBody,
     /no (?:further |additional )?(?:file )?edits|do not edit|make no edits/i,
@@ -368,7 +368,7 @@ test('repair-commit and hardening-commit paths use clean-coder and forbid edits'
 });
 
 test('the code-editor standards-edit path stages hardening without committing and uses clean-coder', () => {
-  const editBody = lensPromptBody('resumeCodeEditorAgent');
+  const editBody = lensPromptBody('runCodeEditorTask');
   assert.match(
     editBody,
     /do not commit and do not push|NO commit and NO push|Do NOT commit/i,
@@ -495,9 +495,9 @@ test('the pre-commit gate step is a shared constant that dry-runs the CODE_RULES
   );
 });
 
-const editStepResumeHelpers = ['resumeCodeEditorAgent', 'resumeFixerAgent'];
+const editStepTaskDispatchers = ['runCodeEditorTask', 'runFixerTask'];
 
-for (const helperName of editStepResumeHelpers) {
+for (const helperName of editStepTaskDispatchers) {
   test(`${helperName} appends the pre-commit gate step to its edit prompts`, () => {
     assert.match(
       functionSource(helperName),
@@ -507,14 +507,14 @@ for (const helperName of editStepResumeHelpers) {
   });
 }
 
-const editStepResumeTasks = [
-  ['resumeCodeEditorAgent', 'fix-edit'],
-  ['resumeCodeEditorAgent', 'repair-edit'],
-  ['resumeCodeEditorAgent', 'standards-edit'],
-  ['resumeCodeEditorAgent', 'commit-recover'],
+const editStepTasks = [
+  ['runCodeEditorTask', 'fix-edit'],
+  ['runCodeEditorTask', 'repair-edit'],
+  ['runCodeEditorTask', 'standards-edit'],
+  ['runCodeEditorTask', 'commit-recover'],
 ];
 
-for (const [helperName, taskName] of editStepResumeTasks) {
+for (const [helperName, taskName] of editStepTasks) {
   test(`${helperName} routes the ${taskName} task to a pre-commit-gated edit prompt`, () => {
     assert.match(
       functionSource(helperName),
@@ -634,37 +634,26 @@ test('SKILL.md attributes the known-temp-var resolution to the cwd-scoped auto-a
   );
 });
 
-test('convergeAgent prepends HEADLESS_SAFETY_PREAMBLE and worktree directive on fresh spawn', () => {
+test('convergeAgent prepends HEADLESS_SAFETY_PREAMBLE and the worktree directive to every prompt', () => {
   const convergeAgentBody = lensPromptBody('convergeAgent');
   assert.match(
     convergeAgentBody,
     /HEADLESS_SAFETY_PREAMBLE.*worktreeDirective/,
-    'expected fresh-spawn path to prepend both preamble and worktree directive',
+    'expected convergeAgent to prepend both preamble and worktree directive',
   );
 });
 
-test('convergeAgent checks isResume before prepending the preamble', () => {
-  const convergeAgentBody = lensPromptBody('convergeAgent');
-  assert.match(convergeAgentBody, /isResume/, 'expected an isResume guard in convergeAgent');
-});
-
-const newSpawnResumeHelpers = [
-  { name: 'spawnGitAgent', isAsync: true },
-  { name: 'resumeGitAgent', isAsync: false },
-  { name: 'spawnFixerAgent', isAsync: true },
-  { name: 'resumeFixerAgent', isAsync: false },
+const taskDispatchers = [
+  { name: 'runGitTask', isAsync: false },
+  { name: 'runFixerTask', isAsync: false },
   { name: 'fixerWithRecovery', isAsync: true },
-  { name: 'spawnCodeEditorAgent', isAsync: true },
-  { name: 'resumeCodeEditorAgent', isAsync: false },
-  { name: 'spawnVerifierAgent', isAsync: true },
-  { name: 'resumeVerifierAgent', isAsync: false },
-  { name: 'spawnGeneralUtilityAgent', isAsync: true },
-  { name: 'resumeGeneralUtilityAgent', isAsync: false },
-  { name: 'spawnConvergenceCheckAgent', isAsync: true },
-  { name: 'resumeConvergenceCheckAgent', isAsync: false },
+  { name: 'runCodeEditorTask', isAsync: false },
+  { name: 'runVerifierTask', isAsync: false },
+  { name: 'runGeneralUtilityTask', isAsync: false },
+  { name: 'runConvergenceCheck', isAsync: false },
 ];
 
-for (const { name, isAsync } of newSpawnResumeHelpers) {
+for (const { name, isAsync } of taskDispatchers) {
   const prefix = isAsync ? 'async ' : '';
   test(`function ${prefix}${name} exists in converge.mjs`, () => {
     const needle = isAsync ? `async function ${name}(` : `function ${name}(`;
@@ -672,60 +661,8 @@ for (const { name, isAsync } of newSpawnResumeHelpers) {
   });
 }
 
-const spawnHelperNames = [
-  'spawnGitAgent',
-  'spawnFixerAgent',
-  'spawnCodeEditorAgent',
-  'spawnVerifierAgent',
-  'spawnGeneralUtilityAgent',
-  'spawnConvergenceCheckAgent',
-];
-
-for (const spawnName of spawnHelperNames) {
-  test(`${spawnName} actually spawns an agent via convergeAgent`, () => {
-    const spawnBody = functionSource(spawnName);
-    assert.match(
-      spawnBody,
-      /await convergeAgent\(/,
-      `expected ${spawnName} to spawn a real agent through convergeAgent rather than return a hardcoded label`,
-    );
-  });
-
-  test(`${spawnName} returns the spawned agent's runtime id`, () => {
-    const spawnBody = functionSource(spawnName);
-    assert.match(
-      spawnBody,
-      /return\s+result\?\.agentId/,
-      `expected ${spawnName} to return result?.agentId so resume targets the real session`,
-    );
-    assert.doesNotMatch(
-      spawnBody,
-      /return\s+['"`]/,
-      `expected ${spawnName} not to return a hardcoded label string`,
-    );
-  });
-}
-
-test('spawnGitAgent returns result?.agentId without a tautological ternary', () => {
-  const spawnBody = functionSource('spawnGitAgent');
-  assert.doesNotMatch(
-    spawnBody,
-    /\?\s*'git-utility'\s*:\s*'git-utility'/,
-    'expected the identical-branch ternary that discards the spawn outcome to be gone',
-  );
-});
-
-test('resume helpers fall back to a fresh spawn when no agentId is available', () => {
-  const convergeAgentBody = lensPromptBody('convergeAgent');
-  assert.match(
-    convergeAgentBody,
-    /options\?\.resume.*length\s*>\s*0|length\s*>\s*0.*resume/s,
-    'expected convergeAgent to treat a missing agentId as a fresh spawn (isResume false), restoring the preamble and worktree directive',
-  );
-});
-
-test('resumeGeneralUtilityAgent only handles the two tasks it is called with', () => {
-  const generalBody = functionSource('resumeGeneralUtilityAgent');
+test('runGeneralUtilityTask only handles the two tasks it is called with', () => {
+  const generalBody = functionSource('runGeneralUtilityTask');
   assert.doesNotMatch(
     generalBody,
     /task === 'bugbot-lens'/,
@@ -761,7 +698,7 @@ const orphanedHelperNames = [
 ];
 
 for (const orphanName of orphanedHelperNames) {
-  test(`${orphanName} is removed — its behavior lives in a resume helper`, () => {
+  test(`${orphanName} is removed — its behavior lives in a direct-spawn task dispatcher`, () => {
     assert.ok(
       !convergeSource.includes(`function ${orphanName}(`),
       `expected the orphaned ${orphanName} definition to be deleted (CODE_RULES 9.8)`,
@@ -769,12 +706,11 @@ for (const orphanName of orphanedHelperNames) {
   });
 }
 
-test('convergeAgent omits the preamble when options.resume is a non-empty string', () => {
-  const convergeAgentBody = lensPromptBody('convergeAgent');
-  assert.match(
-    convergeAgentBody,
-    /isResume\s*\?\s*prompt/,
-    'expected the resume path to pass prompt through without the preamble',
+test('the whole priming spawn-agent family is removed — every dispatcher spawns fresh', () => {
+  assert.doesNotMatch(
+    convergeSource,
+    /function\s+spawn\w+Agent\s*\(/,
+    'expected no spawn<Role>Agent priming function to survive — each task dispatcher spawns a fresh agent',
   );
 });
 

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('resumeConvergenceCheckAgent wires the --copilot-down flag from the copilotDown context', () => {
-  const checkConvergenceBody = functionBody('resumeConvergenceCheckAgent');
+test('runConvergenceCheck wires the --copilot-down flag from the copilotDown context', () => {
+  const checkConvergenceBody = functionBody('runConvergenceCheck');
   assert.match(
     checkConvergenceBody,
     /context\.copilotDown \? ' --copilot-down' : ''/,
-    'expected resumeConvergenceCheckAgent to append --copilot-down when copilotDown is set',
+    'expected runConvergenceCheck to append --copilot-down when copilotDown is set',
   );
   assert.match(
     checkConvergenceBody,
@@ -244,8 +244,8 @@ test('markReady receives copilotDown so it can opt the unflagged hook out of the
   );
 });
 
-test('the mark-ready task in resumeGeneralUtilityAgent opts the unflagged convergence hook out of Copilot when copilotDown', () => {
-  const markReadyBody = functionBody('resumeGeneralUtilityAgent');
+test('the mark-ready task in runGeneralUtilityTask opts the unflagged convergence hook out of Copilot when copilotDown', () => {
+  const markReadyBody = functionBody('runGeneralUtilityTask');
   assert.match(
     markReadyBody,
     /context\.copilotDown/,
@@ -263,3 +263,43 @@ test('the mark-ready task in resumeGeneralUtilityAgent opts the unflagged conver
   );
 });
 
+test('the COPILOT phase short-circuits on input.copilotDisabled before spawning the gate agent', () => {
+  const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
+  assert.notEqual(copilotPhaseStart, -1, 'expected a COPILOT phase block');
+  const gateCallIndex = convergeSource.indexOf('await runCopilotGate(head)', copilotPhaseStart);
+  assert.notEqual(gateCallIndex, -1, 'expected the COPILOT phase to call runCopilotGate when Copilot is enabled');
+  const beforeGate = convergeSource.slice(copilotPhaseStart, gateCallIndex);
+  assert.match(
+    beforeGate,
+    /if \(input\.copilotDisabled\)/,
+    'expected the quota pre-check bypass to guard the COPILOT phase before any gate agent spawns',
+  );
+  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, /continue/, 'expected the bypass to continue without spawning the gate agent');
+});
+
+test('copilotDown initializes from input.copilotDisabled so the pre-check decision carries into the loop', () => {
+  assert.match(
+    convergeSource,
+    /let copilotDown = input\.copilotDisabled \|\| false/,
+    'expected copilotDown to seed from the copilotDisabled run input',
+  );
+});
+
+test('a copilotDisabled run reaches FINALIZE with --copilot-down', () => {
+  const copilotPhaseStart = convergeSource.indexOf("if (phase === 'COPILOT') {");
+  const bypassStart = convergeSource.indexOf('if (input.copilotDisabled)', copilotPhaseStart);
+  assert.notEqual(bypassStart, -1, 'expected an input.copilotDisabled 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');
+  const convergenceCheckBody = functionBody('resumeConvergenceCheckAgent');
+  assert.match(
+    convergenceCheckBody,
+    /context\.copilotDown \? ' --copilot-down' : ''/,
+    'expected the convergence check to pass --copilot-down when the bypassed copilotDown reaches FINALIZE',
+  );
+});
+

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

@@ -99,8 +99,8 @@ test('FIX_RECOVERY_MAX_ATTEMPTS is declared and bounds the recovery loop at 2',
   assert.match(constantLine('FIX_RECOVERY_MAX_ATTEMPTS'), /=\s*2\s*$/);
 });
 
-test('the commit path in resumeCodeEditorAgent separates an edit-requiring block from a transient failure', () => {
-  const commitBody = functionSource('resumeCodeEditorAgent');
+test('the commit path in runCodeEditorTask separates an edit-requiring block from a transient failure', () => {
+  const commitBody = functionSource('runCodeEditorTask');
   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(
@@ -115,8 +115,8 @@ test('the commit path in resumeCodeEditorAgent separates an edit-requiring block
   );
 });
 
-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');
+test('the commit-recover task in runCodeEditorTask is a clean-coder edit step bound to the blocker detail and leaves changes uncommitted', () => {
+  const recoverBody = functionSource('runCodeEditorTask');
   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, /task === 'commit-recover'/, 'expected the commit-recover task branch');
@@ -161,88 +161,92 @@ test('commitWithRecovery bounds the loop, re-verifies, and retries the commit on
   );
 });
 
-test('applyFixes routes through spawnFixerAgent and fixerWithRecovery', () => {
+test('applyFixes routes through the fix-edit task and fixerWithRecovery', () => {
   const applyFixesBody = functionSource('applyFixes');
-  assert.match(applyFixesBody, /spawnFixerAgent\(/, 'expected applyFixes to call spawnFixerAgent');
+  assert.match(applyFixesBody, /runCodeEditorTask\('fix-edit'/, "expected applyFixes to call runCodeEditorTask('fix-edit')");
   assert.match(applyFixesBody, /fixerWithRecovery\(/, 'expected applyFixes to call fixerWithRecovery');
 });
 
-test('applyFixes spawns a separate verifier and passes both ids into fixerWithRecovery', () => {
+test('applyFixes delegates to fixerWithRecovery, which grades fixes with a separate verifier from the fixer', () => {
   const applyFixesBody = functionSource('applyFixes');
   assert.match(
     applyFixesBody,
-    /spawnVerifierAgent\(/,
-    'expected applyFixes to spawn a separate verifier agent so the fix-path verdict is independent of the fixer',
+    /fixerWithRecovery\(head, findings, sourceLabel\)/,
+    'expected applyFixes to delegate the verify and commit flow to fixerWithRecovery',
   );
-  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');
+  const recoveryBody = functionSource('fixerWithRecovery');
   assert.match(
-    applyFixesBody,
-    /fixerWithRecovery\(\s*fixerAgentId,\s*verifierId,/,
-    'expected applyFixes to pass both the fixer and verifier ids into fixerWithRecovery',
+    recoveryBody,
+    /runVerifierTask\('fix-verify'/,
+    'expected fixerWithRecovery to grade the fixes with the code-verifier task so the verdict is independent of the fixer',
+  );
+  assert.match(
+    recoveryBody,
+    /runFixerTask\('commit'/,
+    'expected fixerWithRecovery to commit through the clean-coder fixer task',
   );
 });
 
-test('fixerWithRecovery runs verify on the verifier id and edits/commits on the fixer id', () => {
+test('fixerWithRecovery runs verify via runVerifierTask and edits/commits via runFixerTask', () => {
   const recoveryBody = functionSource('fixerWithRecovery');
   assert.match(
     recoveryBody,
-    /resumeVerifierAgent\(\s*verifierId,/,
-    'expected fixerWithRecovery to resume the separate verifier for the verify step',
+    /runVerifierTask\('fix-verify'/,
+    'expected fixerWithRecovery to run the verify step through the separate verifier task',
   );
   assert.match(
     recoveryBody,
-    /resumeFixerAgent\(\s*fixerAgentId,\s*'commit'/,
-    'expected fixerWithRecovery to resume the fixer for the commit step',
+    /runFixerTask\('commit'/,
+    'expected fixerWithRecovery to run the commit step through the fixer task',
   );
   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',
+    /runFixerTask\('(?:verify-commit|fix-verify)'/,
+    'expected the verify step never to route through the fixer task — the verifier grades a different agent than the one that edits',
   );
 });
 
-test('the fix-path verify resumes a different agent id than the fix-path edits, mirroring the repair path', () => {
+test('the fix-path verify routes through a different helper and agentType 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');
+  const verifyHelperMatch = /(\w+)\('fix-verify'/.exec(recoveryBody);
+  const editHelperMatch = /(\w+)\('commit'/.exec(recoveryBody);
+  assert.ok(verifyHelperMatch, 'expected a verify call naming its task helper');
+  assert.ok(editHelperMatch, 'expected an edit/commit call naming its task helper');
+  assert.equal(verifyHelperMatch[1], 'runVerifierTask', 'expected verify to route through runVerifierTask (code-verifier)');
+  assert.equal(editHelperMatch[1], 'runFixerTask', 'expected commit to route through runFixerTask (clean-coder)');
   assert.notEqual(
-    verifyResumeMatch[1],
-    editResumeMatch[1],
-    'expected the verify step to resume a different agent id than the edit/commit step',
+    verifyHelperMatch[1],
+    editHelperMatch[1],
+    'expected the verify step to route through a different helper 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');
+test('the verifier carries a fix-verify task so the fix path verdict comes from the verifier', () => {
+  const verifierBody = functionSource('runVerifierTask');
+  assert.match(verifierBody, /task === 'fix-verify'/, 'expected runVerifierTask 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');
+test('runFixerTask no longer verifies its own edits — no code-verifier verify-commit task remains', () => {
+  const fixerBody = functionSource('runFixerTask');
   assert.doesNotMatch(
     fixerBody,
     /task === 'verify-commit'/,
-    'expected the fixer to no longer carry the verify-commit task that graded its own session',
+    'expected the fixer to no longer carry the verify-commit task that graded its own edits',
   );
   assert.doesNotMatch(
     fixerBody,
     /agentType:\s*'code-verifier'/,
-    'expected the fixer session to be clean-coder only — a separate verifier grades the working tree',
+    'expected the fixer 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, /resumeCodeEditorAgent\(/, 'expected repairConvergence to use resumeCodeEditorAgent');
-  assert.match(repairBody, /resumeVerifierAgent\(/, 'expected repairConvergence to use resumeVerifierAgent');
+  assert.match(repairBody, /runCodeEditorTask\(/, 'expected repairConvergence to use runCodeEditorTask');
+  assert.match(repairBody, /runVerifierTask\(/, 'expected repairConvergence to use runVerifierTask');
 });
 
 test('the round-loop fix-stalled blockers survive the recovery wiring', () => {
@@ -334,8 +338,8 @@ test('extractVerifyObjection falls back when no finding yields usable text', ()
   assert.equal(extractVerifyObjection(transcript), VERIFY_OBJECTION_FALLBACK);
 });
 
-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');
+test('the verify-recover task in runCodeEditorTask is a clean-coder edit step bound to the verifier objection and leaves changes uncommitted', () => {
+  const recoverBody = functionSource('runCodeEditorTask');
   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, /VERIFY-RECOVERY fixer/, 'expected the verify-recovery prompt body');
@@ -372,12 +376,12 @@ test('verifyWithRecovery bounds the loop, re-fixes on a failed verdict, and re-v
 test('applyFixes routes through fixerWithRecovery which handles verify and commit', () => {
   const applyFixesBody = functionSource('applyFixes');
   assert.match(applyFixesBody, /fixerWithRecovery\(/, 'expected applyFixes to call fixerWithRecovery');
-  assert.match(applyFixesBody, /spawnFixerAgent\(/, 'expected applyFixes to call spawnFixerAgent');
+  assert.match(applyFixesBody, /runCodeEditorTask\('fix-edit'/, "expected applyFixes to call runCodeEditorTask('fix-edit')");
 });
 
-test('repairConvergence routes its verify through verifyWithRecovery wired to resume helpers', () => {
+test('repairConvergence routes its verify through verifyWithRecovery wired to the task helpers', () => {
   const repairBody = functionSource('repairConvergence');
   assert.match(repairBody, /verifyWithRecovery\(/, 'expected repairConvergence to call verifyWithRecovery');
-  assert.match(repairBody, /resumeVerifierAgent\(/, 'expected repairConvergence to use resumeVerifierAgent for verify');
-  assert.match(repairBody, /resumeCodeEditorAgent\(/, 'expected repairConvergence to use resumeCodeEditorAgent for recover');
+  assert.match(repairBody, /runVerifierTask\(/, 'expected repairConvergence to use runVerifierTask for verify');
+  assert.match(repairBody, /runCodeEditorTask\(/, 'expected repairConvergence to use runCodeEditorTask for recover');
 });

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

@@ -32,7 +32,7 @@ test('isMergeConflicting reports a conflict only when the check returned conflic
 });
 
 test('the git agent handles merge-conflict checks with shell-agnostic polling', () => {
-  const gitBody = functionBody('resumeGitAgent');
+  const gitBody = functionBody('runGitTask');
   assert.match(gitBody, /mergeable/, 'expected the git agent to read the PR mergeable field');
   assert.match(
     gitBody,
@@ -43,8 +43,8 @@ test('the git agent handles merge-conflict checks with shell-agnostic polling',
   assert.match(gitBody, /sleep 5|Start-Sleep/, 'expected a shell-agnostic poll delay');
 });
 
-test('resumeCodeEditorAgent conflict-edit path rebases onto origin/main and makes no push', () => {
-  const body = functionBody('resumeCodeEditorAgent');
+test('runCodeEditorTask conflict-edit path rebases onto origin/main and makes no push', () => {
+  const body = functionBody('runCodeEditorTask');
   assert.match(body, /git rebase origin\/main/, 'expected the edit path to rebase onto origin/main');
   assert.match(
     body,
@@ -55,9 +55,9 @@ test('resumeCodeEditorAgent conflict-edit path rebases onto origin/main and make
 
 test('resolveMergeConflicts runs check -> edit -> verify -> commit and gates the push on the verdict', () => {
   const body = functionBody('resolveMergeConflicts');
-  const checkIndex = body.indexOf("resumeGitAgent(gitAgentId, 'check-merge-conflicts'");
-  const editIndex = body.indexOf('spawnCodeEditorAgent(');
-  const verifyIndex = body.indexOf('spawnVerifierAgent(');
+  const checkIndex = body.indexOf("runGitTask('check-merge-conflicts'");
+  const editIndex = body.indexOf("runCodeEditorTask('conflict-edit'");
+  const verifyIndex = body.indexOf('runVerifierTask(');
   const commitIndex = body.indexOf('commitWithRecovery(');
   assert.notEqual(checkIndex, -1, 'expected the conflict check to run');
   assert.notEqual(editIndex, -1, 'expected the edit step to run');