claude-dev-env 8.59.0 → 8.60.0

package/.agents/skills/orchestrator/SKILL.md

@@ -3,8 +3,9 @@ name: orchestrator
 description: >-
   Coordinate user goals, parent tasks, workers, evidence, and recovery.
   Triggers: /orchestrator, orchestrate, operate like a coordinator,
-  track my goals, coordinate workers, retain goals across compaction.
-disable-model-invocation: true
+  track my goals, coordinate workers, retain goals across compaction,
+  before spawning a subagent, thread, or session, or starting work that
+  spans several turns.
 ---
 
 # Orchestrator
@@ -46,6 +47,7 @@ If a run is already active, retain its follow-up entry and answer without replac
 Create durable run state when work spans turns, has several goals, delegates, or waits on an external result.
 An explicit advisor-only request can restrict execution to workers for that run.
 For Claude Projects facts or reported coordinator mechanisms, read [platform evidence](reference/platform-evidence.md).
+Before spawning a subagent, thread, or session, read [oversee delegated work](reference/oversee-delegated-work.md).
 
 ## Process
 
@@ -135,6 +137,7 @@ Report the result, evidence, and any remaining limit.
 | `.claude/CLAUDE.md` | Claude instruction import. |
 | `reference/run-state.md` | Goal records, task authority, follow list, and active-root registry. |
 | `reference/recovery.md` | Cold-start and compaction recovery. |
+| `reference/oversee-delegated-work.md` | Spawner review of delegated work before it reaches the user. |
 | `reference/platform-evidence.md` | Official Projects sources and coordinator report boundaries. |
 | `reference/scheduling.md` | Optional existing gate commands and owned wake lifecycle. |
 | `reference/consult-the-orchestrator.md` | Executor consults and four-signal replies. |

package/.agents/skills/orchestrator/reference/oversee-delegated-work.md

@@ -0,0 +1,12 @@
+# Oversee delegated work
+
+Every agent that spawns a subagent, thread, or session owns that work until it reaches the user.
+Agents make mistakes. The spawner is a fresh second set of eyes that catches and corrects them before they reach the user.
+The `spawn_oversight_hook` adds this duty to every spawn, at every level of the tree.
+
+- Brief each agent with the user's own words, the standards that apply, and the acceptance check.
+- While it runs, read its progress. Wake a quiet agent with one concrete next step.
+- Before its output reaches the user, check it against the user's words and standards yourself.
+- Send the agent a correction when it misses, and check the corrected output the same way.
+- Give each piece of a multi-piece task its own reviewer or helper.
+- Show the user you are involved: say what you checked and what you corrected.

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

@@ -124,9 +124,10 @@ test('seeds one editable policy and one native Codex routing hook', () => {
             group => group.matcher === 'multi_agent_v1__spawn_agent',
         );
         assert.equal(firstRoutingGroups.length, 1);
-        assert.equal(firstRoutingGroups[0].hooks.length, 2);
+        assert.equal(firstRoutingGroups[0].hooks.length, 3);
         assert.match(firstRoutingGroups[0].hooks[0].command, /subagent_model_routing\.mjs/);
         assert.match(firstRoutingGroups[0].hooks[1].command, /spawn_readiness_hook\.py/);
+        assert.match(firstRoutingGroups[0].hooks[2].command, /spawn_oversight_hook\.py/);
         const firstSpawnPromptGroups = firstCodexHooks.hooks.PreToolUse.filter(
             group => group.matcher === 'Agent|Task',
         );

package/hooks/features/spawn-routing.md

@@ -1,10 +1,11 @@
 # Spawn routing
 
-This family reminds the agent to gather context before a spawn, adjusts thread requests when usage exceeds pace, and selects an allowed subagent model.
+This family reminds the agent to gather context before a spawn, tells it that it owns the spawned work, adjusts thread requests when usage exceeds pace, and selects an allowed subagent model.
 
 ## Checks
 
 - `routing/spawn_readiness_hook.py` adds context to a spawn that comes before a read step, or before an answered question or a settled-scope line. The spawn still runs.
+- `routing/spawn_oversight_hook.py` adds the orchestrator oversight directive to every spawn: watch the agent, check its output against the user's words and standards, and correct it before the output reaches the user. The spawn still runs.
 - `routing/thread_spawn_pace_hook.py` reshapes a thread request when usage is over pace or unreadable.
 - `routing/subagent_model_pin_hook.py` moves every Agent and Task subagent to Opus. A spawn that names Opus or Fable runs unchanged.
 - `routing/subagent_model_routing.mjs` allows a selected Luna model, remaps eligible requests, and denies unsupported model routing.
@@ -12,6 +13,7 @@ This family reminds the agent to gather context before a spawn, adjusts thread r
 ## When it fires
 
 - `routing/spawn_readiness_hook.py` runs on `PreToolUse` with matchers `Agent|Task`, `multi_agent_v1__spawn_agent`, `Workflow|mcp__github__actions_run_trigger`, and `mcp__hearthbot__start_thread_session`, each at `10` seconds in `hooks.json`. A workflow dispatch counts only when its inputs carry a `prompt`.
+- `routing/spawn_oversight_hook.py` runs on `PreToolUse` with matchers `Agent|Task`, `multi_agent_v1__spawn_agent`, `Workflow|mcp__github__actions_run_trigger`, `mcp__hearthbot__start_thread_session`, and `mcp__hearthbot__start_rc_session`, each at `10` seconds in `hooks.json`. A workflow dispatch counts only when its inputs carry a `prompt`.
 - `routing/thread_spawn_pace_hook.py` runs on `PreToolUse`, matcher `mcp__hearthbot__start_thread_session`, timeout `30` seconds in `hooks.json`.
 - `routing/subagent_model_pin_hook.py` runs on `PreToolUse`, matcher `Agent|Task`, timeout `10` seconds in `hooks.json`.
 - `routing/subagent_model_routing.mjs` runs on `PreToolUse`, matcher `multi_agent_v1__spawn_agent`, timeout `10` seconds through the quoted Node command in `hooks.json`.
@@ -23,6 +25,7 @@ Preconditions:
 - Run each command from the repository root. Python and pytest cover the two Python scripts; Node covers the model router.
 
 - **Spawn readiness.** Input is a spawn after a read, a question, and its answer. Run `python -m pytest packages/claude-dev-env/hooks/routing/test_spawn_readiness_hook.py -q`. The adjacent test observes no output for a ready spawn and reminder context for each missing step.
+- **Spawn oversight.** Input is a spawn from each registered tool, a subagent's own spawn, and a non-spawn call. Run `python -m pytest packages/claude-dev-env/hooks/routing/test_spawn_oversight_hook.py -q`. The adjacent test observes the directive for every spawn and no output for the other calls.
 - **Thread pace.** Input is a thread spawn with usage over pace. Run `python -m pytest packages/claude-dev-env/hooks/routing/test_thread_spawn_pace_hook.py -q`. The adjacent test observes updated tool input with the selected model, effort, and advisor line.
 - **Model pin.** Input is an Agent spawn that names a Sonnet model. Run `python -m pytest packages/claude-dev-env/hooks/routing/test_subagent_model_pin_hook.py -q`. The adjacent test observes updated tool input with model `opus`.
 - **Model routing.** Input is a `multi_agent_v1__spawn_agent` payload with a model choice. Run `node --test packages/claude-dev-env/hooks/routing/subagent_model_routing.test.mjs`. The adjacent test observes an allow or deny decision with the routed model.
@@ -30,5 +33,6 @@ Preconditions:
 ## Gotchas
 
 - `routing/spawn_readiness_hook.py` also runs after the pace hook on thread spawns. A reshaped request still gets the readiness check.
+- The oversight hook fires inside subagents too, so each level of the tree oversees the level below it. It emits `additionalContext` only and never blocks.
 - The readiness hook emits `additionalContext` only, so it never blocks. It passes subagent calls, read-only helper types, a non-object tool input, and unreadable transcripts.
 - The model router allows an advisor flag to bypass the Luna restriction. Its ordinary path denies unresolved or unsupported models.

package/hooks/hooks.json

@@ -19,6 +19,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/subagent_model_pin_hook.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/spawn_oversight_hook.py",
+            "timeout": 10
           }
         ]
       },
@@ -34,6 +39,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/spawn_readiness_hook.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/spawn_oversight_hook.py",
+            "timeout": 10
           }
         ]
       },
@@ -44,6 +54,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/spawn_readiness_hook.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/spawn_oversight_hook.py",
+            "timeout": 10
           }
         ]
       },
@@ -159,6 +174,21 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/spawn_readiness_hook.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/spawn_oversight_hook.py",
+            "timeout": 10
+          }
+        ]
+      },
+      {
+        "matcher": "mcp__hearthbot__start_rc_session",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/routing/spawn_oversight_hook.py",
+            "timeout": 10
           }
         ]
       },

package/hooks/hooks_constants/pre_tool_use_context_runner.py

@@ -0,0 +1,38 @@
+"""Shared main loop for PreToolUse hooks that only add context.
+
+Reads the payload from stdin, asks the hook's decide function for an output,
+and writes it as JSON. Exit status is always 0, so the tool call runs; a
+decide function that raises leaves the call with no output.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Callable
+
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+
+
+def run_context_hook(
+    decide_hook_output: Callable[[dict[str, object]], dict[str, object] | None],
+) -> int:
+    """Print the decided output for the stdin payload, or nothing.
+
+    Args:
+        decide_hook_output: Maps the parsed payload to an output or None.
+
+    Returns:
+        0 in every case; the context travels in the JSON output.
+    """
+    hook_payload = read_hook_input_dictionary_from_stdin()
+    if hook_payload is None:
+        return 0
+    try:
+        hook_output = decide_hook_output(hook_payload)
+    except Exception:
+        return 0
+    if hook_output is not None:
+        sys.stdout.write(json.dumps(hook_output))
+        sys.stdout.flush()
+    return 0

package/hooks/hooks_constants/spawn_oversight_hook_constants.py

@@ -0,0 +1,40 @@
+"""Constants for the spawn oversight PreToolUse hook.
+
+Groups: the spawn tools it answers, the workflow dispatch that carries an
+agent prompt, the payload keys it reads, and the
+oversight directive it adds to every spawn.
+"""
+
+from __future__ import annotations
+
+TOOL_NAME_KEY = "tool_name"
+TOOL_INPUT_KEY = "tool_input"
+PRE_TOOL_USE_EVENT_NAME = "PreToolUse"
+ADDITIONAL_CONTEXT_KEY = "additionalContext"
+
+WORKFLOW_DISPATCH_TOOL_NAME = "mcp__github__actions_run_trigger"
+DISPATCH_METHOD_INPUT_KEY = "method"
+DISPATCH_RUN_WORKFLOW_METHOD = "run_workflow"
+DISPATCH_INPUTS_KEY = "inputs"
+DISPATCH_PROMPT_INPUT_KEY = "prompt"
+
+ALL_SPAWN_TOOL_NAMES = frozenset(
+    {
+        "Agent",
+        "Task",
+        "Workflow",
+        "multi_agent_v1__spawn_agent",
+        "mcp__hearthbot__start_thread_session",
+        "mcp__hearthbot__start_rc_session",
+    }
+)
+
+SPAWN_OVERSIGHT_DIRECTIVE = (
+    "You own the work this spawn starts. Load the orchestrator skill and follow "
+    "its oversee delegated work reference. While the agent runs, read its progress "
+    "and wake it with one next step when it goes quiet. Before its output "
+    "reaches the user, check it against the user's own words and standards, and "
+    "send the agent a correction when it misses. Give each piece of a "
+    "multi-piece task its own reviewer or helper. Tell the user you are "
+    "checking the work."
+)

package/hooks/hooks_constants/test_pre_tool_use_context_runner.py

@@ -0,0 +1,47 @@
+import io
+import json
+import sys
+
+import pytest
+
+from hooks_constants.pre_tool_use_context_runner import run_context_hook
+
+
+def _feed_stdin(monkeypatch: pytest.MonkeyPatch, text: str) -> None:
+    monkeypatch.setattr(sys, "stdin", io.TextIOWrapper(io.BytesIO(text.encode("utf-8"))))
+
+
+def test_prints_the_decided_output(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _feed_stdin(monkeypatch, json.dumps({"tool_name": "Agent"}))
+    exit_code = run_context_hook(lambda payload: {"seen": payload["tool_name"]})
+    assert exit_code == 0
+    assert json.loads(capsys.readouterr().out) == {"seen": "Agent"}
+
+
+def test_prints_nothing_when_the_decision_is_none(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _feed_stdin(monkeypatch, json.dumps({"tool_name": "Bash"}))
+    assert run_context_hook(lambda payload: None) == 0
+    assert capsys.readouterr().out == ""
+
+
+def test_prints_nothing_for_empty_stdin(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _feed_stdin(monkeypatch, "")
+    assert run_context_hook(lambda payload: {"never": True}) == 0
+    assert capsys.readouterr().out == ""
+
+
+def test_prints_nothing_and_exits_zero_when_the_decision_raises(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    def _raise(payload: dict[str, object]) -> dict[str, object] | None:
+        raise KeyError(payload["missing"])
+
+    _feed_stdin(monkeypatch, json.dumps({"tool_name": "Agent"}))
+    assert run_context_hook(_raise) == 0
+    assert capsys.readouterr().out == ""

package/hooks/routing/spawn_oversight_hook.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""PreToolUse hook: tell the spawning session it owns the work it delegates.
+
+Registered on every tool that starts another agent: ``Agent``, ``Task``,
+``Workflow``, ``multi_agent_v1__spawn_agent``,
+``mcp__hearthbot__start_thread_session``, and
+``mcp__hearthbot__start_rc_session``, plus a workflow dispatch whose inputs
+carry a ``prompt`` for an agent. Each spawn gets the oversight directive
+as ``additionalContext``, so the spawn runs and keeps its normal permission
+flow. A subagent that spawns its own agents gets the same directive, so every
+level of the tree oversees the level below it.
+
+::
+
+    Agent {"prompt": "Do X."}        -> additionalContext: the directive
+    actions trigger {"method": "run_workflow",
+                     "inputs": {"prompt": "Do X."}}
+                                     -> additionalContext: the directive
+    actions trigger {"method": "cancel_workflow_run"}
+                                     -> no output
+    Bash {"command": "ls"}           -> no output
+    Agent "not an object"            -> no output
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+hooks_root_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_root_directory not in sys.path:
+    sys.path.insert(0, hooks_root_directory)
+
+from hooks_constants.hook_specific_output_keys import (
+    HOOK_EVENT_NAME_KEY,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+)
+from hooks_constants.pre_tool_use_context_runner import run_context_hook
+from hooks_constants.spawn_oversight_hook_constants import (
+    ADDITIONAL_CONTEXT_KEY,
+    ALL_SPAWN_TOOL_NAMES,
+    DISPATCH_INPUTS_KEY,
+    DISPATCH_METHOD_INPUT_KEY,
+    DISPATCH_PROMPT_INPUT_KEY,
+    DISPATCH_RUN_WORKFLOW_METHOD,
+    PRE_TOOL_USE_EVENT_NAME,
+    SPAWN_OVERSIGHT_DIRECTIVE,
+    TOOL_INPUT_KEY,
+    TOOL_NAME_KEY,
+    WORKFLOW_DISPATCH_TOOL_NAME,
+)
+
+
+def starts_an_agent(tool_name: object, all_tool_input_fields: dict[str, object]) -> bool:
+    """Return True when the call starts an agent: a spawn tool or a prompt dispatch.
+
+    Args:
+        tool_name: The tool the session called.
+        all_tool_input_fields: The tool input.
+    """
+    if tool_name in ALL_SPAWN_TOOL_NAMES:
+        return True
+    if tool_name != WORKFLOW_DISPATCH_TOOL_NAME:
+        return False
+    if all_tool_input_fields.get(DISPATCH_METHOD_INPUT_KEY) != DISPATCH_RUN_WORKFLOW_METHOD:
+        return False
+    workflow_inputs = all_tool_input_fields.get(DISPATCH_INPUTS_KEY)
+    return isinstance(workflow_inputs, dict) and isinstance(
+        workflow_inputs.get(DISPATCH_PROMPT_INPUT_KEY), str
+    )
+
+
+def decide_hook_output(all_hook_fields: dict[str, object]) -> dict[str, object] | None:
+    """Return the oversight directive for a spawn call, else None.
+
+    Args:
+        all_hook_fields: The parsed PreToolUse payload.
+    """
+    all_tool_input_fields = all_hook_fields.get(TOOL_INPUT_KEY)
+    if not isinstance(all_tool_input_fields, dict):
+        return None
+    if not starts_an_agent(all_hook_fields.get(TOOL_NAME_KEY), all_tool_input_fields):
+        return None
+    return {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            HOOK_EVENT_NAME_KEY: PRE_TOOL_USE_EVENT_NAME,
+            ADDITIONAL_CONTEXT_KEY: SPAWN_OVERSIGHT_DIRECTIVE,
+        }
+    }
+
+
+def main() -> int:
+    """Run the hook on the stdin payload; always 0."""
+    return run_context_hook(decide_hook_output)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/routing/spawn_readiness_hook.py

@@ -35,7 +35,7 @@ routing_directory = str(Path(__file__).resolve().parent)
 if routing_directory not in sys.path:
     sys.path.insert(0, routing_directory)
 
-from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+from hooks_constants.pre_tool_use_context_runner import run_context_hook
 from hooks_constants.spawn_readiness_hook_constants import (
     ADDITIONAL_CONTEXT_KEY,
     AGENT_ID_KEY,
@@ -250,19 +250,8 @@ def decide_hook_output(all_hook_fields: dict[str, object]) -> dict[str, object]
 
 
 def main() -> int:
-    """Read the PreToolUse payload and print the reminder when the spawn is not ready.
-
-    Returns:
-        0 in every case; the reminder travels in the JSON output.
-    """
-    hook_payload = read_hook_input_dictionary_from_stdin()
-    if hook_payload is None:
-        return 0
-    hook_output = decide_hook_output(hook_payload)
-    if hook_output is not None:
-        sys.stdout.write(json.dumps(hook_output))
-        sys.stdout.flush()
-    return 0
+    """Run the hook on the stdin payload; always 0."""
+    return run_context_hook(decide_hook_output)
 
 
 if __name__ == "__main__":

package/hooks/routing/test_spawn_oversight_hook.py

@@ -0,0 +1,104 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+import spawn_oversight_hook
+from hooks_constants.spawn_oversight_hook_constants import SPAWN_OVERSIGHT_DIRECTIVE
+
+HOOK_SCRIPT = Path(__file__).resolve().parent / "spawn_oversight_hook.py"
+
+
+def _expected_output() -> dict[str, object]:
+    return {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "additionalContext": SPAWN_OVERSIGHT_DIRECTIVE,
+        }
+    }
+
+
+@pytest.mark.parametrize(
+    "tool_name",
+    [
+        "Agent",
+        "Task",
+        "Workflow",
+        "multi_agent_v1__spawn_agent",
+        "mcp__hearthbot__start_thread_session",
+        "mcp__hearthbot__start_rc_session",
+    ],
+)
+def test_every_spawn_tool_gets_the_oversight_directive(tool_name: str) -> None:
+    payload = {"tool_name": tool_name, "tool_input": {"prompt": "Do X."}}
+    assert spawn_oversight_hook.decide_hook_output(payload) == _expected_output()
+
+
+def test_a_subagent_spawning_its_own_agent_gets_the_directive() -> None:
+    payload = {
+        "tool_name": "Agent",
+        "tool_input": {"prompt": "Do X."},
+        "agent_id": "agent_child",
+    }
+    assert spawn_oversight_hook.decide_hook_output(payload) == _expected_output()
+
+
+def test_a_read_only_helper_spawn_gets_the_directive() -> None:
+    payload = {
+        "tool_name": "Agent",
+        "tool_input": {"subagent_type": "Explore", "prompt": "Find X."},
+    }
+    assert spawn_oversight_hook.decide_hook_output(payload) == _expected_output()
+
+
+def test_a_workflow_dispatch_with_an_agent_prompt_gets_the_directive() -> None:
+    payload = {
+        "tool_name": "mcp__github__actions_run_trigger",
+        "tool_input": {"method": "run_workflow", "inputs": {"prompt": "Do X."}},
+    }
+    assert spawn_oversight_hook.decide_hook_output(payload) == _expected_output()
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {
+            "tool_name": "mcp__github__actions_run_trigger",
+            "tool_input": {"method": "cancel_workflow_run", "run_id": 1},
+        },
+        {
+            "tool_name": "mcp__github__actions_run_trigger",
+            "tool_input": {"method": "run_workflow", "inputs": {"head": "branch"}},
+        },
+        {"tool_name": "Bash", "tool_input": {"command": "ls"}},
+        {"tool_name": "mcp__hearthbot__reply", "tool_input": {"text": "hi"}},
+        {"tool_name": "Agent", "tool_input": "not an object"},
+        {"tool_input": {"prompt": "Do X."}},
+    ],
+)
+def test_other_calls_get_no_output(payload: dict[str, object]) -> None:
+    assert spawn_oversight_hook.decide_hook_output(payload) is None
+
+
+def test_script_prints_the_directive_for_a_spawn() -> None:
+    completed = subprocess.run(
+        [sys.executable, str(HOOK_SCRIPT)],
+        input=json.dumps({"tool_name": "Agent", "tool_input": {"prompt": "Do X."}}),
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert json.loads(completed.stdout) == _expected_output()
+
+
+def test_script_prints_nothing_for_empty_stdin() -> None:
+    completed = subprocess.run(
+        [sys.executable, str(HOOK_SCRIPT)],
+        input="",
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert completed.stdout == ""

package/hooks/routing/test_spawn_readiness_hook.py

@@ -368,3 +368,15 @@ def test_should_quiet_a_codex_spawn_whose_brief_settles_scope(tmp_path: Path) ->
     assert stdout == ""
     [log_record] = _decision_log(tmp_path)
     assert log_record["outcome"] == "scope_settled"
+
+
+def test_should_print_nothing_for_empty_stdin(tmp_path: Path) -> None:
+    completed = subprocess.run(
+        [sys.executable, str(HOOK_SCRIPT)],
+        input="",
+        capture_output=True,
+        text=True,
+        env={**os.environ, "HOME": str(tmp_path)},
+        check=True,
+    )
+    assert completed.stdout == ""

package/package.json

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