claude-dev-env 8.87.1 → 8.88.1

package/hooks/features/session-context.md

@@ -18,6 +18,7 @@ This family injects reminders and task guidance when an agent starts, resumes, s
 - `session/skill_loaded_reminder.py` runs on `PreToolUse` matcher `Agent|Task` at `10` seconds, `UserPromptSubmit` matcher empty at `10` seconds, `SessionStart` matcher `compact` at `10` seconds, and `SubagentStart` matcher `workflow-subagent` at `10` seconds in `hooks.json`.
 - `session/task_tool_prompt.py`, `session/working_style_prompt.py`, `session/advisor_rules_prompt.py`, and `session/orchestrator_auto_starter.py` run on `SessionStart`, matcher empty, timeout `10` seconds each in `hooks.json`.
 - `session/deepen_first_prompt.py` runs on `UserPromptSubmit`, matcher empty, timeout `10` seconds in `hooks.json`.
+- In Cursor, `session/deepen_first_prompt.py` also runs on `beforeSubmitPrompt`. Cursor passes that event name to the `UserPromptSubmit` copy it imports from the Claude Code settings too. When both copies run, `session/deepen_turn_marker.py` creates the turn marker only when it does not exist yet, so one copy injects. A later prompt skips when either the transcript marker or the session marker exists, or when the transcript already has a user line in Claude Code's or Cursor's shape.
 - `session/artifact_template_pointer.py` runs on `PreToolUse` matcher `Artifact|Skill` at `10` seconds in `hooks.json`. It speaks only on an `Artifact` call with action `quickstart` or a `Skill` call that loads `artifact-design`.
 - `advisory/auto_mode_denial_quick_fix.py` runs on `PermissionDenied`, matcher `*`, timeout `10` seconds in `hooks.json`.
 
@@ -32,7 +33,7 @@ Preconditions:
 - **Working style.** Input is a SessionStart event. Run `python -m pytest packages/claude-dev-env/hooks/session/test_working_style_prompt.py -q`. The adjacent test observes the fixed context text.
 - **Advisor guidance.** Input is SessionStart with `advisorModel` set. Run `python -m pytest packages/claude-dev-env/hooks/session/test_advisor_rules_prompt.py -q`. The adjacent test observes guidance only when the advisor setting is enabled.
 - **Orchestrator start.** Input is SessionStart with its opt-in flag set. Run `python -m pytest packages/claude-dev-env/hooks/session/test_orchestrator_auto_starter.py -q`. The adjacent test observes an orchestrator directive.
-- **First-task deepen.** Input is a first UserPromptSubmit task. Run `python -m pytest packages/claude-dev-env/hooks/session/test_deepen_first_prompt.py -q`. The adjacent test observes a skip table, a refusal of the paste path, and a rewrite that carries the SCOPE, EXAMPLES, and ZOOM-IN BLOCKER lines.
+- **First-task deepen.** Input is a first UserPromptSubmit task. Run `python -m pytest packages/claude-dev-env/hooks/session/test_deepen_first_prompt.py -q`. The adjacent test observes a skip table, a refusal of the paste path, a rewrite that carries the SCOPE, EXAMPLES, and ZOOM-IN BLOCKER lines, and one injection when two copies see the same Cursor prompt. `python -m pytest packages/claude-dev-env/hooks/session/test_deepen_turn_marker.py -q` observes that only the first marker claim wins.
 - **Artifact template pointer.** Input is an `Artifact` quickstart call. Run `python -m pytest packages/claude-dev-env/hooks/session/test_artifact_template_pointer.py -q`. The adjacent test observes the status flowchart path first, the html-plan path ahead of the template path in `additionalContext`, and silence on a publish call or another skill.
 - **Denial quick fix.** Input is a `PermissionDenied` event with a bracketed rule label and a classifier verdict. Run `python -m pytest packages/claude-dev-env/hooks/advisory/test_auto_mode_denial_quick_fix.py -q`. The adjacent test observes the named rule, the allow entry, and the PowerShell block; a denial with no verdict gets a note and no block.
 

package/hooks/hooks.json

@@ -379,6 +379,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/final_reply_gate.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/open_tasks_stop_gate.py",
+            "timeout": 10
           }
         ]
       }

package/hooks/hooks_constants/cursor_agents_guidance_constants.py

@@ -0,0 +1,6 @@
+"""Constants for cursor_agents_guidance.py, the Cursor SessionStart hook."""
+
+GUIDANCE_PATH_ARGUMENT_INDEX = 1
+CURSOR_CONTEXT_KEY = "additional_context"
+UTF8_ENCODING = "utf-8"
+EMPTY_OUTPUT = "{}"

package/hooks/hooks_constants/deepen_first_prompt_constants.py

@@ -45,6 +45,9 @@ __all__ = [
     "DEEPEN_SLASH_COMMAND",
     "DEEPEN_TIMEOUT_SECONDS",
     "DEEPEN_TURN_MARKER_SUFFIX",
+    "DEEPEN_SESSION_MARKER_PREFIX",
+    "ALL_FIRST_PROMPT_EVENT_NAMES",
+    "CURSOR_BEFORE_SUBMIT_PROMPT_EVENT_NAME",
     "HOOK_EVENT_NAME_KEY",
     "HOOK_SPECIFIC_OUTPUT_KEY",
     "JSONL_ROLE_KEY",
@@ -66,10 +69,15 @@ DEEPEN_MARKER: str = "CDE_DEEPEN:v1"
 DEEPEN_AGENT_MARKER: str = "CDE_DEEPEN_AGENT"
 DEEPEN_SLASH_COMMAND: str = "/deepen"
 DEEPEN_TURN_MARKER_SUFFIX: str = ".cde-deepen-turn1"
+DEEPEN_SESSION_MARKER_PREFIX: str = "cde-deepen-"
 DEEPEN_TIMEOUT_SECONDS: int = 10
 DEEPEN_COMMAND_TIMEOUT_MARGIN_SECONDS: int = 2
 DEEPEN_COMMAND_TIMEOUT_SECONDS: int = DEEPEN_TIMEOUT_SECONDS - DEEPEN_COMMAND_TIMEOUT_MARGIN_SECONDS
 USER_PROMPT_SUBMIT_EVENT_NAME: str = "UserPromptSubmit"
+CURSOR_BEFORE_SUBMIT_PROMPT_EVENT_NAME: str = "beforeSubmitPrompt"
+ALL_FIRST_PROMPT_EVENT_NAMES: frozenset[str] = frozenset(
+    {USER_PROMPT_SUBMIT_EVENT_NAME, CURSOR_BEFORE_SUBMIT_PROMPT_EVENT_NAME}
+)
 PROMPT_FIELD_NAME: str = "prompt"
 TRANSCRIPT_PATH_FIELD_NAME: str = "transcript_path"
 SESSION_ID_FIELD_NAME: str = "session_id"

package/hooks/hooks_constants/open_tasks_stop_gate_constants.py

@@ -0,0 +1,72 @@
+"""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
+UTF8_ENCODING = "utf-8"
+WORD_SEPARATOR = " "
+TASK_LIST_ID_ENVIRONMENT_VARIABLE = "CLAUDE_CODE_TASK_LIST_ID"
+CLAUDE_CONFIG_DIRECTORY_ENVIRONMENT_VARIABLE = "CLAUDE_CONFIG_DIR"
+CLAUDE_HOME_DIRECTORY_NAME = ".claude"
+TASKS_DIRECTORY_NAME = "tasks"
+TASK_FILE_GLOB = "*.json"
+TASK_ID_KEY = "id"
+TASK_SUBJECT_KEY = "subject"
+TASK_STATUS_KEY = "status"
+PENDING_STATUS = "pending"
+INCOMPLETE_STATUSES = frozenset({PENDING_STATUS, "in_progress"})
+RECORD_TYPE_KEY = "type"
+MESSAGE_KEY = "message"
+CONTENT_KEY = "content"
+TEXT_KEY = "text"
+TOOL_NAME_KEY = "name"
+TOOL_INPUT_KEY = "input"
+TOOL_USE_ID_KEY = "tool_use_id"
+TODOS_KEY = "todos"
+TODO_CONTENT_KEY = "content"
+TODO_ID_KEY = "id"
+TODO_MERGE_KEY = "merge"
+ROLE_KEY = "role"
+ASSISTANT_ROLE = "assistant"
+CURSOR_CONVERSATION_ID_KEY = "conversation_id"
+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"
+DYNAMIC_TOOL_NAME_KEY = "toolName"
+DYNAMIC_TOOL_ARGUMENTS_KEY = "arguments"
+TASK_CREATE_TOOL_NAME = "TaskCreate"
+TASK_UPDATE_TOOL_NAME = "TaskUpdate"
+TOOL_USE_BLOCK_TYPE = "tool_use"
+TOOL_RESULT_BLOCK_TYPE = "tool_result"
+CODEX_RESPONSE_ITEM_TYPE = "response_item"
+CODEX_FUNCTION_CALL_TYPE = "function_call"
+CODEX_PAYLOAD_KEY = "payload"
+CODEX_ARGUMENTS_KEY = "arguments"
+CODEX_PLAN_TOOL_NAME = "update_plan"
+CODEX_PLAN_KEY = "plan"
+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."
+)

package/hooks/session/cursor_agents_guidance.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Cursor sessionStart hook that puts the installed agent guidance into every session.
+
+Cursor keeps user rules in its app settings, and it reads ``~/.cursor/rules``
+only for a workspace inside the home directory, so no file under ``~/.cursor``
+carries global guidance. The installer registers this hook as a native
+``sessionStart`` entry in ``~/.cursor/hooks.json`` with the installed
+``AGENTS.md`` path as its one argument. The hook prints that file as Cursor's
+``additional_context``, which Cursor adds to the session's context::
+
+    python3 cursor_agents_guidance.py ~/.agents/AGENTS.md
+    -> {"additional_context": "# Agent guidance ..."}
+
+A missing or unreadable file prints ``{}`` so the session starts without it.
+"""
+
+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)
+
+from hooks_constants.cursor_agents_guidance_constants import (
+    CURSOR_CONTEXT_KEY,
+    EMPTY_OUTPUT,
+    GUIDANCE_PATH_ARGUMENT_INDEX,
+    UTF8_ENCODING,
+)
+
+
+def guidance_output(all_arguments: list[str]) -> str:
+    """Return the SessionStart output for the guidance file named in the arguments."""
+    if len(all_arguments) <= GUIDANCE_PATH_ARGUMENT_INDEX:
+        return EMPTY_OUTPUT
+    try:
+        guidance_text = Path(all_arguments[GUIDANCE_PATH_ARGUMENT_INDEX]).read_text(encoding=UTF8_ENCODING)
+    except OSError:
+        return EMPTY_OUTPUT
+    if not guidance_text.strip():
+        return EMPTY_OUTPUT
+    return json.dumps({CURSOR_CONTEXT_KEY: guidance_text})
+
+
+def main() -> None:
+    sys.stdin.read()
+    sys.stdout.write(guidance_output(sys.argv))
+
+
+if __name__ == "__main__":
+    main()

package/hooks/session/deepen_first_prompt.py

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 """UserPromptSubmit hook: deepen the first interactive task before work starts.
 
+Cursor runs it on ``beforeSubmitPrompt`` too, and passes that event name to
+the copy it imports from the Claude Code settings, so both names count as a
+first prompt. When both copies run, the turn marker lets one inject.
+
 Skip checks stay local. One bounded deepen call runs only for a first task.
 Claude settings and Codex cannot replace the prompt string, so this hook emits
 additionalContext. Claude desktop and CLI also ship a prompt.submit mod that
@@ -26,6 +30,7 @@ if _hooks_dir not in sys.path:
 from hooks_constants.cloud_session import is_cloud_session
 from hooks_constants.deepen_first_prompt_constants import (
     ADDITIONAL_CONTEXT_KEY,
+    ALL_FIRST_PROMPT_EVENT_NAMES,
     ALL_FOUR_QUESTION_STEMS,
     QUESTION_LINE_SEPARATOR,
     ALL_HELPER_REPORT_MARKERS,
@@ -45,7 +50,6 @@ from hooks_constants.deepen_first_prompt_constants import (
     DEEPEN_OUTPUT_REWRITE,
     DEEPEN_REWRITE_ENV_VAR,
     DEEPEN_SLASH_COMMAND,
-    DEEPEN_TURN_MARKER_SUFFIX,
     HOOK_EVENT_NAME_KEY,
     HOOK_SPECIFIC_OUTPUT_KEY,
     JSONL_ROLE_KEY,
@@ -53,7 +57,6 @@ from hooks_constants.deepen_first_prompt_constants import (
     NONINTERACTIVE_CODEX_ENV_VAR,
     NONINTERACTIVE_PRINT_ENV_VAR,
     PROMPT_FIELD_NAME,
-    SESSION_ID_FIELD_NAME,
     SKIP_DEEPEN_ENV_VAR,
     SKIP_DEEPEN_TRUE_VALUE,
     TRANSCRIPT_PATH_FIELD_NAME,
@@ -66,6 +69,7 @@ from hooks_constants.mod_handoff import is_mod_plugin_enabled
 from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
 from hooks_constants.subprocess_window import hidden_window_creation_flags
 from deepen_role_gate import refusal_reason
+from deepen_turn_marker import claim_turn_marker, turn_marker_exists
 
 
 class SkipReason(StrEnum):
@@ -146,6 +150,8 @@ def _is_user_entry(all_entry_fields: dict[str, object] | None) -> bool:
         return False
     if all_entry_fields.get(JSONL_TYPE_KEY) == USER_TYPE_NAME:
         return True
+    if all_entry_fields.get(JSONL_ROLE_KEY) == USER_ROLE_NAME:
+        return True
     message = all_entry_fields.get("message")
     return isinstance(message, dict) and message.get(JSONL_ROLE_KEY) == USER_ROLE_NAME
 
@@ -160,32 +166,6 @@ def _transcript_has_prior_user_turn(transcript_path: object) -> bool:
         return False
 
 
-def _turn_marker_path(all_hook_fields: dict[str, object]) -> Path | None:
-    transcript_path = all_hook_fields.get(TRANSCRIPT_PATH_FIELD_NAME)
-    if isinstance(transcript_path, str) and transcript_path:
-        return Path(transcript_path + DEEPEN_TURN_MARKER_SUFFIX)
-    session_id = all_hook_fields.get(SESSION_ID_FIELD_NAME)
-    if isinstance(session_id, str) and session_id:
-        return Path(os.environ.get("TMPDIR", "/tmp")) / f"cde-deepen-{session_id}"
-    return None
-
-
-def _turn_marker_exists(all_hook_fields: dict[str, object]) -> bool:
-    marker_path = _turn_marker_path(all_hook_fields)
-    return marker_path is not None and marker_path.is_file()
-
-
-def write_turn_marker(all_hook_fields: dict[str, object]) -> None:
-    """Record that this session already deepened turn one."""
-    marker_path = _turn_marker_path(all_hook_fields)
-    if marker_path is None:
-        return
-    try:
-        marker_path.write_text(DEEPEN_MARKER, encoding=UTF8_ENCODING)
-    except OSError:
-        return
-
-
 def _environment_skip_reason() -> SkipReason | None:
     if os.environ.get(SKIP_DEEPEN_ENV_VAR, "").strip() == SKIP_DEEPEN_TRUE_VALUE:
         return SkipReason.SKIP_FLAG
@@ -224,13 +204,13 @@ def _shape_skip_reason(prompt: str) -> SkipReason | None:
 def skip_reason_for(all_hook_fields: dict[str, object]) -> SkipReason | None:
     """Return the first skip that matches, or None when the gate should deepen."""
     event_name = all_hook_fields.get("hook_event_name")
-    if event_name not in (USER_PROMPT_SUBMIT_EVENT_NAME, None, ""):
+    if event_name not in ALL_FIRST_PROMPT_EVENT_NAMES and event_name not in (None, ""):
         return SkipReason.LATER_TURN
     prompt = submitted_prompt_text(all_hook_fields)
     reason = _environment_skip_reason() or _marker_skip_reason(prompt) or _shape_skip_reason(prompt)
     if reason is not None:
         return reason
-    if _turn_marker_exists(all_hook_fields) or _transcript_has_prior_user_turn(
+    if turn_marker_exists(all_hook_fields) or _transcript_has_prior_user_turn(
         all_hook_fields.get(TRANSCRIPT_PATH_FIELD_NAME)
     ):
         return SkipReason.LATER_TURN
@@ -388,7 +368,8 @@ def emit_decision(decision: DeepenDecision, all_hook_fields: dict[str, object])
         if output_mode == DEEPEN_OUTPUT_JSON:
             _print_refuse_json(decision.reason)
         return
-    write_turn_marker(all_hook_fields)
+    if not claim_turn_marker(all_hook_fields):
+        return
     if output_mode == DEEPEN_OUTPUT_JSON:
         _print_deepen_json(decision)
         return

package/hooks/session/deepen_turn_marker.py

@@ -0,0 +1,75 @@
+"""Turn-one marker for the first-task deepen hook.
+
+The marker records that a session already deepened its first task, so later
+prompts stay untouched. A host can run two copies of the hook for one prompt:
+Cursor runs its own ``beforeSubmitPrompt`` entry and the ``UserPromptSubmit``
+entry it imports from the Claude Code settings, side by side. Each copy claims
+the marker by creating the file only when it does not exist yet, so exactly
+one copy wins and injects.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+from hooks_constants.deepen_first_prompt_constants import (
+    DEEPEN_MARKER,
+    DEEPEN_SESSION_MARKER_PREFIX,
+    DEEPEN_TURN_MARKER_SUFFIX,
+    SESSION_ID_FIELD_NAME,
+    TRANSCRIPT_PATH_FIELD_NAME,
+    UTF8_ENCODING,
+)
+
+
+def _all_turn_marker_paths(all_hook_fields: dict[str, object]) -> list[Path]:
+    all_marker_paths: list[Path] = []
+    transcript_path = all_hook_fields.get(TRANSCRIPT_PATH_FIELD_NAME)
+    if isinstance(transcript_path, str) and transcript_path:
+        all_marker_paths.append(Path(transcript_path + DEEPEN_TURN_MARKER_SUFFIX))
+    session_id = all_hook_fields.get(SESSION_ID_FIELD_NAME)
+    if isinstance(session_id, str) and session_id:
+        all_marker_paths.append(Path(tempfile.gettempdir()) / f"{DEEPEN_SESSION_MARKER_PREFIX}{session_id}")
+    return all_marker_paths
+
+
+def turn_marker_path(all_hook_fields: dict[str, object]) -> Path | None:
+    """Return the marker path for this session, or None when the payload names none.
+
+    The transcript path wins when the payload has one. Cursor sends no transcript
+    path before the first reply, so the session id names a file in the system
+    temp folder instead.
+    """
+    all_marker_paths = _all_turn_marker_paths(all_hook_fields)
+    return all_marker_paths[0] if all_marker_paths else None
+
+
+def turn_marker_exists(all_hook_fields: dict[str, object]) -> bool:
+    """Return True when this session already deepened a task.
+
+    Both marker locations count. Cursor's first prompt claims the session marker
+    because it has no transcript path yet, and a later prompt carries one.
+    """
+    return any(each_marker_path.is_file() for each_marker_path in _all_turn_marker_paths(all_hook_fields))
+
+
+def claim_turn_marker(all_hook_fields: dict[str, object]) -> bool:
+    """Create the marker, and return False when another copy created it first.
+
+    A payload with no transcript path or session id, or a marker that cannot be
+    written, returns True: the hook then deepens without a guard, as before.
+    """
+    marker_path = turn_marker_path(all_hook_fields)
+    if marker_path is None:
+        return True
+    try:
+        marker_descriptor = os.open(marker_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+    except FileExistsError:
+        return False
+    except OSError:
+        return True
+    with os.fdopen(marker_descriptor, "w", encoding=UTF8_ENCODING) as marker_file:
+        marker_file.write(DEEPEN_MARKER)
+    return True

package/hooks/session/test_cursor_agents_guidance.py

@@ -0,0 +1,24 @@
+import json
+import sys
+from pathlib import Path
+
+SESSION_DIRECTORY = Path(__file__).resolve().parent
+if str(SESSION_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(SESSION_DIRECTORY))
+
+import cursor_agents_guidance
+
+
+def test_should_emit_the_guidance_file_as_cursor_additional_context(tmp_path: Path) -> None:
+    guidance_path = tmp_path / "AGENTS.md"
+    guidance_path.write_text("# Agent guidance\n- **Asks.** Work every ask now.\n", encoding="utf-8")
+    printed_output = cursor_agents_guidance.guidance_output(["hook", str(guidance_path)])
+    assert json.loads(printed_output) == {"additional_context": guidance_path.read_text(encoding="utf-8")}
+
+
+def test_should_emit_an_empty_object_when_the_file_is_missing(tmp_path: Path) -> None:
+    assert cursor_agents_guidance.guidance_output(["hook", str(tmp_path / "absent.md")]) == "{}"
+
+
+def test_should_emit_an_empty_object_without_a_path_argument() -> None:
+    assert cursor_agents_guidance.guidance_output(["hook"]) == "{}"

package/hooks/session/test_deepen_first_prompt.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import sys
+import tempfile
 from io import StringIO
 from pathlib import Path
 from unittest.mock import patch
@@ -32,6 +33,7 @@ from hooks_constants.deepen_first_prompt_constants import (
     REFUSAL_RESTATES_FOUR_QUESTIONS,
     SKIP_DEEPEN_ENV_VAR,
     USER_PROMPT_SUBMIT_EVENT_NAME,
+    CURSOR_BEFORE_SUBMIT_PROMPT_EVENT_NAME,
 )
 from hooks_constants.skill_loaded_reminder_constants import CLAUDE_SUBAGENT_PROMPT_PREFIX
 
@@ -58,6 +60,10 @@ def _user_transcript_line() -> str:
     return json.dumps({"type": "user", "message": {"role": "user", "content": "earlier task"}})
 
 
+def _cursor_transcript_line(role: str, text: str) -> str:
+    return json.dumps({"role": role, "message": {"content": [{"type": "text", "text": text}]}})
+
+
 def _role_rewrite(body: str) -> str:
     return (
         f"{DEEPEN_MARKER}\n"
@@ -157,6 +163,24 @@ class TestSkipReasonFor:
     def test_should_deepen_a_first_task(self) -> None:
         assert deepen.skip_reason_for(_payload("Add dark mode to the settings page")) is None
 
+    def test_should_deepen_a_first_task_from_the_cursor_prompt_event(self) -> None:
+        fields = _payload("Add dark mode to the settings page")
+        fields["hook_event_name"] = CURSOR_BEFORE_SUBMIT_PROMPT_EVENT_NAME
+        assert deepen.skip_reason_for(fields) is None
+
+    def test_should_skip_when_a_cursor_transcript_already_has_a_user_turn(self, tmp_path: Path) -> None:
+        cursor_transcript_path = tmp_path / "cursor.jsonl"
+        cursor_transcript_path.write_text(_cursor_transcript_line("user", "earlier task"), encoding="utf-8")
+        fields = _payload("Add dark mode to the settings page", str(cursor_transcript_path))
+        fields["hook_event_name"] = CURSOR_BEFORE_SUBMIT_PROMPT_EVENT_NAME
+        fields.pop("session_id")
+        assert deepen.skip_reason_for(fields) is deepen.SkipReason.LATER_TURN
+
+    def test_should_skip_any_other_event(self) -> None:
+        fields = _payload("Add dark mode to the settings page")
+        fields["hook_event_name"] = "stop"
+        assert deepen.skip_reason_for(fields) is deepen.SkipReason.LATER_TURN
+
 
 class TestDecideFirstPrompt:
     def test_should_emit_additional_context_with_the_four_answers_for_a_first_task(
@@ -193,6 +217,45 @@ class TestDecideFirstPrompt:
         second_stdout = _run_main(_payload("and also the billing page", str(transcript_path)))
         assert second_stdout == ""
 
+    def test_should_inject_once_when_two_copies_see_the_same_cursor_prompt(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, _role_rewrite("Deeper task body"))
+        monkeypatch.delenv("CDE_DEEPEN_OUTPUT", raising=False)
+        monkeypatch.setattr(tempfile, "tempdir", str(tmp_path))
+        cursor_fields = _payload("Add dark mode to the settings page")
+        cursor_fields["hook_event_name"] = CURSOR_BEFORE_SUBMIT_PROMPT_EVENT_NAME
+        cursor_fields["transcript_path"] = None
+        cursor_fields["session_id"] = "cursor-conversation"
+        all_outputs = [_run_main(cursor_fields), _run_main(cursor_fields)]
+        assert sum(DEEPEN_MARKER in each_output for each_output in all_outputs) == 1
+
+    def test_should_keep_cursor_turn_two_silent_once_the_transcript_appears(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, _role_rewrite("Deeper task body"))
+        monkeypatch.delenv("CDE_DEEPEN_OUTPUT", raising=False)
+        monkeypatch.setattr(tempfile, "tempdir", str(tmp_path))
+        first_fields = _payload("Add dark mode to the settings page")
+        first_fields["hook_event_name"] = CURSOR_BEFORE_SUBMIT_PROMPT_EVENT_NAME
+        first_fields["transcript_path"] = None
+        first_fields["session_id"] = "cursor-conversation"
+        assert DEEPEN_MARKER in _run_main(first_fields)
+        cursor_transcript_path = tmp_path / "cursor-conversation.jsonl"
+        cursor_transcript_path.write_text(
+            "\n".join(
+                [
+                    _cursor_transcript_line("user", "Add dark mode to the settings page"),
+                    _cursor_transcript_line("assistant", "Done."),
+                ]
+            ),
+            encoding="utf-8",
+        )
+        second_fields = dict(first_fields)
+        second_fields["prompt"] = "and also the billing page"
+        second_fields["transcript_path"] = str(cursor_transcript_path)
+        assert _run_main(second_fields) == ""
+
     def test_should_print_rewrite_text_for_the_claude_mod(
         self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
     ) -> None:

package/hooks/session/test_deepen_turn_marker.py

@@ -0,0 +1,59 @@
+"""Tests for the deepen turn-one marker."""
+
+from __future__ import annotations
+
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import deepen_turn_marker as marker
+from hooks_constants.deepen_first_prompt_constants import (
+    DEEPEN_SESSION_MARKER_PREFIX,
+    DEEPEN_TURN_MARKER_SUFFIX,
+)
+
+
+def test_should_name_the_marker_after_the_transcript_when_there_is_one(tmp_path: Path) -> None:
+    transcript_path = str(tmp_path / "session.jsonl")
+    assert marker.turn_marker_path({"transcript_path": transcript_path, "session_id": "s"}) == Path(
+        transcript_path + DEEPEN_TURN_MARKER_SUFFIX
+    )
+
+
+def test_should_name_the_marker_after_the_session_in_the_temp_folder(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setattr(tempfile, "tempdir", str(tmp_path))
+    assert marker.turn_marker_path({"transcript_path": None, "session_id": "abc"}) == (
+        tmp_path / f"{DEEPEN_SESSION_MARKER_PREFIX}abc"
+    )
+
+
+def test_should_let_only_the_first_claim_win(tmp_path: Path) -> None:
+    fields = {"transcript_path": str(tmp_path / "session.jsonl")}
+    assert marker.claim_turn_marker(fields) is True
+    assert marker.claim_turn_marker(fields) is False
+    assert marker.turn_marker_exists(fields)
+
+
+def test_should_allow_a_claim_when_the_payload_names_no_session() -> None:
+    assert marker.claim_turn_marker({}) is True
+
+
+def test_should_allow_a_claim_when_the_marker_cannot_be_written(tmp_path: Path) -> None:
+    fields = {"transcript_path": str(tmp_path / "missing-folder" / "session.jsonl")}
+    assert marker.claim_turn_marker(fields) is True
+
+
+def test_should_see_the_session_marker_once_a_transcript_path_appears(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setattr(tempfile, "tempdir", str(tmp_path))
+    assert marker.claim_turn_marker({"transcript_path": None, "session_id": "abc"}) is True
+    later_fields = {"transcript_path": str(tmp_path / "cursor.jsonl"), "session_id": "abc"}
+    assert marker.turn_marker_exists(later_fields)

package/package.json

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

package/scripts/policy_lint/adapter_configuration.py

@@ -139,6 +139,7 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
         hooks/blocking/build_eval_before_eval_write_gate.py -> exempt
         hooks/blocking/merge_over_review_offer_gate.py   -> exempt
         hooks/blocking/final_reply_gate.py               -> exempt
+        hooks/blocking/open_tasks_stop_gate.py           -> exempt
         hooks/blocking/some_new_blocker.py               -> flagged
 
     The Bash PreToolUse dispatcher sits under ``blocking/`` for layout reasons
@@ -179,6 +180,11 @@ 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.
+
     Args:
         registered_string: One command, path, script, or entrypoint string.
     """

package/scripts/policy_lint/config/constants.py

@@ -78,6 +78,7 @@ ALL_ACTION_BOUNDARY_EXEMPT_REGISTRATION_PATHS = (
     "blocking/build_eval_before_eval_write_gate.py",
     "blocking/merge_over_review_offer_gate.py",
     "blocking/final_reply_gate.py",
+    "blocking/open_tasks_stop_gate.py",
 )
 ALL_TEST_DIRECTORY_NAMES = frozenset({"tests"})
 ALL_TEST_FILE_PREFIXES = ("test_",)

package/scripts/tests/test_adapter_configuration.py

@@ -74,6 +74,14 @@ def test_new_final_reply_gate_registration_is_clean(tmp_path: Path) -> None:
     assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
 
 
+def test_new_open_tasks_stop_gate_registration_is_clean(tmp_path: Path) -> None:
+    current_document = _hook_document(
+        ["hooks/blocking/open_tasks_stop_gate.py"],
+        '{"hooks": {}}',
+    )
+    assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
+
+
 def test_new_step_note_gate_registration_is_clean(tmp_path: Path) -> None:
     current_document = _hook_document(
         ["hooks/blocking/step_note_gate.py"],