claude-dev-env 8.98.9 → 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_session_title_turn_gate.py

@@ -5,6 +5,7 @@ from pathlib import Path
 import pytest
 
 import session_title_turn_gate
+from open_tasks_transcript import TaskItem
 
 REMOTE_TITLE_TOOL = "mcp__claude-code-remote__set_session_title"
 DESKTOP_TITLE_TOOL = "mcp__ccd_session_mgmt__set_session_title"
@@ -28,10 +29,16 @@ WORK_RESULT = {
     "type": "user",
     "message": {"content": [{"type": "tool_result", "tool_use_id": "w1", "content": "ok"}]},
 }
+SESSION_ID = "s-title"
+RED_FLAG_TITLE = "\U0001f6a9 Merge approval"
+HOURGLASS_TITLE = "\u23f3 Export"
+QUESTION_PROMPT = {"type": "user", "message": {"role": "user", "content": "did the export fail?"}}
 REPLY = {"type": "assistant", "message": {"content": [{"type": "text", "text": "Done."}]}}
 
 
-def title_call(tool_use_id: str, tool_name: str = REMOTE_TITLE_TOOL) -> dict[str, object]:
+def title_call(
+    tool_use_id: str, tool_name: str = REMOTE_TITLE_TOOL, title: str = "✅ Gate"
+) -> dict[str, object]:
     return {
         "type": "assistant",
         "message": {
@@ -40,7 +47,7 @@ def title_call(tool_use_id: str, tool_name: str = REMOTE_TITLE_TOOL) -> dict[str
                     "type": "tool_use",
                     "id": tool_use_id,
                     "name": tool_name,
-                    "input": {"title": "✅ Gate"},
+                    "input": {"title": title},
                 }
             ]
         },
@@ -76,6 +83,7 @@ def run_gate(
     )
     hook_input = {
         "hook_event_name": "Stop",
+        "session_id": SESSION_ID,
         "stop_hook_active": is_stop_hook_active,
         "transcript_path": str(transcript_path),
     }
@@ -90,9 +98,33 @@ def run_gate(
 def isolated_home(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
     monkeypatch.setenv("HOME", str(tmp_path))
     monkeypatch.setenv("USERPROFILE", str(tmp_path))
+    monkeypatch.delenv("CLAUDE_CONFIG_DIR", raising=False)
+    monkeypatch.delenv("CLAUDE_CODE_TASK_LIST_ID", raising=False)
 
 
-def test_should_hold_a_turn_that_set_no_title(
+def write_task_store(home_directory: Path, all_statuses: list[str]) -> None:
+    task_directory = home_directory / ".claude" / "tasks" / SESSION_ID
+    task_directory.mkdir(parents=True)
+    for each_number, each_status in enumerate(all_statuses, start=1):
+        each_task = {"id": str(each_number), "subject": f"Step {each_number}", "status": each_status}
+        (task_directory / f"{each_number}.json").write_text(json.dumps(each_task), encoding="utf-8")
+
+
+def earlier_turn(title: str) -> list[dict[str, object]]:
+    return [TOOL_LISTING, PROMPT, title_call("t0", title=title), title_result("t0"), REPLY]
+
+
+def block_reason(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    tmp_path: Path,
+    all_entries: list[dict[str, object]],
+) -> str:
+    stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries)[1]
+    return json.loads(stdout_text)["reason"] if stdout_text else ""
+
+
+def test_should_hold_a_work_turn_in_a_session_with_no_title(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
     exit_code, stdout_text = run_gate(
@@ -101,6 +133,7 @@ def test_should_hold_a_turn_that_set_no_title(
     block_output = json.loads(stdout_text)
     assert exit_code == 0
     assert block_output["decision"] == "block"
+    assert "no title yet" in block_output["reason"]
     assert REMOTE_TITLE_TOOL in block_output["reason"]
     assert all(
         each_emoji in block_output["reason"]
@@ -111,144 +144,136 @@ def test_should_hold_a_turn_that_set_no_title(
 def test_should_pass_a_turn_that_set_a_title(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
+    write_task_store(tmp_path, ["completed"])
     all_entries = [
         TOOL_LISTING,
         PROMPT,
         WORK_CALL,
         WORK_RESULT,
-        title_call("t1"),
+        title_call("t1", title=HOURGLASS_TITLE),
         title_result("t1"),
         REPLY,
     ]
     assert run_gate(monkeypatch, capsys, tmp_path, all_entries) == (0, "")
 
 
-def test_should_hold_a_turn_whose_title_call_was_denied(
+@pytest.mark.parametrize(
+    ("earlier_title", "all_statuses"),
+    [
+        (HOURGLASS_TITLE, ["completed", "in_progress"]),
+        ("✅ Gate", []),
+        ("✅ Gate", ["completed"]),
+        ("\U0001f6a7 Org secret", ["pending"]),
+    ],
+)
+def test_should_pass_a_work_turn_whose_carried_title_still_fits(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    tmp_path: Path,
+    earlier_title: str,
+    all_statuses: list[str],
+) -> None:
+    if all_statuses:
+        write_task_store(tmp_path, all_statuses)
+    all_entries = [*earlier_turn(earlier_title), PROMPT, WORK_CALL, WORK_RESULT, REPLY]
+    assert run_gate(monkeypatch, capsys, tmp_path, all_entries) == (0, "")
+
+
+def test_should_hold_a_carried_red_flag_after_a_prompt_that_gives_work(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
-    all_entries = [TOOL_LISTING, PROMPT, title_call("t1"), title_result("t1", is_error=True), REPLY]
-    assert (
-        json.loads(run_gate(monkeypatch, capsys, tmp_path, all_entries)[1])["decision"] == "block"
-    )
+    all_entries = [*earlier_turn(RED_FLAG_TITLE), PROMPT, WORK_CALL, WORK_RESULT, REPLY]
+    reason_text = block_reason(monkeypatch, capsys, tmp_path, all_entries)
+    assert RED_FLAG_TITLE in reason_text
+    assert "red flag" in reason_text
 
 
-def test_should_pass_a_held_turn_whose_title_call_failed(
+def test_should_pass_a_carried_red_flag_after_a_question(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
-    all_entries = [TOOL_LISTING, PROMPT, title_call("t1"), title_result("t1", is_error=True), REPLY]
-    assert run_gate(monkeypatch, capsys, tmp_path, all_entries, is_stop_hook_active=True) == (
-        0,
-        "",
+    all_entries = [*earlier_turn(RED_FLAG_TITLE), QUESTION_PROMPT, WORK_CALL, WORK_RESULT, REPLY]
+    assert run_gate(monkeypatch, capsys, tmp_path, all_entries) == (0, "")
+
+
+def test_should_hold_a_carried_check_mark_while_items_are_open(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    write_task_store(tmp_path, ["completed", "pending"])
+    all_entries = [*earlier_turn("✅ Gate"), QUESTION_PROMPT, WORK_CALL, WORK_RESULT, REPLY]
+    assert "open items" in block_reason(monkeypatch, capsys, tmp_path, all_entries)
+
+
+def test_should_hold_a_carried_hourglass_once_every_item_is_completed(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    write_task_store(tmp_path, ["completed", "completed"])
+    all_entries = [*earlier_turn(HOURGLASS_TITLE), PROMPT, WORK_CALL, WORK_RESULT, REPLY]
+    assert "every task list item is completed" in block_reason(
+        monkeypatch, capsys, tmp_path, all_entries
     )
 
 
-def test_should_hold_a_held_turn_with_no_title_call(
+def test_should_pass_a_held_turn_even_with_no_title(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
     all_entries = [TOOL_LISTING, PROMPT, WORK_CALL, WORK_RESULT, REPLY]
-    stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries, is_stop_hook_active=True)[1]
-    assert json.loads(stdout_text)["decision"] == "block"
+    assert run_gate(monkeypatch, capsys, tmp_path, all_entries, is_stop_hook_active=True) == (0, "")
+
+
+def test_should_pass_a_tool_free_turn_with_no_title(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    assert run_gate(monkeypatch, capsys, tmp_path, [TOOL_LISTING, PROMPT, REPLY]) == (0, "")
 
 
-def test_should_hold_when_the_title_was_set_only_in_an_earlier_turn(
+def test_should_keep_showing_the_earlier_title_when_this_turns_title_call_was_denied(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
     all_entries = [
-        PROMPT,
-        title_call("t1"),
-        title_result("t1"),
-        REPLY,
+        *earlier_turn(RED_FLAG_TITLE),
         PROMPT,
         WORK_CALL,
         WORK_RESULT,
+        title_call("t1", title="⏳ bad title."),
+        title_result("t1", is_error=True),
         REPLY,
     ]
-    block_output = json.loads(run_gate(monkeypatch, capsys, tmp_path, all_entries)[1])
-    assert block_output["decision"] == "block"
+    assert RED_FLAG_TITLE in block_reason(monkeypatch, capsys, tmp_path, all_entries)
 
 
-@pytest.mark.parametrize(
-    "all_turn_tail",
-    [
-        [REPLY],
-        [title_call("t2"), title_result("t2", is_error=True), REPLY],
-    ],
-)
-def test_should_pass_a_tool_free_turn_after_an_earlier_title(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-    tmp_path: Path,
-    all_turn_tail: list[dict[str, object]],
+def test_should_ignore_a_title_set_on_a_sidechain(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
+    sidechain_call = {**title_call("s1"), "isSidechain": True}
+    sidechain_result = {**title_result("s1"), "isSidechain": True}
     all_entries = [
         TOOL_LISTING,
         PROMPT,
-        title_call("t1"),
-        title_result("t1"),
+        sidechain_call,
+        sidechain_result,
+        WORK_CALL,
+        WORK_RESULT,
         REPLY,
-        PROMPT,
-        *all_turn_tail,
     ]
-    assert run_gate(monkeypatch, capsys, tmp_path, all_entries) == (0, "")
-
-
-@pytest.mark.parametrize(
-    "all_earlier_title_entries",
-    [
-        [],
-        [title_call("t1"), title_result("t1", is_error=True)],
-        [
-            {**title_call("s1"), "isSidechain": True},
-            {**title_result("s1"), "isSidechain": True},
-        ],
-    ],
-)
-def test_should_hold_a_tool_free_turn_without_an_earlier_title(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-    tmp_path: Path,
-    all_earlier_title_entries: list[dict[str, object]],
-) -> None:
-    all_entries = [TOOL_LISTING, PROMPT, *all_earlier_title_entries, REPLY, PROMPT, REPLY]
-    stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries)[1]
-    assert json.loads(stdout_text)["decision"] == "block"
+    assert "no title yet" in block_reason(monkeypatch, capsys, tmp_path, all_entries)
 
 
 def test_should_start_a_turn_at_an_image_only_prompt(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
+    write_task_store(tmp_path, ["pending"])
     image_prompt = {
         "type": "user",
         "message": {"content": [{"type": "image", "source": {"type": "base64", "data": ""}}]},
     }
-    all_entries = [
-        TOOL_LISTING,
-        PROMPT,
-        title_call("t1"),
-        title_result("t1"),
-        REPLY,
-        image_prompt,
-        WORK_CALL,
-        WORK_RESULT,
-        REPLY,
-    ]
-    stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries)[1]
-    assert json.loads(stdout_text)["decision"] == "block"
-
-
-def test_should_hold_a_turn_whose_only_title_call_ran_on_a_sidechain(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    sidechain_call = {**title_call("s1"), "isSidechain": True}
-    sidechain_result = {**title_result("s1"), "isSidechain": True}
-    all_entries = [TOOL_LISTING, PROMPT, sidechain_call, sidechain_result, REPLY]
-    stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries)[1]
-    assert json.loads(stdout_text)["decision"] == "block"
+    all_entries = [*earlier_turn("✅ Gate"), image_prompt, WORK_CALL, WORK_RESULT, REPLY]
+    assert "open items" in block_reason(monkeypatch, capsys, tmp_path, all_entries)
 
 
 def test_should_keep_the_turn_across_a_stop_block_and_a_meta_entry(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
+    write_task_store(tmp_path, ["pending"])
     stop_block = {
         "type": "attachment",
         "attachment": {"type": "hook_blocking_error", "hookEvent": "Stop"},
@@ -257,6 +282,8 @@ def test_should_keep_the_turn_across_a_stop_block_and_a_meta_entry(
     all_entries = [
         TOOL_LISTING,
         PROMPT,
+        WORK_CALL,
+        WORK_RESULT,
         title_call("t1"),
         title_result("t1"),
         REPLY,
@@ -270,10 +297,8 @@ def test_should_keep_the_turn_across_a_stop_block_and_a_meta_entry(
 def test_should_name_a_deferred_title_tool_in_the_reason(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
-    block_output = json.loads(
-        run_gate(monkeypatch, capsys, tmp_path, [DEFERRED_LISTING, PROMPT, REPLY])[1]
-    )
-    assert DESKTOP_TITLE_TOOL in block_output["reason"]
+    all_entries = [DEFERRED_LISTING, PROMPT, WORK_CALL, WORK_RESULT, REPLY]
+    assert DESKTOP_TITLE_TOOL in block_reason(monkeypatch, capsys, tmp_path, all_entries)
 
 
 @pytest.mark.parametrize(
@@ -290,6 +315,8 @@ def test_should_name_a_deferred_title_tool_in_the_reason(
                 },
             },
             PROMPT,
+            WORK_CALL,
+            WORK_RESULT,
             REPLY,
         ],
     ],
@@ -311,3 +338,59 @@ def test_should_pass_when_the_transcript_cannot_be_read(
         "sys.stdin", io.TextIOWrapper(io.BytesIO(json.dumps(hook_input).encode("utf-8")))
     )
     assert (session_title_turn_gate.main(), capsys.readouterr().out) == (0, "")
+
+
+def test_should_return_the_last_title_that_came_back_without_an_error() -> None:
+    all_entries = [
+        title_call("t1", title=HOURGLASS_TITLE),
+        title_result("t1"),
+        title_call("t2", title=RED_FLAG_TITLE),
+        title_result("t2", is_error=True),
+    ]
+    assert session_title_turn_gate.shown_title(all_entries) == HOURGLASS_TITLE
+    assert session_title_turn_gate.shown_title([PROMPT]) is None
+
+
+@pytest.mark.parametrize(
+    ("title", "expected_status"),
+    [(RED_FLAG_TITLE, "\U0001f6a9"), ("⏳️ Export", "⏳"), ("Export", None)],
+)
+def test_should_read_the_status_emoji_without_its_variation_selector(
+    title: str, expected_status: str | None
+) -> None:
+    assert session_title_turn_gate.title_status(title) == expected_status
+
+
+@pytest.mark.parametrize(
+    ("title", "is_ask_turn", "all_statuses", "is_expected_stale"),
+    [
+        (RED_FLAG_TITLE, True, [], True),
+        (RED_FLAG_TITLE, False, [], False),
+        ("✅ Gate", False, ["pending"], True),
+        ("✅ Gate", True, ["completed"], False),
+        ("✅ Gate", True, ["completed", "deleted"], False),
+        (HOURGLASS_TITLE, True, ["completed", "deleted"], True),
+        (HOURGLASS_TITLE, True, ["completed"], True),
+        (HOURGLASS_TITLE, True, ["in_progress"], False),
+        (HOURGLASS_TITLE, True, [], False),
+    ],
+)
+def test_should_call_a_status_stale_only_when_the_session_state_contradicts_it(
+    title: str, is_ask_turn: bool, all_statuses: list[str], is_expected_stale: bool
+) -> None:
+    all_items = [
+        TaskItem(str(each_number), "Step", each_status)
+        for each_number, each_status in enumerate(all_statuses)
+    ]
+    stale_reason = session_title_turn_gate.stale_status_reason(title, is_ask_turn, all_items)
+    assert (stale_reason is not None) is is_expected_stale
+    if stale_reason is not None:
+        assert title in stale_reason
+
+
+def test_should_build_the_block_reason_from_the_stale_status() -> None:
+    all_entries = [*earlier_turn(RED_FLAG_TITLE), PROMPT, WORK_CALL, WORK_RESULT, REPLY]
+    reason_text = session_title_turn_gate.turn_block_reason(all_entries, False, True, [])
+    assert reason_text is not None
+    assert reason_text.startswith("The title '" + RED_FLAG_TITLE)
+    assert session_title_turn_gate.turn_block_reason(all_entries, False, False, []) is None