claude-dev-env 2.30.1 → 2.31.1

package/hooks/hooks_constants/test_multi_edit_reconstruction.py

@@ -0,0 +1,103 @@
+"""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"
+        )

package/hooks/hooks_constants/test_subprocess_budget_completeness_content.py

@@ -0,0 +1,103 @@
+"""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"})
+        == ""
+    )
+
+
+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/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,113 @@
+#!/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
+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,
+    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,
+)
+
+
+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.
+    """
+    return shared_spawn_marker_path(session_id, temp_directory)
+
+
+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)