claude-dev-env 8.38.2 → 8.38.3

package/hooks/session/skill_loaded_reminder.py

@@ -1,15 +1,18 @@
 #!/usr/bin/env python3
-"""Hook that keeps poteto-mode loaded in every session, subagent and workflow helper.
+"""Hook that restores poteto-mode after compaction and loads it for helpers.
 
 ::
 
     Agent or Codex spawn_agent, skill not named -> prompt opens with "invoke poteto-mode"
     Workflow script helper starts               -> "invoke poteto-mode now"
-    context compacted mid-run                    -> "invoke poteto-mode again"
-    user turn, skill not loaded since compacting -> "invoke poteto-mode now"
-    user turn, skill already loaded              -> nothing
-
-A session that loaded the skill hears nothing more until a compaction drops it.
+    compact SessionStart, skill invoked before   -> "invoke the skill again"
+    compact SessionStart, no prior invocation
+    or transcript unavailable                    -> nothing
+    user turn, skill invoked then compacted      -> "invoke poteto-mode now"
+    user turn, skill loaded, never invoked,
+    or transcript unavailable                    -> nothing
+
+A session that invoked the skill hears nothing more until a compaction drops it.
 The hook prints its output and stops.
 """
 
@@ -116,66 +119,92 @@ def _is_loaded_after(all_entry_fields: dict[str, object], was_loaded: bool) -> b
     return was_loaded or _invokes_poteto_mode(all_entry_fields)
 
 
-def is_poteto_mode_loaded(all_transcript_lines: Iterable[str]) -> bool:
-    """Return True when the transcript invoked the skill after its last compaction.
+def poteto_mode_status(all_transcript_lines: Iterable[str]) -> tuple[bool, bool]:
+    """Report whether the skill was invoked and whether it remains loaded.
 
     ::
 
-        Skill(poteto-mode) ... Read ... Edit               -> True
-        /poteto-mode typed as a command ... Read           -> True
-        Skill(poteto-mode) ... compact_boundary ... Read   -> False
-        Read ... Edit                                             -> False
+        Skill(poteto-mode) ... Read                   -> (True, True)
+        /poteto-mode ... compact_boundary             -> (True, False)
+        Skill(poteto-mode) ... compact_boundary ... Skill(poteto-mode)
+                                                      -> (True, True)
+        Read ... Edit                                 -> (False, False)
 
     Only lines naming the skill or a compaction are parsed, so a long transcript
     reads fast.
 
     Args:
         all_transcript_lines: The session transcript, one JSON entry per line.
+
+    Returns:
+        Whether the skill was invoked at any point and whether it is loaded now.
     """
+    was_invoked = False
     is_loaded = False
     for each_line in all_transcript_lines:
         all_entry_fields = _marker_entry(each_line)
         if all_entry_fields is not None:
             is_loaded = _is_loaded_after(all_entry_fields, is_loaded)
-    return is_loaded
+            was_invoked = was_invoked or is_loaded
+    return was_invoked, is_loaded
+
 
+def is_poteto_mode_loaded(all_transcript_lines: Iterable[str]) -> bool:
+    """Return whether the transcript invoked the skill after its last compaction.
+
+    Args:
+        all_transcript_lines: The session transcript, one JSON entry per line.
 
-def _is_loaded_in_transcript(transcript_path: object) -> bool:
+    Returns:
+        Whether the skill is loaded now.
+    """
+    return poteto_mode_status(all_transcript_lines)[1]
+
+
+def _status_in_transcript(transcript_path: object) -> tuple[bool, bool]:
     if not isinstance(transcript_path, str):
-        return False
+        return False, False
     try:
         with open(
             transcript_path, encoding=UTF8_ENCODING, errors=DECODE_ERRORS_POLICY
         ) as transcript:
-            return is_poteto_mode_loaded(transcript)
+            return poteto_mode_status(transcript)
     except OSError:
-        return False
+        return False, False
 
 
 def reminder_for(all_hook_fields: dict[str, object]) -> str | None:
-    """Return the reminder a session event carries, or None when the skill is in view.
+    """Return a reminder only for helpers or sessions that need the skill restored.
 
     ::
 
-        SessionStart, source compact                     -> COMPACTION_REMINDER
+        SessionStart, compact, skill invoked before      -> COMPACTION_REMINDER
+        SessionStart, compact, no prior invocation
+        or transcript unavailable                        -> None
         SubagentStart, workflow-subagent                 -> NOT_LOADED_REMINDER
-        UserPromptSubmit, transcript lacks the skill     -> NOT_LOADED_REMINDER
-        UserPromptSubmit, transcript loaded the skill    -> None
+        UserPromptSubmit, skill invoked then compacted   -> NOT_LOADED_REMINDER
+        UserPromptSubmit, skill loaded, never invoked,
+        or transcript unavailable                        -> None
 
     Args:
         all_hook_fields: The parsed hook input.
+
+    Returns:
+        The event's reminder, or None when no reminder is needed.
     """
     event_name = all_hook_fields.get("hook_event_name")
     if event_name == SESSION_START_EVENT_NAME:
-        return COMPACTION_REMINDER if all_hook_fields.get("source") == COMPACTION_SOURCE else None
+        if all_hook_fields.get("source") != COMPACTION_SOURCE:
+            return None
+        was_invoked, _ = _status_in_transcript(all_hook_fields.get("transcript_path"))
+        return COMPACTION_REMINDER if was_invoked else None
     if event_name == SUBAGENT_START_EVENT_NAME:
         is_workflow_helper = all_hook_fields.get("agent_type") == WORKFLOW_SUBAGENT_TYPE
         return NOT_LOADED_REMINDER if is_workflow_helper else None
     if event_name != USER_PROMPT_SUBMIT_EVENT_NAME:
         return None
-    if _is_loaded_in_transcript(all_hook_fields.get("transcript_path")):
-        return None
-    return NOT_LOADED_REMINDER
+    was_invoked, is_loaded = _status_in_transcript(all_hook_fields.get("transcript_path"))
+    return NOT_LOADED_REMINDER if was_invoked and not is_loaded else None
 
 
 def _is_subagent_spawn(all_hook_fields: dict[str, object]) -> bool:

package/hooks/session/test_skill_loaded_reminder.py

@@ -1,4 +1,4 @@
-"""Tests for skill_loaded_reminder. Checks every fresh context gets poteto-mode, and loaded ones hear nothing."""
+"""Tests for skill_loaded_reminder. Checks restoration after compaction and helper prompts."""
 
 import json
 import sys
@@ -167,14 +167,25 @@ class TestCodexSpawn:
 
     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")
-            )
+            _run_main(_agent_call({"message": "$poteto-mode\n\nFix it."}, tool_name="spawn_agent"))
             == ""
         )
 
 
 class TestIsPotetoModeLoaded:
+    def test_status_without_a_skill_call_reports_no_invocation_or_load(self) -> None:
+        assert reminder.poteto_mode_status(iter([READ_CALL_LINE])) == (False, False)
+
+    def test_status_keeps_invocation_history_after_compaction(self) -> None:
+        assert reminder.poteto_mode_status(
+            iter([SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE, READ_CALL_LINE])
+        ) == (True, False)
+
+    def test_status_reports_the_skill_loaded_again_after_compaction(self) -> None:
+        assert reminder.poteto_mode_status(
+            iter([SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE, SKILL_CALL_LINE])
+        ) == (True, True)
+
     def test_a_skill_call_loads_it(self) -> None:
         assert reminder.is_poteto_mode_loaded([READ_CALL_LINE, SKILL_CALL_LINE, READ_CALL_LINE])
 
@@ -210,35 +221,106 @@ class TestIsPotetoModeLoaded:
 
 
 class TestReminderFor:
-    def test_a_user_turn_in_a_session_that_never_loaded_the_skill_gets_the_reminder(
+    def test_a_user_turn_in_a_session_that_never_loaded_the_skill_prints_nothing(
         self, tmp_path: Path
     ) -> None:
         transcript_path = _write_transcript(tmp_path, [READ_CALL_LINE])
+        assert _run_main(_user_turn(transcript_path)) == ""
+
+    def test_a_user_turn_after_the_skill_and_compaction_gets_the_reminder(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = _write_transcript(
+            tmp_path, [SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE, READ_CALL_LINE]
+        )
         emitted = json.loads(_run_main(_user_turn(transcript_path)))
         hook_output = emitted["hookSpecificOutput"]
         assert hook_output["hookEventName"] == "UserPromptSubmit"
         assert hook_output["additionalContext"] == NOT_LOADED_REMINDER
         assert "poteto-mode" in NOT_LOADED_REMINDER
 
+    def test_a_user_turn_after_the_skill_is_reloaded_prints_nothing(self, tmp_path: Path) -> None:
+        transcript_path = _write_transcript(
+            tmp_path, [SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE, SKILL_CALL_LINE]
+        )
+        assert _run_main(_user_turn(transcript_path)) == ""
+
     def test_a_user_turn_in_a_session_that_loaded_the_skill_prints_nothing(
         self, tmp_path: Path
     ) -> None:
         transcript_path = _write_transcript(tmp_path, [SKILL_CALL_LINE, READ_CALL_LINE])
         assert _run_main(_user_turn(transcript_path)) == ""
 
-    def test_a_user_turn_with_no_transcript_yet_gets_the_reminder(self, tmp_path: Path) -> None:
-        assert (
-            reminder.reminder_for(_user_turn(tmp_path / "not-written-yet.jsonl"))
-            == NOT_LOADED_REMINDER
-        )
+    def test_a_user_turn_with_no_transcript_yet_prints_nothing(self, tmp_path: Path) -> None:
+        assert _run_main(_user_turn(tmp_path / "not-written-yet.jsonl")) == ""
 
-    def test_session_start_after_compaction_tells_the_session_to_invoke_it_again(self) -> None:
-        emitted = json.loads(_run_main({"hook_event_name": "SessionStart", "source": "compact"}))
+    def test_session_start_after_compaction_tells_a_prior_user_to_invoke_it_again(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = _write_transcript(tmp_path, [SKILL_CALL_LINE, READ_CALL_LINE])
+        emitted = json.loads(
+            _run_main(
+                {
+                    "hook_event_name": "SessionStart",
+                    "source": "compact",
+                    "transcript_path": str(transcript_path),
+                }
+            )
+        )
         hook_output = emitted["hookSpecificOutput"]
         assert hook_output["hookEventName"] == "SessionStart"
         assert hook_output["additionalContext"] == COMPACTION_REMINDER
         assert "poteto-mode" in COMPACTION_REMINDER
 
+    def test_session_start_after_a_written_boundary_reminds_a_prior_user(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = _write_transcript(tmp_path, [SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE])
+        assert (
+            reminder.reminder_for(
+                {
+                    "hook_event_name": "SessionStart",
+                    "source": "compact",
+                    "transcript_path": str(transcript_path),
+                }
+            )
+            == COMPACTION_REMINDER
+        )
+
+    def test_session_start_after_compaction_without_a_prior_skill_call_prints_nothing(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = _write_transcript(tmp_path, [READ_CALL_LINE])
+        assert (
+            _run_main(
+                {
+                    "hook_event_name": "SessionStart",
+                    "source": "compact",
+                    "transcript_path": str(transcript_path),
+                }
+            )
+            == ""
+        )
+
+    def test_session_start_after_compaction_without_a_transcript_path_prints_nothing(
+        self,
+    ) -> None:
+        assert _run_main({"hook_event_name": "SessionStart", "source": "compact"}) == ""
+
+    def test_session_start_after_compaction_with_an_unreadable_transcript_prints_nothing(
+        self, tmp_path: Path
+    ) -> None:
+        assert (
+            _run_main(
+                {
+                    "hook_event_name": "SessionStart",
+                    "source": "compact",
+                    "transcript_path": str(tmp_path / "not-written-yet.jsonl"),
+                }
+            )
+            == ""
+        )
+
     def test_a_resumed_session_keeps_its_context_and_prints_nothing(self) -> None:
         assert _run_main({"hook_event_name": "SessionStart", "source": "resume"}) == ""
 

package/package.json

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