claude-dev-env 1.59.0 → 1.61.0

package/hooks/blocking/test_code_rules_enforcer_annotations.py

@@ -320,3 +320,243 @@ def test_should_flag_undefaulted_fixture_before_defaulted_one() -> None:
     )
 
 
+def test_should_flag_unused_known_fixture_parameter_in_test_file() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_omits_config(tmp_path: Path) -> None:\n"
+        "    command = build_command('module.py', None)\n"
+        "    assert command[-1] == 'module.py'\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue for each_issue in issues
+    ), f"Expected unused tmp_path fixture parameter flagged, got: {issues}"
+
+
+def test_should_not_flag_used_known_fixture_parameter() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_includes_config(tmp_path: Path) -> None:\n"
+        "    config_file = tmp_path / 'pyproject.toml'\n"
+        "    assert config_file.name == 'pyproject.toml'\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A referenced fixture parameter must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_unused_ordinary_test_parameter() -> None:
+    source = "def test_thing(some_value):\n    return 1\n"
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Only known pytest fixtures are checked, not arbitrary params, got: {issues}"
+    )
+
+
+def test_should_not_flag_unused_fixture_outside_test_files() -> None:
+    source = "def build(tmp_path):\n    return 1\n"
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"This check applies to test files only, got: {issues}"
+    )
+
+
+def test_should_flag_unused_monkeypatch_fixture_parameter() -> None:
+    source = (
+        "import pytest\n"
+        "def test_env(monkeypatch: pytest.MonkeyPatch) -> None:\n"
+        "    assert build_command('m.py', None)[-1] == 'm.py'\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "monkeypatch" in each_issue for each_issue in issues
+    ), f"Expected unused monkeypatch fixture parameter flagged, got: {issues}"
+
+
+def test_should_count_attribute_access_as_fixture_use() -> None:
+    source = (
+        "import pytest\n"
+        "def test_env(monkeypatch: pytest.MonkeyPatch) -> None:\n"
+        "    monkeypatch.setenv('A', 'B')\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Attribute access on the fixture counts as a use, got: {issues}"
+    )
+
+
+def test_should_count_nested_function_reference_as_fixture_use() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_board(tmp_path: Path) -> None:\n"
+        "    def inner() -> Path:\n"
+        "        return tmp_path\n"
+        "    assert inner().name\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A reference inside a nested function counts as a use, got: {issues}"
+    )
+
+
+def test_should_not_flag_unused_fixture_in_decorated_fixture_function() -> None:
+    source = (
+        "import pytest\n"
+        "from pathlib import Path\n"
+        "@pytest.fixture\n"
+        "def board(tmp_path: Path) -> int:\n"
+        "    return 1\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A fixture composing another fixture by injection alone is intentional "
+        f"and must not be flagged, got: {issues}"
+    )
+
+
+def test_should_count_comprehension_reference_as_fixture_use() -> None:
+    source = (
+        "import pytest\n"
+        "def test_log_lines(caplog: pytest.LogCaptureFixture) -> None:\n"
+        "    messages = [each_record.message for each_record in caplog.records]\n"
+        "    assert messages == []\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A reference inside a comprehension counts as a use, got: {issues}"
+    )
+
+
+def test_should_not_flag_unused_fixture_in_decorated_test_named_function() -> None:
+    source = (
+        "import pytest\n"
+        "from pathlib import Path\n"
+        "@pytest.fixture\n"
+        "def test_board(tmp_path: Path) -> int:\n"
+        "    return 1\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A @pytest.fixture-decorated function named test_* is a fixture, not a "
+        f"test, and must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_fixture_param_on_nested_test_named_helper() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_outer(tmp_path: Path) -> None:\n"
+        "    assert tmp_path\n"
+        "    def test_inner(tmp_path) -> None:\n"
+        "        return None\n"
+        "    test_inner(tmp_path)\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A fixture-named parameter on a function nested inside a test body is a "
+        f"local helper argument pytest never injects, got: {issues}"
+    )
+
+
+def test_should_count_augmented_assignment_as_fixture_reference() -> None:
+    source = "def test_aug(request) -> None:\n    request += 1\n"
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"An augmented assignment to the fixture references it, got: {issues}"
+    )
+
+
+def test_should_count_del_as_fixture_reference() -> None:
+    source = "def test_d(tmp_path: Path) -> None:\n    del tmp_path\n"
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A del of the fixture references it, got: {issues}"
+    )
+
+
+def test_should_flag_unused_fixture_parameter_on_class_method() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "class TestThing:\n"
+        "    def test_method(self, tmp_path: Path) -> None:\n"
+        "        assert 1 == 1\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue for each_issue in issues
+    ), f"An unused fixture on a class-body test method must be flagged, got: {issues}"
+
+
+def test_should_flag_unused_fixture_parameter_on_nested_class_method() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "class TestOuter:\n"
+        "    class TestInner:\n"
+        "        def test_method(self, tmp_path: Path) -> None:\n"
+        "            assert 1 == 1\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue for each_issue in issues
+    ), f"An unused fixture on a nested-class test method must be flagged, got: {issues}"
+
+
+def test_should_flag_fixture_when_body_only_plain_assigns_it() -> None:
+    source = "def test_x(tmp_path: Path) -> None:\n    tmp_path = 1\n"
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue for each_issue in issues
+    ), f"A plain Store target is not a reference, so tmp_path is unused, got: {issues}"
+
+
+def test_annotation_check_skips_fixture_param_on_function_nested_in_test() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_outer(tmp_path: Path) -> None:\n"
+        "    def inner(tmp_path) -> None:\n"
+        "        return None\n"
+        "    inner(tmp_path)\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A fixture-named param on a function nested in a test body is not an "
+        f"injection site, and the correctly annotated outer param is fine, "
+        f"got: {issues}"
+    )
+
+

package/hooks/blocking/test_code_rules_enforcer_cap_meta.py

@@ -77,6 +77,7 @@ KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW: frozenset[str] = frozenset(
         "check_return_annotations",
         "check_skip_decorators_in_tests",
         "check_string_literal_magic",
+        "check_unused_known_pytest_fixture_parameters",
         "check_unused_optional_parameters",
     }
 )

package/hooks/blocking/test_code_rules_enforcer_cross_skill_duplicate.py

@@ -0,0 +1,146 @@
+"""Tests for the cross-skill duplicate-helper advisory.
+
+PR #233 on JonEcho/python-automation copied a Chrome-launch helper from the
+``stp-recolor`` skill's ``scripts`` directory into the ``iconize-and-recolor-stp``
+skill's ``scripts`` directory. The two skills install on their own, so a shared
+module would couple them and break independent install; the copy is a defensible
+skill-isolation tradeoff. ``advise_cross_skill_duplicate_helper`` surfaces that
+copy as a non-blocking ``[CODE_RULES advisory]`` on stderr so a reviewer confirms
+the copy was intentional, without denying the write.
+
+The tests build a real ``skills/<name>/scripts`` layout on disk and run the
+advisory against it, so they exercise the on-disk cross-skill scan rather than a
+stubbed view of the filesystem.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import pathlib
+import shutil
+import sys
+import tempfile
+from collections.abc import Iterator
+
+import pytest
+
+_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_duplicate_body",
+    _HOOK_DIRECTORY / "code_rules_duplicate_body.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)
+advise_cross_skill_duplicate_helper = _hook_module.advise_cross_skill_duplicate_helper
+
+
+CHROME_HELPER_SOURCE = (
+    "import winreg\n"
+    "from pathlib import Path\n"
+    "\n"
+    "chrome_app_paths_key = r'SOFTWARE\\Microsoft\\App Paths\\chrome.exe'\n"
+    "chrome_fallback_paths = ('C:/chrome.exe',)\n"
+    "\n"
+    "def _chrome_executable() -> Path | None:\n"
+    "    for each_root in (winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE):\n"
+    "        try:\n"
+    "            registered = winreg.QueryValue(each_root, chrome_app_paths_key)\n"
+    "        except OSError:\n"
+    "            continue\n"
+    "        registered_path = Path(registered)\n"
+    "        if registered_path.exists():\n"
+    "            return registered_path\n"
+    "    for each_fallback in chrome_fallback_paths:\n"
+    "        fallback_path = Path(each_fallback)\n"
+    "        if fallback_path.exists():\n"
+    "            return fallback_path\n"
+    "    return None\n"
+)
+
+
+@pytest.fixture
+def skills_root() -> Iterator[pathlib.Path]:
+    base_directory = pathlib.Path(tempfile.mkdtemp())
+    skills_directory = base_directory / "skills"
+    skills_directory.mkdir()
+    try:
+        yield skills_directory
+    finally:
+        shutil.rmtree(base_directory, ignore_errors=False)
+
+
+def _make_skill_scripts(skills_directory: pathlib.Path, skill_name: str) -> pathlib.Path:
+    scripts_directory = skills_directory / skill_name / "scripts"
+    scripts_directory.mkdir(parents=True)
+    return scripts_directory
+
+
+def test_advises_when_helper_copied_from_another_skill(
+    skills_root: pathlib.Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    source_scripts = _make_skill_scripts(skills_root, "stp-recolor")
+    (source_scripts / "palette_board.py").write_text(CHROME_HELPER_SOURCE, encoding="utf-8")
+    target_scripts = _make_skill_scripts(skills_root, "iconize-and-recolor-stp")
+    target_file = target_scripts / "combine_report.py"
+
+    advise_cross_skill_duplicate_helper(CHROME_HELPER_SOURCE, str(target_file))
+
+    captured = capsys.readouterr()
+    assert "[CODE_RULES advisory]" in captured.err, (
+        f"Expected a cross-skill advisory on stderr, got: {captured.err!r}"
+    )
+    assert "_chrome_executable" in captured.err, (
+        f"Expected the duplicated function named, got: {captured.err!r}"
+    )
+    assert "stp-recolor" in captured.err, f"Expected the source skill named, got: {captured.err!r}"
+
+
+def test_advisory_does_not_block(
+    skills_root: pathlib.Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    source_scripts = _make_skill_scripts(skills_root, "stp-recolor")
+    (source_scripts / "palette_board.py").write_text(CHROME_HELPER_SOURCE, encoding="utf-8")
+    target_scripts = _make_skill_scripts(skills_root, "iconize-and-recolor-stp")
+    target_file = target_scripts / "combine_report.py"
+
+    returned = advise_cross_skill_duplicate_helper(CHROME_HELPER_SOURCE, str(target_file))
+
+    assert returned is None, "The advisory returns nothing so it never enters the deny path"
+
+
+def test_no_advisory_within_one_skill(
+    skills_root: pathlib.Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    scripts_directory = _make_skill_scripts(skills_root, "stp-recolor")
+    (scripts_directory / "palette_board.py").write_text(CHROME_HELPER_SOURCE, encoding="utf-8")
+    sibling_file = scripts_directory / "combine_report.py"
+
+    advise_cross_skill_duplicate_helper(CHROME_HELPER_SOURCE, str(sibling_file))
+
+    captured = capsys.readouterr()
+    assert captured.err == "", (
+        "Within one skill the blocking gate covers the copy; the cross-skill "
+        f"advisory must stay silent, got: {captured.err!r}"
+    )
+
+
+def test_no_advisory_outside_a_skill_scripts_directory(
+    skills_root: pathlib.Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    source_scripts = _make_skill_scripts(skills_root, "stp-recolor")
+    (source_scripts / "palette_board.py").write_text(CHROME_HELPER_SOURCE, encoding="utf-8")
+    non_skill_directory = skills_root.parent / "elsewhere"
+    non_skill_directory.mkdir()
+    target_file = non_skill_directory / "combine_report.py"
+
+    advise_cross_skill_duplicate_helper(CHROME_HELPER_SOURCE, str(target_file))
+
+    captured = capsys.readouterr()
+    assert captured.err == "", (
+        f"A file outside a skill scripts directory draws no advisory, got: {captured.err!r}"
+    )

package/hooks/blocking/test_code_rules_enforcer_dead_module_constant.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import importlib.util
+import os
+import shutil
+import stat
+import tempfile
+from collections.abc import Callable, Iterator
+from pathlib import Path
+
+import pytest
+
+ENFORCER_PATH = Path(__file__).resolve().parent / "code_rules_enforcer.py"
+specification = importlib.util.spec_from_file_location("code_rules_enforcer", ENFORCER_PATH)
+assert specification is not None and specification.loader is not None
+code_rules_enforcer = importlib.util.module_from_spec(specification)
+specification.loader.exec_module(code_rules_enforcer)
+
+CONSTANTS_BODY = 'MEDIUM_TERMINAL = "terminal"\nMEDIUM_CODE = "code"\nMEDIUM_TEXT = "text"\n'
+
+
+def _strip_read_only_and_retry(
+    removal_function: Callable[[str], object],
+    target_path: str,
+    _exc_info: BaseException,
+) -> None:
+    try:
+        os.chmod(target_path, stat.S_IWRITE)
+        removal_function(target_path)
+    except OSError:
+        pass
+
+
+@pytest.fixture
+def neutral_root() -> Iterator[Path]:
+    """Yield a temp directory whose path carries no ``test_`` segment.
+
+    The enforcer's ``is_test_file`` keys on the full path string, and pytest's
+    own ``tmp_path`` directory name embeds the test name, which would make every
+    synthetic constants path look like a test file. A neutral ``mkdtemp`` root
+    mirrors how a production constants module path looks.
+    """
+    neutral_directory = Path(tempfile.mkdtemp(prefix="deadconst-")).resolve()
+    try:
+        yield neutral_directory
+    finally:
+        shutil.rmtree(neutral_directory, onexc=_strip_read_only_and_retry)
+
+
+def _check(source: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_dead_module_constants(source, file_path)
+
+
+def _build_constants_package(
+    workflow_directory: Path,
+    constants_body: str,
+    consumer_body: str,
+) -> Path:
+    constants_package = workflow_directory / "report_constants"
+    constants_package.mkdir(parents=True)
+    (constants_package / "__init__.py").write_text("", encoding="utf-8")
+    constants_path = constants_package / "render_report_constants.py"
+    constants_path.write_text(constants_body, encoding="utf-8")
+    (workflow_directory / "render_report.py").write_text(consumer_body, encoding="utf-8")
+    return constants_path
+
+
+def test_flags_constant_imported_by_no_module_in_the_tree(neutral_root: Path) -> None:
+    consumer_body = (
+        "from report_constants.render_report_constants import (\n"
+        "    MEDIUM_CODE,\n"
+        "    MEDIUM_TERMINAL,\n"
+        ")\n"
+        "\n"
+        "def panel_class(medium: str) -> str:\n"
+        "    if medium == MEDIUM_TERMINAL:\n"
+        "        return 'terminal'\n"
+        "    return 'code-panel' if medium == MEDIUM_CODE else 'text-panel'\n"
+    )
+    constants_path = _build_constants_package(
+        neutral_root / "workflow", CONSTANTS_BODY, consumer_body
+    )
+    issues = _check(CONSTANTS_BODY, str(constants_path))
+    assert any("MEDIUM_TEXT" in each_issue for each_issue in issues), (
+        f"Expected dead MEDIUM_TEXT flagged, got: {issues}"
+    )
+    assert not any(
+        "MEDIUM_TERMINAL" in each_issue or "MEDIUM_CODE" in each_issue for each_issue in issues
+    ), f"Imported constants must not be flagged, got: {issues}"
+
+
+def test_does_not_flag_constant_imported_one_directory_up(neutral_root: Path) -> None:
+    consumer_uses_text = (
+        "from report_constants.render_report_constants import (\n"
+        "    MEDIUM_CODE,\n"
+        "    MEDIUM_TERMINAL,\n"
+        "    MEDIUM_TEXT,\n"
+        ")\n"
+        "\n"
+        "def panel_class(medium: str) -> str:\n"
+        "    if medium == MEDIUM_TERMINAL:\n"
+        "        return 'terminal'\n"
+        "    if medium == MEDIUM_TEXT:\n"
+        "        return 'text-panel'\n"
+        "    return 'code-panel' if medium == MEDIUM_CODE else 'text-panel'\n"
+    )
+    constants_path = _build_constants_package(
+        neutral_root / "workflow", CONSTANTS_BODY, consumer_uses_text
+    )
+    issues = _check(CONSTANTS_BODY, str(constants_path))
+    assert issues == [], f"No constant is dead when all are imported, got: {issues}"
+
+
+def test_does_not_flag_when_module_declares_dunder_all(neutral_root: Path) -> None:
+    constants_body = CONSTANTS_BODY + '__all__ = ["MEDIUM_TERMINAL"]\n'
+    consumer_body = (
+        "from report_constants.render_report_constants import MEDIUM_TERMINAL\n"
+        "\n"
+        "def label() -> str:\n"
+        "    return MEDIUM_TERMINAL\n"
+    )
+    constants_path = _build_constants_package(
+        neutral_root / "workflow", constants_body, consumer_body
+    )
+    issues = _check(constants_body, str(constants_path))
+    assert issues == [], f"__all__ surface suppresses the check, got: {issues}"
+
+
+def test_does_not_run_on_ordinary_production_module(neutral_root: Path) -> None:
+    workflow_directory = neutral_root / "workflow"
+    workflow_directory.mkdir(parents=True)
+    ordinary_path = workflow_directory / "render_report.py"
+    body = "WIDGET_LIMIT = 5\n\ndef widgets() -> int:\n    return WIDGET_LIMIT\n"
+    ordinary_path.write_text(body, encoding="utf-8")
+    issues = _check(body, str(ordinary_path))
+    assert issues == [], (
+        f"The dead-constant check runs only on dedicated constants modules, got: {issues}"
+    )
+
+
+def test_runs_on_config_directory_module(neutral_root: Path) -> None:
+    package_directory = neutral_root / "app"
+    config_directory = package_directory / "config"
+    config_directory.mkdir(parents=True)
+    constants_body = "TIMEOUT_SECONDS = 30\nUNUSED_THRESHOLD = 99\n"
+    constants_path = config_directory / "timing.py"
+    constants_path.write_text(constants_body, encoding="utf-8")
+    consumer_body = (
+        "from config.timing import TIMEOUT_SECONDS\n"
+        "\n"
+        "def deadline() -> int:\n"
+        "    return TIMEOUT_SECONDS\n"
+    )
+    (package_directory / "service.py").write_text(consumer_body, encoding="utf-8")
+    issues = _check(constants_body, str(constants_path))
+    assert any("UNUSED_THRESHOLD" in each_issue for each_issue in issues), (
+        f"Expected dead UNUSED_THRESHOLD flagged in config module, got: {issues}"
+    )
+    assert not any("TIMEOUT_SECONDS" in each_issue for each_issue in issues), (
+        f"Consumed config constant must not be flagged, got: {issues}"
+    )
+
+
+def test_counts_a_reference_from_a_test_module(neutral_root: Path) -> None:
+    workflow_directory = neutral_root / "workflow"
+    constants_body = 'ONLY_TESTS_USE_THIS = "x"\n'
+    constants_path = workflow_directory / "render_report_constants.py"
+    workflow_directory.mkdir(parents=True)
+    constants_path.write_text(constants_body, encoding="utf-8")
+    test_body = (
+        "from render_report_constants import ONLY_TESTS_USE_THIS\n"
+        "\n"
+        "def test_value() -> None:\n"
+        "    assert ONLY_TESTS_USE_THIS == 'x'\n"
+    )
+    (workflow_directory / "test_render_report.py").write_text(test_body, encoding="utf-8")
+    issues = _check(constants_body, str(constants_path))
+    assert issues == [], f"A constant used only by a test under the tree stays live, got: {issues}"
+
+
+def test_is_skipped_on_a_constants_test_file(neutral_root: Path) -> None:
+    workflow_directory = neutral_root / "workflow"
+    workflow_directory.mkdir(parents=True)
+    test_constants_path = workflow_directory / "test_render_report_constants.py"
+    body = 'UNREFERENCED = "y"\n'
+    test_constants_path.write_text(body, encoding="utf-8")
+    issues = _check(body, str(test_constants_path))
+    assert issues == [], f"Test files are exempt, got: {issues}"

package/hooks/blocking/test_code_rules_enforcer_dispatch_wiring.py

@@ -0,0 +1,82 @@
+"""Meta-test asserting every check_* function is dispatched from validate_content.
+
+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 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; no such checks exist today. The companion ``test_code_rules_enforcer_
+cap_meta.py`` guards the payload-cap convention; this module guards the wiring.
+"""
+
+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_specification = importlib.util.spec_from_file_location(
+    "code_rules_enforcer",
+    _HOOK_DIRECTORY / "code_rules_enforcer.py",
+)
+assert _hook_specification is not None
+assert _hook_specification.loader is not None
+_hook_module = importlib.util.module_from_spec(_hook_specification)
+_hook_specification.loader.exec_module(_hook_module)
+
+KNOWN_UNDISPATCHED_CHECKS: frozenset[str] = frozenset()
+
+
+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 _validate_content_source() -> str:
+    return inspect.getsource(_hook_module.validate_content)
+
+
+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
+    }
+    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."
+    )
+
+
+def test_dead_module_constant_check_stays_wired() -> None:
+    validate_content_source = _validate_content_source()
+    assert "check_dead_module_constants" in validate_content_source, (
+        "check_dead_module_constants must stay dispatched from validate_content so a "
+        "dead exported constant (the MEDIUM_TEXT class) is blocked at Write/Edit time."
+    )
+
+
+def test_known_undispatched_set_lists_only_existing_checks() -> None:
+    all_check_names = set(_all_check_function_names())
+    stale_names = KNOWN_UNDISPATCHED_CHECKS - all_check_names
+    assert stale_names == set(), (
+        f"KNOWN_UNDISPATCHED_CHECKS lists functions that no longer exist: "
+        f"{sorted(stale_names)}. Restore the function or remove it from the set."
+    )