claude-dev-env 1.34.1 → 1.35.0

package/agents/docs-agent.md

@@ -33,7 +33,7 @@ color: cyan
 
 You handle all documentation tasks: orchestrating doc workflows, analyzing project docs, and writing user-facing guides.
 
-**Works with:** clean-coder (identify reusable utilities), validation-expert (path changes trigger doc updates)
+**Works with:** clean-coder (identify reusable utilities)
 
 ## Mode 1: Documentation Orchestration
 

package/agents/project-docs-analyzer.md

@@ -8,7 +8,6 @@ color: cyan
 You analyze project documentation to prevent code duplication and provide implementation guidance.
 
 **Use before:** implementing new features (check for duplication)
-**Works with:** refactoring-specialist (identify reusable utilities)
 
 ## Primary Responsibilities
 

package/agents/skill-to-agent-converter.md

@@ -162,7 +162,6 @@ Trigger this agent when:
 
 Do NOT use this agent when:
 
-- User wants to create a brand-new agent from scratch (use agent-writer instead)
 - No skills exist to convert
 - User wants to modify existing agent (direct editing is better)
 - User wants to create a skill (different workflow)

package/commands/initialize.md

@@ -17,7 +17,6 @@ Read CLAUDE.md now and focus on:
 **Agent Decision Tree:**
 - Automation work → check available agents for automation patterns
 - Web App Development → check available agents for framework-specific patterns
-- Configuration/Architecture → config-extraction-agent, parallel-workflow-coordinator
 
 **Never skip agent check to "save time" or because request "seems simple"**
 

package/commands/readability-review.md

@@ -1,14 +1,14 @@
 ---
 description: "8-dimension readability review: scores and FIXES code to 160/160. Also handles paste-rewrite via arguments."
-allowed-tools: Task, Read, Edit, Grep, Glob
+allowed-tools: Skill, Read, Edit, Grep, Glob, Bash
 ---
 
-Launch the readability-review agent to review and fix code readability.
+Invoke the `readability-review` skill to review and fix code readability.
 
 ## Steps
 
-1. Launch a `readability-review-agent` via the Task tool
-2. The agent will: load its rubric → discover target code → read it → score every function → FIX anything below 16/20 → report
+1. Invoke the `readability-review` skill via the Skill tool
+2. The skill will: load its rubric → discover target code → read it → score every function → FIX anything below 16/20 → report
 
 ## User Arguments
 

package/commands/review-plan.md

@@ -1,7 +1,5 @@
 Review the current plan against code standards.
 
-MANDATORY: Spawn a `readability-review-agent` via Task tool to perform the review. NEVER review inline in the main conversation.
-
 1. Identify plan files in `.planning/phases/` or `docs/plans/`
-2. Spawn `readability-review-agent` with full review instructions from the `review-plan` skill
-3. Report the agent's verdict back to the user
+2. Invoke the `readability-review` skill via the Skill tool with the plan file paths
+3. Report the verdict back to the user

package/commands/stubcheck.md

@@ -49,7 +49,7 @@ Missing details in implementation guides
 **Web Automation stubs →**
 - Automation: automation-agent or automation skill
 - Google Sheets: sheets orchestrator agent
-- Config issues: config-extraction-agent or config-extraction skill
+- Config issues: clean-coder agent (extracts magic values to `config/` per CODE_RULES.md)
 
 **Web framework stubs →**
 - Models/views/forms: domain-specific agent
@@ -81,7 +81,6 @@ Incomplete matching logic
 [HIGH] tests/test_integration.py:234
 Missing integration test
 → Recommendation: Follow TDD workflow
-→ Agent: tdd-test-writer
 
 Would you like me to fix CRITICAL stubs now?
 ```

package/hooks/blocking/code_rules_enforcer.py

@@ -28,6 +28,7 @@ import json
 import re
 import sys
 import tokenize
+from collections.abc import Iterator
 from pathlib import Path
 from typing import Optional
 
@@ -50,14 +51,12 @@ ADVISORY_LINE_THRESHOLD_SOFT = 400
 ADVISORY_LINE_THRESHOLD_HARD = 1000
 
 BOOLEAN_NAME_PREFIXES: tuple[str, ...] = ("is_", "has_", "should_", "can_")
-BOOLEAN_NAMING_ISSUE_CAP = 3
 UPPER_SNAKE_CONSTANT_PATTERN = re.compile(r"^[A-Z][A-Z0-9_]*$")
 
 
 TYPE_CHECKING_BLOCK_PATTERN = re.compile(r"^(?P<indent>\s*)if\s+(typing\.)?TYPE_CHECKING\s*:\s*$")
 IMPORT_STATEMENT_PREFIXES: tuple[str, ...] = ("import ", "from ")
 NOT_INSIDE_TYPE_CHECKING_BLOCK = -1
-MAX_ISSUES_PER_CHECK = 3
 FILE_GLOBAL_UPPER_SNAKE_PATTERN = re.compile(r"^_?[A-Z][A-Z0-9_]*$")
 
 COLLECTION_TYPE_NAMES: frozenset[str] = frozenset({
@@ -355,9 +354,6 @@ def check_imports_at_top(content: str) -> list[str]:
             if stripped.startswith(IMPORT_STATEMENT_PREFIXES):
                 issues.append(f"Line {line_number}: Import inside function - move to top of file")
 
-        if len(issues) >= MAX_ISSUES_PER_CHECK:
-            break
-
     return issues
 
 
@@ -758,7 +754,7 @@ def check_constants_outside_config(content: str, file_path: str) -> list[str]:
     inside_function = False
     inside_class = False
 
-    constant_pattern = re.compile(r"^([A-Z][A-Z0-9_]{2,})\s*=\s*[^=]")
+    constant_pattern = re.compile(r"^([A-Z][A-Z0-9_]{2,})(?:\s*:\s*[^=]+)?\s*=\s*[^=]")
 
     for line_number, line in enumerate(lines, 1):
         stripped = line.strip()
@@ -787,9 +783,6 @@ def check_constants_outside_config(content: str, file_path: str) -> list[str]:
                 if constant_name not in ("__all__",):
                     issues.append(f"Line {line_number}: Constant {constant_name} - move to config/")
 
-        if len(issues) >= 3:
-            break
-
     return issues
 
 
@@ -811,12 +804,11 @@ def _scan_function_body_constants(content: str) -> list[str]:
 
     Only lines inside a function body (tracked via an indent stack) are
     flagged. Module-level assignments and class-body assignments are ignored.
-    Returns at most MAX_ISSUES_PER_CHECK entries.
     """
     advisory_issues: list[str] = []
     lines = content.split("\n")
     function_indent_stack: list[int] = []
-    constant_pattern = re.compile(r"^([A-Z][A-Z0-9_]{2,})\s*=\s*[^=]")
+    constant_pattern = re.compile(r"^([A-Z][A-Z0-9_]{2,})(?:\s*:\s*[^=]+)?\s*=\s*[^=]")
 
     for line_number, line in enumerate(lines, 1):
         stripped = line.strip()
@@ -846,9 +838,6 @@ def _scan_function_body_constants(content: str) -> list[str]:
                     f"Line {line_number}: Function-local constant {constant_name} - consider moving to config/"
                 )
 
-        if len(advisory_issues) >= MAX_ISSUES_PER_CHECK:
-            break
-
     return advisory_issues
 
 
@@ -1066,8 +1055,6 @@ def check_boolean_naming(content: str, file_path: str) -> list[str]:
         issues.append(
             f"Line {line_number}: Boolean {name} - prefix with is_/has_/should_/can_"
         )
-        if len(issues) >= BOOLEAN_NAMING_ISSUE_CAP:
-            break
     return issues
 
 
@@ -1110,8 +1097,6 @@ def check_skip_decorators_in_tests(content: str, file_path: str) -> list[str]:
                     f"Line {each_decorator.lineno}: @skip decorator on test"
                     f" — tests must fail on missing deps"
                 )
-                if len(issues) >= MAX_ISSUES_PER_CHECK:
-                    return issues
 
     return issues
 
@@ -1215,8 +1200,6 @@ def check_existence_check_tests(content: str, file_path: str) -> list[str]:
                 f"Line {each_node.lineno}: existence-check test"
                 f" — delete or replace with a behavior test"
             )
-            if len(issues) >= MAX_ISSUES_PER_CHECK:
-                return issues
 
     return issues
 
@@ -1278,8 +1261,6 @@ def check_constant_equality_tests(content: str, file_path: str) -> list[str]:
                 f"Line {each_node.lineno}: constant-value test"
                 f" — delete; tests must cover behavior"
             )
-            if len(issues) >= MAX_ISSUES_PER_CHECK:
-                return issues
 
     return issues
 
@@ -1391,8 +1372,6 @@ def check_file_global_constants_use_count(content: str, file_path: str) -> list[
             issues.append(
                 f"Line {line_number}: File-global constant {each_constant_name} used by only 1 function/method - move to method scope or add a second caller"
             )
-        if len(issues) >= MAX_ISSUES_PER_CHECK:
-            break
 
     return issues
 
@@ -1934,21 +1913,40 @@ def check_unused_optional_parameters(content: str, file_path: str) -> list[str]:
                     f"Line {function_node.lineno}: optional parameter {param_name}"
                     f" is never varied — inline default or drop"
                 )
-                if len(issues) >= MAX_ISSUES_PER_CHECK:
-                    return issues
 
     return issues
 
 
+UNION_TYPING_NAMES: frozenset[str] = frozenset({"Optional", "Union"})
+
+
 def _annotation_names_collection(annotation_node: ast.expr | None) -> bool:
     if annotation_node is None:
         return False
     if isinstance(annotation_node, ast.Name):
         return annotation_node.id in COLLECTION_TYPE_NAMES
-    if isinstance(annotation_node, ast.Subscript):
-        return _annotation_names_collection(annotation_node.value)
     if isinstance(annotation_node, ast.Attribute):
         return annotation_node.attr in COLLECTION_TYPE_NAMES
+    if isinstance(annotation_node, ast.BinOp) and isinstance(annotation_node.op, ast.BitOr):
+        return (
+            _annotation_names_collection(annotation_node.left)
+            or _annotation_names_collection(annotation_node.right)
+        )
+    if isinstance(annotation_node, ast.Subscript):
+        outer_value = annotation_node.value
+        is_optional_or_union_subscript = (
+            (isinstance(outer_value, ast.Name) and outer_value.id in UNION_TYPING_NAMES)
+            or (isinstance(outer_value, ast.Attribute) and outer_value.attr in UNION_TYPING_NAMES)
+        )
+        if is_optional_or_union_subscript:
+            slice_node = annotation_node.slice
+            if isinstance(slice_node, ast.Tuple):
+                return any(
+                    _annotation_names_collection(each_element)
+                    for each_element in slice_node.elts
+                )
+            return _annotation_names_collection(slice_node)
+        return _annotation_names_collection(outer_value)
     return False
 
 
@@ -1983,8 +1981,6 @@ def check_collection_prefix(content: str, file_path: str) -> list[str]:
         issues.append(
             f"Line {target_line}: Collection constant {target_name} - prefix with ALL_ (CODE_RULES §5)"
         )
-        if len(issues) >= MAX_ISSUES_PER_CHECK:
-            break
     for node in ast.walk(tree):
         if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
             continue
@@ -1998,8 +1994,6 @@ def check_collection_prefix(content: str, file_path: str) -> list[str]:
             issues.append(
                 f"Line {each_arg.lineno}: Collection parameter {each_arg.arg} - prefix with all_ (CODE_RULES §5)"
             )
-            if len(issues) >= MAX_ISSUES_PER_CHECK:
-                return issues
     return issues
 
 
@@ -2035,8 +2029,224 @@ def check_library_print(content: str, file_path: str) -> list[str]:
                     issues.append(
                         f"Line {node.lineno}: sys.{value_node.attr}.write - route through logger"
                     )
-        if len(issues) >= MAX_ISSUES_PER_CHECK:
-            break
+    return issues
+
+
+SELF_AND_CLS_PARAMETER_NAMES: frozenset[str] = frozenset({"self", "cls"})
+LOOP_INDEX_LETTER_EXEMPTIONS: frozenset[str] = frozenset({"i", "j", "k", "_"})
+EACH_PREFIX = "each_"
+BARE_EACH_TOKEN = "each"
+INLINE_COLLECTION_MIN_LENGTH = 3
+ALL_CAPS_WITH_UNDERSCORE_PATTERN = re.compile(r"^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$")
+DOTTED_SEGMENT_PATTERN = re.compile(r"^\.[a-z][a-z0-9_]*$")
+
+
+def _is_magic_string_literal(string_value: str) -> bool:
+    if not string_value:
+        return False
+    if ALL_CAPS_WITH_UNDERSCORE_PATTERN.match(string_value):
+        return True
+    if DOTTED_SEGMENT_PATTERN.match(string_value):
+        return True
+    return False
+
+
+def _collect_docstring_node_ids(tree: ast.Module) -> set[int]:
+    docstring_ids: set[int] = set()
+    docstring_owner_node_types = (
+        ast.Module,
+        ast.FunctionDef,
+        ast.AsyncFunctionDef,
+        ast.ClassDef,
+    )
+    for node in ast.walk(tree):
+        if not isinstance(node, docstring_owner_node_types):
+            continue
+        if not node.body:
+            continue
+        first_statement = node.body[0]
+        if not isinstance(first_statement, ast.Expr):
+            continue
+        first_value = first_statement.value
+        if isinstance(first_value, ast.Constant) and isinstance(first_value.value, str):
+            docstring_ids.add(id(first_value))
+    return docstring_ids
+
+
+def _collect_fstring_part_node_ids(tree: ast.Module) -> set[int]:
+    fstring_part_ids: set[int] = set()
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.JoinedStr):
+            continue
+        for each_value in node.values:
+            if isinstance(each_value, ast.Constant) and isinstance(each_value.value, str):
+                fstring_part_ids.add(id(each_value))
+    return fstring_part_ids
+
+
+def _walk_skipping_nested_function_defs(start_node: ast.AST) -> Iterator[ast.AST]:
+    if isinstance(start_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        return
+    nodes_to_visit: list[ast.AST] = [start_node]
+    while nodes_to_visit:
+        current_node = nodes_to_visit.pop()
+        yield current_node
+        all_child_nodes = list(ast.iter_child_nodes(current_node))
+        for each_child_node in reversed(all_child_nodes):
+            if isinstance(each_child_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            nodes_to_visit.append(each_child_node)
+
+
+def check_string_literal_magic(content: str, file_path: str) -> list[str]:
+    if is_test_file(file_path):
+        return []
+    if is_config_file(file_path):
+        return []
+    if is_workflow_registry_file(file_path) or is_migration_file(file_path):
+        return []
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    docstring_node_ids = _collect_docstring_node_ids(tree)
+    fstring_part_node_ids = _collect_fstring_part_node_ids(tree)
+    issues: list[str] = []
+    flagged_node_ids: set[int] = set()
+    for function_node in ast.walk(tree):
+        if not isinstance(function_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        for each_body_statement in function_node.body:
+            for each_descendant in _walk_skipping_nested_function_defs(each_body_statement):
+                if not isinstance(each_descendant, ast.Constant):
+                    continue
+                if not isinstance(each_descendant.value, str):
+                    continue
+                if id(each_descendant) in flagged_node_ids:
+                    continue
+                if id(each_descendant) in docstring_node_ids:
+                    continue
+                if id(each_descendant) in fstring_part_node_ids:
+                    continue
+                if not _is_magic_string_literal(each_descendant.value):
+                    continue
+                flagged_node_ids.add(id(each_descendant))
+                issues.append(
+                    f"Line {each_descendant.lineno}: string magic value {each_descendant.value!r}"
+                    f" - extract to config/"
+                )
+    return issues
+
+
+def check_inline_literal_collections(content: str, file_path: str) -> list[str]:
+    if is_test_file(file_path):
+        return []
+    if is_config_file(file_path):
+        return []
+    if is_workflow_registry_file(file_path) or is_migration_file(file_path):
+        return []
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    issues: list[str] = []
+    flagged_node_ids: set[int] = set()
+    for function_node in ast.walk(tree):
+        if not isinstance(function_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        for each_body_statement in function_node.body:
+            for each_descendant in _walk_skipping_nested_function_defs(each_body_statement):
+                if not isinstance(each_descendant, (ast.Set, ast.List)):
+                    continue
+                if id(each_descendant) in flagged_node_ids:
+                    continue
+                all_elements = each_descendant.elts
+                if len(all_elements) < INLINE_COLLECTION_MIN_LENGTH:
+                    continue
+                if not all(isinstance(each_element, ast.Constant) for each_element in all_elements):
+                    continue
+                flagged_node_ids.add(id(each_descendant))
+                collection_kind = "set" if isinstance(each_descendant, ast.Set) else "list"
+                issues.append(
+                    f"Line {each_descendant.lineno}: inline {collection_kind} literal of {len(all_elements)}"
+                    f" constants in function body - extract to config/"
+                )
+    return issues
+
+
+def check_loop_variable_naming(content: str, file_path: str) -> list[str]:
+    if is_test_file(file_path):
+        return []
+    if is_workflow_registry_file(file_path) or is_migration_file(file_path):
+        return []
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    issues: list[str] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.For, ast.AsyncFor)):
+            continue
+        target = node.target
+        if not isinstance(target, ast.Name):
+            continue
+        target_name = target.id
+        if target_name in LOOP_INDEX_LETTER_EXEMPTIONS:
+            continue
+        if target_name == BARE_EACH_TOKEN:
+            issues.append(
+                f"Line {target.lineno}: loop variable 'each' is a bare token without subject"
+                f" - rename to each_<subject> (CODE_RULES §5)"
+            )
+            continue
+        if target_name.startswith(EACH_PREFIX) and len(target_name) > len(EACH_PREFIX):
+            continue
+        issues.append(
+            f"Line {target.lineno}: loop variable {target_name!r} - prefix with each_ (CODE_RULES §5)"
+        )
+    return issues
+
+
+def check_parameter_annotations(content: str, file_path: str) -> list[str]:
+    if is_test_file(file_path):
+        return []
+    if is_workflow_registry_file(file_path) or is_migration_file(file_path):
+        return []
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    issues: list[str] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        for each_arg in _collect_annotated_arguments(node):
+            if each_arg.arg in SELF_AND_CLS_PARAMETER_NAMES:
+                continue
+            if each_arg.annotation is None:
+                issues.append(
+                    f"Line {each_arg.lineno}: parameter {each_arg.arg!r} on {node.name!r} missing type annotation (CODE_RULES §6)"
+                )
+    return issues
+
+
+def check_return_annotations(content: str, file_path: str) -> list[str]:
+    if is_test_file(file_path):
+        return []
+    if is_workflow_registry_file(file_path) or is_migration_file(file_path):
+        return []
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    issues: list[str] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        if node.returns is None:
+            issues.append(
+                f"Line {node.lineno}: function {node.name!r} missing return type annotation (CODE_RULES §6)"
+            )
     return issues
 
 
@@ -2061,8 +2271,7 @@ def validate_content(content: str, file_path: str, old_content: str = "") -> lis
         all_issues.extend(check_magic_values(content, file_path))
         all_issues.extend(check_fstring_structural_literals(content, file_path))
         all_issues.extend(check_constants_outside_config(content, file_path))
-        for each_advisory in check_constants_outside_config_advisory(content, file_path):
-            print(f"[CODE_RULES advisory] {file_path}: {each_advisory}", file=sys.stderr)
+        all_issues.extend(check_constants_outside_config_advisory(content, file_path))
         all_issues.extend(check_file_global_constants_use_count(content, file_path))
         all_issues.extend(check_type_escape_hatches(content, file_path))
         all_issues.extend(check_banned_identifiers(content, file_path))
@@ -2073,6 +2282,11 @@ def validate_content(content: str, file_path: str, old_content: str = "") -> lis
         all_issues.extend(check_unused_optional_parameters(content, file_path))
         all_issues.extend(check_collection_prefix(content, file_path))
         all_issues.extend(check_library_print(content, file_path))
+        all_issues.extend(check_parameter_annotations(content, file_path))
+        all_issues.extend(check_return_annotations(content, file_path))
+        all_issues.extend(check_loop_variable_naming(content, file_path))
+        all_issues.extend(check_inline_literal_collections(content, file_path))
+        all_issues.extend(check_string_literal_magic(content, file_path))
         check_incomplete_mocks(content, file_path)
         check_duplicated_format_patterns(content, file_path)
 

package/hooks/blocking/test_code_rules_enforcer.py

@@ -188,34 +188,6 @@ def test_should_flag_when_every_call_passes_the_exact_default() -> None:
     )
 
 
-def test_check_unused_optional_parameters_stops_at_max_issues_per_check() -> None:
-    source = (
-        "def make_url_one(path: str, prefix: str = '/api') -> str:\n"
-        "    return f'{prefix}{path}'\n"
-        "def make_url_two(path: str, prefix: str = '/api') -> str:\n"
-        "    return f'{prefix}{path}'\n"
-        "def make_url_three(path: str, prefix: str = '/api') -> str:\n"
-        "    return f'{prefix}{path}'\n"
-        "def make_url_four(path: str, prefix: str = '/api') -> str:\n"
-        "    return f'{prefix}{path}'\n"
-        "def make_url_five(path: str, prefix: str = '/api') -> str:\n"
-        "    return f'{prefix}{path}'\n"
-        "\n"
-        "def call_all() -> None:\n"
-        "    make_url_one('/a')\n"
-        "    make_url_two('/b')\n"
-        "    make_url_three('/c')\n"
-        "    make_url_four('/d')\n"
-        "    make_url_five('/e')\n"
-    )
-    issues = code_rules_enforcer.check_unused_optional_parameters(
-        source, UNUSED_OPTIONAL_PRODUCTION_FILE_PATH
-    )
-    assert len(issues) == code_rules_enforcer.MAX_ISSUES_PER_CHECK, (
-        f"Expected exactly MAX_ISSUES_PER_CHECK issues, got {len(issues)}: {issues}"
-    )
-
-
 INCOMPLETE_MOCK_TEST_FILE_PATH = "packages/app/tests/test_orders.py"
 INCOMPLETE_MOCK_PRODUCTION_FILE_PATH = "packages/app/services/orders.py"
 
@@ -675,22 +647,20 @@ def test_advisory_should_still_flag_actual_method_body_constant() -> None:
     assert "MAXIMUM_RETRIES" in advisory_issues[0]
 
 
-def test_advisory_cap_matches_max_issues_per_check_constant() -> None:
-    many_constants_source = (
-        "def crowded_function():\n"
-        "    ALPHA_CONSTANT = 1\n"
-        "    BETA_CONSTANT = 2\n"
-        "    GAMMA_CONSTANT = 3\n"
-        "    DELTA_CONSTANT = 4\n"
-        "    EPSILON_CONSTANT = 5\n"
+def test_advisory_should_flag_annotated_function_body_constant() -> None:
+    source_with_annotated_function_body_constant = (
+        "def example_function() -> None:\n"
+        "    MAXIMUM_RETRIES: int = 3\n"
+        "    return None\n"
     )
     advisory_issues = code_rules_enforcer.check_constants_outside_config_advisory(
-        many_constants_source,
+        source_with_annotated_function_body_constant,
         "example_module.py",
     )
-    assert len(advisory_issues) == code_rules_enforcer.MAX_ISSUES_PER_CHECK, (
-        "Advisory cap must equal MAX_ISSUES_PER_CHECK, not a hardcoded literal"
+    assert len(advisory_issues) == 1, (
+        "Annotated function-body UPPER_SNAKE constant (PEP 526) must surface as advisory"
     )
+    assert "MAXIMUM_RETRIES" in advisory_issues[0]
 
 
 def test_advisory_should_flag_outer_constants_after_nested_def() -> None:
@@ -958,3 +928,85 @@ def test_should_still_advise_when_duplicated_fstring_literal_is_long(capsys: obj
         "Expected the existing /api/<x> path-shape advisory to still fire, "
         f"got: {captured.err!r}"
     )
+
+
+LOOP_NAMING_PRODUCTION_FILE_PATH = "packages/app/services/loop_naming.py"
+
+
+def test_check_loop_variable_naming_flags_missing_each_prefix() -> None:
+    source = (
+        "def consume() -> None:\n"
+        "    for marker in []:\n"
+        "        return None\n"
+    )
+    issues = code_rules_enforcer.check_loop_variable_naming(
+        source, LOOP_NAMING_PRODUCTION_FILE_PATH
+    )
+    assert any("marker" in each_issue for each_issue in issues), (
+        f"Expected 'marker' loop variable flagged, got: {issues}"
+    )
+
+
+INLINE_LITERAL_PRODUCTION_FILE_PATH = "packages/app/services/inline_literal.py"
+
+
+def test_check_inline_literal_collections_flags_three_string_set_in_function() -> None:
+    source = (
+        "def is_known(value: str) -> bool:\n"
+        "    return value in {'true', 'false', 'none'}\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, INLINE_LITERAL_PRODUCTION_FILE_PATH
+    )
+    assert len(issues) == 1, f"Expected 3-element string set flagged, got: {issues}"
+
+
+STRING_MAGIC_PRODUCTION_FILE_PATH = "packages/app/services/string_magic.py"
+
+
+def test_check_string_literal_magic_flags_env_var_name() -> None:
+    source = (
+        "import os\n"
+        "\n"
+        "def fetch_secret() -> str:\n"
+        "    return os.environ['STRIPE_SECRET']\n"
+    )
+    issues = code_rules_enforcer.check_string_literal_magic(
+        source, STRING_MAGIC_PRODUCTION_FILE_PATH
+    )
+    assert any("STRIPE_SECRET" in each_issue for each_issue in issues), (
+        f"Expected env-var name flagged, got: {issues}"
+    )
+
+
+CONSTANTS_OUTSIDE_CONFIG_PRODUCTION_FILE_PATH = "packages/app/services/encoding.py"
+
+
+def test_check_constants_outside_config_flags_annotated_assignment() -> None:
+    source = "TEXT_FILE_ENCODING: str = 'utf-8'\n"
+    issues = code_rules_enforcer.check_constants_outside_config(
+        source, CONSTANTS_OUTSIDE_CONFIG_PRODUCTION_FILE_PATH
+    )
+    assert any("TEXT_FILE_ENCODING" in each_issue for each_issue in issues), (
+        f"Expected annotated UPPER_SNAKE assignment flagged, got: {issues}"
+    )
+
+
+def test_check_constants_outside_config_reports_more_than_three_constants() -> None:
+    source = (
+        "ALPHA_VALUE = 1\n"
+        "BETA_VALUE = 2\n"
+        "GAMMA_VALUE = 3\n"
+        "DELTA_VALUE = 4\n"
+        "EPSILON_VALUE = 5\n"
+        "\n"
+        "def consumer() -> int:\n"
+        "    return ALPHA_VALUE + BETA_VALUE\n"
+    )
+    issues = code_rules_enforcer.check_constants_outside_config(
+        source, CONSTANTS_OUTSIDE_CONFIG_PRODUCTION_FILE_PATH
+    )
+    expected_constant_count = 5
+    assert len(issues) == expected_constant_count, (
+        f"Expected all {expected_constant_count} constants reported, got {len(issues)}: {issues}"
+    )