fix(windows): resolve PATH whatever casing the child was handed

Routing the release script through the launcher was necessary but not
sufficient, because the launcher was reading the wrong list. Windows treats
environment variable names case-insensitively, so a spawned child can arrive
with Path, PATH, or both -- and the release test built its env as
{...process.env, PATH: shims}, which on Windows leaves the inherited Path
sitting beside the new PATH. The resolver read two fixed spellings and matched
whichever came first, so the shim directory was invisible and the real git ran.
That is why the branch guard kept reporting dev when the test had faked main.

The resolver now matches the key however it is spelled, and the test sets a
single Path entry instead of layering a second casing on top of the inherited
one. Both halves matter: either alone leaves the same ambiguity for the next
caller to trip over.

A host-platform run cannot observe any of this, which is how the suite stayed
green on macOS through four red Windows rounds, so the casing matrix is pinned
as a test rather than left to CI to rediscover.

Author: lidge-jun

src/lib/win-exec.ts

@@ -44,8 +44,18 @@ export function resolveWindowsCommand(command: string, deps: ResolveDeps = {}):
   if (win32.extname(command) || command.includes("\\") || command.includes("/") || win32.isAbsolute(command)) {
     return command;
   }
-  const exts = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
-  for (const dir of (env.PATH ?? env.Path ?? "").split(win32.delimiter).filter(Boolean)) {
+  // Windows environment variables are case-insensitive, and a spawned child can
+  // arrive with `Path`, `PATH`, or both depending on who built its env. Reading
+  // only two fixed spellings silently resolved against the wrong list once a
+  // caller added a second casing, so match however the key is spelled.
+  const lookup = (name: string): string | undefined => {
+    const direct = env[name] ?? env[name.toUpperCase()] ?? env[name.toLowerCase()];
+    if (direct !== undefined) return direct;
+    const key = Object.keys(env).find(k => k.toLowerCase() === name.toLowerCase());
+    return key ? env[key] : undefined;
+  };
+  const exts = (lookup("PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  for (const dir of (lookup("PATH") ?? "").split(win32.delimiter).filter(Boolean)) {
     for (const ext of exts) {
       const candidate = win32.join(dir, command + ext.toLowerCase());
       if (exists(candidate)) return candidate;

tests/release-helper.test.ts

@@ -192,11 +192,23 @@ function runRelease(version: string, scenario: ReleaseScenario = {}) {
     installCommandShim(shimDir, name);
   }
 
+  // Windows names the variable `Path`, and `...process.env` copies it in under
+  // that spelling. Adding a separate `PATH` key leaves BOTH present, and which
+  // one wins is not something this test should be gambling on — the child saw
+  // the real git instead of the shim, so the branch guard read `dev` and the
+  // script aborted before logging a single call. Strip every case variant, then
+  // set exactly one.
+  const inheritedEnv = Object.fromEntries(
+    Object.entries(process.env).filter(([key]) => key.toLowerCase() !== "path"),
+  );
+  const pathKey = process.platform === "win32" ? "Path" : "PATH";
+  const pathValue = `${shimDir}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? process.env.Path ?? ""}`;
+
   const result = spawnSync(process.execPath, [releaseScriptPath, version], {
     cwd: repoRoot,
     env: {
-      ...process.env,
-      PATH: `${shimDir}${process.platform === "win32" ? ";" : ":"}${process.env.PATH ?? ""}`,
+      ...inheritedEnv,
+      [pathKey]: pathValue,
       FAKE_RELEASE_LOG: logPath,
       FAKE_GIT_BRANCH: scenario.branch ?? "main",
       FAKE_GIT_HEAD_SHA: scenario.headSha ?? "abc123def456",

tests/win-exec.test.ts

@@ -60,6 +60,33 @@ describe("resolveWindowsCommand", () => {
     expect(resolveWindowsCommand("claude", { env, exists: () => false })).toBe("claude");
     expect(resolveWindowsCommand("claude", { env: {}, exists: () => true })).toBe("claude");
   });
+
+  /**
+   * Windows env vars are case-insensitive and a spawned child can arrive with
+   * `Path`, `PATH`, or both — `{...process.env, PATH: x}` on Windows leaves the
+   * inherited `Path` in place beside the new `PATH`. Reading two fixed spellings
+   * resolved against whichever happened to be listed first, which is how a test
+   * that put shims on PATH still reached the real `git`: the branch guard then
+   * read the wrong branch and the script aborted before running anything.
+   */
+  test("PATH and PATHEXT resolve whatever casing the child was handed", () => {
+    const exists = (p: string) => p === "D:\\shims\\git.cmd";
+
+    for (const pathKey of ["PATH", "Path", "path"]) {
+      const cased = { [pathKey]: "D:\\shims", PATHEXT: ".COM;.EXE;.BAT;.CMD" };
+      expect(resolveWindowsCommand("git", { env: cased, exists })).toBe("D:\\shims\\git.cmd");
+    }
+
+    for (const extKey of ["PATHEXT", "PathExt", "pathext"]) {
+      const cased = { Path: "D:\\shims", [extKey]: ".COM;.EXE;.BAT;.CMD" };
+      expect(resolveWindowsCommand("git", { env: cased, exists })).toBe("D:\\shims\\git.cmd");
+    }
+
+    // Both spellings present: the shim directory must still win, whichever key
+    // the platform ends up honouring.
+    const both = { Path: "D:\\shims", PATH: "D:\\shims", PATHEXT: ".CMD" };
+    expect(resolveWindowsCommand("git", { env: both, exists })).toBe("D:\\shims\\git.cmd");
+  });
 });
 
 describe("commandInvocation", () => {