claude-dev-env 2.17.0 → 2.19.0

package/hooks/blocking/code_rules_enforcer_test_support.py

@@ -0,0 +1,92 @@
+"""Shared entrypoint helpers for code-rules enforcer behavior tests."""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+import subprocess
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+
+_ENFORCER_SCRIPT_PATH = Path(__file__).with_name("code_rules_enforcer.py")
+
+
+def build_write_payload(file_path: str, content: str) -> str:
+    """Build the JSON payload sent by a Write tool call."""
+    return json.dumps(
+        {
+            "tool_name": "Write",
+            "tool_input": {"file_path": file_path, "content": content},
+        }
+    )
+
+
+def run_serialized_payload_entrypoint(
+    entrypoint: Callable[[list[str]], None],
+    serialized_payload: str,
+) -> tuple[str, int | None]:
+    """Run a callable hook entrypoint with a serialized stdin payload."""
+    input_stream = io.StringIO(serialized_payload)
+    captured_stream = io.StringIO()
+    original_stdin = sys.stdin
+    original_stdout = sys.stdout
+    exit_code: int | None = None
+    try:
+        sys.stdin = input_stream
+        sys.stdout = captured_stream
+        entrypoint([])
+    except SystemExit as each_exit:
+        raw_code = each_exit.code
+        exit_code = raw_code if isinstance(raw_code, int) else None
+    finally:
+        sys.stdin = original_stdin
+        sys.stdout = original_stdout
+    return captured_stream.getvalue(), exit_code
+
+
+def run_write_entrypoint(
+    entrypoint: Callable[[list[str]], None],
+    file_path: str,
+    content: str,
+) -> tuple[str, int]:
+    """Drive a real hook entrypoint with a Write payload and capture stdout."""
+    captured_stdout, exit_code = run_serialized_payload_entrypoint(
+        entrypoint, build_write_payload(file_path, content)
+    )
+    return captured_stdout, int(exit_code or 0)
+
+
+def run_enforcer_cli(
+    script_path: Path,
+    all_arguments: list[str],
+    extra_environment_by_name: dict[str, str] | None,
+) -> subprocess.CompletedProcess[str]:
+    """Run an enforcer script through its real command-line entrypoint."""
+    subprocess_environment: dict[str, str] | None = None
+    if extra_environment_by_name is not None:
+        subprocess_environment = os.environ.copy()
+        subprocess_environment.update(extra_environment_by_name)
+    return subprocess.run(
+        [sys.executable, str(script_path), *all_arguments],
+        stdin=subprocess.DEVNULL,
+        capture_output=True,
+        text=True,
+        check=False,
+        env=subprocess_environment,
+    )
+
+
+def run_precheck(
+    candidate_path: Path,
+    target_path: str,
+    extra_environment_by_name: dict[str, str] | None,
+) -> subprocess.CompletedProcess[str]:
+    """Run an enforcer script through its real precheck command."""
+    return run_enforcer_cli(
+        _ENFORCER_SCRIPT_PATH,
+        ["--check", str(candidate_path), "--as", target_path],
+        extra_environment_by_name,
+    )

package/hooks/blocking/destructive_command_blocker.py

@@ -20,12 +20,16 @@ from hooks_constants.convergence_branch_constants import (  # noqa: E402
     CONVERGENCE_FORCE_PUSH_DETECTION_PATTERN,
 )
 from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-from hooks_constants.destructive_command_segment_constants import (  # noqa: E402
-    ALL_BENIGN_COMPOUND_SEGMENT_COMMANDS,
-    ALL_COMMAND_LAUNCHER_WRAPPER_COMMANDS,
+from hooks_constants.destructive_command_environment_constants import (  # noqa: E402
     ALL_KNOWN_TEMPORARY_ENVIRONMENT_VARIABLE_NAMES,
     ALL_TRUTHY_ENV_VALUES,
     DESTRUCTIVE_DENY_MODE_ENV_VAR,
+    EPHEMERAL_AUTO_ALLOW_DISABLE_ENV_VAR,
+    GH_REDIRECT_ACTIVE_ENV_VAR,
+)
+from hooks_constants.destructive_command_segment_constants import (  # noqa: E402
+    ALL_BENIGN_COMPOUND_SEGMENT_COMMANDS,
+    ALL_COMMAND_LAUNCHER_WRAPPER_COMMANDS,
     ALL_FILE_WRITING_OUTPUT_FLAGS_BY_BENIGN_PROGRAM,
     ALL_FIND_EXEC_ACTION_FLAGS,
     ALL_FIND_EXEC_ACTION_TERMINATORS,
@@ -57,7 +61,6 @@ from hooks_constants.destructive_command_segment_constants import (  # noqa: E40
 )
 
 CLAUDE_DIRECTORY_PATH = os.path.normpath(os.path.expanduser("~/.claude"))
-GH_REDIRECT_ACTIVE_ENV_VAR = "CLAUDE_GH_REDIRECT_ACTIVE"
 
 
 def gh_redirect_is_active() -> bool:
@@ -87,9 +90,7 @@ def directory_is_ephemeral(directory_path: str) -> bool:
     Returns:
         True when the directory belongs to the ephemeral auto-allow namespace.
     """
-    ephemeral_auto_allow_disabled_env_var = "CLAUDE_DESTRUCTIVE_DISABLE_EPHEMERAL_AUTO_ALLOW"
-    truthy_string_values = frozenset({"1", "true", "yes", "on"})
-    if os.environ.get(ephemeral_auto_allow_disabled_env_var, "").strip().lower() in truthy_string_values:
+    if os.environ.get(EPHEMERAL_AUTO_ALLOW_DISABLE_ENV_VAR, "").strip().lower() in ALL_TRUTHY_ENV_VALUES:
         return False
     forward_slash_normalized_directory_path = os.path.normpath(directory_path).replace("\\", "/").lower()
     all_worktree_path_segments = ("/worktrees/", "/worktree/")

package/hooks/blocking/pre_tool_use_dispatcher.py

@@ -486,16 +486,20 @@ def _emit_allow_decision(decision: DispatcherDecision) -> None:
 
     Matches the shape a standalone hosted hook emits when it auto-approves the
     write, so a write a hosted hook allows explicitly is auto-approved under the
-    dispatcher rather than falling back to the default permission flow. When a
-    hook also carried an advisory systemMessage,
-    that notice rides on the allow payload without denying.
+    dispatcher rather than falling back to the default permission flow. Advisory
+    systemMessage and additionalContext fields ride on the allow payload.
     """
+    allow_hook_specific: dict[str, object] = {
+        "hookEventName": HOOK_EVENT_NAME,
+        "permissionDecision": ALLOW_DECISION,
+    }
     allow_payload: dict[str, object] = {
-        "hookSpecificOutput": {
-            "hookEventName": HOOK_EVENT_NAME,
-            "permissionDecision": ALLOW_DECISION,
-        }
+        "hookSpecificOutput": allow_hook_specific,
     }
+    if decision.all_additional_context:
+        allow_hook_specific["additionalContext"] = CONTEXT_JOIN_SEPARATOR.join(
+            decision.all_additional_context
+        )
     if decision.all_system_messages:
         allow_payload["systemMessage"] = SYSTEM_MESSAGE_JOIN_SEPARATOR.join(
             decision.all_system_messages

package/hooks/blocking/precommit_code_rules_gate.py

@@ -1,40 +1,26 @@
-"""PreToolUse hook that runs the staged CODE_RULES gate before git commit.
+"""PreToolUse hook that passes Git commit validation to Git hooks.
 
 Intercepts Bash `git commit` invocations (including `git -C <path> commit`),
-resolves the repository root, and runs the shared code_rules_gate engine in
-``--staged`` mode over the staged files. A commit that would introduce
-CODE_RULES violations is denied with the gate's file:line report so the
-violations surface before the commit instead of stalling converge loops at
-commit time. Non-commit commands, repositories with no staged Python files,
-and clean staged changes pass through silently. A gate-engine failure denies
-the commit with the failure detail — the gate never fails open.
+emits neutral evidence, and returns control to Git. Configured Git hooks
+receive the commit at the commit boundary.
 """
 
-import json
 import re
 import subprocess
 import sys
 from pathlib import Path
 
-_blocking_dir = str(Path(__file__).resolve().parent)
-if _blocking_dir not in sys.path:
-    sys.path.insert(0, _blocking_dir)
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
+_hooks_directory = str(Path(__file__).resolve().parent.parent)
+if _hooks_directory not in sys.path:
+    sys.path.insert(0, _hooks_directory)
 
 from block_main_commit import (  # noqa: E402
-    extract_git_working_directory,
     is_commit_command,
     parse_bash_command_from_stdin,
-    resolve_directory,
 )
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
+
 from hooks_constants.precommit_code_rules_gate_constants import (  # noqa: E402
     ALL_GIT_REPOSITORY_ROOT_COMMAND,
-    ALL_STAGED_PYTHON_FILES_COMMAND,
-    GATE_RELATIVE_PATH,
-    GATE_TIMEOUT_SECONDS,
     GIT_COMMAND_TIMEOUT_SECONDS,
     GIT_DASH_C_COMMIT_PATTERN,
 )
@@ -59,20 +45,19 @@ def is_git_commit_invocation(bash_command: str) -> bool:
 
 
 def resolve_repository_root(working_directory: str | None) -> Path | None:
-    """Resolve the git repository root for the commit's working directory.
+    """Resolve the Git repository root for a directory.
 
     Args:
-        working_directory: Directory the commit runs in, or None for the
-            hook's current working directory.
+        working_directory: Directory inside the repository.
 
     Returns:
-        The repository root path, or None when the directory is not inside
-        a git repository or git is unavailable.
+        Repository root. Returns None when Git cannot resolve the directory.
     """
     try:
         completed_process = subprocess.run(
             list(ALL_GIT_REPOSITORY_ROOT_COMMAND),
-            check=False, capture_output=True,
+            check=False,
+            capture_output=True,
             text=True,
             timeout=GIT_COMMAND_TIMEOUT_SECONDS,
             cwd=working_directory,
@@ -87,122 +72,12 @@ def resolve_repository_root(working_directory: str | None) -> Path | None:
     return Path(top_level_text)
 
 
-def list_staged_python_files(repository_root: Path) -> list[str]:
-    """List repository-relative paths of staged Python files.
-
-    Args:
-        repository_root: Repository root used as the git working directory.
-
-    Returns:
-        Repository-relative paths of Python files staged for add, copy,
-        modify, or rename. Empty when the listing command fails — the
-        caller then allows the commit because git itself will surface the
-        repository problem.
-    """
-    try:
-        completed_process = subprocess.run(
-            list(ALL_STAGED_PYTHON_FILES_COMMAND),
-            check=False, capture_output=True,
-            text=True,
-            timeout=GIT_COMMAND_TIMEOUT_SECONDS,
-            cwd=str(repository_root),
-        )
-    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
-        return []
-    if completed_process.returncode != 0:
-        return []
-    return [
-        each_line.strip()
-        for each_line in completed_process.stdout.splitlines()
-        if each_line.strip()
-    ]
-
-
-def run_staged_gate(repository_root: Path) -> tuple[int, str]:
-    """Run the shared code_rules_gate engine in staged mode.
-
-    Args:
-        repository_root: Repository root passed to the gate's --repo-root
-            and used as the gate subprocess working directory, so relative
-            paths the gate's checks resolve land in the committing worktree
-            rather than the hook's own working directory.
-
-    Returns:
-        Tuple of the gate exit code and its stderr report. A missing gate
-        script or a gate timeout returns a non-zero code with an
-        explanatory message so the commit is denied rather than waved
-        through on infrastructure failure.
-    """
-    gate_path = Path(__file__).resolve().parents[2] / GATE_RELATIVE_PATH
-    if not gate_path.is_file():
-        return 1, f"precommit_code_rules_gate: gate engine missing at {gate_path}"
-    try:
-        completed_process = subprocess.run(
-            [
-                sys.executable,
-                str(gate_path),
-                "--repo-root",
-                str(repository_root),
-                "--staged",
-            ],
-            check=False, capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=GATE_TIMEOUT_SECONDS,
-            cwd=str(repository_root),
-        )
-    except subprocess.TimeoutExpired:
-        return 1, (
-            f"precommit_code_rules_gate: gate engine timed out after {GATE_TIMEOUT_SECONDS}s"
-        )
-    return completed_process.returncode, completed_process.stderr
-
-
-def build_denial_response(gate_report: str) -> dict:
-    """Build the PreToolUse deny payload carrying the gate report.
-
-    Args:
-        gate_report: The gate's stderr report listing file:line violations.
-
-    Returns:
-        The hookSpecificOutput deny mapping for the PreToolUse protocol.
-    """
-    denial_reason = (
-        f"BLOCKED: staged files violate CODE_RULES; fix before committing.\n{gate_report.strip()}"
-    )
-    return {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": denial_reason,
-        }
-    }
-
-
 def main() -> None:
-    """Gate git commits on the staged CODE_RULES report."""
+    """Pass Git commit validation through to configured Git hooks."""
     bash_command = parse_bash_command_from_stdin()
     if not is_git_commit_invocation(bash_command):
         sys.exit(0)
-    working_directory = resolve_directory(extract_git_working_directory(bash_command))
-    repository_root = resolve_repository_root(working_directory)
-    if repository_root is None:
-        sys.exit(0)
-    if not list_staged_python_files(repository_root):
-        sys.exit(0)
-    gate_exit_code, gate_report = run_staged_gate(repository_root)
-    if gate_exit_code == 0:
-        sys.exit(0)
-    denial = build_denial_response(gate_report)
-    log_hook_block(
-        calling_hook_name="precommit_code_rules_gate.py",
-        hook_event="PreToolUse",
-        block_reason=denial["hookSpecificOutput"]["permissionDecisionReason"],
-        tool_name="Bash",
-        offending_input_preview=bash_command,
-    )
-    print(json.dumps(denial))
+    sys.stderr.write("Git commit proceeds to configured Git hooks.\n")
     sys.exit(0)
 
 

package/hooks/blocking/sensitive_file_protector.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Deny a Write or Edit whose target filename names a secret or a lock file.
+"""Deny a Write, Edit, or MultiEdit whose target filename names a secret or a lock file.
 
 ::
 
@@ -35,10 +35,12 @@ import sys
 import _path_setup  # noqa: F401
 
 from hooks_constants.hook_block_logger import log_hook_block
+from hooks_constants.pre_tool_use_dispatcher_constants import (
+    ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
+)
 from hooks_constants.sensitive_file_protector_constants import (
     ALL_SENSITIVE_PATTERNS,
     ALL_TEMPLATE_SUFFIXES,
-    ALL_WRITE_EDIT_TOOLS,
     DENY_DECISION,
     DENY_REASON_TEMPLATE,
     HOOK_EVENT_NAME,
@@ -57,7 +59,7 @@ def is_template_filename(filename: str) -> bool:
         .env.local       -> False
 
     Args:
-        filename: The basename of the file a Write or Edit targets.
+        filename: The basename of the file a Write, Edit, or MultiEdit targets.
 
     Returns:
         True when the basename's final suffix is a template suffix.
@@ -69,7 +71,7 @@ def is_sensitive_file(file_path: str) -> str | None:
     """Return the sensitive pattern a path's basename matches, or None.
 
     Args:
-        file_path: The path the Write or Edit targets.
+        file_path: The path the Write, Edit, or MultiEdit targets.
 
     Returns:
         The matched pattern, or None when the basename names a template or
@@ -106,7 +108,7 @@ def deny_write(file_path: str, matched_pattern: str) -> None:
     """Record the block in the hook-blocks log and emit the deny decision.
 
     Args:
-        file_path: The path the Write or Edit targets.
+        file_path: The path the Write, Edit, or MultiEdit targets.
         matched_pattern: The sensitive pattern the basename matched.
     """
     deny_reason = DENY_REASON_TEMPLATE.format(
@@ -132,7 +134,7 @@ def main() -> None:
     tool_name = hook_input.get("tool_name", "")
     tool_input = hook_input.get("tool_input", {})
 
-    if tool_name not in ALL_WRITE_EDIT_TOOLS:
+    if tool_name not in ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES:
         sys.exit(0)
 
     file_path = tool_input.get("file_path", "")

package/hooks/blocking/session_edit_stage_gate.py

@@ -18,6 +18,7 @@ blocks on infrastructure trouble.
 from __future__ import annotations
 
 import json
+import os
 import shlex
 import subprocess
 import sys
@@ -601,6 +602,35 @@ def _build_denial(all_offending_paths: list[str]) -> dict:
     }
 
 
+def _resolve_hook_working_directory(
+    bash_command: str,
+    all_hook_payload: dict[str, object],
+) -> str | None:
+    """Resolve the commit directory from the command or its event payload.
+
+    Args:
+        bash_command: Bash command whose explicit directory takes precedence.
+        all_hook_payload: PreToolUse payload carrying the event ``cwd``.
+
+    Returns:
+        The validated commit directory, or None for the hook process directory.
+    """
+    command_directory = extract_git_working_directory(bash_command)
+    event_directory = all_hook_payload.get("cwd")
+    if not isinstance(event_directory, str) or not event_directory:
+        return resolve_directory(command_directory)
+    validated_event_directory = resolve_directory(event_directory)
+    if command_directory is None:
+        return validated_event_directory
+    expanded_command_directory = os.path.expanduser(command_directory)
+    command_path = Path(expanded_command_directory)
+    if command_path.is_absolute():
+        return resolve_directory(str(command_path))
+    if validated_event_directory is None:
+        return None
+    return resolve_directory(str(Path(validated_event_directory) / command_path))
+
+
 def main() -> None:
     """Deny a git commit that would drop a tracked file that was edited yet left unstaged."""
     hook_payload = read_hook_input_dictionary_from_stdin()
@@ -620,7 +650,7 @@ def main() -> None:
     session_edited_keys = _session_edited_keys(session_id)
     if not session_edited_keys:
         sys.exit(0)
-    working_directory = resolve_directory(extract_git_working_directory(bash_command))
+    working_directory = _resolve_hook_working_directory(bash_command, hook_payload)
     repository_root = resolve_repository_root(working_directory)
     if repository_root is None:
         sys.exit(0)

package/hooks/blocking/test_claude_md_orphan_file_blocker.py

@@ -1,6 +1,7 @@
 """Tests for claude_md_orphan_file_blocker hook."""
 
 import json
+import importlib
 import os
 import subprocess
 import sys
@@ -9,7 +10,57 @@ from pathlib import Path
 
 import pytest
 
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+_test_file_path = Path(__file__).resolve()
+_blocking_directory = str(_test_file_path.parent)
+_hooks_directory = str(_test_file_path.parent.parent)
+_blocking_directory_key = os.path.normcase(os.path.abspath(_blocking_directory))
+_hooks_directory_key = os.path.normcase(os.path.abspath(_hooks_directory))
+_hooks_directory_origin_key = _hooks_directory_key
+sys.path[:] = [_blocking_directory, _hooks_directory] + [
+    each_path
+    for each_path in sys.path
+    if not isinstance(each_path, str)
+    or os.path.normcase(os.path.abspath(each_path))
+    not in (_blocking_directory_key, _hooks_directory_key)
+]
+importlib.invalidate_caches()
+
+_all_cached_module_prefixes = (
+    "claude_md_orphan_file_blocker",
+    "claude_md_orphan_file_blocker_parts",
+    "inventory_intent_records",
+    "hooks_constants",
+    "code_rules_annotations_length",
+    "code_rules_boolean_mustcheck",
+    "code_rules_naming_collection",
+    "code_rules_path_utils",
+    "code_rules_shared",
+)
+
+
+for each_module_name, each_module in tuple(sys.modules.items()):
+    if not any(
+        each_module_name == each_prefix or each_module_name.startswith(f"{each_prefix}.")
+        for each_prefix in _all_cached_module_prefixes
+    ):
+        continue
+    module_file = getattr(each_module, "__file__", None)
+    is_cached_module_in_this_checkout = False
+    if isinstance(module_file, str):
+        module_file_key = os.path.normcase(str(Path(module_file).resolve()))
+        try:
+            is_cached_module_in_this_checkout = (
+                os.path.commonpath((_hooks_directory_origin_key, module_file_key))
+                == _hooks_directory_origin_key
+            )
+        except ValueError:
+            pass
+    if is_cached_module_in_this_checkout:
+        continue
+    raise ImportError(
+        "test_claude_md_orphan_file_blocker: cached module outside this checkout: "
+        f"{each_module_name} ({module_file!r})"
+    )
 
 import claude_md_orphan_file_blocker as blocker_module
 from claude_md_orphan_file_blocker import (
@@ -82,6 +133,125 @@ def _isolated_claude_md_path(tmp_path: Path) -> Path:
     return isolated_directory / "CLAUDE.md"
 
 
+def _run_isolated_test_module_import(
+    driver_setup: str, driver_assertions: str
+) -> subprocess.CompletedProcess:
+    """Import this test module in an isolated interpreter with caller-supplied state."""
+    test_module_path = _test_file_path
+    driver = (
+        "import importlib.util\n"
+        "import os\n"
+        "import site\n"
+        "import sys\n"
+        "from pathlib import Path\n"
+        f"test_module_path = Path({str(test_module_path)!r})\n"
+        "sys.path.append(site.getusersitepackages())\n"
+        f"{driver_setup}"
+        "spec = importlib.util.spec_from_file_location('bootstrap_target_test', test_module_path)\n"
+        "module = importlib.util.module_from_spec(spec)\n"
+        "spec.loader.exec_module(module)\n"
+        f"{driver_assertions}"
+    )
+    return subprocess.run(
+        [sys.executable, "-I", "-c", driver],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+
+def test_import_bootstrap_prioritizes_this_checkout(tmp_path: Path) -> None:
+    foreign_hooks_directory = tmp_path / "foreign_hooks"
+    foreign_blocking_directory = foreign_hooks_directory / "blocking"
+    foreign_constants_directory = foreign_hooks_directory / "hooks_constants"
+    foreign_blocking_directory.mkdir(parents=True)
+    foreign_constants_directory.mkdir()
+    (foreign_blocking_directory / "claude_md_orphan_file_blocker.py").write_text(
+        "raise RuntimeError('foreign blocker loaded')\n", encoding="utf-8"
+    )
+    (foreign_constants_directory / "__init__.py").write_text(
+        "raise RuntimeError('foreign constants loaded')\n", encoding="utf-8"
+    )
+    target_blocking_directory = Path(__file__).resolve().parent
+    target_hooks_directory = target_blocking_directory.parent
+    driver_setup = (
+        f"foreign_blocking_directory = Path({str(foreign_blocking_directory)!r})\n"
+        f"foreign_hooks_directory = Path({str(foreign_hooks_directory)!r})\n"
+        f"target_blocking_directory = Path({str(target_blocking_directory)!r})\n"
+        f"target_hooks_directory = Path({str(target_hooks_directory)!r})\n"
+        "sys.path[:0] = [\n"
+        "    str(foreign_blocking_directory), str(foreign_hooks_directory),\n"
+        "    str(target_blocking_directory), str(target_hooks_directory),\n"
+        "]\n"
+    )
+    driver_assertions = (
+        "import claude_md_orphan_file_blocker\n"
+        "import hooks_constants\n"
+        "assert Path(claude_md_orphan_file_blocker.__file__).resolve().parent "
+        "== target_blocking_directory\n"
+        "assert Path(hooks_constants.__file__).resolve().parent.parent "
+        "== target_hooks_directory\n"
+        "all_uncovered_module_names = [\n"
+        "    each_module_name\n"
+        "    for each_module_name, each_loaded_module in sys.modules.items()\n"
+        "    if each_loaded_module is not module\n"
+        "    and isinstance(getattr(each_loaded_module, '__file__', None), str)\n"
+        "    and Path(each_loaded_module.__file__).resolve().is_relative_to(\n"
+        "        target_hooks_directory\n"
+        "    )\n"
+        "    and not any(\n"
+        "        each_module_name == each_prefix\n"
+        "        or each_module_name.startswith(f'{each_prefix}.')\n"
+        "        for each_prefix in module._all_cached_module_prefixes\n"
+        "    )\n"
+        "]\n"
+        "assert not all_uncovered_module_names, all_uncovered_module_names\n"
+    )
+    completed = _run_isolated_test_module_import(driver_setup, driver_assertions)
+    assert completed.returncode == 0, completed.stderr
+
+
+def test_import_bootstrap_preserves_non_string_path_entries() -> None:
+    completed = _run_isolated_test_module_import(
+        "sys.path.insert(0, None)\n", "assert None in sys.path\n"
+    )
+    assert completed.returncode == 0, completed.stderr
+
+
+def test_import_bootstrap_invalidates_stale_importer_cache() -> None:
+    target_blocking_directory = Path(__file__).resolve().parent
+    driver_setup = (
+        f"target_blocking_directory = Path({str(target_blocking_directory)!r})\n"
+        "sys.path_importer_cache[str(target_blocking_directory)] = None\n"
+    )
+    completed = _run_isolated_test_module_import(driver_setup, "")
+    assert completed.returncode == 0, completed.stderr
+
+
+@pytest.mark.parametrize(
+    "cached_module_name",
+    (
+        "hooks_constants",
+        "claude_md_orphan_file_blocker",
+        "code_rules_path_utils",
+    ),
+)
+def test_import_bootstrap_rejects_foreign_cached_modules(
+    tmp_path: Path, cached_module_name: str
+) -> None:
+    foreign_module_path = tmp_path / "foreign_hooks" / f"{cached_module_name}.py"
+    driver_setup = (
+        "import types\n"
+        f"cached_module_name = {cached_module_name!r}\n"
+        "cached_module = types.ModuleType(cached_module_name)\n"
+        f"cached_module.__file__ = {str(foreign_module_path)!r}\n"
+        "sys.modules[cached_module_name] = cached_module\n"
+    )
+    completed = _run_isolated_test_module_import(driver_setup, "")
+    assert completed.returncode != 0
+    assert f"cached module outside this checkout: {cached_module_name}" in completed.stderr
+
+
 def test_blocks_write_naming_absent_python_file(tmp_path: Path):
     claude_md_path = _isolated_claude_md_path(tmp_path)
     result = _run_hook(