claude-dev-env 7.4.1 → 7.6.0

package/hooks/blocking/code_rules_comments.py

@@ -30,6 +30,7 @@ from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
     ALL_TOKEN_ANCHORED_EXEMPT_COMMENT_BODIES,
     CHAINED_INLINE_COMMENT_PATTERN,
     MAX_COMMENT_ISSUES,
+    STEALTH_KEEP_COMMENT_MARKER,
 )
 _javascript_comment_scanner = importlib.import_module("javascript_comment_scanner")
 extract_javascript_comment_occurrences = (
@@ -152,10 +153,36 @@ def _python_comment_occurrences(
     return all_occurrences, True
 
 
+def _is_stealth_keep_occurrence(comment_text: str) -> bool:
+    """Return True for a ``# STEALTH: Keep`` occurrence.
+
+    ``STEALTH: Keep`` is meant to be freely added and to survive edits to
+    the line it sits on, unlike ``noqa`` or ``TODO``, which AGENTS.md
+    requires to be removed rather than added or justified. It is excluded
+    here rather than through the shared exempt-marker set that
+    ``check_comment_changes`` deliberately still blocks on add.
+    """
+    return comment_text.startswith("#") and comment_text[1:].lstrip().startswith(
+        STEALTH_KEEP_COMMENT_MARKER
+    )
+
+
+def _without_stealth_keep_occurrences(
+    all_occurrences: list[tuple[str, int, bool]]
+) -> list[tuple[str, int, bool]]:
+    return [
+        each_occurrence
+        for each_occurrence in all_occurrences
+        if not _is_stealth_keep_occurrence(each_occurrence[0])
+    ]
+
+
 def check_comment_changes(old_content: str, new_content: str, file_path: str) -> list[str]:
     """Check for comment additions or removals between old and new content.
 
-    Inline and standalone comments are blocking findings when added.
+    Inline and standalone comments are blocking findings when added, except
+    ``STEALTH: Keep`` occurrences, which are excluded entirely so the marker
+    can be added and can persist across edits to its line.
     Existing comments can be removed when the touched code no longer needs them.
 
     When the file is Python and either *old_content* or *new_content* cannot
@@ -178,6 +205,9 @@ def check_comment_changes(old_content: str, new_content: str, file_path: str) ->
         old_occurrences = extract_javascript_comment_occurrences(old_content, True)
         new_occurrences = extract_javascript_comment_occurrences(new_content, True)
 
+    old_occurrences = _without_stealth_keep_occurrences(old_occurrences)
+    new_occurrences = _without_stealth_keep_occurrences(new_occurrences)
+
     old_occurrence_counts = Counter(
         (each_text, is_inline)
         for each_text, _line_number, is_inline in old_occurrences
@@ -264,6 +294,8 @@ def _retained_comment_issues(
     (old_occurrences, old_tokenize_ok), (new_occurrences, new_tokenize_ok) = (_comment_occurrences(old_content, file_path, True), _comment_occurrences(new_content, file_path, True))
     if not (old_tokenize_ok and new_tokenize_ok):
         return []
+    old_occurrences = _without_stealth_keep_occurrences(old_occurrences)
+    new_occurrences = _without_stealth_keep_occurrences(new_occurrences)
     all_changed_lines, all_deleted_lines, old_line_by_new_line = _line_diff_data(old_content, new_content)
     old_line_by_key = {
         each_key: [each_line for each_text, each_line, each_is_inline in old_occurrences if (each_text, each_is_inline) == each_key]
@@ -346,12 +378,14 @@ def _is_exempt_python_comment(comment_token: tokenize.TokenInfo) -> bool:
     token-anchored directive body never legitimately carries a ``#``
     (noqa codes, pylint symbols, and pragma directives contain none), so
     any inner ``#`` reliably marks chained prose. Free-form markers
-    (``type:``, ``TODO``, ``FIXME``, ``HACK``, ``XXX``) accept any
-    trailing prose:
+    (``type:``, ``TODO``, ``FIXME``, ``HACK``, ``XXX``, ``STEALTH: Keep``)
+    accept any trailing prose:
     ``# type:`` participates in the documented justification
     convention enforced by ``check_type_escape_hatches`` (which
-    requires a trailing reason), and the TODO-family markers carry
-    annotation text by convention.
+    requires a trailing reason), the TODO-family markers carry
+    annotation text by convention, and ``STEALTH: Keep`` is the
+    acknowledged-bypass marker the CDP runtime-usage scanner reads
+    from the flagged line together with its reason.
     """
     comment_string = comment_token.string
     if comment_string.startswith("#!") and comment_token.start == (1, 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/pii_prevention_blocker_parts/repository_exemption.py

@@ -16,6 +16,8 @@ import sys
 from pathlib import Path
 from urllib.parse import urlparse
 
+from hooks_constants.subprocess_window import hidden_window_creation_flags
+
 try:
     _blocking_directory = str(Path(__file__).resolve().parent.parent)
     _hooks_directory = str(Path(__file__).resolve().parent.parent.parent)
@@ -186,6 +188,7 @@ def _repository_origin_slug(repository_root: Path) -> str | None:
             text=True,
             timeout=GIT_COMMAND_TIMEOUT_SECONDS,
             cwd=str(repository_root),
+            creationflags=hidden_window_creation_flags(),
         )
     except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
         return None

package/hooks/blocking/precommit_code_rules_gate.py

@@ -18,6 +18,8 @@ from hooks_constants.precommit_code_rules_gate_constants import (  # noqa: E402
     GIT_COMMAND_TIMEOUT_SECONDS,
 )
 
+from hooks_constants.subprocess_window import hidden_window_creation_flags
+
 
 def resolve_repository_root(working_directory: str | None) -> Path | None:
     """Resolve the Git repository root for a directory.
@@ -36,6 +38,7 @@ def resolve_repository_root(working_directory: str | None) -> Path | None:
             text=True,
             timeout=GIT_COMMAND_TIMEOUT_SECONDS,
             cwd=working_directory,
+            creationflags=hidden_window_creation_flags(),
         )
     except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
         return None

package/hooks/blocking/tdd_enforcer_parts/content_analysis.py

@@ -30,6 +30,10 @@ def _safe_constant_attribute_calls() -> frozenset[tuple[str, str]]:
     return frozenset({("re", "compile")})
 
 
+def _safe_string_literal_methods() -> frozenset[str]:
+    return frozenset({"join"})
+
+
 def _node_is_unsafe_construct(subnode: ast.AST) -> bool:
     return isinstance(
         subnode,
@@ -37,7 +41,18 @@ def _node_is_unsafe_construct(subnode: ast.AST) -> bool:
     )
 
 
+def _is_safe_string_literal_method_call(function_node: ast.Attribute) -> bool:
+    receiver = function_node.value
+    return (
+        isinstance(receiver, ast.Constant)
+        and isinstance(receiver.value, str)
+        and function_node.attr in _safe_string_literal_methods()
+    )
+
+
 def _attribute_call_is_unsafe(function_node: ast.Attribute) -> bool:
+    if _is_safe_string_literal_method_call(function_node):
+        return False
     if not isinstance(function_node.value, ast.Name):
         return True
     pair = (function_node.value.id, function_node.attr)
@@ -56,9 +71,10 @@ def _call_is_unsafe(call_node: ast.Call) -> bool:
 def _rhs_has_unsafe_call(rhs_node: ast.AST) -> bool:
     """Return True when a constant's value contains a non-allowlisted call.
 
-    Safe calls are value constructors (``Path(...)``, ``re.compile(...)``) that
-    build objects without side effects; any other call or a comprehension reads
-    as import-time behavior.
+    Safe calls are value constructors (``Path(...)``, ``re.compile(...)``) and
+    a pure string-literal method call (``"|".join(...)``) that build objects
+    without side effects; any other call or a comprehension reads as
+    import-time behavior.
 
     Args:
         rhs_node: The assignment's right-hand-side expression node.

package/hooks/blocking/tdd_enforcer_parts/git_tracking.py

@@ -29,6 +29,8 @@ from tdd_enforcer_parts.config.tdd_enforcer_constants import (
     GIT_PATHSPEC_SEPARATOR,
 )
 
+from hooks_constants.subprocess_window import hidden_window_creation_flags
+
 
 def _git_ls_files_command(file_name: str) -> list[str]:
     return [GIT_EXECUTABLE_NAME, GIT_LS_FILES_SUBCOMMAND, GIT_PATHSPEC_SEPARATOR, file_name]
@@ -57,6 +59,7 @@ def _git_tracks_path(path: Path) -> bool:
             text=True,
             check=False,
             timeout=GIT_LS_FILES_TIMEOUT_SECONDS,
+            creationflags=hidden_window_creation_flags(),
         )
     except (OSError, subprocess.SubprocessError):
         return False
@@ -80,6 +83,7 @@ def _working_tree_differs_from_head(path: Path) -> bool:
             text=True,
             check=False,
             timeout=GIT_DIFF_TIMEOUT_SECONDS,
+            creationflags=hidden_window_creation_flags(),
         )
     except (OSError, subprocess.SubprocessError):
         return True

package/hooks/blocking/tdd_enforcer_parts/tests/test_content_analysis.py

@@ -12,6 +12,31 @@ def test_constants_only_rejects_function_definition() -> None:
     assert content_analysis._is_constants_only_python_content("def f():\n    return 1\n") is False
 
 
+def test_constants_only_accepts_join_on_a_string_literal_inside_re_compile() -> None:
+    content = (
+        '"""doc."""\n'
+        "import re\n"
+        "NAMES = ('one', 'two')\n"
+        'PATTERN = re.compile("(" + "|".join(NAMES) + ")")\n'
+    )
+    assert content_analysis._is_constants_only_python_content(content) is True
+
+
+def test_constants_only_rejects_join_on_a_non_literal_receiver() -> None:
+    content = (
+        '"""doc."""\n'
+        'SEPARATOR = "|"\n'
+        'NAMES = ("one", "two")\n'
+        "PATTERN = SEPARATOR.join(NAMES)\n"
+    )
+    assert content_analysis._is_constants_only_python_content(content) is False
+
+
+def test_constants_only_rejects_a_non_allowlisted_method_on_a_string_literal() -> None:
+    content = '"""doc."""\nSHOUT = "hi".upper()\n'
+    assert content_analysis._is_constants_only_python_content(content) is False
+
+
 def test_post_edit_import_only_allows_import_removal() -> None:
     existing = "import os\n\ndef run(): return 1\n"
     tool_input = {"old_string": "import os\n", "new_string": ""}

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_code_rules_enforcer_comment_string_awareness.py

@@ -133,6 +133,33 @@ def test_check_comment_changes_allows_comment_removal_without_advisory(
     assert captured.err == ""
 
 
+def test_check_comment_changes_does_not_flag_added_stealth_keep_marker() -> None:
+    old_content = "x = 1\n"
+    new_content = "x = 1  # STEALTH: Keep -- reason\n"
+    issues = code_rules_enforcer.check_comment_changes(old_content, new_content, "foo.py")
+    assert issues == []
+
+
+def test_check_comment_changes_does_not_flag_stealth_keep_retained_on_touched_line() -> None:
+    old_content = "x = 1  # STEALTH: Keep -- reason\n"
+    new_content = "x = 2  # STEALTH: Keep -- reason\n"
+    issues = code_rules_enforcer.check_comment_changes(old_content, new_content, "foo.py")
+    assert issues == []
+
+
+@pytest.mark.parametrize(
+    "each_marker",
+    ("# noqa: E501", "# type: ignore[misc]", "# TODO: revisit", "# FIXME: revisit"),
+)
+def test_check_comment_changes_still_flags_other_added_directive_markers(
+    each_marker: str,
+) -> None:
+    old_content = "x = 1\n"
+    new_content = f"x = 1  {each_marker}\n"
+    issues = code_rules_enforcer.check_comment_changes(old_content, new_content, "foo.py")
+    assert any("comment added" in each_issue.lower() for each_issue in issues)
+
+
 def test_python_check_should_exempt_directive_without_space_after_hash() -> None:
     for each_directive in ("#noqa", "#type: ignore", "#pylint: disable", "#pragma: no cover"):
         content = f"{each_directive}\n"

package/hooks/blocking/test_code_rules_enforcer_exempt_marker_chained.py

@@ -156,6 +156,16 @@ def test_should_exempt_fixme_with_trailing_prose() -> None:
     assert _is_exempt_python_comment(token) is True
 
 
+def test_should_exempt_stealth_keep_with_trailing_reason() -> None:
+    token = _build_comment_token("# STEALTH: Keep bypass reviewed in incident 4021")
+    assert _is_exempt_python_comment(token) is True
+
+
+def test_should_flag_stealth_marker_missing_required_space_after_colon() -> None:
+    token = _build_comment_token("# STEALTH:Keep bypass reviewed in incident 4021")
+    assert _is_exempt_python_comment(token) is False
+
+
 def test_should_exempt_shebang_at_line_one_column_zero() -> None:
     token = tokenize.TokenInfo(
         type=tokenize.COMMENT,

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/git-hooks/git_hooks_constants/verification_notice_constants.py

@@ -111,6 +111,4 @@ ALL_RUNNER_FIELDS: frozenset[str] = frozenset(
 )
 AUTOMATIC_ADVISORY_DIRECTORY_NAME: str = "automatic_advisory"
 AUTOMATIC_ADVISORY_CLI_FILE_NAME: str = "cli.py"
-WINDOWS_PLATFORM: str = "win32"
-CREATE_NO_WINDOW_ATTRIBUTE: str = "CREATE_NO_WINDOW"
 POWERSHELL_CALL_OPERATOR: str = "& "

package/hooks/git-hooks/pull_request_handoff.py

@@ -9,6 +9,8 @@ from git_hooks_constants import (
     GH_PR_VIEW_TIMEOUT_SECONDS,
 )
 
+from subprocess_window_access import hidden_window_creation_flags
+
 
 def get_pull_request_url(repo_dir: Path) -> str | None:
     try:
@@ -19,6 +21,7 @@ def get_pull_request_url(repo_dir: Path) -> str | None:
             capture_output=True,
             text=True,
             timeout=GH_PR_VIEW_TIMEOUT_SECONDS,
+            creationflags=hidden_window_creation_flags(),
         )
     except (OSError, subprocess.SubprocessError):
         return None