claude-dev-env 2.4.0 → 2.5.0

package/hooks/blocking/pre_tool_use_dispatcher.py

@@ -7,10 +7,10 @@ declared in the constants module, aggregates the results, and emits one deny
 decision when any hook denied (carrying every denying reason) or exits zero to
 allow.
 
-The per-hook coverage matrix:
-- Write  -> 20 hooks from ALL_HOSTED_HOOK_ENTRIES that list Write
-- Edit   -> 21 hooks from ALL_HOSTED_HOOK_ENTRIES that list Edit
-- MultiEdit -> 9 hooks from ALL_HOSTED_HOOK_ENTRIES that list MultiEdit
+Each tool runs the ``ALL_HOSTED_HOOK_ENTRIES`` whose ``applicable_tool_names``
+list that tool; that roster is the live source of the per-tool coverage, and the
+dispatcher roster tests in ``test_pre_tool_use_dispatcher.py`` assert the counts,
+rather than a hardcoded matrix here that would drift as hooks are added.
 """
 
 from __future__ import annotations
@@ -24,20 +24,18 @@ from collections.abc import Callable
 from dataclasses import dataclass, field
 from pathlib import Path
 
-_hooks_directory = str(Path(__file__).resolve().parent.parent)
-if _hooks_directory not in sys.path:
-    sys.path.insert(0, _hooks_directory)
+import _path_setup  # noqa: F401
 
-from plain_language_blocker import (  # noqa: E402
+from plain_language_blocker import (
     build_deny_payload as build_plain_language_deny_payload,
 )
-from plain_language_blocker import evaluate as evaluate_plain_language  # noqa: E402
-from state_description_blocker import (  # noqa: E402
+from plain_language_blocker import evaluate as evaluate_plain_language
+from state_description_blocker import (
     build_deny_payload as build_state_description_deny_payload,
 )
-from state_description_blocker import evaluate as evaluate_state_description  # noqa: E402
+from state_description_blocker import evaluate as evaluate_state_description
 
-from hooks_constants.pre_tool_use_dispatcher_constants import (  # noqa: E402
+from hooks_constants.pre_tool_use_dispatcher_constants import (
     ALL_HOSTED_HOOK_ENTRIES,
     ALLOW_DECISION,
     BLOCKING_CRASH_DENY_REASON,
@@ -49,7 +47,7 @@ from hooks_constants.pre_tool_use_dispatcher_constants import (  # noqa: E402
     STATE_DESCRIPTION_BLOCKER_MODULE_NAME,
     HostedHookEntry,
 )
-from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin  # noqa: E402
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
 
 NativeEvaluator = Callable[[dict[str, object]], str | None]
 DenyPayloadBuilder = Callable[[str], dict[str, object]]
@@ -70,6 +68,18 @@ class NativeHook:
     build_deny_payload: DenyPayloadBuilder
 
 
+_native_hook_by_module_name: dict[str, NativeHook] = {
+    STATE_DESCRIPTION_BLOCKER_MODULE_NAME: NativeHook(
+        evaluate=evaluate_state_description,
+        build_deny_payload=build_state_description_deny_payload,
+    ),
+    PLAIN_LANGUAGE_BLOCKER_MODULE_NAME: NativeHook(
+        evaluate=evaluate_plain_language,
+        build_deny_payload=build_plain_language_deny_payload,
+    ),
+}
+
+
 @dataclass
 class HostedHookResult:
     """Outcome of running one hosted hook inside the dispatcher process.
@@ -477,17 +487,7 @@ def _run_one_hosted_hook(
         The HostedHookResult for this hook's run.
     """
     if each_entry.native_module_name is not None:
-        native_hook_by_module_name: dict[str, NativeHook] = {
-            STATE_DESCRIPTION_BLOCKER_MODULE_NAME: NativeHook(
-                evaluate=evaluate_state_description,
-                build_deny_payload=build_state_description_deny_payload,
-            ),
-            PLAIN_LANGUAGE_BLOCKER_MODULE_NAME: NativeHook(
-                evaluate=evaluate_plain_language,
-                build_deny_payload=build_plain_language_deny_payload,
-            ),
-        }
-        native_hook = native_hook_by_module_name[each_entry.native_module_name]
+        native_hook = _native_hook_by_module_name[each_entry.native_module_name]
         return run_native_hook(native_hook, payload_by_key, each_entry.is_blocking)
     script_path = _resolve_hook_script_path(each_entry.script_relative_path)
     return run_hosted_hook(script_path, payload_text, each_entry.is_blocking)

package/hooks/blocking/test_code_review_pr_create_gate.py

@@ -43,6 +43,12 @@ store_module = _load_module("code_review_stamp_store")
 deny_module = _load_module("code_review_gate_deny")
 
 
+@pytest.fixture(autouse=True)
+def enable_code_review_enforcement(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Behavior tests exercise the gates with enforcement on."""
+    monkeypatch.setattr(gate_module, "CODE_REVIEW_ENFORCEMENT_ENABLED", True)
+
+
 def _run_git(repository_directory: Path, *git_arguments: str) -> None:
     subprocess.run(
         ["git", "-C", str(repository_directory), *git_arguments],
@@ -183,3 +189,11 @@ def test_build_deny_payload_shape() -> None:
     deny_payload = deny_module.build_code_review_deny_payload("blocked reason")
     assert deny_payload["hookSpecificOutput"]["permissionDecision"] == "deny"
     assert deny_payload["hookSpecificOutput"]["permissionDecisionReason"] == "blocked reason"
+
+
+def test_enforcement_off_allows_pr_create_without_stamp(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setattr(gate_module, "CODE_REVIEW_ENFORCEMENT_ENABLED", False)
+    work_directory = _prepared_repo(monkeypatch, tmp_path)
+    assert gate_module.deny_reason_for_directory(str(work_directory)) is None

package/hooks/blocking/test_code_review_push_gate.py

@@ -46,6 +46,12 @@ gate_module = _load_module("code_review_push_gate")
 store_module = _load_module("code_review_stamp_store")
 
 
+@pytest.fixture(autouse=True)
+def enable_code_review_enforcement(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Behavior tests exercise the gates with enforcement on."""
+    monkeypatch.setattr(gate_module, "CODE_REVIEW_ENFORCEMENT_ENABLED", True)
+
+
 def _run_git(repository_directory: Path, *git_arguments: str) -> None:
     subprocess.run(
         ["git", "-C", str(repository_directory), *git_arguments],
@@ -187,3 +193,13 @@ def test_code_review_skip_marker_allows_push(
     work_directory = _prepared_code_repo(monkeypatch, tmp_path)
     emitted = _run_main(monkeypatch, f"git push origin main {BYPASS_MARKER}", work_directory)
     assert emitted == ""
+
+
+def test_enforcement_off_allows_push_without_stamp(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setattr(gate_module, "CODE_REVIEW_ENFORCEMENT_ENABLED", False)
+    work_directory = _prepared_code_repo(monkeypatch, tmp_path)
+    assert gate_module.deny_reason_for_directory(str(work_directory)) is None
+    emitted = _run_main(monkeypatch, "git push origin main", work_directory)
+    assert emitted == ""

package/hooks/blocking/test_code_review_stamp_directory_write_blocker.py

@@ -53,6 +53,12 @@ def _load_module(module_name: str) -> ModuleType:
 blocker_module = _load_module("code_review_stamp_directory_write_blocker")
 
 
+@pytest.fixture(autouse=True)
+def enable_code_review_enforcement(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Behavior tests exercise the write-blocker with enforcement on."""
+    monkeypatch.setattr(blocker_module, "CODE_REVIEW_ENFORCEMENT_ENABLED", True)
+
+
 def _isolate_home(monkeypatch: pytest.MonkeyPatch, fake_home: Path) -> None:
     home_text = str(fake_home)
     monkeypatch.setenv("HOME", home_text)
@@ -178,3 +184,16 @@ def test_chr_chain_obfuscated_stamp_path_is_blocked() -> None:
 
 def test_benign_decode_to_other_path_is_not_blocked() -> None:
     assert not blocker_module.references_stamp_directory(_hex_forge(BENIGN_OBFUSCATION_PATH))
+
+
+def test_enforcement_off_allows_stamp_directory_access(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(blocker_module, "CODE_REVIEW_ENFORCEMENT_ENABLED", False)
+    decision = blocker_module.decision_for_payload(
+        {
+            "tool_name": "Bash",
+            "tool_input": {"command": "rm -rf ~/.claude/code-review-stamps"},
+        }
+    )
+    assert decision is None

package/hooks/blocking/test_orchestrator_refresh_reschedule_gate.py

@@ -0,0 +1,231 @@
+"""Tests for orchestrator_refresh_reschedule_gate PreToolUse hook."""
+
+from __future__ import annotations
+
+import importlib.util
+import io
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+BLOCKING_DIRECTORY = Path(__file__).resolve().parent
+HOOKS_DIRECTORY = BLOCKING_DIRECTORY.parent
+if str(HOOKS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(HOOKS_DIRECTORY))
+
+SKILL_SCRIPTS = HOOKS_DIRECTORY.parent / "skills" / "orchestrator" / "scripts"
+if str(SKILL_SCRIPTS) not in sys.path:
+    sys.path.insert(0, str(SKILL_SCRIPTS))
+
+from status_gate_constants.config.constants import RUN_STATUS_ACTIVE, RUN_STATUS_DONE  # noqa: E402
+from status_gate import write_status_file  # noqa: E402
+
+
+def load_gate_module() -> ModuleType:
+    module_path = BLOCKING_DIRECTORY / "orchestrator_refresh_reschedule_gate.py"
+    spec = importlib.util.spec_from_file_location(
+        "orchestrator_refresh_reschedule_gate",
+        module_path,
+    )
+    assert spec is not None
+    assert spec.loader is not None
+    gate_module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = gate_module
+    spec.loader.exec_module(gate_module)
+    return gate_module
+
+
+def run_main_with_payload(
+    gate_module: ModuleType,
+    payload: dict[str, object],
+    monkeypatch: pytest.MonkeyPatch,
+) -> tuple[int, str]:
+    stdin_buffer = io.StringIO(json.dumps(payload))
+    stdout_buffer = io.StringIO()
+    monkeypatch.setattr(sys, "stdin", stdin_buffer)
+    monkeypatch.setattr(sys, "stdout", stdout_buffer)
+    exit_code = 0
+    try:
+        gate_module.main()
+    except SystemExit as system_exit:
+        exit_code = int(system_exit.code or 0)
+    return exit_code, stdout_buffer.getvalue()
+
+
+class TestOrchestratorRefreshRescheduleGate:
+    def should_allow_when_status_is_active(
+        self,
+        temporary_directory: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        status_file_path = temporary_directory / "status.json"
+        write_status_file(status_file_path, RUN_STATUS_ACTIVE, "", is_rearm_pending=False)
+        monkeypatch.setenv("ORCHESTRATOR_RUN_STATUS_FILE", str(status_file_path))
+        gate_module = load_gate_module()
+        payload = {
+            "tool_name": "ScheduleWakeup",
+            "tool_input": {"prompt": "/orchestrator-refresh", "delaySeconds": 1200},
+            "cwd": str(temporary_directory),
+        }
+        exit_code, stdout_text = run_main_with_payload(
+            gate_module, payload, monkeypatch
+        )
+        assert exit_code == 0
+        assert stdout_text == ""
+
+    def should_deny_when_status_is_done(
+        self,
+        temporary_directory: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        status_file_path = temporary_directory / "status.json"
+        write_status_file(status_file_path, RUN_STATUS_DONE, "", is_rearm_pending=False)
+        monkeypatch.setenv("ORCHESTRATOR_RUN_STATUS_FILE", str(status_file_path))
+        gate_module = load_gate_module()
+        payload = {
+            "tool_name": "ScheduleWakeup",
+            "tool_input": {"prompt": "/orchestrator-refresh re-arm"},
+            "cwd": str(temporary_directory),
+        }
+        exit_code, stdout_text = run_main_with_payload(
+            gate_module, payload, monkeypatch
+        )
+        assert exit_code == 0
+        denial = json.loads(stdout_text)
+        assert denial["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+    def should_deny_when_status_file_missing(
+        self,
+        temporary_directory: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        missing_path = temporary_directory / "nope.json"
+        monkeypatch.setenv("ORCHESTRATOR_RUN_STATUS_FILE", str(missing_path))
+        gate_module = load_gate_module()
+        payload = {
+            "tool_name": "ScheduleWakeup",
+            "tool_input": {"prompt": "/orchestrator-refresh now"},
+            "cwd": str(temporary_directory),
+        }
+        _exit_code, stdout_text = run_main_with_payload(
+            gate_module, payload, monkeypatch
+        )
+        denial = json.loads(stdout_text)
+        assert denial["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+    def should_deny_when_rearm_slot_already_pending(
+        self,
+        temporary_directory: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        status_file_path = temporary_directory / "status.json"
+        write_status_file(
+            status_file_path, RUN_STATUS_ACTIVE, "", is_rearm_pending=True
+        )
+        monkeypatch.setenv("ORCHESTRATOR_RUN_STATUS_FILE", str(status_file_path))
+        gate_module = load_gate_module()
+        payload = {
+            "tool_name": "ScheduleWakeup",
+            "tool_input": {"prompt": "/orchestrator-refresh", "delaySeconds": 1200},
+            "cwd": str(temporary_directory),
+        }
+        _exit_code, stdout_text = run_main_with_payload(
+            gate_module, payload, monkeypatch
+        )
+        denial = json.loads(stdout_text)
+        assert denial["hookSpecificOutput"]["permissionDecision"] == "deny"
+        assert "rearm_already_pending" in denial["hookSpecificOutput"][
+            "permissionDecisionReason"
+        ]
+
+    def should_always_deny_cron_create_for_orchestrator_refresh(
+        self,
+        temporary_directory: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        status_file_path = temporary_directory / "status.json"
+        write_status_file(status_file_path, RUN_STATUS_ACTIVE, "", is_rearm_pending=False)
+        monkeypatch.setenv("ORCHESTRATOR_RUN_STATUS_FILE", str(status_file_path))
+        gate_module = load_gate_module()
+        payload = {
+            "tool_name": "CronCreate",
+            "tool_input": {"prompt": "/orchestrator-refresh"},
+            "cwd": str(temporary_directory),
+        }
+        _exit_code, stdout_text = run_main_with_payload(
+            gate_module, payload, monkeypatch
+        )
+        denial = json.loads(stdout_text)
+        assert denial["hookSpecificOutput"]["permissionDecision"] == "deny"
+        assert "cron_create_forbidden" in denial["hookSpecificOutput"][
+            "permissionDecisionReason"
+        ]
+
+    def should_ignore_unrelated_schedule_prompts(
+        self,
+        temporary_directory: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        gate_module = load_gate_module()
+        payload = {
+            "tool_name": "ScheduleWakeup",
+            "tool_input": {"prompt": "/pr-converge"},
+            "cwd": str(temporary_directory),
+        }
+        exit_code, stdout_text = run_main_with_payload(
+            gate_module, payload, monkeypatch
+        )
+        assert exit_code == 0
+        assert stdout_text == ""
+
+    def should_ignore_prose_mention_of_orchestrator_refresh(
+        self,
+        temporary_directory: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        gate_module = load_gate_module()
+        payload = {
+            "tool_name": "ScheduleWakeup",
+            "tool_input": {
+                "prompt": "See docs about /orchestrator-refresh for later"
+            },
+            "cwd": str(temporary_directory),
+        }
+        exit_code, stdout_text = run_main_with_payload(
+            gate_module, payload, monkeypatch
+        )
+        assert exit_code == 0
+        assert stdout_text == ""
+
+    def should_allow_when_prompt_carries_run_slug_for_scoped_status(
+        self,
+        temporary_directory: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        run_slug = "demo-run"
+        status_file_path = temporary_directory.joinpath(
+            "docs", "plans", run_slug, ".orchestrator-run-status.json"
+        )
+        write_status_file(status_file_path, RUN_STATUS_ACTIVE, run_slug, is_rearm_pending=False)
+        monkeypatch.delenv("ORCHESTRATOR_RUN_STATUS_FILE", raising=False)
+        gate_module = load_gate_module()
+        payload = {
+            "tool_name": "ScheduleWakeup",
+            "tool_input": {
+                "prompt": f"/orchestrator-refresh --run-slug {run_slug}"
+            },
+            "cwd": str(temporary_directory),
+        }
+        exit_code, stdout_text = run_main_with_payload(
+            gate_module, payload, monkeypatch
+        )
+        assert exit_code == 0
+        assert stdout_text == ""
+
+
+@pytest.fixture
+def temporary_directory(tmp_path: Path) -> Path:
+    return tmp_path

package/hooks/blocking/test_pre_tool_use_dispatcher.py

@@ -300,6 +300,15 @@ def test_plain_language_denial_on_multi_edit_of_markdown_file() -> None:
     _assert_dispatcher_matches_individual_hooks(payload_text, MULTI_EDIT_TOOL_NAME)
 
 
+def test_dispatcher_docstring_points_at_roster_not_hardcoded_counts() -> None:
+    """The dispatcher docstring names the roster, not per-tool counts that drift."""
+    dispatcher_source = Path(_DISPATCHER_SCRIPT).read_text(encoding="utf-8")
+    assert "ALL_HOSTED_HOOK_ENTRIES" in dispatcher_source
+    assert "-> 20 hooks" not in dispatcher_source
+    assert "-> 21 hooks" not in dispatcher_source
+    assert "-> 9 hooks" not in dispatcher_source
+
+
 def test_multi_edit_runs_only_group_b_hooks() -> None:
     """Dispatcher invokes only Group-B hooks on MultiEdit, not Group-A hooks.
 
@@ -667,7 +676,7 @@ def test_proceed_after_run_all_validators_removal_allows() -> None:
     it was never a PreToolUse hook and never hosted by the PreToolUse dispatcher.
     A Python Write payload that run_all_validators would have flagged (mypy errors, for
     instance) still produces ALLOW from the PreToolUse dispatcher because the PreToolUse
-    dispatcher covers only its 22 hosted blocking hooks — none of which includes the
+    dispatcher covers only its 23 hosted blocking hooks — none of which includes the
     validators runner.
     """
     python_content_with_type_error = (