claude-dev-env 8.35.2 → 8.36.0

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

@@ -52,6 +52,7 @@ For Claude Projects facts or reported coordinator mechanisms, read [platform evi
 ### Orient and retain the goals
 
 Read the current user message and applicable project instructions.
+Read `~/.claude/rules/long-horizon-autonomy.md` and `~/.claude/rules/workers-done-before-complete.md` before the first dispatch. Invoking this skill does not load those two rules, so this read does.
 At startup or after context loss, inspect `.orchestrator/active-runs/` under the supplied project directory.
 Use an alternate registry only when loaded instructions or the runtime provide its exact locator.
 Verify the startup loader pointer described in run state before claiming recovery from a cold session.

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

@@ -28,7 +28,7 @@ Keep current authorization and configured model routing when restoring work.
 ## Process
 
 1. Read the current message and loaded instructions. Load the orchestrator entrypoint.
-2. Resolve the run from its supplied locator or `.orchestrator/active-runs/` under the project directory.
+   Read `~/.claude/rules/long-horizon-autonomy.md` and `~/.claude/rules/workers-done-before-complete.md`. Invoking this skill does not load those two rules, so this read does.2. Resolve the run from its supplied locator or `.orchestrator/active-runs/` under the project directory.
    Read the run record's owner and optional wake metadata first.
    For a recorded one-shot firing, confirm both the invocation's wake identity and current root ownership.
    Immediately run `begin-firing` with its explicit `--status-file` and `--run-slug` through [optional scheduling](../orchestrator/reference/scheduling.md).

package/hooks/validation/mypy_validator.py

@@ -13,7 +13,6 @@ Project root is discovered via CLAUDE_PROJECT_ROOT env var or git rev-parse.
 """
 
 import hashlib
-import importlib
 import json
 import os
 import platform
@@ -21,13 +20,9 @@ import stat
 import subprocess
 import sys
 from pathlib import Path
-from types import ModuleType
 
 _hooks_directory = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
-_notification_utils_directory = os.path.join(_hooks_directory, "notification")
-sys.path.insert(0, _notification_utils_directory)
-
 _validators_directory = os.path.join(_hooks_directory, "validators")
 if _validators_directory not in sys.path:
     sys.path.insert(0, _validators_directory)
@@ -59,14 +54,6 @@ from json_file_reader import read_json_object  # noqa: E402
 
 from hooks_constants.subprocess_window import hidden_window_creation_flags
 
-
-def load_notification_utils() -> ModuleType | None:
-    try:
-        return importlib.import_module("notification_utils")
-    except ImportError:
-        return None
-
-
 IS_WINDOWS = platform.system() == "Windows"
 
 GIT_COMMAND_TIMEOUT_SECONDS = 5
@@ -530,25 +517,6 @@ def format_error_summary(all_error_lines: list[str]) -> str:
     return error_summary
 
 
-def send_block_notification(error_summary: str) -> None:
-    notification_module = load_notification_utils()
-    if notification_module is None:
-        return
-
-    notification_title = "Mypy Type Errors"
-    notification_body = f"Write blocked: {error_summary[:200]}"
-
-    try:
-        if notification_module.is_wsl():
-            notification_module.notify_wsl(notification_title, notification_body)
-        elif platform.system() == "Linux":
-            notification_module.notify_linux()
-        elif platform.system() == "Windows":
-            notification_module.notify_windows(notification_title, notification_body)
-    except (AttributeError, OSError):
-        pass
-
-
 def build_block_response(error_summary: str) -> dict[str, str | dict[str, str]]:
     return {
         "decision": "block",
@@ -615,7 +583,6 @@ def main() -> None:
         sys.exit(0)
 
     error_summary = format_error_summary(all_error_lines)
-    send_block_notification(error_summary)
     block_response = build_block_response(error_summary)
     log_hook_block(
         calling_hook_name="mypy_validator.py",

package/hooks/validation/test_mypy_validator_toast.py

@@ -0,0 +1,77 @@
+"""The mypy_validator hook reports a block through its reply and nothing else.
+
+An install from before the package dropped ``hooks/notification`` keeps
+``notification_utils.py`` on disk. This test puts a recording stand-in for
+that module on the import path and checks a blocked write never reads it.
+"""
+
+import importlib.util
+import io
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+HOOK_PATH = Path(__file__).resolve().parent / "mypy_validator.py"
+TYPE_ERROR_MODULE_SOURCE = 'value: int = "not an integer"\n'
+
+
+def _load_validator() -> ModuleType:
+    spec = importlib.util.spec_from_file_location("mypy_validator_toast_under_test", HOOK_PATH)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _build_recording_notification_module(all_touched_names: list[str]) -> ModuleType:
+    class RecordingNotificationModule(ModuleType):
+        def __getattr__(self, attribute_name: str) -> object:
+            if not attribute_name.startswith("__"):
+                all_touched_names.append(attribute_name)
+            return lambda *_arguments, **_options: False
+
+    return RecordingNotificationModule("notification_utils")
+
+
+def test_type_error_block_opens_no_desktop_toast(
+    tmp_path_factory: pytest.TempPathFactory,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """A blocked write reports through the hook reply and leaves the desktop alone.
+
+    ::
+
+        mypy typed_module.py  ->  error: Incompatible types
+        ok:   {"decision": "block"} on stdout, notification_utils untouched
+        flag: notify_windows() opens a toast window at the bottom of the screen
+    """
+    validator = _load_validator()
+    project_root = tmp_path_factory.mktemp("blocked_project")
+    target_file = project_root / "typed_module.py"
+    target_file.write_text(TYPE_ERROR_MODULE_SOURCE, encoding="utf-8")
+    all_touched_names: list[str] = []
+    monkeypatch.setitem(
+        sys.modules,
+        "notification_utils",
+        _build_recording_notification_module(all_touched_names),
+    )
+    monkeypatch.setattr(validator, "discover_project_root", lambda _target: project_root)
+    monkeypatch.setattr(
+        validator,
+        "run_mypy",
+        lambda _target, _root: (1, f"{target_file}:1: error: Incompatible types\n"),
+    )
+    monkeypatch.setattr(validator, "log_hook_block", lambda **_details: None)
+    monkeypatch.setattr(
+        sys, "stdin", io.StringIO(json.dumps({"tool_input": {"file_path": str(target_file)}}))
+    )
+
+    with pytest.raises(SystemExit):
+        validator.main()
+
+    assert json.loads(capsys.readouterr().out)["decision"] == "block"
+    assert all_touched_names == []

package/hooks/workflow/auto_formatter.py

@@ -4,15 +4,12 @@
 
 from __future__ import annotations
 
-import importlib
 import json
 import os
-import platform
 import subprocess
 import sys
 from collections.abc import Mapping
 from pathlib import Path
-from types import ModuleType
 
 _subprocess_window_hooks_directory = str(Path(__file__).resolve().parents[2] / "hooks")
 if _subprocess_window_hooks_directory not in sys.path:
@@ -20,11 +17,6 @@ if _subprocess_window_hooks_directory not in sys.path:
 
 from hooks_constants.subprocess_window import hidden_window_creation_flags
 
-NOTIFICATION_UTILS_DIRECTORY = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "notification"
-)
-sys.path.insert(0, NOTIFICATION_UTILS_DIRECTORY)
-
 PYTHON_EXTENSIONS = frozenset({".py"})
 JS_EXTENSIONS = frozenset({".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs"})
 JSON_EXTENSIONS = frozenset({".json"})
@@ -57,32 +49,6 @@ PRETTIER_CONFIG_NAMES = frozenset(
 )
 
 
-def load_notification_utils() -> ModuleType | None:
-    try:
-        return importlib.import_module("notification_utils")
-    except ImportError:
-        return None
-
-
-def send_format_notification(file_path: str, formatter_name: str) -> None:
-    notification_module = load_notification_utils()
-    if notification_module is None:
-        return
-
-    notification_title = "Auto-Formatter"
-    notification_body = f"{formatter_name} formatted: {Path(file_path).name}"
-
-    try:
-        if notification_module.is_wsl():
-            notification_module.notify_wsl(notification_title, notification_body)
-        elif platform.system() == "Linux":
-            notification_module.notify_linux()
-        elif platform.system() == "Windows":
-            notification_module.notify_windows(notification_title, notification_body)
-    except (AttributeError, OSError):
-        pass
-
-
 def has_prettier_config(file_path: str) -> bool:
     each_ancestor = Path(file_path).resolve().parent
     while True:
@@ -249,16 +215,9 @@ def _run_python_format_commands(file_path: str) -> None:
         if did_timeout:
             return
         if completed_process is not None and completed_process.returncode == 0:
-            send_format_notification(file_path, formatter_name_for_command(each_command))
             return
 
 
-def formatter_name_for_command(command: list[str]) -> str:
-    if command[0] == sys.executable:
-        return command[2]
-    return command[0]
-
-
 def _run_prettier(file_path: str) -> None:
     prettier_command = [
         NPX_EXECUTABLE,
@@ -267,11 +226,7 @@ def _run_prettier(file_path: str) -> None:
         "--write",
         os.path.realpath(file_path),
     ]
-    completed_process, _did_timeout = _run_command(
-        prettier_command, file_path, JS_FORMAT_TIMEOUT_SECONDS
-    )
-    if completed_process is not None and completed_process.returncode == 0:
-        send_format_notification(file_path, PRETTIER_FORMATTER_NAME)
+    _run_command(prettier_command, file_path, JS_FORMAT_TIMEOUT_SECONDS)
 
 
 def run_eligible_formatter(file_path: str) -> None:

package/hooks/workflow/test_auto_formatter_toast.py

@@ -0,0 +1,67 @@
+"""The auto_formatter hook leaves the desktop alone after a format.
+
+An install from before the package dropped ``hooks/notification`` keeps
+``notification_utils.py`` on disk. These tests put a recording stand-in for
+that module on the import path and check the hook never reads it.
+"""
+
+import importlib.util
+import subprocess
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+HOOK_SCRIPT_PATH = Path(__file__).resolve().parent / "auto_formatter.py"
+
+
+def _load_auto_formatter_module() -> ModuleType:
+    module_spec = importlib.util.spec_from_file_location(
+        "auto_formatter_toast_under_test", HOOK_SCRIPT_PATH
+    )
+    assert module_spec is not None and module_spec.loader is not None
+    auto_formatter_module = importlib.util.module_from_spec(module_spec)
+    module_spec.loader.exec_module(auto_formatter_module)
+    return auto_formatter_module
+
+
+def _build_recording_notification_module(all_touched_names: list[str]) -> ModuleType:
+    class RecordingNotificationModule(ModuleType):
+        def __getattr__(self, attribute_name: str) -> object:
+            if not attribute_name.startswith("__"):
+                all_touched_names.append(attribute_name)
+            return lambda *_arguments, **_options: False
+
+    return RecordingNotificationModule("notification_utils")
+
+
+def test_successful_format_opens_no_desktop_toast(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A stale notification_utils on the import path stays untouched after a format.
+
+    ::
+
+        ~/.claude/hooks/notification/notification_utils.py   left behind by an old install
+        ruff format module.py  ->  exit 0
+        ok:   nothing reads notification_utils
+        flag: notify_windows() opens a toast window at the bottom of the screen
+    """
+    auto_formatter_module = _load_auto_formatter_module()
+    all_touched_names: list[str] = []
+    monkeypatch.setitem(
+        sys.modules,
+        "notification_utils",
+        _build_recording_notification_module(all_touched_names),
+    )
+
+    def report_formatter_success(
+        command: list[str], _file_path: str, _timeout_seconds: int
+    ) -> tuple[subprocess.CompletedProcess[str], bool]:
+        return subprocess.CompletedProcess(command, 0, "", ""), False
+
+    monkeypatch.setattr(auto_formatter_module, "_run_command", report_formatter_success)
+
+    auto_formatter_module.run_eligible_formatter("formatted_module.py")
+    auto_formatter_module._run_prettier("formatted_module.js")
+
+    assert all_touched_names == []

package/package.json

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

package/rules/archiving-agent-config.md

@@ -1,3 +1,14 @@
+---
+paths:
+  - "**/rules/**"
+  - "**/rules-archived/**"
+  - "**/skills/**"
+  - "**/skills-archived/**"
+  - "**/agents/**"
+  - "**/commands/**"
+  - "**/ever-shipped-skills.mjs"
+---
+
 # Archiving a Rule, Skill, Agent, or Command
 
 **When this applies:** Pruning agent configuration in this package — moving a

package/rules/bdd.md

@@ -1,3 +1,12 @@
+---
+paths:
+  - "**/*.py"
+  - "**/*.mjs"
+  - "**/*.js"
+  - "**/*.ts"
+  - "**/*.tsx"
+---
+
 # BDD (discovery-driven development)
 
 **Canonical detail:** `~/.claude/system-prompts/software-engineer.xml` → `<behavior_protocol>`.

package/rules/build-needs-a-user.md

@@ -1,3 +1,14 @@
+---
+paths:
+  - "**/scripts/**"
+  - "**/hooks/**"
+  - "**/bin/**"
+  - "**/ci/**"
+  - "**/tools/**"
+  - "**/skills/**"
+  - "**/commands/**"
+---
+
 # Build Needs a User
 
 **When this applies:** Before you build a new tool, script, hook, gate, skill,

package/rules/code-standards.md

@@ -1,3 +1,13 @@
+---
+paths:
+  - "**/*.py"
+  - "**/*.mjs"
+  - "**/*.js"
+  - "**/*.ts"
+  - "**/*.tsx"
+  - "**/*.ps1"
+---
+
 # Code Standards
 
 > **Canonical review contract:** [`CODE_RULES.md`](../docs/CODE_RULES.md) — the human and AI review contract for code quality, loaded on demand.

package/rules/failure-blast-radius.md

@@ -1,3 +1,12 @@
+---
+paths:
+  - "**/*.py"
+  - "**/*.mjs"
+  - "**/*.js"
+  - "**/*.ts"
+  - "**/*.ps1"
+---
+
 # Failure Blast Radius
 
 **When this applies:** Batch code that processes assets, rows, accounts, messages, or files where one member can fail while the others are fine.

package/rules/flag-non-breaking-findings.md

@@ -1,3 +1,14 @@
+---
+paths:
+  - "**/hooks/**"
+  - "**/policy_lint/**"
+  - "**/repository_checks/**"
+  - "**/.pre-commit-config.yaml"
+  - "**/.githooks/**"
+  - "**/.husky/**"
+  - "**/.github/workflows/**"
+---
+
 # Flag Non-Breaking Findings
 
 **When this applies:** Writing or changing a local gate — a git hook, a

package/rules/long-horizon-autonomy.md

@@ -1,3 +1,9 @@
+---
+paths:
+  - "**/skills/orchestrator/**"
+  - "**/skills/orchestrator-refresh/**"
+---
+
 # Long-Horizon Autonomy
 
 Source: [Anthropic - Prompting Claude Fable 5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5)

package/rules/prefer-existing-tools.md

@@ -1,3 +1,16 @@
+---
+paths:
+  - "**/scripts/**"
+  - "**/hooks/**"
+  - "**/bin/**"
+  - "**/ci/**"
+  - "**/tools/**"
+  - "**/skills/**"
+  - "**/package.json"
+  - "**/pyproject.toml"
+  - "**/requirements*.txt"
+---
+
 # Prefer Existing Tools
 
 **When this applies:** Before you build a tool, check, scanner, script, or library of your own.

package/rules/workers-done-before-complete.md

@@ -1,3 +1,9 @@
+---
+paths:
+  - "**/skills/orchestrator/**"
+  - "**/skills/orchestrator-refresh/**"
+---
+
 # Workers Done Before Complete
 
 Before marking a task `completed` that spawned workers — subagents, workflow agents, or background shells — confirm both: every worker has finished, and each worker's result is merged into run state (`state.json`, `pr-converge-state.json`, the task list, or whatever record the task keeps). A worker still running, or one whose output never landed in run state, keeps the task `in_progress`: list the live workers, report any dead or hung one as a finding rather than dropping it in silence, and schedule a wakeup so the run picks the workers back up before the task closes.

package/scripts/tests/test_rule_load_scopes.py

@@ -0,0 +1,77 @@
+"""Which rules load in every session, and how skill-scoped rules still reach their skill."""
+
+from pathlib import Path
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[2]
+RULES_DIRECTORY = PACKAGE_ROOT / "rules"
+SKILLS_DIRECTORY = PACKAGE_ROOT / ".agents" / "skills"
+
+ALWAYS_ON_RULE_NAMES = frozenset(
+    {
+        "AGENTS.md",
+        "CLAUDE.md",
+        "agent-merges-its-own-green-pull-request.md",
+        "asd-ste100-language.md",
+        "ci-owns-the-gate.md",
+        "cleanup-temp-files.md",
+        "correction-lens.md",
+        "destructive-commands.md",
+        "durable-post-artifacts.md",
+        "explore-thoroughly.md",
+        "filesystem-search.md",
+        "gh-cli-conventions.md",
+        "git-workflow.md",
+        "memory-stores-durable-facts.md",
+        "no-contrast-framing.md",
+        "question-presentation.md",
+        "re-stage-before-commit.md",
+        "research-mode.md",
+        "review-closure-is-a-check.md",
+        "shell-invocation.md",
+        "verify-before-asking.md",
+        "verify-runtime-state.md",
+    }
+)
+
+SKILL_SCOPED_RULES = {
+    "long-horizon-autonomy.md": ("orchestrator", "orchestrator-refresh"),
+    "workers-done-before-complete.md": ("orchestrator", "orchestrator-refresh"),
+}
+
+
+def _declares_paths(rule_path: Path) -> bool:
+    lines = rule_path.read_text(encoding="utf-8").splitlines()
+    if not lines or lines[0] != "---":
+        return False
+    for each_line in lines[1:]:
+        if each_line == "---":
+            return False
+        if each_line.startswith("paths:"):
+            return True
+    return False
+
+
+def test_only_allowlisted_rules_load_in_every_session() -> None:
+    unscoped_rule_names = {
+        each_rule.name
+        for each_rule in RULES_DIRECTORY.glob("*.md")
+        if not _declares_paths(each_rule)
+    }
+    assert unscoped_rule_names == ALWAYS_ON_RULE_NAMES
+
+
+def test_skill_scoped_rules_carry_paths_on_their_skill_directories() -> None:
+    for each_rule_name, all_skill_names in SKILL_SCOPED_RULES.items():
+        rule_text = (RULES_DIRECTORY / each_rule_name).read_text(encoding="utf-8")
+        assert _declares_paths(RULES_DIRECTORY / each_rule_name)
+        for each_skill_name in all_skill_names:
+            assert f'"**/skills/{each_skill_name}/**"' in rule_text
+
+
+def test_each_scoping_skill_tells_the_agent_to_read_its_rules() -> None:
+    for each_rule_name, all_skill_names in SKILL_SCOPED_RULES.items():
+        for each_skill_name in all_skill_names:
+            skill_text = (SKILLS_DIRECTORY / each_skill_name / "SKILL.md").read_text(
+                encoding="utf-8"
+            )
+            assert f"~/.claude/rules/{each_rule_name}" in skill_text