claude-dev-env 1.82.0 → 1.84.0

package/hooks/blocking/test_code_rules_magic_values.py

@@ -0,0 +1,54 @@
+"""Behavior tests for the code_rules_magic_values check module.
+
+A diagram-first docstring may carry a bare number on an illustrative row
+(``at line 2``). That number is prose, not a code literal, so the magic-value
+check skips docstring rows while still flagging a real magic number in an
+actual code statement.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+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)
+
+from code_rules_magic_values import check_magic_values  # noqa: E402
+
+PRODUCTION_FILE_PATH = "packages/app/rendering.py"
+
+
+def test_magic_value_check_skips_bare_number_inside_docstring_illustration() -> None:
+    source = (
+        "def summarize(record):\n"
+        '    """Summarize how a run ended.\n'
+        "\n"
+        "    A finished run shows a clean outcome::\n"
+        "\n"
+        "        marked in-flight at row 2\n"
+        '    """\n'
+        "    return record\n"
+    )
+    issues = check_magic_values(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Expected no magic-value issue on an illustrative row, got: {issues}"
+
+
+def test_magic_value_check_still_flags_real_magic_number_in_code_statement() -> None:
+    source = (
+        "def summarize(record):\n"
+        '    """Summarize how a run ended.\n'
+        "\n"
+        "        marked in-flight at row 2\n"
+        '    """\n'
+        "    threshold = record.score * 42\n"
+        "    return threshold\n"
+    )
+    issues = check_magic_values(source, PRODUCTION_FILE_PATH)
+    assert any(issue.endswith("Magic value 42 - extract to named constant") for issue in issues), (
+        f"Expected the real magic number 42 to stay flagged, got: {issues}"
+    )

package/hooks/blocking/test_duplicate_rmtree_helper_blocker.py

@@ -142,12 +142,6 @@ def test_path_exempts_existing_session_env_cleanup_definition_site() -> None:
     assert path_is_exempt("packages/claude-dev-env/hooks/session/session_env_cleanup.py")
 
 
-def test_path_exempts_existing_md_to_html_test_support_definition_site() -> None:
-    assert path_is_exempt(
-        "packages/claude-dev-env/hooks/blocking/_md_to_html_blocker_test_support.py"
-    )
-
-
 def test_path_exempts_existing_teardown_worktrees_definition_site() -> None:
     assert path_is_exempt(
         "packages/claude-dev-env/skills/_shared/pr-loop/scripts/teardown_worktrees.py"

package/hooks/blocking/test_pr_converge_bugteam_enforcer_state_tolerance.py

@@ -0,0 +1,184 @@
+"""Unit tests: persistent-agent state keys leave both pr-converge hooks unchanged.
+
+pr-converge-state.json carries `agents_session_id` and `persistent_agents`
+(the persistent per-step agent map with a `fix_executor` entry). Neither the
+enforcer (`pr_converge_bugteam_enforcer`) nor the tracker
+(`pr_converge_bugteam_skill_tracker`) reads these keys, so their allow/block
+decisions and stamped fields match a state file without them, and the tracker
+preserves the keys unchanged on its stamp write.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import io
+import json
+import pathlib
+import sys
+from types import ModuleType
+from typing import Any
+from unittest import mock
+
+import pytest
+
+_BLOCKING_DIR = pathlib.Path(__file__).parent
+_HOOKS_TREE = _BLOCKING_DIR.parent
+_LIFECYCLE_DIR = _HOOKS_TREE / "lifecycle"
+for each_path in (str(_BLOCKING_DIR), str(_HOOKS_TREE)):
+    if each_path not in sys.path:
+        sys.path.insert(0, each_path)
+
+
+def _load_hook_module(module_name: str, module_path: pathlib.Path) -> ModuleType:
+    hook_spec = importlib.util.spec_from_file_location(module_name, module_path)
+    assert hook_spec is not None
+    assert hook_spec.loader is not None
+    loaded_module = importlib.util.module_from_spec(hook_spec)
+    hook_spec.loader.exec_module(loaded_module)
+    return loaded_module
+
+
+enforcer_module = _load_hook_module(
+    "pr_converge_bugteam_enforcer_state_tolerance_target",
+    _BLOCKING_DIR / "pr_converge_bugteam_enforcer.py",
+)
+tracker_module = _load_hook_module(
+    "pr_converge_bugteam_skill_tracker_state_tolerance_target",
+    _LIFECYCLE_DIR / "pr_converge_bugteam_skill_tracker.py",
+)
+
+from hooks_constants.pr_converge_bugteam_enforcer_constants import (
+    BUGTEAM_PHASE,
+    CLAUDE_JOB_DIR_ENV_VAR,
+    PR_CONVERGE_STATE_FILENAME,
+)
+
+_HEAD_SHA_CURRENT = "abc123def456abc123def456abc123def456abcd"
+_TICK_CURRENT = 7
+_AUDIT_PROMPT = "Run the bugteam audit and report findings against the A-J categories."
+_AGENTS_SESSION_ID = "session-0123456789abcdef"
+_FIX_EXECUTOR_AGENT_ID = "prc-fix-42"
+
+
+def _persistent_agent_state_keys() -> dict[str, Any]:
+    return {
+        "agents_session_id": _AGENTS_SESSION_ID,
+        "persistent_agents": {
+            "fix_executor": {
+                "agent_id": _FIX_EXECUTOR_AGENT_ID,
+                "created_tick": 2,
+                "last_used_tick": 6,
+            }
+        },
+    }
+
+
+def _bugteam_phase_state(**overrides: Any) -> dict[str, Any]:
+    baseline_state: dict[str, Any] = {
+        "phase": BUGTEAM_PHASE,
+        "current_head": _HEAD_SHA_CURRENT,
+        "tick_count": _TICK_CURRENT,
+        "bugteam_skill_invoked_at_head": None,
+        "bugteam_skill_invoked_at_tick": None,
+    }
+    baseline_state.update(_persistent_agent_state_keys())
+    baseline_state.update(overrides)
+    return baseline_state
+
+
+def _write_state(state_directory: pathlib.Path, state: dict[str, Any]) -> pathlib.Path:
+    state_path = state_directory / PR_CONVERGE_STATE_FILENAME
+    state_path.write_text(json.dumps(state), encoding="utf-8")
+    return state_path
+
+
+def _read_state(state_directory: pathlib.Path) -> dict[str, Any]:
+    state_path = state_directory / PR_CONVERGE_STATE_FILENAME
+    return json.loads(state_path.read_text(encoding="utf-8"))
+
+
+def _clean_coder_audit_payload() -> dict[str, Any]:
+    return {
+        "tool_name": "Agent",
+        "tool_input": {
+            "subagent_type": "clean-coder",
+            "prompt": _AUDIT_PROMPT,
+            "description": "Audit the PR",
+        },
+    }
+
+
+def _bugteam_skill_payload() -> dict[str, Any]:
+    return {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam", "args": "https://github.com/o/r/pull/1"},
+    }
+
+
+def _run_enforcer_main_with_io(input_text: str) -> str:
+    with mock.patch("sys.stdin", io.StringIO(input_text)):
+        with mock.patch("sys.stdout", new_callable=io.StringIO) as captured_stdout:
+            try:
+                enforcer_module.main()
+            except SystemExit:
+                pass
+            return captured_stdout.getvalue()
+
+
+def _run_tracker_main_with_io(input_text: str) -> None:
+    with mock.patch("sys.stdin", io.StringIO(input_text)):
+        with mock.patch("sys.stdout", new_callable=io.StringIO):
+            with mock.patch("sys.stderr", new_callable=io.StringIO):
+                try:
+                    tracker_module.main()
+                except SystemExit:
+                    pass
+
+
+@pytest.fixture()
+def claude_job_directory(tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch) -> pathlib.Path:
+    monkeypatch.setenv(CLAUDE_JOB_DIR_ENV_VAR, str(tmp_path))
+    return tmp_path
+
+
+def test_should_block_enforcer_when_persistent_agent_keys_present_without_skill(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(claude_job_directory, _bugteam_phase_state())
+    captured_output = _run_enforcer_main_with_io(json.dumps(_clean_coder_audit_payload()))
+    deny_payload = json.loads(captured_output)
+    assert deny_payload["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_should_allow_enforcer_when_persistent_agent_keys_present_with_skill_recorded(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(
+        claude_job_directory,
+        _bugteam_phase_state(
+            bugteam_skill_invoked_at_head=_HEAD_SHA_CURRENT,
+            bugteam_skill_invoked_at_tick=_TICK_CURRENT,
+        ),
+    )
+    captured_output = _run_enforcer_main_with_io(json.dumps(_clean_coder_audit_payload()))
+    assert captured_output == ""
+
+
+def test_should_stamp_tracker_fields_when_persistent_agent_keys_present(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(claude_job_directory, _bugteam_phase_state())
+    _run_tracker_main_with_io(json.dumps(_bugteam_skill_payload()))
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["bugteam_skill_invoked_at_head"] == _HEAD_SHA_CURRENT
+    assert updated_state["bugteam_skill_invoked_at_tick"] == _TICK_CURRENT
+
+
+def test_should_preserve_persistent_agent_keys_on_tracker_stamp_write(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(claude_job_directory, _bugteam_phase_state())
+    _run_tracker_main_with_io(json.dumps(_bugteam_skill_payload()))
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["agents_session_id"] == _AGENTS_SESSION_ID
+    assert updated_state["persistent_agents"] == _persistent_agent_state_keys()["persistent_agents"]

package/hooks/blocking/test_pre_tool_use_dispatcher.py

@@ -638,10 +638,16 @@ def test_dispatcher_write_applies_both_groups() -> None:
 
 
 def test_dispatcher_edit_applies_both_groups() -> None:
-    """Edit tool triggers both Group A and Group B hooks through the dispatcher."""
+    """Edit triggers Group A, Group B, and the Edit-scoped entry through the
+    dispatcher.
+    """
     all_edit_entries = _applicable_entries_for_tool(EDIT_TOOL_NAME)
-    assert len(all_edit_entries) == 19, (
-        f"Edit tool must apply to all 19 hosted hooks, got {len(all_edit_entries)}"
+    all_edit_script_paths = {each_entry.script_relative_path for each_entry in all_edit_entries}
+    assert "blocking/stale_comment_reference_blocker.py" in all_edit_script_paths, (
+        "stale_comment_reference_blocker belongs in the Edit applicable set"
+    )
+    assert len(all_edit_entries) == 20, (
+        f"expected 20 Edit entries, got {len(all_edit_entries)}"
     )
 
 

package/hooks/blocking/test_reviewer_spawn_gate.py

@@ -0,0 +1,230 @@
+"""Unit tests for reviewer_spawn_gate PreToolUse hook."""
+
+import importlib.util
+import io
+import json
+import pathlib
+import sys
+from contextlib import redirect_stderr, redirect_stdout
+
+import pytest
+
+_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(
+    "reviewer_spawn_gate",
+    _HOOK_DIR / "reviewer_spawn_gate.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)
+
+_matches_copilot_trigger = hook_module._matches_copilot_trigger
+_matches_bugbot_trigger = hook_module._matches_bugbot_trigger
+_reviewer_trigger = hook_module._reviewer_trigger
+
+_SENTINEL_MARKER = hook_module.GATE_SENTINEL_MARKER
+_AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME = hook_module.AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME
+
+_COPILOT_TRIGGER_COMMAND = (
+    f"{_SENTINEL_MARKER} gh api repos/o/r/pulls/1/requested_reviewers "
+    f'-f "reviewers[]=copilot-pull-request-reviewer[bot]"'
+)
+_BUGBOT_TRIGGER_COMMAND = f'{_SENTINEL_MARKER} python post_fix_reply.py --body "bugbot run"'
+
+
+def _write_fake_availability_script(tmp_path: pathlib.Path, exit_code: int) -> pathlib.Path:
+    fake_script_path = tmp_path / "fake_reviewer_availability.py"
+    fake_script_path.write_text(f"import sys\nsys.exit({exit_code})\n", encoding="utf-8")
+    return fake_script_path
+
+
+def _run_hook_with_stdin_text(stdin_text: str) -> tuple[str, str, int]:
+    captured_stdout = io.StringIO()
+    captured_stderr = io.StringIO()
+    exit_code = 0
+    sys.stdin = io.StringIO(stdin_text)
+    try:
+        with redirect_stdout(captured_stdout), redirect_stderr(captured_stderr):
+            try:
+                hook_module.main()
+            except SystemExit as exit_signal:
+                exit_code = exit_signal.code if isinstance(exit_signal.code, int) else 0
+    finally:
+        sys.stdin = sys.__stdin__
+    return captured_stdout.getvalue(), captured_stderr.getvalue(), exit_code
+
+
+def _run_hook(hook_input: dict) -> tuple[str, int]:
+    stdout_text, _stderr_text, exit_code = _run_hook_with_stdin_text(json.dumps(hook_input))
+    return stdout_text, exit_code
+
+
+def test_matches_copilot_trigger_true_for_request_reviewers_command() -> None:
+    assert _matches_copilot_trigger(_COPILOT_TRIGGER_COMMAND)
+
+
+def test_matches_copilot_trigger_false_for_unrelated_command() -> None:
+    assert not _matches_copilot_trigger("gh pr list")
+
+
+def test_matches_bugbot_trigger_true_for_rerun_comment_command() -> None:
+    assert _matches_bugbot_trigger(_BUGBOT_TRIGGER_COMMAND)
+
+
+def test_matches_bugbot_trigger_false_for_unrelated_command() -> None:
+    assert not _matches_bugbot_trigger("python post_fix_reply.py --body 'looks good'")
+
+
+def test_reviewer_trigger_returns_none_for_unrecognized_command() -> None:
+    assert _reviewer_trigger("gh pr list") is None
+
+
+def test_main_allows_copilot_shaped_command_with_no_sentinel_marker(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_script_path = _write_fake_availability_script(tmp_path, exit_code=3)
+    monkeypatch.setenv(_AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME, str(fake_script_path))
+    stdout_text, exit_code = _run_hook(
+        {
+            "tool_name": "Bash",
+            "tool_input": {
+                "command": (
+                    "gh api repos/o/r/pulls/1/requested_reviewers "
+                    '-f "reviewers[]=copilot-pull-request-reviewer[bot]"'
+                )
+            },
+        }
+    )
+    assert exit_code == 0
+    assert stdout_text == ""
+
+
+def test_main_allows_copilot_trigger_when_available(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_script_path = _write_fake_availability_script(tmp_path, exit_code=0)
+    monkeypatch.setenv(_AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME, str(fake_script_path))
+    stdout_text, exit_code = _run_hook(
+        {"tool_name": "Bash", "tool_input": {"command": _COPILOT_TRIGGER_COMMAND}}
+    )
+    assert exit_code == 0
+    assert stdout_text == ""
+
+
+def test_main_denies_copilot_trigger_when_down(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_script_path = _write_fake_availability_script(tmp_path, exit_code=3)
+    monkeypatch.setenv(_AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME, str(fake_script_path))
+    stdout_text, exit_code = _run_hook(
+        {"tool_name": "Bash", "tool_input": {"command": _COPILOT_TRIGGER_COMMAND}}
+    )
+    assert exit_code == 0
+    response_payload = json.loads(stdout_text)
+    decision_block = response_payload["hookSpecificOutput"]
+    assert decision_block["permissionDecision"] == "deny"
+    assert "GitHub Copilot" in decision_block["permissionDecisionReason"]
+
+
+def test_main_allows_copilot_trigger_on_unexpected_exit_code(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_script_path = _write_fake_availability_script(tmp_path, exit_code=2)
+    monkeypatch.setenv(_AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME, str(fake_script_path))
+    stdout_text, exit_code = _run_hook(
+        {"tool_name": "Bash", "tool_input": {"command": _COPILOT_TRIGGER_COMMAND}}
+    )
+    assert exit_code == 0
+    assert stdout_text == ""
+
+
+def test_main_allows_copilot_trigger_when_availability_script_crashes(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_script_path = tmp_path / "fake_reviewer_availability.py"
+    fake_script_path.write_text(
+        "import module_that_does_not_exist_anywhere\n", encoding="utf-8"
+    )
+    monkeypatch.setenv(_AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME, str(fake_script_path))
+    stdout_text, exit_code = _run_hook(
+        {"tool_name": "Bash", "tool_input": {"command": _COPILOT_TRIGGER_COMMAND}}
+    )
+    assert exit_code == 0
+    assert stdout_text == ""
+
+
+def test_main_allows_bugbot_trigger_when_available(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_script_path = _write_fake_availability_script(tmp_path, exit_code=0)
+    monkeypatch.setenv(_AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME, str(fake_script_path))
+    stdout_text, exit_code = _run_hook(
+        {"tool_name": "Bash", "tool_input": {"command": _BUGBOT_TRIGGER_COMMAND}}
+    )
+    assert exit_code == 0
+    assert stdout_text == ""
+
+
+def test_main_denies_bugbot_trigger_when_opted_out(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_script_path = _write_fake_availability_script(tmp_path, exit_code=3)
+    monkeypatch.setenv(_AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME, str(fake_script_path))
+    stdout_text, exit_code = _run_hook(
+        {"tool_name": "Bash", "tool_input": {"command": _BUGBOT_TRIGGER_COMMAND}}
+    )
+    assert exit_code == 0
+    response_payload = json.loads(stdout_text)
+    decision_block = response_payload["hookSpecificOutput"]
+    assert decision_block["permissionDecision"] == "deny"
+    assert "Cursor Bugbot" in decision_block["permissionDecisionReason"]
+
+
+def test_main_allows_marker_command_with_no_recognized_trigger(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    fake_script_path = _write_fake_availability_script(tmp_path, exit_code=3)
+    monkeypatch.setenv(_AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME, str(fake_script_path))
+    stdout_text, exit_code = _run_hook(
+        {"tool_name": "Bash", "tool_input": {"command": f"{_SENTINEL_MARKER} gh pr list"}}
+    )
+    assert exit_code == 0
+    assert stdout_text == ""
+
+
+def test_main_allows_when_availability_script_missing(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    missing_script_path = tmp_path / "does_not_exist.py"
+    monkeypatch.setenv(_AVAILABILITY_SCRIPT_PATH_ENV_VAR_NAME, str(missing_script_path))
+    stdout_text, exit_code = _run_hook(
+        {"tool_name": "Bash", "tool_input": {"command": _COPILOT_TRIGGER_COMMAND}}
+    )
+    assert exit_code == 0
+    assert stdout_text == ""
+
+
+def test_main_allows_non_bash_tool() -> None:
+    stdout_text, exit_code = _run_hook(
+        {"tool_name": "Write", "tool_input": {"content": _COPILOT_TRIGGER_COMMAND}}
+    )
+    assert exit_code == 0
+    assert stdout_text == ""
+
+
+def test_main_with_empty_stdin_exits_silently() -> None:
+    stdout_text, stderr_text, exit_code = _run_hook_with_stdin_text("")
+    assert exit_code == 0
+    assert stdout_text == ""
+    assert stderr_text == ""
+
+
+def test_main_with_invalid_json_stdin_exits_silently() -> None:
+    stdout_text, stderr_text, exit_code = _run_hook_with_stdin_text("{broken")
+    assert exit_code == 0
+    assert stdout_text == ""
+    assert stderr_text == ""

package/hooks/blocking/test_shared_stdin_adoption.py

@@ -10,11 +10,11 @@ each real hook script through its production ``__main__`` stdin path over a
 corpus that pins those fail-soft edges plus a representative allow payload, so a
 conversion that changes any decision is caught.
 
-The deterministic deny payloads for the two Write/Edit blockers whose triggers
-need no filesystem or state setup (``md_to_html_blocker``,
-``open_questions_in_plans_blocker``) are exercised here too; each remaining
-hook's full deny coverage stays in its own suite, which also drives the real
-``main()`` and so re-proves the decision after the parser swap.
+The deterministic deny payload for the Write/Edit blocker whose trigger
+needs no filesystem or state setup (``open_questions_in_plans_blocker``) is
+exercised here too; each remaining hook's full deny coverage stays in its own
+suite, which also drives the real ``main()`` and so re-proves the decision
+after the parser swap.
 """
 
 import json
@@ -28,7 +28,6 @@ import pytest
 _BLOCKING_DIRECTORY = Path(__file__).resolve().parent
 
 ALL_CONVERTED_HOOK_FILENAMES = (
-    "md_to_html_blocker.py",
     "open_questions_in_plans_blocker.py",
     "claude_md_orphan_file_blocker.py",
     "pr_converge_bugteam_enforcer.py",
@@ -83,30 +82,6 @@ def test_fail_soft_payload_exits_zero_with_no_decision(hook_filename: str, stdin
     )
 
 
-def test_md_to_html_blocker_still_denies_relative_markdown_write() -> None:
-    payload = json.dumps(
-        {
-            "tool_name": "Write",
-            "tool_input": {"file_path": "notes/topic.md", "content": "# Topic"},
-        }
-    )
-    completed = _run_hook_script("md_to_html_blocker.py", payload)
-    assert completed.returncode == 0
-    assert _decision_from_stdout(completed) == "deny"
-
-
-def test_md_to_html_blocker_still_allows_non_markdown_write() -> None:
-    payload = json.dumps(
-        {
-            "tool_name": "Write",
-            "tool_input": {"file_path": "notes/topic.txt", "content": "plain"},
-        }
-    )
-    completed = _run_hook_script("md_to_html_blocker.py", payload)
-    assert completed.returncode == 0
-    assert _decision_from_stdout(completed) is None
-
-
 def test_open_questions_blocker_still_denies_plan_with_open_questions(
     tmp_path: Path,
 ) -> None: