claude-dev-env 2.28.0 → 2.29.0

package/hooks/blocking/precommit_code_rules_gate.py

@@ -1,11 +1,13 @@
-"""PreToolUse hook that passes Git commit validation to Git hooks.
-
-Intercepts Bash `git commit` invocations (including `git -C <path> commit`),
-emits neutral evidence, and returns control to Git. Configured Git hooks
-receive the commit at the commit boundary.
+"""Library helper: resolve a directory's Git repository root.
+
+``pii_prevention_blocker.py`` and ``pii_payload_scan.py`` import
+``resolve_repository_root`` to find the repository a staged-commit scan
+targets, and ``session_edit_stage_gate.py`` imports it to find the
+repository a commit's unstaged-edit check targets. This module carries no
+hook entry point of its own; the native ``git-hooks/pre_commit.py`` runs
+the real commit-time CODE_RULES enforcement.
 """
 
-import re
 import subprocess
 import sys
 from pathlib import Path
@@ -14,36 +16,12 @@ _hooks_directory = str(Path(__file__).resolve().parent.parent)
 if _hooks_directory not in sys.path:
     sys.path.insert(0, _hooks_directory)
 
-from block_main_commit import (  # noqa: E402
-    is_commit_command,
-    parse_bash_command_from_stdin,
-)
-
 from hooks_constants.precommit_code_rules_gate_constants import (  # noqa: E402
     ALL_GIT_REPOSITORY_ROOT_COMMAND,
     GIT_COMMAND_TIMEOUT_SECONDS,
-    GIT_DASH_C_COMMIT_PATTERN,
 )
 
 
-def is_git_commit_invocation(bash_command: str) -> bool:
-    """Report whether *bash_command* runs a git commit.
-
-    Matches both the plain ``git commit`` substring form and the
-    ``git -C <path> commit`` form, where the directory flag sits between
-    the two words.
-
-    Args:
-        bash_command: The Bash tool command string from the hook payload.
-
-    Returns:
-        True when the command invokes git commit; False otherwise.
-    """
-    if is_commit_command(bash_command):
-        return True
-    return re.search(GIT_DASH_C_COMMIT_PATTERN, bash_command) is not None
-
-
 def resolve_repository_root(working_directory: str | None) -> Path | None:
     """Resolve the Git repository root for a directory.
 
@@ -70,16 +48,3 @@ def resolve_repository_root(working_directory: str | None) -> Path | None:
     if not top_level_text:
         return None
     return Path(top_level_text)
-
-
-def main() -> None:
-    """Pass Git commit validation through to configured Git hooks."""
-    bash_command = parse_bash_command_from_stdin()
-    if not is_git_commit_invocation(bash_command):
-        sys.exit(0)
-    sys.stderr.write("Git commit proceeds to configured Git hooks.\n")
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/state_description_blocker.py

@@ -20,9 +20,6 @@ if _hooks_dir not in sys.path:
     sys.path.insert(0, _hooks_dir)
 
 from blocking.code_rules_shared import is_ephemeral_path  # noqa: E402
-from blocking.config.prose_style_enforcement_constants import (  # noqa: E402
-    prose_style_enforcement_enabled_in_environment,
-)
 from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin  # noqa: E402
 from hooks_constants.state_description_blocker_constants import (  # noqa: E402
@@ -281,8 +278,7 @@ def evaluate(payload_by_key: dict[str, object]) -> str | None:
 
     Applies the same tool-name gate, file-extension gate, content selection, and
     pattern scan the standalone hook applies. Returns the deny-reason text when a
-    historical phrase is found, or None to allow. Opinionated prose enforcement
-    is default-off via ``prose_style_enforcement_enabled_in_environment()``.
+    historical phrase is found, or None to allow. The check is unconditional.
 
     Args:
         payload_by_key: The PreToolUse payload with tool_name and tool_input.
@@ -291,8 +287,6 @@ def evaluate(payload_by_key: dict[str, object]) -> str | None:
         The permissionDecisionReason text when the write is denied, or None when
         the write is allowed.
     """
-    if not prose_style_enforcement_enabled_in_environment():
-        return None
     raw_tool_name = payload_by_key.get("tool_name", "")
     tool_name = raw_tool_name if isinstance(raw_tool_name, str) else ""
     if tool_name not in ("Write", "Edit"):

package/hooks/blocking/tdd_enforcer_parts/AGENTS.md

@@ -1,30 +1 @@
-# tdd_enforcer_parts
 
-The concern modules `tdd_enforcer.py` wires together to run the TDD gate. Each
-module owns one concern; the entry hook imports them and re-exports their
-surface for the test suite.
-
-## Modules
-
-| File | Purpose |
-|---|---|
-| `path_classification.py` | Classifies a write target (docs, tests, `.claude` trees) the gate skips, and extracts the written text from a Write, Edit, or MultiEdit payload |
-| `content_analysis.py` | Decides whether a payload is constants-only, and whether an Edit or MultiEdit merely removes or reorders imports |
-| `candidate_paths.py` | Resolves the candidate test files whose freshness can satisfy the gate for a production file |
-| `freshness.py` | Checks whether a candidate test was modified within the window and holds a real test function |
-| `git_tracking.py` | Detects a write that restores a git-tracked file absent on disk, so a remove-then-Write rewrite is exempt from the gate |
-| `decisions.py` | Builds the deny reason and writes the allow or deny decision JSON to stdout |
-| `__init__.py` | Package marker |
-
-## Subdirectories
-
-| Entry | Description |
-|---|---|
-| `config/` | The freshness window, the ancestor-walk limit, the git-tracking command tokens, the source-file extension sets, and the join separator (`tdd_enforcer_constants.py`) |
-| `tests/` | pytest suite with one test module per module above |
-
-## Running tests
-
-```bash
-python -m pytest packages/claude-dev-env/hooks/blocking/tdd_enforcer_parts/tests/
-```

package/hooks/blocking/test_code_rules_enforcer_cap_meta.py

@@ -47,7 +47,6 @@ VOID_ADVISORY_CHECK_FUNCTION_NAMES: frozenset[str] = frozenset(
     {
         "check_duplicated_format_patterns",
         "check_flag_gated_scenario_test_naming",
-        "check_incomplete_mocks",
     }
 )
 

package/hooks/blocking/test_code_rules_enforcer_dispatch_wiring.py

@@ -71,14 +71,6 @@ def test_every_check_function_is_called_in_validate_content() -> None:
     )
 
 
-def test_dead_module_constant_check_stays_wired() -> None:
-    validate_content_source = _validate_content_source()
-    assert "check_dead_module_constants" in validate_content_source, (
-        "check_dead_module_constants must stay dispatched from validate_content so a "
-        "dead exported constant (the MEDIUM_TEXT class) is blocked at Write/Edit time."
-    )
-
-
 def test_known_undispatched_set_lists_only_existing_checks() -> None:
     all_check_names = set(_all_check_function_names())
     stale_names = KNOWN_UNDISPATCHED_CHECKS - all_check_names

package/hooks/blocking/test_code_rules_enforcer_module_docstring_roster.py

@@ -1,11 +1,9 @@
-"""Tests for the module-docstring check roster and docstring tuple-enumeration checks.
+"""Tests for the module-docstring check roster.
 
-Both checks catch docstring-prose-vs-implementation drift in a check-registry
-module — a hook module that exposes several public ``check_*`` functions and a
-module-level tuple of literal attribute names. The drift the
+Catches docstring-prose-vs-implementation drift in a check-registry module — a
+hook module that exposes several public ``check_*`` functions. The drift the
 ``code_rules_test_assertions.py`` module hit at PR #713 HEAD: a one-line module
-docstring that names four of its five public checks, and a function docstring
-that enumerates three plumbing attributes while the tuple it reads holds four.
+docstring that names four of its five public checks.
 """
 
 from __future__ import annotations
@@ -32,10 +30,6 @@ def check_module_docstring_names_public_checks(content: str, file_path: str) ->
     return code_rules_enforcer.check_module_docstring_names_public_checks(content, file_path)
 
 
-def check_docstring_tuple_enumeration_match(content: str, file_path: str) -> list[str]:
-    return code_rules_enforcer.check_docstring_tuple_enumeration_match(content, file_path)
-
-
 def validate_content(content: str, file_path: str, old_content: str) -> list[str]:
     return code_rules_enforcer.validate_content(content, file_path, old_content)
 
@@ -202,101 +196,6 @@ def test_should_handle_module_roster_syntax_error_gracefully() -> None:
     assert issues == [], f"Syntax error must yield no issues, got: {issues!r}"
 
 
-def _module_with_drifted_tuple_enumeration() -> str:
-    return (
-        '"""Call-args plumbing detection."""\n'
-        "\n"
-        '_CALL_ARGS_PLUMBING_ATTRIBUTES = ("call_args", "call_args_list", "called", "call_count")\n'
-        "\n"
-        "def check_plumbing(content: str, file_path: str) -> list[str]:\n"
-        '    """Advise when a test asserts only on call-args plumbing.\n'
-        "\n"
-        "    A body asserting on call-args plumbing (``call_args``, ``call_args_list``,\n"
-        "    ``.kwargs``) reaches into mock internals rather than observed behavior.\n"
-        '    """\n'
-        "    for each_name in _CALL_ARGS_PLUMBING_ATTRIBUTES:\n"
-        "        if each_name in content:\n"
-        "            return [each_name]\n"
-        "    return []\n"
-    )
-
-
-def test_should_flag_docstring_tuple_enumeration_drift() -> None:
-    issues = check_docstring_tuple_enumeration_match(
-        _module_with_drifted_tuple_enumeration(), HOOK_INFRASTRUCTURE_PATH
-    )
-    assert any("check_plumbing" in each for each in issues), (
-        f"Expected the drifted enumeration to flag, got: {issues!r}"
-    )
-    assert any("kwargs" in each for each in issues), (
-        f"Expected the docstring-only token named in the message, got: {issues!r}"
-    )
-    assert any("called" in each for each in issues), (
-        f"Expected a tuple-only member named in the message, got: {issues!r}"
-    )
-    assert len(issues) == 1
-
-
-def test_should_not_flag_docstring_tuple_enumeration_match() -> None:
-    source = (
-        '"""Call-args plumbing detection."""\n'
-        "\n"
-        '_CALL_ARGS_PLUMBING_ATTRIBUTES = ("call_args", "call_args_list", "called", "call_count")\n'
-        "\n"
-        "def check_plumbing(content: str, file_path: str) -> list[str]:\n"
-        '    """Advise when a test asserts only on call-args plumbing.\n'
-        "\n"
-        "    A body asserting on call-args plumbing (``call_args``, ``call_args_list``,\n"
-        "    ``called``, ``call_count``) reaches into mock internals.\n"
-        '    """\n'
-        "    for each_name in _CALL_ARGS_PLUMBING_ATTRIBUTES:\n"
-        "        if each_name in content:\n"
-        "            return [each_name]\n"
-        "    return []\n"
-    )
-    issues = check_docstring_tuple_enumeration_match(source, HOOK_INFRASTRUCTURE_PATH)
-    assert issues == [], f"Matching enumeration must not flag, got: {issues!r}"
-
-
-def test_should_not_flag_docstring_without_tuple_overlap() -> None:
-    source = (
-        '"""Call-args plumbing detection."""\n'
-        "\n"
-        '_CALL_ARGS_PLUMBING_ATTRIBUTES = ("call_args", "call_args_list", "called", "call_count")\n'
-        "\n"
-        "def check_plumbing(content: str, file_path: str) -> list[str]:\n"
-        '    """Advise when a test asserts only on mock internals.\n'
-        "\n"
-        "    A body reading ``foo``, ``bar``, ``baz`` is unrelated to the tuple.\n"
-        '    """\n'
-        "    for each_name in _CALL_ARGS_PLUMBING_ATTRIBUTES:\n"
-        "        if each_name in content:\n"
-        "            return [each_name]\n"
-        "    return []\n"
-    )
-    issues = check_docstring_tuple_enumeration_match(source, HOOK_INFRASTRUCTURE_PATH)
-    assert issues == [], f"A docstring not naming the tuple must not flag, got: {issues!r}"
-
-
-def test_should_not_flag_when_function_does_not_reference_the_tuple() -> None:
-    source = (
-        '"""Call-args plumbing detection."""\n'
-        "\n"
-        '_CALL_ARGS_PLUMBING_ATTRIBUTES = ("call_args", "call_args_list", "called", "call_count")\n'
-        "\n"
-        "def check_unrelated(content: str, file_path: str) -> list[str]:\n"
-        '    """Advise on ``call_args`` and ``call_args_list`` usage in tests."""\n'
-        "    return [content[:0]]\n"
-    )
-    issues = check_docstring_tuple_enumeration_match(source, HOOK_INFRASTRUCTURE_PATH)
-    assert issues == [], f"A function not reading the tuple must not flag, got: {issues!r}"
-
-
-def test_should_handle_tuple_enumeration_syntax_error_gracefully() -> None:
-    issues = check_docstring_tuple_enumeration_match("def broken(\n", HOOK_INFRASTRUCTURE_PATH)
-    assert issues == [], f"Syntax error must yield no issues, got: {issues!r}"
-
-
 def test_validate_content_surfaces_module_roster_drift() -> None:
     issues = validate_content(
         _registry_module_omitting_a_check(), HOOK_INFRASTRUCTURE_PATH, old_content=""
@@ -309,11 +208,11 @@ def test_validate_content_surfaces_module_roster_drift() -> None:
     )
 
 
-def test_validate_content_surfaces_tuple_enumeration_drift() -> None:
-    issues = validate_content(
-        _module_with_drifted_tuple_enumeration(), HOOK_INFRASTRUCTURE_PATH, old_content=""
-    )
-    matching_issues = [each for each in issues if "check_plumbing" in each and "enumerat" in each]
-    assert matching_issues, (
-        f"Expected validate_content to surface the tuple-enumeration drift, got: {issues!r}"
+def test_imports_logging_module_docstring_names_every_public_check() -> None:
+    """The shipped imports-logging module's own roster stays complete after trims."""
+    module_path = Path(__file__).resolve().parent / "code_rules_imports_logging.py"
+    module_source = module_path.read_text(encoding="utf-8")
+    issues = check_module_docstring_names_public_checks(
+        module_source, HOOK_INFRASTRUCTURE_PATH
     )
+    assert issues == [], f"Roster drift in code_rules_imports_logging.py: {issues!r}"

package/hooks/blocking/test_code_rules_enforcer_narrow_edit.py

@@ -39,7 +39,6 @@ class NarrowEditFixture:
 ALL_SCOPE_AWARE_RULE_NAMES = frozenset(
     {
         "check_blast_radius_declared",
-        "check_import_block_sorted",
         "check_magic_values",
         "check_duplicate_function_body_across_files",
         "check_same_file_inline_duplicate_body",

package/hooks/blocking/test_code_rules_enforcer_split_entry_1.py

@@ -28,8 +28,6 @@ code_rules_enforcer = SimpleNamespace(
 
 DUPLICATED_FORMAT_PRODUCTION_FILE_PATH = "packages/app/services/api_client.py"
 
-INCOMPLETE_MOCK_TEST_FILE_PATH = "packages/app/tests/test_orders.py"
-
 
 def _oversized_function_source(name: str) -> str:
     body_line_count = code_rules_enforcer.FUNCTION_LENGTH_BLOCKING_THRESHOLD - 1
@@ -39,24 +37,9 @@ def _oversized_function_source(name: str) -> str:
     return f"def {name}() -> None:\n" + "\n".join(body_lines) + "\n"
 
 
-def test_should_emit_advisories_for_incomplete_mocks_and_format_patterns_via_validate_content(
+def test_should_emit_advisory_for_duplicated_format_patterns_via_validate_content(
     capsys: object,
 ) -> None:
-    incomplete_mock_source = (
-        "mock_order = {'id': 1}\n"
-        "\n"
-        "def test_order_total() -> None:\n"
-        "    total = mock_order['total']\n"
-        "    assert total > 0\n"
-    )
-    code_rules_enforcer.validate_content(
-        incomplete_mock_source, INCOMPLETE_MOCK_TEST_FILE_PATH
-    )
-    captured = getattr(capsys, "readouterr")()
-    assert "mock_order" in captured.err and "total" in captured.err, (
-        f"Expected incomplete-mock advisory from validate_content, got: {captured.err!r}"
-    )
-
     repeated_pattern_source = (
         "def get_user(user_id: str) -> str:\n"
         "    return f'/api/{user_id}'\n"

package/hooks/blocking/test_code_rules_shared.py

@@ -279,3 +279,15 @@ def test_is_ephemeral_path_reads_session_id_from_environment(
     throwaway_script = scratchpad_directory / "probe.py"
 
     assert _SHARED_MODULE.is_ephemeral_path(str(throwaway_script)) is True
+
+
+def test_is_dedicated_constants_module_true_for_constants_suffix() -> None:
+    assert _SHARED_MODULE._is_dedicated_constants_module("hooks_constants/foo_constants.py") is True
+
+
+def test_is_dedicated_constants_module_true_for_config_directory() -> None:
+    assert _SHARED_MODULE._is_dedicated_constants_module("app/config/timing.py") is True
+
+
+def test_is_dedicated_constants_module_false_for_ordinary_module() -> None:
+    assert _SHARED_MODULE._is_dedicated_constants_module("app/services/orders.py") is False

package/hooks/blocking/test_precommit_code_rules_gate.py

@@ -1,111 +1,23 @@
-"""Behavior tests for the pass-through precommit_code_rules_gate hook.
+"""Behavior tests for the precommit_code_rules_gate library module.
 
-Each test builds a real git repository in a temporary directory, stages
-real files, and runs the hook script as a subprocess with a PreToolUse
-JSON payload on stdin through the exact production invocation path.
+The module carries no hook entry point of its own; it exports
+``resolve_repository_root`` for its importers (``pii_prevention_blocker.py``,
+``pii_payload_scan.py``, ``session_edit_stage_gate.py``).
 """
 
-import json
 import subprocess
 import sys
 from pathlib import Path
 
-HOOK_PATH = Path(__file__).resolve().parent / "precommit_code_rules_gate.py"
-
-CLEAN_MODULE_SOURCE = '''"""Increment helper used by the precommit gate tests."""
-
-
-def add_one(number: int) -> int:
-    """Return *number* plus one.
-
-    Args:
-        number: The integer to increment.
-
-    Returns:
-        The incremented integer.
-    """
-    return number + 1
-'''
-
-VIOLATING_MODULE_SOURCE = '''"""Module carrying a banned identifier for the precommit gate tests."""
-
-
-def compute_total() -> int:
-    """Return a fixed total.
-
-    Returns:
-        The fixed total.
-    """
-    result = 1
-    return result
-'''
-
-WIDGET_MODULE_BASE_SOURCE = '''"""Arithmetic helpers used by the precommit gate worktree tests."""
-
-
-def add_one(number: int) -> int:
-    """Return *number* plus one.
-
-    Args:
-        number: The integer to increment.
-
-    Returns:
-        The incremented integer.
-    """
-    return number + 1
-'''
-
-WIDGET_MODULE_EXPANDED_SOURCE = '''"""Arithmetic helpers used by the precommit gate worktree tests."""
-
-
-def add_one(number: int) -> int:
-    """Return *number* plus one.
-
-    Args:
-        number: The integer to increment.
-
-    Returns:
-        The incremented integer.
-    """
-    return number + 1
-
-
-def subtract_one(number: int) -> int:
-    """Return *number* minus one.
-
-    Args:
-        number: The integer to decrement.
-
-    Returns:
-        The decremented integer.
-    """
-    return number - 1
-'''
-
-WIDGET_TEST_BASE_SOURCE = '''"""Behavior tests for the widget arithmetic helpers."""
-
-from widget import add_one
-
-
-def test_add_one_increments() -> None:
-    """add_one returns its argument plus one."""
-    assert add_one(1) == 2
-'''
-
-WIDGET_TEST_EXPANDED_SOURCE = '''"""Behavior tests for the widget arithmetic helpers."""
-
-from widget import add_one, subtract_one
-
-
-def test_add_one_increments() -> None:
-    """add_one returns its argument plus one."""
-    assert add_one(1) == 2
-
-
-def test_subtract_one_decrements() -> None:
-    """subtract_one returns its argument minus one."""
-    assert subtract_one(2) == 1
-'''
+try:
+    import precommit_code_rules_gate as gate_module
+    from precommit_code_rules_gate import resolve_repository_root
+except ModuleNotFoundError:
+    _BLOCKING_DIR = str(Path(__file__).resolve().parent)
+    if _BLOCKING_DIR not in sys.path:
+        sys.path.insert(0, _BLOCKING_DIR)
+    import precommit_code_rules_gate as gate_module
+    from precommit_code_rules_gate import resolve_repository_root
 
 
 def run_git(repository_root: Path, *git_arguments: str) -> None:
@@ -123,88 +35,29 @@ def initialize_repository(repository_root: Path) -> None:
     run_git(repository_root, "commit", "--allow-empty", "-m", "initial")
 
 
-def stage_file(repository_root: Path, relative_name: str, source_text: str) -> None:
-    (repository_root / relative_name).write_text(source_text, encoding="utf-8")
-    run_git(repository_root, "add", relative_name)
-
-
-def run_hook(bash_command: str, working_directory: Path) -> subprocess.CompletedProcess[str]:
-    payload = json.dumps({"tool_input": {"command": bash_command}})
-    return subprocess.run(
-        [sys.executable, str(HOOK_PATH)],
-        input=payload,
-        capture_output=True,
-        text=True,
-        cwd=str(working_directory),
-        timeout=120,
-    )
-
-
-def test_non_commit_command_passes_through(tmp_path: Path) -> None:
-    initialize_repository(tmp_path)
-    completed_hook = run_hook("git status", tmp_path)
-    assert completed_hook.returncode == 0
-    assert completed_hook.stdout.strip() == ""
-
-
-def test_commit_with_clean_staged_python_file_is_allowed(tmp_path: Path) -> None:
-    initialize_repository(tmp_path)
-    stage_file(tmp_path, "incrementer.py", CLEAN_MODULE_SOURCE)
-    completed_hook = run_hook("git commit -m add", tmp_path)
-    assert completed_hook.returncode == 0
-    assert completed_hook.stdout.strip() == ""
-    assert "Git commit proceeds to configured Git hooks." in completed_hook.stderr
-
-
-def test_commit_with_staged_python_file_passes_through(tmp_path: Path) -> None:
+def test_resolve_repository_root_returns_root_for_directory_inside_repository(
+    tmp_path: Path,
+) -> None:
     initialize_repository(tmp_path)
-    stage_file(tmp_path, "totals.py", VIOLATING_MODULE_SOURCE)
-    completed_hook = run_hook("git commit -m add", tmp_path)
-    assert completed_hook.returncode == 0
-    assert completed_hook.stdout.strip() == ""
-    assert "Git commit proceeds to configured Git hooks." in completed_hook.stderr
+    nested_directory = tmp_path / "nested"
+    nested_directory.mkdir()
+    resolved_root = resolve_repository_root(str(nested_directory))
+    assert resolved_root == tmp_path.resolve()
 
 
-def test_git_dash_c_commit_form_passes_through(tmp_path: Path) -> None:
-    repository_root = tmp_path / "repo"
-    repository_root.mkdir()
-    initialize_repository(repository_root)
-    stage_file(repository_root, "totals.py", VIOLATING_MODULE_SOURCE)
-    elsewhere = tmp_path / "elsewhere"
-    elsewhere.mkdir()
-    quoted_root = str(repository_root)
-    completed_hook = run_hook(f'git -C "{quoted_root}" commit -m add', elsewhere)
-    assert completed_hook.returncode == 0
-    assert completed_hook.stdout.strip() == ""
-    assert "Git commit proceeds to configured Git hooks." in completed_hook.stderr
+def test_resolve_repository_root_returns_none_outside_a_repository(
+    tmp_path: Path,
+) -> None:
+    non_repository_directory = tmp_path / "not_a_repo"
+    non_repository_directory.mkdir()
+    assert resolve_repository_root(str(non_repository_directory)) is None
 
 
-def test_commit_with_no_staged_python_files_is_allowed(tmp_path: Path) -> None:
-    initialize_repository(tmp_path)
-    stage_file(tmp_path, "notes.md", "# Notes\n")
-    completed_hook = run_hook("git commit -m docs", tmp_path)
-    assert completed_hook.returncode == 0
-    assert completed_hook.stdout.strip() == ""
+def test_module_carries_no_main_entry_point() -> None:
+    """The module has no dispatcher-facing hook entry point."""
+    assert not hasattr(gate_module, "main")
 
 
-def test_worktree_commit_passes_through(
-    tmp_path: Path,
-) -> None:
-    main_checkout = tmp_path / "main_checkout"
-    main_checkout.mkdir()
-    initialize_repository(main_checkout)
-    (main_checkout / "widget.py").write_text(WIDGET_MODULE_BASE_SOURCE, encoding="utf-8")
-    (main_checkout / "test_widget.py").write_text(WIDGET_TEST_BASE_SOURCE, encoding="utf-8")
-    run_git(main_checkout, "add", "widget.py", "test_widget.py")
-    run_git(main_checkout, "commit", "-m", "base")
-    worktree_root = tmp_path / "sibling_worktree"
-    run_git(main_checkout, "worktree", "add", str(worktree_root), "-b", "feature")
-    stage_file(worktree_root, "widget.py", WIDGET_MODULE_EXPANDED_SOURCE)
-    stage_file(worktree_root, "test_widget.py", WIDGET_TEST_EXPANDED_SOURCE)
-    quoted_worktree = str(worktree_root)
-    completed_hook = run_hook(
-        f'git -C "{quoted_worktree}" commit -m expand', main_checkout
-    )
-    assert completed_hook.returncode == 0
-    assert completed_hook.stdout.strip() == ""
-    assert "Git commit proceeds to configured Git hooks." in completed_hook.stderr
+def test_module_carries_no_commit_invocation_detector() -> None:
+    """The commit-detection helper lives in block_main_commit, not duplicated here."""
+    assert not hasattr(gate_module, "is_git_commit_invocation")

package/hooks/blocking/test_precommit_code_rules_gate_native_owner.py

@@ -183,7 +183,6 @@ def test_agent_dispatcher_passes_commit_through_without_running_gate(
 
     assert completed_dispatcher.returncode == 0, completed_dispatcher.stderr
     assert completed_dispatcher.stdout.strip() == ""
-    assert "Git commit proceeds to configured Git hooks." in completed_dispatcher.stderr
     assert not gate_marker_path.exists()
 
 

package/hooks/blocking/test_state_description_blocker.py

@@ -74,7 +74,7 @@ class _RunHook:
 _run_hook = _RunHook()
 
 
-def test_historical_phrase_scan_is_default_off(
+def test_historical_phrase_scan_runs_with_the_env_flag_unset(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.delenv("CLAUDE_PROSE_STYLE_ENFORCEMENT", raising=False)
@@ -87,8 +87,8 @@ def test_historical_phrase_scan_is_default_off(
         is_prose_style_enabled=False,
     )
     assert result.returncode == 0
-    assert result.stdout == ""
-    assert _evaluate_without_opt_in(
+    assert result.stdout.strip() != ""
+    deny_reason = _evaluate_without_opt_in(
         {
             "tool_name": "Write",
             "tool_input": {
@@ -96,7 +96,9 @@ def test_historical_phrase_scan_is_default_off(
                 "content": VIOLATION_INSTEAD_OF_COMMENT,
             },
         }
-    ) is None
+    )
+    assert deny_reason is not None
+    assert "instead of" in deny_reason
 
 
 def test_block_clean_python_comment_passes():