claude-dev-env 2.18.0 → 2.20.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_block_main_commit.py

@@ -0,0 +1,145 @@
+"""Production-path tests for direct commit branch protection."""
+
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+
+def _run_git(from_directory: Path, *arguments: str) -> None:
+    subprocess.run(
+        ["git", *arguments],
+        cwd=from_directory,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _create_repository(from_directory: Path, branch_name: str) -> Path:
+    repository = from_directory / branch_name
+    repository.mkdir()
+    _run_git(repository, "init", "--initial-branch", "main")
+    hook_directory = repository / ".git" / "test-hooks"
+    hook_directory.mkdir()
+    _run_git(repository, "config", "core.hooksPath", str(hook_directory))
+    _run_git(repository, "config", "user.email", "test@example.com")
+    _run_git(repository, "config", "user.name", "Test User")
+    (repository / "tracked.txt").write_text("tracked\n", encoding="utf-8")
+    _run_git(repository, "add", "tracked.txt")
+    _run_git(repository, "-c", "commit.gpgsign=false", "commit", "-m", "initial")
+    if branch_name != "main":
+        _run_git(repository, "switch", "-c", branch_name)
+    return repository
+
+
+def _run_commit_gate(
+    from_directory: Path,
+    process_directory: Path,
+    command: str = "git commit -m test",
+    include_event_cwd: bool = True,
+) -> subprocess.CompletedProcess[str]:
+    hook_script = Path(__file__).with_name("block_main_commit.py")
+    home_directory = from_directory.parent / "test-home"
+    home_directory.mkdir(exist_ok=True)
+    environment = os.environ.copy()
+    environment.update({"HOME": str(home_directory), "USERPROFILE": str(home_directory)})
+    hook_payload: dict[str, object] = {
+        "tool_name": "Bash",
+        "tool_input": {"command": command},
+    }
+    if include_event_cwd:
+        hook_payload["cwd"] = str(from_directory)
+    return subprocess.run(
+        [sys.executable, str(hook_script)],
+        cwd=process_directory,
+        input=json.dumps(hook_payload),
+        check=False,
+        capture_output=True,
+        text=True,
+        env=environment,
+    )
+
+
+def test_blocks_commit_on_protected_branch_from_hook_event_cwd(tmp_path: Path) -> None:
+    repository = _create_repository(tmp_path, "main")
+    process_repository = _create_repository(tmp_path, "agent-owned-change")
+
+    completed_process = _run_commit_gate(repository, process_repository)
+
+    assert completed_process.returncode == 0
+    hook_response = json.loads(completed_process.stdout)
+    assert hook_response["hookSpecificOutput"]["permissionDecision"] == "deny"
+    assert str(repository) in hook_response["hookSpecificOutput"]["permissionDecisionReason"]
+
+
+def test_allows_commit_on_owned_branch_from_hook_event_cwd(tmp_path: Path) -> None:
+    repository = _create_repository(tmp_path, "agent-owned-change")
+    process_repository = _create_repository(tmp_path, "main")
+
+    completed_process = _run_commit_gate(repository, process_repository)
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_resolves_relative_git_c_from_hook_event_cwd(tmp_path: Path) -> None:
+    repository = _create_repository(tmp_path, "main")
+    process_repository = _create_repository(tmp_path, "agent-owned-change")
+
+    completed_process = _run_commit_gate(
+        tmp_path,
+        process_repository,
+        command="git -C main commit -m test",
+    )
+
+    assert completed_process.returncode == 0
+    hook_response = json.loads(completed_process.stdout)
+    assert hook_response["hookSpecificOutput"]["permissionDecision"] == "deny"
+    assert str(repository) in hook_response["hookSpecificOutput"]["permissionDecisionReason"]
+
+
+def test_preserves_dispatcher_ownership_without_event_cwd(tmp_path: Path) -> None:
+    repository = _create_repository(tmp_path, "main")
+    process_repository = _create_repository(tmp_path, "agent-owned-change")
+
+    completed_process = _run_commit_gate(
+        tmp_path,
+        process_repository,
+        command=f'git -C "{repository}" commit -m test',
+        include_event_cwd=False,
+    )
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_matches_case_insensitive_shell_git_command(tmp_path: Path) -> None:
+    repository = _create_repository(tmp_path, "main")
+    process_repository = _create_repository(tmp_path, "agent-owned-change")
+
+    completed_process = _run_commit_gate(
+        tmp_path,
+        process_repository,
+        command="CD main && GIT COMMIT -m test",
+    )
+
+    assert completed_process.returncode == 0
+    hook_response = json.loads(completed_process.stdout)
+    assert hook_response["hookSpecificOutput"]["permissionDecision"] == "deny"
+    assert str(repository) in hook_response["hookSpecificOutput"]["permissionDecisionReason"]
+
+
+def test_ignores_unrelated_command_containing_git_commit(tmp_path: Path) -> None:
+    repository = _create_repository(tmp_path, "main")
+    process_repository = _create_repository(tmp_path, "agent-owned-change")
+
+    completed_process = _run_commit_gate(
+        repository,
+        process_repository,
+        command="echo git commit",
+    )
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""

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(

package/hooks/blocking/test_code_rules_blast_radius.py

@@ -0,0 +1,161 @@
+"""Tests for the blast-radius declaration check."""
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_blocking_directory = str(Path(__file__).resolve().parent)
+if _blocking_directory not in sys.path:
+    sys.path.insert(0, _blocking_directory)
+
+from code_rules_blast_radius import check_blast_radius_declared  # noqa: E402
+
+PRODUCTION_PATH = "pipeline/asset_run.py"
+
+
+def test_should_report_a_loop_raise_with_pending_blast_radius_declaration() -> None:
+    """A loop-body raise gets an advisory requesting its blast-radius declaration."""
+    content = (
+        "def run(all_members):\n"
+        "    for each_member in all_members:\n"
+        "        if each_member.requires_preparation:\n"
+        "            raise AssetError('member requires preparation')\n"
+    )
+
+    all_issues = check_blast_radius_declared(content, PRODUCTION_PATH)
+
+    assert len(all_issues) == 1
+    assert "Line 4" in all_issues[0]
+
+
+def test_should_accept_a_run_fatal_raise_inside_a_loop() -> None:
+    """A RunFatal type declares that the whole run ends."""
+    content = (
+        "def run(all_members):\n"
+        "    for each_member in all_members:\n"
+        "        if each_member.digest_differs:\n"
+        "            raise AssetRunFatal('source bytes changed')\n"
+    )
+
+    assert check_blast_radius_declared(content, PRODUCTION_PATH) == []
+
+
+def test_should_accept_an_item_blocked_raise_inside_a_loop() -> None:
+    """An ItemBlocked type declares a member-scoped stop."""
+    content = (
+        "def run(all_members):\n"
+        "    for each_member in all_members:\n"
+        "        if each_member.requires_resize:\n"
+        "            raise AssetItemBlocked('member requires resizing')\n"
+    )
+
+    assert check_blast_radius_declared(content, PRODUCTION_PATH) == []
+
+
+def test_should_accept_a_raise_wrapped_by_a_blast_radius_boundary() -> None:
+    """A per-member boundary catches a declared type and parks the failure."""
+    content = (
+        "def run(all_members):\n"
+        "    for each_member in all_members:\n"
+        "        try:\n"
+        "            if each_member.requires_resize:\n"
+                "                raise AssetItemBlocked('member requires resizing')\n"
+        "        except AssetItemBlocked as failure:\n"
+        "            park(each_member, failure)\n"
+    )
+
+    assert check_blast_radius_declared(content, PRODUCTION_PATH) == []
+
+
+def test_should_report_runtime_error_with_a_different_declared_handler() -> None:
+    """A different declared handler leaves a runtime crash requiring a name."""
+    content = (
+        "def run(all_members):\n"
+        "    for each_member in all_members:\n"
+        "        try:\n"
+        "            raise RuntimeError('code defect')\n"
+        "        except AssetItemBlocked:\n"
+        "            park(each_member)\n"
+    )
+
+    assert len(check_blast_radius_declared(content, PRODUCTION_PATH)) == 1
+
+
+@pytest.mark.parametrize("raised_type", ["RuntimeError", "TypeError", "AttributeError", "ValueError"])
+def test_should_require_corresponding_handler_for_each_explicit_raise(
+    raised_type: str,
+) -> None:
+    """Each explicit raise needs a handler naming that same type."""
+    content = (
+        "def run(all_members):\n"
+        "    for each_member in all_members:\n"
+        "        try:\n"
+        f"            raise {raised_type}('code defect')\n"
+        "        except AssetItemBlocked:\n"
+        "            park(each_member)\n"
+    )
+
+    assert len(check_blast_radius_declared(content, PRODUCTION_PATH)) == 1
+
+
+def test_should_accept_a_run_level_raise_during_manifest_preparation() -> None:
+    """A run-level raise belongs to manifest preparation."""
+    content = (
+        "def prepare(manifest):\n"
+        "    if manifest.requires_preparation:\n"
+        "        raise AssetError('manifest requires preparation')\n"
+    )
+
+    assert check_blast_radius_declared(content, PRODUCTION_PATH) == []
+
+
+def test_should_accept_a_bare_reraise_inside_a_loop() -> None:
+    """A bare re-raise propagates an error carrying a declared radius."""
+    content = (
+        "def run(all_members):\n"
+        "    for each_member in all_members:\n"
+        "        try:\n"
+        "            process(each_member)\n"
+        "        except AssetItemBlocked:\n"
+        "            raise\n"
+    )
+
+    assert check_blast_radius_declared(content, PRODUCTION_PATH) == []
+
+
+def test_should_accept_test_files() -> None:
+    """Test modules raise freely during scenario coverage."""
+    content = (
+        "def test_records_member_failure(all_members):\n"
+        "    for each_member in all_members:\n"
+        "        raise AssetError('member failure')\n"
+    )
+
+    assert check_blast_radius_declared(content, "pipeline/test_asset_run.py") == []
+
+
+def test_should_report_each_loop_raise_with_pending_blast_radius_declaration() -> None:
+    """Each loop-body raise gets an advisory requesting its blast-radius declaration."""
+    content = (
+        "def run(all_members):\n"
+        "    for each_member in all_members:\n"
+        "        if each_member.requires_source:\n"
+        "            raise AssetError('member requires a source')\n"
+        "        if each_member.requires_resize:\n"
+        "            raise AssetError('member requires resizing')\n"
+    )
+
+    assert len(check_blast_radius_declared(content, PRODUCTION_PATH)) == 2
+
+
+def test_should_ignore_raise_in_nested_helper_body() -> None:
+    """A nested helper body is checked at its own call boundary."""
+    content = (
+        "def run(all_members):\n"
+        "    for each_member in all_members:\n"
+        "        def validate_member():\n"
+        "            raise AssetError('member validation failed')\n"
+    )
+
+    assert check_blast_radius_declared(content, PRODUCTION_PATH) == []

package/hooks/blocking/test_code_rules_enforcer_agent_home_tooling.py

@@ -12,20 +12,21 @@ so the repository code rules do not govern it::
 from __future__ import annotations
 
 import os
-import subprocess
-import sys
+from subprocess import CompletedProcess
 import tempfile
 from pathlib import Path
 
+import pytest
+
 from blocking import _path_setup  # noqa: F401  (pins this checkout ahead of sibling worktrees)
+import code_rules_enforcer_test_support
 from blocking.code_rules_shared import is_agent_home_tooling, is_ephemeral_path
-
-_ENFORCER_SCRIPT = Path(__file__).resolve().parent / "code_rules_enforcer.py"
+from code_rules_enforcer_test_support import run_precheck
 
 _VIOLATING_PRODUCTION_SOURCE = "def process_data(payload: str) -> None:\n    print(payload)\n"
 
 
-def _check_as(candidate_source: str, target_path: str) -> subprocess.CompletedProcess[str]:
+def _check_as(candidate_source: str, target_path: str) -> CompletedProcess[str]:
     """Run the enforcer's pre-check on a candidate judged as another path.
 
     Args:
@@ -38,13 +39,37 @@ def _check_as(candidate_source: str, target_path: str) -> subprocess.CompletedPr
     with tempfile.TemporaryDirectory() as scratch:
         candidate = Path(scratch) / "candidate.py"
         candidate.write_text(candidate_source, encoding="utf-8")
-        return subprocess.run(
-            [sys.executable, str(_ENFORCER_SCRIPT), "--check", str(candidate), "--as", target_path],
-            input="",
-            capture_output=True,
-            text=True,
-            check=False,
-        )
+        return run_precheck(candidate, target_path, None)
+
+
+def test_run_precheck_forwards_environment_mapping(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    expected_environment_by_name = {"CLAUDE_JOB_DIR": "/agent/jobs"}
+    captured_environment_by_name: dict[str, str] | None = None
+
+    def capture_run_enforcer_cli(
+        _script_path: Path,
+        _all_arguments: list[str],
+        extra_environment_by_name: dict[str, str] | None,
+    ) -> CompletedProcess[str]:
+        nonlocal captured_environment_by_name
+        captured_environment_by_name = extra_environment_by_name
+        return CompletedProcess(args=[], returncode=0, stdout="", stderr="")
+
+    monkeypatch.setattr(
+        code_rules_enforcer_test_support,
+        "run_enforcer_cli",
+        capture_run_enforcer_cli,
+    )
+    completed = run_precheck(
+        Path("candidate.py"),
+        "target.py",
+        expected_environment_by_name,
+    )
+
+    assert completed.returncode == 0
+    assert captured_environment_by_name == {"CLAUDE_JOB_DIR": "/agent/jobs"}
 
 
 def test_posix_agent_home_path_is_agent_tooling() -> None: