claude-dev-env 2.33.0 → 2.33.2

package/_shared/pr-loop/scripts/code_rules_gate.py

@@ -251,6 +251,16 @@ def _report_empty_file_set() -> int:
     return EMPTY_FILE_SET_EXIT_CODE
 
 
+def _report_empty_diff() -> int:
+    """Print inspected 0 and return 0 when git has no changed files.
+
+    HEAD equals the chosen base and nothing is untracked. That is a clean
+    tree, so the gate stays quiet.
+    """
+    sys.stderr.write(INSPECTED_COUNT_MESSAGE.format(inspected_count=0) + "\n")
+    return 0
+
+
 def _run_explicit_paths_mode(
     validate_content: enforcer_loading.ValidateContentCallable,
     arguments: argparse.Namespace,
@@ -327,7 +337,7 @@ def _run_diff_mode(
         + paths_from_git_untracked(repository_root)
     )
     if not all_candidate_paths:
-        return _report_empty_file_set()
+        return _report_empty_diff()
     file_paths = filter_paths_under_prefixes(
         all_candidate_paths, repository_root, arguments.only_under
     )

package/_shared/pr-loop/scripts/test_code_rules_gate.py

@@ -96,26 +96,23 @@ def temporary_git_repository(tmp_path: Path) -> Path:
     return repository_root
 
 
-def test_diff_mode_with_empty_file_set_exits_non_zero_and_says_so(
+def test_diff_mode_with_empty_file_set_exits_zero_and_says_so(
     temporary_git_repository: Path,
     monkeypatch: pytest.MonkeyPatch,
     capsys: pytest.CaptureFixture[str],
 ) -> None:
-    """HEAD == base and nothing untracked: the gate refuses to vouch for nothing.
+    """HEAD equals base and nothing is untracked, so there is no diff.
 
-    A diff that resolves zero candidate files means the gate inspected
-    nothing — a bad merge base or a wrong directory looks exactly like this.
-    Issue #62's contract: that run exits non-zero and says so, because a
-    silent pass over zero files is trusted like a real pass.
+    Report inspected 0 and exit 0. A bad merge base or a wrong directory
+    can also look empty, but a clean tree is the case this test covers.
     """
     monkeypatch.chdir(temporary_git_repository)
 
     exit_code = gate_module.main(["--base", "HEAD"])
 
     captured = capsys.readouterr()
-    assert exit_code != 0
+    assert exit_code == 0
     assert "inspected 0 file(s)" in captured.err
-    assert "empty" in captured.err.lower()
 
 
 def test_diff_mode_changes_outside_only_under_prefixes_exit_clean_and_report(

package/_shared/pr-loop/scripts/tests/test_code_rules_gate.py

@@ -2949,6 +2949,23 @@ def test_diff_mode_untracked_png_does_not_flood_stderr(
     assert "untracked_icon.png" not in captured.err
 
 
+def test_diff_mode_empty_diff_exits_zero(
+    temporary_git_repository: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    write_file(temporary_git_repository / "seed.txt", "seed\n")
+    commit_all_files(temporary_git_repository, "seed")
+    monkeypatch.chdir(temporary_git_repository)
+
+    exit_code = gate_module.main(["--base", "HEAD"])
+
+    captured = capsys.readouterr()
+    assert exit_code == 0
+    assert "inspected 0 file(s)" in captured.err
+    assert gate_module.EMPTY_FILE_SET_MESSAGE not in captured.err
+
+
 def test_diff_mode_image_only_surface_exits_zero_not_empty_file_set(
     temporary_git_repository: Path,
     monkeypatch: pytest.MonkeyPatch,

package/audit-rubrics/prompts/category-e-dead-code.md

@@ -20,7 +20,7 @@ Inline the artifact under this section using the section types defined in the ch
 **E1. New imports without references**
 - Walk every `import` line introduced or modified by the artifact. For each, locate at least one body reference in the same file (function call, attribute access, type annotation, decorator, default-argument expression).
 - Confirm `__all__` re-exports: if the file declares `__all__`, an import that appears only in `__all__` still counts as referenced; if no `__all__` is declared, the exemption is inert and must be stated as such.
-- Confirm `# noqa` markers: every `# noqa` on an import line must be justified by a specific lint code (e.g., `E402` for module-level imports following a `sys.path` mutation). State the justification.
+- Confirm changed `# noqa` directives are removed or resolved. Leave directives on untouched lines outside the change scope.
 - Confirm `TYPE_CHECKING` blocks: imports inside `if TYPE_CHECKING:` are referenced only by string-form annotations or runtime `typing.get_type_hints` consumers; verify at least one such consumer or mark the exemption inert.
 - Constants-only or re-export-only files (no imports of their own) — state explicitly that there is nothing to sweep.
 

package/docs/REACT_PATTERNS.md

@@ -104,7 +104,7 @@ components/
 
 - **Complete type annotations** - All props, state, and return types defined
 - **No `any` types** - Use generics, union types, or `unknown` with type guards
-- **No `@ts-ignore` or `@ts-expect-error`** without clear justification
+- **Resolve `@ts-ignore` and `@ts-expect-error`** instead of adding or justifying them
 - **Functional components only** - No class components (except error boundaries)
 - **Custom hooks for logic** - Separate business logic from UI
 - **Props interfaces** - Define explicit Props type for every component

package/hooks/blocking/code_rules_comments.py

@@ -8,7 +8,6 @@ import tokenize
 from collections import Counter
 from collections.abc import Iterator
 from pathlib import Path
-from typing import cast
 
 _blocking_directory = str(Path(__file__).resolve().parent)
 _hooks_directory = str(Path(__file__).resolve().parent.parent)
@@ -100,49 +99,41 @@ def check_comments_javascript(content: str) -> list[str]:
     return issues
 
 
-def extract_comment_texts(
+def _comment_occurrences(
     content: str, file_path: str, include_directive_comments: bool = False
-) -> tuple[set[str], set[str]]:
-    """Extract normalized comment text strings from content for comparison.
+) -> tuple[list[tuple[str, int, bool]], bool]:
+    """List comments as text, line number, and inline vs standalone.
 
-    Returns:
-        Tuple of (inline_comments, standalone_comments).
-        Inline comments appear after code on the same line.
-        Standalone comments are lines where the entire line is a comment.
+    Python tokenize failure returns an empty list and False. JavaScript
+    returns the shared scanner's list and True. Other extensions return
+    an empty list and True.
     """
     extension = get_file_extension(file_path)
-    inline_comments: set[str] = set()
-    standalone_comments: set[str] = set()
-    if not content:
-        return inline_comments, standalone_comments
-
     if extension in ALL_PYTHON_EXTENSIONS:
-        inline_comments, standalone_comments, _ = _extract_python_comment_sets(
+        return _python_comment_occurrences(content, include_directive_comments)
+    if extension in ALL_JAVASCRIPT_EXTENSIONS:
+        all_occurrences = extract_javascript_comment_occurrences(
             content, include_directive_comments
         )
-        return inline_comments, standalone_comments
+        return [tuple(each_occurrence) for each_occurrence in all_occurrences], True
+    return [], True
 
-    if extension in ALL_JAVASCRIPT_EXTENSIONS:
-        all_occurrences: list[tuple[str, int, bool]] = cast(
-            list[tuple[str, int, bool]],
-            extract_javascript_comment_occurrences(content, include_directive_comments),
-        )
-        inline_comments = {
-            each_text
-            for each_text, _each_line_number, is_inline in all_occurrences
-            if is_inline
-        }
-        standalone_comments = {
-            each_text
-            for each_text, _each_line_number, is_inline in all_occurrences
-            if not is_inline
-        }
 
-    return inline_comments, standalone_comments
+def extract_comment_texts(
+    content: str, file_path: str, include_directive_comments: bool = False
+) -> tuple[set[str], set[str]]:
+    """Extract normalized comment text strings from content for comparison."""
+    all_occurrences, _ = _comment_occurrences(
+        content, file_path, include_directive_comments
+    )
+    return (
+        {each_text for each_text, _each_line, each_is_inline in all_occurrences if each_is_inline},
+        {each_text for each_text, _each_line, each_is_inline in all_occurrences if not each_is_inline},
+    )
 
 
 def _python_comment_occurrences(
-    content: str,
+    content: str, include_directive_comments: bool = True
 ) -> tuple[list[tuple[str, int, bool]], bool]:
     """Return Python comments with exact lines and a tokenize status."""
     source_lines = content.split("\n")
@@ -156,6 +147,8 @@ def _python_comment_occurrences(
             continue
         if each_token.string.startswith("#!") and each_token.start == (1, 0):
             continue
+        if not include_directive_comments and _is_exempt_python_comment(each_token):
+            continue
         source_line = source_lines[each_token.start[0] - 1]
         is_inline = bool(source_line[: each_token.start[1]].strip())
         all_occurrences.append(
@@ -182,8 +175,8 @@ def check_comment_changes(old_content: str, new_content: str, file_path: str) ->
 
     extension = get_file_extension(file_path)
     if extension in ALL_PYTHON_EXTENSIONS:
-        old_occurrences, old_tokenize_ok = _python_comment_occurrences(old_content)
-        new_occurrences, new_tokenize_ok = _python_comment_occurrences(new_content)
+        old_occurrences, old_tokenize_ok = _python_comment_occurrences(old_content, True)
+        new_occurrences, new_tokenize_ok = _python_comment_occurrences(new_content, True)
         if not (old_tokenize_ok and new_tokenize_ok):
             return issues
     else:
@@ -223,25 +216,70 @@ def _changed_line_numbers(old_content: str, new_content: str) -> set[int]:
     }
 
 
+def _deleted_line_numbers(old_content: str, new_content: str) -> set[int]:
+    """Old-file line numbers that a delete or replace covers."""
+    matcher = difflib.SequenceMatcher(
+        None, old_content.splitlines(), new_content.splitlines(), autojunk=False
+    )
+    return {
+        each_line_number
+        for each_tag, each_old_start, each_old_end, _, _ in matcher.get_opcodes()
+        if each_tag in {"delete", "replace"}
+        for each_line_number in range(each_old_start + 1, each_old_end + 1)
+    }
+
+
+def _comment_lines_by_key(
+    all_occurrences: list[tuple[str, int, bool]],
+) -> dict[tuple[str, bool], list[int]]:
+    """Group line numbers by comment text and inline vs standalone."""
+    lines_by_key: dict[tuple[str, bool], list[int]] = {}
+    for each_text, each_line_number, each_is_inline in all_occurrences:
+        lines_by_key.setdefault((each_text, each_is_inline), []).append(each_line_number)
+    return lines_by_key
+
+
+def _is_attached_to_changed_code(
+    each_line_number: int,
+    each_is_inline: bool,
+    old_line_number: int,
+    all_changed_lines: set[int],
+    all_deleted_lines: set[int],
+) -> bool:
+    """Check if this leftover comment still sits on a changed line.
+
+    Inline comments count when their own line changed. Standalone comments
+    count when the next line changed, or when the next line in the old file
+    was deleted.
+    """
+    if each_is_inline:
+        return each_line_number in all_changed_lines
+    return each_line_number + 1 in all_changed_lines or old_line_number + 1 in all_deleted_lines
+
+
 def _retained_comment_issues(
     old_content: str, new_content: str, file_path: str
 ) -> list[str]:
-    old_inline, old_standalone = extract_comment_texts(old_content, file_path, True)
-    new_inline, new_standalone = extract_comment_texts(new_content, file_path, True)
-    shared_inline = set(Counter(old_inline) & Counter(new_inline))
-    shared_standalone = old_standalone & new_standalone
-    if not shared_inline and not shared_standalone:
+    old_occurrences, old_tokenize_ok = _comment_occurrences(old_content, file_path, True)
+    new_occurrences, new_tokenize_ok = _comment_occurrences(new_content, file_path, True)
+    if not (old_tokenize_ok and new_tokenize_ok):
         return []
-    changed_lines = _changed_line_numbers(old_content, new_content)
-    new_lines = new_content.splitlines()
+    all_changed_lines = _changed_line_numbers(old_content, new_content)
+    all_deleted_lines = _deleted_line_numbers(old_content, new_content)
+    old_line_by_key = _comment_lines_by_key(old_occurrences)
     issues: list[str] = []
-    for each_line_number in sorted(changed_lines):
-        inline_comment = next((each_comment for each_comment in shared_inline if each_comment in new_lines[each_line_number - 1]), None)
-        if inline_comment is not None:
-            issues.append(f"Line {each_line_number}: Inline comment retained on changed code: {inline_comment} - remove the comment")
-        preceding_line_number = each_line_number - 1
-        if preceding_line_number > 0 and new_lines[preceding_line_number - 1].strip() in shared_standalone:
-            issues.append(f"Line {each_line_number}: Standalone comment retained on changed code at line {preceding_line_number}: {new_lines[preceding_line_number - 1].strip()} - remove the comment")
+    for each_text, each_line_number, each_is_inline in new_occurrences:
+        matching_old_lines = old_line_by_key.get((each_text, each_is_inline), [])
+        if not matching_old_lines:
+            continue
+        old_line_number = matching_old_lines.pop(0)
+        if not _is_attached_to_changed_code(each_line_number, each_is_inline, old_line_number, all_changed_lines, all_deleted_lines):
+            continue
+        comment_kind = "Inline" if each_is_inline else "Standalone"
+        issues.append(
+            f"Line {each_line_number}: {comment_kind} comment still on the changed lines: "
+            f"{each_text} - remove the comment"
+        )
         if len(issues) >= MAX_COMMENT_ISSUES:
             break
     return issues[:MAX_COMMENT_ISSUES]
@@ -263,12 +301,11 @@ def _python_tokens(source: str) -> Iterator[tokenize.TokenInfo]:
 def _comment_tokens(source: str) -> Iterator[tokenize.TokenInfo]:
     """Yield COMMENT tokens from *source* one at a time.
 
-    Streams from ``_python_tokens`` so consumers that early-exit (e.g.
-    ``check_comments_python`` caps at ``MAX_COMMENT_ISSUES``) avoid
-    materializing the entire token list. Silently stops on tokenize
-    failure so callers receive only valid comment tokens — no
-    indeterminate signal is exposed at this layer because the consumers
-    that need it (``_extract_python_comment_sets``) bypass this helper.
+    Streams from ``_python_tokens`` so consumers that early-exit, such as
+    ``check_comments_python`` capping at ``MAX_COMMENT_ISSUES``, avoid
+    materializing the entire token list. Tokenize failure stops the
+    stream with no extra flag. Callers that need to know tokenize failed
+    use ``_python_comment_occurrences``.
     """
     try:
         for each_token in _python_tokens(source):
@@ -356,41 +393,3 @@ def _starts_with_bounded_token_anchored_directive(directive_body: str) -> bool:
         if next_character in ALL_TOKEN_ANCHORED_DIRECTIVE_BOUNDARY_CHARACTERS:
             return True
     return False
-
-
-def _extract_python_comment_sets(
-    content: str, include_directive_comments: bool = False
-) -> tuple[set[str], set[str], bool]:
-    """Return (inline_comments, standalone_comments, tokenize_succeeded).
-
-    Streams *content* once via ``_python_tokens``. A tokenize failure
-    (mid-edit fragment, syntax error) returns empty sets and ``False``
-    so callers can treat the situation as indeterminate rather than as
-    "no comments present". Inline vs standalone is decided by inspecting
-    the column offset of each ``COMMENT`` token against its source
-    line: an all-whitespace prefix means standalone.
-    """
-    inline_comments: set[str] = set()
-    standalone_comments: set[str] = set()
-    lines = content.split("\n")
-    try:
-        for each_token in _python_tokens(content):
-            if each_token.type != tokenize.COMMENT:
-                continue
-            is_shebang = each_token.string.startswith("#!") and each_token.start == (1, 0)
-            if is_shebang or (
-                not include_directive_comments and _is_exempt_python_comment(each_token)
-            ):
-                continue
-            line_number = each_token.start[0]
-            column_offset = each_token.start[1]
-            source_line = lines[line_number - 1] if line_number - 1 < len(lines) else ""
-            text_before_comment = source_line[:column_offset]
-            normalized_comment_text = each_token.string.strip()
-            if not text_before_comment.strip():
-                standalone_comments.add(normalized_comment_text)
-            else:
-                inline_comments.add(normalized_comment_text)
-    except ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS:
-        return set(), set(), False
-    return inline_comments, standalone_comments, True

package/hooks/blocking/code_rules_enforcer.py

@@ -236,7 +236,7 @@ class _ValidationContext(NamedTuple):
     defer_scope_to_caller: bool
     sibling_directory: Path | None
     phase: str
-    include_comment_policy: bool = True
+    include_comment_policy: bool = False
 
 
 def _validated_phase(phase: str) -> str:
@@ -653,7 +653,7 @@ def validate_content_for_phase(
     sibling_directory: Path | None = None,
     *,
     phase: str,
-    include_comment_policy: bool = True,
+    include_comment_policy: bool = False,
 ) -> list[str]:
     """Run all applicable validators on content for one named validation phase."""
     validated_phase = _validated_phase(phase)
@@ -703,7 +703,7 @@ def validate_content_for_full_gate(
     defer_scope_to_caller: bool = False,
     sibling_directory: Path | None = None,
     *,
-    include_comment_policy: bool = True,
+    include_comment_policy: bool = False,
 ) -> list[str]:
     """Run the full-gate phase, including the six checks that read sibling files."""
     return validate_content_for_phase(

package/hooks/blocking/javascript_comment_scanner.py

@@ -1,14 +1,11 @@
 """Extract JavaScript comments without matching comment-like strings."""
 
-import io
 import re
-import tokenize
 from typing import NamedTuple
 
 from hooks_constants.code_rules_enforcer_constants import (
     ALL_JAVASCRIPT_EXEMPT_COMMENT_PREFIXES,
     ALL_JAVASCRIPT_EXEMPT_INLINE_COMMENT_PREFIXES,
-    ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS,
 )
 
 
@@ -72,28 +69,3 @@ def extract_javascript_comment_occurrences(
             JavaScriptCommentOccurrence(comment_text, line_number, is_inline)
         )
     return all_occurrences
-
-
-def extract_python_comment_occurrences(
-    content: str,
-) -> tuple[list[JavaScriptCommentOccurrence], bool]:
-    """Return Python comments with exact lines and a tokenize status."""
-    source_lines = content.split("\n")
-    try:
-        all_tokens = list(tokenize.generate_tokens(io.StringIO(content).readline))
-    except ALL_PYTHON_TOKENIZE_FAILURE_EXCEPTIONS:
-        return [], False
-    all_occurrences: list[JavaScriptCommentOccurrence] = []
-    for each_token in all_tokens:
-        if each_token.type != tokenize.COMMENT:
-            continue
-        if each_token.string.startswith("#!") and each_token.start == (1, 0):
-            continue
-        source_line = source_lines[each_token.start[0] - 1]
-        is_inline = bool(source_line[: each_token.start[1]].strip())
-        all_occurrences.append(
-            JavaScriptCommentOccurrence(
-                each_token.string.strip(), each_token.start[0], is_inline
-            )
-        )
-    return all_occurrences, True

package/hooks/blocking/test_code_rules_enforcer_comment_string_awareness.py

@@ -208,7 +208,12 @@ def test_full_gate_blocks_python_inline_comment_in_test_file() -> None:
         sibling_directory=None,
         phase="edit",
     )
-    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(
+        context.content,
+        context.file_path,
+        context.old_content,
+        include_comment_policy=True,
+    )
     assert any("Inline comment added" in each_issue for each_issue in issues)
 
 
@@ -223,7 +228,7 @@ def test_full_gate_blocks_javascript_inline_comment_in_test_file() -> None:
         sibling_directory=None,
         phase="edit",
     )
-    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content, include_comment_policy=True)
     assert any("Inline comment added" in each_issue for each_issue in issues)
 
 
@@ -238,7 +243,7 @@ def test_full_gate_blocks_javascript_inline_block_comment_in_test_file() -> None
         sibling_directory=None,
         phase="edit",
     )
-    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content, include_comment_policy=True)
     assert any("Inline comment added" in each_issue for each_issue in issues)
 
 
@@ -253,7 +258,7 @@ def test_full_gate_blocks_javascript_directive_comment_in_test_file() -> None:
         sibling_directory=None,
         phase="edit",
     )
-    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content, include_comment_policy=True)
     assert any("Inline comment added" in each_issue for each_issue in issues)
 
 
@@ -268,7 +273,7 @@ def test_full_gate_blocks_python_directive_comment_in_test_file() -> None:
         sibling_directory=None,
         phase="edit",
     )
-    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content, include_comment_policy=True)
     assert any("comment added" in each_issue.lower() for each_issue in issues)
 
 
@@ -286,7 +291,7 @@ def test_full_gate_blocks_changed_marker_comments_in_test_file(each_marker: str)
         sibling_directory=None,
         phase="edit",
     )
-    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content, include_comment_policy=True)
     assert any("comment added" in each_issue.lower() for each_issue in issues)
 
 
@@ -301,7 +306,7 @@ def test_full_gate_blocks_standalone_comment_in_test_file() -> None:
         sibling_directory=None,
         phase="edit",
     )
-    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content, include_comment_policy=True)
     assert any("Standalone comment added" in each_issue for each_issue in issues)
 
 
@@ -316,7 +321,7 @@ def test_full_gate_preserves_shebang_and_docstring_in_test_file() -> None:
         sibling_directory=None,
         phase="edit",
     )
-    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content, include_comment_policy=True)
     assert not any("comment added" in each_issue.lower() for each_issue in issues)
 
 
@@ -333,7 +338,7 @@ def test_full_gate_allows_existing_comment_removal_without_advisory(
         sibling_directory=None,
         phase="edit",
     )
-    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content, include_comment_policy=True)
     assert not any("Existing comment removed" in each_issue for each_issue in issues)
     assert capsys.readouterr().err == ""
 
@@ -373,11 +378,11 @@ def test_check_comment_changes_blocks_retained_comments_on_changed_code(
     file_path: str, old_content: str, new_content: str
 ) -> None:
     issues = code_rules_enforcer.check_comment_changes(old_content, new_content, file_path)
-    assert any("retained on changed code" in each_issue for each_issue in issues)
+    assert any("still on the changed lines" in each_issue for each_issue in issues)
 
 
 def test_check_comment_changes_accepts_distant_untouched_comment() -> None:
     old_content = "# TODO #999: distant note\n\ntotal = 1\n"
     new_content = "# TODO #999: distant note\n\ntotal = 2\n"
     issues = code_rules_enforcer.check_comment_changes(old_content, new_content, "totals.py")
-    assert not any("retained on changed code" in each_issue for each_issue in issues)
+    assert not any("still on the changed lines" in each_issue for each_issue in issues)

package/hooks/blocking/test_code_rules_enforcer_javascript_comments.py

@@ -13,9 +13,9 @@ if _BLOCKING_DIRECTORY not in sys.path:
 if _HOOKS_DIRECTORY not in sys.path:
     sys.path.insert(0, _HOOKS_DIRECTORY)
 
-check_comment_changes = importlib.import_module(
-    "code_rules_comments"
-).check_comment_changes
+comment_rules_module = importlib.import_module("code_rules_comments")
+check_comment_changes = comment_rules_module.check_comment_changes
+code_rules_enforcer_module = importlib.import_module("code_rules_enforcer")
 
 
 def test_check_comment_changes_ignores_javascript_url_string() -> None:
@@ -42,3 +42,33 @@ def test_check_comment_changes_reports_duplicate_identical_comment_occurrence()
     )
 
     assert any("Line 2: Inline comment added" in each_issue for each_issue in issues)
+
+
+def test_check_comment_changes_does_not_match_comment_text_inside_changed_string() -> None:
+    issues = check_comment_changes(
+        "# note\n\ntotal = 1\n",
+        '"# note"\ntotal = 2\n',
+        "totals.py",
+    )
+
+    assert not any("still on the changed lines" in each_issue for each_issue in issues)
+
+
+def test_check_comment_changes_flags_comment_attached_to_deleted_code() -> None:
+    issues = check_comment_changes(
+        "# attached\nold_total = 1\nnew_total = 2\n",
+        "# attached\nnew_total = 2\n",
+        "totals.py",
+    )
+
+    assert any("Standalone comment still on the changed lines" in each_issue for each_issue in issues)
+
+
+def test_full_gate_skips_comment_policy_by_default() -> None:
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(
+        "total = 1  # added\n",
+        "totals.py",
+        "total = 1\n",
+    )
+
+    assert not any("comment" in each_issue.lower() for each_issue in issues)

package/hooks/blocking/test_pre_tool_use_dispatcher.py

@@ -723,14 +723,12 @@ def test_dispatcher_edit_applies_both_groups() -> None:
     """
     all_edit_entries = _applicable_entries_for_tool(EDIT_TOOL_NAME)
     all_edit_script_paths = {each_entry.script_relative_path for each_entry in all_edit_entries}
-    assert "blocking/stale_comment_reference_blocker.py" in all_edit_script_paths, (
-        "stale_comment_reference_blocker belongs in the Edit applicable set"
-    )
+    assert "blocking/stale_comment_reference_blocker.py" not in all_edit_script_paths
     assert "advisory/refactor_guard.py" in all_edit_script_paths, (
         "refactor_guard is Edit-scoped and hosted, so it belongs in the Edit applicable set"
     )
-    assert len(all_edit_entries) == 21, (
-        f"expected 21 Edit entries, got {len(all_edit_entries)}"
+    assert len(all_edit_entries) == 20, (
+        f"expected 20 Edit entries, got {len(all_edit_entries)}"
     )
 
 

package/hooks/hooks_constants/pre_tool_use_dispatcher_constants.py

@@ -130,10 +130,6 @@ ALL_HOSTED_HOOK_ENTRIES: tuple[HostedHookEntry, ...] = (
         applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
         native_module_name=STATE_DESCRIPTION_BLOCKER_MODULE_NAME,
     ),
-    HostedHookEntry(
-        script_relative_path="blocking/stale_comment_reference_blocker.py",
-        applicable_tool_names=frozenset({EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME}),
-    ),
     HostedHookEntry(
         script_relative_path="blocking/subprocess_budget_completeness.py",
         applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,

package/hooks/hooks_constants/test_pre_tool_use_dispatcher_constants.py

@@ -165,7 +165,6 @@ _ALL_DEFERRED_LINT_SCRIPT_PATHS = (
     "blocking/duplicate_rmtree_helper_blocker.py",
     "validation/hook_format_validator.py",
     "blocking/hook_prose_detector_consistency.py",
-    "blocking/stale_comment_reference_blocker.py",
     "blocking/subprocess_budget_completeness.py",
     "blocking/windows_rmtree_blocker.py",
     "advisory/refactor_guard.py",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "2.33.0",
+    "version": "2.33.2",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/scripts/check.ps1

@@ -61,13 +61,22 @@ function Resolve-CommentPolicyBase {
         }
         throw "Comment-policy baseline '$ExplicitBase' does not resolve in the repository."
     }
-    foreach ($candidateBase in @('origin/main', 'HEAD^1')) {
+
+    $headCommit = & git -C $repositoryRoot rev-parse --verify --quiet 'HEAD^{commit}' 2>$null
+    $ciBases = @($env:GITHUB_BASE_SHA, $env:GITHUB_EVENT_BEFORE)
+    foreach ($candidateBase in @($ciBases + 'origin/main' + 'HEAD^1')) {
+        if (-not $candidateBase) {
+            continue
+        }
         $resolvedCandidateBase = & git -C $repositoryRoot rev-parse --verify --quiet "${candidateBase}^{commit}" 2>$null
         if ($LASTEXITCODE -eq 0 -and $resolvedCandidateBase) {
+            if ($candidateBase -eq 'origin/main' -and $resolvedCandidateBase.Trim() -eq $headCommit.Trim()) {
+                continue
+            }
             return $candidateBase
         }
     }
-    throw 'Comment-policy baseline does not resolve to origin/main or HEAD^1.'
+    throw 'Comment-policy baseline does not resolve to a CI base, origin/main, or HEAD^1.'
 }
 
 $commentPolicyBase = Resolve-CommentPolicyBase -ExplicitBase $CommentPolicyBase

package/scripts/tests/test_rules.py

@@ -187,3 +187,20 @@ def test_comment_policy_uses_changed_comment_names_and_type_directives() -> None
     assert "production and test code" in code_quality
     assert "comments tied to touched code are removed" in gate
     assert "comments tied to untouched code remain unchanged" in gate
+
+
+def test_comment_policy_removes_directive_justification_guidance() -> None:
+    react_patterns = (
+        _PACKAGE_ROOT / "docs" / "REACT_PATTERNS.md"
+    ).read_text(encoding="utf-8").lower()
+    category_e_prompt = (
+        _PACKAGE_ROOT
+        / "audit-rubrics"
+        / "prompts"
+        / "category-e-dead-code.md"
+    ).read_text(encoding="utf-8").lower()
+
+    assert "resolve `@ts-ignore` and `@ts-expect-error`" in react_patterns
+    assert "without clear justification" not in react_patterns
+    assert "changed `# noqa` directives are removed or resolved" in category_e_prompt
+    assert "every `# noqa` on an import line must be justified" not in category_e_prompt