claude-dev-env 8.106.1 → 8.106.3

package/hooks/session/test_skill_loaded_reminder.py

@@ -1,4 +1,4 @@
-"""Tests for skill_loaded_reminder. Checks restoration after compaction and helper prompts."""
+"""Tests for skill_loaded_reminder. Checks restoration after compaction and spawn pass-through."""
 
 import json
 import sys
@@ -76,10 +76,6 @@ def _run_main(hook_payload: object) -> str:
     return captured_stdout.getvalue()
 
 
-def _agent_call(tool_input: dict[str, object], tool_name: str = "Agent") -> dict[str, object]:
-    return {"hook_event_name": "PreToolUse", "tool_name": tool_name, "tool_input": tool_input}
-
-
 def _user_turn(transcript_path: Path) -> dict[str, object]:
     return {"hook_event_name": "UserPromptSubmit", "transcript_path": str(transcript_path)}
 
@@ -90,85 +86,28 @@ def _write_transcript(tmp_path: Path, all_lines: list[str]) -> Path:
     return transcript_path
 
 
-class TestSubagentSpawn:
-    def test_a_plain_subagent_prompt_opens_with_the_poteto_mode_invocation(self) -> None:
-        emitted = json.loads(
-            _run_main(
-                _agent_call(
-                    {
-                        "description": "Find callers",
-                        "subagent_type": "Explore",
-                        "prompt": "List every caller of main.",
-                    }
-                )
-            )
-        )
-        hook_output = emitted["hookSpecificOutput"]
-        rewritten_input = hook_output["updatedInput"]
-        assert hook_output["permissionDecision"] == "allow"
-        assert rewritten_input["prompt"].startswith(
-            "Before any other work, invoke the poteto-mode skill with the Skill tool."
-        )
-        assert rewritten_input["prompt"].endswith("\n\nList every caller of main.")
-        assert rewritten_input["subagent_type"] == "Explore"
-        assert rewritten_input["description"] == "Find callers"
-
-    def test_the_legacy_task_tool_name_is_rewritten_too(self) -> None:
-        emitted = json.loads(_run_main(_agent_call({"prompt": "Go."}, tool_name="Task")))
-        assert "poteto-mode" in emitted["hookSpecificOutput"]["updatedInput"]["prompt"]
-
-    def test_a_prompt_that_already_names_the_skill_is_left_alone(self) -> None:
-        assert _run_main(_agent_call({"prompt": "Invoke poteto-mode first. Then go."})) == ""
+class TestRegistration:
+    def test_a_spawn_payload_from_a_stale_registration_prints_nothing(self) -> None:
+        stale_spawn_payload = {
+            "hook_event_name": "PreToolUse",
+            "tool_name": "Agent",
+            "tool_input": {"prompt": "Reply leaf."},
+        }
+        assert _run_main(stale_spawn_payload) == ""
 
-    def test_a_poteto_agent_is_left_alone_because_it_loads_the_skill_itself(self) -> None:
-        assert (
-            _run_main(_agent_call({"subagent_type": "pstack:poteto-agent", "prompt": "Go."})) == ""
+    def test_no_pre_tool_use_group_runs_the_reminder(self) -> None:
+        shipped_hooks = json.loads(
+            (Path(__file__).resolve().parents[1] / "hooks.json").read_text(encoding="utf-8")
         )
-
-    def test_another_tool_is_left_alone(self) -> None:
-        assert _run_main(_agent_call({"prompt": "Go."}, tool_name="Bash")) == ""
-
-
-class TestSubagentInputWithPotetoMode:
-    def test_every_other_input_field_is_kept(self) -> None:
-        rewritten_input = reminder.subagent_input_with_poteto_mode(
-            "Agent", {"prompt": "Go.", "model": "sonnet", "run_in_background": True}
-        )
-        assert rewritten_input is not None
-        assert rewritten_input["model"] == "sonnet"
-        assert rewritten_input["run_in_background"] is True
-
-    def test_an_input_with_no_prompt_is_left_alone(self) -> None:
-        assert reminder.subagent_input_with_poteto_mode("Agent", {"description": "Go"}) is None
-
-    def test_a_codex_spawn_input_with_only_items_is_left_alone(self) -> None:
-        assert (
-            reminder.subagent_input_with_poteto_mode(
-                "spawn_agent", {"items": [{"type": "text", "text": "Go."}]}
-            )
-            is None
-        )
-
-
-class TestCodexSpawn:
-    def test_a_codex_spawn_message_opens_with_the_skill_mention(self) -> None:
-        emitted = json.loads(
-            _run_main(
-                _agent_call(
-                    {"message": "Fix the failing test.", "model": "gpt-6-luna"},
-                    tool_name="spawn_agent",
-                )
-            )
-        )
-        rewritten_input = emitted["hookSpecificOutput"]["updatedInput"]
-        assert rewritten_input["message"] == "$poteto-mode\n\nFix the failing test."
-        assert rewritten_input["model"] == "gpt-6-luna"
-        assert "prompt" not in rewritten_input
-
-    def test_a_codex_spawn_message_that_already_mentions_the_skill_is_left_alone(self) -> None:
-        assert (
-            _run_main(_agent_call({"message": "$poteto-mode\n\nFix it."}, tool_name="spawn_agent"))
-            == ""
+        all_pre_tool_use_commands = [
+            each_hook.get("command", "")
+            for each_group in shipped_hooks["hooks"]["PreToolUse"]
+            for each_hook in each_group["hooks"]
+        ]
+        assert all_pre_tool_use_commands
+        assert not any(
+            "skill_loaded_reminder.py" in each_command
+            for each_command in all_pre_tool_use_commands
         )
 
 
@@ -353,9 +292,7 @@ class TestReminderFor:
         assert hook_output["hookEventName"] == "SubagentStart"
         assert hook_output["additionalContext"] == NOT_LOADED_REMINDER
 
-    def test_an_agent_tool_helper_starting_prints_nothing_since_its_prompt_carries_the_line(
-        self,
-    ) -> None:
+    def test_an_agent_tool_helper_starting_prints_nothing(self) -> None:
         assert (
             _run_main({"hook_event_name": "SubagentStart", "agent_type": "general-purpose"}) == ""
         )

package/hooks/test_visual_reply_rules.py

@@ -72,6 +72,18 @@ def test_abbreviation_violation_flags_a_lowercase_abbreviation_and_a_tracker_num
     assert 'Tracker number "card 12"' in str(abbreviation_violation("See card 12.", SHIPPED_RULES))
 
 
+def test_abbreviation_violation_names_every_abbreviation_and_tracker_number_on_its_own_line() -> None:
+    assert SHIPPED_RULES is not None
+    violation = str(abbreviation_violation("The UI and the API, e.g. card 12 and card 13.", SHIPPED_RULES))
+    all_lines = violation.splitlines()
+    assert len(all_lines) == 5
+    assert 'Abbreviation "UI"' in all_lines[0]
+    assert 'Abbreviation "API"' in all_lines[1]
+    assert 'Abbreviation "e.g."' in all_lines[2]
+    assert 'Tracker number "card 12"' in all_lines[3]
+    assert 'Tracker number "card 13"' in all_lines[4]
+
+
 def test_widget_anchor_violation_reads_only_widget_calls() -> None:
     anchor_input = {"widget_code": '<a href="https://example.com">page</a>'}
     assert widget_anchor_violation("mcp__hearthbot__post_widget", anchor_input) is not None

package/hooks/visual_reply_rules.py

@@ -19,6 +19,7 @@ from pathlib import Path
 from json_file_reader import read_json_object
 from hooks_constants.visual_reply_rules_constants import (
     ABBREVIATION_MESSAGE,
+    VIOLATION_LINE_SEPARATOR,
     ABBREVIATIONS_RULE_KEY,
     ALL_REPLY_TOOL_NAME_SUFFIXES,
     ALL_VISUAL_TOOL_NAME_SUFFIXES,
@@ -140,19 +141,35 @@ def mode_enabled(claude_home: Path) -> bool:
 
 
 def abbreviation_violation(prose_text: str, rules: VisualReplyRules) -> str | None:
-    """Return the deny reason for the first abbreviation in prose with links and code removed."""
+    """Return the deny reason naming each abbreviation and tracker number in prose with links and code removed.
+
+    Each one gets its own line, so one refusal names them all.
+    """
     reminder = rules.reminder(ABBREVIATIONS_RULE_KEY)
-    for each_match in CAPITALIZED_ABBREVIATION_PATTERN.finditer(prose_text):
-        if each_match.group(0) not in rules.all_allowed_capitalized_words:
-            return ABBREVIATION_MESSAGE.format(abbreviation=each_match.group(0), reminder=reminder)
-    for each_abbreviation in rules.all_lowercase_abbreviations:
-        pattern = LOWERCASE_ABBREVIATION_TEMPLATE.format(abbreviation=re.escape(each_abbreviation))
-        if re.search(pattern, prose_text, re.IGNORECASE):
-            return ABBREVIATION_MESSAGE.format(abbreviation=each_abbreviation, reminder=reminder)
-    tracker_match = TRACKER_NUMBER_PATTERN.search(prose_text)
-    if tracker_match is not None:
-        return TRACKER_NUMBER_MESSAGE.format(reference=tracker_match.group(0), reminder=reminder)
-    return None
+    all_abbreviations = [
+        each_match.group(0)
+        for each_match in CAPITALIZED_ABBREVIATION_PATTERN.finditer(prose_text)
+        if each_match.group(0) not in rules.all_allowed_capitalized_words
+    ] + [
+        each_abbreviation
+        for each_abbreviation in rules.all_lowercase_abbreviations
+        if re.search(
+            LOWERCASE_ABBREVIATION_TEMPLATE.format(abbreviation=re.escape(each_abbreviation)),
+            prose_text,
+            re.IGNORECASE,
+        )
+    ]
+    all_violations = [
+        *(
+            ABBREVIATION_MESSAGE.format(abbreviation=each_abbreviation, reminder=reminder)
+            for each_abbreviation in dict.fromkeys(all_abbreviations)
+        ),
+        *(
+            TRACKER_NUMBER_MESSAGE.format(reference=each_match.group(0), reminder=reminder)
+            for each_match in TRACKER_NUMBER_PATTERN.finditer(prose_text)
+        ),
+    ]
+    return VIOLATION_LINE_SEPARATOR.join(all_violations) if all_violations else None
 
 
 def widget_anchor_violation(tool_name: str, all_tool_input: dict[str, object]) -> str | None:

package/package.json

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

package/hooks/workflow/investigation_tracker_reset.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python3
-"""PostToolUse hook — resets the serial investigation tracker when delegation occurs.
-
-Clears the investigation timestamp tracker when the lead session delegates work
-via Agent, Task, or TeamCreate tools. This allows the lead to resume limited
-diagnostic calls after properly delegating.
-
-Companion: blocking/serial-investigation-blocker.py (PreToolUse on Read|Bash|Grep)
-"""
-
-import json
-import os
-import sys
-
-TRACKER_STATE_PATH = os.path.join(
-    os.path.expanduser("~"), ".claude", "runtime", "investigation-tracker.json"
-)
-
-DELEGATION_TOOLS = frozenset({"Agent", "Task", "TeamCreate"})
-
-
-def clear_investigation_tracker() -> None:
-    try:
-        os.remove(TRACKER_STATE_PATH)
-    except FileNotFoundError:
-        pass
-    except OSError:
-        pass
-
-
-def main() -> None:
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-    if not isinstance(hook_input, dict):
-        sys.exit(0)
-
-    tool_name = hook_input.get("tool_name", "")
-    if tool_name not in DELEGATION_TOOLS:
-        sys.exit(0)
-
-    clear_investigation_tracker()
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/workflow/test_investigation_tracker_reset.py

@@ -1,90 +0,0 @@
-"""Behavior tests for investigation tracker reset."""
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import json
-from pathlib import Path
-from unittest import mock
-
-import pytest
-
-
-HOOK_DIRECTORY = Path(__file__).parent
-HOOK_SPEC = importlib.util.spec_from_file_location(
-    "investigation_tracker_reset",
-    HOOK_DIRECTORY / "investigation_tracker_reset.py",
-)
-assert HOOK_SPEC is not None
-assert HOOK_SPEC.loader is not None
-HOOK_MODULE = importlib.util.module_from_spec(HOOK_SPEC)
-HOOK_SPEC.loader.exec_module(HOOK_MODULE)
-
-
-def _run_main(input_text: str) -> int | None:
-    with mock.patch("sys.stdin", io.StringIO(input_text)):
-        try:
-            HOOK_MODULE.main()
-        except SystemExit as system_exit:
-            if system_exit.code not in (None, 0):
-                raise
-            return system_exit.code if isinstance(system_exit.code, int) else None
-    return None
-
-
-@pytest.mark.parametrize("delegation_tool", ["Agent", "Task", "TeamCreate"])
-def test_main_removes_tracker_after_delegation(
-    tmp_path: Path,
-    delegation_tool: str,
-) -> None:
-    tracker_path = tmp_path / "investigation-tracker.json"
-    tracker_path.write_text("{}", encoding="utf-8")
-    HOOK_MODULE.__dict__["TRACKER_STATE_PATH"] = str(tracker_path)
-
-    exit_status = _run_main(json.dumps({"tool_name": delegation_tool}))
-
-    assert exit_status in (None, 0)
-    assert not tracker_path.exists()
-
-
-@pytest.mark.parametrize("unrelated_tool", ["Read", "Bash", "Grep"])
-def test_main_keeps_tracker_for_unrelated_tool(
-    tmp_path: Path,
-    unrelated_tool: str,
-) -> None:
-    tracker_path = tmp_path / "investigation-tracker.json"
-    tracker_path.write_text("{}", encoding="utf-8")
-    HOOK_MODULE.__dict__["TRACKER_STATE_PATH"] = str(tracker_path)
-
-    exit_status = _run_main(json.dumps({"tool_name": unrelated_tool}))
-
-    assert exit_status in (None, 0)
-    assert tracker_path.exists()
-
-
-@pytest.mark.parametrize("invalid_input", ["not json", json.dumps([])])
-def test_main_ignores_invalid_input(
-    tmp_path: Path,
-    invalid_input: str,
-) -> None:
-    tracker_path = tmp_path / "investigation-tracker.json"
-    tracker_path.write_text("{}", encoding="utf-8")
-    HOOK_MODULE.__dict__["TRACKER_STATE_PATH"] = str(tracker_path)
-
-    exit_status = _run_main(invalid_input)
-
-    assert exit_status in (None, 0)
-    assert tracker_path.exists()
-
-
-def test_main_keeps_running_when_tracker_removal_fails(tmp_path: Path) -> None:
-    tracker_path = tmp_path / "investigation-tracker.json"
-    tracker_path.write_text("{}", encoding="utf-8")
-    HOOK_MODULE.__dict__["TRACKER_STATE_PATH"] = str(tracker_path)
-
-    with mock.patch.object(HOOK_MODULE.os, "remove", side_effect=OSError("locked")):
-        exit_status = _run_main(json.dumps({"tool_name": "Agent"}))
-
-    assert exit_status in (None, 0)
-    assert tracker_path.exists()