claude-dev-env 2.30.1 → 2.31.1

package/hooks/validators/test_directory_exemption_constants.py

@@ -8,8 +8,6 @@ from __future__ import annotations
 
 from pathlib import Path
 
-import pytest
-
 from hooks_constants.code_rules_enforcer_constants import ALL_CLI_FILE_PATH_MARKERS
 from hooks_constants.code_rules_path_utils_constants import ALL_CONFIG_DIRECTORY_NAMES
 from validators.config.directory_exemption_constants import (
@@ -19,6 +17,7 @@ from validators.config.directory_exemption_constants import (
     all_directory_segments_in_path_pattern,
     directory_segment_names_from_path_patterns,
     is_filename_like_path_segment,
+    is_pytest_scratch_directory_segment,
     substring_patterns_from_path_patterns,
 )
 from validators.exempt_paths import (
@@ -36,6 +35,9 @@ ALL_SYNTHETIC_DIRECTORY_PATTERNS = frozenset(
     {"/foo/", "\\bar\\", "/baz.py", "plain", "/.hidden/qux/"}
 )
 ALL_EXPECTED_SYNTHETIC_SEGMENTS = frozenset({"foo", "bar", ".hidden", "qux"})
+OVER_LONG_STEM_DIRECTORY_NAME = "test_helpers_for_a_very_long_domain_name0"
+PROJECT_ROOTED_BASETEMP_PATH = "/srv/projects/scratch-basetemp"
+PYTEST_SCRATCH_DIRECTORY_NAME = "test_edit_introducing_new_viol0"
 
 
 def test_is_filename_like_path_segment_detects_extensions() -> None:
@@ -45,6 +47,21 @@ def test_is_filename_like_path_segment_detects_extensions() -> None:
     assert is_filename_like_path_segment(".claude") is False
 
 
+def test_is_pytest_scratch_directory_segment_detects_numbered_test_directories() -> None:
+    assert is_pytest_scratch_directory_segment("test_drops_leading_anchor0") is True
+    assert is_pytest_scratch_directory_segment("test_edit_introducing_new_viol0") is True
+    assert is_pytest_scratch_directory_segment("pytest-of-root") is True
+    assert is_pytest_scratch_directory_segment("pytest-9") is True
+
+
+def test_is_pytest_scratch_directory_segment_keeps_real_project_directories() -> None:
+    assert is_pytest_scratch_directory_segment("test_helpers") is False
+    assert is_pytest_scratch_directory_segment("tests") is False
+    assert is_pytest_scratch_directory_segment("scripts") is False
+    assert is_pytest_scratch_directory_segment("conftest") is False
+    assert is_pytest_scratch_directory_segment(OVER_LONG_STEM_DIRECTORY_NAME) is False
+
+
 def test_all_directory_segments_in_path_pattern_keeps_directory_tokens_only() -> None:
     assert all_directory_segments_in_path_pattern("/.claude/hooks/") == [
         ".claude",
@@ -136,32 +153,21 @@ def test_absolute_system_temp_pytest_shaped_path_stages_flat_basename(
     assert staged_path == staging_root / "legacy_module.py"
 
 
-def test_runner_temp_pytest_shaped_path_stages_flat_basename_when_gettempdir_differs(
+def test_pytest_shaped_path_stages_flat_basename_under_every_basetemp_placement(
     tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    """GHA basetemp lives under RUNNER_TEMP while gettempdir is often /tmp."""
-    runner_temp_root = tmp_path / "runner_temp"
-    os_gettemp = tmp_path / "os_gettemp"
-    runner_temp_root.mkdir()
-    os_gettemp.mkdir()
-    monkeypatch.setenv("RUNNER_TEMP", str(runner_temp_root))
-    monkeypatch.setattr(
-        "validators.system_temporary_roots.tempfile.gettempdir",
-        lambda: str(os_gettemp),
-    )
-    pytest_shaped_target = (
-        runner_temp_root
-        / "pytest-basetemp-pkg"
-        / "test_edit_introducing_new_viol0"
-        / "legacy_module.py"
-    )
+    """A ``--basetemp`` outside every temp root must not change the staged path."""
     staging_root = tmp_path / "staging_root"
     staging_root.mkdir()
-    staged_path = _temporary_path_preserving_directory_signal(
-        staging_root, str(pytest_shaped_target)
-    )
-    assert staged_path == staging_root / "legacy_module.py"
+    all_basetemp_roots = (tmp_path, Path(PROJECT_ROOTED_BASETEMP_PATH))
+    all_staged_paths = {
+        _temporary_path_preserving_directory_signal(
+            staging_root,
+            str(each_root / PYTEST_SCRATCH_DIRECTORY_NAME / "legacy_module.py"),
+        )
+        for each_root in all_basetemp_roots
+    }
+    assert all_staged_paths == {staging_root / "legacy_module.py"}
 
 
 def test_substring_patterns_from_path_patterns_skips_directory_tokens() -> None:

package/hooks/validators/test_fast_save_validators.py

@@ -0,0 +1,172 @@
+"""Tests for fast_save_validators.py -- the in-process save-path validator roster."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from .fast_save_validators import run_fast_save_validators
+from .magic_value_checks import validate_file as read_magic_literal_violations
+from .react_checks import check_no_class_components
+from .test_safety_checks import check_no_skip_decorators
+from .todo_checks import validate_file as read_todo_violations
+
+MAGIC_LITERAL_SOURCE = "def compute_total(unit_price: int) -> int:\n    return unit_price * 199\n"
+_UNTRACKED_TODO_MARKER = "#" + " TODO"
+TODO_SOURCE = f"{_UNTRACKED_TODO_MARKER}: revisit this\ndef clean() -> None:\n    return None\n"
+REACT_CLASS_COMPONENT_SOURCE = "class Widget extends Component {\n  render() { return null; }\n}\n"
+TEST_SKIP_DECORATOR_SOURCE = (
+    "import pytest\n\n\n@pytest.mark.skip\ndef test_something() -> None:\n    pass\n"
+)
+
+_ALL_EXPECTED_FAST_SAVE_VALIDATOR_NAMES = frozenset(
+    {
+        "Python Style",
+        "Abbreviations",
+        "Magic Values",
+        "TODO Tracking",
+        "Security",
+        "Code Quality",
+        "Python Anti-patterns",
+        "Type Safety",
+        "Test Safety",
+        "Useless Tests",
+        "React",
+        "PR References",
+    }
+)
+
+
+def test_run_fast_save_validators_covers_every_non_mypy_non_ruff_check(
+    tmp_path: Path,
+) -> None:
+    target_file = tmp_path / "legacy_module.py"
+    target_file.write_text(MAGIC_LITERAL_SOURCE, encoding="utf-8")
+
+    all_outcomes = run_fast_save_validators([target_file])
+
+    assert {each_outcome.name for each_outcome in all_outcomes} == (
+        _ALL_EXPECTED_FAST_SAVE_VALIDATOR_NAMES
+    )
+
+
+def test_run_fast_save_validators_excludes_mypy_and_ruff(tmp_path: Path) -> None:
+    target_file = tmp_path / "legacy_module.py"
+    target_file.write_text(MAGIC_LITERAL_SOURCE, encoding="utf-8")
+
+    all_outcomes = run_fast_save_validators([target_file])
+
+    assert all(each_outcome.name != "Mypy" for each_outcome in all_outcomes)
+    assert all(each_outcome.name != "Ruff" for each_outcome in all_outcomes)
+
+
+def test_run_fast_save_validators_spawns_no_subprocess(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    target_file = tmp_path / "legacy_module.py"
+    target_file.write_text(MAGIC_LITERAL_SOURCE, encoding="utf-8")
+
+    def _fail_if_called(*args: object, **kwargs: object) -> None:
+        raise AssertionError("run_fast_save_validators must not spawn a subprocess")
+
+    monkeypatch.setattr("subprocess.run", _fail_if_called)
+
+    run_fast_save_validators([target_file])
+
+
+def test_magic_values_outcome_matches_direct_validate_file_call(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    # A directory with no "test_"-patterned segment: magic_value_checks exempts
+    # any path under one, which pytest's own tmp_path always carries (tmp_path
+    # names itself "test_<function name><N>"). tmp_path's own parent carries no
+    # such segment. Routing TMPDIR there through monkeypatch, and also passing
+    # it as TemporaryDirectory's own ``dir``, keeps the probe from depending on
+    # whatever the real process environment happens to hold.
+    isolated_root = tmp_path.parent
+    monkeypatch.setenv("TMPDIR", str(isolated_root))
+    with tempfile.TemporaryDirectory(
+        dir=str(isolated_root), prefix="fast_save_probe_"
+    ) as workspace_name:
+        target_file = Path(workspace_name) / "legacy_module.py"
+        target_file.write_text(MAGIC_LITERAL_SOURCE, encoding="utf-8")
+        expected_lines = [
+            str(each) for each in read_magic_literal_violations(target_file)
+        ]
+        assert expected_lines != []
+
+        all_outcomes = run_fast_save_validators([target_file])
+
+    magic_values_outcome = next(
+        each for each in all_outcomes if each.name == "Magic Values"
+    )
+    assert magic_values_outcome.output == "\n".join(expected_lines)
+
+
+def test_todo_outcome_matches_direct_validate_file_call(tmp_path: Path) -> None:
+    target_file = tmp_path / "legacy_module.py"
+    target_file.write_text(TODO_SOURCE, encoding="utf-8")
+    expected_lines = [str(each) for each in read_todo_violations(target_file)]
+    assert expected_lines != []
+
+    all_outcomes = run_fast_save_validators([target_file])
+
+    todo_outcome = next(each for each in all_outcomes if each.name == "TODO Tracking")
+    assert todo_outcome.output == "\n".join(expected_lines)
+
+
+def test_abbreviations_outcome_reports_clean_for_a_clean_file(tmp_path: Path) -> None:
+    target_file = tmp_path / "legacy_module.py"
+    target_file.write_text(
+        "def add_two_numbers(first: int, second: int) -> int:\n    return first + second\n",
+        encoding="utf-8",
+    )
+
+    all_outcomes = run_fast_save_validators([target_file])
+
+    abbreviations_outcome = next(
+        each for each in all_outcomes if each.name == "Abbreviations"
+    )
+    assert abbreviations_outcome.passed is True
+
+
+def test_react_outcome_matches_direct_check_function_call(tmp_path: Path) -> None:
+    target_file = tmp_path / "widget.tsx"
+    target_file.write_text(REACT_CLASS_COMPONENT_SOURCE, encoding="utf-8")
+    expected_violations = check_no_class_components([str(target_file)])
+    expected_lines = [f"{each.file}:{each.line}: {each.message}" for each in expected_violations]
+    assert expected_lines != []
+
+    all_outcomes = run_fast_save_validators([target_file])
+
+    react_outcome = next(each for each in all_outcomes if each.name == "React")
+    assert react_outcome.output == "\n".join(expected_lines)
+
+
+def test_test_safety_outcome_matches_direct_check_function_calls(
+    tmp_path: Path,
+) -> None:
+    target_file = tmp_path / "test_something.py"
+    target_file.write_text(TEST_SKIP_DECORATOR_SOURCE, encoding="utf-8")
+    code = target_file.read_text(encoding="utf-8")
+    expected_violations = check_no_skip_decorators(code, str(target_file))
+    expected_lines = [str(each) for each in expected_violations]
+    assert expected_lines != []
+
+    all_outcomes = run_fast_save_validators([target_file])
+
+    test_safety_outcome = next(each for each in all_outcomes if each.name == "Test Safety")
+    assert test_safety_outcome.output == "\n".join(expected_lines)
+
+
+def test_no_matching_files_reports_configured_message(tmp_path: Path) -> None:
+    target_file = tmp_path / "widget.tsx"
+    target_file.write_text("export const Widget = () => null;\n", encoding="utf-8")
+
+    all_outcomes = run_fast_save_validators([target_file])
+
+    abbreviations_outcome = next(
+        each for each in all_outcomes if each.name == "Abbreviations"
+    )
+    assert abbreviations_outcome.passed is True
+    assert abbreviations_outcome.output == "No Python files to check"

package/hooks/validators/test_hook_timing_harness.py

@@ -106,8 +106,16 @@ def test_ensure_real_repository_target_accepts_a_repo_file_under_the_os_temp_roo
 
 
 def test_ensure_real_repository_target_refuses_a_scratch_path_outside_the_repository_root(
-    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
+    """The refusal is under test, so this pins the temp root it is judged against.
+
+    ``--basetemp`` places ``tmp_path`` wherever the caller asks, so a run that
+    points it outside the OS temp root leaves the scratch target real and this
+    assertion measures the caller's flags. Naming the root here keeps the
+    subject of the test inside the test.
+    """
+    monkeypatch.setattr(tempfile, "gettempdir", lambda: str(tmp_path))
     repository_root = tmp_path / "repo"
     repository_root.mkdir()
     scratch_target = tmp_path / "scratch.py"
@@ -194,6 +202,7 @@ def test_measure_hosted_command_wall_times_honors_a_repository_root_override(
     gap the wrapper-plumb-through check caught.
     """
     monkeypatch.setattr(hook_timing_harness, "write_edit_hook_commands", lambda path: [])
+    monkeypatch.setattr(tempfile, "gettempdir", lambda: str(tmp_path))
     repository_root = tmp_path / "repo"
     real_file = repository_root / "hooks" / "blocking" / "code_rules_shared.py"
     real_file.parent.mkdir(parents=True)

package/hooks/validators/test_python_style_checks.py

@@ -197,6 +197,15 @@ class TestImportsAtTop:
         assert len(violations) == 1
         assert "inside function" in violations[0].message.lower()
 
+    def test_sys_path_bootstrap_guard_does_not_fail(self) -> None:
+        """The mandated sys.path dedup-guard idiom should not fail (see test_python_style_import_bootstrap.py)."""
+        tree = ast.parse(
+            "import sys\n_hooks_dir = str(__file__)\n"
+            "if _hooks_dir not in sys.path:\n    sys.path.insert(0, _hooks_dir)\n"
+            "from hooks_constants.something import NAME  # noqa: E402\n"
+        )
+        assert check_imports_at_top(tree, "test.py") == []
+
 
 class TestNoEmptyLineAfterDecorators:
     """Test decorator spacing validation."""

package/hooks/validators/test_python_style_checks_import_order.py

@@ -0,0 +1,81 @@
+"""Tests for the sys.path bootstrap-guard idiom in the import-order check.
+
+Split from ``test_python_style_checks.py`` to stay under its line cap,
+matching the existing ``test_python_style_checks_decorator_gap.py`` split.
+"""
+
+import ast
+from pathlib import Path
+
+from .python_style_checks import check_imports_at_top
+
+SYS_PATH_BOOTSTRAP_GUARD_IMPORTS = """import sys
+from pathlib import Path
+
+_hooks_dir = str(Path(__file__).resolve().parent.parent)
+if _hooks_dir not in sys.path:
+    sys.path.insert(0, _hooks_dir)
+
+from hooks_constants.something import NAME  # noqa: E402
+"""
+
+TWO_SYS_PATH_BOOTSTRAP_GUARD_BLOCKS = """import sys
+from pathlib import Path
+
+_first_dir = str(Path(__file__).resolve().parent)
+if _first_dir not in sys.path:
+    sys.path.insert(0, _first_dir)
+
+from hooks_constants.first import FIRST_NAME  # noqa: E402
+
+_second_dir = str(Path(__file__).resolve().parent.parent)
+if _second_dir not in sys.path:
+    sys.path.insert(0, _second_dir)
+
+from hooks_constants.second import SECOND_NAME  # noqa: E402
+"""
+
+UNGUARDED_SYS_PATH_INSERT_THEN_IMPORT = """import sys
+
+sys.path.insert(0, "/some/hooks/dir")
+
+import os
+"""
+
+
+class TestSysPathBootstrapGuardImportOrder:
+    """Tests pinning the sys.path bootstrap-guard exemption in import ordering."""
+
+    def test_sys_path_bootstrap_guard_passes(self) -> None:
+        """The mandated dedup-guard idiom must not flag its own import."""
+        tree = ast.parse(SYS_PATH_BOOTSTRAP_GUARD_IMPORTS)
+        violations = check_imports_at_top(tree, "test.py")
+        assert violations == []
+
+    def test_two_sys_path_bootstrap_guard_blocks_pass(self) -> None:
+        """Two separate bootstrap-guard blocks in one file both pass."""
+        tree = ast.parse(TWO_SYS_PATH_BOOTSTRAP_GUARD_BLOCKS)
+        violations = check_imports_at_top(tree, "test.py")
+        assert violations == []
+
+    def test_unguarded_sys_path_insert_still_fails(self) -> None:
+        """A bare sys.path.insert with no membership guard still counts as ordinary code.
+
+        Only the guarded idiom `check_sys_path_insert_deduplication_guard`
+        mandates is exempt. An unguarded insert is itself a violation of that
+        same guard, so an import after it stays flagged rather than rewarding
+        the shape the other gate penalizes.
+        """
+        tree = ast.parse(UNGUARDED_SYS_PATH_INSERT_THEN_IMPORT)
+        violations = check_imports_at_top(tree, "test.py")
+        assert len(violations) == 1
+        assert violations[0].line == 5
+
+    def test_code_rules_enforcer_bootstrap_produces_no_findings(self) -> None:
+        """The enforcer's own real bootstrap block goes from 29 findings to 0."""
+        enforcer_path = (
+            Path(__file__).resolve().parent.parent / "blocking" / "code_rules_enforcer.py"
+        )
+        tree = ast.parse(enforcer_path.read_text(encoding="utf-8"))
+        violations = check_imports_at_top(tree, str(enforcer_path))
+        assert violations == []

package/hooks/validators/test_python_style_helpers.py

@@ -6,11 +6,18 @@ from .python_style_helpers import (
     blank_line_for_source,
     function_start_line,
     gap_is_blank_only,
+    is_docstring_statement,
+    is_import_statement,
     iter_function_definitions,
     real_newline_lines,
     top_level_functions,
 )
 
+
+def _first_statement(source: str) -> ast.stmt:
+    """Return the first top-level statement of *source*."""
+    return ast.parse(source).body[0]
+
 TWO_FUNCTIONS = """def foo() -> None:
     pass
 
@@ -123,3 +130,31 @@ class TestBlankLineForSource:
     def test_crlf_source_returns_crlf(self) -> None:
         """CRLF source yields a CRLF blank line."""
         assert blank_line_for_source(CRLF_SOURCE) == "\r\n"
+
+
+class TestIsImportStatement:
+    """Tests pinning which statements the import-order scan treats as imports."""
+
+    def test_import_statement_is_recognized(self) -> None:
+        """A plain `import` statement is recognized."""
+        assert is_import_statement(_first_statement("import os\n")) is True
+
+    def test_from_import_statement_is_recognized(self) -> None:
+        """A `from ... import ...` statement is recognized."""
+        assert is_import_statement(_first_statement("from os import path\n")) is True
+
+    def test_assignment_is_not_an_import_statement(self) -> None:
+        """An assignment is not treated as an import."""
+        assert is_import_statement(_first_statement("X = 1\n")) is False
+
+
+class TestIsDocstringStatement:
+    """Tests pinning which statements the import-order scan treats as docstrings."""
+
+    def test_leading_string_literal_is_a_docstring(self) -> None:
+        """A bare string-literal expression statement is a docstring."""
+        assert is_docstring_statement(_first_statement('"""A module docstring."""\n')) is True
+
+    def test_assignment_is_not_a_docstring(self) -> None:
+        """An assignment is not a docstring, even with a string value."""
+        assert is_docstring_statement(_first_statement('X = "not a docstring"\n')) is False

package/hooks/validators/test_python_style_import_bootstrap.py

@@ -0,0 +1,69 @@
+"""Tests for the sys.path bootstrap-guard idiom recognizer."""
+
+import ast
+
+from .python_style_import_bootstrap import is_sys_path_bootstrap_prelude
+
+
+def _module_body(source: str) -> list[ast.stmt]:
+    """Return the top-level statements of *source* for use as a pending run."""
+    return ast.parse(source).body
+
+
+class TestIsSysPathBootstrapPrelude:
+    """Tests pinning which statement runs qualify as the bootstrap prelude."""
+
+    def test_empty_run_is_not_a_prelude(self) -> None:
+        """An empty run carries no guard, so it is not the bootstrap idiom."""
+        assert is_sys_path_bootstrap_prelude([]) is False
+
+    def test_guard_alone_is_a_prelude(self) -> None:
+        """A bare guarded insert, with no preceding assignment, still counts."""
+        body = _module_body(
+            'if "/some/dir" not in sys.path:\n    sys.path.insert(0, "/some/dir")\n'
+        )
+        assert is_sys_path_bootstrap_prelude(body) is True
+
+    def test_assignment_feeding_guard_is_a_prelude(self) -> None:
+        """The mandated `path = ...` plus guarded insert pair passes."""
+        body = _module_body(
+            "_hooks_dir = str(Path(__file__).resolve().parent)\n"
+            "if _hooks_dir not in sys.path:\n"
+            "    sys.path.insert(0, _hooks_dir)\n"
+        )
+        assert is_sys_path_bootstrap_prelude(body) is True
+
+    def test_unrelated_trailing_constant_stays_a_prelude(self) -> None:
+        """A plain constant sitting alongside a real guard does not break it.
+
+        Mirrors code_rules_enforcer.py's own bootstrap block, which tucks an
+        unrelated `_codex_apply_patch_tool_name = "apply_patch"` constant
+        right after its guarded sys.path.insert calls.
+        """
+        body = _module_body(
+            "_hooks_dir = str(Path(__file__).resolve().parent)\n"
+            "if _hooks_dir not in sys.path:\n"
+            "    sys.path.insert(0, _hooks_dir)\n"
+            '_codex_apply_patch_tool_name = "apply_patch"\n'
+        )
+        assert is_sys_path_bootstrap_prelude(body) is True
+
+    def test_plain_assignments_with_no_guard_are_not_a_prelude(self) -> None:
+        """Assignments alone, with no guard anywhere, are ordinary code."""
+        body = _module_body("MY_CONSTANT = 42\n")
+        assert is_sys_path_bootstrap_prelude(body) is False
+
+    def test_unguarded_insert_is_not_a_prelude(self) -> None:
+        """A bare sys.path.insert with no membership guard is ordinary code."""
+        body = _module_body('sys.path.insert(0, "/some/dir")\n')
+        assert is_sys_path_bootstrap_prelude(body) is False
+
+    def test_guard_alongside_a_function_def_is_not_a_prelude(self) -> None:
+        """A real statement (a function def) in the run still counts as ordinary code."""
+        body = _module_body(
+            'if "/some/dir" not in sys.path:\n'
+            '    sys.path.insert(0, "/some/dir")\n'
+            "def foo() -> None:\n"
+            "    pass\n"
+        )
+        assert is_sys_path_bootstrap_prelude(body) is False

package/hooks/validators/test_run_all_validators.py

@@ -31,6 +31,10 @@ _ASSERT_FALSE_SOURCE = (
     "    assert False, observed_total\n"
 )
 PRINT_PRODUCTION_CONTENT = 'def run() -> None:\n    print("x")\n'
+CLEAN_PROBE_SOURCE = (
+    "def add_two_numbers(first_number: int, second_number: int) -> int:\n"
+    "    return first_number + second_number\n"
+)
 ALL_PYTHON_TEST_EXEMPT_PATHS = [
     "pkg/test_helpers/worker.py",
     "pkg/conftest.py",
@@ -66,6 +70,48 @@ def test_validate_proposed_file_threads_ruff_config_from_original_path() -> None
     assert "B011" in ruff_output
 
 
+def test_validate_proposed_file_never_probes_mypy_availability() -> None:
+    """The save-path gate drops Mypy entirely; it must not even probe for it.
+
+    Mypy runs 500-1800ms cold, the largest single item on the save path by a
+    wide margin (see hooks/validators/hook_timing_harness.py). CLI/full mode
+    keeps probing it; only the save-path gate skips the probe.
+    """
+    with patch("validators.run_all_validators.check_mypy_available") as mock_check_mypy:
+        validate_proposed_file(
+            str(_VALIDATORS_DIRECTORY / "probe_target.py"), CLEAN_PROBE_SOURCE
+        )
+
+    mock_check_mypy.assert_not_called()
+
+
+def test_validate_proposed_file_never_spawns_a_validator_subprocess() -> None:
+    """The save-path gate must not spawn a ``python -m validators.<module>`` per check.
+
+    Twelve validator subprocesses cost roughly 600ms in interpreter startup
+    and import alone (see hook_timing_harness.py), for checks that measure in
+    single digits once running. CLI/full mode keeps spawning one process per
+    validator; only the save-path gate runs them in-process instead.
+    """
+    with patch("validators.run_all_validators.invoke_validator_module") as mock_invoke:
+        validate_proposed_file(
+            str(_VALIDATORS_DIRECTORY / "probe_target.py"), CLEAN_PROBE_SOURCE
+        )
+
+    mock_invoke.assert_not_called()
+
+
+def test_validate_proposed_file_still_finds_a_fast_path_violation() -> None:
+    """Dropping mypy and the per-validator subprocess must not blind the gate."""
+    all_results = validate_proposed_file(
+        str(_VALIDATORS_DIRECTORY / "probe_target.py"), PRINT_PRODUCTION_CONTENT
+    )
+
+    failed_names = {each_result.name for each_result in all_results if not each_result.passed}
+    assert failed_names, "expected at least one failing fast-path check"
+    assert "Mypy" not in failed_names
+
+
 def _validators_deny_print(file_path: str) -> bool:
     all_results = validate_proposed_file(file_path, PRINT_PRODUCTION_CONTENT)
     return any(not each_result.passed for each_result in all_results)