claude-dev-env 2.31.1 → 2.33.0

package/hooks/blocking/tdd_enforcer_parts/tests/test_content_hash_store.py

@@ -1,4 +1,11 @@
-"""Behavioral tests for the content_hash_store parts module."""
+"""Behavioral tests for the content_hash_store parts module.
+
+Covers the recorded-test-failure evidence path: a genuinely failing test
+command outranks a stale mtime, never satisfies a candidate it did not
+name, expires after the freshness window, and applies only while the
+candidate's content still matches what actually failed. Also covers the
+private decision helpers by name, so a rename keeps its own paired test.
+"""
 
 import json
 import os
@@ -141,3 +148,109 @@ def test_denies_when_no_candidate_file_exists(tmp_path: Path) -> None:
     )
 
     assert is_allowed is False
+
+
+def test_recorded_failure_allows_a_stale_candidate(tmp_path: Path) -> None:
+    """RED-evidence: a genuinely recorded failure outranks a stale mtime."""
+    candidate = _write_fresh_test_file(tmp_path)
+    stale_timestamp = time.time() - 700
+    os.utime(candidate, (stale_timestamp, stale_timestamp))
+    session_id, repository_root = "session-failure-1", str(tmp_path)
+    content_hash_store.record_test_command_failure(
+        [candidate], "pytest test_orders.py", 1, session_id, repository_root
+    )
+
+    is_allowed = content_hash_store.has_recorded_or_fresh_test(
+        [candidate], session_id, repository_root, 600
+    )
+
+    assert is_allowed is True
+
+
+def test_recorded_failure_stores_the_command_and_exit_status(tmp_path: Path) -> None:
+    candidate = _write_fresh_test_file(tmp_path)
+    session_id, repository_root = "session-failure-2", str(tmp_path)
+
+    content_hash_store.record_test_command_failure(
+        [candidate], "pytest test_orders.py -q", 1, session_id, repository_root
+    )
+
+    state_file = content_hash_store._state_file_path(session_id, repository_root)
+    state = json.loads(state_file.read_text())
+    entry = state[content_hash_store._state_key_for(candidate)]
+    assert entry[content_hash_store.STORED_FAILURE_COMMAND_KEY] == "pytest test_orders.py -q"
+    assert entry[content_hash_store.STORED_FAILURE_EXIT_STATUS_KEY] == 1
+
+
+def test_recorded_failure_does_not_satisfy_a_different_candidate(tmp_path: Path) -> None:
+    """Anti-bypass: a failure recorded for one test file must not unlock a sibling."""
+    failing_candidate = tmp_path / "test_bar.py"
+    failing_candidate.write_text("def test_bar(): pass\n")
+    unrelated_candidate = tmp_path / "test_foo.py"
+    unrelated_candidate.write_text("def test_foo(): pass\n")
+    stale_timestamp = time.time() - 700
+    os.utime(unrelated_candidate, (stale_timestamp, stale_timestamp))
+    session_id, repository_root = "session-failure-3", str(tmp_path)
+    content_hash_store.record_test_command_failure(
+        [failing_candidate], "pytest test_bar.py", 1, session_id, repository_root
+    )
+
+    is_allowed = content_hash_store.has_recorded_or_fresh_test(
+        [unrelated_candidate], session_id, repository_root, 600
+    )
+
+    assert is_allowed is False
+
+
+def test_recorded_failure_expires_after_the_freshness_window(tmp_path: Path) -> None:
+    candidate = _write_fresh_test_file(tmp_path)
+    stale_timestamp = time.time() - 700
+    os.utime(candidate, (stale_timestamp, stale_timestamp))
+    session_id, repository_root = "session-failure-4", str(tmp_path)
+    state_file = content_hash_store._state_file_path(session_id, repository_root)
+    candidate_key = content_hash_store._state_key_for(candidate)
+    stale_failed_at = time.time() - 700
+    state_file.write_text(
+        json.dumps(
+            {
+                candidate_key: {
+                    content_hash_store.STORED_FAILURE_HASH_KEY: content_hash_store._content_hash(
+                        candidate.read_text()
+                    ),
+                    content_hash_store.STORED_FAILED_AT_KEY: stale_failed_at,
+                }
+            }
+        )
+    )
+
+    is_allowed = content_hash_store.has_recorded_or_fresh_test(
+        [candidate], session_id, repository_root, 600
+    )
+
+    assert is_allowed is False
+
+
+def test_recorded_failure_does_not_apply_once_content_no_longer_matches(
+    tmp_path: Path,
+) -> None:
+    """Anti-bypass: editing the test after a recorded RED clears that RED as evidence.
+
+    A bare failure-only entry (no prior content-hash tracking) must not fall
+    through to the unconditional hash-differs allow either -- it still needs a
+    real qualifying first sight (fresh mtime plus a real git-visible edit).
+    """
+    candidate = tmp_path / "test_orders.py"
+    candidate.write_text("def test_fulfill(): pass\n")
+    session_id, repository_root = "session-failure-5", str(tmp_path)
+    content_hash_store.record_test_command_failure(
+        [candidate], "pytest test_orders.py", 1, session_id, repository_root
+    )
+    candidate.write_text("def test_fulfill(): assert True\n")
+    stale_timestamp = time.time() - 700
+    os.utime(candidate, (stale_timestamp, stale_timestamp))
+
+    is_allowed = content_hash_store.has_recorded_or_fresh_test(
+        [candidate], session_id, repository_root, 600
+    )
+
+    assert is_allowed is False

package/hooks/blocking/test_bash_post_call_dispatcher.py

@@ -0,0 +1,112 @@
+"""Behavior tests for the Bash PostToolUse dispatcher.
+
+One interpreter start runs every hosted PostToolUse hook a Bash call fires.
+The unit tests pin selection, call order, and crash isolation with a fake
+runner; the end-to-end test drives the real hosted hooks through a real
+payload and confirms the recorder's own real side effect lands.
+``hooks/conftest.py`` already puts the hooks and blocking directories on
+sys.path for test collection, so this file needs no bootstrap of its own.
+"""
+
+import io
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+from bash_post_call_dispatcher import dispatch, main, select_applicable_entries
+from hooks_constants.bash_pre_tool_use_dispatcher_constants import BASH_TOOL_NAME
+from hooks_constants.hosted_hook_runner import HostedHookRun
+from tdd_enforcer_parts import content_hash_store
+
+
+def test_select_applicable_entries_returns_both_hosted_hooks_for_bash() -> None:
+    all_entries = select_applicable_entries(BASH_TOOL_NAME)
+    all_script_paths = [each_entry.script_relative_path for each_entry in all_entries]
+    assert all_script_paths == [
+        "blocking/gh_pr_author_restore.py",
+        "observability/test_failure_recorder.py",
+    ]
+
+
+def test_select_applicable_entries_returns_none_for_a_write_tool() -> None:
+    assert select_applicable_entries("Write") == []
+
+
+def test_dispatch_runs_every_hosted_hook_in_roster_order(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_call_paths: list[str] = []
+
+    def _fake_run_hook(script_path: str, payload_text: str) -> HostedHookRun:
+        del payload_text
+        all_call_paths.append(Path(script_path).name)
+        return HostedHookRun(captured_stdout="", did_crash=False)
+
+    monkeypatch.setattr("bash_post_call_dispatcher.run_hook_capturing_output", _fake_run_hook)
+
+    dispatch('{"tool_name": "Bash"}', BASH_TOOL_NAME)
+
+    assert all_call_paths == ["gh_pr_author_restore.py", "test_failure_recorder.py"]
+
+
+def test_dispatch_runs_the_later_hook_after_an_earlier_one_crashes(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_call_paths: list[str] = []
+
+    def _fake_run_hook(script_path: str, payload_text: str) -> HostedHookRun:
+        del payload_text
+        script_name = Path(script_path).name
+        all_call_paths.append(script_name)
+        if script_name == "gh_pr_author_restore.py":
+            return HostedHookRun(captured_stdout="", did_crash=True)
+        return HostedHookRun(captured_stdout="", did_crash=False)
+
+    monkeypatch.setattr("bash_post_call_dispatcher.run_hook_capturing_output", _fake_run_hook)
+
+    dispatch('{"tool_name": "Bash"}', BASH_TOOL_NAME)
+
+    assert all_call_paths == ["gh_pr_author_restore.py", "test_failure_recorder.py"]
+
+
+def test_main_exits_zero_and_writes_nothing_to_stdout(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    payload = json.dumps({"tool_name": "Write", "tool_input": {}})
+    monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
+
+    with pytest.raises(SystemExit) as raised_exit:
+        main()
+
+    assert int(raised_exit.value.code or 0) == 0
+    assert capsys.readouterr().out == ""
+
+
+def test_end_to_end_real_hosted_hooks_record_a_real_pytest_failure(tmp_path: Path) -> None:
+    """Drives the real, unfaked roster: both scripts run in one process."""
+    test_file = tmp_path / "test_orders.py"
+    test_file.write_text("def test_fulfill(): assert False\n")
+    session_id = "post-dispatcher-session"
+    failing_output = (
+        "Error: Exit code 1\n"
+        "FAILED test_orders.py::test_fulfill - AssertionError\n"
+        "1 failed in 0.02s"
+    )
+    payload = json.dumps(
+        {
+            "session_id": session_id,
+            "cwd": str(tmp_path),
+            "tool_name": "Bash",
+            "tool_input": {"command": "pytest test_orders.py"},
+            "tool_response": failing_output,
+        }
+    )
+
+    dispatch(payload, BASH_TOOL_NAME)
+
+    state_file = content_hash_store._state_file_path(session_id, str(tmp_path))
+    state = json.loads(state_file.read_text())
+    entry = state[content_hash_store._state_key_for(test_file)]
+    assert entry[content_hash_store.STORED_FAILURE_EXIT_STATUS_KEY] == 1

package/hooks/blocking/test_code_rules_enforcer_any_type_ignore.py

@@ -56,6 +56,7 @@ def test_should_flag_bare_type_ignore() -> None:
     source = "x = 1  # type: ignore\n"
     issues = check_type_escape_hatches(source, PRODUCTION_FILE_PATH)
     assert any("type: ignore" in issue for issue in issues)
+    assert any("remove it and use a typed boundary or real type" in issue for issue in issues)
 
 
 def test_should_flag_coded_type_ignore_without_justification() -> None:
@@ -64,16 +65,35 @@ def test_should_flag_coded_type_ignore_without_justification() -> None:
     assert any("type: ignore" in issue for issue in issues)
 
 
-def test_should_allow_justified_type_ignore() -> None:
+def test_should_flag_justified_type_ignore() -> None:
     source = "x = 1  # type: ignore[misc]  # stubs missing in foo library\n"
     issues = check_type_escape_hatches(source, PRODUCTION_FILE_PATH)
-    assert not any("type: ignore" in issue for issue in issues)
+    assert any("type: ignore" in issue for issue in issues)
+
+
+def test_should_flag_justified_type_ignore_in_test_files() -> None:
+    source = "x = 1  # type: ignore[misc]  # stubs missing in foo library\n"
+    issues = check_type_escape_hatches(source, TEST_FILE_PATH)
+    assert any("type: ignore" in issue for issue in issues)
 
 
-def test_should_skip_test_files() -> None:
+def test_should_flag_type_ignore_in_test_files() -> None:
     source = "def foo(x: Any) -> Any:\n    y: Any = 1  # type: ignore\n    return y\n"
     issues = check_type_escape_hatches(source, TEST_FILE_PATH)
-    assert issues == []
+    assert any("type: ignore" in issue for issue in issues)
+    assert not any("Any annotation" in issue for issue in issues)
+
+
+def test_edit_lane_does_not_report_type_ignore_comment_policy() -> None:
+    source = "total = 1  # type: ignore[misc]\n"
+    issues = hook_module.validate_content_for_edit_lane(source, TEST_FILE_PATH)
+    assert not any("type: ignore" in issue for issue in issues)
+
+
+def test_edit_lane_does_not_report_production_type_ignore_comment_policy() -> None:
+    source = "total = 1  # type: ignore[misc]\n"
+    issues = hook_module.validate_content_for_edit_lane(source, PRODUCTION_FILE_PATH)
+    assert not any("type: ignore" in issue for issue in issues)
 
 
 def test_should_flag_any_on_positional_only_parameter() -> None:

package/hooks/blocking/test_code_rules_enforcer_cap_meta.py

@@ -68,7 +68,6 @@ KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW: frozenset[str] = frozenset(
     {
         "check_boolean_naming",
         "check_collection_prefix",
-        "check_comment_changes",
         "check_constant_equality_tests",
         "check_constants_outside_config",
         "check_existence_check_tests",

package/hooks/blocking/test_code_rules_enforcer_comment_string_awareness.py

@@ -14,6 +14,7 @@ a string still flag.
 from __future__ import annotations
 
 import sys
+import importlib
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -31,12 +32,12 @@ from code_rules_comments import (  # noqa: E402
     check_comments_python,
     extract_comment_texts,
 )
-
 code_rules_enforcer = SimpleNamespace(
     check_comment_changes=check_comment_changes,
     check_comments_python=check_comments_python,
     extract_comment_texts=extract_comment_texts,
 )
+code_rules_enforcer_module = importlib.import_module("code_rules_enforcer")
 
 
 def test_python_check_should_not_flag_hex_color_literal() -> None:
@@ -121,7 +122,7 @@ def test_check_comment_changes_skips_removal_when_old_python_un_parseable() -> N
     assert issues == []
 
 
-def test_check_comment_changes_advises_without_blocking_on_removal_on_parseable_python(
+def test_check_comment_changes_allows_comment_removal_without_advisory(
     capsys: pytest.CaptureFixture[str],
 ) -> None:
     old_content = 'x = 1  # existing comment\n'
@@ -129,7 +130,7 @@ def test_check_comment_changes_advises_without_blocking_on_removal_on_parseable_
     issues = code_rules_enforcer.check_comment_changes(old_content, new_content, "foo.py")
     assert not any("Existing comment removed" in each_issue for each_issue in issues)
     captured = capsys.readouterr()
-    assert "[CODE_RULES advisory] Existing comment removed" in captured.err
+    assert captured.err == ""
 
 
 def test_python_check_should_exempt_directive_without_space_after_hash() -> None:
@@ -194,3 +195,189 @@ def test_extract_should_classify_inline_shebang_lookalike_as_inline_comment() ->
     inline, standalone = code_rules_enforcer.extract_comment_texts(content, "foo.py")
     assert inline != set()
     assert standalone == set()
+
+
+def test_full_gate_blocks_python_inline_comment_in_test_file() -> None:
+    context = code_rules_enforcer_module._ValidationContext(
+        content="total = 1  # added\n",
+        old_content="total = 1\n",
+        effective_content="total = 1  # added\n",
+        file_path="test_totals.py",
+        all_changed_lines=None,
+        defer_scope_to_caller=False,
+        sibling_directory=None,
+        phase="edit",
+    )
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    assert any("Inline comment added" in each_issue for each_issue in issues)
+
+
+def test_full_gate_blocks_javascript_inline_comment_in_test_file() -> None:
+    context = code_rules_enforcer_module._ValidationContext(
+        content="const total = 1; // added\n",
+        old_content="const total = 1;\n",
+        effective_content="const total = 1; // added\n",
+        file_path="totals.test.js",
+        all_changed_lines=None,
+        defer_scope_to_caller=False,
+        sibling_directory=None,
+        phase="edit",
+    )
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    assert any("Inline comment added" in each_issue for each_issue in issues)
+
+
+def test_full_gate_blocks_javascript_inline_block_comment_in_test_file() -> None:
+    context = code_rules_enforcer_module._ValidationContext(
+        content="const total = 1; /* added */\n",
+        old_content="const total = 1;\n",
+        effective_content="const total = 1; /* added */\n",
+        file_path="totals.test.js",
+        all_changed_lines=None,
+        defer_scope_to_caller=False,
+        sibling_directory=None,
+        phase="edit",
+    )
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    assert any("Inline comment added" in each_issue for each_issue in issues)
+
+
+def test_full_gate_blocks_javascript_directive_comment_in_test_file() -> None:
+    context = code_rules_enforcer_module._ValidationContext(
+        content="const total = 1; // eslint-disable-next-line\n",
+        old_content="const total = 1;\n",
+        effective_content="const total = 1; // eslint-disable-next-line\n",
+        file_path="totals.test.js",
+        all_changed_lines=None,
+        defer_scope_to_caller=False,
+        sibling_directory=None,
+        phase="edit",
+    )
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    assert any("Inline comment added" in each_issue for each_issue in issues)
+
+
+def test_full_gate_blocks_python_directive_comment_in_test_file() -> None:
+    context = code_rules_enforcer_module._ValidationContext(
+        content="total = 1  # noqa\n",
+        old_content="total = 1\n",
+        effective_content="total = 1  # noqa\n",
+        file_path="test_totals.py",
+        all_changed_lines=None,
+        defer_scope_to_caller=False,
+        sibling_directory=None,
+        phase="edit",
+    )
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    assert any("comment added" in each_issue.lower() for each_issue in issues)
+
+
+@pytest.mark.parametrize(
+    "each_marker", ("# TODO #999: track", "# FIXME #999: track", "# HACK #999: track", "# XXX #999: track", "# type: ignore[misc]")
+)
+def test_full_gate_blocks_changed_marker_comments_in_test_file(each_marker: str) -> None:
+    context = code_rules_enforcer_module._ValidationContext(
+        content=f"total = 1  {each_marker}\n",
+        old_content="total = 1\n",
+        effective_content=f"total = 1  {each_marker}\n",
+        file_path="test_totals.py",
+        all_changed_lines=None,
+        defer_scope_to_caller=False,
+        sibling_directory=None,
+        phase="edit",
+    )
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    assert any("comment added" in each_issue.lower() for each_issue in issues)
+
+
+def test_full_gate_blocks_standalone_comment_in_test_file() -> None:
+    context = code_rules_enforcer_module._ValidationContext(
+        content="# added\ntotal = 1\n",
+        old_content="total = 1\n",
+        effective_content="# added\ntotal = 1\n",
+        file_path="test_totals.py",
+        all_changed_lines=None,
+        defer_scope_to_caller=False,
+        sibling_directory=None,
+        phase="edit",
+    )
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    assert any("Standalone comment added" in each_issue for each_issue in issues)
+
+
+def test_full_gate_preserves_shebang_and_docstring_in_test_file() -> None:
+    context = code_rules_enforcer_module._ValidationContext(
+        content='#!/usr/bin/env python3\n"""Describe totals."""\ntotal = 1\n',
+        old_content="#!/usr/bin/env python3\n",
+        effective_content='#!/usr/bin/env python3\n"""Describe totals."""\ntotal = 1\n',
+        file_path="test_totals.py",
+        all_changed_lines=None,
+        defer_scope_to_caller=False,
+        sibling_directory=None,
+        phase="edit",
+    )
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    assert not any("comment added" in each_issue.lower() for each_issue in issues)
+
+
+def test_full_gate_allows_existing_comment_removal_without_advisory(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    context = code_rules_enforcer_module._ValidationContext(
+        content="total = 1\n",
+        old_content="total = 1  # existing\n",
+        effective_content="total = 1\n",
+        file_path="test_totals.py",
+        all_changed_lines=None,
+        defer_scope_to_caller=False,
+        sibling_directory=None,
+        phase="edit",
+    )
+    issues = code_rules_enforcer_module.validate_content_for_full_gate(context.content, context.file_path, context.old_content)
+    assert not any("Existing comment removed" in each_issue for each_issue in issues)
+    assert capsys.readouterr().err == ""
+
+
+@pytest.mark.parametrize(
+    ("file_path", "old_content", "new_content"),
+    (
+        ("totals.py", "total = 1\n", "total = 2  # TODO #999: track\n"),
+        ("test_totals.py", "total = 1\n", "total = 2  # TODO #999: track\n"),
+        ("totals.js", "const total = 1;\n", "const total = 2; // eslint-disable-next-line\n"),
+        ("totals.test.js", "const total = 1;\n", "const total = 2; // eslint-disable-next-line\n"),
+    ),
+)
+def test_edit_lane_does_not_report_comment_policy(
+    file_path: str, old_content: str, new_content: str
+) -> None:
+    issues = code_rules_enforcer_module.validate_content_for_edit_lane(
+        new_content, file_path, old_content
+    )
+    assert not any("comment" in each_issue.lower() for each_issue in issues)
+
+
+@pytest.mark.parametrize(
+    ("file_path", "old_content", "new_content"),
+    (
+        ("totals.py", "total = 1  # TODO #999: track\n", "total = 2  # TODO #999: track\n"),
+        ("totals.py", "# TODO #999: track\ntotal = 1\n", "# TODO #999: track\ntotal = 2\n"),
+        ("totals.py", "total = 1  # noqa\n", "total = 2  # noqa\n"),
+        (
+            "totals.js",
+            "const total = 1; // eslint-disable-next-line\n",
+            "const total = 2; // eslint-disable-next-line\n",
+        ),
+    ),
+)
+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)
+
+
+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)

package/hooks/blocking/test_code_rules_enforcer_javascript_comments.py

@@ -0,0 +1,44 @@
+"""Tests for JavaScript comment extraction and diff occurrence reporting."""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from pathlib import Path
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+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
+
+
+def test_check_comment_changes_ignores_javascript_url_string() -> None:
+    issues = check_comment_changes(
+        "", 'const docsUrl = "https://example.com/guide";\n', "docs.js"
+    )
+
+    assert issues == []
+
+
+def test_check_comment_changes_reports_javascript_comment_line() -> None:
+    issues = check_comment_changes(
+        "", 'const total = 1;\nconst next = 2; // added\n', "totals.js"
+    )
+
+    assert any("Line 2: Inline comment added" in each_issue for each_issue in issues)
+
+
+def test_check_comment_changes_reports_duplicate_identical_comment_occurrence() -> None:
+    issues = check_comment_changes(
+        "total = 1  # repeated\n",
+        "total = 1  # repeated\ntotal = 2  # repeated\n",
+        "totals.py",
+    )
+
+    assert any("Line 2: Inline comment added" in each_issue for each_issue in issues)

package/hooks/blocking/test_code_rules_enforcer_join_separator_magic.py

@@ -74,7 +74,6 @@ def test_should_grandfather_unchanged_join_separator_in_wide_edit() -> None:
     )
     proposed_fragment = (
         "def render(all_paths: list) -> str:\n"
-        "    # keep the join separator the same\n"
         "    return ', '.join(str(each_path) for each_path in all_paths)\n"
     )
     issues = code_rules_enforcer.validate_content_for_full_gate(

package/hooks/blocking/test_code_rules_enforcer_same_file_inline_duplicate.py

@@ -648,8 +648,11 @@ def test_should_read_no_function_when_the_file_holds_no_qualifying_helper() -> N
     pins the verdict such a file gets.
     """
     all_module_functions = ast.parse(NO_INLINE_DUPLICATE_SOURCE).body
+    dump_by_statement: dict[ast.stmt, str] = {}
     all_windows = [
-        _duplicate_body_module._helper_match_window_dumps(each_function)
+        _duplicate_body_module._helper_match_window_dumps(
+            each_function, dump_by_statement
+        )
         for each_function in all_module_functions
         if isinstance(each_function, ast.FunctionDef | ast.AsyncFunctionDef)
     ]
@@ -657,6 +660,10 @@ def test_should_read_no_function_when_the_file_holds_no_qualifying_helper() -> N
         "this source must hold no qualifying helper for the skip to be exercised, "
         f"got windows: {all_windows}"
     )
+    assert dump_by_statement == {}, (
+        "a source with no qualifying helper must take no statement dumps, "
+        f"got {len(dump_by_statement)} memo entries"
+    )
     issues = check_same_file_inline_duplicate_body(
         NO_INLINE_DUPLICATE_SOURCE, "module.py"
     )

package/hooks/blocking/test_pre_tool_use_dispatcher_native.py

@@ -46,8 +46,13 @@ import state_description_blocker  # noqa: E402, I001
 _STATE_DESCRIPTION_SCRIPT = str(_BLOCKING_DIR / "state_description_blocker.py")
 _DISPATCHER_SCRIPT = str(_BLOCKING_DIR / "pre_tool_use_dispatcher.py")
 
-_REPOSITORY_ROOT = str(Path(__file__).resolve().parents[4])
-_MARKDOWN_PATH = str(Path(_REPOSITORY_ROOT) / "docs" / "native_equivalence_probe.md")
+from code_rules_enforcer_test_support import (  # noqa: E402
+    repository_file_path,
+    repository_root,
+)
+
+_REPOSITORY_ROOT = str(repository_root())
+_MARKDOWN_PATH = repository_file_path("docs/native_equivalence_probe.md")
 _STATE_DESCRIPTION_ALLOW_CONTENT = "# Guide\n\nThe API uses port 8080.\n"
 _STATE_DESCRIPTION_DENY_CONTENT = "# Guide\n\nPreviously the system used port 8080.\n"