claude-dev-env 8.82.1 → 8.83.0

package/hooks/session/deepen_first_prompt.py

@@ -0,0 +1,390 @@
+#!/usr/bin/env python3
+"""UserPromptSubmit hook: deepen the first interactive task before work starts.
+
+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
+rewrites the visible text; this hook stays silent when that mod is on outside
+a cloud session.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import subprocess
+import sys
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+
+_hooks_dir = str(Path(__file__).resolve().parent.parent)
+if _hooks_dir not in sys.path:
+    sys.path.insert(0, _hooks_dir)
+
+from hooks_constants.cloud_session import is_cloud_session
+from hooks_constants.deepen_first_prompt_constants import (
+    ADDITIONAL_CONTEXT_KEY,
+    ALL_HELPER_REPORT_MARKERS,
+    ALL_LOOP_PROMPT_PREFIXES,
+    ALL_NONINTERACTIVE_ENV_TRUE_VALUES,
+    ALL_SPAWN_REWRITE_PREFIXES,
+    ALL_TRIVIAL_PROMPTS,
+    CLAUDE_HOST_ENV_VAR,
+    CLAUDE_HOST_TRUE_VALUE,
+    DEEPEN_AGENT_MARKER,
+    DEEPEN_COMMAND_ENV_VAR,
+    DEEPEN_COMMAND_TIMEOUT_SECONDS,
+    DEEPEN_FIRST_PROMPT_PLUGIN_NAME,
+    DEEPEN_MARKER,
+    DEEPEN_OUTPUT_ENV_VAR,
+    DEEPEN_OUTPUT_JSON,
+    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,
+    JSONL_TYPE_KEY,
+    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,
+    USER_PROMPT_SUBMIT_EVENT_NAME,
+    USER_ROLE_NAME,
+    USER_TYPE_NAME,
+    UTF8_ENCODING,
+)
+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
+
+
+class SkipReason(StrEnum):
+    """Why the first-task gate left a prompt unchanged."""
+
+    LATER_TURN = "later-turn"
+    MARKER_PRESENT = "marker-present"
+    SPAWN_REWRITE = "spawn-rewrite"
+    SKIP_FLAG = "skip-flag"
+    NONINTERACTIVE = "noninteractive"
+    TRIVIAL = "trivial"
+    SLASH_COMMAND = "slash-command"
+    DEEPEN_AGENT = "deepen-agent"
+    LOOP_OR_HELPER = "loop-or-helper"
+
+
+@dataclass(frozen=True)
+class Skip:
+    """Leave the submitted prompt text unchanged."""
+
+    reason: SkipReason
+
+
+@dataclass(frozen=True)
+class Deepen:
+    """Replace the first task with a deeper rewrite."""
+
+    rewritten_prompt: str
+    additional_context: str
+
+
+DeepenDecision = Skip | Deepen
+
+
+def submitted_prompt_text(all_hook_fields: dict[str, object]) -> str:
+    """Return the submitted prompt text, or empty when the payload has none."""
+    prompt = all_hook_fields.get(PROMPT_FIELD_NAME)
+    if isinstance(prompt, str):
+        return prompt
+    return ""
+
+
+def _env_flag_is_true(variable_name: str) -> bool:
+    return os.environ.get(variable_name, "").strip().lower() in ALL_NONINTERACTIVE_ENV_TRUE_VALUES
+
+
+def _normalized_prompt(prompt: str) -> str:
+    return prompt.strip().lower()
+
+
+def _first_token(prompt: str) -> str:
+    stripped = prompt.strip()
+    if not stripped:
+        return ""
+    return stripped.split(None, 1)[0]
+
+
+def _parsed_transcript_entry(transcript_line: str) -> dict[str, object] | None:
+    stripped_line = transcript_line.strip()
+    if not stripped_line:
+        return None
+    try:
+        parsed_entry = json.loads(stripped_line)
+    except json.JSONDecodeError:
+        return None
+    return parsed_entry if isinstance(parsed_entry, dict) else None
+
+
+def _is_user_entry(all_entry_fields: dict[str, object] | None) -> bool:
+    if all_entry_fields is None:
+        return False
+    if all_entry_fields.get(JSONL_TYPE_KEY) == USER_TYPE_NAME:
+        return True
+    message = all_entry_fields.get("message")
+    return isinstance(message, dict) and message.get(JSONL_ROLE_KEY) == USER_ROLE_NAME
+
+
+def _transcript_has_prior_user_turn(transcript_path: object) -> bool:
+    if not isinstance(transcript_path, str) or not transcript_path:
+        return False
+    try:
+        with Path(transcript_path).open(encoding=UTF8_ENCODING) as transcript:
+            return any(_is_user_entry(_parsed_transcript_entry(each_line)) for each_line in transcript)
+    except OSError:
+        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
+    if _env_flag_is_true(NONINTERACTIVE_PRINT_ENV_VAR) or _env_flag_is_true(
+        NONINTERACTIVE_CODEX_ENV_VAR
+    ):
+        return SkipReason.NONINTERACTIVE
+    return None
+
+
+def _marker_skip_reason(prompt: str) -> SkipReason | None:
+    if DEEPEN_MARKER in prompt:
+        return SkipReason.MARKER_PRESENT
+    if DEEPEN_AGENT_MARKER in prompt:
+        return SkipReason.DEEPEN_AGENT
+    if any(prompt.startswith(each_prefix) for each_prefix in ALL_SPAWN_REWRITE_PREFIXES):
+        return SkipReason.SPAWN_REWRITE
+    if any(prompt.lstrip().lower().startswith(each_prefix) for each_prefix in ALL_LOOP_PROMPT_PREFIXES):
+        return SkipReason.LOOP_OR_HELPER
+    if any(each_marker in prompt.lower() for each_marker in ALL_HELPER_REPORT_MARKERS):
+        return SkipReason.LOOP_OR_HELPER
+    return None
+
+
+def _shape_skip_reason(prompt: str) -> SkipReason | None:
+    first_token = _first_token(prompt)
+    if first_token.startswith("/") and first_token.lower() != DEEPEN_SLASH_COMMAND:
+        return SkipReason.SLASH_COMMAND
+    if first_token.lower() == DEEPEN_SLASH_COMMAND and prompt.strip().lower() == DEEPEN_SLASH_COMMAND:
+        return SkipReason.SLASH_COMMAND
+    if _normalized_prompt(prompt) in ALL_TRIVIAL_PROMPTS or not prompt.strip():
+        return SkipReason.TRIVIAL
+    return 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, ""):
+        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(
+        all_hook_fields.get(TRANSCRIPT_PATH_FIELD_NAME)
+    ):
+        return SkipReason.LATER_TURN
+    return None
+
+
+def task_text_for_deepen(prompt: str) -> str:
+    """Return the task body, stripping a leading /deepen command when present."""
+    stripped = prompt.strip()
+    first_token = _first_token(stripped)
+    if first_token.lower() != DEEPEN_SLASH_COMMAND:
+        return stripped
+    remainder = stripped[len(first_token) :].strip()
+    return remainder or stripped
+
+
+def _with_deepen_marker(rewritten_body: str) -> str:
+    if DEEPEN_MARKER in rewritten_body:
+        return rewritten_body
+    return f"{DEEPEN_MARKER}\n\n{rewritten_body}"
+
+
+def _command_rewrite(task_text: str) -> str | None:
+    command = os.environ.get(DEEPEN_COMMAND_ENV_VAR, "").strip()
+    if not command:
+        return None
+    try:
+        completed = subprocess.run(
+            shlex.split(command),
+            input=task_text,
+            capture_output=True,
+            text=True,
+            timeout=DEEPEN_COMMAND_TIMEOUT_SECONDS,
+            check=False,
+            creationflags=hidden_window_creation_flags(),
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    command_text = completed.stdout.strip()
+    if completed.returncode != 0 or not command_text:
+        return None
+    return _with_deepen_marker(command_text)
+
+
+def _default_rewrite(task_text: str) -> str:
+    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"
+        "1. What a top person in that field would do that this prompt omitted.\n"
+        "2. The raw source to start from.\n"
+        "3. The methods and tools they would use.\n"
+        "4. What besides the agent or Jon would show the result is right.\n"
+        "Then do exactly that job."
+    )
+
+
+def expand_first_task(prompt: str) -> str:
+    """Rewrite a first task so the worker does the omitted expert job."""
+    stub_rewrite = os.environ.get(DEEPEN_REWRITE_ENV_VAR, "").strip()
+    task_text = task_text_for_deepen(prompt)
+    if stub_rewrite:
+        return _with_deepen_marker(stub_rewrite.replace("{prompt}", task_text))
+    command_rewrite = _command_rewrite(task_text)
+    if command_rewrite is not None:
+        return command_rewrite
+    return _default_rewrite(task_text)
+
+
+def additional_context_for(rewritten_prompt: str) -> str:
+    """Return the context a command hook can inject beside the original prompt."""
+    return (
+        f"{DEEPEN_MARKER}\n"
+        "Treat the submitted prompt as this rewritten task and do only that job.\n\n"
+        f"{rewritten_prompt}"
+    )
+
+
+def decide_first_prompt(all_hook_fields: dict[str, object]) -> DeepenDecision:
+    """Skip or deepen one UserPromptSubmit payload."""
+    reason = skip_reason_for(all_hook_fields)
+    if reason is not None:
+        return Skip(reason)
+    rewritten_prompt = expand_first_task(submitted_prompt_text(all_hook_fields))
+    return Deepen(
+        rewritten_prompt=rewritten_prompt,
+        additional_context=additional_context_for(rewritten_prompt),
+    )
+
+
+def _print_skip_json(reason: SkipReason) -> None:
+    sys.stdout.write(json.dumps({"decision": "skip", "reason": reason.value}) + "\n")
+
+
+def _print_deepen_json(deepen: Deepen) -> None:
+    sys.stdout.write(
+        json.dumps(
+            {
+                "decision": "deepen",
+                "rewrittenPrompt": deepen.rewritten_prompt,
+                "additionalContext": deepen.additional_context,
+            }
+        )
+        + "\n"
+    )
+
+
+def _print_additional_context(deepen: Deepen) -> None:
+    sys.stdout.write(
+        json.dumps(
+            {
+                HOOK_SPECIFIC_OUTPUT_KEY: {
+                    HOOK_EVENT_NAME_KEY: USER_PROMPT_SUBMIT_EVENT_NAME,
+                    ADDITIONAL_CONTEXT_KEY: deepen.additional_context,
+                }
+            }
+        )
+        + "\n"
+    )
+
+
+def should_leave_rewrite_to_mod() -> bool:
+    """Return True when the Claude prompt.submit mod will rewrite the visible text.
+
+    Claude Code sets ``CLAUDECODE=1`` for every command hook. Codex reads the same
+    Claude settings file but runs no Claude mod, so a Codex run keeps the envelope.
+    """
+    is_claude_host = os.environ.get(CLAUDE_HOST_ENV_VAR, "").strip() == CLAUDE_HOST_TRUE_VALUE
+    return (
+        is_claude_host
+        and is_mod_plugin_enabled(DEEPEN_FIRST_PROMPT_PLUGIN_NAME)
+        and not is_cloud_session()
+    )
+
+
+def emit_decision(decision: DeepenDecision, all_hook_fields: dict[str, object]) -> None:
+    """Write the host encoding for one decision."""
+    output_mode = os.environ.get(DEEPEN_OUTPUT_ENV_VAR, "").strip().lower()
+    if isinstance(decision, Skip):
+        if output_mode == DEEPEN_OUTPUT_JSON:
+            _print_skip_json(decision.reason)
+        return
+    write_turn_marker(all_hook_fields)
+    if output_mode == DEEPEN_OUTPUT_JSON:
+        _print_deepen_json(decision)
+        return
+    if output_mode == DEEPEN_OUTPUT_REWRITE:
+        sys.stdout.write(decision.rewritten_prompt)
+        if not decision.rewritten_prompt.endswith("\n"):
+            sys.stdout.write("\n")
+        return
+    if should_leave_rewrite_to_mod():
+        return
+    _print_additional_context(decision)
+
+
+def main() -> None:
+    """Read one UserPromptSubmit payload and emit a skip or a deepened rewrite."""
+    hook_payload = read_hook_input_dictionary_from_stdin()
+    if hook_payload is None:
+        return
+    emit_decision(decide_first_prompt(hook_payload), hook_payload)
+
+
+if __name__ == "__main__":
+    main()

package/hooks/session/test_deepen_first_prompt.py

@@ -0,0 +1,274 @@
+"""Behavior tests for first-task deepening."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from io import StringIO
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+_SESSION_DIR = Path(__file__).resolve().parent
+_HOOKS_ROOT = _SESSION_DIR.parent
+for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
+    if each_sys_path_entry not in sys.path:
+        sys.path.insert(0, each_sys_path_entry)
+
+import deepen_first_prompt as deepen
+
+from hooks_constants.deepen_first_prompt_constants import (
+    DEEPEN_AGENT_MARKER,
+    DEEPEN_MARKER,
+    DEEPEN_OUTPUT_JSON,
+    DEEPEN_OUTPUT_REWRITE,
+    DEEPEN_REWRITE_ENV_VAR,
+    DEEPEN_TURN_MARKER_SUFFIX,
+    SKIP_DEEPEN_ENV_VAR,
+    USER_PROMPT_SUBMIT_EVENT_NAME,
+)
+from hooks_constants.skill_loaded_reminder_constants import CLAUDE_SUBAGENT_PROMPT_PREFIX
+
+
+def _payload(prompt: str, transcript_path: str | None = None) -> dict[str, object]:
+    fields: dict[str, object] = {
+        "hook_event_name": USER_PROMPT_SUBMIT_EVENT_NAME,
+        "prompt": prompt,
+        "session_id": "session-one",
+    }
+    if transcript_path is not None:
+        fields["transcript_path"] = transcript_path
+    return fields
+
+
+def _run_main(payload: dict[str, object]) -> str:
+    captured_stdout = StringIO()
+    with patch("sys.stdin", StringIO(json.dumps(payload))), patch("sys.stdout", captured_stdout):
+        deepen.main()
+    return captured_stdout.getvalue()
+
+
+def _user_transcript_line() -> str:
+    return json.dumps({"type": "user", "message": {"role": "user", "content": "earlier task"}})
+
+
+class TestSkipReasonFor:
+    def test_should_skip_a_thanks_prompt(self) -> None:
+        assert deepen.skip_reason_for(_payload("thanks")) is deepen.SkipReason.TRIVIAL
+
+    def test_should_skip_a_yes_prompt(self) -> None:
+        assert deepen.skip_reason_for(_payload("Yes")) is deepen.SkipReason.TRIVIAL
+
+    def test_should_skip_status(self) -> None:
+        assert deepen.skip_reason_for(_payload("status")) is deepen.SkipReason.TRIVIAL
+
+    def test_should_skip_a_slash_command_other_than_deepen(self) -> None:
+        assert deepen.skip_reason_for(_payload("/sr-loop")) is deepen.SkipReason.SLASH_COMMAND
+
+    def test_should_skip_bare_deepen_with_no_task(self) -> None:
+        assert deepen.skip_reason_for(_payload("/deepen")) is deepen.SkipReason.SLASH_COMMAND
+
+    def test_should_allow_deepen_with_a_task(self) -> None:
+        assert deepen.skip_reason_for(_payload("/deepen fix the login page")) is None
+
+    def test_should_skip_a_loop_iteration(self) -> None:
+        assert (
+            deepen.skip_reason_for(_payload("/loop until the tests pass"))
+            is deepen.SkipReason.LOOP_OR_HELPER
+        )
+
+    def test_should_skip_a_helper_report(self) -> None:
+        assert (
+            deepen.skip_reason_for(_payload("<task-notification> helper finished"))
+            is deepen.SkipReason.LOOP_OR_HELPER
+        )
+
+    def test_should_skip_a_spawn_rewrite_prefix(self) -> None:
+        prompt = CLAUDE_SUBAGENT_PROMPT_PREFIX + "\n\nReply leaf."
+        assert deepen.skip_reason_for(_payload(prompt)) is deepen.SkipReason.SPAWN_REWRITE
+
+    def test_should_skip_when_the_prompt_already_carries_the_marker(self) -> None:
+        assert (
+            deepen.skip_reason_for(_payload(f"{DEEPEN_MARKER}\n\nDo the job."))
+            is deepen.SkipReason.MARKER_PRESENT
+        )
+
+    def test_should_skip_the_deepen_agent_prompt(self) -> None:
+        prompt = f"{DEEPEN_AGENT_MARKER}\nAnswer the four deepening questions."
+        assert deepen.skip_reason_for(_payload(prompt)) is deepen.SkipReason.DEEPEN_AGENT
+
+    def test_should_skip_when_the_skip_flag_is_set(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv(SKIP_DEEPEN_ENV_VAR, "1")
+        assert (
+            deepen.skip_reason_for(_payload("Add dark mode to settings"))
+            is deepen.SkipReason.SKIP_FLAG
+        )
+
+    def test_should_skip_a_print_mode_session(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("CLAUDE_CODE_NONINTERACTIVE", "true")
+        assert (
+            deepen.skip_reason_for(_payload("Add dark mode to settings"))
+            is deepen.SkipReason.NONINTERACTIVE
+        )
+
+    def test_should_skip_codex_exec(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("CODEX_EXEC", "1")
+        assert (
+            deepen.skip_reason_for(_payload("Add dark mode to settings"))
+            is deepen.SkipReason.NONINTERACTIVE
+        )
+
+    def test_should_skip_turn_two_when_the_transcript_has_a_user_line(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = tmp_path / "session.jsonl"
+        transcript_path.write_text(_user_transcript_line() + "\n", encoding="utf-8")
+        assert (
+            deepen.skip_reason_for(_payload("Add dark mode", str(transcript_path)))
+            is deepen.SkipReason.LATER_TURN
+        )
+
+    def test_should_deepen_a_first_task(self) -> None:
+        assert deepen.skip_reason_for(_payload("Add dark mode to the settings page")) is None
+
+
+class TestDecideFirstPrompt:
+    def test_should_emit_additional_context_with_the_four_answers_for_a_first_task(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        monkeypatch.setenv(
+            DEEPEN_REWRITE_ENV_VAR,
+            (
+                "Omitted: ship contrast tokens with the theme.\n"
+                "Source: src/settings/theme.ts\n"
+                "Methods: existing token file and a visual check.\n"
+                "Proof: screenshot of the settings page in dark mode."
+            ),
+        )
+        transcript_path = tmp_path / "fresh.jsonl"
+        decision = deepen.decide_first_prompt(
+            _payload("Add dark mode to the settings page", str(transcript_path))
+        )
+        assert isinstance(decision, deepen.Deepen)
+        assert DEEPEN_MARKER in decision.rewritten_prompt
+        assert "Omitted: ship contrast tokens" in decision.rewritten_prompt
+        assert "src/settings/theme.ts" in decision.rewritten_prompt
+        assert "visual check" in decision.rewritten_prompt
+        assert "screenshot of the settings page" in decision.additional_context
+        assert decision.additional_context.startswith(DEEPEN_MARKER)
+
+    def test_should_keep_a_skip_silent_on_the_command_hook(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("CDE_DEEPEN_OUTPUT", raising=False)
+        assert _run_main(_payload("thanks")) == ""
+
+    def test_should_write_a_turn_marker_so_turn_two_stays_silent(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, "Deeper task body")
+        transcript_path = tmp_path / "fresh.jsonl"
+        first_stdout = _run_main(_payload("Add dark mode to the settings page", str(transcript_path)))
+        assert DEEPEN_MARKER in first_stdout
+        marker_path = Path(str(transcript_path) + DEEPEN_TURN_MARKER_SUFFIX)
+        assert marker_path.is_file()
+        second_stdout = _run_main(_payload("and also the billing page", str(transcript_path)))
+        assert second_stdout == ""
+
+    def test_should_print_rewrite_text_for_the_claude_mod(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, "Deeper task body")
+        monkeypatch.setenv("CDE_DEEPEN_OUTPUT", DEEPEN_OUTPUT_REWRITE)
+        transcript_path = tmp_path / "fresh.jsonl"
+        printed = _run_main(_payload("Add dark mode to the settings page", str(transcript_path)))
+        assert printed.startswith(DEEPEN_MARKER)
+        assert "Deeper task body" in printed
+        assert "hookSpecificOutput" not in printed
+
+    def test_should_print_json_decisions_for_the_playtest(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, "Deeper task body")
+        monkeypatch.setenv("CDE_DEEPEN_OUTPUT", DEEPEN_OUTPUT_JSON)
+        transcript_path = tmp_path / "fresh.jsonl"
+        deepen_payload = json.loads(
+            _run_main(_payload("Add dark mode to the settings page", str(transcript_path)))
+        )
+        assert deepen_payload["decision"] == "deepen"
+        skip_payload = json.loads(_run_main(_payload("thanks")))
+        assert skip_payload == {"decision": "skip", "reason": "trivial"}
+
+    def test_should_stay_silent_when_the_claude_mod_is_on(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        config_directory = tmp_path / "claude-config"
+        config_directory.mkdir()
+        (config_directory / "settings.json").write_text(
+            json.dumps({"enabledPlugins": {"deepen-first-prompt@claude-dev-env": True}}),
+            encoding="utf-8",
+        )
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config_directory))
+        monkeypatch.setenv("CLAUDE_PROJECT_DIR", str(tmp_path))
+        monkeypatch.setenv("CLAUDECODE", "1")
+        monkeypatch.delenv("CLAUDE_CODE_REMOTE", raising=False)
+        monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, "Deeper task body")
+        transcript_path = tmp_path / "fresh.jsonl"
+        assert _run_main(_payload("Add dark mode to the settings page", str(transcript_path))) == ""
+
+    def test_should_emit_context_for_codex_when_the_claude_mod_is_on(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        config_directory = tmp_path / "claude-config"
+        config_directory.mkdir()
+        (config_directory / "settings.json").write_text(
+            json.dumps({"enabledPlugins": {"deepen-first-prompt@claude-dev-env": True}}),
+            encoding="utf-8",
+        )
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config_directory))
+        monkeypatch.setenv("CLAUDE_PROJECT_DIR", str(tmp_path))
+        monkeypatch.delenv("CLAUDECODE", raising=False)
+        monkeypatch.delenv("CLAUDE_CODE_REMOTE", raising=False)
+        monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, "Deeper task body")
+        transcript_path = tmp_path / "codex-fresh.jsonl"
+        printed = _run_main(_payload("Add dark mode to the settings page", str(transcript_path)))
+        envelope = json.loads(printed)
+        assert envelope["hookSpecificOutput"]["hookEventName"] == USER_PROMPT_SUBMIT_EVENT_NAME
+        assert "Deeper task body" in envelope["hookSpecificOutput"]["additionalContext"]
+
+    def test_should_still_emit_context_in_a_cloud_session_when_the_mod_is_on(
+        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+    ) -> None:
+        config_directory = tmp_path / "claude-config"
+        config_directory.mkdir()
+        (config_directory / "settings.json").write_text(
+            json.dumps({"enabledPlugins": {"deepen-first-prompt@claude-dev-env": True}}),
+            encoding="utf-8",
+        )
+        monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config_directory))
+        monkeypatch.setenv("CLAUDE_PROJECT_DIR", str(tmp_path))
+        monkeypatch.setenv("CLAUDE_CODE_REMOTE", "true")
+        monkeypatch.setenv(DEEPEN_REWRITE_ENV_VAR, "Deeper task body")
+        transcript_path = tmp_path / "fresh.jsonl"
+        printed = _run_main(_payload("Add dark mode to the settings page", str(transcript_path)))
+        envelope = json.loads(printed)
+        assert envelope["hookSpecificOutput"]["hookEventName"] == USER_PROMPT_SUBMIT_EVENT_NAME
+        assert "Deeper task body" in envelope["hookSpecificOutput"]["additionalContext"]
+
+
+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_name_the_four_omitted_answers_in_the_default_rewrite() -> None:
+    rewritten = deepen.expand_first_task("Add dark mode to the settings page")
+    assert rewritten.startswith(DEEPEN_MARKER)
+    assert "Add dark mode to the settings page" in rewritten
+    assert "What a top person in that field would do that this prompt omitted." in rewritten
+    assert "The raw source to start from." in rewritten
+    assert "The methods and tools they would use." in rewritten
+    assert "What besides the agent or Jon would show the result is right." in rewritten

package/package.json

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