claude-dev-env 2.12.0 → 2.13.0

package/hooks/blocking/test_verified_commit_gate_additional_context.py

@@ -1,134 +0,0 @@
-"""The verified-commit gate's deny payload teaches the verify-skip policy.
-
-A blocked commit prints a PreToolUse ``hookSpecificOutput`` deny whose
-``additionalContext`` carries the ``# verify-skip`` usage rule, so the agent
-learns at the moment of the block when the marker is legitimate.
-"""
-
-import importlib.util
-import io
-import json
-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))
-
-gate_spec = importlib.util.spec_from_file_location(
-    "verified_commit_gate",
-    _HOOK_DIR / "verified_commit_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_main = gate_module.main
-
-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"
-
-
-def _run_git(work_dir: pathlib.Path, *git_arguments: str) -> None:
-    subprocess.run(
-        ["git", "-C", str(work_dir), *git_arguments],
-        check=True,
-        capture_output=True,
-        text=True,
-    )
-
-
-def _make_gated_repo(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,
-    )
-    _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", "Gate Tests")
-    (work_dir / "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")
-    (work_dir / "app.py").write_text(CHANGED_SOURCE, encoding="utf-8")
-    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 _run_gate_main(
-    monkeypatch: pytest.MonkeyPatch, command_text: str, work_dir: pathlib.Path
-) -> None:
-    payload_text = json.dumps(
-        {
-            "tool_name": "Bash",
-            "tool_input": {"command": command_text},
-            "cwd": str(work_dir),
-            "transcript_path": "",
-        }
-    )
-    monkeypatch.setattr(sys, "stdin", io.StringIO(payload_text))
-    gate_main()
-
-
-def test_deny_payload_carries_verify_skip_additional_context(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-    tmp_path: pathlib.Path,
-) -> None:
-    fake_home = tmp_path / "home"
-    fake_home.mkdir()
-    _isolate_home(monkeypatch, fake_home)
-    work_dir = _make_gated_repo(tmp_path)
-    _run_gate_main(monkeypatch, "git commit -m x", work_dir)
-    deny_payload = json.loads(capsys.readouterr().out)
-    hook_specific_output = deny_payload["hookSpecificOutput"]
-    assert hook_specific_output["permissionDecision"] == "deny"
-    additional_context = hook_specific_output["additionalContext"]
-    assert "# verify-skip" in additional_context
-    assert "already passed clean" in additional_context
-    assert "fresh verification" in additional_context
-
-
-def test_marker_inside_a_quoted_message_still_denies(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-    tmp_path: pathlib.Path,
-) -> None:
-    fake_home = tmp_path / "home"
-    fake_home.mkdir()
-    _isolate_home(monkeypatch, fake_home)
-    work_dir = _make_gated_repo(tmp_path)
-    quoted_marker_command = 'git commit -m "docs: explain the # verify-skip escape hatch"'
-    _run_gate_main(monkeypatch, quoted_marker_command, work_dir)
-    deny_payload = json.loads(capsys.readouterr().out)
-    assert deny_payload["hookSpecificOutput"]["permissionDecision"] == "deny"
-
-
-def test_marker_as_a_trailing_comment_bypasses(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-    tmp_path: pathlib.Path,
-) -> None:
-    fake_home = tmp_path / "home"
-    fake_home.mkdir()
-    _isolate_home(monkeypatch, fake_home)
-    work_dir = _make_gated_repo(tmp_path)
-    trailing_marker_command = 'git commit -m "wire up feature" # verify-skip'
-    _run_gate_main(monkeypatch, trailing_marker_command, work_dir)
-    assert capsys.readouterr().out == ""

package/hooks/blocking/test_verified_commit_message_accuracy_blocker.py

@@ -1,131 +0,0 @@
-"""Unit tests for the verified-commit-message-accuracy PreToolUse hook."""
-
-import importlib.util
-import pathlib
-import sys
-
-_HOOK_DIR = pathlib.Path(__file__).parent
-if str(_HOOK_DIR) not in sys.path:
-    sys.path.insert(0, str(_HOOK_DIR))
-
-hook_spec = importlib.util.spec_from_file_location(
-    "verified_commit_message_accuracy_blocker",
-    _HOOK_DIR / "verified_commit_message_accuracy_blocker.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)
-is_guarded_file = hook_module.is_guarded_file
-claims_blanket_comment_exemption = hook_module.claims_blanket_comment_exemption
-extract_written_text = hook_module.extract_written_text
-build_corrective_message = hook_module.build_corrective_message
-
-OFFENDING_MESSAGE = (
-    "CORRECTIVE_MESSAGE = (\n"
-    '    "BLOCKED: [VERIFIED_COMMIT_GATE] This branch surface has no passing "\n'
-    '    "verification verdict. Spawn the code-verifier agent (Agent tool, "\n'
-    "    \"subagent_type 'code-verifier') with the task texts, the diff scope, \"\n"
-    '    "and recorded baselines; when it finishes with a clean verdict the "\n'
-    '    "SubagentStop hook mints the verdict and this command will pass. Any "\n'
-    '    "file change after verification invalidates the verdict, so verify "\n'
-    '    "last. Docs-, docstring-, comment-, and test-only surfaces are exempt "\n'
-    '    "automatically."\n'
-    ")\n"
-)
-ACCURATE_DOCS_EXEMPTION_MENTIONING_COMMENTS = (
-    "Comments inside Python files are stripped; docs are exempt "
-    "automatically by extension."
-)
-ACCURATE_MESSAGE = (
-    "CORRECTIVE_MESSAGE = (\n"
-    '    "BLOCKED: [VERIFIED_COMMIT_GATE] ... Docs and images are exempt by "\n'
-    '    "extension, and Python files whose docstring- and comment-stripped AST "\n'
-    '    "is unchanged."\n'
-    ")\n"
-)
-
-
-def test_constants_file_is_guarded() -> None:
-    assert is_guarded_file(
-        "/repo/.claude/hooks/blocking/config/verified_commit_constants.py"
-    )
-
-
-def test_unrelated_file_is_not_guarded() -> None:
-    assert not is_guarded_file("/repo/.claude/hooks/blocking/gh_body_arg_blocker.py")
-
-
-def test_blanket_comment_exemption_claim_is_detected() -> None:
-    assert claims_blanket_comment_exemption(OFFENDING_MESSAGE)
-
-
-def test_blanket_claim_detected_regardless_of_leading_words() -> None:
-    assert claims_blanket_comment_exemption(
-        "Comment-only surfaces are exempt automatically."
-    )
-
-
-def test_accurate_exemption_wording_passes() -> None:
-    assert not claims_blanket_comment_exemption(ACCURATE_MESSAGE)
-
-
-def test_accurate_docs_exemption_mentioning_comments_passes() -> None:
-    assert not claims_blanket_comment_exemption(
-        ACCURATE_DOCS_EXEMPTION_MENTIONING_COMMENTS
-    )
-
-
-def test_comma_joined_docs_exemption_mentioning_comments_passes() -> None:
-    assert not claims_blanket_comment_exemption(
-        "Comments are handled, and docs are exempt automatically."
-    )
-
-
-def test_python_ast_clause_mentioning_comments_passes() -> None:
-    assert not claims_blanket_comment_exemption(
-        "Python comment-stripped AST changes and docs are exempt automatically "
-        "by extension"
-    )
-
-
-def test_single_clause_python_ast_exemption_passes() -> None:
-    assert not claims_blanket_comment_exemption(
-        "Python files whose comment-stripped AST is unchanged are exempt "
-        "automatically."
-    )
-
-
-def test_commentary_word_stem_passes() -> None:
-    assert not claims_blanket_comment_exemption(
-        "Our commentary on the approach is exempt automatically from blame."
-    )
-
-
-def test_corrective_message_names_only_the_two_real_exemptions() -> None:
-    corrective_message = build_corrective_message()
-    assert "exempt by extension" in corrective_message
-    assert "docstring- and comment-stripped AST" in corrective_message
-    assert "test file" not in corrective_message
-    assert "by name convention" not in corrective_message
-
-
-def test_message_without_exemption_claim_passes() -> None:
-    assert not claims_blanket_comment_exemption(
-        'CORRECTIVE_MESSAGE = "Spawn the code-verifier agent to earn a verdict."'
-    )
-
-
-def test_write_content_is_extracted() -> None:
-    written_text = extract_written_text({"content": OFFENDING_MESSAGE})
-    assert claims_blanket_comment_exemption(written_text)
-
-
-def test_edit_new_string_is_extracted() -> None:
-    written_text = extract_written_text({"new_string": OFFENDING_MESSAGE})
-    assert claims_blanket_comment_exemption(written_text)
-
-
-def test_edit_new_string_with_accurate_wording_is_clean() -> None:
-    written_text = extract_written_text({"new_string": ACCURATE_MESSAGE})
-    assert not claims_blanket_comment_exemption(written_text)

package/hooks/blocking/test_verifier_verdict_minter.py

@@ -1,299 +0,0 @@
-"""Tests for the agent-type gate in verifier_verdict_minter.
-
-The minter mints a verdict only for a code-verifier stop event. The
-SubagentStop payload names the stopping subagent's own transcript
-(``agent_transcript_path``), which sits beside a harness-written
-``agent-<id>.meta.json`` sidecar naming the spawning ``agentType``. These
-tests build that sidecar and assert the minter gates on the resolved type and
-on the shared MINTING_AGENT_TYPE constant, so a rename in config propagates to
-the minter without a second edit. A malformed or non-string sidecar resolves
-nothing, and an absent sidecar mints nothing even when the transcript carries a
-verdict fence — the main session controls the prompt of any Agent-tool subagent
-it spawns, so a verdict fence in the transcript proves nothing about the agent
-type, and only the harness-written sidecar attests a code-verifier. A further
-test holds the shipped settings.json to the minter docstring's anti-forgery
-claim: the main session is denied writes to the verdict directory, so only this
-hook can mint a passing verdict.
-"""
-
-import importlib.util
-import json
-import pathlib
-import subprocess
-import sys
-from collections.abc import Callable
-
-_HOOK_DIR = pathlib.Path(__file__).parent
-if str(_HOOK_DIR) not in sys.path:
-    sys.path.insert(0, str(_HOOK_DIR))
-
-_SETTINGS_PATH = _HOOK_DIR.parent.parent / "settings.json"
-
-minter_spec = importlib.util.spec_from_file_location(
-    "verifier_verdict_minter",
-    _HOOK_DIR / "verifier_verdict_minter.py",
-)
-assert minter_spec is not None
-assert minter_spec.loader is not None
-minter_module = importlib.util.module_from_spec(minter_spec)
-minter_spec.loader.exec_module(minter_module)
-mint_for_payload = minter_module.mint_for_payload
-resolved_subagent_type = minter_module.resolved_subagent_type
-
-store_spec = importlib.util.spec_from_file_location(
-    "verification_verdict_store",
-    _HOOK_DIR / "verification_verdict_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)
-empty_surface_hash = store_module.empty_surface_hash
-
-constants_spec = importlib.util.spec_from_file_location(
-    "verified_commit_constants",
-    _HOOK_DIR / "config" / "verified_commit_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)
-MINTING_AGENT_TYPE = constants_module.MINTING_AGENT_TYPE
-
-
-def _write_sidecar(agent_transcript_file: pathlib.Path, agent_type: str) -> None:
-    sidecar_file = agent_transcript_file.with_name(f"{agent_transcript_file.stem}.meta.json")
-    sidecar_file.write_text(
-        json.dumps({"agentType": agent_type, "description": "Verify"}) + "\n",
-        encoding="utf-8",
-    )
-
-
-def _write_verdict_transcript(agent_transcript_file: pathlib.Path, verdict_body: str) -> None:
-    verdict_text = f"ok\n```verdict\n{verdict_body}\n```\n"
-    agent_transcript_file.write_text(
-        json.dumps(
-            {
-                "type": "assistant",
-                "message": {"content": [{"type": "text", "text": verdict_text}]},
-            }
-        )
-        + "\n",
-        encoding="utf-8",
-    )
-
-
-def _make_repo(tmp_path: pathlib.Path) -> pathlib.Path:
-    repo_root = tmp_path / "repo"
-    repo_root.mkdir()
-    return repo_root
-
-
-def _mint_payload(
-    agent_transcript_file: pathlib.Path, repo_root: pathlib.Path, agent_id: str
-) -> dict[str, str]:
-    return {
-        "agent_transcript_path": str(agent_transcript_file),
-        "cwd": str(repo_root),
-        "agent_id": agent_id,
-    }
-
-
-def test_resolves_subagent_type_from_sidecar(tmp_path: pathlib.Path) -> None:
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    agent_transcript.write_text("", encoding="utf-8")
-    _write_sidecar(agent_transcript, MINTING_AGENT_TYPE)
-    payload = {"agent_transcript_path": str(agent_transcript)}
-    assert resolved_subagent_type(payload) == MINTING_AGENT_TYPE
-
-
-def test_resolves_none_when_sidecar_absent(tmp_path: pathlib.Path) -> None:
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    agent_transcript.write_text("", encoding="utf-8")
-    payload = {"agent_transcript_path": str(agent_transcript)}
-    assert resolved_subagent_type(payload) is None
-
-
-def test_resolves_none_when_agent_transcript_path_empty() -> None:
-    assert resolved_subagent_type({"agent_transcript_path": ""}) is None
-    assert resolved_subagent_type({}) is None
-
-
-def test_resolves_none_when_sidecar_names_no_string_type(tmp_path: pathlib.Path) -> None:
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    agent_transcript.write_text("", encoding="utf-8")
-    sidecar_file = agent_transcript.with_name("agent-7.meta.json")
-    sidecar_file.write_text(json.dumps({"agentType": 123}), encoding="utf-8")
-    payload = {"agent_transcript_path": str(agent_transcript)}
-    assert resolved_subagent_type(payload) is None
-
-
-def test_unparseable_sidecar_resolves_nothing(tmp_path: pathlib.Path) -> None:
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    agent_transcript.write_text("", encoding="utf-8")
-    sidecar_file = agent_transcript.with_name("agent-7.meta.json")
-    sidecar_file.write_text("{not valid json", encoding="utf-8")
-    payload = {"agent_transcript_path": str(agent_transcript)}
-    assert resolved_subagent_type(payload) is None
-
-
-def test_invalid_utf8_sidecar_resolves_nothing(tmp_path: pathlib.Path) -> None:
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    agent_transcript.write_text("", encoding="utf-8")
-    sidecar_file = agent_transcript.with_name("agent-7.meta.json")
-    sidecar_file.write_bytes(b'{"agentType": "\xff\xfe bad"}')
-    payload = {"agent_transcript_path": str(agent_transcript)}
-    assert resolved_subagent_type(payload) is None
-
-
-def test_non_object_json_sidecar_resolves_nothing(tmp_path: pathlib.Path) -> None:
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    agent_transcript.write_text("", encoding="utf-8")
-    sidecar_file = agent_transcript.with_name("agent-7.meta.json")
-    sidecar_file.write_text(json.dumps(["agentType", "code-verifier"]), encoding="utf-8")
-    payload = {"agent_transcript_path": str(agent_transcript)}
-    assert resolved_subagent_type(payload) is None
-
-
-def test_non_verifier_agent_type_mints_nothing(tmp_path: pathlib.Path) -> None:
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    agent_transcript.write_text("", encoding="utf-8")
-    _write_sidecar(agent_transcript, "general-purpose")
-    payload = {"agent_transcript_path": str(agent_transcript)}
-    assert mint_for_payload(payload) is None
-
-
-def test_verifier_type_without_a_verdict_mints_nothing(tmp_path: pathlib.Path) -> None:
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    agent_transcript.write_text("", encoding="utf-8")
-    _write_sidecar(agent_transcript, MINTING_AGENT_TYPE)
-    payload = {"agent_transcript_path": str(agent_transcript)}
-    assert mint_for_payload(payload) is None
-
-
-def _init_repo_with_upstream(repo_root: pathlib.Path) -> None:
-    subprocess.run(["git", "-C", str(repo_root), "init", "-q"], check=True)
-    subprocess.run(
-        ["git", "-C", str(repo_root), "config", "user.email", "verifier@test"], check=True
-    )
-    subprocess.run(["git", "-C", str(repo_root), "config", "user.name", "verifier"], check=True)
-    (repo_root / "module.py").write_text("answer = 1\n", encoding="utf-8")
-    subprocess.run(["git", "-C", str(repo_root), "add", "-A"], check=True)
-    subprocess.run(["git", "-C", str(repo_root), "commit", "-qm", "init"], check=True)
-    subprocess.run(["git", "-C", str(repo_root), "branch", "-f", "origin/main", "HEAD"], check=True)
-
-
-def _init_repo_with_upstream_and_edit(repo_root: pathlib.Path) -> None:
-    _init_repo_with_upstream(repo_root)
-    (repo_root / "module.py").write_text("answer = 2\n", encoding="utf-8")
-
-
-def test_clean_verifier_verdict_mints_a_verdict_file(tmp_path: pathlib.Path) -> None:
-    repo_root = _make_repo(tmp_path)
-    _init_repo_with_upstream_and_edit(repo_root)
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    _write_verdict_transcript(agent_transcript, '{"all_pass": true, "findings": []}')
-    _write_sidecar(agent_transcript, MINTING_AGENT_TYPE)
-    payload = _mint_payload(agent_transcript, repo_root, "a02b9583eedc74093")
-    verdict_path = mint_for_payload(payload)
-    try:
-        assert verdict_path is not None
-        verdict_record = json.loads(verdict_path.read_text(encoding="utf-8"))
-        assert verdict_record["all_pass"] is True
-        assert verdict_record["minted_from_agent_id"] == "a02b9583eedc74093"
-    finally:
-        if verdict_path is not None and verdict_path.exists():
-            verdict_path.unlink()
-
-
-def _deny_rules() -> list[str]:
-    settings_record = json.loads(_SETTINGS_PATH.read_text(encoding="utf-8"))
-    return settings_record["permissions"]["deny"]
-
-
-def test_settings_deny_verdict_directory_write() -> None:
-    assert "Edit($HOME/.claude/verification/**)" in _deny_rules()
-    assert "Write($HOME/.claude/verification/**)" not in _deny_rules()
-
-
-def test_settings_deny_verdict_directory_edit() -> None:
-    assert "Edit($HOME/.claude/verification/**)" in _deny_rules()
-
-
-def test_minter_refuses_when_attested_hash_equals_empty_surface_hash(
-    tmp_path: pathlib.Path,
-) -> None:
-    repo_root = _make_repo(tmp_path)
-    _init_repo_with_upstream_and_edit(repo_root)
-    attested_empty = empty_surface_hash()
-    verdict_fence = json.dumps(
-        {"all_pass": True, "findings": [], "manifest_sha256": attested_empty}
-    )
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    _write_verdict_transcript(agent_transcript, verdict_fence)
-    _write_sidecar(agent_transcript, MINTING_AGENT_TYPE)
-    payload = _mint_payload(agent_transcript, repo_root, "empty-surface-1")
-    assert mint_for_payload(payload) is None
-
-
-def test_minter_refuses_when_recomputed_surface_is_empty(
-    tmp_path: pathlib.Path,
-) -> None:
-    repo_root = _make_repo(tmp_path)
-    _init_repo_with_upstream(repo_root)
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    _write_verdict_transcript(agent_transcript, '{"all_pass": true, "findings": []}')
-    _write_sidecar(agent_transcript, MINTING_AGENT_TYPE)
-    payload = _mint_payload(agent_transcript, repo_root, "empty-recompute-1")
-    assert mint_for_payload(payload) is None
-
-
-def test_resolves_none_when_sidecar_absent_even_with_verdict_fence(
-    tmp_path: pathlib.Path,
-) -> None:
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    _write_verdict_transcript(agent_transcript, '{"all_pass": true, "findings": []}')
-    payload = {"agent_transcript_path": str(agent_transcript)}
-    assert resolved_subagent_type(payload) is None
-
-
-def test_does_not_mint_when_sidecar_absent_but_transcript_has_verdict(
-    tmp_path: pathlib.Path,
-) -> None:
-    repo_root = _make_repo(tmp_path)
-    _init_repo_with_upstream_and_edit(repo_root)
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    _write_verdict_transcript(agent_transcript, '{"all_pass": true, "findings": []}')
-    payload = _mint_payload(agent_transcript, repo_root, "no-sidecar-1")
-    assert mint_for_payload(payload) is None
-
-
-def test_attested_manifest_hash_binds_over_cwd_surface(tmp_path: pathlib.Path) -> None:
-    repo_root = _make_repo(tmp_path)
-    _init_repo_with_upstream_and_edit(repo_root)
-    attested_hash = "c" * 64
-    verdict_fence = json.dumps(
-        {"all_pass": True, "findings": [], "manifest_sha256": attested_hash}
-    )
-    agent_transcript = tmp_path / "agent-7.jsonl"
-    _write_verdict_transcript(agent_transcript, verdict_fence)
-    _write_sidecar(agent_transcript, MINTING_AGENT_TYPE)
-    payload = _mint_payload(agent_transcript, repo_root, "attest-1")
-    verdict_path = mint_for_payload(payload)
-    try:
-        assert verdict_path is not None
-        verdict_record = json.loads(verdict_path.read_text(encoding="utf-8"))
-        assert verdict_record["manifest_sha256"] == attested_hash
-    finally:
-        if verdict_path is not None and verdict_path.exists():
-            verdict_path.unlink()
-
-
-def test_minter_imports_under_foreign_config_shadow(
-    run_under_config_shadow: Callable[[str], subprocess.CompletedProcess[str]],
-) -> None:
-    completed_probe = run_under_config_shadow(
-        "import verifier_verdict_minter\nprint('IMPORT_OK')\n"
-    )
-    assert completed_probe.returncode == 0, completed_probe.stderr
-    assert "IMPORT_OK" in completed_probe.stdout

package/hooks/blocking/tests/test_verified_commit_gate.py

@@ -1,41 +0,0 @@
-"""Entry-boundary behavior of the verified_commit_gate hook process.
-
-Runs the hook as a subprocess the way Claude Code does and pins the two
-silent paths: a tool the gate does not cover, and a gated command carrying
-the bypass marker.
-"""
-
-import json
-import pathlib
-import subprocess
-import sys
-
-_BLOCKING_DIRECTORY = pathlib.Path(__file__).resolve().parent.parent
-_GATE_SCRIPT_PATH = _BLOCKING_DIRECTORY / "verified_commit_gate.py"
-
-
-def _run_gate_process(tool_name: str, command_text: str) -> str:
-    payload_text = json.dumps(
-        {
-            "tool_name": tool_name,
-            "tool_input": {"command": command_text},
-            "cwd": str(_BLOCKING_DIRECTORY),
-            "transcript_path": "",
-        }
-    )
-    completed_process = subprocess.run(
-        [sys.executable, str(_GATE_SCRIPT_PATH)],
-        input=payload_text,
-        capture_output=True,
-        text=True,
-        check=True,
-    )
-    return completed_process.stdout
-
-
-def test_uncovered_tool_name_stays_silent() -> None:
-    assert _run_gate_process("Read", "git commit -m x") == ""
-
-
-def test_bypass_marker_stays_silent_at_the_process_boundary() -> None:
-    assert _run_gate_process("Bash", "git commit -m x # verify-skip") == ""