claude-dev-env 8.96.8 → 8.98.0

package/hooks/session/test_plugin_change_warning.py

@@ -0,0 +1,216 @@
+"""Tests for plugin_change_warning: the UserPromptSubmit plugin restart warning."""
+
+from __future__ import annotations
+
+import io
+import json
+import sys
+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 plugin_change_warning
+import plugin_session_baseline
+import plugin_session_baseline_writer
+
+SESSION_ID = "session-two"
+DEEPSTACK_ID = "deepstack@deepstack"
+PSTACK_ID = "pstack@pstack-claude"
+
+
+def _plugin_entry(version: str, install_path: str, last_updated: str) -> dict[str, str]:
+    return {
+        "scope": "user",
+        "installPath": install_path,
+        "version": version,
+        "installedAt": "2026-10-21T19:00:00.000Z",
+        "lastUpdated": last_updated,
+    }
+
+
+def write_installed_plugins(
+    config_directory: Path, all_plugins: dict[str, list[dict[str, str]]]
+) -> None:
+    plugins_directory = config_directory / "plugins"
+    plugins_directory.mkdir(parents=True, exist_ok=True)
+    (plugins_directory / "installed_plugins.json").write_text(
+        json.dumps({"version": 2, "plugins": all_plugins}), encoding="utf-8"
+    )
+
+
+def _run_main(main_function: object, payload: dict[str, str]) -> str:
+    payload_bytes = json.dumps(payload).encode("utf-8")
+    captured_stdout = io.StringIO()
+    with (
+        patch("sys.stdin", io.TextIOWrapper(io.BytesIO(payload_bytes))),
+        patch("sys.stdout", captured_stdout),
+    ):
+        main_function()
+    return captured_stdout.getvalue()
+
+
+def start_session(source: str) -> None:
+    _run_main(
+        plugin_session_baseline_writer.main,
+        {"session_id": SESSION_ID, "hook_event_name": "SessionStart", "source": source},
+    )
+
+
+def submit_prompt() -> dict[str, object] | None:
+    hook_output = _run_main(
+        plugin_change_warning.main,
+        {
+            "session_id": SESSION_ID,
+            "hook_event_name": "UserPromptSubmit",
+            "prompt": "run /deepstack-mode",
+        },
+    )
+    return json.loads(hook_output) if hook_output else None
+
+
+@pytest.fixture
+def config_directory(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    claude_config_directory = tmp_path / "config"
+    state_directory = tmp_path / "state"
+    state_directory.mkdir()
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(claude_config_directory))
+    monkeypatch.setattr(
+        plugin_session_baseline.tempfile, "gettempdir", lambda: str(state_directory)
+    )
+    return claude_config_directory
+
+
+def _warning_text(hook_output: dict[str, object] | None) -> str:
+    assert hook_output is not None
+    system_message = hook_output["systemMessage"]
+    assert isinstance(system_message, str)
+    hook_specific_output = hook_output["hookSpecificOutput"]
+    assert isinstance(hook_specific_output, dict)
+    assert hook_specific_output["hookEventName"] == "UserPromptSubmit"
+    assert hook_specific_output["additionalContext"] == system_message
+    return system_message
+
+
+def test_a_changed_version_should_warn_once(config_directory: Path) -> None:
+    write_installed_plugins(
+        config_directory,
+        {PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/1.0.0", "a")]},
+    )
+    start_session("startup")
+    write_installed_plugins(
+        config_directory,
+        {PSTACK_ID: [_plugin_entry("1.1.0", "/cache/pstack/1.1.0", "b")]},
+    )
+    warning_text = _warning_text(submit_prompt())
+    assert PSTACK_ID in warning_text
+    assert "Restart Claude Code" in warning_text
+    assert submit_prompt() is None
+
+
+def test_a_plugin_new_since_start_should_warn(config_directory: Path) -> None:
+    write_installed_plugins(
+        config_directory,
+        {PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/1.0.0", "a")]},
+    )
+    start_session("startup")
+    write_installed_plugins(
+        config_directory,
+        {
+            PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/1.0.0", "a")],
+            DEEPSTACK_ID: [_plugin_entry("3.0.0", "/cache/deepstack/3.0.0", "b")],
+        },
+    )
+    warning_text = _warning_text(submit_prompt())
+    assert DEEPSTACK_ID in warning_text
+    assert PSTACK_ID not in warning_text
+
+
+def test_a_changed_install_path_should_warn(config_directory: Path) -> None:
+    write_installed_plugins(
+        config_directory,
+        {PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/old", "a")]},
+    )
+    start_session("startup")
+    write_installed_plugins(
+        config_directory,
+        {PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/new", "a")]},
+    )
+    assert PSTACK_ID in _warning_text(submit_prompt())
+
+
+def test_a_bare_last_updated_refresh_should_stay_quiet(config_directory: Path) -> None:
+    write_installed_plugins(
+        config_directory,
+        {PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/1.0.0", "a")]},
+    )
+    start_session("startup")
+    write_installed_plugins(
+        config_directory,
+        {PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/1.0.0", "later")]},
+    )
+    assert submit_prompt() is None
+
+
+def test_an_install_then_compact_then_prompt_should_still_warn(
+    config_directory: Path,
+) -> None:
+    write_installed_plugins(
+        config_directory,
+        {PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/1.0.0", "a")]},
+    )
+    start_session("startup")
+    write_installed_plugins(
+        config_directory,
+        {
+            PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/1.0.0", "a")],
+            DEEPSTACK_ID: [_plugin_entry("3.0.0", "/cache/deepstack/3.0.0", "b")],
+        },
+    )
+    start_session("compact")
+    assert DEEPSTACK_ID in _warning_text(submit_prompt())
+
+
+def test_a_second_plugin_change_should_warn_only_for_that_plugin(
+    config_directory: Path,
+) -> None:
+    write_installed_plugins(
+        config_directory,
+        {
+            PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/1.0.0", "a")],
+            DEEPSTACK_ID: [_plugin_entry("3.0.0", "/cache/deepstack/3.0.0", "a")],
+        },
+    )
+    start_session("startup")
+    write_installed_plugins(
+        config_directory,
+        {
+            PSTACK_ID: [_plugin_entry("1.1.0", "/cache/pstack/1.1.0", "b")],
+            DEEPSTACK_ID: [_plugin_entry("3.0.0", "/cache/deepstack/3.0.0", "a")],
+        },
+    )
+    assert PSTACK_ID in _warning_text(submit_prompt())
+    write_installed_plugins(
+        config_directory,
+        {
+            PSTACK_ID: [_plugin_entry("1.2.0", "/cache/pstack/1.2.0", "c")],
+            DEEPSTACK_ID: [_plugin_entry("3.1.0", "/cache/deepstack/3.1.0", "c")],
+        },
+    )
+    second_warning_text = _warning_text(submit_prompt())
+    assert DEEPSTACK_ID in second_warning_text
+    assert PSTACK_ID not in second_warning_text
+
+
+def test_a_session_without_a_baseline_should_stay_quiet(config_directory: Path) -> None:
+    write_installed_plugins(
+        config_directory,
+        {PSTACK_ID: [_plugin_entry("1.0.0", "/cache/pstack/1.0.0", "a")]},
+    )
+    assert submit_prompt() is None

package/hooks/session/test_plugin_session_baseline_writer.py

@@ -0,0 +1,136 @@
+"""Tests for plugin_session_baseline_writer: the SessionStart plugin baseline hook."""
+
+from __future__ import annotations
+
+import io
+import json
+import sys
+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 plugin_session_baseline
+import plugin_session_baseline_writer
+
+SESSION_ID = "session-one"
+PLUGIN_ID = "deepstack@deepstack"
+
+
+def _plugin_entry(version: str, install_path: str, last_updated: str) -> dict[str, str]:
+    return {
+        "scope": "user",
+        "installPath": install_path,
+        "version": version,
+        "installedAt": "2026-10-21T19:00:00.000Z",
+        "lastUpdated": last_updated,
+    }
+
+
+def write_installed_plugins(
+    config_directory: Path, all_plugins: dict[str, list[dict[str, str]]]
+) -> None:
+    plugins_directory = config_directory / "plugins"
+    plugins_directory.mkdir(parents=True, exist_ok=True)
+    (plugins_directory / "installed_plugins.json").write_text(
+        json.dumps({"version": 2, "plugins": all_plugins}), encoding="utf-8"
+    )
+
+
+def run_writer(session_id: str, source: str) -> str:
+    payload_text = json.dumps(
+        {"session_id": session_id, "hook_event_name": "SessionStart", "source": source}
+    )
+    captured_stdout = io.StringIO()
+    with (
+        patch("sys.stdin", io.TextIOWrapper(io.BytesIO(payload_text.encode("utf-8")))),
+        patch("sys.stdout", captured_stdout),
+    ):
+        plugin_session_baseline_writer.main()
+    return captured_stdout.getvalue()
+
+
+@pytest.fixture
+def config_directory(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    claude_config_directory = tmp_path / "config"
+    state_directory = tmp_path / "state"
+    state_directory.mkdir()
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(claude_config_directory))
+    monkeypatch.setattr(
+        plugin_session_baseline.tempfile, "gettempdir", lambda: str(state_directory)
+    )
+    return claude_config_directory
+
+
+def test_startup_should_record_each_plugin_version_and_install_path(
+    config_directory: Path,
+) -> None:
+    write_installed_plugins(
+        config_directory,
+        {PLUGIN_ID: [_plugin_entry("1.0.0", "/cache/deepstack/1.0.0", "a")]},
+    )
+    assert run_writer(SESSION_ID, "startup") == ""
+    baseline_record = plugin_session_baseline.read_baseline_record(SESSION_ID)
+    assert baseline_record == {
+        "plugins": {
+            PLUGIN_ID: [{"version": "1.0.0", "installPath": "/cache/deepstack/1.0.0"}]
+        },
+        "warned": [],
+    }
+
+
+@pytest.mark.parametrize("source", ["resume", "clear", "compact"])
+def test_a_later_source_should_leave_an_existing_baseline_alone(
+    config_directory: Path, source: str
+) -> None:
+    write_installed_plugins(
+        config_directory,
+        {PLUGIN_ID: [_plugin_entry("1.0.0", "/cache/deepstack/1.0.0", "a")]},
+    )
+    run_writer(SESSION_ID, "startup")
+    baseline_path = plugin_session_baseline.baseline_record_path(SESSION_ID)
+    baseline_text = baseline_path.read_text(encoding="utf-8")
+    write_installed_plugins(
+        config_directory,
+        {PLUGIN_ID: [_plugin_entry("2.0.0", "/cache/deepstack/2.0.0", "b")]},
+    )
+    run_writer(SESSION_ID, source)
+    assert baseline_path.read_text(encoding="utf-8") == baseline_text
+
+
+def test_resume_without_a_baseline_should_write_one(config_directory: Path) -> None:
+    write_installed_plugins(
+        config_directory,
+        {PLUGIN_ID: [_plugin_entry("1.0.0", "/cache/deepstack/1.0.0", "a")]},
+    )
+    run_writer(SESSION_ID, "resume")
+    baseline_record = plugin_session_baseline.read_baseline_record(SESSION_ID)
+    assert baseline_record is not None
+    assert PLUGIN_ID in baseline_record["plugins"]
+
+
+def test_a_payload_without_a_session_id_should_write_nothing(
+    config_directory: Path, tmp_path: Path
+) -> None:
+    write_installed_plugins(
+        config_directory,
+        {PLUGIN_ID: [_plugin_entry("1.0.0", "/cache/deepstack/1.0.0", "a")]},
+    )
+    run_writer("", "startup")
+    assert list((tmp_path / "state").iterdir()) == []
+
+
+def test_a_missing_installed_plugins_file_should_record_an_empty_baseline(
+    config_directory: Path,
+) -> None:
+    run_writer(SESSION_ID, "startup")
+    assert plugin_session_baseline.read_baseline_record(SESSION_ID) == {
+        "plugins": {},
+        "warned": [],
+    }

package/hooks/test_context_budget_hooks.py

@@ -29,6 +29,8 @@ UNMEASURED_REASON_BY_SCRIPT = {
     "routing/thread_spawn_pace_hook.py": "quotes a usage reading capped by its own constant",
     "session/issue_tracker_session_starter.py": "emits only for a repository the user's "
     "project registry names by absolute path",
+    "session/plugin_change_warning.py": "emits only after a plugin changes on disk mid-session, "
+    "once per plugin, naming plugin ids",
 }
 
 

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_plugin_session_baseline.py

@@ -0,0 +1,98 @@
+"""Behavior tests for the plugin session baseline record."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+import plugin_session_baseline
+
+PLUGIN_ID = "pstack@pstack-claude"
+
+
+@pytest.fixture(autouse=True)
+def isolated_temp_folder(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setattr(
+        plugin_session_baseline.tempfile, "gettempdir", lambda: str(tmp_path)
+    )
+
+
+def test_installed_plugins_path_should_follow_the_config_directory(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(tmp_path))
+    assert plugin_session_baseline.installed_plugins_path() == (
+        tmp_path / "plugins" / "installed_plugins.json"
+    )
+
+
+def test_baseline_record_path_should_name_the_session_in_the_temp_folder(
+    tmp_path: Path,
+) -> None:
+    assert plugin_session_baseline.baseline_record_path("a/b c") == (
+        tmp_path / "plugin-session-baseline-abc.json"
+    )
+
+
+def test_current_plugin_snapshot_should_keep_only_version_and_install_path(
+    tmp_path: Path,
+) -> None:
+    record_path = tmp_path / "installed_plugins.json"
+    record_path.write_text(
+        json.dumps(
+            {
+                "plugins": {
+                    PLUGIN_ID: [
+                        {
+                            "scope": "user",
+                            "installPath": "/cache/pstack/1.0.0",
+                            "version": "1.0.0",
+                            "lastUpdated": "2026-10-21T21:26:12.000Z",
+                        }
+                    ]
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+    assert plugin_session_baseline.current_plugin_snapshot(record_path) == {
+        PLUGIN_ID: [{"version": "1.0.0", "installPath": "/cache/pstack/1.0.0"}]
+    }
+
+
+def test_current_plugin_snapshot_should_read_a_malformed_record_as_empty(
+    tmp_path: Path,
+) -> None:
+    record_path = tmp_path / "installed_plugins.json"
+    record_path.write_text("{not json", encoding="utf-8")
+    assert plugin_session_baseline.current_plugin_snapshot(record_path) == {}
+
+
+def test_read_baseline_record_should_return_what_the_writer_stored() -> None:
+    snapshot = {PLUGIN_ID: [{"version": "1.0.0", "installPath": "/cache/pstack/1.0.0"}]}
+    plugin_session_baseline.write_baseline_record("session", snapshot, [PLUGIN_ID])
+    assert plugin_session_baseline.read_baseline_record("session") == {
+        "plugins": snapshot,
+        "warned": [PLUGIN_ID],
+    }
+
+
+def test_all_changed_plugin_ids_should_name_changed_and_new_plugins_only() -> None:
+    unchanged_entries = [{"version": "1.0.0", "installPath": "/cache/a/1.0.0"}]
+    baseline_snapshot = {
+        "a@m": unchanged_entries,
+        "b@m": [{"version": "1.0.0", "installPath": "/cache/b/1.0.0"}],
+    }
+    current_snapshot = {
+        "a@m": unchanged_entries,
+        "b@m": [{"version": "2.0.0", "installPath": "/cache/b/2.0.0"}],
+        "c@m": [{"version": "1.0.0", "installPath": "/cache/c/1.0.0"}],
+    }
+    assert plugin_session_baseline.all_changed_plugin_ids(
+        baseline_snapshot, current_snapshot
+    ) == [
+        "b@m",
+        "c@m",
+    ]

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.96.8",
+    "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"],