claude-dev-env 8.2.0 → 8.3.0

package/hooks/advisory/test_msys_path_conversion_advisor.py

@@ -1,223 +0,0 @@
-"""Behavior tests for the MSYS path-conversion advisory hook.
-
-The hook is a PostToolUse observer on Bash. It never blocks. These tests pin
-which failed git call wakes it, which lookalike failures stay quiet, and what
-the advisory text says.
-"""
-
-from __future__ import annotations
-
-import io
-import json
-import sys
-from pathlib import Path
-
-import pytest
-
-try:
-    advisory_directory = str(Path(__file__).resolve().parent)
-    if advisory_directory not in sys.path:
-        sys.path.insert(0, advisory_directory)
-    import msys_path_conversion_advisor
-except ImportError as import_error:
-    raise ImportError(
-        "test_msys_path_conversion_advisor: cannot import its sibling modules; "
-        "ensure the advisory directory is importable."
-    ) from import_error
-
-
-_MANGLED_ARGUMENT = r"origin\main;.claude\skills\x\test_run_evals.py"
-_MANGLED_FAILURE_RESPONSE = (
-    "Error: Exit code 128\n"
-    r"fatal: ambiguous argument 'origin\main;.claude\skills\x\test_run_evals.py': "
-    "unknown revision or path not in the working tree."
-)
-_MISSING_REVISION_RESPONSE = (
-    "Error: Exit code 128\n"
-    "fatal: ambiguous argument 'origin/nope:packages/app/main.py': "
-    "unknown revision or path not in the working tree."
-)
-_MANGLED_OBJECT_NAME_RESPONSE = (
-    "Error: Exit code 128\n" + r"fatal: invalid object name 'origin\main;C'."
-)
-_MISSING_OBJECT_NAME_RESPONSE = (
-    "Error: Exit code 128\nfatal: invalid object name 'nosuchbranch'."
-)
-_SHOW_COMMAND = "git show origin/main:.claude/skills/x/test_run_evals.py"
-_ABSOLUTE_PATH_SHOW_COMMAND = "git show origin/main:/nope"
-_MISSING_OBJECT_SHOW_COMMAND = "git show nosuchbranch:AGENTS.md"
-_EXPORT_LINE = "export MSYS_NO_PATHCONV=1 MSYS2_ARG_CONV_EXCL='*'"
-
-
-def _payload(command: str, tool_response: object) -> str:
-    return json.dumps(
-        {
-            "session_id": "msys-session",
-            "cwd": "C:/repo",
-            "tool_name": "Bash",
-            "tool_input": {"command": command},
-            "tool_response": tool_response,
-        }
-    )
-
-
-def _run_main(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-    payload_text: str,
-) -> str:
-    monkeypatch.setattr(sys, "stdin", io.StringIO(payload_text))
-    msys_path_conversion_advisor.main()
-    return capsys.readouterr().out
-
-
-def test_should_return_the_mangled_argument_word_for_word() -> None:
-    mangled_argument = msys_path_conversion_advisor.mangled_revision_path_argument(
-        _SHOW_COMMAND, _MANGLED_FAILURE_RESPONSE
-    )
-
-    assert mangled_argument == r"origin\main;.claude\skills\x\test_run_evals.py"
-
-
-def test_should_return_the_mangled_argument_from_an_invalid_object_name_failure() -> None:
-    mangled_argument = msys_path_conversion_advisor.mangled_revision_path_argument(
-        _ABSOLUTE_PATH_SHOW_COMMAND, _MANGLED_OBJECT_NAME_RESPONSE
-    )
-
-    assert mangled_argument == r"origin\main;C"
-
-
-def test_should_stay_quiet_when_the_object_name_failure_names_an_unmangled_argument() -> None:
-    assert (
-        msys_path_conversion_advisor.mangled_revision_path_argument(
-            _MISSING_OBJECT_SHOW_COMMAND, _MISSING_OBJECT_NAME_RESPONSE
-        )
-        is None
-    )
-
-
-def test_should_stay_quiet_when_the_command_succeeded() -> None:
-    zero_exit_response = {"stdout": "", "stderr": ""}
-
-    assert (
-        msys_path_conversion_advisor.mangled_revision_path_argument(
-            _SHOW_COMMAND, zero_exit_response
-        )
-        is None
-    )
-
-
-def test_should_stay_quiet_when_the_quoted_argument_is_unmangled() -> None:
-    assert (
-        msys_path_conversion_advisor.mangled_revision_path_argument(
-            "git show origin/nope:packages/app/main.py", _MISSING_REVISION_RESPONSE
-        )
-        is None
-    )
-
-
-def test_should_stay_quiet_when_the_command_already_exports_the_workaround() -> None:
-    already_fixed_command = (
-        "export MSYS_NO_PATHCONV=1 MSYS2_ARG_CONV_EXCL='*' && "
-        "git show origin/main:.claude/skills/x/test_run_evals.py"
-    )
-
-    assert (
-        msys_path_conversion_advisor.mangled_revision_path_argument(
-            already_fixed_command, _MANGLED_FAILURE_RESPONSE
-        )
-        is None
-    )
-
-
-def test_should_stay_quiet_when_the_command_exports_only_the_argument_exclusion() -> None:
-    argument_exclusion_only_command = (
-        "export MSYS2_ARG_CONV_EXCL='*' && "
-        "git show origin/main:.claude/skills/x/test_run_evals.py"
-    )
-
-    assert (
-        msys_path_conversion_advisor.mangled_revision_path_argument(
-            argument_exclusion_only_command, _MANGLED_FAILURE_RESPONSE
-        )
-        is None
-    )
-
-
-def test_should_stay_quiet_without_the_ambiguous_argument_marker() -> None:
-    other_failure = "Error: Exit code 1\nfatal: not a git repository"
-
-    assert (
-        msys_path_conversion_advisor.mangled_revision_path_argument(_SHOW_COMMAND, other_failure)
-        is None
-    )
-
-
-def test_should_stay_quiet_when_the_quoted_argument_never_closes() -> None:
-    unterminated_failure = (
-        "Error: Exit code 128\n" + r"fatal: ambiguous argument 'origin\main;.claude"
-    )
-
-    assert (
-        msys_path_conversion_advisor.mangled_revision_path_argument(
-            _SHOW_COMMAND, unterminated_failure
-        )
-        is None
-    )
-
-
-def test_advisory_should_name_the_argument_and_the_export_line() -> None:
-    advisory_text = msys_path_conversion_advisor.build_advisory_context(_MANGLED_ARGUMENT)
-
-    assert advisory_text.startswith("=== MSYS PATH CONVERSION")
-    assert "never a block" in advisory_text
-    assert r"origin\main;.claude\skills\x\test_run_evals.py" in advisory_text
-    assert _EXPORT_LINE in advisory_text
-    assert "Git Bash rewrote a <rev>:<path> argument" in advisory_text
-    assert "same command" in advisory_text
-
-
-def test_main_should_emit_additional_context_after_a_mangled_failure(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    stdout_text = _run_main(monkeypatch, capsys, _payload(_SHOW_COMMAND, _MANGLED_FAILURE_RESPONSE))
-
-    payload = json.loads(stdout_text)
-    assert payload["hookSpecificOutput"]["hookEventName"] == "PostToolUse"
-    additional_context = str(payload["hookSpecificOutput"]["additionalContext"])
-    assert _EXPORT_LINE in additional_context
-    assert r"origin\main;.claude\skills\x\test_run_evals.py" in additional_context
-
-
-def test_main_should_stay_quiet_for_a_non_bash_tool(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
-) -> None:
-    payload = json.loads(_payload(_SHOW_COMMAND, _MANGLED_FAILURE_RESPONSE))
-    payload["tool_name"] = "PowerShell"
-
-    assert _run_main(monkeypatch, capsys, json.dumps(payload)) == ""
-
-
-def test_should_return_an_argument_whose_only_mangling_mark_is_the_semicolon() -> None:
-    semicolon_only_response = (
-        "Error: Exit code 128\nfatal: invalid object name 'HEAD;.gitignore'."
-    )
-
-    mangled_argument = msys_path_conversion_advisor.mangled_revision_path_argument(
-        "git show HEAD:.gitignore", semicolon_only_response
-    )
-
-    assert mangled_argument == "HEAD;.gitignore"
-
-
-def test_should_stay_quiet_when_the_command_exports_only_the_path_conversion_switch() -> None:
-    path_conversion_only_command = (
-        "export MSYS_NO_PATHCONV=1 && git show origin/main:.claude/skills/x/test_run_evals.py"
-    )
-
-    assert (
-        msys_path_conversion_advisor.mangled_revision_path_argument(
-            path_conversion_only_command, _MANGLED_FAILURE_RESPONSE
-        )
-        is None
-    )

package/hooks/hooks_constants/test_failure_recorder_constants.py

@@ -1,34 +0,0 @@
-"""Constants for the failing-test-run PostToolUse recorder hook.
-
-Holds the cheap substring check the hook runs before any shell parsing, the
-chaining and redirection operator
-tokens that keep the recognizer to one unchained command, the pytest program
-and Python interpreter basenames, and the flag-token marker the path
-extractor uses to skip an option rather than an existing test file argument.
-
-The pytest-program and interpreter recognition here is deliberately its own small, stdlib-only
-check rather than a reuse of ``piped_pytest_blocker_constants`` /
-``pytest_invocation``: those solve the harder pipe-and-wrapper problem and
-pull in a much larger transitive import for every Bash call regardless of
-content, working against the point of the recognizer's own cheap prefilter.
-"""
-
-from __future__ import annotations
-
-import re
-
-BASH_TOOL_NAME = "Bash"
-
-ALL_PYTEST_MENTION_SUBSTRINGS: tuple[str, ...] = ("pytest", "py.test")
-OPTION_TOKEN_PREFIX: str = "-"
-NODE_ID_FILE_PATH_SEPARATOR: str = "::"
-ALL_CHAINING_OPERATOR_SUBSTRINGS: tuple[str, ...] = ("&&", "||", ";", "|", "\n")
-ALL_REDIRECTION_TOKENS: frozenset[str] = frozenset(
-    {">", ">>", "<", "<<", "2>&1", "1>&2", "2>", "1>"}
-)
-ALL_PYTEST_PROGRAM_BASENAMES: frozenset[str] = frozenset({"pytest", "py.test"})
-MODULE_RUN_FLAG: str = "-m"
-PYTEST_MODULE_NAME: str = "pytest"
-PYTHON_INTERPRETER_BASENAME_PATTERN: re.Pattern[str] = re.compile(
-    r"^(?:python|py|pypy)[0-9.]*(?:\.exe)?$"
-)

package/hooks/observability/test_failure_recorder.py

@@ -1,221 +0,0 @@
-#!/usr/bin/env python3
-"""PostToolUse hook: record a failing single pytest run as TDD-gate evidence.
-
-A file-content edit is not the same claim as a test that ran and failed. The
-content-hash store in ``tdd_enforcer_parts/content_hash_store.py`` already
-tracks whether a candidate test file's content changed; this hook adds a
-stronger form of evidence -- a real RED -- by watching every Bash call finish
-and, for a genuine failing pytest run, recording the command, its real exit
-status, and the test file paths it named into that same store.
-
-::
-
-    pytest test_orders.py                    (exit 1)  -> record test_orders.py
-    pytest test_orders.py -k fulfill          (exit 1)  -> record test_orders.py
-    pytest test_orders.py::test_fulfill       (exit 1)  -> record test_orders.py
-    pytest -q                                 (exit 1)  -> no path named, no record
-    cd repo && pytest test_orders.py          (exit 1)  -> chained, no record
-    pytest test_orders.py | tee run.log       (blocked by piped_pytest_blocker
-                                                first -- this hook never sees it)
-    npm test                                  (exit 1)  -> not pytest, no record
-    pytest test_orders.py                     (exit 0)  -> passed, no record
-
-What this hook matches, and why
---------------------------------
-
-Only a single, unchained Bash command whose own program is ``pytest`` /
-``py.test``, or a Python interpreter running ``-m pytest``. A chained command
-(``&&``, ``;``, ``|``, ``||``, a newline) is rejected outright: this repo's own
-``piped_pytest_blocker.py`` already tells the caller to "run pytest alone" for
-exactly this reason, and a chain's reported exit status may belong to a
-command other than pytest, or to none of them if an earlier link short-
-circuited before pytest even ran. ``npm test``, ``node --test``, and
-``vitest`` are deliberately not matched: ``npm test`` is a script indirection
-whose real test runner lives in ``package.json``, not on the command line,
-and the other two have no existing, tested classification helper in this
-repository the way pytest does. Extending to them would mean inventing new
-parsing rather than reusing anything proven, which is the over-reach this
-mechanism is built to avoid.
-
-The recognizer here is deliberately its own small, stdlib-only ``shlex``
-check rather than a reuse of ``hooks_constants.pytest_invocation`` /
-``shell_command_pipeline``. Those solve the harder pipe-and-wrapper problem a
-PreToolUse blocker needs, and this repository's own style rule forbids an
-import inside a function body, so importing that larger machinery here would
-mean paying its full transitive import cost on every single Bash call this
-hook sees, pytest or not -- working directly against the point of watching
-every Bash call. The narrower, single-unchained-command scope this hook
-accepts does not need that machinery.
-
-Where the exit status comes from
----------------------------------
-
-Not from scraping the command's output text for words like "failed" or
-"error". The Bash tool's own PostToolUse ``tool_response`` takes two shapes
-observed directly in this session's own transcript: a dict with ``stdout``/
-``stderr`` keys when the command's reported exit status is 0, and the literal
-string ``"Error: Exit code <N>\\n<output>"`` when it is not. This hook reads
-that harness-authored ``<N>`` directly; it is a real Bash mechanism doing the
-work correctly, not a lookalike that only mimics one.
-
-Where the test paths come from
---------------------------------
-
-The command's own arguments, not its output. A bare ``pytest`` or ``pytest
--q`` names no path and is left unrecorded on purpose: recording it against
-every test file pytest might have discovered would satisfy the gate for a
-file this run never demonstrably covered, which is the exact bypass the
-audit calls out. Only a token that is not an option flag and resolves to a
-real file on disk, relative to the command's own ``cwd``, counts.
-
-What stops a bypass
----------------------
-
-Three things, together:
-
-1. ``content_hash_store.record_test_command_failure`` keys each entry
-   exactly as the gate looks candidates up, so a failure never satisfies a
-   sibling file the same command also happened to run (see
-   ``test_content_hash_store.py::test_recorded_failure_does_not_satisfy_a_different_candidate``).
-2. The gate consults a recorded failure only while the file's *current*
-   content hash still matches what actually failed (see
-   ``test_recorded_failure_does_not_apply_once_content_no_longer_matches``).
-   Editing the test again clears it as evidence.
-3. A record ages out after the same freshness window every other form of
-   evidence uses (see ``test_recorded_failure_expires_after_the_freshness_window``).
-
-The hook never blocks a tool call. A non-Bash tool, a malformed payload, a
-command that does not mention "pytest", a chained command, a command with no
-real path argument, or a failed record each returns quietly.
-"""
-
-from __future__ import annotations
-
-import shlex
-import sys
-from pathlib import Path
-
-try:
-    _hooks_root_directory = str(Path(__file__).resolve().parent.parent)
-    _blocking_directory = str(Path(_hooks_root_directory) / "blocking")
-    for each_bootstrap_directory in (_hooks_root_directory, _blocking_directory):
-        if each_bootstrap_directory not in sys.path:
-            sys.path.insert(0, each_bootstrap_directory)
-    from hooks_constants.bash_post_call_dispatcher_constants import (
-        EXIT_CODE_ERROR_PREFIX,
-    )
-    from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
-    from hooks_constants.test_failure_recorder_constants import (
-        ALL_CHAINING_OPERATOR_SUBSTRINGS,
-        ALL_PYTEST_MENTION_SUBSTRINGS,
-        ALL_PYTEST_PROGRAM_BASENAMES,
-        ALL_REDIRECTION_TOKENS,
-        BASH_TOOL_NAME,
-        MODULE_RUN_FLAG,
-        NODE_ID_FILE_PATH_SEPARATOR,
-        OPTION_TOKEN_PREFIX,
-        PYTEST_MODULE_NAME,
-        PYTHON_INTERPRETER_BASENAME_PATTERN,
-    )
-    from tdd_enforcer_parts import content_hash_store
-except ImportError as import_error:
-    raise ImportError(
-        "test_failure_recorder: cannot import its dependencies; "
-        "ensure the hooks directory is importable."
-    ) from import_error
-
-
-def _mentions_pytest(command: str) -> bool:
-    lowered_command = command.lower()
-    return any(
-        each_substring in lowered_command for each_substring in ALL_PYTEST_MENTION_SUBSTRINGS
-    )
-
-
-def _harness_reported_exit_status(tool_response: object) -> int | None:
-    if not isinstance(tool_response, str) or not tool_response.startswith(EXIT_CODE_ERROR_PREFIX):
-        return None
-    remainder = tool_response[len(EXIT_CODE_ERROR_PREFIX) :]
-    digit_count = 0
-    while digit_count < len(remainder) and remainder[digit_count].isdigit():
-        digit_count += 1
-    return int(remainder[:digit_count]) if digit_count else None
-
-
-def _is_single_unchained_command(command: str) -> bool:
-    return not any(each_operator in command for each_operator in ALL_CHAINING_OPERATOR_SUBSTRINGS)
-
-
-def _runs_pytest_via_module_flag(all_tokens: list[str]) -> bool:
-    if MODULE_RUN_FLAG not in all_tokens:
-        return False
-    flag_index = all_tokens.index(MODULE_RUN_FLAG)
-    return flag_index + 1 < len(all_tokens) and all_tokens[flag_index + 1] == PYTEST_MODULE_NAME
-
-
-def _command_tokens_run_pytest(all_tokens: list[str]) -> bool:
-    if not all_tokens:
-        return False
-    first_basename = Path(all_tokens[0]).name
-    if first_basename in ALL_PYTEST_PROGRAM_BASENAMES:
-        return True
-    if not PYTHON_INTERPRETER_BASENAME_PATTERN.match(first_basename):
-        return False
-    return _runs_pytest_via_module_flag(all_tokens)
-
-
-def _existing_test_file_paths(all_tokens: list[str], cwd: str) -> list[Path]:
-    all_paths: list[Path] = []
-    for each_token in all_tokens:
-        if each_token.startswith(OPTION_TOKEN_PREFIX) or each_token in ALL_REDIRECTION_TOKENS:
-            continue
-        file_path_text = each_token.split(NODE_ID_FILE_PATH_SEPARATOR, 1)[0]
-        candidate_path = Path(cwd, file_path_text) if cwd else Path(file_path_text)
-        if candidate_path.is_file():
-            all_paths.append(candidate_path)
-    return all_paths
-
-
-def _command_tokens(command: str) -> list[str]:
-    try:
-        return shlex.split(command)
-    except ValueError:
-        return []
-
-
-def _record_pytest_failure(hook_payload: dict, command: str) -> None:
-    exit_status = _harness_reported_exit_status(hook_payload.get("tool_response"))
-    if exit_status is None or not _is_single_unchained_command(command):
-        return
-    all_tokens = _command_tokens(command)
-    if not _command_tokens_run_pytest(all_tokens):
-        return
-    cwd = str(hook_payload.get("cwd") or "")
-    all_test_file_paths = _existing_test_file_paths(all_tokens, cwd)
-    if not all_test_file_paths:
-        return
-    session_id = str(hook_payload.get("session_id") or "")
-    content_hash_store.record_test_command_failure(
-        all_test_file_paths, command, exit_status, session_id, cwd
-    )
-
-
-def main() -> None:
-    """Record one failing pytest run's evidence from a PostToolUse Bash payload.
-
-    Reads the payload from stdin. Returns quietly on every branch that is not
-    a genuine, single, unchained, path-naming pytest failure, so a logging
-    problem never surfaces as a blocked or altered tool call.
-    """
-    hook_payload = read_hook_input_dictionary_from_stdin()
-    if hook_payload is None or hook_payload.get("tool_name") != BASH_TOOL_NAME:
-        return
-    tool_input = hook_payload.get("tool_input")
-    command = tool_input.get("command", "") if isinstance(tool_input, dict) else ""
-    if not isinstance(command, str) or not _mentions_pytest(command):
-        return
-    _record_pytest_failure(hook_payload, command)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/observability/test_test_failure_recorder.py

@@ -1,173 +0,0 @@
-"""Behavior tests for the test_failure_recorder PostToolUse hook.
-
-Drives the hook's main through real stdin payloads shaped like a genuine
-Bash PostToolUse call, then reads the shared content-hash store back to
-confirm what -- if anything -- it recorded. The store's real state file
-under the OS temp directory is read directly, the same way
-test_content_hash_store.py and test_tdd_enforcer.py already do, rather than
-mocking tempfile.gettempdir. ``hooks/conftest.py`` already puts the hooks
-and blocking directories on sys.path for test collection, so this file needs
-no bootstrap of its own before importing content_hash_store.
-"""
-
-import contextlib
-import importlib.util
-import io
-import json
-from pathlib import Path
-from unittest import mock
-
-from tdd_enforcer_parts import content_hash_store
-
-_HOOK_DIRECTORY = Path(__file__).parent
-_hook_spec = importlib.util.spec_from_file_location(
-    "test_failure_recorder_under_test", _HOOK_DIRECTORY / "test_failure_recorder.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)
-
-
-def _run_hook_with_payload(payload: dict) -> None:
-    with (
-        mock.patch("sys.stdin", io.StringIO(json.dumps(payload))),
-        contextlib.suppress(SystemExit),
-    ):
-        _hook_module.main()
-
-
-def _recorded_failure_entry(test_file: Path, session_id: str, repository_root: str) -> dict | None:
-    state_file = content_hash_store._state_file_path(session_id, repository_root)
-    if not state_file.exists():
-        return None
-    state = json.loads(state_file.read_text())
-    return state.get(content_hash_store._state_key_for(test_file))
-
-
-def _bash_payload(command: str, tool_response: object, cwd: Path, session_id: str) -> dict:
-    return {
-        "session_id": session_id,
-        "cwd": str(cwd),
-        "tool_name": "Bash",
-        "tool_input": {"command": command},
-        "tool_response": tool_response,
-    }
-
-
-_FAILING_OUTPUT = (
-    "Error: Exit code 1\n"
-    "F                                                                    [100%]\n"
-    "=================================== FAILURES ===================================\n"
-    "FAILED test_orders.py::test_fulfill - AssertionError\n"
-    "1 failed in 0.02s"
-)
-_PASSING_OUTPUT = {"stdout": "1 passed in 0.02s", "stderr": "", "interrupted": False}
-
-
-def test_records_a_failure_for_a_bare_pytest_command_naming_a_real_file(
-    tmp_path: Path,
-) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_fulfill(): assert False\n")
-    session_id = "recorder-session-1"
-
-    _run_hook_with_payload(
-        _bash_payload("pytest test_orders.py", _FAILING_OUTPUT, tmp_path, session_id)
-    )
-
-    entry = _recorded_failure_entry(test_file, session_id, str(tmp_path))
-    assert entry is not None
-    assert entry[content_hash_store.STORED_FAILURE_EXIT_STATUS_KEY] == 1
-    assert entry[content_hash_store.STORED_FAILURE_COMMAND_KEY] == "pytest test_orders.py"
-
-
-def test_does_not_record_for_a_passing_command(tmp_path: Path) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_fulfill(): pass\n")
-    session_id = "recorder-session-2"
-
-    _run_hook_with_payload(
-        _bash_payload("pytest test_orders.py", _PASSING_OUTPUT, tmp_path, session_id)
-    )
-
-    assert _recorded_failure_entry(test_file, session_id, str(tmp_path)) is None
-
-
-def test_does_not_record_for_a_non_pytest_command(tmp_path: Path) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_fulfill(): assert False\n")
-    session_id = "recorder-session-3"
-
-    _run_hook_with_payload(
-        _bash_payload("npm test", "Error: Exit code 1\n1 failing", tmp_path, session_id)
-    )
-
-    assert _recorded_failure_entry(test_file, session_id, str(tmp_path)) is None
-
-
-def test_does_not_record_for_a_chained_command(tmp_path: Path) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_fulfill(): assert False\n")
-    session_id = "recorder-session-4"
-
-    _run_hook_with_payload(
-        _bash_payload("cd /repo && pytest test_orders.py", _FAILING_OUTPUT, tmp_path, session_id)
-    )
-
-    assert _recorded_failure_entry(test_file, session_id, str(tmp_path)) is None
-
-
-def test_does_not_record_for_a_bare_pytest_run_with_no_path_argument(
-    tmp_path: Path,
-) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_fulfill(): assert False\n")
-    session_id = "recorder-session-5"
-
-    _run_hook_with_payload(_bash_payload("pytest -q", _FAILING_OUTPUT, tmp_path, session_id))
-
-    assert _recorded_failure_entry(test_file, session_id, str(tmp_path)) is None
-
-
-def test_records_only_the_named_file_not_an_option_or_expression_token(
-    tmp_path: Path,
-) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_fulfill(): assert False\n")
-    session_id = "recorder-session-6"
-
-    _run_hook_with_payload(
-        _bash_payload("pytest test_orders.py -k fulfill", _FAILING_OUTPUT, tmp_path, session_id)
-    )
-
-    entry = _recorded_failure_entry(test_file, session_id, str(tmp_path))
-    assert entry is not None
-    state_file = content_hash_store._state_file_path(session_id, str(tmp_path))
-    state = json.loads(state_file.read_text())
-    assert len(state) == 1
-
-
-def test_ignores_a_tool_other_than_bash(tmp_path: Path) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_fulfill(): assert False\n")
-    session_id = "recorder-session-7"
-    payload = _bash_payload("pytest test_orders.py", _FAILING_OUTPUT, tmp_path, session_id)
-    payload["tool_name"] = "Write"
-
-    _run_hook_with_payload(payload)
-
-    assert _recorded_failure_entry(test_file, session_id, str(tmp_path)) is None
-
-
-def test_does_not_record_when_the_named_file_does_not_exist_on_disk(
-    tmp_path: Path,
-) -> None:
-    session_id = "recorder-session-8"
-    missing_file = tmp_path / "test_missing.py"
-
-    _run_hook_with_payload(
-        _bash_payload("pytest test_missing.py", _FAILING_OUTPUT, tmp_path, session_id)
-    )
-
-    assert _recorded_failure_entry(missing_file, session_id, str(tmp_path)) is None