claude-dev-env 2.2.1 → 2.4.0

package/hooks/blocking/test_code_verifier_spawn_preflight_gate.py

@@ -183,6 +183,20 @@ def other_value() -> int:
     return 42
 '''
 
+BROKEN_ENFORCER_SOURCE = (
+    '"""Enforcer stub that raises a non-import error at load time."""\n'
+    "\n"
+    "raise RuntimeError('deliberate enforcer load failure')\n"
+)
+
+RE_ERROR_ENFORCER_SOURCE = (
+    '"""Enforcer stub whose module-scope regex compile raises re.error."""\n'
+    "\n"
+    "import re\n"
+    "\n"
+    "re.compile('(')\n"
+)
+
 
 def run_git(repository_root: Path, *git_arguments: str) -> str:
     completed = subprocess.run(
@@ -240,16 +254,24 @@ def advance_origin_main_divergent(
     run_git(repository_root, "checkout", "feature")
 
 
-def write_agent_payload(subagent_type: str, prompt: str, cwd: Path) -> str:
+def _spawn_payload(tool_name: str, subagent_type: str, prompt: str, cwd: Path) -> str:
     return json.dumps(
         {
-            "tool_name": "Agent",
+            "tool_name": tool_name,
             "tool_input": {"subagent_type": subagent_type, "prompt": prompt},
             "cwd": str(cwd),
         }
     )
 
 
+def write_agent_payload(subagent_type: str, prompt: str, cwd: Path) -> str:
+    return _spawn_payload("Agent", subagent_type, prompt, cwd)
+
+
+def write_task_payload(subagent_type: str, prompt: str, cwd: Path) -> str:
+    return _spawn_payload("Task", subagent_type, prompt, cwd)
+
+
 def run_hook(payload: str, cwd: Path) -> subprocess.CompletedProcess[str]:
     return subprocess.run(
         [sys.executable, str(HOOK_PATH)],
@@ -586,3 +608,103 @@ def test_hook_imports_real_config_when_parent_holds_shadowing_config(
 
     assert "ModuleNotFoundError" not in completed.stderr
     assert completed.returncode == 0
+
+
+def test_task_tool_code_verifier_spawn_is_gated_like_agent(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    initialize_repository(repository_root)
+    run_git(repository_root, "checkout", "-b", "feature")
+    write_working_tree_file(repository_root, "fresh.py", VIOLATING_MODULE_SOURCE)
+    task_payload = write_task_payload("code-verifier", "verify the change", repository_root)
+    task_result = run_hook(task_payload, repository_root)
+    assert not is_allow(task_result)
+    task_reason = deny_reason(task_result)
+    assert "fresh.py" in task_reason
+    assert "CODE_RULES violations on changed lines:" in task_reason
+    clean_coder_payload = write_task_payload("clean-coder", "write code", repository_root)
+    clean_coder_result = run_hook(clean_coder_payload, repository_root)
+    assert is_allow(clean_coder_result)
+
+
+def stage_package_and_feature_repo(tmp_path: Path) -> tuple[Path, Path]:
+    """Copy the hook package and build a clean feature repo for load-failure tests.
+
+    Args:
+        tmp_path: The pytest temporary directory the staged copy lands under.
+
+    Returns:
+        A ``(staged_enforcer_path, repository_root)`` pair: the copied
+        ``code_rules_enforcer.py`` a test renders unloadable, and the clean
+        feature repository the staged hook runs against.
+    """
+    real_hooks_directory = HOOK_PATH.parent.parent
+    real_package_directory = real_hooks_directory.parent
+    staged_package_directory = tmp_path / "claude-dev-env"
+    shutil.copytree(real_hooks_directory, staged_package_directory / "hooks")
+    shutil.copytree(
+        real_package_directory / "_shared", staged_package_directory / "_shared"
+    )
+    enforcer_path = staged_package_directory / "hooks" / "blocking" / "code_rules_enforcer.py"
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    initialize_repository(repository_root)
+    run_git(repository_root, "checkout", "-b", "feature")
+    write_working_tree_file(repository_root, "feature.py", CLEAN_MODULE_SOURCE)
+    return enforcer_path, repository_root
+
+
+def run_staged_preflight_hook(
+    enforcer_path: Path, repository_root: Path
+) -> subprocess.CompletedProcess[str]:
+    """Run the staged preflight hook that sits beside *enforcer_path*.
+
+    Args:
+        enforcer_path: The staged ``code_rules_enforcer.py`` path; the staged
+            hook is its sibling in the same ``hooks/blocking`` directory.
+        repository_root: The feature repository the hook inspects.
+
+    Returns:
+        The completed hook subprocess run.
+    """
+    staged_hook = enforcer_path.parent / "code_verifier_spawn_preflight_gate.py"
+    payload = write_agent_payload("code-verifier", "verify the change", repository_root)
+    return subprocess.run(
+        [sys.executable, str(staged_hook)],
+        check=False,
+        input=payload,
+        capture_output=True,
+        text=True,
+        cwd=str(repository_root),
+        timeout=120,
+    )
+
+
+def test_engine_load_failure_denies_with_named_reason(tmp_path: Path) -> None:
+    enforcer_path, repository_root = stage_package_and_feature_repo(tmp_path)
+    enforcer_path.unlink()
+    completed = run_staged_preflight_hook(enforcer_path, repository_root)
+    assert not is_allow(completed)
+    reason = deny_reason(completed)
+    assert "CODE_RULES engine failed to load" in reason
+    assert "load_validate_content" in reason
+
+
+def test_engine_import_error_denies_with_named_reason(tmp_path: Path) -> None:
+    enforcer_path, repository_root = stage_package_and_feature_repo(tmp_path)
+    enforcer_path.write_text(BROKEN_ENFORCER_SOURCE, encoding="utf-8")
+    completed = run_staged_preflight_hook(enforcer_path, repository_root)
+    assert not is_allow(completed)
+    reason = deny_reason(completed)
+    assert "CODE_RULES engine failed to load" in reason
+    assert "load_validate_content" in reason
+
+
+def test_engine_re_error_denies_with_named_reason(tmp_path: Path) -> None:
+    enforcer_path, repository_root = stage_package_and_feature_repo(tmp_path)
+    enforcer_path.write_text(RE_ERROR_ENFORCER_SOURCE, encoding="utf-8")
+    completed = run_staged_preflight_hook(enforcer_path, repository_root)
+    assert not is_allow(completed)
+    reason = deny_reason(completed)
+    assert "CODE_RULES engine failed to load" in reason
+    assert "load_validate_content" in reason

package/hooks/blocking/test_code_verifier_tools_contract.py

@@ -0,0 +1,28 @@
+"""Contract: code-verifier cannot message a warm session-advisor."""
+
+from pathlib import Path
+
+_PACKAGE_ROOT = Path(__file__).resolve().parents[2]
+_CODE_VERIFIER_AGENT_PATH = _PACKAGE_ROOT / "agents" / "code-verifier.md"
+_FRONTMATTER_OPEN = "---\n"
+_FRONTMATTER_CLOSE = "\n---\n"
+_TOOLS_PREFIX = "tools:"
+_SEND_MESSAGE_TOOL_NAME = "SendMessage"
+
+
+def test_code_verifier_tools_exclude_sendmessage() -> None:
+    """tools frontmatter must not list SendMessage (warm-advisor path closed)."""
+    agent_text = _CODE_VERIFIER_AGENT_PATH.read_text(encoding="utf-8")
+    assert agent_text.startswith(_FRONTMATTER_OPEN), "missing frontmatter open"
+    frontmatter_end = agent_text.find(_FRONTMATTER_CLOSE, len(_FRONTMATTER_OPEN))
+    assert frontmatter_end > 0, "missing frontmatter close"
+    frontmatter_body = agent_text[len(_FRONTMATTER_OPEN) : frontmatter_end]
+    all_tools_lines = [
+        each_line
+        for each_line in frontmatter_body.splitlines()
+        if each_line.startswith(_TOOLS_PREFIX)
+    ]
+    assert len(all_tools_lines) == 1, all_tools_lines
+    tools_value = all_tools_lines[0].removeprefix(_TOOLS_PREFIX).strip()
+    all_tool_names = {each_name.strip() for each_name in tools_value.split(",")}
+    assert _SEND_MESSAGE_TOOL_NAME not in all_tool_names, all_tool_names

package/hooks/blocking/test_convergence_gate_blocker.py

@@ -4,6 +4,7 @@ import importlib.util
 import io
 import json
 import pathlib
+import re
 import subprocess
 import sys
 
@@ -13,8 +14,6 @@ _HOOK_DIR = pathlib.Path(__file__).parent
 if str(_HOOK_DIR) not in sys.path:
     sys.path.insert(0, str(_HOOK_DIR))
 
-import re
-
 _GH_PR_READY_PATTERN = re.compile(r"\bgh\s+pr\s+ready\b(?![^&|;\n]*--undo)")
 
 hook_spec = importlib.util.spec_from_file_location(
@@ -53,15 +52,44 @@ def test_does_not_match_gh_issue_close() -> None:
 
 
 def test_extracts_pr_number_from_command() -> None:
-    assert _resolve_pr_number("gh pr ready 418", None) == 418
+    assert _resolve_pr_number("gh pr ready 418", None, None, None) == 418
+
+
+def test_extracts_pr_number_when_repo_flag_precedes_number() -> None:
+    assert (
+        _resolve_pr_number(
+            "gh pr ready --repo sample-owner/target-repo 161",
+            None,
+            "sample-owner",
+            "target-repo",
+        )
+        == 161
+    )
 
 
 def test_extracts_pr_number_with_flags() -> None:
-    assert _resolve_pr_number("gh pr ready 99 --undo", None) == 99
+    assert _resolve_pr_number("gh pr ready 99 --undo", None, None, None) == 99
 
 
 def test_returns_none_when_no_number_and_no_repo() -> None:
-    assert _resolve_pr_number("gh pr ready", "/nonexistent/path") is None
+    assert _resolve_pr_number("gh pr ready", "/nonexistent/path", None, None) is None
+
+
+def test_number_resolution_binds_gh_view_to_named_repo(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured_commands: list[list[str]] = []
+
+    def fake_run(all_arguments: list[str], **_kwargs: object) -> subprocess.CompletedProcess[str]:
+        captured_commands.append(all_arguments)
+        return subprocess.CompletedProcess(args=all_arguments, returncode=0, stdout="500\n", stderr="")
+
+    monkeypatch.setattr(hook_module.subprocess, "run", fake_run)
+    assert _resolve_pr_number("gh pr ready", None, "flag-owner", "flag-repo") == 500
+    assert captured_commands
+    for each_command in captured_commands:
+        assert "--repo" in each_command
+        assert "flag-owner/flag-repo" in each_command
 
 
 def test_matches_gh_pr_ready_in_compound_command() -> None:
@@ -226,6 +254,13 @@ def test_parse_repo_flag_short_alias() -> None:
     )
 
 
+def test_parse_repo_flag_short_alias_attached_value() -> None:
+    assert hook_module._parse_repo_flag("gh pr ready 161 -Rsample-owner/target-repo") == (
+        "sample-owner",
+        "target-repo",
+    )
+
+
 def test_parse_repo_flag_absent_returns_none() -> None:
     assert hook_module._parse_repo_flag("gh pr ready 418") is None
 
@@ -249,6 +284,26 @@ def test_ready_segment_clips_at_command_separator() -> None:
     )
 
 
+def test_ready_segment_keeps_repo_flag_on_a_continued_line() -> None:
+    segment = hook_module._ready_command_segment(
+        "gh pr ready 161 \\\n  --repo target-owner/target-repo"
+    )
+    assert "--repo" in segment
+    assert "target-owner/target-repo" in segment
+
+
+def test_continued_repo_flag_binds_the_gate_to_the_named_repo(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    identity = _capture_convergence_identity(
+        monkeypatch,
+        tmp_path,
+        "gh pr ready 161 \\\n  --repo target-owner/target-repo",
+        ("cwd-owner", "cwd-repo"),
+    )
+    assert identity == ("target-owner", "target-repo", 161)
+
+
 def test_chained_repo_flag_does_not_misbind_the_gate(
     monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
 ) -> None:
@@ -278,3 +333,96 @@ def test_ready_segment_skips_a_leading_undo_invocation() -> None:
         hook_module._ready_command_segment("gh pr ready --undo && gh pr ready 161")
         == "gh pr ready 161"
     )
+
+
+def test_parse_repo_flag_full_url_form() -> None:
+    assert hook_module._parse_repo_flag(
+        "gh pr ready 161 --repo https://github.com/other-owner/other-repo"
+    ) == ("other-owner", "other-repo")
+
+
+def test_parse_repo_flag_short_alias_full_url_form() -> None:
+    assert hook_module._parse_repo_flag(
+        "gh pr ready 161 -R https://github.com/other-owner/other-repo"
+    ) == ("other-owner", "other-repo")
+
+
+def test_parse_repo_flag_ssh_form() -> None:
+    assert hook_module._parse_repo_flag(
+        "gh pr ready 161 --repo git@github.com:other-owner/other-repo"
+    ) == ("other-owner", "other-repo")
+
+
+def test_parse_repo_flag_ssh_form_strips_git_suffix() -> None:
+    assert hook_module._parse_repo_flag(
+        "gh pr ready 161 --repo git@github.com:other-owner/other-repo.git"
+    ) == ("other-owner", "other-repo")
+
+
+def test_parse_repo_flag_url_form_strips_git_suffix() -> None:
+    assert hook_module._parse_repo_flag(
+        "gh pr ready 161 --repo https://github.com/other-owner/other-repo.git"
+    ) == ("other-owner", "other-repo")
+
+
+def test_parse_pr_url_accepts_enterprise_host() -> None:
+    assert hook_module._parse_pr_url(
+        "gh pr ready https://github.example.com/other-owner/other-repo/pull/161"
+    ) == ("other-owner", "other-repo", 161)
+
+
+def test_background_operator_clips_chained_repo_flag(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    identity = _capture_convergence_identity(
+        monkeypatch,
+        tmp_path,
+        "gh pr ready 161 & gh pr comment 999 --repo other-owner/other-repo",
+        ("cwd-owner", "cwd-repo"),
+    )
+    assert identity == ("cwd-owner", "cwd-repo", 161)
+
+
+def test_trailing_redirect_keeps_earlier_repo_flag(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    identity = _capture_convergence_identity(
+        monkeypatch,
+        tmp_path,
+        "gh pr ready 161 --repo other-owner/other-repo 2>&1",
+        ("cwd-owner", "cwd-repo"),
+    )
+    assert identity == ("other-owner", "other-repo", 161)
+
+
+def test_stderr_redirect_dup_keeps_repo_flag() -> None:
+    segment = hook_module._ready_command_segment(
+        "gh pr ready 161 >&2 --repo other-owner/other-repo"
+    )
+    assert hook_module._parse_repo_flag(segment) == ("other-owner", "other-repo")
+
+
+def test_stderr_to_stdout_redirect_keeps_repo_flag() -> None:
+    segment = hook_module._ready_command_segment(
+        "gh pr ready 2>&1 --repo other-owner/other-repo"
+    )
+    assert hook_module._parse_repo_flag(segment) == ("other-owner", "other-repo")
+
+
+def test_append_all_output_redirect_keeps_repo_flag() -> None:
+    segment = hook_module._ready_command_segment(
+        "gh pr ready 161 &> log --repo other-owner/other-repo"
+    )
+    assert hook_module._parse_repo_flag(segment) == ("other-owner", "other-repo")
+
+
+def test_stderr_redirect_binds_repo_end_to_end(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    identity = _capture_convergence_identity(
+        monkeypatch,
+        tmp_path,
+        "gh pr ready 161 >&2 --repo other-owner/other-repo",
+        ("cwd-owner", "cwd-repo"),
+    )
+    assert identity == ("other-owner", "other-repo", 161)

package/hooks/blocking/test_destructive_command_blocker.py

@@ -1,4 +1,4 @@
-"""Tests for destructive-command-blocker hook."""
+"""Tests for the destructive-command-blocker hook."""
 
 import json
 import os

package/hooks/blocking/test_destructive_command_blocker_deny_mode.py

@@ -0,0 +1,45 @@
+"""Tests for the destructive-command-blocker deny mode.
+
+The sandbox runs under ``--dangerously-skip-permissions``, which auto-resolves
+an ``ask`` decision, so only a hard ``deny`` contains a destructive command.
+Setting ``CLAUDE_DESTRUCTIVE_DENY_MODE`` turns the hook's terminal ``ask`` into
+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,
+    )
+    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 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"]

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

@@ -633,8 +633,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 +647,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 +667,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 22 hosted blocking hooks — none of which includes the
     validators runner.
     """
     python_content_with_type_error = (