diff --git a/src/process-sessions.test.ts b/src/process-sessions.test.ts
index b050e7903..3214e2fe8 100644
--- a/src/process-sessions.test.ts
+++ b/src/process-sessions.test.ts
@@ -178,6 +178,48 @@ if (!buffered.outputTruncated && buffered.sessionId) {
 assert.equal(buffered.outputTruncated, true);
 if (buffered.sessionId) manager.terminate("workspace-a", buffered.sessionId);
 
+if (process.platform !== "win32") {
+  // Regression: a stdin write racing child exit must not crash the process via
+  // an unhandled EPIPE 'error' event on the child's stdin. The shell exits
+  // immediately while the backgrounded `sleep` keeps stdout open, so the
+  // session stays running with an already-dead stdin.
+  const deadStdin = await manager.start({
+    workspaceId: "workspace-a",
+    cwd: process.cwd(),
+    command: "sleep 5 </dev/null & exit 0",
+    yieldTimeMs: 250,
+  });
+  assert.equal(deadStdin.running, true);
+  assert.ok(deadStdin.sessionId);
+
+  const deadStdinWrite = await manager.write({
+    workspaceId: "workspace-a",
+    sessionId: deadStdin.sessionId,
+    chars: "hello\n",
+    yieldTimeMs: 10,
+  });
+  assert.equal(deadStdinWrite.running, true);
+  manager.terminate("workspace-a", deadStdin.sessionId);
+
+  // Regression: pipe sessions must launch the resolved login shell (`-lc`),
+  // not a plain `-c` invocation, so PATH entries from ~/.zprofile etc. apply.
+  const previousShell = process.env.SHELL;
+  process.env.SHELL = "/bin/bash";
+  try {
+    const login = await manager.start({
+      workspaceId: "workspace-a",
+      cwd: process.cwd(),
+      command: "shopt -q login_shell && echo LOGIN_OK || echo LOGIN_MISSING",
+      yieldTimeMs: 2_000,
+    });
+    assert.equal(login.running, false);
+    assert.match(login.output, /LOGIN_OK/);
+  } finally {
+    if (previousShell === undefined) delete process.env.SHELL;
+    else process.env.SHELL = previousShell;
+  }
+}
+
 try {
   if (process.platform === "win32") {
     const pty = await manager.start({
@@ -188,6 +230,7 @@ try {
       yieldTimeMs: 10_000,
     });
     assert.equal(pty.running, false);
+    assert.equal(pty.signal, undefined);
     assert.match(pty.output, /pty-ok/);
   } else {
     const pty = await manager.start({
@@ -210,6 +253,7 @@ try {
       yieldTimeMs: 2_000,
     });
     assert.equal(resizedPty.running, false);
+    assert.equal(resizedPty.signal, undefined);
     assert.match(resizedPty.output, /columns:120/);
   }
 } finally {
diff --git a/src/process-sessions.ts b/src/process-sessions.ts
index 0a6b775e5..4d9d86a4c 100644
--- a/src/process-sessions.ts
+++ b/src/process-sessions.ts
@@ -322,8 +322,16 @@ export class ProcessSessionManager {
 
   private startPipe(session: ProcessSession, input: StartCommandInput): void {
     const shell = resolveShellCommand(input.command);
-    const detached = process.platform !== "win32";
-    const child = spawn(input.command, {
+    const windows = process.platform === "win32";
+    const detached = !windows;
+    // Spawn the resolved shell directly (like the PTY path) so its full argument
+    // list survives: Node's `shell` option always invokes `<shell> -c <command>`,
+    // dropping the login-shell flag resolved for POSIX. On Windows, replicate
+    // what Node's `shell` option does for cmd.exe — verbatim arguments with the
+    // command wrapped in an extra pair of quotes — because cmd does not honor
+    // Node's default backslash escaping of embedded quotes.
+    const args = windows ? ["/d", "/s", "/c", `"${input.command}"`] : shell.args;
+    const child = spawn(shell.executable, args, {
       cwd: input.cwd,
       env: processEnvironment({
         workspaceId: input.workspaceId,
@@ -332,7 +340,7 @@ export class ProcessSessionManager {
       stdio: "pipe",
       windowsHide: true,
       detached,
-      shell: shell.executable,
+      windowsVerbatimArguments: windows,
     });
 
     session.process = {
@@ -340,6 +348,10 @@ export class ProcessSessionManager {
       kill: (signal = "SIGTERM") => terminateProcessTree(child, signal, detached),
       resize: input.tty ? () => undefined : undefined,
     };
+    // A stdin write racing child exit surfaces as an EPIPE 'error' event with no
+    // listener, which would crash the process; the 'close' handler already
+    // reports the session as ended, so the error can be ignored.
+    child.stdin.on("error", () => undefined);
     child.stdout.on("data", (data: Buffer) => this.append(session, data.toString("utf8")));
     child.stderr.on("data", (data: Buffer) => this.append(session, data.toString("utf8")));
     child.on("error", (error) => this.append(session, `${error.message}\n`));
@@ -378,7 +390,14 @@ export class ProcessSessionManager {
     };
     pty.onData((data) => this.append(session, data));
     pty.onExit(({ exitCode, signal }) => {
-      this.finish(session, exitCode, signal === 0 ? undefined : String(signal));
+      // node-pty only delivers a numeric signal on POSIX; on Windows it is
+      // undefined, and `String(undefined)` would record "undefined" for clean
+      // exits.
+      this.finish(
+        session,
+        exitCode,
+        typeof signal === "number" && signal !== 0 ? String(signal) : undefined,
+      );
     });
   }