[Bug]: Python not detected when it lives behind a Store App Execution Alias (pyenv-win, and others)

[magnetica]

What happened?

On Windows, the dependency check reports "Python not found in PATH" on a machine
where python works fine from a terminal. uv is detected correctly; only Python
fails.

I'm using pyenv-win. python --version prints Python 3.12.9 in any shell, and
uv python list finds the interpreter too, but Window > MCP for Unity > Local
Setup Window insists Python is missing, so setup cannot complete.

The trigger is not pyenv specifically. WindowsPlatformDetector.DetectPython()
looks up the literal name python.exe and validates only the FIRST match where
returns. On a stock Windows install that first match is the Microsoft Store App
Execution Alias at %LOCALAPPDATA%\Microsoft\WindowsApps\python.exe — a 0-byte stub
that exits 9009 when Python wasn't installed from the Store. Detection stops
there and never looks at the PATH entries behind it, so any Python that sits
after the alias is invisible.

Expected: Python 3.12.9 detected, setup proceeds.
Actual: "Python not found in PATH" / "Install Python 3.10+ and ensure it's
added to PATH."

I traced this to three independent bugs (one of which makes extraPathPrepend a
no-op on Windows for every lookup, not just Python) and have a patch with tests.
Posting the full analysis and the diff as a comment below.

Reproduction steps

1. On Windows 11, leave the default App Execution Aliases enabled (this is the
   out-of-the-box state) and do NOT install Python from the Microsoft Store.
2. Install Python via pyenv-win:
   pyenv install 3.12.9
   pyenv global 3.12.9
   Confirm it works: python --version -> Python 3.12.9
3. Install uv and confirm: uv --version
4. Note what the two lookups return:
   where python -> ....pyenv\pyenv-win\shims\python
   ....pyenv\pyenv-win\shims\python.bat
   ...\AppData\Local\Microsoft\WindowsApps\python.exe
   where python.exe -> ...\AppData\Local\Microsoft\WindowsApps\python.exe
   The plugin queries the second form, which only finds the Store stub.
5. In Unity, open Window > MCP for Unity > Local Setup Window and run the
   dependency check.
6. Observe: uv is found, Python is reported as not found.

Any setup where a working interpreter sits behind the WindowsApps alias on PATH
should reproduce step 6; pyenv-win just makes it the common case, because its
shims are .bat files that where python.exe cannot match at all.

Unity version

6000.5.7f1

MCP for Unity package version

10.1.2

Python server version

No response

MCP client

Claude Code

Transport

Don't know

OS

Windows

Relevant logs / console output

=== where lookups ===
> where python
C:\Users\<me>\.pyenv\pyenv-win\shims\python
C:\Users\<me>\.pyenv\pyenv-win\shims\python.bat
C:\Users\<me>\AppData\Local\Microsoft\WindowsApps\python.exe

> where python.exe
C:\Users\<me>\AppData\Local\Microsoft\WindowsApps\python.exe

=== the Store alias, which is what detection ends up probing ===
> (Get-Item "...\WindowsApps\python.exe").Length
0
> & "...\WindowsApps\python.exe" --version
exit code = 9009
stdout    = (empty)
stderr    = Python was not found; run without arguments to install from the
            Microsoft Store, or disable this shortcut from Settings > Apps >
            Advanced app settings > App execution aliases.

=== uv sees the interpreter fine ===
> uv python list
cpython-3.12.9-windows-x86_64-none   C:\Users\<me>\.pyenv\pyenv-win\shims\python.bat
cpython-3.7.8-windows-x86_64-none    C:\Program Files (x86)\...\Python37_64\python.exe

=== DependencyManager.CheckAllDependencies -> DetectPython() ===
Name         : Python
IsAvailable  : False
Version      :
Path         :
Details      : Install Python 3.10+ and ensure it's added to PATH.
ErrorMessage : Python not found in PATH

=== same call, with the patch applied ===
Name         : Python
IsAvailable  : True
Version      : 3.12.9
Path         : C:\Users\<me>\.pyenv\pyenv-win\shims\python3.bat
Details      : Found Python 3.12.9 in PATH
ErrorMessage :

Checks

• I searched existing issues and did not find a duplicate
• I included logs / steps to reproduce

[magnetica]

Root cause analysis

I dug into this and there turned out to be three independent bugs on the Windows
detection path, plus one filter that discards valid results. Each of them alone is
enough to make detection fail.

1. Only the first where hit is ever validated

WindowsPlatformDetector.DetectPython() looks up the literal names python.exe
and python3.exe and validates only the first match it gets back. On a default
Windows install that first match is
%LOCALAPPDATA%\Microsoft\WindowsApps\python.exe — the Microsoft Store App
Execution Alias stub. It is a 0-byte reparse point that exits with code 9009 when
Python was not installed from the Store:

> where python.exe
C:\Users\me\AppData\Local\Microsoft\WindowsApps\python.exe

> & "C:\Users\me\AppData\Local\Microsoft\WindowsApps\python.exe" --version
exit code = 9009
stdout    = (empty)
stderr    = "Python was not found; run without arguments to install from the
             Microsoft Store, or disable this shortcut from Settings > ..."

ExecPath.TryRun returns false because ExitCode != 0, and detection stops
there — it never looks at the PATH entries behind the stub, which is where the
real interpreter lives. Note also that querying the literal python.exe skips
PATHEXT expansion entirely, so pyenv-win's shims\python.bat is invisible to
this lookup even though where python finds it first:

> where python
C:\Users\me\.pyenv\pyenv-win\shims\python
C:\Users\me\.pyenv\pyenv-win\shims\python.bat
C:\Users\me\AppData\Local\Microsoft\WindowsApps\python.exe

2. ExecPath.TryRun cannot launch batch shims at all

pyenv-win publishes its interpreters as .bat shims rather than .exe. With
UseShellExecute = false, CreateProcess does not run .bat/.cmd files: the
call throws a Win32Exception, which the surrounding catch swallows into a
silent return false. So even once a shim is found, it can never be validated.
TryRun already special-cases .ps1 by routing through powershell.exe; batch
files need the same treatment via cmd.exe.

3. extraPathPrepend has never worked on Windows

This one is broader than the pyenv case. Mono — the runtime the Editor runs on —
backs ProcessStartInfo.EnvironmentVariables with a case-sensitive
dictionary, while the inherited Windows environment spells the key Path.
Writing psi.EnvironmentVariables["PATH"] = ... therefore adds a second,
separate entry, and the child process keeps reading the original Path.

Verified under Unity's own Mono runtime (MonoBleedingEdge/bin/mono.exe):

keys matching PATH in the psi:      [Path]
keys matching PATH after the set:   [Path, PATH]
where <shim> with ["PATH"] set:     exit=1, stdout=[]            <-- ignored
where <shim> with ["Path"] set:     exit=0, stdout=[C:\...\shim] <-- works

The consequence is that every augmented-PATH lookup on Windows has silently been
running against the unmodified PATH, so all the directories BuildAugmentedPath()
carefully collects — uv, Python, npm — have never had any effect. (This is
Mono-specific: on .NET Framework EnvironmentVariables is case-insensitive on
Windows, which is probably why it went unnoticed.)

4. The uv fallback discards .bat interpreters

TryFindPythonViaUv filters on EndsWith("python.exe") || EndsWith("python3.exe").
uv python list reports the pyenv interpreter correctly, but as a .bat, so it is
thrown away:

> uv python list
cpython-3.12.9-windows-x86_64-none    C:\Users\me\.pyenv\pyenv-win\shims\python.bat   <-- discarded
cpython-3.7.8-windows-x86_64-none     C:\Program Files (x86)\...\Python37_64\python.exe <-- kept, but < 3.10

The only .exe on the list is a Python 3.7.8 that then fails the >= 3.10 check,
so the fallback reports nothing.

Proposed fix

• ExecPath.TryRun: route .bat/.cmd through cmd.exe /s /c, mirroring the
  existing .ps1 handling.
• ExecPath.FindAllInPath: new; returns every where match in PATH order.
  FindInPath keeps its single-result contract, implemented on top of it.
• ExecPath: assign PATH using whatever spelling the inherited environment already
  uses, so the value actually reaches the child process.
• WindowsPlatformDetector.DetectPython: probe every candidate in PATH order,
  including the extension-less names so where expands through PATHEXT.
• WindowsPlatformDetector.IsPythonExecutable: accept .bat/.cmd shims from
  uv python list, excluding pythonw.
• WindowsPlatformDetector / LinuxPlatformDetector: add the pyenv shim
  directories to the PATH additions, as fix: add pyenv shims to PATH on macOS #813 already did for macOS.

Applies cleanly on beta at c21bf49.

Diff — MCPForUnity/Editor (3 files, +198 −39)

diff --git a/MCPForUnity/Editor/Dependencies/PlatformDetectors/LinuxPlatformDetector.cs b/MCPForUnity/Editor/Dependencies/PlatformDetectors/LinuxPlatformDetector.cs
index be9db17..4dd344e 100644
--- a/MCPForUnity/Editor/Dependencies/PlatformDetectors/LinuxPlatformDetector.cs
+++ b/MCPForUnity/Editor/Dependencies/PlatformDetectors/LinuxPlatformDetector.cs
@@ -190,6 +190,7 @@ Note: Make sure ~/.local/bin is in your PATH for user-local installations.";
             var homeDir = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
             return new[]
             {
+                Path.Combine(homeDir, ".pyenv", "shims"), // pyenv: Python/uv when Unity is launched from a desktop entry
                 "/usr/local/bin",
                 "/usr/bin",
                 "/bin",
diff --git a/MCPForUnity/Editor/Dependencies/PlatformDetectors/WindowsPlatformDetector.cs b/MCPForUnity/Editor/Dependencies/PlatformDetectors/WindowsPlatformDetector.cs
index 706e503..000858b 100644
--- a/MCPForUnity/Editor/Dependencies/PlatformDetectors/WindowsPlatformDetector.cs
+++ b/MCPForUnity/Editor/Dependencies/PlatformDetectors/WindowsPlatformDetector.cs
@@ -29,22 +29,14 @@ namespace MCPForUnity.Editor.Dependencies.PlatformDetectors
 
             try
             {
-                // Try running python directly first (works with Windows App Execution Aliases)
-                if (TryValidatePython("python3.exe", out string version, out string fullPath) ||
-                    TryValidatePython("python.exe", out version, out fullPath))
+                // Probe every python-like entry on PATH instead of only the first match. A single
+                // name routinely resolves to several files on Windows - the Microsoft Store App
+                // Execution Alias stub, pyenv-win's .bat shims, and real interpreters - and stopping
+                // at the first one made pyenv (and any setup shadowed by the Store stub) report
+                // "Python not found" even though the interpreter works fine from a terminal.
+                foreach (string candidate in EnumeratePythonCandidates())
                 {
-                    status.IsAvailable = true;
-                    status.Version = version;
-                    status.Path = fullPath;
-                    status.Details = $"Found Python {version} in PATH";
-                    return status;
-                }
-
-                // Fallback: try 'where' command
-                if (TryFindInPath("python3.exe", out string pathResult) ||
-                    TryFindInPath("python.exe", out pathResult))
-                {
-                    if (TryValidatePython(pathResult, out version, out fullPath))
+                    if (TryValidatePython(candidate, out string version, out string fullPath))
                     {
                         status.IsAvailable = true;
                         status.Version = version;
@@ -55,12 +47,12 @@ namespace MCPForUnity.Editor.Dependencies.PlatformDetectors
                 }
 
                 // Fallback: try to find python via uv
-                if (TryFindPythonViaUv(out version, out fullPath))
+                if (TryFindPythonViaUv(out string uvVersion, out string uvFullPath))
                 {
                     status.IsAvailable = true;
-                    status.Version = version;
-                    status.Path = fullPath;
-                    status.Details = $"Found Python {version} via uv";
+                    status.Version = uvVersion;
+                    status.Path = uvFullPath;
+                    status.Details = $"Found Python {uvVersion} via uv";
                     return status;
                 }
 
@@ -152,6 +144,54 @@ namespace MCPForUnity.Editor.Dependencies.PlatformDetectors
         }
 
 
+        /// <summary>
+        /// Every python-like executable reachable from PATH, in priority order and de-duplicated.
+        /// The extension-less names matter: they let 'where' expand through PATHEXT, which is what
+        /// surfaces pyenv-win's python.bat shims next to regular python.exe installs.
+        /// </summary>
+        private IEnumerable<string> EnumeratePythonCandidates()
+        {
+            string augmentedPath = BuildAugmentedPath();
+            var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (string name in new[] { "python3.exe", "python.exe", "python3", "python" })
+            {
+                foreach (string match in ExecPath.FindAllInPath(name, augmentedPath))
+                {
+                    if (seen.Add(match)) yield return match;
+                }
+            }
+
+            // Last resort: hand the bare names to the process launcher so a working App Execution
+            // Alias that 'where' failed to report still gets a chance to answer --version.
+            foreach (string name in new[] { "python3.exe", "python.exe" })
+            {
+                if (seen.Add(name)) yield return name;
+            }
+        }
+
+        /// <summary>
+        /// Whether a path found in 'uv python list' output looks like a launchable interpreter.
+        /// pyenv-win registers its interpreters as .bat shims, so restricting this to .exe hid
+        /// perfectly valid installs.
+        /// </summary>
+        internal static bool IsPythonExecutable(string path)
+        {
+            string extension = Path.GetExtension(path);
+            if (!extension.Equals(".exe", StringComparison.OrdinalIgnoreCase) &&
+                !extension.Equals(".bat", StringComparison.OrdinalIgnoreCase) &&
+                !extension.Equals(".cmd", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            string name = Path.GetFileNameWithoutExtension(path);
+
+            // pythonw is the console-less variant and never writes a version to stdout/stderr
+            return name.StartsWith("python", StringComparison.OrdinalIgnoreCase) &&
+                   !name.StartsWith("pythonw", StringComparison.OrdinalIgnoreCase);
+        }
+
         private bool TryFindPythonViaUv(out string version, out string fullPath)
         {
             version = null;
@@ -173,8 +213,7 @@ namespace MCPForUnity.Editor.Dependencies.PlatformDetectors
                     if (parts.Length >= 2)
                     {
                         string potentialPath = parts[parts.Length - 1];
-                        if (File.Exists(potentialPath) &&
-                            (potentialPath.EndsWith("python.exe") || potentialPath.EndsWith("python3.exe")))
+                        if (File.Exists(potentialPath) && IsPythonExecutable(potentialPath))
                         {
                             if (TryValidatePython(potentialPath, out version, out fullPath))
                             {
@@ -201,9 +240,10 @@ namespace MCPForUnity.Editor.Dependencies.PlatformDetectors
             {
                 string augmentedPath = BuildAugmentedPath();
 
-                // First, try to resolve the absolute path for better UI/logging display
+                // First, try to resolve the absolute path for better UI/logging display.
+                // Already-rooted candidates are passed through: 'where' rejects full paths.
                 string commandToRun = pythonPath;
-                if (TryFindInPath(pythonPath, out string resolvedPath))
+                if (!Path.IsPathRooted(pythonPath) && TryFindInPath(pythonPath, out string resolvedPath))
                 {
                     commandToRun = resolvedPath;
                 }
@@ -287,6 +327,17 @@ namespace MCPForUnity.Editor.Dependencies.PlatformDetectors
                 catch { /* Ignore if directory doesn't exist */ }
             }
 
+            // pyenv-win: shims are what 'python' resolves to in a terminal, but Unity launched from
+            // the Hub does not always inherit the PATH entry that pyenv's installer added.
+            var pyenvRoot = Environment.GetEnvironmentVariable("PYENV");
+            if (string.IsNullOrEmpty(pyenvRoot) && !string.IsNullOrEmpty(homeDir))
+                pyenvRoot = Path.Combine(homeDir, ".pyenv", "pyenv-win");
+            if (!string.IsNullOrEmpty(pyenvRoot))
+            {
+                additions.Add(Path.Combine(pyenvRoot, "shims"));
+                additions.Add(Path.Combine(pyenvRoot, "bin"));
+            }
+
             // User scripts
             if (!string.IsNullOrEmpty(homeDir))
                 additions.Add(Path.Combine(homeDir, ".local", "bin"));
diff --git a/MCPForUnity/Editor/Helpers/ExecPath.cs b/MCPForUnity/Editor/Helpers/ExecPath.cs
index 4125421..f69f85f 100644
--- a/MCPForUnity/Editor/Helpers/ExecPath.cs
+++ b/MCPForUnity/Editor/Helpers/ExecPath.cs
@@ -166,6 +166,27 @@ namespace MCPForUnity.Editor.Helpers
             catch { }
         }
 
+        /// <summary>
+        /// Assigns PATH on a ProcessStartInfo using the spelling the inherited environment already
+        /// uses. Mono - the runtime the Editor runs on - backs EnvironmentVariables with a
+        /// case-SENSITIVE dictionary, so writing "PATH" when Windows handed us "Path" adds a second,
+        /// separate entry and the child process keeps reading the original one. That silently made
+        /// every extraPathPrepend on Windows a no-op.
+        /// </summary>
+        private static void SetPathVariable(ProcessStartInfo psi, string value)
+        {
+            string key = "PATH";
+            foreach (string existing in psi.EnvironmentVariables.Keys)
+            {
+                if (string.Equals(existing, "PATH", StringComparison.OrdinalIgnoreCase))
+                {
+                    key = existing;
+                    break;
+                }
+            }
+            psi.EnvironmentVariables[key] = value;
+        }
+
         internal static bool TryRun(
             string file,
             string args,
@@ -179,16 +200,41 @@ namespace MCPForUnity.Editor.Helpers
             stderr = string.Empty;
             try
             {
+                bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+
                 // Handle PowerShell scripts on Windows by invoking through powershell.exe
-                bool isPs1 = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) &&
-                             file.EndsWith(".ps1", StringComparison.OrdinalIgnoreCase);
+                bool isPs1 = isWindows && file.EndsWith(".ps1", StringComparison.OrdinalIgnoreCase);
+
+                // Handle batch shims (pyenv-win, npm .cmd wrappers, ...) on Windows: CreateProcess
+                // cannot launch .bat/.cmd directly while UseShellExecute is false, so route them
+                // through cmd.exe instead of failing with a Win32Exception.
+                bool isBatch = isWindows &&
+                               (file.EndsWith(".bat", StringComparison.OrdinalIgnoreCase) ||
+                                file.EndsWith(".cmd", StringComparison.OrdinalIgnoreCase));
+
+                string fileName;
+                string arguments;
+                if (isPs1)
+                {
+                    fileName = "powershell.exe";
+                    arguments = $"-NoProfile -ExecutionPolicy Bypass -File \"{file}\" {args}".Trim();
+                }
+                else if (isBatch)
+                {
+                    fileName = "cmd.exe";
+                    // /s /c plus an outer pair of quotes keeps paths containing spaces intact
+                    arguments = $"/s /c \"\"{file}\" {args}\"";
+                }
+                else
+                {
+                    fileName = file;
+                    arguments = args;
+                }
 
                 var psi = new ProcessStartInfo
                 {
-                    FileName = isPs1 ? "powershell.exe" : file,
-                    Arguments = isPs1
-                        ? $"-NoProfile -ExecutionPolicy Bypass -File \"{file}\" {args}".Trim()
-                        : args,
+                    FileName = fileName,
+                    Arguments = arguments,
                     WorkingDirectory = string.IsNullOrEmpty(workingDir) ? Environment.CurrentDirectory : workingDir,
                     UseShellExecute = false,
                     RedirectStandardOutput = true,
@@ -198,9 +244,9 @@ namespace MCPForUnity.Editor.Helpers
                 if (!string.IsNullOrEmpty(extraPathPrepend))
                 {
                     string currentPath = Environment.GetEnvironmentVariable("PATH") ?? string.Empty;
-                    psi.EnvironmentVariables["PATH"] = string.IsNullOrEmpty(currentPath)
+                    SetPathVariable(psi, string.IsNullOrEmpty(currentPath)
                         ? extraPathPrepend
-                        : (extraPathPrepend + System.IO.Path.PathSeparator + currentPath);
+                        : (extraPathPrepend + System.IO.Path.PathSeparator + currentPath));
                 }
 
                 using var process = new Process { StartInfo = psi, EnableRaisingEvents = false };
@@ -249,6 +295,22 @@ namespace MCPForUnity.Editor.Helpers
 #endif
         }
 
+        /// <summary>
+        /// Like <see cref="FindInPath"/>, but returns every match in PATH order instead of only the
+        /// first one. On Windows a single name can resolve to several entries (App Execution Alias
+        /// stubs, pyenv-win .bat shims, real interpreters); callers that validate the candidate need
+        /// to be able to skip the ones that turn out to be non-functional.
+        /// </summary>
+        internal static string[] FindAllInPath(string executable, string extraPathPrepend = null)
+        {
+#if UNITY_EDITOR_WIN
+            return FindAllInPathWindows(executable, extraPathPrepend);
+#else
+            string single = FindInPath(executable, extraPathPrepend);
+            return string.IsNullOrEmpty(single) ? Array.Empty<string>() : new[] { single };
+#endif
+        }
+
 #if UNITY_EDITOR_OSX || UNITY_EDITOR_LINUX
         private static string Which(string exe, string prependPath)
         {
@@ -261,7 +323,7 @@ namespace MCPForUnity.Editor.Helpers
                     CreateNoWindow = true,
                 };
                 string path = Environment.GetEnvironmentVariable("PATH") ?? string.Empty;
-                psi.EnvironmentVariables["PATH"] = string.IsNullOrEmpty(path) ? prependPath : (prependPath + Path.PathSeparator + path);
+                SetPathVariable(psi, string.IsNullOrEmpty(path) ? prependPath : (prependPath + Path.PathSeparator + path));
 
                 using var p = Process.Start(psi);
                 if (p == null) return null;
@@ -286,6 +348,11 @@ namespace MCPForUnity.Editor.Helpers
 
 #if UNITY_EDITOR_WIN
         internal static string FindInPathWindows(string exe, string extraPathPrepend = null)
+        {
+            return FindAllInPathWindows(exe, extraPathPrepend).FirstOrDefault();
+        }
+
+        private static string[] FindAllInPathWindows(string exe, string extraPathPrepend = null)
         {
             try
             {
@@ -303,11 +370,11 @@ namespace MCPForUnity.Editor.Helpers
                 };
                 if (!string.IsNullOrEmpty(effectivePath))
                 {
-                    psi.EnvironmentVariables["PATH"] = effectivePath;
+                    SetPathVariable(psi, effectivePath);
                 }
 
                 using var p = Process.Start(psi);
-                if (p == null) return null;
+                if (p == null) return Array.Empty<string>();
 
                 var so = new StringBuilder();
                 p.OutputDataReceived += (_, e) => { if (e.Data != null) so.AppendLine(e.Data); };
@@ -316,16 +383,17 @@ namespace MCPForUnity.Editor.Helpers
                 if (!p.WaitForExit(1500))
                 {
                     try { p.Kill(); } catch { }
-                    return null;
+                    return Array.Empty<string>();
                 }
 
                 p.WaitForExit();
-                string first = so.ToString()
+                return so.ToString()
                     .Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
-                    .FirstOrDefault();
-                return (!string.IsNullOrEmpty(first) && File.Exists(first)) ? first : null;
+                    .Select(line => line.Trim())
+                    .Where(line => line.Length > 0 && File.Exists(line))
+                    .ToArray();
             }
-            catch { return null; }
+            catch { return Array.Empty<string>(); }
         }
 #endif
     }

Tests

New EditMode tests covering each cause. The batch-execution ones Assert.Ignore
off Windows, following the existing WriteToConfigTests convention since CI runs
on Linux; the IsPythonExecutable cases are pure path classification and run
everywhere.

I ran these against the patched assembly under Unity's Mono runtime: 17/17 pass.
Worth noting that the extraPathPrepend test is what surfaced cause 3 — an
equivalent check under .NET Framework passes even on the unpatched code, because
only Mono is case-sensitive there.

Diff — tests (+152)

diff --git a/TestProjects/UnityMCPTests/Assets/Tests/EditMode/Helpers/ExecPathBatchShimTests.cs b/TestProjects/UnityMCPTests/Assets/Tests/EditMode/Helpers/ExecPathBatchShimTests.cs
new file mode 100644
index 0000000..8ddfe3b
--- /dev/null
+++ b/TestProjects/UnityMCPTests/Assets/Tests/EditMode/Helpers/ExecPathBatchShimTests.cs
@@ -0,0 +1,152 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using MCPForUnity.Editor.Dependencies.PlatformDetectors;
+using MCPForUnity.Editor.Helpers;
+using NUnit.Framework;
+
+namespace MCPForUnityTests.Editor.Helpers
+{
+    /// <summary>
+    /// Covers the Windows interpreter-discovery path that pyenv-win exposed: batch shims have to be
+    /// launchable, and a single executable name has to be resolvable to more than one PATH hit so a
+    /// dead Microsoft Store alias cannot mask a working interpreter behind it.
+    /// </summary>
+    public class ExecPathBatchShimTests
+    {
+        private string _tempRoot;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _tempRoot = Path.Combine(Path.GetTempPath(), "mcp_execpath_" + Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(_tempRoot);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            try { if (Directory.Exists(_tempRoot)) Directory.Delete(_tempRoot, true); } catch { }
+        }
+
+        private static void RequireWindows()
+        {
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                Assert.Ignore("Batch shim launching is Windows-only (CI runs linux).");
+            }
+        }
+
+        private string WriteShim(string directory, string fileName, string body)
+        {
+            Directory.CreateDirectory(directory);
+            string path = Path.Combine(directory, fileName);
+            File.WriteAllText(path, "@echo off" + Environment.NewLine + body + Environment.NewLine);
+            return path;
+        }
+
+        [Test]
+        public void TryRun_BatchShim_RunsAndForwardsArguments()
+        {
+            RequireWindows();
+
+            // pyenv-win publishes interpreters as .bat shims; CreateProcess cannot start those
+            // directly while UseShellExecute is false, so TryRun has to route them via cmd.exe.
+            string shim = WriteShim(_tempRoot, "fake_python.bat", "echo Python 3.12.9 %*");
+
+            bool ok = ExecPath.TryRun(shim, "--version", null, out string stdout, out string stderr, 10000);
+
+            Assert.IsTrue(ok, $"Batch shim should run. stderr: {stderr}");
+            Assert.That(stdout, Does.Contain("Python 3.12.9"));
+            Assert.That(stdout, Does.Contain("--version"), "Arguments must reach the shim, not be swallowed by cmd.exe quoting.");
+        }
+
+        [Test]
+        public void TryRun_BatchShimInPathWithSpaces_RunsAndForwardsArguments()
+        {
+            RequireWindows();
+
+            string spaced = Path.Combine(_tempRoot, "Program Files Like");
+            string shim = WriteShim(spaced, "fake_python.cmd", "echo Python 3.12.9 %*");
+
+            bool ok = ExecPath.TryRun(shim, "--version", null, out string stdout, out string stderr, 10000);
+
+            Assert.IsTrue(ok, $"Batch shim under a path containing spaces should run. stderr: {stderr}");
+            Assert.That(stdout, Does.Contain("Python 3.12.9"));
+            Assert.That(stdout, Does.Contain("--version"));
+        }
+
+        [Test]
+        public void FindAllInPath_ReturnsEveryMatchInPathOrder()
+        {
+            RequireWindows();
+
+            // The real-world shape: a non-working entry earlier on PATH shadowing a working one.
+            string first = Path.Combine(_tempRoot, "first");
+            string second = Path.Combine(_tempRoot, "second");
+            string name = "mcp_probe_" + Guid.NewGuid().ToString("N").Substring(0, 8) + ".cmd";
+            string firstShim = WriteShim(first, name, "exit /b 1");
+            string secondShim = WriteShim(second, name, "echo Python 3.12.9");
+
+            string prepend = first + Path.PathSeparator + second;
+            string[] matches = ExecPath.FindAllInPath(name, prepend);
+
+            Assert.AreEqual(2, matches.Length, "Both PATH entries should be reported: " + string.Join(", ", matches));
+            Assert.AreEqual(firstShim, matches[0]);
+            Assert.AreEqual(secondShim, matches[1]);
+
+            // FindInPath keeps its single-result contract, returning the first match only.
+            Assert.AreEqual(firstShim, ExecPath.FindInPath(name, prepend));
+        }
+
+        [Test]
+        public void TryRun_ExtraPathPrepend_IsVisibleToChildProcess()
+        {
+            RequireWindows();
+
+            // Mono backs ProcessStartInfo.EnvironmentVariables with a case-sensitive dictionary while
+            // Windows spells the inherited key "Path". Writing "PATH" therefore used to create a
+            // second entry the child never read, making extraPathPrepend a silent no-op.
+            string dir = Path.Combine(_tempRoot, "prepended");
+            WriteShim(dir, "mcp_onpath.cmd", "echo shim reached");
+
+            bool ok = ExecPath.TryRun("mcp_onpath.cmd", string.Empty, null, out string stdout, out string stderr, 10000, dir);
+
+            Assert.IsTrue(ok, $"Prepended PATH entry should be resolvable by the child process. stderr: {stderr}");
+            Assert.That(stdout, Does.Contain("shim reached"));
+        }
+
+        [Test]
+        public void FindAllInPath_UnknownExecutable_ReturnsEmpty()
+        {
+            RequireWindows();
+
+            string[] matches = ExecPath.FindAllInPath("mcp_definitely_missing_" + Guid.NewGuid().ToString("N") + ".exe");
+
+            Assert.IsNotNull(matches);
+            Assert.IsEmpty(matches);
+        }
+
+        [TestCase("python.exe", true)]
+        [TestCase("python3.exe", true)]
+        [TestCase("python.bat", true)]
+        [TestCase("python3.bat", true)]
+        [TestCase("python3.12.bat", true)]
+        [TestCase("python.cmd", true)]
+        [TestCase("PYTHON.EXE", true)]
+        [TestCase("pythonw.exe", false)]
+        [TestCase("pythonw3.12.bat", false)]
+        [TestCase("python", false)]
+        [TestCase("python.dll", false)]
+        [TestCase("uv.exe", false)]
+        public void IsPythonExecutable_ClassifiesUvListedPaths(string fileName, bool expected)
+        {
+            // Runs on every platform: this is pure path classification of `uv python list` output,
+            // which used to accept only .exe and therefore hid pyenv-win's .bat shims.
+            string path = Path.Combine("C:", "some", "dir", fileName);
+
+            Assert.AreEqual(expected, WindowsPlatformDetector.IsPythonExecutable(path), fileName);
+        }
+    }
+}
diff --git a/TestProjects/UnityMCPTests/Assets/Tests/EditMode/Helpers/ExecPathBatchShimTests.cs.meta b/TestProjects/UnityMCPTests/Assets/Tests/EditMode/Helpers/ExecPathBatchShimTests.cs.meta
new file mode 100644
index 0000000..83f86cd
--- /dev/null
+++ b/TestProjects/UnityMCPTests/Assets/Tests/EditMode/Helpers/ExecPathBatchShimTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6211241939d54f7cb012f2dacb803541
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
\ No newline at end of file

---

I did not open a PR because I would rather not maintain a fork, but the change is
committed locally and applies cleanly — happy for a maintainer to take it as-is,
or to send it as a PR against beta if you prefer that route.