fix(test): isolate Windows background terminal tests

.github/workflows/ci.yml

@@ -117,3 +117,6 @@ jobs:
             "extensions/background-terminals/manager.test.ts"
           }
           node --test --experimental-strip-types $testPath
+      - name: Test Windows full-suite isolation
+        timeout-minutes: 5
+        run: bun run test

scripts/node-test-groups.d.mts

@@ -0,0 +1,4 @@
+export function partitionNodeTestsByPlatform(
+  files: string[],
+  platform?: NodeJS.Platform,
+): { parallel: string[]; serial: string[] };

scripts/node-test-groups.mjs

@@ -0,0 +1,33 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+const backgroundTerminalsRoot = resolve(
+  "tests",
+  "extensions",
+  "background-terminals",
+);
+
+function isBackgroundTerminalsTest(file) {
+  const relativePath = relative(backgroundTerminalsRoot, file);
+  return (
+    relativePath !== "" &&
+    relativePath !== ".." &&
+    !relativePath.startsWith(`..${sep}`) &&
+    !isAbsolute(relativePath)
+  );
+}
+
+export function partitionNodeTestsByPlatform(
+  files,
+  platform = process.platform,
+) {
+  if (platform !== "win32") {
+    return { parallel: files, serial: [] };
+  }
+
+  const parallel = [];
+  const serial = [];
+  for (const file of files) {
+    (isBackgroundTerminalsTest(file) ? serial : parallel).push(file);
+  }
+  return { parallel, serial };
+}

scripts/run-tests.mjs

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { resolve } from "node:path";
 import { discoverTestFiles } from "./discover-tests.mjs";
+import { partitionNodeTestsByPlatform } from "./node-test-groups.mjs";
 
 const files = discoverTestFiles(resolve("tests"));
 const nodeTests = files.filter((file) => file.endsWith(".test.ts"));
@@ -12,13 +13,29 @@ if (nodeTests.length === 0 || vitestTests.length === 0) {
   );
 }
 
-const nodeResult = spawnSync(
-  process.execPath,
-  ["--test", "--experimental-strip-types", ...nodeTests],
-  { stdio: "inherit" },
-);
-if (nodeResult.status !== 0) {
-  process.exit(nodeResult.status ?? 1);
+function runNodeTests(files, options = []) {
+  if (files.length === 0) return 0;
+  const result = spawnSync(
+    process.execPath,
+    ["--test", "--experimental-strip-types", ...options, ...files],
+    { stdio: "inherit" },
+  );
+  return result.status ?? 1;
+}
+
+const nodeTestGroups = partitionNodeTestsByPlatform(nodeTests);
+const parallelNodeResult = runNodeTests(nodeTestGroups.parallel);
+if (parallelNodeResult !== 0) {
+  process.exit(parallelNodeResult);
+}
+
+// Windows process-tree tests must not overlap unrelated Node test files.
+// Keep the rest of the suite on Node's default file-level concurrency.
+const serialNodeResult = runNodeTests(nodeTestGroups.serial, [
+  "--test-concurrency=1",
+]);
+if (serialNodeResult !== 0) {
+  process.exit(serialNodeResult);
 }
 
 // Invoke the CLI module through Node instead of the package-manager shim.

tests/extensions/file-mutation-display/render.test.ts

@@ -65,7 +65,7 @@ const fixtures: Array<{
       content: [{ type: "text", text: "one\ntwo" }],
       details: undefined,
     },
-    success: /Read\s+src\/long-file\.ts:10-29/,
+    success: /Read\s+src[\\/]long-file\.ts:10-29/,
   },
   {
     name: "bash",

tests/extensions/file-search/index.spec.ts

@@ -232,17 +232,19 @@ it.effect("binary resolution: fdfind is accepted as a system fd", () =>
 
 it.effect("binary resolution: an existing cached binary is used silently", () =>
   Effect.gen(function* () {
-    const env = makeEnv({ available: ["/cache/bin/rg"] });
+    const binDir = join("/cache", "bin");
+    const cachedBinary = join(binDir, "rg");
+    const env = makeEnv({ available: [cachedBinary] });
     const resolved = yield* resolveBinary(
       TOOL_SPECS.rg,
-      "/cache/bin",
+      binDir,
       darwinArm,
       env,
     );
 
     assert.deepEqual(resolved, {
       tool: "rg",
-      command: "/cache/bin/rg",
+      command: cachedBinary,
       source: "cached",
     });
     assert.equal(env.installs.length, 0);
@@ -253,16 +255,17 @@ it.effect(
   "binary resolution: missing everywhere triggers exactly one install",
   () =>
     Effect.gen(function* () {
+      const binDir = join("/repo", "bin");
       const env = makeEnv({ available: [] });
       const resolved = yield* resolveBinary(
         TOOL_SPECS.rg,
-        "/repo/bin",
+        binDir,
         darwinArm,
         env,
       );
 
       assert.equal(resolved.source, "installed");
-      assert.equal(resolved.command, "/repo/bin/rg");
+      assert.equal(resolved.command, join(binDir, "rg"));
       assert.equal(env.installs.length, 1);
       assert.match(
         env.installs[0].url,

tests/extensions/git-info/index.test.ts

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import {
   chmodSync,
+  copyFileSync,
   existsSync,
   mkdirSync,
   mkdtempSync,
@@ -9,7 +10,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { delimiter, join } from "node:path";
 import test from "node:test";
 import type {
   ExtensionAPI,
@@ -32,10 +33,46 @@ test("automatic refresh stays local until /pr explicitly requests GitHub data",
   const callLog = join(root, "gh-calls.log");
   mkdirSync(bin);
 
-  const gitPath = join(bin, "git");
-  writeFileSync(
-    gitPath,
-    `#!/bin/sh
+  const isWindows = process.platform === "win32";
+  const gitPath = join(bin, isWindows ? "git.exe" : "git");
+  const ghPath = join(bin, isWindows ? "gh.exe" : "gh");
+  const commandRunner = join(root, "command-runner.cjs");
+  if (isWindows) {
+    // Direct Node spawning does not resolve .cmd fixtures without a shell, so
+    // use copied Node executables with a per-process command shim instead.
+    writeFileSync(
+      commandRunner,
+      `const { appendFileSync } = require("node:fs");
+const command = /[\\\\/]git\\.exe$/i.test(process.execPath)
+  ? "git"
+  : /[\\\\/]gh\\.exe$/i.test(process.execPath)
+    ? "gh"
+    : null;
+const args = [
+  ...(process.argv[1]?.split(/[\\\\/]/).pop() ? [process.argv[1].split(/[\\\\/]/).pop()] : []),
+  ...process.argv.slice(2),
+];
+if (command === "git") {
+  const key = \`\${args[0] ?? ""} \${args[1] ?? ""}\`;
+  if (key === "rev-parse --is-inside-work-tree") process.stdout.write("true\\n");
+  else if (key === "branch --show-current") process.stdout.write("main\\n");
+  else if (key === "rev-parse --short") process.stdout.write("abc123\\n");
+  else if (key === "status --porcelain=v1") process.stdout.write(" M local.ts\\n?? new.ts\\n");
+  else process.exitCode = 2;
+  process.exit();
+} else if (command === "gh") {
+  appendFileSync(process.env.GH_CALL_LOG, args.join(" ") + "\\n");
+  process.stdout.write("{\\"number\\":42,\\"url\\":\\"https://example.test/pr/42\\",\\"state\\":\\"OPEN\\",\\"isDraft\\":false}\\n");
+  process.exit();
+}
+`,
+    );
+    copyFileSync(process.execPath, gitPath);
+    copyFileSync(process.execPath, ghPath);
+  } else {
+    writeFileSync(
+      gitPath,
+      `#!/bin/sh
 case "$1 $2" in
   "rev-parse --is-inside-work-tree") echo true ;;
   "branch --show-current") echo main ;;
@@ -44,23 +81,31 @@ case "$1 $2" in
   *) exit 2 ;;
 esac
 `,
-  );
-  chmodSync(gitPath, 0o755);
-
-  const ghPath = join(bin, "gh");
-  writeFileSync(
-    ghPath,
-    `#!/bin/sh
+    );
+    chmodSync(gitPath, 0o755);
+    writeFileSync(
+      ghPath,
+      `#!/bin/sh
 printf '%s\\n' "$*" >> "$GH_CALL_LOG"
 printf '%s\\n' '{"number":42,"url":"https://example.test/pr/42","state":"OPEN","isDraft":false}'
 `,
-  );
-  chmodSync(ghPath, 0o755);
+    );
+    chmodSync(ghPath, 0o755);
+  }
 
   const previousPath = process.env.PATH;
   const previousLog = process.env.GH_CALL_LOG;
-  process.env.PATH = `${bin}:${previousPath ?? ""}`;
+  const previousNodeOptions = process.env.NODE_OPTIONS;
+  process.env.PATH = `${bin}${delimiter}${previousPath ?? ""}`;
   process.env.GH_CALL_LOG = callLog;
+  if (isWindows) {
+    process.env.NODE_OPTIONS = [
+      previousNodeOptions,
+      `--require=${commandRunner}`,
+    ]
+      .filter(Boolean)
+      .join(" ");
+  }
 
   const hooks = new Map<
     string,
@@ -110,7 +155,16 @@ printf '%s\\n' '{"number":42,"url":"https://example.test/pr/42","state":"OPEN","
 
   try {
     await hooks.get("session_start")?.({}, ctx);
-    const local = await localPublished;
+    let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+    const local = await Promise.race([
+      localPublished,
+      new Promise<never>((_, reject) => {
+        timeoutHandle = setTimeout(
+          () => reject(new Error("Timed out waiting for local git info")),
+          5_000,
+        );
+      }),
+    ]).finally(() => clearTimeout(timeoutHandle));
     assert.equal(local.branch, "main");
     assert.equal(local.changedFiles, 2);
     assert.equal(local.pullRequest, null);
@@ -127,6 +181,8 @@ printf '%s\\n' '{"number":42,"url":"https://example.test/pr/42","state":"OPEN","
     process.env.PATH = previousPath;
     if (previousLog === undefined) delete process.env.GH_CALL_LOG;
     else process.env.GH_CALL_LOG = previousLog;
+    if (previousNodeOptions === undefined) delete process.env.NODE_OPTIONS;
+    else process.env.NODE_OPTIONS = previousNodeOptions;
     rmSync(root, { recursive: true, force: true });
   }
 });

tests/extensions/sessions/git-stats.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { mkdtemp, mkdir, rm, symlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import test from "node:test";
 import { createSessionStatsLoader } from "../../../extensions/sessions/git-stats.ts";
 import type { SessionInfoLike } from "../../../extensions/sessions/sessions.ts";
@@ -105,6 +105,7 @@ test("overlapping viewport work is retained while work that leaves is cancelled"
   });
   const loader = createSessionStatsLoader({
     maxConcurrency: 4,
+    canonicalizeCwd: async (cwd) => cwd,
     runGit: (args, cwd, signal) => {
       const id = `${cwd}:${args[0]}`;
       started.push(id);
@@ -140,7 +141,8 @@ test("overlapping viewport work is retained while work that leaves is cancelled"
 
   assert.equal(aborted.length, 4);
   assert.equal(
-    started.filter((entry) => entry.startsWith("/tmp/project-2:")).length,
+    started.filter((entry) => entry.startsWith(`${resolve("/tmp/project-2")}:`))
+      .length,
     2,
     "overlapping work must not restart",
   );
@@ -219,7 +221,11 @@ test("real and symlink workspace paths share one canonical latest bucket", async
   const alias = join(root, "alias");
   try {
     await mkdir(workspace);
-    await symlink(workspace, alias);
+    await symlink(
+      workspace,
+      alias,
+      process.platform === "win32" ? "junction" : "dir",
+    );
     const [newest, older] = makeSessions(2).map((entry, index) => ({
       ...entry,
       cwd: index === 0 ? workspace : alias,

tests/extensions/sessions/preview-loader.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { appendFileSync, renameSync } from "node:fs";
+import { appendFileSync, renameSync, writeFileSync } from "node:fs";
 import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -399,10 +399,10 @@ for (const version of [1, 3]) {
         : [header(3), message("m1", null, "user", "replaced")];
     const fixture = await writeSession(originalEntries);
     const replacementPath = join(fixture.directory, "replacement.jsonl");
-    await writeFile(
-      replacementPath,
-      `${replacementEntries.map((entry) => JSON.stringify(entry)).join("\n")}\n`,
-    );
+    const replacementContent = `${replacementEntries
+      .map((entry) => JSON.stringify(entry))
+      .join("\n")}\n`;
+    await writeFile(replacementPath, replacementContent);
     t.after(() => rm(fixture.directory, { recursive: true, force: true }));
 
     let replaced = false;
@@ -411,7 +411,13 @@ for (const version of [1, 3]) {
         onRead: () => {
           if (replaced) return;
           replaced = true;
-          renameSync(replacementPath, fixture.path);
+          if (process.platform === "win32") {
+            // Windows rejects rename-over-open. An in-place replacement still
+            // exercises the loader's changed-file rejection on that platform.
+            writeFileSync(fixture.path, `${replacementContent}\n`);
+          } else {
+            renameSync(replacementPath, fixture.path);
+          }
         },
       }),
       /changed while preview was loading/,

tests/extensions/shared/worktree.test.ts

@@ -554,7 +554,12 @@ describe("worktree lifecycle", () => {
         `child ${index}\n`,
       );
     }
-    assert.equal(fs.readFileSync(path.join(repo, "a.txt"), "utf8"), "hello\n");
+    assert.equal(
+      fs
+        .readFileSync(path.join(repo, "a.txt"), "utf8")
+        .replaceAll("\r\n", "\n"),
+      "hello\n",
+    );
 
     for (const worktree of worktrees) {
       if (!worktree) continue;
@@ -577,10 +582,19 @@ describe("worktree lifecycle", () => {
     });
     assert.ok(inner.ok);
     if (!inner.ok) return;
-    assert.equal(
-      // realpath because git resolves symlinks and macOS tmpdirs are one.
-      fs.realpathSync(path.dirname(path.dirname(inner.worktree.path))),
-      fs.realpathSync(path.join(repo, ".git")),
+    const worktreeContainer = fs.statSync(
+      path.dirname(path.dirname(inner.worktree.path)),
+    );
+    const commonGitDirectory = fs.statSync(path.join(repo, ".git"));
+    assert.deepEqual(
+      {
+        dev: worktreeContainer.dev,
+        ino: worktreeContainer.ino,
+      },
+      {
+        dev: commonGitDirectory.dev,
+        ino: commonGitDirectory.ino,
+      },
     );
 
     git(repo, "worktree", "remove", "--force", inner.worktree.path);