claude-dev-env 8.61.0 → 8.61.1

package/hooks/lifecycle/nested_project_hooks.py

@@ -14,8 +14,9 @@ guards then never run. This hook runs them::
 Each child hook receives the same stdin payload, runs inside its checkout, and
 keeps its own matcher and timeout. A child ``exit 2`` blocks the tool call and a
 child ``deny`` or ``ask`` decision passes through; a child ``allow`` is dropped,
-so no child widens permissions for the session. SessionStart output from every
-child joins into one ``additionalContext``.
+so no child widens permissions for the session. The ``additionalContext`` of
+every child, at SessionStart and at PreToolUse, joins into one
+``additionalContext``.
 
 When the session directory is itself a checkout or holds its own settings,
 Claude Code already runs those hooks, and this hook exits at once.
@@ -285,33 +286,58 @@ def pre_tool_use_verdict(
 
     Returns:
         A blocking exit carrying the child's stderr when any child exits 2,
-        else the first child ``deny`` or ``ask`` output, else an empty pass.
+        else the first child ``deny`` or ``ask`` output carrying one copy
+        of each distinct child ``additionalContext``, else a pass carrying
+        that context, else an empty pass.
     """
     for each_result in all_results:
         if each_result.returncode == BLOCKING_EXIT_CODE:
             return HookVerdict(BLOCKING_EXIT_CODE, "", each_result.stderr)
-    for each_result in all_results:
-        if each_result.returncode != 0:
-            continue
-        parsed_output = _parsed_hook_output(each_result.stdout)
-        if parsed_output is None:
-            continue
-        if _permission_decision(parsed_output) in ALL_FORWARDED_PERMISSION_DECISIONS:
-            return HookVerdict(0, json.dumps(parsed_output), "")
-    return HookVerdict(0, "", "")
+    all_parsed_outputs = [
+        _parsed_hook_output(each_result.stdout)
+        for each_result in all_results
+        if each_result.returncode == 0
+    ]
+    all_parsed_outputs = [each_output for each_output in all_parsed_outputs if each_output is not None]
+    all_context_sections = _non_empty_sections(
+        _json_additional_context(each_parsed_output) for each_parsed_output in all_parsed_outputs
+    )
+    all_distinct_context_sections = list(dict.fromkeys(all_context_sections))
+    joined_context = CONTEXT_SECTION_SEPARATOR.join(all_distinct_context_sections)
+    for each_parsed_output in all_parsed_outputs:
+        if _permission_decision(each_parsed_output) in ALL_FORWARDED_PERMISSION_DECISIONS:
+            decision_output = dict(each_parsed_output)
+            if joined_context:
+                decision_specific_output = dict(decision_output[HOOK_SPECIFIC_OUTPUT_KEY])
+                decision_specific_output[ADDITIONAL_CONTEXT_KEY] = joined_context
+                decision_output[HOOK_SPECIFIC_OUTPUT_KEY] = decision_specific_output
+            return HookVerdict(0, json.dumps(decision_output), "")
+    if not joined_context:
+        return HookVerdict(0, "", "")
+    hook_output = {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            HOOK_EVENT_NAME_OUTPUT_KEY: PRE_TOOL_USE_EVENT,
+            ADDITIONAL_CONTEXT_KEY: joined_context,
+        }
+    }
+    return HookVerdict(0, json.dumps(hook_output), "")
 
 
-def _session_start_context(stdout_text: str) -> str:
-    parsed_output = _parsed_hook_output(stdout_text)
-    if parsed_output is None:
-        return stdout_text.strip()
-    specific_output = parsed_output.get(HOOK_SPECIFIC_OUTPUT_KEY)
+def _json_additional_context(all_output_fields: dict[str, object]) -> str:
+    specific_output = all_output_fields.get(HOOK_SPECIFIC_OUTPUT_KEY)
     if not isinstance(specific_output, dict):
         return ""
     context_text = specific_output.get(ADDITIONAL_CONTEXT_KEY)
     return context_text.strip() if isinstance(context_text, str) else ""
 
 
+def _session_start_context(stdout_text: str) -> str:
+    parsed_output = _parsed_hook_output(stdout_text)
+    if parsed_output is None:
+        return stdout_text.strip()
+    return _json_additional_context(parsed_output)
+
+
 def _non_empty_sections(all_sections: Iterable[str]) -> list[str]:
     return [each_section for each_section in all_sections if each_section]
 

package/hooks/lifecycle/test_nested_project_hooks.py

@@ -178,6 +178,95 @@ def test_should_not_forward_a_child_allow_decision(tmp_path: pathlib.Path) -> No
     assert completed_process.stdout.strip() == ""
 
 
+def test_should_carry_child_pre_tool_use_context_without_its_allow(
+    tmp_path: pathlib.Path,
+) -> None:
+    context_output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": "allow",
+            "additionalContext": "Build this page from the house template.",
+        }
+    }
+    _make_checkout(
+        tmp_path,
+        "alpha",
+        {"PreToolUse": [_command_group("Artifact", f"echo '{json.dumps(context_output)}'")]},
+    )
+
+    completed_process = _run_hook(tmp_path, _pre_tool_use_payload("Artifact"))
+
+    assert completed_process.returncode == 0
+    assert json.loads(completed_process.stdout) == {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "additionalContext": "Build this page from the house template.",
+        }
+    }
+
+
+def test_should_carry_another_child_context_into_an_ask_decision(
+    tmp_path: pathlib.Path,
+) -> None:
+    context_output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "additionalContext": "Build this page from the house template.",
+        }
+    }
+    ask_output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": "ask",
+            "permissionDecisionReason": "publishing needs a person",
+        }
+    }
+    _make_checkout(
+        tmp_path,
+        "alpha",
+        {"PreToolUse": [_command_group("Artifact", f"echo '{json.dumps(context_output)}'")]},
+    )
+    _make_checkout(
+        tmp_path,
+        "beta",
+        {"PreToolUse": [_command_group("Artifact", f"echo '{json.dumps(ask_output)}'")]},
+    )
+
+    completed_process = _run_hook(tmp_path, _pre_tool_use_payload("Artifact"))
+
+    assert completed_process.returncode == 0
+    assert json.loads(completed_process.stdout) == {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": "ask",
+            "permissionDecisionReason": "publishing needs a person",
+            "additionalContext": "Build this page from the house template.",
+        }
+    }
+
+
+def test_should_carry_one_copy_of_context_two_checkouts_repeat(
+    tmp_path: pathlib.Path,
+) -> None:
+    context_output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "additionalContext": "Build this page from the house template.",
+        }
+    }
+    for each_checkout_name in ("alpha", "beta"):
+        _make_checkout(
+            tmp_path,
+            each_checkout_name,
+            {"PreToolUse": [_command_group("Artifact", f"echo '{json.dumps(context_output)}'")]},
+        )
+
+    completed_process = _run_hook(tmp_path, _pre_tool_use_payload("Artifact"))
+
+    assert completed_process.returncode == 0
+    assert json.loads(completed_process.stdout) == context_output
+
+
 def test_should_skip_a_child_hook_whose_matcher_names_another_tool(
     tmp_path: pathlib.Path,
 ) -> None:

package/package.json

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