claude-dev-env 2.29.0 → 2.30.0

package/hooks/blocking/test_code_rules_enforcer_banned_noun_word.py

@@ -28,7 +28,7 @@ assert hook_spec.loader is not None
 hook_module = importlib.util.module_from_spec(hook_spec)
 hook_spec.loader.exec_module(hook_module)
 check_banned_noun_word_boundary = hook_module.check_banned_noun_word_boundary
-validate_content = hook_module.validate_content
+validate_content = hook_module.validate_content_for_full_gate
 
 from code_rules_banned_identifiers import (  # noqa: E402
     _find_banned_noun_word,

package/hooks/blocking/test_code_rules_enforcer_class_docstring_methods.py

@@ -31,7 +31,7 @@ def check_class_docstring_names_public_methods(content: str, file_path: str) ->
 
 
 def validate_content(content: str, file_path: str, old_content: str) -> list[str]:
-    return code_rules_enforcer.validate_content(content, file_path, old_content)
+    return code_rules_enforcer.validate_content_for_full_gate(content, file_path, old_content)
 
 
 PRODUCTION_FILE_PATH = "/project/src/break_reporter.py"

package/hooks/blocking/test_code_rules_enforcer_dispatch_wiring.py

@@ -1,25 +1,49 @@
-"""Meta-test asserting every check_* function is dispatched from validate_content.
+"""Meta-test asserting every check_* function is reachable from the full gate.
 
 The per-check test modules each prove one ``check_*`` function flags the right
 violation, but none proves the enforcer actually calls that function. A refactor
-that drops a dispatch line from ``validate_content`` leaves every per-check test
-green while the check stops firing at Write/Edit time — the precise failure mode
+that drops a dispatch line from ``validate_content_for_full_gate`` or from one
+of its extension-issue helper functions leaves every per-check test green
+while the check stops firing at Write/Edit time — the precise failure mode
 that would let a dead module-level constant (the ``MEDIUM_TEXT`` class) or an
 orphan CSS class slip past the gate again.
 
-This module reads ``validate_content``'s source and asserts every ``check_*``
-attribute on the enforcer module appears in it. A check that is intentionally
-not wired must be listed in ``KNOWN_UNDISPATCHED_CHECKS`` with a reason in this
-docstring. ``check_unanchored_command_dispatch`` is listed there: it guards a
-``hooks/blocking`` command classifier, and the whole ``validate_content`` verdict
-stays off hook-infrastructure files, so the enforcer dispatches it from
+::
+
+    validate_content_for_full_gate -> _python_extension_issues -> _python_magic_value_and_constant_issues
+                                                                        |
+                                                                        v
+                                                            references check_magic_values
+    -> check_magic_values counts as reachable
+
+    check_unanchored_command_dispatch: called only from
+    _hook_infrastructure_blocking_issues, which the full gate's call graph
+    never reaches -> stays in KNOWN_UNDISPATCHED_CHECKS
+
+This module walks the enforcer's real call graph from
+``validate_content_for_full_gate``, following every direct function call into
+the functions the enforcer module defines, and collects every
+``check_*``/``advise_*`` name each reached function body references — a direct
+call or a bare reference passed on as a callback (the
+``_fragment_or_deferred_check(check_magic_values, ...)`` shape). A name that
+surfaces only in an import statement or a docstring is not a reference inside
+a reached function body, so it does not count; this is what keeps the check
+from going vacuous the way a whole-module substring scan would.
+
+A check that is intentionally not wired must be listed in
+``KNOWN_UNDISPATCHED_CHECKS`` with a reason in this docstring.
+``check_unanchored_command_dispatch`` is listed there: it guards a
+``hooks/blocking`` command classifier, and the whole
+``validate_content_for_full_gate`` verdict stays off hook-infrastructure
+files, so the enforcer dispatches it from
 ``_hook_infrastructure_blocking_issues`` instead. The companion
-``test_code_rules_enforcer_cap_meta.py`` guards the payload-cap convention; this
-module guards the wiring.
+``test_code_rules_enforcer_cap_meta.py`` guards the payload-cap convention;
+this module guards the wiring.
 """
 
 from __future__ import annotations
 
+import ast
 import importlib.util
 import inspect
 import pathlib
@@ -42,6 +66,8 @@ KNOWN_UNDISPATCHED_CHECKS: frozenset[str] = frozenset(
     {"check_unanchored_command_dispatch"}
 )
 
+DISPATCH_ENTRY_POINT_NAME = "validate_content_for_full_gate"
+
 
 def _all_check_function_names() -> list[str]:
     return [
@@ -52,22 +78,91 @@ def _all_check_function_names() -> list[str]:
     ]
 
 
-def _validate_content_source() -> str:
-    return inspect.getsource(_hook_module.validate_content)
+def _module_level_function_defs(module_tree: ast.Module) -> dict[str, ast.FunctionDef]:
+    """Map each module-level function's name to its definition node."""
+    return {
+        each_node.name: each_node
+        for each_node in module_tree.body
+        if isinstance(each_node, ast.FunctionDef)
+    }
 
 
-def test_every_check_function_is_called_in_validate_content() -> None:
-    all_check_names = set(_all_check_function_names())
-    validate_content_source = _validate_content_source()
-    undispatched_check_names = {
-        each_name for each_name in all_check_names if each_name not in validate_content_source
+def _local_call_targets(function_node: ast.FunctionDef) -> set[str]:
+    """Return the plain-name targets one function directly calls."""
+    return {
+        each_call.func.id
+        for each_call in ast.walk(function_node)
+        if isinstance(each_call, ast.Call) and isinstance(each_call.func, ast.Name)
+    }
+
+
+def _unvisited_local_calls(
+    function_name: str,
+    function_defs_by_name: dict[str, ast.FunctionDef],
+    visited: set[str],
+) -> list[str]:
+    """Return *function_name*'s call targets not already visited by the walk."""
+    function_node = function_defs_by_name.get(function_name)
+    if function_node is None:
+        return []
+    return [each for each in _local_call_targets(function_node) if each not in visited]
+
+
+def _reachable_function_names(
+    start_name: str, function_defs_by_name: dict[str, ast.FunctionDef]
+) -> set[str]:
+    """Return every function name the call graph reaches, starting from start_name."""
+    visited: set[str] = set()
+    pending = [start_name]
+    while pending:
+        each_pending_name = pending.pop()
+        if each_pending_name in visited:
+            continue
+        visited.add(each_pending_name)
+        pending.extend(_unvisited_local_calls(each_pending_name, function_defs_by_name, visited))
+    return visited
+
+
+def _referenced_names(function_node: ast.FunctionDef) -> set[str]:
+    """Return every loaded identifier one function body references.
+
+    A callback-style dispatch (``_fragment_or_deferred_check(check_magic_values,
+    ...)``) passes the check function by bare name rather than calling it
+    directly, so this collects every loaded ``Name``, not only call targets.
+    """
+    return {
+        each_name.id
+        for each_name in ast.walk(function_node)
+        if isinstance(each_name, ast.Name) and isinstance(each_name.ctx, ast.Load)
     }
+
+
+def _reachable_referenced_names(
+    start_name: str, function_defs_by_name: dict[str, ast.FunctionDef]
+) -> set[str]:
+    """Return every identifier referenced by a function the call graph reaches."""
+    reachable_function_names = _reachable_function_names(start_name, function_defs_by_name)
+    referenced_names: set[str] = set()
+    for each_function_name in reachable_function_names:
+        function_node = function_defs_by_name.get(each_function_name)
+        if function_node is not None:
+            referenced_names.update(_referenced_names(function_node))
+    return referenced_names
+
+
+def test_every_check_function_is_reachable_from_the_full_gate() -> None:
+    module_tree = ast.parse(inspect.getsource(_hook_module))
+    function_defs_by_name = _module_level_function_defs(module_tree)
+    reachable_names = _reachable_referenced_names(DISPATCH_ENTRY_POINT_NAME, function_defs_by_name)
+    all_check_names = set(_all_check_function_names())
+    undispatched_check_names = all_check_names - reachable_names
     unexpected_undispatched = undispatched_check_names - KNOWN_UNDISPATCHED_CHECKS
     assert unexpected_undispatched == set(), (
-        f"check_* functions are imported but never called in validate_content: "
-        f"{sorted(unexpected_undispatched)}. Wire each into validate_content so the "
-        f"check fires at Write/Edit time, or list it in KNOWN_UNDISPATCHED_CHECKS "
-        f"with a reason in the test header docstring."
+        f"check_* functions are imported but never reachable from "
+        f"validate_content_for_full_gate's call graph: {sorted(unexpected_undispatched)}. "
+        f"Wire each into validate_content_for_phase or one of its extension-issue "
+        f"helpers so the check fires at Write/Edit time, or list it in "
+        f"KNOWN_UNDISPATCHED_CHECKS with a reason in the test header docstring."
     )
 
 

package/hooks/blocking/test_code_rules_enforcer_docstring_args_signature.py

@@ -30,7 +30,7 @@ def check_docstring_args_match_signature(content: str, file_path: str) -> list[s
 
 
 def validate_content(content: str, file_path: str, old_content: str) -> list[str]:
-    return code_rules_enforcer.validate_content(content, file_path, old_content)
+    return code_rules_enforcer.validate_content_for_full_gate(content, file_path, old_content)
 
 
 PRODUCTION_FILE_PATH = "/project/src/services.py"

package/hooks/blocking/test_code_rules_enforcer_docstring_prose_wall_illustration.py

@@ -39,7 +39,7 @@ def check_docstring_prose_wall_without_illustration(content: str, file_path: str
 
 
 def validate_content(content: str, file_path: str, old_content: str) -> list[str]:
-    return code_rules_enforcer.validate_content(content, file_path, old_content)
+    return code_rules_enforcer.validate_content_for_full_gate(content, file_path, old_content)
 
 
 PRODUCTION_FILE_PATH = "/project/src/tally.py"

package/hooks/blocking/test_code_rules_enforcer_docstring_runon_sentence.py

@@ -42,7 +42,7 @@ def check_docstring_runon_sentence(content: str, file_path: str) -> list[str]:
 
 
 def validate_content(content: str, file_path: str, old_content: str) -> list[str]:
-    return code_rules_enforcer.validate_content(content, file_path, old_content)
+    return code_rules_enforcer.validate_content_for_full_gate(content, file_path, old_content)
 
 
 PRODUCTION_FILE_PATH = "/project/src/run_lifecycle.py"

package/hooks/blocking/test_code_rules_enforcer_docstring_unreferenced_param.py

@@ -32,7 +32,7 @@ def check_documents_unreferenced_parameter(content: str, file_path: str) -> list
 
 
 def validate_content(content: str, file_path: str, old_content: str) -> list[str]:
-    return code_rules_enforcer.validate_content(content, file_path, old_content)
+    return code_rules_enforcer.validate_content_for_full_gate(content, file_path, old_content)
 
 
 PRODUCTION_FILE_PATH = "/project/src/per_theme_loop.py"

package/hooks/blocking/test_code_rules_enforcer_fstring_scan.py

@@ -17,7 +17,7 @@ assert hook_spec.loader is not None
 hook_module = importlib.util.module_from_spec(hook_spec)
 hook_spec.loader.exec_module(hook_module)
 check_fstring_structural_literals = hook_module.check_fstring_structural_literals
-validate_content = hook_module.validate_content
+validate_content = hook_module.validate_content_for_full_gate
 
 PRODUCTION_FILE_PATH = "packages/claude-dev-env/example.py"
 TEST_FILE_PATH = "packages/claude-dev-env/test_example.py"

package/hooks/blocking/test_code_rules_enforcer_ignored_must_check_return.py

@@ -25,7 +25,7 @@ from code_rules_boolean_mustcheck import (  # noqa: E402
     check_ignored_must_check_return as _check_ignored_must_check_return,
 )
 from code_rules_enforcer import (  # noqa: E402
-    validate_content as _validate_content,
+    validate_content_for_full_gate as _validate_content,
 )
 
 code_rules_enforcer = SimpleNamespace(

package/hooks/blocking/test_code_rules_enforcer_inline_tuple_string_magic.py

@@ -23,7 +23,7 @@ assert hook_spec.loader is not None
 hook_module = importlib.util.module_from_spec(hook_spec)
 hook_spec.loader.exec_module(hook_module)
 check_inline_tuple_string_magic = hook_module.check_inline_tuple_string_magic
-validate_content = hook_module.validate_content
+validate_content = hook_module.validate_content_for_full_gate
 
 PRODUCTION_FILE_PATH = "packages/app/services/loader.py"
 TEST_FILE_PATH = "packages/app/services/test_loader.py"

package/hooks/blocking/test_code_rules_enforcer_join_separator_magic.py

@@ -77,7 +77,7 @@ def test_should_grandfather_unchanged_join_separator_in_wide_edit() -> None:
         "    # keep the join separator the same\n"
         "    return ', '.join(str(each_path) for each_path in all_paths)\n"
     )
-    issues = code_rules_enforcer.validate_content(
+    issues = code_rules_enforcer.validate_content_for_full_gate(
         proposed_fragment,
         PRODUCTION_FILE_PATH,
         prior_fragment,
@@ -97,7 +97,7 @@ def test_should_block_new_join_separator_in_wide_edit() -> None:
         "def render(all_paths: list) -> str:\n"
         "    return ', '.join(all_paths)\n"
     )
-    issues = code_rules_enforcer.validate_content(
+    issues = code_rules_enforcer.validate_content_for_full_gate(
         proposed_fragment,
         PRODUCTION_FILE_PATH,
         prior_fragment,

package/hooks/blocking/test_code_rules_enforcer_js_returns_object.py

@@ -1,6 +1,6 @@
 """Enforcer-dispatch tests for the JS returns-object schema-less branch check.
 
-These drive ``validate_content`` end-to-end on a ``.mjs`` payload, so they prove
+These drive ``validate_content_for_full_gate`` end-to-end on a ``.mjs`` payload, so they prove
 the check is wired into the JavaScript branch of the enforcer, not just callable
 in isolation. The drift: a ``function`` whose JSDoc ``@returns {Promise<object>}``
 promises a structured object while one branch returns the agent helper with an
@@ -62,11 +62,11 @@ def _has_returns_object_finding(all_issues: list[str]) -> bool:
 
 def test_enforcer_reports_schema_less_branch_under_returns_object() -> None:
     drift_source = _mixed_schema_mjs()
-    all_issues = code_rules_enforcer.validate_content(drift_source, _MJS_PATH, drift_source)
+    all_issues = code_rules_enforcer.validate_content_for_full_gate(drift_source, _MJS_PATH, drift_source)
     assert _has_returns_object_finding(all_issues)
 
 
 def test_enforcer_accepts_every_branch_with_a_schema() -> None:
     clean_source = _all_schema_mjs()
-    all_issues = code_rules_enforcer.validate_content(clean_source, _MJS_PATH, clean_source)
+    all_issues = code_rules_enforcer.validate_content_for_full_gate(clean_source, _MJS_PATH, clean_source)
     assert not _has_returns_object_finding(all_issues)

package/hooks/blocking/test_code_rules_enforcer_module_docstring_roster.py

@@ -31,7 +31,7 @@ def check_module_docstring_names_public_checks(content: str, file_path: str) ->
 
 
 def validate_content(content: str, file_path: str, old_content: str) -> list[str]:
-    return code_rules_enforcer.validate_content(content, file_path, old_content)
+    return code_rules_enforcer.validate_content_for_full_gate(content, file_path, old_content)
 
 
 HOOK_INFRASTRUCTURE_PATH = "/home/user/.claude/hooks/blocking/code_rules_test_assertions.py"

package/hooks/blocking/test_code_rules_enforcer_naming_pattern.py

@@ -18,7 +18,7 @@ assert _hook_spec.loader is not None
 _hook_module = importlib.util.module_from_spec(_hook_spec)
 _hook_spec.loader.exec_module(_hook_module)
 check_boolean_naming = _hook_module.check_boolean_naming
-validate_content = _hook_module.validate_content
+validate_content = _hook_module.validate_content_for_full_gate
 
 
 PRODUCTION_FILE_PATH = "src/app/feature.py"

package/hooks/blocking/test_code_rules_enforcer_narrow_edit.py

@@ -20,7 +20,7 @@ if _HOOKS_DIRECTORY not in sys.path:
 
 from code_rules_enforcer import (  # noqa: E402
     main,
-    validate_content,
+    validate_content_for_full_gate as validate_content,
 )
 
 
@@ -165,47 +165,126 @@ def _validate_narrow_edit(narrow_edit_fixture: NarrowEditFixture) -> list[str]:
     )
 
 
-def _scope_aware_rule_names_from_source() -> frozenset[str]:
-    source_tree = ast.parse(inspect.getsource(validate_content))
-    all_rule_names: set[str] = set()
-    for each_call in ast.walk(source_tree):
-        if not isinstance(each_call, ast.Call):
+_SCOPE_CARRYING_ATTRIBUTE_NAMES = frozenset({"all_changed_lines", "defer_scope_to_caller"})
+
+
+def _assignment_target_names(target: ast.expr) -> list[str]:
+    """Return the plain names one assignment target binds, Name or Tuple-of-Name."""
+    if isinstance(target, ast.Name):
+        return [target.id]
+    if isinstance(target, ast.Tuple):
+        return [each.id for each in target.elts if isinstance(each, ast.Name)]
+    return []
+
+
+def _scope_aliases_for_pair(target_names: list[str], all_values: list[ast.expr]) -> dict[str, str]:
+    """Return the local-name-to-scope-attribute map one assignment pair contributes."""
+    aliases: dict[str, str] = {}
+    for each_name, each_value in zip(target_names, all_values):
+        if not isinstance(each_value, ast.Attribute):
             continue
-        if not isinstance(each_call.func, ast.Name):
+        if each_value.attr not in _SCOPE_CARRYING_ATTRIBUTE_NAMES:
             continue
-        if each_call.func.id == "_fragment_or_deferred_check":
-            all_argument_names = {
-                each_name.id
-                for each_argument in each_call.args[1:]
-                for each_name in ast.walk(each_argument)
-                if isinstance(each_name, ast.Name)
-            }
-            if (
-                "defer_scope_to_caller" in all_argument_names
-                and each_call.args
-                and isinstance(each_call.args[0], ast.Name)
-            ):
-                all_rule_names.add(each_call.args[0].id)
+        aliases[each_name] = each_value.attr
+    return aliases
+
+
+def _context_alias_map(function_node: ast.AST) -> dict[str, str]:
+    """Map each local name one function binds from ``context.<scope attribute>``.
+
+    A dispatch helper unpacks ``context.all_changed_lines`` and
+    ``context.defer_scope_to_caller`` into a short local name (``changed``,
+    ``defer``) before passing it on, so a call carrying that local name still
+    carries scope, even though the local name spells out none of it.
+    """
+    aliases: dict[str, str] = {}
+    for each_node in ast.walk(function_node):
+        if not isinstance(each_node, ast.Assign) or len(each_node.targets) != 1:
             continue
-        if not each_call.func.id.startswith("check_"):
+        target_names = _assignment_target_names(each_node.targets[0])
+        if not target_names:
             continue
-        all_argument_names = {
-            each_name.id
-            for each_argument in each_call.args
-            for each_name in ast.walk(each_argument)
-            if isinstance(each_name, ast.Name)
-        }
-        all_argument_names.update(
-            each_name.id
-            for each_keyword in each_call.keywords
-            for each_name in ast.walk(each_keyword.value)
-            if isinstance(each_name, ast.Name)
-        )
-        if (
-            "all_changed_lines" in all_argument_names
-            or "defer_scope_to_caller" in all_argument_names
-        ):
-            all_rule_names.add(each_call.func.id)
+        value = each_node.value
+        all_values = value.elts if isinstance(value, ast.Tuple) else [value]
+        aliases.update(_scope_aliases_for_pair(target_names, all_values))
+    return aliases
+
+
+def _scope_names_for_reference(reference: ast.AST, aliases: dict[str, str]) -> set[str]:
+    """Return the scope-carrying attribute name one AST reference resolves to, if any."""
+    if isinstance(reference, ast.Name) and reference.id in aliases:
+        return {aliases[reference.id]}
+    if isinstance(reference, ast.Attribute) and reference.attr in _SCOPE_CARRYING_ATTRIBUTE_NAMES:
+        return {reference.attr}
+    return set()
+
+
+def _referenced_scope_attribute_names(node: ast.AST, aliases: dict[str, str]) -> set[str]:
+    """Return every scope-carrying attribute name *node* references, direct or aliased."""
+    found: set[str] = set()
+    for each_reference in ast.walk(node):
+        found.update(_scope_names_for_reference(each_reference, aliases))
+    return found
+
+
+def _fragment_deferred_rule_name(call_node: ast.Call, aliases: dict[str, str]) -> str | None:
+    """Return the rule name one ``_fragment_or_deferred_check`` call selects, if scoped."""
+    argument_scope_names = {
+        each_scope_name
+        for each_argument in call_node.args[1:]
+        for each_scope_name in _referenced_scope_attribute_names(each_argument, aliases)
+    }
+    if "defer_scope_to_caller" not in argument_scope_names:
+        return None
+    if not call_node.args or not isinstance(call_node.args[0], ast.Name):
+        return None
+    return call_node.args[0].id
+
+
+def _check_call_rule_name(call_node: ast.Call, aliases: dict[str, str]) -> str | None:
+    """Return the rule name one direct ``check_*`` call selects, if it carries scope."""
+    func_name = call_node.func.id  # type: ignore[attr-defined]  # caller already narrowed func to ast.Name
+    if not func_name.startswith("check_"):
+        return None
+    all_call_arguments = (*call_node.args, *(each_keyword.value for each_keyword in call_node.keywords))
+    argument_scope_names = {
+        each_scope_name
+        for each_argument in all_call_arguments
+        for each_scope_name in _referenced_scope_attribute_names(each_argument, aliases)
+    }
+    return func_name if argument_scope_names else None
+
+
+def _rule_names_from_function(function_node: ast.FunctionDef) -> set[str]:
+    """Return the check_* names *function_node* calls with scope-carrying arguments."""
+    aliases = _context_alias_map(function_node)
+    rule_names: set[str] = set()
+    for each_call in ast.walk(function_node):
+        if not isinstance(each_call, ast.Call) or not isinstance(each_call.func, ast.Name):
+            continue
+        if each_call.func.id == "_fragment_or_deferred_check":
+            rule_name = _fragment_deferred_rule_name(each_call, aliases)
+        else:
+            rule_name = _check_call_rule_name(each_call, aliases)
+        if rule_name is not None:
+            rule_names.add(rule_name)
+    return rule_names
+
+
+def _scope_aware_rule_names_from_source() -> frozenset[str]:
+    """Return every check_* name dispatched anywhere in the enforcer with scope.
+
+    Walks every function in the enforcer module rather than only
+    ``validate_content``, since the extension-issue helper functions hold the
+    actual dispatch calls today.
+    """
+    enforcer_module = inspect.getmodule(validate_content)
+    assert enforcer_module is not None
+    module_tree = ast.parse(inspect.getsource(enforcer_module))
+    all_rule_names: set[str] = set()
+    for each_function in ast.walk(module_tree):
+        if isinstance(each_function, ast.FunctionDef):
+            all_rule_names.update(_rule_names_from_function(each_function))
     return frozenset(all_rule_names)
 
 

package/hooks/blocking/test_code_rules_enforcer_output_snapshot.py

@@ -0,0 +1,121 @@
+"""Golden-output snapshot for the phase-split validators, guarding both phases.
+
+Records the full-gate phase's ordered issue list for three representative
+fixtures — a Python cross-file duplicate-body hit, a JavaScript boolean-naming
+hit, and a Python-built-HTML orphan-CSS-class hit — so a decomposition that
+reorders or drops a dispatch line shows up as a changed list, not a
+still-green suite. Each fixture also records the edit-lane phase's list, which
+matches the full-gate list except for the cross-file finding the edit lane
+skips.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_module_from_path(module_name: str, module_path: Path) -> ModuleType:
+    """Load and execute the module found at module_path, under module_name."""
+    specification = importlib.util.spec_from_file_location(module_name, module_path)
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    specification.loader.exec_module(module)
+    return module
+
+
+_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
+code_rules_enforcer = _load_module_from_path(
+    "code_rules_enforcer", _BLOCKING_DIRECTORY / "code_rules_enforcer.py"
+)
+
+_DUPLICATE_FUNCTION_SOURCE = (
+    "def compute_shipping_total(order_total: float, tax_rate: float) -> float:\n"
+    "    taxed_total = order_total * (1 + tax_rate)\n"
+    "    rounded_total = round(taxed_total, 2)\n"
+    "    return rounded_total\n"
+)
+_JS_BOOLEAN_SOURCE = "const active = true;\n"
+_CSS_ORPHAN_CLASS_SOURCE = (
+    '"""Render a status badge."""\n\n'
+    "STATUS_MARKUP = '<div class=\"status-badge\">Active</div>'\n"
+    "STYLE_BLOCK = '<style>.status-pill { color: green; }</style>'\n"
+)
+
+EXPECTED_PYTHON_CROSS_FILE_ISSUES = [
+    "Line 3: Magic value 2 - extract to named constant",
+    "Function 'compute_shipping_total' duplicates shipping_helper.py::compute_shipping_total"
+    " — this function body is identical to one in a sibling module; extract a single shared"
+    " helper (for example in hooks_constants/) and import it from both modules instead of"
+    " copying it (Reuse before create / DRY) (duplicate body span at line 1, spanning 4 lines)",
+]
+EXPECTED_PYTHON_CROSS_FILE_EDIT_LANE_ISSUES = [
+    "Line 3: Magic value 2 - extract to named constant",
+]
+EXPECTED_JS_ISSUES = [
+    "Line 1: Boolean active - prefix with is/has/should/can/was/did",
+]
+EXPECTED_CSS_ISSUES = [
+    "Line 3: Constant STATUS_MARKUP - move to config/",
+    "Line 4: Constant STYLE_BLOCK - move to config/",
+    "Line 3: CSS class 'status-badge' used in markup has no matching '.status-badge' selector"
+    " - add a matching '.<class>' selector to the <style> block, or drop the unused class"
+    " attribute (CODE_RULES self-documenting markup)",
+]
+EXPECTED_CSS_EDIT_LANE_ISSUES = [
+    "Line 3: Constant STATUS_MARKUP - move to config/",
+    "Line 4: Constant STYLE_BLOCK - move to config/",
+]
+
+
+def test_python_cross_file_duplicate_snapshot_is_unchanged(tmp_path: Path) -> None:
+    """Both phases' ordered output for a cross-file duplicate stays fixed.
+
+    ``file_path`` is a fixed classification-only path, never opened, so the
+    real ``tmp_path`` sibling scan (which embeds this test's own name, a
+    ``test_`` match) never misclassifies the fixture as a test file.
+    """
+    sibling_dir = tmp_path / "sibling_dir"
+    sibling_dir.mkdir()
+    (sibling_dir / "shipping_helper.py").write_text(_DUPLICATE_FUNCTION_SOURCE, encoding="utf-8")
+    classification_only_file_path = "/repo/packages/demo/shipping/shipping_target.py"
+
+    full_gate_issues = code_rules_enforcer.validate_content_for_full_gate(
+        _DUPLICATE_FUNCTION_SOURCE,
+        classification_only_file_path,
+        "",
+        sibling_directory=sibling_dir,
+    )
+    edit_lane_issues = code_rules_enforcer.validate_content_for_edit_lane(
+        _DUPLICATE_FUNCTION_SOURCE,
+        classification_only_file_path,
+        "",
+        sibling_directory=sibling_dir,
+    )
+
+    assert full_gate_issues == EXPECTED_PYTHON_CROSS_FILE_ISSUES
+    assert edit_lane_issues == EXPECTED_PYTHON_CROSS_FILE_EDIT_LANE_ISSUES
+
+
+def test_javascript_boolean_naming_snapshot_is_unchanged() -> None:
+    full_gate_issues = code_rules_enforcer.validate_content_for_full_gate(
+        _JS_BOOLEAN_SOURCE, "packages/app/frontend/status.js", ""
+    )
+    edit_lane_issues = code_rules_enforcer.validate_content_for_edit_lane(
+        _JS_BOOLEAN_SOURCE, "packages/app/frontend/status.js", ""
+    )
+    assert full_gate_issues == EXPECTED_JS_ISSUES
+    assert edit_lane_issues == EXPECTED_JS_ISSUES
+
+
+def test_python_orphan_css_class_snapshot_is_unchanged() -> None:
+    full_gate_issues = code_rules_enforcer.validate_content_for_full_gate(
+        _CSS_ORPHAN_CLASS_SOURCE, "packages/app/widgets/status_widget.py", ""
+    )
+    edit_lane_issues = code_rules_enforcer.validate_content_for_edit_lane(
+        _CSS_ORPHAN_CLASS_SOURCE, "packages/app/widgets/status_widget.py", ""
+    )
+    assert full_gate_issues == EXPECTED_CSS_ISSUES
+    assert edit_lane_issues == EXPECTED_CSS_EDIT_LANE_ISSUES