claude-dev-env 8.98.8 → 8.98.10

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

package/hooks/features/conduct-gates.md

@@ -6,18 +6,18 @@ This family stops a chat reply, edited message, or tool call when its payload br
 
 - `blocking/reply_length_gate.py` caps chat reply length, denies a configured banned word, requires a readable link when the text names a pull request number, and denies a causal claim in a reply that cites no code span, output block, or link. It denies a sentence that guesses, estimates, hedges a duration, or admits a skipped check, such as "I didn't confirm this one." It denies a cited Actions run, pull request, or run, job, or check id that no successful tool result in the transcript shows; a subagent's report is the result of its Agent call. A question card from `AskUserQuestion` gets the banned word check and `unvalidated_claim_violation`, like a decision card. With visual reply mode on, it also runs the checks in `visual_reply_rules.py` from the rule list in `rules/visual-reply-rules.json`: no abbreviation or tracker number outside a link, a widget or page before a reply of more than one sentence, and no anchor link inside widget code. The mode is off by default; `~/.claude/visual-reply-mode.json` with `{"enabled": true}` turns the mode checks on.
 - `blocking/final_reply_gate.py` applies the banned words, `unvalidated_claim_violation`, and `unseen_citation_violation` from the reply gate to the reply a session ends its turn with. Its `windows_path_violation` blocks a path the terminal would render without one of its backslashes.
-- `blocking/open_tasks_stop_gate.py` holds the end of a turn while the session has open items that the closing reply does not name on a `Blocked:` or `Open:` line. It merges the task store, the transcript task calls, the desktop `mcp__ccd_turn__update_plan` plan, and the recorded asks. A transcript item whose subject the task store holds is dropped, and every other item stays. `blocking/open_tasks_transcript.py` rebuilds the task list and the last reply from the transcript for it. Each new desktop plan list carries the unfinished items of the list before it after its own items, so `done` and `start` positions still point at its own items. An ask stays open until a reply line `Done: #ask-N` closes it. A line `Dropped: <#ask-N or carried item> - "<quote>"` closes an ask or a carried plan item when the quote is in a prompt the user sent after that ask or that list.
-- `session/open_task_ask_recorder.py` records each prompt in `~/.claude/open-task-asks/<session id>.json`, outside the task store. A prompt that asks for work gets the next `#ask-N` id. A question-only prompt, an acknowledgement such as `thanks!`, an empty prompt, a prompt of only `<system-reminder>` blocks, and an envelope such as `<agent-message>` or `<task-notification>` get none.
+- `blocking/open_tasks_stop_gate.py` holds the end of a turn once when the prompt that started it asks for work, the turn ran a work tool, and the turn made no tracker call: TaskCreate, TaskUpdate, TodoWrite, the Codex `update_plan`, or the desktop `mcp__ccd_turn__update_plan`. A work tool is any tool but a tracker call, the session title tool, `AskUserQuestion`, a hearthbot decision card, Codex `request_user_input`, `ToolSearch`, `TaskList`, or `TaskGet`. It never reads the reply text. `open_task_asks.is_ask` decides whether a prompt asks for work: a question-only prompt, an acknowledgement such as `thanks!`, an empty prompt, a prompt of only `<system-reminder>` blocks, and an envelope such as `<agent-message>` or `<task-notification>` do not. `blocking/open_tasks_transcript.py` replays the transcript for it: the turn's prompt, its tool calls, and the task list. `session_task_items` merges the task store with the transcript items whose subject the store does not hold, for the session title gate.
+- `session/tracking_nudge.py` adds one `additionalContext` note to a prompt that asks for work. The note asks for a task list item. When the title shows the red flag or the check mark, it also asks for the hourglass before other work. It never blocks.
 - The claim judge is a `prompt` hook in `hooks.json`, with no `model` set, so Claude Code's small default hook model reads each chat message and denies the first claim about how code, a file, a tool, a service, a run, or a process behaves, or why something happened, when nothing in the message shows it: inline code that quotes output or a code line, a file and line, or a link. A pull request link covers what that change does, what it blocks or lets through, and its checks. The author's own actions, a restatement of the user's words, questions, instructions, and a decision card's option consequences pass. It catches the plain claims the causal word list in `blocking/reply_length_gate.py` misses, such as "The code lets any of them rewrite it mid-check." `continueOnBlock` returns the reason to the agent as the tool error, so it can add the source and send again. The installer owns it through the `claude-dev-env: ` prefix on its `statusMessage`. It skips `post_widget`, whose input is SVG or HTML markup.
 - `blocking/chat_reply_gate.py` runs the `reply_length_gate.py` reply checks on a plain chat reply, which is no tool call. On `UserPromptSubmit` it adds the reply rules as `additionalContext`. On `MessageDisplay` it holds each streamed batch until the message ends. A message that passes shows whole. A message that fails shows as a draft from `claude -p` on Haiku that passes the same checks, and the original shows when two drafts fail. The draft changes only the text on screen, so the next `UserPromptSubmit` tells the agent the text the user saw, and `SessionEnd` deletes the stored draft. The [reply arena harness](https://github.com/jl-cmd-projects/claude-dev-env/tree/160349b90f627ea542fc6bc7b2b7f86dcbf98b73/tests/reply_arena) ran the comparison that chose this display path.
 - `blocking/edit_marker_gate.py` rejects strikethrough and edit-note markers in replacement chat text or cards.
 - `blocking/issue_close_handoff_gate.py` denies an issue comment or issue write that closes the issue and routes a found defect to another issue or epic.
 - `blocking/session_title_format_gate.py` denies a session title that breaks the `<emoji> <name>` shape or has a name longer than 25 characters.
-- `blocking/session_title_turn_gate.py` holds the end of a turn in a session that has a `__set_session_title` tool until a title call in that turn comes back without an error. A turn that called no tool other than the title tool may end when an earlier turn already set the title. A held turn whose title call failed may end.
+- `blocking/session_title_turn_gate.py` holds the end of a turn once, in a session that has a `__set_session_title` tool, when the shown title does not fit the session's state: no title yet, a red flag after a prompt that asks for work, a check mark while the task list has open items, or an hourglass once every item is completed or deleted. A turn that set a title passes. A turn that called no tool other than the title tool passes, and so does a held turn.
 - `blocking/step_note_gate.py` requires a status line before a tool call while its opt-in flag is on.
 - `blocking/verify_before_acting.py` blocks a completed mutating call when the agent's reasoning contains an unchecked claim.
 - `blocking/pr_lifecycle_skill_gate.py` denies a commit, push, pull request action, or merge until the `pr-lifecycle` skill appears in the transcript since the last compaction.
-- `blocking/resolve_thread_reply_gate.py` denies a review thread resolve until the agent's own transcript shows a reply on a thread that posted after the last user prompt and that no successful resolve has spent. Each successful resolve spends one posted reply. A reply is an `add_reply_to_pull_request_comment` call, or a `gh api` call to a comment's `replies` endpoint or to `addPullRequestReviewThreadReply`. A reply whose result is an error, such as a refusal from `blocking/reply_length_gate.py`, does not count. With no readable transcript, the resolve passes.
+- `blocking/resolve_thread_reply_gate.py` denies a review thread resolve until the agent's own transcript shows a reply on that same thread that posted after the last user prompt and that no successful resolve of the thread has spent. A resolve is a `resolve_review_thread` call, which names the thread by `threadID`; a `pull_request_review_write` call with method `resolve_thread`, which names it by `threadId`; a shell command with a `gh api graphql` `resolveReviewThread` mutation, which names it by a literal `PRRT_` id; or a shell call to `pulls/<n>/ccr/comments/<id>/resolve`, which names it by a comment id. A graphql resolve that names no `PRRT_` id is denied. A reply is an `add_reply_to_pull_request_comment` call, or a `gh api` call to a comment's `replies` endpoint or to `addPullRequestReviewThreadReply`, which names its thread by `PRRT_` id. A reply and a resolve by comment id match when they name the same comment, or when a successful tool result in the transcript, such as `pull_request_read` `get_review_comments`, lists the comment under the thread by its `discussion_r` anchor or `databaseId`. A reply whose result is an error, such as a refusal from `blocking/reply_length_gate.py`, does not count. With no readable transcript, the resolve passes.
 - `blocking/verify_before_commit_gate.py` denies a `git commit` in a repository with a `.claude/skills/verify` or `.agents/skills/verify` directory until the `verify` skill loads after the last user prompt, through a Skill call or the `/verify` command in that prompt. It reads the committed paths from the staged diff, the tracked changes for `-a`, and the paths of each `git add` earlier in the same command, and passes a commit whose paths are all docs, images, or test files.
 - `blocking/build_eval_before_eval_write_gate.py` denies a write to an eval file until a Skill call named exactly `claude-api` with args `build-eval`, or the `/claude-api build-eval` command, appears in the transcript.
 - `blocking/merge_review_gate.py` denies an agent's merge until a review pass on the merged head reported zero findings, or ruled out every finding and linked the posted rulings. It reads the receipt `scripts/merge_review_receipt.py` writes, requires the merge, auto-merge or merge-queue entry to be pinned to that head, and skips repositories listed in `CLAUDE_MERGE_REVIEW_EXEMPT_REPOSITORIES`. Its deny reason names the review command `CLAUDE_MERGE_REVIEW_COMMAND` sets. The reason tells the agent to run that command for the first three passes and `/code-review low --fix <number>` for each later pass; the gate itself counts no passes.
@@ -29,8 +29,8 @@ This family stops a chat reply, edited message, or tool call when its payload br
 
 - `blocking/reply_length_gate.py` runs on `PreToolUse`, matcher `mcp__hearthbot__reply|mcp__hearthbot__post_message|mcp__hearthbot__update_message|mcp__hearthbot__ask_decision|AskUserQuestion|mcp__hearthbot__post_widget`, timeout `10` seconds in `hooks.json`.
 - `blocking/final_reply_gate.py` runs on `Stop`, timeout `10` seconds in `hooks.json`.
-- `blocking/open_tasks_stop_gate.py` runs on `Stop`, timeout `10` seconds in `hooks.json`. The installer also registers it on Codex `Stop` and as a native Cursor `stop` entry in `~/.cursor/hooks.json`, where a block also returns `followup_message`. A Cursor stop with status `aborted` or `error` passes. A Cursor stop whose `loop_count` is 5 or more passes, because a copy Cursor imports from `~/.claude/settings.json` has no follow-up limit.
-- `session/open_task_ask_recorder.py` runs on `UserPromptSubmit`, matcher empty, timeout `10` seconds in `hooks.json`. It prints nothing.
+- `blocking/open_tasks_stop_gate.py` runs on `Stop`, timeout `10` seconds in `hooks.json`. The installer also registers it on Codex `Stop` and as a native Cursor `stop` entry in `~/.cursor/hooks.json`, where a block also returns `followup_message`. A Cursor stop with status `aborted` or `error` passes. A Cursor stop whose `loop_count` is above 0 passes, because a copy Cursor imports from `~/.claude/settings.json` has no follow-up limit.
+- `session/tracking_nudge.py` runs on `UserPromptSubmit`, matcher empty, timeout `10` seconds in `hooks.json`.
 - The claim judge runs on `PreToolUse`, matcher `mcp__hearthbot__reply|mcp__hearthbot__post_message|mcp__hearthbot__update_message|mcp__hearthbot__ask_decision`, timeout `30` seconds in `hooks.json`.
 - `blocking/chat_reply_gate.py` runs on `UserPromptSubmit`, matcher empty, timeout `10` seconds, on `MessageDisplay`, timeout `100` seconds, and on `SessionEnd`, timeout `3` seconds, in `hooks.json`.
 - `blocking/edit_marker_gate.py` runs on `PreToolUse`, matcher `mcp__.*__update_message`, timeout `10` seconds in `hooks.json`.
@@ -40,7 +40,7 @@ This family stops a chat reply, edited message, or tool call when its payload br
 - `blocking/step_note_gate.py` runs on `PreToolUse`, matcher `*`, timeout `15` seconds in `hooks.json`.
 - `blocking/verify_before_acting.py` runs on `PostToolUse`, matcher `Write|Edit|MultiEdit|NotebookEdit|Agent|Task|apply_patch|Bash|PowerShell|mcp__.*`, timeout `10` seconds in `hooks.json`.
 - `blocking/pr_lifecycle_skill_gate.py` runs on `PreToolUse`, matcher `Bash|PowerShell|mcp__.*__(create_pull_request|merge_pull_request|enable_pr_auto_merge|update_pull_request|actions_run_trigger)`, timeout `10` seconds in `hooks.json`.
-- `blocking/resolve_thread_reply_gate.py` runs on `PreToolUse`, matcher `mcp__.*__resolve_review_thread`, timeout `10` seconds in `hooks.json`.
+- `blocking/resolve_thread_reply_gate.py` runs on `PreToolUse`, matcher `Bash|PowerShell|mcp__.*__resolve_review_thread|mcp__.*__pull_request_review_write`, timeout `10` seconds in `hooks.json`.
 - `blocking/verify_before_commit_gate.py` runs on `PreToolUse`, matcher `Bash|PowerShell`, timeout `30` seconds in `hooks.json`.
 - `blocking/build_eval_before_eval_write_gate.py` runs on `PreToolUse`, matcher `Write|Edit|MultiEdit|NotebookEdit|apply_patch`, timeout `10` seconds in `hooks.json`.
 - `blocking/merge_review_gate.py` runs on `PreToolUse`, matcher `Bash|PowerShell|mcp__.*__(merge_pull_request|enable_pr_auto_merge)`, timeout `10` seconds in `hooks.json`.
@@ -55,16 +55,16 @@ Preconditions:
 - Run each command from the repository root with Python and pytest available. The tests create transcript and payload fixtures.
 
 - **Reply length.** Input is a reply with four sentences, a plain pull request number, an abbreviation, two sentences with no widget this turn, or widget code with an anchor link. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_reply_length_gate.py -q`. The adjacent test observes a denial and its count, link, or mode reason. Widget code with no flowchart passes with a flowchart reminder in `additionalContext`.
-- **Resolve reply.** Input is a transcript where a thread reply came back refused, or with no reply, or with one reply already spent on a resolve, then a resolve call. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_resolve_thread_reply_gate.py -q`. The adjacent test observes a deny whose reason says to post the reply, confirm it posted, then resolve. A reply that posted before the resolve passes, and an unreadable transcript passes.
+- **Resolve reply.** Input is a transcript where a thread reply came back refused, or with no reply, or with one reply already spent on a resolve, or with a reply on another thread, then a resolve call, a `pull_request_review_write` `resolve_thread` call, a graphql `resolveReviewThread` command, or a `ccr/comments/<id>/resolve` call. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_resolve_thread_reply_gate.py -q`. The adjacent test observes a deny whose reason says to post the reply, confirm it posted, then resolve. A reply that posted before the resolve passes, and an unreadable transcript passes.
 - **Final reply.** Input is a closing reply that says "My guess is one to two hours." or cites a run no tool result shows. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_final_reply_gate.py -q`. The adjacent test observes a `block` decision that quotes the sentence or the citation; a reply that cites a run a tool result shows passes. A reply with a plain-text `D:\Reports\.claude\report.html` is blocked; the same path in backticks or a fenced block passes.
-- **Open tasks.** Input is a session whose task list still has "rotate the deploy key" pending and a closing reply of "Done.". Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_open_tasks_stop_gate.py -q`. The adjacent test observes a `block` decision that names the item; a reply line `Blocked: rotate the deploy key - <what the user must give>` passes. The same file covers an interrupted ask, a continuation plan list that leaves items out, `Done:` and `Dropped:` lines, and a carried item that a later list marks completed.
-- **Ask recorder.** Input is a `UserPromptSubmit` payload with a work prompt, a question, a `<task-notification>` envelope, and a polite request. Run `python -m pytest packages/claude-dev-env/hooks/session/test_open_task_ask_recorder.py -q`. The adjacent test observes `ask-1` and `ask-2` for the work prompt and the request, no ask for the other two, and empty stdout.
+- **Open tasks.** Input is a transcript whose last prompt asks for work and whose turn ran a Bash call and no tracker call. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_open_tasks_stop_gate.py -q`. The adjacent test observes one `block` decision; the same turn with a TaskCreate, TaskUpdate, TodoWrite, or desktop plan call passes. A question, an acknowledgement, a `<task-notification>` envelope, a tool-free turn, and a held stop pass. The same file covers Codex and Cursor payloads.
+- **Ask nudge.** Input is a `UserPromptSubmit` payload with a work prompt, a question, and a `<task-notification>` envelope, after a transcript whose title shows the red flag. Run `python -m pytest packages/claude-dev-env/hooks/session/test_tracking_nudge.py -q`. The adjacent test observes a task list note and a title note for the work prompt, and empty stdout for the other two.
 - **Claim judge.** Input is a headless `claude -p` session with a stub MCP server named `hearthbot` that exposes `reply` and `ask_decision`, told to send "The code lets any of them rewrite it mid-check." The session settings add the `hooks.json` prompt hook. The stub logs zero bytes sent, and the tool error reads `PreToolUse:mcp__hearthbot__reply hook error: [<the prompt>]: Fact with no source: ...`. The same sentence with a `file:line` in backticks posts. A hook whose `model` Claude Code does not recognize lets every message through, so leave `model` unset. Run `node --test packages/claude-dev-env/bin/install.prompt-hook.test.mjs` for the installer side; it observes one managed prompt hook after two installs and none after uninstall.
 - **Chat reply.** Input is a `MessageDisplay` event whose message holds four sentences, the same message split over two batches, and a `UserPromptSubmit` event. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_chat_reply_gate.py -q`. The adjacent test observes the drafter's text in `displayContent`, an empty first batch, no output for three sentences, the original after two failed drafts, the shown draft in the next `additionalContext`, and the stored draft deleted at session end.
 - **Edit marker.** Input is an update message with strikethrough or an edit note. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_edit_marker_gate.py -q`. The adjacent test observes a denial; clean replacement text passes.
 - **Handoff close.** Input is an issue comment that says the issue is closed and that the found defect belongs to another issue. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_issue_close_handoff_gate.py -q`. The adjacent test observes a denial; a close with a plain cross-reference and a routing comment on an open issue both pass.
 - **Session title.** Input is a set session title call with no leading emoji or a name over 25 characters. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_session_title_format_gate.py -q`. The adjacent test observes a denial that names the broken rule; a well-formed title passes.
-- **Title this turn.** Input is a transcript that lists the title tool and a turn with no title call. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_session_title_turn_gate.py -q`. The adjacent test observes a `block` decision that names the tool and the four status emoji; a turn whose title call came back without an error passes.
+- **Stale title.** Input is a transcript that lists the title tool, an earlier turn that set the red flag, and a work prompt whose turn ran a tool and set no title. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_session_title_turn_gate.py -q`. The adjacent test observes a `block` decision that names the shown title, the tool, and the four status emoji. A carried hourglass with an item in progress passes, and so does a turn whose title call came back without an error.
 - **Step note.** Input is a tool call after a transcript message without a status line while the flag is on. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_step_note_gate.py -q`. The adjacent test observes a block until a status line appears.
 - **Checked claim.** Input is a Write after hedged reasoning in the transcript. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_verify_before_acting.py -q`. The adjacent test observes a block and a logged blocked outcome.
 - **Lifecycle skill.** Input is a `git commit` or `gh pr create` command with no `pr-lifecycle` invocation in the transcript. Run `python -m pytest packages/claude-dev-env/hooks/blocking/test_pr_lifecycle_skill_gate.py -q`. The adjacent test observes a denial, then a silent allow once the skill or its slash command appears.
@@ -77,7 +77,7 @@ Preconditions:
 
 ## Gotchas
 
-- The open tasks gate reads `Done:` and `Dropped:` lines in every assistant text of the transcript, so a close holds for later stops. The ask recorder runs only from `hooks.json`, so Codex and Cursor sessions get no asks.
+- The ask nudge runs only from `hooks.json`, so Codex and Cursor sessions get no turn-start note. Their Stop gate still holds a work turn with no tracker call.
 - `blocking/step_note_gate.py` is off by default and polls for the transcript record. Subagent calls and unreadable records pass.
 - `blocking/verify_before_acting.py` runs after the tool. A block asks the agent to check the claim and undo a contradicted change.
 - The reply gate counts each nonempty list line as a sentence. Link targets and code spans add no words. Its banned words come from `reply-banned-words.json` in the Claude home, or the file `CLAUDE_REPLY_BANNED_WORDS_PATH` names, with built-in defaults.

package/hooks/hooks.json

@@ -103,7 +103,7 @@
         ]
       },
       {
-        "matcher": "mcp__.*__resolve_review_thread",
+        "matcher": "Bash|PowerShell|mcp__.*__resolve_review_thread|mcp__.*__pull_request_review_write",
         "hooks": [
           {
             "type": "command",
@@ -336,7 +336,7 @@
           },
           {
             "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/open_task_ask_recorder.py",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/tracking_nudge.py",
             "timeout": 10
           },
           {