claude-dev-env 8.9.0 → 8.10.0

package/bin/install-constants.mjs

@@ -179,3 +179,8 @@ export const WINDOWS_PYTHON_LAUNCHER_COMMAND = 'py -3';
 export const PYTHON_PROBE_TIMEOUT_MILLISECONDS = 10_000;
 export const ADDITIONAL_SETTINGS_BLOB_PREFIX = 'settings-';
 export const CODEX_NATIVE_ROUTING_MATCHER = 'multi_agent_v1__spawn_agent';
+export const CODEX_SUBAGENT_PROMPT_MATCHER = 'Agent|Task';
+export const ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS = new Set([
+    CODEX_NATIVE_ROUTING_MATCHER,
+    CODEX_SUBAGENT_PROMPT_MATCHER,
+]);

package/bin/install.cursor-rules.test.mjs

@@ -148,6 +148,12 @@ test('seeds one editable policy and one native Codex routing hook', () => {
         assert.equal(firstRoutingGroups.length, 1);
         assert.equal(firstRoutingGroups[0].hooks.length, 1);
         assert.match(firstRoutingGroups[0].hooks[0].command, /subagent_model_routing\.mjs/);
+        const firstSpawnPromptGroups = firstCodexHooks.hooks.PreToolUse.filter(
+            group => group.matcher === 'Agent|Task',
+        );
+        assert.equal(firstSpawnPromptGroups.length, 1);
+        assert.match(firstSpawnPromptGroups[0].hooks[0].command, /skill_loaded_reminder\.py/);
+        assert.deepEqual(Object.keys(firstCodexHooks.hooks), ['PreToolUse']);
         assert.equal(
             firstCodexHooks.hooks.PreToolUse.some(group => group.matcher === 'Write|Edit|MultiEdit|apply_patch'),
             false,

package/bin/install.mjs

@@ -38,7 +38,7 @@ import {
     SUBAGENT_MODEL_POLICY_FILE_NAME,
     WINDOWS_PYTHON_LAUNCHER_COMMAND,
     PYTHON_PROBE_TIMEOUT_MILLISECONDS,
-    CODEX_NATIVE_ROUTING_MATCHER,
+    ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS,
 } from './install-constants.mjs';
 import {
     installPstackPlugin,
@@ -2102,7 +2102,7 @@ function selectCodexNativeHooksConfig(hooksConfig) {
         ...hooksConfig,
         hooks: {
             PreToolUse: Array.isArray(preToolUseGroups)
-                ? preToolUseGroups.filter(group => group?.matcher === CODEX_NATIVE_ROUTING_MATCHER)
+                ? preToolUseGroups.filter(group => ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS.has(group?.matcher))
                 : [],
         },
     };

package/hooks/hooks.json

@@ -122,6 +122,18 @@
         ]
       }
     ],
+    "SubagentStart": [
+      {
+        "matcher": "workflow-subagent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/skill_loaded_reminder.py",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
     "SessionEnd": [
       {
         "matcher": "",

package/hooks/hooks_constants/skill_loaded_reminder_constants.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 __all__ = [
     "ALL_SELF_LOADING_SUBAGENT_TYPES",
-    "ALL_SUBAGENT_TOOL_NAMES",
     "ASSISTANT_ENTRY_TYPE",
     "COMPACT_BOUNDARY_SUBTYPE",
     "COMPACTION_REMINDER",
@@ -16,18 +15,23 @@ __all__ = [
     "SESSION_START_EVENT_NAME",
     "SKILL_TOOL_NAME",
     "SLASH_COMMAND_MARKER",
-    "SUBAGENT_PROMPT_PREFIX",
+    "SUBAGENT_START_EVENT_NAME",
+    "CLAUDE_SUBAGENT_PROMPT_PREFIX",
+    "CODEX_SUBAGENT_PROMPT_PREFIX",
+    "ALL_SPAWN_PROMPT_FIELDS_AND_PREFIXES_BY_TOOL_NAME",
     "TOOL_USE_BLOCK_TYPE",
     "USER_ENTRY_TYPE",
     "USER_PROMPT_SUBMIT_EVENT_NAME",
+    "WORKFLOW_SUBAGENT_TYPE",
 ]
 
 PRE_TOOL_USE_EVENT_NAME = "PreToolUse"
 SESSION_START_EVENT_NAME = "SessionStart"
 USER_PROMPT_SUBMIT_EVENT_NAME = "UserPromptSubmit"
 COMPACTION_SOURCE = "compact"
+SUBAGENT_START_EVENT_NAME = "SubagentStart"
+WORKFLOW_SUBAGENT_TYPE = "workflow-subagent"
 
-ALL_SUBAGENT_TOOL_NAMES = frozenset({"Agent", "Task"})
 ALL_SELF_LOADING_SUBAGENT_TYPES = frozenset({"pstack:poteto-agent", "poteto-agent"})
 
 POTETO_MODE_SKILL_NAME = "pstack:poteto-mode"
@@ -40,11 +44,19 @@ USER_ENTRY_TYPE = "user"
 TOOL_USE_BLOCK_TYPE = "tool_use"
 COMPACT_BOUNDARY_SUBTYPE = "compact_boundary"
 
-SUBAGENT_PROMPT_PREFIX = (
+CLAUDE_SUBAGENT_PROMPT_PREFIX = (
     "Before any other work, invoke the pstack:poteto-mode skill with the Skill tool. "
     "Every prompt you write for a subagent opens with the same instruction."
 )
 
+CODEX_SUBAGENT_PROMPT_PREFIX = "$pstack:poteto-mode"
+
+ALL_SPAWN_PROMPT_FIELDS_AND_PREFIXES_BY_TOOL_NAME = {
+    "Agent": ("prompt", CLAUDE_SUBAGENT_PROMPT_PREFIX),
+    "Task": ("prompt", CLAUDE_SUBAGENT_PROMPT_PREFIX),
+    "spawn_agent": ("message", CODEX_SUBAGENT_PROMPT_PREFIX),
+}
+
 NOT_LOADED_REMINDER = (
     "The pstack:poteto-mode skill is not loaded in this context. "
     "Your next tool call is the Skill tool with skill pstack:poteto-mode, before any other "

package/hooks/session/skill_loaded_reminder.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
-"""PreToolUse, SessionStart and UserPromptSubmit hook. Keeps poteto-mode loaded in every context.
+"""Hook that keeps poteto-mode loaded in every session, subagent and workflow helper.
 
 ::
 
-    Agent tool call, prompt lacks the skill      -> prompt opens with "invoke pstack:poteto-mode"
+    Agent or Codex spawn_agent, skill not named -> prompt opens with "invoke pstack:poteto-mode"
+    Workflow script helper starts               -> "invoke pstack:poteto-mode now"
     context compacted mid-run                    -> "invoke pstack:poteto-mode again"
     user turn, skill not loaded since compacting -> "invoke pstack:poteto-mode now"
     user turn, skill already loaded              -> nothing
@@ -25,7 +26,6 @@ if _hooks_dir not in sys.path:
 
 from hooks_constants.skill_loaded_reminder_constants import (
     ALL_SELF_LOADING_SUBAGENT_TYPES,
-    ALL_SUBAGENT_TOOL_NAMES,
     ASSISTANT_ENTRY_TYPE,
     COMPACT_BOUNDARY_SUBTYPE,
     COMPACTION_REMINDER,
@@ -37,10 +37,12 @@ from hooks_constants.skill_loaded_reminder_constants import (
     SESSION_START_EVENT_NAME,
     SKILL_TOOL_NAME,
     SLASH_COMMAND_MARKER,
-    SUBAGENT_PROMPT_PREFIX,
+    SUBAGENT_START_EVENT_NAME,
+    ALL_SPAWN_PROMPT_FIELDS_AND_PREFIXES_BY_TOOL_NAME,
     TOOL_USE_BLOCK_TYPE,
     USER_ENTRY_TYPE,
     USER_PROMPT_SUBMIT_EVENT_NAME,
+    WORKFLOW_SUBAGENT_TYPE,
 )
 from hooks_constants.pre_tool_use_allow_output import write_pre_tool_use_allow_to_stdout
 from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
@@ -48,25 +50,32 @@ from hooks_constants.setup_project_paths_constants import DECODE_ERRORS_POLICY,
 
 
 def subagent_input_with_poteto_mode(
+    tool_name: str,
     all_tool_input_fields: dict[str, object],
 ) -> dict[str, object] | None:
-    """Return the Agent tool input with the poteto-mode instruction first, or None to leave it.
+    """Return the spawn input with the poteto-mode invocation first, or None to leave it.
 
     ::
 
-        {"prompt": "Reply leaf."}                          -> {"prompt": "Before any ...\\n\\nReply leaf."}
-        {"prompt": "Invoke pstack:poteto-mode, then ..."}  -> None
-        {"subagent_type": "pstack:poteto-agent", ...}      -> None, that agent loads the skill itself
+        Agent        {"prompt": "Reply leaf."}   -> {"prompt": "Before any ...\\n\\nReply leaf."}
+        spawn_agent  {"message": "Fix it."}      -> {"message": "$pstack:poteto-mode\\n\\nFix it."}
+        Agent        {"prompt": "Invoke pstack:poteto-mode, then ..."}  -> None
+        Agent        {"subagent_type": "pstack:poteto-agent", ...}      -> None, it loads the skill
+
+    Claude Code spawns through Agent or Task and Codex through spawn_agent, so
+    each tool name carries its own prompt field and invocation text.
 
     Args:
-        all_tool_input_fields: The Agent tool input the session is about to send.
+        tool_name: The spawn tool the session called.
+        all_tool_input_fields: The spawn input the session is about to send.
     """
-    prompt = all_tool_input_fields.get("prompt")
+    field_name, invocation_prefix = ALL_SPAWN_PROMPT_FIELDS_AND_PREFIXES_BY_TOOL_NAME[tool_name]
+    prompt = all_tool_input_fields.get(field_name)
     if not isinstance(prompt, str) or POTETO_MODE_SKILL_NAME in prompt:
         return None
     if all_tool_input_fields.get("subagent_type") in ALL_SELF_LOADING_SUBAGENT_TYPES:
         return None
-    return {**all_tool_input_fields, "prompt": SUBAGENT_PROMPT_PREFIX + PROMPT_SEPARATOR + prompt}
+    return {**all_tool_input_fields, field_name: invocation_prefix + PROMPT_SEPARATOR + prompt}
 
 
 def _invokes_poteto_mode(all_entry_fields: dict[str, object]) -> bool:
@@ -149,6 +158,7 @@ def reminder_for(all_hook_fields: dict[str, object]) -> str | None:
     ::
 
         SessionStart, source compact                     -> COMPACTION_REMINDER
+        SubagentStart, workflow-subagent                 -> NOT_LOADED_REMINDER
         UserPromptSubmit, transcript lacks the skill     -> NOT_LOADED_REMINDER
         UserPromptSubmit, transcript loaded the skill    -> None
 
@@ -158,6 +168,9 @@ def reminder_for(all_hook_fields: dict[str, object]) -> str | None:
     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 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")):
@@ -168,7 +181,7 @@ def reminder_for(all_hook_fields: dict[str, object]) -> str | None:
 def _is_subagent_spawn(all_hook_fields: dict[str, object]) -> bool:
     return (
         all_hook_fields.get("hook_event_name") == PRE_TOOL_USE_EVENT_NAME
-        and all_hook_fields.get("tool_name") in ALL_SUBAGENT_TOOL_NAMES
+        and all_hook_fields.get("tool_name") in ALL_SPAWN_PROMPT_FIELDS_AND_PREFIXES_BY_TOOL_NAME
         and isinstance(all_hook_fields.get("tool_input"), dict)
     )
 
@@ -179,7 +192,9 @@ def main() -> None:
     if hook_payload is None:
         return
     if _is_subagent_spawn(hook_payload):
-        rewritten_input = subagent_input_with_poteto_mode(hook_payload["tool_input"])
+        rewritten_input = subagent_input_with_poteto_mode(
+            hook_payload["tool_name"], hook_payload["tool_input"]
+        )
         if rewritten_input is not None:
             write_pre_tool_use_allow_to_stdout(rewritten_input)
         return

package/hooks/session/test_skill_loaded_reminder.py

@@ -132,14 +132,46 @@ class TestSubagentSpawn:
 class TestSubagentInputWithPotetoMode:
     def test_every_other_input_field_is_kept(self) -> None:
         rewritten_input = reminder.subagent_input_with_poteto_mode(
-            {"prompt": "Go.", "model": "sonnet", "run_in_background": True}
+            "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({"description": "Go"}) is 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"] == "$pstack: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": "$pstack:poteto-mode\n\nFix it."}, tool_name="spawn_agent")
+            )
+            == ""
+        )
 
 
 class TestIsPotetoModeLoaded:
@@ -202,5 +234,20 @@ class TestReminderFor:
     def test_a_resumed_session_keeps_its_context_and_prints_nothing(self) -> None:
         assert _run_main({"hook_event_name": "SessionStart", "source": "resume"}) == ""
 
+    def test_a_workflow_helper_starting_is_told_to_invoke_the_skill(self) -> None:
+        emitted = json.loads(
+            _run_main({"hook_event_name": "SubagentStart", "agent_type": "workflow-subagent"})
+        )
+        hook_output = emitted["hookSpecificOutput"]
+        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:
+        assert (
+            _run_main({"hook_event_name": "SubagentStart", "agent_type": "general-purpose"}) == ""
+        )
+
     def test_a_payload_that_is_not_json_prints_nothing(self) -> None:
         assert _run_main("not json") == ""

package/package.json

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