claude-dev-env 2.28.0 → 2.28.1

package/hooks/blocking/code_rules_docstrings.py

@@ -23,107 +23,41 @@ from code_rules_shared import (  # noqa: E402
 )
 
 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,
-    ALL_DOCSTRING_GUARDED_FAILURE_CLAIM_PHRASES,
     ALL_DOCSTRING_IMPLICIT_INSTANCE_PARAMETER_NAMES,
-    ALL_DOCSTRING_MULTIPLE_CONDITION_JOINING_PHRASES,
-    ALL_DOCSTRING_NO_CONSUMER_CLAIM_PHRASES,
-    ALL_DOCSTRING_NO_INLINE_LITERAL_CLAIM_PHRASES,
-    ALL_DOCSTRING_NO_NETWORK_CLAIM_PHRASES,
     ALL_DOCSTRING_NON_CONSTANT_REFERENCE_MARKERS,
-    ALL_DOCSTRING_PER_RECORD_WRITE_OUTCOME_PHRASES,
-    ALL_DOCSTRING_RUN_MODE_PHRASES,
-    ALL_DOCSTRING_RUNMODE_FLAG_FIELD_NAME_TOKENS,
     ALL_DOCSTRING_RUNON_JOINER_MARKERS,
-    ALL_DOCSTRING_SINGLE_LINE_SCOPE_PHRASES,
-    ALL_DOCSTRING_SPAN_RANGE_BODY_CALLEE_NAMES,
-    ALL_DOCSTRING_SPAN_SCOPE_OVERRIDE_PHRASES,
     ALL_GENERIC_CHECK_NAME_TOKENS,
-    ALL_LENGTH_CONSTANT_NAME_SUFFIXES,
-    ALL_LENGTH_SUPERLATIVE_RANGE_PHRASES,
     ALL_NAMING_CONVENTION_DESCRIPTOR_TOKENS,
-    ALL_PATH_METADATA_ACCESS_METHOD_NAMES,
-    ALL_PUNCTUATION_MARK_GLYPH_PROSE_NAMES,
     ALL_USER_FACING_TEXT_SCOPE_DOCSTRING_PHRASES,
-    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,
     DOCSTRING_TRIVIAL_FUNCTION_BODY_LINE_LIMIT,
-    LENGTH_CONFIG_SUBDIRECTORY_NAME,
-    LENGTH_GATE_PACKAGE_SCAN_FILE_LIMIT,
     MAX_CLASS_DOCSTRING_PUBLIC_METHOD_ISSUES,
-    MAX_COMPANION_MODULE_RESOLUTION_DEPTH,
     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,
-    MAX_DOCSTRING_INLINE_LITERAL_CLAIM_ISSUES,
-    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,
-    MAX_DOCSTRING_STEP_DISPATCH_ISSUES,
-    MAX_DOCSTRING_TUPLE_ENUMERATION_ISSUES,
-    MAX_DOCSTRING_TYPE_CHECKING_GATE_ISSUES,
     MAX_DOCSTRING_UNDEFINED_CONSTANT_ISSUES,
-    MAX_DOCSTRING_UNGUARDED_PAYLOAD_CLAIM_ISSUES,
-    MAX_LENGTH_CONSTANT_SUPERLATIVE_ISSUES,
     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_RANGE_ARGS_FOR_SPAN,
     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,
-    ZIPFILE_ALLOW_ZIP64_POSITIONAL_INDEX,
-    ZIPFILE_MODE_KEYWORD,
-    ZIPFILE_MODE_POSITIONAL_INDEX,
-    ZIPFILE_WRITER_CLASS_NAME,
 )
 from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
     ALL_CAPS_WITH_UNDERSCORE_PATTERN,
-    ALL_CARDINAL_NUMBER_WORD_VALUES,
     ALL_DOCSTRING_ARGS_SECTION_HEADERS,
     ALL_DOCSTRING_TERMINATING_SECTION_HEADERS,
     ALL_SELF_AND_CLS_PARAMETER_NAMES,
     DOCSTRING_ARG_ENTRY_PATTERN,
-    DOCSTRING_CARDINAL_OUTCOME_PHRASE_PATTERN,
-    DOCSTRING_MULTI_SEGMENT_SNAKE_TOKEN_PATTERN,
-    DOCSTRING_PLURAL_FAMILY_STOP_PATTERN,
-    IDENTIFIER_SHAPED_TUPLE_MEMBER_PATTERN,
-    INLINE_CODE_TOKEN_PATTERN,
 )
 
 
@@ -466,158 +400,6 @@ def check_docstring_documents_unreferenced_parameter(
     return issues[:MAX_DOCSTRING_ARGS_SIGNATURE_ISSUES]
 
 
-def _callee_expression_name(expression: ast.expr) -> str:
-    if isinstance(expression, ast.Name):
-        return expression.id
-    if isinstance(expression, ast.Attribute):
-        receiver_name = _callee_expression_name(expression.value)
-        if not receiver_name:
-            return ast.unparse(expression)
-        return f"{receiver_name}.{expression.attr}"
-    return ""
-
-
-def _call_callee_name(call_node: ast.Call) -> str:
-    return _callee_expression_name(call_node.func)
-
-
-def _branch_routes_directly_to_call(branch_node: ast.If) -> str:
-    """Return the callee name an early-return guard routes to, or empty string.
-
-    A guard counts when its block contains exactly one call expression and then
-    returns. A second call expression disqualifies the block; non-call
-    statements such as an assignment or a loop are skipped and do not
-    disqualify it. The await wrapper around an async call is unwrapped first.
-    """
-    routed_callee = ""
-    saw_return = False
-    for each_statement in branch_node.body:
-        candidate_expression: ast.expr | None = None
-        if isinstance(each_statement, ast.Expr):
-            candidate_expression = each_statement.value
-        elif isinstance(each_statement, ast.Return):
-            saw_return = True
-            continue
-        if candidate_expression is None:
-            continue
-        if isinstance(candidate_expression, ast.Await):
-            candidate_expression = candidate_expression.value
-        if not isinstance(candidate_expression, ast.Call):
-            return ""
-        if routed_callee:
-            return ""
-        routed_callee = _call_callee_name(candidate_expression)
-    if not saw_return:
-        return ""
-    return routed_callee
-
-
-def _shared_fallback_route_count(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-) -> tuple[str, int]:
-    route_count_by_callee: dict[str, int] = {}
-    for each_statement in function_node.body:
-        if not isinstance(each_statement, ast.If):
-            continue
-        routed_callee = _branch_routes_directly_to_call(each_statement)
-        if not routed_callee:
-            continue
-        route_count_by_callee[routed_callee] = (
-            route_count_by_callee.get(routed_callee, 0) + 1
-        )
-    if not route_count_by_callee:
-        return "", 0
-    busiest_callee = max(route_count_by_callee, key=lambda name: route_count_by_callee[name])
-    return busiest_callee, route_count_by_callee[busiest_callee]
-
-
-def _summary_contains_phrase_at_word_boundary(summary_text: str, phrase: str) -> bool:
-    search_start = 0
-    while True:
-        match_index = summary_text.find(phrase, search_start)
-        if match_index == -1:
-            return False
-        preceding_is_boundary = (
-            match_index == 0 or not summary_text[match_index - 1].isalnum()
-        )
-        following_index = match_index + len(phrase)
-        following_is_boundary = (
-            following_index >= len(summary_text)
-            or not summary_text[following_index].isalnum()
-        )
-        if preceding_is_boundary and following_is_boundary:
-            return True
-        search_start = match_index + 1
-
-
-def _summary_joins_multiple_conditions(summary_text: str) -> bool:
-    return any(
-        joining_phrase in summary_text
-        for joining_phrase in ALL_DOCSTRING_MULTIPLE_CONDITION_JOINING_PHRASES
-    )
-
-
-def _docstring_summary_scopes_a_single_condition(docstring_text: str) -> bool:
-    summary_text = docstring_text.split("\n\n", 1)[0].lower()
-    has_scope_phrase = any(
-        _summary_contains_phrase_at_word_boundary(summary_text, each_phrase)
-        for each_phrase in ALL_DOCSTRING_EXCLUSIVE_SCOPE_PHRASES
-    )
-    if not has_scope_phrase:
-        return False
-    return not _summary_joins_multiple_conditions(summary_text)
-
-
-def check_docstring_fallback_branch_coverage(content: str, file_path: str) -> list[str]:
-    """Flag a fallback docstring that scopes a branch the body reaches twice.
-
-    The drift this catches: a function whose summary describes a fallback
-    action under a single condition (``only when``, ``falls back to ... when``)
-    while the body routes to that same fallback call from two or more distinct
-    early-return guards. The second guard fires under a condition the prose
-    never names, so the enumeration the reader trusts is incomplete. This is
-    the deterministic slice of Category O6 (docstring prose vs implementation
-    drift): a structural branch-count-versus-prose-condition mismatch.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per function whose fallback prose omits a second route to the
-        same call, capped at the module limit.
-    """
-    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_node in _walk_skipping_type_checking_blocks(parsed_tree):
-        if not isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        if _function_has_exempt_decorator(each_node):
-            continue
-        docstring_text = _function_docstring_text(each_node)
-        if not docstring_text:
-            continue
-        if not _docstring_summary_scopes_a_single_condition(docstring_text):
-            continue
-        fallback_callee, route_count = _shared_fallback_route_count(each_node)
-        if route_count < DOCSTRING_FALLBACK_BRANCH_MINIMUM_ROUTE_COUNT:
-            continue
-        issues.append(
-            f"Line {each_node.lineno}: {each_node.name}() docstring scopes a fallback to "
-            f"one condition, but the body routes to {fallback_callee}() from {route_count} "
-            "distinct branches — enumerate every condition that reaches the fallback "
-            "(Category O6 docstring-vs-implementation drift)"
-        )
-        if len(issues) >= MAX_DOCSTRING_FALLBACK_BRANCH_ISSUES:
-            break
-    return issues[:MAX_DOCSTRING_FALLBACK_BRANCH_ISSUES]
-
-
 def _class_docstring_summary_is_single_line(docstring_text: str) -> bool:
     stripped_text = docstring_text.strip()
     if not stripped_text:
@@ -713,405 +495,6 @@ def check_class_docstring_names_public_methods(
     return issues[:MAX_CLASS_DOCSTRING_PUBLIC_METHOD_ISSUES]
 
 
-def _docstring_claims_no_consumer(docstring_text: str) -> str:
-    lowered_docstring = docstring_text.lower()
-    for each_phrase in ALL_DOCSTRING_NO_CONSUMER_CLAIM_PHRASES:
-        if each_phrase in lowered_docstring:
-            return each_phrase
-    return ""
-
-
-def check_docstring_no_consumer_claim(content: str, file_path: str) -> list[str]:
-    """Flag a docstring that asserts no consumer reads its produced artifact yet.
-
-    A producer docstring claiming "no consumer reads it yet" (or
-    "producer-only artifact") is a transitional statement that drifts the moment
-    a consumer lands. Once a submission run, gate, or any reader loads the
-    artifact, the claim contradicts both the live behavior and any companion
-    SKILL.md that documents the consumer — the Category O8 docstring /
-    companion-doc producer-consumer drift. The claim is also a no-historical /
-    no-transitional-language violation in its own right: a docstring describes
-    the contract that exists, not a not-yet-wired future. Rephrase to state what
-    reads the artifact, or drop the no-consumer sentence entirely.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per function whose docstring claims no consumer reads its
-        output, capped at the module limit.
-    """
-    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_node in _walk_skipping_type_checking_blocks(parsed_tree):
-        if not isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        if _function_has_exempt_decorator(each_node):
-            continue
-        docstring_text = _function_docstring_text(each_node)
-        if not docstring_text:
-            continue
-        matched_phrase = _docstring_claims_no_consumer(docstring_text)
-        if not matched_phrase:
-            continue
-        issues.append(
-            f"Line {each_node.lineno}: {each_node.name}() docstring claims "
-            f"'{matched_phrase}' — a no-consumer-yet claim drifts the moment a reader "
-            "lands and contradicts any companion SKILL.md; state what reads the artifact "
-            "or drop the sentence (Category O8 docstring / companion-doc drift)"
-        )
-        if len(issues) >= MAX_DOCSTRING_NO_CONSUMER_CLAIM_ISSUES:
-            break
-    return issues[:MAX_DOCSTRING_NO_CONSUMER_CLAIM_ISSUES]
-
-
-def _docstring_claims_malformed_payload_is_guarded(docstring_text: str) -> str:
-    collapsed_docstring = " ".join(docstring_text.lower().split())
-    for each_phrase in ALL_DOCSTRING_GUARDED_FAILURE_CLAIM_PHRASES:
-        if each_phrase in collapsed_docstring:
-            return each_phrase
-    return ""
-
-
-def _try_handler_returns_none(try_node: ast.Try) -> bool:
-    for each_handler in try_node.handlers:
-        for each_statement in each_handler.body:
-            if isinstance(each_statement, ast.Return) and isinstance(
-                each_statement.value, ast.Constant
-            ):
-                if each_statement.value.value is None:
-                    return True
-    return False
-
-
-def _names_bound_in_try_body(try_node: ast.Try) -> set[str]:
-    all_bound_names: set[str] = set()
-    for each_statement in try_node.body:
-        for each_descendant in ast.walk(each_statement):
-            if isinstance(each_descendant, ast.Name) and isinstance(
-                each_descendant.ctx, ast.Store
-            ):
-                all_bound_names.add(each_descendant.id)
-    return all_bound_names
-
-
-def _statement_subscripts_one_of(
-    statement: ast.stmt, all_payload_names: set[str]
-) -> bool:
-    for each_descendant in ast.walk(statement):
-        if (
-            isinstance(each_descendant, ast.Subscript)
-            and isinstance(each_descendant.value, ast.Name)
-            and each_descendant.value.id in all_payload_names
-        ):
-            return True
-    return False
-
-
-def _function_has_unguarded_payload_dereference(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-) -> bool:
-    all_payload_names: set[str] = set()
-    saw_returning_guard = False
-    for each_statement in function_node.body:
-        if isinstance(each_statement, ast.Try) and _try_handler_returns_none(
-            each_statement
-        ):
-            all_payload_names |= _names_bound_in_try_body(each_statement)
-            saw_returning_guard = True
-            continue
-        if not saw_returning_guard:
-            continue
-        if _statement_subscripts_one_of(each_statement, all_payload_names):
-            return True
-    return False
-
-
-def check_docstring_unguarded_malformed_payload_claim(
-    content: str, file_path: str
-) -> list[str]:
-    """Flag a docstring that promises malformed-payload safety the guard misses.
-
-    The drift this catches: a function whose docstring states that a malformed
-    payload "resolves to None" while a subscript dereference of that payload
-    (``payload["key"]``, ``float(payload["key"])``) sits OUTSIDE the try/except
-    whose handler returns None. A present-but-malformed payload then raises
-    KeyError or TypeError from that unguarded access and propagates rather than
-    resolving to None, so the docstring overstates the protection. This is the
-    deterministic slice of Category O6 (docstring prose vs implementation drift)
-    for an exception-guard claim: move the dereference inside the guarded block,
-    or narrow the docstring to the failures the guard actually catches.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per function whose malformed-payload claim outruns its guard,
-        capped at the module limit.
-    """
-    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_node in _walk_skipping_type_checking_blocks(parsed_tree):
-        if not isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        if _function_has_exempt_decorator(each_node):
-            continue
-        docstring_text = _function_docstring_text(each_node)
-        if not docstring_text:
-            continue
-        matched_phrase = _docstring_claims_malformed_payload_is_guarded(docstring_text)
-        if not matched_phrase:
-            continue
-        if not _function_has_unguarded_payload_dereference(each_node):
-            continue
-        issues.append(
-            f"Line {each_node.lineno}: {each_node.name}() docstring claims "
-            f"'{matched_phrase}' but a payload subscript sits outside the try/except that "
-            "returns None — a malformed-but-present payload raises rather than resolving to "
-            "None; move the dereference inside the guard or narrow the docstring "
-            "(Category O6 docstring-vs-implementation drift)"
-        )
-        if len(issues) >= MAX_DOCSTRING_UNGUARDED_PAYLOAD_CLAIM_ISSUES:
-            break
-    return issues[:MAX_DOCSTRING_UNGUARDED_PAYLOAD_CLAIM_ISSUES]
-
-
-def _docstring_claims_no_network_access(docstring_text: str) -> str:
-    collapsed_docstring = " ".join(docstring_text.lower().split())
-    for each_phrase in ALL_DOCSTRING_NO_NETWORK_CLAIM_PHRASES:
-        if each_phrase in collapsed_docstring:
-            return each_phrase
-    return ""
-
-
-def _function_performs_path_metadata_access(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-) -> str:
-    for each_descendant in ast.walk(function_node):
-        if not isinstance(each_descendant, ast.Call):
-            continue
-        callee = each_descendant.func
-        if (
-            isinstance(callee, ast.Attribute)
-            and callee.attr in ALL_PATH_METADATA_ACCESS_METHOD_NAMES
-        ):
-            return callee.attr
-    return ""
-
-
-def check_docstring_no_network_claim_with_metadata_access(
-    content: str, file_path: str
-) -> list[str]:
-    """Flag a docstring promising no network touch while the body stats a path.
-
-    Picture a cache helper whose docstring says it returns the warm cache
-    "without touching the network." A reader trusts that a cache hit costs
-    nothing on the share. But the body calls ``share_path.is_file()`` and
-    ``share_path.stat().st_size`` before it can return the cache — and on a
-    network share each of those metadata calls is a round-trip over the wire.
-    The promise drifts: every cache hit still pays two network stats the
-    docstring swore it avoided.
-
-    This is the deterministic slice of Category O6 (docstring prose versus
-    implementation drift) for a no-network claim: a function docstring that
-    states the path returns ``without touching the network`` (or a sibling
-    no-network phrase) while the body calls ``is_file``, ``is_dir``,
-    ``exists``, ``stat``, or ``lstat``. Either reword the claim to state that
-    the path is stat-checked on every call, or short-circuit to the cached
-    path before the share is touched.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per function whose no-network claim coexists with a
-        path-metadata call, capped at the module limit.
-    """
-    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_node in _walk_skipping_type_checking_blocks(parsed_tree):
-        if not isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        if _function_has_exempt_decorator(each_node):
-            continue
-        docstring_text = _function_docstring_text(each_node)
-        if not docstring_text:
-            continue
-        matched_phrase = _docstring_claims_no_network_access(docstring_text)
-        if not matched_phrase:
-            continue
-        accessed_method = _function_performs_path_metadata_access(each_node)
-        if not accessed_method:
-            continue
-        issues.append(
-            f"Line {each_node.lineno}: {each_node.name}() docstring claims "
-            f"'{matched_phrase}' but the body calls .{accessed_method}() on a path — "
-            "a metadata stat is itself a network touch on a share, so the no-network "
-            "claim drifts; reword the docstring to state the path is stat-checked on "
-            "every call, or short-circuit before touching the share "
-            "(Category O6 docstring-vs-implementation drift)"
-        )
-        if len(issues) >= MAX_DOCSTRING_NO_NETWORK_CLAIM_ISSUES:
-            break
-    return issues[:MAX_DOCSTRING_NO_NETWORK_CLAIM_ISSUES]
-
-
-def _module_code_references_type_checking(parsed_tree: ast.Module) -> bool:
-    """Return True when a code identifier in the module handles TYPE_CHECKING.
-
-    A module that names TYPE_CHECKING in code genuinely gates on it. That covers
-    a Name reference (any context — load, store, or delete), an import alias, an
-    attribute access, or a function or class definition whose name carries the
-    type_checking marker. Docstring text is an ast.Constant and never counts, so
-    the check can still flag a gate the prose names while the body performs none.
-    """
-    for each_node in ast.walk(parsed_tree):
-        if isinstance(each_node, ast.Name) and (
-            TYPE_CHECKING_IDENTIFIER_MARKER in each_node.id.lower()
-        ):
-            return True
-        if isinstance(each_node, ast.Attribute) and (
-            TYPE_CHECKING_IDENTIFIER_MARKER in each_node.attr.lower()
-        ):
-            return True
-        if isinstance(each_node, ast.alias) and any(
-            each_alias_name and TYPE_CHECKING_IDENTIFIER_MARKER in each_alias_name.lower()
-            for each_alias_name in (each_node.name, each_node.asname)
-        ):
-            return True
-        if isinstance(
-            each_node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
-        ) and TYPE_CHECKING_IDENTIFIER_MARKER in each_node.name.lower():
-            return True
-    return False
-
-
-def _docstring_names_absent_type_checking_gate(docstring_text: str) -> str:
-    collapsed_docstring = " ".join(docstring_text.replace("`", " ").lower().split())
-    for each_phrase in ALL_ABSENT_TYPE_CHECKING_GATE_DOCSTRING_PHRASES:
-        if each_phrase in collapsed_docstring:
-            return each_phrase
-    return ""
-
-
-def check_docstring_names_absent_type_checking_gate(
-    content: str, file_path: str
-) -> list[str]:
-    """Flag a docstring naming a TYPE_CHECKING gate the module's code never runs.
-
-    Picture a hook whose docstring advertises a `TYPE_CHECKING` gate-detection
-    step, or a module summary that names `type-checking-gate` helpers, while no
-    identifier in the body handles TYPE_CHECKING. A reader trusts the prose and
-    looks for the gate, but the code performs none, so the claim points at
-    machinery the module does not hold.
-
-    This is the deterministic slice of Category O6 docstring-prose-vs-
-    implementation drift for a TYPE_CHECKING gate claim. The check reads the
-    module docstring and every function and class docstring. It fires only when
-    a docstring names a `TYPE_CHECKING` gate or a `type-checking-gate` helper
-    family while no code identifier in the module carries the `type_checking`
-    marker, so a module that genuinely gates on TYPE_CHECKING is left alone.
-    Hook infrastructure is in scope, since the import-scan hooks that carry this
-    drift class are themselves hooks. Test files are exempt.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per docstring naming a TYPE_CHECKING gate the code never
-        performs, capped at the module limit.
-    """
-    if is_strict_test_file(file_path):
-        return []
-    try:
-        parsed_tree = ast.parse(content)
-    except SyntaxError:
-        return []
-    if _module_code_references_type_checking(parsed_tree):
-        return []
-    issues: list[str] = []
-    for each_line_number, each_docstring in _documentable_nodes_with_docstrings(parsed_tree):
-        matched_phrase = _docstring_names_absent_type_checking_gate(each_docstring)
-        if not matched_phrase:
-            continue
-        issues.append(
-            f"Line {each_line_number}: docstring names a '{matched_phrase}' the module's "
-            "code never performs — no identifier in the body handles TYPE_CHECKING, so the "
-            "gate-detection claim is stale; drop the TYPE_CHECKING gate wording or add the "
-            "detection (Category O6 docstring-vs-implementation drift)"
-        )
-        if len(issues) >= MAX_DOCSTRING_TYPE_CHECKING_GATE_ISSUES:
-            break
-    return issues[:MAX_DOCSTRING_TYPE_CHECKING_GATE_ISSUES]
-
-
-def _module_docstring_claims_no_inline_literal(module_docstring: str) -> str:
-    collapsed_docstring = " ".join(module_docstring.lower().split())
-    for each_phrase in ALL_DOCSTRING_NO_INLINE_LITERAL_CLAIM_PHRASES:
-        if each_phrase in collapsed_docstring:
-            return each_phrase
-    return ""
-
-
-def check_docstring_no_inline_literal_claim(content: str, file_path: str) -> list[str]:
-    """Flag a module docstring that asserts no literals appear inline elsewhere.
-
-    A constants-module docstring claiming "no literals appear inline in the
-    dispatcher" makes an unverifiable completeness claim about a companion file.
-    The claim drifts the moment a literal lands inline in that companion — a deny
-    or block reason left inline in the dispatcher contradicts the docstring even
-    though the constants file under edit never changed. This is the deterministic
-    slice of Category O6 (docstring prose vs implementation drift) and a
-    no-transitional-language violation in its own right: a docstring describes
-    what the module holds, not the absence of literals in a sibling. Rephrase to
-    state what the module centralizes, or drop the no-inline-literal sentence.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue when the module docstring carries a no-inline-literal claim,
-        capped at the module limit.
-    """
-    if is_strict_test_file(file_path):
-        return []
-    try:
-        parsed_tree = ast.parse(content)
-    except SyntaxError:
-        return []
-    module_docstring = ast.get_docstring(parsed_tree) or ""
-    matched_phrase = _module_docstring_claims_no_inline_literal(module_docstring)
-    if not matched_phrase:
-        return []
-    issues = [
-        f"Line 1: module docstring claims '{matched_phrase}' about a companion file "
-        "— an unverifiable completeness claim that drifts the moment a literal lands "
-        "inline; state what the module centralizes instead (Category O6 docstring-vs-"
-        "implementation drift)"
-    ]
-    return issues[:MAX_DOCSTRING_INLINE_LITERAL_CLAIM_ISSUES]
-
-
 def _module_docstring_summary_is_single_paragraph(module_docstring: str) -> bool:
     stripped_text = module_docstring.strip()
     if not stripped_text:
@@ -1342,896 +725,16 @@ def check_module_docstring_scope_omits_data_schema_constants(
     ][:MAX_MODULE_DOCSTRING_DATA_SCHEMA_SCOPE_ISSUES]
 
 
-def _module_string_tuple_members(parsed_tree: ast.Module) -> dict[str, frozenset[str]]:
-    members_by_constant: dict[str, frozenset[str]] = {}
-    for each_statement in parsed_tree.body:
-        if not isinstance(each_statement, ast.Assign):
-            continue
-        if not isinstance(each_statement.value, ast.Tuple):
-            continue
-        literal_members: set[str] = set()
-        every_member_is_identifier_shaped = True
-        for each_element in each_statement.value.elts:
-            if (
-                isinstance(each_element, ast.Constant)
-                and isinstance(each_element.value, str)
-                and IDENTIFIER_SHAPED_TUPLE_MEMBER_PATTERN.match(each_element.value)
-            ):
-                literal_members.add(each_element.value.lstrip("."))
-                continue
-            every_member_is_identifier_shaped = False
-            break
-        if not every_member_is_identifier_shaped:
-            continue
-        if len(literal_members) < MINIMUM_TUPLE_MEMBERS_FOR_DOCSTRING_ENUMERATION:
-            continue
-        for each_target in each_statement.targets:
-            if isinstance(each_target, ast.Name):
-                members_by_constant[each_target.id] = frozenset(literal_members)
-    return members_by_constant
-
-
-def _names_referenced_in_function(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-) -> set[str]:
-    return {
-        each_node.id
-        for each_node in ast.walk(function_node)
-        if isinstance(each_node, ast.Name)
-    }
-
-
-def _docstring_inline_code_tokens(docstring_text: str) -> set[str]:
-    tokens: set[str] = set()
-    for each_match in INLINE_CODE_TOKEN_PATTERN.finditer(docstring_text):
-        token = each_match.group(1).strip().lstrip(".")
-        if token:
-            tokens.add(token)
-    return tokens
-
-
-def check_docstring_tuple_enumeration_match(content: str, file_path: str) -> list[str]:
-    """Flag a docstring enumeration that drifts from a literal tuple it reads.
-
-    The drift this catches: a function reads a module-level tuple of literal
-    string members and its docstring enumerates inline-code tokens that name
-    some of those members, but the enumerated set and the tuple membership
-    differ. A token the docstring lists that the tuple lacks, or a tuple member
-    the docstring omits, misleads a reader who trusts the prose enumeration to
-    match the detection set — the deterministic slice of Category O6
-    docstring-prose-vs-implementation drift. The check binds only when the
-    docstring's inline-code tokens overlap the tuple membership, so a docstring
-    that names unrelated attributes is left alone. This check covers hook
-    infrastructure, where the affected detection tuples live.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per function whose docstring enumeration diverges from the
-        tuple it reads, capped at the module limit.
-    """
-    if is_strict_test_file(file_path):
-        return []
-    try:
-        parsed_tree = ast.parse(content)
-    except SyntaxError:
-        return []
-    members_by_constant = _module_string_tuple_members(parsed_tree)
-    if not members_by_constant:
-        return []
-    issues: list[str] = []
-    for each_node in _walk_skipping_type_checking_blocks(parsed_tree):
-        if not isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        docstring_text = _function_docstring_text(each_node)
-        if not docstring_text:
-            continue
-        docstring_tokens = _docstring_inline_code_tokens(docstring_text)
-        if not docstring_tokens:
-            continue
-        referenced_names = _names_referenced_in_function(each_node)
-        for each_constant_name in referenced_names & set(members_by_constant):
-            tuple_members = members_by_constant[each_constant_name]
-            if not (docstring_tokens & tuple_members):
-                continue
-            if docstring_tokens == tuple_members:
-                continue
-            docstring_only = sorted(docstring_tokens - tuple_members)
-            tuple_only = sorted(tuple_members - docstring_tokens)
-            issues.append(
-                f"Line {each_node.lineno}: {each_node.name}() docstring enumerates "
-                f"{sorted(docstring_tokens)} but {each_constant_name} holds "
-                f"{sorted(tuple_members)} — docstring-only: {docstring_only}, "
-                f"tuple-only: {tuple_only}; match the enumeration to the tuple "
-                "(Category O6 docstring-vs-implementation drift)"
-            )
-            if len(issues) >= MAX_DOCSTRING_TUPLE_ENUMERATION_ISSUES:
-                return issues[:MAX_DOCSTRING_TUPLE_ENUMERATION_ISSUES]
-    return issues[:MAX_DOCSTRING_TUPLE_ENUMERATION_ISSUES]
-
-
-def _known_glyph_marker_members(
-    sequence_node: ast.Tuple | ast.List,
-) -> frozenset[str] | None:
-    normalized_glyphs: set[str] = set()
-    for each_element in sequence_node.elts:
-        if not (
-            isinstance(each_element, ast.Constant)
-            and isinstance(each_element.value, str)
-        ):
-            return None
-        normalized_glyph = each_element.value.strip()
-        if normalized_glyph not in ALL_PUNCTUATION_MARK_GLYPH_PROSE_NAMES:
-            return None
-        normalized_glyphs.add(normalized_glyph)
-    return frozenset(normalized_glyphs)
-
-
-def _assignment_targets_and_sequence(
-    statement: ast.stmt,
-) -> tuple[list[str], ast.Tuple | ast.List | None]:
-    if isinstance(statement, ast.Assign) and isinstance(
-        statement.value, (ast.Tuple, ast.List)
-    ):
-        plain_target_names = [
-            each_target.id
-            for each_target in statement.targets
-            if isinstance(each_target, ast.Name)
-        ]
-        return plain_target_names, statement.value
-    if (
-        isinstance(statement, ast.AnnAssign)
-        and isinstance(statement.target, ast.Name)
-        and isinstance(statement.value, (ast.Tuple, ast.List))
-    ):
-        return [statement.target.id], statement.value
-    return [], None
-
-
-def _module_glyph_marker_tuples(parsed_tree: ast.Module) -> dict[str, frozenset[str]]:
-    glyphs_by_constant: dict[str, frozenset[str]] = {}
-    for each_statement in parsed_tree.body:
-        target_names, sequence_node = _assignment_targets_and_sequence(each_statement)
-        if sequence_node is None:
-            continue
-        marker_glyphs = _known_glyph_marker_members(sequence_node)
-        if marker_glyphs is None:
-            continue
-        if len(marker_glyphs) < MINIMUM_NAMED_MARKS_FOR_PROSE_ENUMERATION:
-            continue
-        for each_target_name in target_names:
-            glyphs_by_constant[each_target_name] = marker_glyphs
-    return glyphs_by_constant
-
-
-def _companion_module_file(dotted_module: str, file_path: str) -> Path | None:
-    relative_module_path = Path(*dotted_module.split(".")).with_suffix(
-        PYTHON_MODULE_FILE_SUFFIX
-    )
-    file_directory = Path(file_path).parent
-    candidate_roots = [file_directory, *file_directory.parents]
-    for each_root in candidate_roots[:MAX_COMPANION_MODULE_RESOLUTION_DEPTH]:
-        candidate_path = each_root / relative_module_path
-        if candidate_path.is_file():
-            return candidate_path
-    return None
-
-
-def _companion_glyph_marker_tuples(companion_path: Path) -> dict[str, frozenset[str]]:
-    try:
-        companion_source = companion_path.read_text(encoding="utf-8")
-        companion_tree = ast.parse(companion_source)
-    except (OSError, ValueError, SyntaxError):
-        return {}
-    return _module_glyph_marker_tuples(companion_tree)
-
-
-def _import_brings_upper_snake_name(import_node: ast.ImportFrom) -> bool:
-    return any(
-        ALL_CAPS_WITH_UNDERSCORE_PATTERN.match(each_alias.name)
-        for each_alias in import_node.names
-    )
-
-
-def _imported_glyph_marker_tuples(
-    parsed_tree: ast.Module, file_path: str
-) -> dict[str, frozenset[str]]:
-    glyphs_by_imported_name: dict[str, frozenset[str]] = {}
-    for each_statement in parsed_tree.body:
-        if not isinstance(each_statement, ast.ImportFrom):
-            continue
-        if not each_statement.module:
-            continue
-        if not _import_brings_upper_snake_name(each_statement):
-            continue
-        companion_path = _companion_module_file(each_statement.module, file_path)
-        if companion_path is None:
-            continue
-        companion_tuples = _companion_glyph_marker_tuples(companion_path)
-        for each_alias in each_statement.names:
-            if each_alias.name not in companion_tuples:
-                continue
-            imported_name = each_alias.asname or each_alias.name
-            glyphs_by_imported_name[imported_name] = companion_tuples[each_alias.name]
-    return glyphs_by_imported_name
-
-
-def _docstring_names_mark_glyph(docstring_text: str, normalized_glyph: str) -> bool:
-    lowercased_docstring = docstring_text.lower()
-    for each_name in ALL_PUNCTUATION_MARK_GLYPH_PROSE_NAMES[normalized_glyph]:
-        boundary_wrapped_name = (
-            WORD_BOUNDARY_REGEX + re.escape(each_name) + WORD_BOUNDARY_REGEX
-        )
-        if re.search(boundary_wrapped_name, lowercased_docstring):
-            return True
-    return False
-
-
-def _marks_named_in_docstring(
-    docstring_text: str, all_marker_glyphs: frozenset[str]
-) -> set[str]:
-    return {
-        each_glyph
-        for each_glyph in all_marker_glyphs
-        if _docstring_names_mark_glyph(docstring_text, each_glyph)
-    }
-
-
-def _text_names_multiple_marks(content_text: str) -> bool:
-    all_known_glyphs = frozenset(ALL_PUNCTUATION_MARK_GLYPH_PROSE_NAMES)
-    named_glyphs = _marks_named_in_docstring(content_text, all_known_glyphs)
-    return len(named_glyphs) >= MINIMUM_NAMED_MARKS_FOR_PROSE_ENUMERATION
-
-
-def check_docstring_punctuation_mark_enumeration_coverage(
-    content: str, file_path: str
-) -> list[str]:
-    """Flag a docstring that names some marks of a glyph tuple but omits one.
-
-    A module reads a tuple of punctuation-mark glyphs as its detection set. The
-    tuple is defined in the module or imported from a companion module beside it.
-    A docstring then enumerates those marks by their English names. When the
-    prose names a closed set of marks but leaves one the tuple holds unnamed, a
-    reader trusts the enumeration and believes an active mark never triggers the
-    check. This is the shape that appears when a glyph joins the tuple while the
-    prose enumeration stays as it was.
-
-    The check binds only when a docstring names two or more marks of one tuple. A
-    docstring that mentions a single mark, names every mark, or describes
-    unrelated punctuation is left alone. This is the deterministic glyph-prose
-    slice of Category O6 docstring-prose-vs-implementation drift, the companion
-    to check_docstring_tuple_enumeration_match for glyph members named in prose
-    rather than identifier members named in inline code. It covers hook
-    infrastructure, where the affected detection tuples live.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per docstring whose mark enumeration omits a glyph the tuple it
-        describes holds, capped at the module limit.
-    """
-    if is_strict_test_file(file_path):
-        return []
-    if not _text_names_multiple_marks(content):
-        return []
-    try:
-        parsed_tree = ast.parse(content)
-    except SyntaxError:
-        return []
-    glyphs_by_constant = {
-        **_module_glyph_marker_tuples(parsed_tree),
-        **_imported_glyph_marker_tuples(parsed_tree, file_path),
-    }
-    if not glyphs_by_constant:
-        return []
-    issues: list[str] = []
-    for each_line, each_docstring in _documentable_docstrings_with_line(parsed_tree):
-        for each_constant_name in sorted(glyphs_by_constant):
-            marker_glyphs = glyphs_by_constant[each_constant_name]
-            named_glyphs = _marks_named_in_docstring(each_docstring, marker_glyphs)
-            if len(named_glyphs) < MINIMUM_NAMED_MARKS_FOR_PROSE_ENUMERATION:
-                continue
-            omitted_glyphs = marker_glyphs - named_glyphs
-            if not omitted_glyphs:
-                continue
-            issues.append(
-                f"Line {each_line}: docstring names {sorted(named_glyphs)} from "
-                f"{each_constant_name} but omits {sorted(omitted_glyphs)} — name every "
-                "mark the tuple holds so the enumeration matches the detection set "
-                "(Category O6 docstring-vs-implementation drift)"
-            )
-            if len(issues) >= MAX_DOCSTRING_MARK_GLYPH_ENUMERATION_ISSUES:
-                return issues[:MAX_DOCSTRING_MARK_GLYPH_ENUMERATION_ISSUES]
-    return issues[:MAX_DOCSTRING_MARK_GLYPH_ENUMERATION_ISSUES]
-
-
-def _returns_section_text(docstring_text: str) -> str:
-    docstring_lines = docstring_text.splitlines()
-    returns_section_lines: list[str] = []
-    inside_returns_section = False
-    for each_line in docstring_lines:
-        stripped_line = each_line.strip()
-        if stripped_line in ("Returns:", "Yields:"):
-            inside_returns_section = True
-            continue
-        if not inside_returns_section:
-            continue
-        if _is_docstring_terminating_section_header(stripped_line):
-            break
-        returns_section_lines.append(stripped_line)
-    return " ".join(returns_section_lines)
-
-
-def _plural_families_in_returns_section(returns_section_text: str) -> set[str]:
-    return {
-        each_match.group(1)
-        for each_match in DOCSTRING_PLURAL_FAMILY_STOP_PATTERN.finditer(returns_section_text)
-    }
-
-
-def _returned_dict_key_names(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-) -> set[str]:
-    all_key_names: set[str] = set()
-    for each_node in ast.walk(function_node):
-        if not isinstance(each_node, ast.Return):
-            continue
-        if not isinstance(each_node.value, ast.Dict):
-            continue
-        for each_key in each_node.value.keys:
-            if isinstance(each_key, ast.Constant) and isinstance(each_key.value, str):
-                all_key_names.add(each_key.value)
-    return all_key_names
-
-
-def _family_prefixed_key_count(family: str, all_key_names: set[str]) -> int:
-    family_prefix = f"{family}_"
-    return sum(1 for each_key in all_key_names if each_key.startswith(family_prefix))
-
-
-def check_docstring_returns_plural_cardinality(content: str, file_path: str) -> list[str]:
-    """Flag a Returns clause plural noun that names one dict key in its family.
-
-    The drift this catches: a function returns a dict literal whose keys carry
-    prefix families (``sheen_mid``, ``body_highlight``), and its Returns clause
-    names one family with a plural noun (``the sheen stops``) while exactly one
-    key in that family exists. The plural prose claims two or more entries the
-    dict no longer holds — the shape that appears when a producer removes the
-    second key in a family but leaves the plural prose untouched. The check binds
-    only when the plural family prefixes exactly one returned dict key, so a
-    singular noun, a family with two or more keys, and a family absent from the
-    dict are all left alone. This is the deterministic single-key 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.
-
-    Returns:
-        One issue per function whose Returns clause names a plural family that
-        prefixes a single returned dict key, capped at the module limit.
-    """
-    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_node in _walk_skipping_type_checking_blocks(parsed_tree):
-        if not isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        docstring_text = _function_docstring_text(each_node)
-        if not docstring_text:
-            continue
-        returns_section_text = _returns_section_text(docstring_text)
-        if not returns_section_text:
-            continue
-        plural_families = _plural_families_in_returns_section(returns_section_text)
-        if not plural_families:
-            continue
-        all_key_names = _returned_dict_key_names(each_node)
-        for each_family in sorted(plural_families):
-            matching_key_count = _family_prefixed_key_count(each_family, all_key_names)
-            if matching_key_count != SINGLE_DICT_KEY_COUNT_FOR_PLURAL_CARDINALITY_DRIFT:
-                continue
-            issues.append(
-                f"Line {each_node.lineno}: {each_node.name}() Returns clause says "
-                f"'the {each_family} stops' (plural) but the returned dict holds a "
-                f"single {each_family}_ key — match the noun to the cardinality "
-                "(Category O6 docstring-vs-implementation drift)"
-            )
-            if len(issues) >= MAX_DOCSTRING_RETURNS_PLURAL_CARDINALITY_ISSUES:
-                return issues[:MAX_DOCSTRING_RETURNS_PLURAL_CARDINALITY_ISSUES]
-    return issues[:MAX_DOCSTRING_RETURNS_PLURAL_CARDINALITY_ISSUES]
-
-
-def _module_level_length_constant_names(parsed_tree: ast.Module) -> set[str]:
-    all_length_constant_names: set[str] = set()
-    for each_statement in parsed_tree.body:
-        target_names: list[str] = []
-        assigned_value: ast.expr | None = None
-        if isinstance(each_statement, ast.Assign):
-            assigned_value = each_statement.value
-            target_names = [
-                each_target.id
-                for each_target in each_statement.targets
-                if isinstance(each_target, ast.Name)
-            ]
-        elif isinstance(each_statement, ast.AnnAssign) and isinstance(
-            each_statement.target, ast.Name
-        ):
-            assigned_value = each_statement.value
-            target_names = [each_statement.target.id]
-        if not isinstance(assigned_value, ast.Constant) or not isinstance(
-            assigned_value.value, int
-        ):
-            continue
-        for each_name in target_names:
-            if not ALL_CAPS_WITH_UNDERSCORE_PATTERN.match(each_name):
-                continue
-            if each_name.endswith(ALL_LENGTH_CONSTANT_NAME_SUFFIXES):
-                all_length_constant_names.add(each_name)
-    return all_length_constant_names
-
-
-def _superlative_phrase_by_length_constant(
-    parsed_tree: ast.Module, all_length_constant_names: set[str]
-) -> tuple[dict[str, str], str]:
-    module_docstring = ast.get_docstring(parsed_tree) or ""
-    phrase_by_constant: dict[str, str] = {}
-    unattributed_phrase = ""
-    for each_sentence in DOCSTRING_RUNON_SENTENCE_BOUNDARY_PATTERN.split(module_docstring):
-        lowered_sentence = each_sentence.lower()
-        sentence_phrase = next(
-            (
-                each_phrase
-                for each_phrase in ALL_LENGTH_SUPERLATIVE_RANGE_PHRASES
-                if each_phrase in lowered_sentence
-            ),
-            "",
-        )
-        if not sentence_phrase:
-            continue
-        named_constants = {
-            each_name
-            for each_name in all_length_constant_names
-            if each_name in each_sentence
-        }
-        if named_constants:
-            for each_name in named_constants:
-                phrase_by_constant.setdefault(each_name, sentence_phrase)
-        elif not unattributed_phrase:
-            unattributed_phrase = sentence_phrase
-    return phrase_by_constant, unattributed_phrase
-
-
-def _compare_targets_a_length_constant(
-    compare_node: ast.Compare, all_length_constant_names: set[str]
-) -> str:
-    operands = [compare_node.left, *compare_node.comparators]
-    has_length_call = any(
-        isinstance(each_operand, ast.Call)
-        and isinstance(each_operand.func, ast.Name)
-        and each_operand.func.id == "len"
-        for each_operand in operands
-    )
-    if not has_length_call:
-        return ""
-    for each_operand in operands:
-        if isinstance(each_operand, ast.Name) and each_operand.id in all_length_constant_names:
-            return each_operand.id
-    return ""
-
-
-def _length_gate_comparison_kinds_in_tree(
-    parsed_tree: ast.Module, all_length_constant_names: set[str]
-) -> dict[str, set[str]]:
-    comparison_kinds_by_constant: dict[str, set[str]] = {}
-    for each_node in ast.walk(parsed_tree):
-        if not isinstance(each_node, ast.Compare):
-            continue
-        compared_constant = _compare_targets_a_length_constant(
-            each_node, all_length_constant_names
-        )
-        if not compared_constant:
-            continue
-        for each_operator in each_node.ops:
-            kind = (
-                "equality"
-                if isinstance(each_operator, (ast.Eq, ast.NotEq))
-                else "ordered"
-            )
-            comparison_kinds_by_constant.setdefault(compared_constant, set()).add(kind)
-    return comparison_kinds_by_constant
-
-
-def _package_scan_python_files(file_path: str) -> list[Path]:
-    file = Path(file_path)
-    scan_root = (
-        file.parent.parent
-        if file.parent.name == LENGTH_CONFIG_SUBDIRECTORY_NAME
-        else file.parent
-    )
-    try:
-        all_python_files = sorted(scan_root.rglob(f"*{PYTHON_MODULE_FILE_SUFFIX}"))
-    except OSError:
-        return []
-    return [
-        each_file
-        for each_file in all_python_files[:LENGTH_GATE_PACKAGE_SCAN_FILE_LIMIT]
-        if each_file.resolve() != file.resolve()
-        and not is_test_file(str(each_file))
-    ]
-
-
-def _exact_length_gate_constants_in_package(
-    file_path: str, all_length_constant_names: set[str]
-) -> set[str]:
-    aggregate_kinds: dict[str, set[str]] = {}
-    for each_file in _package_scan_python_files(file_path):
-        try:
-            sibling_tree = ast.parse(each_file.read_text(encoding="utf-8"))
-        except (OSError, SyntaxError, ValueError):
-            continue
-        for each_constant, each_kinds in _length_gate_comparison_kinds_in_tree(
-            sibling_tree, all_length_constant_names
-        ).items():
-            aggregate_kinds.setdefault(each_constant, set()).update(each_kinds)
-    return {
-        each_constant
-        for each_constant, each_kinds in aggregate_kinds.items()
-        if "equality" in each_kinds and "ordered" not in each_kinds
-    }
-
-
-def check_docstring_length_constant_superlative_vs_exact_gate(
-    content: str, file_path: str
-) -> list[str]:
-    """Flag a length-constant docstring that calls an exact gate the "longest" form.
-
-    The drift this catches: a config module defines an integer ``*_LENGTH``
-    constant and its docstring describes that constant with a superlative or
-    range word (``the longest color string the swatch accepts``), while the only
-    code that consumes the constant treats it as an exact-length equality gate
-    (``len(hex_color) != COLOR_AARRGGBB_LENGTH``) — a shorter string is rejected,
-    not accepted at a shorter length. The superlative prose implies a range of
-    accepted lengths the code never allows. The consumer lives in a sibling
-    module, so the check scans the constant module's package tree (its own
-    directory, or its parent package when the module sits in a ``config/``
-    subdirectory) for the comparison; it binds only when a length constant is
-    compared with ``==``/``!=`` against ``len(...)`` somewhere in that tree and
-    never with an ordered operator, so a constant genuinely used as a ceiling
-    (``len(x) <= LIMIT``) is left alone. The superlative phrase is read from the
-    module docstring only, and it is bound to a constant before flagging: a
-    constant is flagged when the docstring sentence carrying the phrase names
-    that constant, or when the phrase sits in a sentence naming no length
-    constant and the docstring never names the constant elsewhere — so a phrase
-    describing one constant (``MAX_NAME_LENGTH is the longest label``) does not
-    flag a different exact-gated constant documented on its own terms. This is
-    the deterministic exact-gate slice of Category O6/O8
-    docstring-vs-implementation drift; the cross-module free-prose variant where
-    the docstring never names the constant stays an audit-lane finding.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions
-            and to locate the package tree the consumer lives in.
-
-    Returns:
-        One issue per length constant the package exact-gates while the module
-        docstring binds a superlative phrase to that constant, capped at the
-        module limit.
-    """
-    if is_test_file(file_path) or is_hook_infrastructure(file_path):
-        return []
-    try:
-        parsed_tree = ast.parse(content)
-    except SyntaxError:
-        return []
-    all_length_constant_names = _module_level_length_constant_names(parsed_tree)
-    if not all_length_constant_names:
-        return []
-    phrase_by_constant, unattributed_phrase = _superlative_phrase_by_length_constant(
-        parsed_tree, all_length_constant_names
-    )
-    if not phrase_by_constant and not unattributed_phrase:
-        return []
-    module_docstring = ast.get_docstring(parsed_tree) or ""
-    named_length_constants = {
-        each_name for each_name in all_length_constant_names if each_name in module_docstring
-    }
-    exact_gate_constants = _exact_length_gate_constants_in_package(
-        file_path, all_length_constant_names
-    )
-    issues: list[str] = []
-    for each_constant in sorted(exact_gate_constants):
-        bound_phrase = phrase_by_constant.get(each_constant, "")
-        if not bound_phrase and each_constant not in named_length_constants:
-            bound_phrase = unattributed_phrase
-        if not bound_phrase:
-            continue
-        issues.append(
-            f"Line 1: module docstring says '{bound_phrase}' about "
-            f"{each_constant}, but the package compares len(...) against it only "
-            "with ==/!= (an exact-length gate that rejects every other length) — "
-            "state the exact required length, not a longest/maximum range "
-            "(Category O6 docstring-vs-implementation drift)"
-        )
-        if len(issues) >= MAX_LENGTH_CONSTANT_SUPERLATIVE_ISSUES:
-            return issues[:MAX_LENGTH_CONSTANT_SUPERLATIVE_ISSUES]
-    return issues[:MAX_LENGTH_CONSTANT_SUPERLATIVE_ISSUES]
-
-
-def _referenced_constant_families(parsed_tree: ast.Module) -> dict[str, set[str]]:
-    members_by_family: dict[str, set[str]] = {}
-    for each_node in ast.walk(parsed_tree):
-        if not isinstance(each_node, ast.Name):
-            continue
-        if not isinstance(each_node.ctx, ast.Load):
-            continue
-        if not ALL_CAPS_WITH_UNDERSCORE_PATTERN.match(each_node.id):
-            continue
-        family_prefix, _, member_suffix = each_node.id.partition("_")
-        if not member_suffix:
-            continue
-        members_by_family.setdefault(family_prefix, set()).add(member_suffix.lower())
-    return members_by_family
-
-
-def _eligible_constant_families(parsed_tree: ast.Module) -> dict[str, set[str]]:
-    return {
-        each_family: each_members
-        for each_family, each_members in _referenced_constant_families(parsed_tree).items()
-        if len(each_members) >= MINIMUM_CONSTANT_FAMILY_MEMBERS_FOR_CARDINAL_CHECK
-    }
-
-
-def _docstring_snake_case_tokens(docstring_text: str) -> set[str]:
-    return set(DOCSTRING_MULTI_SEGMENT_SNAKE_TOKEN_PATTERN.findall(docstring_text))
-
-
-def _docstring_stated_outcome_cardinals(docstring_text: str) -> set[int]:
-    return {
-        ALL_CARDINAL_NUMBER_WORD_VALUES[each_match.group(1).lower()]
-        for each_match in DOCSTRING_CARDINAL_OUTCOME_PHRASE_PATTERN.finditer(docstring_text)
-    }
-
-
-def _documentable_docstrings_with_line(parsed_tree: ast.Module) -> list[tuple[int, str]]:
-    docstrings_with_line: list[tuple[int, str]] = []
-    module_docstring = ast.get_docstring(parsed_tree) or ""
-    if module_docstring:
-        docstrings_with_line.append((1, module_docstring))
-    for each_node in ast.walk(parsed_tree):
-        if not isinstance(
-            each_node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
-        ):
-            continue
-        node_docstring = ast.get_docstring(each_node) or ""
-        if node_docstring:
-            docstrings_with_line.append((each_node.lineno, node_docstring))
-    return docstrings_with_line
-
-
-def check_docstring_cardinal_count_matches_constant_family(
-    content: str, file_path: str
-) -> list[str]:
-    """Flag a docstring cardinal count that differs from a referenced constant family.
-
-    The drift this catches: a docstring states a cardinal count of an outcome
-    family (``Covers the four outcome branches: ...``) and enumerates that
-    family's members in prose, while the module references a member set of the
-    same ``UPPER_SNAKE`` constant family whose size differs from the stated
-    count — above it and below it both trip. The prose
-    misdescribes the code — a reader trusts the count and the enumeration to
-    be the full set, but the module imports and exercises an outcome the summary
-    omits. The check binds only when the docstring states a cardinal beside an
-    outcome noun, names two or more members of one referenced family, leaves at
-    least one referenced family member unnamed, and the family member count
-    differs from every stated cardinal; a complete enumeration, a count that
-    matches the family, and a single passing mention are all left alone. This is
-    the deterministic cardinal-count slice of Category O6
-    docstring-prose-vs-implementation drift. The check runs on test files too,
-    since the drift class lives in a test-module summary.
-
-    Args:
-        content: The source text to inspect.
-        file_path: Accepted for the uniform check interface; the body does not
-            read it.
-
-    Returns:
-        One issue per docstring whose cardinal count and enumeration omit a
-        referenced constant-family member, capped at the module limit.
-    """
-    try:
-        parsed_tree = ast.parse(content)
-    except SyntaxError:
-        return []
-    eligible_families = _eligible_constant_families(parsed_tree)
-    if not eligible_families:
-        return []
-    issues: list[str] = []
-    for each_line, each_docstring in _documentable_docstrings_with_line(parsed_tree):
-        stated_cardinals = _docstring_stated_outcome_cardinals(each_docstring)
-        if not stated_cardinals:
-            continue
-        docstring_tokens = _docstring_snake_case_tokens(each_docstring)
-        if not docstring_tokens:
-            continue
-        for each_family in sorted(eligible_families):
-            family_members = eligible_families[each_family]
-            named_members = docstring_tokens & family_members
-            if len(named_members) < MINIMUM_DOCSTRING_FAMILY_OVERLAP_FOR_CARDINAL_CHECK:
-                continue
-            omitted_members = family_members - docstring_tokens
-            if not omitted_members:
-                continue
-            if len(family_members) in stated_cardinals:
-                continue
-            issues.append(
-                f"Line {each_line}: docstring names {sorted(stated_cardinals)} as the "
-                f"{each_family}_ count but the module references {len(family_members)} "
-                f"{each_family}_ constants — omits {sorted(omitted_members)}; match the "
-                "count and enumeration to the referenced family "
-                "(Category O6 docstring-vs-implementation drift)"
-            )
-            if len(issues) >= MAX_DOCSTRING_CARDINAL_FAMILY_ISSUES:
-                return issues[:MAX_DOCSTRING_CARDINAL_FAMILY_ISSUES]
-    return issues[:MAX_DOCSTRING_CARDINAL_FAMILY_ISSUES]
-
-
-def _called_callee_name(statement: ast.stmt) -> str:
-    candidate_expression: ast.expr | None = None
-    if isinstance(statement, ast.Expr):
-        candidate_expression = statement.value
-    elif isinstance(statement, ast.Assign):
-        candidate_expression = statement.value
-    elif isinstance(statement, ast.AnnAssign):
-        candidate_expression = statement.value
-    if candidate_expression is None:
-        return ""
-    if isinstance(candidate_expression, ast.Await):
-        candidate_expression = candidate_expression.value
-    if not isinstance(candidate_expression, ast.Call):
-        return ""
-    return _call_callee_name(candidate_expression)
-
-
-def _called_callees_in_expression(expression: ast.expr) -> set[str]:
-    callees: set[str] = set()
-    for each_descendant in ast.walk(expression):
-        if not isinstance(each_descendant, ast.Call):
-            continue
-        callee_name = _call_callee_name(each_descendant)
-        if callee_name:
-            callees.add(callee_name)
-    return callees
-
-
-def _linear_step_callees(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-) -> set[str]:
-    callees: set[str] = set()
-    for each_statement in function_node.body:
-        callee_name = _called_callee_name(each_statement)
-        if callee_name:
-            callees.add(callee_name)
-        if isinstance(each_statement, ast.If):
-            callees |= _called_callees_in_expression(each_statement.test)
-    return callees
-
-
-def _branch_guarded_dispatch_callees(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-) -> set[str]:
-    callees: set[str] = set()
-    for each_statement in function_node.body:
-        if not isinstance(each_statement, ast.If):
-            continue
-        for each_branch_statement in each_statement.body + each_statement.orelse:
-            for each_descendant in ast.walk(each_branch_statement):
-                if not isinstance(each_descendant, ast.If):
-                    continue
-                callees |= _called_callees_in_expression(each_descendant.test)
-    return callees
-
-
-def _bare_callee_name(qualified_callee: str) -> str:
-    return qualified_callee.rsplit(".", 1)[-1]
-
-
-def _docstring_names_all_callee_tokens(docstring_text: str, callee_name: str) -> bool:
-    bare_name = _bare_callee_name(callee_name)
-    lowered_docstring = docstring_text.lower()
-    if bare_name.lower() in lowered_docstring:
-        return True
-    callee_tokens = _name_tokens(bare_name)
-    if not callee_tokens:
-        return False
-    return all(each_token.lower() in lowered_docstring for each_token in callee_tokens)
-
-
-def check_docstring_step_enumeration_dispatch_coverage(
-    content: str, file_path: str
-) -> list[str]:
-    """Flag a step-enumeration docstring that omits a conditional dispatch call.
-
-    The drift this catches: a function whose docstring enumerates a linear
-    sequence of steps (``Navigates ..., searches ..., clicks ..., uploads ...``)
-    matching the body's linear-step calls, while the body also routes to a
-    corrective workflow step inside an ``if``/``elif`` branch — a cancel-and-reinitiate
-    or replace-target-row step — whose name the prose never spells out. A reader
-    who trusts the step list to be complete misses that the function can take that
-    conditional path. This is the deterministic slice of Category O4 (step-ordering
-    narrative): a body that guards a branch-only workflow step the enumeration omits.
-
-    A linear-step call is one made as a top-level statement or inside the ``If.test``
-    guard of a top-level ``if`` (``if not await self.navigate(): return``). A
-    dispatch step is a call inside a guard (``If.test``) nested within an
-    ``if``/``elif`` branch (``if not await cancel_and_reinitiate_update(...): return``)
-    that is never also a linear step — the same control-flow-gating shape as a
-    linear step, so plain (unguarded) logging, screenshot, or method-on-local
-    calls inside a branch body are not dispatch steps. The check binds only when
-    the docstring already names two or more linear-step callees by their
-    underscore tokens, proving the prose is a step enumeration describing this
-    body. A dispatch-step callee with two or more underscore tokens, none of
-    whose tokens appear in the prose, is flagged.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per conditional dispatch call the step enumeration omits, capped
-        at the module limit.
-    """
-    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_node in _walk_skipping_type_checking_blocks(parsed_tree):
-        if not isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        if _function_has_exempt_decorator(each_node):
-            continue
-        docstring_text = _function_docstring_text(each_node)
-        if not docstring_text:
-            continue
-        linear_step_callees = _linear_step_callees(each_node)
-        named_linear_steps = [
-            each_callee
-            for each_callee in linear_step_callees
-            if _docstring_names_all_callee_tokens(docstring_text, each_callee)
-        ]
-        if len(named_linear_steps) < MINIMUM_NAMED_LINEAR_STEPS_FOR_DISPATCH_CHECK:
-            continue
-        branch_only_callees = (
-            _branch_guarded_dispatch_callees(each_node) - linear_step_callees
-        )
-        for each_callee in sorted(branch_only_callees):
-            if len(_name_tokens(_bare_callee_name(each_callee))) < MINIMUM_TOKENS_FOR_DISPATCH_CALLEE:
-                continue
-            if _docstring_names_all_callee_tokens(docstring_text, each_callee):
-                continue
-            issues.append(
-                f"Line {each_node.lineno}: {each_node.name}() docstring enumerates linear "
-                f"steps but omits the conditional dispatch step {each_callee}() the body "
-                "guards inside a branch — add the corrective-path step to the enumeration "
-                "(Category O4 step-ordering narrative drift)"
-            )
-            if len(issues) >= MAX_DOCSTRING_STEP_DISPATCH_ISSUES:
-                return issues[:MAX_DOCSTRING_STEP_DISPATCH_ISSUES]
-    return issues[:MAX_DOCSTRING_STEP_DISPATCH_ISSUES]
-
-
+def _names_referenced_in_function(
+    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
+) -> set[str]:
+    return {
+        each_node.id
+        for each_node in ast.walk(function_node)
+        if isinstance(each_node, ast.Name)
+    }
+
+
 def _imported_binding_names(import_node: ast.Import | ast.ImportFrom) -> set[str]:
     bound_names: set[str] = set()
     for each_alias in import_node.names:
@@ -2434,135 +937,6 @@ def check_docstring_names_undefined_constant(content: str, file_path: str) -> li
     return issues[:MAX_DOCSTRING_UNDEFINED_CONSTANT_ISSUES]
 
 
-def _args_entry_prose_by_argument(docstring_text: str) -> dict[str, str]:
-    docstring_lines = docstring_text.splitlines()
-    args_section_index = _find_args_section_index(docstring_lines)
-    if args_section_index is None:
-        return {}
-    prose_by_argument: dict[str, list[str]] = {}
-    current_argument_name: str | None = None
-    entry_indent: int | None = None
-    for each_line in docstring_lines[args_section_index + 1:]:
-        stripped_line = each_line.strip()
-        if not stripped_line:
-            continue
-        if _is_docstring_terminating_section_header(stripped_line):
-            break
-        current_indent = len(each_line) - len(each_line.lstrip())
-        if current_indent == 0:
-            break
-        if entry_indent is None:
-            entry_indent = current_indent
-        if current_indent <= entry_indent:
-            entry_match = DOCSTRING_ARG_ENTRY_PATTERN.match(stripped_line)
-            if entry_match is not None:
-                current_argument_name = entry_match.group(1)
-                prose_by_argument[current_argument_name] = [stripped_line]
-                continue
-        if current_argument_name is not None:
-            prose_by_argument[current_argument_name].append(stripped_line)
-    return {
-        each_name: " ".join(each_lines).lower()
-        for each_name, each_lines in prose_by_argument.items()
-    }
-
-
-def _argument_prose_scopes_a_single_line(argument_prose: str) -> bool:
-    if any(
-        each_phrase in argument_prose for each_phrase in ALL_DOCSTRING_SPAN_SCOPE_OVERRIDE_PHRASES
-    ):
-        return False
-    return any(
-        each_phrase in argument_prose for each_phrase in ALL_DOCSTRING_SINGLE_LINE_SCOPE_PHRASES
-    )
-
-
-def _call_node_builds_explicit_start_range(call_node: ast.Call) -> bool:
-    callee = call_node.func
-    return (
-        isinstance(callee, ast.Name)
-        and callee.id == "range"
-        and len(call_node.args) >= MINIMUM_RANGE_ARGS_FOR_SPAN
-    )
-
-
-def _function_body_scopes_a_span_by_intersection(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-) -> bool:
-    builds_range_span = False
-    calls_span_scoper = False
-    for each_node in ast.walk(function_node):
-        if not isinstance(each_node, ast.Call):
-            continue
-        if _call_node_builds_explicit_start_range(each_node):
-            builds_range_span = True
-        if _call_callee_name(each_node) in ALL_DOCSTRING_SPAN_RANGE_BODY_CALLEE_NAMES:
-            calls_span_scoper = True
-    return builds_range_span and calls_span_scoper
-
-
-def check_docstring_args_single_line_scope_vs_span(content: str, file_path: str) -> list[str]:
-    """Flag a docstring Args entry scoping a finding to one line over a span body.
-
-    The drift this catches: an ``Args:`` entry whose prose says a finding blocks
-    "only when its block-anchor line is among the changed lines" (a single named
-    line) while the function body builds a ``range(...)`` span over the finding's
-    source lines and routes it through a span-intersection scoper that blocks when
-    ANY line of the span is among the changed lines. The Args sentence claims a
-    narrower single-line scope than the body applies, so an edit touching a
-    non-anchor line of the span still blocks — contradicting the Args entry. This
-    is the deterministic slice of Category O6 docstring-vs-implementation drift
-    for an Args single-line scope claim disagreeing with a span-intersection body.
-
-    An entry is left alone when its prose says "any line of" / "any line in" /
-    "any of its lines" / "any span line" about its span, since that wording
-    matches the span body. The body is judged a span-intersection scoper only
-    when it both builds an explicit-start ``range(...)`` (two or more
-    arguments) and calls a known span scoper, so a body that scopes by a
-    single line never trips the check. Hook infrastructure is in scope here — the import-sort gate
-    that carries this drift class is itself a hook — and test files are exempt.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per function whose Args single-line scope claim disagrees with
-        its span-intersection body, capped at the module limit.
-    """
-    if is_test_file(file_path):
-        return []
-    try:
-        parsed_tree = ast.parse(content)
-    except SyntaxError:
-        return []
-    issues: list[str] = []
-    for each_node in _walk_skipping_type_checking_blocks(parsed_tree):
-        if not isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        if _function_has_exempt_decorator(each_node):
-            continue
-        docstring_text = _function_docstring_text(each_node)
-        if not docstring_text:
-            continue
-        if not _function_body_scopes_a_span_by_intersection(each_node):
-            continue
-        for each_argument, each_prose in _args_entry_prose_by_argument(docstring_text).items():
-            if not _argument_prose_scopes_a_single_line(each_prose):
-                continue
-            issues.append(
-                f"Line {each_node.lineno}: {each_node.name}() Args entry '{each_argument}' "
-                "scopes a finding to a single line ('anchor line is among the changed lines') "
-                "while the body builds a range() span and scopes by span intersection — an "
-                "edit touching any non-anchor line of the span still blocks; restate the Args "
-                "entry as 'any line of its span is among the changed lines' (Category O6 "
-                "docstring-vs-implementation drift)"
-            )
-            if len(issues) >= MAX_DOCSTRING_ARGS_SPAN_SCOPE_ISSUES:
-                return issues[:MAX_DOCSTRING_ARGS_SPAN_SCOPE_ISSUES]
-    return issues[:MAX_DOCSTRING_ARGS_SPAN_SCOPE_ISSUES]
-
-
 def _is_narrative_cut_header(stripped_line: str) -> bool:
     return (
         stripped_line in ALL_DOCSTRING_TERMINATING_SECTION_HEADERS
@@ -2883,505 +1257,3 @@ def check_docstring_prose_wall_without_illustration(
     return scoped_issues[:MAX_DOCSTRING_PROSE_WALL_ISSUES]
 
 
-def _raises_section_text(docstring_text: str) -> str:
-    docstring_lines = docstring_text.splitlines()
-    raises_section_lines: list[str] = []
-    inside_raises_section = False
-    for each_line in docstring_lines:
-        stripped_line = each_line.strip()
-        if stripped_line == "Raises:":
-            inside_raises_section = True
-            continue
-        if not inside_raises_section:
-            continue
-        if _is_docstring_terminating_section_header(stripped_line):
-            break
-        raises_section_lines.append(stripped_line)
-    return " ".join(raises_section_lines)
-
-
-def _call_argument_by_keyword_or_position(
-    call_node: ast.Call, keyword_name: str, positional_index: int
-) -> ast.expr | None:
-    for each_keyword in call_node.keywords:
-        if each_keyword.arg == keyword_name:
-            return each_keyword.value
-    if positional_index >= len(call_node.args):
-        return None
-    if any(
-        isinstance(each_argument, ast.Starred)
-        for each_argument in call_node.args[: positional_index + 1]
-    ):
-        return None
-    return call_node.args[positional_index]
-
-
-def _call_opens_zipfile_write_mode_writer(call_node: ast.Call) -> bool:
-    callee = call_node.func
-    if isinstance(callee, ast.Attribute):
-        callee_name = callee.attr
-    elif isinstance(callee, ast.Name):
-        callee_name = callee.id
-    else:
-        return False
-    if callee_name != ZIPFILE_WRITER_CLASS_NAME:
-        return False
-    mode_argument = _call_argument_by_keyword_or_position(
-        call_node, ZIPFILE_MODE_KEYWORD, ZIPFILE_MODE_POSITIONAL_INDEX
-    )
-    return (
-        isinstance(mode_argument, ast.Constant)
-        and mode_argument.value in ALL_ZIPFILE_WRITE_MODE_VALUES
-    )
-
-
-def _zipfile_writer_forbids_zip64(call_node: ast.Call) -> bool:
-    allow_zip64_argument = _call_argument_by_keyword_or_position(
-        call_node, ZIPFILE_ALLOW_ZIP64_KEYWORD, ZIPFILE_ALLOW_ZIP64_POSITIONAL_INDEX
-    )
-    return (
-        isinstance(allow_zip64_argument, ast.Constant)
-        and allow_zip64_argument.value is False
-    )
-
-
-def _function_documents_unraisable_largezipfile(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-    docstring_text: str,
-) -> bool:
-    if DOCSTRING_LARGE_ZIP_FILE_EXCEPTION_NAME not in _raises_section_text(docstring_text):
-        return False
-    write_mode_writers = [
-        each_descendant
-        for each_descendant in _walk_skipping_nested_functions(function_node)
-        if isinstance(each_descendant, ast.Call)
-        and _call_opens_zipfile_write_mode_writer(each_descendant)
-    ]
-    if not write_mode_writers:
-        return False
-    return not any(
-        _zipfile_writer_forbids_zip64(each_writer) for each_writer in write_mode_writers
-    )
-
-
-def _attributes_section_entries(docstring_text: str) -> list[tuple[str, str]]:
-    """Return each ``name: description`` entry under an Attributes section.
-
-    A continuation line indented under an entry joins that entry's description,
-    so a field whose description wraps across lines reads as one string. The
-    scan ends at the next Google-style section header or at the docstring end.
-
-    Args:
-        docstring_text: The full class docstring text to scan.
-
-    Returns:
-        One ``(field_name, description)`` pair per Attributes entry, in order.
-    """
-    all_lines = docstring_text.splitlines()
-    inside_section = False
-    entries: list[tuple[str, str]] = []
-    for each_line in all_lines:
-        stripped_line = each_line.strip()
-        if not inside_section:
-            if stripped_line in ("Attributes:", "Attrs:"):
-                inside_section = True
-            continue
-        if stripped_line.endswith(":") and not each_line.startswith((" ", "\t")):
-            break
-        if stripped_line in ALL_DOCSTRING_TERMINATING_SECTION_HEADERS:
-            break
-        entry_match = re.match(
-            r"^\s+(?P<field_name>[A-Za-z_][A-Za-z0-9_]*):\s*(?P<description>.*)$",
-            each_line,
-        )
-        if entry_match:
-            entries.append(
-                (entry_match.group("field_name"), entry_match.group("description"))
-            )
-        elif entries and stripped_line:
-            previous_name, previous_description = entries[-1]
-            entries[-1] = (previous_name, f"{previous_description} {stripped_line}")
-    return entries
-
-def _field_name_is_run_mode_flag(field_name: str) -> bool:
-    lowered_name = field_name.lower()
-    return any(
-        each_token in lowered_name
-        for each_token in ALL_DOCSTRING_RUNMODE_FLAG_FIELD_NAME_TOKENS
-    )
-
-def _description_claims_per_record_write_outcome(description: str) -> bool:
-    lowered_description = description.lower()
-    has_write_outcome_phrase = any(
-        each_phrase in lowered_description
-        for each_phrase in ALL_DOCSTRING_PER_RECORD_WRITE_OUTCOME_PHRASES
-    )
-    has_run_mode_phrase = any(
-        each_phrase in lowered_description
-        for each_phrase in ALL_DOCSTRING_RUN_MODE_PHRASES
-    )
-    return has_write_outcome_phrase and not has_run_mode_phrase
-
-def check_docstring_field_runmode_outcome(content: str, file_path: str) -> list[str]:
-    """Flag a run-mode flag field documented as a per-record write outcome.
-
-    The drift this catches: a dataclass or TypedDict field whose name marks a
-    run-mode flag (``is_dry_run``) is documented in the class Attributes block
-    with per-record write-outcome prose (``True when no STP was written``),
-    while the value is set the same way for every record from the run mode
-    (``is_dry_run=not is_execute``). An already-OK record in an execute run then
-    writes no file yet still stores ``False``, so the per-record prose misleads
-    every reader. The check binds only when the description carries a
-    write-outcome phrase and no run-mode phrase, so a field documented by its
-    run-mode meaning is left alone. This is the deterministic single-file slice
-    of Category O6 run-mode-versus-per-record docstring drift.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per run-mode flag field whose Attributes description claims a
-        per-record write outcome, capped at the module limit.
-    """
-    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_node in ast.walk(parsed_tree):
-        if not isinstance(each_node, ast.ClassDef):
-            continue
-        docstring_text = ast.get_docstring(each_node) or ""
-        if not docstring_text:
-            continue
-        for each_field_name, each_description in _attributes_section_entries(docstring_text):
-            if not _field_name_is_run_mode_flag(each_field_name):
-                continue
-            if not _description_claims_per_record_write_outcome(each_description):
-                continue
-            issues.append(
-                f"Line {each_node.lineno}: {each_node.name}.{each_field_name} is a "
-                "run-mode flag but its Attributes description claims a per-record "
-                "write outcome — restate it as the run-mode meaning the assignment "
-                "gives it (Category O6 run-mode-versus-per-record docstring drift)"
-            )
-            if len(issues) >= MAX_DOCSTRING_FIELD_RUNMODE_OUTCOME_ISSUES:
-                return issues[:MAX_DOCSTRING_FIELD_RUNMODE_OUTCOME_ISSUES]
-    return issues[:MAX_DOCSTRING_FIELD_RUNMODE_OUTCOME_ISSUES]
-
-
-def check_docstring_raises_unraisable_largezipfile(
-    content: str, file_path: str
-) -> list[str]:
-    """Flag a Raises clause naming LargeZipFile over a default-ZIP64 writer.
-
-    The drift this catches: a function whose docstring Raises clause lists
-    ``zipfile.LargeZipFile`` while the function opens its ``zipfile.ZipFile``
-    writer in a write mode (``w``/``a``/``x``) with ``allowZip64`` left at its
-    default of True. The stdlib raises ``LargeZipFile`` only when an entry needs
-    ZIP64 AND ``allowZip64`` is False; with ZIP64 permitted the writer
-    transparently uses it and never raises. The Raises entry then documents an
-    exception the body cannot produce, so a caller guarding ``LargeZipFile`` on
-    the strength of the docstring guards an unreachable path. This is the
-    deterministic slice of Category O6 docstring-prose-vs-implementation drift
-    where a writer opened with default ZIP64 disagrees with a LargeZipFile
-    Raises clause.
-
-    The check binds only when the function opens at least one write-mode
-    ``ZipFile`` and every such writer permits ZIP64, so a function that forbids
-    ZIP64 on any writer (``allowZip64=False``, by keyword or position), a
-    read-only open, and a function that opens no writer — where the exception may
-    propagate from a callee — are all left alone.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per function whose LargeZipFile Raises clause names an
-        unreachable exception, capped at the module limit.
-    """
-    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_node in _walk_skipping_type_checking_blocks(parsed_tree):
-        if not isinstance(each_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        if _function_has_exempt_decorator(each_node):
-            continue
-        docstring_text = _function_docstring_text(each_node)
-        if not docstring_text:
-            continue
-        if not _function_documents_unraisable_largezipfile(each_node, docstring_text):
-            continue
-        issues.append(
-            f"Line {each_node.lineno}: {each_node.name}() docstring Raises lists "
-            "zipfile.LargeZipFile, but the function opens its ZipFile writer with ZIP64 "
-            "permitted (allowZip64 defaults to True) — LargeZipFile raises only when "
-            "allowZip64 is False, so drop the entry or pass allowZip64=False "
-            "(Category O6 docstring-vs-implementation drift)"
-        )
-        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]