claude-dev-env 1.82.0 → 1.83.0

package/hooks/blocking/code_rules_constants_config.py

@@ -1,4 +1,9 @@
-"""Constants-outside-config checks and the file-global constant use-count check."""
+"""Constants-outside-config checks and the file-global constant use-count check.
+
+Also carries check_config_duplicate_path_anchor, which flags a config module
+that rebuilds a directory a sibling module in the same package already
+anchors from its own location.
+"""
 
 import ast
 import re
@@ -24,6 +29,9 @@ from code_rules_shared import (  # noqa: E402
     is_workflow_registry_file,
 )
 
+from hooks_constants.blocking_check_limits import (  # noqa: E402
+    MAX_CONFIG_DUPLICATE_PATH_ANCHOR_ISSUES,
+)
 from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
     ALL_PYTHON_EXTENSIONS,
     FILE_GLOBAL_UPPER_SNAKE_PATTERN,
@@ -253,3 +261,153 @@ def check_file_global_constants_use_count(content: str, file_path: str) -> list[
             )
 
     return issues
+
+
+def _references_dunder_file(node: ast.AST) -> bool:
+    """Return True when the expression tree reads ``__file__``."""
+    return any(
+        isinstance(each_node, ast.Name) and each_node.id == "__file__"
+        for each_node in ast.walk(node)
+    )
+
+
+def _file_anchor_up_count(node: ast.AST) -> Optional[int]:
+    """Return how many directory levels a ``__file__`` anchor climbs, else None.
+
+    A ``parents[N]`` subscript on a ``__file__``-rooted expression climbs
+    ``N + 1`` levels; a chain of ``.parent`` attributes climbs one level per
+    link. Any other expression returns None.
+    """
+    if isinstance(node, ast.Subscript):
+        subscripted = node.value
+        if (
+            isinstance(subscripted, ast.Attribute)
+            and subscripted.attr == "parents"
+            and isinstance(node.slice, ast.Constant)
+            and isinstance(node.slice.value, int)
+            and _references_dunder_file(subscripted.value)
+        ):
+            return node.slice.value + 1
+    parent_step_count = 0
+    current_node = node
+    while isinstance(current_node, ast.Attribute) and current_node.attr == "parent":
+        parent_step_count += 1
+        current_node = current_node.value
+    if parent_step_count and _references_dunder_file(current_node):
+        return parent_step_count
+    return None
+
+
+def _anchored_join_signature(node: ast.AST) -> Optional[tuple[int, str]]:
+    """Return (up_count, first literal segment) for an anchored ``/`` join, else None.
+
+    Flattens a left-leaning ``/`` chain, requires the left-most operand to be
+    a ``__file__`` anchor, and requires the first joined segment to be a
+    string literal.
+    """
+    if not isinstance(node, ast.BinOp) or not isinstance(node.op, ast.Div):
+        return None
+    all_segments: list[str] = []
+    current_node: ast.expr = node
+    while isinstance(current_node, ast.BinOp) and isinstance(current_node.op, ast.Div):
+        right_operand = current_node.right
+        if isinstance(right_operand, ast.Constant) and isinstance(right_operand.value, str):
+            all_segments.insert(0, right_operand.value)
+        else:
+            all_segments.insert(0, "")
+        current_node = current_node.left
+    anchor_up_count = _file_anchor_up_count(current_node)
+    if anchor_up_count is None or not all_segments or not all_segments[0]:
+        return None
+    return anchor_up_count, all_segments[0]
+
+
+def _module_anchor_signatures(module_tree: ast.Module) -> dict[tuple[int, str], int]:
+    """Return line numbers keyed by anchored-join signature for top-level assignments."""
+    signatures_by_key: dict[tuple[int, str], int] = {}
+    for each_statement in module_tree.body:
+        if isinstance(each_statement, ast.Assign):
+            assigned_expression = each_statement.value
+        elif isinstance(each_statement, ast.AnnAssign) and each_statement.value is not None:
+            assigned_expression = each_statement.value
+        else:
+            continue
+        for each_node in ast.walk(assigned_expression):
+            signature = _anchored_join_signature(each_node)
+            if signature is not None:
+                signatures_by_key.setdefault(signature, each_statement.lineno)
+    return signatures_by_key
+
+
+def _config_anchor_check_applies(file_path: str) -> bool:
+    """Return whether the duplicate-path-anchor check should inspect this file."""
+    return (
+        is_config_file(file_path)
+        and not is_test_file(file_path)
+        and get_file_extension(file_path) in ALL_PYTHON_EXTENSIONS
+    )
+
+
+def _sibling_anchor_owner_names(config_directory: Path, written_name: str) -> dict[tuple[int, str], str]:
+    """Return the sibling config module name that first builds each anchor signature."""
+    owner_name_by_signature: dict[tuple[int, str], str] = {}
+    for each_sibling_path in sorted(config_directory.glob("*.py")):
+        if each_sibling_path.name == written_name or is_test_file(str(each_sibling_path)):
+            continue
+        try:
+            sibling_tree = ast.parse(each_sibling_path.read_text(encoding="utf-8"))
+        except (OSError, SyntaxError, UnicodeDecodeError):
+            continue
+        for each_signature in _module_anchor_signatures(sibling_tree):
+            owner_name_by_signature.setdefault(each_signature, each_sibling_path.name)
+    return owner_name_by_signature
+
+
+def check_config_duplicate_path_anchor(content: str, file_path: str) -> list[str]:
+    """Flag a config module re-anchoring a path a sibling config module already builds.
+
+    Two config modules in the same ``config/`` directory that each anchor
+    ``Path(__file__)`` the same number of levels up and join the same first
+    literal segment are two sources of truth for one directory: a rename in
+    one module silently leaves the other pointing at the old folder. The
+    check fires on a config-module write whose module-level assignment joins
+    a ``__file__`` anchor (``parents[N]`` or a ``.parent`` chain) with a
+    literal segment that a sibling module in the same directory also joins at
+    the same depth. Compose one shared base constant and build the other path
+    from it. Test files, non-Python files, and modules outside a config
+    directory are exempt; an unreadable or unparseable sibling is skipped.
+
+    Args:
+        content: The Python source under validation.
+        file_path: The destination path, used to locate sibling config modules.
+
+    Returns:
+        One issue line per duplicated anchor, capped at the configured maximum.
+    """
+    if not _config_anchor_check_applies(file_path):
+        return []
+    try:
+        module_tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    written_signatures = _module_anchor_signatures(module_tree)
+    if not written_signatures:
+        return []
+    config_directory = Path(file_path).parent
+    if not config_directory.is_dir():
+        return []
+    owner_name_by_signature = _sibling_anchor_owner_names(config_directory, Path(file_path).name)
+    issues: list[str] = []
+    for each_signature, each_line_number in sorted(written_signatures.items(), key=lambda pair: pair[1]):
+        owner_name = owner_name_by_signature.get(each_signature)
+        if owner_name is None:
+            continue
+        anchor_up_count, first_segment = each_signature
+        issues.append(
+            f"Line {each_line_number}: joins {first_segment} onto the same base, "
+            f"{anchor_up_count} levels above this file, that {owner_name} "
+            "already builds - define the base once and compose both paths from it"
+        )
+        if len(issues) >= MAX_CONFIG_DUPLICATE_PATH_ANCHOR_ISSUES:
+            break
+    return issues

package/hooks/blocking/code_rules_docstrings.py

@@ -25,6 +25,7 @@ from hooks_constants.blocking_check_limits import (  # noqa: E402
     ALL_ABSENT_TYPE_CHECKING_GATE_DOCSTRING_PHRASES,
     ALL_DATA_SCHEMA_CONSTANT_NAME_MARKERS,
     ALL_DATA_SCHEMA_DOCSTRING_ACKNOWLEDGEMENT_PHRASES,
+    ALL_DELEGATION_ENUMERATION_STOP_TOKENS,
     ALL_DOCSTRING_EXCLUSIVE_SCOPE_PHRASES,
     ALL_DOCSTRING_EXEMPT_DECORATOR_NAMES,
     ALL_DOCSTRING_FILE_REFERENCE_SUFFIXES,
@@ -63,6 +64,7 @@ from hooks_constants.blocking_check_limits import (  # noqa: E402
     MAX_DOCSTRING_ARGS_SIGNATURE_ISSUES,
     MAX_DOCSTRING_ARGS_SPAN_SCOPE_ISSUES,
     MAX_DOCSTRING_CARDINAL_FAMILY_ISSUES,
+    MAX_DOCSTRING_DELEGATION_ENUMERATION_ISSUES,
     MAX_DOCSTRING_FALLBACK_BRANCH_ISSUES,
     MAX_DOCSTRING_FIELD_RUNMODE_OUTCOME_ISSUES,
     MAX_DOCSTRING_FORMAT_ISSUES,
@@ -82,16 +84,21 @@ from hooks_constants.blocking_check_limits import (  # noqa: E402
     MAX_MODULE_DOCSTRING_CHECK_ROSTER_ISSUES,
     MAX_MODULE_DOCSTRING_DATA_SCHEMA_SCOPE_ISSUES,
     MINIMUM_CONSTANT_FAMILY_MEMBERS_FOR_CARDINAL_CHECK,
+    MINIMUM_DELEGATION_ENUMERATION_ITEMS,
     MINIMUM_DOCSTRING_FAMILY_OVERLAP_FOR_CARDINAL_CHECK,
     MINIMUM_NAMED_LINEAR_STEPS_FOR_DISPATCH_CHECK,
     MINIMUM_NAMED_MARKS_FOR_PROSE_ENUMERATION,
     MINIMUM_PUBLIC_CHECKS_FOR_MODULE_DOCSTRING_ROSTER,
     MINIMUM_PUBLIC_METHODS_FOR_CLASS_DOCSTRING_BREADTH,
+    MINIMUM_SIBLING_OCCURRENCES_FOR_SHARED_TOKEN,
     MINIMUM_TOKENS_FOR_DISPATCH_CALLEE,
     MINIMUM_TUPLE_MEMBERS_FOR_DOCSTRING_ENUMERATION,
     MODULE_DOCSTRING_DATA_SCHEMA_CONSTANT_SAMPLE_LIMIT,
+    NEIGHBOR_SCAN_FILE_LIMIT,
+    POINTER_TO_DELEGATE_PATTERN,
     PYTHON_MODULE_FILE_SUFFIX,
     SINGLE_DICT_KEY_COUNT_FOR_PLURAL_CARDINALITY_DRIFT,
+    TOKEN_WORD_PATTERN,
     TYPE_CHECKING_IDENTIFIER_MARKER,
     WORD_BOUNDARY_REGEX,
     ZIPFILE_ALLOW_ZIP64_KEYWORD,
@@ -1128,14 +1135,48 @@ def _distinctive_name_tokens(check_name: str) -> list[str]:
     ]
 
 
-def _docstring_mentions_check(docstring_text: str, check_name: str) -> bool:
+def _shared_sibling_name_tokens(all_check_names: list[str]) -> frozenset[str]:
+    token_occurrence_count: dict[str, int] = {}
+    for each_check_name in all_check_names:
+        for each_token in set(each_token.lower() for each_token in _name_tokens(each_check_name)):
+            token_occurrence_count[each_token] = token_occurrence_count.get(each_token, 0) + 1
+    return frozenset(
+        each_token
+        for each_token, each_count in token_occurrence_count.items()
+        if each_count >= MINIMUM_SIBLING_OCCURRENCES_FOR_SHARED_TOKEN
+    )
+
+
+def _module_distinctive_name_tokens(
+    check_name: str, all_shared_sibling_tokens: frozenset[str]
+) -> list[str]:
+    return [
+        each_token
+        for each_token in _distinctive_name_tokens(check_name)
+        if each_token.lower() not in all_shared_sibling_tokens
+    ]
+
+
+def _token_present_in_text(token: str, lowered_text: str) -> bool:
+    lowered_token = token.lower()
+    if lowered_token in lowered_text:
+        return True
+    return lowered_token.endswith("s") and lowered_token[:-1] in lowered_text
+
+
+def _docstring_mentions_check(
+    docstring_text: str, check_name: str, all_shared_sibling_tokens: frozenset[str]
+) -> bool:
     lowered_docstring = docstring_text.lower()
     if check_name.lower() in lowered_docstring:
         return True
-    distinctive_tokens = _distinctive_name_tokens(check_name)
-    if not distinctive_tokens:
+    distinguishing_tokens = _module_distinctive_name_tokens(check_name, all_shared_sibling_tokens)
+    if not distinguishing_tokens:
         return True
-    return any(each_token.lower() in lowered_docstring for each_token in distinctive_tokens)
+    return any(
+        _token_present_in_text(each_token, lowered_docstring)
+        for each_token in distinguishing_tokens
+    )
 
 
 def check_module_docstring_names_public_checks(content: str, file_path: str) -> list[str]:
@@ -1146,10 +1187,17 @@ def check_module_docstring_names_public_checks(content: str, file_path: str) ->
     roster. When the module grows a public ``check_*`` entry point the summary
     never names, the enumeration under-describes the module — the
     docstring-prose-vs-implementation drift the repo flags as Category O6/O8.
-    A check counts as named when the full ``check_*`` name, or any distinctive
-    (non-generic) underscore-separated token of it, appears in the summary;
-    generic tokens (``check``, ``test``, ``tests``) do not count. A module with
-    two or more public checks and any check the summary never names is reported
+    A check counts as named when the full ``check_*`` name, or a
+    module-distinctive underscore-separated token of it, appears in the summary
+    (matched allowing a trailing-``s`` plural). A token is module-distinctive
+    when it is non-generic (generic tokens ``check``, ``test``, ``tests`` never
+    count) and it is not shared by two or more of the module's check names — a
+    token such as ``string`` or ``magic`` that recurs across sibling checks is
+    no evidence that any one check is named, so a check whose only
+    summary-present tokens are shared ones is reported. A check with no
+    module-distinctive token is treated as named, since the summary cannot single
+    it out. A module with two or more public checks and any check the summary
+    never names is reported
     so the summary names the full roster. Modules with a multi-paragraph
     docstring body are left to the audit lane, since their prose can carry the
     roster without naming each check by name. This check covers hook
@@ -1175,9 +1223,10 @@ def check_module_docstring_names_public_checks(content: str, file_path: str) ->
     public_check_names = _module_public_check_names(parsed_tree)
     if len(public_check_names) < MINIMUM_PUBLIC_CHECKS_FOR_MODULE_DOCSTRING_ROSTER:
         return []
+    all_shared_sibling_tokens = _shared_sibling_name_tokens(public_check_names)
     issues: list[str] = []
     for each_name in public_check_names:
-        if _docstring_mentions_check(module_docstring, each_name):
+        if _docstring_mentions_check(module_docstring, each_name, all_shared_sibling_tokens):
             continue
         issues.append(
             f"Line 1: module docstring omits public check {each_name}() — name every "
@@ -2874,3 +2923,257 @@ def check_docstring_raises_unraisable_largezipfile(
         if len(issues) >= MAX_DOCSTRING_RAISES_LARGEZIPFILE_ISSUES:
             break
     return issues[:MAX_DOCSTRING_RAISES_LARGEZIPFILE_ISSUES]
+
+
+def _leading_summary_line(raw_docstring: str) -> str:
+    summary_paragraph = raw_docstring.strip().split("\n\n", maxsplit=1)[0]
+    return " ".join(summary_paragraph.split())
+
+
+def _pointer_target_stem(raw_docstring: str) -> str:
+    marker_match = POINTER_TO_DELEGATE_PATTERN.search(raw_docstring)
+    return marker_match.group(1) if marker_match is not None else ""
+
+
+def _listed_entries(wrapper_summary: str) -> list[str]:
+    marker_match = POINTER_TO_DELEGATE_PATTERN.search(wrapper_summary)
+    if marker_match is None:
+        return []
+    listed_text = wrapper_summary[: marker_match.start()].strip().rstrip(";,").strip()
+    normalized_text = re.sub(r"\s+and\s+", ", ", listed_text, flags=re.IGNORECASE)
+    return [
+        each_entry.strip()
+        for each_entry in normalized_text.split(",")
+        if each_entry.strip()
+    ]
+
+
+def _words_of_entry(raw_entry: str) -> list[str]:
+    return [
+        each_token.lower()
+        for each_token in TOKEN_WORD_PATTERN.findall(raw_entry)
+        if each_token.lower() not in ALL_DELEGATION_ENUMERATION_STOP_TOKENS
+    ]
+
+
+def _matches_any_word(delegate_summary: str, all_distinct_words: list[str]) -> bool:
+    lowered_summary = delegate_summary.lower()
+    return any(
+        re.search(
+            WORD_BOUNDARY_REGEX + re.escape(each_token) + WORD_BOUNDARY_REGEX,
+            lowered_summary,
+        )
+        is not None
+        for each_token in all_distinct_words
+    )
+
+
+def _absent_entries(wrapper_summary: str, delegate_summary: str) -> list[str]:
+    all_entries = _listed_entries(wrapper_summary)
+    if len(all_entries) < MINIMUM_DELEGATION_ENUMERATION_ITEMS:
+        return []
+    if "," not in delegate_summary:
+        return []
+    absent_entry_texts: list[str] = []
+    for each_entry in all_entries:
+        distinct_words = _words_of_entry(each_entry)
+        if not distinct_words:
+            continue
+        if _matches_any_word(delegate_summary, distinct_words):
+            continue
+        absent_entry_texts.append(each_entry)
+    return absent_entry_texts
+
+
+def _top_level_definitions_and_methods(
+    parsed_tree: ast.Module,
+) -> list[ast.FunctionDef | ast.AsyncFunctionDef]:
+    all_definitions_and_methods: list[ast.FunctionDef | ast.AsyncFunctionDef] = []
+    for each_node in parsed_tree.body:
+        if isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            all_definitions_and_methods.append(each_node)
+        elif isinstance(each_node, ast.ClassDef):
+            all_definitions_and_methods.extend(
+                each_member
+                for each_member in each_node.body
+                if isinstance(each_member, (ast.FunctionDef, ast.AsyncFunctionDef))
+            )
+    return all_definitions_and_methods
+
+
+def _entries_by_function_name(parsed_tree: ast.Module) -> dict[str, tuple[int, str]]:
+    entries_by_name: dict[str, tuple[int, str]] = {}
+    ambiguous_names: set[str] = set()
+    for each_definition in _top_level_definitions_and_methods(parsed_tree):
+        if each_definition.name in entries_by_name:
+            ambiguous_names.add(each_definition.name)
+            continue
+        entries_by_name[each_definition.name] = (
+            each_definition.lineno,
+            ast.get_docstring(each_definition) or "",
+        )
+    for each_ambiguous_name in ambiguous_names:
+        del entries_by_name[each_ambiguous_name]
+    return entries_by_name
+
+
+def _source_text_or_empty(source_path: Path) -> str:
+    try:
+        return source_path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return ""
+
+
+def _parsed_module_or_none(source_text: str) -> ast.Module | None:
+    if not source_text:
+        return None
+    try:
+        return ast.parse(source_text)
+    except SyntaxError:
+        return None
+
+
+def _outbound_pointer_issues(parsed_tree: ast.Module, file_path: str) -> list[str]:
+    parent_directory = Path(file_path).parent
+    issues: list[str] = []
+    delegate_entries_by_stem: dict[str, dict[str, tuple[int, str]]] = {}
+    for each_node in _top_level_definitions_and_methods(parsed_tree):
+        wrapper_docstring = ast.get_docstring(each_node) or ""
+        wrapper_summary = _leading_summary_line(wrapper_docstring)
+        target_stem = _pointer_target_stem(wrapper_summary)
+        if not target_stem:
+            continue
+        if target_stem not in delegate_entries_by_stem:
+            delegate_path = parent_directory / (target_stem + PYTHON_MODULE_FILE_SUFFIX)
+            delegate_tree = _parsed_module_or_none(_source_text_or_empty(delegate_path))
+            delegate_entries_by_stem[target_stem] = (
+                _entries_by_function_name(delegate_tree)
+                if delegate_tree is not None
+                else {}
+            )
+        delegate_entry = delegate_entries_by_stem[target_stem].get(each_node.name)
+        if delegate_entry is None:
+            continue
+        delegate_summary = _leading_summary_line(delegate_entry[1])
+        for each_entry in _absent_entries(wrapper_summary, delegate_summary):
+            issues.append(
+                f"Line {each_node.lineno}: {each_node.name}() names "
+                f"'{each_entry}' in its summary, but the summary of the "
+                f"same-named function in {target_stem} omits it - align the "
+                "two summaries (Category O6 docstring-vs-implementation drift)"
+            )
+    return issues
+
+
+def _scannable_neighbor_paths(written_path: Path) -> list[Path]:
+    try:
+        all_neighbor_paths = sorted(
+            written_path.parent.glob("*" + PYTHON_MODULE_FILE_SUFFIX)
+        )
+    except OSError:
+        return []
+    scannable_paths: list[Path] = []
+    for each_path in all_neighbor_paths:
+        if each_path.name == written_path.name:
+            continue
+        if is_strict_test_file(str(each_path)):
+            continue
+        scannable_paths.append(each_path)
+        if len(scannable_paths) >= NEIGHBOR_SCAN_FILE_LIMIT:
+            break
+    return scannable_paths
+
+
+def _inbound_pointer_issues(
+    neighbor_tree: ast.Module,
+    neighbor_name: str,
+    delegate_stem: str,
+    all_entries_by_name: dict[str, tuple[int, str]],
+) -> list[str]:
+    issues: list[str] = []
+    for each_node in _top_level_definitions_and_methods(neighbor_tree):
+        wrapper_docstring = ast.get_docstring(each_node) or ""
+        wrapper_summary = _leading_summary_line(wrapper_docstring)
+        if _pointer_target_stem(wrapper_summary) != delegate_stem:
+            continue
+        delegate_entry = all_entries_by_name.get(each_node.name)
+        if delegate_entry is None:
+            continue
+        delegate_summary = _leading_summary_line(delegate_entry[1])
+        for each_entry in _absent_entries(wrapper_summary, delegate_summary):
+            issues.append(
+                f"Line {delegate_entry[0]}: {each_node.name}() summary omits "
+                f"'{each_entry}', named by the pointing wrapper docstring in "
+                f"{neighbor_name} - reword that wrapper docstring in the same "
+                "change (Category O6 docstring-vs-implementation drift)"
+            )
+    return issues
+
+
+def _neighbor_scan_issues(parsed_tree: ast.Module, file_path: str) -> list[str]:
+    written_path = Path(file_path)
+    all_entries_by_name = _entries_by_function_name(parsed_tree)
+    if not all_entries_by_name:
+        return []
+    issues: list[str] = []
+    for each_neighbor in _scannable_neighbor_paths(written_path):
+        neighbor_source = _source_text_or_empty(each_neighbor)
+        if POINTER_TO_DELEGATE_PATTERN.search(neighbor_source) is None:
+            continue
+        neighbor_tree = _parsed_module_or_none(neighbor_source)
+        if neighbor_tree is None:
+            continue
+        issues.extend(
+            _inbound_pointer_issues(
+                neighbor_tree,
+                each_neighbor.name,
+                written_path.stem,
+                all_entries_by_name,
+            )
+        )
+    return issues
+
+
+def check_docstring_delegation_summary_enumeration_drift(
+    content: str, file_path: str
+) -> list[str]:
+    """Flag a delegating wrapper summary that its delegation target contradicts.
+
+    The drift this catches: a thin wrapper method whose docstring summary
+    enumerates the actions it stands for and points at the home of the real
+    body ("Apply App Info, Russia, review note, publication edits; full doc
+    on `listing_edit_flow`"), while the same-named function in that named
+    sibling file carries a summary enumeration that omits one of those
+    actions. An edit that moves one action out of the delegated body and
+    rewords only the delegated docstring leaves the wrapper claiming work the
+    body skips. The gate fires from both sides. On a wrapper save, it resolves
+    the named sibling file beside the saved one, finds the same-named
+    function, and compares the two summary enumerations. On a delegated-body
+    save, it scans neighboring .py files for a wrapper docstring pointing at
+    the saved stem and runs the same comparison, so the save that removes the
+    action hears about the stranded wrapper docstring. A listed action counts
+    as named when any of its distinctive words appears at a word boundary in
+    the delegated summary. The comparison binds when the wrapper enumerates
+    two or more actions and the delegated summary itself holds a comma, so a
+    plain one-purpose delegated summary never gets compared. This covers the
+    deterministic delegating-wrapper slice of Category O6
+    docstring-prose-vs-implementation drift.
+
+    Args:
+        content: The source text to inspect.
+        file_path: The path the source will be written to, used for exemptions
+            and to resolve the delegated or wrapping file beside it.
+
+    Returns:
+        One issue per listed wrapper action the paired delegated summary
+        omits, capped at the module limit.
+    """
+    if is_strict_test_file(file_path) or is_hook_infrastructure(file_path):
+        return []
+    try:
+        parsed_tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    issues = _outbound_pointer_issues(parsed_tree, file_path)
+    issues.extend(_neighbor_scan_issues(parsed_tree, file_path))
+    return issues[:MAX_DOCSTRING_DELEGATION_ENUMERATION_ISSUES]

package/hooks/blocking/code_rules_enforcer.py

@@ -51,6 +51,7 @@ from code_rules_comments import (  # noqa: E402
     check_comment_changes,
 )
 from code_rules_constants_config import (  # noqa: E402
+    check_config_duplicate_path_anchor,
     check_constants_outside_config,
     check_constants_outside_config_advisory,
     check_file_global_constants_use_count,
@@ -75,6 +76,7 @@ from code_rules_docstrings import (  # noqa: E402
     check_docstring_args_match_signature,
     check_docstring_args_single_line_scope_vs_span,
     check_docstring_cardinal_count_matches_constant_family,
+    check_docstring_delegation_summary_enumeration_drift,
     check_docstring_documents_unreferenced_parameter,
     check_docstring_fallback_branch_coverage,
     check_docstring_field_runmode_outcome,
@@ -105,11 +107,15 @@ from code_rules_imports_logging import (  # noqa: E402
     check_e2e_test_naming,
     check_import_block_sorted,
     check_imports_at_top,
+    check_js_bare_flag_return_directive,
     check_js_resume_task_enumeration_coverage,
     check_js_returns_object_schemaless_branch,
+    check_js_sibling_return_object_key_drift,
     check_library_print,
+    check_logging_adjacent_string_literals,
     check_logging_fstrings,
     check_logging_printf_tokens,
+    check_naive_datetime_construction,
     check_windows_api_none,
 )
 from code_rules_js_conventions import (  # noqa: E402
@@ -127,6 +133,7 @@ from code_rules_naming_collection import (  # noqa: E402
     check_collection_prefix,
     check_loop_variable_naming,
     check_polarity_name_contradiction,
+    check_referenced_underscore_loop_variable,
     check_stuttering_collection_prefix,
 )
 from code_rules_optional_params import (  # noqa: E402
@@ -154,6 +161,7 @@ from code_rules_shared import (  # noqa: E402
 from code_rules_string_magic import (  # noqa: E402
     check_inline_literal_collections,
     check_inline_tuple_string_magic,
+    check_join_separator_string_magic,
     check_string_literal_magic,
     check_whitespace_indentation_magic,
 )
@@ -268,10 +276,13 @@ def validate_content(
         )
         all_issues.extend(check_logging_fstrings(content))
         all_issues.extend(check_logging_printf_tokens(content, file_path))
+        all_issues.extend(check_logging_adjacent_string_literals(content, file_path))
         all_issues.extend(check_windows_api_none(content))
+        all_issues.extend(check_naive_datetime_construction(content, file_path))
         all_issues.extend(check_magic_values(content, file_path))
         all_issues.extend(check_fstring_structural_literals(content, file_path))
         all_issues.extend(check_constants_outside_config(content, file_path))
+        all_issues.extend(check_config_duplicate_path_anchor(content, file_path))
         all_issues.extend(check_constants_outside_config_advisory(content, file_path))
         all_issues.extend(check_file_global_constants_use_count(content, file_path))
         all_issues.extend(
@@ -389,6 +400,11 @@ def validate_content(
         all_issues.extend(
             check_docstring_args_single_line_scope_vs_span(effective_content, file_path)
         )
+        all_issues.extend(
+            check_docstring_delegation_summary_enumeration_drift(
+                effective_content, file_path
+            )
+        )
         all_issues.extend(
             check_boolean_naming(
                 effective_content,
@@ -477,9 +493,11 @@ def validate_content(
             )
         )
         all_issues.extend(check_loop_variable_naming(content, file_path))
+        all_issues.extend(check_referenced_underscore_loop_variable(content, file_path))
         all_issues.extend(check_polarity_name_contradiction(content, file_path))
         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_join_separator_string_magic(content, file_path))
         all_issues.extend(check_string_literal_magic(content, file_path))
         all_issues.extend(check_whitespace_indentation_magic(content, file_path))
         all_issues.extend(check_orphan_css_classes(effective_content, file_path))
@@ -513,6 +531,17 @@ def validate_content(
         all_issues.extend(
             check_js_returns_object_schemaless_branch(content, file_path)
         )
+        all_issues.extend(
+            check_js_sibling_return_object_key_drift(content, file_path)
+        )
+        all_issues.extend(
+            check_js_bare_flag_return_directive(
+                effective_content,
+                file_path,
+                all_changed_lines,
+                defer_scope_to_caller,
+            )
+        )
 
     if extension in ALL_CODE_EXTENSIONS:
         advise_file_line_count(content, file_path)