claude-dev-env 2.17.0 → 2.19.0

package/hooks/blocking/test_code_rules_enforcer_split_entry_2.py

@@ -2,12 +2,13 @@
 
 from __future__ import annotations
 
-import io
 import json
 import sys
 from pathlib import Path
 from types import SimpleNamespace
 
+import pytest
+
 _BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
 _HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
 if _BLOCKING_DIRECTORY not in sys.path:
@@ -23,6 +24,9 @@ from code_rules_enforcer import (  # noqa: E402
     prior_and_post_edit_content,
     validate_content,
 )
+from code_rules_enforcer_test_support import (  # noqa: E402
+    run_serialized_payload_entrypoint,
+)
 
 code_rules_enforcer = SimpleNamespace(
     FUNCTION_LENGTH_BLOCKING_THRESHOLD=FUNCTION_LENGTH_BLOCKING_THRESHOLD,
@@ -35,9 +39,7 @@ code_rules_enforcer = SimpleNamespace(
 
 def _oversized_function_source(name: str) -> str:
     body_line_count = code_rules_enforcer.FUNCTION_LENGTH_BLOCKING_THRESHOLD - 1
-    body_lines = [
-        f"    bound_{each_index} = {each_index}" for each_index in range(body_line_count)
-    ]
+    body_lines = [f"    bound_{each_index} = {each_index}" for each_index in range(body_line_count)]
     return f"def {name}() -> None:\n" + "\n".join(body_lines) + "\n"
 
 
@@ -45,21 +47,8 @@ def _run_main_with_edit_payload(
     file_path: str,
     old_string: str,
     new_string: str,
-    monkeypatch: object,
-    capsys: object,
 ) -> str:
-    """Drive ``main()`` through its stdin entry point for an Edit and return stdout.
-
-    Args:
-        file_path: The on-disk path the Edit targets.
-        old_string: The Edit's ``old_string`` fragment.
-        new_string: The Edit's ``new_string`` fragment.
-        monkeypatch: The pytest fixture used to redirect ``sys.stdin``.
-        capsys: The pytest fixture used to capture the deny payload on stdout.
-
-    Returns:
-        The captured stdout, which holds the deny payload when violations fire.
-    """
+    """Drive ``main()`` through its stdin entry point for an Edit."""
     edit_payload = json.dumps(
         {
             "tool_name": "Edit",
@@ -70,13 +59,10 @@ def _run_main_with_edit_payload(
             },
         }
     )
-    getattr(monkeypatch, "setattr")(code_rules_enforcer.sys, "stdin", io.StringIO(edit_payload))
-    try:
-        code_rules_enforcer.main([])
-    except SystemExit:
-        pass
-    captured = getattr(capsys, "readouterr")()
-    return captured.out
+    captured_stdout, _exit_code = run_serialized_payload_entrypoint(
+        code_rules_enforcer.main, edit_payload
+    )
+    return captured_stdout
 
 
 def test_banned_noun_word_keeps_in_scope_binding_among_untouched_ones() -> None:
@@ -85,8 +71,7 @@ def test_banned_noun_word_keeps_in_scope_binding_among_untouched_ones() -> None:
     binding while leaving the untouched bindings out of scope."""
     leading_count = 5
     leading_bindings = "".join(
-        f"LEADING_{each_index}_RESULT_PATH = {each_index}\n"
-        for each_index in range(leading_count)
+        f"LEADING_{each_index}_RESULT_PATH = {each_index}\n" for each_index in range(leading_count)
     )
     target_before = "PLACEHOLDER_NAME = 0\n"
     target_after = "INTRODUCED_RESULT_PATH = 0\n"
@@ -99,9 +84,9 @@ def test_banned_noun_word_keeps_in_scope_binding_among_untouched_ones() -> None:
         full_file_content=post_edit_full_file,
         prior_full_file_content=prior_full_file,
     )
-    assert any(
-        "INTRODUCED_RESULT_PATH" in each_issue for each_issue in issues
-    ), f"in-scope banned-noun past the cap window must still block, got: {issues!r}"
+    assert any("INTRODUCED_RESULT_PATH" in each_issue for each_issue in issues), (
+        f"in-scope banned-noun past the cap window must still block, got: {issues!r}"
+    )
 
 
 def test_banned_noun_edit_drops_untouched_out_of_scope_binding() -> None:
@@ -122,9 +107,9 @@ def test_banned_noun_edit_drops_untouched_out_of_scope_binding() -> None:
         full_file_content=post_edit_full_file,
         prior_full_file_content=prior_full_file,
     )
-    assert not any(
-        "RESULT_PATH" in each_issue for each_issue in issues
-    ), f"untouched banned-noun bindings must stay out of scope, got: {issues!r}"
+    assert not any("RESULT_PATH" in each_issue for each_issue in issues), (
+        f"untouched banned-noun bindings must stay out of scope, got: {issues!r}"
+    )
 
 
 def test_banned_noun_edit_keeps_touched_binding_in_scope() -> None:
@@ -144,9 +129,9 @@ def test_banned_noun_edit_keeps_touched_binding_in_scope() -> None:
         full_file_content=post_edit_full_file,
         prior_full_file_content=prior_full_file,
     )
-    assert any(
-        "INTRODUCED_RESULT_PATH" in each_issue for each_issue in issues
-    ), f"introduced banned-noun binding must block, got: {issues!r}"
+    assert any("INTRODUCED_RESULT_PATH" in each_issue for each_issue in issues), (
+        f"introduced banned-noun binding must block, got: {issues!r}"
+    )
 
 
 def test_banned_noun_edit_does_not_reflag_param_when_unrelated_body_line_changes() -> None:
@@ -171,9 +156,9 @@ def test_banned_noun_edit_does_not_reflag_param_when_unrelated_body_line_changes
         full_file_content=post_edit_full_file,
         prior_full_file_content=prior_full_file,
     )
-    assert not any(
-        "canned_results" in each_issue for each_issue in issues
-    ), f"pre-existing param must not re-flag on unrelated body edit, got: {issues!r}"
+    assert not any("canned_results" in each_issue for each_issue in issues), (
+        f"pre-existing param must not re-flag on unrelated body edit, got: {issues!r}"
+    )
 
 
 def test_unreadable_prior_yields_no_prior_and_no_reconstruction() -> None:
@@ -191,13 +176,13 @@ def test_unreadable_prior_yields_no_prior_and_no_reconstruction() -> None:
 
 
 def test_edit_with_missing_old_string_runs_whole_file_against_on_disk_content(
-    tmp_path_factory: object, monkeypatch: object, capsys: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """When an Edit's old_string is absent from the file, ``prior_and_post_edit_content``
     yields ``(None, None)``; ``main()`` must analyze the real on-disk file whole-file
     rather than the new_string fragment, so an oversized function elsewhere in the
     file is still reported with its true line numbers."""
-    production_directory = getattr(tmp_path_factory, "mktemp")("production_pkg")
+    production_directory = tmp_path_factory.mktemp("production_pkg")
     untouched_long_function = _oversized_function_source("untouched_long")
     short_helper = "def short_helper() -> int:\n    return 1\n"
     on_disk_content = untouched_long_function + "\n" + short_helper
@@ -206,7 +191,9 @@ def test_edit_with_missing_old_string_runs_whole_file_against_on_disk_content(
     absent_fragment_old = "def absent_function() -> int:\n    return 0\n"
     short_fragment_new = "def absent_function() -> int:\n    return 2\n"
     stdout = _run_main_with_edit_payload(
-        str(source_file), absent_fragment_old, short_fragment_new, monkeypatch, capsys,
+        str(source_file),
+        absent_fragment_old,
+        short_fragment_new,
     )
     assert "untouched_long" in stdout, (
         "an unreconstructable Edit must fall back to whole-file on-disk analysis, "
@@ -215,13 +202,13 @@ def test_edit_with_missing_old_string_runs_whole_file_against_on_disk_content(
 
 
 def test_edit_with_unreadable_file_does_not_analyze_fragment_as_whole_file(
-    tmp_path_factory: object, monkeypatch: object, capsys: object,
+    tmp_path_factory: pytest.TempPathFactory,
 ) -> None:
     """When the on-disk file cannot be read, no well-defined post-edit content
     exists; ``main()`` must exit cleanly rather than analyze the new_string
     fragment as if it were the whole file, so the fragment's own function-length
     violation does not surface as a deny payload."""
-    production_directory = getattr(tmp_path_factory, "mktemp")("production_pkg")
+    production_directory = tmp_path_factory.mktemp("production_pkg")
     missing_path = str(production_directory / "never_created.py")
     oversized_fragment_old = "def grows() -> int:\n    return 0\n"
     oversized_fragment_new = _oversized_function_source("grows")
@@ -229,8 +216,6 @@ def test_edit_with_unreadable_file_does_not_analyze_fragment_as_whole_file(
         missing_path,
         oversized_fragment_old,
         oversized_fragment_new,
-        monkeypatch,
-        capsys,
     )
     assert stdout == "", (
         "an unreadable Edit target has no well-defined whole-file content, so the "

package/hooks/blocking/test_code_rules_enforcer_stage.py

@@ -0,0 +1,192 @@
+"""Test stage ownership for the code-rules enforcer entrypoint."""
+
+from __future__ import annotations
+
+import io
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+_PR_LOOP_SCRIPTS_DIRECTORY = str(
+    Path(__file__).resolve().parents[2] / "_shared" / "pr-loop" / "scripts"
+)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+if _PR_LOOP_SCRIPTS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _PR_LOOP_SCRIPTS_DIRECTORY)
+
+from code_rules_enforcer import (  # noqa: E402
+    _fragment_or_deferred_check,
+    main,
+    validate_content,
+)
+from code_rules_gate_parts import gate_running  # noqa: E402
+from code_rules_gate_parts.tests._repo_test_helpers import (  # noqa: E402
+    init_repository,
+    write_commit_and_stage_change,
+)
+
+
+PRODUCTION_FILE_PATH = "packages/app/services.py"
+ENFORCER_SCRIPT_PATH = Path(__file__).with_name("code_rules_enforcer.py")
+
+
+def _write_payload(file_path: str, source: str) -> str:
+    return json.dumps(
+        {
+            "tool_name": "Write",
+            "tool_input": {"file_path": file_path, "content": source},
+        }
+    )
+
+
+def _run_write_stage(
+    file_path: str,
+    source: str,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> str:
+    payload = _write_payload(file_path, source)
+    monkeypatch.setattr(sys, "stdin", io.StringIO(payload))
+    try:
+        main([])
+    except SystemExit:
+        pass
+    return capsys.readouterr().out
+def _run_precheck_stage(candidate_path: Path, target_path: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [
+            sys.executable,
+            str(ENFORCER_SCRIPT_PATH),
+            "--check",
+            str(candidate_path),
+            "--as",
+            target_path,
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+def test_edit_stage_baselines_the_new_fragment_against_the_old_fragment() -> None:
+    all_seen_contents: list[str] = []
+
+    def record_check(content: str, file_path: str) -> list[str]:
+        all_seen_contents.append(content)
+        if "introduced" in content:
+            return [f"finding in {file_path}"]
+        return []
+
+    all_issues = _fragment_or_deferred_check(
+        record_check,
+        "existing fragment",
+        "introduced fragment",
+        PRODUCTION_FILE_PATH,
+        defer_scope_to_caller=False,
+    )
+
+    assert all_seen_contents == ["introduced fragment", "existing fragment"]
+    assert all_issues == [f"finding in {PRODUCTION_FILE_PATH}"]
+
+
+def test_commit_stage_owns_scope_and_scans_the_complete_candidate_once() -> None:
+    all_seen_contents: list[str] = []
+
+    def record_check(content: str, file_path: str) -> list[str]:
+        all_seen_contents.append(content)
+        return [f"finding in {file_path}"]
+
+    all_issues = _fragment_or_deferred_check(
+        record_check,
+        "HEAD content",
+        "staged candidate",
+        PRODUCTION_FILE_PATH,
+        defer_scope_to_caller=True,
+    )
+
+    assert all_seen_contents == ["staged candidate"]
+    assert all_issues == [f"finding in {PRODUCTION_FILE_PATH}"]
+
+
+def test_write_stage_runs_the_real_entrypoint_and_reports_a_deny_payload(
+    tmp_path_factory: pytest.TempPathFactory,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    staging_directory = tmp_path_factory.mktemp("stage")
+    target_path = str(staging_directory / "service.py")
+    source = "def process_data() -> None:\n    print('payload')\n"
+
+    captured_stdout = _run_write_stage(target_path, source, monkeypatch, capsys)
+
+    deny_payload = json.loads(captured_stdout)
+    deny_reason = deny_payload["hookSpecificOutput"]["permissionDecisionReason"]
+    assert deny_payload["hookSpecificOutput"]["permissionDecision"] == "deny"
+    assert "process_data" in deny_reason
+
+
+def test_write_stage_allows_a_clean_candidate_through_the_real_entrypoint(
+    tmp_path_factory: pytest.TempPathFactory,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    staging_directory = tmp_path_factory.mktemp("stage")
+    target_path = str(staging_directory / "service.py")
+    source = "def calculate_total() -> int:\n    return 0\n"
+
+    captured_stdout = _run_write_stage(target_path, source, monkeypatch, capsys)
+
+    assert captured_stdout == ""
+
+
+def test_precheck_stage_runs_the_cli_and_uses_the_declared_target_path(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> None:
+    staging_directory = tmp_path_factory.mktemp("stage")
+    candidate_path = staging_directory / "candidate.py"
+    candidate_path.write_text(
+        "def process_data() -> None:\n    print('payload')\n",
+        encoding="utf-8",
+    )
+    target_path = str(staging_directory / "service.py")
+
+    completed_process = _run_precheck_stage(candidate_path, target_path)
+
+    assert completed_process.returncode == 1
+    assert "process_data" in completed_process.stdout
+def test_gate_caller_scans_staged_content_with_commit_stage_scope(
+    tmp_path: Path,
+) -> None:
+    repository_root = tmp_path / "repository"
+    repository_root.mkdir()
+    init_repository(repository_root)
+    committed_source = "def calculate_total() -> int:\n    return 0\n"
+    staged_source = (
+        "def calculate_total() -> int:\n"
+        "    total = 9999\n"
+        "    return total\n"
+    )
+    file_path = write_commit_and_stage_change(
+        repository_root,
+        "service.py",
+        committed_source,
+        staged_source,
+    )
+
+    all_partitioned_violations = gate_running._scoped_violations_for_file(
+        validate_content=validate_content,
+        resolved_path=file_path,
+        repository_root=repository_root,
+        all_added_lines_for_file={2, 3},
+        should_read_staged_content=True,
+    )
+
+    assert all_partitioned_violations is not None
+    all_blocking_violations, _all_advisory_violations = all_partitioned_violations
+    assert any("9999" in each_issue for each_issue in all_blocking_violations)

package/hooks/blocking/test_code_rules_enforcer_zero_payload_alias_hook_routing.py

@@ -14,16 +14,12 @@ the target path the same way it would for the real directory.
 
 from __future__ import annotations
 
-import contextlib
-import io
 import json
 import pathlib
 import shutil
-import subprocess
 import sys
 import tempfile
 from collections.abc import Iterator
-from types import SimpleNamespace
 
 import pytest
 
@@ -35,10 +31,10 @@ if str(_HOOKS_PARENT) not in sys.path:
     sys.path.insert(0, str(_HOOKS_PARENT))
 
 from code_rules_enforcer import main  # noqa: E402
-
-code_rules_enforcer = SimpleNamespace(main=main, sys=sys)
-
-_ENFORCER_SCRIPT_PATH = _HOOK_DIRECTORY / "code_rules_enforcer.py"
+from code_rules_enforcer_test_support import (  # noqa: E402
+    run_precheck,
+    run_write_entrypoint,
+)
 
 PASS_THROUGH_ALIAS_SOURCE = (
     "def find_bare_path_segments(content: str) -> set[str]:\n"
@@ -62,39 +58,8 @@ def hook_blocking_dir() -> Iterator[pathlib.Path]:
         shutil.rmtree(base_directory, ignore_errors=False)
 
 
-def _run_main_with_write_payload(
-    file_path: str,
-    content: str,
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-) -> str:
-    """Drive ``main()`` through its stdin entry point for a Write and return stdout.
-
-    Args:
-        file_path: The on-disk path the Write targets.
-        content: The whole-file body the Write would create.
-        monkeypatch: The fixture used to redirect ``sys.stdin``.
-        capsys: The fixture used to capture the deny payload on stdout.
-
-    Returns:
-        The captured stdout, which holds the deny payload when violations fire.
-    """
-    write_payload = json.dumps(
-        {
-            "tool_name": "Write",
-            "tool_input": {"file_path": file_path, "content": content},
-        }
-    )
-    monkeypatch.setattr(code_rules_enforcer.sys, "stdin", io.StringIO(write_payload))
-    with contextlib.suppress(SystemExit):
-        code_rules_enforcer.main([])
-    return capsys.readouterr().out
-
-
 def test_write_of_pass_through_alias_into_hook_directory_denies(
     hook_blocking_dir: pathlib.Path,
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
 ) -> None:
     """A Write that introduces a pass-through alias into a hook file is denied.
 
@@ -103,14 +68,16 @@ def test_write_of_pass_through_alias_into_hook_directory_denies(
     directory its docstring names as the motivating case — at the PreToolUse Write
     point, not only through ``validate_content``."""
     new_file = hook_blocking_dir / "new_blocker.py"
-    stdout = _run_main_with_write_payload(
-        str(new_file), PASS_THROUGH_ALIAS_SOURCE, monkeypatch, capsys
+    captured_stdout, _exit_code = run_write_entrypoint(
+        main,
+        str(new_file),
+        PASS_THROUGH_ALIAS_SOURCE,
     )
-    assert stdout != "", (
+    assert captured_stdout != "", (
         "A pass-through alias written into a hook-infrastructure file must produce "
         "a deny payload, got empty stdout"
     )
-    deny_payload = json.loads(stdout)
+    deny_payload = json.loads(captured_stdout)
     decision = deny_payload["hookSpecificOutput"]["permissionDecision"]
     reason = deny_payload["hookSpecificOutput"]["permissionDecisionReason"]
     assert decision == "deny", f"expected deny, got: {decision!r}"
@@ -121,31 +88,18 @@ def test_write_of_pass_through_alias_into_hook_directory_denies(
 
 def test_precheck_of_pass_through_alias_at_hook_target_exits_nonzero(
     hook_blocking_dir: pathlib.Path,
-    tmp_path_factory: pytest.TempPathFactory,
+    tmp_path: pathlib.Path,
 ) -> None:
     """The pre-check CLI flags a pass-through alias judged at a hook-infrastructure target.
 
     Driving the real ``--check`` argv path proves the gate's pre-check mode also
     routes a hook ``.py`` target through the zero-payload-alias check rather than
     exiting clean on the blanket hook-infrastructure exemption."""
-    staging_directory = tmp_path_factory.mktemp("staging")
+    staging_directory = tmp_path
     candidate_file = staging_directory / "candidate.py"
     candidate_file.write_text(PASS_THROUGH_ALIAS_SOURCE, encoding="utf-8")
     target_path = str(hook_blocking_dir / "new_blocker.py")
-    completed = subprocess.run(
-        [
-            sys.executable,
-            str(_ENFORCER_SCRIPT_PATH),
-            "--check",
-            str(candidate_file),
-            "--as",
-            target_path,
-        ],
-        input="",
-        capture_output=True,
-        text=True,
-        check=False,
-    )
+    completed = run_precheck(candidate_file, target_path, None)
     assert completed.returncode == 1, (
         "a pass-through alias at a hook target must exit nonzero, got: "
         f"{completed.returncode}, stdout: {completed.stdout!r}, "

package/hooks/blocking/test_destructive_command_blocker_deny_mode.py

@@ -9,37 +9,54 @@ a ``deny`` so the sandbox can be contained.
 from __future__ import annotations
 
 import json
-import os
 import subprocess
 import sys
 from pathlib import Path
 
-SCRIPT_PATH = Path(__file__).parent / "destructive_command_blocker.py"
-DENY_MODE_ENV_VAR = "CLAUDE_DESTRUCTIVE_DENY_MODE"
-
-
-def _run_hook_with_environment(command: str, extra_environment: dict[str, str]) -> dict:
-    child_environment = os.environ.copy()
-    child_environment.pop(DENY_MODE_ENV_VAR, None)
-    child_environment.update(extra_environment)
-    completed_process = subprocess.run(
-        [sys.executable, str(SCRIPT_PATH)],
-        input=json.dumps({"tool_name": "Bash", "tool_input": {"command": command}}),
-        text=True,
-        capture_output=True,
-        check=False,
-        env=child_environment,
+_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
+if str(_BLOCKING_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_BLOCKING_DIRECTORY))
+
+SCRIPT_PATH = _BLOCKING_DIRECTORY / "destructive_command_blocker.py"
+
+import _path_setup  # noqa: E402, F401
+
+from test_hook_subprocess_support import (  # noqa: E402
+    build_bash_payload,
+    run_hook_as_subprocess,
+)
+
+
+def _run_hook_with_environment(
+    command: str,
+    environment_update_by_name: dict[str, str],
+    temporary_home_directory: Path,
+) -> subprocess.CompletedProcess[str]:
+    return run_hook_as_subprocess(
+        hook_script_path=SCRIPT_PATH,
+        payload_text=build_bash_payload(command),
+        working_directory=temporary_home_directory,
+        home_directory=temporary_home_directory,
+        all_environment_names_to_remove=("CLAUDE_DESTRUCTIVE_DENY_MODE",),
+        environment_updates_by_name=environment_update_by_name,
+    )
+
+
+def test_rm_rf_denies_when_deny_mode_env_is_set(tmp_path: Path) -> None:
+    completed_hook = _run_hook_with_environment(
+        "rm -rf /var/log/myapp",
+        {"CLAUDE_DESTRUCTIVE_DENY_MODE": "1"},
+        tmp_path,
     )
-    return json.loads(completed_process.stdout)
+    hook_decision_by_field = json.loads(completed_hook.stdout)
 
+    assert hook_decision_by_field["hookSpecificOutput"]["permissionDecision"] == "deny"
+    assert "rm -rf" in hook_decision_by_field["hookSpecificOutput"]["permissionDecisionReason"]
 
-def test_rm_rf_denies_when_deny_mode_env_is_set() -> None:
-    response = _run_hook_with_environment("rm -rf /var/log/myapp", {DENY_MODE_ENV_VAR: "1"})
-    assert response["hookSpecificOutput"]["permissionDecision"] == "deny"
-    assert "rm -rf" in response["hookSpecificOutput"]["permissionDecisionReason"]
 
+def test_rm_rf_asks_when_deny_mode_env_is_absent(tmp_path: Path) -> None:
+    completed_hook = _run_hook_with_environment("rm -rf /var/log/myapp", {}, tmp_path)
+    hook_decision_by_field = json.loads(completed_hook.stdout)
 
-def test_rm_rf_asks_when_deny_mode_env_is_absent() -> None:
-    response = _run_hook_with_environment("rm -rf /var/log/myapp", {})
-    assert response["hookSpecificOutput"]["permissionDecision"] == "ask"
-    assert "rm -rf" in response["hookSpecificOutput"]["permissionDecisionReason"]
+    assert hook_decision_by_field["hookSpecificOutput"]["permissionDecision"] == "ask"
+    assert "rm -rf" in hook_decision_by_field["hookSpecificOutput"]["permissionDecisionReason"]