claude-dev-env 1.82.0 → 1.84.0

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,
@@ -52,6 +53,8 @@ from hooks_constants.blocking_check_limits import (  # noqa: E402
     ALL_ZIPFILE_WRITE_MODE_VALUES,
     DOCSTRING_FALLBACK_BRANCH_MINIMUM_ROUTE_COUNT,
     DOCSTRING_LARGE_ZIP_FILE_EXCEPTION_NAME,
+    DOCSTRING_NARRATIVE_LINE_JOIN_SEPARATOR,
+    DOCSTRING_NARRATIVE_PROSE_LINE_LIMIT,
     DOCSTRING_REFERENCE_MARKER_WINDOW,
     DOCSTRING_RUNON_SENTENCE_BOUNDARY_PATTERN,
     DOCSTRING_RUNON_SENTENCE_WORD_LIMIT,
@@ -63,6 +66,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,
@@ -70,6 +74,7 @@ from hooks_constants.blocking_check_limits import (  # noqa: E402
     MAX_DOCSTRING_MARK_GLYPH_ENUMERATION_ISSUES,
     MAX_DOCSTRING_NO_CONSUMER_CLAIM_ISSUES,
     MAX_DOCSTRING_NO_NETWORK_CLAIM_ISSUES,
+    MAX_DOCSTRING_PROSE_WALL_ISSUES,
     MAX_DOCSTRING_RAISES_LARGEZIPFILE_ISSUES,
     MAX_DOCSTRING_RETURNS_PLURAL_CARDINALITY_ISSUES,
     MAX_DOCSTRING_RUNON_SENTENCE_ISSUES,
@@ -82,16 +87,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 +1138,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 +1190,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 +1226,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 "
@@ -2513,14 +2565,71 @@ def _is_narrative_cut_header(stripped_line: str) -> bool:
     )
 
 
-def _docstring_narrative_text(docstring_text: str) -> str:
-    narrative_lines: list[str] = []
-    for each_line in docstring_text.splitlines():
-        stripped_line = each_line.strip()
+def _docstring_narrative_partition(docstring_text: str) -> tuple[list[str], bool]:
+    """Split a docstring narrative into its prose lines and whether it shows an example.
+
+    Walk the narrative up to the first ``Args:``/``Returns:`` cut header and sort
+    every line into one of two buckets::
+
+        Render the report so the reader sees how it ended.   <- prose line
+        A finished run versus an interrupted one::           <- prose line (opener)
+            theme_42 -- interrupted -> marked in-flight       -- indented example body
+            OK:   a clean run reads differently in the log    -- indented example body
+        The reader reads the final outcome at a glance.      <- prose line
+
+    A ``>>>`` doctest region and a ``::`` block with an indented body both count as
+    an illustration, so their lines never join the prose bucket. The caller reads
+    the prose count to size the wall and the flag to know whether an example is present.
+    """
+    prose_lines: list[str] = []
+    has_illustration = False
+    all_lines = docstring_text.splitlines()
+    total_lines = len(all_lines)
+    line_index = 0
+    while line_index < total_lines:
+        raw_line = all_lines[line_index]
+        stripped_line = raw_line.strip()
         if _is_narrative_cut_header(stripped_line):
             break
-        narrative_lines.append(stripped_line)
-    return " ".join(narrative_lines)
+        if stripped_line.startswith(">>>"):
+            has_illustration = True
+            line_index += 1
+            while line_index < total_lines:
+                inner_stripped = all_lines[line_index].strip()
+                if not inner_stripped or _is_narrative_cut_header(inner_stripped):
+                    break
+                line_index += 1
+            continue
+        if stripped_line.endswith("::"):
+            opener_indent = len(raw_line) - len(raw_line.lstrip())
+            probe_index = line_index + 1
+            has_indented_body = False
+            while probe_index < total_lines:
+                probe_raw = all_lines[probe_index]
+                probe_stripped = probe_raw.strip()
+                if not probe_stripped:
+                    probe_index += 1
+                    continue
+                probe_indent = len(probe_raw) - len(probe_raw.lstrip())
+                if probe_indent > opener_indent:
+                    has_indented_body = True
+                    probe_index += 1
+                    continue
+                break
+            if has_indented_body:
+                has_illustration = True
+                prose_lines.append(stripped_line)
+                line_index = probe_index
+                continue
+        if stripped_line:
+            prose_lines.append(stripped_line)
+        line_index += 1
+    return prose_lines, has_illustration
+
+
+def _docstring_narrative_text(docstring_text: str) -> str:
+    prose_lines, _has_illustration = _docstring_narrative_partition(docstring_text)
+    return DOCSTRING_NARRATIVE_LINE_JOIN_SEPARATOR.join(prose_lines)
 
 
 def _sentence_word_count(sentence_text: str) -> int:
@@ -2626,6 +2735,56 @@ def check_docstring_runon_sentence(content: str, file_path: str) -> list[str]:
     return issues[:MAX_DOCSTRING_RUNON_SENTENCE_ISSUES]
 
 
+def check_docstring_prose_wall_without_illustration(content: str, file_path: str) -> list[str]:
+    """Flag a summary that tells for many sentences and shows nothing.
+
+    A reader trusts the opening to paint a scene. A run of short sentences with
+    no worked example leaves the reader piecing that scene together alone::
+
+        A calm voyage ends well for every vessel.            <- one more line
+        A halted voyage marks the vessel it neared.          <- and another
+        ... more like these, no worked example ...           flag: a wall, no scene
+        A calm voyage versus a halted one::                  ok: a worked example
+            a lone vessel -- halted -> marked mid-voyage
+
+    Past the prose-line limit with no ``::`` listing and no ``>>>`` doctest, this
+    fires. A narrative that shows a worked example, or one at the limit, passes.
+
+    Args:
+        content: The source text to inspect.
+        file_path: The path the source will be written to, used for exemptions.
+
+    Returns:
+        One issue per summary that runs a wall of sentences with no worked
+        example, capped at the issue limit for the rule.
+    """
+    if is_test_file(file_path) or is_hook_infrastructure(file_path):
+        return []
+    try:
+        parsed_tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    issues: list[str] = []
+    for each_line_number, each_label, each_docstring in _documentable_docstring_targets(
+        parsed_tree
+    ):
+        prose_lines, has_illustration = _docstring_narrative_partition(each_docstring)
+        if has_illustration:
+            continue
+        prose_line_count = len(prose_lines)
+        if prose_line_count <= DOCSTRING_NARRATIVE_PROSE_LINE_LIMIT:
+            continue
+        issues.append(
+            f"Line {each_line_number}: {each_label} summary runs {prose_line_count} "
+            "narrative lines with no worked example - show, don't tell: swap the wall for a "
+            "'::' listing (a sample input, an annotated outcome, ok/flag contrast rows) and "
+            "keep the narrative to a few short lines (plain-illustrative-docstrings)"
+        )
+        if len(issues) >= MAX_DOCSTRING_PROSE_WALL_ISSUES:
+            break
+    return issues[:MAX_DOCSTRING_PROSE_WALL_ISSUES]
+
+
 def _raises_section_text(docstring_text: str) -> str:
     docstring_lines = docstring_text.splitlines()
     raises_section_lines: list[str] = []
@@ -2874,3 +3033,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,
@@ -85,6 +87,7 @@ from code_rules_docstrings import (  # noqa: E402
     check_docstring_no_consumer_claim,
     check_docstring_no_inline_literal_claim,
     check_docstring_no_network_claim_with_metadata_access,
+    check_docstring_prose_wall_without_illustration,
     check_docstring_punctuation_mark_enumeration_coverage,
     check_docstring_raises_unraisable_largezipfile,
     check_docstring_returns_plural_cardinality,
@@ -105,11 +108,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 +134,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 +162,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 +277,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(
@@ -340,6 +352,9 @@ def validate_content(
             check_class_docstring_names_public_methods(effective_content, file_path)
         )
         all_issues.extend(check_docstring_runon_sentence(effective_content, file_path))
+        all_issues.extend(
+            check_docstring_prose_wall_without_illustration(effective_content, file_path)
+        )
         all_issues.extend(
             check_module_docstring_names_public_checks(effective_content, file_path)
         )
@@ -389,6 +404,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 +497,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 +535,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)