gsd-pi 2.54.0-dev.e1efc1a → 2.55.0-dev.9ec7cdf

package/src/resources/extensions/gsd/tests/parallel-worker-lock-contention.test.ts

@@ -0,0 +1,226 @@
+/**
+ * parallel-worker-lock-contention.test.ts — Regression tests for #2184.
+ *
+ * Covers all four bugs from the parallel worker contention issue:
+ *   Bug 1: Session lock contention — per-milestone lock isolation
+ *   Bug 2: Budget ceiling scoped to current session for parallel workers
+ *   Bug 3: syncProjectRootToWorktree skips when source === destination (symlinks)
+ *   Bug 4: createMilestoneWorktree copies planning artifacts
+ *
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ */
+
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  existsSync,
+  symlinkSync,
+  readFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  acquireSessionLock,
+  releaseSessionLock,
+  effectiveLockFile,
+  effectiveLockTarget,
+} from "../session-lock.ts";
+import { gsdRoot } from "../paths.ts";
+import {
+  syncProjectRootToWorktree,
+  syncStateToProjectRoot,
+} from "../auto-worktree.ts";
+import { writeLock, readCrashLock, clearLock } from "../crash-recovery.ts";
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+
+// ─── Bug 1: Per-milestone lock isolation ──────────────────────────────────────
+
+describe("parallel-worker-lock-contention (#2184)", () => {
+  // Save and restore env vars between tests
+  const savedEnv: Record<string, string | undefined> = {};
+
+  beforeEach(() => {
+    savedEnv.GSD_PARALLEL_WORKER = process.env.GSD_PARALLEL_WORKER;
+    savedEnv.GSD_MILESTONE_LOCK = process.env.GSD_MILESTONE_LOCK;
+  });
+
+  afterEach(() => {
+    if (savedEnv.GSD_PARALLEL_WORKER === undefined) {
+      delete process.env.GSD_PARALLEL_WORKER;
+    } else {
+      process.env.GSD_PARALLEL_WORKER = savedEnv.GSD_PARALLEL_WORKER;
+    }
+    if (savedEnv.GSD_MILESTONE_LOCK === undefined) {
+      delete process.env.GSD_MILESTONE_LOCK;
+    } else {
+      process.env.GSD_MILESTONE_LOCK = savedEnv.GSD_MILESTONE_LOCK;
+    }
+  });
+
+  // ─── Bug 1a: effectiveLockFile returns per-milestone name ────────────────
+  test("Bug 1a: effectiveLockFile returns auto.lock without parallel env", () => {
+    delete process.env.GSD_PARALLEL_WORKER;
+    delete process.env.GSD_MILESTONE_LOCK;
+    assert.equal(effectiveLockFile(), "auto.lock");
+  });
+
+  test("Bug 1a: effectiveLockFile returns auto-<MID>.lock in parallel mode", () => {
+    process.env.GSD_PARALLEL_WORKER = "1";
+    process.env.GSD_MILESTONE_LOCK = "M003";
+    assert.equal(effectiveLockFile(), "auto-M003.lock");
+  });
+
+  // ─── Bug 1b: effectiveLockTarget returns per-milestone directory ─────────
+  test("Bug 1b: effectiveLockTarget returns gsdDir without parallel env", () => {
+    delete process.env.GSD_PARALLEL_WORKER;
+    const gsdDir = "/tmp/test/.gsd";
+    assert.equal(effectiveLockTarget(gsdDir), gsdDir);
+  });
+
+  test("Bug 1b: effectiveLockTarget returns parallel/<MID> in parallel mode", () => {
+    process.env.GSD_PARALLEL_WORKER = "1";
+    process.env.GSD_MILESTONE_LOCK = "M003";
+    const gsdDir = "/tmp/test/.gsd";
+    assert.equal(effectiveLockTarget(gsdDir), join(gsdDir, "parallel", "M003"));
+  });
+
+  // ─── Bug 1c: Two parallel workers acquire independent locks ──────────────
+  test("Bug 1c: parallel workers use per-milestone lock files, not shared auto.lock", () => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-parallel-lock-"));
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    try {
+      // Simulate worker for M001
+      process.env.GSD_PARALLEL_WORKER = "1";
+      process.env.GSD_MILESTONE_LOCK = "M001";
+
+      const r1 = acquireSessionLock(base);
+      assert.ok(r1.acquired, "M001 worker acquires lock");
+
+      // Verify the lock file is per-milestone
+      const gsdDir = gsdRoot(base);
+      const m001LockFile = join(gsdDir, "auto-M001.lock");
+      assert.ok(existsSync(m001LockFile), "auto-M001.lock exists");
+
+      // The shared auto.lock should NOT exist
+      const sharedLockFile = join(gsdDir, "auto.lock");
+      assert.ok(!existsSync(sharedLockFile), "shared auto.lock does NOT exist");
+
+      // The per-milestone lock target directory should exist
+      const m001LockTarget = join(gsdDir, "parallel", "M001");
+      assert.ok(existsSync(m001LockTarget), "parallel/M001 directory exists");
+
+      releaseSessionLock(base);
+
+      // After release, per-milestone lock file should be cleaned
+      assert.ok(!existsSync(m001LockFile), "auto-M001.lock cleaned after release");
+    } finally {
+      delete process.env.GSD_PARALLEL_WORKER;
+      delete process.env.GSD_MILESTONE_LOCK;
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Bug 1d: crash-recovery uses per-milestone lock file ─────────────────
+  test("Bug 1d: crash-recovery writeLock/readCrashLock uses per-milestone lock in parallel mode", () => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-parallel-crash-"));
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    try {
+      process.env.GSD_PARALLEL_WORKER = "1";
+      process.env.GSD_MILESTONE_LOCK = "M002";
+
+      writeLock(base, "execute-task", "M002/S01/T01");
+
+      const gsdDir = gsdRoot(base);
+      const lockFile = join(gsdDir, "auto-M002.lock");
+      assert.ok(existsSync(lockFile), "crash-recovery writes auto-M002.lock");
+
+      const data = readCrashLock(base);
+      assert.ok(data !== null, "readCrashLock reads per-milestone lock");
+      assert.equal(data!.unitId, "M002/S01/T01");
+
+      clearLock(base);
+      assert.ok(!existsSync(lockFile), "clearLock removes per-milestone lock");
+    } finally {
+      delete process.env.GSD_PARALLEL_WORKER;
+      delete process.env.GSD_MILESTONE_LOCK;
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Bug 3: syncProjectRootToWorktree skips same-path symlinks ───────────
+  test("Bug 3: syncProjectRootToWorktree skips when .gsd resolves to same path (symlink)", () => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-symlink-sync-"));
+    const externalGsd = join(base, "external-gsd");
+    const projectRoot = join(base, "project");
+    const worktreePath = join(base, "worktree");
+
+    mkdirSync(externalGsd, { recursive: true });
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(worktreePath, { recursive: true });
+
+    // Create the external state directory with a milestone
+    mkdirSync(join(externalGsd, "milestones", "M001"), { recursive: true });
+    writeFileSync(
+      join(externalGsd, "milestones", "M001", "M001-ROADMAP.md"),
+      "# Roadmap",
+    );
+
+    // Symlink both project and worktree .gsd to the same external directory
+    symlinkSync(externalGsd, join(projectRoot, ".gsd"));
+    symlinkSync(externalGsd, join(worktreePath, ".gsd"));
+
+    try {
+      // This should NOT throw ERR_FS_CP_EINVAL — it should skip silently
+      let threw = false;
+      try {
+        syncProjectRootToWorktree(projectRoot, worktreePath, "M001");
+      } catch {
+        threw = true;
+      }
+      assert.ok(!threw, "syncProjectRootToWorktree does not throw on same-path symlink");
+
+      // Same for reverse direction
+      threw = false;
+      try {
+        syncStateToProjectRoot(worktreePath, projectRoot, "M001");
+      } catch {
+        threw = true;
+      }
+      assert.ok(!threw, "syncStateToProjectRoot does not throw on same-path symlink");
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Bug 3b: sync still works when paths are different ───────────────────
+  test("Bug 3b: syncProjectRootToWorktree copies when .gsd paths are different", () => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-diff-sync-"));
+    const projectRoot = join(base, "project");
+    const worktreePath = join(base, "worktree");
+
+    mkdirSync(join(projectRoot, ".gsd", "milestones", "M001"), { recursive: true });
+    mkdirSync(join(worktreePath, ".gsd", "milestones"), { recursive: true });
+
+    writeFileSync(
+      join(projectRoot, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "# Roadmap content",
+    );
+
+    try {
+      syncProjectRootToWorktree(projectRoot, worktreePath, "M001");
+
+      // The roadmap should have been copied
+      const copied = join(worktreePath, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+      assert.ok(existsSync(copied), "milestone roadmap copied to worktree");
+      assert.equal(readFileSync(copied, "utf-8"), "# Roadmap content");
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/plan-milestone-queue-context.test.ts

@@ -0,0 +1,48 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildPlanMilestonePrompt } from "../auto-prompts.ts";
+
+function createBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-plan-queue-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M010"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+describe("plan-milestone queue context", () => {
+  test("includes queue brief when planning milestone without roadmap context", async () => {
+    const base = createBase();
+    try {
+      writeFileSync(
+        join(base, ".gsd", "QUEUE.md"),
+        [
+          "# Queue",
+          "",
+          "### M010: Analytics Dashboard — Interactivity, Intelligence & Demo Readiness",
+          "**Vision:** Ship a polished analytics dashboard with drilldowns and AI assistance.",
+          "",
+          "## Scope",
+          "- Interactivity",
+          "- Intelligence",
+          "- Demo readiness",
+          "",
+        ].join("\n"),
+      );
+
+      const prompt = await buildPlanMilestonePrompt("M010", "M010", base);
+
+      assert.match(prompt, /Source: `\.gsd\/QUEUE\.md`/);
+      assert.match(prompt, /Analytics Dashboard — Interactivity, Intelligence & Demo Readiness/);
+      assert.match(prompt, /Ship a polished analytics dashboard/);
+    } finally {
+      cleanup(base);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/preferences-worktree-sync.test.ts

@@ -1,17 +1,19 @@
 /**
- * Regression tests for #2684: preferences.md must be included in both
- * ROOT_STATE_FILES (sync) and copyPlanningArtifacts (initial seed).
+ * Regression tests for #2684 plus uppercase-preference normalization:
+ * preferences files are handled explicitly
+ * outside ROOT_STATE_FILES and prefer canonical PREFERENCES.md over the
+ * legacy lowercase fallback.
  *
  * Without this, post_unit_hooks and all preference-driven config silently
  * stop working inside auto-mode worktrees.
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-test("#2684: preferences.md is NOT in ROOT_STATE_FILES (forward-only sync)", () => {
+test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)", () => {
   const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
   const src = readFileSync(srcPath, "utf-8");
 
@@ -22,21 +24,23 @@ test("#2684: preferences.md is NOT in ROOT_STATE_FILES (forward-only sync)", ()
   const arrayEnd = src.indexOf("] as const", arrayStart);
   const block = src.slice(arrayStart, arrayEnd);
 
-  // preferences.md must NOT be in ROOT_STATE_FILES — it is handled separately
+  // Project preferences must NOT be in ROOT_STATE_FILES — they are handled separately
   // in syncGsdStateToWorktree() (forward-only, additive). Including it in
   // ROOT_STATE_FILES would cause syncWorktreeStateBack() to overwrite the
   // authoritative project root copy (#2684).
   const entries = block.split("\n")
     .map(l => l.trim())
     .filter(l => l.startsWith('"') && l.includes(".md"));
-  const hasPrefs = entries.some(l => l.includes("preferences.md"));
+  const hasPrefs = entries.some(
+    l => l.includes("PREFERENCES.md") || l.includes("preferences.md"),
+  );
   assert.ok(
     !hasPrefs,
-    "preferences.md must NOT be in ROOT_STATE_FILES (back-sync would overwrite root)",
+    "preferences files must NOT be in ROOT_STATE_FILES (back-sync would overwrite root)",
   );
 });
 
-test("#2684: copyPlanningArtifacts file list includes preferences.md", () => {
+test("copyPlanningArtifacts prefers canonical PREFERENCES.md with lowercase fallback", () => {
   const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
   const src = readFileSync(srcPath, "utf-8");
 
@@ -45,15 +49,15 @@ test("#2684: copyPlanningArtifacts file list includes preferences.md", () => {
   assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
 
   // Extract function body (up to the next top-level function)
-  const fnBody = src.slice(fnIdx, fnIdx + 1500);
+  const fnBody = src.slice(fnIdx, fnIdx + 2200);
 
   assert.ok(
-    fnBody.includes('"preferences.md"'),
-    "preferences.md should be in copyPlanningArtifacts file list",
+    fnBody.includes("PROJECT_PREFERENCES_FILE") && fnBody.includes("LEGACY_PROJECT_PREFERENCES_FILE"),
+    "copyPlanningArtifacts should prefer canonical PREFERENCES.md and retain lowercase fallback via the shared constants",
   );
 });
 
-test("#2684: syncGsdStateToWorktree copies preferences.md", async () => {
+test("syncGsdStateToWorktree copies canonical PREFERENCES.md", async () => {
   // Functional test: create a mock source and destination, call the sync
   const srcBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-src-"));
   const dstBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-dst-"));
@@ -63,9 +67,9 @@ test("#2684: syncGsdStateToWorktree copies preferences.md", async () => {
   mkdirSync(dstGsd, { recursive: true });
 
   try {
-    // Write a preferences.md in source
+    // Write a canonical PREFERENCES.md in source
     writeFileSync(
-      join(srcGsd, "preferences.md"),
+      join(srcGsd, "PREFERENCES.md"),
       "---\nversion: 1\n---\n\npost_unit_hooks:\n  - name: notify\n    command: echo done\n",
     );
 
@@ -73,16 +77,54 @@ test("#2684: syncGsdStateToWorktree copies preferences.md", async () => {
     const { syncGsdStateToWorktree } = await import("../auto-worktree.ts");
     syncGsdStateToWorktree(srcBase, dstBase);
 
-    // Verify preferences.md was copied
+    // Verify PREFERENCES.md was copied
     assert.ok(
-      existsSync(join(dstGsd, "preferences.md")),
-      "preferences.md should be copied to worktree",
+      existsSync(join(dstGsd, "PREFERENCES.md")),
+      "PREFERENCES.md should be copied to worktree",
     );
 
-    const content = readFileSync(join(dstGsd, "preferences.md"), "utf-8");
+    const content = readFileSync(join(dstGsd, "PREFERENCES.md"), "utf-8");
     assert.ok(
       content.includes("post_unit_hooks"),
-      "copied preferences.md should contain the hooks config",
+      "copied PREFERENCES.md should contain the hooks config",
+    );
+  } finally {
+    rmSync(srcBase, { recursive: true, force: true });
+    rmSync(dstBase, { recursive: true, force: true });
+  }
+});
+
+test("syncGsdStateToWorktree falls back to legacy lowercase preferences.md", async () => {
+  const srcBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-legacy-src-"));
+  const dstBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-legacy-dst-"));
+  const srcGsd = join(srcBase, ".gsd");
+  const dstGsd = join(dstBase, ".gsd");
+  mkdirSync(srcGsd, { recursive: true });
+  mkdirSync(dstGsd, { recursive: true });
+
+  try {
+    writeFileSync(
+      join(srcGsd, "preferences.md"),
+      "---\nversion: 1\n---\n\ngit:\n  auto_push: true\n",
+    );
+
+    const { syncGsdStateToWorktree } = await import("../auto-worktree.ts");
+    const result = syncGsdStateToWorktree(srcBase, dstBase);
+
+    const copiedEntries = readdirSync(dstGsd)
+      .filter((name) => name === "PREFERENCES.md" || name === "preferences.md");
+
+    assert.ok(
+      copiedEntries.length === 1,
+      `expected exactly one preferences file in worktree, got ${copiedEntries.join(", ") || "(none)"}`,
+    );
+    assert.ok(
+      copiedEntries[0] === "PREFERENCES.md" || copiedEntries[0] === "preferences.md",
+      "legacy fallback should still result in one readable preferences file",
+    );
+    assert.ok(
+      result.synced.includes("preferences.md") || result.synced.includes("PREFERENCES.md"),
+      "legacy fallback copy should be reported in synced list",
     );
   } finally {
     rmSync(srcBase, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -12,6 +12,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { classifyError, isTransient, isTransientNetworkError } from "../error-classifier.ts";
 import { pauseAutoForProviderError } from "../provider-error-pause.ts";
+import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -268,6 +269,90 @@ test("pauseAutoForProviderError falls back to indefinite pause when not rate lim
   ]);
 });
 
+// ── resumeAutoAfterProviderDelay ────────────────────────────────────────────
+
+test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded base path", async () => {
+  const startCalls: Array<{ base: string; verboseMode: boolean; step?: boolean }> = [];
+  const result = await resumeAutoAfterProviderDelay(
+    {} as any,
+    { ui: { notify() {} } } as any,
+    {
+      getSnapshot: () => ({
+        active: false,
+        paused: true,
+        stepMode: true,
+        basePath: "/tmp/project",
+      }),
+      startAuto: async (_ctx, _pi, base, verboseMode, options) => {
+        startCalls.push({ base, verboseMode, step: options?.step });
+      },
+    },
+  );
+
+  assert.equal(result, "resumed");
+  assert.deepEqual(startCalls, [
+    { base: "/tmp/project", verboseMode: false, step: true },
+  ]);
+});
+
+test("resumeAutoAfterProviderDelay does not double-start when auto-mode is already active", async () => {
+  let startCalls = 0;
+  const result = await resumeAutoAfterProviderDelay(
+    {} as any,
+    { ui: { notify() {} } } as any,
+    {
+      getSnapshot: () => ({
+        active: true,
+        paused: false,
+        stepMode: false,
+        basePath: "/tmp/project",
+      }),
+      startAuto: async () => {
+        startCalls += 1;
+      },
+    },
+  );
+
+  assert.equal(result, "already-active");
+  assert.equal(startCalls, 0);
+});
+
+test("resumeAutoAfterProviderDelay leaves auto paused when no base path is available", async () => {
+  const notifications: Array<{ message: string; level: string }> = [];
+  let startCalls = 0;
+
+  const result = await resumeAutoAfterProviderDelay(
+    {} as any,
+    {
+      ui: {
+        notify(message: string, level?: string) {
+          notifications.push({ message, level: level ?? "info" });
+        },
+      },
+    } as any,
+    {
+      getSnapshot: () => ({
+        active: false,
+        paused: true,
+        stepMode: false,
+        basePath: "",
+      }),
+      startAuto: async () => {
+        startCalls += 1;
+      },
+    },
+  );
+
+  assert.equal(result, "missing-base");
+  assert.equal(startCalls, 0);
+  assert.deepEqual(notifications, [
+    {
+      message: "Provider error recovery delay elapsed, but no paused auto-mode base path was available. Leaving auto-mode paused.",
+      level: "warning",
+    },
+  ]);
+});
+
 // ── Escalating backoff for transient errors (#1166) ─────────────────────────
 
 test("agent-end-recovery.ts tracks consecutive transient errors for escalating backoff", () => {
@@ -303,6 +388,19 @@ test("agent-end-recovery.ts applies escalating delay for repeated transient erro
   );
 });
 
+test("agent-end-recovery.ts resumes transient provider pauses through startAuto instead of a hidden prompt", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
+
+  assert.ok(
+    src.includes("resumeAutoAfterProviderDelay"),
+    "agent-end-recovery.ts must resume paused auto-mode through resumeAutoAfterProviderDelay (#2813)",
+  );
+  assert.ok(
+    !src.includes('Continue execution — provider error recovery delay elapsed.'),
+    "transient provider resume must not rely on a hidden continue prompt (#2813)",
+  );
+});
+
 // ── Codex error extraction (#1166) ──────────────────────────────────────────
 
 test("openai-codex-responses.ts extracts nested error fields", () => {

package/src/resources/extensions/gsd/tests/register-extension-guard.test.ts

@@ -0,0 +1,59 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { handleRecoverableExtensionProcessError } from "../bootstrap/register-extension.ts";
+
+test("handleRecoverableExtensionProcessError swallows spawn ENOENT", () => {
+  let stderr = "";
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    const handled = handleRecoverableExtensionProcessError(
+      Object.assign(new Error("missing binary"), {
+        code: "ENOENT",
+        syscall: "spawn npm",
+        path: "npm",
+      }),
+    );
+    assert.equal(handled, true);
+    assert.match(stderr, /spawn ENOENT: npm/);
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+});
+
+test("handleRecoverableExtensionProcessError swallows uv_cwd ENOENT", () => {
+  let stderr = "";
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    const handled = handleRecoverableExtensionProcessError(
+      Object.assign(new Error("process.cwd failed"), {
+        code: "ENOENT",
+        syscall: "uv_cwd",
+      }),
+    );
+    assert.equal(handled, true);
+    assert.match(stderr, /ENOENT \(uv_cwd\): process\.cwd failed/);
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+});
+
+test("handleRecoverableExtensionProcessError leaves unrelated errors unhandled", () => {
+  const handled = handleRecoverableExtensionProcessError(
+    Object.assign(new Error("permission denied"), {
+      code: "EPERM",
+      syscall: "open",
+    }),
+  );
+  assert.equal(handled, false);
+});