claude-dev-env 8.96.8 → 8.98.0

package/hooks/hooks_constants/test_bash_pre_tool_use_dispatcher_constants.py

@@ -12,7 +12,7 @@ ALL_BASH_AND_POWERSHELL_TOOL_NAMES = ALL_CONSTANT_BINDINGS["ALL_BASH_AND_POWERSH
 BashHostedHookEntry = ALL_CONSTANT_BINDINGS["BashHostedHookEntry"]
 
 
-def test_roster_hosts_the_four_gates_and_hands_two_to_the_shell_guards_mod() -> None:
+def test_roster_hosts_the_five_gates_and_hands_two_to_the_shell_guards_mod() -> None:
     assert ALL_BASH_HOSTED_HOOK_ENTRIES == (
         BashHostedHookEntry(
             script_relative_path="blocking/msys_rev_path_rewriter.py",
@@ -32,4 +32,8 @@ def test_roster_hosts_the_four_gates_and_hands_two_to_the_shell_guards_mod() ->
             script_relative_path="blocking/cloud_graphql_gate.py",
             applicable_tool_names=ALL_BASH_AND_POWERSHELL_TOOL_NAMES,
         ),
+        BashHostedHookEntry(
+            script_relative_path="blocking/python_windows_invocation_gate.py",
+            applicable_tool_names=ALL_BASH_AND_POWERSHELL_TOOL_NAMES,
+        ),
     )

package/hooks/hooks_constants/transcript_skill_scan_constants.py

@@ -6,3 +6,5 @@ SKILL_TOOL_NAME = "Skill"
 TOOL_USE_BLOCK_TYPE = "tool_use"
 USER_ENTRY_TYPE = "user"
 COMMAND_ARGUMENTS_PATTERN = r"<command-args>(.*?)</command-args>"
+META_ENTRY_FIELD = "isMeta"
+TOOL_RESULT_BLOCK_TYPE = "tool_result"

package/hooks/hooks_constants/verify_before_commit_gate_constants.py

@@ -0,0 +1,54 @@
+"""Constants for the verify-before-commit gate."""
+
+DENY_REASON = (
+    "This repository has a verify skill, and this commit changes code. Invoke the verify "
+    "skill with the Skill tool, run the check it routes you to, then run the same command again. "
+    "A commit that changes only docs or tests passes without it."
+)
+SKILL_NAME = "verify"
+ALL_SLASH_COMMAND_MARKERS = ("<command-name>/verify</command-name>",)
+ALL_VERIFY_SKILL_DIRECTORIES = (".claude/skills/verify", ".agents/skills/verify")
+COMMIT_ACTION = "commit"
+ADD_ACTION = "add"
+ALL_GIT_EXECUTABLES = frozenset({"git", "git.exe"})
+GIT_DIRECTORY_OPTION = "-C"
+ALL_COMMIT_ALL_OPTIONS = frozenset({"-a", "--all"})
+COMMIT_ALL_SHORT_FLAG = "a"
+ALL_COMMIT_VALUED_SHORT_FLAGS = frozenset("mFCct")
+ALL_ADD_EVERYTHING_OPTIONS = frozenset({"-A", "--all", "-u", "--update"})
+WHOLE_TREE_PATHSPEC = ":/"
+PATHSPEC_TERMINATOR = "--"
+GIT_TIMEOUT_SECONDS = 5
+ALL_TOP_LEVEL_ARGUMENTS = ("rev-parse", "--show-toplevel")
+ALL_STAGED_PATHS_ARGUMENTS = ("diff", "--cached", "--name-only")
+ALL_TRACKED_CHANGE_ARGUMENTS = ("diff", "--name-only")
+ALL_WORKING_TREE_PATHS_ARGUMENTS = (
+    "ls-files",
+    "--modified",
+    "--others",
+    "--deleted",
+    "--exclude-standard",
+    "--full-name",
+    "--",
+)
+ALL_DOCS_EXTENSIONS = frozenset(
+    {
+        ".md",
+        ".mdx",
+        ".txt",
+        ".rst",
+        ".adoc",
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".svg",
+        ".webp",
+        ".ico",
+    }
+)
+ALL_TEST_DIRECTORY_NAMES = frozenset({"tests", "test", "__tests__"})
+ALL_TEST_FILE_PREFIXES = ("test_",)
+ALL_TEST_FILE_SUFFIXES = ("_test.py",)
+ALL_TEST_FILE_INFIXES = (".test.", ".spec.")
+ALL_TEST_FILE_NAMES = frozenset({"conftest.py"})

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/plugin_session_baseline.py

@@ -0,0 +1,190 @@
+"""Per-session baseline of the installed plugins, read against the live plugin record.
+
+The SessionStart baseline writer records each plugin's ``version`` and
+``installPath`` from ``installed_plugins.json`` into one JSON file per session
+in the system temp folder. The UserPromptSubmit warning hook reads the same
+file back, compares it with the live record, and lists the plugin ids it has
+already warned about under ``warned``::
+
+    plugin-session-baseline-<session id>.json
+    {"plugins": {"pstack@pstack-claude": [{"version": "1.0.0",
+      "installPath": "/cache/pstack/1.0.0"}]}, "warned": []}
+
+Fields such as ``lastUpdated`` stay out of the snapshot, so a refresh that
+changes nothing a session loads reads as unchanged.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+
+from atomic_file_writer import write_text_atomically
+from hooks_constants.atomic_file_writer_constants import ATOMIC_WRITE_TEMPORARY_SUFFIX
+from hooks_constants.plugin_session_baseline_constants import (
+    BASELINE_PLUGINS_KEY,
+    BASELINE_RECORD_FILE_TEMPLATE,
+    BASELINE_RECORD_TEMPORARY_PREFIX,
+    BASELINE_TEXT_ENCODING,
+    BASELINE_WARNED_KEY,
+    CLAUDE_CONFIG_DIR_ENV_VAR,
+    DEFAULT_CLAUDE_CONFIG_DIRECTORY_NAME,
+    INSTALLED_PLUGINS_FILE_NAME,
+    INSTALLED_PLUGINS_RECORD_KEY,
+    INSTALL_PATH_FIELD,
+    PLUGINS_DIRECTORY_NAME,
+    VERSION_FIELD,
+)
+from hooks_constants.session_file_id import session_file_id
+from json_file_reader import read_json_object
+
+__all__ = [
+    "all_changed_plugin_ids",
+    "baseline_record_path",
+    "current_plugin_snapshot",
+    "installed_plugins_path",
+    "read_baseline_record",
+    "write_baseline_record",
+]
+
+PluginSnapshot = dict[str, list[dict[str, str]]]
+
+
+def installed_plugins_path() -> Path:
+    """Return the installed plugin record under the active Claude config directory."""
+    configured_directory = os.environ.get(CLAUDE_CONFIG_DIR_ENV_VAR, "").strip()
+    config_directory = (
+        Path(configured_directory)
+        if configured_directory
+        else Path.home() / DEFAULT_CLAUDE_CONFIG_DIRECTORY_NAME
+    )
+    return config_directory / PLUGINS_DIRECTORY_NAME / INSTALLED_PLUGINS_FILE_NAME
+
+
+def _loaded_fields(each_entry: object) -> dict[str, str] | None:
+    if not isinstance(each_entry, dict):
+        return None
+    version = each_entry.get(VERSION_FIELD)
+    install_path = each_entry.get(INSTALL_PATH_FIELD)
+    if not isinstance(version, str) or not isinstance(install_path, str):
+        return None
+    return {VERSION_FIELD: version, INSTALL_PATH_FIELD: install_path}
+
+
+def _sorted_entries(all_entries: list[dict[str, str]]) -> list[dict[str, str]]:
+    return sorted(
+        all_entries,
+        key=lambda each_entry: (
+            each_entry[INSTALL_PATH_FIELD],
+            each_entry[VERSION_FIELD],
+        ),
+    )
+
+
+def current_plugin_snapshot(record_path: Path) -> PluginSnapshot:
+    """Return each plugin id with the version and install path of each of its installs.
+
+    A missing, unreadable, or malformed record reads as no plugins.
+
+    Args:
+        record_path: The ``installed_plugins.json`` path.
+    """
+    installed_record = read_json_object(record_path, BASELINE_TEXT_ENCODING)
+    if installed_record is None:
+        return {}
+    all_plugins = installed_record.get(INSTALLED_PLUGINS_RECORD_KEY)
+    if not isinstance(all_plugins, dict):
+        return {}
+    snapshot: PluginSnapshot = {}
+    for each_plugin_id, each_plugin_entries in all_plugins.items():
+        if not isinstance(each_plugin_entries, list):
+            continue
+        all_loaded_entries = [
+            loaded_entry
+            for loaded_entry in (
+                _loaded_fields(each_entry) for each_entry in each_plugin_entries
+            )
+            if loaded_entry is not None
+        ]
+        snapshot[str(each_plugin_id)] = _sorted_entries(all_loaded_entries)
+    return snapshot
+
+
+def baseline_record_path(session_id: object) -> Path:
+    """Return the baseline file path for one session.
+
+    Args:
+        session_id: The ``session_id`` field of the hook payload.
+    """
+    file_name = BASELINE_RECORD_FILE_TEMPLATE.format(
+        session_file_id=session_file_id(session_id)
+    )
+    return Path(tempfile.gettempdir()) / file_name
+
+
+def read_baseline_record(session_id: object) -> dict[str, object] | None:
+    """Return the session's baseline record, or None when none is readable.
+
+    Args:
+        session_id: The ``session_id`` field of the hook payload.
+    """
+    baseline_record = read_json_object(
+        baseline_record_path(session_id), BASELINE_TEXT_ENCODING
+    )
+    if baseline_record is None:
+        return None
+    if not isinstance(baseline_record.get(BASELINE_PLUGINS_KEY), dict):
+        return None
+    if not isinstance(baseline_record.get(BASELINE_WARNED_KEY), list):
+        return None
+    return baseline_record
+
+
+def write_baseline_record(
+    session_id: object, snapshot: PluginSnapshot, all_warned_plugin_ids: list[str]
+) -> None:
+    """Replace the session's baseline record.
+
+    A write that fails leaves the file as it was, so the hook never fails the session.
+
+    Args:
+        session_id: The ``session_id`` field of the hook payload.
+        snapshot: The plugin snapshot the session loaded at start.
+        all_warned_plugin_ids: The plugin ids already named in a warning.
+    """
+    serialized_record = json.dumps(
+        {
+            BASELINE_PLUGINS_KEY: snapshot,
+            BASELINE_WARNED_KEY: sorted(all_warned_plugin_ids),
+        }
+    )
+    try:
+        write_text_atomically(
+            baseline_record_path(session_id),
+            serialized_record,
+            BASELINE_TEXT_ENCODING,
+            BASELINE_RECORD_TEMPORARY_PREFIX,
+            ATOMIC_WRITE_TEMPORARY_SUFFIX,
+            False,
+        )
+    except (OSError, UnicodeError):
+        return
+
+
+def all_changed_plugin_ids(
+    baseline_snapshot: object, current_snapshot: PluginSnapshot
+) -> list[str]:
+    """Return each plugin id whose installs differ from the baseline, or that the baseline lacks.
+
+    Args:
+        baseline_snapshot: The ``plugins`` value of the baseline record.
+        current_snapshot: The live snapshot from ``current_plugin_snapshot``.
+    """
+    known_snapshot = baseline_snapshot if isinstance(baseline_snapshot, dict) else {}
+    return sorted(
+        each_plugin_id
+        for each_plugin_id, each_plugin_entries in current_snapshot.items()
+        if known_snapshot.get(each_plugin_id) != each_plugin_entries
+    )

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/plugin_change_warning.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""UserPromptSubmit hook: tell the user to restart when a plugin changed after start.
+
+A running Claude Code session keeps the plugin files it loaded at start. After
+an install or update, ``installed_plugins.json`` names a new ``version`` or
+``installPath``, or a plugin the session never loaded, and its new skills and
+commands stay unavailable until a restart. The hook compares the live record
+with the baseline that ``plugin_session_baseline_writer.py`` wrote at
+SessionStart and names each changed plugin once per session, in a
+``systemMessage`` for the user and in ``additionalContext`` for the agent.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+_hooks_directory = str(Path(__file__).resolve().parent.parent)
+if _hooks_directory not in sys.path:
+    sys.path.insert(0, _hooks_directory)
+
+from hooks_constants.plugin_session_baseline_constants import (
+    BASELINE_PLUGINS_KEY,
+    BASELINE_WARNED_KEY,
+    PLUGIN_CHANGE_WARNING_TEMPLATE,
+    PLUGIN_ID_SEPARATOR,
+    SESSION_ID_FIELD,
+    USER_PROMPT_SUBMIT_EVENT_NAME,
+)
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+from plugin_session_baseline import (
+    all_changed_plugin_ids,
+    current_plugin_snapshot,
+    installed_plugins_path,
+    read_baseline_record,
+    write_baseline_record,
+)
+
+
+def plugin_change_output(all_plugin_ids: list[str]) -> dict[str, object]:
+    """Return the hook output that names each changed plugin and asks for a restart.
+
+    Args:
+        all_plugin_ids: The plugin ids to name, in order.
+    """
+    warning_text = PLUGIN_CHANGE_WARNING_TEMPLATE.format(
+        plugin_ids=PLUGIN_ID_SEPARATOR.join(all_plugin_ids)
+    )
+    return {
+        "systemMessage": warning_text,
+        "hookSpecificOutput": {
+            "hookEventName": USER_PROMPT_SUBMIT_EVENT_NAME,
+            "additionalContext": warning_text,
+        },
+    }
+
+
+def main() -> None:
+    """Warn once per plugin when the live plugin record differs from the session baseline."""
+    hook_payload = read_hook_input_dictionary_from_stdin()
+    if hook_payload is None:
+        return
+    session_id = hook_payload.get(SESSION_ID_FIELD)
+    if not isinstance(session_id, str) or not session_id:
+        return
+    baseline_record = read_baseline_record(session_id)
+    if baseline_record is None:
+        return
+    baseline_snapshot = baseline_record[BASELINE_PLUGINS_KEY]
+    all_warned_plugin_ids = [
+        str(each_plugin_id) for each_plugin_id in baseline_record[BASELINE_WARNED_KEY]
+    ]
+    all_new_plugin_ids = [
+        each_plugin_id
+        for each_plugin_id in all_changed_plugin_ids(
+            baseline_snapshot, current_plugin_snapshot(installed_plugins_path())
+        )
+        if each_plugin_id not in all_warned_plugin_ids
+    ]
+    if not all_new_plugin_ids:
+        return
+    write_baseline_record(
+        session_id, baseline_snapshot, [*all_warned_plugin_ids, *all_new_plugin_ids]
+    )
+    sys.stdout.write(json.dumps(plugin_change_output(all_new_plugin_ids)) + "\n")
+
+
+if __name__ == "__main__":
+    main()

package/hooks/session/plugin_session_baseline_writer.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""SessionStart hook: record the plugin versions this session loads at start.
+
+On ``startup``, and on any source when the session has no baseline yet, the
+hook writes each plugin's ``version`` and ``installPath`` from
+``installed_plugins.json`` to the session's baseline file. On ``resume``,
+``clear``, and ``compact`` it leaves an existing baseline alone, because the
+session keeps the plugin files it loaded at its first start. The
+UserPromptSubmit hook ``plugin_change_warning.py`` compares against this file.
+The hook prints nothing.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_hooks_directory = str(Path(__file__).resolve().parent.parent)
+if _hooks_directory not in sys.path:
+    sys.path.insert(0, _hooks_directory)
+
+from hooks_constants.plugin_session_baseline_constants import (
+    SESSION_ID_FIELD,
+    SESSION_SOURCE_FIELD,
+    STARTUP_SOURCE,
+)
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+from plugin_session_baseline import (
+    current_plugin_snapshot,
+    installed_plugins_path,
+    read_baseline_record,
+    write_baseline_record,
+)
+
+
+def main() -> None:
+    """Write the session's plugin baseline on startup or when none exists yet."""
+    hook_payload = read_hook_input_dictionary_from_stdin()
+    if hook_payload is None:
+        return
+    session_id = hook_payload.get(SESSION_ID_FIELD)
+    if not isinstance(session_id, str) or not session_id:
+        return
+    is_startup = hook_payload.get(SESSION_SOURCE_FIELD) == STARTUP_SOURCE
+    if not is_startup and read_baseline_record(session_id) is not None:
+        return
+    write_baseline_record(
+        session_id, current_plugin_snapshot(installed_plugins_path()), []
+    )
+
+
+if __name__ == "__main__":
+    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, "")