claude-dev-env 1.80.0 → 1.81.0

package/skills/_shared/pr-loop/scripts/build_audit_prompt.py

@@ -3,7 +3,8 @@
 Builds <context> and <scope> from CLI args; <bug_categories>,
 <rubric_reference>, and <constraints> come from the shared constants in
 skills_pr_loop_constants; <comment_posting> and <output_format> are built
-inline.
+inline. <pr_description> carries the PR body text read from --pr-body-file,
+and stays empty when that argument is absent or the file cannot be read.
 
 Usage:
   python scripts/build_audit_prompt.py --owner jl-cmd --repo claude-code-config --pr-number 422 --loop 1 --head-ref feat/branch --base-ref main --worktree-path <PATH> --run-temp-dir <PATH>
@@ -28,6 +29,38 @@ from skills_pr_loop_constants.path_resolver_constants import (
 )
 
 
+def read_pr_body_text(pr_body_file: Path | None) -> str | None:
+    """Read the PR description body from a file when given and readable.
+
+    Args:
+        pr_body_file: Path to a file holding the PR description body, or None.
+
+    Returns:
+        The file's text when the path is given and readable, otherwise None.
+    """
+    if pr_body_file is None:
+        return None
+    try:
+        return pr_body_file.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+
+def _append_pr_description(root: Element, pr_body_text: str | None) -> None:
+    """Append a <pr_description> element carrying the PR body text.
+
+    Args:
+        root: Root element the <pr_description> child is appended to.
+        pr_body_text: PR description body text, or None when unavailable.
+
+    Returns:
+        None.
+    """
+    pr_description = SubElement(root, "pr_description")
+    if pr_body_text:
+        pr_description.text = pr_body_text
+
+
 def build_audit_prompt_xml(
     *,
     owner: str,
@@ -38,6 +71,7 @@ def build_audit_prompt_xml(
     base_ref: str,
     worktree_path: Path,
     run_temp_dir: Path,
+    pr_body_text: str | None = None,
 ) -> Element:
     """Build the complete AUDIT spawn prompt XML.
 
@@ -50,6 +84,7 @@ def build_audit_prompt_xml(
         base_ref: Base branch ref.
         worktree_path: Path to the git worktree.
         run_temp_dir: Path to the run temp directory.
+        pr_body_text: PR description body text, or None when unavailable.
 
     Returns:
         Root <spawn_prompt> element.
@@ -72,6 +107,8 @@ def build_audit_prompt_xml(
         f"bugs, and anti-patterns. Work in {worktree_path.as_posix()}."
     )
 
+    _append_pr_description(root, pr_body_text)
+
     bug_categories = SubElement(root, "bug_categories")
     for each_category_id, each_category_label in ALL_AUDIT_CATEGORY_ENTRIES:
         cat_elem = SubElement(bug_categories, "category", {"id": each_category_id})
@@ -110,6 +147,7 @@ def emit_audit_prompt(
     base_ref: str,
     worktree_path: Path,
     run_temp_dir: Path,
+    pr_body_text: str | None = None,
 ) -> str:
     """Build and serialize the AUDIT spawn prompt to a pretty-printed XML string.
 
@@ -122,6 +160,7 @@ def emit_audit_prompt(
         base_ref: Base branch ref.
         worktree_path: Path to the git worktree.
         run_temp_dir: Path to the run temp directory.
+        pr_body_text: PR description body text, or None when unavailable.
 
     Returns:
         Pretty-printed XML string.
@@ -135,6 +174,7 @@ def emit_audit_prompt(
         base_ref=base_ref,
         worktree_path=worktree_path,
         run_temp_dir=run_temp_dir,
+        pr_body_text=pr_body_text,
     )
     return emit_pretty_xml(root)
 
@@ -157,6 +197,7 @@ def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
     parser.add_argument("--base-ref", required=True)
     parser.add_argument("--worktree-path", type=Path, required=True)
     parser.add_argument("--run-temp-dir", type=Path, required=True)
+    parser.add_argument("--pr-body-file", type=Path, default=None)
     return parser.parse_args(all_argv)
 
 
@@ -179,6 +220,7 @@ def main(all_arguments: list[str]) -> int:
         base_ref=arguments.base_ref,
         worktree_path=arguments.worktree_path,
         run_temp_dir=arguments.run_temp_dir,
+        pr_body_text=read_pr_body_text(arguments.pr_body_file),
     )
     sys.stdout.write(xml_output)
     return 0

package/skills/_shared/pr-loop/scripts/skills_pr_loop_constants/CLAUDE.md

@@ -7,7 +7,7 @@ Python package of named constants for the `pr-loop` shared scripts. All constant
 | File | Role |
 |---|---|
 | `__init__.py` | Package marker. |
-| `path_resolver_constants.py` | Path template strings and format constants: workspace directory naming, worktree directory name, diff patch filename pattern, outcome XML filename patterns, loop state filename, fix status values, audit constraint texts, audit category entries, fix execution steps, fix constraint texts, and XML serialization settings. |
+| `path_resolver_constants.py` | Path template strings and format constants: workspace directory naming, worktree directory name, diff patch filename pattern, outcome XML filename patterns, fix status values, audit constraint texts, audit category entries, fix execution steps, and fix constraint texts. |
 | `preflight_constants.py` | Constants used by `preflight_worktree.py` for exit codes and output marker strings. |
 
 ## Usage
@@ -15,5 +15,5 @@ Python package of named constants for the `pr-loop` shared scripts. All constant
 Scripts import directly from the package:
 
 ```python
-from skills_pr_loop_constants.path_resolver_constants import LOOP_STATE_FILENAME
+from skills_pr_loop_constants.path_resolver_constants import PER_PR_WORKSPACE_TEMPLATE
 ```

package/skills/_shared/pr-loop/scripts/skills_pr_loop_constants/path_resolver_constants.py

@@ -9,7 +9,6 @@ WORKTREE_DIRNAME = "worktree"
 DIFF_PATCH_TEMPLATE = "loop-{loop}.patch"
 OUTCOME_XML_TEMPLATE = ".bugteam-pr{number}-loop{loop}.outcomes.xml"
 FIX_OUTCOME_XML_TEMPLATE = ".bugteam-pr{number}-loop{loop}.fix-outcomes.xml"
-LOOP_STATE_FILENAME = "loop-state.json"
 SLUGIFY_SAFE_CHARS = re.compile(r"[^A-Za-z0-9._-]")
 SLUGIFY_REPLACEMENT = "-"
 MULTI_PR_SLUG_TEMPLATE = "{owner}-{repo}-pr-{number}"
@@ -47,6 +46,7 @@ ALL_AUDIT_CATEGORY_ENTRIES = [
     ("N", "Test-name scenario verifier"),
     ("O", "Docstring / fixture-prose vs implementation drift"),
     ("P", "Name / regex / word-list vs behavior-contract precision"),
+    ("Q", "Cross-surface claim consistency (terminology, PR-description claims, message-vs-guard)"),
 ]
 
 AUDIT_RUBRIC_REFERENCE_TEXT = (
@@ -77,9 +77,6 @@ ALL_FIX_CONSTRAINT_TEXTS = [
     "forward slashes (e.g. C:/Users/...), even on Windows.",
 ]
 
-XML_PRETTY_INDENT = "  "
-XML_SERIALIZE_ENCODING = "unicode"
-XML_OUTPUT_ENCODING = "utf-8"
 ALL_PYTHON_ONEXC_VERSION = (3, 12)
 
 ALL_FINDING_BODY_ELEMENT_KEYS: tuple[str, ...] = (

package/skills/_shared/pr-loop/scripts/test_build_audit_prompt.py

@@ -1,4 +1,4 @@
-"""Tests pinning build_audit_prompt's emitted A-P category taxonomy."""
+"""Tests pinning build_audit_prompt's emitted A-Q category taxonomy."""
 
 from __future__ import annotations
 
@@ -18,7 +18,7 @@ from skills_pr_loop_constants.path_resolver_constants import (
 )
 
 _CATEGORY_RUBRICS_DIR = _SCRIPTS_DIR.parents[3] / "audit-rubrics" / "category_rubrics"
-_HEADING_PATTERN = re.compile(r"^# Category ([A-P]) — (.+)$")
+_HEADING_PATTERN = re.compile(r"^# Category ([A-Q]) — (.+)$")
 
 
 def _load_build_audit_prompt() -> ModuleType:
@@ -84,12 +84,12 @@ def test_context_and_scope_render_paths_with_forward_slashes() -> None:
     assert "C:/Users/jon/AppData/Local/Temp/bugteam-pr-376/worktree" in scope.text
 
 
-def test_bug_categories_carry_ids_a_through_p_in_order() -> None:
+def test_bug_categories_carry_ids_a_through_q_in_order() -> None:
     root = _build_audit_root()
     bug_categories = root.find("bug_categories")
     assert bug_categories is not None
     all_emitted_ids = [each_category.get("id") for each_category in bug_categories]
-    all_expected_ids = list("ABCDEFGHIJKLMNOP")
+    all_expected_ids = list("ABCDEFGHIJKLMNOPQ")
     assert all_emitted_ids == all_expected_ids
 
 
@@ -161,3 +161,99 @@ def test_prompt_skeleton_sub_bucket_counts_match_rubric_rows() -> None:
                 f"{each_letter}{each_walk_match.group(1)} but rubric has "
                 f"{sub_bucket_row_count} rows"
             )
+
+
+def test_bug_categories_include_category_q() -> None:
+    root = _build_audit_root()
+    bug_categories = root.find("bug_categories")
+    assert bug_categories is not None
+    label_by_id = {
+        each_category.get("id"): each_category.text for each_category in bug_categories
+    }
+    assert label_by_id["Q"] == (
+        "Cross-surface claim consistency "
+        "(terminology, PR-description claims, message-vs-guard)"
+    )
+
+
+def test_pr_description_carries_body_text_when_supplied() -> None:
+    root = build_audit_prompt.build_audit_prompt_xml(
+        owner="jl-cmd",
+        repo="claude-code-config",
+        pr_number=422,
+        loop=1,
+        head_ref="feat/branch",
+        base_ref="main",
+        worktree_path=Path("/tmp/bugteam-pr-422/worktree"),
+        run_temp_dir=Path("/tmp/bugteam-pr-422"),
+        pr_body_text="## Summary\nCloses the gate.",
+    )
+    pr_description = root.find("pr_description")
+    assert pr_description is not None
+    assert pr_description.text == "## Summary\nCloses the gate."
+
+
+def test_pr_description_empty_when_body_absent() -> None:
+    root = _build_audit_root()
+    pr_description = root.find("pr_description")
+    assert pr_description is not None
+    assert pr_description.text is None
+
+
+def test_read_pr_body_text_returns_file_contents(tmp_path: Path) -> None:
+    body_file = tmp_path / "pr-body.md"
+    body_file.write_text("body from disk", encoding="utf-8")
+    assert build_audit_prompt.read_pr_body_text(body_file) == "body from disk"
+
+
+def test_read_pr_body_text_returns_none_when_path_absent() -> None:
+    assert build_audit_prompt.read_pr_body_text(None) is None
+
+
+def test_read_pr_body_text_returns_none_when_file_missing(tmp_path: Path) -> None:
+    missing_file = tmp_path / "does-not-exist.md"
+    assert build_audit_prompt.read_pr_body_text(missing_file) is None
+
+
+def test_emit_audit_prompt_embeds_pr_body_text_in_pr_description() -> None:
+    xml_text = build_audit_prompt.emit_audit_prompt(
+        owner="jl-cmd",
+        repo="claude-code-config",
+        pr_number=422,
+        loop=1,
+        head_ref="feat/branch",
+        base_ref="main",
+        worktree_path=Path("/tmp/bugteam-pr-422/worktree"),
+        run_temp_dir=Path("/tmp/bugteam-pr-422"),
+        pr_body_text="body via emit",
+    )
+    assert "body via emit" in xml_text
+
+
+def test_parse_arguments_defaults_pr_body_file_to_none() -> None:
+    arguments = build_audit_prompt.parse_arguments([
+        "--owner", "jl-cmd",
+        "--repo", "claude-code-config",
+        "--pr-number", "422",
+        "--loop", "1",
+        "--head-ref", "feat/branch",
+        "--base-ref", "main",
+        "--worktree-path", "/tmp/wt",
+        "--run-temp-dir", "/tmp/rt",
+    ])
+    assert arguments.pr_body_file is None
+
+
+def test_parse_arguments_reads_pr_body_file_path() -> None:
+    arguments = build_audit_prompt.parse_arguments([
+        "--owner", "jl-cmd",
+        "--repo", "claude-code-config",
+        "--pr-number", "422",
+        "--loop", "1",
+        "--head-ref", "feat/branch",
+        "--base-ref", "main",
+        "--worktree-path", "/tmp/wt",
+        "--run-temp-dir", "/tmp/rt",
+        "--pr-body-file", "/tmp/body.md",
+    ])
+    assert arguments.pr_body_file == Path("/tmp/body.md")

package/skills/autoconverge/SKILL.md

@@ -312,10 +312,10 @@ matches.
   (hooks/rules that block those violation classes at Write/Edit time), resolves
   any bot threads with a deferral note, and reports the deferral in
   `standardsNote`.
-- **Copilot gate:** request a Copilot review, poll up to three times; findings
+- **Copilot gate:** request a Copilot review, poll up to the configured cap; findings
   route back into Converge. When Copilot is down or out of quota — it posts an
   out-of-usage notice (the requester hit their quota) on the HEAD, or surfaces no
-  review at all after the cap — the gate logs a notice and the run marks the PR
+  review at all after the configured cap — the gate logs a notice and the run marks the PR
   ready with the Copilot gate bypassed. `copilotNote` records the bypass.
 - **Convergence check:** `check_convergence.py` is the authoritative gate; on a
   full pass the workflow marks `draft=false`.

package/skills/autoconverge/reference/convergence.md

@@ -79,11 +79,11 @@ tracks CONVERGE passes only and is never the cap.
 **COPILOT** gate:
 
 - Request a Copilot review on HEAD (skipping a duplicate request), then poll up
-  to three times, 360 seconds apart.
+  to the configured cap, 360 seconds apart.
 - Copilot findings → fix them and return to CONVERGE on the new HEAD.
 - Copilot clean or approved → move to the convergence check.
-- Copilot down or out of quota (an out-of-usage notice, or no review after three
-  polls) → log a notice and move to the convergence check with the Copilot gate
+- Copilot down or out of quota (an out-of-usage notice, or no review after the
+  configured cap) → log a notice and move to the convergence check with the Copilot gate
   bypassed.
 
 **Convergence check**:

package/skills/autoconverge/reference/stop-conditions.md

@@ -47,7 +47,7 @@ skill still runs teardown (revoke permissions, final report).
   Bugbot gate is bypassed.
 - **Copilot down or out of quota** — when Copilot posts an out-of-usage notice on
   the current HEAD (the user who requested the review reached their quota limit)
-  rather than a code review, or surfaces no review at all after three polls, the
+  rather than a code review, or surfaces no review at all after the configured cap, the
   Copilot gate returns `down: true`. The run logs a notice, runs the convergence
   check with `--copilot-down` (the Copilot review gate and the
   pending-requested-reviews gate bypassed), and marks the PR ready. `copilotNote`

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

@@ -385,8 +385,8 @@ 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,

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,229 @@ 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,
+    /return wasStandardsHardeningPrOpened/,
+    'expected the skip path to return the cached hardening outcome',
+  );
+});
+
+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);
+}
+
+function loadStandardsFollowUpRuntime(recordedCalls, standardsEditResult) {
+  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" +
+    '}\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('spawnStandardsFollowUp')}\n` +
+    `${extractCallableSource('resolveStandardsThreadsForBatch')}\n` +
+    `${extractCallableSource('openStandardsFollowUpOnce')}\n` +
+    'return {\n' +
+    '  openStandardsFollowUpOnce,\n' +
+    '  guards: () => ({ hasStandardsFollowUpFiled, wasStandardsHardeningPrOpened, standardsFollowUpIssueUrl }),\n' +
+    '};';
+  return new Function('recordedCalls', 'standardsEditResult', runtimeSource)(
+    recordedCalls,
+    standardsEditResult,
+  );
+}
+
+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, 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(
+    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 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',
+  );
+});
+