claude-dev-env 1.88.1 → 1.90.0

package/CLAUDE.md

@@ -1,13 +1,19 @@
 # Claude Development Assistant
 
-The user is short on time and tokens. When you reply, always assume they'll only read your first few sentences and final sentences. Anything else is skimmed at best. Frame your replies accordingly.
-
-The user is short on tokens; whenever a task can be achieved cleanly and effectively, optimize to save the user $$ and token usage.
+The user is short on time and appreciates brevity in replies. When you reply, always assume they'll only read your first few sentences and final sentences. Anything else is skimmed at best. Frame your replies accordingly.
 
 The user delegates execution to you and expects zero manual steps unless strictly necessary. Execute every command you can directly. Only instruct the user to do something manually when you are technically unable to do it yourself. When a task involves credentials or other sensitive input, display a minimal secure UI (e.g., a password dialog) to collect it rather than asking the user to paste it into chat or run the command themselves. When direction is ambiguous, use AskUserQuestion to clarify before acting.
 
-## Code Rules
-@~/.claude/docs/CODE_RULES.md
+You have access to an `advisor` tool backed by a stronger reviewer model. It takes NO parameters — when you call advisor(), your entire conversation history is automatically forwarded. They see the task, every tool call you've made, every result you've seen.
+
+Call advisor BEFORE substantive work — before writing, before committing to an interpretation, before building on an assumption. If the task requires orientation first (finding files, fetching a source, seeing what's there), do that, then call advisor. Orientation is not substantive work. Writing, editing, and declaring an answer are.
+
+Also call advisor:
+- When you believe the task is complete. BEFORE this call, make your deliverable durable: write the file, save the result, commit the change. The advisor call takes time; if the session ends during it, a durable result persists and an unwritten one doesn't.
+- When stuck — errors recurring, approach not converging, results that don't fit.
+- When considering a change of approach.
+
+On tasks longer than a few steps, call advisor at least once before committing to an approach and once before declaring done. On short reactive tasks where the next action is dictated by tool output you just read, you don't need to keep calling — the advisor adds most of its value on the first call, before the approach crystallizes.
 
 ALWAYS call the AskUserQuestion tool if you have a question for the user. Provide content-appropriate default options, with a flag for the recommended one.
 
@@ -21,12 +27,8 @@ Every Markdown file I write or edit describes the system's **current** state onl
 Full banned-pattern set + enforcement: `~/.claude/rules/no-historical-clutter.md` (hook `state-description-blocker`) and `~/.claude/rules/self-contained-docs.md`.
 
 ## GOTCHAS
-ALWAYS base new worktrees off of UPSTREAM origin main. Assume local is out of date.
-
 ALWAYS start each session with a /loop 15m populate or update the task list based on remaining todos.
 
-When making code changes, make sure you are working in the proper worktree path for the task at hand.
-
 ## Choosing Edit vs Write
 
 `Edit` changes existing files; `Write` creates new ones. Default to `Edit` — reach for `Write` only for a genuinely new path. For a true full rewrite, delete the file first, then `Write`.
@@ -37,10 +39,6 @@ When I ask you to "show me", "open", "display", "let me see", or "pull up" a fil
 
 `Start-Process pwsh -WindowStyle Hidden -ArgumentList '-NoProfile','-File',"$HOME\.claude\scripts\Show-Asset.ps1",'<path 1>','<path 2>'`
 
-It sizes each image window to the image (scaled down to fit the screen) and opens non-image files in their default app; pass every path I name. Printing a path or attaching the file is not showing it — do that only when the file truly cannot be opened, and say why.
-
-The `send_user_file_open_locally_blocker` hook backs this up: it blocks a desk-side `SendUserFile` attach and sends you back to this command, while a phone push (`status: "proactive"`) stays allowed.
-
 ## Test Philosophy
 
 When writing tests, always write tests that actually test the behavior of the function against actual, real data and environments.
@@ -59,34 +57,15 @@ Reserve `Read`/`Grep`/`Glob` for files you will actually touch this turn. Compos
 
 Run every multi-step code task in two phases:
 
-1. **Coders** — one coder agent per scoped assignment writes the code. A coder that hits a decision it can't reasonably solve consults the tool-less `code-advisor` agent — which returns a plan, a correction, or a stop signal — and resumes. Source: Anthropic's advisor strategy (https://claude.com/blog/the-advisor-strategy).
-2. **Verification** — when the coders finish, the main session spawns the `code-verifier` agent in a fresh context. It derives and runs the checks itself rather than trusting coder reports: the task's named gates, tests against baselines recorded before the coders ran, and a two-way diff-vs-assignment reading (every task item maps to a hunk, every hunk maps to a task item, nothing missing). A finding must cite a failing command or a named task item. Source: the fresh-context review step in Claude Code best practices (https://code.claude.com/docs/en/best-practices) — the agent doing the work isn't the one grading it.
+1. **Coders** — one coder agent per scoped assignment writes the code. A coder that hits a decision it can't reasonably solve consults the advisor (see beginning of this file).
+2. **Verification** — when the coders finish, the main session spawns the `code-verifier` agent in a fresh context, but you must first verify that their work is based on upstream's origin main (aka: the commit live on github). It derives and runs the checks itself rather than trusting coder reports: the task's named gates, tests against baselines recorded before the coders ran, and a two-way diff-vs-assignment reading (every task item maps to a hunk, every hunk maps to a task item, nothing missing). A finding must cite a failing command or a named task item. Source: the fresh-context review step in Claude Code best practices (https://code.claude.com/docs/en/best-practices) — the agent doing the work isn't the one grading it.
 
 Repair agents run only on reported findings; the verifier re-checks after each repair. Work lands (commit, push, draft PR) only on a clean verdict — enforced by the `verified_commit_gate` hook, which blocks `git commit`/`git push` unless a hook-minted verdict covers the current branch diff. The one exemption is mechanical, not discretionary: a diff whose every changed file is non-code or has an unchanged Python AST once docstrings are stripped (docs, docstrings, comments).
 
-## Converge & Review Loop Discipline
-
-- **Worktree isolation:** Run every PR convergence and review loop in an isolated worktree, never a shared checkout that concurrent processes may advance. Verify isolation (the working directory path includes `.claude/worktrees/`) before the first tick or round.
-- **No hedging in findings:** Findings and PR reports state verified facts only — never `likely`, `probably`, `should`, `appears to`. Verify each claim against the code before stating it; the anti-hallucination Stop hook rejects hedged responses.
-- **Tight edit scope:** Edit exactly what the task names — no whole-file rewrites, no renaming public method parameters, no changes beyond the stated task. When the user asks for a "lasting" or "reusable" fix, prefer the durable systemic fix over a one-off edit. When the task touches a pipeline, generator, or other repeated process, fix the process itself, not its individual outputs — even when the request does not say so; for one-off targets, a scoped patch remains the default.
-- **GitHub MCP first:** The GitHub MCP (`mcp__plugin_github_github__*`) is the primary path for PR and review-thread inspection; raw `gh api` is the fallback, not the default — MCP calls work the same from any worktree.
-
-## Destructive-command literals in Bash
-
-Never put a destructive-command literal (`rm -rf`, `git reset --hard`, `dd`, `mkfs`) inside a Bash command string, even when the shell never runs it — a quoted `python -c` argument, a heredoc body, an echoed string, a commit or PR body. The `destructive_command_blocker` hook matches the raw text and asks for confirmation, which a background run cannot answer, so the call stalls. Run hook and deletion checks through the committed test suite (`python -m pytest <test_file>`), or a throwaway script under `$CLAUDE_JOB_DIR/tmp` run as `python <file>.py` — either way the command string carries no destructive text, so the hook stays silent. Group genuine cleanup deletions into one teardown step. See `~/.claude/rules/no-inline-destructive-literals.md`.
-
 ## Sub-agent Output Validation
 
 After any sub-agent returns a PR description, file list, or counts, verify each claim against the actual diff and repo state before using it. Flag and correct any invented paths, fabricated counts, or out-of-scope changes before they land in commits or PR bodies.
 
-## Git Sync Intent
-
-When asked to sync git ("get X onto origin main", "update main"), fast-forward local main to origin — do NOT commit untracked working-tree files unless explicitly told to.
-
-## Scheduled Task Cadence
-
-For scheduled/cron tasks, default to sub-hour intervals (30-minute); do not propose hourly cadences.
-
 ## Task Tracking
 
 Track every task with the task tool, always — for all sessions and all tasks. Capture each task with `TaskCreate` as it arrives, mark it `in_progress` with `TaskUpdate` when you start, and `completed` when it is done. Run `/task-build` to gather any open tasks and add them to the list in one pass.

package/_shared/pr-loop/scripts/code_rules_gate.py

@@ -15,6 +15,7 @@ from pr_loop_shared_constants.code_rules_gate_constants import (  # noqa: E402
     ALL_CODE_FILE_EXTENSIONS,
     ALL_GIT_DIFF_CACHED_NAME_ONLY_NULL_TERMINATED_COMMAND,
     ALL_GIT_DIFF_NAME_ONLY_NULL_TERMINATED_COMMAND_PREFIX,
+    ALL_PYTEST_CONFIG_FILE_SECTIONS,
     ALL_PYTEST_MODULE_INVOCATION,
     ALL_TEST_FILENAME_GLOB_SUFFIXES,
     ALL_TEST_FILENAME_SUFFIXES,
@@ -38,6 +39,7 @@ from pr_loop_shared_constants.code_rules_gate_constants import (  # noqa: E402
     PYTHON_FILE_EXTENSION,
     STAGED_PYTEST_TIMEOUT_SECONDS,
     STAGED_TEST_FAILURE_HEADER,
+    STAGED_TEST_GROUP_FAILURE_MESSAGE,
     TEST_CONFTEST_FILENAME,
     TEST_FILENAME_PREFIX,
     TESTS_PATH_SEGMENT,
@@ -1559,39 +1561,129 @@ def _staged_test_file_paths(repository_root: Path) -> list[Path]:
     return all_test_paths
 
 
-def run_staged_test_files(repository_root: Path) -> int:
-    """Run pytest over the staged test files and return the gate exit code.
+def _directory_holds_pytest_config(directory: Path) -> bool:
+    """Return True when *directory* holds a recognized pytest configuration file."""
+    for each_filename, each_required_section in ALL_PYTEST_CONFIG_FILE_SECTIONS:
+        config_path = directory / each_filename
+        if not config_path.is_file():
+            continue
+        if each_required_section is None:
+            return True
+        try:
+            config_text = config_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        if each_required_section in config_text:
+            return True
+    return False
+
+
+def _resolve_owning_test_root(test_file_path: Path, repository_root: Path) -> Path:
+    """Return the nearest ancestor of *test_file_path* that owns a pytest config.
+
+    Walks up from the test file to the first directory holding a pytest config,
+    stopping at *repository_root*, which is the fallback when none is found.
 
     Args:
-        repository_root: The repository root the staged test files belong to.
+        test_file_path: The staged test file to resolve a root for.
+        repository_root: The repository root that bounds the upward walk.
 
     Returns:
-        0 when no test file is staged, when the staged test files collect
-        no tests (pytest's no-tests-collected exit code), or when every staged
-        test passes. pytest's non-zero exit code otherwise, which blocks the
-        commit.
+        The resolved owning test root directory.
+    """
+    resolved_repository_root = repository_root.resolve()
+    for each_ancestor in test_file_path.resolve().parents:
+        if _directory_holds_pytest_config(each_ancestor):
+            return each_ancestor
+        if each_ancestor == resolved_repository_root:
+            return resolved_repository_root
+    return resolved_repository_root
+
+
+def _group_staged_tests_by_root(
+    all_test_paths: list[Path],
+    repository_root: Path,
+) -> dict[Path, list[Path]]:
+    """Group *all_test_paths* by their owning pytest-config root.
+
+    Args:
+        all_test_paths: The staged test files to partition.
+        repository_root: The repository root that bounds each upward walk.
+
+    Returns:
+        A mapping from owning test root to the staged test files under it.
+    """
+    tests_by_root: dict[Path, list[Path]] = {}
+    for each_test_path in all_test_paths:
+        owning_root = _resolve_owning_test_root(each_test_path, repository_root)
+        tests_by_root.setdefault(owning_root, []).append(each_test_path)
+    return tests_by_root
+
+
+def _run_pytest_for_group(group_root: Path, all_group_test_paths: list[Path]) -> int:
+    """Run pytest over one group's test files with the working directory at its root.
+
+    Args:
+        group_root: The owning test root used as the pytest working directory.
+        all_group_test_paths: The staged test files that share *group_root*.
+
+    Returns:
+        0 when the group's tests pass or collect nothing; pytest's non-zero
+        exit code otherwise.
     """
-    all_test_paths = _staged_test_file_paths(repository_root)
-    if not all_test_paths:
-        return 0
     pytest_process = subprocess.run(
         [
             sys.executable,
             *ALL_PYTEST_MODULE_INVOCATION,
-            *[str(each_path) for each_path in all_test_paths],
+            *[str(each_path) for each_path in all_group_test_paths],
         ],
-        cwd=str(repository_root),
+        cwd=str(group_root),
         timeout=STAGED_PYTEST_TIMEOUT_SECONDS,
         check=False,
         env=repository_environment(),
     )
     if pytest_process.returncode == PYTEST_NO_TESTS_COLLECTED_EXIT_CODE:
         return 0
-    if pytest_process.returncode != 0:
-        print(STAGED_TEST_FAILURE_HEADER, file=sys.stderr)
     return pytest_process.returncode
 
 
+def run_staged_test_files(repository_root: Path) -> int:
+    """Run pytest over the staged test files and return the gate exit code.
+
+    Groups the staged test files by their owning pytest-config root and runs one
+    pytest session per group with the working directory at that root, so two
+    packages that expose a same-named top-level package never share one session
+    and shadow each other's imports.
+
+    Args:
+        repository_root: The repository root the staged test files belong to.
+
+    Returns:
+        0 when no test file is staged, when every group collects no tests, or
+        when every group passes. The first failing group's non-zero pytest exit
+        code otherwise, which blocks the commit.
+    """
+    all_test_paths = _staged_test_file_paths(repository_root)
+    if not all_test_paths:
+        return 0
+    tests_by_root = _group_staged_tests_by_root(all_test_paths, repository_root)
+    first_failing_exit_code = 0
+    for each_group_root in sorted(tests_by_root):
+        group_exit_code = _run_pytest_for_group(
+            each_group_root, tests_by_root[each_group_root]
+        )
+        if group_exit_code != 0:
+            print(
+                STAGED_TEST_GROUP_FAILURE_MESSAGE.format(group_root=each_group_root),
+                file=sys.stderr,
+            )
+            if first_failing_exit_code == 0:
+                first_failing_exit_code = group_exit_code
+    if first_failing_exit_code != 0:
+        print(STAGED_TEST_FAILURE_HEADER, file=sys.stderr)
+    return first_failing_exit_code
+
+
 def _report_terminology_findings(all_findings: list[str]) -> None:
     """Print the terminology-sweep findings, when any, to standard error.
 

package/_shared/pr-loop/scripts/pr_loop_shared_constants/code_rules_gate_constants.py

@@ -93,3 +93,29 @@ STAGED_PYTEST_TIMEOUT_SECONDS: int = 600
 STAGED_TEST_FAILURE_HEADER: str = (
     "code_rules_gate: staged test file(s) failed under pytest; commit blocked."
 )
+
+PYTEST_INI_FILENAME: str = "pytest.ini"
+
+PYPROJECT_TOML_FILENAME: str = "pyproject.toml"
+
+SETUP_CFG_FILENAME: str = "setup.cfg"
+
+TOX_INI_FILENAME: str = "tox.ini"
+
+PYPROJECT_PYTEST_CONFIG_SECTION: str = "[tool.pytest.ini_options]"
+
+SETUP_CFG_PYTEST_CONFIG_SECTION: str = "[tool:pytest]"
+
+TOX_INI_PYTEST_CONFIG_SECTION: str = "[pytest]"
+
+ALL_PYTEST_CONFIG_FILE_SECTIONS: tuple[tuple[str, str | None], ...] = (
+    (PYTEST_INI_FILENAME, None),
+    (PYPROJECT_TOML_FILENAME, PYPROJECT_PYTEST_CONFIG_SECTION),
+    (SETUP_CFG_FILENAME, SETUP_CFG_PYTEST_CONFIG_SECTION),
+    (TOX_INI_FILENAME, TOX_INI_PYTEST_CONFIG_SECTION),
+)
+
+STAGED_TEST_GROUP_FAILURE_MESSAGE: str = (
+    "code_rules_gate: staged test group rooted at {group_root} "
+    "failed under pytest; commit blocked."
+)

package/_shared/pr-loop/scripts/tests/test_code_rules_gate.py

@@ -2418,3 +2418,163 @@ def test_run_staged_test_files_runs_pytest_without_git_environment(
     monkeypatch.setenv("GIT_AUTHOR_NAME", "Hostile Hook Environment")
 
     assert gate_module.run_staged_test_files(repository_root) == 0
+
+
+def _build_shadowing_skill(
+    repository_root: Path,
+    skill_name: str,
+    module_name: str,
+) -> Path:
+    skill_directory = repository_root / skill_name
+    write_file(skill_directory / "pytest.ini", "[pytest]\n")
+    write_file(skill_directory / "scripts" / "__init__.py", "")
+    write_file(
+        skill_directory / "scripts" / f"{module_name}.py",
+        f"{module_name}_marker = 1\n",
+    )
+    test_relative_path = f"{skill_name}/test_{module_name}.py"
+    write_file(
+        repository_root / test_relative_path,
+        f"from scripts.{module_name} import {module_name}_marker\n"
+        "\n"
+        "\n"
+        f"def test_{module_name}_marker_is_one() -> None:\n"
+        f"    assert {module_name}_marker == 1\n",
+    )
+    stage_file(repository_root, test_relative_path)
+    return repository_root / test_relative_path
+
+
+def test_run_staged_test_files_passes_when_same_named_package_would_shadow(
+    temporary_git_repository: Path,
+) -> None:
+    """Two skill roots each own a top-level ``scripts`` package. One combined
+    pytest session binds ``scripts`` to whichever imports first and the other
+    skill's ``from scripts.<module>`` then raises ImportError. Per-root sessions
+    keep each ``scripts`` isolated, so the gate passes."""
+    first_test_path = _build_shadowing_skill(
+        temporary_git_repository, "skill_alpha", "widget"
+    )
+    second_test_path = _build_shadowing_skill(
+        temporary_git_repository, "skill_beta", "gadget"
+    )
+
+    combined_session = subprocess.run(
+        [sys.executable, "-m", "pytest", "-q", str(first_test_path), str(second_test_path)],
+        cwd=str(temporary_git_repository),
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+    assert combined_session.returncode != 0, (
+        "one combined pytest session must fail on the same-named scripts package "
+        "shadow; if it does not, the shadow scenario is not being reproduced"
+    )
+
+    assert gate_module.run_staged_test_files(temporary_git_repository) == 0, (
+        "per-root pytest sessions must keep each scripts package isolated so both "
+        "staged suites pass"
+    )
+
+
+def test_resolve_owning_test_root_returns_pyproject_config_directory(
+    tmp_path: Path,
+) -> None:
+    package_root = tmp_path / "package_root"
+    write_file(
+        package_root / "pyproject.toml",
+        "[tool.pytest.ini_options]\ntestpaths = ['tests']\n",
+    )
+    test_path = package_root / "tests" / "test_behavior.py"
+    write_file(test_path, "def test_behavior() -> None:\n    assert True\n")
+
+    resolved_root = gate_module._resolve_owning_test_root(test_path, tmp_path)
+
+    assert resolved_root == package_root.resolve()
+
+
+def test_resolve_owning_test_root_returns_pytest_ini_directory(
+    tmp_path: Path,
+) -> None:
+    package_root = tmp_path / "package_root"
+    write_file(package_root / "pytest.ini", "[pytest]\n")
+    test_path = package_root / "suite" / "test_behavior.py"
+    write_file(test_path, "def test_behavior() -> None:\n    assert True\n")
+
+    resolved_root = gate_module._resolve_owning_test_root(test_path, tmp_path)
+
+    assert resolved_root == package_root.resolve()
+
+
+def test_resolve_owning_test_root_falls_back_to_repository_root(
+    tmp_path: Path,
+) -> None:
+    test_path = tmp_path / "nested" / "deeper" / "test_behavior.py"
+    write_file(test_path, "def test_behavior() -> None:\n    assert True\n")
+
+    resolved_root = gate_module._resolve_owning_test_root(test_path, tmp_path)
+
+    assert resolved_root == tmp_path.resolve()
+
+
+def test_resolve_owning_test_root_skips_pyproject_without_pytest_section(
+    tmp_path: Path,
+) -> None:
+    outer_root = tmp_path / "outer"
+    write_file(
+        outer_root / "pyproject.toml",
+        "[tool.pytest.ini_options]\ntestpaths = ['tests']\n",
+    )
+    write_file(outer_root / "inner" / "pyproject.toml", "[project]\nname = 'inner'\n")
+    test_path = outer_root / "inner" / "test_behavior.py"
+    write_file(test_path, "def test_behavior() -> None:\n    assert True\n")
+
+    resolved_root = gate_module._resolve_owning_test_root(test_path, tmp_path)
+
+    assert resolved_root == outer_root.resolve()
+
+
+def test_group_staged_tests_by_root_shares_a_session_for_same_root(
+    tmp_path: Path,
+) -> None:
+    package_root = tmp_path / "package_root"
+    write_file(package_root / "pytest.ini", "[pytest]\n")
+    first_test_path = package_root / "tests" / "test_first.py"
+    second_test_path = package_root / "tests" / "test_second.py"
+    write_file(first_test_path, "def test_first() -> None:\n    assert True\n")
+    write_file(second_test_path, "def test_second() -> None:\n    assert True\n")
+
+    tests_by_root = gate_module._group_staged_tests_by_root(
+        [first_test_path, second_test_path], tmp_path
+    )
+
+    assert set(tests_by_root) == {package_root.resolve()}
+    assert sorted(tests_by_root[package_root.resolve()]) == sorted(
+        [first_test_path, second_test_path]
+    )
+
+
+def test_run_staged_test_files_fails_when_one_group_fails(
+    temporary_git_repository: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    write_file(temporary_git_repository / "passing_skill" / "pytest.ini", "[pytest]\n")
+    write_file(
+        temporary_git_repository / "passing_skill" / "test_pass.py",
+        "def test_pass() -> None:\n    assert True\n",
+    )
+    stage_file(temporary_git_repository, "passing_skill/test_pass.py")
+    write_file(temporary_git_repository / "failing_skill" / "pytest.ini", "[pytest]\n")
+    write_file(
+        temporary_git_repository / "failing_skill" / "test_fail.py",
+        "def test_fail() -> None:\n    assert False\n",
+    )
+    stage_file(temporary_git_repository, "failing_skill/test_fail.py")
+
+    exit_code = gate_module.run_staged_test_files(temporary_git_repository)
+
+    assert exit_code != 0
+    captured_error = capsys.readouterr().err
+    assert "failing_skill" in captured_error

package/agents/code-verifier.md

@@ -2,7 +2,8 @@
 name: code-verifier
 description: Post-hoc verification agent for the two-phase code workflow. Spawned by the main session after coder agents finish. Runs every check itself in a fresh context — named gates, tests against recorded baselines, two-way diff-vs-task reading — and ends with a fenced verdict block the verifier_verdict_minter hook turns into the commit-gate verdict. Read and execute only; it never edits files.
 tools: Read, Grep, Glob, Bash
-model: inherit
+model: sonnet
+effort: medium
 color: orange
 ---
 

package/bin/install.mjs

@@ -147,7 +147,6 @@ const INSTALL_GROUPS = {
     core: {
         description: 'Development standards, hooks, agents, commands',
         skills: [
-            'advisor', 'advisor-refresh',
             'anthropic-plan', 'everything-search',
             'pr-review-responder',
             'recall', 'remember', 'task-build', 'verified-build'

package/hooks/blocking/CLAUDE.md

@@ -98,6 +98,7 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | `verified_commit_gate.py` | PreToolUse (Bash/PowerShell) | `git commit`/`git push` without a passing verifier verdict |
 | `verified_commit_message_accuracy_blocker.py` | PreToolUse | Commit messages that misstate what the diff has |
 | `verifier_verdict_minter.py` | SubagentStop | Mints a passing verdict file when a `code-verifier` agent finishes cleanly |
+| `volatile_path_in_post_blocker.py` | PreToolUse (Bash/MCP GitHub) | `gh` post commands and GitHub MCP post tools whose body references a volatile path (job scratch dir, worktree, or system temp) that outlives the durable post |
 | `windows_rmtree_blocker.py` | PreToolUse (Write/Edit) | `shutil.rmtree` with `ignore_errors=True` on Windows |
 | `workflow_substitution_slot_blocker.py` | PreToolUse (Write/Edit) | Workflow templates with bare per-iteration tokens missing angle-bracket slots |
 | `write_existing_file_blocker.py` | PreToolUse (Write) | Write to a path where a file already exists |