claude-dev-env 4.3.0 → 7.1.0

package/hooks/blocking/test_luna_fast_mode_gate.py

@@ -1,211 +0,0 @@
-"""Behavior tests for the Codex Luna fast-mode spawn gate."""
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import json
-import pathlib
-import subprocess
-import sys
-from typing import Any
-from unittest import mock
-
-_HOOK_DIR = pathlib.Path(__file__).parent
-_HOOKS_TREE = _HOOK_DIR.parent
-for each_path in (str(_HOOK_DIR), str(_HOOKS_TREE)):
-    if each_path not in sys.path:
-        sys.path.insert(0, each_path)
-
-hook_spec = importlib.util.spec_from_file_location(
-    "luna_fast_mode_gate",
-    _HOOK_DIR / "luna_fast_mode_gate.py",
-)
-assert hook_spec is not None
-assert hook_spec.loader is not None
-hook_module = importlib.util.module_from_spec(hook_spec)
-hook_spec.loader.exec_module(hook_module)
-
-from hooks_constants.luna_fast_mode_gate_constants import (  # noqa: E402
-    AGENT_TOOL_NAME,
-    CALLING_HOOK_NAME,
-    CODEX_AGENT_TOOL_NAME,
-    FAST_SERVICE_TIER,
-    TASK_TOOL_NAME,
-)
-
-_MODEL_ID = "gpt-5.6-luna"
-_NON_LUNA_MODEL_ID = "gpt-5.6-sol"
-_UNRELATED_TOOL_NAME = "Write"
-_SERVICE_TIER_FIELD_NAME = "service_tier"
-_MODEL_FIELD_NAME = "model"
-_DENY_DECISION = "deny"
-
-
-def _spawn_payload(
-    *,
-    tool_name: str = AGENT_TOOL_NAME,
-    model: object = _MODEL_ID,
-    service_tier: object = None,
-    include_service_tier: bool = True,
-) -> dict[str, Any]:
-    """Build one PreToolUse payload for a spawn surface."""
-    tool_input: dict[str, object] = {
-        _MODEL_FIELD_NAME: model,
-    }
-    if include_service_tier:
-        tool_input[_SERVICE_TIER_FIELD_NAME] = service_tier
-    return {"tool_name": tool_name, "tool_input": tool_input}
-
-
-def _run_main(payload: object) -> str:
-    """Run the production hook and return its stdout."""
-    with mock.patch("sys.stdin", io.StringIO(json.dumps(payload))):
-        with mock.patch("sys.stdout", new_callable=io.StringIO) as captured_stdout:
-            try:
-                hook_module.main()
-            except SystemExit:
-                pass
-            return captured_stdout.getvalue()
-
-
-def _decision(payload: object) -> str:
-    """Return the hook decision for a payload."""
-    return json.loads(_run_main(payload))["hookSpecificOutput"]["permissionDecision"]
-
-
-def test_blocks_luna_without_fast_for_headless_and_in_session_surfaces() -> None:
-    all_tool_names = (AGENT_TOOL_NAME, TASK_TOOL_NAME, CODEX_AGENT_TOOL_NAME)
-    for each_tool_name in all_tool_names:
-        payload = _spawn_payload(tool_name=each_tool_name, service_tier="flex")
-        assert _decision(payload) == _DENY_DECISION
-
-
-def test_allows_luna_with_exact_fast_service_tier() -> None:
-    for each_tool_name in (AGENT_TOOL_NAME, TASK_TOOL_NAME, CODEX_AGENT_TOOL_NAME):
-        payload = _spawn_payload(
-            tool_name=each_tool_name,
-            service_tier=FAST_SERVICE_TIER,
-        )
-        assert _run_main(payload) == ""
-
-
-def test_allows_luna_with_native_priority_service_tier() -> None:
-    payload = _spawn_payload(
-        tool_name=CODEX_AGENT_TOOL_NAME,
-        service_tier="priority",
-    )
-    assert _run_main(payload) == ""
-
-
-def test_blocks_luna_with_priority_for_agent_and_task_surfaces() -> None:
-    for each_tool_name in (AGENT_TOOL_NAME, TASK_TOOL_NAME):
-        payload = _spawn_payload(
-            tool_name=each_tool_name,
-            service_tier="priority",
-        )
-        assert _decision(payload) == _DENY_DECISION
-
-
-def test_blocks_missing_and_non_string_service_tier() -> None:
-    assert _decision(_spawn_payload(include_service_tier=False)) == _DENY_DECISION
-    assert _decision(_spawn_payload(service_tier=None)) == _DENY_DECISION
-    assert _decision(_spawn_payload(service_tier=True)) == _DENY_DECISION
-
-
-def test_blocks_default_and_wrong_case_fast_service_tiers() -> None:
-    assert _decision(_spawn_payload(service_tier="default")) == _DENY_DECISION
-    assert _decision(_spawn_payload(service_tier="FAST")) == _DENY_DECISION
-
-
-def test_allows_non_luna_and_unrelated_tool_payloads() -> None:
-    assert _run_main(_spawn_payload(model=_NON_LUNA_MODEL_ID)) == ""
-    assert _run_main(
-        _spawn_payload(tool_name=_UNRELATED_TOOL_NAME, service_tier="flex")
-    ) == ""
-
-
-def test_recognizes_case_insensitive_luna_model_segments() -> None:
-    assert _decision(_spawn_payload(model="GPT-5.6-LUNA", service_tier="flex")) == (
-        _DENY_DECISION
-    )
-    assert _run_main(_spawn_payload(model="gpt-5.6-lunacy", service_tier="flex")) == ""
-
-
-def test_malformed_outer_payload_allows() -> None:
-    assert _run_main({"tool_name": AGENT_TOOL_NAME}) == ""
-    assert _run_main({"tool_name": AGENT_TOOL_NAME, "tool_input": []}) == ""
-    assert _run_main("not an object") == ""
-    assert _run_main({"tool_name": AGENT_TOOL_NAME, "tool_input": {_MODEL_FIELD_NAME: 7}}) == ""
-
-
-def test_deny_payload_and_log_do_not_include_a_prompt() -> None:
-    payload = _spawn_payload(service_tier="default")
-    with mock.patch.object(hook_module, "log_hook_block") as recorded_block:
-        output = _run_main(payload)
-    parsed_output = json.loads(output)
-    assert parsed_output["hookSpecificOutput"]["permissionDecision"] == _DENY_DECISION
-    assert recorded_block.call_args.kwargs["calling_hook_name"] == CALLING_HOOK_NAME
-    assert "prompt" not in recorded_block.call_args.kwargs["offending_input_preview"]
-
-
-def test_hooks_json_registers_all_spawn_surfaces() -> None:
-    hooks_configuration = json.loads(
-        (_HOOKS_TREE / "hooks.json").read_text(encoding="utf-8")
-    )
-    matching_groups = [
-        each_group
-        for each_group in hooks_configuration["hooks"]["PreToolUse"]
-        if CALLING_HOOK_NAME
-        in " ".join(each_hook["command"] for each_hook in each_group["hooks"])
-    ]
-    assert len(matching_groups) == 1
-    assert matching_groups[0]["matcher"] == (
-        f"{AGENT_TOOL_NAME}|{TASK_TOOL_NAME}|{CODEX_AGENT_TOOL_NAME}"
-    )
-    registered_command = matching_groups[0]["hooks"][0]["command"]
-    assert registered_command.endswith(
-        f"/hooks/blocking/{CALLING_HOOK_NAME}"
-    )
-    assert (_HOOKS_TREE / "blocking" / CALLING_HOOK_NAME).is_file()
-
-
-def test_registered_command_runs_under_windows_cmd_for_allow_and_deny() -> None:
-    hooks_configuration = json.loads(
-        (_HOOKS_TREE / "hooks.json").read_text(encoding="utf-8")
-    )
-    matching_group = next(
-        each_group
-        for each_group in hooks_configuration["hooks"]["PreToolUse"]
-        if CALLING_HOOK_NAME
-        in " ".join(each_hook["command"] for each_hook in each_group["hooks"])
-    )
-    registered_command = matching_group["hooks"][0]["command"]
-    assert registered_command.startswith("python ")
-    command_line = registered_command.replace(
-        "${CLAUDE_PLUGIN_ROOT}",
-        str(_HOOKS_TREE.parent).replace("\\", "/"),
-    )
-
-    for each_service_tier, expected_output in (
-        (FAST_SERVICE_TIER, ""),
-        ("flex", _DENY_DECISION),
-    ):
-        completed_process = subprocess.run(
-            command_line,
-            input=json.dumps(_spawn_payload(service_tier=each_service_tier)),
-            capture_output=True,
-            shell=True,
-            text=True,
-            check=False,
-        )
-        assert completed_process.returncode == 0, completed_process.stderr
-        if expected_output == "":
-            assert completed_process.stdout == ""
-        else:
-            assert (
-                json.loads(completed_process.stdout)["hookSpecificOutput"][
-                    "permissionDecision"
-                ]
-                == expected_output
-            )

package/hooks/blocking/test_nas_ssh_binary_enforcer.py

@@ -1,225 +0,0 @@
-"""Unit tests for nas-ssh-binary-enforcer PreToolUse hook.
-
-The real NAS host, ssh user, and port are private, so these tests set them via
-the ``CLAUDE_NAS_*`` environment variables and drive the real hook, asserting
-the runtime-built host pattern and deny messages.
-"""
-
-import importlib.util
-import os
-import pathlib
-import sys
-from collections.abc import Iterator
-from unittest.mock import patch
-
-import pytest
-
-_HOOK_DIR = pathlib.Path(__file__).parent
-if str(_HOOK_DIR) not in sys.path:
-    sys.path.insert(0, str(_HOOK_DIR))
-if str(_HOOK_DIR.parent) not in sys.path:
-    sys.path.insert(0, str(_HOOK_DIR.parent))
-
-hook_spec = importlib.util.spec_from_file_location(
-    "nas_ssh_binary_enforcer",
-    _HOOK_DIR / "nas_ssh_binary_enforcer.py",
-)
-assert hook_spec is not None
-assert hook_spec.loader is not None
-hook_module = importlib.util.module_from_spec(hook_spec)
-hook_spec.loader.exec_module(hook_module)
-_find_nas_ssh_violation = hook_module._find_nas_ssh_violation
-
-from hooks_constants.local_identity import (  # noqa: E402
-    bare_ssh_binary_deny_message,
-    missing_batch_mode_deny_message,
-)
-
-NAS_HOST = "test-nas.example.net"
-NAS_SSH_USER = "tester"
-NAS_SSH_PORT = "2222"
-
-
-@pytest.fixture(autouse=True)
-def _set_nas_identity_env() -> Iterator[None]:
-    with patch.dict(
-        os.environ,
-        {
-            "CLAUDE_NAS_HOST": NAS_HOST,
-            "CLAUDE_NAS_SSH_USER": NAS_SSH_USER,
-            "CLAUDE_NAS_SSH_PORT": NAS_SSH_PORT,
-        },
-        clear=False,
-    ):
-        yield
-
-
-def test_bare_ssh_to_nas_is_denied_with_binary_message() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            f'ssh -p {NAS_SSH_PORT} {NAS_SSH_USER}@{NAS_HOST} "ls /volume1"'
-        )
-        == bare_ssh_binary_deny_message()
-    )
-
-
-def test_bare_scp_to_nas_is_denied() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            f"scp -P {NAS_SSH_PORT} file.txt {NAS_SSH_USER}@{NAS_HOST}:/volume1/"
-        )
-        == bare_ssh_binary_deny_message()
-    )
-
-
-def test_bare_sftp_to_nas_is_denied() -> None:
-    assert (
-        _find_nas_ssh_violation(f"sftp -P {NAS_SSH_PORT} {NAS_SSH_USER}@{NAS_HOST}")
-        == bare_ssh_binary_deny_message()
-    )
-
-
-def test_bare_ssh_to_nas_behind_launcher_wrapper_is_denied() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            f'timeout 10 ssh -p {NAS_SSH_PORT} {NAS_SSH_USER}@{NAS_HOST} "uptime"'
-        )
-        == bare_ssh_binary_deny_message()
-    )
-
-
-def test_bare_ssh_to_nas_after_shell_operator_is_denied() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            f'cd /tmp && ssh -p {NAS_SSH_PORT} {NAS_SSH_USER}@{NAS_HOST} "uptime"'
-        )
-        == bare_ssh_binary_deny_message()
-    )
-
-
-def test_bare_ssh_to_nas_after_glued_operator_is_denied() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            f'true;ssh -p {NAS_SSH_PORT} {NAS_SSH_USER}@{NAS_HOST} "uptime"'
-        )
-        == bare_ssh_binary_deny_message()
-    )
-
-
-def test_bare_ssh_to_nas_after_pipe_ampersand_operator_is_denied() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            f'echo start |& ssh -p {NAS_SSH_PORT} {NAS_SSH_USER}@{NAS_HOST} "echo hi"'
-        )
-        == bare_ssh_binary_deny_message()
-    )
-
-
-def test_full_openssh_binary_to_nas_without_batchmode_is_denied() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            '"/c/Windows/System32/OpenSSH/ssh.exe" -o ConnectTimeout=10 '
-            f'-p {NAS_SSH_PORT} {NAS_SSH_USER}@{NAS_HOST} "uptime"'
-        )
-        == missing_batch_mode_deny_message()
-    )
-
-
-def test_full_openssh_scp_to_nas_without_batchmode_is_denied() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            '"/c/Windows/System32/OpenSSH/scp.exe" '
-            f"-P {NAS_SSH_PORT} file.txt {NAS_SSH_USER}@{NAS_HOST}:/volume1/"
-        )
-        == missing_batch_mode_deny_message()
-    )
-
-
-def test_full_openssh_binary_to_nas_with_batchmode_is_allowed() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            '"/c/Windows/System32/OpenSSH/ssh.exe" -o BatchMode=yes '
-            f'-o ConnectTimeout=10 -p {NAS_SSH_PORT} {NAS_SSH_USER}@{NAS_HOST} "uptime"'
-        )
-        is None
-    )
-
-
-def test_full_openssh_binary_glued_batchmode_flag_is_allowed() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            '"/c/Windows/System32/OpenSSH/ssh.exe" -oBatchMode=yes '
-            f'-p {NAS_SSH_PORT} {NAS_SSH_USER}@{NAS_HOST} "uptime"'
-        )
-        is None
-    )
-
-
-def test_bare_ssh_to_other_host_is_allowed() -> None:
-    assert _find_nas_ssh_violation(f'ssh -p 22 {NAS_SSH_USER}@example.com "uptime"') is None
-
-
-def test_full_openssh_binary_to_other_host_without_batchmode_is_allowed() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            f'"/c/Windows/System32/OpenSSH/ssh.exe" -p 22 {NAS_SSH_USER}@example.com "uptime"'
-        )
-        is None
-    )
-
-
-def test_nas_host_as_echoed_data_is_allowed() -> None:
-    assert _find_nas_ssh_violation(f'echo "connect via ssh to {NAS_HOST}"') is None
-
-
-def test_nas_host_mentioned_without_ssh_command_word_is_allowed() -> None:
-    assert _find_nas_ssh_violation(f"ping -c 1 {NAS_HOST}") is None
-
-
-def test_ssh_family_word_only_in_remote_command_argument_is_allowed() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            '"/c/Windows/System32/OpenSSH/ssh.exe" -o BatchMode=yes '
-            f'-p {NAS_SSH_PORT} {NAS_SSH_USER}@{NAS_HOST} "grep ssh /etc/config"'
-        )
-        is None
-    )
-
-
-def test_nas_host_in_different_segment_than_ssh_is_allowed() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            f'echo {NAS_HOST} && ssh -p 22 {NAS_SSH_USER}@example.com "id"'
-        )
-        is None
-    )
-
-
-def test_ssh_to_other_host_with_nas_host_in_remote_command_is_allowed() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            f'ssh -p 22 {NAS_SSH_USER}@example.com "ping -c1 {NAS_HOST}"'
-        )
-        is None
-    )
-
-
-def test_scp_to_other_host_with_nas_host_in_remote_path_is_allowed() -> None:
-    assert (
-        _find_nas_ssh_violation(
-            f"scp -P 22 f.txt {NAS_SSH_USER}@example.com:/backup/{NAS_HOST}/"
-        )
-        is None
-    )
-
-
-def test_similar_host_suffix_is_not_matched() -> None:
-    assert _find_nas_ssh_violation(f'ssh -p 22 {NAS_SSH_USER}@{NAS_HOST}x "id"') is None
-
-
-def test_empty_command_is_allowed() -> None:
-    assert _find_nas_ssh_violation("") is None
-
-
-def test_unbalanced_quotes_command_is_allowed() -> None:
-    assert _find_nas_ssh_violation(f"ssh 'unterminated {NAS_HOST}") is None

package/hooks/blocking/test_orchestrator_refresh_reschedule_gate.py

@@ -1,231 +0,0 @@
-"""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 / ".agents" / "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