claude-dev-env 1.35.0 → 1.36.0

package/hooks/blocking/test_code_rules_enforcer.py

@@ -33,14 +33,82 @@ def _load_enforcer_module() -> ModuleType:
 code_rules_enforcer = _load_enforcer_module()
 
 _BLOCKING_DIR = Path(__file__).resolve().parent
+_HOOKS_TREE_DIR = _BLOCKING_DIR.parent
 if str(_BLOCKING_DIR) not in sys.path:
     sys.path.insert(0, str(_BLOCKING_DIR))
+if str(_HOOKS_TREE_DIR) not in sys.path:
+    sys.path.insert(0, str(_HOOKS_TREE_DIR))
 
 from code_rules_path_utils import is_config_file as path_utils_is_config_file  # noqa: E402
+from config.banned_identifiers_constants import (  # noqa: E402
+    ALL_BANNED_IDENTIFIERS as config_all_banned_identifiers,
+    BANNED_IDENTIFIER_MESSAGE_SUFFIX as config_banned_identifier_message_suffix,
+    BANNED_IDENTIFIER_SKIP_ADVISORY as config_banned_identifier_skip_advisory,
+    MAX_BANNED_IDENTIFIER_ISSUES as config_max_banned_identifier_issues,
+)
+from config.hardcoded_user_path_constants import (  # noqa: E402
+    HARDCODED_USER_PATH_GUIDANCE as config_hardcoded_user_path_guidance,
+    HARDCODED_USER_PATH_PATTERN as config_hardcoded_user_path_pattern,
+    MAX_HARDCODED_USER_PATH_ISSUES as config_max_hardcoded_user_path_issues,
+)
+from config.stuttering_check_config import (  # noqa: E402
+    MAX_STUTTERING_PREFIX_ISSUES as config_max_stuttering_prefix_issues,
+    STUTTERING_ALL_PREFIX_PATTERN as config_stuttering_all_prefix_pattern,
+)
 
 PRODUCTION_FILE_PATH = "packages/claude-dev-env/hooks/blocking/example_production.py"
 
 
+def test_should_expose_all_banned_identifiers_from_config() -> None:
+    expected_banned_identifiers = frozenset({
+        "result", "data", "output", "response", "value", "item", "temp",
+        "argv", "args", "kwargs", "argc",
+    })
+    actual_banned_identifiers = getattr(
+        code_rules_enforcer, "ALL_BANNED_IDENTIFIERS", None
+    )
+    assert actual_banned_identifiers is not None, (
+        "Renamed constant ALL_BANNED_IDENTIFIERS must be importable from "
+        "config/banned_identifiers_constants.py and re-exposed on the "
+        f"enforcer module, got: {actual_banned_identifiers!r}"
+    )
+    assert expected_banned_identifiers <= actual_banned_identifiers, (
+        "ALL_BANNED_IDENTIFIERS must contain every expected banned identifier; "
+        f"missing: {expected_banned_identifiers - actual_banned_identifiers!r}"
+    )
+
+
+def test_should_source_banned_identifier_companion_constants_from_config() -> None:
+    assert (
+        code_rules_enforcer.MAX_BANNED_IDENTIFIER_ISSUES
+        is config_max_banned_identifier_issues
+    )
+    assert (
+        code_rules_enforcer.BANNED_IDENTIFIER_MESSAGE_SUFFIX
+        is config_banned_identifier_message_suffix
+    )
+    assert (
+        code_rules_enforcer.BANNED_IDENTIFIER_SKIP_ADVISORY
+        is config_banned_identifier_skip_advisory
+    )
+
+
+def test_should_reexport_hardcoded_user_path_pattern_from_config() -> None:
+    assert code_rules_enforcer.HARDCODED_USER_PATH_PATTERN is config_hardcoded_user_path_pattern
+
+
+def test_should_reexport_max_hardcoded_user_path_issues_from_config() -> None:
+    assert code_rules_enforcer.MAX_HARDCODED_USER_PATH_ISSUES == config_max_hardcoded_user_path_issues
+
+
+def test_should_reexport_hardcoded_user_path_guidance_from_config() -> None:
+    assert code_rules_enforcer.HARDCODED_USER_PATH_GUIDANCE == config_hardcoded_user_path_guidance
+
+
+def test_should_reexport_all_banned_identifiers_from_config() -> None:
+    assert code_rules_enforcer.ALL_BANNED_IDENTIFIERS is config_all_banned_identifiers
+
+
 def test_should_flag_constant_used_only_in_class_level_decorator() -> None:
     source = (
         "TIMEOUT = 5\n"
@@ -1010,3 +1078,117 @@ def test_check_constants_outside_config_reports_more_than_three_constants() -> N
     assert len(issues) == expected_constant_count, (
         f"Expected all {expected_constant_count} constants reported, got {len(issues)}: {issues}"
     )
+
+
+def test_stuttering_collection_prefix_flags_function_name_loop1_1() -> None:
+    source = "def all_all_process() -> None:\n    return None\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, "packages/app/services/foo.py"
+    )
+    assert any("all_all_process" in each_issue for each_issue in issues), (
+        f"loop1-1: stuttering function name must be flagged, got: {issues}"
+    )
+
+
+def test_stuttering_collection_prefix_flags_with_as_binding_loop3_1() -> None:
+    source = "def f() -> None:\n    with open('x') as all_all_context:\n        pass\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, "packages/app/services/foo.py"
+    )
+    assert any("all_all_context" in each_issue for each_issue in issues), (
+        f"loop3-1: stuttering with-as binding must be flagged, got: {issues}"
+    )
+
+
+def test_stuttering_collection_prefix_flags_except_as_binding_loop3_1() -> None:
+    source = (
+        "def f() -> None:\n"
+        "    try:\n"
+        "        pass\n"
+        "    except Exception as all_all_error:\n"
+        "        pass\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, "packages/app/services/foo.py"
+    )
+    assert any("all_all_error" in each_issue for each_issue in issues), (
+        f"loop3-1: stuttering except-as binding must be flagged, got: {issues}"
+    )
+
+
+def test_stuttering_constants_live_under_config_subpackage() -> None:
+    """Stuttering-prefix constants must be sourced from the hooks-tree config package.
+
+    Per CODE_RULES, module-level UPPER_SNAKE constants must live under a
+    directory segment named ``config``. This test pins the move so the
+    constants cannot regress to inline definition at the enforcer module's
+    top level. The enforcer's own bootstrap inserts the hooks tree onto
+    ``sys.path`` so ``config.stuttering_check_config`` resolves at runtime.
+    """
+    assert (
+        code_rules_enforcer.STUTTERING_ALL_PREFIX_PATTERN
+        is config_stuttering_all_prefix_pattern
+    ), "Enforcer must reuse the hooks-tree config STUTTERING_ALL_PREFIX_PATTERN object"
+    assert (
+        code_rules_enforcer.MAX_STUTTERING_PREFIX_ISSUES
+        == config_max_stuttering_prefix_issues
+    ), "Enforcer must reuse the hooks-tree config MAX_STUTTERING_PREFIX_ISSUES value"
+
+
+SYS_PATH_INSERT_PRODUCTION_FILE_PATH = "packages/app/services/loader.py"
+SYS_PATH_INSERT_HOOK_INFRASTRUCTURE_FILE_PATH = "/repo/.claude/hooks/blocking/some_hook.py"
+
+
+def test_sys_path_insert_should_flag_mismatched_guard_path() -> None:
+    source = (
+        "import sys\n"
+        'if "wrong_path" not in sys.path:\n'
+        '    sys.path.insert(0, "actual_path")\n'
+    )
+    issues = code_rules_enforcer.check_sys_path_insert_deduplication_guard(
+        source, SYS_PATH_INSERT_PRODUCTION_FILE_PATH
+    )
+    assert any("sys.path.insert" in each_issue for each_issue in issues), (
+        "Guard testing a different value than what is inserted must be flagged, "
+        f"got: {issues}"
+    )
+
+
+def test_sys_path_insert_should_not_flag_matching_guard_path() -> None:
+    source = (
+        "import sys\n"
+        'if "correct_path" not in sys.path:\n'
+        '    sys.path.insert(0, "correct_path")\n'
+    )
+    issues = code_rules_enforcer.check_sys_path_insert_deduplication_guard(
+        source, SYS_PATH_INSERT_PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Guard testing the same value that is inserted must not be flagged, got: {issues}"
+    )
+
+
+def test_sys_path_insert_should_not_flag_guarded_insert_in_class_body() -> None:
+    source = (
+        "import sys\n"
+        "class Configurator:\n"
+        "    target = '/some/path'\n"
+        "    if target not in sys.path:\n"
+        "        sys.path.insert(0, target)\n"
+    )
+    issues = code_rules_enforcer.check_sys_path_insert_deduplication_guard(
+        source, SYS_PATH_INSERT_PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Guarded sys.path.insert directly in a class body must not be flagged, got: {issues}"
+    )
+
+
+def test_sys_path_insert_should_skip_hook_infrastructure_files() -> None:
+    source = "import sys\nsys.path.insert(0, '/some/path')\n"
+    issues = code_rules_enforcer.check_sys_path_insert_deduplication_guard(
+        source, SYS_PATH_INSERT_HOOK_INFRASTRUCTURE_FILE_PATH
+    )
+    assert issues == [], (
+        f"Hook infrastructure files are exempt from this rule, got: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_banned_identifier.py

@@ -229,3 +229,109 @@ def test_should_emit_stderr_advisory_on_syntax_error(
     captured = capsys.readouterr()  # type: ignore[attr-defined]
     assert "banned-identifier check skipped" in captured.err
     assert PRODUCTION_FILE_PATH in captured.err
+
+
+def test_should_flag_argv_assignment() -> None:
+    content = "def parse_command():\n    argv = collect()\n    return argv\n"
+    issues = check_banned_identifiers(content, PRODUCTION_FILE_PATH)
+    assert any("'argv'" in each_issue for each_issue in issues), (
+        f"Expected 'argv' flagged — use arguments_list, got: {issues}"
+    )
+
+
+def test_should_flag_args_assignment() -> None:
+    content = "def parse_command():\n    args = collect()\n    return args\n"
+    issues = check_banned_identifiers(content, PRODUCTION_FILE_PATH)
+    assert any("'args'" in each_issue for each_issue in issues), (
+        f"Expected 'args' flagged — use arguments, got: {issues}"
+    )
+
+
+def test_should_not_flag_args_assigned_parse_args_call() -> None:
+    content = (
+        "def main():\n"
+        "    parser = build_parser()\n"
+        "    args = parser.parse_args()\n"
+        "    return args\n"
+    )
+    issues = check_banned_identifiers(content, PRODUCTION_FILE_PATH)
+    assert issues == [], (
+        "args = parser.parse_args() is established argparse idiom; must not flag, "
+        f"got: {issues}"
+    )
+
+
+def test_should_not_flag_args_annotated_parse_args_call() -> None:
+    content = (
+        "def main():\n"
+        "    parser = build_parser()\n"
+        "    args: object = parser.parse_args()\n"
+        "    return args\n"
+    )
+    issues = check_banned_identifiers(content, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Annotated parse_args binding must not flag, got: {issues}"
+
+
+def test_should_not_flag_args_walrus_parse_args_call() -> None:
+    content = (
+        "def main():\n"
+        "    parser = build_parser()\n"
+        "    if (args := parser.parse_args()):\n"
+        "        return args\n"
+        "    return None\n"
+    )
+    issues = check_banned_identifiers(content, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Walrus parse_args binding must not flag, got: {issues}"
+
+
+def test_should_flag_args_assigned_parse_args_method_reference() -> None:
+    content = (
+        "def main():\n"
+        "    parser = build_parser()\n"
+        "    args = parser.parse_args\n"
+        "    return args\n"
+    )
+    issues = check_banned_identifiers(content, PRODUCTION_FILE_PATH)
+    assert any("'args'" in each_issue for each_issue in issues), (
+        "Method reference (no call) is not the namespace idiom; must flag, "
+        f"got: {issues}"
+    )
+
+
+def test_should_flag_kwargs_assignment() -> None:
+    content = "def parse_command():\n    kwargs = collect()\n    return kwargs\n"
+    issues = check_banned_identifiers(content, PRODUCTION_FILE_PATH)
+    assert any("'kwargs'" in each_issue for each_issue in issues), (
+        f"Expected 'kwargs' flagged — use keyword_arguments, got: {issues}"
+    )
+
+
+def test_should_flag_argc_assignment() -> None:
+    content = "def parse_command():\n    argc = count()\n    return argc\n"
+    issues = check_banned_identifiers(content, PRODUCTION_FILE_PATH)
+    assert any("'argc'" in each_issue for each_issue in issues), (
+        f"Expected 'argc' flagged — use argument_count, got: {issues}"
+    )
+
+
+def test_should_not_flag_args_as_function_parameter() -> None:
+    content = (
+        "def passthrough(*args, **kwargs):\n"
+        "    return args, kwargs\n"
+    )
+    issues = check_banned_identifiers(content, PRODUCTION_FILE_PATH)
+    assert issues == [], (
+        f"*args/**kwargs parameters are Python convention, must not flag, got: {issues}"
+    )
+
+
+def test_should_not_flag_argv_substring_in_local_name() -> None:
+    content = (
+        "def parse_command():\n"
+        "    parsed_argv_entries = []\n"
+        "    return parsed_argv_entries\n"
+    )
+    issues = check_banned_identifiers(content, PRODUCTION_FILE_PATH)
+    assert issues == [], (
+        f"Substring 'argv' inside parsed_argv_entries must not flag, got: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_cap_meta.py

@@ -0,0 +1,173 @@
+"""Meta-test asserting every check_* function in code_rules_enforcer follows the cap convention.
+
+Bot reviewers on PR #232 flagged check_existence_check_tests,
+check_constant_equality_tests, and check_unused_optional_parameters for
+returning unbounded issue lists, which produces a spammy blocking
+payload when a single file has many violations of the same kind.
+
+The convention is: every check_* function should either apply an
+explicit cap (the meta-test treats a function as capped when its source
+contains a ``MAX_`` constant name or uses ``itertools.islice`` for bounded
+iteration), or be explicitly listed below as a known-uncapped check
+along with the reason, or appear in VOID_ADVISORY_CHECK_FUNCTION_NAMES
+when the function is annotated ``-> None`` and never contributes issues to the
+blocking payload (stderr-only advisories). New check_* functions added to the
+module without consideration will trip this test.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import inspect
+import pathlib
+import sys
+
+
+_HOOK_DIRECTORY = pathlib.Path(__file__).parent
+if str(_HOOK_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_HOOK_DIRECTORY))
+
+_hook_spec = importlib.util.spec_from_file_location(
+    "code_rules_enforcer",
+    _HOOK_DIRECTORY / "code_rules_enforcer.py",
+)
+assert _hook_spec is not None
+assert _hook_spec.loader is not None
+_hook_module = importlib.util.module_from_spec(_hook_spec)
+_hook_spec.loader.exec_module(_hook_module)
+
+VOID_ADVISORY_CHECK_FUNCTION_NAMES: frozenset[str] = frozenset(
+    {
+        "check_duplicated_format_patterns",
+        "check_incomplete_mocks",
+    }
+)
+
+KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW: frozenset[str] = frozenset(
+    {
+        "check_boolean_naming",
+        "check_collection_prefix",
+        "check_comment_changes",
+        "check_comments_javascript",
+        "check_comments_python",
+        "check_constant_equality_tests",
+        "check_constants_outside_config",
+        "check_constants_outside_config_advisory",
+        "check_e2e_test_naming",
+        "check_existence_check_tests",
+        "check_file_global_constants_use_count",
+        "check_fstring_structural_literals",
+        "check_imports_at_top",
+        "check_inline_literal_collections",
+        "check_library_print",
+        "check_logging_fstrings",
+        "check_loop_variable_naming",
+        "check_magic_values",
+        "check_parameter_annotations",
+        "check_return_annotations",
+        "check_skip_decorators_in_tests",
+        "check_string_literal_magic",
+        "check_type_escape_hatches",
+        "check_unused_optional_parameters",
+        "check_windows_api_none",
+    }
+)
+
+CAP_TOKEN_FRAGMENTS: tuple[str, ...] = ("MAX_", "islice")
+
+
+def _all_check_function_names() -> list[str]:
+    return [
+        each_attribute_name
+        for each_attribute_name in dir(_hook_module)
+        if each_attribute_name.startswith("check_")
+        and callable(getattr(_hook_module, each_attribute_name))
+    ]
+
+
+def _function_source_contains_cap(function_name: str) -> bool:
+    function_object = getattr(_hook_module, function_name)
+    function_source = inspect.getsource(function_object)
+    return any(
+        each_fragment in function_source for each_fragment in CAP_TOKEN_FRAGMENTS
+    )
+
+
+def test_every_check_function_either_caps_or_is_explicitly_pending() -> None:
+    all_check_names = set(_all_check_function_names())
+    capped_check_names = {
+        each_name
+        for each_name in all_check_names
+        if _function_source_contains_cap(each_name)
+    }
+    uncapped_check_names = all_check_names - capped_check_names
+    unexpected_uncapped = (
+        uncapped_check_names
+        - KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW
+        - VOID_ADVISORY_CHECK_FUNCTION_NAMES
+    )
+    assert unexpected_uncapped == set(), (
+        f"New check_* functions added without a cap and not on the pending-review list: "
+        f"{sorted(unexpected_uncapped)}. Either add a MAX_* cap or islice-bounded loop in "
+        f"source, or explicitly add the function to KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW with "
+        f"a reason in the test header docstring, or list it in VOID_ADVISORY_CHECK_FUNCTION_NAMES "
+        f"when it is annotated -> None and emits only stderr guidance."
+    )
+
+
+def test_pending_review_set_does_not_grow_silently() -> None:
+    all_check_names = set(_all_check_function_names())
+    stale_pending = KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW - all_check_names
+    assert stale_pending == set(), (
+        f"KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW lists functions that no longer exist: "
+        f"{sorted(stale_pending)}. Either restore the function or remove it from the list."
+    )
+
+
+def test_pending_review_set_excludes_functions_that_already_match_cap_heuristic() -> None:
+    all_check_names = set(_all_check_function_names())
+    pending_that_exist = KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW & all_check_names
+    capped_but_still_pending = {
+        each_name
+        for each_name in pending_that_exist
+        if _function_source_contains_cap(each_name)
+    }
+    assert capped_but_still_pending == set(), (
+        f"KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW must not list checks that already satisfy the "
+        f"cap heuristic (would hide a later cap removal): {sorted(capped_but_still_pending)}. "
+        f"Remove those names from the pending set after capping."
+    )
+
+
+def test_void_advisory_checks_are_registered_and_disjoint() -> None:
+    all_check_names = set(_all_check_function_names())
+    assert VOID_ADVISORY_CHECK_FUNCTION_NAMES <= all_check_names, (
+        f"VOID_ADVISORY_CHECK_FUNCTION_NAMES references missing names: "
+        f"{sorted(VOID_ADVISORY_CHECK_FUNCTION_NAMES - all_check_names)}"
+    )
+    for each_name in VOID_ADVISORY_CHECK_FUNCTION_NAMES:
+        function_object = getattr(_hook_module, each_name)
+        return_annotation = inspect.signature(function_object).return_annotation
+        assert return_annotation is None, (
+            f"VOID_ADVISORY_CHECK_FUNCTION_NAMES must list only advisory-only checks annotated "
+            f"with -> None (stderr-only, never block). {each_name!r} has return annotation "
+            f"{return_annotation!r}."
+        )
+    overlap = VOID_ADVISORY_CHECK_FUNCTION_NAMES & KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW
+    assert overlap == set(), (
+        f"Void-advisory checks must not also appear on the uncapped pending list: "
+        f"{sorted(overlap)}"
+    )
+
+
+def test_already_capped_checks_stay_capped() -> None:
+    capped_baseline: frozenset[str] = frozenset(
+        {
+            "check_banned_identifiers",
+        }
+    )
+    for each_name in capped_baseline:
+        assert _function_source_contains_cap(each_name), (
+            f"{each_name} previously had a cap reference and now does not. "
+            f"Caps protect blocking output from spamming reviewers — restore it."
+        )

package/hooks/blocking/test_code_rules_enforcer_collection_prefix.py

@@ -135,3 +135,194 @@ def test_should_flag_module_level_qualified_typing_optional_constant() -> None:
     assert any("RAW_NUMBERS" in each_issue for each_issue in issues), (
         f"Expected typing.Optional[set[int]] module-level constant flagged, got: {issues}"
     )
+
+
+def test_should_flag_function_local_double_all_prefix() -> None:
+    source = (
+        "def grant() -> None:\n"
+        "    all_all_permission_rules = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_permission_rules" in each_issue for each_issue in issues), (
+        f"PR #289 finding: stuttering all_all_ must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_module_level_double_all_uppercase() -> None:
+    source = "ALL_ALL_PROVIDERS = []\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("ALL_ALL_PROVIDERS" in each_issue for each_issue in issues), (
+        f"Stuttering ALL_ALL_ at module scope must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_triple_all_prefix_stuttering() -> None:
+    source = (
+        "def consume() -> None:\n"
+        "    all_all_all_things = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_all_things" in each_issue for each_issue in issues), (
+        f"Triple all_ stuttering must be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_single_all_prefix() -> None:
+    source = (
+        "def consume() -> None:\n"
+        "    all_users = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Single all_ prefix is correct usage, must not flag, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_in_function_parameter() -> None:
+    source = (
+        "def consume(all_all_users: list) -> None:\n"
+        "    return None\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_users" in each_issue for each_issue in issues), (
+        f"Stuttering parameter name must be flagged, got: {issues}"
+    )
+
+
+def test_should_skip_stuttering_check_in_test_files() -> None:
+    source = (
+        "def test_something() -> None:\n"
+        "    all_all_results = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, "packages/app/tests/test_foo.py"
+    )
+    assert issues == [], f"Test files exempt, got: {issues}"
+
+
+def test_should_not_flag_all_all_when_used_as_substring() -> None:
+    source = (
+        "def consume() -> None:\n"
+        "    install_all_users = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"'all_all_' as substring inside install_all_users must not flag, got: {issues}"
+    )
+
+
+def test_should_flag_underscore_prefixed_uppercase_double_all() -> None:
+    source = "_ALL_ALL_PROVIDERS = []\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("_ALL_ALL_PROVIDERS" in each_issue for each_issue in issues), (
+        f"Stuttering _ALL_ALL_ private constant must be flagged (regex symmetry), got: {issues}"
+    )
+
+
+def test_should_flag_underscore_prefixed_lowercase_double_all() -> None:
+    source = (
+        "def grant() -> None:\n"
+        "    _all_all_permission_rules = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("_all_all_permission_rules" in each_issue for each_issue in issues), (
+        f"Stuttering _all_all_ private local must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_function_name() -> None:
+    source = "def all_all_process() -> None:\n    return None\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_process" in each_issue for each_issue in issues), (
+        f"Stuttering function name must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_async_function_name() -> None:
+    source = "async def all_all_fetch() -> None:\n    return None\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_fetch" in each_issue for each_issue in issues), (
+        f"Stuttering async function name must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_walrus_target() -> None:
+    source = (
+        "def grant() -> None:\n"
+        "    if (all_all_result := compute()):\n"
+        "        return None\n"
+        "def compute() -> int:\n"
+        "    return 0\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_result" in each_issue for each_issue in issues), (
+        f"Stuttering walrus target must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_comprehension_target() -> None:
+    source = (
+        "def grant() -> list[int]:\n"
+        "    return [all_all_item for all_all_item in range(10)]\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_item" in each_issue for each_issue in issues), (
+        f"Stuttering comprehension target must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_import_as_alias() -> None:
+    source = "import collections as all_all_collections\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_collections" in each_issue for each_issue in issues), (
+        f"Stuttering import-as alias must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_from_import_as_alias() -> None:
+    source = "from collections import OrderedDict as all_all_ordered\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_ordered" in each_issue for each_issue in issues), (
+        f"Stuttering from-import as alias must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_class_name() -> None:
+    source = (
+        "class all_all_models:\n"
+        "    value = 1\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_models" in each_issue for each_issue in issues), (
+        f"Stuttering class name must be flagged, got: {issues}"
+    )