claude-dev-env 2.3.0 → 2.5.0

package/hooks/blocking/test_code_review_stamp_store.py

@@ -0,0 +1,205 @@
+"""Behavioral tests for the per-work-tree code-review stamp store.
+
+Each test builds a real git repository with a real origin remote and records or
+reads real stamp files under an isolated home, so it exercises the same store
+surface the push and PR-create gates call: record a clean stamp, then ask
+whether it covers the live branch surface at a given effort.
+"""
+
+import importlib.util
+import pathlib
+import subprocess
+import sys
+
+import pytest
+
+_HOOK_DIR = pathlib.Path(__file__).parent
+if str(_HOOK_DIR) not in sys.path:
+    sys.path.insert(0, str(_HOOK_DIR))
+
+_store_spec = importlib.util.spec_from_file_location(
+    "code_review_stamp_store",
+    _HOOK_DIR / "code_review_stamp_store.py",
+)
+assert _store_spec is not None
+assert _store_spec.loader is not None
+_store_module = importlib.util.module_from_spec(_store_spec)
+_store_spec.loader.exec_module(_store_module)
+
+record_clean_stamp = _store_module.record_clean_stamp
+stamp_covers_surface = _store_module.stamp_covers_surface
+live_surface_hash = _store_module.live_surface_hash
+stamp_path_for_repo = _store_module.stamp_path_for_repo
+
+_verdict_store_module = sys.modules["verification_verdict_store"]
+root_key_for_repo = _verdict_store_module.root_key_for_repo
+
+_constants_spec = importlib.util.spec_from_file_location(
+    "code_review_enforcement_constants",
+    _HOOK_DIR / "config" / "code_review_enforcement_constants.py",
+)
+assert _constants_spec is not None
+assert _constants_spec.loader is not None
+_constants_module = importlib.util.module_from_spec(_constants_spec)
+_constants_spec.loader.exec_module(_constants_module)
+PUSH_REQUIRED_EFFORT = _constants_module.PUSH_REQUIRED_EFFORT
+PR_CREATE_REQUIRED_EFFORT = _constants_module.PR_CREATE_REQUIRED_EFFORT
+ALL_EFFORT_TOKENS_IN_ASCENDING_ORDER = _constants_module.ALL_EFFORT_TOKENS_IN_ASCENDING_ORDER
+
+PRODUCTION_SOURCE = "def add(left: int, right: int) -> int:\n    return left + right\n"
+CHANGED_SOURCE = "def add(left: int, right: int) -> int:\n    return left - right\n"
+FURTHER_CHANGED_SOURCE = "def add(left: int, right: int) -> int:\n    return left * right\n"
+
+
+def _run_git(repo_dir: pathlib.Path, *git_arguments: str) -> None:
+    subprocess.run(
+        ["git", "-C", str(repo_dir), *git_arguments],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _make_repo_with_origin(tmp_path: pathlib.Path) -> pathlib.Path:
+    origin_dir = tmp_path / "origin.git"
+    work_dir = tmp_path / "work"
+    work_dir.mkdir()
+    subprocess.run(
+        ["git", "init", "--bare", "--initial-branch=main", str(origin_dir)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    empty_hooks_dir = tmp_path / "nohooks"
+    empty_hooks_dir.mkdir()
+    _run_git(work_dir, "init", "--initial-branch=main")
+    _run_git(work_dir, "config", "user.email", "tests@example.com")
+    _run_git(work_dir, "config", "user.name", "Stamp Store Tests")
+    _run_git(work_dir, "config", "core.hooksPath", str(empty_hooks_dir))
+    (work_dir / "src").mkdir()
+    (work_dir / "src" / "app.py").write_text(PRODUCTION_SOURCE, encoding="utf-8")
+    _run_git(work_dir, "add", "-A")
+    _run_git(work_dir, "commit", "-m", "base")
+    _run_git(work_dir, "remote", "add", "origin", str(origin_dir))
+    _run_git(work_dir, "push", "-u", "origin", "main")
+    return work_dir
+
+
+def _isolate_home(monkeypatch: pytest.MonkeyPatch, fake_home: pathlib.Path) -> None:
+    home_text = str(fake_home)
+    monkeypatch.setenv("HOME", home_text)
+    monkeypatch.setenv("USERPROFILE", home_text)
+    monkeypatch.delenv("HOMEDRIVE", raising=False)
+    monkeypatch.delenv("HOMEPATH", raising=False)
+
+
+def _repo_with_change(tmp_path: pathlib.Path, changed_source: str) -> pathlib.Path:
+    work_dir = _make_repo_with_origin(tmp_path)
+    (work_dir / "src" / "app.py").write_text(changed_source, encoding="utf-8")
+    return work_dir
+
+
+def test_recorded_low_stamp_covers_the_push_surface(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    _isolate_home(monkeypatch, tmp_path / "home")
+    work_dir = _repo_with_change(tmp_path, CHANGED_SOURCE)
+    surface_hash = live_surface_hash(str(work_dir))
+    assert surface_hash is not None
+    record_clean_stamp(str(work_dir), surface_hash, PUSH_REQUIRED_EFFORT)
+    assert stamp_covers_surface(str(work_dir), surface_hash, PUSH_REQUIRED_EFFORT) is True
+
+
+def test_low_stamp_does_not_cover_the_pr_create_surface(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    _isolate_home(monkeypatch, tmp_path / "home")
+    work_dir = _repo_with_change(tmp_path, CHANGED_SOURCE)
+    surface_hash = live_surface_hash(str(work_dir))
+    assert surface_hash is not None
+    record_clean_stamp(str(work_dir), surface_hash, PUSH_REQUIRED_EFFORT)
+    assert stamp_covers_surface(str(work_dir), surface_hash, PR_CREATE_REQUIRED_EFFORT) is False
+
+
+def test_xhigh_stamp_covers_both_push_and_pr_create(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    _isolate_home(monkeypatch, tmp_path / "home")
+    work_dir = _repo_with_change(tmp_path, CHANGED_SOURCE)
+    surface_hash = live_surface_hash(str(work_dir))
+    assert surface_hash is not None
+    record_clean_stamp(str(work_dir), surface_hash, PR_CREATE_REQUIRED_EFFORT)
+    assert stamp_covers_surface(str(work_dir), surface_hash, PUSH_REQUIRED_EFFORT) is True
+    assert stamp_covers_surface(str(work_dir), surface_hash, PR_CREATE_REQUIRED_EFFORT) is True
+
+
+def test_stamp_bound_to_one_hash_does_not_cover_a_different_hash(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    _isolate_home(monkeypatch, tmp_path / "home")
+    work_dir = _repo_with_change(tmp_path, CHANGED_SOURCE)
+    surface_hash = live_surface_hash(str(work_dir))
+    assert surface_hash is not None
+    record_clean_stamp(str(work_dir), surface_hash, PUSH_REQUIRED_EFFORT)
+    other_hash = "f" * len(surface_hash)
+    assert stamp_covers_surface(str(work_dir), other_hash, PUSH_REQUIRED_EFFORT) is False
+
+
+def test_editing_a_file_after_minting_drops_coverage(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    _isolate_home(monkeypatch, tmp_path / "home")
+    work_dir = _repo_with_change(tmp_path, CHANGED_SOURCE)
+    minted_hash = live_surface_hash(str(work_dir))
+    assert minted_hash is not None
+    record_clean_stamp(str(work_dir), minted_hash, PUSH_REQUIRED_EFFORT)
+    (work_dir / "src" / "app.py").write_text(FURTHER_CHANGED_SOURCE, encoding="utf-8")
+    live_hash_after_edit = live_surface_hash(str(work_dir))
+    assert live_hash_after_edit is not None
+    assert live_hash_after_edit != minted_hash
+    assert stamp_covers_surface(str(work_dir), live_hash_after_edit, PUSH_REQUIRED_EFFORT) is False
+
+
+def test_no_stamp_file_reads_as_not_covered(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    _isolate_home(monkeypatch, tmp_path / "home")
+    work_dir = _repo_with_change(tmp_path, CHANGED_SOURCE)
+    surface_hash = live_surface_hash(str(work_dir))
+    assert surface_hash is not None
+    assert not stamp_path_for_repo(str(work_dir)).exists()
+    assert stamp_covers_surface(str(work_dir), surface_hash, PUSH_REQUIRED_EFFORT) is False
+
+
+def test_recording_a_second_effort_keeps_the_first(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    _isolate_home(monkeypatch, tmp_path / "home")
+    work_dir = _repo_with_change(tmp_path, CHANGED_SOURCE)
+    surface_hash = live_surface_hash(str(work_dir))
+    assert surface_hash is not None
+    record_clean_stamp(str(work_dir), surface_hash, PUSH_REQUIRED_EFFORT)
+    record_clean_stamp(str(work_dir), surface_hash, PR_CREATE_REQUIRED_EFFORT)
+    assert stamp_covers_surface(str(work_dir), surface_hash, PUSH_REQUIRED_EFFORT) is True
+    assert stamp_covers_surface(str(work_dir), surface_hash, PR_CREATE_REQUIRED_EFFORT) is True
+
+
+def test_live_surface_hash_is_none_when_nothing_changed(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    _isolate_home(monkeypatch, tmp_path / "home")
+    work_dir = _make_repo_with_origin(tmp_path)
+    assert live_surface_hash(str(work_dir)) is None
+
+
+def test_push_required_effort_is_the_lowest_known_token() -> None:
+    assert PUSH_REQUIRED_EFFORT == ALL_EFFORT_TOKENS_IN_ASCENDING_ORDER[0]
+
+
+def test_stamp_path_for_repo_stem_matches_the_shared_root_key(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    _isolate_home(monkeypatch, tmp_path / "home")
+    work_dir = tmp_path / "work-tree"
+    work_dir.mkdir()
+    assert stamp_path_for_repo(str(work_dir)).stem == root_key_for_repo(str(work_dir))

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_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"]