claude-dev-env 1.78.0 → 1.80.0

package/hooks/blocking/test_code_rules_enforcer_module_docstring_data_schema_scope.py

@@ -0,0 +1,82 @@
+"""Tests for check_module_docstring_scope_omits_data_schema_constants (Category O).
+
+A module whose one-line docstring scopes its contents to user-facing text while
+the body also defines serialization field keys, run-metadata schema keys, or
+runtime config under-describes the module — the Category O module-responsibility
+drift. The gate fires only when the docstring claims a user-facing-text scope and
+acknowledges no data-schema or runtime-config category, so broadening the summary
+to name the data-schema keys and runtime config clears it.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+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()
+
+
+def check_scope(content: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_module_docstring_scope_omits_data_schema_constants(
+        content, file_path
+    )
+
+
+PRODUCTION_FILE_PATH = "/project/stp_contrast_fix/config/messages.py"
+TEST_FILE_PATH = "/project/stp_contrast_fix/config/test_messages.py"
+
+USER_FACING_SUMMARY = '"""User-facing strings: CLI flag names, help text, and log messages."""\n'
+DATA_SCHEMA_BODY = (
+    "from typing import Final\n"
+    'CLI_FLAG_EXECUTE: Final[str] = "--execute"\n'
+    'JSONL_FIELD_STP_PATH: Final[str] = "stp_path"\n'
+    'RUN_METADATA_CLI_ARG_KEY_LIMIT: Final[str] = "limit"\n'
+    'STDOUT_ENCODING: Final[str] = "utf-8"\n'
+    'MAIN_LOGGING_FORMAT_STRING: Final[str] = "%(message)s"\n'
+)
+
+
+def test_flags_user_facing_summary_over_data_schema_constants() -> None:
+    issues = check_scope(USER_FACING_SUMMARY + DATA_SCHEMA_BODY, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "JSONL_FIELD_STP_PATH" in issues[0]
+    assert "RUN_METADATA_CLI_ARG_KEY_LIMIT" in issues[0]
+    assert "module-responsibility drift" in issues[0]
+
+
+def test_passes_when_summary_acknowledges_data_schema_scope() -> None:
+    acknowledging_summary = (
+        '"""User-facing strings plus per-theme JSONL field keys, run-metadata '
+        'schema keys, and runtime config."""\n'
+    )
+    assert check_scope(acknowledging_summary + DATA_SCHEMA_BODY, PRODUCTION_FILE_PATH) == []
+
+
+def test_passes_when_module_has_no_data_schema_constants() -> None:
+    strings_only_body = (
+        "from typing import Final\n"
+        'CLI_FLAG_EXECUTE: Final[str] = "--execute"\n'
+        'CLI_FLAG_LIMIT: Final[str] = "--limit"\n'
+    )
+    assert check_scope(USER_FACING_SUMMARY + strings_only_body, PRODUCTION_FILE_PATH) == []
+
+
+def test_passes_when_summary_does_not_claim_user_facing_scope() -> None:
+    non_user_facing_summary = '"""Theme-database column names and SQL templates."""\n'
+    assert check_scope(non_user_facing_summary + DATA_SCHEMA_BODY, PRODUCTION_FILE_PATH) == []
+
+
+def test_test_files_are_exempt() -> None:
+    assert check_scope(USER_FACING_SUMMARY + DATA_SCHEMA_BODY, TEST_FILE_PATH) == []

package/hooks/blocking/test_code_rules_enforcer_paired_test.py

@@ -21,9 +21,15 @@ if str(_BLOCKING_DIRECTORY) not in sys.path:
 
 from code_rules_paired_test import (  # noqa: E402
     check_public_function_missing_paired_test,
+    check_test_file_omits_module_public_function,
 )
 
 _TWO_PUBLIC_FUNCTIONS = "def alpha():\n    return 1\n\n\ndef beta():\n    return 2\n"
+_THREE_PUBLIC_FUNCTIONS = (
+    "def alpha():\n    return 1\n\n\n"
+    "def beta():\n    return 2\n\n\n"
+    "def gamma():\n    return 3\n"
+)
 
 
 @pytest.fixture
@@ -97,6 +103,29 @@ def test_skips_when_suite_covers_no_public_function(
     assert all_issues == []
 
 
+def test_flags_public_surface_when_suite_exercises_only_private_helper(
+    neutral_package_directory: Path,
+) -> None:
+    module_source = (
+        "def _aarrggbb_to_css(value):\n    return value\n\n\n"
+        "def render_table():\n    return _aarrggbb_to_css('x')\n\n\n"
+        "def render_summary():\n    return 2\n"
+    )
+    _write_test_file(
+        neutral_package_directory,
+        "test_mod.py",
+        "from pkg.mod import _aarrggbb_to_css\n\n"
+        "def test_helper():\n    assert _aarrggbb_to_css('x') == 'x'\n",
+    )
+    all_issues = check_public_function_missing_paired_test(
+        module_source, str(neutral_package_directory / "mod.py")
+    )
+    assert len(all_issues) == 2
+    flagged_names = " ".join(all_issues)
+    assert "render_table" in flagged_names
+    assert "render_summary" in flagged_names
+
+
 def test_counts_coverage_across_sibling_test_files(
     neutral_package_directory: Path,
 ) -> None:
@@ -147,3 +176,164 @@ def test_exempts_hook_infrastructure_and_test_paths(
     test_path = str(neutral_package_directory / "tests" / "test_mod.py")
     assert check_public_function_missing_paired_test(_TWO_PUBLIC_FUNCTIONS, hook_path) == []
     assert check_public_function_missing_paired_test(_TWO_PUBLIC_FUNCTIONS, test_path) == []
+
+
+def _write_module(package_directory: Path, body: str) -> None:
+    (package_directory / "mod.py").write_text(body, encoding="utf-8")
+
+
+_SUITE_COVERS_ALPHA_BETA = (
+    "from pkg.mod import alpha, beta\n\n"
+    "def test_pair():\n    assert alpha() == 1 and beta() == 2\n"
+)
+
+
+def test_flags_module_public_function_when_test_suite_omits_it(
+    neutral_package_directory: Path,
+) -> None:
+    _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
+    test_path = str(neutral_package_directory / "tests" / "test_mod.py")
+    all_issues = check_test_file_omits_module_public_function(
+        _SUITE_COVERS_ALPHA_BETA, test_path
+    )
+    assert len(all_issues) == 1
+    assert "gamma" in all_issues[0]
+    assert "mod.py" in all_issues[0]
+    assert "alpha" not in all_issues[0]
+    assert "beta" not in all_issues[0]
+
+
+def test_clean_when_test_suite_covers_every_module_public_function(
+    neutral_package_directory: Path,
+) -> None:
+    _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
+    test_path = str(neutral_package_directory / "tests" / "test_mod.py")
+    suite_covers_all = (
+        "from pkg.mod import alpha, beta, gamma\n\n"
+        "def test_all():\n    assert alpha() and beta() and gamma()\n"
+    )
+    all_issues = check_test_file_omits_module_public_function(suite_covers_all, test_path)
+    assert all_issues == []
+
+
+def test_skips_when_test_suite_covers_no_module_public_function(
+    neutral_package_directory: Path,
+) -> None:
+    _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
+    test_path = str(neutral_package_directory / "tests" / "test_mod.py")
+    all_issues = check_test_file_omits_module_public_function(
+        "def test_unrelated():\n    assert 1 + 1 == 2\n", test_path
+    )
+    assert all_issues == []
+
+
+def test_skips_test_file_with_no_paired_production_module(
+    neutral_package_directory: Path,
+) -> None:
+    test_path = str(neutral_package_directory / "tests" / "test_mod.py")
+    all_issues = check_test_file_omits_module_public_function(
+        _SUITE_COVERS_ALPHA_BETA, test_path
+    )
+    assert all_issues == []
+
+
+def test_ignores_a_non_stem_matched_written_file(
+    neutral_package_directory: Path,
+) -> None:
+    _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
+    helper_path = str(neutral_package_directory / "helper.py")
+    all_issues = check_test_file_omits_module_public_function(
+        _SUITE_COVERS_ALPHA_BETA, helper_path
+    )
+    assert all_issues == []
+
+
+def test_resolves_production_module_beside_the_test_file(
+    neutral_package_directory: Path,
+) -> None:
+    _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
+    beside_test_path = str(neutral_package_directory / "test_mod.py")
+    all_issues = check_test_file_omits_module_public_function(
+        _SUITE_COVERS_ALPHA_BETA, beside_test_path
+    )
+    assert len(all_issues) == 1
+    assert "gamma" in all_issues[0]
+
+
+def test_judges_post_edit_content_over_stale_on_disk_test(
+    neutral_package_directory: Path,
+) -> None:
+    _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
+    _write_test_file(
+        neutral_package_directory,
+        "test_mod.py",
+        _SUITE_COVERS_ALPHA_BETA,
+    )
+    test_path = str(neutral_package_directory / "tests" / "test_mod.py")
+    post_edit_covers_all = (
+        "from pkg.mod import alpha, beta, gamma\n\n"
+        "def test_all():\n    assert alpha() and beta() and gamma()\n"
+    )
+    all_issues = check_test_file_omits_module_public_function(
+        post_edit_covers_all, test_path
+    )
+    assert all_issues == []
+
+
+def test_counts_coverage_across_sibling_test_files_on_test_write(
+    neutral_package_directory: Path,
+) -> None:
+    _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
+    _write_test_file(
+        neutral_package_directory,
+        "test_extra.py",
+        "from pkg.mod import gamma\n\ndef test_gamma():\n    assert gamma() == 3\n",
+    )
+    test_path = str(neutral_package_directory / "tests" / "test_mod.py")
+    all_issues = check_test_file_omits_module_public_function(
+        _SUITE_COVERS_ALPHA_BETA, test_path
+    )
+    assert all_issues == []
+
+
+def test_test_side_message_names_module_and_function_without_line_prefix(
+    neutral_package_directory: Path,
+) -> None:
+    _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
+    test_path = str(neutral_package_directory / "tests" / "test_mod.py")
+    all_issues = check_test_file_omits_module_public_function(
+        _SUITE_COVERS_ALPHA_BETA, test_path
+    )
+    assert len(all_issues) == 1
+    assert not all_issues[0].startswith("Line ")
+    assert "mod.py" in all_issues[0]
+    assert "gamma" in all_issues[0]
+
+
+def test_test_side_omission_blocks_on_any_test_file_edit(
+    neutral_package_directory: Path,
+) -> None:
+    _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
+    test_path = str(neutral_package_directory / "tests" / "test_mod.py")
+    all_issues = check_test_file_omits_module_public_function(
+        _SUITE_COVERS_ALPHA_BETA, test_path
+    )
+    assert len(all_issues) == 1
+    assert "gamma" in all_issues[0]
+
+
+def test_skips_when_paired_production_module_is_exempt(
+    neutral_package_directory: Path,
+) -> None:
+    (neutral_package_directory / "__init__.py").write_text(
+        _THREE_PUBLIC_FUNCTIONS, encoding="utf-8"
+    )
+    beside_test_path = str(neutral_package_directory / "test___init__.py")
+    suite_covers_all = (
+        "from pkg import alpha, beta, gamma\n\n"
+        "def test_all():\n    assert alpha() and beta() and gamma()\n"
+    )
+    all_issues = check_test_file_omits_module_public_function(
+        suite_covers_all, beside_test_path
+    )
+    assert all_issues == []

package/hooks/blocking/test_code_rules_enforcer_polarity_name_contradiction.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+ENFORCER_PATH = Path(__file__).resolve().parent / "code_rules_enforcer.py"
+specification = importlib.util.spec_from_file_location("code_rules_enforcer", ENFORCER_PATH)
+code_rules_enforcer = importlib.util.module_from_spec(specification)
+specification.loader.exec_module(code_rules_enforcer)
+
+PRODUCTION_FILE_PATH = "packages/app/services/foo.py"
+TEST_FILE_PATH = "packages/app/tests/test_foo.py"
+
+
+def test_should_flag_allowed_target_assigned_from_forbidden_callee() -> None:
+    source = (
+        "def offset() -> None:\n"
+        "    is_inside_allowed = _point_hits_any_forbidden(px, py, rects)\n"
+        "    return is_inside_allowed\n"
+    )
+    issues = code_rules_enforcer.check_polarity_name_contradiction(source, PRODUCTION_FILE_PATH)
+    assert any("is_inside_allowed" in each_issue for each_issue in issues), (
+        f"Expected the allowed/forbidden contradiction flagged, got: {issues}"
+    )
+
+
+def test_should_flag_attribute_callee_with_antonym() -> None:
+    source = (
+        "def gate() -> None:\n    is_enabled = self._is_disabled(state)\n    return is_enabled\n"
+    )
+    issues = code_rules_enforcer.check_polarity_name_contradiction(source, PRODUCTION_FILE_PATH)
+    assert any("is_enabled" in each_issue for each_issue in issues), (
+        f"Expected the enabled/disabled contradiction flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_when_callee_polarity_matches_target() -> None:
+    source = (
+        "def gate() -> None:\n"
+        "    is_allowed = _point_inside_any_allowed_rect(px, py, rects)\n"
+        "    return is_allowed\n"
+    )
+    issues = code_rules_enforcer.check_polarity_name_contradiction(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Matching polarity must pass, got: {issues}"
+
+
+def test_should_not_flag_neutral_callee() -> None:
+    source = (
+        "def gate() -> None:\n"
+        "    is_allowed = _point_inside_any_rect(px, py, rects)\n"
+        "    return is_allowed\n"
+    )
+    issues = code_rules_enforcer.check_polarity_name_contradiction(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Neutral callee must pass, got: {issues}"
+
+
+def test_should_not_flag_substring_only_token_match() -> None:
+    source = (
+        "def gate() -> None:\n"
+        "    is_disallowed_count = compute_blocked_total(rects)\n"
+        "    return is_disallowed_count\n"
+    )
+    issues = code_rules_enforcer.check_polarity_name_contradiction(source, PRODUCTION_FILE_PATH)
+    assert issues == [], (
+        f"'disallowed' embeds 'allowed' as a substring, not a whole token; must not flag, got: {issues}"
+    )
+
+
+def test_should_skip_in_test_files() -> None:
+    source = (
+        "def offset() -> None:\n"
+        "    is_inside_allowed = _point_hits_any_forbidden(px, py, rects)\n"
+        "    return is_inside_allowed\n"
+    )
+    issues = code_rules_enforcer.check_polarity_name_contradiction(source, TEST_FILE_PATH)
+    assert issues == [], f"Test files exempt, got: {issues}"

package/hooks/blocking/test_code_rules_enforcer_unused_imports.py

@@ -5,9 +5,12 @@ ALL_REPOSITORY_ROOT_MARKER_FILENAMES, VENV_DIRECTORY_NAME and other
 imports that survived into a PR without ever being referenced.
 
 The detector is intentionally narrow: it only flags `from X import Y`
-or `import X` where Y/X is never referenced in the file body, the file
-does not declare `__all__`, and the file does not use TYPE_CHECKING
-conditional imports. The narrow scope keeps false positives low.
+or `import X` where Y/X is never referenced in the file body and the
+file does not declare `__all__`. A `TYPE_CHECKING` guard block no longer
+exempts the whole file — its guarded imports live nested inside the
+`if TYPE_CHECKING:` node so they are never flag candidates, while a
+genuinely dead top-level runtime import in the same file is still
+flagged. The narrow scope keeps false positives low.
 """
 
 from __future__ import annotations
@@ -102,7 +105,7 @@ def test_should_skip_file_with_dunder_all_annotated_assignment() -> None:
     )
 
 
-def test_should_skip_file_using_type_checking_block() -> None:
+def test_should_flag_dead_top_level_import_in_type_checking_file() -> None:
     source = (
         "from typing import TYPE_CHECKING\n"
         "from hooks_constants.constants import UNUSED_NAME\n"
@@ -114,8 +117,76 @@ def test_should_skip_file_using_type_checking_block() -> None:
         "    return None\n"
     )
     issues = check_unused_module_level_imports(source, PRODUCTION_FILE_PATH)
+    assert any("UNUSED_NAME" in each_issue for each_issue in issues), (
+        "A dead top-level runtime import must be flagged even when the file "
+        f"also declares a TYPE_CHECKING block, got: {issues}"
+    )
+    assert not any("OtherName" in each_issue for each_issue in issues), (
+        "A TYPE_CHECKING-guarded import is nested inside the if block and is "
+        f"never a flag candidate, got: {issues}"
+    )
+
+
+def test_should_not_flag_standard_type_checking_idiom() -> None:
+    source = (
+        "from typing import TYPE_CHECKING\n"
+        "from hooks_constants.constants import RUNTIME_NAME\n"
+        "\n"
+        "if TYPE_CHECKING:\n"
+        "    from somewhere import TypeOnly\n"
+        "\n"
+        "def run(node: TypeOnly) -> None:\n"
+        "    RUNTIME_NAME()\n"
+    )
+    issues = check_unused_module_level_imports(source, PRODUCTION_FILE_PATH)
     assert issues == [], (
-        f"TYPE_CHECKING-using files have annotation-only imports — skip, got: {issues}"
+        "The standard TYPE_CHECKING idiom — TYPE_CHECKING referenced by the "
+        "guard, the runtime import used in the body, and the guarded import "
+        f"used in an annotation — must produce no findings, got: {issues}"
+    )
+
+
+def test_should_flag_dead_import_beside_type_checking_string_annotation() -> None:
+    source = (
+        "from typing import TYPE_CHECKING\n"
+        "from shared_utils.config import portal_specific_timeouts\n"
+        "\n"
+        "if TYPE_CHECKING:\n"
+        "    from shared_utils.base import BaseAutomation\n"
+        "\n"
+        'async def run(automation: "BaseAutomation") -> None:\n'
+        "    return None\n"
+    )
+    issues = check_unused_module_level_imports(source, PRODUCTION_FILE_PATH)
+    assert any("portal_specific_timeouts" in each_issue for each_issue in issues), (
+        "A dead top-level import in a module that guards its annotation-only "
+        f"import under TYPE_CHECKING must still be flagged, got: {issues}"
+    )
+    assert not any("BaseAutomation" in each_issue for each_issue in issues), (
+        "The TYPE_CHECKING-guarded import used in a string annotation must not "
+        f"be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_dead_import_in_workflow_handler_file() -> None:
+    workflow_handler_path = (
+        "shared_utils/web_automation/samsung_portal/workflow/binary/delete_handlers.py"
+    )
+    source = (
+        "from typing import TYPE_CHECKING\n"
+        "from shared_utils.config import portal_specific_timeouts\n"
+        "\n"
+        "if TYPE_CHECKING:\n"
+        "    from shared_utils.base import BaseAutomation\n"
+        "\n"
+        'async def run(automation: "BaseAutomation") -> None:\n'
+        "    return None\n"
+    )
+    issues = check_unused_module_level_imports(source, workflow_handler_path)
+    assert any("portal_specific_timeouts" in each_issue for each_issue in issues), (
+        "A handler file under a workflow/ directory is not a state/module "
+        "registry; a dead import in it must be flagged, not exempted by the "
+        f"workflow path, got: {issues}"
     )
 
 
@@ -364,7 +435,7 @@ def test_should_skip_when_full_file_declares_dunder_all() -> None:
     )
 
 
-def test_should_skip_when_full_file_uses_type_checking_gate() -> None:
+def test_should_flag_dead_fragment_import_when_full_file_uses_type_checking() -> None:
     fragment = "from hooks_constants.constants import NEW_NAME\n"
     full_file = (
         "from typing import TYPE_CHECKING\n"
@@ -379,9 +450,9 @@ def test_should_skip_when_full_file_uses_type_checking_gate() -> None:
     issues = check_unused_module_level_imports(
         fragment, PRODUCTION_FILE_PATH, full_file_content=full_file,
     )
-    assert issues == [], (
-        "TYPE_CHECKING gate in the post-edit file must skip the scan, "
-        f"got: {issues}"
+    assert any("NEW_NAME" in each_issue for each_issue in issues), (
+        "A TYPE_CHECKING block in the post-edit file must not exempt a dead "
+        f"import added by the edit fragment, got: {issues}"
     )
 
 
@@ -472,7 +543,7 @@ def test_should_flag_import_when_only_shadowed_local_name_is_loaded() -> None:
     )
 
 
-def test_should_skip_when_type_checking_uses_imported_alias() -> None:
+def test_should_not_flag_guarded_import_under_imported_type_checking_alias() -> None:
     source = (
         "from typing import TYPE_CHECKING as IS_TYPE_CHECKING\n"
         "from hooks_constants.constants import UNUSED_NAME\n"
@@ -484,12 +555,17 @@ def test_should_skip_when_type_checking_uses_imported_alias() -> None:
         "    return None\n"
     )
     issues = check_unused_module_level_imports(source, PRODUCTION_FILE_PATH)
-    assert issues == [], (
-        f"TYPE_CHECKING imported aliases must skip annotation-only files, got: {issues}"
+    assert not any("OtherName" in each_issue for each_issue in issues), (
+        "An import guarded under an aliased TYPE_CHECKING is nested in the if "
+        f"block and is never a flag candidate, got: {issues}"
+    )
+    assert any("UNUSED_NAME" in each_issue for each_issue in issues), (
+        "A dead top-level import beside an aliased TYPE_CHECKING guard is still "
+        f"flagged, got: {issues}"
     )
 
 
-def test_should_skip_when_type_checking_uses_module_alias() -> None:
+def test_should_not_flag_guarded_import_under_module_type_checking_alias() -> None:
     source = (
         "import typing as t\n"
         "from hooks_constants.constants import UNUSED_NAME\n"
@@ -501,8 +577,13 @@ def test_should_skip_when_type_checking_uses_module_alias() -> None:
         "    return None\n"
     )
     issues = check_unused_module_level_imports(source, PRODUCTION_FILE_PATH)
-    assert issues == [], (
-        f"TYPE_CHECKING module aliases must skip annotation-only files, got: {issues}"
+    assert not any("OtherName" in each_issue for each_issue in issues), (
+        "An import guarded under a module-qualified TYPE_CHECKING is nested in "
+        f"the if block and is never a flag candidate, got: {issues}"
+    )
+    assert any("UNUSED_NAME" in each_issue for each_issue in issues), (
+        "A dead top-level import beside a module-qualified TYPE_CHECKING guard "
+        f"is still flagged, got: {issues}"
     )
 
 

package/hooks/blocking/test_code_rules_enforcer_vacuous_cleanup_assertion.py

@@ -0,0 +1,132 @@
+"""Tests for vacuous cleanup-on-failure assertion detection.
+
+A cleanup-on-failure test that asserts no leftover temp file is left behind,
+yet never proves the temp file was created, passes vacuously: the assertion
+holds even when the on-failure cleanup is entirely broken. The gate flags that
+shape so the author arranges a post-creation failure and asserts real removal.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+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()
+
+TEST_FILE_PATH = "packages/app/tests/test_archive_rewrite.py"
+PRODUCTION_FILE_PATH = "packages/app/services/archive_rewrite.py"
+
+
+def test_should_flag_glob_emptiness_cleanup_test_without_temp_creation() -> None:
+    source = (
+        "def test_rewrite_removes_tmp_file_on_failure(tmp_path: Path) -> None:\n"
+        "    stp_path = build_corrupt_stp(stp_path=tmp_path / 'corrupt.stp')\n"
+        "    rewrite_properties_xml_atomically(stp_path=stp_path, patched='<x/>')\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert len(all_tmp_siblings) == 0\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert any("vacuous" in issue.lower() for issue in issues), (
+        f"Expected a vacuous-cleanup issue, got: {issues}"
+    )
+
+
+def test_should_not_flag_when_post_creation_failure_is_arranged() -> None:
+    source = (
+        "def test_rewrite_removes_tmp_file_on_replace_failure(tmp_path, monkeypatch)"
+        " -> None:\n"
+        "    stp_path = build_valid_stp(stp_path=tmp_path / 'theme.stp')\n"
+        "    monkeypatch.setattr(os, 'replace', _raise_oserror)\n"
+        "    rewrite_properties_xml_atomically(stp_path=stp_path, patched='<x/>')\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert len(all_tmp_siblings) == 0\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issue when failure is arranged, got: {issues}"
+
+
+def test_should_not_flag_when_temp_existence_is_proven_first() -> None:
+    source = (
+        "def test_cleanup_removes_temp_on_failure(tmp_path: Path) -> None:\n"
+        "    temporary_path = tmp_path / 'theme.stp.tmp'\n"
+        "    temporary_path.write_bytes(b'partial')\n"
+        "    assert temporary_path.exists()\n"
+        "    run_cleanup_after_failure(temporary_path)\n"
+        "    assert not list(tmp_path.glob('*.tmp'))\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issue when temp existence proven, got: {issues}"
+
+
+def test_should_not_flag_success_named_cleanup_assertion() -> None:
+    source = (
+        "def test_rewrite_leaves_no_tmp_sibling_on_success(tmp_path: Path) -> None:\n"
+        "    stp_path = build_valid_stp(stp_path=tmp_path / 'theme.stp')\n"
+        "    rewrite_properties_xml_atomically(stp_path=stp_path, patched='<x/>')\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert len(all_tmp_siblings) == 0\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issue for a success-named test, got: {issues}"
+
+
+def test_should_not_flag_failure_test_asserting_real_behavior() -> None:
+    source = (
+        "def test_rewrite_reports_cleanup_failure_on_directory_tmp("
+        "tmp_path: Path) -> None:\n"
+        "    temporary_path = tmp_path / 'theme.stp.tmp'\n"
+        "    temporary_path.mkdir()\n"
+        "    write_outcome = rewrite_properties_xml_atomically("
+        "stp_path=tmp_path / 't.stp', patched='<x/>')\n"
+        "    assert write_outcome.temporary_cleanup_error_message is not None\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issue for a behavior assertion, got: {issues}"
+
+
+def test_should_not_flag_mixed_assertion_cleanup_test() -> None:
+    source = (
+        "def test_rewrite_removes_tmp_and_reports_failure(tmp_path: Path) -> None:\n"
+        "    stp_path = build_corrupt_stp(stp_path=tmp_path / 'corrupt.stp')\n"
+        "    write_outcome = rewrite_properties_xml_atomically("
+        "stp_path=stp_path, patched='<x/>')\n"
+        "    assert write_outcome.is_write_successful is False\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert len(all_tmp_siblings) == 0\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issue for a mixed-assertion test, got: {issues}"
+
+
+def test_should_not_flag_in_production_files() -> None:
+    source = (
+        "def test_rewrite_removes_tmp_file_on_failure(tmp_path: Path) -> None:\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert len(all_tmp_siblings) == 0\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Expected no issue in a production file, got: {issues}"
+
+
+def test_should_include_line_number_in_issue() -> None:
+    source = (
+        "def test_rewrite_removes_tmp_file_on_failure(tmp_path: Path) -> None:\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert all_tmp_siblings == []\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert any("Line 1" in issue for issue in issues), (
+        f"Expected a line number in the issue, got: {issues}"
+    )