claude-dev-env 2.30.0 → 2.31.0

package/hooks/validators/test_run_all_validators.py

@@ -31,6 +31,10 @@ _ASSERT_FALSE_SOURCE = (
     "    assert False, observed_total\n"
 )
 PRINT_PRODUCTION_CONTENT = 'def run() -> None:\n    print("x")\n'
+CLEAN_PROBE_SOURCE = (
+    "def add_two_numbers(first_number: int, second_number: int) -> int:\n"
+    "    return first_number + second_number\n"
+)
 ALL_PYTHON_TEST_EXEMPT_PATHS = [
     "pkg/test_helpers/worker.py",
     "pkg/conftest.py",
@@ -66,6 +70,48 @@ def test_validate_proposed_file_threads_ruff_config_from_original_path() -> None
     assert "B011" in ruff_output
 
 
+def test_validate_proposed_file_never_probes_mypy_availability() -> None:
+    """The save-path gate drops Mypy entirely; it must not even probe for it.
+
+    Mypy runs 500-1800ms cold, the largest single item on the save path by a
+    wide margin (see hooks/validators/hook_timing_harness.py). CLI/full mode
+    keeps probing it; only the save-path gate skips the probe.
+    """
+    with patch("validators.run_all_validators.check_mypy_available") as mock_check_mypy:
+        validate_proposed_file(
+            str(_VALIDATORS_DIRECTORY / "probe_target.py"), CLEAN_PROBE_SOURCE
+        )
+
+    mock_check_mypy.assert_not_called()
+
+
+def test_validate_proposed_file_never_spawns_a_validator_subprocess() -> None:
+    """The save-path gate must not spawn a ``python -m validators.<module>`` per check.
+
+    Twelve validator subprocesses cost roughly 600ms in interpreter startup
+    and import alone (see hook_timing_harness.py), for checks that measure in
+    single digits once running. CLI/full mode keeps spawning one process per
+    validator; only the save-path gate runs them in-process instead.
+    """
+    with patch("validators.run_all_validators.invoke_validator_module") as mock_invoke:
+        validate_proposed_file(
+            str(_VALIDATORS_DIRECTORY / "probe_target.py"), CLEAN_PROBE_SOURCE
+        )
+
+    mock_invoke.assert_not_called()
+
+
+def test_validate_proposed_file_still_finds_a_fast_path_violation() -> None:
+    """Dropping mypy and the per-validator subprocess must not blind the gate."""
+    all_results = validate_proposed_file(
+        str(_VALIDATORS_DIRECTORY / "probe_target.py"), PRINT_PRODUCTION_CONTENT
+    )
+
+    failed_names = {each_result.name for each_result in all_results if not each_result.passed}
+    assert failed_names, "expected at least one failing fast-path check"
+    assert "Mypy" not in failed_names
+
+
 def _validators_deny_print(file_path: str) -> bool:
     all_results = validate_proposed_file(file_path, PRINT_PRODUCTION_CONTENT)
     return any(not each_result.passed for each_result in all_results)

package/hooks/validators/test_run_all_validators_pretooluse.py

@@ -26,6 +26,8 @@ from .run_all_validators import (
     run_validators_entrypoint_subprocess,
 )
 
+pytestmark = pytest.mark.usefixtures("ephemeral_exempt_off")
+
 CONFIG_DIR_TARGET_PATH = (
     "CDP Automations/os_update_workflow/config/submission_constants.py"
 )

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "2.30.0",
+    "version": "2.31.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/rules/docstring-prose-matches-implementation.md

@@ -34,7 +34,7 @@ Many deterministic shapes of this drift have Write/Edit gates in `~/.claude/hook
 
 A hook module is the sharpest case of the same rule: its docstring lead narrative and its `CORRECTIVE_MESSAGE` describe exactly the shapes the detector flags, and claim no broader trigger surface than the regex enforces.
 
-`hook_prose_detector_consistency` (PreToolUse on Write|Edit of hook modules and their `*_constants.py` companions) blocks prose that claims a trigger the detector never fires on, and names the fix.
+`hook_prose_detector_consistency` (PreToolUse on Write|Edit|MultiEdit of hook modules and their `*_constants.py` companions) blocks prose that claims a trigger the detector never fires on, and names the fix.
 
 After writing a hook, ask: would a token matching every word of this message actually trip the detector? When the message names a shape the regex skips, rewrite the message to name only what the regex catches. The path-shape case is the common overstatement — a detector that keys off a path separator must not claim it blocks an "output-key segment". The corrective message spells the rewrite.
 

package/rules/git-workflow.md

@@ -17,6 +17,8 @@ User-level rule: applies to **every** git repo that uses GitHub with `gh` (no ex
 
 **ALWAYS create PRs as DRAFT:** Use `gh pr create --draft` for ALL PRs
 
+**The pr-description-writer agent writes the body:** Spawn the `pr-description-writer` agent (Agent tool, `subagent_type` `pr-description-writer`), then publish what it returns with `--body-file`. `pr_description_writer_gate.py` (PreToolUse on Bash and PowerShell, hosted by `bash_pre_tool_use_dispatcher`) denies a `gh pr create` when the session records no such spawn. A trailing `# pr-description-skip` comment on the command opts out for a body you write yourself.
+
 ## Git Golden Rules (NON-NEGOTIABLE)
 
 1. **DRAFT BEFORE PUSH**: When pushing ANYTHING to a PR, it MUST be in draft state first

package/rules/testing.md

@@ -22,3 +22,7 @@ Incomplete mocks make it impossible to distinguish "broken code" from "missing d
 ## Tests Exercise Real Behavior
 
 Tests exercise real behavior, real data, and production code paths. A test that asserts on a stand-in for the production path proves the stand-in works.
+
+## The File-Level TDD Gate Reads Content
+
+`tdd_enforcer.py` records each candidate test's content hash at every sighting and compares that hash on the next write. A first sighting requires content that differs from HEAD.

package/scripts/codex_compat_materializer.py

@@ -64,6 +64,8 @@ codex_hook_dependency_manifest = (
     "hooks/blocking/code_rules_comments.py",
     "hooks/blocking/code_rules_constants_config.py",
     "hooks/blocking/codex_apply_patch.py",
+    "hooks/blocking/config/__init__.py",
+    "hooks/blocking/config/codex_apply_patch_constants.py",
     "hooks/blocking/code_rules_docstrings.py",
     "hooks/blocking/code_rules_duplicate_body.py",
     "hooks/blocking/code_rules_enforcer.py",
@@ -101,14 +103,17 @@ codex_hook_dependency_manifest = (
     "hooks/hooks_constants/hook_block_logger.py",
     "hooks/hooks_constants/inline_tuple_string_magic_constants.py",
     "hooks/hooks_constants/js_conventions_constants.py",
+    "hooks/hooks_constants/multi_edit_reconstruction.py",
     "hooks/hooks_constants/orphan_css_class_constants.py",
     "hooks/hooks_constants/paired_test_coverage_constants.py",
     "hooks/hooks_constants/setup_project_paths_constants.py",
     "hooks/hooks_constants/stuttering_check_config.py",
     "hooks/hooks_constants/stuttering_import_binding_constants.py",
+    "hooks/hooks_constants/subprocess_budget_completeness_content.py",
     "hooks/hooks_constants/sys_path_insert_constants.py",
     "hooks/hooks_constants/test_layout_constants.py",
     "hooks/hooks_constants/unused_module_import_constants.py",
+    "hooks/hooks_constants/validation_phase_constants.py",
 )
 full_prune_opt_in_flag = "--allow-prune-all"
 unreadable_source_root_message = (

package/scripts/tests/test_codex_compat_materializer.py

@@ -1,4 +1,5 @@
 import json
+import os
 import subprocess
 import sys
 from pathlib import Path
@@ -841,23 +842,35 @@ def test_build_plan_publishes_owned_agents_projection_and_tracks_drift(
     assert drifted_projection != first_projection
 
 
-def test_codex_hook_manifest_keeps_dispatcher_order_and_adds_enforcer() -> None:
+def test_codex_hook_manifest_folds_apply_patch_into_the_dispatcher_matcher() -> None:
+    """apply_patch's code_rules_enforcer coverage comes from the dispatcher's own matcher.
+
+    hooks.json once ran a separate apply_patch -> code_rules_enforcer.py
+    PreToolUse command after the dispatcher entry. That coverage is now
+    folded into the dispatcher's own Write|Edit|MultiEdit|apply_patch
+    matcher, so no standalone apply_patch entry remains.
+    """
     hooks_path = Path(__file__).parents[2] / "hooks" / "hooks.json"
     hooks_configuration = json.loads(hooks_path.read_text(encoding="utf-8"))
     pre_tool_use_entries = hooks_configuration["hooks"]["PreToolUse"]
-    matcher_names = [each_entry.get("matcher") for each_entry in pre_tool_use_entries]
 
-    dispatcher_index = matcher_names.index("Write|Edit|MultiEdit")
-    enforcer_entries = [
+    dispatcher_entries = [
+        each_entry
+        for each_entry in pre_tool_use_entries
+        if any(
+            "/hooks/blocking/pre_tool_use_dispatcher.py" in each_hook.get("command", "")
+            for each_hook in each_entry.get("hooks", [])
+        )
+    ]
+    assert len(dispatcher_entries) == 1
+    assert dispatcher_entries[0]["matcher"] == "Write|Edit|MultiEdit|apply_patch"
+
+    standalone_apply_patch_entries = [
         each_entry
         for each_entry in pre_tool_use_entries
         if each_entry.get("matcher") == "apply_patch"
     ]
-    assert len(enforcer_entries) == 1
-    assert matcher_names.index("apply_patch") > dispatcher_index
-    assert enforcer_entries[0]["hooks"][0]["command"].endswith(
-        "/hooks/blocking/code_rules_enforcer.py"
-    )
+    assert standalone_apply_patch_entries == []
 
 
 def _prepare_projection_fixture(
@@ -1008,7 +1021,18 @@ def _assert_projection_and_manifest(
 
 
 def _assert_detached_enforcer_behavior(target: Path) -> None:
+    """Prove the detached, materialized enforcer allows a clean add and denies an unnamed raise.
+
+    Disables the ephemeral-path exemption for both runs: without it, a target
+    rooted under the OS temp directory (where this fixture lives) would skip
+    code_rules_enforcer's checks entirely and both assertions would pass
+    without the enforcer ever judging the payload.
+    """
     target_entrypoint = target / materializer.codex_enforcer_script_relative_path
+    subprocess_environment = {
+        **os.environ,
+        "CLAUDE_CODE_RULES_DISABLE_EPHEMERAL_EXEMPT": "1",
+    }
     allow_payload = {
         "tool_name": "apply_patch",
         "cwd": str(target),
@@ -1029,8 +1053,9 @@ def _assert_detached_enforcer_behavior(target: Path) -> None:
         capture_output=True,
         text=True,
         check=False,
+        env=subprocess_environment,
     )
-    assert allow_run.returncode == 0
+    assert allow_run.returncode == 0, allow_run.stderr
     assert allow_run.stdout == ""
 
     allow_tool_input = allow_payload["tool_input"]
@@ -1050,8 +1075,9 @@ def _assert_detached_enforcer_behavior(target: Path) -> None:
         capture_output=True,
         text=True,
         check=False,
+        env=subprocess_environment,
     )
-    assert deny_run.returncode == 0
+    assert deny_run.returncode == 0, deny_run.stderr
     assert json.loads(deny_run.stdout)["hookSpecificOutput"]["permissionDecision"] == "deny"
     assert target_entrypoint.is_file()
 

package/hooks/blocking/tests/conftest.py

@@ -1,10 +0,0 @@
-"""Put the blocking and hooks directories on sys.path for the blocking tests."""
-
-import sys
-from pathlib import Path
-
-_blocking_directory = str(Path(__file__).resolve().parents[1])
-_hooks_directory = str(Path(__file__).resolve().parents[2])
-for each_bootstrap_directory in (_blocking_directory, _hooks_directory):
-    if each_bootstrap_directory not in sys.path:
-        sys.path.insert(0, each_bootstrap_directory)

package/hooks/hooks_constants/task_list_loop_starter_constants.py

@@ -1,19 +0,0 @@
-"""Directive text for the task_list_loop_starter SessionStart hook."""
-
-from __future__ import annotations
-
-__all__ = [
-    "TASK_LIST_MAINTENANCE_INSTRUCTION",
-    "TASK_LIST_LOOP_DIRECTIVE",
-]
-
-TASK_LIST_MAINTENANCE_INSTRUCTION = "build or update the task list using the task tools"
-
-TASK_LIST_LOOP_DIRECTIVE = (
-    "TASK LIST MAINTENANCE: Keep this session's task list current on a 10-minute "
-    "cadence. Reuse the active task-list maintenance loop when available. Start "
-    "Claude Code's built-in /loop skill with a 10-minute interval when this session "
-    "needs its first loop: "
-    f'/loop 10m "{TASK_LIST_MAINTENANCE_INSTRUCTION}". Run that instruction once '
-    "immediately when starting the loop, then let the loop refresh the list every 10 minutes."
-)

package/hooks/session/task_list_loop_starter.py

@@ -1,45 +0,0 @@
-#!/usr/bin/env python3
-"""SessionStart hook — start a task-list maintenance loop for the session.
-
-At session start this hook emits an ``additionalContext`` directive asking Claude
-to keep the session's task list current on a 10-minute cadence. Claude reuses the
-active ``/loop`` skill when available and starts the skill for the session's first
-task-list maintenance loop.
-"""
-
-from __future__ import annotations
-
-import json
-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.task_list_loop_starter_constants import (  # noqa: E402
-    TASK_LIST_LOOP_DIRECTIVE,
-)
-
-
-def build_session_directive() -> str:
-    """Return the task-list loop directive emitted at session start."""
-    return TASK_LIST_LOOP_DIRECTIVE
-
-
-def main() -> None:
-    """Emit the task-list loop directive as SessionStart additionalContext."""
-    print(
-        json.dumps(
-            {
-                "hookSpecificOutput": {
-                    "hookEventName": "SessionStart",
-                    "additionalContext": build_session_directive(),
-                }
-            }
-        )
-    )
-
-
-if __name__ == "__main__":
-    main()

package/hooks/session/test_task_list_loop_starter.py

@@ -1,63 +0,0 @@
-"""Tests for task_list_loop_starter — SessionStart hook that starts a task-list loop."""
-
-import json
-import sys
-from io import StringIO
-from pathlib import Path
-from unittest.mock import patch
-
-_SESSION_DIR = Path(__file__).resolve().parent
-_HOOKS_ROOT = _SESSION_DIR.parent
-for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
-    if each_sys_path_entry not in sys.path:
-        sys.path.insert(0, each_sys_path_entry)
-
-import task_list_loop_starter as starter
-
-from hooks_constants.task_list_loop_starter_constants import (
-    TASK_LIST_LOOP_DIRECTIVE,
-    TASK_LIST_MAINTENANCE_INSTRUCTION,
-)
-
-
-def _run_main() -> str:
-    """Return stdout produced by running the hook's main()."""
-    captured_stdout = StringIO()
-    with patch("sys.stdout", captured_stdout):
-        starter.main()
-    return captured_stdout.getvalue()
-
-
-class TestSessionDirective:
-    def test_main_emits_additional_context(self) -> None:
-        emitted = json.loads(_run_main())
-        hook_output = emitted["hookSpecificOutput"]
-        assert hook_output["hookEventName"] == "SessionStart"
-        assert "additionalContext" in hook_output
-
-    def test_directive_carries_the_one_line_instruction(self) -> None:
-        emitted = json.loads(_run_main())
-        assert TASK_LIST_MAINTENANCE_INSTRUCTION in emitted["hookSpecificOutput"]["additionalContext"]
-
-    def test_directive_names_the_ten_minute_cadence(self) -> None:
-        emitted = json.loads(_run_main())
-        assert "10-minute" in emitted["hookSpecificOutput"]["additionalContext"]
-
-    def test_directive_names_the_loop_command(self) -> None:
-        emitted = json.loads(_run_main())
-        assert "/loop 10m" in emitted["hookSpecificOutput"]["additionalContext"]
-
-    def test_directive_runs_the_instruction_immediately(self) -> None:
-        emitted = json.loads(_run_main())
-        assert "Run that instruction once immediately when starting the loop, then" in emitted[
-            "hookSpecificOutput"
-        ]["additionalContext"]
-
-    def test_directive_reuses_an_existing_loop(self) -> None:
-        emitted = json.loads(_run_main())
-        assert "Reuse the active task-list maintenance loop when available." in emitted[
-            "hookSpecificOutput"
-        ]["additionalContext"]
-
-    def test_build_session_directive_returns_the_shared_constant(self) -> None:
-        assert starter.build_session_directive() == TASK_LIST_LOOP_DIRECTIVE