claude-dev-env 7.4.1 → 7.5.0

package/hooks/blocking/msys_rev_path_rewriter.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""PreToolUse rewriter: keep Git Bash from converting a ``<rev>:<path>`` argument.
+
+Git Bash rewrites a git argument such as ``origin/main:.claude/settings.json``
+into a backslash-separated form joined by a semicolon before git sees it, and
+git then fails with ``fatal: ambiguous argument``. This hook reads the command
+before it runs, finds every token MSYS would convert, and prepends one
+``export MSYS2_ARG_CONV_EXCL='<rev1>:;<rev2>:'; `` naming exactly those
+prefixes. Every other argument in the command keeps converting as before.
+
+A token is converted only when the part before its first colon carries a slash
+and the part after that colon opens a repository-root path, so ``HEAD:.gitignore``
+and ``origin/main:packages/app.py`` both reach git untouched and neither is
+collected.
+
+Quiet branches, each emitting nothing: a non-Bash tool, a command that already
+names one of the MSYS conversion variables, and a command from which no prefix
+was collected.
+
+Hosted by ``blocking/bash_pre_tool_use_dispatcher.py``, which carries the
+``updatedInput`` this hook prints through to the harness.
+"""
+
+from __future__ import annotations
+
+import shlex
+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_pre_tool_use_dispatcher_constants import BASH_TOOL_NAME
+    from hooks_constants.msys_path_conversion_advisor_constants import (
+        ALL_MSYS_PATH_CONVERSION_VARIABLE_NAMES,
+    )
+    from hooks_constants.msys_rev_path_rewriter_constants import (
+        ALL_CONVERTED_PATH_START_CHARACTERS,
+        ALL_REVISION_FORBIDDEN_CHARACTERS,
+        ALL_UNCONVERTED_PATH_START_PREFIXES,
+        EXCLUSION_EXPORT_TEMPLATE,
+        EXCLUSION_PREFIX_JOIN_SEPARATOR,
+        GIT_PROGRAM_NAME,
+        REVISION_PATH_SEPARATOR,
+        REVISION_PATH_SPLIT_COUNT,
+        REVISION_SLASH_CHARACTER,
+    )
+    from hooks_constants.pre_tool_use_allow_output import (
+        write_pre_tool_use_allow_to_stdout,
+    )
+    from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+    from hooks_constants.shell_command_segments import (
+        effective_leading_program,
+        split_into_segments,
+        token_basename,
+    )
+except ImportError as import_error:
+    raise ImportError(
+        "The MSYS revision-path rewriter cannot import its dependencies; "
+        "ensure the hooks directory is importable."
+    ) from import_error
+
+
+def _all_git_segment_tokens(command: str) -> list[list[str]]:
+    """Return the token lists of the command's segments that run git."""
+    try:
+        all_command_tokens = shlex.split(command, posix=True)
+    except ValueError:
+        all_command_tokens = command.split()
+    all_git_segments: list[list[str]] = []
+    for each_segment in split_into_segments(all_command_tokens):
+        program_token = effective_leading_program(each_segment)
+        if program_token is None:
+            continue
+        if token_basename(program_token) == GIT_PROGRAM_NAME:
+            all_git_segments.append(each_segment)
+    return all_git_segments
+
+
+def _is_revision_shaped(revision_text: str) -> bool:
+    """Return True when the text can name a git revision.
+
+    ::
+
+        origin/main                 -> True
+        HEAD                        -> False, no slash
+        don't touch a/b             -> False, a quoted message, not a revision
+
+    Args:
+        revision_text: The part of a token before its first colon.
+    """
+    if not revision_text or REVISION_SLASH_CHARACTER not in revision_text:
+        return False
+    if any(each_character.isspace() for each_character in revision_text):
+        return False
+    return not any(
+        each_character in revision_text for each_character in ALL_REVISION_FORBIDDEN_CHARACTERS
+    )
+
+
+def _converted_revision_prefix(token: str) -> str | None:
+    """Return the ``<rev>:`` prefix MSYS would convert in this token, or None.
+
+    Args:
+        token: One shell token from a git segment.
+    """
+    if REVISION_PATH_SEPARATOR not in token:
+        return None
+    revision_text, path_text = token.split(REVISION_PATH_SEPARATOR, REVISION_PATH_SPLIT_COUNT)
+    if not _is_revision_shaped(revision_text):
+        return None
+    if not path_text.startswith(ALL_CONVERTED_PATH_START_CHARACTERS):
+        return None
+    if path_text.startswith(ALL_UNCONVERTED_PATH_START_PREFIXES):
+        return None
+    return revision_text + REVISION_PATH_SEPARATOR
+
+
+def _extend_with_new_prefixes(
+    all_ordered_prefixes: list[str], all_segment_tokens: list[str]
+) -> None:
+    """Append each convertible prefix this segment adds, skipping repeats.
+
+    Args:
+        all_ordered_prefixes: The prefixes collected so far, appended in place.
+        all_segment_tokens: One git segment's shell tokens.
+    """
+    for each_token in all_segment_tokens:
+        revision_prefix = _converted_revision_prefix(each_token)
+        if revision_prefix is not None and revision_prefix not in all_ordered_prefixes:
+            all_ordered_prefixes.append(revision_prefix)
+
+
+def all_exclusion_prefixes(command: str) -> tuple[str, ...]:
+    """Return the ``<rev>:`` prefixes MSYS would convert, deduplicated in order.
+
+    Args:
+        command: The Bash command text the agent is about to run.
+
+    Returns:
+        Each distinct prefix in first-appearance order, empty when the command
+        carries no token Git Bash would convert.
+    """
+    all_ordered_prefixes: list[str] = []
+    for each_segment in _all_git_segment_tokens(command):
+        _extend_with_new_prefixes(all_ordered_prefixes, each_segment)
+    return tuple(all_ordered_prefixes)
+
+
+def command_with_exclusion_export(command: str) -> str:
+    """Return the command prefixed with the surgical exclusion export.
+
+    Returns the command unchanged when it already names an MSYS conversion
+    variable or when no convertible token was found.
+
+    Args:
+        command: The Bash command text the agent is about to run.
+    """
+    if any(
+        each_variable_name in command
+        for each_variable_name in ALL_MSYS_PATH_CONVERSION_VARIABLE_NAMES
+    ):
+        return command
+    all_prefixes = all_exclusion_prefixes(command)
+    if not all_prefixes:
+        return command
+    export_prefix = EXCLUSION_EXPORT_TEMPLATE.format(
+        all_prefixes=EXCLUSION_PREFIX_JOIN_SEPARATOR.join(all_prefixes)
+    )
+    return export_prefix + command
+
+
+def main() -> None:
+    """Emit an allow carrying the exclusion-prefixed command, or stay quiet."""
+    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")
+    if not isinstance(tool_input, dict):
+        return
+    command = tool_input.get("command", "")
+    if not isinstance(command, str):
+        return
+    rewritten_command = command_with_exclusion_export(command)
+    if rewritten_command == command:
+        return
+    write_pre_tool_use_allow_to_stdout({**tool_input, "command": rewritten_command})
+
+
+if __name__ == "__main__":
+    main()

package/hooks/blocking/test_bash_dispatcher_interpreter_starts.py

@@ -1,4 +1,10 @@
-"""Tests for the retired Bash and PowerShell blocking roster."""
+"""Tests for what the Bash and PowerShell PreToolUse chain costs to run.
+
+A Bash tool call starts one interpreter, the dispatcher's own. Each roster
+entry then runs in that process through runpy, so the roster's exact content is
+the chain's cost after that single start. One allow-and-rewrite hook is the
+whole roster; a blocking hook added here fails this test.
+"""
 
 import sys
 from pathlib import Path
@@ -9,8 +15,15 @@ if str(_HOOKS_ROOT) not in sys.path:
 
 from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
     ALL_BASH_HOSTED_HOOK_ENTRIES,
+    ALL_BASH_ONLY_TOOL_NAMES,
+    BashHostedHookEntry,
 )
 
 
-def test_retired_bash_roster_has_no_effective_blocking_hooks() -> None:
-    assert ALL_BASH_HOSTED_HOOK_ENTRIES == ()
+def test_bash_roster_starts_only_the_msys_rewriter_and_no_blocking_hook() -> None:
+    assert ALL_BASH_HOSTED_HOOK_ENTRIES == (
+        BashHostedHookEntry(
+            script_relative_path="blocking/msys_rev_path_rewriter.py",
+            applicable_tool_names=ALL_BASH_ONLY_TOOL_NAMES,
+        ),
+    )

package/hooks/blocking/test_bash_post_call_dispatcher.py

@@ -28,6 +28,7 @@ from tdd_enforcer_parts import content_hash_store
 _ALL_EXPECTED_ROSTER_PATHS = [
     "observability/test_failure_recorder.py",
     "advisory/pr_done_reminder.py",
+    "advisory/msys_path_conversion_advisor.py",
 ]
 
 
@@ -66,6 +67,7 @@ def test_dispatch_forwards_hosted_hook_additional_context_as_one_payload(
         "pr_done_reminder.py": json.dumps(
             {"hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": "PR #42"}}
         ),
+        "msys_path_conversion_advisor.py": "",
     }
 
     def _fake_run_hook(script_path: str, payload_text: str) -> HostedHookRun:

package/hooks/blocking/test_msys_rev_path_rewriter.py

@@ -0,0 +1,141 @@
+"""Tests for msys_rev_path_rewriter, the MSYS <rev>:<path> exclusion rewriter."""
+
+from __future__ import annotations
+
+import json
+from io import StringIO
+from unittest.mock import patch
+
+import msys_rev_path_rewriter as rewriter
+
+SETTINGS_SHOW_COMMAND = "git show origin/main:.claude/settings.json"
+SETTINGS_SHOW_REWRITTEN = (
+    "export MSYS2_ARG_CONV_EXCL='origin/main:'; git show origin/main:.claude/settings.json"
+)
+
+
+def _stdout_from_main(payload: dict[str, object]) -> str:
+    """Return what main() wrote to stdout for one hook payload."""
+    captured_stdout = StringIO()
+    with patch("sys.stdin", StringIO(json.dumps(payload))), patch("sys.stdout", captured_stdout):
+        try:
+            rewriter.main()
+        except SystemExit:
+            pass
+    return captured_stdout.getvalue()
+
+
+def test_settings_path_after_slashed_revision_yields_one_prefix() -> None:
+    assert rewriter.all_exclusion_prefixes(SETTINGS_SHOW_COMMAND) == ("origin/main:",)
+
+
+def test_settings_path_command_gains_the_surgical_export_prefix() -> None:
+    assert rewriter.command_with_exclusion_export(SETTINGS_SHOW_COMMAND) == SETTINGS_SHOW_REWRITTEN
+
+
+def test_unslashed_revision_beside_a_slashed_one_stays_out_of_the_prefixes() -> None:
+    assert rewriter.all_exclusion_prefixes(
+        "git diff origin/main:.gitignore HEAD:.gitignore"
+    ) == ("origin/main:",)
+
+
+def test_two_slashed_revisions_join_with_a_semicolon_in_first_appearance_order() -> None:
+    assert rewriter.command_with_exclusion_export(
+        "git diff origin/main:.gitignore origin/develop:.gitignore"
+    ) == (
+        "export MSYS2_ARG_CONV_EXCL='origin/main:;origin/develop:'; "
+        "git diff origin/main:.gitignore origin/develop:.gitignore"
+    )
+
+
+def test_one_slashed_revision_used_twice_yields_one_prefix() -> None:
+    assert rewriter.all_exclusion_prefixes(
+        "git diff origin/main:.gitignore origin/main:.gitattributes"
+    ) == ("origin/main:",)
+
+
+def test_dot_file_after_the_colon_is_collected() -> None:
+    assert rewriter.all_exclusion_prefixes("git show origin/main:.gitignore") == ("origin/main:",)
+
+
+def test_plain_directory_path_after_the_colon_is_left_alone() -> None:
+    command = "git show origin/main:packages/app.py"
+    assert rewriter.all_exclusion_prefixes(command) == ()
+    assert rewriter.command_with_exclusion_export(command) == command
+
+
+def test_revision_without_a_slash_is_left_alone() -> None:
+    command = "git show HEAD:.claude/settings.json"
+    assert rewriter.all_exclusion_prefixes(command) == ()
+    assert rewriter.command_with_exclusion_export(command) == command
+
+
+def test_dot_slash_path_after_the_colon_is_left_alone() -> None:
+    assert rewriter.all_exclusion_prefixes("git show origin/main:./settings.json") == ()
+
+
+def test_parent_directory_path_after_the_colon_is_left_alone() -> None:
+    assert rewriter.all_exclusion_prefixes("git show origin/main:../settings.json") == ()
+
+
+def test_command_already_naming_the_exclusion_variable_is_left_alone() -> None:
+    command = "MSYS2_ARG_CONV_EXCL='*' git show origin/main:.gitignore"
+    assert rewriter.command_with_exclusion_export(command) == command
+
+
+def test_command_already_naming_the_path_conversion_variable_is_left_alone() -> None:
+    command = "export MSYS_NO_PATHCONV=1; git show origin/main:.gitignore"
+    assert rewriter.command_with_exclusion_export(command) == command
+
+
+def test_colon_token_in_a_non_git_segment_is_left_alone() -> None:
+    assert rewriter.all_exclusion_prefixes("echo origin/main:.gitignore") == ()
+
+
+def test_quoted_message_token_carrying_a_slash_and_a_dot_is_left_alone() -> None:
+    command = "git commit -m \"don't touch a/b:.x\""
+    assert rewriter.all_exclusion_prefixes(command) == ()
+    assert rewriter.command_with_exclusion_export(command) == command
+
+
+def test_url_token_in_a_curl_command_is_left_alone() -> None:
+    assert rewriter.all_exclusion_prefixes("curl https://example.com/x") == ()
+
+
+def test_git_segment_after_a_non_git_segment_still_contributes() -> None:
+    assert rewriter.all_exclusion_prefixes(
+        "echo start && git show origin/main:.gitignore"
+    ) == ("origin/main:",)
+
+
+def test_main_emits_an_allow_carrying_the_rewritten_command() -> None:
+    emitted_text = _stdout_from_main(
+        {
+            "tool_name": "Bash",
+            "tool_input": {"command": SETTINGS_SHOW_COMMAND, "description": "read settings"},
+        }
+    )
+    assert json.loads(emitted_text) == {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": "allow",
+            "updatedInput": {
+                "command": SETTINGS_SHOW_REWRITTEN,
+                "description": "read settings",
+            },
+        }
+    }
+
+
+def test_main_emits_nothing_for_a_non_bash_tool() -> None:
+    emitted_text = _stdout_from_main(
+        {"tool_name": "PowerShell", "tool_input": {"command": SETTINGS_SHOW_COMMAND}}
+    )
+    assert emitted_text == ""
+
+
+def test_main_emits_nothing_for_a_command_with_no_collected_prefix() -> None:
+    emitted_text = _stdout_from_main(
+        {"tool_name": "Bash", "tool_input": {"command": "git show HEAD:.gitignore"}}
+    )
+    assert emitted_text == ""

package/hooks/hooks.json

@@ -12,6 +12,16 @@
           }
         ]
       },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/bash_pre_tool_use_dispatcher.py",
+            "timeout": 60
+          }
+        ]
+      },
       {
         "matcher": "EnterWorktree",
         "hooks": [

package/hooks/hooks_constants/bash_post_call_dispatcher_constants.py

@@ -5,6 +5,10 @@ finishes. Reuses ``BashHostedHookEntry`` and the Bash-only tool-name set from
 ``bash_pre_tool_use_dispatcher_constants`` -- the entry shape and the tool-name
 membership question are identical on the PostToolUse side, so this module adds
 no second copy of either.
+
+Also the one home for the harness PostToolUse output contract every hook on
+this roster shares: the exit-code prefix a failed call's response text opens
+with, and the three payload keys that carry a context note back to the agent.
 """
 
 from __future__ import annotations
@@ -17,8 +21,10 @@ from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
 
 __all__ = [
     "ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES",
+    "EXIT_CODE_ERROR_PREFIX",
     "POST_TOOL_USE_HOOK_EVENT_NAME",
     "HOOK_SPECIFIC_OUTPUT_KEY",
+    "HOOK_EVENT_NAME_KEY",
     "ADDITIONAL_CONTEXT_KEY",
     "ADDITIONAL_CONTEXT_JOIN_SEPARATOR",
 ]
@@ -26,9 +32,12 @@ __all__ = [
 ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = (
     BashHostedHookEntry("observability/test_failure_recorder.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("advisory/pr_done_reminder.py", ALL_BASH_AND_POWERSHELL_TOOL_NAMES),
+    BashHostedHookEntry("advisory/msys_path_conversion_advisor.py", ALL_BASH_ONLY_TOOL_NAMES),
 )
 
+EXIT_CODE_ERROR_PREFIX: str = "Error: Exit code "
 POST_TOOL_USE_HOOK_EVENT_NAME: str = "PostToolUse"
 HOOK_SPECIFIC_OUTPUT_KEY: str = "hookSpecificOutput"
+HOOK_EVENT_NAME_KEY: str = "hookEventName"
 ADDITIONAL_CONTEXT_KEY: str = "additionalContext"
 ADDITIONAL_CONTEXT_JOIN_SEPARATOR: str = "\n\n"

package/hooks/hooks_constants/bash_pre_tool_use_dispatcher_constants.py

@@ -54,4 +54,9 @@ class BashHostedHookEntry:
     applicable_tool_names: frozenset[str]
 
 
-ALL_BASH_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = ()
+ALL_BASH_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = (
+    BashHostedHookEntry(
+        script_relative_path="blocking/msys_rev_path_rewriter.py",
+        applicable_tool_names=ALL_BASH_ONLY_TOOL_NAMES,
+    ),
+)

package/hooks/hooks_constants/msys_path_conversion_advisor_constants.py

@@ -0,0 +1,48 @@
+"""Constants for the MSYS path-conversion context advisory.
+
+The advisory is a PostToolUse observer on Bash. It never blocks. When a git
+call fails because Git Bash rewrote a ``<rev>:<path>`` argument before git saw
+it, the advisory adds one loud note naming the two exports that turn the
+rewriting off.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "ALL_MANGLED_ARGUMENT_MARKERS",
+    "MANGLED_ARGUMENT_CLOSING_QUOTE",
+    "ALL_MSYS_MANGLING_CHARACTERS",
+    "ALL_MSYS_PATH_CONVERSION_VARIABLE_NAMES",
+    "ADVISORY_HEADER",
+    "MANGLED_ARGUMENT_LINE_TEMPLATE",
+    "MANGLING_EXPLANATION_LINE",
+    "FIX_LINE",
+    "SAME_COMMAND_LINE",
+    "ADVISORY_LINE_SEPARATOR",
+]
+
+AMBIGUOUS_ARGUMENT_MARKER: str = "fatal: ambiguous argument '"
+INVALID_OBJECT_NAME_MARKER: str = "fatal: invalid object name '"
+ALL_MANGLED_ARGUMENT_MARKERS: tuple[str, ...] = (
+    AMBIGUOUS_ARGUMENT_MARKER,
+    INVALID_OBJECT_NAME_MARKER,
+)
+MANGLED_ARGUMENT_CLOSING_QUOTE: str = "'"
+ALL_MSYS_MANGLING_CHARACTERS: frozenset[str] = frozenset({"\\", ";"})
+MSYS_PATH_CONVERSION_VARIABLE_NAME: str = "MSYS_NO_PATHCONV"
+MSYS_ARGUMENT_CONVERSION_EXCLUSION_VARIABLE_NAME: str = "MSYS2_ARG_CONV_EXCL"
+ALL_MSYS_PATH_CONVERSION_VARIABLE_NAMES: tuple[str, ...] = (
+    MSYS_PATH_CONVERSION_VARIABLE_NAME,
+    MSYS_ARGUMENT_CONVERSION_EXCLUSION_VARIABLE_NAME,
+)
+MSYS_EXPORT_FIX_LINE: str = "export MSYS_NO_PATHCONV=1 MSYS2_ARG_CONV_EXCL='*'"
+
+ADVISORY_HEADER: str = "=== MSYS PATH CONVERSION (context reminder, never a block) ==="
+MANGLED_ARGUMENT_LINE_TEMPLATE: str = "Git saw:     {argument}"
+MANGLING_EXPLANATION_LINE: str = (
+    "Git Bash rewrote a <rev>:<path> argument before git saw it, turning the "
+    "colon into a semicolon and the slashes into backslashes."
+)
+FIX_LINE: str = "Fix:         " + MSYS_EXPORT_FIX_LINE
+SAME_COMMAND_LINE: str = "Put that export and the git command in the same command."
+ADVISORY_LINE_SEPARATOR: str = "\n"

package/hooks/hooks_constants/msys_rev_path_rewriter_constants.py

@@ -0,0 +1,37 @@
+"""Constants for the MSYS ``<rev>:<path>`` argument-exclusion rewriter.
+
+Git Bash converts a git argument such as ``origin/main:.claude/settings.json``
+before git sees it. ``MSYS2_ARG_CONV_EXCL`` takes a semicolon-separated list of
+argument prefixes to leave alone, so naming one ``<rev>:`` prefix per detected
+token keeps every other argument in the command converting as before.
+"""
+
+from __future__ import annotations
+
+from hooks_constants.msys_path_conversion_advisor_constants import (
+    MSYS_ARGUMENT_CONVERSION_EXCLUSION_VARIABLE_NAME,
+)
+
+__all__ = [
+    "GIT_PROGRAM_NAME",
+    "REVISION_PATH_SEPARATOR",
+    "REVISION_PATH_SPLIT_COUNT",
+    "REVISION_SLASH_CHARACTER",
+    "ALL_CONVERTED_PATH_START_CHARACTERS",
+    "ALL_UNCONVERTED_PATH_START_PREFIXES",
+    "ALL_REVISION_FORBIDDEN_CHARACTERS",
+    "EXCLUSION_PREFIX_JOIN_SEPARATOR",
+    "EXCLUSION_EXPORT_TEMPLATE",
+]
+
+GIT_PROGRAM_NAME: str = "git"
+REVISION_PATH_SEPARATOR: str = ":"
+REVISION_PATH_SPLIT_COUNT: int = 1
+REVISION_SLASH_CHARACTER: str = "/"
+ALL_CONVERTED_PATH_START_CHARACTERS: tuple[str, ...] = ("/", ".")
+ALL_UNCONVERTED_PATH_START_PREFIXES: tuple[str, ...] = ("./", "../")
+ALL_REVISION_FORBIDDEN_CHARACTERS: tuple[str, ...] = ("'", '"')
+EXCLUSION_PREFIX_JOIN_SEPARATOR: str = ";"
+EXCLUSION_EXPORT_TEMPLATE: str = (
+    "export " + MSYS_ARGUMENT_CONVERSION_EXCLUSION_VARIABLE_NAME + "='{all_prefixes}'; "
+)

package/hooks/hooks_constants/post_tool_use_context.py

@@ -0,0 +1,34 @@
+"""Shared stdout emitter for PostToolUse hooks that add context."""
+
+from __future__ import annotations
+
+import json
+import sys
+
+from hooks_constants.bash_post_call_dispatcher_constants import (
+    ADDITIONAL_CONTEXT_KEY,
+    HOOK_EVENT_NAME_KEY,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+    POST_TOOL_USE_HOOK_EVENT_NAME,
+)
+
+
+def write_post_tool_use_context_to_stdout(context_text: str) -> None:
+    """Write one PostToolUse additionalContext payload to stdout.
+
+    A hosted hook writes its note here and the Bash PostToolUse dispatcher
+    reads it back, joins it with the other hooks' notes, and writes the joined
+    text here in turn. Both ends of that hop share this one payload shape
+    rather than each carrying a copy of it.
+
+    Args:
+        context_text: The advisory text the dispatcher forwards.
+    """
+    payload = {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            HOOK_EVENT_NAME_KEY: POST_TOOL_USE_HOOK_EVENT_NAME,
+            ADDITIONAL_CONTEXT_KEY: context_text,
+        }
+    }
+    sys.stdout.write(json.dumps(payload))
+    sys.stdout.flush()

package/hooks/hooks_constants/pr_done_reminder_constants.py

@@ -19,7 +19,6 @@ __all__ = [
     "ALL_GH_PR_VIEW_ARGUMENTS",
     "GH_PR_VIEW_TIMEOUT_SECONDS",
     "NO_PULL_REQUEST_MARKER",
-    "EXIT_CODE_ERROR_PREFIX",
     "DONE_LABEL_NAME",
     "MERGEABLE_CLEAN_VALUE",
     "MERGEABLE_CONFLICTING_VALUE",
@@ -59,7 +58,6 @@ ALL_GH_PR_VIEW_ARGUMENTS: tuple[str, ...] = (
 )
 GH_PR_VIEW_TIMEOUT_SECONDS: int = 20
 NO_PULL_REQUEST_MARKER: str = "no pull requests found"
-EXIT_CODE_ERROR_PREFIX: str = "Error: Exit code "
 
 DONE_LABEL_NAME: str = "done"
 

package/hooks/hooks_constants/pre_tool_use_allow_output.py

@@ -0,0 +1,48 @@
+"""Shared stdout emitter for PreToolUse hooks that allow a rewritten tool input."""
+
+from __future__ import annotations
+
+import json
+import sys
+
+from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
+    ALLOW_DECISION,
+    HOOK_EVENT_NAME,
+)
+
+__all__ = [
+    "HOOK_SPECIFIC_OUTPUT_KEY",
+    "HOOK_EVENT_NAME_KEY",
+    "PERMISSION_DECISION_KEY",
+    "UPDATED_INPUT_KEY",
+    "write_pre_tool_use_allow_to_stdout",
+]
+
+HOOK_SPECIFIC_OUTPUT_KEY: str = "hookSpecificOutput"
+HOOK_EVENT_NAME_KEY: str = "hookEventName"
+PERMISSION_DECISION_KEY: str = "permissionDecision"
+UPDATED_INPUT_KEY: str = "updatedInput"
+
+
+def write_pre_tool_use_allow_to_stdout(
+    all_updated_tool_input_fields: dict[str, object],
+) -> None:
+    """Write one PreToolUse allow payload carrying a rewritten tool input.
+
+    A rewriter writes its replacement input here and the Bash PreToolUse
+    dispatcher reads it back, carrying the updatedInput through to the harness.
+    Both ends of that hop share this one payload shape rather than each holding
+    a copy of it.
+
+    Args:
+        all_updated_tool_input_fields: The full tool_input the tool call should run with.
+    """
+    payload = {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            HOOK_EVENT_NAME_KEY: HOOK_EVENT_NAME,
+            PERMISSION_DECISION_KEY: ALLOW_DECISION,
+            UPDATED_INPUT_KEY: all_updated_tool_input_fields,
+        }
+    }
+    sys.stdout.write(json.dumps(payload))
+    sys.stdout.flush()

package/hooks/hooks_constants/test_bash_post_call_dispatcher_constants.py

@@ -7,22 +7,29 @@ from hooks_constants.bash_post_call_dispatcher_constants import (
 from hooks_constants.bash_pre_tool_use_dispatcher_constants import BASH_TOOL_NAME
 
 
-def test_roster_runs_the_recorder_then_the_pr_done_reminder() -> None:
+def test_roster_runs_the_recorder_then_the_pr_reminder_then_the_msys_advisor() -> None:
     all_script_paths = [
         each_entry.script_relative_path for each_entry in ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES
     ]
     assert all_script_paths == [
         "observability/test_failure_recorder.py",
         "advisory/pr_done_reminder.py",
+        "advisory/msys_path_conversion_advisor.py",
     ]
 
 
 def test_pr_done_reminder_also_serves_the_powershell_tool() -> None:
-    reminder_entry = ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES[-1]
+    reminder_entry = ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES[1]
     assert reminder_entry.script_relative_path == "advisory/pr_done_reminder.py"
     assert "PowerShell" in reminder_entry.applicable_tool_names
 
 
+def test_msys_advisor_serves_the_bash_tool_only() -> None:
+    advisor_entry = ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES[-1]
+    assert advisor_entry.script_relative_path == "advisory/msys_path_conversion_advisor.py"
+    assert advisor_entry.applicable_tool_names == frozenset({"Bash"})
+
+
 def test_context_forwarding_keys_match_the_hook_output_contract() -> None:
     assert constants.POST_TOOL_USE_HOOK_EVENT_NAME == "PostToolUse"
     assert constants.HOOK_SPECIFIC_OUTPUT_KEY == "hookSpecificOutput"