claude-dev-env 4.1.0 → 4.3.0

package/hooks/blocking/test_pr_description_writer_gate.py

@@ -1,234 +0,0 @@
-"""Unit tests for the pr-description-writer PreToolUse gate on gh pr create."""
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import json
-import sys
-from pathlib import Path
-from unittest import mock
-
-import pytest
-
-_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
-_HOOKS_DIRECTORY = _BLOCKING_DIRECTORY.parent
-for each_directory in (_BLOCKING_DIRECTORY, _HOOKS_DIRECTORY):
-    if str(each_directory) not in sys.path:
-        sys.path.insert(0, str(each_directory))
-
-_GATE_SPEC = importlib.util.spec_from_file_location(
-    "pr_description_writer_gate",
-    _BLOCKING_DIRECTORY / "pr_description_writer_gate.py",
-)
-assert _GATE_SPEC is not None
-assert _GATE_SPEC.loader is not None
-gate_module = importlib.util.module_from_spec(_GATE_SPEC)
-_GATE_SPEC.loader.exec_module(gate_module)
-
-_GATE_CONSTANTS = importlib.import_module(
-    "hooks_constants.pr_description_writer_gate_constants"
-)
-_PR_DESCRIPTION_WRITER_SUBAGENT_TYPE = _GATE_CONSTANTS.PR_DESCRIPTION_WRITER_SUBAGENT_TYPE
-
-_SESSION_ID = "session-abc123"
-_PLAIN_CREATE_COMMAND = 'gh pr create --draft --title "feat: add it" --body-file body.md'
-
-
-def _payload(command: str, tool_name: str = "Bash") -> dict[str, object]:
-    """Build a PreToolUse payload carrying one shell command.
-
-    Args:
-        command: The shell command the gate inspects.
-        tool_name: The tool the command runs through.
-
-    Returns:
-        The payload dictionary the gate reads from stdin.
-    """
-    return {
-        "tool_name": tool_name,
-        "session_id": _SESSION_ID,
-        "tool_input": {"command": command},
-    }
-
-
-def _printed_output_for(command: str, temp_directory: Path, tool_name: str = "Bash") -> str:
-    """Run the gate against one command and return everything it printed.
-
-    Args:
-        command: The shell command the gate inspects.
-        temp_directory: The directory standing in for the system temp root.
-        tool_name: The tool the command runs through.
-
-    Returns:
-        The gate's stripped stdout — empty on an allow.
-    """
-    captured_stdout = io.StringIO()
-    payload_text = json.dumps(_payload(command, tool_name))
-    with (
-        mock.patch("sys.stdin", io.StringIO(payload_text)),
-        mock.patch("sys.stdout", captured_stdout),
-        mock.patch.object(_GATE_CONSTANTS.tempfile, "gettempdir", return_value=str(temp_directory)),
-        pytest.raises(SystemExit),
-    ):
-        gate_module.main()
-    return captured_stdout.getvalue().strip()
-
-
-def _decision_for(command: str, temp_directory: Path, tool_name: str = "Bash") -> str:
-    """Return the gate's permission decision for one command.
-
-    Args:
-        command: The shell command the gate inspects.
-        temp_directory: The directory standing in for the system temp root.
-        tool_name: The tool the command runs through.
-
-    Returns:
-        The ``permissionDecision`` string, or an empty string on an allow.
-    """
-    printed_text = _printed_output_for(command, temp_directory, tool_name)
-    if not printed_text:
-        return ""
-    hook_output = json.loads(printed_text).get("hookSpecificOutput", {})
-    return str(hook_output.get("permissionDecision", ""))
-
-
-def _record_spawn(temp_directory: Path, session_id: str = _SESSION_ID) -> None:
-    """Write the marker file that stands for a recorded agent spawn.
-
-    Args:
-        temp_directory: The directory standing in for the system temp root.
-    """
-    marker_name = (
-        f"{_GATE_CONSTANTS.SPAWN_MARKER_FILE_PREFIX}{session_id}"
-        f"{_GATE_CONSTANTS.SPAWN_MARKER_FILE_SUFFIX}"
-    )
-    (temp_directory / marker_name).touch()
-
-
-def should_deny_pr_create_with_no_recorded_spawn(tmp_path: Path) -> None:
-    """A gh pr create with no recorded spawn is denied."""
-    assert _decision_for(_PLAIN_CREATE_COMMAND, tmp_path) == "deny"
-
-
-def should_allow_pr_create_after_a_recorded_spawn(tmp_path: Path) -> None:
-    """A gh pr create is allowed once this session recorded a spawn."""
-    _record_spawn(tmp_path)
-    assert _decision_for(_PLAIN_CREATE_COMMAND, tmp_path) == ""
-
-
-def should_allow_pr_create_carrying_the_bypass_marker(tmp_path: Path) -> None:
-    """A trailing bypass comment allows the create with no recorded spawn."""
-    command = f"{_PLAIN_CREATE_COMMAND} {gate_module.SPAWN_BYPASS_MARKER}"
-    assert _decision_for(command, tmp_path) == ""
-
-
-def should_allow_multiline_pr_create_carrying_the_bypass_marker(tmp_path: Path) -> None:
-    """A final bypass comment allows a create after a continued shell line."""
-    command = f"cd . && \\\n+{_PLAIN_CREATE_COMMAND} {gate_module.SPAWN_BYPASS_MARKER}"
-    assert _decision_for(command, tmp_path) == ""
-
-
-def should_deny_when_the_bypass_marker_follows_another_shell_segment(tmp_path: Path) -> None:
-    """A final marker for echo cannot opt a preceding create out."""
-    command = f"{_PLAIN_CREATE_COMMAND} && echo {gate_module.SPAWN_BYPASS_MARKER}"
-    assert _decision_for(command, tmp_path) == "deny"
-
-
-def should_deny_when_only_another_session_has_a_spawn_marker(tmp_path: Path) -> None:
-    """A marker from another session cannot unlock this session's create."""
-    _record_spawn(tmp_path, session_id="earlier-session")
-    assert _decision_for(_PLAIN_CREATE_COMMAND, tmp_path) == "deny"
-
-
-def should_deny_when_the_marker_text_sits_inside_a_quoted_value(tmp_path: Path) -> None:
-    """The bypass text inside a quoted title leaves the gate running."""
-    command = 'gh pr create --title "fix # pr-description-skip" --body-file body.md'
-    assert _decision_for(command, tmp_path) == "deny"
-
-
-def should_deny_a_pr_create_that_follows_another_command(tmp_path: Path) -> None:
-    """A create in a later command segment is still gated."""
-    command = f"cd /repo && {_PLAIN_CREATE_COMMAND}"
-    assert _decision_for(command, tmp_path) == "deny"
-
-
-@pytest.mark.parametrize("shell_tool_name", ["Bash", "PowerShell"])
-def should_gate_each_shell_tool(shell_tool_name: str, tmp_path: Path) -> None:
-    """Both shell tools reach the gate."""
-    decision = _decision_for(_PLAIN_CREATE_COMMAND, tmp_path, tool_name=shell_tool_name)
-    assert decision == "deny"
-
-
-@pytest.mark.parametrize(
-    "unrelated_command",
-    [
-        "gh pr edit 12 --body-file body.md",
-        "gh pr comment 12 --body-file body.md",
-        "gh pr ready 12",
-        "gh issue create --title x --body-file body.md",
-        "git commit -m x",
-        "echo gh pr create",
-    ],
-)
-def should_stay_quiet_for_a_command_that_creates_no_pull_request(
-    unrelated_command: str, tmp_path: Path
-) -> None:
-    """A command other than gh pr create passes untouched."""
-    assert _decision_for(unrelated_command, tmp_path) == ""
-
-
-def should_stay_quiet_for_a_tool_that_runs_no_shell(tmp_path: Path) -> None:
-    """A non-shell tool carrying the same text passes untouched."""
-    assert _decision_for(_PLAIN_CREATE_COMMAND, tmp_path, tool_name="Write") == ""
-
-
-def should_deny_when_the_payload_names_no_session(tmp_path: Path) -> None:
-    """A payload with no session id reads as no record and denies.
-
-    A shared fallback marker would let one session's spawn silently clear a
-    later session's create, so an unusable session id denies instead.
-    """
-    _record_spawn(tmp_path)
-    captured_stdout = io.StringIO()
-    payload = _payload(_PLAIN_CREATE_COMMAND)
-    payload["session_id"] = ""
-    with (
-        mock.patch("sys.stdin", io.StringIO(json.dumps(payload))),
-        mock.patch("sys.stdout", captured_stdout),
-        mock.patch.object(_GATE_CONSTANTS.tempfile, "gettempdir", return_value=str(tmp_path)),
-        pytest.raises(SystemExit),
-    ):
-        gate_module.main()
-    hook_output = json.loads(captured_stdout.getvalue().strip())["hookSpecificOutput"]
-    assert hook_output["permissionDecision"] == "deny"
-
-
-def should_allow_an_untokenizable_command(tmp_path: Path) -> None:
-    """A command that will not tokenize fails open."""
-    assert _decision_for('gh pr create --title "unclosed', tmp_path) == ""
-
-
-def should_name_both_ways_forward_in_the_denial(tmp_path: Path) -> None:
-    """The denial text names the agent spawn and the bypass marker."""
-    printed_text = _printed_output_for(_PLAIN_CREATE_COMMAND, tmp_path)
-    denial_reason = json.loads(printed_text)["hookSpecificOutput"]["permissionDecisionReason"]
-    assert _PR_DESCRIPTION_WRITER_SUBAGENT_TYPE in denial_reason
-    assert gate_module.SPAWN_BYPASS_MARKER in denial_reason
-
-
-def should_read_the_marker_path_the_shared_builder_produces(tmp_path: Path) -> None:
-    """The gate reads exactly the file the shared path builder names.
-
-    The tracker writes through `spawn_marker_path` and the gate reads through it,
-    so neither side owns a private copy of the marker file name.
-    """
-    marker_file = _GATE_CONSTANTS.spawn_marker_path(_SESSION_ID, temp_directory=tmp_path)
-    assert marker_file is not None
-    marker_file.touch()
-    assert _decision_for(_PLAIN_CREATE_COMMAND, tmp_path) == ""
-
-
-def should_deny_when_the_session_id_names_no_marker(tmp_path: Path) -> None:
-    """A session id that sanitizes to nothing yields no path, so the gate denies."""
-    assert _GATE_CONSTANTS.spawn_marker_path("", temp_directory=tmp_path) is None

package/hooks/blocking/test_preflight_check.py

@@ -1,343 +0,0 @@
-#!/usr/bin/env python3
-"""
-PreToolUse:Bash hook that validates prerequisites before running test commands.
-
-Intercepts playwright/pytest commands and checks:
-  1. Target server is reachable and healthy
-  2. Database file exists (for Django projects)
-  3. (Playwright only) Django server has --test-db flag
-  4. (Playwright only) Frontend builds successfully before e2e tests
-
-Blocks doomed test runs early instead of letting them hang for minutes.
-"""
-import json
-import os
-import re
-import subprocess
-import sys
-from urllib.parse import urlparse
-
-try:
-    import psutil
-except Exception:
-    psutil = None
-
-TEST_COMMAND_PATTERNS = [
-    re.compile(r'\bplaywright\s+test\b'),
-    re.compile(r'\bnpx\s+playwright\b'),
-    re.compile(r'\bpytest\b'),
-    re.compile(r'\bpython\s+-m\s+pytest\b'),
-]
-
-SERVER_URL_PATTERN = re.compile(r'https?://[^\s"\']+')
-
-DEFAULT_PLAYWRIGHT_URL = "http://localhost:3000"
-DEFAULT_DJANGO_URL = "http://localhost:8000"
-
-CURL_TIMEOUT_SECONDS = 2
-DJANGO_DB_FILENAME = "db.sqlite3"
-
-BLOCKED_STATUS_CODES = {500, 502, 503, 504}
-HEALTH_CHECK_ERROR_TEMPLATE = "BLOCKED: Server at {} is not healthy ({}). Fix the server before running tests."
-UNREACHABLE_ERROR_TEMPLATE = "BLOCKED: Server at {} is unreachable. Start the server before running tests."
-MISSING_DB_ERROR_TEMPLATE = "BLOCKED: No database file ({}) found in {}. Run migrations before running tests."
-FRONTEND_BUILD_FAILED_MESSAGE = "BLOCKED: Frontend build failed. Fix build errors before running e2e tests."
-MISSING_TEST_DB_FLAG_TEMPLATE = "BLOCKED: Django server on port {} is not running with --test-db. Restart with: python manage.py runserver --test-db 0.0.0.0:{}"
-PORT_CONFLICT_ERROR_TEMPLATE = "BLOCKED: Multiple Django runserver processes are bound to port {} across worktrees: {}. Stop stale servers first."
-FRONTEND_DIRECTORY_NAME = "frontend"
-NPM_BUILD_COMMAND = "npm run build"
-COLLECTSTATIC_COMMAND = "python manage.py collectstatic --noinput"
-BUILD_TIMEOUT_SECONDS = 120
-PLAYWRIGHT_COMMAND_PATTERNS = [
-    re.compile(r'\bplaywright\s+test\b'),
-    re.compile(r'\bnpx\s+playwright\b'),
-]
-
-
-def is_test_command(command: str) -> bool:
-    for each_pattern in TEST_COMMAND_PATTERNS:
-        if each_pattern.search(command):
-            return True
-    return False
-
-
-def is_playwright_command(command: str) -> bool:
-    for each_pattern in PLAYWRIGHT_COMMAND_PATTERNS:
-        if each_pattern.search(command):
-            return True
-    return False
-
-
-def extract_target_url(command: str) -> str:
-    url_match = SERVER_URL_PATTERN.search(command)
-    if url_match:
-        return url_match.group(0)
-
-    is_playwright = "playwright" in command
-    if is_playwright:
-        return DEFAULT_PLAYWRIGHT_URL
-
-    is_pytest = "pytest" in command
-    if is_pytest:
-        return DEFAULT_DJANGO_URL
-
-    return DEFAULT_PLAYWRIGHT_URL
-
-
-def check_server_health(target_url: str) -> str | None:
-    try:
-        curl_result = subprocess.run(
-            ["curl", "-s", "-o", "/dev/null", "-w", "%{http_code}", "--max-time", str(CURL_TIMEOUT_SECONDS), target_url],
-            capture_output=True,
-            text=True,
-            timeout=CURL_TIMEOUT_SECONDS + 1,
-        )
-        http_status_code = int(curl_result.stdout.strip())
-    except (subprocess.TimeoutExpired, ValueError, OSError):
-        return UNREACHABLE_ERROR_TEMPLATE.format(target_url)
-
-    if http_status_code == 0:
-        return UNREACHABLE_ERROR_TEMPLATE.format(target_url)
-
-    if http_status_code in BLOCKED_STATUS_CODES:
-        return HEALTH_CHECK_ERROR_TEMPLATE.format(target_url, f"HTTP {http_status_code}")
-
-    return None
-
-
-def find_project_root(command: str) -> str | None:
-    working_directory = os.environ.get("PWD", os.getcwd())
-
-    directory_match = re.search(r'--project[= ](\S+)', command)
-    if directory_match:
-        return os.path.abspath(directory_match.group(1))
-
-    cd_match = re.search(r'cd\s+"([^"]+)"', command) or re.search(r"cd\s+'([^']+)'", command) or re.search(r'cd\s+(\S+)', command)
-    if cd_match:
-        cd_target = cd_match.group(1)
-        if os.path.isabs(cd_target):
-            return cd_target
-        return os.path.join(working_directory, cd_target)
-
-    return working_directory
-
-
-def check_django_database(command: str) -> str | None:
-    is_django_test = "pytest" in command or "manage.py" in command
-    if not is_django_test:
-        return None
-
-    project_root = find_project_root(command)
-    if not project_root:
-        return None
-
-    manage_py_path = os.path.join(project_root, "manage.py")
-    if not os.path.exists(manage_py_path):
-        return None
-
-    database_path = os.path.join(project_root, DJANGO_DB_FILENAME)
-    if os.path.exists(database_path):
-        return None
-
-    return MISSING_DB_ERROR_TEMPLATE.format(DJANGO_DB_FILENAME, project_root)
-
-
-def find_frontend_directory(command: str) -> str | None:
-    project_root = find_project_root(command)
-    if not project_root:
-        return None
-
-    frontend_path = os.path.join(project_root, FRONTEND_DIRECTORY_NAME)
-    if os.path.isdir(frontend_path):
-        return frontend_path
-
-    return None
-
-
-def build_frontend(command: str) -> str | None:
-    frontend_path = find_frontend_directory(command)
-    if not frontend_path:
-        return None
-
-    project_root = find_project_root(command)
-
-    npm_build_result = subprocess.run(
-        NPM_BUILD_COMMAND.split(),
-        cwd=frontend_path,
-        capture_output=True,
-        text=True,
-        timeout=BUILD_TIMEOUT_SECONDS,
-    )
-    if npm_build_result.returncode != 0:
-        return FRONTEND_BUILD_FAILED_MESSAGE
-
-    collectstatic_result = subprocess.run(
-        COLLECTSTATIC_COMMAND.split(),
-        cwd=project_root,
-        capture_output=True,
-        text=True,
-        timeout=BUILD_TIMEOUT_SECONDS,
-    )
-    if collectstatic_result.returncode != 0:
-        return FRONTEND_BUILD_FAILED_MESSAGE
-
-    return None
-
-
-def extract_port_from_url(target_url: str) -> str:
-    parsed_url = urlparse(target_url)
-    if parsed_url.port:
-        return str(parsed_url.port)
-    return "8000"
-
-
-def check_test_db_flag(target_url: str) -> str | None:
-    port = extract_port_from_url(target_url)
-
-    try:
-        ps_result = subprocess.run(
-            ["ps", "aux"],
-            capture_output=True,
-            text=True,
-            timeout=CURL_TIMEOUT_SECONDS,
-        )
-    except (subprocess.TimeoutExpired, OSError):
-        return None
-
-    is_runserver_found = False
-    for each_line in ps_result.stdout.splitlines():
-        if "runserver" not in each_line:
-            continue
-        if "grep" in each_line:
-            continue
-        is_runserver_found = True
-        if "--test-db" in each_line:
-            return None
-
-    if not is_runserver_found:
-        return None
-
-    return MISSING_TEST_DB_FLAG_TEMPLATE.format(port, port)
-
-
-def _get_runserver_processes_on_port(target_port: str) -> list[tuple[int, str]]:
-    if psutil is None:
-        return []
-
-    runserver_processes: list[tuple[int, str]] = []
-    port_token = f":{target_port}"
-
-    for each_process in psutil.process_iter(["pid", "cmdline", "cwd"]):
-        try:
-            commandline_parts = each_process.info.get("cmdline") or []
-            if len(commandline_parts) < 3:
-                continue
-            if commandline_parts[1] != "manage.py" or commandline_parts[2] != "runserver":
-                continue
-
-            full_commandline = " ".join(commandline_parts)
-            if port_token not in full_commandline:
-                continue
-
-            process_working_directory = each_process.info.get("cwd") or ""
-            runserver_processes.append((each_process.info["pid"], process_working_directory))
-        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess, KeyError):
-            continue
-
-    return runserver_processes
-
-
-def check_runserver_port_conflicts(target_url: str, project_root: str | None) -> str | None:
-    parsed_target_url = urlparse(target_url)
-    target_host = parsed_target_url.hostname or ""
-    if target_host not in {"localhost", "127.0.0.1", "0.0.0.0"}:
-        return None
-
-    target_port = str(parsed_target_url.port or 8000)
-    runserver_processes = _get_runserver_processes_on_port(target_port)
-    if len(runserver_processes) <= 1:
-        return None
-
-    project_root_realpath = os.path.realpath(project_root) if project_root else None
-    unique_directories: set[str] = set()
-    for _, directory_path in runserver_processes:
-        if not directory_path:
-            continue
-        unique_directories.add(os.path.realpath(directory_path))
-
-    if len(unique_directories) <= 1:
-        return None
-
-    if project_root_realpath and project_root_realpath in unique_directories:
-        other_worktrees = sorted(path for path in unique_directories if path != project_root_realpath)
-        if not other_worktrees:
-            return None
-        return PORT_CONFLICT_ERROR_TEMPLATE.format(target_port, ", ".join(other_worktrees))
-
-    return PORT_CONFLICT_ERROR_TEMPLATE.format(target_port, ", ".join(sorted(unique_directories)))
-
-
-def build_deny_response(reason: str) -> dict:
-    return {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": reason,
-        }
-    }
-
-
-def main() -> None:
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    tool_name = hook_input.get("tool_name", "")
-    if tool_name != "Bash":
-        sys.exit(0)
-
-    command = hook_input.get("tool_input", {}).get("command", "")
-    if not is_test_command(command):
-        sys.exit(0)
-
-    project_root = find_project_root(command)
-    is_django_project = project_root and os.path.exists(os.path.join(project_root, "manage.py"))
-
-    if not is_django_project and not is_playwright_command(command):
-        sys.exit(0)
-
-    database_error = check_django_database(command)
-    if database_error:
-        print(json.dumps(build_deny_response(database_error)))
-        sys.exit(0)
-
-    target_url = extract_target_url(command)
-
-    is_e2e_test = is_playwright_command(command)
-    if is_e2e_test:
-        conflict_error = check_runserver_port_conflicts(target_url, project_root)
-        if conflict_error:
-            print(json.dumps(build_deny_response(conflict_error)))
-            sys.exit(0)
-
-        test_db_error = check_test_db_flag(target_url)
-        if test_db_error:
-            print(json.dumps(build_deny_response(test_db_error)))
-            sys.exit(0)
-
-        frontend_build_error = build_frontend(command)
-        if frontend_build_error:
-            print(json.dumps(build_deny_response(frontend_build_error)))
-            sys.exit(0)
-
-    server_error = check_server_health(target_url)
-    if server_error:
-        print(json.dumps(build_deny_response(server_error)))
-        sys.exit(0)
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/test_test_preflight_check.py

@@ -1,80 +0,0 @@
-"""Production-path tests for pytest-Django and Playwright preflight selection."""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
-_DISPATCHER_PATH = _BLOCKING_DIRECTORY / "bash_pre_tool_use_dispatcher.py"
-if str(_BLOCKING_DIRECTORY) not in sys.path:
-    sys.path.insert(0, str(_BLOCKING_DIRECTORY))
-
-from test_hook_subprocess_support import (  # noqa: E402
-    build_bash_payload,
-    read_hook_permission_decision,
-    run_hook_as_subprocess,
-)
-
-
-def _run_bash_dispatch(
-    command: str, project_root: Path
-) -> subprocess.CompletedProcess[str]:
-    return run_hook_as_subprocess(
-        hook_script_path=_DISPATCHER_PATH,
-        payload_text=build_bash_payload(command),
-        working_directory=project_root,
-        home_directory=project_root,
-        environment_updates_by_name={"PWD": str(project_root)},
-    )
-
-
-def _create_django_project_fixture(tmp_path: Path) -> Path:
-    project_root = tmp_path / "django-project"
-    project_root.mkdir()
-    (project_root / "manage.py").write_text(
-        "import sys\n\nif __name__ == '__main__':\n    sys.exit(0)\n",
-        encoding="utf-8",
-    )
-    return project_root
-
-
-def test_dispatcher_selects_pytest_django_changed_test(tmp_path: Path) -> None:
-    project_root = _create_django_project_fixture(tmp_path)
-
-    command = "python -m pytest tests/test_models.py"
-    completed_process = _run_bash_dispatch(command, project_root)
-
-    assert completed_process.returncode == 0, completed_process.stderr
-    decision, reason = read_hook_permission_decision(completed_process.stdout)
-    assert decision == "deny"
-    assert "No database file (db.sqlite3)" in reason
-
-
-def test_dispatcher_ignores_unrecognized_django_test_runner(tmp_path: Path) -> None:
-    project_root = _create_django_project_fixture(tmp_path)
-
-    command = "python -m unittest tests/test_models.py"
-    completed_process = _run_bash_dispatch(command, project_root)
-
-    assert completed_process.returncode == 0, completed_process.stderr
-    assert completed_process.stdout == ""
-
-
-def test_dispatcher_selects_playwright_changed_spec(tmp_path: Path) -> None:
-    command = "npx playwright test tests/account.spec.ts --base-url http://127.0.0.1:1"
-    completed_process = _run_bash_dispatch(command, tmp_path)
-
-    assert completed_process.returncode == 0, completed_process.stderr
-    decision, reason = read_hook_permission_decision(completed_process.stdout)
-    assert decision == "deny"
-    assert "Server at http://127.0.0.1:1 is unreachable" in reason
-
-
-def test_dispatcher_ignores_non_playwright_test_runner(tmp_path: Path) -> None:
-    command = "node tests/account.spec.ts"
-    completed_process = _run_bash_dispatch(command, tmp_path)
-
-    assert completed_process.returncode == 0, completed_process.stderr
-    assert completed_process.stdout == ""