claude-dev-env 8.88.0 → 8.88.2

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,8 +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_FOUR_QUESTION_STEMS,
-    QUESTION_LINE_SEPARATOR,
+    ALL_FIRST_PROMPT_EVENT_NAMES,
     ALL_HELPER_REPORT_MARKERS,
     ALL_LOOP_PROMPT_PREFIXES,
     ALL_NONINTERACTIVE_ENV_TRUE_VALUES,
@@ -45,7 +48,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 +55,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,
@@ -65,7 +66,9 @@ from hooks_constants.deepen_first_prompt_constants import (
 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_default_rewrite import role_default_rewrite
 from deepen_role_gate import refusal_reason
+from deepen_turn_marker import claim_turn_marker, turn_marker_exists
 
 
 class SkipReason(StrEnum):
@@ -146,6 +149,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 +165,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 +203,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
@@ -276,19 +255,8 @@ def _command_rewrite(task_text: str) -> str | None:
 
 
 def _default_rewrite(task_text: str) -> str:
-    """Return the paste path: the four question stems and an order to do the job."""
-    numbered_stems = QUESTION_LINE_SEPARATOR.join(
-        f"{each_index}. {each_stem}"
-        for each_index, each_stem in enumerate(ALL_FOUR_QUESTION_STEMS, start=1)
-    )
-    return (
-        f"{DEEPEN_MARKER}\n\n"
-        "Do this task as a leading practitioner in its field would.\n\n"
-        f"{task_text}\n\n"
-        "Cover four things the original prompt left out:\n"
-        f"{numbered_stems}\n"
-        "Then do exactly that job."
-    )
+    """Return the role-shaped default rewrite the gate accepts."""
+    return role_default_rewrite(task_text)
 
 
 def expand_first_task(prompt: str) -> str:
@@ -388,7 +356,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_deepen_default_rewrite.py

@@ -0,0 +1,90 @@
+"""Tests for the role-shaped default rewrite."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from deepen_default_rewrite import role_default_rewrite
+from deepen_role_gate import refusal_reason
+from hooks_constants.deepen_first_prompt_constants import ALL_FOUR_QUESTION_STEMS, DEEPEN_MARKER
+
+
+def _role_line(rewrite: str, label: str) -> str:
+    return next(each for each in rewrite.splitlines() if each.startswith(label))[len(label) :].strip()
+
+
+def test_should_pass_the_gate_for_a_plain_task() -> None:
+    task = "Add dark mode to the settings page"
+    rewrite = role_default_rewrite(task)
+    assert rewrite.startswith(DEEPEN_MARKER)
+    assert refusal_reason(task, rewrite) is None
+    assert _role_line(rewrite, "SCOPE (role):") == task
+    assert _role_line(rewrite, "EXAMPLES (illustration only):") == "none"
+
+
+def test_should_not_paste_the_four_question_stems() -> None:
+    rewrite = role_default_rewrite("Add dark mode to the settings page")
+    assert not any(each_stem in rewrite for each_stem in ALL_FOUR_QUESTION_STEMS)
+
+
+def test_should_move_a_marked_example_out_of_the_scope() -> None:
+    task = "fix the flaky tests, e.g. test_auth and test_cache, and keep CI fast"
+    rewrite = role_default_rewrite(task)
+    assert refusal_reason(task, rewrite) is None
+    assert _role_line(rewrite, "SCOPE (role):") == "fix the flaky tests and keep CI fast"
+    assert _role_line(rewrite, "EXAMPLES (illustration only):") == "test_auth and test_cache"
+
+
+def test_should_ask_before_narrowing_when_the_scope_names_the_example() -> None:
+    task = "Fix the login failure. For example, the login failure on Safari."
+    rewrite = role_default_rewrite(task)
+    assert refusal_reason(task, rewrite) is None
+    assert _role_line(rewrite, "ZOOM-IN BLOCKER:").startswith("the scope names something")
+
+
+def test_should_keep_every_hard_constraint_line() -> None:
+    task = "Keep the build green. For example, the login failure.\n\nHARD CONSTRAINTS\n- Never open a pull request.\n"
+    rewrite = role_default_rewrite(task)
+    assert refusal_reason(task, rewrite) is None
+    assert "- Never open a pull request." in rewrite.splitlines()
+
+
+def test_should_keep_every_task_sentence_in_scope_when_the_task_opens_with_context() -> None:
+    task = "We have a Django app. Add CSV export to the reports page, e.g. the monthly sales report, and keep the existing URLs."
+    rewrite = role_default_rewrite(task)
+    assert refusal_reason(task, rewrite) is None
+    assert _role_line(rewrite, "SCOPE (role):") == (
+        "We have a Django app. Add CSV export to the reports page and keep the existing URLs."
+    )
+    assert _role_line(rewrite, "EXAMPLES (illustration only):") == "the monthly sales report"
+
+
+def test_should_clip_a_long_scope_and_point_at_the_full_task() -> None:
+    task = "Refactor the module. " * 40
+    rewrite = role_default_rewrite(task.strip())
+    scope = _role_line(rewrite, "SCOPE (role):")
+    assert scope.endswith("(the rest is in the task below)")
+    assert len(scope) < len(task)
+    assert refusal_reason(task.strip(), rewrite) is None
+
+
+def test_should_keep_a_marker_word_inside_a_longer_word_in_the_scope() -> None:
+    task = "Search the codebase for examples of deprecated API calls and replace each one with the new client."
+    rewrite = role_default_rewrite(task)
+    assert refusal_reason(task, rewrite) is None
+    assert _role_line(rewrite, "SCOPE (role):") == task
+    assert _role_line(rewrite, "EXAMPLES (illustration only):") == "none"
+    assumption_task = "Avoid such assumptions in the parser and add input validation."
+    assert _role_line(role_default_rewrite(assumption_task), "SCOPE (role):") == assumption_task
+
+
+def test_should_move_every_marked_example_in_a_sentence_out_of_the_scope() -> None:
+    task = "Speed up the slow pages such as the dashboard, and cache reads, e.g. the user lookup, and keep the API stable."
+    rewrite = role_default_rewrite(task)
+    assert refusal_reason(task, rewrite) is None
+    assert _role_line(rewrite, "SCOPE (role):") == "Speed up the slow pages and cache reads and keep the API stable."
+    assert _role_line(rewrite, "EXAMPLES (illustration only):") == "the dashboard; the user lookup"

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
@@ -30,8 +31,10 @@ from hooks_constants.deepen_first_prompt_constants import (
     REFUSAL_EXAMPLE_NOUN_IN_SCOPE,
     REFUSAL_MISSING_ROLE_LINES,
     REFUSAL_RESTATES_FOUR_QUESTIONS,
+    ALL_FOUR_QUESTION_STEMS,
     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 +61,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 +164,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 +218,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:
@@ -278,12 +342,20 @@ def test_should_strip_the_deepen_slash_before_rewriting() -> None:
     assert deepen.task_text_for_deepen("/deepen fix the login page") == "fix the login page"
 
 
-def test_should_refuse_the_paste_path_as_the_known_bad() -> None:
+def test_should_refuse_the_paste_path_as_the_known_bad(monkeypatch: pytest.MonkeyPatch) -> None:
+    pasted_questions = "\n".join(ALL_FOUR_QUESTION_STEMS)
+    monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, _role_rewrite(pasted_questions))
     decision = deepen.decide_first_prompt(_payload("Add dark mode to the settings page"))
     assert isinstance(decision, deepen.Refuse)
     assert decision.reason == REFUSAL_RESTATES_FOUR_QUESTIONS
 
 
+def test_should_deepen_with_the_default_rewrite_when_nothing_is_configured() -> None:
+    decision = deepen.decide_first_prompt(_payload("Add dark mode to the settings page"))
+    assert isinstance(decision, deepen.Deepen)
+    assert "SCOPE (role): Add dark mode to the settings page" in decision.rewritten_prompt
+
+
 def test_should_refuse_the_filled_four_answer_stub_without_role_lines(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -364,6 +436,7 @@ def test_should_print_a_json_refusal_for_the_paste_path(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.setenv("CDE_DEEPEN_OUTPUT", DEEPEN_OUTPUT_JSON)
+    monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, _role_rewrite("\n".join(ALL_FOUR_QUESTION_STEMS)))
     printed = _run_main(_payload("Add dark mode to the settings page"))
     assert json.loads(printed) == {
         "decision": "refuse",
@@ -375,4 +448,5 @@ def test_should_stay_silent_in_rewrite_mode_when_the_gate_refuses(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.setenv("CDE_DEEPEN_OUTPUT", DEEPEN_OUTPUT_REWRITE)
+    monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, _FILLED_FOUR_ANSWERS)
     assert _run_main(_payload("Add dark mode to the settings page")) == ""

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.88.0",
+    "version": "8.88.2",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {