@@ -105,6 +105,11 @@ describe.skipIf(HostProcess.Platform.defaultValue() !== "linux")("NonBlockingSpa
           const native = yield* run(command).pipe(Effect.provide(NodeServices.layer));
           expect(yield* run(command).pipe(Effect.provide(spawner))).toBe(native);
         }
+        // GNU env reads a lone `-` as -i even after `--`.
+        yield* fileSystem.writeFileString(`${root}/fresh/-`, "#!/bin/sh\necho dash\n");
+        yield* fileSystem.chmod(`${root}/fresh/-`, 0o755);
+        const dash = ChildProcess.make("-", [], { env: { PATH: `${root}/fresh` }, cwd: root });
+        expect(yield* run(dash).pipe(Effect.provide(spawner))).toBe("dash\n");
       }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
     );
   });
 
@@ -98,7 +98,7 @@ const spawnFailure = (command: ChildProcess.StandardCommand, code: SpawnFailure)
 };
 
 // GNU env passes the environment through untouched and execvp's the command.
-// It reads any operand containing `=` as an assignment, even after `--`.
+// It reads any operand containing `=` as an assignment, and a lone `-` as -i, even after `--`.
 const viaEnv = (command: ChildProcess.StandardCommand, cwd: string | undefined) =>
   ChildProcess.make(
     "/usr/bin/env",
@@ -226,7 +226,7 @@ const make = Effect.gen(function* () {
       try: () => findExecutable(candidates, command.command.includes("/")),
       catch: (code) => spawnFailure(command, code as SpawnFailure),
     });
-    return envChdir && !command.command.includes("=")
+    return envChdir && command.command !== "-" && !command.command.includes("=")
       ? viaEnv(command, workingDirectory)
       : viaShell(command, workingDirectory);
   });
 
@@ -258,6 +258,48 @@ describe("Muse SDK host", () => {
   );
 });
 
+describe("Muse startup off Windows", () => {
+  it.effect("starts Muse in its cwd without handing libuv the cwd or the PATH search", () =>
+    Effect.gen(function* () {
+      if ((yield* HostProcess.Platform) === "win32") return;
+      const fs = yield* FileSystem.FileSystem;
+      const directory = yield* fs.realPath(yield* fs.makeTempDirectoryScoped());
+      const sdk = yield* Effect.promise(() =>
+        vi.importActual<typeof import("@muse-code/sdk")>("@muse-code/sdk"),
+      );
+      const fixture = `
+        require("node:readline").createInterface({ input: process.stdin }).on("line", line => {
+          const frame = JSON.parse(line);
+          if (!("id" in frame)) return;
+          const result = frame.method === "fixture/cwd"
+            ? { cwd: process.cwd() }
+            : { schema: { version: 1, fingerprint: "t3-cwd-fixture" }, grantedCapabilities: [] };
+          process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result }) + "\\n");
+        });
+      `;
+      const spawned: Array<Parameters<typeof sdk.spawnMspConnection>[0]> = [];
+      const host = yield* createMuseSdkHostEffect(
+        {
+          binaryPath: "node",
+          launch: { command: "node", args: ["-e", fixture] },
+          cwd: directory,
+          environment: { PATH: process.env.PATH },
+        },
+        (options) =>
+          createMuseSdkHost(options, (spawnOptions) => {
+            spawned.push(spawnOptions);
+            return sdk.spawnMspConnection(spawnOptions);
+          }),
+      );
+      const response = yield* Effect.promise(() => host.connection.request("fixture/cwd", {}));
+      yield* Effect.promise(() => host.close());
+      expect(response).toEqual({ cwd: directory });
+      expect(spawned[0]?.command).toBe("/bin/sh");
+      expect(spawned[0]?.cwd).toBeUndefined();
+    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+  );
+});
+
 describe("Muse launch", () => {
   const CMD = "C:\\Windows\\system32\\cmd.exe";
   const onWindows = (resolved: string | undefined, env: NodeJS.ProcessEnv = { ComSpec: CMD }) =>
 
@@ -212,10 +212,30 @@ export const createMuseSdkHostEffect = Effect.fn("createMuseSdkHostEffect")(func
   options: Omit<MuseSdkHostOptions, "signal">,
   createHost: typeof createMuseSdkHost = createMuseSdkHost,
 ) {
-  const launch = options.launch ?? (yield* museLaunch(options.binaryPath, options.environment));
+  const native = options.launch ?? (yield* museLaunch(options.binaryPath, options.environment));
+  // libuv blocks the server while the child runs chdir and the PATH search, which a hung
+  // mount stalls, so off Windows the shell does both in the child.
+  const { cwd = ".", ...childEntered } = options;
+  const hostOptions: Omit<MuseSdkHostOptions, "signal"> =
+    (yield* HostProcess.Platform) === "win32"
+      ? { ...options, launch: native }
+      : {
+          ...childEntered,
+          launch: {
+            command: "/bin/sh",
+            args: [
+              "-c",
+              'cd -P -- "$1" || exit 125\nshift\nexec "$@"',
+              "t3-muse",
+              cwd.startsWith("/") ? cwd : `./${cwd}`,
+              native.command,
+              ...native.args,
+            ],
+          },
+        };
   let startup: Promise<MuseSdkHost> | undefined;
   return yield* Effect.tryPromise((signal) => {
-    startup = createHost({ ...options, launch, signal });
+    startup = createHost({ ...hostOptions, signal });
     return startup;
   }).pipe(
     Effect.onInterrupt(() =>