claude-dev-env 1.80.0 → 1.82.0

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

@@ -107,42 +107,28 @@ test('repair-convergence edit step no longer instructs resolving every unresolve
   );
 });
 
-test('bugbot lens delay instructions are shell-agnostic with PowerShell as an alternative', () => {
+test('the bugbot lens waits through the Monitor tool, not a foreground sleep', () => {
   const bugbotPrompt = lensPromptBody('runBugbotLens');
-  assert.match(bugbotPrompt, /sleep 60/, 'expected a shell-agnostic 60-second poll delay');
-  assert.match(bugbotPrompt, /sleep 8/, 'expected a concrete 8-second delay command');
-  assert.match(
-    bugbotPrompt,
-    /Start-Sleep[\s\S]*alternative|alternative[\s\S]*Start-Sleep/i,
-    'expected PowerShell to be named only as an allowed alternative',
-  );
+  assert.match(bugbotPrompt, /Monitor tool/, 'expected the bugbot poll to wait via the Monitor tool');
   assert.doesNotMatch(
     bugbotPrompt,
-    /wait 8 seconds(?!,)/,
-    'the vague "wait 8 seconds" phrasing must carry a concrete command',
+    /sleep 60|sleep 8|Start-Sleep/,
+    'expected no foreground sleep in the bugbot poll delays',
   );
 });
 
-test('copilot gate delay instruction is shell-agnostic with PowerShell as an alternative', () => {
+test('the copilot gate waits through the Monitor tool, not a foreground sleep', () => {
   const copilotPrompt = lensPromptBody('runCopilotGate');
-  assert.match(copilotPrompt, /sleep 360/, 'expected a shell-agnostic 360-second poll delay');
-  assert.match(
-    copilotPrompt,
-    /Start-Sleep[\s\S]*alternative|alternative[\s\S]*Start-Sleep/i,
-    'expected PowerShell to be named only as an allowed alternative',
-  );
+  assert.match(copilotPrompt, /Monitor tool/, 'expected the copilot poll to wait via the Monitor tool');
+  assert.doesNotMatch(copilotPrompt, /sleep 360|Start-Sleep/, 'expected no foreground sleep in the copilot poll delay');
 });
 
-test('gotchas doc describes the reviewer wait as shell-agnostic', () => {
-  assert.match(
-    gotchasSource,
-    /\bsleep\b/i,
-    'expected the wait guidance to name a shell-agnostic sleep',
-  );
+test('gotchas doc describes the reviewer wait as a Monitor poll, not a foreground sleep', () => {
+  assert.match(gotchasSource, /Monitor tool/, 'expected the gotcha to name the Monitor-based reviewer wait');
   assert.doesNotMatch(
     gotchasSource,
-    /a single PowerShell\s*`?Start-Sleep`?\s*loop/i,
-    'PowerShell Start-Sleep must be an alternative, not the sole mechanism',
+    /shell-agnostic/i,
+    'the reviewer wait is a Monitor poll, not a shell-agnostic sleep loop',
   );
 });
 
@@ -385,13 +371,45 @@ test('spawnStandardsFollowUp reports whether a hardening PR opened on every path
   const body = lensPromptBody('spawnStandardsFollowUp');
   const falseReturns = body.match(/hardeningPrOpened:\s*false/g) || [];
   assert.ok(
-    falseReturns.length >= 2,
-    'expected both skip paths (no hardening staged, verify failed) to return hardeningPrOpened:false',
+    falseReturns.length >= 3,
+    'expected every skip path (hardening PR already opened, no hardening staged, verify failed) to return hardeningPrOpened:false',
   );
   assert.match(
     body,
-    /hardeningPrOpened:\s*true/,
-    'expected the commit path to return hardeningPrOpened:true',
+    /const hardeningPrOpened =\s*typeof commitResult\?\.hardeningPrUrl === 'string' && commitResult\.hardeningPrUrl\.length > 0/,
+    'expected the commit path to derive hardeningPrOpened from a non-empty hardeningPrUrl, so a PR that opened with an unparseable URL still latches the guard while an empty URL (no PR opened) leaves it clear to retry',
+  );
+});
+
+test('spawnStandardsFollowUp reports the deferred PR identity on every path', () => {
+  const body = lensPromptBody('spawnStandardsFollowUp');
+  const nullDeferred = body.match(/deferredPr:\s*null/g) || [];
+  assert.ok(
+    nullDeferred.length >= 2,
+    'expected both skip paths (no hardening staged, verify failed) to return deferredPr:null',
+  );
+  assert.match(
+    body,
+    /parseDeferredPr\(commitResult\?\.hardeningPrUrl\)/,
+    'expected the commit path to parse the deferred PR identity from the commit step hardeningPrUrl',
+  );
+  assert.doesNotMatch(
+    body,
+    /hardeningPrOpened:\s*deferredPr !== null/,
+    'expected the commit path to keep hardeningPrOpened separate from the parsed deferredPr so an unparseable URL still latches the guard',
+  );
+});
+
+test('the workflow return objects carry the accumulated deferredPrs list', () => {
+  const converged = convergeSource.match(/deferredPrs/g) || [];
+  assert.ok(
+    converged.length >= 4,
+    'expected deferredPrs to be declared, pushed at both deferral call sites, and returned',
+  );
+  assert.match(
+    convergeSource,
+    /if \(standardsOutcome\?\.deferredPr\) deferredPrs\.push\(standardsOutcome\.deferredPr\)/,
+    'expected each deferral call site to accumulate the deferred PR into deferredPrs',
   );
 });
 
@@ -758,3 +776,117 @@ test('extractVerifyObjection calls parseLastVerdictFence', () => {
   const objectionBody = lensPromptBody('extractVerifyObjection');
   assert.match(objectionBody, /parseLastVerdictFence\(/, 'expected extractVerifyObjection to call the shared parser');
 });
+
+test('the headless preamble routes waits through the Monitor tool and forbids ending a turn to await work', () => {
+  const preambleStart = convergeSource.indexOf('const HEADLESS_SAFETY_PREAMBLE =');
+  assert.notEqual(preambleStart, -1, 'expected a HEADLESS_SAFETY_PREAMBLE definition');
+  const preambleEnd = convergeSource.indexOf('\n\nlet activeRepoPath', preambleStart);
+  assert.notEqual(preambleEnd, -1, 'expected the preamble to end before activeRepoPath');
+  const preamble = convergeSource.slice(preambleStart, preambleEnd);
+  assert.match(preamble, /foreground sleep is blocked/i, 'expected the preamble to state foreground sleep is blocked');
+  assert.match(preamble, /Monitor tool/, 'expected the preamble to route waits through the Monitor tool');
+  assert.match(preamble, /StructuredOutput/, 'expected the preamble to require a schema agent to always call StructuredOutput');
+  assert.match(preamble, /never end your turn to wait/i, 'expected the preamble to forbid ending a turn to await background work');
+});
+
+test('the preamble describes the Monitor wait by its real contract: a bounded until-loop consuming notifications as they arrive, rather than an in-turn synchronous return', () => {
+  const blockStart = convergeSource.indexOf('const HEADLESS_SAFETY_PREAMBLE =');
+  assert.ok(blockStart !== -1, 'expected a wait-safety preamble to exist');
+  const blockEnd = convergeSource.indexOf('\n\nlet activeRepoPath', blockStart);
+  assert.ok(blockEnd !== -1, 'expected the preamble to end before activeRepoPath');
+  const preamble = convergeSource.slice(blockStart, blockEnd);
+  assert.doesNotMatch(
+    preamble,
+    /never move a wait to a background process/i,
+    'the Monitor tool is itself a background monitor, so the preamble must avoid forbidding a wait that moves to a background process',
+  );
+  assert.doesNotMatch(
+    preamble,
+    /return to you when the condition holds/i,
+    'the Monitor tool streams notifications across turns rather than returning in-turn, so the preamble must avoid describing an in-turn synchronous return',
+  );
+  assert.match(
+    preamble,
+    /until-loop/i,
+    'expected the preamble to describe the wait as a bounded until-loop paired with the Monitor tool',
+  );
+  assert.match(
+    preamble,
+    /notifications? as they arrive/i,
+    'expected the preamble to say Monitor notifications are consumed as they arrive',
+  );
+});
+
+test('the background-wait clause gives "await" an explicit object, not a dangling "await never resumes"', () => {
+  const text = preambleText();
+  assert.doesNotMatch(
+    text,
+    /end your turn to await never resumes/i,
+    'expected the background-wait clause to name what is awaited, not read as "await never resumes" with no object',
+  );
+  assert.match(
+    text,
+    /end your turn to await it/i,
+    'expected the background-wait clause to name the wait as the object of "await"',
+  );
+});
+
+test('the wait guidance names the full down-result schema, not a bare down flag', () => {
+  const text = preambleText();
+  assert.doesNotMatch(
+    text,
+    /Copilot gate, down: true\)/,
+    'expected the down signal to name the full schema, not a bare down flag that reads as a partial object',
+  );
+  assert.match(
+    text,
+    /down:true, findings:\[\]/,
+    'expected the wait guidance to name the full down-result fields',
+  );
+});
+
+test('no agent prompt instructs a foreground sleep as the poll delay', () => {
+  assert.doesNotMatch(
+    convergeSource,
+    /delay each (?:attempt|iteration|retry) with "sleep/,
+    'expected no poll directive to instruct a foreground sleep as the between-attempt delay',
+  );
+  assert.doesNotMatch(
+    convergeSource,
+    /Start-Sleep -Seconds/,
+    'expected no agent prompt to instruct a foreground PowerShell Start-Sleep',
+  );
+});
+
+test('the wait guidance sizes the Monitor timeout_ms above the 300s default', () => {
+  const text = preambleText();
+  assert.match(text, /timeout_ms/, 'names the timeout_ms parameter the wait rule tells the agent to set');
+  assert.match(text, /persistent/, 'offers persistent as an alternative to a sized timeout_ms');
+  assert.match(text, /300000|300 second/, 'names the 300000 default that truncates a long wait');
+  assert.match(
+    text,
+    /interval[\s\S]{0,60}attempt|interval-times-attempts/i,
+    'sizes timeout_ms to the interval-times-attempts span the step names',
+  );
+});
+
+test('the Monitor ceiling the guidance names covers the longest interval-times-attempts wait the steps prescribe', () => {
+  const cap = /(\d{7})\s*(?:ms|millisecond)/i.exec(preambleText());
+  assert.ok(cap !== null, 'the guidance names a seven-digit Monitor ceiling in milliseconds');
+  const ceiling = Number(cap[1]);
+
+  const copilot = lensPromptBody('runCopilotGate');
+  const bugbot = lensPromptBody('runBugbotLens');
+  const apart = Number(/(\d+)\s*seconds apart/.exec(copilot)[1]);
+  const polls = Number(/copilotMaxPolls:\s*(\d+)/.exec(convergeSource)[1]);
+  const seconds = Number(/every\s*(\d+)\s*seconds/.exec(bugbot)[1]);
+  const iterations = Number(/up to\s*(\d+)\s*iterations/.exec(bugbot)[1]);
+  const spans = [apart * polls * 1000, seconds * iterations * 1000];
+
+  for (const span of spans) {
+    assert.ok(
+      span <= ceiling,
+      `a ${span}ms wait span exceeds the ${ceiling}ms Monitor ceiling the guidance names`,
+    );
+  }
+});

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

@@ -129,6 +129,24 @@ test('a Copilot no-show after the poll cap returns a down result rather than a b
   );
 });
 
+test('the Copilot gate accepts a COMMENTED review with no inline findings as a clean pass', () => {
+  const copilotPrompt = functionBody('runCopilotGate');
+  assert.match(
+    copilotPrompt,
+    /COMMENTED with no inline findings/,
+    'expected the clean-pass branch to accept a COMMENTED review with no inline findings, matching the canonical ALL_COPILOT_CLEAN_REVIEW_STATES rule where a Copilot COMMENTED review is a clean state',
+  );
+});
+
+test('the Copilot gate polls long enough to catch a normal-latency Copilot review', () => {
+  const budgetMatch = convergeSource.match(/copilotMaxPolls:\s*(\d+)/);
+  assert.notEqual(budgetMatch, null, 'expected copilotMaxPolls in CONFIG');
+  assert.ok(
+    Number(budgetMatch[1]) >= 6,
+    `expected copilotMaxPolls >= 6 (>= ~36 min at 360s per attempt) so a normal-latency Copilot review lands before the no-show fallback triggers, got ${budgetMatch[1]}`,
+  );
+});
+
 test('runConvergenceCheck wires the --copilot-down flag from the copilotDown context', () => {
   const checkConvergenceBody = functionBody('runConvergenceCheck');
   assert.match(
@@ -295,7 +313,7 @@ test('a copilotDisabled run reaches FINALIZE with --copilot-down', () => {
   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');
+  const convergenceCheckBody = functionBody('runConvergenceCheck');
   assert.match(
     convergenceCheckBody,
     /context\.copilotDown \? ' --copilot-down' : ''/,
@@ -303,3 +321,326 @@ test('a copilotDisabled run reaches FINALIZE with --copilot-down', () => {
   );
 });
 
+function loadStandardsFollowUpDecision() {
+  return new Function(
+    `${functionBody('shouldOpenStandardsFollowUp')}\n` +
+      'return shouldOpenStandardsFollowUp;',
+  )();
+}
+
+test('the deferred follow-up create runs exactly once across a three-round standards run', () => {
+  const shouldOpenStandardsFollowUp = loadStandardsFollowUpDecision();
+  let alreadyOpened = false;
+  let createCount = 0;
+  for (let round = 0; round < 3; round += 1) {
+    if (shouldOpenStandardsFollowUp(alreadyOpened)) {
+      createCount += 1;
+      alreadyOpened = true;
+    }
+  }
+  assert.equal(
+    createCount,
+    1,
+    'expected the deferred follow-up issue and hardening PR to be created exactly once across a multi-round run',
+  );
+});
+
+test('shouldOpenStandardsFollowUp opens on the first standards-only round and skips afterward', () => {
+  const shouldOpenStandardsFollowUp = loadStandardsFollowUpDecision();
+  assert.equal(shouldOpenStandardsFollowUp(false), true);
+  assert.equal(shouldOpenStandardsFollowUp(true), false);
+});
+
+test('the run seeds the standards follow-up flags to false so the first standards-only round opens the follow-up', () => {
+  assert.match(
+    convergeSource,
+    /let hasStandardsFollowUpFiled = false/,
+    'expected a run-scoped hasStandardsFollowUpFiled flag seeded false',
+  );
+  assert.match(
+    convergeSource,
+    /let wasStandardsHardeningPrOpened = false/,
+    'expected a run-scoped wasStandardsHardeningPrOpened flag seeded false',
+  );
+});
+
+test('openStandardsFollowUpOnce gates spawnStandardsFollowUp behind the run-once flag and remembers the outcome', () => {
+  const onceBody = extractCallableSource('openStandardsFollowUpOnce');
+  assert.match(
+    onceBody,
+    /shouldOpenStandardsFollowUp\(hasStandardsFollowUpFiled\)/,
+    'expected the helper to consult the run-once decision on the current flag',
+  );
+  assert.match(
+    onceBody,
+    /await spawnStandardsFollowUp\(head, findings, sourceLabel, wasStandardsHardeningPrOpened\)/,
+    'expected the helper to pass the remembered hardening state into the spawn so an already-opened PR is never re-opened',
+  );
+  assert.match(
+    onceBody,
+    /hasStandardsFollowUpFiled = standardsOutcome\?\.followUpIssueFiled === true/,
+    'expected the helper to latch the flag only when the follow-up issue was actually filed so a transient failure retries on a later round',
+  );
+  assert.match(
+    onceBody,
+    /wasStandardsHardeningPrOpened = wasStandardsHardeningPrOpened \|\| standardsOutcome\?\.hardeningPrOpened === true/,
+    'expected the hardening guard to latch the moment a hardening PR opens and stay latched across rounds so a later issue-filing retry never re-opens it',
+  );
+  assert.match(
+    onceBody,
+    /hardeningPrOpened: wasStandardsHardeningPrOpened/,
+    'expected the helper to return the cached hardening outcome as hardeningPrOpened',
+  );
+});
+
+test('both standards-deferral call sites route the create through openStandardsFollowUpOnce', () => {
+  const onceCalls = convergeSource.match(/await openStandardsFollowUpOnce\(/g) || [];
+  assert.equal(
+    onceCalls.length,
+    2,
+    'expected the converge-round and copilot standards call sites to both defer to openStandardsFollowUpOnce',
+  );
+  const directCreates = convergeSource.match(/await spawnStandardsFollowUp\(/g) || [];
+  assert.equal(
+    directCreates.length,
+    1,
+    'expected spawnStandardsFollowUp to be invoked once from openStandardsFollowUpOnce, never directly at a call site',
+  );
+});
+
+function extractCallableSource(functionName) {
+  const asyncStart = convergeSource.indexOf(`async function ${functionName}(`);
+  const plainStart = convergeSource.indexOf(`function ${functionName}(`);
+  const declarationStart = asyncStart !== -1 ? asyncStart : plainStart;
+  assert.notEqual(declarationStart, -1, `expected ${functionName} to exist`);
+  const bodyStart = convergeSource.indexOf('{', declarationStart);
+  let depth = 0;
+  let index = bodyStart;
+  for (; index < convergeSource.length; index += 1) {
+    const character = convergeSource[index];
+    if (character === '{') {
+      depth += 1;
+    } else if (character === '}') {
+      depth -= 1;
+      if (depth === 0) {
+        index += 1;
+        break;
+      }
+    }
+  }
+  return convergeSource.slice(declarationStart, index);
+}
+
+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' +
+    "  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' +
+    '}\n' +
+    'function verdictPassed() {\n' +
+    '  return true;\n' +
+    '}\n' +
+    'function log() {}\n' +
+    `${extractCallableSource('collectFindingThreadIds')}\n` +
+    `${extractCallableSource('findingsCarryThreads')}\n` +
+    `${extractCallableSource('shouldOpenStandardsFollowUp')}\n` +
+    `${extractCallableSource('parseDeferredPr')}\n` +
+    `${extractCallableSource('spawnStandardsFollowUp')}\n` +
+    `${extractCallableSource('resolveStandardsThreadsForBatch')}\n` +
+    `${extractCallableSource('openStandardsFollowUpOnce')}\n` +
+    'return {\n' +
+    '  openStandardsFollowUpOnce,\n' +
+    '  guards: () => ({ hasStandardsFollowUpFiled, wasStandardsHardeningPrOpened, standardsFollowUpIssueUrl }),\n' +
+    '};';
+  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 = {
+    issueUrl: '',
+    hardeningEdited: true,
+    hardeningRepoPath: '/tmp/hardening',
+    hardeningBranch: 'harden-standards',
+  };
+  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 hardeningCommitCalls = recordedCalls.filter((call) => call.task === 'hardening-commit').length;
+  assert.equal(
+    hardeningCommitCalls,
+    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.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,
+    'expected the hardening guard to stay latched across rounds',
+  );
+  assert.equal(
+    runtime.guards().hasStandardsFollowUpFiled,
+    false,
+    'expected the issue guard to stay clear so the filing keeps retrying',
+  );
+});
+
+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');
+  const secondRoundHardeningPr = await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1 }], 'copilot');
+
+  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');
+  const secondRoundHardeningPr = await runtime.openStandardsFollowUpOnce('sha1', [{ file: 'a.py', line: 1 }], 'copilot');
+
+  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 = {
+    issueUrl: 'https://github.com/jl-cmd/claude-code-config/issues/900',
+    hardeningEdited: false,
+    hardeningRepoPath: '',
+    hardeningBranch: '',
+  };
+  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');
+
+  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');
+
+  const resolveCalls = recordedCalls.filter((call) => call.task === 'standards-resolve-threads');
+  assert.equal(resolveCalls.length, 1, 'expected the reuse-path round to resolve its own batch review threads');
+  assert.deepEqual(
+    resolveCalls[0].context.findings,
+    [{ file: 'b.py', line: 2, replyToCommentId: 42 }],
+    'expected the resolve step to receive the reuse-path batch findings so their threads get replied-to and resolved',
+  );
+  assert.equal(
+    resolveCalls[0].context.issueUrl,
+    'https://github.com/jl-cmd/claude-code-config/issues/900',
+    'expected the resolve step to reference the already-filed follow-up issue in its inline reply',
+  );
+});
+
+test('a reuse-path standards round carrying no review threads spawns no thread-resolution agent', async () => {
+  const recordedCalls = [];
+  const issueFiledNoHardening = {
+    issueUrl: 'https://github.com/jl-cmd/claude-code-config/issues/901',
+    hardeningEdited: false,
+    hardeningRepoPath: '',
+    hardeningBranch: '',
+  };
+  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');
+
+  const resolveCalls = recordedCalls.filter((call) => call.task === 'standards-resolve-threads');
+  assert.equal(
+    resolveCalls.length,
+    0,
+    'expected no thread-resolution agent when the reuse-path batch of in-memory findings carries no review threads',
+  );
+});
+

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', () => {