claude-dev-env 8.73.0 → 8.73.2

package/hooks/blocking/code_rules_enforcer.py

@@ -118,9 +118,10 @@ from code_rules_paths_syspath import (  # noqa: E402
     check_hardcoded_user_paths,
     check_sys_path_insert_deduplication_guard,
 )
-from code_rules_shared import (  # noqa: E402
+from code_rules_shared import (
     changed_line_numbers,
     get_file_extension,
+    is_agent_home_tooling_outside_working_directory,
     is_ephemeral_script_path,
     is_hook_infrastructure,
     is_test_file,
@@ -754,6 +755,13 @@ def prior_and_post_edit_content(
     return existing_content, apply_edits(existing_content, [one_edit])
 
 
+def _is_exempt_tooling(file_path: str, repository_root: str) -> bool:
+    """Return whether the path is hook infrastructure or agent-home tooling outside the cwd."""
+    return is_hook_infrastructure(file_path) or is_agent_home_tooling_outside_working_directory(
+        file_path, repository_root
+    )
+
+
 def _is_validated_target(file_path: str, repository_root: str = "") -> bool:
     """Return whether the path is subject to code-rules validation.
 
@@ -764,14 +772,15 @@ def _is_validated_target(file_path: str, repository_root: str = "") -> bool:
             scratch merely because the repository sits under ``/tmp``.
 
     Returns:
-        True when the path is non-empty, outside hook infrastructure, and
-        carries a code extension; False for every exempt path.
+        Whether the path is non-empty, outside hook infrastructure, outside
+        agent-home tooling that sits beyond ``repository_root``, and carries a
+        code extension.
     """
     if not file_path:
         return False
     if is_ephemeral_script_path(file_path, repository_root):
         return False
-    if is_hook_infrastructure(file_path):
+    if _is_exempt_tooling(file_path, repository_root):
         return False
     return get_file_extension(file_path) in ALL_CODE_EXTENSIONS
 
@@ -791,13 +800,14 @@ def _is_hook_infrastructure_python_target(file_path: str, repository_root: str =
             scratch merely because the repository sits under ``/tmp``.
 
     Returns:
-        True when the path names a Python file inside hook infrastructure.
+        Whether the path names a Python file inside hook infrastructure or
+        inside agent-home tooling that sits beyond ``repository_root``.
     """
     if not file_path:
         return False
     if is_ephemeral_script_path(file_path, repository_root):
         return False
-    if not is_hook_infrastructure(file_path):
+    if not _is_exempt_tooling(file_path, repository_root):
         return False
     return get_file_extension(file_path) in ALL_PYTHON_EXTENSIONS
 

package/hooks/blocking/code_rules_shared.py

@@ -69,6 +69,27 @@ def is_agent_home_tooling(file_path: str) -> bool:
     return any(each_pattern in path_lower for each_pattern in ALL_AGENT_HOME_TOOLING_PATTERNS)
 
 
+def is_agent_home_tooling_outside_working_directory(file_path: str, repository_root: str) -> bool:
+    """Check whether a path is agent-home tooling that sits outside the session cwd.
+
+    A repository checked out under an agent home, such as
+    ``~/.grok/runs/<repo>/``, is project code whenever the session works inside
+    it, so only agent-home paths outside the payload ``cwd`` stay exempt.
+
+    Args:
+        file_path: The candidate path to classify.
+        repository_root: The PreToolUse payload's ``cwd``, or an empty string
+            when the payload names none.
+
+    Returns:
+        Whether the path sits under a recognized agent home directory and
+        outside ``repository_root``.
+    """
+    return is_agent_home_tooling(file_path) and not _is_at_or_under_payload_working_directory(
+        file_path, {"cwd": repository_root}
+    )
+
+
 def is_test_file(file_path: str) -> bool:
     """Check if file is a test file."""
     path_lower = file_path.lower()
@@ -502,7 +523,7 @@ def is_ephemeral_path(file_path: str, hook_payload: dict | None = None) -> bool:
     checked out under ``/tmp`` or ``~/.grok/runs/`` still receives full
     enforcement. The scratchpad match reads the session id from the payload
     when supplied, else the harness environment variable. The code-rules and TDD gates call the underlying predicates
-    ``is_ephemeral_script_path``, ``is_agent_home_tooling``, and
+    ``is_ephemeral_script_path``, ``is_agent_home_tooling_outside_working_directory``, and
     ``is_under_session_scratchpad`` directly.
 
     Args:
@@ -517,9 +538,7 @@ def is_ephemeral_path(file_path: str, hook_payload: dict | None = None) -> bool:
     repository_root = str((hook_payload or {}).get("cwd") or "")
     if is_ephemeral_script_path(file_path, repository_root):
         return True
-    if is_agent_home_tooling(file_path) and not _is_at_or_under_payload_working_directory(
-        file_path, hook_payload or {}
-    ):
+    if is_agent_home_tooling_outside_working_directory(file_path, repository_root):
         return True
     return is_under_session_scratchpad(file_path, hook_payload or {})
 

package/hooks/blocking/reply_length_gate.py

@@ -41,6 +41,15 @@ Each non-empty line counts as its own sentence, so a list counts one
 sentence per item. URLs, markdown link targets, inline code spans, and
 fenced blocks carry no words.
 
+With visual reply mode on, the gate also runs the checks in
+``visual_reply_rules.py``. The mode is off until
+``~/.claude/visual-reply-mode.json`` holds ``{"enabled": true}``. A reply
+or a decision card may hold no abbreviation and no tracker number outside
+a link. A reply of more than one sentence needs a widget or a page earlier
+in the turn. A turn sends one reply, so a reply after a delivered reply in
+the same turn is denied. A widget may hold no anchor link, since a widget
+link does not open in the Claude app.
+
 A length limit is a smell elsewhere in this package, recorded and fixed in a
 later pass. A posted reply reaches the user the moment it sends and has no
 later pass, so this gate denies it and the model resends a shorter one.
@@ -58,6 +67,15 @@ if hooks_root_directory not in sys.path:
     sys.path.insert(0, hooks_root_directory)
 
 from json_file_reader import read_json_object
+from visual_reply_rules import (
+    VisualReplyRules,
+    abbreviation_violation,
+    load_rules,
+    mode_enabled,
+    second_reply_violation,
+    visual_violation,
+    widget_anchor_violation,
+)
 from hooks_constants.hook_block_logger import log_hook_block
 from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
 from hooks_constants.reply_length_gate_constants import (
@@ -101,6 +119,7 @@ from hooks_constants.reply_length_gate_constants import (
     TOO_MANY_SENTENCES_MESSAGE,
     TOOL_INPUT_KEY,
     TOOL_NAME_KEY,
+    TRANSCRIPT_PATH_KEY,
     UNLINKED_PULL_REQUEST_MESSAGE,
     UNLINKED_PULL_REQUEST_PATTERN,
     UNSOURCED_CAUSE_MESSAGE,
@@ -176,12 +195,17 @@ def unsourced_cause_violation(reply_text: str) -> str | None:
     return None
 
 
-def unlinked_pull_request_violation(reply_text: str) -> str | None:
-    """Return the deny reason for a pull request number outside a link, or None."""
+def prose_outside_links(reply_text: str) -> str:
+    """Remove fenced blocks, code spans, whole markdown links and URLs."""
     without_fences = FENCED_BLOCK_PATTERN.sub(" ", reply_text)
     without_code = INLINE_CODE_PATTERN.sub(" ", without_fences)
     without_links = MARKDOWN_LINK_PATTERN.sub(" ", without_code)
-    unlinked_match = UNLINKED_PULL_REQUEST_PATTERN.search(URL_PATTERN.sub(" ", without_links))
+    return URL_PATTERN.sub(" ", without_links)
+
+
+def unlinked_pull_request_violation(reply_text: str) -> str | None:
+    """Return the deny reason for a pull request number outside a link, or None."""
+    unlinked_match = UNLINKED_PULL_REQUEST_PATTERN.search(prose_outside_links(reply_text))
     if unlinked_match is None:
         return None
     return UNLINKED_PULL_REQUEST_MESSAGE.format(reference=unlinked_match.group(0))
@@ -240,17 +264,24 @@ def all_card_texts(all_card_input: dict[str, object]) -> list[str]:
     ]
 
 
-def tool_violation(tool_name: object, all_tool_input: dict[str, object]) -> tuple[str, str] | None:
-    """Return the deny reason and the checked text for one call, or None when it passes."""
-    if tool_name == DECISION_CARD_TOOL_NAME:
-        card_text = CARD_TEXT_SEPARATOR.join(all_card_texts(all_tool_input))
-        card_violation = banned_word_violation(card_text, configured_banned_words())
-        return None if card_violation is None else (card_violation, card_text)
-    if tool_name not in ALL_CHECKED_TOOL_NAMES:
-        return None
-    reply_text = all_tool_input.get(TEXT_KEY)
-    if not isinstance(reply_text, str):
+def active_mode_rules() -> VisualReplyRules | None:
+    """Return the visual reply rules when the mode is on and the rule file parses."""
+    if not mode_enabled(Path.home() / CLAUDE_HOME_DIRECTORY_NAME):
         return None
+    return load_rules()
+
+
+def card_violation(card_text: str, mode_rules: VisualReplyRules | None) -> str | None:
+    """Return the deny reason for a decision card's prose, or None."""
+    return banned_word_violation(card_text, configured_banned_words()) or (
+        None if mode_rules is None else abbreviation_violation(prose_outside_links(card_text), mode_rules)
+    )
+
+
+def reply_violation(
+    reply_text: str, transcript_path: object, mode_rules: VisualReplyRules | None
+) -> str | None:
+    """Return the deny reason for a reply's text, or None."""
     violation = (
         length_violation(reply_text)
         or mid_sentence_colon_violation(reply_text)
@@ -259,6 +290,35 @@ def tool_violation(tool_name: object, all_tool_input: dict[str, object]) -> tupl
         or unsourced_cause_violation(reply_text)
         or banned_word_violation(reply_text, configured_banned_words())
     )
+    if violation is not None or mode_rules is None:
+        return violation
+    prose_text = prose_outside_links(reply_text)
+    return (
+        abbreviation_violation(prose_text, mode_rules)
+        or second_reply_violation(transcript_path, mode_rules)
+        or visual_violation(len(sentence_word_lists(reply_text)), transcript_path, mode_rules)
+    )
+
+
+def tool_violation(
+    tool_name: object, all_tool_input: dict[str, object], transcript_path: object = None
+) -> tuple[str, str] | None:
+    """Return the deny reason and the checked text for one call, or None when it passes."""
+    mode_rules = active_mode_rules()
+    if isinstance(tool_name, str) and mode_rules is not None:
+        anchor_violation = widget_anchor_violation(tool_name, all_tool_input)
+        if anchor_violation is not None:
+            return anchor_violation, str(all_tool_input)
+    if tool_name == DECISION_CARD_TOOL_NAME:
+        card_text = CARD_TEXT_SEPARATOR.join(all_card_texts(all_tool_input))
+        violation = card_violation(card_text, mode_rules)
+        return None if violation is None else (violation, card_text)
+    if tool_name not in ALL_CHECKED_TOOL_NAMES:
+        return None
+    reply_text = all_tool_input.get(TEXT_KEY)
+    if not isinstance(reply_text, str):
+        return None
+    violation = reply_violation(reply_text, transcript_path, mode_rules)
     return None if violation is None else (violation, reply_text)
 
 
@@ -270,7 +330,7 @@ def main() -> int:
     tool_input = hook_input.get(TOOL_INPUT_KEY)
     if not isinstance(tool_input, dict):
         return ALLOW_EXIT_CODE
-    checked = tool_violation(tool_name, tool_input)
+    checked = tool_violation(tool_name, tool_input, hook_input.get(TRANSCRIPT_PATH_KEY))
     if checked is None:
         return ALLOW_EXIT_CODE
     violation, reply_text = checked

package/hooks/blocking/state_description_blocker.py

@@ -500,7 +500,7 @@ def build_deny_payload(deny_reason: str) -> dict[str, object]:
                 "only the current state. For example:\n"
                 '  BAD: "Uses X instead of Y"  →  GOOD: "Uses X"\n'
                 '  BAD: "Previously configured via Z"  →  GOOD: "Configured via Z"\n'
-                "Apply ~/.claude/rules/asd-ste100-language.md for user-facing language."
+                "Apply ~/.claude/docs/rule-guides/asd-ste100-language.md for user-facing language."
             ),
         },
         "systemMessage": "Agent wrote comparative/historical language - describe current state only",

package/hooks/blocking/test_code_rules_enforcer_agent_home_tooling.py

@@ -11,6 +11,7 @@ so the repository code rules do not govern it::
 
 from __future__ import annotations
 
+import json
 import os
 from subprocess import CompletedProcess
 import tempfile
@@ -20,8 +21,9 @@ import pytest
 
 from blocking import _path_setup  # noqa: F401  (pins this checkout ahead of sibling worktrees)
 import code_rules_enforcer_test_support
+from blocking.code_rules_enforcer import main as enforcer_main
 from blocking.code_rules_shared import is_agent_home_tooling, is_ephemeral_path
-from code_rules_enforcer_test_support import run_precheck
+from code_rules_enforcer_test_support import run_precheck, run_serialized_payload_entrypoint
 
 _VIOLATING_PRODUCTION_SOURCE = "def process_data(payload: str) -> None:\n    print(payload)\n"
 
@@ -122,3 +124,54 @@ def test_enforcer_still_flags_the_same_source_in_a_project_path() -> None:
     completed = _check_as(_VIOLATING_PRODUCTION_SOURCE, target)
 
     assert completed.returncode != 0
+
+
+def _run_enforcer_with_payload(all_pretooluse_payload: dict[str, object]) -> str:
+    """Drive the enforcer's stdin entry point and return what it wrote to stdout."""
+    captured_stdout, _exit_code = run_serialized_payload_entrypoint(
+        enforcer_main, json.dumps(all_pretooluse_payload)
+    )
+    return captured_stdout
+
+
+def test_enforcer_applies_every_rule_to_a_repository_checked_out_under_the_agent_home(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> None:
+    home_root = tmp_path_factory.mktemp("agent-home")
+    repository_directory = home_root / "home" / "example" / ".grok" / "runs" / "checkout"
+    service_module = repository_directory / "src" / "service.py"
+    service_module.parent.mkdir(parents=True)
+    service_module.write_text(
+        "def process_data(payload: str) -> None:\n    return None\n", encoding="utf-8"
+    )
+
+    captured_stdout = _run_enforcer_with_payload(
+        {
+            "tool_name": "Edit",
+            "tool_input": {
+                "file_path": str(service_module),
+                "old_string": "    return None\n",
+                "new_string": "    print(payload)\n",
+            },
+            "cwd": str(repository_directory),
+        }
+    )
+
+    assert '"permissionDecision": "deny"' in captured_stdout
+    assert "Library print()" in captured_stdout
+    assert "banned noun word" in captured_stdout
+
+
+def test_enforcer_keeps_agent_home_tooling_outside_the_cwd_exempt() -> None:
+    helper_script = os.path.join("/home/example", ".grok", "runs", "worktree-health", "health.py")
+    repository_directory = os.path.join("/home/example", ".grok", "runs", "checkout")
+
+    captured_stdout = _run_enforcer_with_payload(
+        {
+            "tool_name": "Write",
+            "tool_input": {"file_path": helper_script, "content": _VIOLATING_PRODUCTION_SOURCE},
+            "cwd": repository_directory,
+        }
+    )
+
+    assert captured_stdout == ""

package/hooks/blocking/test_code_rules_shared.py

@@ -374,3 +374,36 @@ def test_ephemeral_path_stays_true_for_agent_home_file_outside_payload_cwd() ->
     helper_script = os.path.join("/home/example", ".grok", "runs", "worktree-health", "health.py")
 
     assert _SHARED_MODULE.is_ephemeral_path(helper_script, {"cwd": checkout_directory}) is True
+
+
+def test_agent_home_tooling_under_the_cwd_is_not_exempt() -> None:
+    checkout_directory = os.path.join("/home/example", ".grok", "runs", "checkout")
+    repository_module = os.path.join(checkout_directory, "src", "service.py")
+
+    assert (
+        _SHARED_MODULE.is_agent_home_tooling_outside_working_directory(
+            repository_module, checkout_directory
+        )
+        is False
+    )
+
+
+def test_agent_home_tooling_outside_the_cwd_is_exempt() -> None:
+    checkout_directory = os.path.join("/home/example", ".grok", "runs", "checkout")
+    helper_script = os.path.join("/home/example", ".grok", "runs", "worktree-health", "health.py")
+
+    assert _SHARED_MODULE.is_agent_home_tooling_outside_working_directory(
+        helper_script, checkout_directory
+    )
+
+
+def test_agent_home_tooling_with_no_cwd_is_exempt() -> None:
+    helper_script = os.path.join("/home/example", ".grok", "runs", "worktree-health", "health.py")
+
+    assert _SHARED_MODULE.is_agent_home_tooling_outside_working_directory(helper_script, "")
+
+
+def test_hook_infrastructure_excludes_agent_home_tooling() -> None:
+    helper_script = os.path.join("/home/example", ".grok", "runs", "worktree-health", "health.py")
+
+    assert _SHARED_MODULE.is_hook_infrastructure(helper_script) is False

package/hooks/blocking/test_reply_length_gate.py

@@ -22,12 +22,15 @@ def run_gate(
     capsys: pytest.CaptureFixture[str],
     tool_name: str,
     tool_input: dict[str, object],
+    transcript_path: Path | None = None,
 ) -> tuple[int, str]:
-    hook_input = {
+    hook_input: dict[str, object] = {
         "hook_event_name": "PreToolUse",
         "tool_name": tool_name,
         "tool_input": tool_input,
     }
+    if transcript_path is not None:
+        hook_input["transcript_path"] = str(transcript_path)
     monkeypatch.setattr(
         "sys.stdin", io.TextIOWrapper(io.BytesIO(json.dumps(hook_input).encode("utf-8")))
     )
@@ -39,6 +42,9 @@ def run_gate(
 def isolated_home(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
     monkeypatch.setenv("HOME", str(tmp_path))
     monkeypatch.setenv("USERPROFILE", str(tmp_path))
+    switch_path = tmp_path / ".claude" / "visual-reply-mode.json"
+    switch_path.parent.mkdir(exist_ok=True)
+    switch_path.write_text('{"enabled": true}', encoding="utf-8")
 
 
 def test_should_allow_three_short_sentences(
@@ -48,7 +54,7 @@ def test_should_allow_three_short_sentences(
         monkeypatch,
         capsys,
         REPLY_TOOL_NAME,
-        {"text": "The fix is in. Tests pass on CI. It ships with the next release."},
+        {"text": "The fix is in. Tests pass. It ships with the next release."},
     )
     assert (exit_code, stderr_text) == (0, "")
 
@@ -292,7 +298,7 @@ def test_should_replace_the_defaults_with_the_configured_list(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
     config_path = tmp_path / ".claude" / "reply-banned-words.json"
-    config_path.parent.mkdir()
+    config_path.parent.mkdir(exist_ok=True)
     config_path.write_text(json.dumps({"banned_words": ["synergy"]}), encoding="utf-8")
     likely_exit_code, _ = run_gate(
         monkeypatch, capsys, REPLY_TOOL_NAME, {"text": "It likely passed."}
@@ -318,7 +324,7 @@ def test_should_keep_the_defaults_when_the_config_file_is_malformed(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
     config_path = tmp_path / ".claude" / "reply-banned-words.json"
-    config_path.parent.mkdir()
+    config_path.parent.mkdir(exist_ok=True)
     config_path.write_text("{not json", encoding="utf-8")
     exit_code, _ = run_gate(monkeypatch, capsys, REPLY_TOOL_NAME, {"text": "It likely passed."})
     assert exit_code == 2
@@ -426,7 +432,7 @@ def test_should_apply_the_configured_list_to_decision_cards(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
 ) -> None:
     config_path = tmp_path / ".claude" / "reply-banned-words.json"
-    config_path.parent.mkdir()
+    config_path.parent.mkdir(exist_ok=True)
     config_path.write_text(json.dumps({"banned_words": ["synergy"]}), encoding="utf-8")
     probably_exit_code, _ = run_gate(
         monkeypatch,
@@ -489,6 +495,179 @@ def test_should_deny_an_em_dash_and_allow_one_in_code(
     assert "em dash" in denied_text
 
 
+WIDGET_TOOL_NAME = "mcp__hearthbot__post_widget"
+TWO_SENTENCE_REPLY = "The deploy stopped on a missing file. The page shows each step."
+
+
+def write_transcript(transcript_path: Path, all_entries: list[dict[str, object]]) -> Path:
+    transcript_path.write_text(
+        "\n".join(json.dumps(each_entry) for each_entry in all_entries), encoding="utf-8"
+    )
+    return transcript_path
+
+
+def prompt_entry(text: str) -> dict[str, object]:
+    return {"type": "user", "message": {"role": "user", "content": text}}
+
+
+def tool_call_entry(tool_name: str) -> dict[str, object]:
+    return {
+        "type": "assistant",
+        "message": {"content": [{"type": "tool_use", "id": "t1", "name": tool_name, "input": {}}]},
+    }
+
+
+def turn_mode_off(tmp_path: Path) -> None:
+    switch_path = tmp_path / ".claude" / "visual-reply-mode.json"
+    switch_path.parent.mkdir(exist_ok=True)
+    switch_path.write_text('{"enabled": false}', encoding="utf-8")
+
+
+def test_should_deny_an_abbreviation_in_a_reply(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, stderr_text = run_gate(
+        monkeypatch, capsys, REPLY_TOOL_NAME, {"text": "The API deploy is fixed."}
+    )
+    assert exit_code == 2
+    assert 'Abbreviation "API"' in stderr_text
+
+
+def test_should_allow_an_abbreviation_inside_a_pull_request_link(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, _ = run_gate(
+        monkeypatch,
+        capsys,
+        REPLY_TOOL_NAME,
+        {"text": "It merged in [PR 5256](https://github.com/owner/repo/pull/5256)."},
+    )
+    assert exit_code == 0
+
+
+def test_should_deny_a_tracker_item_number(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, stderr_text = run_gate(
+        monkeypatch, capsys, REPLY_TOOL_NAME, {"text": "Item 6 is ready for you."}
+    )
+    assert exit_code == 2
+    assert 'Tracker number "Item 6"' in stderr_text
+
+
+def test_should_deny_an_abbreviation_in_a_decision_card(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, stderr_text = run_gate(
+        monkeypatch,
+        capsys,
+        DECISION_TOOL_NAME,
+        {"question": "Ship the API fix?", "options": [{"label": "Ship it", "consequence": "It merges."}]},
+    )
+    assert exit_code == 2
+    assert 'Abbreviation "API"' in stderr_text
+
+
+def test_should_deny_two_sentences_with_no_visual_this_turn(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    transcript_path = write_transcript(
+        tmp_path / "t.jsonl",
+        [prompt_entry("why did the deploy stop"), tool_call_entry("Bash")],
+    )
+    exit_code, stderr_text = run_gate(
+        monkeypatch, capsys, REPLY_TOOL_NAME, {"text": TWO_SENTENCE_REPLY}, transcript_path
+    )
+    assert exit_code == 2
+    assert "no visual this turn" in stderr_text
+
+
+def test_should_allow_two_sentences_after_a_widget_this_turn(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    transcript_path = write_transcript(
+        tmp_path / "t.jsonl",
+        [prompt_entry("why did the deploy stop"), tool_call_entry(WIDGET_TOOL_NAME)],
+    )
+    exit_code, _ = run_gate(
+        monkeypatch, capsys, REPLY_TOOL_NAME, {"text": TWO_SENTENCE_REPLY}, transcript_path
+    )
+    assert exit_code == 0
+
+
+def test_should_deny_when_the_only_widget_came_before_the_last_prompt(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    transcript_path = write_transcript(
+        tmp_path / "t.jsonl",
+        [
+            prompt_entry("why did the deploy stop"),
+            tool_call_entry(WIDGET_TOOL_NAME),
+            prompt_entry("and the logs"),
+        ],
+    )
+    exit_code, _ = run_gate(
+        monkeypatch, capsys, REPLY_TOOL_NAME, {"text": TWO_SENTENCE_REPLY}, transcript_path
+    )
+    assert exit_code == 2
+
+
+def test_should_allow_one_sentence_with_no_visual(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    transcript_path = write_transcript(tmp_path / "t.jsonl", [prompt_entry("merge it")])
+    exit_code, _ = run_gate(
+        monkeypatch, capsys, REPLY_TOOL_NAME, {"text": "It merged."}, transcript_path
+    )
+    assert exit_code == 0
+
+
+def test_should_deny_an_anchor_link_inside_widget_code(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, stderr_text = run_gate(
+        monkeypatch,
+        capsys,
+        WIDGET_TOOL_NAME,
+        {"widget_code": '<div><a href="https://claude.ai/artifact/x">Review page</a></div>'},
+    )
+    assert exit_code == 2
+    assert "does not open in the Claude app" in stderr_text
+
+
+def test_should_allow_widget_code_with_no_anchor(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, _ = run_gate(
+        monkeypatch, capsys, WIDGET_TOOL_NAME, {"widget_code": "<div>Three steps</div>"}
+    )
+    assert exit_code == 0
+
+
+def test_should_skip_the_mode_checks_when_the_switch_turns_the_mode_off(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    turn_mode_off(tmp_path)
+    transcript_path = write_transcript(tmp_path / "t.jsonl", [prompt_entry("status")])
+    all_exit_codes = [
+        run_gate(monkeypatch, capsys, REPLY_TOOL_NAME, {"text": "The API deploy is fixed."})[0],
+        run_gate(monkeypatch, capsys, REPLY_TOOL_NAME, {"text": "Which build ships first?"})[0],
+        run_gate(
+            monkeypatch, capsys, REPLY_TOOL_NAME, {"text": TWO_SENTENCE_REPLY}, transcript_path
+        )[0],
+        run_gate(monkeypatch, capsys, WIDGET_TOOL_NAME, {"widget_code": '<a href="x">go</a>'})[0],
+    ]
+    assert all_exit_codes == [0, 0, 0, 0]
+
+
+def test_should_keep_the_length_check_when_the_mode_is_off(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    turn_mode_off(tmp_path)
+    exit_code, _ = run_gate(monkeypatch, capsys, REPLY_TOOL_NAME, {"text": "One. Two. Three. Four."})
+    assert exit_code == 2
+
+
 def test_should_deny_the_quoted_cause_with_no_source(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:

package/hooks/blocking/test_state_description_blocker.py

@@ -741,7 +741,7 @@ def test_additional_context_contains_examples():
     ctx = output["hookSpecificOutput"].get("additionalContext", "")
     assert "BAD:" in ctx
     assert "GOOD:" in ctx
-    assert "~/.claude/rules/asd-ste100-language.md" in ctx
+    assert "~/.claude/docs/rule-guides/asd-ste100-language.md" in ctx
 
 
 def test_handles_non_dict_stdin():