@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.0

package/packages/server/src/__tests__/concurrent-launch.test.ts

@@ -0,0 +1,110 @@
+/**
+ * Integration test — concurrent launches.
+ *
+ * Simulates two dashboard startups racing for the same per-HOME lock.
+ * Asserts that exactly one wins (`acquired`) and the other falls back
+ * cleanly (`attach` OR `InstanceLockMismatchError`, depending on liveness
+ * of the winner's probe).
+ *
+ * Uses real tmp dirs (not memfs) because proper-lockfile requires real
+ * filesystem semantics.
+ *
+ * See change: single-dashboard-per-home, task 12.1.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { acquireOrAttach, InstanceLockMismatchError } from "../home-lock.js";
+
+let tmpHome: string;
+let lockPath: string;
+let metaPath: string;
+
+beforeEach(() => {
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-concurrent-"));
+  lockPath = path.join(tmpHome, ".pi", "dashboard", "server.lock");
+  metaPath = `${lockPath}.meta.json`;
+});
+
+afterEach(() => {
+  try { fs.rmSync(tmpHome, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe("concurrent launch", () => {
+  it("exactly one of two parallel acquireOrAttach calls wins the lock", async () => {
+    // Both attempts race. Whichever wins first gets `acquired`. The loser
+    // sees ELOCKED; because our probe says the winner is "not alive" (we
+    // intentionally return dead to avoid racing the probe), the loser
+    // steals the stale lock and also acquires. That's not right for
+    // same-HOME same-instant races — we need the loser to SEE the winner.
+    //
+    // To mimic reality: make isProcessAlive true (process IS alive) and
+    // have the probe treat the metadata's identity as authoritative.
+    const hookFactory = () => ({
+      lockPath, metaPath, staleMs: 5_000,
+      isProcessAlive: () => true,
+      probeHealth: async () => {
+        // Read the live metadata file and echo back its identity — this
+        // models a working /api/health from the winner.
+        try {
+          const raw = fs.readFileSync(metaPath, "utf-8");
+          const m = JSON.parse(raw) as { identity?: string; pid?: number };
+          if (m && typeof m.identity === "string") {
+            return { running: true, identity: m.identity, pid: m.pid };
+          }
+        } catch { /* metadata not yet written */ }
+        return { running: true, pid: process.pid };
+      },
+    });
+
+    const cfg = (id: string) => ({
+      httpPort: 8000, piPort: 9999, version: "t",
+      identity: id,
+      hooks: hookFactory(),
+    });
+
+    const [a, b] = await Promise.allSettled([
+      acquireOrAttach(cfg("racer-A")),
+      acquireOrAttach(cfg("racer-B")),
+    ]);
+
+    // Count outcomes.
+    const outcomes = [a, b].map(r => {
+      if (r.status === "rejected") return "error";
+      return r.value.mode;
+    });
+
+    // Exactly one winner, and the loser is either "attach" or "error"
+    // (identity mismatch if the winner's identity appears in metadata
+    // before the loser reads it).
+    const winners = outcomes.filter(o => o === "acquired");
+    expect(winners).toHaveLength(1);
+
+    const losers = outcomes.filter(o => o !== "acquired");
+    expect(losers).toHaveLength(1);
+    expect(["attach", "error"]).toContain(losers[0]);
+
+    // Cleanup: release whichever won.
+    for (const r of [a, b]) {
+      if (r.status === "fulfilled" && r.value.mode === "acquired") {
+        await r.value.release();
+      }
+    }
+  });
+
+  it("the winning identity is persisted to metadata", async () => {
+    const first = await acquireOrAttach({
+      httpPort: 8000, piPort: 9999, version: "t",
+      identity: "winner",
+      hooks: { lockPath, metaPath, staleMs: 5_000 },
+    });
+    expect(first.mode).toBe("acquired");
+
+    const raw = fs.readFileSync(metaPath, "utf-8");
+    const meta = JSON.parse(raw) as { identity: string };
+    expect(meta.identity).toBe("winner");
+
+    if (first.mode === "acquired") await first.release();
+  });
+});

package/packages/server/src/__tests__/config-api.test.ts

@@ -100,5 +100,73 @@ describe("config-api", () => {
       // providers preserved
       expect(written.auth.providers.github.clientId).toBe("x");
     });
+
+    // ── fix-trusted-networks-no-oauth regression tests ─────────────────
+    // These assert that auth.bypassHosts and auth.bypassUrls are persisted
+    // through PUT /api/config. Before the fix, the auth-merge block only
+    // copied secret / providers / allowedUsers, silently dropping bypass*
+    // on every save.
+
+    it("should persist auth.bypassHosts with no pre-existing auth (task 1.5)", () => {
+      fs.writeFileSync(configFile, JSON.stringify({ port: 8000 }));
+      const result = writeConfigPartial({
+        auth: { providers: {}, bypassHosts: ["192.168.1.0/24"] },
+      });
+      expect(result.success).toBe(true);
+      const written = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+      expect(written.auth.bypassHosts).toEqual(["192.168.1.0/24"]);
+    });
+
+    it("should persist auth.bypassHosts alongside existing providers (task 1.6)", () => {
+      fs.writeFileSync(configFile, JSON.stringify({
+        auth: {
+          secret: "s",
+          providers: { github: { clientId: "abc", clientSecret: "xyz" } },
+        },
+      }));
+      const result = writeConfigPartial({
+        auth: { bypassHosts: ["10.0.0.0/8"] },
+      });
+      expect(result.success).toBe(true);
+      const written = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+      expect(written.auth.providers.github.clientId).toBe("abc");
+      expect(written.auth.providers.github.clientSecret).toBe("xyz");
+      expect(written.auth.bypassHosts).toEqual(["10.0.0.0/8"]);
+    });
+
+    it("should clear auth.bypassHosts via empty array (task 1.7)", () => {
+      fs.writeFileSync(configFile, JSON.stringify({
+        auth: { providers: {}, bypassHosts: ["192.168.1.0/24"] },
+      }));
+      const result = writeConfigPartial({
+        auth: { bypassHosts: [] },
+      });
+      expect(result.success).toBe(true);
+      const written = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+      expect(written.auth.bypassHosts).toEqual([]);
+    });
+
+    it("should preserve existing auth.bypassHosts when partial omits the key (task 1.8)", () => {
+      fs.writeFileSync(configFile, JSON.stringify({
+        auth: { providers: {}, bypassHosts: ["192.168.1.0/24"] },
+      }));
+      const result = writeConfigPartial({
+        auth: { allowedUsers: ["alice"] },
+      });
+      expect(result.success).toBe(true);
+      const written = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+      expect(written.auth.bypassHosts).toEqual(["192.168.1.0/24"]);
+      expect(written.auth.allowedUsers).toEqual(["alice"]);
+    });
+
+    it("should persist auth.bypassUrls symmetrically (task 1.9)", () => {
+      fs.writeFileSync(configFile, JSON.stringify({ port: 8000 }));
+      const result = writeConfigPartial({
+        auth: { providers: {}, bypassUrls: ["/webhooks/", "/metrics"] },
+      });
+      expect(result.success).toBe(true);
+      const written = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+      expect(written.auth.bypassUrls).toEqual(["/webhooks/", "/metrics"]);
+    });
   });
 });

package/packages/server/src/__tests__/crash-recovery.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Integration test — crash recovery.
+ *
+ * Simulates the "SIGKILL, no cleanup" case:
+ *   1. Acquire lock
+ *   2. Skip release() (simulated crash)
+ *   3. Attempt to acquire again from a different caller
+ *   4. Assert: stale detection fires, new caller acquires cleanly
+ *
+ * See change: single-dashboard-per-home, task 12.2.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { acquireOrAttach } from "../home-lock.js";
+
+let tmpHome: string;
+let lockPath: string;
+let metaPath: string;
+
+beforeEach(() => {
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-crash-"));
+  lockPath = path.join(tmpHome, ".pi", "dashboard", "server.lock");
+  metaPath = `${lockPath}.meta.json`;
+});
+
+afterEach(() => {
+  try { fs.rmSync(tmpHome, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe("crash recovery", () => {
+  it("steals a stale lock when the previous holder's process is dead", async () => {
+    // First acquire — simulate a dead process.
+    const first = await acquireOrAttach({
+      httpPort: 8000, piPort: 9999, version: "t",
+      identity: "dead-holder",
+      hooks: { lockPath, metaPath, staleMs: 1 },
+    });
+    expect(first.mode).toBe("acquired");
+    // INTENTIONALLY don't release.
+
+    // Allow stale threshold to elapse.
+    await new Promise(r => setTimeout(r, 50));
+
+    const second = await acquireOrAttach({
+      httpPort: 8000, piPort: 9999, version: "t",
+      identity: "recovery",
+      hooks: {
+        lockPath, metaPath, staleMs: 1,
+        isProcessAlive: () => false,           // previous holder is dead
+        probeHealth: async () => ({ running: false }),
+      },
+    });
+    expect(second.mode).toBe("acquired");
+
+    // Metadata now reflects the new holder.
+    const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8")) as { identity: string };
+    expect(meta.identity).toBe("recovery");
+
+    if (second.mode === "acquired") await second.release();
+  });
+
+  it("cleans up the metadata sidecar on graceful release", async () => {
+    const r = await acquireOrAttach({
+      httpPort: 8000, piPort: 9999, version: "t",
+      hooks: { lockPath, metaPath, staleMs: 1_000 },
+    });
+    expect(r.mode).toBe("acquired");
+    expect(fs.existsSync(metaPath)).toBe(true);
+
+    if (r.mode === "acquired") {
+      await r.release();
+      expect(fs.existsSync(metaPath)).toBe(false);
+    }
+  });
+
+  it("leaves metadata in place on crash (no release called)", async () => {
+    const r = await acquireOrAttach({
+      httpPort: 8000, piPort: 9999, version: "t",
+      hooks: { lockPath, metaPath, staleMs: 1_000 },
+    });
+    expect(r.mode).toBe("acquired");
+    // Don't release; metadata should persist until the next successful
+    // acquire clears it as part of steal.
+    expect(fs.existsSync(metaPath)).toBe(true);
+  });
+});

package/packages/server/src/__tests__/directory-service.test.ts

@@ -7,9 +7,23 @@ import type { PreferencesStore } from "../preferences-store.js";
 import type { SessionManager } from "../memory-session-manager.js";
 import type { DashboardSession } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 
-// Mock the shared openspec poller
-vi.mock("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js", () => ({
-  pollOpenSpecAsync: vi.fn(async () => ({ initialized: false, changes: [] })),
+// Mock the shared openspec poller. We expose three entry points now:
+//   - pollOpenSpecAsync: legacy monolithic (still used as fallback where no mtime gate applies)
+//   - runOpenSpecList:   new granular list call
+//   - runOpenSpecStatus: new granular status call
+vi.mock("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js")>();
+  return {
+    ...actual,
+    pollOpenSpecAsync: vi.fn(async () => ({ initialized: false, changes: [] })),
+    runOpenSpecList: vi.fn(async () => null),
+    runOpenSpecStatus: vi.fn(async () => null),
+  };
+});
+
+// Mock pi-resource-scanner so polling ticks don't hit the filesystem.
+vi.mock("../pi-resource-scanner.js", () => ({
+  scanPiResources: vi.fn(async () => ({ local: { extensions: [], skills: [], prompts: [] }, global: { extensions: [], skills: [], prompts: [] }, packages: [] })),
 }));
 
 // Mock the shared state replay
@@ -184,20 +198,33 @@ describe("DirectoryService", () => {
 
   describe("getOpenSpecData / refreshOpenSpec", () => {
     it("returns cached data after polling", async () => {
-      const { pollOpenSpecAsync } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
-      (pollOpenSpecAsync as any).mockResolvedValue({ initialized: true, changes: [{ name: "change-1" }] });
+      // Use the granular mocks; fs.stat on the bogus path will return undefined so
+      // the new gated poll short-circuits. To exercise the happy path we set up a
+      // real tmp dir with an openspec/changes folder.
+      const fs = await import("node:fs");
+      const os = await import("node:os");
+      const path = await import("node:path");
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "ds-cache-"));
+      fs.mkdirSync(path.join(tmp, "openspec", "changes", "change-1"), { recursive: true });
+
+      const { runOpenSpecList, runOpenSpecStatus } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
+      (runOpenSpecList as any).mockResolvedValue({ changes: [
+        { name: "change-1", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+      ] });
+      (runOpenSpecStatus as any).mockResolvedValue({ artifacts: [], isComplete: false });
 
       const stateStore = createMockPreferencesStore();
       const sessionManager = createMockSessionManager();
       service = createDirectoryService(stateStore, sessionManager);
 
-      const data = await service.refreshOpenSpec("/project");
+      const data = await service.refreshOpenSpec(tmp);
       expect(data.initialized).toBe(true);
       expect(data.changes[0].name).toBe("change-1");
 
-      // getOpenSpecData returns cached value
-      const cached = service.getOpenSpecData("/project");
+      const cached = service.getOpenSpecData(tmp);
       expect(cached).toEqual(data);
+
+      fs.rmSync(tmp, { recursive: true, force: true });
     });
   });
 
@@ -237,4 +264,203 @@ describe("DirectoryService", () => {
       vi.useRealTimers();
     });
   });
+
+  describe("mtime gate", () => {
+    const fs = require("node:fs") as typeof import("node:fs");
+    const os = require("node:os") as typeof import("node:os");
+    const path = require("node:path") as typeof import("node:path");
+
+    let tmpDir: string;
+    let cwd: string;
+    let changesDir: string;
+
+    beforeEach(async () => {
+      vi.clearAllMocks();
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ds-mtime-"));
+      cwd = tmpDir;
+      changesDir = path.join(cwd, "openspec", "changes");
+      fs.mkdirSync(changesDir, { recursive: true });
+      fs.mkdirSync(path.join(changesDir, "change-a"));
+      fs.mkdirSync(path.join(changesDir, "change-b"));
+    });
+
+    afterEach(() => {
+      if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it("first poll invokes list and status for each change", async () => {
+      const { runOpenSpecList, runOpenSpecStatus } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
+      (runOpenSpecList as any).mockResolvedValue({ changes: [
+        { name: "change-a", status: "in-progress", completedTasks: 1, totalTasks: 2 },
+        { name: "change-b", status: "in-progress", completedTasks: 0, totalTasks: 3 },
+      ] });
+      (runOpenSpecStatus as any).mockResolvedValue({ artifacts: [], isComplete: false });
+
+      const stateStore = createMockPreferencesStore();
+      const sessionManager = createMockSessionManager();
+      service = createDirectoryService(stateStore, sessionManager);
+
+      const data = await service.refreshOpenSpec(cwd);
+      expect(data.initialized).toBe(true);
+      expect(data.changes).toHaveLength(2);
+      expect(runOpenSpecList).toHaveBeenCalledTimes(1);
+      expect(runOpenSpecStatus).toHaveBeenCalledTimes(2);
+    });
+
+    it("second poll with unchanged mtimes makes zero CLI calls", async () => {
+      const { runOpenSpecList, runOpenSpecStatus } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
+      (runOpenSpecList as any).mockResolvedValue({ changes: [
+        { name: "change-a", status: "in-progress", completedTasks: 1, totalTasks: 2 },
+      ] });
+      (runOpenSpecStatus as any).mockResolvedValue({ artifacts: [], isComplete: false });
+
+      const stateStore = createMockPreferencesStore();
+      const sessionManager = createMockSessionManager();
+      service = createDirectoryService(stateStore, sessionManager);
+
+      // First poll (force = true bypasses gate, populates cache).
+      await service.refreshOpenSpec(cwd);
+      (runOpenSpecList as any).mockClear();
+      (runOpenSpecStatus as any).mockClear();
+
+      // Second poll via the internal gated path.
+      await service.pollDirectoryGated(cwd);
+      expect(runOpenSpecList).not.toHaveBeenCalled();
+      expect(runOpenSpecStatus).not.toHaveBeenCalled();
+    });
+
+    it("mtime advance on one change runs status only for that change", async () => {
+      const { runOpenSpecList, runOpenSpecStatus } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
+      (runOpenSpecList as any).mockResolvedValue({ changes: [
+        { name: "change-a", status: "in-progress", completedTasks: 1, totalTasks: 2 },
+        { name: "change-b", status: "in-progress", completedTasks: 0, totalTasks: 3 },
+      ] });
+      (runOpenSpecStatus as any).mockResolvedValue({ artifacts: [], isComplete: false });
+
+      const stateStore = createMockPreferencesStore();
+      const sessionManager = createMockSessionManager();
+      service = createDirectoryService(stateStore, sessionManager);
+      await service.refreshOpenSpec(cwd);
+      (runOpenSpecList as any).mockClear();
+      (runOpenSpecStatus as any).mockClear();
+
+      // Bump mtime of change-a only by touching a file inside it.
+      const future = new Date(Date.now() + 10_000);
+      fs.utimesSync(path.join(changesDir, "change-a"), future, future);
+
+      await service.pollDirectoryGated(cwd);
+      // List is gated by top-level mtime (unchanged) so it's skipped.
+      expect(runOpenSpecList).not.toHaveBeenCalled();
+      // Status re-run exactly once, for change-a.
+      expect(runOpenSpecStatus).toHaveBeenCalledTimes(1);
+      expect((runOpenSpecStatus as any).mock.calls[0][1]).toBe("change-a");
+    });
+
+    it("changeDetection: 'always' bypasses the gate", async () => {
+      const { runOpenSpecList, runOpenSpecStatus } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
+      (runOpenSpecList as any).mockResolvedValue({ changes: [
+        { name: "change-a", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+      ] });
+      (runOpenSpecStatus as any).mockResolvedValue({ artifacts: [], isComplete: false });
+
+      const stateStore = createMockPreferencesStore();
+      const sessionManager = createMockSessionManager();
+      service = createDirectoryService(stateStore, sessionManager, { changeDetection: "always" });
+      await service.refreshOpenSpec(cwd);
+      (runOpenSpecList as any).mockClear();
+      (runOpenSpecStatus as any).mockClear();
+
+      await service.pollDirectoryGated(cwd);
+      expect(runOpenSpecList).toHaveBeenCalledTimes(1);
+      expect(runOpenSpecStatus).toHaveBeenCalledTimes(1);
+    });
+
+    it("removed change is pruned from cache", async () => {
+      const { runOpenSpecList, runOpenSpecStatus } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
+      (runOpenSpecList as any).mockResolvedValueOnce({ changes: [
+        { name: "change-a", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+        { name: "change-b", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+      ] });
+      (runOpenSpecStatus as any).mockResolvedValue({ artifacts: [], isComplete: false });
+
+      const stateStore = createMockPreferencesStore();
+      const sessionManager = createMockSessionManager();
+      service = createDirectoryService(stateStore, sessionManager);
+      await service.refreshOpenSpec(cwd);
+
+      // Remove change-b and bump top-level mtime.
+      fs.rmSync(path.join(changesDir, "change-b"), { recursive: true });
+      const future = new Date(Date.now() + 20_000);
+      fs.utimesSync(changesDir, future, future);
+      (runOpenSpecList as any).mockResolvedValueOnce({ changes: [
+        { name: "change-a", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+      ] });
+      (runOpenSpecStatus as any).mockClear();
+
+      await service.pollDirectoryGated(cwd);
+      const data = service.getOpenSpecData(cwd);
+      expect(data?.changes).toHaveLength(1);
+      expect(data?.changes[0].name).toBe("change-a");
+    });
+  });
+
+  describe("semaphore + refresh", () => {
+    it("caps concurrent CLI spawns during refresh storms", async () => {
+      const { runOpenSpecList, runOpenSpecStatus } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
+      (runOpenSpecList as any).mockImplementation(async () => ({ changes: [
+        { name: "c1", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+      ] }));
+
+      let active = 0;
+      let peak = 0;
+      (runOpenSpecStatus as any).mockImplementation(async () => {
+        active++;
+        peak = Math.max(peak, active);
+        await new Promise((r) => setTimeout(r, 10));
+        active--;
+        return { artifacts: [], isComplete: false };
+      });
+
+      const stateStore = createMockPreferencesStore();
+      const sessionManager = createMockSessionManager();
+      service = createDirectoryService(stateStore, sessionManager, { maxConcurrentSpawns: 2, changeDetection: "always" });
+
+      // 10 concurrent refreshes across 5 dirs with list returning 1 change each.
+      await Promise.all(Array.from({ length: 10 }, (_, i) => service.refreshOpenSpec(`/project-${i}`)));
+      expect(peak).toBeLessThanOrEqual(2);
+    });
+  });
+
+  describe("jitter", () => {
+    it("produces deterministic per-cwd offsets within jitterSeconds", async () => {
+      const { phaseOffsetMs } = await import("../directory-service.js");
+      const a1 = phaseOffsetMs("/project/a", 5);
+      const a2 = phaseOffsetMs("/project/a", 5);
+      const b = phaseOffsetMs("/project/b", 5);
+      expect(a1).toBe(a2);          // stable
+      expect(a1).toBeLessThan(5000);
+      expect(a1).toBeGreaterThanOrEqual(0);
+      expect(b).toBeLessThan(5000);
+    });
+
+    it("returns 0 when jitterSeconds is 0", async () => {
+      const { phaseOffsetMs } = await import("../directory-service.js");
+      expect(phaseOffsetMs("/any", 0)).toBe(0);
+    });
+  });
+
+  describe("reconfigurePolling", () => {
+    it("accepts a new interval without losing cached data", async () => {
+      const { runOpenSpecList, runOpenSpecStatus } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
+      (runOpenSpecList as any).mockResolvedValue({ changes: [] });
+      (runOpenSpecStatus as any).mockResolvedValue(null);
+
+      const stateStore = createMockPreferencesStore();
+      const sessionManager = createMockSessionManager();
+      service = createDirectoryService(stateStore, sessionManager);
+      await service.refreshOpenSpec("/x");
+      service.reconfigurePolling({ pollIntervalSeconds: 60, maxConcurrentSpawns: 5, changeDetection: "mtime", jitterSeconds: 0 });
+      expect(service.getOpenSpecData("/x")).toBeDefined();
+    });
+  });
 });

package/packages/server/src/__tests__/editor-registry.test.ts

@@ -1,12 +1,18 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
-const { mockedExecSync } = vi.hoisted(() => ({
+const { mockedExecSync, mockedSpawnSync } = vi.hoisted(() => ({
   mockedExecSync: vi.fn(),
+  mockedSpawnSync: vi.fn(),
 }));
 
+// platform/process.ts and platform/tools.ts now use spawnSync via whereAllLines
+// and isProcessRunning; both must be mocked to exercise the detection path in
+// isolation. Default return is status:1 (not found) so each test explicitly
+// overrides what it needs.
 vi.mock("node:child_process", () => ({
-  default: { execSync: mockedExecSync },
+  default: { execSync: mockedExecSync, spawnSync: mockedSpawnSync },
   execSync: mockedExecSync,
+  spawnSync: mockedSpawnSync,
 }));
 
 import { detectEditors, isProcessRunning, isProcessRunningWin32, EDITORS, type DetectedEditor } from "../editor-registry.js";
@@ -14,6 +20,9 @@ import { detectEditors, isProcessRunning, isProcessRunningWin32, EDITORS, type D
 describe("editor-registry", () => {
   beforeEach(() => {
     vi.resetAllMocks();
+    // Default: spawnSync reports not-found so any un-overridden test still
+    // sees clean state rather than stale returns from previous tests.
+    mockedSpawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
   });
 
   describe("EDITORS", () => {
@@ -74,20 +83,22 @@ describe("editor-registry", () => {
 
   describe("detectEditors", () => {
     it("should return editor when process is running AND CLI is available", () => {
+      // platform/process.ts isProcessRunning uses execSync (pgrep) internally.
       mockedExecSync.mockImplementation((cmd) => {
         const s = String(cmd);
         if (s.includes("pgrep")) {
-          // Only Zed is running — match on both the macOS pattern
-          // ("/Applications/Zed.app") and the Linux pattern ("zed").
           if (s.includes("Zed") || s.includes("zed")) return Buffer.from("12345\n");
           throw new Error("not found");
         }
-        if (s.includes("which")) {
-          if (s.includes("zed")) return Buffer.from("/usr/local/bin/zed\n");
-          throw new Error("not found");
-        }
         throw new Error("unexpected command");
       });
+      // ToolResolver.which uses spawnSync for `which`/`where` lookup.
+      mockedSpawnSync.mockImplementation((cmd, args) => {
+        if ((cmd === "which" || cmd === "where") && args?.[0] === "zed") {
+          return { status: 0, stdout: "/usr/local/bin/zed\n", stderr: "" };
+        }
+        return { status: 1, stdout: "", stderr: "" };
+      });
 
       const result = detectEditors("/some/project");
       expect(result).toEqual([{ id: "zed", name: "Zed" }]);
@@ -97,9 +108,9 @@ describe("editor-registry", () => {
       mockedExecSync.mockImplementation((cmd) => {
         const s = String(cmd);
         if (s.includes("pgrep")) throw new Error("not found");
-        if (s.includes("which")) return Buffer.from("/usr/local/bin/zed\n");
         throw new Error("unexpected command");
       });
+      mockedSpawnSync.mockImplementation(() => ({ status: 0, stdout: "/usr/local/bin/zed\n", stderr: "" }));
 
       const result = detectEditors("/some/project");
       expect(result).toEqual([]);
@@ -109,9 +120,9 @@ describe("editor-registry", () => {
       mockedExecSync.mockImplementation((cmd) => {
         const s = String(cmd);
         if (s.includes("pgrep")) return Buffer.from("12345\n");
-        if (s.includes("which")) throw new Error("not found");
         throw new Error("unexpected command");
       });
+      mockedSpawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
 
       const result = detectEditors("/some/project");
       expect(result).toEqual([]);
@@ -125,13 +136,15 @@ describe("editor-registry", () => {
           if (s.includes("Visual Studio Code") || s.includes("code")) return Buffer.from("67890\n");
           throw new Error("not found");
         }
-        if (s.includes("which")) {
-          if (s.includes("zed")) return Buffer.from("/usr/local/bin/zed\n");
-          if (s.includes("code")) return Buffer.from("/usr/local/bin/code\n");
-          throw new Error("not found");
-        }
         throw new Error("unexpected command");
       });
+      mockedSpawnSync.mockImplementation((cmd, args) => {
+        if (cmd === "which" || cmd === "where") {
+          if (args?.[0] === "zed") return { status: 0, stdout: "/usr/local/bin/zed\n", stderr: "" };
+          if (args?.[0] === "code") return { status: 0, stdout: "/usr/local/bin/code\n", stderr: "" };
+        }
+        return { status: 1, stdout: "", stderr: "" };
+      });
 
       const result = detectEditors("/some/project");
       expect(result).toEqual([

package/packages/server/src/__tests__/extension-register-appimage.test.ts

@@ -30,7 +30,11 @@ describe("findBundledExtension - AppImage guard", () => {
   });
 
   it("returns null when extension does not exist", () => {
-    expect(findBundledExtension(tmpDir)).toBeNull();
+    // Disable Strategy 2 (node-resolver fallback) so this test exercises
+    // the AppImage guard path in isolation.
+    expect(
+      findBundledExtension(tmpDir, { resolvePackage: () => null }),
+    ).toBeNull();
   });
 
   // Note: We can't easily test the /tmp/.mount_ guard with real paths

package/packages/server/src/__tests__/extension-register.test.ts

@@ -26,7 +26,9 @@ describe("bridge extension registration (server context)", () => {
   });
 
   it("findBundledExtension returns null when extension dir does not exist", () => {
-    const result = findBundledExtension(tmpDir);
+    // Strategy 2 (require.resolve) would find the monorepo extension;
+    // disable it for this test so we exercise Strategy 1 in isolation.
+    const result = findBundledExtension(tmpDir, { resolvePackage: () => null });
     expect(result).toBeNull();
   });