claude-dev-env 8.88.7 → 8.90.0

package/hooks/hooks_constants/deepen_first_prompt_constants.py

@@ -1,187 +0,0 @@
-"""Named values for first-task deepening."""
-
-from __future__ import annotations
-
-from hooks_constants.mod_handoff_constants import DEEPEN_FIRST_PROMPT_PLUGIN_NAME
-from hooks_constants.skill_loaded_reminder_constants import (
-    CLAUDE_SUBAGENT_PROMPT_PREFIX,
-    CODEX_SUBAGENT_PROMPT_PREFIX,
-)
-
-__all__ = [
-    "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",
-    "ALL_EXAMPLE_NOUN_STOPWORDS",
-    "ALL_FOUR_QUESTION_STEMS",
-    "EXAMPLE_NOUN_PATTERN",
-    "HARD_CONSTRAINTS_LABEL",
-    "REFUSAL_DROPPED_HARD_CONSTRAINT",
-    "REFUSAL_EXAMPLE_NOUN_IN_SCOPE",
-    "REFUSAL_MISSING_ROLE_LINES",
-    "REFUSAL_RESTATES_FOUR_QUESTIONS",
-    "ROLE_BLOCKER_LABEL",
-    "ROLE_BLOCKER_NONE",
-    "ROLE_EXAMPLES_LABEL",
-    "BULLET_PREFIX",
-    "QUESTION_LINE_SEPARATOR",
-    "SCORE_ACCEPT",
-    "SCORE_REFUSE",
-    "ROLE_SCOPE_LABEL",
-    "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",
-    "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",
-]
-
-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"
-HOOK_SPECIFIC_OUTPUT_KEY: str = "hookSpecificOutput"
-HOOK_EVENT_NAME_KEY: str = "hookEventName"
-ADDITIONAL_CONTEXT_KEY: str = "additionalContext"
-SKIP_DEEPEN_ENV_VAR: str = "CDE_SKIP_DEEPEN"
-SKIP_DEEPEN_TRUE_VALUE: str = "1"
-DEEPEN_REWRITE_ENV_VAR: str = "CDE_DEEPEN_REWRITE"
-DEEPEN_COMMAND_ENV_VAR: str = "CDE_DEEPEN_COMMAND"
-DEEPEN_OUTPUT_ENV_VAR: str = "CDE_DEEPEN_OUTPUT"
-DEEPEN_OUTPUT_REWRITE: str = "rewrite"
-DEEPEN_OUTPUT_JSON: str = "json"
-NONINTERACTIVE_PRINT_ENV_VAR: str = "CLAUDE_CODE_NONINTERACTIVE"
-NONINTERACTIVE_CODEX_ENV_VAR: str = "CODEX_EXEC"
-CLAUDE_HOST_ENV_VAR: str = "CLAUDECODE"
-CLAUDE_HOST_TRUE_VALUE: str = "1"
-ALL_NONINTERACTIVE_ENV_TRUE_VALUES: frozenset[str] = frozenset({"1", "true", "yes"})
-UTF8_ENCODING: str = "utf-8"
-JSONL_TYPE_KEY: str = "type"
-JSONL_ROLE_KEY: str = "role"
-USER_TYPE_NAME: str = "user"
-USER_ROLE_NAME: str = "user"
-
-ALL_TRIVIAL_PROMPTS: frozenset[str] = frozenset(
-    {
-        "yes",
-        "y",
-        "no",
-        "n",
-        "ok",
-        "okay",
-        "thanks",
-        "thank you",
-        "thx",
-        "status",
-        "hello",
-        "hi",
-        "hey",
-        "k",
-        "sure",
-        "continue",
-        "go",
-        "?",
-    }
-)
-
-ALL_LOOP_PROMPT_PREFIXES: tuple[str, ...] = (
-    "/loop",
-    "<scheduled-task",
-    "scheduled task firing",
-)
-
-ALL_HELPER_REPORT_MARKERS: tuple[str, ...] = (
-    "<task-notification",
-    "background subagent reporting",
-    "a message another session sends",
-)
-
-ALL_SPAWN_REWRITE_PREFIXES: tuple[str, ...] = (
-    CLAUDE_SUBAGENT_PROMPT_PREFIX,
-    CODEX_SUBAGENT_PROMPT_PREFIX,
-)
-
-ROLE_SCOPE_LABEL: str = "SCOPE (role):"
-ROLE_EXAMPLES_LABEL: str = "EXAMPLES (illustration only):"
-ROLE_BLOCKER_LABEL: str = "ZOOM-IN BLOCKER:"
-ROLE_BLOCKER_NONE: str = "none"
-HARD_CONSTRAINTS_LABEL: str = "HARD CONSTRAINTS"
-REFUSAL_RESTATES_FOUR_QUESTIONS: str = "restates-four-questions"
-REFUSAL_MISSING_ROLE_LINES: str = "missing-role-lines"
-REFUSAL_EXAMPLE_NOUN_IN_SCOPE: str = "example-noun-in-scope"
-REFUSAL_DROPPED_HARD_CONSTRAINT: str = "dropped-hard-constraint"
-BULLET_PREFIX: str = "- "
-QUESTION_LINE_SEPARATOR: str = "\n"
-SCORE_ACCEPT: str = "accept"
-SCORE_REFUSE: str = "refuse"
-EXAMPLE_NOUN_PATTERN: str = r"[A-Za-z][A-Za-z0-9_+-]{3,}"
-ALL_FOUR_QUESTION_STEMS: tuple[str, ...] = (
-    "What a top person in that field would do that this prompt omitted.",
-    "The raw source to start from.",
-    "The methods and tools they would use.",
-    "What besides the agent or Jon would show the result is right.",
-)
-ALL_EXAMPLE_NOUN_STOPWORDS: frozenset[str] = frozenset(
-    {
-        "none",
-        "the",
-        "and",
-        "for",
-        "with",
-        "from",
-        "that",
-        "this",
-        "only",
-        "illustration",
-        "example",
-        "into",
-        "when",
-        "your",
-        "their",
-        "about",
-        "such",
-        "like",
-        "say",
-    }
-)

package/hooks/session/deepen_default_rewrite.py

@@ -1,128 +0,0 @@
-"""Role-shaped default rewrite for a first task when no rewrite command is set.
-
-``refusal_reason`` in ``deepen_role_gate.py`` refuses a rewrite that pastes the
-four question stems back at the worker, and one without the SCOPE, EXAMPLES,
-and ZOOM-IN BLOCKER lines. The default rewrite is built to carry those lines,
-so a first task deepens on every host with nothing configured: the scope is
-the task's own sentences with the marked examples taken out, the examples are
-the parts the task marks as examples, and the blocker asks for confirmation
-when the scope names one of those examples.
-"""
-
-from __future__ import annotations
-
-import re
-
-from hooks_constants.deepen_default_rewrite_constants import (
-    ALL_EXAMPLE_END_MARKERS,
-    ALL_EXAMPLE_SENTENCE_MARKERS,
-    DEFAULT_BLOCKER_TEMPLATE,
-    DEFAULT_CLOSING_LINE,
-    DEFAULT_SCOPE_MAX_CHARACTERS,
-    DEFAULT_TASK_HEADING,
-    EXAMPLE_LEAD_PUNCTUATION,
-    EXAMPLE_LIST_SEPARATOR,
-    EXAMPLE_MARKER_ALTERNATION_SEPARATOR,
-    EXAMPLE_MARKER_PATTERN_TEMPLATE,
-    SCOPE_CLIPPED_SUFFIX,
-    SENTENCE_BREAK_PATTERN,
-    WORD_SEPARATOR,
-)
-from hooks_constants.deepen_first_prompt_constants import (
-    DEEPEN_MARKER,
-    HARD_CONSTRAINTS_LABEL,
-    REFUSAL_EXAMPLE_NOUN_IN_SCOPE,
-    ROLE_BLOCKER_LABEL,
-    ROLE_BLOCKER_NONE,
-    ROLE_EXAMPLES_LABEL,
-    ROLE_SCOPE_LABEL,
-)
-from deepen_role_gate import refusal_reason
-
-
-def _body_before_constraints(task_text: str) -> str:
-    all_body_lines: list[str] = []
-    for each_line in task_text.splitlines():
-        if each_line.strip().upper().startswith(HARD_CONSTRAINTS_LABEL):
-            break
-        all_body_lines.append(each_line)
-    return WORD_SEPARATOR.join(WORD_SEPARATOR.join(all_body_lines).split())
-
-
-def _sentences(body_text: str) -> list[str]:
-    return [each.strip() for each in re.split(SENTENCE_BREAK_PATTERN, body_text) if each.strip()]
-
-
-def _example_marker_pattern() -> re.Pattern[str]:
-    alternatives = EXAMPLE_MARKER_ALTERNATION_SEPARATOR.join(re.escape(each_marker) for each_marker in ALL_EXAMPLE_SENTENCE_MARKERS)
-    return re.compile(EXAMPLE_MARKER_PATTERN_TEMPLATE.format(alternatives=alternatives), re.IGNORECASE)
-
-
-def _split_example(sentence: str) -> tuple[str, list[str]]:
-    """Return the sentence without its marked examples, and the example texts.
-
-    A marker counts only as a whole phrase, so "for examples of" and "such
-    assumptions" stay in the scope. The earliest marker splits first, and the
-    text after the example is split again for later markers.
-    """
-    marker_match = _example_marker_pattern().search(sentence)
-    if marker_match is None:
-        return sentence, []
-    head = sentence[: marker_match.start()].rstrip(EXAMPLE_LEAD_PUNCTUATION + "(")
-    tail = sentence[marker_match.end() :].lstrip(EXAMPLE_LEAD_PUNCTUATION)
-    end_index = min(
-        (tail.find(each_end) for each_end in ALL_EXAMPLE_END_MARKERS if tail.find(each_end) >= 0),
-        default=len(tail),
-    )
-    example = tail[:end_index].rstrip(".!? ")
-    remainder_scope, all_remainder_examples = _split_example(
-        tail[end_index:].lstrip(EXAMPLE_LEAD_PUNCTUATION + ")")
-    )
-    all_examples = ([example] if example else []) + all_remainder_examples
-    scope_part = f"{head} {remainder_scope}".strip() if head else ""
-    return scope_part, all_examples
-
-
-def _clipped(text: str) -> str:
-    if len(text) <= DEFAULT_SCOPE_MAX_CHARACTERS:
-        return text
-    cut = text[:DEFAULT_SCOPE_MAX_CHARACTERS]
-    kept = cut[: cut.rfind(" ")] if " " in cut else cut
-    return f"{kept} {SCOPE_CLIPPED_SUFFIX}"
-
-
-def _scope_and_examples(task_text: str) -> tuple[str, str]:
-    all_splits = [_split_example(each) for each in _sentences(_body_before_constraints(task_text))]
-    all_examples = [each_example for _, all_sentence_examples in all_splits for each_example in all_sentence_examples]
-    all_scope_parts = [each_part for each_part, _ in all_splits if each_part]
-    scope_text = WORD_SEPARATOR.join(all_scope_parts) or task_text.strip()
-    examples_text = EXAMPLE_LIST_SEPARATOR.join(all_examples) if all_examples else ROLE_BLOCKER_NONE
-    return _clipped(scope_text), examples_text
-
-
-def _rewrite_with_blocker(scope: str, examples: str, blocker: str, task_text: str) -> str:
-    return (
-        f"{DEEPEN_MARKER}\n\n"
-        f"{ROLE_SCOPE_LABEL} {scope}\n"
-        f"{ROLE_EXAMPLES_LABEL} {examples}\n"
-        f"{ROLE_BLOCKER_LABEL} {blocker}\n\n"
-        f"{DEFAULT_TASK_HEADING}\n{task_text}\n\n"
-        f"{DEFAULT_CLOSING_LINE}"
-    )
-
-
-def role_default_rewrite(task_text: str) -> str:
-    """Return the default rewrite: role lines from the task, the task itself, and one closing order.
-
-    Args:
-        task_text: The first task with any leading /deepen removed.
-
-    Returns:
-        A rewrite that opens with the deepen marker and carries the three role lines.
-    """
-    scope, examples = _scope_and_examples(task_text)
-    rewrite = _rewrite_with_blocker(scope, examples, ROLE_BLOCKER_NONE, task_text)
-    if refusal_reason(task_text, rewrite) != REFUSAL_EXAMPLE_NOUN_IN_SCOPE:
-        return rewrite
-    blocker = DEFAULT_BLOCKER_TEMPLATE.format(examples=examples)
-    return _rewrite_with_blocker(scope, examples, blocker, task_text)

package/hooks/session/deepen_first_prompt.py

@@ -1,383 +0,0 @@
-#!/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
-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_FIRST_PROMPT_EVENT_NAMES,
-    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,
-    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,
-    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
-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):
-    """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
-
-
-@dataclass(frozen=True)
-class Refuse:
-    """Leave the submitted prompt unchanged because the candidate rewrite failed."""
-
-    reason: str
-
-
-DeepenDecision = Skip | Deepen | Refuse
-
-
-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
-    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
-
-
-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 _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 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(
-        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 the role-shaped default rewrite the gate accepts."""
-    return role_default_rewrite(task_text)
-
-
-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, refuse, or deepen one UserPromptSubmit payload."""
-    reason = skip_reason_for(all_hook_fields)
-    if reason is not None:
-        return Skip(reason)
-    prompt = submitted_prompt_text(all_hook_fields)
-    rewritten_prompt = expand_first_task(prompt)
-    refusal = refusal_reason(task_text_for_deepen(prompt), rewritten_prompt)
-    if refusal is not None:
-        return Refuse(refusal)
-    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_refuse_json(reason: str) -> None:
-    sys.stdout.write(json.dumps({"decision": "refuse", "reason": reason}) + "\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
-    if isinstance(decision, Refuse):
-        if output_mode == DEEPEN_OUTPUT_JSON:
-            _print_refuse_json(decision.reason)
-        return
-    if not claim_turn_marker(all_hook_fields):
-        return
-    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()