claude-dev-env 8.98.8 → 8.98.10

package/hooks/hooks_constants/open_tasks_stop_gate_constants.py

@@ -1,13 +1,12 @@
 """Constants for the open tasks Stop gate."""
 
 HOOK_EVENT_NAME = "Stop"
-SESSION_ID_KEY = "session_id"
 TRANSCRIPT_PATH_KEY = "transcript_path"
-LAST_ASSISTANT_MESSAGE_KEY = "last_assistant_message"
 DECISION_KEY = "decision"
 BLOCK_DECISION = "block"
 REASON_KEY = "reason"
 ALLOW_EXIT_CODE = 0
+STOP_HOOK_ACTIVE_KEY = "stop_hook_active"
 UTF8_ENCODING = "utf-8"
 WORD_SEPARATOR = " "
 TASK_LIST_ID_ENVIRONMENT_VARIABLE = "CLAUDE_CODE_TASK_LIST_ID"
@@ -38,8 +37,6 @@ CURSOR_FOLLOWUP_MESSAGE_KEY = "followup_message"
 CURSOR_STATUS_KEY = "status"
 CURSOR_COMPLETED_STATUS = "completed"
 CURSOR_LOOP_COUNT_KEY = "loop_count"
-CURSOR_FOLLOWUP_LIMIT = 5
-REPLY_TEXT_SEPARATOR = "\n"
 TASK_UPDATE_ID_KEY = "taskId"
 TODO_WRITE_TOOL_NAME = "TodoWrite"
 DYNAMIC_TOOL_CALL_NAME = "CallDynamicTool"
@@ -59,51 +56,15 @@ CODEX_STEP_KEY = "step"
 FIRST_ITEM_NUMBER = 1
 TASK_CREATED_PATTERN = r"Task #(\d+) created"
 CREATED_TASK_ID_GROUP_INDEX = 1
-REPORT_LINE_PATTERN = r"^\s*(?:[-*]\s*)?(open|blocked)\b\s*[:\-]?\s*(.*)$"
-REPORTED_TEXT_GROUP_INDEX = 2
-WORD_BOUNDARY_PATTERN = r"\b"
 TASK_NUMBER_REFERENCE_TEMPLATE = "#{task_id}"
-ITEM_LINE_TEMPLATE = "\n- {subject}"
-BLOCK_REASON_PREFIX = "The task list still has incomplete items that this reply does not report:"
-BLOCK_REASON_SUFFIX = (
-    "\nKeep working each one now. End the reply with one line per item you cannot finish this turn:"
-    " 'Blocked: <item> - <what the user must give>' when only the user can unblock it, or"
-    " 'Open: <item> - <the step you take next>' when you are still working it."
-    " When the user must decide, choose, or approve, ask on a question card (AskUserQuestion,"
-    " or mcp__hearthbot__ask_decision / request_decision) this turn, then add the Blocked line."
-)
-BLOCKED_REPORT_KIND = "blocked"
-REPORT_KIND_GROUP_INDEX = 1
-DECISION_WORD_PATTERN = (
-    r"\b(?:ok|okay|approve[sd]?|approval|go-?ahead|green\s+light|sign-?off|decide[sd]?|decision"
-    r"|choose|choice|permission|consent|say-?so|your\s+call|prefer(?:s|ence)?)\b"
-)
-DECISION_CARD_TOOL_PATTERN = (
-    r"(?:^|__)AskUserQuestion$|hearthbot__(?:ask|request)_decision$|^request_user_input(?:_async)?$"
-)
 ALL_SKIPPED_PROMPT_FLAGS = ("isMeta", "isSidechain", "isCompactSummary")
 USER_ROLE = "user"
 USER_RECORD_TYPE = "user"
 CODEX_MESSAGE_TYPE = "message"
-CODEX_CARD_EVENT = "card"
-CODEX_PROMPT_EVENT = "prompt"
 STOP_HOOK_FEEDBACK_PREFIX = "Stop hook feedback"
-DECISION_LINE_TEMPLATE = "\n- {line}"
-DECISION_BLOCK_REASON_PREFIX = "This reply asks the user for a decision in a Blocked line, with no question card this turn:"
-DECISION_BLOCK_REASON_SUFFIX = (
-    "\nPut the decision on a question card now: call AskUserQuestion, or mcp__hearthbot__ask_decision or"
-    " mcp__hearthbot__request_decision, with two or three choices. Then end the reply with the Blocked line."
-)
-ASK_CLOSE_SUFFIX = (
-    "\nClose a finished ask with a 'Done: #ask-N' line. Close an ask or a carried plan item the user"
-    " called off with 'Dropped: <#ask-N or item> - \"<the user's words that called it off>\"'."
-)
 COMPLETED_STATUS = "completed"
 IN_PROGRESS_STATUS = "in_progress"
 ASSISTANT_RECORD_TYPE = "assistant"
-RECORD_TIMESTAMP_KEY = "timestamp"
-UTC_SUFFIX = "Z"
-UTC_OFFSET_TEXT = "+00:00"
 CCD_PLAN_TOOL_NAME = "mcp__ccd_turn__update_plan"
 CCD_PLAN_ITEMS_KEY = "items"
 CCD_PLAN_CONTENT_KEY = "content"
@@ -111,21 +72,7 @@ CCD_PLAN_DONE_KEY = "done"
 CCD_PLAN_START_KEY = "start"
 CCD_PLAN_ADVANCE_KEY = "advance"
 CCD_PLAN_ITEM_ID_TEMPLATE = "plan-{position}"
-ASK_ID_PREFIX = "ask-"
-ASK_ID_TEMPLATE = "ask-{ask_number}"
-ASK_LINE_TEMPLATE = "\n- #{ask_id}: {subject}"
-ASK_SUBJECT_CHARACTER_LIMIT = 120
-ASK_SUBJECT_ELLIPSIS = "..."
-ASKS_DIRECTORY_NAME = "open-task-asks"
-ASKS_FILE_SUFFIX = ".json"
-ASKS_TEMPORARY_PREFIX = ".open-task-asks-"
-ASKS_TEMPORARY_SUFFIX = ".tmp"
-ASKS_PROMPTS_KEY = "prompts"
-ASK_PROMPT_TEXT_KEY = "text"
-ASK_PROMPT_RECORDED_AT_KEY = "recorded_at"
-ASK_PROMPT_ID_KEY = "ask_id"
 PROMPT_KEY = "prompt"
-SAFE_SESSION_ID_PATTERN = r"[\w-]+"
 SENTENCE_SPLIT_PATTERN = r"(?<=[.!?])\s+|\n+"
 QUESTION_END_PATTERN = r"\?\s*$"
 YES_OR_NO_END_PATTERN = r"\byes\s+or\s+no\W*$"
@@ -140,9 +87,29 @@ ACKNOWLEDGEMENT_PATTERN = (
     r"|sounds\s+good|looks\s+good|lgtm)(?:[\s,]+(?:thanks?|thank\s+you))?\W*$"
 )
 POLITE_REQUEST_START_PATTERN = r"^\s*(?:please\b|(?:can|could|would|will)\s+you\b)"
-DONE_LINE_PATTERN = r"^\s*(?:[-*]\s*)?done\b\s*[:\-]?\s*(.*)$"
-DONE_TEXT_GROUP_INDEX = 1
-ASK_REFERENCE_PATTERN = r"#(ask-\d+)\b"
-DROPPED_LINE_PATTERN = r"^\s*(?:[-*]\s*)?dropped\b\s*[:\-]?\s*(.+?)\s+-\s+[\"“](.+?)[\"”]\s*$"
-DROPPED_TARGET_GROUP_INDEX = 1
-DROPPED_QUOTE_GROUP_INDEX = 2
+ALL_TRACKER_TOOL_NAMES = frozenset({TODO_WRITE_TOOL_NAME, TASK_CREATE_TOOL_NAME, TASK_UPDATE_TOOL_NAME})
+ALL_NON_WORK_TOOL_NAMES = frozenset(
+    {
+        "AskUserQuestion",
+        "mcp__hearthbot__ask_decision",
+        "mcp__hearthbot__request_decision",
+        "ToolSearch",
+        "TaskList",
+        "TaskGet",
+        "request_user_input",
+        "request_user_input_async",
+    }
+)
+SESSION_TITLE_TOOL_SUFFIX = "__set_session_title"
+ALL_CODEX_TOOL_CALL_TYPES = frozenset({CODEX_FUNCTION_CALL_TYPE, "custom_tool_call", "local_shell_call"})
+BLOCK_REASON = (
+    "This turn worked on the user's ask and left the task list unchanged. The user follows your work"
+    " there. Update it now: TaskCreate the ask if it has no item, and TaskUpdate each item to its"
+    " current status (TodoWrite or update_plan where that is the tracker). Then end the turn. Leave"
+    " the reply as it stands."
+)
+PROMPT_SUBMIT_EVENT_NAME = "UserPromptSubmit"
+TASK_LIST_NUDGE = (
+    "The user follows your work in the task list. Give this ask a task list item (TaskCreate) and"
+    " keep each item's status current as the work moves."
+)

package/hooks/hooks_constants/resolve_thread_reply_gate_constants.py

@@ -8,15 +8,30 @@ from hooks_constants.reply_length_gate_constants import (
 )
 
 RESOLVE_TOOL_NAME_PATTERN = re.compile(r"^mcp__.+__resolve_review_thread$")
+REVIEW_WRITE_TOOL_NAME_PATTERN = re.compile(r"^mcp__.+__pull_request_review_write$")
+REVIEW_WRITE_METHOD_KEY = "method"
+RESOLVE_THREAD_METHOD = "resolve_thread"
 ALL_REPLY_TOOL_NAME_SUFFIXES = ("__add_reply_to_pull_request_comment",)
 SHELL_COMMAND_KEY = "command"
 SHELL_REPLY_COMMAND_PATTERN = re.compile(
     r"\bgh\s+api\b.*(?:/comments/\d+/replies\b|addPullRequestReviewThreadReply)", re.DOTALL
 )
+SHELL_RESOLVE_COMMAND_PATTERN = re.compile(r"\bgh\s+api\s+graphql\b.*\bresolveReviewThread\b", re.DOTALL)
+SHELL_RESOLVE_COMMENT_ID_PATTERN = re.compile(r"/pulls/\d+/ccr/comments/(\d+)/resolve\b")
+ALL_THREAD_ID_INPUT_KEYS = ("threadID", "threadId")
+COMMENT_ID_INPUT_KEY = "commentId"
+THREAD_ID_PATTERN = re.compile(r"\bPRRT_[A-Za-z0-9_-]+")
+COMMENT_ANCHOR_PATTERN = re.compile(r"(?:discussion_r|\"databaseId\"\s*:\s*)(\d+)")
+SHELL_REPLY_COMMENT_ID_PATTERN = re.compile(r"/comments/(\d+)/replies\b")
+TEXT_BLOCK_TYPE = "text"
+TEXT_FIELD = "text"
 MISSING_REPLY_REASON = (
-    "This review thread has no reply that posted since the last user prompt and the last resolve."
-    " Post the reply with add_reply_to_pull_request_comment, confirm its result came back without"
-    " an error, then resolve the thread. A reply that a hook refused did not post; shorten it to"
+    "This review thread has no reply on it that posted since the last user prompt and the last"
+    " resolve of the thread. Post the reply on this thread with add_reply_to_pull_request_comment,"
+    " or with gh api graphql addPullRequestReviewThreadReply and the thread's PRRT_ id, confirm its"
+    " result came back without an error, then resolve the thread by its PRRT_ id or by the comment id the reply answered. A comment id"
+    " ties to a thread only through a pull_request_read get_review_comments result in this session."
+    " A reply that a hook refused did not post; shorten it to"
     f" at most {MAXIMUM_SENTENCE_COUNT} sentences of at most {MAXIMUM_WORDS_PER_SENTENCE} words each,"
     " footer included, and send it again."
 )

package/hooks/hooks_constants/session_title_constants.py

@@ -60,8 +60,21 @@ ALL_TOOL_LISTING_RECORD_KEYS = ("tools", "entries")
 REMOVED_NAMES_KEY = "removedNames"
 TITLE_TOOL_DISPLAY_SEPARATOR = " or "
 
+SESSION_ID_KEY = "session_id"
+BLOCK_INPUT_KEY = "input"
+RED_FLAG_STATUS = "\U0001f6a9"
+CHECK_MARK_STATUS = "\u2705"
+HOURGLASS_STATUS = "\u23f3"
+NO_TITLE_REASON = "This session has no title yet."
+STALE_FLAG_REASON = (
+    "The title '{title}' still shows the red flag from before the user's last message,"
+    " and that message gave you work."
+)
+OPEN_ITEMS_REASON = "The title '{title}' shows the work as done, and the task list has open items."
+ALL_ITEMS_COMPLETED_REASON = "The title '{title}' shows work running, and every task list item is completed or deleted."
+
 TURN_BLOCK_REASON = (
-    "This turn set no session title. Call {tool_name} now with '<emoji> <name>':"
+    "{why} Call {tool_name} now with '<emoji> <name>' for the current status:"
     " \U0001f6a9 the user must act, \U0001f6a7 an outside dependency blocks the work,"
     " \u2705 the work is done, \u23f3 work runs and nothing waits on the user."
     " When the tool is deferred, load its schema with ToolSearch first."
@@ -69,3 +82,8 @@ TURN_BLOCK_REASON = (
     " After the call, end the turn with one short closing sentence."
     " Leave the earlier reply as it stands and do not repeat it."
 )
+ALL_STALE_AT_START_STATUSES = frozenset({RED_FLAG_STATUS, CHECK_MARK_STATUS})
+TITLE_NUDGE_TEMPLATE = (
+    "The session title shows '{title}' from before this message. Set it with {tool_name} to"
+    " '⏳ <name>' before other work, so the user sees the session working."
+)

package/hooks/open_task_asks.py

@@ -1,67 +1,33 @@
-"""Per-session record of the user's prompts, read by the open tasks Stop gate.
+"""Tell a prompt that asks for work from one that does not.
 
-Every prompt lands in one file outside the task store::
-
-    ~/.claude/open-task-asks/<session id>.json
-    {"prompts": [{"text": "...", "recorded_at": 1761076800.0, "ask_id": "ask-1"}, ...]}
-
-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 ``ask_id`` null, and the gate still reads their
-text when it checks the quote on a ``Dropped:`` line.
+The open tasks Stop gate, the session title gate, and the ask tracking nudge
+read a prompt through ``is_ask``. 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>``
+ask for no work.
 """
 
 from __future__ import annotations
 
-import json
 import os
 import re
-import time
 from pathlib import Path
-from typing import NamedTuple
 
-from atomic_file_writer import write_text_atomically
 from hooks_constants.open_tasks_stop_gate_constants import (
     ACKNOWLEDGEMENT_PATTERN,
     ALL_ASK_ONLY_ENVELOPE_MARKERS,
-    ASK_ID_TEMPLATE,
-    ASK_PROMPT_ID_KEY,
-    ASK_PROMPT_RECORDED_AT_KEY,
-    ASK_PROMPT_TEXT_KEY,
-    ASKS_DIRECTORY_NAME,
-    ASKS_FILE_SUFFIX,
-    ASKS_PROMPTS_KEY,
-    ASKS_TEMPORARY_PREFIX,
-    ASKS_TEMPORARY_SUFFIX,
     CLAUDE_CONFIG_DIRECTORY_ENVIRONMENT_VARIABLE,
     CLAUDE_HOME_DIRECTORY_NAME,
     INTERROGATIVE_START_PATTERN,
     POLITE_REQUEST_START_PATTERN,
     QUESTION_END_PATTERN,
-    SAFE_SESSION_ID_PATTERN,
     SENTENCE_SPLIT_PATTERN,
     SYSTEM_REMINDER_BLOCK_PATTERN,
-    UTF8_ENCODING,
     YES_OR_NO_END_PATTERN,
 )
 from hooks_constants.spawn_readiness_hook_constants import ALL_HARNESS_ENVELOPE_MARKERS
 
 
-class RecordedPrompt(NamedTuple):
-    """One prompt the user sent.
-
-    Attributes:
-        text: The prompt as the user sent it, with ``<system-reminder>`` blocks removed.
-        recorded_at: Seconds since the epoch when the recorder saw it.
-        ask_id: ``ask-N`` for a prompt that asks for work, or None.
-    """
-
-    text: str
-    recorded_at: float
-    ask_id: str | None
-
-
 def claude_home() -> Path:
     """Return the Claude home directory, honoring ``CLAUDE_CONFIG_DIR``."""
     configured_directory = os.environ.get(CLAUDE_CONFIG_DIRECTORY_ENVIRONMENT_VARIABLE)
@@ -70,12 +36,6 @@ def claude_home() -> Path:
     return Path.home() / CLAUDE_HOME_DIRECTORY_NAME
 
 
-def _asks_file(session_id: object) -> Path | None:
-    if not isinstance(session_id, str) or not re.fullmatch(SAFE_SESSION_ID_PATTERN, session_id):
-        return None
-    return claude_home() / ASKS_DIRECTORY_NAME / (session_id + ASKS_FILE_SUFFIX)
-
-
 def is_question_only(prompt_text: str) -> bool:
     """Return True when the prompt asks a question and asks for no work.
 
@@ -122,58 +82,3 @@ def is_ask(prompt_text: str) -> bool:
     if re.fullmatch(ACKNOWLEDGEMENT_PATTERN, stripped_text, re.IGNORECASE):
         return False
     return not is_question_only(stripped_text)
-
-
-def recorded_prompts(session_id: object) -> list[RecordedPrompt]:
-    """Return every prompt recorded for the session, oldest first."""
-    asks_file = _asks_file(session_id)
-    if asks_file is None:
-        return []
-    try:
-        all_file_fields = json.loads(asks_file.read_text(encoding=UTF8_ENCODING))
-    except (OSError, ValueError):
-        return []
-    all_entries = (
-        all_file_fields.get(ASKS_PROMPTS_KEY) if isinstance(all_file_fields, dict) else None
-    )
-    if not isinstance(all_entries, list):
-        return []
-    return [
-        _parsed_prompt(each_entry) for each_entry in all_entries if isinstance(each_entry, dict)
-    ]
-
-
-def _parsed_prompt(all_entry_fields: dict[str, object]) -> RecordedPrompt:
-    recorded_at = all_entry_fields.get(ASK_PROMPT_RECORDED_AT_KEY)
-    ask_id = all_entry_fields.get(ASK_PROMPT_ID_KEY)
-    return RecordedPrompt(
-        str(all_entry_fields.get(ASK_PROMPT_TEXT_KEY, "")),
-        float(recorded_at) if isinstance(recorded_at, (int, float)) else 0.0,
-        ask_id if isinstance(ask_id, str) else None,
-    )
-
-
-def record_prompt(session_id: object, prompt_text: str) -> str | None:
-    """Append the prompt to the session's file and return its ``ask-N`` id, or None for no ask."""
-    asks_file = _asks_file(session_id)
-    if asks_file is None:
-        return None
-    all_prompts = recorded_prompts(session_id)
-    ask_count = sum(1 for each_prompt in all_prompts if each_prompt.ask_id)
-    ask_id = ASK_ID_TEMPLATE.format(ask_number=ask_count + 1) if is_ask(prompt_text) else None
-    all_prompts.append(RecordedPrompt(prompt_without_reminders(prompt_text), time.time(), ask_id))
-    serialized_text = json.dumps(
-        {ASKS_PROMPTS_KEY: [each_prompt._asdict() for each_prompt in all_prompts]}
-    )
-    try:
-        write_text_atomically(
-            asks_file,
-            serialized_text,
-            UTF8_ENCODING,
-            ASKS_TEMPORARY_PREFIX,
-            ASKS_TEMPORARY_SUFFIX,
-            False,
-        )
-    except OSError:
-        return None
-    return ask_id

package/hooks/session/test_tracking_nudge.py

@@ -0,0 +1,124 @@
+import importlib
+import io
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+_SESSION_DIR = Path(__file__).resolve().parent
+if str(_SESSION_DIR) not in sys.path:
+    sys.path.insert(0, str(_SESSION_DIR))
+
+tracking_nudge = importlib.import_module("tracking_nudge")
+
+NUDGE_PATH = _SESSION_DIR / "tracking_nudge.py"
+TITLE_TOOL = "mcp__claude-code-remote__set_session_title"
+TOOL_LISTING = {"type": "attachment", "attachment": {"tools": [{"name": TITLE_TOOL}]}}
+
+
+def titled_entries(title: str) -> list[dict[str, object]]:
+    title_use = {"type": "tool_use", "id": "t1", "name": TITLE_TOOL, "input": {"title": title}}
+    title_done = {"type": "tool_result", "tool_use_id": "t1", "content": "ok"}
+    return [
+        TOOL_LISTING,
+        {"type": "assistant", "message": {"content": [title_use]}},
+        {"type": "user", "message": {"content": [title_done]}},
+    ]
+
+
+def run_nudge(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    tmp_path: Path,
+    prompt_text: str,
+    all_entries: list[dict[str, object]],
+) -> str:
+    transcript_path = tmp_path / "s.jsonl"
+    transcript_path.write_text(
+        "\n".join(json.dumps(each) for each in all_entries), encoding="utf-8"
+    )
+    hook_input = {
+        "hook_event_name": "UserPromptSubmit",
+        "prompt": prompt_text,
+        "transcript_path": str(transcript_path),
+    }
+    monkeypatch.setattr(
+        "sys.stdin", io.TextIOWrapper(io.BytesIO(json.dumps(hook_input).encode("utf-8")))
+    )
+    assert tracking_nudge.main() == 0
+    printed_output = capsys.readouterr().out
+    return (
+        json.loads(printed_output)["hookSpecificOutput"]["additionalContext"]
+        if printed_output
+        else ""
+    )
+
+
+def test_should_remind_a_work_prompt_to_use_the_task_list(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    context_text = run_nudge(
+        monkeypatch, capsys, tmp_path, "Export the APKs", titled_entries("⏳ Export")
+    )
+    assert "TaskCreate" in context_text
+    assert "⏳ Export" not in context_text
+
+
+@pytest.mark.parametrize("earlier_title", ["\U0001f6a9 Merge approval", "✅ Gate"])
+def test_should_ask_to_refresh_a_title_that_says_the_session_waits_or_is_done(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    tmp_path: Path,
+    earlier_title: str,
+) -> None:
+    context_text = run_nudge(
+        monkeypatch, capsys, tmp_path, "Export the APKs", titled_entries(earlier_title)
+    )
+    assert earlier_title in context_text
+    assert TITLE_TOOL in context_text
+
+
+@pytest.mark.parametrize(
+    "prompt_text",
+    ["did the export fail?", "thanks!", "<task-notification>done</task-notification>"],
+)
+def test_should_stay_silent_for_a_prompt_that_asks_for_no_work(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    tmp_path: Path,
+    prompt_text: str,
+) -> None:
+    assert (
+        run_nudge(
+            monkeypatch, capsys, tmp_path, prompt_text, titled_entries("\U0001f6a9 Merge approval")
+        )
+        == ""
+    )
+
+
+def test_should_skip_the_title_note_in_a_session_without_the_title_tool() -> None:
+    assert tracking_nudge.title_nudge([]) is None
+    assert tracking_nudge.title_nudge(titled_entries("✅ Gate")) is not None
+
+
+def test_should_build_the_note_only_for_a_work_prompt() -> None:
+    assert tracking_nudge.ask_tracking_context("did it fail?", []) is None
+    assert "task list" in (tracking_nudge.ask_tracking_context("Export the APKs", []) or "")
+
+
+def test_should_print_the_documented_output_through_a_subprocess(tmp_path: Path) -> None:
+    hook_input = {"hook_event_name": "UserPromptSubmit", "prompt": "Export the APKs"}
+    completed_process = subprocess.run(
+        [sys.executable, str(NUDGE_PATH)],
+        input=json.dumps(hook_input),
+        capture_output=True,
+        text=True,
+        env={"HOME": str(tmp_path), "USERPROFILE": str(tmp_path), "PATH": ""},
+        check=False,
+    )
+    assert completed_process.returncode == 0
+    hook_output = json.loads(completed_process.stdout)["hookSpecificOutput"]
+    assert hook_output["hookEventName"] == "UserPromptSubmit"
+    assert "TaskCreate" in hook_output["additionalContext"]

package/hooks/session/tracking_nudge.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""UserPromptSubmit hook that reminds the agent to track a new ask before it starts.
+
+The user follows a session in two places: the task list shows what the agent
+does, and the title's status emoji shows whether the session needs them. A new
+ask changes both, so the hook adds one short ``additionalContext`` note when the
+prompt asks for work::
+
+    "Export the APKs"                        -> task list note
+    "Export the APKs", title shows a red flag or a check mark
+                                             -> task list note + title note
+    "did the export fail?"                   -> nothing
+    "<task-notification>...</task-notification>"
+                                             -> nothing
+
+The note never blocks. The Stop gates ``open_tasks_stop_gate.py`` and
+``session_title_turn_gate.py`` hold the turn once only when the agent skipped it.
+The title note needs the title tool in the transcript, as the title gate does.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+hooks_root_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_root_directory not in sys.path:
+    sys.path.insert(0, hooks_root_directory)
+blocking_directory = str(Path(__file__).resolve().parent.parent / "blocking")
+if blocking_directory not in sys.path:
+    sys.path.insert(0, blocking_directory)
+
+from hooks_constants.open_tasks_stop_gate_constants import (
+    ALLOW_EXIT_CODE,
+    PROMPT_KEY,
+    PROMPT_SUBMIT_EVENT_NAME,
+    TASK_LIST_NUDGE,
+    TRANSCRIPT_PATH_KEY,
+    WORD_SEPARATOR,
+)
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+from hooks_constants.session_title_constants import (
+    ALL_STALE_AT_START_STATUSES,
+    TITLE_NUDGE_TEMPLATE,
+    TITLE_TOOL_DISPLAY_SEPARATOR,
+)
+from open_task_asks import is_ask
+from session_title_turn_gate import (
+    available_title_tools,
+    read_transcript_entries,
+    shown_title,
+    title_status,
+)
+
+
+def title_nudge(all_entries: list[dict[str, object]]) -> str | None:
+    """Return the title note when the shown title says the session waits or is done, else None.
+
+    ::
+
+        title tool listed, shows "\U0001f6a9 Merge approval"   -> note naming that title
+        title tool listed, shows "⏳ Export"               -> None
+        no title tool in the transcript                         -> None
+
+    Args:
+        all_entries: The transcript entries, oldest first.
+
+    Returns:
+        The note text, or None.
+    """
+    all_title_tools = available_title_tools(all_entries)
+    title = shown_title(all_entries)
+    if (
+        not all_title_tools
+        or title is None
+        or title_status(title) not in ALL_STALE_AT_START_STATUSES
+    ):
+        return None
+    return TITLE_NUDGE_TEMPLATE.format(
+        title=title, tool_name=TITLE_TOOL_DISPLAY_SEPARATOR.join(all_title_tools)
+    )
+
+
+def ask_tracking_context(prompt_text: str, all_entries: list[dict[str, object]]) -> str | None:
+    """Return the note for a prompt that asks for work, or None for any other prompt."""
+    if not is_ask(prompt_text):
+        return None
+    all_notes = [TASK_LIST_NUDGE, title_nudge(all_entries)]
+    return WORD_SEPARATOR.join(each_note for each_note in all_notes if each_note)
+
+
+def main() -> int:
+    hook_input = read_hook_input_dictionary_from_stdin()
+    prompt_value = hook_input.get(PROMPT_KEY) if hook_input is not None else None
+    if hook_input is None or not isinstance(prompt_value, str):
+        return ALLOW_EXIT_CODE
+    context_text = ask_tracking_context(
+        prompt_value, read_transcript_entries(hook_input.get(TRANSCRIPT_PATH_KEY))
+    )
+    if context_text:
+        hook_output = {
+            "hookSpecificOutput": {
+                "hookEventName": PROMPT_SUBMIT_EVENT_NAME,
+                "additionalContext": context_text,
+            }
+        }
+        sys.stdout.write(json.dumps(hook_output))
+    return ALLOW_EXIT_CODE
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/test_open_task_asks.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 import pytest
 
-from open_task_asks import is_ask, record_prompt, recorded_prompts
+from open_task_asks import claude_home, is_ask
 
 
 @pytest.fixture(autouse=True)
@@ -41,17 +41,10 @@ def test_should_classify_work_prompts_as_asks(prompt_text: str, is_expected_ask:
     assert is_ask(prompt_text) is is_expected_ask
 
 
-def test_should_number_asks_and_keep_every_prompt_in_order() -> None:
-    assert record_prompt("s-1", "Export the APKs") == "ask-1"
-    assert record_prompt("s-1", "did it fail?") is None
-    assert record_prompt("s-1", "Submit them") == "ask-2"
-    assert [each_prompt.ask_id for each_prompt in recorded_prompts("s-1")] == [
-        "ask-1",
-        None,
-        "ask-2",
-    ]
+def test_should_read_the_claude_home_from_claude_config_dir(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(tmp_path / "profile"))
+    assert claude_home() == tmp_path / "profile"
 
 
-def test_should_skip_a_session_id_that_is_not_a_plain_name() -> None:
-    assert record_prompt("../escape", "Export the APKs") is None
-    assert recorded_prompts("../escape") == []
+def test_should_default_the_claude_home_to_the_user_home(tmp_path: Path) -> None:
+    assert claude_home() == tmp_path / ".claude"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.98.8",
+    "version": "8.98.10",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/rules/index.md

@@ -24,7 +24,7 @@ Each line gives a rule in brief. When its trigger matches your task, open the gu
 **Shipping**
 - **Pull request lifecycle**. Before a commit, push, pull request action, or merge. Invoke the `pr-lifecycle` skill; a hook denies those commands until it loads.
 - **Proof before a pull request** ([guide](../docs/rule-guides/proof-before-pull-request.md)). Before you open a pull request. Run the change with and without it, and quote both under "Proof in practice".
-- **Session title** ([guide](../docs/rule-guides/session-title.md)). The session has a tool whose name ends in `__set_session_title`. Set `<emoji> <name>` before each turn ends.
+- **Session title** ([guide](../docs/rule-guides/session-title.md)). The session has a tool whose name ends in `__set_session_title`. Set `<emoji> <name>` when the status changes.
 
 **Memory**
 - **Durable facts only** ([guide](../docs/rule-guides/memory-stores-durable-facts.md)). Writing auto-memory or a `MEMORY.md` entry. Keep only a fact that helps a fresh session weeks later.

package/scripts/policy_lint/adapter_configuration.py

@@ -175,8 +175,9 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
     asks the model to check a hedged claim, and the call it reads stays in place.
 
     The session title gates keep the session title in its status format. One
-    denies a malformed title, and the other asks for a title before a turn
-    ends. They decide the shape of a title and no code or safety policy.
+    denies a malformed title, and the other asks for a new title when the
+    shown status stops fitting. They decide the shape of a title and no code
+    or safety policy.
 
     The artifact page gate denies a page publish whose text is unreadable in
     dark mode. It decides how a page renders and no code or safety policy.
@@ -193,10 +194,9 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
     names open review findings. It reads only the wording of a chat card and
     decides no code or safety policy; the merge review gate holds the merge.
 
-    The open tasks Stop gate holds the end of a turn while the session's task
-    list has items the closing reply neither completes nor reports as
-    ``Blocked:`` or ``Open:``. It decides when a turn may end and no code or
-    safety policy.
+    The open tasks Stop gate holds the end of a turn once when the turn worked
+    on an ask and made no task list call. It decides when a turn may end and
+    no code or safety policy.
 
     The owned pull request Stop gate holds the end of a turn while a pull
     request the session opened on an owned repository is still open and the