claude-dev-env 8.88.0 → 8.88.1

package/bin/install.mjs

@@ -126,6 +126,7 @@ import {
     resolveFaultPhaseFromEnvironment,
     runWithInstallTransaction,
 } from './install-transaction.mjs';
+import { pythonExecutableProbeCommand } from './python-probe.mjs';
 
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const INSTALL_ROOT_RESOLUTION = resolveInstallRoot({
@@ -550,7 +551,9 @@ function quoteStandalonePluginRootHookPath(commandString, pluginRootForward) {
  * sys.executable and that path is baked in, so a later PATH change or Microsoft
  * Store update that re-points the `py`/`python` launcher cannot silently break
  * the hooks; candidates resolving to the non-spawnable WindowsApps stub are
- * skipped. Other platforms keep the bare command (e.g. `python3`).
+ * skipped. The path probe runs in isolated mode so the folder the installer
+ * runs from cannot slow or change it. Other platforms keep the bare command
+ * (e.g. `python3`).
  *
  * @returns {string|null} The interpreter command, or null when none is usable.
  */
@@ -561,7 +564,7 @@ export function detectPython() {
             const version = execSync(`${command} ${versionFlag}`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: PYTHON_PROBE_TIMEOUT_MILLISECONDS }).trim();
             if (!version.includes('Python 3.')) continue;
             if (process.platform !== 'win32') return command;
-            const executablePath = execSync(`${command} -c "import sys; print(sys.executable)"`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: PYTHON_PROBE_TIMEOUT_MILLISECONDS }).trim();
+            const executablePath = execSync(pythonExecutableProbeCommand(command), { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: PYTHON_PROBE_TIMEOUT_MILLISECONDS }).trim();
             if (!executablePath || isWindowsStorePythonStub(executablePath)) continue;
             return interpreterCommandFromPath(executablePath);
         } catch { /* try next */ }

package/bin/python-probe.mjs

@@ -0,0 +1,20 @@
+/**
+ * Command line for the probe that asks a Python candidate for its absolute
+ * interpreter path.
+ *
+ * `python -c` puts the current directory first on `sys.path`, and Python
+ * lists that whole directory the first time it imports a module from disk.
+ * When the installer runs from a large folder, such as a temp folder with
+ * hundreds of thousands of entries, that listing can outlast the probe
+ * timeout, so every candidate fails and the install stops with "No usable
+ * Python 3 found". A module in that folder with a standard library name is
+ * imported in place of the real one. `-I` (isolated mode, Python 3.4+) keeps
+ * the current directory off `sys.path`, so the probe gives the same answer
+ * from any folder.
+ *
+ * @param {string} candidateCommand A Python launcher command, such as `py -3`.
+ * @returns {string} The shell command that prints the interpreter path.
+ */
+export function pythonExecutableProbeCommand(candidateCommand) {
+    return `${candidateCommand} -I -c "import sys; print(sys.executable)"`;
+}

package/bin/python-probe.test.mjs

@@ -0,0 +1,37 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { execSync } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { detectPython } from './install.mjs';
+import { pythonExecutableProbeCommand } from './python-probe.mjs';
+
+const SHADOWED_STANDARD_LIBRARY_MODULES = ['linecache.py', 'encodings.py', 'site.py', 'os.py'];
+
+test('the interpreter path probe ignores modules in the current directory', () => {
+    const candidateCommand = detectPython();
+    assert.ok(candidateCommand, 'a Python 3 interpreter is needed for this test');
+    const shadowDirectory = mkdtempSync(join(tmpdir(), 'cde-python-probe-'));
+    try {
+        for (const moduleFileName of SHADOWED_STANDARD_LIBRARY_MODULES) {
+            writeFileSync(join(shadowDirectory, moduleFileName), 'raise SystemExit("shadow module imported")\n');
+        }
+        const printedPath = execSync(pythonExecutableProbeCommand(candidateCommand), {
+            cwd: shadowDirectory,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        assert.ok(printedPath.length > 0);
+        assert.doesNotMatch(printedPath, /shadow module imported/);
+    } finally {
+        rmSync(shadowDirectory, { recursive: true, force: true });
+    }
+});
+
+test('the interpreter path probe runs Python in isolated mode', () => {
+    assert.equal(
+        pythonExecutableProbeCommand('py -3'),
+        'py -3 -I -c "import sys; print(sys.executable)"',
+    );
+});

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