claude-dev-env 2.3.0 → 2.5.0

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_pr_description_proof_of_work.py

@@ -17,6 +17,7 @@ _HOOKS_ROOT = _HOOK_DIR.parent
 if str(_HOOKS_ROOT) not in sys.path:
     sys.path.insert(0, str(_HOOKS_ROOT))
 
+from blocking import convergence_gate_blocker as convergence_module  # noqa: E402
 from blocking import pr_description_proof_of_work as proof_module  # noqa: E402
 from blocking.pr_description_proof_of_work import (  # noqa: E402
     audit_proof_comment_body,
@@ -70,6 +71,34 @@ def _install_fake_gh(monkeypatch, all_comment_bodies, all_diff_names, diff_text)
     monkeypatch.setattr(proof_module, "_run_gh_command", _fake_run_gh_command)
 
 
+def _install_recording_fake_gh(monkeypatch, all_comment_bodies, all_diff_names, diff_text):
+    all_comment_records = [{"body": each_body} for each_body in all_comment_bodies]
+    all_recorded_argument_lists: list[list[str]] = []
+
+    def _fake_run_gh_command(all_gh_arguments):
+        all_recorded_argument_lists.append(list(all_gh_arguments))
+        if all_gh_arguments and all_gh_arguments[0] == "api":
+            return json.dumps([all_comment_records])
+        if list(all_gh_arguments[:2]) == ["pr", "view"]:
+            return json.dumps({"number": 77})
+        if "--name-only" in all_gh_arguments:
+            return "\n".join(all_diff_names)
+        if list(all_gh_arguments[:2]) == ["pr", "diff"]:
+            return diff_text
+        return None
+
+    monkeypatch.setattr(proof_module, "_run_gh_command", _fake_run_gh_command)
+    return all_recorded_argument_lists
+
+
+def _argument_lists_with_leading(all_recorded_argument_lists, first_token, second_token):
+    return [
+        each_arguments
+        for each_arguments in all_recorded_argument_lists
+        if list(each_arguments[:2]) == [first_token, second_token]
+    ]
+
+
 def test_is_proof_shaped_body_detects_verification_heading() -> None:
     assert is_proof_shaped_body(PASSING_PROOF_COMMENT_BODY)
 
@@ -159,4 +188,126 @@ def test_ready_gate_resolves_pr_number_from_current_branch(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     _install_fake_gh(monkeypatch, [PASSING_PROOF_COMMENT_BODY], ["src/parser.py"], "")
+    monkeypatch.setattr(
+        convergence_module,
+        "_resolve_current_branch_pr_number",
+        lambda all_target_repo, cwd: 77,
+    )
     assert evaluate_pr_ready_gate("gh pr ready") is None
+
+
+def test_ready_gate_reads_comments_from_repo_named_by_flag(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_recorded = _install_recording_fake_gh(
+        monkeypatch, [PASSING_PROOF_COMMENT_BODY], ["src/parser.py"], ""
+    )
+    evaluate_pr_ready_gate("gh pr ready 42 --repo other-owner/other-repo")
+    all_api_calls = _argument_lists_with_leading(
+        all_recorded, "api", "repos/other-owner/other-repo/issues/42/comments"
+    )
+    assert all_api_calls
+    for each_arguments in all_api_calls:
+        assert "{owner}" not in each_arguments[1]
+        assert "{repo}" not in each_arguments[1]
+
+
+def test_ready_gate_resolves_pr_number_from_repo_named_by_flag(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _install_fake_gh(monkeypatch, [PASSING_PROOF_COMMENT_BODY], ["src/parser.py"], "")
+    all_captured_repo_pairs: list[tuple[str, str] | None] = []
+
+    def fake_resolver(all_target_repo: tuple[str, str] | None, cwd: str | None) -> int:
+        all_captured_repo_pairs.append(all_target_repo)
+        return 77
+
+    monkeypatch.setattr(convergence_module, "_resolve_current_branch_pr_number", fake_resolver)
+    evaluate_pr_ready_gate("gh pr ready --repo other-owner/other-repo")
+    assert all_captured_repo_pairs == [("other-owner", "other-repo")]
+
+
+def test_ready_gate_reads_comments_from_repo_named_by_url(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_recorded = _install_recording_fake_gh(
+        monkeypatch, [PASSING_PROOF_COMMENT_BODY], ["src/parser.py"], ""
+    )
+    evaluate_pr_ready_gate("gh pr ready https://github.com/url-owner/url-repo/pull/99")
+    all_api_calls = _argument_lists_with_leading(
+        all_recorded, "api", "repos/url-owner/url-repo/issues/99/comments"
+    )
+    assert all_api_calls
+    all_view_calls = _argument_lists_with_leading(all_recorded, "pr", "view")
+    assert not all_view_calls
+
+
+def test_ready_gate_leaves_bare_command_bound_to_current_directory(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_recorded = _install_recording_fake_gh(
+        monkeypatch, [PASSING_PROOF_COMMENT_BODY], ["src/parser.py"], ""
+    )
+    evaluate_pr_ready_gate("gh pr ready 123")
+    all_api_calls = _argument_lists_with_leading(
+        all_recorded, "api", "repos/{owner}/{repo}/issues/123/comments"
+    )
+    assert all_api_calls
+    for each_arguments in all_recorded:
+        assert "--repo" not in each_arguments
+
+
+def test_ready_gate_ignores_repo_flag_of_chained_command(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_recorded = _install_recording_fake_gh(
+        monkeypatch, [PASSING_PROOF_COMMENT_BODY], ["src/parser.py"], ""
+    )
+    evaluate_pr_ready_gate(
+        "gh pr ready 161 && gh pr comment 999 --repo other-owner/other-repo"
+    )
+    all_api_calls = _argument_lists_with_leading(
+        all_recorded, "api", "repos/{owner}/{repo}/issues/161/comments"
+    )
+    assert all_api_calls
+    for each_arguments in all_recorded:
+        assert "other-owner/other-repo" not in each_arguments
+
+
+def test_ready_gate_reads_comments_from_repo_named_by_full_url_flag(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_recorded = _install_recording_fake_gh(
+        monkeypatch, [PASSING_PROOF_COMMENT_BODY], ["src/parser.py"], ""
+    )
+    evaluate_pr_ready_gate("gh pr ready 42 --repo https://github.com/other-owner/other-repo")
+    all_api_calls = _argument_lists_with_leading(
+        all_recorded, "api", "repos/other-owner/other-repo/issues/42/comments"
+    )
+    assert all_api_calls
+
+
+def test_ready_gate_reads_comments_from_repo_named_by_short_url_flag(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_recorded = _install_recording_fake_gh(
+        monkeypatch, [PASSING_PROOF_COMMENT_BODY], ["src/parser.py"], ""
+    )
+    evaluate_pr_ready_gate("gh pr ready 42 -R https://github.com/other-owner/other-repo")
+    all_api_calls = _argument_lists_with_leading(
+        all_recorded, "api", "repos/other-owner/other-repo/issues/42/comments"
+    )
+    assert all_api_calls
+
+
+def test_ready_gate_reads_comments_from_repo_named_by_ssh_flag(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_recorded = _install_recording_fake_gh(
+        monkeypatch, [PASSING_PROOF_COMMENT_BODY], ["src/parser.py"], ""
+    )
+    evaluate_pr_ready_gate("gh pr ready 42 --repo git@github.com:other-owner/other-repo")
+    all_api_calls = _argument_lists_with_leading(
+        all_recorded, "api", "repos/other-owner/other-repo/issues/42/comments"
+    )
+    assert all_api_calls

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.
 
@@ -633,8 +642,8 @@ def test_dispatcher_write_applies_both_groups() -> None:
     assert "blocking/plain_language_blocker.py" in all_write_script_paths, (
         "plain_language_blocker (Group B) must be in Write applicable set"
     )
-    assert len(all_write_entries) == 20, (
-        f"Write tool must apply to all 20 hosted hooks, got {len(all_write_entries)}"
+    assert len(all_write_entries) == 21, (
+        f"Write tool must apply to all 21 hosted hooks, got {len(all_write_entries)}"
     )
 
 
@@ -647,16 +656,16 @@ def test_dispatcher_edit_applies_both_groups() -> None:
     assert "blocking/stale_comment_reference_blocker.py" in all_edit_script_paths, (
         "stale_comment_reference_blocker belongs in the Edit applicable set"
     )
-    assert len(all_edit_entries) == 21, (
-        f"expected 21 Edit entries, got {len(all_edit_entries)}"
+    assert len(all_edit_entries) == 22, (
+        f"expected 22 Edit entries, got {len(all_edit_entries)}"
     )
 
 
 def test_dispatcher_multi_edit_applies_only_group_b() -> None:
-    """MultiEdit tool triggers only Group B (9 hooks), not Group A."""
+    """MultiEdit tool triggers only Group B (10 hooks), not Group A."""
     all_multi_edit_entries = _applicable_entries_for_tool(MULTI_EDIT_TOOL_NAME)
-    assert len(all_multi_edit_entries) == 9, (
-        f"MultiEdit tool must apply to exactly 9 Group-B hooks, got {len(all_multi_edit_entries)}"
+    assert len(all_multi_edit_entries) == 10, (
+        f"MultiEdit tool must apply to exactly 10 Group-B hooks, got {len(all_multi_edit_entries)}"
     )
 
 
@@ -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 21 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 = (