claude-dev-env 2.18.0 → 2.20.0

package/hooks/blocking/test_destructive_command_blocker_deny_mode.py

@@ -9,37 +9,97 @@ a ``deny`` so the sandbox can be contained.
 from __future__ import annotations
 
 import json
-import os
 import subprocess
 import sys
 from pathlib import Path
 
-SCRIPT_PATH = Path(__file__).parent / "destructive_command_blocker.py"
-DENY_MODE_ENV_VAR = "CLAUDE_DESTRUCTIVE_DENY_MODE"
-
-
-def _run_hook_with_environment(command: str, extra_environment: dict[str, str]) -> dict:
-    child_environment = os.environ.copy()
-    child_environment.pop(DENY_MODE_ENV_VAR, None)
-    child_environment.update(extra_environment)
-    completed_process = subprocess.run(
-        [sys.executable, str(SCRIPT_PATH)],
-        input=json.dumps({"tool_name": "Bash", "tool_input": {"command": command}}),
-        text=True,
-        capture_output=True,
-        check=False,
-        env=child_environment,
+_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
+if str(_BLOCKING_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_BLOCKING_DIRECTORY))
+
+SCRIPT_PATH = _BLOCKING_DIRECTORY / "destructive_command_blocker.py"
+DISPATCHER_PATH = _BLOCKING_DIRECTORY / "bash_pre_tool_use_dispatcher.py"
+
+import _path_setup  # noqa: E402, F401
+
+from test_hook_subprocess_support import (  # noqa: E402
+    build_bash_payload,
+    run_hook_as_subprocess,
+)
+
+
+def _run_hook_with_environment(
+    hook_script_path: Path,
+    command: str,
+    environment_update_by_name: dict[str, str],
+    temporary_home_directory: Path,
+) -> subprocess.CompletedProcess[str]:
+    return run_hook_as_subprocess(
+        hook_script_path=hook_script_path,
+        payload_text=build_bash_payload(command),
+        working_directory=temporary_home_directory,
+        home_directory=temporary_home_directory,
+        all_environment_names_to_remove=("CLAUDE_DESTRUCTIVE_DENY_MODE",),
+        environment_updates_by_name=environment_update_by_name,
     )
-    return json.loads(completed_process.stdout)
 
 
-def test_rm_rf_denies_when_deny_mode_env_is_set() -> None:
-    response = _run_hook_with_environment("rm -rf /var/log/myapp", {DENY_MODE_ENV_VAR: "1"})
-    assert response["hookSpecificOutput"]["permissionDecision"] == "deny"
-    assert "rm -rf" in response["hookSpecificOutput"]["permissionDecisionReason"]
+def _assert_terminal_response(
+    completed_hook: subprocess.CompletedProcess[str],
+    expected_permission_decision: str,
+    expected_permission_reason: str,
+) -> None:
+    assert completed_hook.returncode == 0
+    assert completed_hook.stderr == ""
+    assert json.loads(completed_hook.stdout) == {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": expected_permission_decision,
+            "permissionDecisionReason": expected_permission_reason,
+        }
+    }
+
 
+def test_rm_rf_denies_when_deny_mode_env_is_set(tmp_path: Path) -> None:
+    completed_hook = _run_hook_with_environment(
+        SCRIPT_PATH,
+        "rm -rf /var/log/myapp",
+        {"CLAUDE_DESTRUCTIVE_DENY_MODE": "1"},
+        tmp_path,
+    )
+    _assert_terminal_response(
+        completed_hook,
+        "deny",
+        "DESTRUCTIVE: rm -rf (destructive recursive forced delete). "
+        "Blocked in deny mode.",
+    )
 
-def test_rm_rf_asks_when_deny_mode_env_is_absent() -> None:
-    response = _run_hook_with_environment("rm -rf /var/log/myapp", {})
-    assert response["hookSpecificOutput"]["permissionDecision"] == "ask"
-    assert "rm -rf" in response["hookSpecificOutput"]["permissionDecisionReason"]
+
+def test_rm_rf_asks_when_deny_mode_env_is_absent(tmp_path: Path) -> None:
+    completed_hook = _run_hook_with_environment(
+        SCRIPT_PATH,
+        "rm -rf /var/log/myapp",
+        {},
+        tmp_path,
+    )
+    _assert_terminal_response(
+        completed_hook,
+        "ask",
+        "DESTRUCTIVE: rm -rf (destructive recursive forced delete). "
+        "Requires explicit user approval.",
+    )
+
+
+def test_dispatcher_short_circuits_on_destructive_deny(tmp_path: Path) -> None:
+    completed_dispatcher = _run_hook_with_environment(
+        DISPATCHER_PATH,
+        "rm -rf /var/log/myapp",
+        {"CLAUDE_DESTRUCTIVE_DENY_MODE": "1"},
+        tmp_path,
+    )
+    _assert_terminal_response(
+        completed_dispatcher,
+        "deny",
+        "DESTRUCTIVE: rm -rf (destructive recursive forced delete). "
+        "Blocked in deny mode.",
+    )

package/hooks/blocking/test_destructive_command_blocker_no_verify.py

@@ -5,34 +5,30 @@ hook signing and verification. The blocker must ASK before allowing them.
 """
 
 import json
-import os
-import subprocess
 import sys
 from pathlib import Path
 
+_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
+if str(_BLOCKING_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_BLOCKING_DIRECTORY))
 
-SCRIPT_PATH = Path(__file__).parent / "destructive_command_blocker.py"
+import _path_setup  # noqa: E402, F401
 
+from test_hook_subprocess_support import (  # noqa: E402
+    build_bash_payload,
+    run_hook_as_subprocess,
+)
 
-def _run_hook(payload: dict) -> subprocess.CompletedProcess[str]:
-    child_environment = os.environ.copy()
-    return subprocess.run(
-        [sys.executable, str(SCRIPT_PATH)],
-        input=json.dumps(payload),
-        text=True,
-        capture_output=True,
-        check=False,
-        env=child_environment,
-    )
-
-
-def _make_bash_payload(command: str) -> dict:
-    return {"tool_name": "Bash", "tool_input": {"command": command}}
+SCRIPT_PATH = _BLOCKING_DIRECTORY / "destructive_command_blocker.py"
 
 
-def test_asks_on_git_commit_no_verify() -> None:
-    payload = _make_bash_payload('git commit -m "wip" --no-verify')
-    result = _run_hook(payload)
+def test_asks_on_git_commit_no_verify(tmp_path: Path) -> None:
+    result = run_hook_as_subprocess(
+        hook_script_path=SCRIPT_PATH,
+        payload_text=build_bash_payload('git commit -m "wip" --no-verify'),
+        working_directory=tmp_path,
+        home_directory=tmp_path,
+    )
     response = json.loads(result.stdout)
     assert response["hookSpecificOutput"]["permissionDecision"] == "ask", (
         f"Expected ask for git commit --no-verify, got: {response!r}"
@@ -42,18 +38,26 @@ def test_asks_on_git_commit_no_verify() -> None:
     )
 
 
-def test_asks_on_git_push_no_verify() -> None:
-    payload = _make_bash_payload("git push --no-verify origin main")
-    result = _run_hook(payload)
+def test_asks_on_git_push_no_verify(tmp_path: Path) -> None:
+    result = run_hook_as_subprocess(
+        hook_script_path=SCRIPT_PATH,
+        payload_text=build_bash_payload("git push --no-verify origin main"),
+        working_directory=tmp_path,
+        home_directory=tmp_path,
+    )
     response = json.loads(result.stdout)
     assert response["hookSpecificOutput"]["permissionDecision"] == "ask", (
         f"Expected ask for git push --no-verify, got: {response!r}"
     )
 
 
-def test_asks_on_git_no_gpg_sign() -> None:
-    payload = _make_bash_payload("git commit --no-gpg-sign -m wip")
-    result = _run_hook(payload)
+def test_asks_on_git_no_gpg_sign(tmp_path: Path) -> None:
+    result = run_hook_as_subprocess(
+        hook_script_path=SCRIPT_PATH,
+        payload_text=build_bash_payload("git commit --no-gpg-sign -m wip"),
+        working_directory=tmp_path,
+        home_directory=tmp_path,
+    )
     response = json.loads(result.stdout)
     assert response["hookSpecificOutput"]["permissionDecision"] == "ask", (
         f"Expected ask for git --no-gpg-sign, got: {response!r}"
@@ -63,36 +67,52 @@ def test_asks_on_git_no_gpg_sign() -> None:
     ), f"Reason must mention --no-gpg-sign, got: {response!r}"
 
 
-def test_asks_on_git_commit_with_no_gpg_sign_config() -> None:
-    payload = _make_bash_payload("git -c commit.gpgsign=false commit -m wip")
-    result = _run_hook(payload)
+def test_asks_on_git_commit_with_no_gpg_sign_config(tmp_path: Path) -> None:
+    result = run_hook_as_subprocess(
+        hook_script_path=SCRIPT_PATH,
+        payload_text=build_bash_payload("git -c commit.gpgsign=false commit -m wip"),
+        working_directory=tmp_path,
+        home_directory=tmp_path,
+    )
     response = json.loads(result.stdout)
     assert response["hookSpecificOutput"]["permissionDecision"] == "ask", (
         f"Expected ask for -c commit.gpgsign=false, got: {response!r}"
     )
 
 
-def test_asks_on_quoted_gpgsign_config() -> None:
-    payload = _make_bash_payload("git -c 'commit.gpgsign=false' commit -m wip")
-    result = _run_hook(payload)
+def test_asks_on_quoted_gpgsign_config(tmp_path: Path) -> None:
+    result = run_hook_as_subprocess(
+        hook_script_path=SCRIPT_PATH,
+        payload_text=build_bash_payload("git -c 'commit.gpgsign=false' commit -m wip"),
+        working_directory=tmp_path,
+        home_directory=tmp_path,
+    )
     response = json.loads(result.stdout)
     assert response["hookSpecificOutput"]["permissionDecision"] == "ask", (
         f"Expected ask for quoted -c commit.gpgsign=false, got: {response!r}"
     )
 
 
-def test_asks_on_value_quoted_gpgsign_config() -> None:
-    payload = _make_bash_payload("git -c commit.gpgsign='false' commit -m wip")
-    result = _run_hook(payload)
+def test_asks_on_value_quoted_gpgsign_config(tmp_path: Path) -> None:
+    result = run_hook_as_subprocess(
+        hook_script_path=SCRIPT_PATH,
+        payload_text=build_bash_payload("git -c commit.gpgsign='false' commit -m wip"),
+        working_directory=tmp_path,
+        home_directory=tmp_path,
+    )
     response = json.loads(result.stdout)
     assert response["hookSpecificOutput"]["permissionDecision"] == "ask", (
         f"Expected ask for value-quoted -c commit.gpgsign='false', got: {response!r}"
     )
 
 
-def test_normal_git_commit_passes() -> None:
-    payload = _make_bash_payload('git commit -m "real commit"')
-    result = _run_hook(payload)
+def test_normal_git_commit_passes(tmp_path: Path) -> None:
+    result = run_hook_as_subprocess(
+        hook_script_path=SCRIPT_PATH,
+        payload_text=build_bash_payload('git commit -m "real commit"'),
+        working_directory=tmp_path,
+        home_directory=tmp_path,
+    )
     if not result.stdout.strip():
         return
     response = json.loads(result.stdout)

package/hooks/blocking/test_destructive_command_blocker_patterns.py

@@ -0,0 +1,133 @@
+"""Production-subprocess coverage for destructive command patterns."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
+if str(_BLOCKING_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_BLOCKING_DIRECTORY))
+
+import _path_setup  # noqa: E402, F401
+
+from hooks_constants.destructive_command_environment_constants import (  # noqa: E402
+    DESTRUCTIVE_DENY_MODE_ENV_VAR,
+    EPHEMERAL_AUTO_ALLOW_DISABLE_ENV_VAR,
+)
+from test_hook_subprocess_support import (  # noqa: E402
+    build_bash_payload,
+    run_hook_as_subprocess,
+)
+
+SCRIPT_PATH = _BLOCKING_DIRECTORY / "destructive_command_blocker.py"
+ALL_DESTRUCTIVE_ENVIRONMENT_NAMES = (
+    DESTRUCTIVE_DENY_MODE_ENV_VAR,
+    EPHEMERAL_AUTO_ALLOW_DISABLE_ENV_VAR,
+)
+
+
+def _run_hook(
+    command: str,
+    working_directory: Path,
+    home_directory: Path,
+) -> subprocess.CompletedProcess[str]:
+    return run_hook_as_subprocess(
+        hook_script_path=SCRIPT_PATH,
+        payload_text=build_bash_payload(command),
+        working_directory=working_directory,
+        home_directory=home_directory,
+        all_environment_names_to_remove=ALL_DESTRUCTIVE_ENVIRONMENT_NAMES,
+    )
+
+
+@pytest.mark.parametrize(
+    ("command", "reason_fragment"),
+    [
+        ("rm -rf /var/log/myapp", "rm -rf"),
+        ("rm --recursive --force /var/log/myapp", "rm --recursive --force"),
+        ("rm -r /", "rm -r on broad path"),
+        ("mkfs.ext4 /dev/sda1", "mkfs"),
+        ("dd if=/tmp/disk.img of=/dev/sda", "dd raw disk write"),
+        ("git reset --hard HEAD~1", "git reset --hard"),
+        ("git push --force origin main", "git push --force"),
+        ("git push -f origin main", "git push -f"),
+        ("git clean -fd", "git clean -fd"),
+        ("git clean -f", "git clean -f"),
+        ("psql -c 'DROP TABLE users'", "DROP TABLE"),
+        ("psql -c 'DROP DATABASE app'", "DROP DATABASE"),
+        ("psql -c 'TRUNCATE TABLE users'", "TRUNCATE TABLE"),
+        ("git commit --no-verify", "git --no-verify"),
+        ("git commit --no-gpg-sign", "git --no-gpg-sign"),
+        ("git -c commit.gpgsign=false commit", "commit.gpgsign=false"),
+    ],
+)
+def test_protected_command_asks_for_approval(
+    command: str,
+    reason_fragment: str,
+    tmp_path: Path,
+) -> None:
+    filesystem_root = Path(Path.cwd().anchor)
+    completed_hook = _run_hook(command, filesystem_root, tmp_path)
+
+    hook_decision_payload = json.loads(completed_hook.stdout)
+    assert completed_hook.returncode == 0
+    assert completed_hook.stderr == ""
+    assert hook_decision_payload["hookSpecificOutput"]["hookEventName"] == "PreToolUse"
+    assert hook_decision_payload["hookSpecificOutput"]["permissionDecision"] == "ask"
+    assert reason_fragment in hook_decision_payload["hookSpecificOutput"][
+        "permissionDecisionReason"
+    ]
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "git status --short",
+        "rm -rf /tmp/destructive-command-blocker/build",
+        "rm -rf /project/worktrees/feature/build",
+        "git push --force origin claude/fix-hook-test",
+    ],
+)
+def test_permitted_command_exits_silently(command: str, tmp_path: Path) -> None:
+    completed_hook = _run_hook(command, tmp_path, tmp_path)
+
+    assert completed_hook.returncode == 0
+    assert completed_hook.stdout == ""
+    assert completed_hook.stderr == ""
+
+
+def test_ephemeral_rm_exits_silently_when_parent_disables_auto_allow(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    monkeypatch.setenv(EPHEMERAL_AUTO_ALLOW_DISABLE_ENV_VAR, "1")
+
+    with tempfile.TemporaryDirectory(
+        dir=tmp_path,
+        prefix="destructive command blocker ",
+    ) as ephemeral_directory_path:
+        completed_hook = _run_hook(
+            f'rm -rf "{ephemeral_directory_path}"',
+            tmp_path,
+            tmp_path,
+        )
+
+        assert completed_hook.returncode == 0
+        assert completed_hook.stdout == ""
+        assert completed_hook.stderr == ""
+
+
+def test_git_reset_hard_in_ephemeral_project_exits_silently(
+    tmp_path: Path,
+) -> None:
+    completed_hook = _run_hook("git reset --hard HEAD~1", tmp_path, tmp_path)
+
+    assert completed_hook.returncode == 0
+    assert completed_hook.stdout == ""
+    assert completed_hook.stderr == ""

package/hooks/blocking/test_docstring_rule_gate_count_blocker.py

@@ -2,11 +2,63 @@
 
 import json
 import os
+import runpy
 import subprocess
 import sys
 from pathlib import Path
 
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+_local_hooks_directory = str(Path(__file__).resolve().parent.parent)
+_all_local_import_directories = (
+    str(Path(_local_hooks_directory) / "blocking"),
+    _local_hooks_directory,
+)
+_all_normalized_local_import_directories = tuple(
+    os.path.normcase(os.path.realpath(each_directory))
+    for each_directory in _all_local_import_directories
+)
+_all_normalized_import_directories = tuple(
+    (
+        os.path.normcase(os.path.realpath(os.fspath(each_directory)))
+        if each_directory != "" and isinstance(each_directory, (str, os.PathLike))
+        else None
+    )
+    for each_directory in sys.path
+)
+_all_prioritized_import_directories = [
+    *_all_local_import_directories,
+    *(
+        each_directory
+        for each_directory, normalized_directory in zip(
+            sys.path,
+            _all_normalized_import_directories,
+        )
+        if normalized_directory not in _all_normalized_local_import_directories
+    ),
+]
+if sys.path != _all_prioritized_import_directories:
+    sys.path[:] = _all_prioritized_import_directories
+
+_all_local_module_prefixes = ("docstring_rule_gate_count_blocker", "hooks_constants")
+for each_module_name, each_module in tuple(sys.modules.items()):
+    if not isinstance(each_module_name, str) or not any(
+        each_module_name == each_prefix or each_module_name.startswith(each_prefix + ".")
+        for each_prefix in _all_local_module_prefixes
+    ):
+        continue
+    module_file = getattr(each_module, "__file__", None)
+    is_local_module = False
+    if isinstance(module_file, (str, os.PathLike)):
+        try:
+            is_local_module = Path(module_file).resolve().is_relative_to(_local_hooks_directory)
+        except (OSError, RuntimeError, TypeError, ValueError):
+            is_local_module = False
+    if not is_local_module:
+        sys.modules.pop(each_module_name, None)
+
+del _all_local_module_prefixes
+del _all_normalized_import_directories
+del _all_normalized_local_import_directories
+del _all_prioritized_import_directories
 
 from docstring_rule_gate_count_blocker import (
     find_gate_count_drift,
@@ -105,6 +157,66 @@ def _target_rule_path(tmp_path: Path) -> Path:
     return tmp_path / TARGET_RULE_BASENAME
 
 
+def _run_test_module_bootstrap(
+    all_import_directories: list[str], run_count: int
+) -> list[str]:
+    """Run this test module against a supplied import path.
+
+    Args:
+        all_import_directories: Import path entries supplied to the module.
+        run_count: Number of module executions.
+
+    Returns:
+        Import path after the final module execution.
+    """
+    all_original_import_directories = list(sys.path)
+    try:
+        sys.path[:] = all_import_directories
+        for each_run_number in range(run_count):
+            runpy.run_path(__file__, run_name=f"bootstrap_probe_{each_run_number}")
+        return list(sys.path)
+    finally:
+        sys.path[:] = all_original_import_directories
+
+
+def should_prioritize_local_import_directories_over_foreign_hooks(tmp_path: Path) -> None:
+    foreign_hooks_directory = str(tmp_path / "hooks")
+    all_import_directories = [
+        foreign_hooks_directory,
+        _local_hooks_directory,
+        "",
+        "tail",
+    ]
+
+    assert _run_test_module_bootstrap(all_import_directories, 1) == [
+        *_all_local_import_directories,
+        foreign_hooks_directory,
+        "",
+        "tail",
+    ]
+
+
+def should_prioritize_local_import_directories_idempotently(tmp_path: Path) -> None:
+    foreign_hooks_directory = str(tmp_path / "hooks")
+    all_import_directories = [
+        foreign_hooks_directory,
+        _local_hooks_directory,
+        _all_local_import_directories[0] + os.sep + ".",
+        _local_hooks_directory + os.sep + ".",
+        "tail",
+    ]
+
+    all_import_directories_after_runs = _run_test_module_bootstrap(all_import_directories, 2)
+
+    assert all_import_directories_after_runs == [
+        *_all_local_import_directories,
+        foreign_hooks_directory,
+        "tail",
+    ]
+    assert all_import_directories_after_runs.count(_all_local_import_directories[0]) == 1
+    assert all_import_directories_after_runs.count(_local_hooks_directory) == 1
+
+
 def should_flag_target_rule_basename() -> None:
     assert is_target_rule_file("/somewhere/" + TARGET_RULE_BASENAME) is True
 

package/hooks/blocking/test_env_var_table_code_drift_blocker.py

@@ -8,17 +8,41 @@ environment variable to a code file whose source never references that variable.
 
 from __future__ import annotations
 
+import json
+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)
+_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
+if str(_BLOCKING_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_BLOCKING_DIRECTORY))
 
 from env_var_table_code_drift_blocker import (  # noqa: E402
     find_drift_rows,
     is_markdown_file,
 )
+from test_hook_subprocess_support import (  # noqa: E402
+    assert_hook_deny_log_contains,
+    run_hook_as_subprocess,
+)
+
+HOOK_PATH = _BLOCKING_DIRECTORY / "env_var_table_code_drift_blocker.py"
+
+
+def _run_hook(
+    file_path: Path, content: str, temporary_repository_root: Path
+) -> subprocess.CompletedProcess[str]:
+    relative_file_path = file_path.relative_to(temporary_repository_root)
+    payload = {
+        "tool_name": "Write",
+        "tool_input": {"file_path": str(relative_file_path), "content": content},
+    }
+    return run_hook_as_subprocess(
+        hook_script_path=HOOK_PATH,
+        payload_text=json.dumps(payload),
+        working_directory=temporary_repository_root,
+        home_directory=temporary_repository_root,
+    )
 
 
 def _write(file_path: Path, content: str) -> None:
@@ -64,6 +88,49 @@ def test_passes_when_variable_present_in_code_file(tmp_path: Path) -> None:
     assert find_drift_rows(content, doc_path.parent) == []
 
 
+def test_production_entrypoint_allows_aligned_table(tmp_path: Path) -> None:
+    _anchor_repo_root(tmp_path)
+    _write(
+        tmp_path / "automation_logging" / "__init__.py",
+        'topic = os.environ["NTFY_TOPIC"]\n',
+    )
+    doc_path = tmp_path / "docs" / "configuration.md"
+    doc_path.parent.mkdir()
+    content = (
+        "| Variable | Used By | Purpose |\n"
+        "|----------|---------|---------|\n"
+        "| `NTFY_TOPIC` | `automation_logging/__init__.py` | ntfy topic |\n"
+    )
+
+    completed = _run_hook(doc_path, content, tmp_path)
+
+    assert completed.returncode == 0, completed.stderr
+    assert completed.stdout == ""
+
+
+def test_production_entrypoint_denies_drifted_table(tmp_path: Path) -> None:
+    _anchor_repo_root(tmp_path)
+    _write(tmp_path / "auth" / "google_auth.py", "def load():\n    return read_bws_secret()\n")
+    doc_path = tmp_path / "docs" / "configuration.md"
+    doc_path.parent.mkdir()
+    content = (
+        "| Variable | Used By | Purpose |\n"
+        "|----------|---------|---------|\n"
+        "| `GOOGLE_APPLICATION_CREDENTIALS` | `auth/google_auth.py` | Path to JSON |\n"
+    )
+
+    completed = _run_hook(doc_path, content, tmp_path)
+
+    parsed_payload = json.loads(completed.stdout)
+    hook_specific_output = parsed_payload["hookSpecificOutput"]
+    assert completed.returncode == 0, completed.stderr
+    assert hook_specific_output["permissionDecision"] == "deny"
+    assert "GOOGLE_APPLICATION_CREDENTIALS -> auth/google_auth.py" in hook_specific_output[
+        "permissionDecisionReason"
+    ]
+    assert_hook_deny_log_contains(tmp_path, "env_var_table_code_drift_blocker.py")
+
+
 def test_skips_row_whose_code_file_is_absent(tmp_path: Path) -> None:
     _anchor_repo_root(tmp_path)
     doc_path = tmp_path / "docs" / "configuration.md"