claude-dev-env 8.98.8 → 8.98.10

package/hooks/blocking/test_open_tasks_transcript.py

@@ -1,7 +1,19 @@
 import json
 from pathlib import Path
 
-from open_tasks_transcript import TaskItem, parsed_object, replayed_transcript, unwrapped_tool_call
+import pytest
+
+from open_tasks_transcript import (
+    TaskItem,
+    claude_prompt_text,
+    codex_prompt_text,
+    is_assistant_record,
+    is_codex_work_call,
+    is_work_tool_name,
+    parsed_object,
+    replayed_transcript,
+    unwrapped_tool_call,
+)
 
 
 def write_transcript(transcript_path: Path, all_records: list[dict[str, object]]) -> Path:
@@ -26,7 +38,7 @@ def test_should_unwrap_a_call_dynamic_tool_todo_write_call() -> None:
     assert unwrapped_tool_call("CallDynamicTool", {"toolName": "TodoWrite"}) == ("CallDynamicTool", {"toolName": "TodoWrite"})
 
 
-def test_should_replay_cursor_dynamic_todo_writes_and_the_last_reply(tmp_path: Path) -> None:
+def test_should_replay_cursor_dynamic_todo_writes_as_tracker_calls(tmp_path: Path) -> None:
     all_first_todos = [
         {"id": "1", "content": "write hello.txt", "status": "in_progress"},
         {"id": "2", "content": "rotate the deploy key", "status": "pending"},
@@ -45,7 +57,103 @@ def test_should_replay_cursor_dynamic_todo_writes_and_the_last_reply(tmp_path: P
         TaskItem("1", "write hello.txt", "completed"),
         TaskItem("2", "rotate the deploy key", "pending"),
     ]
-    assert replay.last_assistant_text == "Done."
+    assert replay.has_turn_tracker_write is True
+    assert replay.has_turn_work_tool is False
+
+
+def test_should_start_a_new_turn_at_each_prompt_and_reset_its_flags(tmp_path: Path) -> None:
+    bash_call = {"type": "tool_use", "id": "b1", "name": "Bash", "input": {"command": "ls"}}
+    transcript_path = write_transcript(
+        tmp_path / "claude.jsonl",
+        [
+            {"type": "user", "message": {"role": "user", "content": "Write the gate"}},
+            dynamic_todo_record([{"id": "1", "content": "Write the gate", "status": "in_progress"}], False),
+            {"type": "user", "message": {"role": "user", "content": "Export the APKs"}},
+            {"type": "assistant", "message": {"content": [bash_call]}},
+        ],
+    )
+    replay = replayed_transcript(str(transcript_path))
+    assert replay.turn_prompt_text == "Export the APKs"
+    assert replay.has_turn_work_tool is True
+    assert replay.has_turn_tracker_write is False
+
+
+def test_should_not_count_a_question_card_lookup_or_title_call_as_work(tmp_path: Path) -> None:
+    all_non_work_calls = [
+        {"type": "tool_use", "id": f"n{each_index}", "name": each_name, "input": {}}
+        for each_index, each_name in enumerate(
+            ["AskUserQuestion", "ToolSearch", "TaskList", "TaskGet", "mcp__claude-code-remote__set_session_title"]
+        )
+    ]
+    transcript_path = write_transcript(
+        tmp_path / "claude.jsonl",
+        [
+            {"type": "user", "message": {"role": "user", "content": "Export the APKs"}},
+            {"type": "assistant", "message": {"content": all_non_work_calls}},
+        ],
+    )
+    replay = replayed_transcript(str(transcript_path))
+    assert replay.has_turn_work_tool is False
+    assert replay.has_turn_tracker_write is False
+
+
+@pytest.mark.parametrize(
+    ("record", "expected_text"),
+    [
+        ({"type": "user", "message": {"role": "user", "content": "Export the APKs"}}, "Export the APKs"),
+        ({"type": "user", "message": {"content": [{"type": "text", "text": "Fix it"}]}}, "Fix it"),
+        ({"type": "user", "message": {"content": [{"type": "tool_result", "tool_use_id": "b1"}]}}, None),
+        ({"type": "user", "isMeta": True, "message": {"content": "Stop hook feedback: hold"}}, None),
+        ({"type": "user", "message": {"content": "Stop hook feedback:\nhold"}}, None),
+        ({"type": "assistant", "message": {"content": "Done."}}, None),
+    ],
+)
+def test_should_read_prompt_text_only_from_a_record_that_starts_a_turn(
+    record: dict[str, object], expected_text: str | None
+) -> None:
+    assert claude_prompt_text(record) == expected_text
+
+
+def test_should_read_codex_user_message_text() -> None:
+    user_message = {
+        "type": "response_item",
+        "payload": {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "Ship it"}]},
+    }
+    assistant_message = {"type": "response_item", "payload": {"type": "message", "role": "assistant", "content": "ok"}}
+    assert codex_prompt_text(user_message) == "Ship it"
+    assert codex_prompt_text(assistant_message) is None
+
+
+def test_should_count_codex_tool_calls_other_than_the_plan_as_work() -> None:
+    def codex_call(call_type: str, tool_name: str) -> dict[str, object]:
+        return {"type": "response_item", "payload": {"type": call_type, "name": tool_name}}
+
+    assert is_codex_work_call(codex_call("function_call", "shell")) is True
+    assert is_codex_work_call(codex_call("local_shell_call", "")) is True
+    assert is_codex_work_call(codex_call("function_call", "update_plan")) is False
+    assert is_codex_work_call(codex_call("function_call", "request_user_input")) is False
+    assert is_codex_work_call(codex_call("function_call", "request_user_input_async")) is False
+    assert is_codex_work_call({"type": "user", "payload": {"type": "function_call"}}) is False
+
+
+def test_should_not_count_a_codex_title_call_as_work() -> None:
+    title_call = {"type": "response_item", "payload": {"type": "function_call", "name": "mcp__session__set_session_title"}}
+    assert is_codex_work_call(title_call) is False
+
+
+def test_should_treat_question_cards_and_the_title_tool_as_non_work() -> None:
+    assert is_work_tool_name("Bash") is True
+    assert is_work_tool_name(None) is True
+    assert is_work_tool_name("mcp__hearthbot__ask_decision") is False
+    assert is_work_tool_name("mcp__hearthbot__request_decision") is False
+    assert is_work_tool_name("mcp__ccd_session__set_session_title") is False
+
+
+def test_should_recognize_an_assistant_record_by_type_role_or_message_role() -> None:
+    assert is_assistant_record({"type": "assistant"}) is True
+    assert is_assistant_record({"role": "assistant"}) is True
+    assert is_assistant_record({"message": {"role": "assistant"}}) is True
+    assert is_assistant_record({"type": "user", "message": {"role": "user"}}) is False
 
 
 def test_should_parse_only_json_objects() -> None:
@@ -59,9 +167,9 @@ def ccd_plan_record(all_plan_input: dict[str, object], record_type: str = "assis
     return {"type": record_type, "timestamp": "2026-01-01T00:00:00.000Z", "message": {"content": [tool_use]}}
 
 
-def plan_statuses(transcript_path: Path) -> list[tuple[str, str, bool]]:
+def plan_statuses(transcript_path: Path) -> list[tuple[str, str]]:
     all_items = replayed_transcript(str(transcript_path)).items() or []
-    return [(each_item.subject, each_item.status, each_item.is_carried) for each_item in all_items]
+    return [(each_item.subject, each_item.status) for each_item in all_items]
 
 
 def test_should_replay_ccd_turn_advance_once_and_skip_request_blob_copies(tmp_path: Path) -> None:
@@ -79,9 +187,9 @@ def test_should_replay_ccd_turn_advance_once_and_skip_request_blob_copies(tmp_pa
         ],
     )
     assert plan_statuses(transcript_path) == [
-        ("Read the gate", "completed", False),
-        ("Write the tests", "in_progress", False),
-        ("Open the PR", "pending", False),
+        ("Read the gate", "completed"),
+        ("Write the tests", "in_progress"),
+        ("Open the PR", "pending"),
     ]
 
 
@@ -99,9 +207,9 @@ def test_should_carry_unfinished_items_after_the_replacing_list(tmp_path: Path)
         ],
     )
     assert plan_statuses(transcript_path) == [
-        ("Set rows in Neon", "in_progress", False),
-        ("Export the OneUI8 APK", "in_progress", True),
-        ("Submit both APKs", "pending", True),
+        ("Set rows in Neon", "in_progress"),
+        ("Export the OneUI8 APK", "in_progress"),
+        ("Submit both APKs", "pending"),
     ]
 
 
@@ -120,9 +228,9 @@ def test_should_point_done_and_start_indices_at_the_tools_own_items(tmp_path: Pa
         ],
     )
     assert plan_statuses(transcript_path) == [
-        ("Beta", "completed", False),
-        ("Gamma", "in_progress", False),
-        ("Alpha", "pending", True),
+        ("Beta", "completed"),
+        ("Gamma", "in_progress"),
+        ("Alpha", "pending"),
     ]
 
 
@@ -140,4 +248,4 @@ def test_should_let_a_later_list_close_a_carried_item_by_subject(tmp_path: Path)
             ),
         ],
     )
-    assert plan_statuses(transcript_path) == [("Beta", "completed", False), ("alpha", "completed", False)]
+    assert plan_statuses(transcript_path) == [("Beta", "completed"), ("alpha", "completed")]

package/hooks/blocking/test_resolve_thread_reply_gate.py

@@ -16,6 +16,11 @@ from transcript_skill_scan import TranscriptToolCall
 GATE_PATH = Path(__file__).resolve().parent / "resolve_thread_reply_gate.py"
 RESOLVE_TOOL_NAME = "mcp__github__resolve_review_thread"
 REPLY_TOOL_NAME = "mcp__github__add_reply_to_pull_request_comment"
+READ_TOOL_NAME = "mcp__github__pull_request_read"
+FIRST_THREAD_ID = "PRRT_kwDOfirst"
+SECOND_THREAD_ID = "PRRT_kwDOsecond"
+FIRST_COMMENT_ID = 350000001
+SECOND_COMMENT_ID = 350000005
 HOOK_DENIAL_TEXT = "PreToolUse:mcp__github__add_reply_to_pull_request_comment hook error: too many sentences"
 
 
@@ -33,17 +38,60 @@ def _result(tool_use_id: str, is_error: bool = False, text: str = "ok") -> str:
     return json.dumps({"type": "user", "message": {"content": [tool_result]}})
 
 
+def _threads_read(tool_use_id: str = "read-1") -> list[str]:
+    all_threads = [
+        {
+            "id": each_thread_id,
+            "is_resolved": False,
+            "comments": [
+                {"path": "a.py", "html_url": f"https://github.com/o/r/pull/7#discussion_r{each_comment_id}"},
+                {"path": "a.py", "html_url": f"https://github.com/o/r/pull/7#discussion_r{each_comment_id + 1}"},
+            ],
+        }
+        for each_thread_id, each_comment_id in ((FIRST_THREAD_ID, FIRST_COMMENT_ID), (SECOND_THREAD_ID, SECOND_COMMENT_ID))
+    ]
+    return [
+        _call(tool_use_id, READ_TOOL_NAME, {"method": "get_review_comments", "pullNumber": 7}),
+        _result(tool_use_id, text=json.dumps({"review_threads": all_threads, "totalCount": 2})),
+    ]
+
+
+def _reply(tool_use_id: str, comment_id: int = FIRST_COMMENT_ID) -> str:
+    return _call(tool_use_id, REPLY_TOOL_NAME, {"commentId": comment_id, "body": "Fixed in `abc1234`."})
+
+
+def _resolve(tool_use_id: str, thread_id: str = FIRST_THREAD_ID) -> str:
+    return _call(tool_use_id, RESOLVE_TOOL_NAME, {"threadID": thread_id})
+
+
+def _shell_resolve_command(thread_id: str = FIRST_THREAD_ID) -> str:
+    return (
+        "gh api graphql -f query='mutation { resolveReviewThread(input: {threadId: \""
+        + thread_id
+        + "\"}) { thread { isResolved } } }'"
+    )
+
+
 def _write_transcript(tmp_path: Path, all_lines: list[str]) -> Path:
     transcript_path = tmp_path / "session.jsonl"
     transcript_path.write_text("\n".join(all_lines) + "\n", encoding="utf-8")
     return transcript_path
 
 
-def _resolve_payload(transcript_path: Path) -> dict[str, object]:
+def _resolve_payload(transcript_path: Path, thread_id: str = FIRST_THREAD_ID) -> dict[str, object]:
     return {
         "hook_event_name": "PreToolUse",
         "tool_name": RESOLVE_TOOL_NAME,
-        "tool_input": {"threadId": "PRRT_1"},
+        "tool_input": {"threadID": thread_id},
+        "transcript_path": str(transcript_path),
+    }
+
+
+def _shell_resolve_payload(transcript_path: Path, command: str) -> dict[str, object]:
+    return {
+        "hook_event_name": "PreToolUse",
+        "tool_name": "Bash",
+        "tool_input": {"command": command},
         "transcript_path": str(transcript_path),
     }
 
@@ -62,9 +110,10 @@ def should_allow_a_resolve_after_a_reply_that_posted(tmp_path: Path) -> None:
         tmp_path,
         [
             _prompt("Address the review threads."),
-            _call("reply-1", REPLY_TOOL_NAME, {"body": "Fixed in `abc1234`."}),
+            *_threads_read(),
+            _reply("reply-1"),
             _result("reply-1"),
-            _call("resolve-1", RESOLVE_TOOL_NAME),
+            _resolve("resolve-1"),
         ],
     )
     assert gate.decision_for(_resolve_payload(transcript_path)) is None
@@ -75,9 +124,10 @@ def should_deny_a_resolve_after_a_reply_a_hook_refused(tmp_path: Path) -> None:
         tmp_path,
         [
             _prompt("Address the review threads."),
-            _call("reply-1", REPLY_TOOL_NAME, {"body": "A long reply."}),
+            *_threads_read(),
+            _reply("reply-1"),
             _result("reply-1", is_error=True, text=HOOK_DENIAL_TEXT),
-            _call("resolve-1", RESOLVE_TOOL_NAME),
+            _resolve("resolve-1"),
         ],
     )
     assert _deny_reason(gate.decision_for(_resolve_payload(transcript_path))) == MISSING_REPLY_REASON
@@ -86,7 +136,7 @@ def should_deny_a_resolve_after_a_reply_a_hook_refused(tmp_path: Path) -> None:
 def should_deny_a_resolve_with_no_reply(tmp_path: Path) -> None:
     transcript_path = _write_transcript(
         tmp_path,
-        [_prompt("Address the review threads."), _call("resolve-1", RESOLVE_TOOL_NAME)],
+        [_prompt("Address the review threads."), *_threads_read(), _resolve("resolve-1")],
     )
     assert _deny_reason(gate.decision_for(_resolve_payload(transcript_path))) == MISSING_REPLY_REASON
 
@@ -96,42 +146,243 @@ def should_deny_a_second_resolve_after_one_reply(tmp_path: Path) -> None:
         tmp_path,
         [
             _prompt("Address the review threads."),
-            _call("reply-1", REPLY_TOOL_NAME, {"body": "Fixed in `abc1234`."}),
+            *_threads_read(),
+            _reply("reply-1"),
             _result("reply-1"),
-            _call("resolve-1", RESOLVE_TOOL_NAME),
+            _resolve("resolve-1"),
             _result("resolve-1"),
-            _call("resolve-2", RESOLVE_TOOL_NAME),
+            _resolve("resolve-2"),
         ],
     )
     assert _deny_reason(gate.decision_for(_resolve_payload(transcript_path))) == MISSING_REPLY_REASON
 
 
-def should_allow_a_second_resolve_after_two_replies(tmp_path: Path) -> None:
+def should_allow_a_second_resolve_after_a_reply_on_each_thread(tmp_path: Path) -> None:
     transcript_path = _write_transcript(
         tmp_path,
         [
             _prompt("Address the review threads."),
-            _call("reply-1", REPLY_TOOL_NAME, {"body": "Fixed in `abc1234`."}),
+            *_threads_read(),
+            _reply("reply-1"),
             _result("reply-1"),
-            _call("reply-2", REPLY_TOOL_NAME, {"body": "Fixed in `def5678`."}),
+            _reply("reply-2", SECOND_COMMENT_ID),
             _result("reply-2"),
-            _call("resolve-1", RESOLVE_TOOL_NAME),
+            _resolve("resolve-1"),
             _result("resolve-1"),
-            _call("resolve-2", RESOLVE_TOOL_NAME),
+            _resolve("resolve-2", SECOND_THREAD_ID),
+        ],
+    )
+    assert gate.decision_for(_resolve_payload(transcript_path, SECOND_THREAD_ID)) is None
+
+
+def should_deny_a_resolve_on_a_thread_the_reply_did_not_answer(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [
+            _prompt("Address the review threads."),
+            *_threads_read(),
+            _reply("reply-1"),
+            _result("reply-1"),
+            _resolve("resolve-1", SECOND_THREAD_ID),
+        ],
+    )
+    decision = gate.decision_for(_resolve_payload(transcript_path, SECOND_THREAD_ID))
+    assert _deny_reason(decision) == MISSING_REPLY_REASON
+
+
+def should_deny_a_second_resolve_of_one_thread_after_replies_on_two_threads(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [
+            _prompt("Address the review threads."),
+            *_threads_read(),
+            _reply("reply-1"),
+            _result("reply-1"),
+            _reply("reply-2", SECOND_COMMENT_ID),
+            _result("reply-2"),
+            _resolve("resolve-1"),
+            _result("resolve-1"),
+            _resolve("resolve-2"),
+        ],
+    )
+    assert _deny_reason(gate.decision_for(_resolve_payload(transcript_path))) == MISSING_REPLY_REASON
+
+
+def should_match_a_reply_on_a_later_comment_in_the_thread(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [
+            _prompt("Address the review threads."),
+            *_threads_read(),
+            _reply("reply-1", SECOND_COMMENT_ID + 1),
+            _result("reply-1"),
+            _resolve("resolve-1", SECOND_THREAD_ID),
+        ],
+    )
+    assert gate.decision_for(_resolve_payload(transcript_path, SECOND_THREAD_ID)) is None
+
+
+def should_read_the_thread_map_from_before_the_last_prompt(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [
+            _prompt("List the review threads."),
+            *_threads_read(),
+            _prompt("Reply and resolve."),
+            _reply("reply-1"),
+            _result("reply-1"),
+            _resolve("resolve-1"),
         ],
     )
     assert gate.decision_for(_resolve_payload(transcript_path)) is None
 
 
+def should_deny_a_resolve_when_no_read_ties_the_reply_to_the_thread(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [
+            _prompt("Address the review threads."),
+            _reply("reply-1"),
+            _result("reply-1"),
+            _resolve("resolve-1"),
+        ],
+    )
+    assert _deny_reason(gate.decision_for(_resolve_payload(transcript_path))) == MISSING_REPLY_REASON
+
+
+def should_allow_a_resolve_after_a_graphql_reply_on_the_thread(tmp_path: Path) -> None:
+    reply_command = (
+        "gh api graphql -f query='mutation { addPullRequestReviewThreadReply(input: "
+        f'{{pullRequestReviewThreadId: "{FIRST_THREAD_ID}", body: "Fixed."}}) {{ comment {{ id }} }} }}\''
+    )
+    transcript_path = _write_transcript(
+        tmp_path,
+        [
+            _prompt("Address the review threads."),
+            _call("reply-1", "Bash", {"command": reply_command}),
+            _result("reply-1"),
+            _resolve("resolve-1"),
+        ],
+    )
+    assert gate.decision_for(_resolve_payload(transcript_path)) is None
+
+
+def should_deny_a_shell_resolve_with_no_reply(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(tmp_path, [_prompt("Address the review threads."), *_threads_read()])
+    decision = gate.decision_for(_shell_resolve_payload(transcript_path, _shell_resolve_command()))
+    assert _deny_reason(decision) == MISSING_REPLY_REASON
+
+
+def should_allow_a_shell_resolve_after_a_rest_reply_on_the_thread(tmp_path: Path) -> None:
+    reply_command = f"gh api repos/o/r/pulls/7/comments/{FIRST_COMMENT_ID}/replies -f body=Fixed."
+    transcript_path = _write_transcript(
+        tmp_path,
+        [
+            _prompt("Address the review threads."),
+            *_threads_read(),
+            _call("reply-1", "Bash", {"command": reply_command}),
+            _result("reply-1"),
+        ],
+    )
+    assert gate.decision_for(_shell_resolve_payload(transcript_path, _shell_resolve_command())) is None
+
+
+def should_deny_a_shell_resolve_on_a_thread_the_reply_did_not_answer(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [_prompt("Address the review threads."), *_threads_read(), _reply("reply-1"), _result("reply-1")],
+    )
+    decision = gate.decision_for(_shell_resolve_payload(transcript_path, _shell_resolve_command(SECOND_THREAD_ID)))
+    assert _deny_reason(decision) == MISSING_REPLY_REASON
+
+
+def should_deny_a_shell_resolve_that_names_no_thread_id(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [_prompt("Address the review threads."), *_threads_read(), _reply("reply-1"), _result("reply-1")],
+    )
+    command = "gh api graphql -f threadId=\"$thread\" -f query='mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }'"
+    assert _deny_reason(gate.decision_for(_shell_resolve_payload(transcript_path, command))) == MISSING_REPLY_REASON
+
+
+def should_spend_the_reply_on_a_shell_resolve(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [
+            _prompt("Address the review threads."),
+            *_threads_read(),
+            _reply("reply-1"),
+            _result("reply-1"),
+            _call("resolve-1", "Bash", {"command": _shell_resolve_command()}),
+            _result("resolve-1"),
+            _resolve("resolve-2"),
+        ],
+    )
+    assert _deny_reason(gate.decision_for(_resolve_payload(transcript_path))) == MISSING_REPLY_REASON
+
+
+def _ccr_resolve_command(comment_id: int = FIRST_COMMENT_ID) -> str:
+    return f"gh api -X POST repos/o/r/pulls/7/ccr/comments/{comment_id}/resolve"
+
+
+def should_deny_a_ccr_resolve_with_no_reply(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(tmp_path, [_prompt("Address the review threads.")])
+    decision = gate.decision_for(_shell_resolve_payload(transcript_path, _ccr_resolve_command()))
+    assert _deny_reason(decision) == MISSING_REPLY_REASON
+
+
+def should_allow_a_ccr_resolve_of_the_comment_the_reply_answered(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [_prompt("Address the review threads."), _reply("reply-1"), _result("reply-1")],
+    )
+    assert gate.decision_for(_shell_resolve_payload(transcript_path, _ccr_resolve_command())) is None
+
+
+def should_deny_a_ccr_resolve_of_a_comment_in_another_thread(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [_prompt("Address the review threads."), *_threads_read(), _reply("reply-1"), _result("reply-1")],
+    )
+    decision = gate.decision_for(_shell_resolve_payload(transcript_path, _ccr_resolve_command(SECOND_COMMENT_ID)))
+    assert _deny_reason(decision) == MISSING_REPLY_REASON
+
+
+def should_spend_the_reply_on_a_ccr_resolve_of_the_same_thread(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [
+            _prompt("Address the review threads."),
+            *_threads_read(),
+            _reply("reply-1"),
+            _result("reply-1"),
+            _call("resolve-1", "Bash", {"command": _ccr_resolve_command(FIRST_COMMENT_ID + 1)}),
+            _result("resolve-1"),
+            _resolve("resolve-2"),
+        ],
+    )
+    assert _deny_reason(gate.decision_for(_resolve_payload(transcript_path))) == MISSING_REPLY_REASON
+
+
+def should_ignore_shell_commands_other_than_a_resolve(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(tmp_path, [_prompt("Address the review threads.")])
+    assert gate.decision_for(_shell_resolve_payload(transcript_path, "gh pr view 7")) is None
+    unresolve_command = _shell_resolve_command().replace("resolveReviewThread", "unresolveReviewThread")
+    assert gate.decision_for(_shell_resolve_payload(transcript_path, unresolve_command)) is None
+    ccr_unresolve_command = _ccr_resolve_command().replace("/resolve", "/unresolve")
+    assert gate.decision_for(_shell_resolve_payload(transcript_path, ccr_unresolve_command)) is None
+
+
 def should_deny_a_resolve_whose_reply_came_before_the_last_prompt(tmp_path: Path) -> None:
     transcript_path = _write_transcript(
         tmp_path,
         [
             _prompt("Reply on the thread."),
-            _call("reply-1", REPLY_TOOL_NAME, {"body": "Fixed in `abc1234`."}),
+            *_threads_read(),
+            _reply("reply-1"),
             _result("reply-1"),
-            _prompt("Now resolve the other thread."),
-            _call("resolve-1", RESOLVE_TOOL_NAME),
+            _prompt("Now resolve the thread."),
+            _resolve("resolve-1"),
         ],
     )
     assert _deny_reason(gate.decision_for(_resolve_payload(transcript_path))) == MISSING_REPLY_REASON
@@ -142,11 +393,12 @@ def should_allow_a_retry_after_a_resolve_error(tmp_path: Path) -> None:
         tmp_path,
         [
             _prompt("Address the review threads."),
-            _call("reply-1", REPLY_TOOL_NAME, {"body": "Fixed in `abc1234`."}),
+            *_threads_read(),
+            _reply("reply-1"),
             _result("reply-1"),
-            _call("resolve-1", RESOLVE_TOOL_NAME),
+            _resolve("resolve-1"),
             _result("resolve-1", is_error=True, text="Bad gateway"),
-            _call("resolve-2", RESOLVE_TOOL_NAME),
+            _resolve("resolve-2"),
         ],
     )
     assert gate.decision_for(_resolve_payload(transcript_path)) is None
@@ -177,16 +429,52 @@ def should_count_a_gh_api_reply_command_as_a_reply() -> None:
     assert not gate.is_reply_call(TranscriptToolCall("mcp__github__add_issue_comment", {}, True))
 
 
+def should_name_the_threads_a_call_resolves() -> None:
+    assert gate.resolved_thread_ids(RESOLVE_TOOL_NAME, {"threadID": FIRST_THREAD_ID}) == {FIRST_THREAD_ID}
+    assert gate.resolved_thread_ids(RESOLVE_TOOL_NAME, {"threadId": FIRST_THREAD_ID}) == {FIRST_THREAD_ID}
+    assert gate.resolved_thread_ids("Bash", {"command": _shell_resolve_command()}) == {FIRST_THREAD_ID}
+    assert gate.resolved_thread_ids("PowerShell", {"command": _shell_resolve_command()}) == {FIRST_THREAD_ID}
+    assert gate.resolved_thread_ids("Bash", {"command": _ccr_resolve_command()}) == {str(FIRST_COMMENT_ID)}
+    assert gate.resolved_thread_ids("Bash", {"command": "gh pr view 7"}) is None
+    assert gate.resolved_thread_ids(REPLY_TOOL_NAME, {"commentId": FIRST_COMMENT_ID}) is None
+
+
+def should_map_comment_ids_to_threads_from_tool_results() -> None:
+    graphql_text = json.dumps(
+        {"nodes": [{"id": SECOND_THREAD_ID, "comments": {"nodes": [{"databaseId": SECOND_COMMENT_ID}]}}]}
+    )
+    graphql_result = json.dumps(
+        {
+            "type": "user",
+            "message": {
+                "content": [
+                    {"type": "tool_result", "tool_use_id": "read-2", "content": [{"type": "text", "text": graphql_text}]}
+                ]
+            },
+        }
+    )
+    refused_text = json.dumps({"id": SECOND_THREAD_ID, "html_url": "x#discussion_r1"})
+    thread_id_by_comment_id = gate.thread_ids_by_comment_id(
+        [*_threads_read(), graphql_result, _result("read-3", is_error=True, text=refused_text), "not json"]
+    )
+    assert thread_id_by_comment_id[str(FIRST_COMMENT_ID)] == FIRST_THREAD_ID
+    assert thread_id_by_comment_id[str(FIRST_COMMENT_ID + 1)] == FIRST_THREAD_ID
+    assert thread_id_by_comment_id[str(SECOND_COMMENT_ID)] == SECOND_THREAD_ID
+    assert "1" not in thread_id_by_comment_id
+
+
 def should_report_a_posted_reply_from_transcript_lines() -> None:
-    all_lines = [_prompt("Go."), _call("reply-1", REPLY_TOOL_NAME), _result("reply-1")]
-    assert gate.has_posted_reply_since_last_resolve(all_lines)
-    assert not gate.has_posted_reply_since_last_resolve(all_lines[:2])
+    all_lines = [_prompt("Go."), *_threads_read(), _reply("reply-1"), _result("reply-1")]
+    assert gate.has_posted_reply_on_threads(all_lines, frozenset({FIRST_THREAD_ID}))
+    assert not gate.has_posted_reply_on_threads(all_lines, frozenset({SECOND_THREAD_ID}))
+    assert not gate.has_posted_reply_on_threads(all_lines[:-1], frozenset({FIRST_THREAD_ID}))
+    assert not gate.has_posted_reply_on_threads(all_lines, frozenset())
 
 
 def should_print_the_deny_when_run_as_a_hook(tmp_path: Path) -> None:
     transcript_path = _write_transcript(
         tmp_path,
-        [_prompt("Address the review threads."), _call("resolve-1", RESOLVE_TOOL_NAME)],
+        [_prompt("Address the review threads."), _resolve("resolve-1")],
     )
     completed_process = subprocess.run(
         [sys.executable, str(GATE_PATH)],
@@ -197,3 +485,31 @@ def should_print_the_deny_when_run_as_a_hook(tmp_path: Path) -> None:
     )
     assert completed_process.returncode == 0
     assert _deny_reason(json.loads(completed_process.stdout)) == MISSING_REPLY_REASON
+
+
+def _review_write_payload(transcript_path: Path, method: str, thread_id: str = FIRST_THREAD_ID) -> dict[str, object]:
+    return {
+        "hook_event_name": "PreToolUse",
+        "tool_name": "mcp__github__pull_request_review_write",
+        "tool_input": {"method": method, "threadId": thread_id, "owner": "o", "repo": "r", "pullNumber": 7},
+        "transcript_path": str(transcript_path),
+    }
+
+
+def should_deny_a_review_write_resolve_with_no_reply(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(tmp_path, [_prompt("Address the review threads.")])
+    decision = gate.decision_for(_review_write_payload(transcript_path, "resolve_thread"))
+    assert _deny_reason(decision) == MISSING_REPLY_REASON
+
+
+def should_allow_a_review_write_resolve_after_a_reply_on_that_thread(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(
+        tmp_path,
+        [_prompt("Address the review threads."), *_threads_read(), _reply("reply-1"), _result("reply-1")],
+    )
+    assert gate.decision_for(_review_write_payload(transcript_path, "resolve_thread")) is None
+
+
+def should_leave_a_review_write_that_submits_a_review_alone(tmp_path: Path) -> None:
+    transcript_path = _write_transcript(tmp_path, [_prompt("Review the pull request.")])
+    assert gate.decision_for(_review_write_payload(transcript_path, "create")) is None