claude-dev-env 2.30.0 → 2.31.0

package/hooks/hooks_constants/pre_tool_use_dispatcher_constants.py

@@ -21,8 +21,11 @@ __all__ = [
     "WRITE_TOOL_NAME",
     "EDIT_TOOL_NAME",
     "MULTI_EDIT_TOOL_NAME",
+    "APPLY_PATCH_TOOL_NAME",
     "ALL_WRITE_AND_EDIT_TOOL_NAMES",
     "ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES",
+    "ALL_WRITE_EDIT_MULTI_EDIT_APPLY_PATCH_TOOL_NAMES",
+    "ALL_IMMEDIATE_HARM_SCRIPT_PATHS",
     "STATE_DESCRIPTION_BLOCKER_MODULE_NAME",
     "SYSTEM_MESSAGE_JOIN_SEPARATOR",
     "HostedHookEntry",
@@ -42,11 +45,25 @@ CONTEXT_JOIN_SEPARATOR = "\n"
 WRITE_TOOL_NAME = "Write"
 EDIT_TOOL_NAME = "Edit"
 MULTI_EDIT_TOOL_NAME = "MultiEdit"
+APPLY_PATCH_TOOL_NAME = "apply_patch"
 
 ALL_WRITE_AND_EDIT_TOOL_NAMES: frozenset[str] = frozenset({WRITE_TOOL_NAME, EDIT_TOOL_NAME})
 ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES: frozenset[str] = frozenset(
     {WRITE_TOOL_NAME, EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME}
 )
+ALL_WRITE_EDIT_MULTI_EDIT_APPLY_PATCH_TOOL_NAMES: frozenset[str] = frozenset(
+    ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES | {APPLY_PATCH_TOOL_NAME}
+)
+
+# apply_patch reaches this narrower roster: the gates whose miss causes immediate
+# harm, plus the TDD gate and the edit tracker. It stays off the full lint surface.
+ALL_IMMEDIATE_HARM_SCRIPT_PATHS: tuple[str, ...] = (
+    "blocking/pii_prevention_blocker.py",
+    "blocking/sensitive_file_protector.py",
+    "blocking/write_existing_file_blocker.py",
+    "blocking/code_rules_enforcer.py",
+    "blocking/tdd_enforcer.py",
+)
 
 
 STATE_DESCRIPTION_BLOCKER_MODULE_NAME = "state_description_blocker"
@@ -78,52 +95,52 @@ class HostedHookEntry:
 ALL_HOSTED_HOOK_ENTRIES: tuple[HostedHookEntry, ...] = (
     HostedHookEntry(
         script_relative_path="blocking/write_existing_file_blocker.py",
-        applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_APPLY_PATCH_TOOL_NAMES,
     ),
     HostedHookEntry(
         script_relative_path="blocking/sensitive_file_protector.py",
-        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_APPLY_PATCH_TOOL_NAMES,
     ),
     HostedHookEntry(
         script_relative_path="blocking/pii_prevention_blocker.py",
-        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_APPLY_PATCH_TOOL_NAMES,
     ),
     HostedHookEntry(
         script_relative_path="validation/hook_format_validator.py",
-        applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
     ),
     HostedHookEntry(
         script_relative_path="blocking/code_rules_enforcer.py",
-        applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_APPLY_PATCH_TOOL_NAMES,
     ),
     HostedHookEntry(
         script_relative_path="blocking/tdd_enforcer.py",
-        applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_APPLY_PATCH_TOOL_NAMES,
     ),
     HostedHookEntry(
         script_relative_path="blocking/windows_rmtree_blocker.py",
-        applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
     ),
     HostedHookEntry(
         script_relative_path="blocking/duplicate_rmtree_helper_blocker.py",
-        applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
     ),
     HostedHookEntry(
         script_relative_path="blocking/state_description_blocker.py",
-        applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
         native_module_name=STATE_DESCRIPTION_BLOCKER_MODULE_NAME,
     ),
     HostedHookEntry(
         script_relative_path="blocking/stale_comment_reference_blocker.py",
-        applicable_tool_names=frozenset({EDIT_TOOL_NAME}),
+        applicable_tool_names=frozenset({EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME}),
     ),
     HostedHookEntry(
         script_relative_path="blocking/subprocess_budget_completeness.py",
-        applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
     ),
     HostedHookEntry(
         script_relative_path="blocking/hook_prose_detector_consistency.py",
-        applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
     ),
     HostedHookEntry(
         script_relative_path="blocking/workflow_substitution_slot_blocker.py",
@@ -155,12 +172,12 @@ ALL_HOSTED_HOOK_ENTRIES: tuple[HostedHookEntry, ...] = (
     ),
     HostedHookEntry(
         script_relative_path="advisory/refactor_guard.py",
-        applicable_tool_names=frozenset({EDIT_TOOL_NAME}),
+        applicable_tool_names=frozenset({EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME}),
         is_blocking=False,
     ),
     HostedHookEntry(
         script_relative_path="advisory/migration_safety_advisor.py",
-        applicable_tool_names=frozenset({EDIT_TOOL_NAME}),
+        applicable_tool_names=frozenset({EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME}),
         is_blocking=False,
     ),
 )

package/hooks/hooks_constants/session_edit_stage_gate_constants.py

@@ -18,6 +18,15 @@ from __future__ import annotations
 
 import re
 
+# The dispatcher constants module is the single source for tool names.
+from hooks_constants.pre_tool_use_dispatcher_constants import (  # noqa: F401
+    APPLY_PATCH_TOOL_NAME,
+    EDIT_TOOL_NAME,
+    MULTI_EDIT_TOOL_NAME,
+    WRITE_TOOL_NAME,
+)
+
+
 SESSION_EDIT_FILE_PREFIX: str = "claude-session-edits-"
 SESSION_EDIT_FILE_SUFFIX: str = ".json"
 ALL_EDITED_FILE_PATHS_KEY: str = "all_edited_file_paths"
@@ -27,7 +36,12 @@ SESSION_ID_UNSAFE_CHARACTERS_PATTERN: re.Pattern[str] = re.compile(r"[^A-Za-z0-9
 SESSION_START_SOURCE_PAYLOAD_KEY: str = "source"
 SESSION_START_SOURCE_FRESH_STARTUP: str = "startup"
 
-ALL_TRACKED_EDIT_TOOL_NAMES: tuple[str, ...] = ("Write", "Edit", "MultiEdit")
+ALL_TRACKED_EDIT_TOOL_NAMES: tuple[str, ...] = (
+    WRITE_TOOL_NAME,
+    EDIT_TOOL_NAME,
+    MULTI_EDIT_TOOL_NAME,
+    APPLY_PATCH_TOOL_NAME,
+)
 
 STATE_FILE_ATOMIC_WRITE_SUFFIX: str = ".tmp"
 STATE_FILE_JSON_INDENT_SPACES: int = 2

package/hooks/hooks_constants/shell_substitution_blocker_constants.py

@@ -41,7 +41,10 @@ PERMISSION_DECISION_KEY = "permissionDecision"
 DENY_DECISION = "deny"
 PERMISSION_DECISION_REASON_KEY = "permissionDecisionReason"
 
-DOLLAR_PAREN_PATTERN = re.compile(r"\$\((?!\()")
+DOLLAR_PAREN_PATTERN = re.compile(r"\$\(")
+OPEN_PAREN_CHARACTER = "("
+CLOSE_PAREN_CHARACTER = ")"
+PAREN_DEPTH_AFTER_DOUBLE_OPEN = 2
 EVEN_BACKSLASH_BACKTICK_PATTERN = re.compile(r"(?<!\\)(?:\\\\)*`")
 PROCESS_SUBSTITUTION_PATTERN = re.compile(r"[<>]\(")
 SINGLE_QUOTED_RUN_PATTERN = re.compile(r"'[^']*'")

package/hooks/hooks_constants/state_description_blocker_constants.py

@@ -2,6 +2,7 @@
 
 from re import IGNORECASE, Pattern, compile
 
+
 ALL_COMMENT_TRANSITION_PATTERNS: list[Pattern[str]] = [
     compile(r"\binstead of\b", IGNORECASE),
     compile(r"\bpreviously\b", IGNORECASE),

package/hooks/hooks_constants/subprocess_budget_completeness_content.py

@@ -0,0 +1,71 @@
+"""Resolve the post-edit content a Write, Edit, or MultiEdit payload leaves on disk.
+
+Shared by subprocess_budget_completeness.py, which parses this content's AST to
+find a named budget helper that omits a reachable subprocess timeout.
+"""
+
+from __future__ import annotations
+
+from hooks_constants.multi_edit_reconstruction import apply_edits
+
+__all__ = [
+    "existing_file_content",
+    "reconstructed_edit_content",
+    "reconstructed_multi_edit_content",
+    "resolved_content",
+]
+
+
+def existing_file_content(file_path: str) -> str | None:
+    try:
+        with open(file_path, "r", encoding="utf-8") as existing_file:
+            return existing_file.read()
+    except (FileNotFoundError, OSError, UnicodeDecodeError):
+        return None
+
+
+def reconstructed_edit_content(all_tool_input_fields: dict[str, object]) -> str:
+    file_path = all_tool_input_fields.get("file_path")
+    old_string = all_tool_input_fields.get("old_string")
+    new_string = all_tool_input_fields.get("new_string")
+    if not isinstance(file_path, str) or not isinstance(old_string, str):
+        return ""
+    if not isinstance(new_string, str) or not old_string:
+        return ""
+    existing_content = existing_file_content(file_path)
+    if existing_content is None or old_string not in existing_content:
+        return ""
+    return existing_content.replace(old_string, new_string, 1)
+
+
+def reconstructed_multi_edit_content(
+    all_tool_input_fields: dict[str, object], all_edits: list[object]
+) -> str:
+    """Return the whole file MultiEdit's edit list would leave on disk.
+
+    Args:
+        all_tool_input_fields: The MultiEdit payload's tool_input mapping.
+        all_edits: The payload's ``edits`` list.
+
+    Returns:
+        The reconstructed content, or an empty string when the target file
+        cannot be read.
+    """
+    file_path = all_tool_input_fields.get("file_path")
+    if not isinstance(file_path, str):
+        return ""
+    existing_content = existing_file_content(file_path)
+    if existing_content is None:
+        return ""
+    all_edit_dicts = [each_edit for each_edit in all_edits if isinstance(each_edit, dict)]
+    return apply_edits(existing_content, all_edit_dicts)
+
+
+def resolved_content(all_tool_input_fields: dict[str, object]) -> str:
+    written_content = all_tool_input_fields.get("content")
+    if isinstance(written_content, str):
+        return written_content
+    all_edits = all_tool_input_fields.get("edits")
+    if isinstance(all_edits, list):
+        return reconstructed_multi_edit_content(all_tool_input_fields, all_edits)
+    return reconstructed_edit_content(all_tool_input_fields)

package/hooks/hooks_constants/task_tool_prompt_constants.py

@@ -0,0 +1,13 @@
+"""Directive text for the task_tool_prompt SessionStart hook."""
+
+from __future__ import annotations
+
+__all__ = [
+    "TASK_TOOL_DIRECTIVE",
+]
+
+TASK_TOOL_DIRECTIVE = (
+    "TASK TRACKING: Track this session's work with the session's task or todo "
+    "tracking tool, whichever this host provides. Create tasks at the start "
+    "of the session, then update them as work proceeds."
+)

package/hooks/hooks_constants/test_bash_pre_tool_use_dispatcher_constants.py

@@ -38,12 +38,14 @@ _EXPECTED_BASH_ORDER = (
     "blocking/test_preflight_check.py",
     "blocking/windows_rmtree_blocker.py",
     "blocking/gh_pr_author_enforcer.py",
+    "blocking/pr_description_writer_gate.py",
 )
 
 _POWERSHELL_APPLICABLE = (
     "blocking/cursor_cli_python_misfire_blocker.py",
     "blocking/unscoped_search_blocker.py",
     "blocking/pii_prevention_blocker.py",
+    "blocking/pr_description_writer_gate.py",
 )
 
 

package/hooks/hooks_constants/test_code_rules_enforcer_constants.py

@@ -17,7 +17,6 @@ if str(_HOOKS_ROOT) not in sys.path:
     sys.path.insert(0, str(_HOOKS_ROOT))
 
 from hooks_constants.code_rules_enforcer_constants import (
-    ALL_HOOK_INFRASTRUCTURE_EDIT_LANE_CHECK_NAMES,
     ALL_VALIDATION_PHASES,
     CONFIG_DIRECTORY_SEGMENT,
     CONSTANTS_MODULE_SUFFIX,
@@ -28,6 +27,8 @@ from hooks_constants.code_rules_enforcer_constants import (
     RETURN_CALL_OPENING_PARENTHESIS_PATTERN,
     SCHEMA_OPTIONS_PROPERTY_KEY_PATTERN,
     UNKNOWN_VALIDATION_PHASE_MESSAGE_TEMPLATE,
+    apply_edits,
+    edits_for_tool,
 )
 
 
@@ -111,11 +112,3 @@ def test_validation_phase_constants_are_reexported_and_render() -> None:
         phase="bogus_phase", all_phases=sorted(ALL_VALIDATION_PHASES)
     )
     assert "bogus_phase" in rendered_message
-
-
-def test_hook_infrastructure_edit_lane_check_names_are_reexported() -> None:
-    assert ALL_HOOK_INFRASTRUCTURE_EDIT_LANE_CHECK_NAMES == {
-        "check_same_file_inline_duplicate_body",
-        "check_zero_payload_function_alias",
-        "check_unanchored_command_dispatch",
-    }

package/hooks/hooks_constants/test_multi_edit_reconstruction.py

@@ -0,0 +1,102 @@
+"""Tests for multi_edit_reconstruction.py."""
+
+from __future__ import annotations
+
+import pathlib
+import sys
+
+try:
+    _HOOKS_ROOT = pathlib.Path(__file__).resolve().parent.parent
+    if str(_HOOKS_ROOT) not in sys.path:
+        sys.path.insert(0, str(_HOOKS_ROOT))
+
+    from hooks_constants.multi_edit_reconstruction import (
+        apply_edits,
+        edits_for_tool,
+        joined_new_strings,
+    )
+except ImportError as import_error:
+    raise ImportError(
+        "test_multi_edit_reconstruction: cannot import its sibling modules; "
+        "ensure the hooks directory is importable."
+    ) from import_error
+
+
+def test_apply_edits_replaces_each_old_string_in_list_order() -> None:
+    """Two edits land in order, each replacing its own first occurrence."""
+    all_edits = [
+        {"old_string": "alpha", "new_string": "beta"},
+        {"old_string": "gamma", "new_string": "delta"},
+    ]
+    assert apply_edits("alpha gamma", all_edits) == "beta delta"
+
+
+def test_edits_for_tool_wraps_an_edit_payload_in_a_single_element_list() -> None:
+    """An Edit payload is its own only edit."""
+    edit_payload = {"old_string": "a", "new_string": "b"}
+    assert edits_for_tool("Edit", edit_payload) == [edit_payload]
+
+
+def test_apply_edits_replaces_every_occurrence_when_replace_all_is_set() -> None:
+    """A replace_all edit rewrites every occurrence, the way MultiEdit does.
+
+    The gates that read this reconstruction judge the file the write would
+    leave on disk. When an edit carries replace_all, MultiEdit rewrites all
+    occurrences, so a reconstruction that rewrites only the first one hands
+    every gate a file that never existed.
+    """
+    all_edits = [{"old_string": "old", "new_string": "new", "replace_all": True}]
+    assert apply_edits("old old old", all_edits) == "new new new"
+
+
+def test_apply_edits_replaces_only_the_first_occurrence_without_replace_all() -> None:
+    """An edit with no replace_all flag rewrites one occurrence."""
+    all_edits = [{"old_string": "old", "new_string": "new"}]
+    assert apply_edits("old old old", all_edits) == "new old old"
+
+
+def test_apply_edits_treats_a_false_replace_all_as_a_single_replacement() -> None:
+    """An explicit replace_all of False rewrites one occurrence."""
+    all_edits = [{"old_string": "old", "new_string": "new", "replace_all": False}]
+    assert apply_edits("old old old", all_edits) == "new old old"
+
+
+def test_apply_edits_mixes_replace_all_and_single_edits_in_one_list() -> None:
+    """Each edit in a list honors its own flag, not the list's first one."""
+    all_edits = [
+        {"old_string": "a", "new_string": "A", "replace_all": True},
+        {"old_string": "b", "new_string": "B"},
+    ]
+    assert apply_edits("a b a b", all_edits) == "A B A b"
+
+def test_joined_new_strings_joins_every_new_string_on_a_newline() -> None:
+    """Each edit's introduced text reaches the scanner as its own line."""
+    tool_input = {
+        "edits": [
+            {"old_string": "x", "new_string": "import os"},
+            {"old_string": "y", "new_string": "shutil.rmtree(p)"},
+        ]
+    }
+    assert joined_new_strings(tool_input) == "import os\nshutil.rmtree(p)"
+
+
+def test_joined_new_strings_separator_keeps_adjacent_edits_apart() -> None:
+    """A phrase spanning the seam belongs to neither edit, so the join breaks it."""
+    tool_input = {
+        "edits": [
+            {"old_string": "x", "new_string": "currently"},
+            {"old_string": "y", "new_string": "holds"},
+        ]
+    }
+    assert "currentlyholds" not in joined_new_strings(tool_input)
+
+
+def test_joined_new_strings_skips_edits_whose_new_string_is_not_a_string() -> None:
+    """A malformed edit contributes nothing rather than raising."""
+    tool_input = {"edits": [{"new_string": None}, {"new_string": "kept"}]}
+    assert joined_new_strings(tool_input) == "kept"
+
+
+def test_joined_new_strings_returns_empty_text_for_a_payload_with_no_edits() -> None:
+    """A payload carrying no edit list scans as empty text."""
+    assert joined_new_strings({"file_path": "a.py"}) == ""

package/hooks/hooks_constants/test_pre_tool_use_dispatcher_constants.py

@@ -4,25 +4,36 @@ import importlib
 import pathlib
 import sys
 
-_HOOKS_ROOT = pathlib.Path(__file__).resolve().parent.parent
-if str(_HOOKS_ROOT) not in sys.path:
-    sys.path.insert(0, str(_HOOKS_ROOT))
-
-_BLOCKING_DIR = _HOOKS_ROOT / "blocking"
-if str(_BLOCKING_DIR) not in sys.path:
-    sys.path.insert(0, str(_BLOCKING_DIR))
-
-from hooks_constants.pre_tool_use_dispatcher_constants import (
-    ALL_HOSTED_HOOK_ENTRIES,
-    ALL_WRITE_AND_EDIT_TOOL_NAMES,
-    BLOCKING_CRASH_DENY_REASON,
-    EDIT_TOOL_NAME,
-    WRITE_TOOL_NAME,
-)
-from pre_tool_use_dispatcher import (
-    HostedHookResult,
-    aggregate_hosted_hook_results,
-)
+try:
+    _HOOKS_ROOT = pathlib.Path(__file__).resolve().parent.parent
+    if str(_HOOKS_ROOT) not in sys.path:
+        sys.path.insert(0, str(_HOOKS_ROOT))
+
+    _BLOCKING_DIR = _HOOKS_ROOT / "blocking"
+    if str(_BLOCKING_DIR) not in sys.path:
+        sys.path.insert(0, str(_BLOCKING_DIR))
+
+    from hooks_constants.pre_tool_use_dispatcher_constants import (
+        ALL_HOSTED_HOOK_ENTRIES,
+        ALL_IMMEDIATE_HARM_SCRIPT_PATHS,
+        ALL_WRITE_AND_EDIT_TOOL_NAMES,
+        ALL_WRITE_EDIT_MULTI_EDIT_APPLY_PATCH_TOOL_NAMES,
+        ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
+        APPLY_PATCH_TOOL_NAME,
+        BLOCKING_CRASH_DENY_REASON,
+        EDIT_TOOL_NAME,
+        MULTI_EDIT_TOOL_NAME,
+        WRITE_TOOL_NAME,
+    )
+    from pre_tool_use_dispatcher import (
+        HostedHookResult,
+        aggregate_hosted_hook_results,
+    )
+except ImportError as import_error:
+    raise ImportError(
+        "test_pre_tool_use_dispatcher_constants: cannot import its sibling modules; "
+        "ensure the hooks and blocking directories are importable."
+    ) from import_error
 
 
 def _entry_for(script_relative_path: str):
@@ -63,11 +74,10 @@ def test_duplicate_rmtree_helper_blocker_runs_via_runpy() -> None:
     assert entry.native_module_name is None
 
 
-
 def test_windows_rmtree_blocker_still_registered() -> None:
     entry = _entry_for("blocking/windows_rmtree_blocker.py")
     assert entry is not None
-    assert entry.applicable_tool_names == ALL_WRITE_AND_EDIT_TOOL_NAMES
+    assert entry.applicable_tool_names == ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES
 
 
 def test_blocking_hook_crash_deny_reason_surfaces_the_constant() -> None:
@@ -82,22 +92,22 @@ def test_blocking_hook_crash_deny_reason_surfaces_the_constant() -> None:
     assert BLOCKING_CRASH_DENY_REASON in decision.all_deny_reasons
 
 
-def test_refactor_guard_is_hosted_as_an_edit_only_advisory_hook() -> None:
+def test_refactor_guard_is_hosted_as_an_edit_and_multi_edit_advisory_hook() -> None:
     entry = _entry_for("advisory/refactor_guard.py")
     assert entry is not None, (
         "refactor_guard must be hosted by the dispatcher rather than spawning its own process"
     )
-    assert entry.applicable_tool_names == frozenset({EDIT_TOOL_NAME})
+    assert entry.applicable_tool_names == frozenset({EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME})
     assert entry.is_blocking is False
 
 
-def test_migration_safety_advisor_is_hosted_as_an_edit_only_advisory_hook() -> None:
+def test_migration_safety_advisor_is_hosted_as_an_edit_and_multi_edit_advisory_hook() -> None:
     entry = _entry_for("advisory/migration_safety_advisor.py")
     assert entry is not None, (
         "migration_safety_advisor must be hosted by the dispatcher rather than "
         "spawning its own process"
     )
-    assert entry.applicable_tool_names == frozenset({EDIT_TOOL_NAME})
+    assert entry.applicable_tool_names == frozenset({EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME})
     assert entry.is_blocking is False
 
 
@@ -125,3 +135,107 @@ def test_every_native_module_exposes_a_callable_evaluate() -> None:
             f"{each_entry.native_module_name} must expose a callable named evaluate, "
             "matching the native_module_name docstring contract"
         )
+
+
+def test_four_way_set_covers_every_mutation_tool_name() -> None:
+    assert ALL_WRITE_EDIT_MULTI_EDIT_APPLY_PATCH_TOOL_NAMES == (
+        ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES | {APPLY_PATCH_TOOL_NAME}
+    )
+
+
+def test_immediate_harm_hooks_reach_apply_patch() -> None:
+    """PII, sensitive-path, existing-file, CODE_RULES, and TDD gates all see apply_patch."""
+    for each_script_path in ALL_IMMEDIATE_HARM_SCRIPT_PATHS:
+        entry = _entry_for(each_script_path)
+        assert entry is not None, f"{each_script_path} must stay on the hosted roster"
+        assert APPLY_PATCH_TOOL_NAME in entry.applicable_tool_names, (
+            f"{each_script_path} must reach apply_patch for mutation-tool parity"
+        )
+
+
+_ALL_DEFERRED_LINT_SCRIPT_PATHS = (
+    "blocking/state_description_blocker.py",
+    "blocking/workflow_substitution_slot_blocker.py",
+    "blocking/claude_md_orphan_file_blocker.py",
+    "blocking/package_inventory_stale_blocker.py",
+    "blocking/env_var_table_code_drift_blocker.py",
+    "blocking/pytest_testpaths_orphan_blocker.py",
+    "blocking/open_questions_in_plans_blocker.py",
+    "blocking/docstring_rule_gate_count_blocker.py",
+    "blocking/duplicate_rmtree_helper_blocker.py",
+    "validation/hook_format_validator.py",
+    "blocking/hook_prose_detector_consistency.py",
+    "blocking/stale_comment_reference_blocker.py",
+    "blocking/subprocess_budget_completeness.py",
+    "blocking/windows_rmtree_blocker.py",
+    "advisory/refactor_guard.py",
+    "advisory/migration_safety_advisor.py",
+)
+
+
+def test_lint_and_advisory_hooks_stay_off_the_apply_patch_roster() -> None:
+    """Every hook reaching MultiEdit but not apply_patch fails the same one rule.
+
+    apply_patch reaches only a gate whose violation is already real and
+    unrecoverable the moment the call returns: a leaked secret, an exposed
+    sensitive path, a blind overwrite, or an untested change landing. Every
+    hook named here instead judges the quality of the authored content for a
+    consequence the write itself does not cause right now: doc-inventory
+    drift, prose or naming style, a future-runtime correctness pattern (an
+    unsafe rmtree that only misbehaves on Windows, a subprocess-timeout
+    budget the harness reads separately), or an advisory suggestion that
+    never denies at all. Each is fixable in a later Edit-tool pass, so none
+    needs apply_patch's narrower, deny-only roster.
+    """
+    for each_script_path in _ALL_DEFERRED_LINT_SCRIPT_PATHS:
+        entry = _entry_for(each_script_path)
+        assert entry is not None, f"{each_script_path} must stay on the hosted roster"
+        assert MULTI_EDIT_TOOL_NAME in entry.applicable_tool_names, (
+            f"{each_script_path} must still reach MultiEdit"
+        )
+        assert APPLY_PATCH_TOOL_NAME not in entry.applicable_tool_names, (
+            f"{each_script_path} judges deferred-fixable quality, not immediate harm, "
+            "so it must stay off the apply_patch roster"
+        )
+
+
+def test_edit_and_multi_edit_applicable_sets_are_equal() -> None:
+    """The Edit roster and the MultiEdit roster name the same hooks.
+
+    Every hook applicable to Edit judges Write's content or an Edit's
+    old/new string pair with no dependency on which tool delivered it, so
+    the two sets must match exactly. A hook that legitimately stays
+    Edit-only is an exception written down here with its reason, not a
+    silent gap this test lets back in.
+    """
+    all_edit_script_paths = {
+        each_entry.script_relative_path
+        for each_entry in ALL_HOSTED_HOOK_ENTRIES
+        if EDIT_TOOL_NAME in each_entry.applicable_tool_names
+    }
+    all_multi_edit_script_paths = {
+        each_entry.script_relative_path
+        for each_entry in ALL_HOSTED_HOOK_ENTRIES
+        if MULTI_EDIT_TOOL_NAME in each_entry.applicable_tool_names
+    }
+    assert all_edit_script_paths == all_multi_edit_script_paths, (
+        "Edit-only (not MultiEdit): "
+        f"{sorted(all_edit_script_paths - all_multi_edit_script_paths)}; "
+        "MultiEdit-only (not Edit): "
+        f"{sorted(all_multi_edit_script_paths - all_edit_script_paths)}"
+    )
+
+
+def test_multi_edit_widened_hooks_reach_multi_edit() -> None:
+    all_multi_edit_widened_script_paths = (
+        "blocking/write_existing_file_blocker.py",
+        "blocking/code_rules_enforcer.py",
+        "blocking/tdd_enforcer.py",
+        "blocking/state_description_blocker.py",
+    )
+    for each_script_path in all_multi_edit_widened_script_paths:
+        entry = _entry_for(each_script_path)
+        assert entry is not None, f"{each_script_path} must stay on the hosted roster"
+        assert MULTI_EDIT_TOOL_NAME in entry.applicable_tool_names, (
+            f"{each_script_path} must reach MultiEdit for mutation-tool parity"
+        )