fix: Windows path handling and MSYS2 process termination

- getDefaultBgOutputDir: return native path for Node fs APIs, POSIX
  conversion happens at shell command construction time
- LocalBackgroundHandle.terminate: run winpid lookup via bash since
  /proc/PID/winpid is MSYS2's virtual filesystem, not visible to Node.js
- Add toPosixPath tests for path conversion behavior
- Add Windows POSIX path handling tests to backgroundCommands.test.ts

Author: ethanndickson

src/node/runtime/LocalBackgroundHandle.ts

@@ -2,6 +2,7 @@ import type { BackgroundHandle } from "./Runtime";
 import { parseExitCode, EXIT_CODE_SIGKILL, EXIT_CODE_SIGTERM } from "./backgroundCommands";
 import { log } from "@/node/services/log";
 import { execAsync } from "@/node/utils/disposableExec";
+import { getBashPath } from "@/node/utils/main/bashPath";
 import * as fs from "fs/promises";
 import * as path from "path";
 
@@ -53,12 +54,22 @@ export class LocalBackgroundHandle implements BackgroundHandle {
     const exitCodePath = path.join(this.outputDir, "exit_code");
 
     // Windows: convert MSYS2 PID to Windows PID and use taskkill
+    // Must run via bash because /proc/PID/winpid is MSYS2's virtual filesystem,
+    // not visible to Node.js running as a native Windows process
     if (process.platform === "win32") {
       try {
-        const winpidPath = `/proc/${this.pid}/winpid`;
-        const winpid = (await fs.readFile(winpidPath, "utf-8")).trim();
-        log.debug(`LocalBackgroundHandle: Killing Windows PID ${winpid} (MSYS2 PID ${this.pid})`);
-        using proc = execAsync(`taskkill /PID ${winpid} /F /T`);
+        // Script reads winpid from MSYS2's /proc, then uses taskkill
+        // taskkill /F = force, /T = kill child processes
+        // Double slashes needed because bash interprets single slash as path
+        const terminateScript = `
+          if [ -f /proc/${this.pid}/winpid ]; then
+            winpid=$(cat /proc/${this.pid}/winpid)
+            taskkill //PID $winpid //F //T 2>/dev/null
+          fi
+          kill -9 ${this.pid} 2>/dev/null || true
+        `;
+        log.debug(`LocalBackgroundHandle: Terminating MSYS2 PID ${this.pid} via bash`);
+        using proc = execAsync(terminateScript, { shell: getBashPath() });
         await proc.result;
       } catch (error) {
         // Process already dead or winpid unavailable

src/node/runtime/WorktreeRuntime.ts

@@ -287,7 +287,9 @@ export class WorktreeRuntime extends LocalBaseRuntime {
 
           // Force delete the directory (use bash shell for rm -rf on Windows)
           // Convert to POSIX path for Git Bash compatibility on Windows
-          using rmProc = execAsync(`rm -rf "${toPosixPath(deletedPath)}"`, { shell: getBashPath() });
+          using rmProc = execAsync(`rm -rf "${toPosixPath(deletedPath)}"`, {
+            shell: getBashPath(),
+          });
           await rmProc.result;
 
           return { success: true, deletedPath };

src/node/runtime/backgroundCommands.test.ts

@@ -288,4 +288,78 @@ describe("backgroundCommands", () => {
       expect(EXIT_CODE_SIGTERM).toBe(143); // 128 + 15
     });
   });
+
+  // Windows/MSYS2 path handling tests
+  // These verify that POSIX-converted paths work correctly in shell commands
+  describe("Windows POSIX path handling", () => {
+    describe("buildWrapperScript with POSIX-converted paths", () => {
+      it("works with POSIX-style paths from toPosixPath", () => {
+        // Simulates paths after toPosixPath conversion on Windows:
+        // C:\Users\test\exit_code → /c/Users/test/exit_code
+        const result = buildWrapperScript({
+          exitCodePath: "/c/Users/test/bg-123/exit_code",
+          cwd: "/c/Projects/myapp",
+          script: "npm start",
+        });
+
+        expect(result).toContain("cd '/c/Projects/myapp'");
+        expect(result).toContain("'/c/Users/test/bg-123/exit_code'");
+      });
+
+      it("handles POSIX paths with spaces (Program Files)", () => {
+        const result = buildWrapperScript({
+          exitCodePath: "/c/Program Files/mux/exit_code",
+          cwd: "/c/Program Files/project",
+          script: "node server.js",
+        });
+
+        expect(result).toContain("cd '/c/Program Files/project'");
+        expect(result).toContain("'/c/Program Files/mux/exit_code'");
+      });
+    });
+
+    describe("buildSpawnCommand with POSIX-converted paths", () => {
+      it("works with POSIX-style paths for redirection", () => {
+        const result = buildSpawnCommand({
+          wrapperScript: "echo test",
+          stdoutPath: "/c/temp/mux-bashes/stdout.log",
+          stderrPath: "/c/temp/mux-bashes/stderr.log",
+        });
+
+        expect(result).toContain("> '/c/temp/mux-bashes/stdout.log'");
+        expect(result).toContain("2> '/c/temp/mux-bashes/stderr.log'");
+      });
+
+      it("handles paths with spaces in POSIX format", () => {
+        const result = buildSpawnCommand({
+          wrapperScript: "echo test",
+          stdoutPath: "/c/Users/John Doe/AppData/Local/Temp/mux-bashes/stdout.log",
+          stderrPath: "/c/Users/John Doe/AppData/Local/Temp/mux-bashes/stderr.log",
+        });
+
+        expect(result).toContain("'/c/Users/John Doe/AppData/Local/Temp/mux-bashes/stdout.log'");
+        expect(result).toContain("'/c/Users/John Doe/AppData/Local/Temp/mux-bashes/stderr.log'");
+      });
+
+      it("handles quoted bash path with spaces (Git Bash default location)", () => {
+        const result = buildSpawnCommand({
+          wrapperScript: "echo test",
+          stdoutPath: "/c/temp/stdout.log",
+          stderrPath: "/c/temp/stderr.log",
+          bashPath: "/c/Program Files/Git/bin/bash.exe",
+        });
+
+        // Bash path should be quoted
+        expect(result).toContain("'/c/Program Files/Git/bin/bash.exe'");
+      });
+    });
+
+    describe("buildTerminateCommand with POSIX paths", () => {
+      it("works with POSIX-style exit code path", () => {
+        const result = buildTerminateCommand(1234, "/c/temp/mux-bashes/bg-abc/exit_code");
+
+        expect(result).toContain("'/c/temp/mux-bashes/bg-abc/exit_code'");
+      });
+    });
+  });
 });

src/node/runtime/runtimeFactory.ts

@@ -1,4 +1,5 @@
 import * as os from "os";
+import * as path from "path";
 
 import type { Runtime } from "./Runtime";
 import { LocalRuntime } from "./LocalRuntime";
@@ -7,19 +8,20 @@ import { SSHRuntime } from "./SSHRuntime";
 import type { RuntimeConfig } from "@/common/types/runtime";
 import { hasSrcBaseDir } from "@/common/types/runtime";
 import { isIncompatibleRuntimeConfig } from "@/common/utils/runtimeCompatibility";
-import { toPosixPath } from "@/node/utils/paths";
 
 // Re-export for backward compatibility with existing imports
 export { isIncompatibleRuntimeConfig };
 
 /**
  * Get the default output directory for background processes.
  * Uses os.tmpdir() for platform-appropriate temp directory.
- * On Windows, converts to POSIX path using cygpath for Git Bash compatibility.
+ *
+ * Returns native path format (Windows or POSIX) since this is used by Node.js
+ * filesystem APIs. Conversion to POSIX for Git Bash shell commands happens
+ * at command construction time via toPosixPath().
  */
 function getDefaultBgOutputDir(): string {
-  const tempDir = os.tmpdir();
-  return `${toPosixPath(tempDir)}/mux-bashes`;
+  return path.join(os.tmpdir(), "mux-bashes");
 }
 
 /**

src/node/utils/paths.test.ts

@@ -1,5 +1,6 @@
 import { describe, test, expect } from "bun:test";
 import { PlatformPaths } from "./paths.main";
+import { toPosixPath } from "./paths";
 import * as os from "os";
 import * as path from "path";
 
@@ -144,3 +145,77 @@ describe("PlatformPaths", () => {
     });
   });
 });
+
+describe("toPosixPath", () => {
+  describe("on non-Windows platforms", () => {
+    test("returns POSIX paths unchanged", () => {
+      if (process.platform !== "win32") {
+        expect(toPosixPath("/home/user/project")).toBe("/home/user/project");
+        expect(toPosixPath("/tmp/mux-bashes")).toBe("/tmp/mux-bashes");
+      }
+    });
+
+    test("returns paths with spaces unchanged", () => {
+      if (process.platform !== "win32") {
+        expect(toPosixPath("/home/user/my project")).toBe("/home/user/my project");
+      }
+    });
+
+    test("returns relative paths unchanged", () => {
+      if (process.platform !== "win32") {
+        expect(toPosixPath("relative/path/file.txt")).toBe("relative/path/file.txt");
+      }
+    });
+
+    test("returns empty string unchanged", () => {
+      if (process.platform !== "win32") {
+        expect(toPosixPath("")).toBe("");
+      }
+    });
+  });
+
+  describe("path format handling", () => {
+    test("handles paths with special characters", () => {
+      const input = "/path/with spaces/and-dashes/under_scores";
+      const result = toPosixPath(input);
+      expect(typeof result).toBe("string");
+      if (process.platform !== "win32") {
+        expect(result).toBe(input);
+      }
+    });
+
+    test("handles deeply nested paths", () => {
+      const input = "/a/b/c/d/e/f/g/h/i/j/file.txt";
+      const result = toPosixPath(input);
+      expect(typeof result).toBe("string");
+      if (process.platform !== "win32") {
+        expect(result).toBe(input);
+      }
+    });
+  });
+
+  // Windows-specific behavior documentation
+  // These tests document expected behavior but can only truly verify on Windows CI
+  describe("Windows behavior (documented)", () => {
+    test("converts Windows drive paths to POSIX format on Windows", () => {
+      // On Windows with Git Bash/MSYS2, cygpath converts:
+      //   "C:\\Users\\test" → "/c/Users/test"
+      //   "C:\\Program Files\\Git" → "/c/Program Files/Git"
+      //   "D:\\Projects\\mux" → "/d/Projects/mux"
+      //
+      // On non-Windows, this is a no-op (returns input unchanged)
+      if (process.platform === "win32") {
+        // Real Windows test - only runs on Windows CI
+        const result = toPosixPath("C:\\Users\\test");
+        expect(result).toMatch(/^\/c\/Users\/test$/i);
+      }
+    });
+
+    test("falls back to original path if cygpath unavailable", () => {
+      // If cygpath is not available (edge case), the function catches
+      // the error and returns the original path unchanged
+      // This prevents crashes if Git Bash is misconfigured
+      expect(true).toBe(true); // Cannot easily test without mocking execSync
+    });
+  });
+});