test(e2e): isolate daemon restart ownership

packages/app/e2e/helpers/daemon-client-loader.ts

@@ -26,13 +26,14 @@ interface E2EDaemonClientConfig {
   webSocketFactory?: NodeWebSocketFactory;
 }
 
-function resolveDaemonWsUrl(): string {
-  return `ws://127.0.0.1:${getE2EDaemonPort()}/ws`;
+function resolveDaemonWsUrl(port?: number): string {
+  return `ws://127.0.0.1:${port ?? getE2EDaemonPort()}/ws`;
 }
 
 export interface ConnectDaemonClientOptions {
   clientIdPrefix: string;
   appVersion?: string;
+  port?: number;
 }
 
 /**
@@ -45,7 +46,7 @@ export async function connectDaemonClient<ClientInstance extends { connect(): Pr
 ): Promise<ClientInstance> {
   const DaemonClient = await loadDaemonClientConstructor<E2EDaemonClientConfig, ClientInstance>();
   const client = new DaemonClient({
-    url: resolveDaemonWsUrl(),
+    url: resolveDaemonWsUrl(options.port),
     clientId: `${options.clientIdPrefix}-${randomUUID()}`,
     clientType: "cli",
     appVersion: options.appVersion ?? loadAppVersion(),

packages/app/e2e/helpers/daemon-restart.ts

@@ -1,159 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-import { createRequire } from "node:module";
-import { readFile } from "node:fs/promises";
-import net from "node:net";
-import path from "node:path";
-
-import { getE2EDaemonPort } from "./daemon-port";
-import { withDisabledE2ESpeechEnv } from "./speech-env";
-
-/**
- * Restarts the isolated E2E daemon against the SAME PASEO_HOME and SAME port so
- * persisted state reloads and existing clients can reconnect. This exercises the
- * post-restart rehydration path (the daemon rebuilding workspace/agent links
- * from disk), which is where the worktree-branch regression lives.
- *
- * The daemon is owned by Playwright's `globalSetup`, which keeps its child
- * handle in module scope we can't reach from a spec. Instead we drive it the
- * same way an operator would: read the supervisor PID from
- * `$PASEO_HOME/paseo.pid`, SIGTERM it (the supervisor forwards the signal to its
- * worker and releases the lock), wait for the port to free, then re-spawn the
- * supervisor with the identical environment globalSetup used. The relay and
- * Metro processes are untouched, so we reuse their already-published ports.
- *
- * This NEVER targets the developer daemon: the port comes from
- * `getE2EDaemonPort()`, which refuses 6767, and PASEO_HOME is the isolated E2E
- * home globalSetup created.
- */
-
-function getEnvOrThrow(name: string): string {
-  const value = process.env[name];
-  if (!value) {
-    throw new Error(`${name} is not set (expected from Playwright globalSetup).`);
-  }
-  return value;
-}
-
-async function readSupervisorPid(paseoHome: string): Promise<number> {
-  const pidPath = path.join(paseoHome, "paseo.pid");
-  const content = await readFile(pidPath, "utf8");
-  const parsed = JSON.parse(content) as { pid?: unknown };
-  if (typeof parsed.pid !== "number") {
-    throw new Error(`Malformed PID lock at ${pidPath}: ${content}`);
-  }
-  return parsed.pid;
-}
-
-function isPidRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function isPortListening(port: number, host = "127.0.0.1"): Promise<boolean> {
-  return new Promise((resolve) => {
-    const socket = net.connect(port, host, () => {
-      socket.end();
-      resolve(true);
-    });
-    socket.setTimeout(1000, () => {
-      socket.destroy();
-      resolve(false);
-    });
-    socket.on("error", () => resolve(false));
-  });
-}
-
-async function waitUntil(
-  predicate: () => Promise<boolean> | boolean,
-  options: { timeoutMs: number; label: string },
-): Promise<void> {
-  const deadline = Date.now() + options.timeoutMs;
-  while (Date.now() < deadline) {
-    if (await predicate()) {
-      return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  throw new Error(`Timed out after ${options.timeoutMs}ms waiting for ${options.label}.`);
-}
-
-function spawnSupervisor(args: {
-  paseoHome: string;
-  port: string;
-  relayPort: string;
-  metroPort: string;
-  editorRecordPath: string;
-}): ChildProcess {
-  const serverDir = path.resolve(__dirname, "../../../..", "packages/server");
-  // Run the supervisor through the resolved tsx CLI under the current node
-  // binary. Spawning the `node_modules/.bin/tsx` shim directly is unreliable
-  // inside the Playwright worker (the shim is a .mjs symlink, not an executable),
-  // so resolve the CLI module and load it with node.
-  const tsxCli = createRequire(path.join(serverDir, "package.json")).resolve("tsx/cli");
-  const env = withDisabledE2ESpeechEnv({
-    ...process.env,
-    PASEO_HOME: args.paseoHome,
-    PASEO_E2E_EDITOR_RECORD_PATH: args.editorRecordPath,
-    PASEO_SERVER_ID: "srv_e2e_test_daemon",
-    PASEO_LISTEN: `0.0.0.0:${args.port}`,
-    PASEO_RELAY_ENDPOINT: `127.0.0.1:${args.relayPort}`,
-    PASEO_CORS_ORIGINS: `http://localhost:${args.metroPort}`,
-    PASEO_NODE_ENV: "development",
-    NODE_ENV: "development",
-  });
-
-  const child = spawn(process.execPath, [tsxCli, "scripts/supervisor-entrypoint.ts", "--dev"], {
-    cwd: serverDir,
-    env,
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: false,
-  });
-
-  child.stdout?.on("data", (data: Buffer) => {
-    for (const line of data.toString().split("\n")) {
-      if (line.trim()) console.log(`[daemon:restart] ${line.trim()}`);
-    }
-  });
-  child.stderr?.on("data", (data: Buffer) => {
-    for (const line of data.toString().split("\n")) {
-      if (line.trim()) console.error(`[daemon:restart] ${line.trim()}`);
-    }
-  });
-
-  // Detach our handles so the spawned supervisor outlives this spec process and
-  // is reaped by globalSetup's cleanup (the original process tree), not us.
-  child.unref();
-  return child;
-}
-
-export async function restartTestDaemon(): Promise<void> {
-  const port = getE2EDaemonPort();
-  const paseoHome = getEnvOrThrow("E2E_PASEO_HOME");
-  const relayPort = getEnvOrThrow("E2E_RELAY_PORT");
-  const metroPort = getEnvOrThrow("E2E_METRO_PORT");
-  const editorRecordPath =
-    process.env.E2E_EDITOR_RECORD_PATH ?? path.join(paseoHome, "editor-open-records.jsonl");
-
-  const pid = await readSupervisorPid(paseoHome);
-  process.kill(pid, "SIGTERM");
-
-  await waitUntil(() => !isPidRunning(pid), {
-    timeoutMs: 15_000,
-    label: `supervisor PID ${pid} to exit`,
-  });
-  await waitUntil(async () => !(await isPortListening(Number(port))), {
-    timeoutMs: 15_000,
-    label: `port ${port} to free`,
-  });
-
-  spawnSupervisor({ paseoHome, port, relayPort, metroPort, editorRecordPath });
-
-  await waitUntil(async () => isPortListening(Number(port)), {
-    timeoutMs: 30_000,
-    label: `restarted daemon to listen on port ${port}`,
-  });
-}

packages/app/e2e/helpers/isolated-host-daemon.ts

@@ -9,6 +9,7 @@ import { withDisabledE2ESpeechEnv } from "./speech-env";
 export interface IsolatedHostDaemon {
   serverId: string;
   port: number;
+  restart(): Promise<void>;
   close(): Promise<void>;
 }
 
@@ -85,43 +86,61 @@ export async function startIsolatedHostDaemon(serverId: string): Promise<Isolate
   const paseoHome = await mkdtemp(path.join(tmpdir(), "paseo-e2e-secondary-host-"));
   const serverDir = path.resolve(__dirname, "../../../server");
   const tsxBin = execSync("which tsx").toString().trim();
-  const child = spawn(tsxBin, ["scripts/supervisor-entrypoint.ts", "--dev"], {
-    cwd: serverDir,
-    env: withDisabledE2ESpeechEnv({
-      ...process.env,
-      PASEO_HOME: paseoHome,
-      PASEO_SERVER_ID: serverId,
-      PASEO_LISTEN: `127.0.0.1:${port}`,
-      PASEO_CORS_ORIGINS: `http://localhost:${metroPort}`,
-      PASEO_RELAY_ENABLED: "0",
-      PASEO_NODE_ENV: "development",
-      NODE_ENV: "development",
-    }),
-    stdio: ["ignore", "ignore", "pipe"],
-    detached: false,
-  });
+  const spawnDaemon = async (): Promise<ChildProcess> => {
+    const child = spawn(tsxBin, ["scripts/supervisor-entrypoint.ts", "--dev"], {
+      cwd: serverDir,
+      env: withDisabledE2ESpeechEnv({
+        ...process.env,
+        PASEO_HOME: paseoHome,
+        PASEO_SERVER_ID: serverId,
+        PASEO_LISTEN: `127.0.0.1:${port}`,
+        PASEO_CORS_ORIGINS: `http://localhost:${metroPort}`,
+        PASEO_RELAY_ENABLED: "0",
+        PASEO_NODE_ENV: "development",
+        NODE_ENV: "development",
+      }),
+      stdio: ["ignore", "ignore", "pipe"],
+      detached: false,
+    });
 
-  let stderr = "";
-  child.stderr?.on("data", (chunk: Buffer) => {
-    stderr += chunk.toString("utf8");
-    stderr = stderr.split("\n").slice(-40).join("\n");
-  });
+    let stderr = "";
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString("utf8");
+      stderr = stderr.split("\n").slice(-40).join("\n");
+    });
 
+    try {
+      await waitForServer(port, child);
+      return child;
+    } catch (error) {
+      await stopProcess(child);
+      throw new Error(
+        `${error instanceof Error ? error.message : String(error)}\nDaemon stderr:\n${stderr}`,
+        { cause: error },
+      );
+    }
+  };
+
+  let child: ChildProcess;
   try {
-    await waitForServer(port, child);
+    child = await spawnDaemon();
   } catch (error) {
-    await stopProcess(child);
     await rm(paseoHome, { recursive: true, force: true });
-    throw new Error(
-      `${error instanceof Error ? error.message : String(error)}\nDaemon stderr:\n${stderr}`,
-      { cause: error },
-    );
+    throw error;
   }
+  let closed = false;
 
   return {
     serverId,
     port,
+    restart: async () => {
+      if (closed) throw new Error(`Cannot restart closed isolated daemon ${serverId}`);
+      await stopProcess(child);
+      child = await spawnDaemon();
+    },
     close: async () => {
+      if (closed) return;
+      closed = true;
       await stopProcess(child);
       await rm(paseoHome, { recursive: true, force: true });
     },

packages/app/e2e/helpers/new-workspace.ts

@@ -89,9 +89,12 @@ function parseWorkspaceIdFromPageUrl(page: Page, serverId: string): string | nul
   return decodeWorkspaceIdFromPathSegment(match[1]);
 }
 
-export async function connectNewWorkspaceDaemonClient(): Promise<NewWorkspaceDaemonClient> {
+export async function connectNewWorkspaceDaemonClient(options?: {
+  port?: number;
+}): Promise<NewWorkspaceDaemonClient> {
   return connectDaemonClient<NewWorkspaceDaemonClient>({
     clientIdPrefix: "app-e2e-new-workspace",
+    port: options?.port,
   });
 }
 

packages/app/e2e/helpers/seed-client.ts

@@ -158,10 +158,11 @@ export interface SeedDaemonClient {
   killTerminal(terminalId: string): Promise<{ error: string | null }>;
 }
 
-export async function connectSeedClient(): Promise<SeedDaemonClient> {
+export async function connectSeedClient(options?: { port?: number }): Promise<SeedDaemonClient> {
   return connectDaemonClient<SeedDaemonClient>({
     clientIdPrefix: "seed",
     appVersion: loadAppVersion(),
+    port: options?.port,
   });
 }
 

packages/app/e2e/worktree-restore-after-restart.spec.ts

@@ -1,9 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
-import { expect, test } from "./fixtures";
+import { expect, test, type Page } from "@playwright/test";
 import { gotoAppShell } from "./helpers/app";
 import { createIdleAgent, expectSessionRowArchived, openSessions } from "./helpers/archive-tab";
-import { restartTestDaemon } from "./helpers/daemon-restart";
+import { buildCreateAgentPreferences, buildSeededHost } from "./helpers/daemon-registry";
+import { startIsolatedHostDaemon, type IsolatedHostDaemon } from "./helpers/isolated-host-daemon";
 import {
   archiveWorkspaceFromDaemon,
   connectNewWorkspaceDaemonClient,
@@ -11,11 +12,12 @@ import {
   openProjectViaDaemon,
 } from "./helpers/new-workspace";
 import { connectSeedClient } from "./helpers/seed-client";
-import { getServerId } from "./helpers/server-id";
 import { createTempGitRepo } from "./helpers/workspace";
 import { waitForSidebarHydration } from "./helpers/workspace-ui";
 
 test.describe("Worktree restore after daemon restart", () => {
+  const serverId = `srv_worktree_restart_${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+  let daemon: IsolatedHostDaemon;
   let client: Awaited<ReturnType<typeof connectSeedClient>>;
   let worktreeClient: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
   let tempRepo: { path: string; cleanup: () => Promise<void> };
@@ -25,8 +27,9 @@ test.describe("Worktree restore after daemon restart", () => {
   test.describe.configure({ retries: 0, timeout: 180_000 });
 
   test.beforeEach(async () => {
-    client = await connectSeedClient();
-    worktreeClient = await connectNewWorkspaceDaemonClient();
+    daemon = await startIsolatedHostDaemon(serverId);
+    client = await connectSeedClient({ port: daemon.port });
+    worktreeClient = await connectNewWorkspaceDaemonClient({ port: daemon.port });
     tempRepo = await createTempGitRepo("wt-restart-");
   });
 
@@ -42,13 +45,33 @@ test.describe("Worktree restore after daemon restart", () => {
     await client?.close().catch(() => undefined);
     await worktreeClient?.close().catch(() => undefined);
     await tempRepo?.cleanup().catch(() => undefined);
+    await daemon?.close().catch(() => undefined);
   });
 
+  async function seedBrowser(page: Page) {
+    const nowIso = new Date().toISOString();
+    await page.addInitScript(
+      ({ host, preferences }) => {
+        localStorage.setItem("@paseo:e2e", "1");
+        localStorage.setItem("@paseo:daemon-registry", JSON.stringify([host]));
+        localStorage.removeItem("@paseo:settings");
+        localStorage.setItem("@paseo:create-agent-preferences", JSON.stringify(preferences));
+      },
+      {
+        host: buildSeededHost({
+          serverId,
+          endpoint: `127.0.0.1:${daemon.port}`,
+          label: "restart daemon",
+          nowIso,
+        }),
+        preferences: buildCreateAgentPreferences(serverId),
+      },
+    );
+  }
+
   test("after archiving a worktree and restarting the daemon, History shows the worktree branch (not main) before any restore", async ({
     page,
   }) => {
-    const serverId = getServerId();
-
     // A paseo worktree is cut on its own branch named after the slug, and the
     // worktree workspace is displayed under the same name. These are the values
     // the History table cells must show after restore — never "main".
@@ -76,14 +99,16 @@ test.describe("Worktree restore after daemon restart", () => {
       .poll(() => existsSync(worktree.workspaceDirectory), { timeout: 30_000 })
       .toBe(false);
 
-    // Bounce the isolated test daemon on the SAME home and port so it rebuilds
-    // all workspace/agent links from persisted state. Then reconnect both clients.
+    // Restart this spec's daemon on the same home and port so it rebuilds all
+    // workspace/agent links from persisted state without replacing the shared
+    // Playwright daemon owned by global setup.
     await client.close().catch(() => undefined);
     await worktreeClient.close().catch(() => undefined);
-    await restartTestDaemon();
-    client = await connectSeedClient();
-    worktreeClient = await connectNewWorkspaceDaemonClient();
+    await daemon.restart();
+    client = await connectSeedClient({ port: daemon.port });
+    worktreeClient = await connectNewWorkspaceDaemonClient({ port: daemon.port });
 
+    await seedBrowser(page);
     await gotoAppShell(page);
     await waitForSidebarHydration(page);
     await openSessions(page);

packages/app/e2e/worktree-restore.spec.ts

@@ -249,7 +249,7 @@ test.describe("Worktree restore", () => {
     try {
       await page.getByTestId("workspace-recovery-action").click();
       await expect(page.getByTestId("workspace-recovery-error")).toHaveText(
-        "The project directory needed to restore this worktree no longer exists.",
+        "The source repository needed to restore this worktree no longer exists.",
       );
       await expect(page.getByTestId("workspace-recovery-action")).toHaveText("Retry");
       expect(existsSync(worktree.workspaceDirectory)).toBe(false);