claude-dev-env 2.30.0 → 2.31.0

package/hooks/hooks_constants/test_subprocess_budget_completeness_content.py

@@ -0,0 +1,70 @@
+"""Tests for subprocess_budget_completeness_content.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.subprocess_budget_completeness_content import (
+        reconstructed_edit_content,
+        reconstructed_multi_edit_content,
+        resolved_content,
+    )
+except ImportError as import_error:
+    raise ImportError(
+        "test_subprocess_budget_completeness_content: cannot import its sibling modules; "
+        "ensure the hooks directory is importable."
+    ) from import_error
+
+
+def test_resolved_content_returns_write_content_directly() -> None:
+    assert resolved_content({"content": "abc"}) == "abc"
+
+
+def test_reconstructed_edit_content_replaces_the_old_string(tmp_path: pathlib.Path) -> None:
+    target_file = tmp_path / "module.py"
+    target_file.write_text("value = 1\n", encoding="utf-8")
+    reconstructed = reconstructed_edit_content(
+        {"file_path": str(target_file), "old_string": "value = 1", "new_string": "value = 2"}
+    )
+    assert reconstructed == "value = 2\n"
+
+
+def test_reconstructed_multi_edit_content_applies_every_edit_in_order(
+    tmp_path: pathlib.Path,
+) -> None:
+    target_file = tmp_path / "module.py"
+    target_file.write_text("a = 1\nb = 2\n", encoding="utf-8")
+    all_edits = [
+        {"old_string": "a = 1", "new_string": "a = 11"},
+        {"old_string": "b = 2", "new_string": "b = 22"},
+    ]
+    reconstructed = reconstructed_multi_edit_content({"file_path": str(target_file)}, all_edits)
+    assert reconstructed == "a = 11\nb = 22\n"
+
+
+def test_resolved_content_dispatches_a_multi_edit_payload(tmp_path: pathlib.Path) -> None:
+    target_file = tmp_path / "module.py"
+    target_file.write_text("a = 1\n", encoding="utf-8")
+    reconstructed = resolved_content(
+        {
+            "file_path": str(target_file),
+            "edits": [{"old_string": "a = 1", "new_string": "a = 11"}],
+        }
+    )
+    assert reconstructed == "a = 11\n"
+
+
+def test_resolved_content_returns_empty_for_an_unreadable_edit_target(
+    tmp_path: pathlib.Path,
+) -> None:
+    missing_target = tmp_path / "missing.py"
+    assert (
+        resolved_content({"file_path": str(missing_target), "old_string": "a", "new_string": "b"})
+        == ""
+    )

package/hooks/hooks_constants/validation_phase_constants.py

@@ -4,6 +4,8 @@ The edit lane and the full gate share every check except six that read
 sibling modules from disk. These names identify each phase, name the checks
 the full gate alone runs, name the hook-infrastructure checks the edit lane
 still runs, and template the error for an unrecognized phase.
+
+Scope assigns the lane. See ``docs/CODE_RULES.md`` section 11.6.
 """
 
 EDIT_LANE_PHASE: str = "edit_lane"

package/hooks/hooks_constants/workflow_substitution_slot_blocker_constants.py

@@ -1,8 +1,12 @@
 """Configuration constants for the workflow_substitution_slot_blocker PreToolUse hook."""
 
-WRITE_TOOL_NAME: str = "Write"
-EDIT_TOOL_NAME: str = "Edit"
-MULTI_EDIT_TOOL_NAME: str = "MultiEdit"
+# The dispatcher constants module is the single source for tool names.
+from hooks_constants.pre_tool_use_dispatcher_constants import (  # noqa: F401
+    EDIT_TOOL_NAME,
+    MULTI_EDIT_TOOL_NAME,
+    WRITE_TOOL_NAME,
+)
+
 
 WORKFLOW_FILE_SUFFIX: str = ".workflow.js"
 

package/hooks/observability/pr_description_writer_spawn_tracker.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""PostToolUse hook: record that this session spawned the pr-description-writer agent.
+
+Picture opening a pull request whose body nobody wrote from the diff — it reads
+like a commit message, and the reviewer learns nothing before opening the files.
+The ``pr-description-writer`` agent exists to write that body, and it hands the
+markdown and a body-file path back to the caller to publish.
+
+This hook remembers that the agent ran. After each Agent or Task spawn naming
+``pr-description-writer``, it touches an empty marker file for this session in
+the system temp directory. The ``gh pr create`` gate reads that marker.
+
+The marker carries one fact — the agent ran this session — so a touch records
+everything the gate needs, and two parallel spawns racing on the same touch
+leave the same result. The file name carries the session id, so a marker a
+crashed session leaves behind is inert: no later session reads it.
+
+The hook never blocks a tool call. A tool that is not a spawn, a spawn of
+another agent, a malformed payload, a payload naming no session, or a failed
+touch each returns quietly.
+"""
+
+from __future__ import annotations
+
+import sys
+import tempfile
+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.pr_description_writer_gate_constants import (  # noqa: E402
+    ALL_AGENT_SPAWN_TOOL_NAMES,
+    PR_DESCRIPTION_WRITER_SUBAGENT_TYPE,
+    SPAWN_MARKER_FILE_PREFIX,
+    SPAWN_MARKER_FILE_SUFFIX,
+    SUBAGENT_TYPE_FIELD_NAME,
+    TOOL_INPUT_FIELD_NAME,
+    TOOL_NAME_FIELD_NAME,
+)
+from hooks_constants.pre_tool_use_stdin import (  # noqa: E402
+    read_hook_input_dictionary_from_stdin,
+)
+from hooks_constants.session_edit_stage_gate_constants import (  # noqa: E402
+    SESSION_ID_UNSAFE_CHARACTERS_PATTERN,
+)
+
+
+def spawn_marker_path(session_id: str, temp_directory: Path | None = None) -> Path | None:
+    """Return the marker path for one session, or None without a usable id.
+
+    ::
+
+        session_id = "abc-123"  ->  <temp>/claude-session-pr-description-writer-abc-123.marker
+        session_id = ""         ->  None
+        session_id = "///"      ->  None
+
+    Unsafe characters are stripped so the name stays anchored inside the temp
+    directory. A session id that sanitizes to nothing yields no path, so every
+    marker on disk belongs to one real session and a marker a crashed session
+    leaves behind is inert — no later session reads it.
+
+    Args:
+        session_id: Raw ``session_id`` from the hook payload.
+        temp_directory: The directory holding the marker. Defaults to the
+            system temp directory.
+
+    Returns:
+        Absolute path to this session's marker file, or None when the payload
+        names no session this hook can key on.
+    """
+    sanitized_session_id = SESSION_ID_UNSAFE_CHARACTERS_PATTERN.sub("", session_id)
+    if not sanitized_session_id:
+        return None
+    file_name = f"{SPAWN_MARKER_FILE_PREFIX}{sanitized_session_id}{SPAWN_MARKER_FILE_SUFFIX}"
+    resolved_temp_directory = temp_directory or Path(tempfile.gettempdir())
+    return resolved_temp_directory / file_name
+
+
+def _record_spawn(session_id: str) -> None:
+    """Touch this session's marker file, ignoring a write failure.
+
+    Args:
+        session_id: Raw ``session_id`` from the hook payload.
+    """
+    marker_file = spawn_marker_path(session_id)
+    if marker_file is None:
+        return
+    try:
+        marker_file.parent.mkdir(parents=True, exist_ok=True)
+        marker_file.touch(exist_ok=True)
+    except OSError:
+        return
+
+
+def main() -> None:
+    """Record the marker when this payload is a pr-description-writer spawn.
+
+    Reads the PostToolUse payload from stdin and touches this session's marker
+    file when an Agent or Task spawn names the ``pr-description-writer`` agent.
+    Returns on every other branch — another tool, another agent, a malformed
+    payload, or a missing ``tool_input`` — so the spawn is never blocked.
+    """
+    hook_payload = read_hook_input_dictionary_from_stdin()
+    if hook_payload is None:
+        return
+    tool_name = hook_payload.get(TOOL_NAME_FIELD_NAME, "")
+    if tool_name not in ALL_AGENT_SPAWN_TOOL_NAMES:
+        return
+    tool_input = hook_payload.get(TOOL_INPUT_FIELD_NAME, {})
+    if not isinstance(tool_input, dict):
+        return
+    if tool_input.get(SUBAGENT_TYPE_FIELD_NAME) != PR_DESCRIPTION_WRITER_SUBAGENT_TYPE:
+        return
+    session_id = str(hook_payload.get("session_id") or "")
+    _record_spawn(session_id)
+
+
+if __name__ == "__main__":
+    main()

package/hooks/observability/session_file_edit_tracker.py

@@ -31,12 +31,14 @@ _hooks_dir = str(Path(__file__).resolve().parent.parent)
 if _hooks_dir not in sys.path:
     sys.path.insert(0, _hooks_dir)
 
+from blocking.codex_apply_patch import payload_patch_target_paths  # noqa: E402
 from hooks_constants.pre_tool_use_stdin import (  # noqa: E402
     read_hook_input_dictionary_from_stdin,
 )
 from hooks_constants.session_edit_stage_gate_constants import (  # noqa: E402
     ALL_EDITED_FILE_PATHS_KEY,
     ALL_TRACKED_EDIT_TOOL_NAMES,
+    APPLY_PATCH_TOOL_NAME,
     LOCK_ACQUIRE_RETRY_SECONDS,
     LOCK_ACQUIRE_TIMEOUT_SECONDS,
     SESSION_EDIT_FILE_PREFIX,
@@ -49,6 +51,23 @@ from hooks_constants.session_edit_stage_gate_constants import (  # noqa: E402
 )
 
 
+def _resolved_path_or_none(file_path: str) -> str | None:
+    """Return the resolved absolute path, or None when resolution fails."""
+    try:
+        return str(Path(file_path).resolve())
+    except OSError:
+        return None
+
+
+def _record_apply_patch_edits(hook_payload: dict, tool_input: dict) -> None:
+    """Record the resolved path of every file a Codex apply_patch payload names."""
+    session_id = str(hook_payload.get("session_id") or "")
+    for each_file_path in payload_patch_target_paths(hook_payload, tool_input):
+        resolved_file_path = _resolved_path_or_none(each_file_path)
+        if resolved_file_path is not None:
+            _record_edited_path(session_id, resolved_file_path)
+
+
 def _session_edit_file_path(session_id: str) -> Path:
     """Return the per-session tracker file path in the system temp directory.
 
@@ -193,7 +212,7 @@ def _record_edited_path(session_id: str, resolved_file_path: str) -> None:
 
 
 def main() -> None:
-    """Record the edited file path for a Write, Edit, or MultiEdit.
+    """Record the edited file path for a Write, Edit, MultiEdit, or apply_patch.
 
     Reads the PostToolUse payload from stdin, and for a tracked edit tool
     appends the resolved absolute file path to this session's tracker file.
@@ -209,12 +228,14 @@ def main() -> None:
     tool_input = hook_payload.get("tool_input", {})
     if not isinstance(tool_input, dict):
         return
+    if tool_name == APPLY_PATCH_TOOL_NAME:
+        _record_apply_patch_edits(hook_payload, tool_input)
+        return
     file_path = tool_input.get("file_path", "")
     if not isinstance(file_path, str) or not file_path:
         return
-    try:
-        resolved_file_path = str(Path(file_path).resolve())
-    except OSError:
+    resolved_file_path = _resolved_path_or_none(file_path)
+    if resolved_file_path is None:
         return
     session_id = str(hook_payload.get("session_id") or "")
     _record_edited_path(session_id, resolved_file_path)

package/hooks/observability/test_pr_description_writer_spawn_tracker.py

@@ -0,0 +1,146 @@
+"""Unit tests for the pr-description-writer spawn tracker PostToolUse hook."""
+
+from __future__ import annotations
+
+import importlib.util
+import io
+import json
+import sys
+from pathlib import Path
+from unittest import mock
+
+import pytest
+
+_OBSERVABILITY_DIRECTORY = Path(__file__).resolve().parent
+_HOOKS_DIRECTORY = _OBSERVABILITY_DIRECTORY.parent
+for each_directory in (_OBSERVABILITY_DIRECTORY, _HOOKS_DIRECTORY):
+    if str(each_directory) not in sys.path:
+        sys.path.insert(0, str(each_directory))
+
+_TRACKER_SPEC = importlib.util.spec_from_file_location(
+    "pr_description_writer_spawn_tracker",
+    _OBSERVABILITY_DIRECTORY / "pr_description_writer_spawn_tracker.py",
+)
+assert _TRACKER_SPEC is not None
+assert _TRACKER_SPEC.loader is not None
+tracker_module = importlib.util.module_from_spec(_TRACKER_SPEC)
+_TRACKER_SPEC.loader.exec_module(tracker_module)
+
+_SESSION_ID = "session-abc123"
+_OTHER_SUBAGENT_TYPE = "general-purpose"
+
+
+def _spawn_payload(
+    subagent_type: str,
+    tool_name: str = "Agent",
+    session_id: str = _SESSION_ID,
+) -> dict[str, object]:
+    """Build a PostToolUse payload for one agent spawn.
+
+    Args:
+        subagent_type: The agent type the spawn names.
+        tool_name: The spawning tool name.
+        session_id: The session the spawn belongs to.
+
+    Returns:
+        The payload dictionary the tracker reads from stdin.
+    """
+    return {
+        "tool_name": tool_name,
+        "session_id": session_id,
+        "tool_input": {
+            "subagent_type": subagent_type,
+            "description": "Write the PR body",
+            "prompt": "Write a PR description from the diff.",
+        },
+    }
+
+
+def _run_tracker(payload: dict[str, object], temp_directory: Path) -> None:
+    """Run the tracker's main against a payload with temp redirected.
+
+    Args:
+        payload: The PostToolUse payload to feed on stdin.
+        temp_directory: The directory standing in for the system temp root.
+    """
+    with mock.patch("sys.stdin", io.StringIO(json.dumps(payload))):
+        with mock.patch.object(
+            tracker_module.tempfile, "gettempdir", return_value=str(temp_directory)
+        ):
+            tracker_module.main()
+
+
+def should_record_marker_when_pr_description_writer_spawns(tmp_path: Path) -> None:
+    """A pr-description-writer spawn leaves this session's marker on disk."""
+    _run_tracker(_spawn_payload(tracker_module.PR_DESCRIPTION_WRITER_SUBAGENT_TYPE), tmp_path)
+    assert tracker_module.spawn_marker_path(_SESSION_ID, tmp_path).exists() is True
+
+
+def should_leave_no_marker_when_another_agent_spawns(tmp_path: Path) -> None:
+    """A spawn of a different agent type records nothing."""
+    _run_tracker(_spawn_payload(_OTHER_SUBAGENT_TYPE), tmp_path)
+    assert tracker_module.spawn_marker_path(_SESSION_ID, tmp_path).exists() is False
+
+
+@pytest.mark.parametrize("spawn_tool_name", ["Agent", "Task"])
+def should_record_marker_for_each_spawn_tool_name(spawn_tool_name: str, tmp_path: Path) -> None:
+    """Both spawning tool names record the marker."""
+    payload = _spawn_payload(
+        tracker_module.PR_DESCRIPTION_WRITER_SUBAGENT_TYPE, tool_name=spawn_tool_name
+    )
+    _run_tracker(payload, tmp_path)
+    assert tracker_module.spawn_marker_path(_SESSION_ID, tmp_path).exists() is True
+
+
+def should_leave_no_marker_for_an_unrelated_tool(tmp_path: Path) -> None:
+    """A tool that is not a spawn records nothing, even naming the agent."""
+    payload = _spawn_payload(tracker_module.PR_DESCRIPTION_WRITER_SUBAGENT_TYPE, tool_name="Bash")
+    _run_tracker(payload, tmp_path)
+    assert tracker_module.spawn_marker_path(_SESSION_ID, tmp_path).exists() is False
+
+
+def should_keep_each_session_marker_separate(tmp_path: Path) -> None:
+    """A spawn in one session leaves another session's marker absent."""
+    payload = _spawn_payload(
+        tracker_module.PR_DESCRIPTION_WRITER_SUBAGENT_TYPE, session_id="session-one"
+    )
+    _run_tracker(payload, tmp_path)
+    assert tracker_module.spawn_marker_path("session-one", tmp_path).exists() is True
+    assert tracker_module.spawn_marker_path("session-two", tmp_path).exists() is False
+
+
+def should_record_twice_without_error(tmp_path: Path) -> None:
+    """A second spawn in one session leaves the marker in place."""
+    payload = _spawn_payload(tracker_module.PR_DESCRIPTION_WRITER_SUBAGENT_TYPE)
+    _run_tracker(payload, tmp_path)
+    _run_tracker(payload, tmp_path)
+    assert tracker_module.spawn_marker_path(_SESSION_ID, tmp_path).exists() is True
+
+
+def should_ignore_a_malformed_payload(tmp_path: Path) -> None:
+    """Unparseable stdin records nothing and raises nothing."""
+    with mock.patch("sys.stdin", io.StringIO("this is not json")):
+        with mock.patch.object(tracker_module.tempfile, "gettempdir", return_value=str(tmp_path)):
+            tracker_module.main()
+    assert list(tmp_path.iterdir()) == []
+
+
+def should_ignore_a_payload_with_no_tool_input(tmp_path: Path) -> None:
+    """A spawn payload missing tool_input records nothing."""
+    payload: dict[str, object] = {"tool_name": "Agent", "session_id": _SESSION_ID}
+    _run_tracker(payload, tmp_path)
+    assert tracker_module.spawn_marker_path(_SESSION_ID, tmp_path).exists() is False
+
+
+@pytest.mark.parametrize("unusable_session_id", ["", "///"])
+def should_record_nothing_without_a_usable_session_id(
+    unusable_session_id: str, tmp_path: Path
+) -> None:
+    """A payload naming no usable session records no marker at all."""
+    payload = _spawn_payload(
+        tracker_module.PR_DESCRIPTION_WRITER_SUBAGENT_TYPE,
+        session_id=unusable_session_id,
+    )
+    _run_tracker(payload, tmp_path)
+    assert tracker_module.spawn_marker_path(unusable_session_id, tmp_path) is None
+    assert list(tmp_path.iterdir()) == []

package/hooks/observability/test_session_file_edit_tracker.py

@@ -172,3 +172,35 @@ def test_should_exit_zero_on_malformed_stdin(
 ) -> None:
     _run_main_with_stdin("not valid json {{{")
     assert not any(redirected_temp_directory.iterdir())
+
+
+def test_should_record_every_apply_patch_target_file(
+    redirected_temp_directory: pathlib.Path,
+) -> None:
+    working_directory = redirected_temp_directory / "repo"
+    working_directory.mkdir()
+    (working_directory / "updated.py").write_text("before\n", encoding="utf-8")
+    patch_command = (
+        "*** Begin Patch\n"
+        "*** Update File: updated.py\n"
+        "@@\n"
+        "-before\n"
+        "+after\n"
+        "*** Add File: added.py\n"
+        "+new\n"
+        "*** End Patch"
+    )
+    payload = json.dumps(
+        {
+            "session_id": _SESSION_ID,
+            "tool_name": "apply_patch",
+            "cwd": str(working_directory),
+            "tool_input": {"command": patch_command},
+        }
+    )
+
+    _run_main_with_stdin(payload)
+
+    recorded = _read_recorded_paths(redirected_temp_directory, _SESSION_ID)
+    assert str((working_directory / "updated.py").resolve()) in recorded
+    assert str((working_directory / "added.py").resolve()) in recorded

package/hooks/session/task_tool_prompt.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""SessionStart hook — direct the session to track work with its task tool.
+
+At session start this hook emits an ``additionalContext`` directive asking
+the session to track its work with the task or todo tracking tool its host
+provides: create tasks at the start of the session, then update them as
+work proceeds.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+
+import _path_setup  # noqa: F401
+
+from hooks_constants.task_tool_prompt_constants import TASK_TOOL_DIRECTIVE
+
+
+def build_session_directive() -> str:
+    """Return the task-tool directive emitted at session start."""
+    return TASK_TOOL_DIRECTIVE
+
+
+def main() -> None:
+    """Emit the task-tool directive as SessionStart additionalContext."""
+    payload = {
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": build_session_directive(),
+        }
+    }
+    sys.stdout.write(json.dumps(payload) + "\n")
+
+
+if __name__ == "__main__":
+    main()

package/hooks/session/test_task_tool_prompt.py

@@ -0,0 +1,65 @@
+"""Tests for task_tool_prompt — SessionStart hook that directs task-tool tracking."""
+
+import importlib
+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)
+
+prompt = importlib.import_module("task_tool_prompt")
+task_tool_prompt_constants = importlib.import_module("hooks_constants.task_tool_prompt_constants")
+TASK_TOOL_DIRECTIVE = task_tool_prompt_constants.TASK_TOOL_DIRECTIVE
+
+
+def _run_main() -> str:
+    """Return stdout produced by running the hook's main()."""
+    captured_stdout = StringIO()
+    with patch("sys.stdout", captured_stdout):
+        prompt.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_names_the_tracking_tool(self) -> None:
+        emitted = json.loads(_run_main())
+        assert "task or todo tracking tool" in emitted["hookSpecificOutput"]["additionalContext"]
+
+    def test_directive_names_no_vendor_or_host_product(self) -> None:
+        emitted = json.loads(_run_main())
+        additional_context = emitted["hookSpecificOutput"]["additionalContext"]
+        for each_forbidden_term in ("Claude", "Cursor", "Codex", "TaskCreate", "TodoWrite"):
+            assert each_forbidden_term not in additional_context
+
+    def test_directive_says_create_tasks_at_session_start(self) -> None:
+        emitted = json.loads(_run_main())
+        additional_context = emitted["hookSpecificOutput"]["additionalContext"]
+        assert "start of the session" in additional_context
+
+    def test_directive_says_update_as_work_proceeds(self) -> None:
+        emitted = json.loads(_run_main())
+        additional_context = emitted["hookSpecificOutput"]["additionalContext"]
+        assert "update" in additional_context
+        assert "as work proceeds" in additional_context
+
+    def test_directive_names_no_loop_cadence(self) -> None:
+        emitted = json.loads(_run_main())
+        additional_context = emitted["hookSpecificOutput"]["additionalContext"]
+        assert "/loop" not in additional_context
+        assert "cadence" not in additional_context
+        assert "minute" not in additional_context
+
+    def test_build_session_directive_returns_the_shared_constant(self) -> None:
+        assert prompt.build_session_directive() == TASK_TOOL_DIRECTIVE

package/hooks/validation/hook_format_validator.py

@@ -9,17 +9,34 @@ import re
 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.hook_block_logger import log_hook_block  # 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.hook_block_logger import log_hook_block
+    from hooks_constants.multi_edit_reconstruction import joined_new_strings
+except ImportError as import_error:
+    raise ImportError(
+        "hook_format_validator: cannot import its sibling modules; "
+        "ensure the hooks directory is importable."
+    ) from import_error
 
 SIMPLE_PATTERN = re.compile(
     r'python3?\s+~/\.claude/hooks/'
 )
 
 
+def _resolve_content(tool_name: str, all_tool_input: dict) -> str:
+    """Return the text a Write, Edit, or MultiEdit payload introduces."""
+    if tool_name == "MultiEdit":
+        return joined_new_strings(all_tool_input)
+    content = all_tool_input.get("content", "")
+    if not content:
+        content = all_tool_input.get("new_string", "")
+    return content
+
+
 def main() -> None:
     try:
         hook_input = json.load(sys.stdin)
@@ -36,10 +53,7 @@ def main() -> None:
         sys.exit(0)
 
     tool_name = hook_input.get("tool_name", "")
-    content = tool_input.get("content", "")
-    if not content:
-        new_string = tool_input.get("new_string", "")
-        content = new_string
+    content = _resolve_content(tool_name, tool_input)
 
     if tool_name == "Write" and content:
         try: