claude-dev-env 2.29.0 → 2.30.1

package/hooks/blocking/test_code_rules_enforcer_narrow_edit.py

@@ -20,7 +20,7 @@ if _HOOKS_DIRECTORY not in sys.path:
 
 from code_rules_enforcer import (  # noqa: E402
     main,
-    validate_content,
+    validate_content_for_full_gate as validate_content,
 )
 
 
@@ -165,47 +165,126 @@ def _validate_narrow_edit(narrow_edit_fixture: NarrowEditFixture) -> list[str]:
     )
 
 
-def _scope_aware_rule_names_from_source() -> frozenset[str]:
-    source_tree = ast.parse(inspect.getsource(validate_content))
-    all_rule_names: set[str] = set()
-    for each_call in ast.walk(source_tree):
-        if not isinstance(each_call, ast.Call):
+_SCOPE_CARRYING_ATTRIBUTE_NAMES = frozenset({"all_changed_lines", "defer_scope_to_caller"})
+
+
+def _assignment_target_names(target: ast.expr) -> list[str]:
+    """Return the plain names one assignment target binds, Name or Tuple-of-Name."""
+    if isinstance(target, ast.Name):
+        return [target.id]
+    if isinstance(target, ast.Tuple):
+        return [each.id for each in target.elts if isinstance(each, ast.Name)]
+    return []
+
+
+def _scope_aliases_for_pair(target_names: list[str], all_values: list[ast.expr]) -> dict[str, str]:
+    """Return the local-name-to-scope-attribute map one assignment pair contributes."""
+    aliases: dict[str, str] = {}
+    for each_name, each_value in zip(target_names, all_values):
+        if not isinstance(each_value, ast.Attribute):
             continue
-        if not isinstance(each_call.func, ast.Name):
+        if each_value.attr not in _SCOPE_CARRYING_ATTRIBUTE_NAMES:
             continue
-        if each_call.func.id == "_fragment_or_deferred_check":
-            all_argument_names = {
-                each_name.id
-                for each_argument in each_call.args[1:]
-                for each_name in ast.walk(each_argument)
-                if isinstance(each_name, ast.Name)
-            }
-            if (
-                "defer_scope_to_caller" in all_argument_names
-                and each_call.args
-                and isinstance(each_call.args[0], ast.Name)
-            ):
-                all_rule_names.add(each_call.args[0].id)
+        aliases[each_name] = each_value.attr
+    return aliases
+
+
+def _context_alias_map(function_node: ast.AST) -> dict[str, str]:
+    """Map each local name one function binds from ``context.<scope attribute>``.
+
+    A dispatch helper unpacks ``context.all_changed_lines`` and
+    ``context.defer_scope_to_caller`` into a short local name (``changed``,
+    ``defer``) before passing it on, so a call carrying that local name still
+    carries scope, even though the local name spells out none of it.
+    """
+    aliases: dict[str, str] = {}
+    for each_node in ast.walk(function_node):
+        if not isinstance(each_node, ast.Assign) or len(each_node.targets) != 1:
             continue
-        if not each_call.func.id.startswith("check_"):
+        target_names = _assignment_target_names(each_node.targets[0])
+        if not target_names:
             continue
-        all_argument_names = {
-            each_name.id
-            for each_argument in each_call.args
-            for each_name in ast.walk(each_argument)
-            if isinstance(each_name, ast.Name)
-        }
-        all_argument_names.update(
-            each_name.id
-            for each_keyword in each_call.keywords
-            for each_name in ast.walk(each_keyword.value)
-            if isinstance(each_name, ast.Name)
-        )
-        if (
-            "all_changed_lines" in all_argument_names
-            or "defer_scope_to_caller" in all_argument_names
-        ):
-            all_rule_names.add(each_call.func.id)
+        value = each_node.value
+        all_values = value.elts if isinstance(value, ast.Tuple) else [value]
+        aliases.update(_scope_aliases_for_pair(target_names, all_values))
+    return aliases
+
+
+def _scope_names_for_reference(reference: ast.AST, aliases: dict[str, str]) -> set[str]:
+    """Return the scope-carrying attribute name one AST reference resolves to, if any."""
+    if isinstance(reference, ast.Name) and reference.id in aliases:
+        return {aliases[reference.id]}
+    if isinstance(reference, ast.Attribute) and reference.attr in _SCOPE_CARRYING_ATTRIBUTE_NAMES:
+        return {reference.attr}
+    return set()
+
+
+def _referenced_scope_attribute_names(node: ast.AST, aliases: dict[str, str]) -> set[str]:
+    """Return every scope-carrying attribute name *node* references, direct or aliased."""
+    found: set[str] = set()
+    for each_reference in ast.walk(node):
+        found.update(_scope_names_for_reference(each_reference, aliases))
+    return found
+
+
+def _fragment_deferred_rule_name(call_node: ast.Call, aliases: dict[str, str]) -> str | None:
+    """Return the rule name one ``_fragment_or_deferred_check`` call selects, if scoped."""
+    argument_scope_names = {
+        each_scope_name
+        for each_argument in call_node.args[1:]
+        for each_scope_name in _referenced_scope_attribute_names(each_argument, aliases)
+    }
+    if "defer_scope_to_caller" not in argument_scope_names:
+        return None
+    if not call_node.args or not isinstance(call_node.args[0], ast.Name):
+        return None
+    return call_node.args[0].id
+
+
+def _check_call_rule_name(call_node: ast.Call, aliases: dict[str, str]) -> str | None:
+    """Return the rule name one direct ``check_*`` call selects, if it carries scope."""
+    func_name = call_node.func.id  # type: ignore[attr-defined]  # caller already narrowed func to ast.Name
+    if not func_name.startswith("check_"):
+        return None
+    all_call_arguments = (*call_node.args, *(each_keyword.value for each_keyword in call_node.keywords))
+    argument_scope_names = {
+        each_scope_name
+        for each_argument in all_call_arguments
+        for each_scope_name in _referenced_scope_attribute_names(each_argument, aliases)
+    }
+    return func_name if argument_scope_names else None
+
+
+def _rule_names_from_function(function_node: ast.FunctionDef) -> set[str]:
+    """Return the check_* names *function_node* calls with scope-carrying arguments."""
+    aliases = _context_alias_map(function_node)
+    rule_names: set[str] = set()
+    for each_call in ast.walk(function_node):
+        if not isinstance(each_call, ast.Call) or not isinstance(each_call.func, ast.Name):
+            continue
+        if each_call.func.id == "_fragment_or_deferred_check":
+            rule_name = _fragment_deferred_rule_name(each_call, aliases)
+        else:
+            rule_name = _check_call_rule_name(each_call, aliases)
+        if rule_name is not None:
+            rule_names.add(rule_name)
+    return rule_names
+
+
+def _scope_aware_rule_names_from_source() -> frozenset[str]:
+    """Return every check_* name dispatched anywhere in the enforcer with scope.
+
+    Walks every function in the enforcer module rather than only
+    ``validate_content``, since the extension-issue helper functions hold the
+    actual dispatch calls today.
+    """
+    enforcer_module = inspect.getmodule(validate_content)
+    assert enforcer_module is not None
+    module_tree = ast.parse(inspect.getsource(enforcer_module))
+    all_rule_names: set[str] = set()
+    for each_function in ast.walk(module_tree):
+        if isinstance(each_function, ast.FunctionDef):
+            all_rule_names.update(_rule_names_from_function(each_function))
     return frozenset(all_rule_names)
 
 

package/hooks/blocking/test_code_rules_enforcer_output_snapshot.py

@@ -0,0 +1,121 @@
+"""Golden-output snapshot for the phase-split validators, guarding both phases.
+
+Records the full-gate phase's ordered issue list for three representative
+fixtures — a Python cross-file duplicate-body hit, a JavaScript boolean-naming
+hit, and a Python-built-HTML orphan-CSS-class hit — so a decomposition that
+reorders or drops a dispatch line shows up as a changed list, not a
+still-green suite. Each fixture also records the edit-lane phase's list, which
+matches the full-gate list except for the cross-file finding the edit lane
+skips.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_module_from_path(module_name: str, module_path: Path) -> ModuleType:
+    """Load and execute the module found at module_path, under module_name."""
+    specification = importlib.util.spec_from_file_location(module_name, module_path)
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    specification.loader.exec_module(module)
+    return module
+
+
+_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
+code_rules_enforcer = _load_module_from_path(
+    "code_rules_enforcer", _BLOCKING_DIRECTORY / "code_rules_enforcer.py"
+)
+
+_DUPLICATE_FUNCTION_SOURCE = (
+    "def compute_shipping_total(order_total: float, tax_rate: float) -> float:\n"
+    "    taxed_total = order_total * (1 + tax_rate)\n"
+    "    rounded_total = round(taxed_total, 2)\n"
+    "    return rounded_total\n"
+)
+_JS_BOOLEAN_SOURCE = "const active = true;\n"
+_CSS_ORPHAN_CLASS_SOURCE = (
+    '"""Render a status badge."""\n\n'
+    "STATUS_MARKUP = '<div class=\"status-badge\">Active</div>'\n"
+    "STYLE_BLOCK = '<style>.status-pill { color: green; }</style>'\n"
+)
+
+EXPECTED_PYTHON_CROSS_FILE_ISSUES = [
+    "Line 3: Magic value 2 - extract to named constant",
+    "Function 'compute_shipping_total' duplicates shipping_helper.py::compute_shipping_total"
+    " — this function body is identical to one in a sibling module; extract a single shared"
+    " helper (for example in hooks_constants/) and import it from both modules instead of"
+    " copying it (Reuse before create / DRY) (duplicate body span at line 1, spanning 4 lines)",
+]
+EXPECTED_PYTHON_CROSS_FILE_EDIT_LANE_ISSUES = [
+    "Line 3: Magic value 2 - extract to named constant",
+]
+EXPECTED_JS_ISSUES = [
+    "Line 1: Boolean active - prefix with is/has/should/can/was/did",
+]
+EXPECTED_CSS_ISSUES = [
+    "Line 3: Constant STATUS_MARKUP - move to config/",
+    "Line 4: Constant STYLE_BLOCK - move to config/",
+    "Line 3: CSS class 'status-badge' used in markup has no matching '.status-badge' selector"
+    " - add a matching '.<class>' selector to the <style> block, or drop the unused class"
+    " attribute (CODE_RULES self-documenting markup)",
+]
+EXPECTED_CSS_EDIT_LANE_ISSUES = [
+    "Line 3: Constant STATUS_MARKUP - move to config/",
+    "Line 4: Constant STYLE_BLOCK - move to config/",
+]
+
+
+def test_python_cross_file_duplicate_snapshot_is_unchanged(tmp_path: Path) -> None:
+    """Both phases' ordered output for a cross-file duplicate stays fixed.
+
+    ``file_path`` is a fixed classification-only path, never opened, so the
+    real ``tmp_path`` sibling scan (which embeds this test's own name, a
+    ``test_`` match) never misclassifies the fixture as a test file.
+    """
+    sibling_dir = tmp_path / "sibling_dir"
+    sibling_dir.mkdir()
+    (sibling_dir / "shipping_helper.py").write_text(_DUPLICATE_FUNCTION_SOURCE, encoding="utf-8")
+    classification_only_file_path = "/repo/packages/demo/shipping/shipping_target.py"
+
+    full_gate_issues = code_rules_enforcer.validate_content_for_full_gate(
+        _DUPLICATE_FUNCTION_SOURCE,
+        classification_only_file_path,
+        "",
+        sibling_directory=sibling_dir,
+    )
+    edit_lane_issues = code_rules_enforcer.validate_content_for_edit_lane(
+        _DUPLICATE_FUNCTION_SOURCE,
+        classification_only_file_path,
+        "",
+        sibling_directory=sibling_dir,
+    )
+
+    assert full_gate_issues == EXPECTED_PYTHON_CROSS_FILE_ISSUES
+    assert edit_lane_issues == EXPECTED_PYTHON_CROSS_FILE_EDIT_LANE_ISSUES
+
+
+def test_javascript_boolean_naming_snapshot_is_unchanged() -> None:
+    full_gate_issues = code_rules_enforcer.validate_content_for_full_gate(
+        _JS_BOOLEAN_SOURCE, "packages/app/frontend/status.js", ""
+    )
+    edit_lane_issues = code_rules_enforcer.validate_content_for_edit_lane(
+        _JS_BOOLEAN_SOURCE, "packages/app/frontend/status.js", ""
+    )
+    assert full_gate_issues == EXPECTED_JS_ISSUES
+    assert edit_lane_issues == EXPECTED_JS_ISSUES
+
+
+def test_python_orphan_css_class_snapshot_is_unchanged() -> None:
+    full_gate_issues = code_rules_enforcer.validate_content_for_full_gate(
+        _CSS_ORPHAN_CLASS_SOURCE, "packages/app/widgets/status_widget.py", ""
+    )
+    edit_lane_issues = code_rules_enforcer.validate_content_for_edit_lane(
+        _CSS_ORPHAN_CLASS_SOURCE, "packages/app/widgets/status_widget.py", ""
+    )
+    assert full_gate_issues == EXPECTED_CSS_ISSUES
+    assert edit_lane_issues == EXPECTED_CSS_EDIT_LANE_ISSUES

package/hooks/blocking/test_code_rules_enforcer_precheck_forecast.py

@@ -7,6 +7,8 @@ import subprocess
 import sys
 from pathlib import Path
 
+import pytest
+
 _BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
 _HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
 if _BLOCKING_DIRECTORY not in sys.path:
@@ -16,7 +18,7 @@ if _HOOKS_DIRECTORY not in sys.path:
 
 from code_rules_enforcer import (  # noqa: E402
     main,
-    validate_content,
+    validate_content_for_full_gate as validate_content,
 )
 from code_rules_enforcer_test_support import (  # noqa: E402
     run_enforcer_cli,
@@ -115,7 +117,7 @@ def test_precheck_stream_parameter_carries_no_banned_noun() -> None:
 
 
 def test_precheck_reports_violations_and_exits_nonzero_for_production_candidate(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """A violating candidate judged at a production target prints each violation to
     stdout and exits 1."""
@@ -138,7 +140,7 @@ def test_precheck_reports_violations_and_exits_nonzero_for_production_candidate(
 
 
 def test_precheck_emits_no_output_and_exits_zero_for_clean_candidate(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """A clean candidate produces no stdout and exits 0."""
     staging_directory = getattr(tmp_path_factory, "mktemp")("staging")
@@ -155,7 +157,7 @@ def test_precheck_emits_no_output_and_exits_zero_for_clean_candidate(
 
 
 def test_precheck_target_path_drives_test_file_exemptions(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """Production-shaped content judged against a ``test_*.py`` target passes
     because test-file exemptions apply through the target path."""
@@ -172,7 +174,7 @@ def test_precheck_target_path_drives_test_file_exemptions(
 
 
 def test_precheck_noncode_target_exits_zero_with_no_output(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """A non-code target extension is exempt: the pre-check exits 0 with no output."""
     staging_directory = getattr(tmp_path_factory, "mktemp")("staging")
@@ -186,7 +188,7 @@ def test_precheck_noncode_target_exits_zero_with_no_output(
 
 
 def test_precheck_missing_candidate_errors_on_stderr_without_traceback(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """A nonexistent candidate path prints a one-line stderr error and exits
     nonzero without a Python traceback."""
@@ -204,7 +206,7 @@ def test_precheck_missing_candidate_errors_on_stderr_without_traceback(
 
 
 def test_edit_deny_reason_includes_forecast_and_precheck_hint(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """An Edit whose new_string introduces a violation on a file that already
     contains a separate violation elsewhere blocks on the fragment violation and
@@ -236,7 +238,7 @@ def test_edit_deny_reason_includes_forecast_and_precheck_hint(
 
 
 def test_edit_clean_fragment_on_dirty_file_produces_no_deny_payload(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """A clean Edit fragment on a file that is dirty elsewhere must not block —
     the forecast never converts a clean-fragment edit into a deny."""
@@ -258,7 +260,7 @@ def test_edit_clean_fragment_on_dirty_file_produces_no_deny_payload(
 
 
 def test_every_deny_reason_carries_the_precheck_hint(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """A deny with no forecast still appends the pre-check hint to the reason."""
     production_directory = getattr(tmp_path_factory, "mktemp")("production_pkg")
@@ -287,7 +289,7 @@ def test_every_deny_reason_carries_the_precheck_hint(
 
 
 def test_forecast_skipped_when_edit_prior_is_unreconstructable(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """An Edit whose old_string is absent from the file has no reliable prior to
     diff against, so the full-file forecast must not run: a pre-existing inline
@@ -313,7 +315,7 @@ def test_forecast_skipped_when_edit_prior_is_unreconstructable(
 
 
 def test_forecast_omits_the_fragment_introduced_violation(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """An Edit that introduces the file's only print() blocks on it without the
     forecast re-listing that same violation under its full-file line number."""
@@ -353,7 +355,7 @@ def test_precheck_missing_candidate_value_exits_two_with_usage() -> None:
 
 
 def test_precheck_flag_shaped_candidate_value_exits_two_with_usage(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """``--check`` immediately followed by ``--as`` is a usage error rather than
     an attempt to read a file literally named ``--as``."""
@@ -370,7 +372,7 @@ def test_precheck_flag_shaped_candidate_value_exits_two_with_usage(
 
 
 def test_precheck_rejects_unrecognized_trailing_token_with_usage(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """A pre-check vector carrying a token beyond the supported
     ``--check <candidate> [--as <target>]`` shape is a usage error: an extra
@@ -393,7 +395,7 @@ def test_precheck_rejects_unrecognized_trailing_token_with_usage(
 
 
 def test_precheck_strips_candidate_byte_order_mark_before_validation(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """A UTF-8 byte-order mark on the candidate must not hide AST-based
     violations: the candidate is judged exactly as its decoded content would
@@ -415,7 +417,7 @@ def test_precheck_strips_candidate_byte_order_mark_before_validation(
 
 
 def test_precheck_strips_every_leading_byte_order_mark_before_validation(
-    tmp_path_factory: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """Stacked byte-order marks must not hide AST-based violations: every
     leading mark is stripped, so a double-BOM candidate fails exactly like its

package/hooks/blocking/test_code_rules_enforcer_split_entry_1.py

@@ -6,6 +6,8 @@ import sys
 from pathlib import Path
 from types import SimpleNamespace
 
+import pytest
+
 _BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
 _HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
 if _BLOCKING_DIRECTORY not in sys.path:
@@ -17,7 +19,7 @@ from code_rules_annotations_length import (  # noqa: E402
     FUNCTION_LENGTH_BLOCKING_THRESHOLD,
 )
 from code_rules_enforcer import (  # noqa: E402
-    validate_content,
+    validate_content_for_full_gate as validate_content,
 )
 
 code_rules_enforcer = SimpleNamespace(
@@ -38,7 +40,7 @@ def _oversized_function_source(name: str) -> str:
 
 
 def test_should_emit_advisory_for_duplicated_format_patterns_via_validate_content(
-    capsys: object,
+    capsys: pytest.CaptureFixture[str],
 ) -> None:
     repeated_pattern_source = (
         "def get_user(user_id: str) -> str:\n"

package/hooks/blocking/test_code_rules_enforcer_split_entry_2.py

@@ -22,7 +22,7 @@ from code_rules_annotations_length import (  # noqa: E402
 from code_rules_enforcer import (  # noqa: E402
     main,
     prior_and_post_edit_content,
-    validate_content,
+    validate_content_for_full_gate as validate_content,
 )
 from code_rules_enforcer_test_support import (  # noqa: E402
     run_serialized_payload_entrypoint,

package/hooks/blocking/test_code_rules_enforcer_stage.py

@@ -25,7 +25,7 @@ if _PR_LOOP_SCRIPTS_DIRECTORY not in sys.path:
 from code_rules_enforcer import (  # noqa: E402
     _fragment_or_deferred_check,
     main,
-    validate_content,
+    validate_content_for_full_gate as validate_content,
 )
 from code_rules_gate_parts import gate_running  # noqa: E402
 from code_rules_gate_parts.tests._repo_test_helpers import (  # noqa: E402

package/hooks/blocking/test_code_rules_enforcer_string_magic.py

@@ -248,7 +248,7 @@ def test_should_grandfather_unchanged_string_magic_in_wide_edit() -> None:
         "    # wide edit that leaves the magic string in place\n"
         "    return os.environ['STRIPE_SECRET']\n"
     )
-    issues = code_rules_enforcer.validate_content(
+    issues = code_rules_enforcer.validate_content_for_full_gate(
         proposed_fragment,
         PRODUCTION_FILE_PATH,
         prior_fragment,
@@ -272,7 +272,7 @@ def test_should_block_new_string_magic_in_wide_edit() -> None:
         "def fetch_secret() -> str:\n"
         "    return os.environ['STRIPE_SECRET']\n"
     )
-    issues = code_rules_enforcer.validate_content(
+    issues = code_rules_enforcer.validate_content_for_full_gate(
         proposed_fragment,
         PRODUCTION_FILE_PATH,
         prior_fragment,
@@ -300,7 +300,7 @@ def test_should_block_second_identical_string_magic_per_occurrence() -> None:
         "def fetch_backup() -> str:\n"
         "    return os.environ['STRIPE_SECRET']\n"
     )
-    issues = code_rules_enforcer.validate_content(
+    issues = code_rules_enforcer.validate_content_for_full_gate(
         proposed_fragment,
         PRODUCTION_FILE_PATH,
         prior_fragment,
@@ -320,7 +320,7 @@ def test_should_surface_magic_when_gate_defers_scope_with_head_as_old() -> None:
         "    old_number = 9999\n"
         "    return old_number\n"
     )
-    issues = code_rules_enforcer.validate_content(
+    issues = code_rules_enforcer.validate_content_for_full_gate(
         source,
         PRODUCTION_FILE_PATH,
         source,

package/hooks/blocking/test_code_rules_enforcer_thin_wrapper_files.py

@@ -149,7 +149,7 @@ def test_should_flag_thin_wrapper_with_module_docstring() -> None:
     )
 
 
-def test_validate_content_uses_empty_full_file_content_over_pre_edit_fragment() -> None:
+def test_validate_content_for_full_gate_uses_empty_full_file_content_over_pre_edit_fragment() -> None:
     """An empty-string `full_file_content` must be honored, not silently replaced with `content`.
 
     Regression for loop1-8: the `or` short-circuit at line 3775 collapsed
@@ -159,7 +159,7 @@ def test_validate_content_uses_empty_full_file_content_over_pre_edit_fragment()
     not a thin wrapper, but a pre-edit fragment with imports + __all__ is.
     """
     pre_edit_fragment = "from real_module import do_thing\n__all__ = ['do_thing']\n"
-    issues = code_rules_enforcer.validate_content(
+    issues = code_rules_enforcer.validate_content_for_full_gate(
         pre_edit_fragment,
         PRODUCTION_FILE_PATH,
         full_file_content="",

package/hooks/blocking/test_code_rules_enforcer_zero_payload_alias.py

@@ -240,7 +240,7 @@ def test_should_not_flag_recursive_self_call() -> None:
     )
 
 
-def test_should_flag_through_validate_content_for_hook_file() -> None:
+def test_should_flag_through_validate_content_for_full_gate_for_hook_file() -> None:
     source = (
         "def find_bare_path_segments(content: str) -> set[str]:\n"
         "    return {part for part in content.split() if part}\n"
@@ -248,7 +248,7 @@ def test_should_flag_through_validate_content_for_hook_file() -> None:
         "def find_bare_index_segments(content: str) -> set[str]:\n"
         "    return find_bare_path_segments(content)\n"
     )
-    issues = code_rules_enforcer.validate_content(source, HOOK_INFRASTRUCTURE_PATH)
+    issues = code_rules_enforcer.validate_content_for_full_gate(source, HOOK_INFRASTRUCTURE_PATH)
     assert any("find_bare_index_segments" in each for each in issues), (
         f"validate_content must surface the alias for hook files, got: {issues!r}"
     )

package/hooks/blocking/test_code_rules_enforcer_zero_payload_alias_hook_routing.py

@@ -3,7 +3,7 @@
 A pass-through alias inside a hook module is the motivating case for the
 zero-payload-alias check, so the deny must fire on the same PreToolUse path a
 live Write into ``packages/claude-dev-env/hooks/blocking`` would take — not only
-through ``validate_content``, which hook files never reach at PreToolUse. These
+through ``validate_content_for_edit_lane``, which hook files never reach at PreToolUse. These
 tests drive the real ``main()`` stdin entry point and the pre-check CLI with a
 hook-infrastructure target.
 
@@ -66,7 +66,7 @@ def test_write_of_pass_through_alias_into_hook_directory_denies(
     The target lives under a hook-infrastructure path the full code-rules suite
     exempts, so this proves the zero-payload-alias check still fires on the exact
     directory its docstring names as the motivating case — at the PreToolUse Write
-    point, not only through ``validate_content``."""
+    point, not only through ``validate_content_for_edit_lane``."""
     new_file = hook_blocking_dir / "new_blocker.py"
     captured_stdout, _exit_code = run_write_entrypoint(
         main,