claude-dev-env 2.12.0 → 2.14.0

package/hooks/blocking/pr_description_readability.py

@@ -1,364 +0,0 @@
-"""Score PR body readability and manage its persisted strike/threshold state.
-
-Computes Flesch Reading Ease and sentence-length metrics over the intro and
-first section of a PR body, escalates repeated readability failures through a
-persisted strike counter, applies the loosen/reset/enable/disable threshold
-overrides, and dispatches the readability-management CLI flags.
-"""
-
-import json
-import math
-import os
-import re
-import sys
-from pathlib import Path
-from typing import TextIO
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from blocking.pr_description_body_audit import strip_markdown_ceremony  # noqa: E402
-from hooks_constants.pr_description_enforcer_constants import (  # noqa: E402
-    ATOMIC_WRITE_TEMP_SUFFIX,
-    DEFAULT_READABILITY_THRESHOLDS,
-    FENCED_CODE_BLOCK_PATTERN,
-    FLESCH_BASE_SCORE,
-    FLESCH_PERFECT_SCORE,
-    FLESCH_SYLLABLES_PER_WORD_COEFFICIENT,
-    FLESCH_WORDS_PER_SENTENCE_COEFFICIENT,
-    HEADING_LINE_PATTERN,
-    READABILITY_AVG_SENTENCE_WORDS_CEILING,
-    READABILITY_ENABLED_STATE_FILE,
-    READABILITY_FLESCH_LOOSEN_FACTOR,
-    READABILITY_LOOSEN_CAP,
-    READABILITY_MAX_SENTENCE_WORDS_CEILING,
-    READABILITY_MIN_FLESCH_FLOOR,
-    READABILITY_SENTENCE_WORDS_LOOSEN_FACTOR,
-    READABILITY_STATE_FILE,
-    READABILITY_THRESHOLD_OVERRIDE_FILE,
-    ReadabilityThresholds,
-)
-from hooks_constants.setup_project_paths_constants import UTF8_ENCODING  # noqa: E402
-
-
-def _atomic_write_json(target_path: Path, all_payload_fields: dict[str, object]) -> None:
-    target_path.parent.mkdir(parents=True, exist_ok=True)
-    temporary_path = target_path.with_suffix(target_path.suffix + ATOMIC_WRITE_TEMP_SUFFIX)
-    with open(temporary_path, "w", encoding=UTF8_ENCODING) as write_handle:
-        json.dump(all_payload_fields, write_handle)
-    os.replace(temporary_path, target_path)
-
-
-def _read_json_or_default(
-    target_path: Path, all_default_payload_fields: dict[str, object]
-) -> dict[str, object]:
-    if not target_path.exists():
-        return dict(all_default_payload_fields)
-    try:
-        with open(target_path, "r", encoding=UTF8_ENCODING) as read_handle:
-            loaded_payload = json.load(read_handle)
-    except (FileNotFoundError, PermissionError, OSError, json.JSONDecodeError):
-        return dict(all_default_payload_fields)
-    if not isinstance(loaded_payload, dict):
-        return dict(all_default_payload_fields)
-    return loaded_payload
-
-
-def _read_strike_count() -> int:
-    payload = _read_json_or_default(READABILITY_STATE_FILE, {"strikes": 0})
-    raw_count = payload.get("strikes", 0)
-    if isinstance(raw_count, int) and not isinstance(raw_count, bool):
-        return max(raw_count, 0)
-    return 0
-
-
-def _increment_strike_count() -> int:
-    payload = _read_json_or_default(READABILITY_STATE_FILE, {"strikes": 0})
-    raw_count = payload.get("strikes", 0)
-    if isinstance(raw_count, int) and not isinstance(raw_count, bool):
-        starting_count = max(raw_count, 0)
-    else:
-        starting_count = 0
-    new_count = starting_count + 1
-    _atomic_write_json(READABILITY_STATE_FILE, {"strikes": new_count})
-    return new_count
-
-
-def _reset_strike_count() -> None:
-    _atomic_write_json(READABILITY_STATE_FILE, {"strikes": 0})
-
-
-def _resolve_integer_field(
-    all_payload_fields: dict[str, object], field_name: str, default_value: int
-) -> int:
-    raw_value = all_payload_fields.get(field_name, default_value)
-    if isinstance(raw_value, int) and not isinstance(raw_value, bool):
-        return raw_value
-    return default_value
-
-
-def _load_readability_thresholds() -> ReadabilityThresholds:
-    payload = _read_json_or_default(READABILITY_THRESHOLD_OVERRIDE_FILE, {})
-    return ReadabilityThresholds(
-        flesch_min=_resolve_integer_field(
-            payload, "flesch_min", DEFAULT_READABILITY_THRESHOLDS.flesch_min
-        ),
-        max_sentence_words=_resolve_integer_field(
-            payload, "max_sentence_words", DEFAULT_READABILITY_THRESHOLDS.max_sentence_words
-        ),
-        avg_sentence_words=_resolve_integer_field(
-            payload, "avg_sentence_words", DEFAULT_READABILITY_THRESHOLDS.avg_sentence_words
-        ),
-    )
-
-
-def _read_loosens_used() -> int:
-    payload = _read_json_or_default(READABILITY_THRESHOLD_OVERRIDE_FILE, {})
-    raw_count = payload.get("loosens_used", 0)
-    if isinstance(raw_count, int) and not isinstance(raw_count, bool):
-        return max(raw_count, 0)
-    return 0
-
-
-def _is_readability_enabled() -> bool:
-    payload = _read_json_or_default(READABILITY_ENABLED_STATE_FILE, {"enabled": True})
-    enabled_value = payload.get("enabled", True)
-    if isinstance(enabled_value, bool):
-        return enabled_value
-    return True
-
-
-def _set_readability_enabled(enabled: bool) -> None:
-    _atomic_write_json(READABILITY_ENABLED_STATE_FILE, {"enabled": enabled})
-
-
-def _count_syllables_in_word(word: str) -> int:
-    all_vowel_characters: frozenset[str] = frozenset("aeiouy")
-    cleaned_word = "".join(
-        each_character for each_character in word.lower() if each_character.isalpha()
-    )
-    if not cleaned_word:
-        return 0
-    syllable_count = 0
-    is_previous_character_vowel = False
-    for each_character in cleaned_word:
-        is_vowel = each_character in all_vowel_characters
-        if is_vowel and not is_previous_character_vowel:
-            syllable_count += 1
-        is_previous_character_vowel = is_vowel
-    if cleaned_word.endswith("e") and syllable_count > 1:
-        syllable_count -= 1
-    return max(syllable_count, 1)
-
-
-def _split_sentences(text: str) -> list[str]:
-    sentence_split_pattern = re.compile(r"[.!?]+\s+")
-    cleaned_text = text.strip()
-    if not cleaned_text:
-        return []
-    raw_pieces = sentence_split_pattern.split(cleaned_text)
-    all_sentences = [each_piece.strip() for each_piece in raw_pieces if each_piece.strip()]
-    return all_sentences
-
-
-def _compute_flesch_reading_ease(text: str) -> float:
-    all_sentences = _split_sentences(text)
-    if not all_sentences:
-        return FLESCH_PERFECT_SCORE
-    all_words: list[str] = []
-    total_syllables = 0
-    for each_sentence in all_sentences:
-        sentence_words = [
-            each_token for each_token in re.split(r"\s+", each_sentence) if each_token
-        ]
-        all_words.extend(sentence_words)
-        for each_word in sentence_words:
-            total_syllables += _count_syllables_in_word(each_word)
-    total_words = len(all_words)
-    if total_words == 0:
-        return FLESCH_PERFECT_SCORE
-    total_sentences = len(all_sentences)
-    return (
-        FLESCH_BASE_SCORE
-        - FLESCH_WORDS_PER_SENTENCE_COEFFICIENT * (total_words / total_sentences)
-        - FLESCH_SYLLABLES_PER_WORD_COEFFICIENT * (total_syllables / total_words)
-    )
-
-
-def _extract_readability_target_text(body: str) -> str:
-    """Return the ceremony-stripped prose window scored for readability.
-
-    Strips fenced code blocks, then builds a window from the body's intro
-    paragraph plus its first section's prose. The intro paragraph ends at the
-    earliest boundary among the first blank line and the first ATX header; when
-    neither boundary exists the whole body is the intro. The first section runs
-    from just after that first header to the next header (or end of body). The
-    intro and first section are joined with a blank line and returned with
-    Markdown ceremony stripped.
-
-    Args:
-        body: The raw PR body markdown text.
-
-    Returns:
-        The ceremony-stripped intro-paragraph plus first-section prose window
-        used for readability scoring.
-    """
-    intro_paragraph = ""
-    body_without_fences = FENCED_CODE_BLOCK_PATTERN.sub("", body)
-    body_after_strip = body_without_fences.lstrip()
-    blank_line_position = body_after_strip.find("\n\n")
-    header_position_match = HEADING_LINE_PATTERN.search(body_after_strip)
-    header_position = header_position_match.start() if header_position_match else -1
-
-    if blank_line_position == -1 and header_position == -1:
-        intro_paragraph = body_after_strip
-    elif blank_line_position == -1:
-        intro_paragraph = body_after_strip[:header_position]
-    elif header_position == -1:
-        intro_paragraph = body_after_strip[:blank_line_position]
-    else:
-        first_boundary = min(blank_line_position, header_position)
-        intro_paragraph = body_after_strip[:first_boundary]
-
-    first_body_section = ""
-    if header_position_match is not None:
-        section_start = header_position_match.end()
-        remainder = body_after_strip[section_start:]
-        next_header_match = HEADING_LINE_PATTERN.search(remainder)
-        if next_header_match is not None:
-            first_body_section = remainder[: next_header_match.start()]
-        else:
-            first_body_section = remainder
-
-    combined_text = f"{intro_paragraph}\n\n{first_body_section}"
-    return strip_markdown_ceremony(combined_text)
-
-
-def _evaluate_readability_metrics(
-    target_text: str,
-    thresholds: ReadabilityThresholds,
-) -> list[str]:
-    all_metric_violations: list[str] = []
-    all_sentences = _split_sentences(target_text)
-    if not all_sentences:
-        return all_metric_violations
-    word_counts_per_sentence: list[int] = []
-    for each_sentence in all_sentences:
-        sentence_words = [
-            each_token for each_token in re.split(r"\s+", each_sentence) if each_token
-        ]
-        word_counts_per_sentence.append(len(sentence_words))
-    max_sentence_words = max(word_counts_per_sentence) if word_counts_per_sentence else 0
-    average_sentence_words = (
-        sum(word_counts_per_sentence) / len(word_counts_per_sentence)
-        if word_counts_per_sentence
-        else 0.0
-    )
-    if max_sentence_words > thresholds.max_sentence_words:
-        all_metric_violations.append(
-            f"Readability: longest sentence is {max_sentence_words} words "
-            f"(maximum {thresholds.max_sentence_words}); "
-            "split or rewrite the longest sentence"
-        )
-    if average_sentence_words > thresholds.avg_sentence_words:
-        all_metric_violations.append(
-            f"Readability: average sentence is {average_sentence_words:.1f} words "
-            f"(maximum {thresholds.avg_sentence_words}); "
-            "shorten or split your longest sentences"
-        )
-    flesch_score = _compute_flesch_reading_ease(target_text)
-    if flesch_score < thresholds.flesch_min:
-        all_metric_violations.append(
-            f"Readability: Flesch Reading Ease is {flesch_score:.1f} "
-            f"(minimum {thresholds.flesch_min}); use shorter words and sentences"
-        )
-    return all_metric_violations
-
-
-def _build_readability_escape_hatch_message() -> str:
-    return (
-        "Readability strike threshold reached. Pick one: "
-        "(1) python <enforcer-path> --readability-loosen to widen thresholds 10%, "
-        "(2) python <enforcer-path> --readability-disable to skip the readability check, "
-        "(3) python <enforcer-path> --readability-reset to zero the strike counter, "
-        "(4) reply with the body plus the intended message to report a false positive."
-    )
-
-
-def _apply_readability_loosen() -> str:
-    current_thresholds = _load_readability_thresholds()
-    loosens_used = _read_loosens_used()
-
-    if loosens_used >= READABILITY_LOOSEN_CAP:
-        return "cap_reached"
-
-    if current_thresholds.flesch_min <= READABILITY_MIN_FLESCH_FLOOR:
-        return "floor_reached"
-
-    if current_thresholds.max_sentence_words >= READABILITY_MAX_SENTENCE_WORDS_CEILING:
-        return "ceiling_reached"
-
-    if current_thresholds.avg_sentence_words >= READABILITY_AVG_SENTENCE_WORDS_CEILING:
-        return "ceiling_reached"
-
-    next_flesch = max(
-        READABILITY_MIN_FLESCH_FLOOR,
-        math.floor(current_thresholds.flesch_min * READABILITY_FLESCH_LOOSEN_FACTOR),
-    )
-    next_max_sentence = min(
-        READABILITY_MAX_SENTENCE_WORDS_CEILING,
-        math.ceil(current_thresholds.max_sentence_words * READABILITY_SENTENCE_WORDS_LOOSEN_FACTOR),
-    )
-    next_avg_sentence = min(
-        READABILITY_AVG_SENTENCE_WORDS_CEILING,
-        math.ceil(current_thresholds.avg_sentence_words * READABILITY_SENTENCE_WORDS_LOOSEN_FACTOR),
-    )
-
-    next_payload: dict[str, object] = {
-        "flesch_min": next_flesch,
-        "max_sentence_words": next_max_sentence,
-        "avg_sentence_words": next_avg_sentence,
-        "loosens_used": loosens_used + 1,
-    }
-    _atomic_write_json(READABILITY_THRESHOLD_OVERRIDE_FILE, next_payload)
-    return "ok"
-
-
-def _apply_readability_reset() -> None:
-    _reset_strike_count()
-    _atomic_write_json(READABILITY_THRESHOLD_OVERRIDE_FILE, {"loosens_used": 0})
-
-
-def _dispatch_cli_flag(
-    flag_token: str,
-    output_stream: TextIO,
-    error_stream: TextIO,
-) -> None:
-    """Handle a single readability-management CLI flag and exit the process."""
-    if flag_token == "--readability-loosen":
-        outcome = _apply_readability_loosen()
-        if outcome == "cap_reached":
-            error_stream.write(
-                "loosen cap reached; use --readability-disable or --readability-reset\n"
-            )
-            sys.exit(1)
-        if outcome in {"floor_reached", "ceiling_reached"}:
-            error_stream.write(
-                "thresholds already at floor/ceiling; use --readability-disable or --readability-reset\n"
-            )
-            sys.exit(1)
-        output_stream.write("readability thresholds loosened 10%\n")
-        sys.exit(0)
-    if flag_token == "--readability-reset":
-        _apply_readability_reset()
-        output_stream.write("readability strike counter and override thresholds reset\n")
-        sys.exit(0)
-    if flag_token == "--readability-disable":
-        _set_readability_enabled(False)
-        output_stream.write("readability check disabled\n")
-        sys.exit(0)
-    if flag_token == "--readability-enable":
-        _set_readability_enabled(True)
-        output_stream.write("readability check enabled\n")
-        sys.exit(0)

package/hooks/blocking/reviewer_spawn_gate.py

@@ -1,182 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: block a reviewer-spawn trigger when that reviewer is down.
-
-autoconverge already skips a reviewer step when its own pre-check reports
-that reviewer unavailable. That skip only protects the trigger commands the
-workflow generates and inspects itself. This hook is the backstop: it reads
-the Bash command a tool call is about to run and blocks it when the matched
-reviewer reports unavailable.
-
-The gate only inspects a command carrying the literal sentinel marker
-`CLAUDE_REVIEWER_GATE=autoconverge`. autoconverge prepends this marker to its
-own trigger commands. A command without the marker is never inspected, so a
-manual or unrelated `gh` call always passes through untouched.
-
-A Copilot trigger is a command containing both `requested_reviewers` and
-`copilot-pull-request-reviewer[bot]`. A Bugbot trigger is a command
-containing `post_fix_reply.py` and a `--body "bugbot run"` argument.
-
-For the matched reviewer, the gate runs
-`reviewer_availability.py --reviewer copilot|bugbot` and denies the call only
-when that script exits with the documented reviewer-down code (3). Any other
-exit code is an unexpected script failure, not a down report, so the call is
-allowed (fail open). The deny reason names the reviewer and carries
-the script's output. The script path resolves relative to this hook's
-install location by default, or from the
-`REVIEWER_SPAWN_GATE_AVAILABILITY_SCRIPT_PATH` environment variable when set.
-A missing script, a timeout, or a failure to launch it allows the call
-(fail open), so a broken availability check never blocks a legitimate run.
-"""
-
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-from hooks_constants.reviewer_spawn_gate_constants import (  # noqa: E402
-    ALL_COPILOT_TRIGGER_MARKERS,
-    AVAILABILITY_DOWN_EXIT_CODE,
-    AVAILABILITY_REVIEWER_FLAG,
-    AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME,
-    AVAILABILITY_SCRIPT_RELATIVE_PATH,
-    AVAILABILITY_SCRIPT_TIMEOUT_SECONDS,
-    BASH_TOOL_NAME,
-    BUGBOT_REVIEWER_LABEL,
-    BUGBOT_REVIEWER_TOKEN,
-    BUGBOT_RUN_BODY_PATTERN,
-    BUGBOT_TRIGGER_SCRIPT_MARKER,
-    COPILOT_REVIEWER_LABEL,
-    COPILOT_REVIEWER_TOKEN,
-    DENY_REASON_TEMPLATE,
-    GATE_SENTINEL_MARKER,
-)
-
-
-def _matches_copilot_trigger(command: str) -> bool:
-    return all(each_marker in command for each_marker in ALL_COPILOT_TRIGGER_MARKERS)
-
-
-def _matches_bugbot_trigger(command: str) -> bool:
-    return BUGBOT_TRIGGER_SCRIPT_MARKER in command and bool(
-        BUGBOT_RUN_BODY_PATTERN.search(command)
-    )
-
-
-def _reviewer_trigger(command: str) -> tuple[str, str] | None:
-    """Return the reviewer token and label a scoped command triggers.
-
-    Args:
-        command: The Bash command text carrying the gate's sentinel marker.
-
-    Returns:
-        The matched reviewer's CLI token paired with its display label, or
-        None when the command matches neither the Copilot review-request
-        shape nor the Bugbot rerun-comment shape.
-    """
-    if _matches_copilot_trigger(command):
-        return COPILOT_REVIEWER_TOKEN, COPILOT_REVIEWER_LABEL
-    if _matches_bugbot_trigger(command):
-        return BUGBOT_REVIEWER_TOKEN, BUGBOT_REVIEWER_LABEL
-    return None
-
-
-def _resolve_availability_script_path() -> Path:
-    override_path = os.environ.get(AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME, "")
-    if override_path:
-        return Path(override_path)
-    plugin_root = Path(__file__).resolve().parents[2]
-    return plugin_root / AVAILABILITY_SCRIPT_RELATIVE_PATH
-
-
-def _probe_reviewer_availability(reviewer_token: str) -> tuple[bool, str]:
-    """Run the shared availability script for a reviewer and report the outcome.
-
-    Args:
-        reviewer_token: The reviewer's CLI token (copilot or bugbot) passed to
-            the availability script's --reviewer flag.
-
-    Returns:
-        A pair of (is_available, detail_text). is_available is False only
-        when the script exits with the documented reviewer-down code;
-        detail_text carries the script's combined stdout and stderr for the
-        deny message. A missing script, a timeout, an OS-level failure to
-        launch the script, or any exit code other than the documented down
-        code reports available (fail open), so an availability-check crash
-        never blocks a legitimate run.
-    """
-    script_path = _resolve_availability_script_path()
-    if not script_path.is_file():
-        return True, f"availability script not found at {script_path}"
-    try:
-        completed_process = subprocess.run(
-            [sys.executable, str(script_path), AVAILABILITY_REVIEWER_FLAG, reviewer_token],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=AVAILABILITY_SCRIPT_TIMEOUT_SECONDS,
-            check=False,
-        )
-    except (OSError, subprocess.TimeoutExpired) as availability_error:
-        return True, f"availability script failed to run: {availability_error}"
-    availability_detail_text = (completed_process.stdout + completed_process.stderr).strip()
-    is_reviewer_down = completed_process.returncode == AVAILABILITY_DOWN_EXIT_CODE
-    return not is_reviewer_down, availability_detail_text
-
-
-def main() -> None:
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-    if not isinstance(hook_input, dict):
-        sys.exit(0)
-
-    tool_name = hook_input.get("tool_name", "")
-    if tool_name != BASH_TOOL_NAME:
-        sys.exit(0)
-
-    tool_input = hook_input.get("tool_input", {})
-    command = tool_input.get("command", "") if isinstance(tool_input, dict) else ""
-    if not command or GATE_SENTINEL_MARKER not in command:
-        sys.exit(0)
-
-    reviewer_trigger = _reviewer_trigger(command)
-    if reviewer_trigger is None:
-        sys.exit(0)
-    reviewer_token, reviewer_label = reviewer_trigger
-
-    is_available, availability_detail = _probe_reviewer_availability(reviewer_token)
-    if is_available:
-        sys.exit(0)
-
-    deny_reason = DENY_REASON_TEMPLATE.format(
-        reviewer_label=reviewer_label, availability_detail=availability_detail
-    )
-    deny_payload = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": deny_reason,
-        }
-    }
-    log_hook_block(
-        calling_hook_name="reviewer_spawn_gate.py",
-        hook_event="PreToolUse",
-        block_reason=deny_reason,
-        tool_name=tool_name,
-        offending_input_preview=command,
-    )
-    print(json.dumps(deny_payload))
-    sys.stdout.flush()
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/test_code_review_enforcement_config_bootstrap.py

@@ -1,62 +0,0 @@
-"""Regression tests for the code-review enforcement constants bootstrap.
-
-These prove the shared constants module resolves to the sibling
-``config/code_review_enforcement_constants.py`` file even when a foreign
-``config`` package sits ahead of ``blocking`` on ``sys.path``, and that a
-registration a caller placed first is left untouched.
-"""
-
-import subprocess
-from collections.abc import Callable
-
-RunUnderConfigShadow = Callable[[str], subprocess.CompletedProcess[str]]
-
-
-def test_register_binds_dotted_name_to_sibling_constants_file(
-    run_under_config_shadow: RunUnderConfigShadow,
-) -> None:
-    completed_probe = run_under_config_shadow(
-        "import code_review_enforcement_config_bootstrap as bootstrap\n"
-        "bootstrap.register_code_review_enforcement_constants()\n"
-        "import config.code_review_enforcement_constants as loaded\n"
-        "print(loaded.__file__)\n"
-        "print(loaded.STAMP_DIRECTORY_NAME)\n"
-    )
-    assert completed_probe.returncode == 0, completed_probe.stderr
-    assert "IS_DECOY_CONFIG" not in completed_probe.stdout
-    resolved_file_line, stamp_directory_line = completed_probe.stdout.splitlines()[:2]
-    assert resolved_file_line.replace("\\", "/").endswith(
-        "blocking/config/code_review_enforcement_constants.py"
-    )
-    assert stamp_directory_line == "code-review-stamps"
-
-
-def test_register_binds_push_required_effort(
-    run_under_config_shadow: RunUnderConfigShadow,
-) -> None:
-    completed_probe = run_under_config_shadow(
-        "import code_review_enforcement_config_bootstrap as bootstrap\n"
-        "bootstrap.register_code_review_enforcement_constants()\n"
-        "import config.code_review_enforcement_constants as loaded\n"
-        "print(loaded.PUSH_REQUIRED_EFFORT)\n"
-    )
-    assert completed_probe.returncode == 0, completed_probe.stderr
-    assert completed_probe.stdout.strip().splitlines()[-1] == "low"
-
-
-def test_register_leaves_an_already_cached_module_untouched(
-    run_under_config_shadow: RunUnderConfigShadow,
-) -> None:
-    completed_probe = run_under_config_shadow(
-        "import sys\n"
-        "import types\n"
-        "sentinel = types.ModuleType('config.code_review_enforcement_constants')\n"
-        "sentinel.ORIGIN = 'caller-seeded'\n"
-        "sys.modules['config.code_review_enforcement_constants'] = sentinel\n"
-        "import code_review_enforcement_config_bootstrap as bootstrap\n"
-        "bootstrap.register_code_review_enforcement_constants()\n"
-        "import config.code_review_enforcement_constants as loaded\n"
-        "print(getattr(loaded, 'ORIGIN', 'displaced'))\n"
-    )
-    assert completed_probe.returncode == 0, completed_probe.stderr
-    assert completed_probe.stdout.strip().splitlines()[-1] == "caller-seeded"

package/hooks/blocking/test_code_review_gate_deny.py

@@ -1,54 +0,0 @@
-"""Behavioral tests for the shared code-review gate deny scaffold.
-
-The tests drive the two shared helpers directly: the payload builder's shape and
-the log-and-emit helper's stdout, so both code-review gates inherit one verified
-deny path.
-"""
-
-from __future__ import annotations
-
-import importlib.util
-import json
-import sys
-from pathlib import Path
-from types import ModuleType
-
-import pytest
-
-_HOOK_DIR = Path(__file__).resolve().parent
-if str(_HOOK_DIR) not in sys.path:
-    sys.path.insert(0, str(_HOOK_DIR))
-
-
-def _load_module(module_name: str) -> ModuleType:
-    module_spec = importlib.util.spec_from_file_location(
-        module_name, _HOOK_DIR / f"{module_name}.py"
-    )
-    assert module_spec is not None
-    assert module_spec.loader is not None
-    loaded_module = importlib.util.module_from_spec(module_spec)
-    module_spec.loader.exec_module(loaded_module)
-    return loaded_module
-
-
-deny_module = _load_module("code_review_gate_deny")
-
-
-def test_build_payload_carries_reason_and_deny_decision() -> None:
-    deny_payload = deny_module.build_code_review_deny_payload("blocked reason")
-    hook_output = deny_payload["hookSpecificOutput"]
-    assert hook_output["permissionDecision"] == "deny"
-    assert hook_output["permissionDecisionReason"] == "blocked reason"
-
-
-def test_log_and_emit_code_review_deny_writes_payload_to_stdout(
-    capsys: pytest.CaptureFixture[str],
-    monkeypatch: pytest.MonkeyPatch,
-    tmp_path: Path,
-) -> None:
-    monkeypatch.setattr(Path, "home", lambda: tmp_path)
-    deny_module.log_and_emit_code_review_deny("blocked reason", "Bash", "code_review_push_gate")
-    emitted_payload = json.loads(capsys.readouterr().out)
-    hook_output = emitted_payload["hookSpecificOutput"]
-    assert hook_output["permissionDecision"] == "deny"
-    assert hook_output["permissionDecisionReason"] == "blocked reason"