claude-dev-env 2.31.0 → 2.32.0

package/hooks/hooks_constants/hosted_hook_runner.py

@@ -13,16 +13,27 @@ blocking the tool call.
     run = run_hook_capturing_output("/hooks/blocking/gate.py", '{"tool_name": "Bash"}')
     ok:   run.captured_stdout carries the gate's deny JSON, run.did_crash is False
     flag: run.did_crash is True when the gate raised, run.captured_stdout is ""
+
+``run_dispatcher_main`` holds the entry-point shell a hosted-hook dispatcher's
+own ``main`` needs: read one stdin payload, resolve its tool_name, and hand
+both to the dispatcher's own ``dispatch`` callback. Every dispatcher's
+``main`` reduces to one call into this shared shell, so the read-resolve-exit
+boilerplate lives in one place rather than once per dispatcher.
 """
 
 from __future__ import annotations
 
 import io
+import json
 import runpy
 import sys
+from pathlib import Path
 import traceback
+from collections.abc import Callable
 from dataclasses import dataclass
 
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+
 
 @dataclass
 class HostedHookRun:
@@ -71,3 +82,45 @@ def run_hook_capturing_output(hook_script_path: str, payload_text: str) -> Hoste
     finally:
         sys.stdin, sys.stdout, sys.argv = original_stdin, original_stdout, original_argv
     return HostedHookRun(captured_stdout=captured_output.getvalue(), did_crash=did_crash)
+
+
+def resolved_hook_script_path(relative_path: str) -> str:
+    """Resolve a hooks/-relative path to the absolute script path to run.
+
+    ::
+
+        "observability/test_failure_recorder.py" -> <hooks>/observability/...
+
+    The root comes from this module's own location, so every dispatcher
+    resolves against the same directory however deep it sits.
+
+    Args:
+        relative_path: A path relative to the hooks directory.
+
+    Returns:
+        The absolute path of that script.
+    """
+    hooks_root = Path(__file__).resolve().parent.parent
+    return str(hooks_root / relative_path)
+
+
+def run_dispatcher_main(dispatch: Callable[[str, str], None]) -> None:
+    """Read one stdin payload and hand its JSON text and tool_name to dispatch.
+
+    Every hosted-hook dispatcher's own ``main`` reduces to this one call.
+    Exits 0 before ever calling dispatch when stdin is empty, malformed, or
+    names no tool_name string; always exits 0 afterward, since a dispatcher
+    signals its own outcome, if any, through what dispatch itself writes.
+
+    Args:
+        dispatch: The dispatcher's own ``dispatch(payload_text, tool_name)``.
+    """
+    payload_dictionary = read_hook_input_dictionary_from_stdin()
+    if payload_dictionary is None:
+        sys.exit(0)
+    payload_text = json.dumps(payload_dictionary)
+    tool_name = payload_dictionary.get("tool_name", "")
+    if not isinstance(tool_name, str) or not tool_name:
+        sys.exit(0)
+    dispatch(payload_text, tool_name)
+    sys.exit(0)

package/hooks/hooks_constants/piped_pytest_blocker_constants.py

@@ -91,7 +91,9 @@ bare, quoted, or backslash-escaped (``<<\\EOF`` quotes the delimiter the way
 ``<<'EOF'`` does). ``<<<`` is a here-string rather than a heredoc, so the
 pattern refuses to read one as an opener and leave the lines below it unread.
 The opener also reports its own ``-``, because ``<<`` closes on a line spelling
-the delimiter exactly while ``<<-`` closes on one carrying leading tabs.
+the delimiter exactly while ``<<-`` closes on one carrying leading tabs. It
+reports the quote and the backslash separately from the delimiter word, because
+either one tells a caller that bash expands nothing inside the body below.
 
 The string-executing shell basenames and command flags start from the shared
 ``unscoped_search_blocker_constants.py`` sets and add the Windows command shell
@@ -167,8 +169,10 @@ __all__ = [
     "HEREDOC_OPENER_PATTERN",
     "HEREDOC_TAB_STRIP_GROUP",
     "HEREDOC_QUOTE_GROUP",
+    "HEREDOC_ESCAPE_GROUP",
     "HEREDOC_TERMINATOR_GROUP",
     "HEREDOC_TAB_STRIP_MARKER",
+    "HEREDOC_UNQUOTED_MARKER",
     "HEREDOC_STRIPPED_INDENT_CHARACTERS",
     "NO_FOLLOWING_OPERATOR",
     "ALL_QUOTE_CHARACTERS",
@@ -340,13 +344,16 @@ CLOSED_GROUP_DEPTH = 0
 _HEREDOC_DELIMITER_CHARACTER_CLASS = r"[^\s'\"<>|&;()`$\\]"
 HEREDOC_TAB_STRIP_GROUP = "heredoc_tab_strip"
 HEREDOC_QUOTE_GROUP = "heredoc_quote"
+HEREDOC_ESCAPE_GROUP = "heredoc_escape"
 HEREDOC_TERMINATOR_GROUP = "heredoc_terminator"
 HEREDOC_OPENER_PATTERN = re.compile(
-    rf"(?<!<)<<(?!<)(?P<{HEREDOC_TAB_STRIP_GROUP}>-?)\s*(?P<{HEREDOC_QUOTE_GROUP}>['\"]?)\\?"
+    rf"(?<!<)<<(?!<)(?P<{HEREDOC_TAB_STRIP_GROUP}>-?)\s*(?P<{HEREDOC_QUOTE_GROUP}>['\"]?)"
+    rf"(?P<{HEREDOC_ESCAPE_GROUP}>\\?)"
     rf"(?P<{HEREDOC_TERMINATOR_GROUP}>{_HEREDOC_DELIMITER_CHARACTER_CLASS}+)"
     rf"(?P={HEREDOC_QUOTE_GROUP})"
 )
 HEREDOC_TAB_STRIP_MARKER = "-"
+HEREDOC_UNQUOTED_MARKER = ""
 HEREDOC_STRIPPED_INDENT_CHARACTERS = "\t"
 NO_FOLLOWING_OPERATOR = ""
 ALL_QUOTE_CHARACTERS = "\"'"

package/hooks/hooks_constants/pr_description_writer_gate_constants.py

@@ -7,6 +7,13 @@ The tracker records one fact per session: the session spawned the
 
 from __future__ import annotations
 
+import tempfile
+from pathlib import Path
+
+from hooks_constants.session_edit_stage_gate_constants import (
+    SESSION_ID_UNSAFE_CHARACTERS_PATTERN,
+)
+
 PR_DESCRIPTION_WRITER_SUBAGENT_TYPE: str = "pr-description-writer"
 
 ALL_AGENT_SPAWN_TOOL_NAMES: frozenset[str] = frozenset({"Agent", "Task"})
@@ -37,3 +44,30 @@ CORRECTIVE_MESSAGE: str = (
     "  2. Append the trailing comment `# pr-description-skip` to the command when "
     "you are writing the body yourself on purpose."
 )
+
+
+def spawn_marker_path(session_id: str, temp_directory: Path | None = None) -> Path | None:
+    """Return this session's marker file path, or None when it names no session.
+
+    The tracker writes this path and the gate reads it, so the file name lives
+    in one place. 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.
+
+    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

package/hooks/hooks_constants/shell_substitution_blocker_constants.py

@@ -25,6 +25,11 @@ __all__ = [
     "PROCESS_SUBSTITUTION_PATTERN",
     "SINGLE_QUOTED_RUN_PATTERN",
     "STRIPPED_RUN_REPLACEMENT",
+    "COMMAND_LINE_SEPARATOR",
+    "BACKSLASH_CHARACTER",
+    "SINGLE_QUOTE_CHARACTER",
+    "DOUBLE_QUOTE_CHARACTER",
+    "NO_TERMINATOR_INDEX",
     "CORRECTIVE_MESSAGE",
 ]
 
@@ -49,6 +54,11 @@ EVEN_BACKSLASH_BACKTICK_PATTERN = re.compile(r"(?<!\\)(?:\\\\)*`")
 PROCESS_SUBSTITUTION_PATTERN = re.compile(r"[<>]\(")
 SINGLE_QUOTED_RUN_PATTERN = re.compile(r"'[^']*'")
 STRIPPED_RUN_REPLACEMENT = ""
+COMMAND_LINE_SEPARATOR = "\n"
+BACKSLASH_CHARACTER = "\\"
+SINGLE_QUOTE_CHARACTER = "'"
+DOUBLE_QUOTE_CHARACTER = '"'
+NO_TERMINATOR_INDEX = -1
 
 CORRECTIVE_MESSAGE = (
     "BLOCKED [shell-substitution]: command contains $(...), backtick, or "

package/hooks/hooks_constants/state_file_lock.py

@@ -0,0 +1,76 @@
+"""Hold a best-effort exclusive lock across one read-modify-write of a state file.
+
+Two hooks can reach the same state file in one turn. The file is written
+through a temporary-plus-replace, so it is never torn; what this closes is
+the separate lost-update race, where one writer reads before the other
+writes and then overwrites it.
+
+::
+
+    with hold_state_file_lock(state_file):
+        all_stored = read(state_file)
+        write(state_file, updated(all_stored))
+
+The lock is best effort. A caller that cannot take it inside the timeout
+proceeds without it rather than stalling the tool call that triggered it.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import sys
+import time
+from collections.abc import Iterator
+from pathlib import Path
+
+_hooks_directory = str(Path(__file__).resolve().parent.parent)
+if _hooks_directory not in sys.path:
+    sys.path.insert(0, _hooks_directory)
+
+from hooks_constants.session_edit_stage_gate_constants import (  # noqa: E402
+    LOCK_ACQUIRE_RETRY_SECONDS,
+    LOCK_ACQUIRE_TIMEOUT_SECONDS,
+    SESSION_EDIT_LOCK_FILE_SUFFIX,
+)
+
+
+def _acquire_lock_descriptor(lock_file: Path) -> int | None:
+    """Grab the exclusive lock, spinning until it frees or the timeout passes.
+
+    Args:
+        lock_file: Path to the lock file beside the state file.
+
+    Returns:
+        An open descriptor for the held lock, or None when it stayed held
+        past the acquire timeout.
+    """
+    lock_acquire_deadline = time.monotonic() + LOCK_ACQUIRE_TIMEOUT_SECONDS
+    while True:
+        try:
+            return os.open(str(lock_file), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+        except FileExistsError:
+            if time.monotonic() >= lock_acquire_deadline:
+                return None
+            time.sleep(LOCK_ACQUIRE_RETRY_SECONDS)
+
+
+@contextlib.contextmanager
+def hold_state_file_lock(state_file: Path) -> Iterator[None]:
+    """Hold the lock beside one state file for the body of the with-block.
+
+    Args:
+        state_file: The state file whose read-modify-write is being guarded.
+
+    Yields:
+        Control to the caller while the lock is held.
+    """
+    lock_file = state_file.with_name(state_file.name + SESSION_EDIT_LOCK_FILE_SUFFIX)
+    lock_file.parent.mkdir(parents=True, exist_ok=True)
+    lock_descriptor = _acquire_lock_descriptor(lock_file)
+    try:
+        yield
+    finally:
+        if lock_descriptor is not None:
+            os.close(lock_descriptor)
+            lock_file.unlink(missing_ok=True)

package/hooks/hooks_constants/subprocess_budget_completeness_content.py

@@ -6,7 +6,7 @@ find a named budget helper that omits a reachable subprocess timeout.
 
 from __future__ import annotations
 
-from hooks_constants.multi_edit_reconstruction import apply_edits
+from hooks_constants.multi_edit_reconstruction import apply_edits, edits_for_tool
 
 __all__ = [
     "existing_file_content",
@@ -35,7 +35,7 @@ def reconstructed_edit_content(all_tool_input_fields: dict[str, object]) -> str:
     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)
+    return apply_edits(existing_content, edits_for_tool("Edit", all_tool_input_fields))
 
 
 def reconstructed_multi_edit_content(

package/hooks/hooks_constants/test_bash_post_call_dispatcher_constants.py

@@ -0,0 +1,27 @@
+"""Behavioral tests for the Bash PostToolUse dispatcher's hosted-hook roster."""
+
+from hooks_constants.bash_post_call_dispatcher_constants import (
+    ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES,
+)
+from hooks_constants.bash_pre_tool_use_dispatcher_constants import BASH_TOOL_NAME
+
+
+def test_roster_names_the_gh_pr_author_restore_hook() -> None:
+    all_script_paths = [
+        each_entry.script_relative_path for each_entry in ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES
+    ]
+    assert "blocking/gh_pr_author_restore.py" in all_script_paths
+
+
+def test_roster_names_the_test_failure_recorder_hook() -> None:
+    all_script_paths = [
+        each_entry.script_relative_path for each_entry in ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES
+    ]
+    assert "observability/test_failure_recorder.py" in all_script_paths
+
+
+def test_every_roster_entry_applies_to_bash() -> None:
+    assert all(
+        BASH_TOOL_NAME in each_entry.applicable_tool_names
+        for each_entry in ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES
+    )

package/hooks/hooks_constants/test_failure_recorder_constants.py

@@ -0,0 +1,35 @@
+"""Constants for the failing-test-run PostToolUse recorder hook.
+
+Holds the cheap substring check the hook runs before any shell parsing, the
+harness's own exit-code error prefix, the chaining and redirection operator
+tokens that keep the recognizer to one unchained command, the pytest program
+and Python interpreter basenames, and the flag-token marker the path
+extractor uses to skip an option rather than an existing test file argument.
+
+``BASH_TOOL_NAME`` lives in ``gh_pr_author_swap_constants`` already; this
+module reuses that name rather than a second literal. The pytest-program and
+interpreter recognition here is deliberately its own small, stdlib-only
+check rather than a reuse of ``piped_pytest_blocker_constants`` /
+``pytest_invocation``: those solve the harder pipe-and-wrapper problem and
+pull in a much larger transitive import for every Bash call regardless of
+content, working against the point of the recognizer's own cheap prefilter.
+"""
+
+from __future__ import annotations
+
+import re
+
+ALL_PYTEST_MENTION_SUBSTRINGS: tuple[str, ...] = ("pytest", "py.test")
+EXIT_CODE_ERROR_PREFIX: str = "Error: Exit code "
+OPTION_TOKEN_PREFIX: str = "-"
+NODE_ID_FILE_PATH_SEPARATOR: str = "::"
+ALL_CHAINING_OPERATOR_SUBSTRINGS: tuple[str, ...] = ("&&", "||", ";", "|", "\n")
+ALL_REDIRECTION_TOKENS: frozenset[str] = frozenset(
+    {">", ">>", "<", "<<", "2>&1", "1>&2", "2>", "1>"}
+)
+ALL_PYTEST_PROGRAM_BASENAMES: frozenset[str] = frozenset({"pytest", "py.test"})
+MODULE_RUN_FLAG: str = "-m"
+PYTEST_MODULE_NAME: str = "pytest"
+PYTHON_INTERPRETER_BASENAME_PATTERN: re.Pattern[str] = re.compile(
+    r"^(?:python|py|pypy)[0-9.]*(?:\.exe)?$"
+)

package/hooks/hooks_constants/test_hosted_hook_runner.py

@@ -7,15 +7,22 @@ and the restoration of the interpreter's stdin, stdout, and argv.
 
 from __future__ import annotations
 
+import io
 import json
 import sys
 from pathlib import Path
 
+import pytest
+
 _HOOKS_DIR = str(Path(__file__).resolve().parent.parent)
 if _HOOKS_DIR not in sys.path:
     sys.path.insert(0, _HOOKS_DIR)
 
-from hooks_constants.hosted_hook_runner import HostedHookRun, run_hook_capturing_output  # noqa: E402
+from hooks_constants.hosted_hook_runner import (  # noqa: E402
+    HostedHookRun,
+    run_dispatcher_main,
+    run_hook_capturing_output,
+)
 
 
 def _write_probe(tmp_path: Path, body: str) -> str:
@@ -99,3 +106,50 @@ def test_returns_a_hosted_hook_run_instance(tmp_path: Path) -> None:
     probe_path = _write_probe(tmp_path, "print('x')\n")
     hook_run = run_hook_capturing_output(probe_path, "{}")
     assert isinstance(hook_run, HostedHookRun)
+
+
+def test_run_dispatcher_main_calls_dispatch_with_payload_text_and_tool_name(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A well-formed payload reaches dispatch with its JSON text and tool_name."""
+    all_calls: list[tuple[str, str]] = []
+    monkeypatch.setattr(
+        sys, "stdin", io.StringIO(json.dumps({"tool_name": "Bash", "tool_input": {}}))
+    )
+
+    with pytest.raises(SystemExit) as raised_exit:
+        run_dispatcher_main(lambda payload_text, tool_name: all_calls.append((payload_text, tool_name)))
+
+    assert int(raised_exit.value.code or 0) == 0
+    assert len(all_calls) == 1
+    recorded_payload_text, recorded_tool_name = all_calls[0]
+    assert recorded_tool_name == "Bash"
+    assert json.loads(recorded_payload_text)["tool_name"] == "Bash"
+
+
+def test_run_dispatcher_main_skips_dispatch_for_malformed_stdin(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Unparseable stdin exits zero and never calls dispatch."""
+    all_calls: list[tuple[str, str]] = []
+    monkeypatch.setattr(sys, "stdin", io.StringIO("not json"))
+
+    with pytest.raises(SystemExit) as raised_exit:
+        run_dispatcher_main(lambda payload_text, tool_name: all_calls.append((payload_text, tool_name)))
+
+    assert int(raised_exit.value.code or 0) == 0
+    assert all_calls == []
+
+
+def test_run_dispatcher_main_skips_dispatch_when_tool_name_is_missing(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A payload with no tool_name exits zero and never calls dispatch."""
+    all_calls: list[tuple[str, str]] = []
+    monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps({"tool_input": {}})))
+
+    with pytest.raises(SystemExit) as raised_exit:
+        run_dispatcher_main(lambda payload_text, tool_name: all_calls.append((payload_text, tool_name)))
+
+    assert int(raised_exit.value.code or 0) == 0
+    assert all_calls == []

package/hooks/hooks_constants/test_multi_edit_reconstruction.py

@@ -69,6 +69,7 @@ def test_apply_edits_mixes_replace_all_and_single_edits_in_one_list() -> None:
     ]
     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 = {

package/hooks/hooks_constants/test_subprocess_budget_completeness_content.py

@@ -68,3 +68,36 @@ def test_resolved_content_returns_empty_for_an_unreadable_edit_target(
         resolved_content({"file_path": str(missing_target), "old_string": "a", "new_string": "b"})
         == ""
     )
+
+
+def test_reconstructed_edit_content_replaces_every_occurrence_when_replace_all_is_set(
+    tmp_path: pathlib.Path,
+) -> None:
+    """An Edit carrying replace_all rewrites every occurrence, as the tool does.
+
+    The MultiEdit branch has honored the flag since it moved onto apply_edits;
+    the Edit branch must agree, or one payload reconstructs two ways.
+    """
+    target_file = tmp_path / "module.py"
+    target_file.write_text("a = 1\na = 1\n", encoding="utf-8")
+    reconstructed = reconstructed_edit_content(
+        {
+            "file_path": str(target_file),
+            "old_string": "a = 1",
+            "new_string": "a = 2",
+            "replace_all": True,
+        }
+    )
+    assert reconstructed == "a = 2\na = 2\n"
+
+
+def test_reconstructed_edit_content_replaces_one_occurrence_without_replace_all(
+    tmp_path: pathlib.Path,
+) -> None:
+    """Without the flag, only the first occurrence changes."""
+    target_file = tmp_path / "module.py"
+    target_file.write_text("a = 1\na = 1\n", encoding="utf-8")
+    reconstructed = reconstructed_edit_content(
+        {"file_path": str(target_file), "old_string": "a = 1", "new_string": "a = 2"}
+    )
+    assert reconstructed == "a = 2\na = 1\n"

package/hooks/observability/pr_description_writer_spawn_tracker.py

@@ -23,7 +23,6 @@ touch each returns quietly.
 from __future__ import annotations
 
 import sys
-import tempfile
 from pathlib import Path
 
 _hooks_dir = str(Path(__file__).resolve().parent.parent)
@@ -33,18 +32,16 @@ if _hooks_dir not in sys.path:
 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.pr_description_writer_gate_constants import (  # noqa: E402
+    spawn_marker_path as shared_spawn_marker_path,
+)
 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:
@@ -70,12 +67,7 @@ def spawn_marker_path(session_id: str, temp_directory: Path | None = None) -> Pa
         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
+    return shared_spawn_marker_path(session_id, temp_directory)
 
 
 def _record_spawn(session_id: str) -> None:

package/hooks/observability/session_file_edit_tracker.py

@@ -18,13 +18,10 @@ never interrupts the edit that triggered it.
 
 from __future__ import annotations
 
-import contextlib
 import json
 import os
 import sys
 import tempfile
-import time
-from collections.abc import Iterator
 from pathlib import Path
 
 _hooks_dir = str(Path(__file__).resolve().parent.parent)
@@ -35,15 +32,13 @@ 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.state_file_lock import hold_state_file_lock  # noqa: E402
 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,
     SESSION_EDIT_FILE_SUFFIX,
-    SESSION_EDIT_LOCK_FILE_SUFFIX,
     SESSION_ID_UNSAFE_CHARACTERS_PATTERN,
     STATE_FILE_ATOMIC_WRITE_SUFFIX,
     STATE_FILE_DEFAULT_SESSION_ID,
@@ -140,54 +135,6 @@ def _atomic_write_edit_file(edit_file: Path, all_edited_file_paths: list[str]) -
         raise
 
 
-def _acquire_edit_file_lock(lock_file: Path) -> int | None:
-    """Grab an exclusive per-session lock, spinning until it frees or times out.
-
-    Args:
-        lock_file: Path to this session's lock file.
-
-    Returns:
-        An open file descriptor for the held lock, or None when the lock stayed
-        held past the acquire timeout so the caller proceeds without it rather
-        than stalling the edit that triggered the hook.
-    """
-    lock_acquire_deadline = time.monotonic() + LOCK_ACQUIRE_TIMEOUT_SECONDS
-    while True:
-        try:
-            return os.open(str(lock_file), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
-        except FileExistsError:
-            if time.monotonic() >= lock_acquire_deadline:
-                return None
-            time.sleep(LOCK_ACQUIRE_RETRY_SECONDS)
-
-
-@contextlib.contextmanager
-def _hold_edit_file_lock(edit_file: Path) -> Iterator[None]:
-    """Hold the per-session lock across one read-modify-write of the tracker.
-
-    Two PostToolUse invocations run concurrently when Claude issues parallel
-    Write or Edit calls in one turn. Serializing the read-then-write on a shared
-    lock file keeps each invocation's appended path from overwriting another's.
-    The lock is best-effort: when it cannot be acquired within the timeout, the
-    write proceeds without it rather than stalling the edit.
-
-    Args:
-        edit_file: This session's tracker file path.
-
-    Yields:
-        Control to the caller while the lock is held.
-    """
-    lock_file = edit_file.with_name(edit_file.name + SESSION_EDIT_LOCK_FILE_SUFFIX)
-    lock_file.parent.mkdir(parents=True, exist_ok=True)
-    lock_descriptor = _acquire_edit_file_lock(lock_file)
-    try:
-        yield
-    finally:
-        if lock_descriptor is not None:
-            os.close(lock_descriptor)
-            lock_file.unlink(missing_ok=True)
-
-
 def _record_edited_path(session_id: str, resolved_file_path: str) -> None:
     """Append one edited path to this session's tracker file when it is new.
 
@@ -200,7 +147,7 @@ def _record_edited_path(session_id: str, resolved_file_path: str) -> None:
         resolved_file_path: The resolved absolute path of the edited file.
     """
     edit_file = _session_edit_file_path(session_id)
-    with _hold_edit_file_lock(edit_file):
+    with hold_state_file_lock(edit_file):
         recorded_paths = _read_recorded_paths(edit_file)
         if resolved_file_path in recorded_paths:
             return