claude-dev-env 1.59.0 → 1.61.0

package/hooks/blocking/code_rules_dead_module_constant.py

@@ -0,0 +1,321 @@
+"""Dead module-level constant check for dedicated constants modules.
+
+A constants module (`*_constants.py`, or any module under a ``config/``
+directory) exists to export named values to importer modules elsewhere in the
+project, so a constant defined there is never proven dead by a single-file scan
+alone. This check resolves the enclosing package tree — the scan root — and
+flags an UPPER_SNAKE constant defined in the written module whose name appears
+in no ``.py`` module anywhere under that root: not as an imported name, not as a
+read, not as a re-export. That is the ``MEDIUM_TEXT``-style dead constant the
+CODE_RULES §9.8 dead-code rule targets, caught at Write/Edit time before the
+unused constant lands.
+
+The scan is deliberately conservative to keep false positives near zero:
+
+- Only dedicated constants modules participate; ordinary production modules,
+  whose file-global constants are governed by the use-count rule, are skipped.
+- A module declaring ``__all__`` is skipped: the author has named its export
+  surface explicitly, so a name listed there is live by declaration and a name
+  absent there is the author's stated intent, neither of which this check second
+  guesses.
+- A constant is live when its name appears anywhere under the scan root —
+  imported, read, listed in ``__all__``, or referenced in a string annotation —
+  in any ``.py`` module, including the constants module itself.
+- Test modules under the scan root still count as references, so a constant used
+  only by a test stays live.
+"""
+
+import ast
+import os
+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)
+
+from code_rules_shared import (  # noqa: E402
+    is_migration_file,
+    is_test_file,
+)
+
+from hooks_constants.dead_module_constant_constants import (  # noqa: E402
+    CONFIG_DIRECTORY_SEGMENT,
+    CONSTANTS_MODULE_SUFFIX,
+    DEAD_MODULE_CONSTANT_GUIDANCE,
+    DUNDER_ALL_NAME,
+    DUNDER_INIT_FILENAME,
+    MAX_DEAD_MODULE_CONSTANT_ISSUES,
+    MAX_SCAN_ROOT_FILE_COUNT,
+    MINIMUM_UPPER_SNAKE_LENGTH,
+    PYTHON_SOURCE_SUFFIX,
+)
+
+
+def _is_dedicated_constants_module(file_path: str) -> bool:
+    """Return whether a path is a dedicated constants module.
+
+    A dedicated constants module is one whose filename ends in
+    ``_constants.py`` or whose path includes a ``config`` directory segment.
+    These modules export named values to importers, so their constants need a
+    cross-module scan to judge liveness.
+
+    Args:
+        file_path: The destination path of the write.
+
+    Returns:
+        True for a constants-suffixed module or a module under ``config/``.
+    """
+    normalized_path = file_path.replace("\\", "/").lower()
+    if normalized_path.endswith(CONSTANTS_MODULE_SUFFIX):
+        return True
+    path_segments = normalized_path.split("/")
+    return CONFIG_DIRECTORY_SEGMENT in path_segments[:-1]
+
+
+def _is_upper_snake_name(name: str) -> bool:
+    """Return whether a name is an UPPER_SNAKE_CASE constant identifier."""
+    if len(name) < MINIMUM_UPPER_SNAKE_LENGTH:
+        return False
+    if not name.replace("_", "").isalnum():
+        return False
+    return name == name.upper() and any(each_char.isalpha() for each_char in name)
+
+
+def _module_constant_definitions(tree: ast.Module) -> list[tuple[str, int]]:
+    """Return (name, line) for each module-scope UPPER_SNAKE constant assignment.
+
+    Both plain assignments (``NAME = value``) and annotated assignments
+    (``NAME: type = value``) at module scope are collected. A name bound more
+    than once keeps the line of its first binding.
+
+    Args:
+        tree: The parsed constants module.
+
+    Returns:
+        One (name, line) pair per distinct module-scope constant, in source
+        order.
+    """
+    line_by_name: dict[str, int] = {}
+    for each_statement in tree.body:
+        targets: list[ast.expr] = []
+        if isinstance(each_statement, ast.Assign):
+            targets = list(each_statement.targets)
+        elif isinstance(each_statement, ast.AnnAssign) and each_statement.value is not None:
+            targets = [each_statement.target]
+        for each_target in targets:
+            if not isinstance(each_target, ast.Name):
+                continue
+            if not _is_upper_snake_name(each_target.id):
+                continue
+            if each_target.id not in line_by_name:
+                line_by_name[each_target.id] = each_statement.lineno
+    return list(line_by_name.items())
+
+
+def _statement_binds_dunder_all(statement: ast.stmt) -> bool:
+    """Return whether a single statement assigns or annotates ``__all__``."""
+    if isinstance(statement, ast.Assign):
+        return any(
+            isinstance(each_target, ast.Name) and each_target.id == DUNDER_ALL_NAME
+            for each_target in statement.targets
+        )
+    return (
+        isinstance(statement, ast.AnnAssign)
+        and isinstance(statement.target, ast.Name)
+        and statement.target.id == DUNDER_ALL_NAME
+    )
+
+
+def _module_declares_dunder_all(tree: ast.Module) -> bool:
+    """Return whether the module body assigns or annotates ``__all__``."""
+    return any(_statement_binds_dunder_all(each_node) for each_node in tree.body)
+
+
+def _referenced_names_in_source(source: str, load_only: bool = False) -> set[str]:
+    """Return every name a module references — imported, read, or re-exported.
+
+    Collects imported binding names, ``from`` import member names, name
+    references, attribute roots, and string literals (so a name listed in an
+    ``__all__`` literal or named in a string annotation counts as a reference).
+    A module that fails to parse contributes no names. With ``load_only`` set,
+    only ``Load``-context names count, so a constant's own assignment target in
+    the module being judged does not count as a reference to itself.
+
+    Args:
+        source: The full text of a ``.py`` module under the scan root.
+        load_only: When True, count only ``Load``-context name references,
+            excluding ``Store``/``Del`` targets. Used for the written constants
+            module so a definition is not mistaken for its own consumer.
+
+    Returns:
+        The set of names the module references.
+    """
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return set()
+    referenced_names: set[str] = set()
+    for each_node in ast.walk(tree):
+        if isinstance(each_node, ast.Name):
+            if load_only and not isinstance(each_node.ctx, ast.Load):
+                continue
+            referenced_names.add(each_node.id)
+        elif isinstance(each_node, ast.Import | ast.ImportFrom):
+            for each_alias in each_node.names:
+                referenced_names.add(each_alias.asname or each_alias.name)
+                referenced_names.add(each_alias.name)
+        elif isinstance(each_node, ast.Constant) and isinstance(each_node.value, str):
+            referenced_names.add(each_node.value)
+    return referenced_names
+
+
+def _scan_root_for_constants_module(file_path: str) -> Path:
+    """Return the directory tree to scan for references to the module's constants.
+
+    For a constants module inside a package subdirectory
+    (``pkg/foo_constants.py``), the scan root is the package's parent, so an
+    importer one directory up (``pkg/../consumer.py``) is in scope. For a
+    constants module at the top of a directory, the scan root is that directory.
+    A ``config/`` module's scan root is the parent of the ``config`` directory.
+
+    Args:
+        file_path: The destination path of the write.
+
+    Returns:
+        The absolute directory to scan recursively for references.
+    """
+    written_path = Path(file_path).resolve()
+    enclosing_directory = written_path.parent
+    if enclosing_directory.name.lower() == CONFIG_DIRECTORY_SEGMENT:
+        return enclosing_directory.parent
+    if (enclosing_directory / DUNDER_INIT_FILENAME).is_file():
+        return enclosing_directory.parent
+    return enclosing_directory
+
+
+def _all_referenced_names_under_root(
+    scan_root: Path,
+    written_path: Path,
+    written_content: str,
+) -> tuple[set[str], bool]:
+    """Return referenced names under the scan root and whether the file cap was hit.
+
+    The written module's on-disk text is replaced by ``written_content`` so the
+    post-edit view is judged, never the stale disk copy. Sibling modules are
+    read from disk. Reading stops after the configured file cap so a write under
+    an unexpectedly large tree cannot stall the hook; the boolean signals the
+    caller to treat that case as "cannot prove dead".
+
+    Args:
+        scan_root: The directory tree to scan.
+        written_path: The resolved path of the module being written.
+        written_content: The post-edit text of the written module.
+
+    Returns:
+        A (referenced_names, cap_was_hit) pair. The name set is the union across
+        every scanned module; cap_was_hit is True when the scan stopped at the
+        configured file cap before scanning the whole tree.
+    """
+    all_referenced_names = _referenced_names_in_source(written_content, load_only=True)
+    written_path_key = os.path.normcase(str(written_path))
+    scanned_file_count = 1
+    for each_path in scan_root.rglob("*" + PYTHON_SOURCE_SUFFIX):
+        if not each_path.is_file():
+            continue
+        if os.path.normcase(str(each_path.resolve())) == written_path_key:
+            continue
+        scanned_file_count += 1
+        if scanned_file_count > MAX_SCAN_ROOT_FILE_COUNT:
+            return all_referenced_names, True
+        try:
+            sibling_source = each_path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        all_referenced_names |= _referenced_names_in_source(sibling_source)
+    return all_referenced_names, False
+
+
+def _module_is_exempt_from_constant_check(file_path: str) -> bool:
+    """Return whether a path is exempt from the dead module-constant check.
+
+    Test modules and migration modules are exempt, and any module that is not a
+    dedicated constants module is out of scope because its file-global constants
+    are governed by the use-count rule instead.
+
+    Args:
+        file_path: The destination path of the write.
+
+    Returns:
+        True when the dead module-constant check must not run on this path.
+    """
+    if is_test_file(file_path):
+        return True
+    if is_migration_file(file_path):
+        return True
+    return not _is_dedicated_constants_module(file_path)
+
+
+def check_dead_module_constants(
+    content: str,
+    file_path: str,
+    full_file_content: str | None = None,
+) -> list[str]:
+    """Flag an UPPER_SNAKE constant in a constants module read by no module.
+
+    Runs only on a dedicated constants module (``*_constants.py`` or a module
+    under ``config/``); every other production module's file-global constants
+    are governed by the use-count rule instead. A constant is dead when its name
+    appears in no ``.py`` module anywhere under the enclosing package tree — not
+    imported, not read, not listed in an ``__all__`` literal, not named in a
+    string annotation. A module declaring its own ``__all__`` is skipped so the
+    author's explicit export surface is never second-guessed. Whole-file
+    analysis runs against ``full_file_content`` when supplied so an Edit fragment
+    is judged against the reconstructed post-edit file.
+
+    Args:
+        content: The new content under validation (Edit fragment or whole file).
+        file_path: The destination path, used for the constants-module gate and
+            the test/registry exemptions.
+        full_file_content: The reconstructed post-edit whole-file content for an
+            Edit, or None for a Write where ``content`` is already the whole file.
+
+    Returns:
+        One violation message per dead module-level constant, capped at the
+        configured maximum.
+    """
+    if _module_is_exempt_from_constant_check(file_path):
+        return []
+    effective_content = content if full_file_content is None else full_file_content
+    try:
+        tree = ast.parse(effective_content)
+    except SyntaxError:
+        return []
+    if _module_declares_dunder_all(tree):
+        return []
+    constant_definitions = _module_constant_definitions(tree)
+    if not constant_definitions:
+        return []
+    scan_root = _scan_root_for_constants_module(file_path)
+    written_path = Path(file_path).resolve()
+    all_referenced_names, cap_was_hit = _all_referenced_names_under_root(
+        scan_root,
+        written_path,
+        effective_content,
+    )
+    if cap_was_hit:
+        return []
+    issues: list[str] = []
+    for each_name, each_line in constant_definitions:
+        if each_name in all_referenced_names:
+            continue
+        issues.append(
+            f"Line {each_line}: module-level constant {each_name!r}"
+            f" - {DEAD_MODULE_CONSTANT_GUIDANCE}"
+        )
+        if len(issues) >= MAX_DEAD_MODULE_CONSTANT_ISSUES:
+            break
+    return issues

package/hooks/blocking/code_rules_duplicate_body.py

@@ -28,6 +28,15 @@ leave the exact violation class unguarded. The enforcer entry points route a
 hook ``.py`` target to this single check even though the full code-rules verdict
 stays off hook infrastructure, so a Write or pre-check against a file under the
 ``blocking/`` directory still blocks a copied sibling helper.
+
+``advise_cross_skill_duplicate_helper`` is the non-blocking companion for a
+different layout: a helper copied between two skills' ``scripts`` directories.
+Two skill folders install on their own, so a shared module would break
+independent install and a same-directory block would be a false positive on a
+sanctioned skill-isolation copy. The advisory prints a ``[CODE_RULES advisory]``
+line to stderr naming the source skill and function so a reviewer confirms the
+copy is intentional, and never enters the deny path. It fires only across skill
+folders; within one skill the blocking check above already covers the copy.
 """
 
 import ast
@@ -47,11 +56,16 @@ from code_rules_shared import (  # noqa: E402
 )
 
 from hooks_constants.duplicate_function_body_constants import (  # noqa: E402
+    CROSS_SKILL_ADVISORY_PREFIX,
+    CROSS_SKILL_DUPLICATE_GUIDANCE,
     DUNDER_INIT_FILENAME,
     DUPLICATE_BODY_GUIDANCE,
+    MAX_CROSS_SKILL_ADVISORY_ISSUES,
     MAX_DUPLICATE_BODY_ISSUES,
     MINIMUM_DUPLICATE_BODY_STATEMENTS,
     PYTHON_SOURCE_SUFFIX,
+    SKILL_SCRIPTS_DIRECTORY_NAME,
+    SKILLS_DIRECTORY_NAME,
 )
 
 
@@ -285,3 +299,141 @@ def check_duplicate_function_body_across_files(
         all_changed_lines,
         defer_scope_to_caller,
     )
+
+
+def _skill_scripts_root(file_path: str) -> Path | None:
+    """Return the ``skills/<name>/scripts`` root the written file sits under.
+
+    A skill's helper scripts live at ``<...>/skills/<skill-name>/scripts/<file>``.
+    This walks the written file's parents for a ``scripts`` directory whose own
+    parent's parent is named ``skills``, and returns that ``scripts`` directory.
+
+    Args:
+        file_path: The destination path of the write.
+
+    Returns:
+        The ``skills/<name>/scripts`` directory containing the file, or None when
+        the file is not under a skill's ``scripts`` directory.
+    """
+    written_path = Path(file_path).resolve()
+    for each_ancestor in written_path.parents:
+        if each_ancestor.name != SKILL_SCRIPTS_DIRECTORY_NAME:
+            continue
+        skill_directory = each_ancestor.parent
+        if skill_directory.parent.name == SKILLS_DIRECTORY_NAME:
+            return each_ancestor
+    return None
+
+
+def _other_skill_scripts_directories(scripts_root: Path) -> list[Path]:
+    """List the ``scripts`` directories of every sibling skill folder.
+
+    Args:
+        scripts_root: The ``skills/<name>/scripts`` directory of the written file.
+
+    Returns:
+        The ``scripts`` directory of each sibling skill that has one, excluding
+        the written file's own skill.
+    """
+    own_skill_directory = scripts_root.parent
+    skills_directory = own_skill_directory.parent
+    all_other_scripts_directories: list[Path] = []
+    try:
+        all_skill_entries = sorted(skills_directory.iterdir())
+    except OSError:
+        return []
+    for each_skill_directory in all_skill_entries:
+        if not each_skill_directory.is_dir():
+            continue
+        if each_skill_directory == own_skill_directory:
+            continue
+        candidate_scripts = each_skill_directory / SKILL_SCRIPTS_DIRECTORY_NAME
+        if candidate_scripts.is_dir():
+            all_other_scripts_directories.append(candidate_scripts)
+    return all_other_scripts_directories
+
+
+def _cross_skill_source_signatures(
+    all_other_scripts_directories: list[Path],
+) -> dict[str, list[str]]:
+    """Map each function body signature to the ``skill/module::function`` copies.
+
+    Args:
+        all_other_scripts_directories: The ``scripts`` directory of each sibling skill.
+
+    Returns:
+        A signature-to-source-names mapping naming the skill, module, and function
+        that carry each comparable top-level body.
+    """
+    source_names_by_signature: dict[str, list[str]] = {}
+    for each_scripts_directory in all_other_scripts_directories:
+        skill_name = each_scripts_directory.parent.name
+        try:
+            all_entries = sorted(each_scripts_directory.iterdir())
+        except OSError:
+            continue
+        for each_entry in all_entries:
+            if not _is_comparable_sibling(each_entry, ""):
+                continue
+            try:
+                sibling_source = each_entry.read_text(encoding="utf-8")
+                sibling_tree = ast.parse(sibling_source)
+            except (OSError, UnicodeDecodeError, SyntaxError):
+                continue
+            for each_name, each_signature in _top_level_function_signatures(sibling_tree).items():
+                location = f"{skill_name}/{each_entry.name}::{each_name}"
+                source_names_by_signature.setdefault(each_signature, []).append(location)
+    return source_names_by_signature
+
+
+def advise_cross_skill_duplicate_helper(content: str, file_path: str) -> None:
+    """Emit non-blocking stderr advisories for helpers copied across skill folders.
+
+    A top-level function in the file being written whose normalized body matches a
+    top-level function in another skill's ``scripts`` directory is surfaced as a
+    ``[CODE_RULES advisory]`` line on stderr — never a block. Two skill folders
+    install on their own, so a shared module would break independent install; the
+    copy is a defensible skill-isolation tradeoff the writer confirms rather than
+    a violation the gate denies. Within one skill the blocking duplicate-body gate
+    already covers the copy, so this advisory fires only across skill folders.
+
+    Test files and ``__init__.py`` are skipped on both the writing side and the
+    sibling side, mirroring the blocking gate.
+
+    Args:
+        content: The full post-edit file content being written.
+        file_path: The destination path of the write.
+    """
+    written_name = Path(file_path).name
+    if written_name == DUNDER_INIT_FILENAME:
+        return
+    if is_test_file(file_path):
+        return
+    scripts_root = _skill_scripts_root(file_path)
+    if scripts_root is None:
+        return
+    try:
+        written_tree = ast.parse(content)
+    except SyntaxError:
+        return
+    written_signatures = _top_level_function_signatures(written_tree)
+    if not written_signatures:
+        return
+    all_other_scripts_directories = _other_skill_scripts_directories(scripts_root)
+    if not all_other_scripts_directories:
+        return
+    source_names_by_signature = _cross_skill_source_signatures(all_other_scripts_directories)
+    advisory_count = 0
+    for each_name, each_signature in written_signatures.items():
+        matching_locations = source_names_by_signature.get(each_signature)
+        if not matching_locations:
+            continue
+        print(
+            f"{CROSS_SKILL_ADVISORY_PREFIX} {file_path}: function {each_name!r} "
+            f"duplicates {matching_locations[0]} in another skill — "
+            f"{CROSS_SKILL_DUPLICATE_GUIDANCE}",
+            file=sys.stderr,
+        )
+        advisory_count += 1
+        if advisory_count >= MAX_CROSS_SKILL_ADVISORY_ISSUES:
+            break

package/hooks/blocking/code_rules_enforcer.py

@@ -33,6 +33,7 @@ from code_rules_annotations_length import (  # noqa: E402
     check_known_pytest_fixture_annotations,
     check_parameter_annotations,
     check_return_annotations,
+    check_unused_known_pytest_fixture_parameters,
 )
 from code_rules_banned_identifiers import (  # noqa: E402
     check_banned_identifiers,
@@ -54,11 +55,15 @@ from code_rules_constants_config import (  # noqa: E402
 from code_rules_dead_dataclass_field import (  # noqa: E402
     check_dead_dataclass_fields,
 )
+from code_rules_dead_module_constant import (  # noqa: E402
+    check_dead_module_constants,
+)
 from code_rules_docstrings import (  # noqa: E402
     check_docstring_args_match_signature,
     check_docstring_format,
 )
 from code_rules_duplicate_body import (  # noqa: E402
+    advise_cross_skill_duplicate_helper,
     check_duplicate_function_body_across_files,
 )
 from code_rules_imports_logging import (  # noqa: E402
@@ -85,6 +90,9 @@ from code_rules_optional_params import (  # noqa: E402
     check_duplicated_format_patterns,
     check_unused_optional_parameters,
 )
+from code_rules_orphan_css_class import (  # noqa: E402
+    check_orphan_css_classes,
+)
 from code_rules_paths_syspath import (  # noqa: E402
     check_hardcoded_user_paths,
     check_sys_path_insert_deduplication_guard,
@@ -120,6 +128,7 @@ from code_rules_typeddict_stub import (  # noqa: E402
     check_stub_implementations,
     check_thin_wrapper_files,
     check_typed_dict_encode_decode,
+    check_zero_payload_function_alias,
 )
 from code_rules_unused_imports import (  # noqa: E402
     check_unused_module_level_imports,
@@ -228,6 +237,7 @@ def validate_content(
         all_issues.extend(check_test_branching_in_production(effective_content, file_path))
         all_issues.extend(check_bare_except(effective_content, file_path))
         all_issues.extend(check_thin_wrapper_files(effective_content, file_path))
+        all_issues.extend(check_zero_payload_function_alias(effective_content, file_path))
         all_issues.extend(check_boundary_types(effective_content, file_path))
         all_issues.extend(check_docstring_format(effective_content, file_path))
         all_issues.extend(check_docstring_args_match_signature(effective_content, file_path))
@@ -269,9 +279,15 @@ def validate_content(
         all_issues.extend(
             check_dead_dataclass_fields(content, file_path, full_file_content)
         )
+        all_issues.extend(
+            check_dead_module_constants(content, file_path, full_file_content)
+        )
         all_issues.extend(check_library_print(content, file_path))
         all_issues.extend(check_parameter_annotations(content, file_path))
         all_issues.extend(check_known_pytest_fixture_annotations(content, file_path))
+        all_issues.extend(
+            check_unused_known_pytest_fixture_parameters(content, file_path)
+        )
         all_issues.extend(check_return_annotations(content, file_path))
         all_issues.extend(
             check_function_length(
@@ -285,8 +301,10 @@ def validate_content(
         all_issues.extend(check_inline_literal_collections(content, file_path))
         all_issues.extend(check_inline_tuple_string_magic(content, file_path))
         all_issues.extend(check_string_literal_magic(content, file_path))
+        all_issues.extend(check_orphan_css_classes(effective_content, file_path))
         check_incomplete_mocks(content, file_path)
         check_duplicated_format_patterns(content, file_path)
+        advise_cross_skill_duplicate_helper(effective_content, file_path)
 
     elif extension in ALL_JAVASCRIPT_EXTENSIONS:
         if not is_test_file(file_path):
@@ -383,18 +401,20 @@ def _is_hook_infrastructure_python_target(file_path: str) -> bool:
     return get_file_extension(file_path) in ALL_PYTHON_EXTENSIONS
 
 
-def _hook_infrastructure_duplicate_body_issues(
+def _hook_infrastructure_blocking_issues(
     content: str,
     file_path: str,
     full_file_content: str | None = None,
     prior_full_file_content: str = "",
 ) -> list[str]:
-    """Run only the cross-file duplicate-body check for a hook Python target.
+    """Run the checks that still guard a hook Python target.
 
     The whole code-rules verdict stays off hook-infrastructure files, so this
-    runs the single check that must still guard them, span-scoped to the lines
-    an edit touched exactly as ``validate_content`` scopes it for production
-    code.
+    runs the two checks that must still guard them: the cross-file duplicate-body
+    check, span-scoped to the lines an edit touched exactly as ``validate_content``
+    scopes it for production code; and the zero-payload alias check, whose
+    docstring names hook modules as its motivating case, run over the whole
+    post-edit file.
 
     Args:
         content: The fragment or whole-file body under validation.
@@ -405,7 +425,8 @@ def _hook_infrastructure_duplicate_body_issues(
             recover the changed lines on an Edit.
 
     Returns:
-        The in-scope duplicate-body violations for the target.
+        The in-scope duplicate-body violations and the zero-payload alias
+        violations for the target.
     """
     effective_content = content if full_file_content is None else full_file_content
     all_changed_lines = (
@@ -413,11 +434,13 @@ def _hook_infrastructure_duplicate_body_issues(
         if full_file_content is not None
         else None
     )
-    return check_duplicate_function_body_across_files(
+    all_issues = check_duplicate_function_body_across_files(
         effective_content,
         file_path,
         all_changed_lines,
     )
+    all_issues.extend(check_zero_payload_function_alias(effective_content, file_path))
+    return all_issues
 
 
 def _without_line_prefix(violation_text: str) -> str:
@@ -540,7 +563,7 @@ def _run_precheck(
         old_content = _read_existing_file_content(target_path) or ""
         all_issues = validate_content(candidate_content, target_path, old_content)
     else:
-        all_issues = _hook_infrastructure_duplicate_body_issues(
+        all_issues = _hook_infrastructure_blocking_issues(
             candidate_content, target_path
         )
     for each_issue in all_issues:
@@ -755,18 +778,18 @@ def _report_blocking_violations(
     )
 
 
-def _report_hook_duplicate_body(
+def _report_hook_blocking_issues(
     content: str,
     file_path: str,
     full_file_content_after_edit: str | None,
     prior_full_file_content: str,
     deny_stream: TextIO,
 ) -> None:
-    """Write a deny payload when a hook target copies a sibling function body.
+    """Write a deny payload when a hook target trips a check that still guards it.
 
-    The full code-rules verdict stays off hook-infrastructure files; this runs
-    the single duplicate-body check that must still guard them and emits the deny
-    payload when it fires.
+    The full code-rules verdict stays off hook-infrastructure files; this runs the
+    two checks that must still guard them — the cross-file duplicate-body check and
+    the zero-payload alias check — and emits the deny payload when either fires.
 
     Args:
         content: The fragment or whole-file body under validation.
@@ -776,7 +799,7 @@ def _report_hook_duplicate_body(
         prior_full_file_content: The on-disk content before the edit.
         deny_stream: The stream the JSON deny payload is written to.
     """
-    all_blocking_issues = _hook_infrastructure_duplicate_body_issues(
+    all_blocking_issues = _hook_infrastructure_blocking_issues(
         content,
         file_path,
         full_file_content_after_edit,
@@ -835,7 +858,7 @@ def main(all_arguments: list[str]) -> None:
         sys.exit(0)
 
     if not runs_full_verdict:
-        _report_hook_duplicate_body(
+        _report_hook_blocking_issues(
             content,
             file_path,
             full_file_content_after_edit,