claude-dev-env 7.4.0 → 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',
@@ -3047,9 +3046,10 @@ test('the base install publishes the pstack poteto-mode entry into the managed s
 
     assert.equal(outcome.status, 'installed');
     assert.equal(outcome.warning, null);
-    const entryPath = join(fixture.managedRoot, 'skills', 'pstack-poteto-mode');
-    assert.equal(lstatSync(entryPath).isSymbolicLink(), true, 'the entry is a pointer into the release');
-    assert.equal(existsSync(join(entryPath, 'SKILL.md')), true, 'the pointer resolves to a skill');
+    const pstackRoot = join(fixture.managedRoot, 'skills', 'pstack');
+    const entryPath = join(pstackRoot, 'poteto-mode');
+    assert.equal(lstatSync(pstackRoot).isSymbolicLink(), true, 'the pstack root is a pointer into the release');
+    assert.equal(existsSync(join(entryPath, 'SKILL.md')), true, 'the nested entry resolves to a skill');
 });
 
 test('an unreachable pstack upstream reports a warning and keeps the base install going', t => {

package/bin/pstack.mjs

@@ -84,6 +84,17 @@ function adaptSkill(text, name, releaseRoot, skillRoot) {
         + fork + '\n' + match[2].trimStart();
 }
 
+function writePstackPluginManifest(stage, skills) {
+    const manifest = {
+        $schema: 'https://anthropic.com/claude-code/plugin.schema.json',
+        name: 'pstack',
+        skills: skills.filter(skill => skill.component === 'pstack').map(skill => `./${skill.slug}`),
+    };
+    const pluginRoot = join(stage, 'runtime', 'pstack', 'skills');
+    mkdirSync(join(pluginRoot, '.claude-plugin'), { recursive: true });
+    writeFileSync(join(pluginRoot, '.claude-plugin', 'plugin.json'), json(manifest));
+}
+
 export function prepareRelease(checkout, stage, finalRoot, lock, adapters) {
     const skills = [];
     const agents = [];
@@ -102,10 +113,11 @@ export function prepareRelease(checkout, stage, finalRoot, lock, adapters) {
         }
         for (const slug of names) {
             if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug)) throw new Error(`Invalid skill directory: ${slug}`);
-            const name = `${component}-${slug}`;
+            const name = component === 'pstack' ? `pstack:${slug}` : `${component}-${slug}`;
+            const frontmatterName = component === 'pstack' ? slug : name;
             const path = join('runtime', component, 'skills', slug);
             const text = readFileSync(join(source, 'skills', slug, 'SKILL.md'), 'utf8');
-            writeFileSync(join(stage, path, 'SKILL.md'), adaptSkill(text, name, finalRoot, join(finalRoot, path)));
+            writeFileSync(join(stage, path, 'SKILL.md'), adaptSkill(text, frontmatterName, finalRoot, join(finalRoot, path)));
             skills.push({ name, component, slug, path });
         }
         const agentHome = join(source, 'agents');
@@ -118,6 +130,7 @@ export function prepareRelease(checkout, stage, finalRoot, lock, adapters) {
     mkdirSync(join(stage, creatorPath), { recursive: true });
     writeFileSync(join(stage, creatorPath, 'SKILL.md'), adapters['create-skill.md']);
     skills.push({ name: 'cde-create-skill', component: 'cde', slug: 'create-skill', path: creatorPath });
+    writePstackPluginManifest(stage, skills);
     const knownNames = new Set(skills.map(skill => `${skill.component}:${skill.slug}`));
     for (const path of filesUnder(join(stage, 'upstream')).filter(path => path.endsWith('.md') && (path.includes(sep + 'skills' + sep) || path.includes(sep + 'agents' + sep)))) {
         const references = readFileSync(path, 'utf8').matchAll(/\b(pstack|cursor-team-kit):([a-z][a-z0-9-]*)/g);
@@ -146,7 +159,9 @@ export function verifyRelease(root) {
         if (digest(readFileSync(assertContained(root, path))) !== hash) throw new Error(`Changed installed file: ${path}`);
     }
     for (const skill of release.skills) {
-        if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(skill.name)) throw new Error('Invalid installed skill name');
+        const validPart = value => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
+        const expectedName = skill.component === 'pstack' ? `pstack:${skill.slug}` : `${skill.component}-${skill.slug}`;
+        if (!validPart(skill.component) || !validPart(skill.slug) || skill.name !== expectedName) throw new Error('Invalid installed skill name');
         const path = join(assertContained(root, skill.path), 'SKILL.md');
         if (!Object.hasOwn(release.fileDigests, relative(root, path)) || !existsSync(path)) throw new Error(`Missing entry: ${skill.name}`);
     }
@@ -177,7 +192,12 @@ export function verifyInstallation(options = {}) {
 
 function publish(releaseRoot, release, homes, prior) {
     const uniqueHomes = [...new Set(homes.map(home => { mkdirSync(home, { recursive: true }); return realpathSync(home); }))];
-    const links = Object.fromEntries(uniqueHomes.flatMap(home => release.skills.map(skill => [join(home, skill.name), join(releaseRoot, skill.path)])));
+    const pstackSkill = release.skills.find(skill => skill.component === 'pstack');
+    const directSkills = release.skills.filter(skill => skill.component !== 'pstack');
+    const links = Object.fromEntries(uniqueHomes.flatMap(home => [
+        ...(pstackSkill ? [[join(home, 'pstack'), join(releaseRoot, dirname(pstackSkill.path))]] : []),
+        ...directSkills.map(skill => [join(home, skill.name), join(releaseRoot, skill.path)]),
+    ]));
     const paths = new Set([...Object.keys(prior?.links ?? {}), ...Object.keys(links)]);
     const before = new Map();
     for (const path of paths) {

package/bin/pstack.test.mjs

@@ -44,15 +44,23 @@ for (const host of ['claude', 'codex', 'cursor']) {
         assert.equal(result.commit, '27e2a62ff94f9af4b5e68435e41cdceacadb840c');
         assert.equal(result.verification, 'filesystem-only');
         const release = join(f.store, 'releases', result.release);
-        const expected = ['cde-create-skill', 'cursor-team-kit-control-cli', 'cursor-team-kit-control-ui', 'cursor-team-kit-deslop', 'pstack-poteto-mode'];
+        const releaseManifest = JSON.parse(readFileSync(join(release, 'release.json'), 'utf8'));
+        assert.equal(releaseManifest.skills.find(skill => skill.component === 'pstack').name, 'pstack:poteto-mode');
+        const expected = ['cde-create-skill', 'cursor-team-kit-control-cli', 'cursor-team-kit-control-ui', 'cursor-team-kit-deslop', 'pstack'];
         for (const home of ['.claude', '.agents']) {
-            assert.deepEqual(readdirSync(join(f.options.project, home, 'skills')).sort(), expected);
-            const entry = join(f.options.project, home, 'skills', 'pstack-poteto-mode');
+            const skillsHome = join(f.options.project, home, 'skills');
+            assert.deepEqual(readdirSync(skillsHome).sort(), expected);
+            const pstackRoot = join(skillsHome, 'pstack');
+            assert.equal(lstatSync(pstackRoot).isSymbolicLink(), true);
+            const entry = join(pstackRoot, 'poteto-mode');
             assert.equal(realpathSync(entry), join(release, 'runtime', 'pstack', 'skills', 'poteto-mode'));
             const text = readFileSync(join(entry, 'SKILL.md'), 'utf8');
-            assert.match(text, /name: pstack-poteto-mode/);
+            assert.match(text, /name: poteto-mode/);
             assert.ok(text.includes(JSON.stringify(join(release, 'compat', 'common.md'))));
             assert.equal(readFileSync(join(entry, 'playbooks', 'feature.md'), 'utf8'), 'Build a small task, delegate, and verify it.\n');
+            const manifest = JSON.parse(readFileSync(join(pstackRoot, '.claude-plugin', 'plugin.json'), 'utf8'));
+            assert.equal(manifest.name, 'pstack');
+            assert.deepEqual(manifest.skills, ['./poteto-mode']);
         }
         assert.equal(existsSync(join(f.options.project, '.cursor')), false);
         for (const component of baseLock.components) {
@@ -89,10 +97,12 @@ test('changed, added, and removed skills converge while old releases remain read
     const after = installPstack({ ...f.options, lock: { ...baseLock, commit: 'b'.repeat(40) } }, f.dependencies);
     assert.equal(after.skillCount, 6);
     for (const home of ['.claude', '.agents']) {
-        const path = join(f.options.project, home, 'skills');
-        assert.equal(existsSync(join(path, 'pstack-old')), false);
-        assert.equal(readFileSync(join(path, 'pstack-new', 'SKILL.md'), 'utf8').endsWith('New body.\n'), true);
-        assert.equal(readFileSync(join(path, 'pstack-poteto-mode', 'playbooks', 'feature.md'), 'utf8'), 'Changed playbook.\n');
+        const pstackRoot = join(f.options.project, home, 'skills', 'pstack');
+        assert.equal(existsSync(join(pstackRoot, 'old')), false);
+        assert.equal(readFileSync(join(pstackRoot, 'new', 'SKILL.md'), 'utf8').endsWith('New body.\n'), true);
+        assert.equal(readFileSync(join(pstackRoot, 'poteto-mode', 'playbooks', 'feature.md'), 'utf8'), 'Changed playbook.\n');
+        const manifest = JSON.parse(readFileSync(join(pstackRoot, '.claude-plugin', 'plugin.json'), 'utf8'));
+        assert.deepEqual(manifest.skills, ['./new', './poteto-mode']);
     }
     assert.equal(readFileSync(join(oldRelease, 'runtime', 'pstack', 'skills', 'poteto-mode', 'SKILL.md'), 'utf8'), firstBody);
 });
@@ -117,9 +127,9 @@ test('a failed first install returns failure and publishes no skills', t => {
     assert.equal(existsSync(join(f.store, '.install-lock')), false);
 });
 
-test('unmanaged skill collision preserves user files', t => {
+test('unmanaged pstack root collision preserves user files', t => {
     const f = fixture(t);
-    const userFile = join(f.options.project, '.claude', 'skills', 'pstack-poteto-mode', 'SKILL.md');
+    const userFile = join(f.options.project, '.claude', 'skills', 'pstack', 'poteto-mode', 'SKILL.md');
     put(userFile, 'Personal workflow\n');
     assert.throws(() => installPstack(f.options, f.dependencies), /Keep existing unmanaged path/);
     assert.equal(readFileSync(userFile, 'utf8'), 'Personal workflow\n');

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) == ""
+