claude-dev-env 1.89.0 → 1.90.0

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/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 |

package/hooks/blocking/test_volatile_path_in_post_blocker.py

@@ -0,0 +1,210 @@
+"""Unit and integration tests for the volatile_path_in_post_blocker PreToolUse hook."""
+
+import importlib.util
+import json
+import pathlib
+import subprocess
+import sys
+
+_HOOK_DIR = pathlib.Path(__file__).parent
+if str(_HOOK_DIR) not in sys.path:
+    sys.path.insert(0, str(_HOOK_DIR))
+
+hook_spec = importlib.util.spec_from_file_location(
+    "volatile_path_in_post_blocker",
+    _HOOK_DIR / "volatile_path_in_post_blocker.py",
+)
+assert hook_spec is not None
+assert hook_spec.loader is not None
+hook_module = importlib.util.module_from_spec(hook_spec)
+hook_spec.loader.exec_module(hook_module)
+
+scan_text_for_volatile_marker = hook_module.scan_text_for_volatile_marker
+extract_gh_post_body_texts = hook_module.extract_gh_post_body_texts
+extract_mcp_body_texts = hook_module.extract_mcp_body_texts
+_collect_body_texts = hook_module._collect_body_texts
+
+
+def _body_names_volatile_path(tool_name: str, tool_input: dict[str, object]) -> bool:
+    all_body_texts = _collect_body_texts(tool_name, tool_input)
+    return hook_module._first_volatile_marker(all_body_texts) is not None
+
+
+def test_scan_detects_job_scratch_path_backslash() -> None:
+    text = r"See C:\Users\jon\.claude-editor\jobs\95762cea\tmp\staging\contact_sheet.png"
+    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+
+
+def test_scan_detects_job_scratch_path_forward_slash() -> None:
+    text = "artifact at /home/user/.claude-editor/jobs/abc/tmp/out.png"
+    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+
+
+def test_scan_detects_worktree_path() -> None:
+    text = r"edited .claude\worktrees\feature\file.py"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_detects_appdata_temp_case_insensitive() -> None:
+    text = r"C:\Users\jon\AppData\Local\Temp\bugteam\worktree"
+    assert scan_text_for_volatile_marker(text) == "appdata/local/temp"
+
+
+def test_scan_detects_unix_tmp() -> None:
+    assert scan_text_for_volatile_marker("output written to /tmp/run/out.log") == "/tmp/"
+
+
+def test_scan_detects_percent_temp_token() -> None:
+    assert scan_text_for_volatile_marker("saved to %TEMP%\\out.txt") == "%temp%"
+
+
+def test_scan_detects_env_temp_token() -> None:
+    assert scan_text_for_volatile_marker("path is $env:TEMP\\out.txt") == "$env:temp"
+
+
+def test_scan_detects_claude_job_dir_token() -> None:
+    assert scan_text_for_volatile_marker("see $CLAUDE_JOB_DIR/staging/report.md") == "$claude_job_dir"
+
+
+def test_scan_clean_body_returns_none() -> None:
+    text = "The failing table is pasted below:\n| case | result |\n| a | pass |"
+    assert scan_text_for_volatile_marker(text) is None
+
+
+def test_gh_comment_with_job_scratch_path_is_blocked() -> None:
+    command = (
+        'gh pr comment 669 --body "Contact sheet at '
+        r'C:\Users\jon\.claude-editor\jobs\95762cea\tmp\staging\contact_sheet.png"'
+    )
+    assert _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_gh_comment_with_clean_body_is_allowed() -> None:
+    command = 'gh pr comment 669 --body "All checks pass. Table pasted inline above."'
+    assert not _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_gh_pr_create_short_flag_blocked() -> None:
+    command = 'gh pr create --title "T" -b "logs under /tmp/run/out.log"'
+    assert _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_gh_issue_create_body_equals_form_blocked() -> None:
+    command = 'gh issue create --title "T" --body="dump in %TEMP%\\dump.json"'
+    assert _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_body_file_content_is_scanned_and_blocked(tmp_path: pathlib.Path) -> None:
+    body_file = tmp_path / "body.md"
+    body_file.write_text(
+        "Artifact: $CLAUDE_JOB_DIR/tmp/contact_sheet.png",
+        encoding="utf-8",
+    )
+    command = f"gh pr comment 669 --body-file {body_file}"
+    assert _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_body_file_clean_content_is_allowed(tmp_path: pathlib.Path) -> None:
+    body_file = tmp_path / "body.md"
+    body_file.write_text("Everything is green. Results inline above.", encoding="utf-8")
+    command = f"gh pr comment 669 --body-file {body_file}"
+    assert not _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_non_post_gh_command_is_untouched() -> None:
+    assert not _body_names_volatile_path("Bash", {"command": "gh pr list --repo owner/repo"})
+
+
+def test_gh_pr_view_with_tmp_in_flag_is_untouched() -> None:
+    command = "gh pr view 10 --json body --jq .body > /tmp/out.json"
+    assert not _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_substring_mention_of_gh_post_does_not_classify() -> None:
+    command = 'echo "example: gh pr comment 42 --body \\"see /tmp/x\\"" >> notes.txt'
+    assert not _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_gh_word_not_first_token_does_not_classify() -> None:
+    command = r'echo gh pr comment 42 --body "see C:\.claude-editor\jobs\x"'
+    assert not _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_env_assignment_prefix_still_classifies() -> None:
+    command = 'GH_TOKEN=abc gh pr comment 669 --body "log at /tmp/run.log"'
+    assert _body_names_volatile_path("Bash", {"command": command})
+
+
+def test_unparseable_command_is_allowed() -> None:
+    assert not _body_names_volatile_path(
+        "Bash", {"command": "gh pr comment 1 --body 'unterminated"}
+    )
+
+
+def test_mcp_issue_comment_body_blocked() -> None:
+    tool_input: dict[str, object] = {"body": "artifact at $CLAUDE_JOB_DIR/tmp/out.png"}
+    assert _body_names_volatile_path("mcp__plugin_github_github__add_issue_comment", tool_input)
+
+
+def test_mcp_review_comment_param_blocked() -> None:
+    tool_input: dict[str, object] = {"comment": r"see .claude\worktrees\x\file"}
+    assert _body_names_volatile_path(
+        "mcp__plugin_github_github__add_reply_to_pull_request_comment", tool_input
+    )
+
+
+def test_mcp_clean_body_allowed() -> None:
+    tool_input: dict[str, object] = {"body": "LGTM, results pasted inline."}
+    assert not _body_names_volatile_path("mcp__plugin_github_github__add_issue_comment", tool_input)
+
+
+def test_mcp_read_tool_without_body_allowed() -> None:
+    tool_input: dict[str, object] = {"pullNumber": 10}
+    assert not _body_names_volatile_path("mcp__plugin_github_github__pull_request_read", tool_input)
+
+
+def test_extract_mcp_body_texts_skips_non_string_values() -> None:
+    tool_input: dict[str, object] = {"body": None, "comment": 42}
+    assert extract_mcp_body_texts(tool_input) == []
+
+
+def test_extract_gh_post_body_texts_returns_inline_and_file(tmp_path: pathlib.Path) -> None:
+    body_file = tmp_path / "b.md"
+    body_file.write_text("file body text", encoding="utf-8")
+    command = f'gh pr create --title "T" --body "inline body" --body-file {body_file}'
+    all_texts = extract_gh_post_body_texts(command)
+    assert "inline body" in all_texts
+    assert "file body text" in all_texts
+
+
+def test_hook_subprocess_denies_volatile_gh_comment() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {
+            "command": 'gh pr comment 669 --body "art at $CLAUDE_JOB_DIR/tmp/x.png"',
+        },
+    }
+    completion = subprocess.run(
+        [sys.executable, str(_HOOK_DIR / "volatile_path_in_post_blocker.py")],
+        input=json.dumps(payload),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    decision = json.loads(completion.stdout)
+    assert decision["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_hook_subprocess_allows_clean_gh_comment() -> None:
+    payload = {
+        "tool_name": "Bash",
+        "tool_input": {"command": 'gh pr comment 669 --body "all green, results inline"'},
+    }
+    completion = subprocess.run(
+        [sys.executable, str(_HOOK_DIR / "volatile_path_in_post_blocker.py")],
+        input=json.dumps(payload),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert completion.stdout.strip() == ""