claude-dev-env 1.80.0 → 1.82.0

package/skills/autoconverge/workflow/converge.mjs

@@ -16,14 +16,14 @@ export const meta = {
   phases: [
     { title: 'Reuse', detail: 'Before convergence, one reuse lens scans the full diff for reuse improvements that are certain, behaviorally identical, and autonomously implementable, and applies the qualifying ones in one commit' },
     { title: 'Converge', detail: 'Bugbot + code-review + bug-audit in parallel each round; one clean-coder applies all fixes; loop until all three are clean on a stable HEAD' },
-    { title: 'Copilot gate', detail: 'When the quota pre-check reports Copilot out of premium-request quota or unavailable, skip the gate with no agent spawned; otherwise request a Copilot review and poll up to three times, route findings back into Converge, and when Copilot is down or out of quota log a notice and mark the PR ready with the gate bypassed' },
+    { title: 'Copilot gate', detail: 'When the quota pre-check reports Copilot out of premium-request quota or unavailable, skip the gate with no agent spawned; otherwise request a Copilot review and poll up to the configured cap, route findings back into Converge, and when Copilot is down or out of quota log a notice and mark the PR ready with the gate bypassed' },
     { title: 'Finalize', detail: 'Run check_convergence.py; mark draft=false on a full pass' },
   ],
 }
 
 const CONFIG = {
   maxIterations: 20,
-  copilotMaxPolls: 3,
+  copilotMaxPolls: 8,
   sharedScripts: '$HOME/.claude/skills/pr-converge/scripts',
   prLoopScripts: '$HOME/.claude/_shared/pr-loop/scripts',
   bugteamRubric: '$HOME/.claude/skills/bugteam/reference/audit-contract.md',
@@ -35,7 +35,11 @@ const HEADLESS_SAFETY_PREAMBLE =
   '- When a commit message, or a PR / issue / review-comment body, must describe destructive-command behavior, write that text to a file and pass it by path (git commit -F <file>, gh ... --body-file <file>); never inline it with git commit -m or gh ... -b, where the literal lands in the Bash command and stalls you.\n' +
   '- Keep scratch files and cleanup inside the OS temp dir; never target a repository or worktree path.\n' +
   '- rm shape rules — the hook grants several rm auto-allow paths. The simplest one accepts a standalone Bash call whose target resolves inside the ephemeral namespace (/tmp, /temp, the OS temp root, or the run worktree); a compound path accepts an rm joined with benign reporting segments when every rm target is an absolute ephemeral path. Both of those paths fail closed on $(...) command substitution and on backtick subshells. The compound path additionally fails closed on any $ in the target — including $CLAUDE_JOB_DIR. The standalone path declines a $-bearing target only when the literal path is not already under an ephemeral root, so it does not by itself stop a $VAR that expands inside an ephemeral root. A third, broad path matches only when the command itself declares an ephemeral working directory (it cds into one, or runs under one): that cwd-scoped path resolves the target against the declared cwd, fails closed on $(...) , backticks, and unknown variables, and resolves the known temporary variables TEMP, TMP, TMPDIR, and CLAUDE_JOB_DIR to the OS temp root, so under that declared ephemeral cwd a bare $CLAUDE_JOB_DIR/tmp/<name> target and a relative target after a cd are auto-allowed. Even so, prefer a Python helper for any cleanup whose path is variable-built or whose setup/teardown spans multiple steps: author the helper file and run it as python <file>.py, which keeps every destructive literal out of a Bash command string entirely and never depends on which auto-allow path matches.\n' +
-  '- If a step appears to require a real destructive command, use a non-destructive equivalent or report it as a blocker instead of running it.\n\n'
+  '- If a step appears to require a real destructive command, use a non-destructive equivalent or report it as a blocker instead of running it.\n\n' +
+  'WAITS AND POLLS — foreground sleep is blocked in this headless harness: a bare Bash "sleep N" or a PowerShell "Start-Sleep" is denied, and a wait you move to a background process — then end your turn to await it — never resumes, because a schema-bearing agent runs for a single turn. Therefore:\n' +
+  '- Perform every required delay or poll-interval wait inside this same turn by pairing the Monitor tool with a bounded until-loop: the Monitor tool streams its events to you while you keep working, and the until-loop re-runs the step condition on the interval the step names, up to the attempt budget the step names, exiting the moment the condition holds or the budget is spent — consume the Monitor notifications as they arrive rather than ending your turn to await them. Never end your turn to wait for something to finish.\n' +
+  '- Size the Monitor to the whole wait: its timeout_ms defaults to 300000 (300 seconds) and the Monitor is killed the moment that elapses, so a poll whose interval or whose interval-times-attempts span runs longer registers a false time-out. Before you arm a Monitor, set timeout_ms to at least the poll interval times the attempt count the step names — up to the 3600000ms ceiling — or pass persistent: true so the Monitor is never timed out. A 360-second interval, or a many-minute total, exceeds the 300000 default, so arming the Monitor with the default truncates the wait; set timeout_ms to the step span instead.\n' +
+  '- When your run was given a result schema, your final action is always the StructuredOutput call. If the poll budget is spent before the awaited signal arrives, call StructuredOutput with the whole time-out result the step documents — for the Copilot gate, the full down result {sha, clean:false, down:true, findings:[]}, never a bare down flag — rather than ending the turn without a result.\n\n'
 
 let activeRepoPath = null
 
@@ -102,7 +106,7 @@ function runGitTask(task, head) {
     `Report whether ${prCoordinates} (HEAD ${head}) has merge conflicts with its base branch. Do not edit, commit, push, or rebase — read only.\n\n` +
       `GitHub computes mergeability asynchronously, so .mergeable is null right after a push until it finishes. Poll until it resolves: run\n` +
       `   gh api repos/${input.owner}/${input.repo}/pulls/${input.prNumber} --jq '{mergeable: .mergeable, state: .mergeable_state}'\n` +
-      `up to 5 times, 5 seconds apart (delay each retry with "sleep 5", or the PowerShell alternative "Start-Sleep -Seconds 5"), stopping as soon as mergeable is true or false.\n\n` +
+      `up to 5 times, 5 seconds apart (wait each 5-second interval inside this turn with the Monitor tool, per the WAITS AND POLLS rule above), stopping as soon as mergeable is true or false.\n\n` +
       `Return conflicting:true when mergeable is false or state is "dirty" (the branch conflicts with the base). Return conflicting:false when mergeable is true, or when mergeable stays null after the full poll budget — mergeability is unknown, so let the bug checks proceed rather than rebase on a guess.`,
     { label: 'git-utility', phase: 'Converge', schema: MERGE_CONFLICT_SCHEMA, agentType: 'Explore' },
   )
@@ -200,11 +204,12 @@ async function fixerWithRecovery(head, findings, sourceLabel) {
 
 /**
  * Spawn a fresh code-editor clean-coder agent for a specific edit task (fix-edit,
- * conflict-edit, repair-edit, repair-commit, standards-edit, hardening-commit,
- * commit-recover, verify-recover). Each task carries its own edit instructions.
+ * conflict-edit, repair-edit, repair-commit, standards-edit,
+ * standards-resolve-threads, hardening-commit, commit-recover, verify-recover).
+ * Each task carries its own edit instructions.
  * @param {string} task the short task name
  * @param {object} context task-specific context
- * @returns {Promise<object|string>} the structured output, or the transcript string when the 'hardening-commit' resume runs schema-less
+ * @returns {Promise<object|string>} the structured output, or the transcript string when a schema-less task ('standards-resolve-threads') runs
  */
 function runCodeEditorTask(task, context) {
   const label = `code-editor:${task}`
@@ -293,14 +298,28 @@ function runCodeEditorTask(task, context) {
       { label, phase: 'Converge', schema: STANDARDS_EDIT_SCHEMA, agentType: 'clean-coder' },
     )
   }
+  if (task === 'standards-resolve-threads') {
+    const findingsBlock = renderFindingsBlock(context.findings)
+    const threadIds = context.findings
+      .flatMap((each) => collectFindingThreadIds(each))
+      .filter((each) => typeof each === 'number')
+    return convergeAgent(
+      `You are the THREAD-RESOLUTION step for a code-standard-only round on ${prCoordinates}, HEAD ${context.head} (${context.sourceLabel}). This run already filed the deferred-fix follow-up issue ${context.issueUrl}, so this batch's code-standard findings defer to that same issue. Make NO code edits, NO commit, and NO push — only reply to and resolve the review threads this batch carries.\n\n` +
+        `Findings:\n${findingsBlock}\n\n` +
+        `For each finding that carries a GitHub review comment id (${threadIds.length ? threadIds.join(', ') : 'none this batch'}): post an inline reply via python "${CONFIG.sharedScripts}/post_fix_reply.py" --owner ${input.owner} --repo ${input.repo} --pr-number ${input.prNumber} --in-reply-to <id> --body "Code-standard-only finding — deferred to follow-up issue ${context.issueUrl}." Then resolve the thread by its PRRT_ node id (GraphQL lookup on comment databaseId, then resolveReviewThread or the github MCP pull_request_review_write method=resolve_thread — not the numeric comment id).\n\n` +
+        `Return a one-line summary naming the threads you resolved.`,
+      { label, phase: 'Converge', agentType: 'clean-coder' },
+    )
+  }
   if (task === 'hardening-commit') {
     return convergeAgent(
       `You are the COMMIT step opening the environment-hardening PR (${context.sourceLabel}) for the change staged in ${context.hardeningRepoPath} on branch ${context.hardeningBranch}. The edit step left the hooks/rules edits in the working tree and the verify step passed, so a verifier verdict already binds to this exact working tree. Do NOT touch the PR's own branch.\n\n` +
         `Rules:\n` +
         `- Make NO further file edits of any kind. Any edit changes the surface and invalidates the verdict that unlocks the commit gate, so the push would be blocked. Only commit and push what is already there.\n` +
-        `- In ${context.hardeningRepoPath}: make ONE commit of the staged hooks/rules change on branch ${context.hardeningBranch}, push it, then open a DRAFT PR. The PR body references the follow-up issue ${context.issueUrl || '(none)'} and states the PR hardens the environment so the deferred violation classes are blocked at Write/Edit time. Honor the gh-body-file rule: write a BOM-free temp file and pass --body-file.\n\n` +
-        `Return a one-line summary naming the hardening PR URL.`,
-      { label, phase: 'Converge', agentType: 'clean-coder' },
+        `- In ${context.hardeningRepoPath}: make ONE commit of the staged hooks/rules change on branch ${context.hardeningBranch}, push it, then open a DRAFT PR. The PR body references the follow-up issue ${context.issueUrl || '(none)'} and states the PR hardens the environment so the deferred violation classes are blocked at Write/Edit time. Honor the gh-body-file rule: write a BOM-free temp file and pass --body-file.\n` +
+        `- Title the PR as a Conventional Commit — a type prefix (feat, fix, chore, docs, refactor, perf, ci, style, test, build, revert), an optional scope in parentheses, then a colon and a short summary, e.g. "feat(hooks): block the deferred violation class". The target repo's CI validates the PR title as a semantic commit and rejects a non-conforming title.\n\n` +
+        `Return the full https URL of the DRAFT hardening PR in hardeningPrUrl (empty string when no PR was opened) and a one-line summary.`,
+      { label, phase: 'Converge', schema: HARDENING_COMMIT_SCHEMA, agentType: 'clean-coder' },
     )
   }
   if (task === 'commit-recover') {
@@ -569,6 +588,16 @@ const STANDARDS_EDIT_SCHEMA = {
   required: ['issueUrl', 'hardeningRepoPath', 'hardeningBranch', 'hardeningEdited', 'summary'],
 }
 
+const HARDENING_COMMIT_SCHEMA = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    hardeningPrUrl: { type: 'string', description: 'the full https URL of the DRAFT environment-hardening PR the commit step opened, or an empty string when no PR was opened' },
+    summary: { type: 'string' },
+  },
+  required: ['hardeningPrUrl', 'summary'],
+}
+
 /**
  * Build the verdict-fence step instructions for a verify agent, binding the
  * surface hash by branch name rather than by a self-resolved cwd. Resolving
@@ -1091,7 +1120,7 @@ function runBugbotLens(head) {
       `   Only count entries whose commit_id starts with ${head}.\n` +
       `   - If findings exist on HEAD -> return them (each with its inline comment id in replyToCommentId when present, else null).\n` +
       `   - If a clean review exists on HEAD -> return clean.\n` +
-      `4. No review yet on HEAD: check_bugbot_ci.py --check-active. If active (exit 0), poll: repeat check_bugbot_ci.py --check-clean / --check-active every 60 seconds (delay each iteration with "sleep 60", or the PowerShell alternative "Start-Sleep -Seconds 60") for up to 25 iterations, then re-fetch the review. If not active (exit 1), post the literal comment "bugbot run" (no @mention, no other text) via python "${CONFIG.sharedScripts}/post_fix_reply.py" --owner ${input.owner} --repo ${input.repo} --pr-number ${input.prNumber} --body "bugbot run", delay 8 seconds with "sleep 8" (PowerShell alternative "Start-Sleep -Seconds 8"), then poll as above.\n` +
+      `4. No review yet on HEAD: check_bugbot_ci.py --check-active. If active (exit 0), poll: repeat check_bugbot_ci.py --check-clean / --check-active every 60 seconds (wait each 60-second interval inside this turn with the Monitor tool, per the WAITS AND POLLS rule above) for up to 25 iterations, then re-fetch the review. If not active (exit 1), post the literal comment "bugbot run" (no @mention, no other text) via python "${CONFIG.sharedScripts}/post_fix_reply.py" --owner ${input.owner} --repo ${input.repo} --pr-number ${input.prNumber} --body "bugbot run", wait 8 seconds inside this turn with the Monitor tool (per the WAITS AND POLLS rule above), then poll as above.\n` +
       `5. If after the full poll budget Bugbot has neither a check run nor a review on HEAD -> return {sha:${'`'}${head}${'`'}, clean:true, down:true, findings:[]} (treat as down).\n\n` +
       `Scope is the whole PR; you are only reading Bugbot's own output here. For each finding set category: 'code-standard' when it is a pure CODE_RULES/style violation (naming, comments, type hints, magic values, structure) with no behavioral impact; 'bug' otherwise. Return strictly the schema.`,
     { label: 'lens:bugbot', phase: 'Converge', schema: LENS_SCHEMA },
@@ -1286,9 +1315,9 @@ function runCopilotGate(head) {
       `Copilot can run out of usage. When the newest Copilot review on HEAD carries an out-of-usage notice — a body stating Copilot was unable to review because the user who requested the review has reached their quota limit, or any equivalent quota / premium-request / usage-limit exhaustion message rather than an actual code review — Copilot is down for this run: return {sha:${'`'}${head}${'`'}, clean:true, down:true, findings:[]} and stop. Do NOT re-request a review, do NOT keep polling, and do NOT treat the notice as a finding.\n\n` +
       `1. Read any existing Copilot review on HEAD first: python "${CONFIG.sharedScripts}/fetch_copilot_reviews.py" --owner ${input.owner} --repo ${input.repo} --pr-number ${input.prNumber}. This lists every Copilot review across all commits newest-first; only count entries whose commit_id starts with ${head}. If the newest such HEAD-scoped Copilot review is the out-of-usage notice above -> return the down result and stop. A notice on any earlier commit is NOT down: ignore it and continue. With no Copilot review on HEAD, skip a duplicate request: python "${CONFIG.sharedScripts}/check_pending_reviews.py" --owner ${input.owner} --repo ${input.repo} --pr-number ${input.prNumber} --user copilot. Exit 0 means a request is already pending; otherwise request one:\n` +
       `   gh api --method POST repos/${input.owner}/${input.repo}/pulls/${input.prNumber}/requested_reviewers -f 'reviewers[]=copilot-pull-request-reviewer[bot]'\n` +
-      `2. Poll for Copilot's review on HEAD ${head}: up to ${CONFIG.copilotMaxPolls} attempts, 360 seconds apart (delay each attempt with "sleep 360", or the PowerShell alternative "Start-Sleep -Seconds 360"). Each attempt: python "${CONFIG.sharedScripts}/fetch_copilot_reviews.py" --owner ${input.owner} --repo ${input.repo} --pr-number ${input.prNumber} for the top-level review state, plus gh api "repos/${input.owner}/${input.repo}/pulls/${input.prNumber}/comments" --paginate --slurp for inline comment ids (Copilot's login contains "copilot", case-insensitive). Only count entries whose commit_id starts with ${head}.\n` +
+      `2. Poll for Copilot's review on HEAD ${head}: up to ${CONFIG.copilotMaxPolls} attempts, 360 seconds apart (wait each 360-second interval inside this turn with the Monitor tool, per the WAITS AND POLLS rule above; if the attempt budget is spent with no review on HEAD, return down: true). Each attempt: python "${CONFIG.sharedScripts}/fetch_copilot_reviews.py" --owner ${input.owner} --repo ${input.repo} --pr-number ${input.prNumber} for the top-level review state, plus gh api "repos/${input.owner}/${input.repo}/pulls/${input.prNumber}/comments" --paginate --slurp for inline comment ids (Copilot's login contains "copilot", case-insensitive). Only count entries whose commit_id starts with ${head}.\n` +
       `   - Out-of-usage notice on HEAD -> return the down result above (clean:true, down:true) and stop.\n` +
-      `   - Copilot review present and clean/approved on HEAD -> return {sha:${'`'}${head}${'`'}, clean:true, down:false, findings:[]}.\n` +
+      `   - Copilot review present on HEAD whose state is APPROVED, or COMMENTED with no inline findings -> a clean pass: return {sha:${'`'}${head}${'`'}, clean:true, down:false, findings:[]}.\n` +
       `   - Copilot findings on HEAD -> return them (each with its inline comment id in replyToCommentId; category 'code-standard' for pure CODE_RULES/style violations with no behavioral impact, 'bug' otherwise), clean:false, down:false.\n` +
       `   - No review after ${CONFIG.copilotMaxPolls} attempts -> Copilot is down for this run (unreachable, or silently out of quota with no notice): return {sha:${'`'}${head}${'`'}, clean:false, down:true, findings:[]}.\n\n` +
       `Return strictly the schema.`,
@@ -1391,19 +1420,54 @@ function isStandardsOnlyRound(findings) {
   return findings.length > 0 && findings.every((each) => each.category === 'code-standard')
 }
 
+/**
+ * Decide whether a standards-only round should file the follow-up fix issue and
+ * open the environment-hardening PR. Standards findings are deferred rather than
+ * fixed on this PR, so the same code-standard findings re-surface on every
+ * converge round and on the Copilot gate; without this guard each re-entry files
+ * a fresh duplicate follow-up issue and hardening PR for the one deferred finding
+ * class. The follow-up issue is filed once per convergence run — a round whose
+ * filing succeeds latches the guard, while a round whose filing failed leaves it
+ * clear so a later round retries the filing.
+ * @param {boolean} hasAlreadyFiled true when an earlier standards-only round in this run already filed the follow-up issue
+ * @returns {boolean} true when this round should attempt the follow-up filing
+ */
+function shouldOpenStandardsFollowUp(hasAlreadyFiled) {
+  return hasAlreadyFiled !== true
+}
+
 /**
  * Build the standards-deferral note for the closing report, naming the
- * environment-hardening PR only when one was opened this round so the note
+ * environment-hardening PR only when one was opened for this run so the note
  * never claims a PR the skip paths did not produce.
  * @param {number} findingsCount count of deferred code-standard findings
- * @param {boolean} hardeningPrOpened true when the hardening PR was opened this round
+ * @param {boolean} wasHardeningPrOpened true when the hardening PR was opened for this run
  * @returns {string} the human-facing deferral note
  */
-function standardsDeferralNote(findingsCount, hardeningPrOpened) {
+function standardsDeferralNote(findingsCount, wasHardeningPrOpened) {
   const base = `${findingsCount} code-standard finding(s) deferred to a follow-up fix issue`
-  return hardeningPrOpened
+  return wasHardeningPrOpened
     ? `${base} plus an environment-hardening PR — verify both land`
-    : `${base} — verify it lands (no environment-hardening PR was opened this round)`
+    : `${base} — verify it lands (no environment-hardening PR was opened for this run)`
+}
+
+/**
+ * Parse a GitHub pull-request URL into the owner, repo, and number a recursive
+ * converge run needs to address it.
+ *
+ * A hardening PR the commit step opens returns its URL as
+ * `https://github.com/<owner>/<repo>/pull/<number>`; this reads those three
+ * coordinates back out so the self-closing orchestrator can converge the
+ * deferred PR in turn. A blank or non-matching string yields null, so a commit
+ * step that opened no PR contributes no deferred coordinate.
+ * @param {string} prUrl the hardening PR's https URL, or an empty string
+ * @returns {{owner: string, repo: string, prNumber: number}|null} the parsed coordinates, or null when the URL does not match
+ */
+function parseDeferredPr(prUrl) {
+  if (typeof prUrl !== 'string') return null
+  const match = prUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?(?:[?#].*)?$/)
+  if (!match) return null
+  return { owner: match[1], repo: match[2], prNumber: Number(match[3]) }
 }
 
 /**
@@ -1414,29 +1478,104 @@ function standardsDeferralNote(findingsCount, hardeningPrOpened) {
  * commit (clean-coder makes one commit, pushes, and opens the DRAFT hardening
  * PR). Splitting the edit from the push lets a workflow code-verifier produce the
  * verdict the verified-commit gate requires for the cross-repo hardening commit.
- * This PR's own branch is never touched. When the edit staged no hardening, or
- * the verify step fails, the follow-up issue still stands and the commit step is
- * skipped.
+ * This PR's own branch is never touched. When a hardening PR already opened for
+ * this run, the edit staged no hardening, or the verify step fails, the follow-up
+ * issue still stands and the commit step is skipped.
  * @param {string} head PR HEAD SHA the findings were raised against
  * @param {Array<object>} findings deduped code-standard-only findings
  * @param {string} sourceLabel short description of where the findings came from
- * @returns {Promise<object>} `{ hardeningPrOpened }` — true only when the hardening PR was opened this round
+ * @param {boolean} hasHardeningPrAlreadyOpened true when an earlier round already opened the environment-hardening PR for this run, so the verify and commit steps are skipped and no second PR opens while the edit retries the issue filing
+ * @returns {Promise<object>} `{ followUpIssueFiled, issueUrl, hardeningPrOpened, deferredPr }` — followUpIssueFiled true when the standards-edit step returned a non-empty issue URL, issueUrl that filed URL (empty string when the filing failed) so a later reuse-path round can reference it when resolving its own threads, hardeningPrOpened true when the hardening-commit step returned a non-empty hardeningPrUrl (a PR opened) so the run-once latch holds even when that URL does not parse into coordinates, and false when the commit step returned an empty URL (no PR opened) so a later round retries the open, and deferredPr the opened PR's `{owner, repo, prNumber}` (null when no PR was opened or the committed URL does not parse) so the self-closing orchestrator can converge it in turn
  */
-async function spawnStandardsFollowUp(head, findings, sourceLabel) {
+async function spawnStandardsFollowUp(head, findings, sourceLabel, hasHardeningPrAlreadyOpened) {
   const editResult = await runCodeEditorTask('standards-edit', { head, findings, sourceLabel })
+  const followUpIssueFiled = typeof editResult?.issueUrl === 'string' && editResult.issueUrl.length > 0
+  const followUpIssueUrl = followUpIssueFiled ? editResult.issueUrl : ''
+  if (hasHardeningPrAlreadyOpened === true) {
+    return { followUpIssueFiled, issueUrl: followUpIssueUrl, hardeningPrOpened: false, deferredPr: null }
+  }
   if (editResult?.hardeningEdited !== true || !editResult?.hardeningRepoPath) {
-    return { hardeningPrOpened: false }
+    return { followUpIssueFiled, issueUrl: followUpIssueUrl, hardeningPrOpened: false, deferredPr: null }
   }
   const verifyTranscript = await runVerifierTask('hardening-verify', {
     head, sourceLabel, hardeningRepoPath: editResult.hardeningRepoPath, hardeningBranch: editResult.hardeningBranch,
   })
   if (!verdictPassed(verifyTranscript)) {
-    return { hardeningPrOpened: false }
+    return { followUpIssueFiled, issueUrl: followUpIssueUrl, hardeningPrOpened: false, deferredPr: null }
   }
-  await runCodeEditorTask('hardening-commit', {
+  const commitResult = await runCodeEditorTask('hardening-commit', {
     head, sourceLabel, hardeningRepoPath: editResult.hardeningRepoPath, hardeningBranch: editResult.hardeningBranch, issueUrl: editResult.issueUrl,
   })
-  return { hardeningPrOpened: true }
+  const deferredPr = parseDeferredPr(commitResult?.hardeningPrUrl)
+  const hardeningPrOpened = typeof commitResult?.hardeningPrUrl === 'string' && commitResult.hardeningPrUrl.length > 0
+  return { followUpIssueFiled, issueUrl: followUpIssueUrl, hardeningPrOpened, deferredPr }
+}
+
+/**
+ * Report whether any finding in a batch carries a GitHub review thread that needs
+ * an inline reply and resolution.
+ * @param {Array<object>} findings the batch of findings
+ * @returns {boolean} true when at least one finding carries a review comment id
+ */
+function findingsCarryThreads(findings) {
+  return findings.some((each) => collectFindingThreadIds(each).length > 0)
+}
+
+/**
+ * On the reuse path — after this run already filed the deferred-fix follow-up
+ * issue — reply to and resolve this batch's code-standard review threads against
+ * that same issue. The issue filing and hardening PR stay gated behind the
+ * run-once flags; only the per-batch thread resolution runs here, so a later
+ * standards-only round's bot threads are still marked resolved and the FINALIZE
+ * zero-unresolved-bot-threads gate passes. A batch of in-memory audit findings
+ * that carries no review thread needs no agent, so the resolve step is skipped.
+ * @param {string} head PR HEAD SHA the findings were raised against
+ * @param {Array<object>} findings this batch's deduped code-standard-only findings
+ * @param {string} sourceLabel short description of where the findings came from
+ * @returns {Promise<void>}
+ */
+async function resolveStandardsThreadsForBatch(head, findings, sourceLabel) {
+  if (!findingsCarryThreads(findings)) {
+    return
+  }
+  await runCodeEditorTask('standards-resolve-threads', {
+    head, findings, sourceLabel, issueUrl: standardsFollowUpIssueUrl,
+  })
+}
+
+/**
+ * File the deferred follow-up issue and open the environment-hardening PR at most
+ * once per convergence run, then reuse them. The two guards latch independently:
+ * the follow-up issue latches only when its filing succeeds, and the hardening PR
+ * latches the moment one opens and never re-opens. A standards-only round whose
+ * issue filing already succeeded — in the converge phase or at the Copilot gate —
+ * skips spawnStandardsFollowUp, resolves this batch's own code-standard review
+ * threads against the already-filed issue via resolveStandardsThreadsForBatch, and
+ * returns the remembered hardening outcome. A round whose issue filing failed
+ * re-runs spawnStandardsFollowUp to retry the filing, passing the remembered
+ * hardening state so an already-opened hardening PR is never re-opened. The run
+ * therefore files one follow-up issue and opens one hardening PR rather than a
+ * fresh duplicate per re-entry — while every round still resolves the review
+ * threads its own findings carry, even when the filing must retry after the
+ * hardening PR has opened.
+ * @param {string} head PR HEAD SHA the findings were raised against
+ * @param {Array<object>} findings deduped code-standard-only findings
+ * @param {string} sourceLabel short description of where the findings came from
+ * @returns {Promise<object>} `{ hardeningPrOpened, deferredPr }` — hardeningPrOpened true when a hardening PR was opened for this run, and deferredPr the opened PR's `{owner, repo, prNumber}` when this call opened it (null otherwise) so the self-closing orchestrator can converge it in turn
+ */
+async function openStandardsFollowUpOnce(head, findings, sourceLabel) {
+  if (!shouldOpenStandardsFollowUp(hasStandardsFollowUpFiled)) {
+    log(`Standards deferral (${sourceLabel}): reusing the follow-up fix issue already filed for this run rather than filing a duplicate; environment-hardening PR ${wasStandardsHardeningPrOpened ? 'was opened for this run' : 'was not opened for this run'}`)
+    await resolveStandardsThreadsForBatch(head, findings, sourceLabel)
+    return { hardeningPrOpened: wasStandardsHardeningPrOpened, deferredPr: null }
+  }
+  const standardsOutcome = await spawnStandardsFollowUp(head, findings, sourceLabel, wasStandardsHardeningPrOpened)
+  hasStandardsFollowUpFiled = standardsOutcome?.followUpIssueFiled === true
+  if (hasStandardsFollowUpFiled) {
+    standardsFollowUpIssueUrl = standardsOutcome.issueUrl
+  }
+  wasStandardsHardeningPrOpened = wasStandardsHardeningPrOpened || standardsOutcome?.hardeningPrOpened === true
+  return { hardeningPrOpened: wasStandardsHardeningPrOpened, deferredPr: standardsOutcome?.deferredPr ?? null }
 }
 
 let phase = 'CONVERGE'
@@ -1448,7 +1587,11 @@ let bugbotDown = input.bugbotDisabled || false
 let copilotDown = input.copilotDisabled || false
 let copilotNote = null
 let standardsNote = null
+let hasStandardsFollowUpFiled = false
+let wasStandardsHardeningPrOpened = false
+let standardsFollowUpIssueUrl = ''
 let reuseNote = null
+const deferredPrs = []
 
 const preflightHead = await runGitTask('resolve-head')
 if (isResolvedHeadUsable(preflightHead?.sha)) {
@@ -1501,8 +1644,9 @@ while (iterations < CONFIG.maxIterations) {
     const findings = roundOutcome.findings
     if (isStandardsOnlyRound(findings)) {
       log(`Round ${rounds}: ${findings.length} code-standard-only finding(s) — deferring to follow-up PRs and treating the round as passed`)
-      const standardsOutcome = await spawnStandardsFollowUp(head, findings, 'converge-round')
-      standardsNote = standardsDeferralNote(findings.length, standardsOutcome?.hardeningPrOpened === true)
+      const standardsOutcome = await openStandardsFollowUpOnce(head, findings, 'converge-round')
+      standardsNote = standardsDeferralNote(findings.length, standardsOutcome.hardeningPrOpened)
+      if (standardsOutcome?.deferredPr) deferredPrs.push(standardsOutcome.deferredPr)
       const auditResult = await runGeneralUtilityTask('post-clean-audit', { head })
       if (!auditResult?.posted) {
         blocker = cleanAuditBlocker(head, auditResult)
@@ -1564,8 +1708,9 @@ while (iterations < CONFIG.maxIterations) {
     if (copilotOutcome.kind === 'fix') {
       if (isStandardsOnlyRound(copilotOutcome.findings)) {
         log(`Copilot raised ${copilotOutcome.findings.length} code-standard-only finding(s) — deferring to follow-up PRs and treating the gate as passed`)
-        const standardsOutcome = await spawnStandardsFollowUp(head, copilotOutcome.findings, 'copilot')
-        standardsNote = standardsDeferralNote(copilotOutcome.findings.length, standardsOutcome?.hardeningPrOpened === true)
+        const standardsOutcome = await openStandardsFollowUpOnce(head, copilotOutcome.findings, 'copilot')
+        standardsNote = standardsDeferralNote(copilotOutcome.findings.length, standardsOutcome.hardeningPrOpened)
+        if (standardsOutcome?.deferredPr) deferredPrs.push(standardsOutcome.deferredPr)
         copilotDown = false
         copilotNote = null
         phase = 'FINALIZE'
@@ -1601,7 +1746,7 @@ while (iterations < CONFIG.maxIterations) {
       const readyResult = await runGeneralUtilityTask('mark-ready', { head, copilotDown })
       const readyOutcome = classifyReadyOutcome(readyResult)
       if (readyOutcome.converged) {
-        return { converged: true, rounds, finalSha: head, blocker: null, standardsNote, copilotNote, reuseNote }
+        return { converged: true, rounds, finalSha: head, blocker: null, standardsNote, copilotNote, reuseNote, deferredPrs }
       }
       blocker = readyOutcome.blocker
       break
@@ -1621,4 +1766,5 @@ return {
   standardsNote,
   copilotNote,
   reuseNote,
+  deferredPrs,
 }

package/skills/autoconverge/workflow/converge_multi.mjs

@@ -126,7 +126,7 @@ function childRunInput(prEntry) {
 
 const multiInput = classifyMultiInput(args)
 if (multiInput.blocker) {
-  return { converged: false, prCount: 0, convergedCount: 0, results: [], blocker: multiInput.blocker }
+  return { converged: false, prCount: 0, convergedCount: 0, results: [], allDeferredPrs: [], blocker: multiInput.blocker }
 }
 const input = multiInput.input
 
@@ -147,6 +147,7 @@ const childResults = await parallel(
       rounds: childOutcome && childOutcome.rounds !== undefined ? childOutcome.rounds : null,
       finalSha: childOutcome && childOutcome.finalSha !== undefined ? childOutcome.finalSha : null,
       blocker: childOutcome && childOutcome.blocker !== undefined ? childOutcome.blocker : null,
+      deferredPrs: childOutcome && Array.isArray(childOutcome.deferredPrs) ? childOutcome.deferredPrs : [],
     }
   }),
 )
@@ -161,17 +162,20 @@ const results = childResults.map((eachResult, eachIndex) =>
         rounds: null,
         finalSha: null,
         blocker: 'child run threw or was skipped before returning an outcome',
+        deferredPrs: [],
       }
     : eachResult,
 )
 
 const convergedCount = results.filter((eachResult) => eachResult.converged).length
-log(`autoconverge multi-PR done: ${convergedCount}/${results.length} PR(s) converged`)
+const allDeferredPrs = results.flatMap((eachResult) => eachResult.deferredPrs)
+log(`autoconverge multi-PR done: ${convergedCount}/${results.length} PR(s) converged, ${allDeferredPrs.length} deferred hardening PR(s) opened`)
 
 return {
   converged: convergedCount === results.length,
   prCount: results.length,
   convergedCount,
   results,
+  allDeferredPrs,
   blocker: null,
 }

package/skills/autoconverge/workflow/converge_multi.run-input.test.mjs

@@ -21,6 +21,19 @@ const productionModule = new Function(
 )();
 const { normalizeMultiInput, classifyMultiInput, childRunInput } = productionModule;
 
+const AsyncFunction = async function () {}.constructor;
+const workflowBodySource = multiSource.slice(multiSource.indexOf('function normalizeMultiInput('));
+const runMultiWorkflowBody = new AsyncFunction(
+  'args',
+  'phase',
+  'log',
+  'parallel',
+  'workflow',
+  workflowBodySource,
+);
+
+function ignoreCall() {}
+
 const SCRIPT_PATH = '/abs/skills/autoconverge/workflow/converge.mjs';
 
 function validEntry(prNumber) {
@@ -124,3 +137,16 @@ test('childRunInput forwards bugbotDisabled true when the entry opts out', () =>
 test('childRunInput defaults bugbotDisabled to false when the entry omits it', () => {
   assert.equal(childRunInput(validEntry(398)).bugbotDisabled, false);
 });
+
+test('the malformed-input blocker return carries an empty allDeferredPrs list', async () => {
+  const blockerOutcome = await runMultiWorkflowBody(
+    'not json at all',
+    ignoreCall,
+    ignoreCall,
+    ignoreCall,
+    ignoreCall,
+  );
+  assert.notEqual(blockerOutcome.blocker, null);
+  assert.equal(blockerOutcome.prCount, 0);
+  assert.deepEqual(blockerOutcome.allDeferredPrs, []);
+});