claude-dev-env 8.2.0 → 8.4.0

package/hooks/advisory/msys_path_conversion_advisor.py

@@ -1,200 +0,0 @@
-#!/usr/bin/env python3
-"""PostToolUse context advisory: Git Bash rewrote a ``<rev>:<path>`` argument.
-
-This hook never blocks. It watches every Bash call finish and, when git failed
-with either its ambiguous-argument error or its invalid-object-name error and
-the quoted argument carries the marks of MSYS path conversion, adds one loud
-note to the agent's context::
-
-    === MSYS PATH CONVERSION (context reminder, never a block) ===
-    Git saw:     origin\\main;.claude\\skills\\x\\test_run_evals.py
-    Git Bash rewrote a <rev>:<path> argument before git saw it, turning the
-    colon into a semicolon and the slashes into backslashes.
-    Fix:         export MSYS_NO_PATHCONV=1 MSYS2_ARG_CONV_EXCL='*'
-    Put that export and the git command in the same command.
-
-Why a reminder and not a gate: the rewriting happens inside the shell, so the
-command text the agent wrote looks correct and the error names an argument the
-agent never typed. The note arrives at the moment the failure lands, which is
-the only moment the two names line up.
-
-Six quiet branches emit nothing: a non-Bash tool, a zero-exit call, a failure
-carrying neither marker, a quoted argument whose closing quote never arrives, a
-quoted argument free of both mangling marks, and a command that already names
-either workaround variable.
-
-The verdict rests on the failure text alone and never parses the command, so
-two shapes get the note without deserving it: an argument the agent typed with
-a semicolon or a backslash of its own, and a failing call whose stdout quotes
-one of the two git messages. Both are rare, and the note costs a reader one
-paragraph, so the detector keeps its single read of the failure text.
-
-Hosted by ``blocking/bash_post_call_dispatcher.py``, which forwards the
-``hookSpecificOutput.additionalContext`` this hook prints.
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-try:
-    _hooks_root_directory = str(Path(__file__).resolve().parent.parent)
-    if _hooks_root_directory not in sys.path:
-        sys.path.insert(0, _hooks_root_directory)
-    from hooks_constants.bash_post_call_dispatcher_constants import (
-        EXIT_CODE_ERROR_PREFIX,
-    )
-    from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
-        ALL_BASH_ONLY_TOOL_NAMES,
-    )
-    from hooks_constants.msys_path_conversion_advisor_constants import (
-        ADVISORY_HEADER,
-        ADVISORY_LINE_SEPARATOR,
-        ALL_MANGLED_ARGUMENT_MARKERS,
-        ALL_MSYS_MANGLING_CHARACTERS,
-        ALL_MSYS_PATH_CONVERSION_VARIABLE_NAMES,
-        FIX_LINE,
-        MANGLED_ARGUMENT_CLOSING_QUOTE,
-        MANGLED_ARGUMENT_LINE_TEMPLATE,
-        MANGLING_EXPLANATION_LINE,
-        SAME_COMMAND_LINE,
-    )
-    from hooks_constants.post_tool_use_context import (
-        write_post_tool_use_context_to_stdout,
-    )
-    from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
-except ImportError as import_error:
-    raise ImportError(
-        "msys_path_conversion_advisor is unable to import its dependencies; "
-        "ensure the hooks directory is importable."
-    ) from import_error
-
-
-def text_after_first_mangled_argument_marker(response_text: str) -> str | None:
-    """Return what follows the first marker present in a git failure, else None.
-
-    Git names a mangled ``<rev>:<path>`` argument under two messages, one for a
-    path after the colon and one for an absolute path after the colon. The
-    markers are walked in order and the first one present wins.
-
-    Args:
-        response_text: The harness response text for the failed call.
-
-    Returns:
-        The text following the opening quote of the first marker present, or
-        None when the response carries no marker.
-    """
-    for each_marker in ALL_MANGLED_ARGUMENT_MARKERS:
-        _, marker_text, text_after_marker = response_text.partition(each_marker)
-        if marker_text:
-            return text_after_marker
-    return None
-
-
-def argument_carries_msys_mangling_marks(argument_text: str) -> bool:
-    """Return whether an argument carries a mark left behind by path conversion.
-
-    Path conversion leaves a backslash or a semicolon in the argument, and that
-    is what separates this failure from a revision that is simply absent.
-
-    Args:
-        argument_text: The quoted argument git named in its failure.
-
-    Returns:
-        True when one of those marks is present, else False.
-    """
-    return any(each_character in argument_text for each_character in ALL_MSYS_MANGLING_CHARACTERS)
-
-
-def command_names_a_path_conversion_variable(command_text: str) -> bool:
-    """Return whether the command already names a variable that stops conversion.
-
-    The advisory names two exports, and either one on its own suppresses the
-    rewriting, so a command carrying either has nothing left to learn.
-
-    Args:
-        command_text: The Bash command text the agent ran.
-
-    Returns:
-        True when one of those variable names is present, else False.
-    """
-    return any(
-        each_variable_name in command_text
-        for each_variable_name in ALL_MSYS_PATH_CONVERSION_VARIABLE_NAMES
-    )
-
-
-def mangled_revision_path_argument(command_text: str, tool_response: object) -> str | None:
-    """Return the argument git reported, when MSYS mangled it, else None.
-
-    Four conditions all hold before an argument is returned. The harness
-    reported a non-zero exit status, which arrives as a string carrying the
-    exit-code prefix. Git printed either its ambiguous-argument error or its
-    invalid-object-name error, and the quoted argument after it closes. That
-    argument carries a path-conversion mark, and the command names neither of
-    the two variables the workaround exports.
-
-    Args:
-        command_text: The Bash command text the agent ran.
-        tool_response: The harness response for the finished call.
-
-    Returns:
-        The quoted argument word for word, or None to stay quiet.
-    """
-    if not isinstance(tool_response, str) or not tool_response.startswith(EXIT_CODE_ERROR_PREFIX):
-        return None
-    text_after_marker = text_after_first_mangled_argument_marker(tool_response)
-    if text_after_marker is None:
-        return None
-    argument_text, closing_quote, _ = text_after_marker.partition(MANGLED_ARGUMENT_CLOSING_QUOTE)
-    if not closing_quote:
-        return None
-    if not argument_carries_msys_mangling_marks(argument_text):
-        return None
-    if command_names_a_path_conversion_variable(command_text):
-        return None
-    return argument_text
-
-
-def build_advisory_context(mangled_argument: str) -> str:
-    """Build the advisory text naming the mangled argument and the two exports.
-
-    Args:
-        mangled_argument: The argument git reported, word for word.
-
-    Returns:
-        The multi-line note the dispatcher forwards as additionalContext.
-    """
-    all_lines = [
-        ADVISORY_HEADER,
-        MANGLED_ARGUMENT_LINE_TEMPLATE.format(argument=mangled_argument),
-        MANGLING_EXPLANATION_LINE,
-        FIX_LINE,
-        SAME_COMMAND_LINE,
-    ]
-    return ADVISORY_LINE_SEPARATOR.join(all_lines)
-
-
-def main() -> None:
-    """Add the MSYS path-conversion note after a git call the shell mangled.
-
-    Reads the PostToolUse payload from stdin. Every quiet branch returns with
-    no output, so this hook can never alter or block a tool call.
-    """
-    hook_payload = read_hook_input_dictionary_from_stdin()
-    if hook_payload is None or hook_payload.get("tool_name") not in ALL_BASH_ONLY_TOOL_NAMES:
-        return
-    tool_input = hook_payload.get("tool_input")
-    command_text = tool_input.get("command", "") if isinstance(tool_input, dict) else ""
-    if not isinstance(command_text, str):
-        return
-    mangled_argument = mangled_revision_path_argument(
-        command_text, hook_payload.get("tool_response")
-    )
-    if mangled_argument is not None:
-        write_post_tool_use_context_to_stdout(build_advisory_context(mangled_argument))
-
-
-if __name__ == "__main__":
-    main()

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()