claude-dev-env 2.0.1 → 2.1.0

package/hooks/blocking/test_convergence_gate_blocker.py

@@ -132,3 +132,149 @@ def test_main_reads_cwd_from_top_level_payload(
         hook_module.main()
 
     assert captured_cwd == [worktree_path]
+
+
+def _capture_convergence_identity(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: pathlib.Path,
+    command: str,
+    cwd_owner_repo: tuple[str, str],
+) -> tuple[str, str, int]:
+    convergence_script = (
+        tmp_path / ".claude" / "skills" / "pr-converge" / "scripts" / "check_convergence.py"
+    )
+    convergence_script.parent.mkdir(parents=True)
+    convergence_script.write_text("")
+    monkeypatch.setattr(hook_module.Path, "home", classmethod(lambda _cls: tmp_path))
+    monkeypatch.setattr(hook_module, "_resolve_owner_repo", lambda _cwd: cwd_owner_repo)
+
+    captured_identity: list[tuple[str, str, int]] = []
+
+    def fake_check(
+        _script: str, owner: str, repo: str, pr_number: int, _cwd: str | None
+    ) -> subprocess.CompletedProcess[str]:
+        captured_identity.append((owner, repo, pr_number))
+        return subprocess.CompletedProcess(args=[], returncode=0, stdout="", stderr="")
+
+    monkeypatch.setattr(hook_module, "_run_convergence_check", fake_check)
+
+    payload = {
+        "tool_name": "Bash",
+        "cwd": str(tmp_path / "worktree"),
+        "tool_input": {"command": command},
+    }
+    monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps(payload)))
+    with pytest.raises(SystemExit):
+        hook_module.main()
+    return captured_identity[0]
+
+
+def test_repo_flag_overrides_cwd_repo(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    identity = _capture_convergence_identity(
+        monkeypatch,
+        tmp_path,
+        "gh pr ready 161 --repo sample-owner/target-repo",
+        ("cwd-owner", "cwd-repo"),
+    )
+    assert identity == ("sample-owner", "target-repo", 161)
+
+
+def test_pr_url_yields_repo_and_number(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    identity = _capture_convergence_identity(
+        monkeypatch,
+        tmp_path,
+        "gh pr ready https://github.com/sample-owner/target-repo/pull/161",
+        ("cwd-owner", "cwd-repo"),
+    )
+    assert identity == ("sample-owner", "target-repo", 161)
+
+
+def test_bare_pr_ready_resolves_repo_from_cwd(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    identity = _capture_convergence_identity(
+        monkeypatch,
+        tmp_path,
+        "gh pr ready 418",
+        ("cwd-owner", "cwd-repo"),
+    )
+    assert identity == ("cwd-owner", "cwd-repo", 418)
+
+
+def test_parse_repo_flag_space_form() -> None:
+    assert hook_module._parse_repo_flag("gh pr ready 161 --repo sample-owner/target-repo") == (
+        "sample-owner",
+        "target-repo",
+    )
+
+
+def test_parse_repo_flag_equals_form() -> None:
+    assert hook_module._parse_repo_flag("gh pr ready 161 --repo=sample-owner/target-repo") == (
+        "sample-owner",
+        "target-repo",
+    )
+
+
+def test_parse_repo_flag_short_alias() -> None:
+    assert hook_module._parse_repo_flag("gh pr ready 161 -R sample-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
+
+
+def test_parse_pr_url_yields_owner_repo_number() -> None:
+    assert hook_module._parse_pr_url(
+        "gh pr ready https://github.com/sample-owner/target-repo/pull/161"
+    ) == ("sample-owner", "target-repo", 161)
+
+
+def test_parse_pr_url_absent_returns_none() -> None:
+    assert hook_module._parse_pr_url("gh pr ready 418") is None
+
+
+def test_ready_segment_clips_at_command_separator() -> None:
+    assert (
+        hook_module._ready_command_segment(
+            "gh pr ready 161 && gh pr comment 999 --repo other-owner/other-repo"
+        )
+        == "gh pr ready 161 "
+    )
+
+
+def test_chained_repo_flag_does_not_misbind_the_gate(
+    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 --body-file note.md",
+        ("cwd-owner", "cwd-repo"),
+    )
+    assert identity == ("cwd-owner", "cwd-repo", 161)
+
+
+def test_chained_pr_url_does_not_misbind_the_gate(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    identity = _capture_convergence_identity(
+        monkeypatch,
+        tmp_path,
+        "gh pr ready 161 && echo https://github.com/other-owner/other-repo/pull/5",
+        ("cwd-owner", "cwd-repo"),
+    )
+    assert identity == ("cwd-owner", "cwd-repo", 161)
+
+
+def test_ready_segment_skips_a_leading_undo_invocation() -> None:
+    assert (
+        hook_module._ready_command_segment("gh pr ready --undo && gh pr ready 161")
+        == "gh pr ready 161"
+    )

package/hooks/blocking/test_plain_language_blocker.py

@@ -14,6 +14,8 @@ import sys
 from pathlib import Path
 from unittest.mock import patch
 
+import pytest
+
 HOOK_SCRIPT_PATH = Path(__file__).parent / "plain_language_blocker.py"
 _HOOKS_DIR = str(Path(__file__).resolve().parent)
 _HOOKS_ROOT = str(Path(__file__).resolve().parent.parent)
@@ -185,6 +187,19 @@ def test_write_markdown_with_banned_term_is_denied(tmp_path: Path) -> None:
     assert _decision_from(completed) == "deny"
 
 
+def test_write_markdown_at_ephemeral_path_is_allowed(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("CLAUDE_CODE_RULES_DISABLE_EPHEMERAL_EXEMPT", raising=False)
+    payload = {
+        "tool_name": "Write",
+        "tool_input": {
+            "file_path": "/tmp/notes.md",
+            "content": "This guide explains how to utilize the new cache layer.",
+        },
+    }
+    completed = _run_hook_with_payload(payload)
+    assert _decision_from(completed) is None
+
+
 def test_write_non_markdown_is_ignored(tmp_path: Path) -> None:
     target = tmp_path / "notes.txt"
     payload = {

package/hooks/blocking/test_state_description_blocker.py

@@ -7,6 +7,8 @@ import sys
 from pathlib import Path
 from unittest.mock import patch
 
+import pytest
+
 _BLOCKING_DIR = str(Path(__file__).resolve().parent)
 _HOOKS_ROOT = str(Path(__file__).resolve().parent.parent)
 if _BLOCKING_DIR not in sys.path:
@@ -207,6 +209,19 @@ def test_detects_now_uses_in_markdown():
     assert output["hookSpecificOutput"]["permissionDecision"] == "deny"
 
 
+def test_markdown_at_ephemeral_path_is_allowed(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("CLAUDE_CODE_RULES_DISABLE_EPHEMERAL_EXEMPT", raising=False)
+    result = _run_hook(
+        "Write",
+        {
+            "file_path": "/tmp/api.md",
+            "content": VIOLATION_MD_INSTEAD,
+        },
+    )
+    assert result.returncode == 0
+    assert result.stdout == ""
+
+
 def test_detects_edit_new_string():
     result = _run_hook(
         "Edit",

package/hooks/blocking/test_verification_verdict_store.py

@@ -211,6 +211,18 @@ def test_corrective_message_scopes_comment_exemption_to_python() -> None:
     assert "comment-, and test-only surfaces are exempt" not in lowered_message
 
 
+def test_corrective_message_names_worktree_surface_keying() -> None:
+    lowered_message = CORRECTIVE_MESSAGE.lower()
+    assert "work tree" in lowered_message
+    assert "byte-identical" in lowered_message
+
+
+def test_corrective_message_gives_cross_worktree_remedy() -> None:
+    lowered_message = CORRECTIVE_MESSAGE.lower()
+    assert "run this command from the work tree" in lowered_message
+    assert "verify this surface here" in lowered_message
+
+
 def test_untracked_claude_production_hook_is_gated(tmp_path: pathlib.Path) -> None:
     work_dir = _make_repo_with_origin(tmp_path)
     new_hook_dir = work_dir / ".claude" / "hooks" / "blocking"

package/hooks/blocking/test_verified_commit_config_bootstrap.py

@@ -31,6 +31,24 @@ def test_register_binds_dotted_name_to_sibling_constants_file(
     assert detached_head_line == "HEAD"
 
 
+def test_register_binds_gate_output_constants_module(
+    run_under_config_shadow: RunUnderConfigShadow,
+) -> None:
+    completed_probe = run_under_config_shadow(
+        "import verified_commit_config_bootstrap as bootstrap\n"
+        "bootstrap.register_verified_commit_constants()\n"
+        "import config.verified_commit_gate_output_constants as loaded\n"
+        "print(loaded.__file__)\n"
+        "print(loaded.DENY_PERMISSION_DECISION)\n"
+    )
+    assert completed_probe.returncode == 0, completed_probe.stderr
+    resolved_file_line, deny_decision_line = completed_probe.stdout.splitlines()[:2]
+    assert resolved_file_line.replace("\\", "/").endswith(
+        "blocking/config/verified_commit_gate_output_constants.py"
+    )
+    assert deny_decision_line == "deny"
+
+
 def test_register_leaves_an_already_cached_module_untouched(
     run_under_config_shadow: RunUnderConfigShadow,
 ) -> None:

package/hooks/blocking/test_verified_commit_docs_delta.py

@@ -0,0 +1,176 @@
+"""Gate behavior for docs-only deltas and the cross-work-tree deny message.
+
+Each test builds a real git repository with a real origin remote and drives
+``deny_reason_for_directory`` — the same decision the verified_commit_gate hook
+runs — so the docs-only exemption, the docs-after-verified-code block, and the
+denial message's work-tree keying are asserted against live git state.
+"""
+
+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))
+
+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)
+deny_reason_for_directory = gate_module.deny_reason_for_directory
+
+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)
+resolve_merge_base = store_module.resolve_merge_base
+branch_surface_manifest = store_module.branch_surface_manifest
+manifest_sha256 = store_module.manifest_sha256
+write_verdict = store_module.write_verdict
+
+PRODUCTION_SOURCE = "def add(left: int, right: int) -> int:\n    return left + right\n"
+BEHAVIORAL_EDIT_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 _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 _empty_hooks_dir(tmp_path: pathlib.Path) -> pathlib.Path:
+    hooks_dir = tmp_path / "nohooks"
+    hooks_dir.mkdir(exist_ok=True)
+    return hooks_dir
+
+
+def _empty_transcript(tmp_path: pathlib.Path) -> pathlib.Path:
+    transcript_path = tmp_path / "projects" / "demo" / "sess1.jsonl"
+    transcript_path.parent.mkdir(parents=True, exist_ok=True)
+    transcript_path.write_text("", encoding="utf-8")
+    return transcript_path
+
+
+def _init_pushed_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", "Docs Delta Tests")
+    _run_git(work_dir, "config", "core.hooksPath", str(_empty_hooks_dir(tmp_path)))
+    (work_dir / "app.py").write_text(PRODUCTION_SOURCE, encoding="utf-8")
+    (work_dir / "README.md").write_text("# base\n", 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 _make_docs_only_repo(tmp_path: pathlib.Path) -> pathlib.Path:
+    work_dir = _init_pushed_repo(tmp_path)
+    (work_dir / "README.md").write_text("# base\n\nUpdated docs.\n", encoding="utf-8")
+    return work_dir
+
+
+def _make_behavioral_code_repo(tmp_path: pathlib.Path) -> pathlib.Path:
+    work_dir = _init_pushed_repo(tmp_path)
+    (work_dir / "app.py").write_text(BEHAVIORAL_EDIT_SOURCE, encoding="utf-8")
+    return work_dir
+
+
+def _live_surface_hash(work_dir: pathlib.Path) -> str:
+    merge_base_sha = resolve_merge_base(str(work_dir))
+    assert merge_base_sha is not None
+    surface_manifest_text = branch_surface_manifest(str(work_dir), merge_base_sha)
+    assert surface_manifest_text is not None
+    return manifest_sha256(surface_manifest_text)
+
+
+def test_pure_docs_only_branch_is_allowed_without_verdict(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    _isolate_home(monkeypatch, fake_home)
+    work_dir = _make_docs_only_repo(tmp_path)
+    transcript_path = _empty_transcript(tmp_path)
+    assert deny_reason_for_directory(str(work_dir), str(transcript_path)) is None
+
+
+def test_readme_change_after_verified_code_commit_is_denied(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    _isolate_home(monkeypatch, fake_home)
+    work_dir = _make_behavioral_code_repo(tmp_path)
+    code_surface_hash = _live_surface_hash(work_dir)
+    write_verdict(str(work_dir), code_surface_hash, True, [], "agent-x")
+    transcript_path = _empty_transcript(tmp_path)
+    assert deny_reason_for_directory(str(work_dir), str(transcript_path)) is None
+    _run_git(work_dir, "add", "-A")
+    _run_git(work_dir, "commit", "-m", "verified code change")
+    (work_dir / "README.md").write_text("# added after verification\n", encoding="utf-8")
+    deny_reason = deny_reason_for_directory(str(work_dir), str(transcript_path))
+    assert deny_reason is not None
+    assert "VERIFIED_COMMIT_GATE" in deny_reason
+
+
+def test_readme_added_beside_unverified_code_is_denied(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    _isolate_home(monkeypatch, fake_home)
+    work_dir = _make_behavioral_code_repo(tmp_path)
+    (work_dir / "README.md").write_text("# docs beside code\n", encoding="utf-8")
+    transcript_path = _empty_transcript(tmp_path)
+    deny_reason = deny_reason_for_directory(str(work_dir), str(transcript_path))
+    assert deny_reason is not None
+    assert "VERIFIED_COMMIT_GATE" in deny_reason
+
+
+def test_deny_reason_for_directory_names_worktree_keying_and_remedy(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    _isolate_home(monkeypatch, fake_home)
+    work_dir = _make_behavioral_code_repo(tmp_path)
+    transcript_path = _empty_transcript(tmp_path)
+    deny_reason = deny_reason_for_directory(str(work_dir), str(transcript_path))
+    assert deny_reason is not None
+    lowered_reason = deny_reason.lower()
+    assert "work tree" in lowered_reason
+    assert "run this command from the work tree" in lowered_reason

package/hooks/blocking/test_verified_commit_gate_additional_context.py

@@ -0,0 +1,134 @@
+"""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/tests/test_pii_prevention_blocker.py

@@ -142,7 +142,6 @@ def test_commit_with_missing_local_identity_still_blocks_the_value(
     assert deny_reason is not None
     assert "email" in deny_reason
 
-
 def _init_repo_with_staged_pii(repository_root: Path) -> None:
     repository_root.mkdir(parents=True, exist_ok=True)
     subprocess.run(["git", "init", "-q"], cwd=repository_root, check=True)

package/hooks/blocking/tests/test_verified_commit_gate.py

@@ -0,0 +1,41 @@
+"""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") == ""

package/hooks/blocking/verified_commit_config_bootstrap.py

@@ -1,12 +1,13 @@
-"""Deterministic loader for the verified-commit constants module.
+"""Deterministic loader for the verified-commit constants modules.
 
 The blocking hooks import their shared constants as
-``from config.verified_commit_constants import ...``. In the installed hook
-tree a second, unrelated ``config`` package can sit ahead of this package on
-``sys.path`` and win that dotted name by path order, so the import binds to the
-wrong file and raises ImportError on any constant the stale copy lacks. This
-module binds the dotted name to the sibling ``config/verified_commit_constants``
-file by explicit location, so resolution never depends on ``sys.path`` order.
+``from config.verified_commit_constants import ...`` and
+``from config.verified_commit_context_constants import ...``. In the installed
+hook tree a second, unrelated ``config`` package can sit ahead of this package
+on ``sys.path`` and win those dotted names by path order, so the import binds
+to the wrong file and raises ImportError on any constant the stale copy lacks.
+This module binds each dotted name to its sibling ``config/`` file by explicit
+location, so resolution never depends on ``sys.path`` order.
 """
 
 from __future__ import annotations
@@ -17,7 +18,7 @@ from pathlib import Path
 
 
 def register_verified_commit_constants() -> None:
-    """Bind ``config.verified_commit_constants`` to the sibling config file.
+    """Bind both verified-commit constants dotted names to their config files.
 
     ::
 
@@ -35,11 +36,22 @@ def register_verified_commit_constants() -> None:
     Returns:
         None. The effect is the ``sys.modules`` registration.
     """
-    config_module_dotted_name = "config.verified_commit_constants"
+    all_constants_module_stems = (
+        "verified_commit_constants",
+        "verified_commit_context_constants",
+        "verified_commit_gate_output_constants",
+    )
+    for each_module_stem in all_constants_module_stems:
+        _register_config_module(each_module_stem)
+
+
+def _register_config_module(module_stem: str) -> None:
+    """Bind one ``config.<module_stem>`` dotted name to its sibling file."""
+    config_module_dotted_name = f"config.{module_stem}"
     if config_module_dotted_name in sys.modules:
         return
     constants_file_path = (
-        Path(__file__).resolve().parent / "config" / "verified_commit_constants.py"
+        Path(__file__).resolve().parent / "config" / f"{module_stem}.py"
     )
     module_spec = importlib.util.spec_from_file_location(
         config_module_dotted_name, constants_file_path