claude-dev-env 1.81.0 → 1.83.0

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

@@ -18,9 +18,10 @@ function functionBody(functionName) {
 const productionModule = new Function(
   `${functionBody('classifyCopilotOutcome')}\n` +
     `${functionBody('resolveCopilotDown')}\n` +
-    'return { classifyCopilotOutcome, resolveCopilotDown };',
+    `${functionBody('resolveReviewerDown')}\n` +
+    'return { classifyCopilotOutcome, resolveCopilotDown, resolveReviewerDown };',
 )();
-const { classifyCopilotOutcome, resolveCopilotDown } = productionModule;
+const { classifyCopilotOutcome, resolveCopilotDown, resolveReviewerDown } = productionModule;
 
 function copilotResult(overrides) {
   return {
@@ -281,7 +282,7 @@ test('the mark-ready task in runGeneralUtilityTask opts the unflagged convergenc
   );
 });
 
-test('the COPILOT phase short-circuits on input.copilotDisabled before spawning the gate agent', () => {
+test('the COPILOT phase short-circuits on the unified reviewer-down gate 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);
@@ -289,8 +290,8 @@ test('the COPILOT phase short-circuits on input.copilotDisabled before spawning
   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',
+    /if \(resolveReviewerDown\(reviewerAvailability\?\.copilot, input\.copilotDisabled \|\| false\)\)/,
+    'expected the unified resolveReviewerDown gate — fed by the reviewer-availability probe or the input override — 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');
@@ -298,6 +299,16 @@ test('the COPILOT phase short-circuits on input.copilotDisabled before spawning
   assert.match(beforeGate, /continue/, 'expected the bypass to continue without spawning the gate agent');
 });
 
+test('the COPILOT phase pre-spawn gate skips the gate agent via input.copilotDisabled with no probe entry', () => {
+  const isDownFromInput = resolveReviewerDown(undefined, true);
+  assert.equal(isDownFromInput, true, 'expected the input override alone to report Copilot down with no probe entry');
+});
+
+test('the COPILOT phase pre-spawn gate skips the gate agent via a probe down entry with no input override', () => {
+  const isDownFromProbe = resolveReviewerDown({ down: true, reason: 'copilot-quota: out of premium-interaction quota' }, false);
+  assert.equal(isDownFromProbe, true, 'expected a probe entry reporting down to skip the gate agent with no input override set');
+});
+
 test('copilotDown initializes from input.copilotDisabled so the pre-check decision carries into the loop', () => {
   assert.match(
     convergeSource,
@@ -308,8 +319,11 @@ test('copilotDown initializes from input.copilotDisabled so the pre-check decisi
 
 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 bypassStart = convergeSource.indexOf(
+    'if (resolveReviewerDown(reviewerAvailability?.copilot, input.copilotDisabled || false))',
+    copilotPhaseStart,
+  );
+  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');
@@ -373,7 +387,7 @@ test('openStandardsFollowUpOnce gates spawnStandardsFollowUp behind the run-once
   );
   assert.match(
     onceBody,
-    /await spawnStandardsFollowUp\(head, findings, sourceLabel, wasStandardsHardeningPrOpened\)/,
+    /await spawnStandardsFollowUp\(head, findings, sourceLabel, wasStandardsHardeningPrOpened, deferredReviewerFlags\)/,
     'expected the helper to pass the remembered hardening state into the spawn so an already-opened PR is never re-opened',
   );
   assert.match(
@@ -388,8 +402,8 @@ test('openStandardsFollowUpOnce gates spawnStandardsFollowUp behind the run-once
   );
   assert.match(
     onceBody,
-    /return wasStandardsHardeningPrOpened/,
-    'expected the skip path to return the cached hardening outcome',
+    /hardeningPrOpened: wasStandardsHardeningPrOpened/,
+    'expected the helper to return the cached hardening outcome as hardeningPrOpened',
   );
 });
 
@@ -431,14 +445,18 @@ function extractCallableSource(functionName) {
   return convergeSource.slice(declarationStart, index);
 }
 
-function loadStandardsFollowUpRuntime(recordedCalls, standardsEditResult) {
+const parseableHardeningCommitResult = { hardeningPrUrl: 'https://github.com/owner/repo/pull/7', summary: 'opened' };
+
+function loadStandardsFollowUpRuntime(recordedCalls, standardsEditResult, hardeningCommitResult = parseableHardeningCommitResult) {
   const runtimeSource =
     'let hasStandardsFollowUpFiled = false;\n' +
     'let wasStandardsHardeningPrOpened = false;\n' +
     "let standardsFollowUpIssueUrl = '';\n" +
     'async function runCodeEditorTask(taskName, context) {\n' +
     '  recordedCalls.push({ task: taskName, context });\n' +
-    "  return taskName === 'standards-edit' ? standardsEditResult : {};\n" +
+    "  if (taskName === 'standards-edit') return standardsEditResult;\n" +
+    "  if (taskName === 'hardening-commit') return hardeningCommitResult;\n" +
+    '  return {};\n' +
     '}\n' +
     'async function runVerifierTask() {\n' +
     '  return { passed: true };\n' +
@@ -450,6 +468,7 @@ function loadStandardsFollowUpRuntime(recordedCalls, standardsEditResult) {
     `${extractCallableSource('collectFindingThreadIds')}\n` +
     `${extractCallableSource('findingsCarryThreads')}\n` +
     `${extractCallableSource('shouldOpenStandardsFollowUp')}\n` +
+    `${extractCallableSource('parseDeferredPr')}\n` +
     `${extractCallableSource('spawnStandardsFollowUp')}\n` +
     `${extractCallableSource('resolveStandardsThreadsForBatch')}\n` +
     `${extractCallableSource('openStandardsFollowUpOnce')}\n` +
@@ -457,12 +476,45 @@ function loadStandardsFollowUpRuntime(recordedCalls, standardsEditResult) {
     '  openStandardsFollowUpOnce,\n' +
     '  guards: () => ({ hasStandardsFollowUpFiled, wasStandardsHardeningPrOpened, standardsFollowUpIssueUrl }),\n' +
     '};';
-  return new Function('recordedCalls', 'standardsEditResult', runtimeSource)(
+  return new Function('recordedCalls', 'standardsEditResult', 'hardeningCommitResult', runtimeSource)(
     recordedCalls,
     standardsEditResult,
+    hardeningCommitResult,
   );
 }
 
+function loadParseDeferredPr() {
+  return new Function(`${extractCallableSource('parseDeferredPr')}\nreturn parseDeferredPr;`)();
+}
+
+test('parseDeferredPr parses a full canonical hardening PR URL into its coordinates', () => {
+  const parseDeferredPr = loadParseDeferredPr();
+  assert.deepEqual(
+    parseDeferredPr('https://github.com/jl-cmd/claude-code-config/pull/824'),
+    { owner: 'jl-cmd', repo: 'claude-code-config', prNumber: 824 },
+  );
+});
+
+test('parseDeferredPr accepts a trailing slash, query string, or fragment on the PR URL', () => {
+  const parseDeferredPr = loadParseDeferredPr();
+  assert.equal(parseDeferredPr('https://github.com/owner/repo/pull/7/').prNumber, 7);
+  assert.equal(parseDeferredPr('https://github.com/owner/repo/pull/7?w=1').prNumber, 7);
+  assert.equal(parseDeferredPr('https://github.com/owner/repo/pull/7#issuecomment-42').prNumber, 7);
+});
+
+test('parseDeferredPr rejects a PR URL embedded in surrounding log text so it never parses the wrong number', () => {
+  const parseDeferredPr = loadParseDeferredPr();
+  assert.equal(
+    parseDeferredPr('opened https://github.com/owner/repo/pull/7 then https://github.com/owner/repo/pull/9'),
+    null,
+  );
+});
+
+test('parseDeferredPr rejects a deep-linked pull path so a non-canonical URL parses no coordinate', () => {
+  const parseDeferredPr = loadParseDeferredPr();
+  assert.equal(parseDeferredPr('https://github.com/owner/repo/pull/7/files'), null);
+});
+
 test('a second standards-only round never re-opens a hardening PR after the first round opened one but failed to file the issue', async () => {
   const recordedCalls = [];
   const issueFailedHardeningStaged = {
@@ -473,8 +525,8 @@ test('a second standards-only round never re-opens a hardening PR after the firs
   };
   const runtime = loadStandardsFollowUpRuntime(recordedCalls, issueFailedHardeningStaged);
 
-  const firstRoundHardeningPr = await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1 }], 'converge-round');
-  const secondRoundHardeningPr = await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1 }], 'copilot');
+  const firstRoundHardeningPr = await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1 }], 'converge-round', { copilotDisabled: false, bugbotDisabled: false });
+  const secondRoundHardeningPr = await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1 }], 'copilot', { copilotDisabled: false, bugbotDisabled: false });
 
   const hardeningCommitCalls = recordedCalls.filter((call) => call.task === 'hardening-commit').length;
   assert.equal(
@@ -482,8 +534,8 @@ test('a second standards-only round never re-opens a hardening PR after the firs
     1,
     'expected the hardening PR to be committed exactly once even when the follow-up issue filing must retry on the second round',
   );
-  assert.equal(firstRoundHardeningPr, true, 'expected the first round to open the hardening PR');
-  assert.equal(secondRoundHardeningPr, true, 'expected the second round to report the hardening PR as opened for this run');
+  assert.equal(firstRoundHardeningPr.hardeningPrOpened, true, 'expected the first round to open the hardening PR');
+  assert.equal(secondRoundHardeningPr.hardeningPrOpened, true, 'expected the second round to report the hardening PR as opened for this run');
   assert.equal(
     runtime.guards().wasStandardsHardeningPrOpened,
     true,
@@ -496,6 +548,65 @@ test('a second standards-only round never re-opens a hardening PR after the firs
   );
 });
 
+test('a hardening-commit that opens a PR but returns an unparseable URL still latches the run-once guard', async () => {
+  const recordedCalls = [];
+  const issueFailedHardeningStaged = {
+    issueUrl: '',
+    hardeningEdited: true,
+    hardeningRepoPath: '/tmp/hardening',
+    hardeningBranch: 'harden-standards',
+  };
+  const unparseableUrlHardeningCommitResult = { hardeningPrUrl: 'draft-hardening-pr-opened', summary: 'opened' };
+  const runtime = loadStandardsFollowUpRuntime(recordedCalls, issueFailedHardeningStaged, unparseableUrlHardeningCommitResult);
+
+  const firstRoundHardeningPr = await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1 }], 'converge-round', { copilotDisabled: false, bugbotDisabled: false });
+  const secondRoundHardeningPr = await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1 }], 'copilot', { copilotDisabled: false, bugbotDisabled: false });
+
+  const hardeningCommitCalls = recordedCalls.filter((call) => call.task === 'hardening-commit').length;
+  assert.equal(
+    hardeningCommitCalls,
+    1,
+    'expected the non-empty-URL commit to latch the guard so a second round opens no duplicate hardening PR',
+  );
+  assert.equal(firstRoundHardeningPr.hardeningPrOpened, true, 'expected a non-empty (though unparseable) URL to report the hardening PR as opened');
+  assert.equal(firstRoundHardeningPr.deferredPr, null, 'expected the unparseable URL to contribute no deferred coordinate');
+  assert.equal(secondRoundHardeningPr.hardeningPrOpened, true, 'expected the second round to report the hardening PR as opened for this run');
+  assert.equal(
+    runtime.guards().wasStandardsHardeningPrOpened,
+    true,
+    'expected the hardening guard to latch even though the returned URL never parsed',
+  );
+});
+
+test('a hardening-commit that opens no PR (empty hardeningPrUrl) leaves the run-once guard clear so a later round retries the open', async () => {
+  const recordedCalls = [];
+  const issueFailedHardeningStaged = {
+    issueUrl: '',
+    hardeningEdited: true,
+    hardeningRepoPath: '/tmp/hardening',
+    hardeningBranch: 'harden-standards',
+  };
+  const noPrHardeningCommitResult = { hardeningPrUrl: '', summary: 'no PR opened' };
+  const runtime = loadStandardsFollowUpRuntime(recordedCalls, issueFailedHardeningStaged, noPrHardeningCommitResult);
+
+  const firstRoundHardeningPr = await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1 }], 'converge-round', { copilotDisabled: false, bugbotDisabled: false });
+  const secondRoundHardeningPr = await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1 }], 'copilot', { copilotDisabled: false, bugbotDisabled: false });
+
+  const hardeningCommitCalls = recordedCalls.filter((call) => call.task === 'hardening-commit').length;
+  assert.equal(
+    hardeningCommitCalls,
+    2,
+    'expected the empty-URL commit (no PR opened) to leave the guard clear so a later round retries the open',
+  );
+  assert.equal(firstRoundHardeningPr.hardeningPrOpened, false, 'expected an empty URL to report no hardening PR opened');
+  assert.equal(secondRoundHardeningPr.hardeningPrOpened, false, 'expected the retry round to still report no hardening PR opened');
+  assert.equal(
+    runtime.guards().wasStandardsHardeningPrOpened,
+    false,
+    'expected the hardening guard to stay clear when no PR opened so the open keeps retrying',
+  );
+});
+
 test('a later standards-only round resolves its own review threads after the follow-up issue was already filed', async () => {
   const recordedCalls = [];
   const issueFiledNoHardening = {
@@ -506,8 +617,8 @@ test('a later standards-only round resolves its own review threads after the fol
   };
   const runtime = loadStandardsFollowUpRuntime(recordedCalls, issueFiledNoHardening);
 
-  await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1, replyToCommentId: null }], 'converge-round');
-  await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'b.py', line: 2, replyToCommentId: 42 }], 'copilot');
+  await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1, replyToCommentId: null }], 'converge-round', { copilotDisabled: false, bugbotDisabled: false });
+  await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'b.py', line: 2, replyToCommentId: 42 }], 'copilot', { copilotDisabled: false, bugbotDisabled: false });
 
   const standardsEditCalls = recordedCalls.filter((call) => call.task === 'standards-edit');
   assert.equal(standardsEditCalls.length, 1, 'expected the follow-up issue to be filed exactly once across the run');
@@ -536,8 +647,8 @@ test('a reuse-path standards round carrying no review threads spawns no thread-r
   };
   const runtime = loadStandardsFollowUpRuntime(recordedCalls, issueFiledNoHardening);
 
-  await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1, replyToCommentId: null }], 'converge-round');
-  await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'b.py', line: 2, replyToCommentId: null }], 'copilot');
+  await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1, replyToCommentId: null }], 'converge-round', { copilotDisabled: false, bugbotDisabled: false });
+  await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'b.py', line: 2, replyToCommentId: null }], 'copilot', { copilotDisabled: false, bugbotDisabled: false });
 
   const resolveCalls = recordedCalls.filter((call) => call.task === 'standards-resolve-threads');
   assert.equal(
@@ -547,3 +658,25 @@ test('a reuse-path standards round carrying no review threads spawns no thread-r
   );
 });
 
+test('resolveReviewerDown is the single reviewer-down gate; resolveBugbotDown no longer exists', () => {
+  assert.doesNotMatch(
+    convergeSource,
+    /function resolveBugbotDown\(/,
+    'expected resolveBugbotDown to be removed in favor of the shared resolveReviewerDown gate',
+  );
+  assert.match(convergeSource, /function resolveReviewerDown\(/, 'expected the shared resolveReviewerDown gate to exist');
+});
+
+test('resolveReviewerDown reports down when the input override is set, even with an available probe entry', () => {
+  assert.equal(resolveReviewerDown({ down: false, reason: 'available' }, true), true);
+});
+
+test('resolveReviewerDown reports available (fail-open) when the probe entry is missing and no input override is set', () => {
+  assert.equal(resolveReviewerDown(null, false), false);
+  assert.equal(resolveReviewerDown(undefined, false), false);
+});
+
+test('resolveReviewerDown reports available when the probe entry explicitly reports available', () => {
+  assert.equal(resolveReviewerDown({ down: false, reason: 'available' }, false), false);
+});
+

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

@@ -31,7 +31,7 @@ test('isMergeConflicting reports a conflict only when the check returned conflic
   assert.equal(isMergeConflicting({ conflicting: false }), false);
 });
 
-test('the git agent handles merge-conflict checks with shell-agnostic polling', () => {
+test('the git agent handles merge-conflict checks with a Monitor-based poll', () => {
   const gitBody = functionBody('runGitTask');
   assert.match(gitBody, /mergeable/, 'expected the git agent to read the PR mergeable field');
   assert.match(
@@ -40,7 +40,7 @@ test('the git agent handles merge-conflict checks with shell-agnostic polling',
     'expected the git agent merge check to be read-only',
   );
   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');
+  assert.match(gitBody, /Monitor tool/, 'expected a Monitor-based poll delay, not a foreground sleep');
 });
 
 test('runCodeEditorTask conflict-edit path rebases onto origin/main and makes no push', () => {