claude-dev-env 1.74.0 → 1.76.0

package/skills/autoconverge/workflow/convergence_summary.py

@@ -83,7 +83,7 @@ def build_summary_prompt(
         copilot_note: Outage note when the Copilot gate was bypassed, else None.
 
     Returns:
-        The full agent prompt instructing a StructuredOutput convergence summary.
+        The full agent prompt instructing a plain-JSON convergence summary.
     """
     pr_url = GITHUB_PR_URL_TEMPLATE.format(owner=owner, repo=repo, number=pr_number)
     pr_coordinates = SUMMARY_PR_COORDINATES_TEMPLATE.format(

package/skills/autoconverge/workflow/render_report.py

@@ -17,7 +17,6 @@ from autoconverge_report_constants.render_report_constants import (
     DEFAULT_FINDING_CATEGORY,
     DEFAULT_FINDING_SEVERITY,
     DEFAULT_ISSUE_ICON,
-    GITHUB_PR_URL_TEMPLATE,
     HTML_DOCTYPE,
     HTML_HEAD_TEMPLATE,
     HTML_STYLE_BLOCK,
@@ -91,12 +90,11 @@ class FixRecord:
 
 @dataclass(frozen=True)
 class PrMetadata:
-    """Owner, repo, number, and pre-built URL for the PR being reported on."""
+    """Owner, repo, number, final sha, and round count for the PR being reported on."""
 
     owner: str
     repo: str
     number: int
-    url: str
     final_sha: str
     round_count: int
 
@@ -888,7 +886,7 @@ def render_report_html(
 
     Args:
         run_data: Aggregated metrics from the workflow journal and transcripts.
-        pr_metadata: Owner, repo, number, URL, final sha, and round count for the PR.
+        pr_metadata: Owner, repo, number, final sha, and round count for the PR.
         generated_date: ISO date string derived from the journal timestamp.
 
     Returns:
@@ -1004,13 +1002,11 @@ def main(out_stream: TextIO = sys.stdout, err_stream: TextIO = sys.stderr) -> in
         return 1
 
     owner, repo, pr_number = parsed_pr
-    pr_url = GITHUB_PR_URL_TEMPLATE.format(owner=owner, repo=repo, number=pr_number)
 
     pr_metadata = PrMetadata(
         owner=owner,
         repo=repo,
         number=pr_number,
-        url=pr_url,
         final_sha=parsed_args.final_sha,
         round_count=parsed_args.rounds,
     )

package/skills/autoconverge/workflow/test_convergence_summary.py

@@ -47,6 +47,23 @@ def test_prompt_carries_pr_coordinates_and_round_count() -> None:
     assert "gh api repos/jl-cmd/claude-code-config/pulls/581" in prompt
 
 
+def test_prompt_instructs_plain_json_object_not_structured_output() -> None:
+    """Should instruct a plain JSON object answer and never name the StructuredOutput tool."""
+    prompt = convergence_summary.build_summary_prompt(
+        owner="jl-cmd",
+        repo="claude-code-config",
+        pr_number=581,
+        round_count=39,
+        findings=SAMPLE_FINDINGS,
+        fix_summaries=[],
+        standards_note=None,
+        copilot_note=None,
+    )
+
+    assert "StructuredOutput" not in prompt
+    assert "Return strictly a JSON object with keys" in prompt
+
+
 def test_prompt_numbers_every_finding_with_severity_and_location() -> None:
     """Should list each aggregated finding numbered with severity, file, and line."""
     prompt = convergence_summary.build_summary_prompt(

package/skills/autoconverge/workflow/test_render_report.py

@@ -448,6 +448,7 @@ def test_cli_injects_summary_from_file_bypassing_transcripts(tmp_path: Path) ->
     assert "An injected class the transcript never carried" in html_content
     assert 'class="pf-grid"' in html_content
     assert f"Raw findings ({EXPECTED_TOTAL_FINDINGS})" in html_content
+    assert "https://github.com/example-owner/example-repo/pull/211" not in html_content
 
 
 def test_html_contains_no_hedging_words(tmp_path: Path) -> None:

package/skills/bugteam/scripts/bugteam_code_rules_gate.py

@@ -23,6 +23,11 @@ from bugteam_scripts_constants.bugteam_code_rules_gate_constants import (
     BANNED_NOUN_DEFINITION_LINE_GROUP_INDEX,
     BANNED_NOUN_SPAN_GROUP_INDEX,
     BANNED_NOUN_VIOLATION_PATTERN,
+    INLINE_DUPLICATE_BODY_ENCLOSING_LINE_GROUP_INDEX,
+    INLINE_DUPLICATE_BODY_ENCLOSING_SPAN_GROUP_INDEX,
+    INLINE_DUPLICATE_BODY_HELPER_LINE_GROUP_INDEX,
+    INLINE_DUPLICATE_BODY_HELPER_SPAN_GROUP_INDEX,
+    INLINE_DUPLICATE_BODY_VIOLATION_PATTERN,
     HUNK_HEADER_RAW_PATTERN,
     ISOLATION_DEFINITION_LINE_GROUP_INDEX,
     ISOLATION_SPAN_GROUP_INDEX,
@@ -958,6 +963,43 @@ def banned_noun_span_range(violation_text: str) -> range | None:
     return range(definition_line, definition_line + line_span)
 
 
+def inline_duplicate_body_span_lines(violation_text: str) -> frozenset[int] | None:
+    """Return the union of both spans of a same-file inline-duplicate issue, or None.
+
+    The same-file inline-duplicate message names two functions that share a body —
+    the helper and the enclosing function carrying the inline copy — and the live
+    Write/Edit hook scopes the violation by the UNION of both spans, blocking when
+    an edit touches either function. So the message carries both spans: ``(inline
+    duplicate body spans: helper at line H spanning P lines, enclosing at line E
+    spanning Q lines)``. The two spans can be disjoint (an unrelated function may
+    sit between the helper and its inline copy), so this returns the union as a
+    line-number set rather than a single contiguous range — a range covering the
+    gap would wrongly block an edit confined to that intervening function, which
+    the PreToolUse path leaves unflagged.
+
+    Args:
+        violation_text: A single violation string emitted by the enforcer.
+
+    Returns:
+        The frozenset of every line in the helper span and the enclosing span, or
+        None when the text is not a same-file inline-duplicate violation.
+    """
+    span_match = INLINE_DUPLICATE_BODY_VIOLATION_PATTERN.search(violation_text)
+    if span_match is None:
+        return None
+    helper_line = int(span_match.group(INLINE_DUPLICATE_BODY_HELPER_LINE_GROUP_INDEX))
+    helper_span = int(span_match.group(INLINE_DUPLICATE_BODY_HELPER_SPAN_GROUP_INDEX))
+    enclosing_line = int(
+        span_match.group(INLINE_DUPLICATE_BODY_ENCLOSING_LINE_GROUP_INDEX)
+    )
+    enclosing_span = int(
+        span_match.group(INLINE_DUPLICATE_BODY_ENCLOSING_SPAN_GROUP_INDEX)
+    )
+    helper_lines = range(helper_line, helper_line + helper_span)
+    enclosing_lines = range(enclosing_line, enclosing_line + enclosing_span)
+    return frozenset(helper_lines) | frozenset(enclosing_lines)
+
+
 def _all_span_range_extractors() -> tuple[Callable[[str], range | None], ...]:
     return (
         function_length_span_range,
@@ -1003,10 +1045,15 @@ def split_violations_by_scope(
 
     Returns:
         Tuple ``(blocking, advisory)``. When *all_added_line_numbers* is
-        None, every issue is blocking. Every diff-scoped violation
-        (function-length, HOME/TMP isolation, banned-noun) carries an
-        enclosing-unit span fragment that ``enclosing_span_range`` reconstructs
-        through one shared extractor registry; such a violation is blocking
+        None, every issue is blocking. A same-file inline-duplicate violation
+        carries both the helper span and the enclosing span;
+        ``inline_duplicate_body_span_lines`` reconstructs their union as a
+        line-number set, and the violation is blocking when an added line falls
+        in either span — matching the live Write/Edit hook's union scoping. Every
+        other diff-scoped violation (function-length, HOME/TMP isolation,
+        banned-noun) carries one enclosing-unit span fragment that
+        ``enclosing_span_range`` reconstructs through one shared extractor
+        registry; such a violation is blocking
         when its declared span intersects the added lines (the unit grew or its
         signature changed in this diff) and advisory otherwise (a pre-existing
         untouched unit). Every other issue is blocking when its ``Line N:``
@@ -1017,6 +1064,13 @@ def split_violations_by_scope(
     blocking: list[str] = []
     advisory: list[str] = []
     for each_issue in all_issues:
+        inline_duplicate_lines = inline_duplicate_body_span_lines(each_issue)
+        if inline_duplicate_lines is not None:
+            if inline_duplicate_lines & all_added_line_numbers:
+                blocking.append(each_issue)
+            else:
+                advisory.append(each_issue)
+            continue
         span_range = enclosing_span_range(each_issue)
         if span_range is not None:
             if any(each_line in all_added_line_numbers for each_line in span_range):

package/skills/bugteam/scripts/bugteam_scripts_constants/bugteam_code_rules_gate_constants.py

@@ -31,6 +31,15 @@ BANNED_NOUN_VIOLATION_PATTERN: re.Pattern[str] = re.compile(
 BANNED_NOUN_DEFINITION_LINE_GROUP_INDEX: int = 1
 BANNED_NOUN_SPAN_GROUP_INDEX: int = 2
 
+INLINE_DUPLICATE_BODY_VIOLATION_PATTERN: re.Pattern[str] = re.compile(
+    r"\(inline duplicate body spans: helper at line (\d+) spanning (\d+) lines, "
+    r"enclosing at line (\d+) spanning (\d+) lines\)"
+)
+INLINE_DUPLICATE_BODY_HELPER_LINE_GROUP_INDEX: int = 1
+INLINE_DUPLICATE_BODY_HELPER_SPAN_GROUP_INDEX: int = 2
+INLINE_DUPLICATE_BODY_ENCLOSING_LINE_GROUP_INDEX: int = 3
+INLINE_DUPLICATE_BODY_ENCLOSING_SPAN_GROUP_INDEX: int = 4
+
 ALL_CODE_FILE_EXTENSIONS: frozenset[str] = frozenset(
     {".py", ".js", ".ts", ".tsx", ".jsx"}
 )

package/skills/bugteam/scripts/test_bugteam_code_rules_gate.py

@@ -1022,3 +1022,45 @@ def test_main_staged_mode_passes_on_staged_deletion_of_clean_file(
         "a staged deletion has no staged blob; the gate must skip it cleanly "
         "rather than fail closed as if the file were unreadable"
     )
+
+
+_INLINE_DUPLICATE_MESSAGE = (
+    "Function '_wait_for_render' duplicates an inline block in '_navigate_then_wait'"
+    " — this function body is also present inline (Reuse before create / DRY) "
+    "(inline duplicate body spans: helper at line 4 spanning 10 lines, "
+    "enclosing at line 16 spanning 11 lines)"
+)
+
+
+def test_inline_duplicate_body_span_lines_unions_helper_and_enclosing_spans() -> None:
+    """The same-file inline-duplicate message carries both spans, and the gate
+    recovers their union as a line-number set so a touch of either function blocks —
+    mirroring the live Write/Edit hook's union scoping."""
+    span_lines = gate_module.inline_duplicate_body_span_lines(_INLINE_DUPLICATE_MESSAGE)
+    assert span_lines == frozenset(range(4, 14)) | frozenset(range(16, 27))
+
+
+def test_inline_duplicate_blocks_when_only_enclosing_copy_added() -> None:
+    """An added line in the enclosing span alone blocks, because the live hook scopes
+    by the union of both spans and blocks the same edit — the common shape where a
+    block is copied INTO a growing enclosing function, leaving the helper untouched."""
+    added_line_in_enclosing_only = 18
+    blocking, advisory = gate_module.split_violations_by_scope(
+        [_INLINE_DUPLICATE_MESSAGE],
+        all_added_line_numbers={added_line_in_enclosing_only},
+    )
+    assert blocking == [_INLINE_DUPLICATE_MESSAGE]
+    assert advisory == []
+
+
+def test_inline_duplicate_advises_when_gap_line_added() -> None:
+    """An edit confined to the gap between the helper span (4-13) and the enclosing
+    span (16-26) must not block, matching the live hook. The union set keeps the gap
+    out of scope where a single contiguous range would wrongly block it."""
+    gap_line_between_spans = 14
+    blocking, advisory = gate_module.split_violations_by_scope(
+        [_INLINE_DUPLICATE_MESSAGE],
+        all_added_line_numbers={gap_line_between_spans},
+    )
+    assert advisory == [_INLINE_DUPLICATE_MESSAGE]
+    assert blocking == []