claude-dev-env 2.30.0 → 2.31.0

package/hooks/blocking/code_rules_constants_config.py

@@ -149,18 +149,19 @@ def _scan_function_body_constants(content: str) -> list[str]:
     return advisory_issues
 
 
-def check_constants_outside_config_advisory(content: str, file_path: str) -> list[str]:
-    """Return advisory entries for UPPER_SNAKE assignments inside function bodies.
+def check_constants_outside_config_advisory(content: str, file_path: str) -> None:
+    """Emit stderr advisories for UPPER_SNAKE assignments inside function bodies.
 
     Module-level UPPER_SNAKE outside config/ is blocking (see
     check_constants_outside_config). Function-local UPPER_SNAKE is a softer
     smell — it belongs in config/ but does not block the write. This function
-    surfaces those as advisory so callers can route them to stderr rather than
-    to the blocking deny payload.
+    writes each finding straight to stderr, matching the other advisory-only
+    checks, so the write proceeds regardless of what it finds.
     """
     if _is_exempt_for_advisory_scan(file_path):
-        return []
-    return _scan_function_body_constants(content)
+        return
+    for each_issue in _scan_function_body_constants(content):
+        sys.stderr.write(f"[CODE_RULES advisory] {file_path}: {each_issue}\n")
 
 
 def _is_upper_snake_constant_name(name: str) -> bool:

package/hooks/blocking/code_rules_enforcer.py

@@ -16,7 +16,6 @@ concern focused. The separate ``tdd_enforcer.py`` hook accepts any
 ``code_rules_*`` module family, so the suffix files satisfy its gate.
 """
 import json
-import os
 import sys
 from collections import Counter
 from collections.abc import Callable
@@ -186,11 +185,42 @@ from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
     PRECHECK_USAGE_MESSAGE,
     UNKNOWN_VALIDATION_PHASE_MESSAGE_TEMPLATE,
     VIOLATION_SEPARATOR,
+    apply_edits,
+    edits_for_tool,
 )
 from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 from hooks_constants.setup_project_paths_constants import (  # noqa: E402
     UTF8_BYTE_ORDER_MARK,
 )
+from hooks_constants.subprocess_budget_completeness_content import (  # noqa: E402
+    existing_file_content,
+)
+
+
+def _multiedit_post_edit_view(
+    file_path: str, all_tool_input: dict[str, object]
+) -> tuple[str, str] | None:
+    """Return the prior and reconstructed post-edit content for a MultiEdit payload.
+
+    Reads ``file_path`` once and applies every edit in the payload's ``edits``
+    list in order, so a violation introduced by any edit — not only the
+    first — is judged against the file's real prior and post-edit state.
+
+    Args:
+        file_path: The destination path the MultiEdit targets.
+        all_tool_input: The MultiEdit payload's input mapping.
+
+    Returns:
+        A ``(prior_content, post_edit_content)`` pair, or None when the target
+        file cannot be read.
+    """
+    existing_content = existing_file_content(file_path)
+    if existing_content is None:
+        return None
+    post_edit_content = apply_edits(
+        existing_content, edits_for_tool("MultiEdit", all_tool_input)
+    )
+    return existing_content, post_edit_content
 
 
 class _ValidationContext(NamedTuple):
@@ -263,9 +293,8 @@ def _report_codex_patch_payload(
             deny_stream,
         )
         return
-    working_directory = all_pretooluse_payload.get("cwd")
-    if not isinstance(working_directory, str):
-        working_directory = os.getcwd()
+    raw_working_directory = all_pretooluse_payload.get("cwd")
+    working_directory = raw_working_directory if isinstance(raw_working_directory, str) else None
     try:
         all_patch_files = parse_codex_apply_patch(patch_command, working_directory)
     except CodexPatchError as error:
@@ -325,7 +354,7 @@ def _python_magic_value_and_constant_issues(context: _ValidationContext) -> list
     )
     all_issues.extend(check_fstring_structural_literals(content, file_path))
     all_issues.extend(check_constants_outside_config(content, file_path))
-    all_issues.extend(check_constants_outside_config_advisory(content, file_path))
+    check_constants_outside_config_advisory(content, file_path)
     all_issues.extend(check_file_global_constants_use_count(content, file_path))
     return all_issues
 
@@ -678,15 +707,6 @@ def validate_content_for_full_gate(
     )
 
 
-def _read_existing_file_content(file_path: str) -> str | None:
-    """Return the on-disk content of *file_path*, or None when it cannot be read."""
-    try:
-        with open(file_path, "r", encoding="utf-8") as existing_file:
-            return existing_file.read()
-    except (FileNotFoundError, OSError, UnicodeDecodeError):
-        return None
-
-
 def prior_and_post_edit_content(
     file_path: str, old_string: str, new_string: str,
 ) -> tuple[str | None, str | None]:
@@ -716,7 +736,7 @@ def prior_and_post_edit_content(
     """
     if not old_string:
         return None, None
-    existing_content = _read_existing_file_content(file_path)
+    existing_content = existing_file_content(file_path)
     if existing_content is None:
         return None, None
     if old_string not in existing_content:
@@ -799,11 +819,8 @@ def _hook_infrastructure_blocking_issues(
     Returns:
         The in-scope violations for the target at the given phase.
     """
-    effective_content = content if full_file_content is None else full_file_content
-    all_changed_lines = (
-        changed_line_numbers(prior_full_file_content, full_file_content)
-        if full_file_content is not None
-        else None
+    effective_content, all_changed_lines = _effective_content_and_changed_lines(
+        content, full_file_content, prior_full_file_content
     )
     all_issues: list[str] = []
     if phase == FULL_GATE_PHASE:
@@ -1051,13 +1068,13 @@ def _run_precheck(
     runs_hook_duplicate_body = _is_hook_infrastructure_python_target(target_path)
     if not runs_full_verdict and not runs_hook_duplicate_body:
         return 0
-    candidate_content = _read_existing_file_content(candidate_path)
+    candidate_content = existing_file_content(candidate_path)
     if candidate_content is None:
         error_stream.write(f"error: cannot read candidate file: {candidate_path}\n")
         return 1
     candidate_content = candidate_content.lstrip(UTF8_BYTE_ORDER_MARK)
     if runs_full_verdict:
-        old_content = _read_existing_file_content(target_path) or ""
+        old_content = existing_file_content(target_path) or ""
         all_issues = validate_content_for_full_gate(candidate_content, target_path, old_content)
     else:
         all_issues = _hook_infrastructure_blocking_issues(
@@ -1130,18 +1147,16 @@ def _run_precheck_command(
 
 def _contents_for_validation(
     tool_name: str,
-    new_string: str,
-    old_string: str,
-    written_content: str,
+    all_tool_input: dict[str, object],
     file_path: str,
 ) -> tuple[str, str, str | None, str] | None:
     """Resolve the content views the verdict needs for the given tool payload.
 
     Args:
         tool_name: The tool named in the PreToolUse payload.
-        new_string: The Edit payload's replacement fragment.
-        old_string: The Edit payload's fragment to replace.
-        written_content: The Write payload's whole file body.
+        all_tool_input: The PreToolUse payload's tool_input mapping, carrying
+            ``new_string``/``old_string`` for Edit, ``content`` for Write, and
+            the ``edits`` list for MultiEdit.
         file_path: The destination path of the write or edit.
 
     Returns:
@@ -1149,17 +1164,26 @@ def _contents_for_validation(
         prior_full_file_content)`` tuple, or None when no validatable view
         exists — an unreadable edit target, or a write over an existing file.
     """
+    new_string = str(all_tool_input.get("new_string", "") or "")
+    old_string = str(all_tool_input.get("old_string", "") or "")
+    written_content = str(all_tool_input.get("content", "") or "")
     if tool_name == "Edit":
         prior_content, full_file_content_after_edit = prior_and_post_edit_content(
             file_path, old_string, new_string,
         )
         if full_file_content_after_edit is None:
-            full_file_content_after_edit = _read_existing_file_content(file_path)
+            full_file_content_after_edit = existing_file_content(file_path)
             if full_file_content_after_edit is None:
                 return None
         return new_string, old_string, full_file_content_after_edit, prior_content or ""
+    if tool_name == "MultiEdit":
+        multiedit_view = _multiedit_post_edit_view(file_path, all_tool_input or {})
+        if multiedit_view is None:
+            return None
+        prior_content, post_edit_content = multiedit_view
+        return post_edit_content, prior_content, post_edit_content, prior_content
     content = written_content or new_string
-    old_content = _read_existing_file_content(file_path) or ""
+    old_content = existing_file_content(file_path) or ""
     if old_content:
         return None
     return content, old_content, None, ""
@@ -1179,7 +1203,7 @@ def _deny_reason_for_issues(
         tool_name: The tool named in the PreToolUse payload.
         file_path: The destination path used for forecast classification.
         full_file_content_after_edit: The whole post-edit file content when the
-            edit reconstructs one, used to run the full-file forecast.
+            edit reconstructs one, for the full-file forecast.
         prior_full_file_content: The whole file content before the edit applied.
             Empty when the edit's old_string is absent and no reliable prior
             exists; the forecast is skipped in that case so a comment diff
@@ -1195,7 +1219,7 @@ def _deny_reason_for_issues(
     )
     has_reconstructed_prior = bool(prior_full_file_content)
     if (
-        tool_name == "Edit"
+        tool_name in ("Edit", "MultiEdit")
         and full_file_content_after_edit is not None
         and has_reconstructed_prior
     ):
@@ -1253,7 +1277,8 @@ def _report_blocking_violations(
         content: The fragment or whole-file body under validation.
         tool_name: The tool named in the PreToolUse payload.
         file_path: The destination path of the write or edit.
-        old_content: The fragment the edit replaces, or empty for a write.
+        old_content: The fragment named by the edit's old_string, or empty for
+            a write.
         full_file_content_after_edit: The reconstructed post-edit file body,
             or None when the payload is not an Edit.
         prior_full_file_content: The on-disk content before the edit.
@@ -1353,9 +1378,7 @@ def main(all_arguments: list[str]) -> None:
 
     validation_contents = _contents_for_validation(
         tool_name,
-        tool_input.get("new_string", ""),
-        tool_input.get("old_string", ""),
-        tool_input.get("content", ""),
+        tool_input,
         file_path,
     )
     if validation_contents is None:

package/hooks/blocking/codex_apply_patch.py

@@ -2,9 +2,21 @@
 
 import os
 import re
+import sys
 from dataclasses import dataclass
+from functools import cache
 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 blocking.config.codex_apply_patch_constants import (  # noqa: E402
+    CODEX_ADD_OPERATION,
+    CODEX_DELETE_OPERATION,
+    CODEX_UPDATE_OPERATION,
+)
+
 _codex_patch_begin_marker = "*** Begin Patch"
 _codex_patch_end_marker = "*** End Patch"
 _codex_update_marker = "*** Update File:"
@@ -14,9 +26,6 @@ _codex_hunk_marker = "@@"
 _codex_end_of_file_marker = "*** End of File"
 _codex_no_newline_marker = "\"
 _codex_minimum_patch_line_count = 2
-_codex_update_operation = "update"
-_codex_add_operation = "add"
-_codex_delete_operation = "delete"
 
 
 class CodexPatchError(ValueError):
@@ -70,6 +79,11 @@ def _codex_patch_sections(command: str) -> list[tuple[str, str, list[str]]]:
         raise CodexPatchError("patch requires a begin marker")
     if _codex_marker_text(all_lines[-1]) != _codex_patch_end_marker:
         raise CodexPatchError("patch requires an end marker")
+    all_marker_by_operation = {
+        CODEX_UPDATE_OPERATION: _codex_update_marker,
+        CODEX_ADD_OPERATION: _codex_add_marker,
+        CODEX_DELETE_OPERATION: _codex_delete_marker,
+    }
     all_sections: list[tuple[str, str, list[str]]] = []
     current_section: tuple[str, str, list[str]] | None = None
     for each_line in all_lines[1:-1]:
@@ -77,11 +91,7 @@ def _codex_patch_sections(command: str) -> list[tuple[str, str, list[str]]]:
         operation = next(
             (
                 each_operation
-                for each_operation, each_marker in (
-                    (_codex_update_operation, _codex_update_marker),
-                    (_codex_add_operation, _codex_add_marker),
-                    (_codex_delete_operation, _codex_delete_marker),
-                )
+                for each_operation, each_marker in all_marker_by_operation.items()
                 if marker_text.startswith(each_marker)
             ),
             None,
@@ -89,12 +99,7 @@ def _codex_patch_sections(command: str) -> list[tuple[str, str, list[str]]]:
         if operation is not None:
             if current_section is not None:
                 all_sections.append(current_section)
-            marker_by_operation = {
-                _codex_update_operation: _codex_update_marker,
-                _codex_add_operation: _codex_add_marker,
-                _codex_delete_operation: _codex_delete_marker,
-            }
-            path_text = marker_text[len(marker_by_operation[operation]) :].strip()
+            path_text = marker_text[len(all_marker_by_operation[operation]) :].strip()
             if not path_text:
                 raise CodexPatchError("patch operation requires a path")
             current_section = (operation, path_text, [])
@@ -190,15 +195,15 @@ def _codex_read_patch_file(
     try:
         prior_content = target_path.read_text(encoding="utf-8")
     except (FileNotFoundError, IsADirectoryError, OSError, UnicodeDecodeError, ValueError) as error:
-        if operation == _codex_add_operation and isinstance(error, FileNotFoundError):
+        if operation == CODEX_ADD_OPERATION and isinstance(error, FileNotFoundError):
             prior_content = ""
         else:
             raise CodexPatchError("patch target requires readable UTF-8 content") from error
-    if operation == _codex_add_operation:
+    if operation == CODEX_ADD_OPERATION:
         if target_path.exists():
             raise CodexPatchError("add target requires a new path")
         post_content = _codex_add_content(all_section_lines)
-    elif operation == _codex_update_operation:
+    elif operation == CODEX_UPDATE_OPERATION:
         post_content = _codex_apply_update(prior_content, all_section_lines)
     else:
         if any(
@@ -210,15 +215,125 @@ def _codex_read_patch_file(
     return CodexPatchFile(str(target_path), prior_content, post_content, operation)
 
 
-def parse_codex_apply_patch(
-    command: str, working_directory: str | None = None
-) -> tuple[CodexPatchFile, ...]:
-    """Return pre-edit and post-edit views for every Codex patch path."""
+def payload_patch_command(hook_payload: dict, tool_input: dict) -> tuple[str, str | None]:
+    """Pull the patch text and its working directory out of an apply_patch payload.
+
+    ::
+
+        hook_payload = {"cwd": "/repo"}
+        tool_input   = {"command": "*** Begin Patch ..."}
+        payload_patch_command(...)  ->  ("*** Begin Patch ...", "/repo")
+
+    A payload whose command or cwd is missing, or carries a non-string value,
+    yields an empty command and a None directory. An empty command tells the
+    caller there is no patch to parse.
+
+    Args:
+        hook_payload: The whole PreToolUse payload, carrying the cwd.
+        tool_input: The tool input mapping, carrying the command text.
+
+    Returns:
+        The command text and the working directory to resolve paths against.
+    """
+    raw_command = (tool_input or {}).get("command", "")
+    command = raw_command if isinstance(raw_command, str) else ""
+    raw_working_directory = (hook_payload or {}).get("cwd")
+    working_directory = raw_working_directory if isinstance(raw_working_directory, str) else None
+    return command, working_directory
+
+
+def _codex_working_directory(command: str, working_directory: str | None) -> Path:
+    """Validate the patch command text and working directory, then resolve it.
+
+    Args:
+        command: The raw Codex apply_patch command text.
+        working_directory: The directory patch paths resolve against, or None
+            to use the current working directory.
+
+    Returns:
+        The resolved, existing working directory.
+    """
     if not isinstance(command, str) or not command.strip():
         raise CodexPatchError("patch command requires text")
     resolved_working_directory = Path(working_directory or os.getcwd()).expanduser().resolve()
     if not resolved_working_directory.is_dir():
         raise CodexPatchError("patch working directory requires an existing directory")
+    return resolved_working_directory
+
+
+@cache
+def codex_patch_operation_targets(
+    command: str, working_directory: str | None = None
+) -> tuple[tuple[str, str], ...]:
+    """Return each (operation, resolved path) pair a Codex patch command names.
+
+    Resolves every section's target path the same way ``parse_codex_apply_patch``
+    does, without reading any file's prior content, so a caller that only needs
+    each target path (a sensitive-path check, an already-exists check) is not
+    tripped up by a prior file it never needs to read.
+
+    Args:
+        command: The raw Codex apply_patch command text.
+        working_directory: The directory patch paths resolve against, or None
+            to use the current working directory.
+
+    Returns:
+        The ordered ``(operation, resolved_path)`` pairs the patch names.
+    """
+    resolved_working_directory = _codex_working_directory(command, working_directory)
+    return tuple(
+        (each_operation, _codex_resolve_patch_path(each_relative_path, resolved_working_directory))
+        for each_operation, each_relative_path, _each_section_lines in _codex_patch_sections(command)
+    )
+
+
+def _target_paths_for_command(command: str, working_directory: str | None) -> tuple[str, ...]:
+    """Return each resolved target path one patch command names.
+
+    An empty command, and a command this parser rejects, both yield an empty
+    tuple, so the caller reads one result shape either way.
+
+    Args:
+        command: The raw Codex apply_patch command text, or an empty string.
+        working_directory: The directory patch paths resolve against, or None.
+
+    Returns:
+        The ordered resolved target paths the patch names.
+    """
+    if not command:
+        return ()
+    try:
+        all_operation_targets = codex_patch_operation_targets(command, working_directory)
+    except CodexPatchError:
+        return ()
+    return tuple(each_path for _each_operation, each_path in all_operation_targets)
+
+
+def payload_patch_target_paths(hook_payload: dict, tool_input: dict) -> tuple[str, ...]:
+    """Return every resolved target path an apply_patch payload names.
+
+    The wrapper a hook wants when it needs target paths and nothing else. It
+    reads the command out of the payload, then resolves paths without reading
+    any target file's prior content.
+
+    Args:
+        hook_payload: The whole hook payload, carrying the cwd.
+        tool_input: The tool input mapping, carrying the command text.
+
+    Returns:
+        The ordered resolved target paths the patch names, empty when the
+        payload names no patch or the patch will not parse.
+    """
+    command, working_directory = payload_patch_command(hook_payload, tool_input)
+    return _target_paths_for_command(command, working_directory)
+
+
+@cache
+def parse_codex_apply_patch(
+    command: str, working_directory: str | None = None
+) -> tuple[CodexPatchFile, ...]:
+    """Return pre-edit and post-edit views for every Codex patch path."""
+    resolved_working_directory = _codex_working_directory(command, working_directory)
     all_patch_files: list[CodexPatchFile] = []
     seen_paths: set[str] = set()
     for each_operation, each_relative_path, each_section_lines in _codex_patch_sections(command):

package/hooks/blocking/config/codex_apply_patch_constants.py

@@ -0,0 +1,13 @@
+"""Shared operation-name constants for codex_apply_patch.py.
+
+A Codex apply_patch command names three operations — add, update, and
+delete — by a literal marker line. These three constants are the single
+source of truth for those spellings, so every caller that branches on one
+compares against one value rather than a second local copy that could drift.
+"""
+
+from __future__ import annotations
+
+CODEX_ADD_OPERATION = "add"
+CODEX_UPDATE_OPERATION = "update"
+CODEX_DELETE_OPERATION = "delete"

package/hooks/blocking/conftest.py

@@ -0,0 +1,70 @@
+"""Add hooks/blocking and hooks/ to sys.path for every test collected under this directory."""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Callable
+
+import pytest
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(_BLOCKING_DIRECTORY).parent)
+for each_directory in (_BLOCKING_DIRECTORY, _HOOKS_DIRECTORY):
+    if each_directory not in sys.path:
+        sys.path.insert(0, each_directory)
+
+
+@pytest.fixture
+def three_operation_patch() -> str:
+    """Build a patch naming one update, one add, and one delete section."""
+    return (
+        "*** Begin Patch\n"
+        "*** Update File: updated.py\n"
+        "@@\n"
+        "-before\n"
+        "+after\n"
+        " keep\n"
+        "*** Add File: added.py\n"
+        "+new\n"
+        "*** Delete File: deleted.py\n"
+        "*** End of File\n"
+        "*** End Patch"
+    )
+
+
+@pytest.fixture
+def init_bare_git_repo() -> Callable[[Path], None]:
+    """Return a helper that initializes an empty git repository at a given path.
+
+    The PII scanner reads an apply_patch payload's ``cwd`` as a git
+    repository root, so a dispatcher-level apply_patch test needs a real
+    repository there rather than a bare temp directory.
+    """
+
+    def _init_bare_git_repo(repository_root: Path) -> None:
+        repository_root.mkdir(parents=True, exist_ok=True)
+        subprocess.run(["git", "init"], cwd=repository_root, check=True, capture_output=True)
+
+    return _init_bare_git_repo
+
+
+@pytest.fixture
+def synthetic_github_token() -> str:
+    """Return a fixture-only GitHub token shape, safe to embed in test payloads."""
+    return "ghp_" + ("C" * 36)
+
+
+@pytest.fixture
+def multi_edit_payload() -> Callable[[str, list[dict[str, str]]], str]:
+    """Return a helper that builds a MultiEdit tool payload JSON string."""
+
+    def _multi_edit_payload(file_path: str, all_edits: list[dict[str, str]]) -> str:
+        return json.dumps(
+            {
+                "tool_name": "MultiEdit",
+                "tool_input": {"file_path": file_path, "edits": all_edits},
+            }
+        )
+
+    return _multi_edit_payload

package/hooks/blocking/duplicate_rmtree_helper_blocker.py

@@ -27,20 +27,28 @@ 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.duplicate_rmtree_helper_blocker_constants import (  # noqa: E402
-    ALL_EXEMPT_PATH_FRAGMENTS,
-    ALL_EXEMPT_TEST_FILE_PREFIXES,
-    ALL_EXEMPT_TEST_FILE_SUFFIXES,
-    HELPER_DEFINITION_PATTERN,
-    PYTHON_FILE_EXTENSION,
-    TRIPLE_QUOTED_STRING_PATTERN,
-)
-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
+try:
+    _hooks_dir = str(Path(__file__).resolve().parent.parent)
+    if _hooks_dir not in sys.path:
+        sys.path.insert(0, _hooks_dir)
+
+    from hooks_constants.duplicate_rmtree_helper_blocker_constants import (
+        ALL_APPLICABLE_TOOL_NAMES,
+        ALL_EXEMPT_PATH_FRAGMENTS,
+        ALL_EXEMPT_TEST_FILE_PREFIXES,
+        ALL_EXEMPT_TEST_FILE_SUFFIXES,
+        HELPER_DEFINITION_PATTERN,
+        PYTHON_FILE_EXTENSION,
+        TRIPLE_QUOTED_STRING_PATTERN,
+    )
+    from hooks_constants.hook_block_logger import log_hook_block
+    from hooks_constants.multi_edit_reconstruction import joined_new_strings
+    from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+except ImportError as import_error:
+    raise ImportError(
+        "duplicate_rmtree_helper_blocker: cannot import its sibling modules; "
+        "ensure the hooks directory is importable."
+    ) from import_error
 
 
 def payload_defines_sanctioned_helper(payload_text: str) -> bool:
@@ -87,7 +95,7 @@ def path_is_exempt(file_path: str) -> bool:
 
 
 def extract_payload_text(tool_name: str, tool_input: dict) -> tuple[str, str]:
-    """Return the (file_path, scanned_text) pair for a Write/Edit to a Python file.
+    """Return the (file_path, scanned_text) pair for a Write/Edit/MultiEdit to a Python file.
 
     Args:
         tool_name: The PreToolUse tool name.
@@ -97,11 +105,13 @@ def extract_payload_text(tool_name: str, tool_input: dict) -> tuple[str, str]:
         A pair of the target path and the text to scan. The text is empty for an
         unrelated tool or a non-Python target, so the caller exits without blocking.
     """
-    if tool_name not in {"Write", "Edit"}:
+    if tool_name not in ALL_APPLICABLE_TOOL_NAMES:
         return "", ""
     file_path = tool_input.get("file_path", "") or ""
     if file_path and not file_path.endswith(PYTHON_FILE_EXTENSION):
         return file_path, ""
+    if tool_name == "MultiEdit":
+        return file_path, joined_new_strings(tool_input)
     scanned_text = tool_input.get("content", "") or tool_input.get("new_string", "") or ""
     return file_path, scanned_text