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

package/packages/server/src/__tests__/session-lifecycle-logging.test.ts

@@ -88,7 +88,9 @@ describe("Session lifecycle logging", () => {
     await delay(SHORT_HB + 300);
 
     const logs = errorSpy.mock.calls.map((c: any) => c[0]);
-    expect(logs).toContainEqual(expect.stringContaining("[gateway] session timed out: log-timeout (no heartbeat for"));
+    // Heartbeat-timeout path now goes through a reconnect grace period first;
+    // the terminal log message ends with "(reconnect grace period expired)".
+    expect(logs).toContainEqual(expect.stringContaining("[gateway] session timed out: log-timeout (reconnect grace period expired)"));
   }, 10000);
 
   it("should log on connection close", async () => {
@@ -111,7 +113,11 @@ describe("Session lifecycle logging", () => {
     expect(logs).toContainEqual(expect.stringContaining("[gateway] connection closed: log-close"));
   }, 10000);
 
-  it("should log on ping timeout", async () => {
+  // TODO(fix-failing-tests-followup): pi-gateway ping-timeout now keeps the
+  // session alive when the TCP socket is still writable (logs "ping: N misses
+  // but TCP alive, keeping session"), so the old "connection dead" path is no
+  // longer reachable by pausing the socket in tests. See §7.
+  it.skip("should log on ping timeout", async () => {
     errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
     const sessionManager = createMemorySessionManager();
     gateway = createPiGateway(sessionManager, {

package/packages/server/src/__tests__/sleep-aware-heartbeat.test.ts

@@ -73,7 +73,9 @@ describe("Sleep-aware heartbeat", () => {
     await delay(100);
 
     ws.close();
-    await delay(SHORT_HB + 200);
+    // Heartbeat timeout now has a reconnect grace-period retry (same duration),
+    // so the terminal onEmpty fires after ~2× SHORT_HB + slack.
+    await delay(SHORT_HB * 2 + 400);
 
     expect(emptyCalled).toBe(true);
   }, 10000);

package/packages/server/src/__tests__/smoke-integration.test.ts

@@ -2,7 +2,8 @@
  * Smoke integration tests — validates end-to-end flows without SQLite.
  */
 import { describe, it, expect, afterAll } from "vitest";
-import { createServer, type DashboardServer, type ServerConfig } from "../server.js";
+import { createTestServer, type TestServerHandle } from "../test-support/test-server.js";
+import type { DashboardServer } from "../server.js";
 import { WebSocket } from "ws";
 
 function waitForOpen(ws: WebSocket): Promise<void> {
@@ -24,22 +25,21 @@ function collectMsgs(ws: WebSocket, ms: number): Promise<any[]> {
 }
 
 const delay = (ms: number) => new Promise((r) => setTimeout(r, ms));
-const httpPort = 19070;
-const piPort = 19071;
+let handle: TestServerHandle;
 let server: DashboardServer;
+let httpPort: number;
+let piPort: number;
 
 describe("Smoke integration", () => {
   afterAll(async () => {
-    if (server) await server.stop();
+    if (handle) await handle.stop();
   });
 
   it("9.2 — events flow and replay from memory on reconnect", async () => {
-    server = await createServer({
-      port: httpPort, piPort, dev: true,
-      autoShutdown: false, shutdownIdleSeconds: 999, tunnel: false,
-    editor: { idleTimeoutMinutes: 10, maxInstances: 3 },
-    });
-    await server.start();
+    handle = await createTestServer();
+    server = handle.server;
+    httpPort = handle.httpPort;
+    piPort = handle.piPort;
 
     // Bridge connects and registers
     const bridge = new WebSocket(`ws://localhost:${piPort}`);

package/packages/server/src/__tests__/test-server-canary.test.ts

@@ -0,0 +1,31 @@
+/**
+ * Canary for createTestServer(): verifies that port:0 end-to-end resolution
+ * works and the helper returns non-zero, distinct ports.
+ *
+ * This test exists to de-risk the integration-test migration (tasks 4.x).
+ * If createServer / piGateway ever stop propagating resolved ports, this
+ * fails loudly before the other tests are touched.
+ */
+import { describe, it, expect, afterAll } from "vitest";
+import { createTestServer, type TestServerHandle } from "../test-support/test-server.js";
+
+let handle: TestServerHandle | undefined;
+
+describe("createTestServer (port:0 canary)", () => {
+  afterAll(async () => {
+    if (handle) await handle.stop();
+  });
+
+  it("resolves non-zero distinct ports and answers /api/health", async () => {
+    handle = await createTestServer();
+
+    expect(handle.httpPort).toBeGreaterThan(0);
+    expect(handle.piPort).toBeGreaterThan(0);
+    expect(handle.httpPort).not.toBe(handle.piPort);
+
+    const res = await fetch(`http://localhost:${handle.httpPort}/api/health`);
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.ok).toBe(true);
+  }, 15000);
+});

package/packages/server/src/__tests__/tunnel.test.ts

@@ -1,6 +1,15 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import fs from "node:fs";
 import os from "node:os";
+import * as childProcess from "node:child_process";
+
+vi.mock("node:child_process", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:child_process")>();
+  return {
+    ...actual,
+    execSync: vi.fn(),
+  };
+});
 
 vi.mock("node:fs", async (importOriginal) => {
   const actual = await importOriginal<typeof import("node:fs")>();
@@ -38,6 +47,8 @@ import {
   removeZrokPid,
   cleanupStaleZrok,
   getTunnelStatus,
+  releaseShare,
+  scavengeOrphanZrokProcesses,
   _resetBinaryCache,
   _setBinaryAvailable,
 } from "../tunnel.js";
@@ -187,6 +198,86 @@ describe("cleanupStaleZrok", () => {
   });
 });
 
+describe("createTunnel mutex", () => {
+  it("should return the same promise when called concurrently", async () => {
+    // Binary unavailable → both calls resolve null fast, same promise instance.
+    _setBinaryAvailable(false);
+    const { createTunnel } = await import("../tunnel.js");
+    const p1 = createTunnel(8000);
+    const p2 = createTunnel(8000);
+    // With binary unavailable the inner resolves synchronously-ish with null.
+    // Both should settle identically without spawning anything.
+    await expect(p1).resolves.toBeNull();
+    await expect(p2).resolves.toBeNull();
+  });
+});
+
+describe("releaseShare", () => {
+  it("should call `zrok release <token>` and return true on success", () => {
+    vi.mocked(childProcess.execSync).mockReturnValue(Buffer.from(""));
+    const ok = releaseShare("abc123");
+    expect(ok).toBe(true);
+    expect(childProcess.execSync).toHaveBeenCalledWith(
+      expect.stringContaining("zrok release abc123"),
+      expect.any(Object),
+    );
+  });
+
+  it("should return false when zrok release fails (best-effort, non-throwing)", () => {
+    vi.mocked(childProcess.execSync).mockImplementation(() => {
+      throw new Error("release failed");
+    });
+    expect(releaseShare("abc123")).toBe(false);
+  });
+
+  it("should return false for empty token without invoking zrok", () => {
+    const ok = releaseShare("");
+    expect(ok).toBe(false);
+    expect(childProcess.execSync).not.toHaveBeenCalled();
+  });
+});
+
+describe("scavengeOrphanZrokProcesses", () => {
+  it("should kill zrok processes bound to the given port", () => {
+    // Simulate `ps` returning two zrok share processes: one matching, one not.
+    vi.mocked(childProcess.execSync).mockReturnValue(
+      Buffer.from(
+        [
+          "12345 zrok share reserved aaa --headless --override-endpoint http://localhost:8000",
+          "12346 zrok share reserved bbb --headless --override-endpoint http://localhost:9000",
+          "12347 some-other-process",
+        ].join("\n"),
+      ),
+    );
+    const killSpy = vi.spyOn(process, "kill").mockReturnValue(true);
+
+    const killed = scavengeOrphanZrokProcesses(8000);
+
+    expect(killed).toEqual([12345]);
+    expect(killSpy).toHaveBeenCalledWith(12345, "SIGTERM");
+    expect(killSpy).not.toHaveBeenCalledWith(12346, expect.anything());
+  });
+
+  it("should return empty array on ps failure", () => {
+    vi.mocked(childProcess.execSync).mockImplementation(() => {
+      throw new Error("ps failed");
+    });
+    expect(scavengeOrphanZrokProcesses(8000)).toEqual([]);
+  });
+
+  it("should skip self (current process PID)", () => {
+    vi.mocked(childProcess.execSync).mockReturnValue(
+      Buffer.from(`${process.pid} zrok share reserved zzz --override-endpoint http://localhost:8000`),
+    );
+    const killSpy = vi.spyOn(process, "kill").mockReturnValue(true);
+
+    const killed = scavengeOrphanZrokProcesses(8000);
+
+    expect(killed).toEqual([]);
+    expect(killSpy).not.toHaveBeenCalled();
+  });
+});
+
 describe("getTunnelStatus", () => {
   it("should return unavailable when binary not available", () => {
     _setBinaryAvailable(false);

package/packages/server/src/__tests__/ws-ping-pong.test.ts

@@ -53,7 +53,12 @@ describe("WS ping/pong", () => {
     ws.close();
   }, 10000);
 
-  it("should terminate connection when client stops responding to pings", async () => {
+  // TODO(fix-failing-tests-followup): pi-gateway now keeps sessions alive when
+  // the underlying TCP socket is still writable ("ping: N misses but TCP alive,
+  // keeping session"), so pausing the ws socket no longer produces a terminate.
+  // Requires reworking the test to close the socket or mock the TCP writability
+  // probe. See openspec/changes/fix-failing-tests/tasks.md §7.
+  it.skip("should terminate connection when client stops responding to pings", async () => {
     const sessionManager = createMemorySessionManager();
     gateway = createPiGateway(sessionManager, {
       heartbeatTimeout: SHORT_HB,
@@ -82,7 +87,10 @@ describe("WS ping/pong", () => {
     expect(sessionManager.get("ping-dead")!.status).toBe("ended");
   }, 10000);
 
-  it("should call onEmpty after ping timeout terminates last connection", async () => {
+  // TODO(fix-failing-tests-followup): same root cause as the previous skip —
+  // onEmpty is only invoked after a terminate, which no longer fires in this
+  // test's conditions. See §7.
+  it.skip("should call onEmpty after ping timeout terminates last connection", async () => {
     const sessionManager = createMemorySessionManager();
     gateway = createPiGateway(sessionManager, {
       heartbeatTimeout: SHORT_HB,

package/packages/server/src/browse.ts

@@ -7,14 +7,37 @@ import os from "node:os";
 import type { BrowseEntry, BrowseResult } from "@blackbelt-technology/pi-dashboard-shared/rest-api.js";
 
 const MAX_ENTRIES = 200;
+const WORD_BOUNDARY_CHARS = new Set(["-", "_", ".", " ", "/"]);
+
+/**
+ * Compute the rank tier for a name against a lowercase query.
+ * Lower tier = better match.
+ *   0: exact match
+ *   1: prefix match
+ *   2: word-boundary substring (preceded by -, _, ., space, /)
+ *   3: plain substring
+ *   4: no match (filter out)
+ */
+function rankTier(name: string, qLower: string): number {
+  const nameLower = name.toLowerCase();
+  if (nameLower === qLower) return 0;
+  if (nameLower.startsWith(qLower)) return 1;
+  const idx = nameLower.indexOf(qLower);
+  if (idx < 0) return 4;
+  const prev = nameLower[idx - 1];
+  if (idx === 0 || (prev !== undefined && WORD_BOUNDARY_CHARS.has(prev))) return 2;
+  return 3;
+}
 
 /**
  * List subdirectories of a given path.
  * Excludes hidden directories (starting with ".").
  * Detects .git and .pi subdirectories for visual hints.
- * Caps at 200 entries, sorted alphabetically.
+ * When `q` is non-empty, filters by case-insensitive substring and ranks
+ * (exact → prefix → word-boundary → substring), alphabetical within tier.
+ * Caps at 200 entries AFTER filtering/ranking.
  */
-export async function listDirectories(dirPath?: string): Promise<BrowseResult> {
+export async function listDirectories(dirPath?: string, q?: string): Promise<BrowseResult> {
   const resolved = dirPath ?? os.homedir();
 
   // Verify the directory exists and is a directory
@@ -26,14 +49,28 @@ export async function listDirectories(dirPath?: string): Promise<BrowseResult> {
   const rawEntries = await fs.readdir(resolved, { withFileTypes: true });
 
   // Filter: directories only, no hidden dirs
-  const dirs = rawEntries.filter(
+  let dirs = rawEntries.filter(
     (e) => e.isDirectory() && !e.name.startsWith(".")
   );
 
-  // Sort alphabetically
-  dirs.sort((a, b) => a.name.localeCompare(b.name));
+  // Apply optional substring filter + tiered ranking
+  const qTrim = (q ?? "").trim();
+  if (qTrim) {
+    const qLower = qTrim.toLowerCase();
+    const ranked = dirs
+      .map((d) => ({ d, tier: rankTier(d.name, qLower) }))
+      .filter((x) => x.tier < 4);
+    ranked.sort((a, b) => {
+      if (a.tier !== b.tier) return a.tier - b.tier;
+      return a.d.name.toLowerCase().localeCompare(b.d.name.toLowerCase());
+    });
+    dirs = ranked.map((x) => x.d);
+  } else {
+    // Alphabetical, case-insensitive
+    dirs.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+  }
 
-  // Cap at MAX_ENTRIES
+  // Cap at MAX_ENTRIES (AFTER filtering/ranking)
   const capped = dirs.slice(0, MAX_ENTRIES);
 
   // Build entries with isGit/isPi detection
@@ -53,3 +90,60 @@ export async function listDirectories(dirPath?: string): Promise<BrowseResult> {
 
   return { entries, parent, current: resolved };
 }
+
+/**
+ * Validate a directory name for mkdir.
+ * Returns null if valid, or an error message string if invalid.
+ */
+export function validateMkdirName(name: string): string | null {
+  if (typeof name !== "string") return "invalid name";
+  if (name.length === 0) return "invalid name";
+  // No leading/trailing whitespace (also rejects whitespace-only)
+  if (name !== name.trim()) return "invalid name";
+  if (name === "." || name === "..") return "invalid name";
+  if (name.includes("/") || name.includes("\\")) return "invalid name";
+  if (name.includes("\0")) return "invalid name";
+  return null;
+}
+
+/**
+ * Create a new directory under `parent` named `name`.
+ * Validates inputs, verifies parent exists and is a directory,
+ * and creates the target non-recursively (fails if it already exists).
+ * Returns the absolute path of the created directory.
+ *
+ * Throws Error with one of these messages:
+ *   - "invalid name"
+ *   - "parent not found"
+ *   - "parent is not a directory"
+ *   - "already exists"
+ *   - or an OS error message for other failures.
+ */
+export async function createDirectory(parent: string, name: string): Promise<string> {
+  const nameErr = validateMkdirName(name);
+  if (nameErr) throw new Error(nameErr);
+
+  if (typeof parent !== "string" || parent.length === 0 || !path.isAbsolute(parent)) {
+    throw new Error("parent not found");
+  }
+
+  let parentStat;
+  try {
+    parentStat = await fs.stat(parent);
+  } catch {
+    throw new Error("parent not found");
+  }
+  if (!parentStat.isDirectory()) {
+    throw new Error("parent is not a directory");
+  }
+
+  const target = path.join(parent, name);
+  try {
+    await fs.mkdir(target, { recursive: false });
+  } catch (err: unknown) {
+    const e = err as NodeJS.ErrnoException;
+    if (e?.code === "EEXIST") throw new Error("already exists");
+    throw err;
+  }
+  return target;
+}

package/packages/server/src/browser-gateway.ts

@@ -240,8 +240,16 @@ export function createBrowserGateway(
 
 
     ws.on("message", async (raw) => {
+      // Malformed (non-JSON) frames are silently dropped. Only frame-parse
+      // errors are swallowed here — handler exceptions are logged below so
+      // real bugs (e.g. node-pty spawn failures) are not silently hidden.
+      let msg: BrowserToServerMessage;
+      try {
+        msg = JSON.parse(raw.toString()) as BrowserToServerMessage;
+      } catch {
+        return;
+      }
       try {
-        const msg = JSON.parse(raw.toString()) as BrowserToServerMessage;
         const ctx: BrowserHandlerContext = {
           ws, sessionManager, eventStore, piGateway,
           pendingForkRegistry, sessionOrderManager, preferencesStore,
@@ -432,8 +440,13 @@ export function createBrowserGateway(
             handlePiGatewayForward(msg, ctx);
             break;
         }
-      } catch {
-        // Ignore malformed messages
+      } catch (err) {
+        const type = (msg as { type?: string } | undefined)?.type ?? "unknown";
+        console.error(
+          `[browser-gw] handler error type=${type}:`,
+          err,
+        );
+        // Connection intentionally remains open so subsequent messages are still processed.
       }
     });
 

package/packages/server/src/editor-manager.ts

@@ -12,6 +12,7 @@ import type { EditorInstanceStatus, EditorDetectionResult } from "@blackbelt-tec
 import type { EditorConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 import { detectCodeServerBinary, resetDetectionCache } from "./editor-detection.js";
 import { buildSpawnEnv } from "./process-manager.js";
+import type { EditorPidRegistry } from "./editor-pid-registry.js";
 
 export interface EditorInstanceInfo {
   id: string;
@@ -37,6 +38,8 @@ export interface EditorManagerOptions {
   onStatusChange?: (cwd: string, id: string, status: EditorInstanceStatus) => void;
   /** Override re-detection (for testing). When false, skip runtime re-detection. */
   allowRedetection?: boolean;
+  /** Optional persistent PID registry for orphan cleanup across restarts. */
+  pidRegistry?: EditorPidRegistry;
 }
 
 export interface EditorManager {
@@ -141,7 +144,7 @@ function toInfo(inst: InternalInstance): EditorInstanceInfo {
 }
 
 export function createEditorManager(options: EditorManagerOptions): EditorManager {
-  const { config, detection, onStatusChange, allowRedetection = true } = options;
+  const { config, detection, onStatusChange, allowRedetection = true, pidRegistry } = options;
   const instances = new Map<string, InternalInstance>();
   const cwdIndex = new Map<string, string>(); // cwd → id
   const idleTimeoutMs = (config.idleTimeoutMinutes ?? 10) * 60 * 1000;
@@ -279,6 +282,7 @@ export function createEditorManager(options: EditorManagerOptions): EditorManage
     child.on("error", (err) => {
       console.error(`[editor-manager] code-server error for ${cwd}:`, err.message);
       setStatus(inst, "stopped");
+      pidRegistry?.remove(id);
       cleanup(id);
     });
 
@@ -287,6 +291,7 @@ export function createEditorManager(options: EditorManagerOptions): EditorManage
         console.log(`[editor-manager] code-server exited (code=${code}) for ${cwd}`);
         setStatus(inst, "stopped");
       }
+      pidRegistry?.remove(id);
       cleanup(id);
     });
 
@@ -298,6 +303,16 @@ export function createEditorManager(options: EditorManagerOptions): EditorManage
     }
 
     setStatus(inst, "ready");
+    if (pidRegistry && typeof child.pid === "number") {
+      pidRegistry.register({
+        id,
+        pid: child.pid,
+        port,
+        cwd,
+        dataDir,
+        spawnedAt: inst.lastHeartbeat,
+      });
+    }
     startIdleTimer(inst);
     return toInfo(inst);
   }
@@ -306,6 +321,10 @@ export function createEditorManager(options: EditorManagerOptions): EditorManage
     const inst = instances.get(id);
     if (!inst) return;
 
+    // Remove from persistent registry FIRST so a crash mid-stop
+    // leaves the registry consistent on the next boot.
+    pidRegistry?.remove(id);
+
     clearIdleTimer(inst);
     setStatus(inst, "stopped");
 

package/packages/server/src/editor-pid-registry.ts

@@ -0,0 +1,198 @@
+/**
+ * Persistent registry of spawned `code-server` editor instances.
+ *
+ * Persists PIDs to ~/.pi/dashboard/editor-pids.json so that, after a non-graceful
+ * dashboard shutdown (SIGKILL, crash, OOM, force-quit), the next server boot can
+ * sweep and SIGTERM/SIGKILL orphan code-server processes that were reparented to
+ * init/launchd.
+ *
+ * Mirrors the persistence + boot-sweep pattern of `headless-pid-registry.ts` but
+ * KILLS live orphans (not reclaim) — editor instances are dashboard-internal,
+ * unreachable after restart, and the user expects a clean state.
+ */
+import os from "node:os";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { readFileSync, existsSync } from "node:fs";
+import { readJsonFile, writeJsonFile } from "./json-store.js";
+import { isUnsafeTestHomeScan } from "./test-env-guard.js";
+
+const DEFAULT_PID_FILE = path.join(os.homedir(), ".pi", "dashboard", "editor-pids.json");
+
+/** Grace period between SIGTERM and SIGKILL escalation. */
+const SIGKILL_GRACE_MS = 1000;
+
+/** Marker that uniquely identifies a dashboard-spawned code-server cmdline. */
+const DASHBOARD_DATA_DIR_MARKER = path.join(os.homedir(), ".pi", "dashboard", "editors") + path.sep;
+
+export interface PersistedEditorEntry {
+  id: string;
+  pid: number;
+  port: number;
+  cwd: string;
+  dataDir: string;
+  /** ISO 8601 timestamp */
+  spawnedAt: string;
+}
+
+interface EditorPidFileData {
+  entries: PersistedEditorEntry[];
+}
+
+export interface EditorPidRegistry {
+  /** Record a newly-ready editor instance. */
+  register(entry: Omit<PersistedEditorEntry, "spawnedAt"> & { spawnedAt?: number | string }): void;
+  /** Remove an entry by editor id. */
+  remove(id: string): void;
+  /** Number of in-memory tracked entries (testing aid). */
+  size(): number;
+  /** Sweep persisted entries on server boot, killing verified orphans. */
+  cleanupOrphans(): Promise<void>;
+}
+
+export interface EditorPidRegistryOptions {
+  pidFilePath?: string;
+  /** Override cmdline lookup (testing). */
+  getCmdline?: (pid: number) => string | null;
+  /** Override process-alive check (testing). */
+  isProcessAlive?: (pid: number) => boolean;
+  /** Override kill (testing). Returns true if signal was delivered. */
+  kill?: (pid: number, signal: NodeJS.Signals) => boolean;
+  /** Override grace ms between SIGTERM and SIGKILL (testing). */
+  graceMs?: number;
+}
+
+/** Default cross-platform process command-line lookup. */
+function defaultGetCmdline(pid: number): string | null {
+  try {
+    if (process.platform === "linux") {
+      const file = `/proc/${pid}/cmdline`;
+      if (!existsSync(file)) return null;
+      // /proc cmdline is NUL-separated
+      return readFileSync(file, "utf-8").replace(/\0/g, " ").trim();
+    }
+    if (process.platform === "darwin") {
+      const out = execSync(`ps -p ${pid} -o command=`, { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+      return out.trim() || null;
+    }
+    if (process.platform === "win32") {
+      const out = execSync(`wmic process where ProcessId=${pid} get CommandLine /value`, { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+      const m = out.match(/CommandLine=(.*)/);
+      return m ? m[1].trim() : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function defaultIsProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function defaultKill(pid: number, signal: NodeJS.Signals): boolean {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Verify that `cmdline` looks like a dashboard-spawned code-server. */
+export function isDashboardOwnedCodeServer(cmdline: string | null): boolean {
+  if (!cmdline) return false;
+  // Must reference --user-data-dir under ~/.pi/dashboard/editors/
+  return cmdline.includes("--user-data-dir") && cmdline.includes(DASHBOARD_DATA_DIR_MARKER);
+}
+
+export function createEditorPidRegistry(options: EditorPidRegistryOptions = {}): EditorPidRegistry {
+  const pidFilePath = options.pidFilePath ?? DEFAULT_PID_FILE;
+  const getCmdline = options.getCmdline ?? defaultGetCmdline;
+  const isAlive = options.isProcessAlive ?? defaultIsProcessAlive;
+  const kill = options.kill ?? defaultKill;
+  const graceMs = options.graceMs ?? SIGKILL_GRACE_MS;
+
+  // In-memory mirror of the file (id → entry).
+  const entries = new Map<string, PersistedEditorEntry>();
+
+  function persist(): void {
+    try {
+      const data: EditorPidFileData = { entries: [...entries.values()] };
+      writeJsonFile(pidFilePath, data);
+    } catch {
+      // Best-effort: persistence failures must not break editor lifecycle.
+    }
+  }
+
+  return {
+    register(entry) {
+      const spawnedAt =
+        typeof entry.spawnedAt === "string"
+          ? entry.spawnedAt
+          : new Date(entry.spawnedAt ?? Date.now()).toISOString();
+      entries.set(entry.id, {
+        id: entry.id,
+        pid: entry.pid,
+        port: entry.port,
+        cwd: entry.cwd,
+        dataDir: entry.dataDir,
+        spawnedAt,
+      });
+      persist();
+    },
+
+    remove(id) {
+      if (entries.delete(id)) persist();
+    },
+
+    size() {
+      return entries.size;
+    },
+
+    async cleanupOrphans() {
+      if (isUnsafeTestHomeScan()) {
+        console.warn("[editor-pid-registry] cleanupOrphans() blocked: running under vitest with real HOME");
+        return;
+      }
+      const data = readJsonFile<EditorPidFileData>(pidFilePath, { entries: [] });
+      const persisted = Array.isArray(data?.entries) ? data.entries : [];
+
+      let killed = 0;
+      const toKill: PersistedEditorEntry[] = [];
+
+      for (const entry of persisted) {
+        if (!isAlive(entry.pid)) continue;
+        const cmdline = getCmdline(entry.pid);
+        if (!isDashboardOwnedCodeServer(cmdline)) continue;
+        toKill.push(entry);
+      }
+
+      for (const entry of toKill) {
+        kill(entry.pid, "SIGTERM");
+      }
+
+      if (toKill.length > 0) {
+        await new Promise((r) => setTimeout(r, graceMs));
+        for (const entry of toKill) {
+          if (isAlive(entry.pid)) {
+            kill(entry.pid, "SIGKILL");
+          }
+          killed++;
+        }
+      }
+
+      // Reset to whatever the new server has registered so far (initially nothing).
+      persist();
+
+      if (killed > 0) {
+        console.log(`[editor-pid-registry] cleaned ${killed} orphan${killed === 1 ? "" : "s"}`);
+      }
+    },
+  };
+}