claude-dev-env 2.28.0 → 2.28.1

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():

package/hooks/blocking/test_stop_dispatcher.py

@@ -90,7 +90,7 @@ def test_dispatch_re_emits_first_block_with_system_message_and_suppress(
         HostedHookRun(captured_stdout="", did_crash=False),
         HostedHookRun(
             captured_stdout=_block_json(
-                "hedging blocked",
+                "keep fields",
                 system_message="rewrite the ending",
                 suppress_output=True,
             ),
@@ -108,15 +108,15 @@ def test_dispatch_re_emits_first_block_with_system_message_and_suppress(
     monkeypatch.setattr(
         "stop_dispatcher.ALL_STOP_HOSTED_HOOK_PATHS",
         (
-            "blocking/hedging_language_blocker.py",
+            "blocking/first_stub_hook.py",
             "blocking/question_to_user_enforcer.py",
-            "blocking/intent_only_ending_blocker.py",
+            "blocking/second_stub_hook.py",
         ),
     )
     dispatch('{"session_id": "test"}')
     emitted_payload = json.loads(capsys.readouterr().out.strip())
     assert emitted_payload["decision"] == "block"
-    assert emitted_payload["reason"] == "hedging blocked"
+    assert emitted_payload["reason"] == "keep fields"
     assert emitted_payload["systemMessage"] == "rewrite the ending"
     assert emitted_payload["suppressOutput"] is True
 
@@ -132,7 +132,7 @@ def test_dispatch_writes_nothing_when_no_hook_blocks(
     )
     monkeypatch.setattr(
         "stop_dispatcher.ALL_STOP_HOSTED_HOOK_PATHS",
-        ("blocking/hedging_language_blocker.py",),
+        ("blocking/first_stub_hook.py",),
     )
     dispatch('{"session_id": "test"}')
     assert capsys.readouterr().out == ""
@@ -151,30 +151,6 @@ def test_dispatcher_exits_zero_on_empty_payload() -> None:
     assert completed.stdout.strip() == ""
 
 
-def test_dispatcher_blocks_hedging_message_matching_standalone() -> None:
-    """A hedging last_assistant_message blocks through the dispatcher."""
-    payload_text = json.dumps(
-        {
-            "stop_hook_active": False,
-            "last_assistant_message": "This is probably correct.",
-        }
-    )
-    environment_by_key = {**os.environ, "CLAUDE_PROSE_STYLE_ENFORCEMENT": "1"}
-    completed = subprocess.run(
-        [sys.executable, _DISPATCHER_SCRIPT],
-        check=False,
-        input=payload_text,
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        env=environment_by_key,
-    )
-    assert completed.returncode == 0
-    parsed = json.loads(completed.stdout)
-    assert parsed["decision"] == "block"
-    assert "probably" in parsed["reason"].lower() or "hedging" in parsed["reason"].lower()
-
-
 def test_dispatcher_imports_standalone_with_only_blocking_on_the_path() -> None:
     """The dispatcher's bootstrap resolves hooks_constants without hooks/ on PYTHONPATH."""
     subprocess_environment = {**os.environ, "PYTHONPATH": str(_BLOCKING_DIR)}

package/hooks/hooks_constants/AGENTS.md

@@ -22,10 +22,6 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `command_dispatch_constants.py` | Command-word regex, command-key access pattern, tokenization pattern, and anchors for the unanchored command-dispatch meta-gate |
 | `conventional_pr_title_gate_constants.py` | Bash tool name, gh executable basenames and pr create/edit subcommand tokens, title/repo flag names, semantic-title-CI workflow markers, the Conventional Commits type list and title pattern, the semantic-pull-request action `types:` input pattern, and block-message text for the conventional-PR-title gate |
 | `cursor_cli_python_misfire_blocker_constants.py` | Detection patterns and deny message for Cursor launches that mistreat a Python code-rules-gate script |
-| `dead_argparse_argument_constants.py` | Patterns for detecting unused argparse arguments |
-| `dead_config_field_constants.py` | Patterns for detecting unused `*Config` / `*Selectors` dataclass fields |
-| `dead_dataclass_field_constants.py` | Patterns for detecting unused dataclass fields |
-| `dead_module_constant_constants.py` | Patterns for detecting unexported `UPPER_SNAKE` constants in `*_constants.py` modules |
 | `destructive_command_environment_constants.py` | Environment keys and shared truthy values used by destructive-command hooks |
 | `destructive_command_segment_constants.py` | The list of destructive shell command patterns the blocker matches |
 | `docstring_rule_gate_count_blocker_constants.py` | Target rule basename, spelled-out-number lookup, count-clause and `check_*` validator patterns, and block-message text for the docstring-rule gate-count staleness blocker |
@@ -36,7 +32,6 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `gh_pr_author_swap_constants.py` | Constants for the PR-author swap enforcement hooks |
 | `hardcoded_user_path_constants.py` | Patterns for detecting hardcoded home-directory paths |
 | `harness_scratchpad_constants.py` | Fixed path components (`claude` / `claude-` user-directory name and prefix, `scratchpad` leaf name), the PreToolUse session-id payload key, and the `CLAUDE_CODE_SESSION_ID` environment variable name that the code-rules and TDD gates use to recognize an existing harness session scratchpad directory |
-| `hedging_uncertainty_constants.py` | Sentence-boundary pattern, explicit uncertainty label patterns, hedge-term list separator, and positive corrective block text for OP-07C sentence-scoped hedging |
 | `hook_block_logger.py` | `log_hook_block()` — shared fail-safe logger every blocking hook calls to append a JSON record of each block decision to `~/.claude/logs/hook-blocks.log` |
 | `hook_prose_detector_consistency_constants.py` | Trigger patterns and corrective messages for the hook-prose consistency checker |
 | `hosted_hook_runner.py` | `run_hook_capturing_output()` — shared runner that runs one dispatcher-hosted hook in-process via runpy and returns its captured stdout and crash flag |
@@ -58,7 +53,7 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `pytest_invocation.py` | Pure parsed-segment classifier for pytest runs through interpreters, shims, wrappers, and shell string-exec forms; no pipeline deny decision |
 | `prose_matcher_precision_constants.py` | Sample floor, keep/narrow precision floors, matcher ids, label decisions, advisory log path, emit caps, and context fingerprint length for OP-07B prose-matcher advisory telemetry |
 | `pre_tool_use_stdin.py` | `read_hook_input_dictionary_from_stdin()` — shared stdin parser for PreToolUse hooks |
-| `precommit_code_rules_gate_constants.py` | Scope argument and exit-code constants for the precommit gate |
+| `precommit_code_rules_gate_constants.py` | Git-repository-root resolution command and timeout for the `precommit_code_rules_gate` library module |
 | project_paths_reader.py | Loads ~/.claude/project-paths.json and finds a home-bounded git root for registry checks |
 | `pyproject_config_discovery_constants.py` | Table names (``tool`` key, ``mypy``, ``ruff``) for resolving a validator's config from a pyproject.toml `[tool.<name>]` table |
 | `pytest_testpaths_orphan_blocker_constants.py` | Marker filename, section and key names, test-file pattern, search budget, and block-message text for the pytest unregistered-test-directory blocker |

package/hooks/hooks_constants/bash_pre_tool_use_dispatcher_constants.py

@@ -72,7 +72,6 @@ ALL_BASH_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = (
     ),
     BashHostedHookEntry("blocking/conventional_pr_title_gate.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/block_main_commit.py", ALL_BASH_ONLY_TOOL_NAMES),
-    BashHostedHookEntry("blocking/precommit_code_rules_gate.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/session_edit_stage_gate.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/test_preflight_check.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/windows_rmtree_blocker.py", ALL_BASH_ONLY_TOOL_NAMES),

package/hooks/hooks_constants/code_rules_enforcer_constants.py

@@ -32,6 +32,9 @@ ALL_HOOK_INFRASTRUCTURE_PATTERNS = {"/.claude/hooks/", "\\.claude\\hooks\\", "\\
 ALL_WORKFLOW_REGISTRY_PATTERNS = {"/workflow/", "\\workflow\\", "_tab.py", "/states.py", "\\states.py", "/modules.py", "\\modules.py"}
 ALL_MIGRATION_PATH_PATTERNS = {"/migrations/", "\\migrations\\"}
 
+CONSTANTS_MODULE_SUFFIX: str = "_constants.py"
+CONFIG_DIRECTORY_SEGMENT: str = "config"
+
 ADVISORY_LINE_THRESHOLD_SOFT = 400
 ADVISORY_LINE_THRESHOLD_HARD = 1000
 

package/hooks/hooks_constants/messages.py

@@ -1,11 +1,9 @@
 """User-facing notice messages for blocking hooks."""
 
-USER_FACING_NOTICE = "Agent was found guessing - sourcing opinions..."
 USER_FACING_TDD_NOTICE = "TDD gate held - writing the failing test first..."
 USER_FACING_ASKUSERQUESTION_NOTICE = (
     "Agent asked the user in prose - rerouting through AskUserQuestion..."
 )
-USER_FACING_INTENT_ENDING_NOTICE = "Agent ended on a promise - doing the work now..."
 USER_FACING_CONTEXT_REASSURANCE_NOTICE = (
     "Agent moved to wrap up early - continuing the work..."
 )

package/hooks/hooks_constants/precommit_code_rules_gate_constants.py

@@ -1,24 +1,10 @@
-"""Constants for the precommit_code_rules_gate PreToolUse hook.
+"""Constants for the precommit_code_rules_gate library module.
 
-Command parsing, git timeouts, and the staged-gate invocation surface used
-to run the shared code_rules_gate engine before a git commit.
+The git-repository-root resolution command and its timeout, used by
+``resolve_repository_root`` to find the repository a directory belongs to.
 """
 
-from pathlib import Path
-
-GIT_DASH_C_COMMIT_PATTERN: str = r"git\s+-C\s+[\"']?[^\"';&|]+?[\"']?\s+commit\b"
 GIT_COMMAND_TIMEOUT_SECONDS: int = 5
-GATE_TIMEOUT_SECONDS: int = 240
-GATE_RELATIVE_PATH: Path = Path("_shared") / "pr-loop" / "scripts" / "code_rules_gate.py"
-ALL_STAGED_PYTHON_FILES_COMMAND: tuple[str, ...] = (
-    "git",
-    "diff",
-    "--cached",
-    "--name-only",
-    "--diff-filter=ACMR",
-    "--",
-    "*.py",
-)
 ALL_GIT_REPOSITORY_ROOT_COMMAND: tuple[str, ...] = (
     "git",
     "rev-parse",