claude-dev-env 8.2.0 → 8.3.0

package/rules/testing.md

@@ -26,5 +26,3 @@ Tests exercise production behavior, production data, and production code paths.
 ## No Gate Holds the Test-First Order
 
 `tdd_enforcer.py` once required a fresh, failing test before a production module was written. Nothing runs it now, and the staged policy lint carries no replacement. Hold the red-green-refactor order yourself, and let review check it on the diff.
-
-`hooks/observability/test_failure_recorder.py` still runs on every Bash call. It records a single unchained pytest run that names a test file path and reports a failing exit status, storing the command, that exit status, and the path in the content-hash store. `content_hash_store.py`'s module docstring holds the full contract. No gate reads that store today, so the record serves as history rather than a precondition.

package/scripts/dev_env_scripts_constants/grok_worker_constants.py

@@ -85,14 +85,14 @@ ROLE_BUGTEAM: str = "bugteam"
 """Role name whose agent definition set the preflight validates by default."""
 
 ROLE_CLEAN_CODER: str = "clean-coder"
-"""Role name that maps to the clean-coder agent for FIX and standards-fix."""
+"""Compatibility role for FIX and standards-fix using poteto-agent."""
 
 DEFAULT_ROLE: str = ROLE_BUGTEAM
 """Role applied when the caller does not pass ``--role``."""
 
 ALL_AGENT_FILENAMES_BY_ROLE: dict[str, tuple[str, ...]] = {
-    ROLE_BUGTEAM: ("code-quality-agent.md", "clean-coder.md"),
-    ROLE_CLEAN_CODER: ("clean-coder.md",),
+    ROLE_BUGTEAM: ("poteto-agent.md",),
+    ROLE_CLEAN_CODER: ("poteto-agent.md",),
 }
 """Agent definition filenames required under ``agents/`` for each known role."""
 

package/scripts/grok_headless_runner.py

@@ -19,7 +19,7 @@ Import ``run_headless_worker`` for the outcome object::
         working_directory=cwd,
         run_state_directory=run_dir,
         timeout_seconds=5400,
-        agent_name="code-quality-agent",
+        agent_name="poteto-agent",
     )
 """
 
@@ -72,6 +72,7 @@ from dev_env_scripts_constants.grok_worker_constants import (
     WORKER_SPEC_TIMEOUT_KEY,
 )
 from shared_tree_paths import resolve_shared_process_tree_scripts_directory
+from grok_worker_preflight import poteto_mode_skill_path
 
 _shared_process_tree_scripts_directory = resolve_shared_process_tree_scripts_directory(
     __file__,
@@ -420,6 +421,23 @@ def run_headless_worker(
         if leader_socket_path is not None
         else _mint_leader_socket_path(run_state_directory)
     )
+    if agent_name == "poteto-agent":
+        try:
+            skill_path = poteto_mode_skill_path().resolve()
+            skill_text = skill_path.read_text(encoding=UTF8_ENCODING)
+            task_text = prompt_file.read_text(encoding=UTF8_ENCODING)
+            run_state_directory.mkdir(parents=True, exist_ok=True)
+            prompt_file = run_state_directory / f"{resolved_leader_socket_path.stem}-poteto.txt"
+            prompt_file.write_text(
+                f"Poteto skill source: {skill_path}\n"
+                "Resolve companion skill paths against that source directory.\n"
+                "The task below defines your review, build, or translation duty. "
+                "Preserve its scope, write permissions, and report contract.\n\n"
+                f"{skill_text}\n\nTask:\n{task_text}",
+                encoding=UTF8_ENCODING,
+            )
+        except OSError as error:
+            return _launch_failure_outcome(error)
     all_arguments = _build_invocation(
         prompt_file=prompt_file,
         working_directory=working_directory,

package/scripts/grok_worker_preflight.py

@@ -45,6 +45,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import shutil
 import subprocess
 import sys
@@ -61,6 +62,7 @@ from dev_env_scripts_constants.grok_worker_constants import (
     CLAUDE_HOME_SUBDIRECTORY,
     CLI_PING_FLAG,
     CLI_ROLE_FLAG,
+    CLAUDE_CONFIG_DIR_ENV_VAR,
     CLI_RUN_STATE_DIR_FLAG,
     DEFAULT_AUTH_TIMEOUT_SECONDS,
     DEFAULT_PING_TIMEOUT_SECONDS,
@@ -111,7 +113,67 @@ class PreflightOutcome:
 
 def claude_config_home() -> Path:
     """Return the per-user Claude configuration directory."""
-    return Path.home() / CLAUDE_HOME_SUBDIRECTORY
+    configured_root = os.environ.get(CLAUDE_CONFIG_DIR_ENV_VAR)
+    return Path(configured_root) if configured_root else Path.home() / CLAUDE_HOME_SUBDIRECTORY
+
+
+def _read_pstack_registry(registry_path: Path) -> dict[str, object]:
+    try:
+        registry = json.loads(registry_path.read_text(encoding=UTF8_ENCODING))
+    except (UnicodeError, json.JSONDecodeError) as error:
+        raise OSError(f"Invalid pstack installation registry {registry_path}: {error}") from error
+    if not isinstance(registry, dict):
+        raise OSError(f"Invalid pstack installation registry {registry_path}: root must be an object")
+    return registry
+
+
+def _user_pstack_entries(all_registry: dict[str, object], registry_path: Path) -> list[dict[str, object]]:
+    plugins = all_registry.get("plugins")
+    if not isinstance(plugins, dict):
+        raise OSError(f"Invalid pstack installation registry {registry_path}: plugins must be an object")
+    entries = plugins.get("pstack@pstack-claude", [])
+    if not isinstance(entries, list) or any(not isinstance(entry, dict) for entry in entries):
+        raise OSError(f"Invalid pstack installation registry {registry_path}: pstack entries must be objects")
+    user_entries = [entry for entry in entries if entry.get("scope") == "user"]
+    if len(user_entries) > 1:
+        raise OSError(f"Invalid pstack installation registry {registry_path}: multiple user pstack installations")
+    return user_entries
+
+
+def _native_pstack_skill_path(registry_path: Path, fallback_path: Path) -> Path:
+    if not registry_path.exists():
+        return fallback_path
+    user_entries = _user_pstack_entries(_read_pstack_registry(registry_path), registry_path)
+    if not user_entries:
+        return fallback_path
+    install_path = user_entries[0].get("installPath")
+    if not isinstance(install_path, str) or not Path(install_path).is_absolute():
+        raise OSError(f"Invalid pstack installation registry {registry_path}: pstack installPath must be absolute")
+    return Path(install_path) / "skills" / "poteto-mode" / "SKILL.md"
+
+
+def poteto_mode_skill_path() -> Path:
+    """Return the selected installed pstack poteto-mode skill path.
+
+    Returns:
+        The validated poteto-mode skill path.
+
+    Raises:
+        OSError: If the registry or selected skill is invalid.
+    """
+    config_root = claude_config_home()
+    fallback_path = config_root / "skills" / "poteto-mode" / "SKILL.md"
+    skill_path = _native_pstack_skill_path(
+        config_root / "plugins" / "installed_plugins.json",
+        fallback_path,
+    )
+    try:
+        skill_text = skill_path.read_text(encoding=UTF8_ENCODING)
+    except UnicodeError as error:
+        raise OSError(f"Invalid UTF-8 poteto skill {skill_path}") from error
+    if not skill_text.strip():
+        raise OSError(f"Empty poteto skill {skill_path}")
+    return skill_path
 
 
 def _install_manifest_path() -> Path:
@@ -218,6 +280,10 @@ def _is_grok_binary_resolvable() -> bool:
 def _is_claude_dev_env_config_present(role: str) -> bool:
     if not _install_manifest_path().is_file():
         return False
+    try:
+        poteto_mode_skill_path()
+    except OSError:
+        return False
     all_agent_filenames = ALL_AGENT_FILENAMES_BY_ROLE.get(role)
     if all_agent_filenames is None:
         return False

package/scripts/resolve_advisor_model_route.mjs

@@ -36,14 +36,14 @@ if (input !== undefined) {
         routingDecision = routingInputIssue
             ? blockedRoute(routingInputIssue)
             : resolveSubagentModelRoute({
-                agent_type: 'session-advisor',
+                agent_type: 'advisor',
                 ...(input.model !== undefined && input.model !== null ? { model: input.model } : {}),
                 ...(input.reasoning_effort !== undefined ? { reasoning_effort: input.reasoning_effort } : {}),
             }, {
                 policyPath: input.policyPath,
                 trustedSessionMetadata: {
                     authorized: true,
-                    registeredAgentType: 'session-advisor',
+                    registeredAgentType: 'advisor',
                 },
             });
     }

package/scripts/subagent_model_policy.mjs

@@ -298,7 +298,10 @@ function validateRoles(roles) {
         const aliases = validateStringList(roles[role], `roles.${role}`).map(normalizeToken);
         const allAliases = [role, ...aliases];
         for (const alias of allAliases) {
-            if (!isIdentifier(alias)) throw new SubagentModelPolicyError(`invalid role name: ${alias}`);
+            const roleParts = alias.split(':');
+            if (roleParts.length > 2 || !roleParts.every(isIdentifier)) {
+                throw new SubagentModelPolicyError(`invalid role name: ${alias}`);
+            }
             const previousRole = roleByAlias.get(alias);
             if (previousRole && previousRole !== role) {
                 throw new SubagentModelPolicyError(`role alias is ambiguous: ${alias}`);

package/scripts/test_grok_headless_runner.py

@@ -7,6 +7,7 @@ include the signature substrings the constants module lists.
 
 from __future__ import annotations
 
+import json
 import subprocess
 import sys
 import time
@@ -336,7 +337,11 @@ def test_argv_includes_agent_when_named(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
     fake_process = _FakeProcess(returncode=0, stdout='{"ok":true}')
-    agent_name = "code-quality-agent"
+    agent_name = "poteto-agent"
+    skill_path = tmp_path / "poteto-mode" / "SKILL.md"
+    skill_path.parent.mkdir()
+    skill_path.write_text("Keep the requested duty.\n", encoding="utf-8")
+    monkeypatch.setattr(runner, "poteto_mode_skill_path", lambda: skill_path)
     outcome, recorder, _, _, _ = _run_once(
         monkeypatch, tmp_path, fake_process, agent_name=agent_name
     )
@@ -345,6 +350,35 @@ def test_argv_includes_agent_when_named(
     invocation = recorder.invocations[0]
     assert AGENT_FLAG in invocation
     assert agent_name in invocation
+    generated_prompt = Path(invocation[invocation.index(PROMPT_FILE_FLAG) + 1])
+    assert "Keep the requested duty." in generated_prompt.read_text(encoding="utf-8")
+    assert str(skill_path) in generated_prompt.read_text(encoding="utf-8")
+
+
+def test_native_plugin_skill_is_included_in_worker_prompt(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_root = tmp_path / "profile"
+    registry_path = config_root / "plugins" / "installed_plugins.json"
+    registry_path.parent.mkdir(parents=True)
+    plugin_root = tmp_path / "plugin" / "version"
+    registry_path.write_text(json.dumps({"plugins": {"pstack@pstack-claude": [
+        {"scope": "user", "installPath": str(plugin_root)},
+    ]}}), encoding="utf-8")
+    skill_path = plugin_root / "skills" / "poteto-mode" / "SKILL.md"
+    skill_path.parent.mkdir(parents=True)
+    skill_path.write_text("Use the native workflow.\n", encoding="utf-8")
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config_root))
+    outcome, recorder, _, _, _ = _run_once(
+        monkeypatch, tmp_path, _FakeProcess(returncode=0, stdout="done"),
+        agent_name="poteto-agent",
+    )
+    assert outcome.is_ok
+    invocation = recorder.invocations[0]
+    prompt = Path(invocation[invocation.index(PROMPT_FILE_FLAG) + 1]).read_text(encoding="utf-8")
+    assert str(skill_path.resolve()) in prompt
+    assert "Use the native workflow." in prompt
+    assert "Resolve companion skill paths against that source directory." in prompt
 
 
 def test_unique_leader_socket_path_per_call(

package/scripts/test_grok_worker_preflight.py

@@ -80,6 +80,9 @@ class _Recorder:
 def _write_install_layout(claude_home: Path, *, role: str = ROLE_BUGTEAM) -> None:
     claude_home.mkdir(parents=True, exist_ok=True)
     (claude_home / MANIFEST_FILENAME).write_text("{}", encoding=UTF8_ENCODING)
+    skill_path = claude_home / "skills" / "poteto-mode" / "SKILL.md"
+    skill_path.parent.mkdir(parents=True, exist_ok=True)
+    skill_path.write_text("Poteto guidance\n", encoding=UTF8_ENCODING)
     agents_directory = claude_home / AGENTS_SUBDIRECTORY
     agents_directory.mkdir(parents=True, exist_ok=True)
     for each_filename in ALL_AGENT_FILENAMES_BY_ROLE[role]:
@@ -88,6 +91,76 @@ def _write_install_layout(claude_home: Path, *, role: str = ROLE_BUGTEAM) -> Non
         )
 
 
+def test_missing_poteto_skill_rejects_installed_agent(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    _write_install_layout(tmp_path)
+    monkeypatch.setattr(preflight, "claude_config_home", lambda: tmp_path)
+    assert preflight._is_claude_dev_env_config_present(ROLE_BUGTEAM)
+    preflight.poteto_mode_skill_path().unlink()
+    assert not preflight._is_claude_dev_env_config_present(ROLE_BUGTEAM)
+
+
+def _write_native_pstack(config_root: Path, plugin_root: Path) -> Path:
+    registry_path = config_root / "plugins" / "installed_plugins.json"
+    registry_path.parent.mkdir(parents=True, exist_ok=True)
+    registry_path.write_text(
+        json.dumps({"plugins": {"pstack@pstack-claude": [
+            {"scope": "user", "installPath": str(plugin_root)},
+            {"scope": "project", "installPath": str(plugin_root / "other")},
+        ]}}),
+        encoding=UTF8_ENCODING,
+    )
+    skill_path = plugin_root / "skills" / "poteto-mode" / "SKILL.md"
+    skill_path.parent.mkdir(parents=True)
+    skill_path.write_text("Native poteto guidance\n", encoding=UTF8_ENCODING)
+    companion = skill_path.parent / "playbooks" / "bug-fix.md"
+    companion.parent.mkdir()
+    companion.write_text("Fix guidance\n", encoding=UTF8_ENCODING)
+    return skill_path
+
+
+def _damage_native_plugin(config_root: Path, native_skill: Path, damage: str) -> None:
+    if damage == "missing":
+        native_skill.unlink()
+        return
+    if damage == "empty":
+        native_skill.write_text("", encoding=UTF8_ENCODING)
+        return
+    if damage == "encoding":
+        native_skill.write_bytes(b"\xff")
+        return
+    (config_root / "plugins" / "installed_plugins.json").write_text(
+        "{", encoding=UTF8_ENCODING
+    )
+
+
+def test_native_plugin_source_overrides_shared_skill(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_root = tmp_path / "profile"
+    _write_install_layout(config_root)
+    native_skill = _write_native_pstack(config_root, tmp_path / "plugin-version")
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config_root))
+    assert preflight.poteto_mode_skill_path() == native_skill
+    assert (native_skill.parent / "playbooks" / "bug-fix.md").read_text() == "Fix guidance\n"
+    assert preflight._is_claude_dev_env_config_present(ROLE_BUGTEAM)
+
+
+@pytest.mark.parametrize("damage", ["missing", "empty", "encoding", "registry"])
+def test_broken_native_plugin_does_not_fall_back_to_shared_skill(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, damage: str
+) -> None:
+    config_root = tmp_path / "profile"
+    _write_install_layout(config_root)
+    native_skill = _write_native_pstack(config_root, tmp_path / "plugin-version")
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config_root))
+    _damage_native_plugin(config_root, native_skill, damage)
+    with pytest.raises(OSError):
+        preflight.poteto_mode_skill_path()
+    assert not preflight._is_claude_dev_env_config_present(ROLE_BUGTEAM)
+
+
 def _install_ok_static_seams(
     monkeypatch: pytest.MonkeyPatch,
     claude_home: Path,

package/scripts/tests/resolve_advisor_model_route.test.mjs

@@ -12,12 +12,12 @@ function runBridge(input) {
     });
 }
 
-test('advisor bridge selects the policy default', () => {
-    const result = runBridge(JSON.stringify({ reasoning_effort: 'xhigh' }));
+test('advisor bridge uses the trusted advisor registration', () => {
+    const result = runBridge(JSON.stringify({ model: 'Astra', reasoning_effort: 'high' }));
     assert.equal(result.status, 0);
     assert.deepEqual(JSON.parse(result.stdout).selected, {
         model: 'gpt-6-astra',
-        effort: 'medium',
+        effort: 'high',
     });
 });
 

package/scripts/tests/test_rules.py

@@ -94,8 +94,8 @@ def _comment_policy_surfaces(package_root: Path) -> tuple[Path, ...]:
         package_root / "AGENTS.md",
         package_root / "docs" / "CODE_RULES.md",
         package_root / "system-prompts" / "software-engineer.xml",
-        package_root / ".agents" / "agents" / "clean-coder.md",
-        package_root / ".agents" / "agents" / "code-quality-agent.md",
+        package_root / ".agents" / "agents-archived" / "clean-coder.md",
+        package_root / ".agents" / "agents-archived" / "code-quality-agent.md",
         package_root / "audit-rubrics" / "category_rubrics" / "category-j-code-rules-compliance.md",
         package_root / "audit-rubrics" / "prompts" / "category-j-code-rules-compliance.md",
         package_root / "audit-rubrics" / "category_rubrics" / "category-l-behavior-equivalence.md",
@@ -119,7 +119,7 @@ def _worker_policy_surfaces(package_root: Path) -> tuple[Path, ...]:
         package_root / "AGENTS.md",
         package_root / "docs" / "CODE_RULES.md",
         package_root / "system-prompts" / "software-engineer.xml",
-        package_root / ".agents" / "agents" / "clean-coder.md",
+        package_root / ".agents" / "agents-archived" / "clean-coder.md",
         package_root / ".agents" / "skills" / "grok-spawn" / "reference" / "worker-briefs.md",
         package_root.parent.parent / ".github" / "copilot-instructions.md",
     )
@@ -185,14 +185,14 @@ def _category_l_policy_texts() -> tuple[str, str, str]:
 
 
 def _comment_policy_summary_texts() -> tuple[str, str, str]:
-    clean_coder = _PACKAGE_ROOT / ".agents" / "agents" / "clean-coder.md"
+    clean_coder = _PACKAGE_ROOT / ".agents" / "agents-archived" / "clean-coder.md"
     category_j = (
         _PACKAGE_ROOT
         / "audit-rubrics"
         / "category_rubrics"
         / "category-j-code-rules-compliance.md"
     )
-    code_quality = _PACKAGE_ROOT / ".agents" / "agents" / "code-quality-agent.md"
+    code_quality = _PACKAGE_ROOT / ".agents" / "agents-archived" / "code-quality-agent.md"
     return tuple(
         each_path.read_text(encoding="utf-8").lower()
         for each_path in (clean_coder, category_j, code_quality)

package/hooks/advisory/msys_path_conversion_advisor.py

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