claude-dev-env 1.50.0 → 1.50.2

package/hooks/blocking/test_code_rules_enforcer_config_path.py

@@ -8,24 +8,28 @@ Covers:
 
 from __future__ import annotations
 
-import importlib.util
-import io
 import sys
 from pathlib import Path
-from types import ModuleType
-
-
-def _load_enforcer_module() -> ModuleType:
-    module_path = Path(__file__).parent / "code_rules_enforcer.py"
-    spec = importlib.util.spec_from_file_location("code_rules_enforcer", module_path)
-    assert spec is not None
-    assert spec.loader is not None
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-code_rules_enforcer = _load_enforcer_module()
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_constants_config import (  # noqa: E402
+    check_constants_outside_config,
+    check_constants_outside_config_advisory,
+)
+from code_rules_path_utils import is_config_file  # noqa: E402
+
+code_rules_enforcer = SimpleNamespace(
+    check_constants_outside_config=check_constants_outside_config,
+    check_constants_outside_config_advisory=check_constants_outside_config_advisory,
+    is_config_file=is_config_file,
+)
 
 PRODUCTION_FILE_PATH = "packages/claude-dev-env/src/example.py"
 

package/hooks/blocking/test_code_rules_enforcer_exempt_marker_chained.py

@@ -31,9 +31,11 @@ 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)
-_is_exempt_python_comment = hook_module._is_exempt_python_comment
-check_comments_python = hook_module.check_comments_python
 
+from code_rules_comments import (  # noqa: E402
+    _is_exempt_python_comment,
+    check_comments_python,
+)
 
 FIXTURE_INLINE_COMMENT_LINE = 5
 FIXTURE_INLINE_COMMENT_COLUMN = 4

package/hooks/blocking/test_code_rules_enforcer_function_length.py

@@ -1,10 +1,15 @@
 """Tests for ``check_function_length``.
 
-Functions whose definition span (signature line through last body statement,
-inclusive) is at or above ``FUNCTION_LENGTH_BLOCKING_THRESHOLD`` (60) block the
-write (small-function basis: Robert C. Martin, Clean Code Ch. 3 "Functions";
-Google Python Style Guide ~40-line function review hint). Spans below the
-threshold pass silently.
+Functions whose executable span (signature line through last body statement,
+inclusive, minus the leading docstring lines of the function and of every
+function or class nested within it) is at or above
+``FUNCTION_LENGTH_BLOCKING_THRESHOLD`` (60) block the write (small-function
+basis: Robert C. Martin, Clean Code Ch. 3 "Functions"; Google Python Style
+Guide ~40-line function review hint — a measure of executable complexity,
+paired with the Guide's complete-docstring mandate for public APIs). Executable
+spans below the threshold pass silently, whatever the docstring adds to the
+full declared span; the issue message keeps reporting the full declared span so
+the commit gate's span recovery holds.
 
 Cited SYNTHESIS evidence: pa#143 F4, F9, F14 (three recurrences in one PR);
 pa#136 F20.
@@ -12,23 +17,28 @@ pa#136 F20.
 
 from __future__ import annotations
 
-import importlib.util
 import pathlib
 import sys
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(pathlib.Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(pathlib.Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_annotations_length import (  # noqa: E402
+    FUNCTION_LENGTH_BLOCKING_MESSAGE_SUFFIX,
+    FUNCTION_LENGTH_BLOCKING_THRESHOLD,
+    check_function_length,
+)
 
-_HOOK_DIR = pathlib.Path(__file__).parent
-if str(_HOOK_DIR) not in sys.path:
-    sys.path.insert(0, str(_HOOK_DIR))
-
-hook_spec = importlib.util.spec_from_file_location(
-    "code_rules_enforcer",
-    _HOOK_DIR / "code_rules_enforcer.py",
+hook_module = SimpleNamespace(
+    FUNCTION_LENGTH_BLOCKING_MESSAGE_SUFFIX=FUNCTION_LENGTH_BLOCKING_MESSAGE_SUFFIX,
+    FUNCTION_LENGTH_BLOCKING_THRESHOLD=FUNCTION_LENGTH_BLOCKING_THRESHOLD,
+    check_function_length=check_function_length,
 )
-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)
-check_function_length = hook_module.check_function_length
 
 PRODUCTION_FILE_PATH = "/project/src/long_module.py"
 TEST_FILE_PATH = "/project/src/test_long_module.py"
@@ -208,3 +218,129 @@ def test_reports_only_in_scope_violation_among_untouched_ones() -> None:
     )
     assert any("target_function" in each_issue for each_issue in issues)
     assert not any("leading_" in each_issue for each_issue in issues)
+
+
+def _build_docstring_function_source(
+    name: str, docstring_line_count: int, body_line_count: int
+) -> str:
+    """Build a function whose leading docstring spans ``docstring_line_count + 2``
+    source lines (opening summary line, the counted filler lines, closing quotes)
+    followed by ``body_line_count`` executable statements."""
+    docstring_lines = [
+        '    """Documented helper.',
+        *(
+            f"    documentation line {each_index}."
+            for each_index in range(docstring_line_count)
+        ),
+        '    """',
+    ]
+    all_source_lines = [
+        f"def {name}() -> None:",
+        *docstring_lines,
+        *(
+            f"    statement_{each_index} = {each_index}"
+            for each_index in range(body_line_count)
+        ),
+    ]
+    return "\n".join(all_source_lines) + "\n"
+
+
+def test_docstring_heavy_function_with_small_body_passes() -> None:
+    """A complete Google-style docstring must not push a small-bodied function
+    over the gate: the threshold measures executable lines only."""
+    source = _build_docstring_function_source(
+        "documented_compact_helper",
+        docstring_line_count=hook_module.FUNCTION_LENGTH_BLOCKING_THRESHOLD,
+        body_line_count=5,
+    )
+    issues = check_function_length(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"docstring lines must not count toward the gate, got: {issues!r}"
+
+
+def test_oversized_executable_body_blocks_despite_docstring() -> None:
+    """A docstring does not acquit a genuinely large executable body, and the
+    issue message reports the full declared span so the commit gate's
+    ``function_length_span_range`` recovery keeps covering the whole function."""
+    docstring_line_count = 10
+    body_line_count = hook_module.FUNCTION_LENGTH_BLOCKING_THRESHOLD - 1
+    source = _build_docstring_function_source(
+        "documented_oversized_helper",
+        docstring_line_count=docstring_line_count,
+        body_line_count=body_line_count,
+    )
+    full_declared_span = 1 + (docstring_line_count + 2) + body_line_count
+    issues = check_function_length(source, PRODUCTION_FILE_PATH)
+    assert any("documented_oversized_helper" in each_issue for each_issue in issues)
+    assert any(f"is {full_declared_span} lines" in each_issue for each_issue in issues)
+
+
+def test_executable_span_boundary_sits_one_below_threshold() -> None:
+    """With the docstring excluded, an executable span of THRESHOLD - 1 passes
+    even though the full declared span sits far above the threshold."""
+    source = _build_docstring_function_source(
+        "documented_boundary_helper",
+        docstring_line_count=20,
+        body_line_count=hook_module.FUNCTION_LENGTH_BLOCKING_THRESHOLD - 2,
+    )
+    issues = check_function_length(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_builder_zero_docstring_line_count_keeps_span_contract() -> None:
+    """The builder's docstring-span contract (``docstring_line_count + 2``) holds
+    at the zero boundary, so hand-computed span oracles in tests cannot drift."""
+    source = _build_docstring_function_source(
+        "documented_minimal_helper", docstring_line_count=0, body_line_count=3
+    )
+    expected_total_lines = 1 + (0 + 2) + 3
+    assert len(source.splitlines()) == expected_total_lines
+
+
+def test_builder_zero_body_line_count_keeps_span_contract() -> None:
+    """The builder's span contract holds at the zero-body boundary, so a
+    docstring-only function's hand-computed span oracle cannot drift."""
+    source = _build_docstring_function_source(
+        "documented_bodyless_helper", docstring_line_count=5, body_line_count=0
+    )
+    expected_total_lines = 1 + (5 + 2) + 0
+    assert len(source.splitlines()) == expected_total_lines
+
+
+def test_nested_function_docstring_does_not_count_toward_outer() -> None:
+    """A nested helper's docstring is documentation too: the outer function's
+    executable span excludes every leading docstring within its declared span."""
+    nested_docstring_filler = "\n".join(
+        f"        nested documentation line {each_index}."
+        for each_index in range(hook_module.FUNCTION_LENGTH_BLOCKING_THRESHOLD)
+    )
+    source = (
+        "def outer_documented_orchestrator() -> None:\n"
+        "    def nested_documented_helper() -> None:\n"
+        '        """Documented nested helper.\n'
+        f"{nested_docstring_filler}\n"
+        '        """\n'
+        "        nested_statement = 1\n"
+        "    outer_statement = 2\n"
+    )
+    issues = check_function_length(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"nested docstring lines must not count toward the gate, got: {issues!r}"
+
+
+def test_nested_class_docstring_does_not_count_toward_outer() -> None:
+    """A nested class's docstring is documentation too: the outer function's
+    executable span excludes leading docstrings of nested classes as well."""
+    nested_class_docstring_filler = "\n".join(
+        f"        nested class documentation line {each_index}."
+        for each_index in range(hook_module.FUNCTION_LENGTH_BLOCKING_THRESHOLD)
+    )
+    source = (
+        "def outer_class_documented_orchestrator() -> None:\n"
+        "    class NestedDocumentedConfig:\n"
+        '        """Documented nested class.\n'
+        f"{nested_class_docstring_filler}\n"
+        '        """\n'
+        "        nested_field = 1\n"
+        "    outer_statement = 2\n"
+    )
+    issues = check_function_length(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"nested class docstring lines must not count toward the gate, got: {issues!r}"

package/hooks/blocking/test_code_rules_enforcer_hardcoded_user_path.py

@@ -12,7 +12,6 @@ import importlib.util
 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))
@@ -26,8 +25,8 @@ assert _hook_spec.loader is not None
 _hook_module = importlib.util.module_from_spec(_hook_spec)
 _hook_spec.loader.exec_module(_hook_module)
 check_hardcoded_user_paths = _hook_module.check_hardcoded_user_paths
-HARDCODED_USER_PATH_PATTERN = _hook_module.HARDCODED_USER_PATH_PATTERN
 
+from code_rules_paths_syspath import HARDCODED_USER_PATH_PATTERN  # noqa: E402
 
 PRODUCTION_FILE_PATH = "packages/app/services/loader.py"
 TEST_FILE_PATH = "packages/app/tests/test_loader.py"

package/hooks/blocking/test_code_rules_enforcer_ignored_must_check_return.py

@@ -7,22 +7,32 @@ call is exempt; only bare ``ast.Expr`` calls are flagged.
 
 from __future__ import annotations
 
-import importlib.util
+import sys
 from pathlib import Path
-from types import ModuleType
+from types import SimpleNamespace
 
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
 
-def _load_enforcer_module() -> ModuleType:
-    module_path = Path(__file__).parent / "code_rules_enforcer.py"
-    spec = importlib.util.spec_from_file_location("code_rules_enforcer", module_path)
-    assert spec is not None
-    assert spec.loader is not None
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
+from code_rules_boolean_mustcheck import (  # noqa: E402
+    MAX_IGNORED_MUST_CHECK_RETURN_ISSUES,
+)
+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,
+)
 
-code_rules_enforcer = _load_enforcer_module()
+code_rules_enforcer = SimpleNamespace(
+    MAX_IGNORED_MUST_CHECK_RETURN_ISSUES=MAX_IGNORED_MUST_CHECK_RETURN_ISSUES,
+    check_ignored_must_check_return=_check_ignored_must_check_return,
+    validate_content=_validate_content,
+)
 
 
 def check_ignored_must_check_return(content: str, file_path: str) -> list[str]:

package/hooks/blocking/test_code_rules_enforcer_split_annotations_length.py

@@ -0,0 +1,55 @@
+"""Behavior tests for the code_rules_annotations_length code-rules check module."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_annotations_length import (  # noqa: E402
+    FUNCTION_LENGTH_BLOCKING_MESSAGE_SUFFIX,
+    check_function_length,
+    is_hook_infrastructure,
+)
+
+code_rules_enforcer = SimpleNamespace(
+    FUNCTION_LENGTH_BLOCKING_MESSAGE_SUFFIX=FUNCTION_LENGTH_BLOCKING_MESSAGE_SUFFIX,
+    check_function_length=check_function_length,
+    is_hook_infrastructure=is_hook_infrastructure,
+)
+
+
+def test_should_treat_repo_relative_hook_path_as_hook_infrastructure() -> None:
+    relative_hook_path = "packages/claude-dev-env/hooks/blocking/code_rules_enforcer.py"
+    assert code_rules_enforcer.is_hook_infrastructure(relative_hook_path) is True
+
+
+def test_should_treat_backslash_repo_relative_hook_path_as_hook_infrastructure() -> None:
+    relative_hook_path = "packages\\claude-dev-env\\hooks\\blocking\\code_rules_enforcer.py"
+    assert code_rules_enforcer.is_hook_infrastructure(relative_hook_path) is True
+
+
+def test_should_not_treat_unrelated_repo_relative_path_as_hook_infrastructure() -> None:
+    relative_source_path = "packages/claude-dev-env/skills/bugteam/scripts/runner.py"
+    assert code_rules_enforcer.is_hook_infrastructure(relative_source_path) is False
+
+
+def test_should_exempt_repo_relative_hook_file_from_function_length() -> None:
+    body_lines = "\n".join(f"    bound_{each_index} = {each_index}" for each_index in range(70))
+    grown_function_source = "def grown_function() -> None:\n" + body_lines + "\n"
+    relative_hook_path = "packages/claude-dev-env/hooks/blocking/code_rules_enforcer.py"
+    assert code_rules_enforcer.check_function_length(grown_function_source, relative_hook_path) == []
+
+
+def test_function_length_message_does_not_cite_file_length_section() -> None:
+    """The blocking message must cite a function-length basis, not the
+    advisory file-length section (CODE_RULES §6.5)."""
+    assert "6.5" not in code_rules_enforcer.FUNCTION_LENGTH_BLOCKING_MESSAGE_SUFFIX
+    assert "Clean Code" in code_rules_enforcer.FUNCTION_LENGTH_BLOCKING_MESSAGE_SUFFIX

package/hooks/blocking/test_code_rules_enforcer_split_banned.py

@@ -0,0 +1,170 @@
+"""Behavior tests for the code_rules_banned_identifiers code-rules check module."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_banned_identifiers import (  # noqa: E402
+    ALL_BANNED_IDENTIFIERS,
+    BANNED_IDENTIFIER_MESSAGE_SUFFIX,
+    BANNED_IDENTIFIER_SKIP_ADVISORY,
+    MAX_BANNED_IDENTIFIER_ISSUES,
+    check_banned_noun_word_boundary,
+)
+
+from hooks_constants.banned_identifiers_constants import (  # noqa: E402
+    ALL_BANNED_IDENTIFIERS as config_all_banned_identifiers,
+)
+from hooks_constants.banned_identifiers_constants import (  # noqa: E402
+    BANNED_IDENTIFIER_MESSAGE_SUFFIX as config_banned_identifier_message_suffix,
+)
+from hooks_constants.banned_identifiers_constants import (  # noqa: E402
+    BANNED_IDENTIFIER_SKIP_ADVISORY as config_banned_identifier_skip_advisory,
+)
+from hooks_constants.banned_identifiers_constants import (  # noqa: E402
+    MAX_BANNED_IDENTIFIER_ISSUES as config_max_banned_identifier_issues,
+)
+
+code_rules_enforcer = SimpleNamespace(
+    ALL_BANNED_IDENTIFIERS=ALL_BANNED_IDENTIFIERS,
+    BANNED_IDENTIFIER_MESSAGE_SUFFIX=BANNED_IDENTIFIER_MESSAGE_SUFFIX,
+    BANNED_IDENTIFIER_SKIP_ADVISORY=BANNED_IDENTIFIER_SKIP_ADVISORY,
+    MAX_BANNED_IDENTIFIER_ISSUES=MAX_BANNED_IDENTIFIER_ISSUES,
+    check_banned_noun_word_boundary=check_banned_noun_word_boundary,
+)
+
+
+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_all_banned_identifiers_from_config() -> None:
+    assert code_rules_enforcer.ALL_BANNED_IDENTIFIERS is config_all_banned_identifiers
+
+
+def test_banned_noun_word_skips_non_aliased_upstream_import() -> None:
+    """A non-aliased upstream import the author cannot rename
+    (`from typing import ItemsView`) must not be flagged, while an
+    author-coined alias still is."""
+    production_path = "packages/myapp/services/customer_pipeline.py"
+    upstream_issues = code_rules_enforcer.check_banned_noun_word_boundary(
+        "from typing import ItemsView\n", production_path
+    )
+    aliased_issues = code_rules_enforcer.check_banned_noun_word_boundary(
+        "import legacy_helper as cached_response\n", production_path
+    )
+    assert upstream_issues == []
+    assert any("cached_response" in each_issue for each_issue in aliased_issues)
+
+
+def test_banned_noun_word_defers_scope_to_caller_when_requested() -> None:
+    """loop7-P1: when the gate sets the deferral flag, the banned-noun check must
+    return every violation so ``split_violations_by_scope`` can scope by added
+    line before reporting the in-scope set."""
+    binding_count = 5
+    source = "".join(
+        f"BINDING_{each_index}_RESULT_PATH = {each_index}\n"
+        for each_index in range(binding_count)
+    )
+    issues = code_rules_enforcer.check_banned_noun_word_boundary(
+        source,
+        "/project/src/many_nouns.py",
+        defer_scope_to_caller=True,
+    )
+    assert len(issues) == binding_count, (
+        "deferral must return every banned-noun violation, "
+        f"got: {issues!r}"
+    )
+
+
+def test_banned_noun_message_carries_binding_line_span() -> None:
+    """A banned-noun binding carries its own binding line as a one-line span so
+    the commit gate reconstructs it through the same shared span mechanism the
+    other diff-scoped checks use, while keeping the Line N: prefix intact. The
+    binding-line granularity matches the companion exact-match
+    check_banned_identifiers and avoids re-flagging a pre-existing binding when
+    an unrelated line of its enclosing function is edited."""
+    source = (
+        "def aggregate() -> list[int]:\n"
+        "    canned_results = [1, 2, 3]\n"
+        "    return canned_results\n"
+    )
+    issues = code_rules_enforcer.check_banned_noun_word_boundary(
+        source, "/project/src/has_noun.py"
+    )
+    binding_line = 2
+    expected_fragment = f"(binding span at line {binding_line}, spanning 1 lines)"
+    assert any(
+        each_issue.startswith(f"Line {binding_line}:") and expected_fragment in each_issue
+        for each_issue in issues
+    ), f"banned-noun message must carry the binding-line span fragment, got: {issues!r}"
+
+
+def test_banned_noun_message_module_level_binding_spans_one_line() -> None:
+    """A module-level banned-noun binding spans its own binding line alone
+    (span 1)."""
+    source = "SAFE_OUTPUT_PATH = '/var/run/x'\n"
+    issues = code_rules_enforcer.check_banned_noun_word_boundary(
+        source, "/project/src/module_noun.py"
+    )
+    expected_fragment = "(binding span at line 1, spanning 1 lines)"
+    assert any(expected_fragment in each_issue for each_issue in issues), (
+        f"module-level banned-noun span must be one line, got: {issues!r}"
+    )
+
+
+def test_banned_noun_word_boundary_flags_plural_results_identifier() -> None:
+    """A plural banned noun ('results') embedded in an identifier must flag.
+
+    ``ALL_BANNED_NOUN_WORDS`` contains plural forms (results, outputs,
+    responses, values, items) in addition to the singular nouns, so an
+    identifier such as ``canned_results`` is flagged even though no singular
+    exact-match identifier appears.
+    """
+    source = "canned_results = []\n"
+    issues = code_rules_enforcer.check_banned_noun_word_boundary(
+        source, "/project/src/pipeline.py"
+    )
+    assert any("canned_results" in each_issue for each_issue in issues), (
+        "a plural banned-noun identifier must be flagged by the word-boundary "
+        f"check; got: {issues!r}"
+    )

package/hooks/blocking/test_code_rules_enforcer_split_comments.py

@@ -0,0 +1,60 @@
+"""Behavior tests for the code_rules_comments code-rules check module."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_comments import (  # noqa: E402
+    check_comments_python,
+)
+
+code_rules_enforcer = SimpleNamespace(
+    check_comments_python=check_comments_python,
+)
+
+
+def test_exempt_comment_rejects_noqa_prefixed_prose_lacking_boundary() -> None:
+    """A comment body that merely starts with `noqa` followed by non-boundary
+    characters is not a real noqa directive and must stay subject to the
+    no-new-comments rule."""
+    source = "x = compute()  # noqa-but-not-really: explanation\n"
+    issues = code_rules_enforcer.check_comments_python(source)
+    assert issues
+
+
+def test_exempt_comment_keeps_bare_and_coded_noqa_exempt() -> None:
+    """A bare `# noqa` and a coded `# noqa: E501` remain exempt under the
+    tightened boundary rule."""
+    bare_source = "x = compute()  # noqa\n"
+    coded_source = "x = compute()  # noqa: E501\n"
+    assert code_rules_enforcer.check_comments_python(bare_source) == []
+    assert code_rules_enforcer.check_comments_python(coded_source) == []
+
+
+def test_exempt_comment_keeps_colon_terminated_markers_without_trailing_space() -> None:
+    """A colon-terminated marker (`pylint:`, `type:`, `pragma:`) is self-bounded
+    by its own colon, so the directive stays exempt even when the next character
+    follows the colon immediately."""
+    pylint_source = "import os  # pylint:disable=unused-import\n"
+    type_ignore_source = "x = compute()  # type:ignore\n"
+    pragma_source = "x = compute()  # pragma:no-cover\n"
+    assert code_rules_enforcer.check_comments_python(pylint_source) == []
+    assert code_rules_enforcer.check_comments_python(type_ignore_source) == []
+    assert code_rules_enforcer.check_comments_python(pragma_source) == []
+
+
+def test_exempt_comment_still_flags_noqa_glued_to_prose_without_boundary() -> None:
+    """The colon-terminated allowance must not loosen the boundary rule for
+    markers that do not end in a colon: `# noqaFOO` still lacks a real boundary
+    after `noqa` and stays subject to the no-new-comments rule."""
+    source = "x = compute()  # noqaFOO\n"
+    assert code_rules_enforcer.check_comments_python(source)

package/hooks/blocking/test_code_rules_enforcer_split_config_path.py

@@ -0,0 +1,52 @@
+"""Behavior tests for the code_rules_path_utils code-rules check module."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_path_utils import is_config_file  # noqa: E402
+from validators.exempt_paths import (  # noqa: E402
+    is_config_file as exempt_paths_is_config_file,
+)
+
+code_rules_enforcer = SimpleNamespace(
+    is_config_file=is_config_file,
+)
+
+
+def test_is_config_file_rejects_filename_only_config_pattern() -> None:
+    """Paths where 'config' appears only in the filename (not as a directory segment) must return False."""
+    assert code_rules_enforcer.is_config_file("scripts/db/config.py") is False, (
+        "scripts/db/config.py — filename is config.py but parent dir is db, must be False"
+    )
+    assert code_rules_enforcer.is_config_file("lib/myconfig.py") is False, (
+        "lib/myconfig.py — config appears only in the filename stem, must be False"
+    )
+    assert code_rules_enforcer.is_config_file("src/app_config.py") is False, (
+        "src/app_config.py — config appears only in the filename stem, must be False"
+    )
+
+
+def test_is_config_file_reexported_by_exempt_paths_matches_canonical() -> None:
+    """The exempt_paths re-export of is_config_file must agree with the canonical code_rules_path_utils implementation on all sample paths."""
+    all_sample_paths = [
+        "scripts/db/config.py",
+        "config/timing.py",
+        "settings.py",
+    ]
+    for each_path in all_sample_paths:
+        canonical_result = code_rules_enforcer.is_config_file(each_path)
+        exempt_paths_result = exempt_paths_is_config_file(each_path)
+        assert canonical_result == exempt_paths_result, (
+            f"is_config_file diverged for {each_path!r}: "
+            f"code_rules_path_utils={canonical_result}, exempt_paths={exempt_paths_result}"
+        )