claude-dev-env 8.97.0 → 8.98.0

package/hooks/open_task_asks.py

@@ -0,0 +1,163 @@
+"""Per-session record of the user's prompts, read by the open tasks Stop gate.
+
+Every prompt lands in one file outside the task store::
+
+    ~/.claude/open-task-asks/<session id>.json
+    {"prompts": [{"text": "...", "recorded_at": 1761076800.0, "ask_id": "ask-1"}, ...]}
+
+A prompt that asks for work gets the next ``ask-N`` id. A question-only
+prompt, an acknowledgement such as ``thanks!``, an empty prompt, and a harness envelope such as
+``<task-notification>`` get ``ask_id`` null, and the gate still reads their
+text when it checks the quote on a ``Dropped:`` line.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from pathlib import Path
+from typing import NamedTuple
+
+from atomic_file_writer import write_text_atomically
+from hooks_constants.open_tasks_stop_gate_constants import (
+    ACKNOWLEDGEMENT_PATTERN,
+    ASK_ID_TEMPLATE,
+    ASK_PROMPT_ID_KEY,
+    ASK_PROMPT_RECORDED_AT_KEY,
+    ASK_PROMPT_TEXT_KEY,
+    ASKS_DIRECTORY_NAME,
+    ASKS_FILE_SUFFIX,
+    ASKS_PROMPTS_KEY,
+    ASKS_TEMPORARY_PREFIX,
+    ASKS_TEMPORARY_SUFFIX,
+    CLAUDE_CONFIG_DIRECTORY_ENVIRONMENT_VARIABLE,
+    CLAUDE_HOME_DIRECTORY_NAME,
+    INTERROGATIVE_START_PATTERN,
+    POLITE_REQUEST_START_PATTERN,
+    QUESTION_END_PATTERN,
+    SAFE_SESSION_ID_PATTERN,
+    SENTENCE_SPLIT_PATTERN,
+    UTF8_ENCODING,
+    YES_OR_NO_END_PATTERN,
+)
+from hooks_constants.spawn_readiness_hook_constants import ALL_HARNESS_ENVELOPE_MARKERS
+
+
+class RecordedPrompt(NamedTuple):
+    """One prompt the user sent.
+
+    Attributes:
+        text: The prompt as the user sent it.
+        recorded_at: Seconds since the epoch when the recorder saw it.
+        ask_id: ``ask-N`` for a prompt that asks for work, or None.
+    """
+
+    text: str
+    recorded_at: float
+    ask_id: str | None
+
+
+def claude_home() -> Path:
+    """Return the Claude home directory, honoring ``CLAUDE_CONFIG_DIR``."""
+    configured_directory = os.environ.get(CLAUDE_CONFIG_DIRECTORY_ENVIRONMENT_VARIABLE)
+    if configured_directory:
+        return Path(configured_directory)
+    return Path.home() / CLAUDE_HOME_DIRECTORY_NAME
+
+
+def _asks_file(session_id: object) -> Path | None:
+    if not isinstance(session_id, str) or not re.fullmatch(SAFE_SESSION_ID_PATTERN, session_id):
+        return None
+    return claude_home() / ASKS_DIRECTORY_NAME / (session_id + ASKS_FILE_SUFFIX)
+
+
+def is_question_only(prompt_text: str) -> bool:
+    """Return True when the prompt asks a question and asks for no work.
+
+    ::
+
+        "did the export fail?"                      -> True
+        "are you monitoring these? yes or no"       -> True
+        "can you check the release dates in neon?"  -> False
+        "Export the APKs and submit them"           -> False
+    """
+    all_sentences = [
+        each_part.strip()
+        for each_part in re.split(SENTENCE_SPLIT_PATTERN, prompt_text.strip())
+        if each_part.strip()
+    ]
+    if not all_sentences or re.search(POLITE_REQUEST_START_PATTERN, prompt_text, re.IGNORECASE):
+        return False
+    if all(re.search(QUESTION_END_PATTERN, each_sentence) for each_sentence in all_sentences):
+        return True
+    return bool(
+        re.search(YES_OR_NO_END_PATTERN, all_sentences[-1], re.IGNORECASE)
+        and re.search(INTERROGATIVE_START_PATTERN, all_sentences[0], re.IGNORECASE)
+    )
+
+
+def is_ask(prompt_text: str) -> bool:
+    """Return True when the prompt asks for work the gate should hold the turn for."""
+    stripped_text = prompt_text.strip()
+    if not stripped_text or stripped_text.startswith(ALL_HARNESS_ENVELOPE_MARKERS):
+        return False
+    if re.fullmatch(ACKNOWLEDGEMENT_PATTERN, stripped_text, re.IGNORECASE):
+        return False
+    return not is_question_only(stripped_text)
+
+
+def recorded_prompts(session_id: object) -> list[RecordedPrompt]:
+    """Return every prompt recorded for the session, oldest first."""
+    asks_file = _asks_file(session_id)
+    if asks_file is None:
+        return []
+    try:
+        all_file_fields = json.loads(asks_file.read_text(encoding=UTF8_ENCODING))
+    except (OSError, ValueError):
+        return []
+    all_entries = (
+        all_file_fields.get(ASKS_PROMPTS_KEY) if isinstance(all_file_fields, dict) else None
+    )
+    if not isinstance(all_entries, list):
+        return []
+    return [
+        _parsed_prompt(each_entry) for each_entry in all_entries if isinstance(each_entry, dict)
+    ]
+
+
+def _parsed_prompt(all_entry_fields: dict[str, object]) -> RecordedPrompt:
+    recorded_at = all_entry_fields.get(ASK_PROMPT_RECORDED_AT_KEY)
+    ask_id = all_entry_fields.get(ASK_PROMPT_ID_KEY)
+    return RecordedPrompt(
+        str(all_entry_fields.get(ASK_PROMPT_TEXT_KEY, "")),
+        float(recorded_at) if isinstance(recorded_at, (int, float)) else 0.0,
+        ask_id if isinstance(ask_id, str) else None,
+    )
+
+
+def record_prompt(session_id: object, prompt_text: str) -> str | None:
+    """Append the prompt to the session's file and return its ``ask-N`` id, or None for no ask."""
+    asks_file = _asks_file(session_id)
+    if asks_file is None:
+        return None
+    all_prompts = recorded_prompts(session_id)
+    ask_count = sum(1 for each_prompt in all_prompts if each_prompt.ask_id)
+    ask_id = ASK_ID_TEMPLATE.format(ask_number=ask_count + 1) if is_ask(prompt_text) else None
+    all_prompts.append(RecordedPrompt(prompt_text, time.time(), ask_id))
+    serialized_text = json.dumps(
+        {ASKS_PROMPTS_KEY: [each_prompt._asdict() for each_prompt in all_prompts]}
+    )
+    try:
+        write_text_atomically(
+            asks_file,
+            serialized_text,
+            UTF8_ENCODING,
+            ASKS_TEMPORARY_PREFIX,
+            ASKS_TEMPORARY_SUFFIX,
+            False,
+        )
+    except OSError:
+        return None
+    return ask_id

package/hooks/session/open_task_ask_recorder.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""UserPromptSubmit hook that records each prompt for the open tasks Stop gate.
+
+A prompt that asks for work becomes ``#ask-N`` in
+``~/.claude/open-task-asks/<session id>.json``. The gate then holds the turn
+until a reply closes it with ``Done: #ask-N``, or with
+``Dropped: #ask-N - "<the user's words>"`` quoting a later prompt. The hook
+prints nothing and always exits 0.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+hooks_root_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_root_directory not in sys.path:
+    sys.path.insert(0, hooks_root_directory)
+
+from hooks_constants.open_tasks_stop_gate_constants import (
+    ALLOW_EXIT_CODE,
+    PROMPT_KEY,
+    SESSION_ID_KEY,
+)
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+from open_task_asks import record_prompt
+
+
+def main() -> int:
+    hook_input = read_hook_input_dictionary_from_stdin()
+    prompt_value = hook_input.get(PROMPT_KEY) if hook_input is not None else None
+    if hook_input is not None and isinstance(prompt_value, str):
+        record_prompt(hook_input.get(SESSION_ID_KEY), prompt_value)
+    return ALLOW_EXIT_CODE
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/session/test_open_task_ask_recorder.py

@@ -0,0 +1,57 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+RECORDER_PATH = Path(__file__).resolve().parent / "open_task_ask_recorder.py"
+SESSION_ID = "s-123"
+
+
+def submit_prompt(home_directory: Path, prompt_text: str) -> subprocess.CompletedProcess[str]:
+    hook_input = {
+        "hook_event_name": "UserPromptSubmit",
+        "session_id": SESSION_ID,
+        "prompt": prompt_text,
+    }
+    return subprocess.run(
+        [sys.executable, str(RECORDER_PATH)],
+        input=json.dumps(hook_input),
+        capture_output=True,
+        text=True,
+        env={
+            "HOME": str(home_directory),
+            "USERPROFILE": str(home_directory),
+            "PATH": "",
+        },
+        check=False,
+    )
+
+
+def recorded_ask_ids(home_directory: Path) -> list[str]:
+    asks_path = home_directory / ".claude" / "open-task-asks" / f"{SESSION_ID}.json"
+    all_prompts = json.loads(asks_path.read_text(encoding="utf-8"))["prompts"]
+    return [each_prompt["ask_id"] for each_prompt in all_prompts if each_prompt["ask_id"]]
+
+
+def test_should_record_each_ask_outside_the_task_store_and_stay_silent(
+    tmp_path: Path,
+) -> None:
+    first_process = submit_prompt(tmp_path, "Export the OneUI8 and OneUI9 APKs and submit them")
+    submit_prompt(tmp_path, "did the export fail?")
+    submit_prompt(tmp_path, "<task-notification>\n<task-id>b1</task-id>\n</task-notification>")
+    submit_prompt(tmp_path, "can you check the release dates in neon?")
+    assert (first_process.returncode, first_process.stdout) == (0, "")
+    assert recorded_ask_ids(tmp_path) == ["ask-1", "ask-2"]
+    assert not (tmp_path / ".claude" / "tasks").exists()
+
+
+def test_should_allow_malformed_input(tmp_path: Path) -> None:
+    completed_process = subprocess.run(
+        [sys.executable, str(RECORDER_PATH)],
+        input="not json",
+        capture_output=True,
+        text=True,
+        env={"HOME": str(tmp_path), "USERPROFILE": str(tmp_path), "PATH": ""},
+        check=False,
+    )
+    assert (completed_process.returncode, completed_process.stdout) == (0, "")

package/hooks/test_open_task_asks.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+
+import pytest
+
+from open_task_asks import is_ask, record_prompt, recorded_prompts
+
+
+@pytest.fixture(autouse=True)
+def isolated_home(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setenv("USERPROFILE", str(tmp_path))
+    monkeypatch.delenv("CLAUDE_CONFIG_DIR", raising=False)
+
+
+@pytest.mark.parametrize(
+    ("prompt_text", "is_expected_ask"),
+    [
+        ("Export the OneUI8 and OneUI9 APKs and submit them", True),
+        ("can you check the release dates in neon?", True),
+        (
+            "set the 8 to ready to export in neon\n\ni dont think you're correct in none are released?",
+            True,
+        ),
+        ("wait, did /deepstack-mode fail?", False),
+        ("are you monitoring these? yes or no", False),
+        ("<task-notification>\n<task-id>b1</task-id>", False),
+        ("   ", False),
+        ("thanks!", False),
+        ("ok, thanks", False),
+        ("Looks good", False),
+        ("ok, ship it", True),
+        ("yes", True),
+    ],
+)
+def test_should_classify_work_prompts_as_asks(prompt_text: str, is_expected_ask: bool) -> None:
+    assert is_ask(prompt_text) is is_expected_ask
+
+
+def test_should_number_asks_and_keep_every_prompt_in_order() -> None:
+    assert record_prompt("s-1", "Export the APKs") == "ask-1"
+    assert record_prompt("s-1", "did it fail?") is None
+    assert record_prompt("s-1", "Submit them") == "ask-2"
+    assert [each_prompt.ask_id for each_prompt in recorded_prompts("s-1")] == [
+        "ask-1",
+        None,
+        "ask-2",
+    ]
+
+
+def test_should_skip_a_session_id_that_is_not_a_plain_name() -> None:
+    assert record_prompt("../escape", "Export the APKs") is None
+    assert recorded_prompts("../escape") == []

package/hooks/test_transcript_skill_scan.py

@@ -11,6 +11,7 @@ if str(HOOKS_DIRECTORY) not in sys.path:
 from transcript_skill_scan import (
     invokes_skill_with_argument,
     is_skill_loaded_after_last_compaction,
+    is_skill_loaded_since_last_prompt,
     skill_invocation_status,
 )
 
@@ -134,3 +135,26 @@ def test_build_eval_invocation_before_a_compact_boundary_should_still_count() ->
         _skill_entry("other"),
     ]
     assert _invokes_build_eval(lines)
+
+
+def _prompt_entry(content: object) -> str:
+    return json.dumps({"type": "user", "message": {"content": content}})
+
+
+def test_skill_since_last_prompt_survives_tool_results_and_skill_bodies() -> None:
+    tool_result = _prompt_entry([{"type": "tool_result", "content": "Launching skill: verify"}])
+    skill_body = json.dumps({"type": "user", "isMeta": True, "message": {"content": "Base directory for this skill"}})
+    lines = [_prompt_entry("Commit it."), _skill_entry("verify"), tool_result, skill_body]
+    assert is_skill_loaded_since_last_prompt(lines, ("verify",), ())
+
+
+def test_next_prompt_drops_a_skill_loaded_in_the_last_turn() -> None:
+    lines = [_prompt_entry("First."), _skill_entry("verify"), _prompt_entry([{"type": "text", "text": "Second."}])]
+    assert not is_skill_loaded_since_last_prompt(lines, ("verify",), ())
+
+
+def test_slash_command_prompt_loads_the_skill_for_its_own_turn() -> None:
+    marker = "<command-name>/verify</command-name>"
+    assert is_skill_loaded_since_last_prompt([_prompt_entry("First."), _prompt_entry(marker)], ("verify",), (marker,))
+    compaction = json.dumps({"subtype": "compact_boundary"})
+    assert not is_skill_loaded_since_last_prompt([_prompt_entry(marker), compaction], ("verify",), (marker,))

package/hooks/transcript_skill_scan.py

@@ -10,7 +10,9 @@ from hooks_constants.transcript_skill_scan_constants import (
     ASSISTANT_ENTRY_TYPE,
     COMMAND_ARGUMENTS_PATTERN,
     COMPACT_BOUNDARY_SUBTYPE,
+    META_ENTRY_FIELD,
     SKILL_TOOL_NAME,
+    TOOL_RESULT_BLOCK_TYPE,
     TOOL_USE_BLOCK_TYPE,
     USER_ENTRY_TYPE,
 )
@@ -87,9 +89,7 @@ def _invokes_skill_with_argument(
     )
 
 
-def _relevant_entry(each_line: str, skill_names: Collection[str]) -> dict[str, object] | None:
-    if not any(name in each_line for name in skill_names) and COMPACT_BOUNDARY_SUBTYPE not in each_line:
-        return None
+def _parsed_entry(each_line: str) -> dict[str, object] | None:
     try:
         all_entry_fields = json.loads(each_line)
     except json.JSONDecodeError:
@@ -97,6 +97,12 @@ def _relevant_entry(each_line: str, skill_names: Collection[str]) -> dict[str, o
     return all_entry_fields if isinstance(all_entry_fields, dict) else None
 
 
+def _relevant_entry(each_line: str, skill_names: Collection[str]) -> dict[str, object] | None:
+    if not any(name in each_line for name in skill_names) and COMPACT_BOUNDARY_SUBTYPE not in each_line:
+        return None
+    return _parsed_entry(each_line)
+
+
 def skill_invocation_status(
     all_transcript_lines: Iterable[str],
     skill_names: Collection[str],
@@ -140,6 +146,51 @@ def is_skill_loaded_after_last_compaction(
     return skill_invocation_status(all_transcript_lines, skill_names, slash_command_markers)[1]
 
 
+def _is_user_prompt(all_entry_fields: dict[str, object]) -> bool:
+    message = all_entry_fields.get("message")
+    if all_entry_fields.get("type") != USER_ENTRY_TYPE or all_entry_fields.get(META_ENTRY_FIELD):
+        return False
+    content = message.get("content") if isinstance(message, dict) else None
+    if isinstance(content, str):
+        return True
+    return isinstance(content, list) and not any(
+        isinstance(each_block, dict) and each_block.get("type") == TOOL_RESULT_BLOCK_TYPE
+        for each_block in content
+    )
+
+
+def is_skill_loaded_since_last_prompt(
+    all_transcript_lines: Iterable[str],
+    skill_names: Collection[str],
+    slash_command_markers: Collection[str],
+) -> bool:
+    """Return whether a matching invocation follows the last user prompt and compact boundary.
+
+    ::
+
+        prompt, Skill verify, tool result, skill body   -> True
+        prompt, Skill verify, prompt                    -> False
+        prompt carrying the /verify command marker      -> True
+        prompt with the marker, compact boundary        -> False
+
+    A tool result and a meta entry, such as the skill body, leave the turn open.
+
+    Args:
+        all_transcript_lines: JSON transcript entries, one per line.
+        skill_names: Accepted skill names, with plugin prefixes accepted.
+        slash_command_markers: Accepted user command tags.
+    """
+    loaded = False
+    for each_line in all_transcript_lines:
+        all_entry_fields = _parsed_entry(each_line)
+        if all_entry_fields is None:
+            continue
+        if all_entry_fields.get("subtype") == COMPACT_BOUNDARY_SUBTYPE or _is_user_prompt(all_entry_fields):
+            loaded = False
+        loaded = loaded or _invokes_skill(all_entry_fields, skill_names, slash_command_markers)
+    return loaded
+
+
 def invokes_skill_with_argument(
     all_transcript_lines: Iterable[str],
     skill_names: Collection[str],

package/package.json

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

package/scripts/policy_lint/adapter_configuration.py

@@ -128,6 +128,7 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
 
         hooks/blocking/bash_pre_tool_use_dispatcher.py   -> exempt
         hooks/blocking/pr_lifecycle_skill_gate.py        -> exempt
+        hooks/blocking/verify_before_commit_gate.py      -> exempt
         hooks/blocking/step_note_gate.py                 -> exempt
         hooks/blocking/reply_length_gate.py              -> exempt
         hooks/blocking/chat_reply_gate.py                -> exempt
@@ -155,6 +156,10 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
     a second open ``Follow-up to #N`` pull request for one parent, a delivery
     rule that names the open follow-up to extend.
 
+    The verify-before-commit gate denies a code commit in a repository with a
+    verify skill until the session loads that skill in the current turn. It
+    decides when a skill loads and no code or safety policy.
+
     The step-note gate allows every call until the user runs ``/step-notes on``.
     It asks for a readable status line and decides no code or safety policy.
 

package/scripts/policy_lint/config/constants.py

@@ -64,6 +64,7 @@ ALL_ACTION_BOUNDARY_PREFIXES = ("deny_", "block_", "ask_")
 ALL_ACTION_BOUNDARY_EXEMPT_REGISTRATION_PATHS = (
     "blocking/bash_pre_tool_use_dispatcher.py",
     "blocking/pr_lifecycle_skill_gate.py",
+    "blocking/verify_before_commit_gate.py",
     "blocking/merge_review_gate.py",
     "blocking/step_note_gate.py",
     "blocking/reply_length_gate.py",

package/scripts/tests/test_adapter_configuration.py

@@ -170,6 +170,14 @@ def test_new_eval_write_gate_registration_is_clean(tmp_path: Path) -> None:
     assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
 
 
+def test_new_verify_before_commit_gate_registration_is_clean(tmp_path: Path) -> None:
+    current_document = _hook_document(
+        ["hooks/blocking/verify_before_commit_gate.py"],
+        '{"hooks": {}}',
+    )
+    assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
+
+
 def test_new_blocker_in_staged_change_is_rejected(tmp_path: Path) -> None:
     current_document = _hook_document(
         ["hooks/blocking/new.py"],

package/settings.json

@@ -24,6 +24,7 @@
     ]
   },
   "env": {
-    "CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS": "100000"
+    "CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS": "100000",
+    "PYTHONUTF8": "1"
   }
 }