claude-dev-env 7.4.1 → 7.5.0

package/bin/install.mjs

@@ -1292,7 +1292,6 @@ export const RETIRED_HOOK_REGISTRATION_RELATIVE_PATHS = new Set([
     'blocking/nas_ssh_binary_enforcer.py',
     'blocking/block_main_commit.py',
     'blocking/session_edit_stage_gate.py',
-    'blocking/bash_pre_tool_use_dispatcher.py',
     'blocking/stop_dispatcher.py',
     'blocking/bot_mention_comment_blocker.py',
     'blocking/fable_spawn_gate.py',

package/bin/install.policy-lint.test.mjs

@@ -36,7 +36,6 @@ const allRetiredPolicyRegistrations = [
     'blocking/nas_ssh_binary_enforcer.py',
     'blocking/block_main_commit.py',
     'blocking/session_edit_stage_gate.py',
-    'blocking/bash_pre_tool_use_dispatcher.py',
     'blocking/stop_dispatcher.py',
     'blocking/bot_mention_comment_blocker.py',
     'blocking/fable_spawn_gate.py',
@@ -117,7 +116,7 @@ test('upgrade prunes legacy direct file checks while retaining foreign hooks', (
     });
     assert.ok(commands.every(command => !command.includes('/blocking/stop_dispatcher.py')));
     assert.ok(commands.some(command => command.includes('/blocking/pre_tool_use_dispatcher.py')));
-    assert.ok(commands.every(command => !command.includes('/blocking/bash_pre_tool_use_dispatcher.py')));
+    assert.ok(commands.some(command => command.includes('/blocking/bash_pre_tool_use_dispatcher.py')));
 });
 
 test('reinstall does not restore retired direct checks or duplicate foreign hooks', () => {

package/bin/install.test.mjs

@@ -1195,7 +1195,6 @@ test('retired hook registrations stay managed so reinstall removes them', () =>
         'blocking/nas_ssh_binary_enforcer.py',
         'blocking/block_main_commit.py',
         'blocking/session_edit_stage_gate.py',
-        'blocking/bash_pre_tool_use_dispatcher.py',
         'blocking/stop_dispatcher.py',
         'blocking/bot_mention_comment_blocker.py',
         'blocking/fable_spawn_gate.py',

package/hooks/advisory/msys_path_conversion_advisor.py

@@ -0,0 +1,200 @@
+#!/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/pr_done_reminder.py

@@ -43,13 +43,18 @@ try:
     from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
         ALL_BASH_AND_POWERSHELL_TOOL_NAMES,
     )
+    from hooks_constants.bash_post_call_dispatcher_constants import (
+        EXIT_CODE_ERROR_PREFIX,
+    )
+    from hooks_constants.post_tool_use_context import (
+        write_post_tool_use_context_to_stdout,
+    )
     from hooks_constants.pr_done_reminder_constants import (
         ADD_LABEL_COMMAND_TEMPLATE,
         ALL_FAILING_CHECK_CONCLUSIONS,
         ALL_PASSING_CHECK_CONCLUSIONS,
         CHECK_COMPLETED_STATUS,
         DONE_LABEL_NAME,
-        EXIT_CODE_ERROR_PREFIX,
         GH_PR_CREATE_ACTION,
         GH_PR_SUBCOMMAND,
         ALL_GH_PR_VIEW_ARGUMENTS,
@@ -304,17 +309,6 @@ def _probe_pull_request(cwd: str) -> str | None:
     return build_reminder_context(all_pr_fields)
 
 
-def _emit_context(context_text: str) -> None:
-    payload = {
-        "hookSpecificOutput": {
-            "hookEventName": "PostToolUse",
-            "additionalContext": context_text,
-        }
-    }
-    sys.stdout.write(json.dumps(payload))
-    sys.stdout.flush()
-
-
 def main() -> None:
     """Add the PR done checklist to context after a successful push or PR creation.
 
@@ -335,7 +329,7 @@ def main() -> None:
         return
     context_text = _probe_pull_request(str(hook_payload.get("cwd") or ""))
     if context_text is not None:
-        _emit_context(context_text)
+        write_post_tool_use_context_to_stdout(context_text)
 
 
 if __name__ == "__main__":

package/hooks/advisory/test_msys_path_conversion_advisor.py

@@ -0,0 +1,223 @@
+"""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/advisory/test_pr_done_reminder.py

@@ -247,3 +247,4 @@ def test_main_should_stay_quiet_on_any_other_gh_failure(
     gh_down = _fake_gh(None, stderr="error connecting to api.github.com")
 
     assert _run_main(monkeypatch, capsys, _payload("git push"), gh_down) == ""
+

package/hooks/blocking/bash_post_call_dispatcher.py

@@ -18,7 +18,8 @@ decision -- it is an observer, not a gate -- so this dispatcher runs the whole
 roster unconditionally and never blocks. The one thing it forwards is context:
 a hosted hook may print a ``hookSpecificOutput.additionalContext`` string (the
 PR done reminder does), and the dispatcher joins every such string into one
-PostToolUse payload. A hook that prints nothing adds nothing.
+PostToolUse payload through the shared emitter every PostToolUse hook here
+writes with. A hook that prints nothing adds nothing.
 
 A single hosted hook crash fails open: ``run_hook_capturing_output`` isolates
 it, so it contributes nothing and does not stop the remaining hosted hooks.
@@ -30,7 +31,6 @@ imports load once into this process rather than once per hook.
 from __future__ import annotations
 
 import json
-import sys
 
 import _path_setup  # noqa: F401
 
@@ -39,8 +39,8 @@ from hooks_constants.bash_post_call_dispatcher_constants import (
     ADDITIONAL_CONTEXT_KEY,
     ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES,
     HOOK_SPECIFIC_OUTPUT_KEY,
-    POST_TOOL_USE_HOOK_EVENT_NAME,
 )
+from hooks_constants.post_tool_use_context import write_post_tool_use_context_to_stdout
 from hooks_constants.bash_pre_tool_use_dispatcher_constants import BashHostedHookEntry
 from hooks_constants.hosted_hook_runner import (
     run_hook_capturing_output,
@@ -98,14 +98,9 @@ def dispatch(payload_text: str, tool_name: str) -> None:
             all_additional_context.append(additional_context)
     if not all_additional_context:
         return
-    payload = {
-        HOOK_SPECIFIC_OUTPUT_KEY: {
-            "hookEventName": POST_TOOL_USE_HOOK_EVENT_NAME,
-            ADDITIONAL_CONTEXT_KEY: ADDITIONAL_CONTEXT_JOIN_SEPARATOR.join(all_additional_context),
-        }
-    }
-    sys.stdout.write(json.dumps(payload))
-    sys.stdout.flush()
+    write_post_tool_use_context_to_stdout(
+        ADDITIONAL_CONTEXT_JOIN_SEPARATOR.join(all_additional_context)
+    )
 
 
 def main() -> None: