Treat every added folder as an independent project (#2098)

* fix(projects): detect when projects become Git repositories Project identity was coupled to Git placement, while non-Git roots were dropped by session-scoped observation. Keep identity tied to the selected root and observe Git transitions daemon-wide so empty projects update without rehoming workspaces. * fix(projects): preserve metadata across Git read failures Refresh archived workspace facts before persistence and treat only confirmed non-repositories as non-Git so transient failures cannot rewrite stored project metadata. * fix(projects): close project update races * fix(projects): refresh checkout metadata when reopening folders Persist worktree ownership separately from workspace kind and gate exact-root project creation on stable host identity. Refresh active and archived records so missed Git transitions cannot return stale checkout descriptors. * test(projects): accept Windows aliases for repaired roots * test(server): retry transient Windows cleanup locks * fix(projects): propagate project metadata refreshes Project-only Git transitions now fan out workspace updates for legacy clients. Explicit project creation refreshes stored kind, and equivalent cwd spellings reuse existing workspace records. * fix(projects): refresh worktree source project kind * fix(projects): preserve exact-folder runtime isolation * fix(projects): preserve exact cwd across worktree lifecycle * fix(projects): harden exact-folder worktree flows * fix(projects): derive exact cwd from matched path identity * fix(projects): preserve nested worktree lifecycle * refactor(projects): centralize workspace placement * test(e2e): verify isolated server ports * fix(projects): preserve placement reshape compatibility * fix(projects): validate created worktree placement * fix(projects): preserve placement through workspace lifecycle Archive and recovery were rediscovering or guessing checkout roots instead of consuming the persisted workspace placement. Make the record authoritative for exact cwd, backing worktree, and source repository, and classify stale paths before Git reconciliation. * fix(worktrees): preserve source checkout root Convert Git's common administrative directory back to the source checkout root when legacy archive placement is reconstructed. * fix(worktrees): compare filesystem identities Resolve discovered worktrees and teardown locations through the shared realpath-aware matcher so Windows short and long path spellings cannot split placement identity. * fix(worktrees): centralize path containment Route worktree ownership, listing, resolution, and deletion through the realpath-aware containment primitive so Windows path aliases cannot be filtered by an earlier raw prefix check. * fix(worktrees): remove duplicate ownership discovery * test(e2e): isolate daemon restart ownership * fix(worktrees): make lifecycle operations transactional * fix(workspaces): share git watches by cwd * test(worktrees): make teardown proof portable * fix(sync): integrate project updates with directory owner * fix(workspaces): close reconciliation edge cases * refactor(sync): remove duplicate project reconciliation Keep workspace and project deltas behind the host directory transaction, with owner-boundary coverage for snapshot replay and queued full reconciliation. * fix(sync): buffer project updates before hydration Start the workspace transaction with the online connection epoch so project broadcasts cannot publish a partial directory before the authoritative snapshot commits.
2026-07-17 19:30:17 +02:00
parent 1977d330ed
commit 39cb3dbb9c
93 changed files with 7426 additions and 2762 deletions
@@ -219,15 +219,20 @@ test.describe("Project remove", () => {

      const readded = await workspace.client.addProject(workspace.repoPath);
      expect(readded.error).toBeNull();
+      expect(readded.project).not.toBeNull();
+      const readdedProjectId = readded.project?.projectId ?? "";
+      expect(readdedProjectId).not.toBe(workspace.projectId);
      expect(readded.project?.projectDisplayName).toBe(workspace.projectDisplayName);

      await page.reload();
      await waitForSidebarHydration(page);
-      await expect(projectRow).toBeVisible({ timeout: 30_000 });
-      await expect(projectRow).toContainText(workspace.projectDisplayName);
-      await expect(projectRow).not.toContainText(workspace.repoPath);
+      await expect(projectRow).toHaveCount(0, { timeout: 30_000 });
+      const readdedProjectRow = page.getByTestId(`sidebar-project-row-${readdedProjectId}`);
+      await expect(readdedProjectRow).toBeVisible({ timeout: 30_000 });
+      await expect(readdedProjectRow).toContainText(workspace.projectDisplayName);
+      await expect(readdedProjectRow).not.toContainText(workspace.repoPath);
      await expect(
-        page.getByTestId(`sidebar-project-new-workspace-row-${workspace.projectId}`),
+        page.getByTestId(`sidebar-project-new-workspace-row-${readdedProjectId}`),
      ).toBeVisible({ timeout: 30_000 });
    } finally {
      await workspace.cleanup();
@@ -14,7 +14,7 @@ import { withDisabledE2ESpeechEnv } from "./helpers/speech-env";

 const wranglerCliPath = path.resolve(__dirname, "../node_modules/wrangler/bin/wrangler.js");

-interface WaitForServerOptions {
+export interface WaitForServerOptions {
  host?: string;
  timeoutMs?: number;
  label: string;
@@ -22,6 +22,8 @@ interface WaitForServerOptions {
  getRecentOutput?: () => string;
 }

+type ServerProbe = (host: string, port: number) => Promise<void>;
+
 async function getAvailablePort(): Promise<number> {
  return new Promise((resolve, reject) => {
    const server = net.createServer();
@@ -75,7 +77,25 @@ function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
 }

-async function waitForServer(port: number, options: WaitForServerOptions): Promise<void> {
+async function connectToServer(host: string, port: number): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const socket = net.connect(port, host, () => {
+      socket.end();
+      resolve();
+    });
+    socket.setTimeout(1000, () => {
+      socket.destroy();
+      reject(new Error(`Connection timed out to ${host}:${port}`));
+    });
+    socket.on("error", reject);
+  });
+}
+
+async function waitForServer(
+  port: number,
+  options: WaitForServerOptions,
+  probe: ServerProbe = connectToServer,
+): Promise<void> {
  const { host = "127.0.0.1", timeoutMs = 15000, label, childProcess, getRecentOutput } = options;
  const start = Date.now();
  let lastConnectionError: unknown = null;
@@ -89,17 +109,7 @@ async function waitForServer(port: number, options: WaitForServerOptions): Promi
    }

    try {
-      await new Promise<void>((resolve, reject) => {
-        const socket = net.connect(port, host, () => {
-          socket.end();
-          resolve();
-        });
-        socket.setTimeout(1000, () => {
-          socket.destroy();
-          reject(new Error(`Connection timed out to ${host}:${port}`));
-        });
-        socket.on("error", reject);
-      });
+      await probe(host, port);
      return;
    } catch (error) {
      lastConnectionError = error;
@@ -116,6 +126,22 @@ async function waitForServer(port: number, options: WaitForServerOptions): Promi
  );
 }

+async function probeMetro(host: string, port: number): Promise<void> {
+  const response = await fetch(`http://${host}:${port}/status`, {
+    signal: AbortSignal.timeout(1000),
+  });
+  const body = (await response.text()).trim();
+  if (response.status !== 200 || body !== "packager-status:running") {
+    throw new Error(
+      `Expected Metro status on ${host}:${port}, received HTTP ${response.status}: ${JSON.stringify(body.slice(0, 200))}`,
+    );
+  }
+}
+
+export async function waitForMetro(port: number, options: WaitForServerOptions): Promise<void> {
+  await waitForServer(port, options, probeMetro);
+}
+
 function parseRelayStartupFailure(line: string): string | null {
  const clean = stripAnsi(line);
  if (/Address already in use/i.test(clean)) {
@@ -556,13 +582,19 @@ async function getAvailablePortExcluding(excludedPorts: Set<number>): Promise<nu
  }
 }

-async function startRelay(excludedPorts: Set<number>): Promise<number> {
+interface RelayPorts {
+  relayPort: number;
+  inspectorPort: number;
+}
+
+async function startRelay(excludedPorts: Set<number>): Promise<RelayPorts> {
  const relayDir = path.resolve(__dirname, "..", "..", "relay");
  const maxRelayStartupAttempts = 5;
  let lastRelayStartupError: unknown = null;

  for (let attempt = 1; attempt <= maxRelayStartupAttempts; attempt += 1) {
    const relayPort = await getAvailablePortExcluding(excludedPorts);
+    const inspectorPort = await getAvailablePortExcluding(new Set([...excludedPorts, relayPort]));
    const buffer = createLineBuffer();
    const state: RelayStreamState = { failureLine: null, readyForSelectedPort: false };

@@ -576,6 +608,10 @@ async function startRelay(excludedPorts: Set<number>): Promise<number> {
        "127.0.0.1",
        "--port",
        String(relayPort),
+        "--inspector-ip",
+        "127.0.0.1",
+        "--inspector-port",
+        String(inspectorPort),
        "--live-reload=false",
        "--show-interactive-dev-session=false",
      ],
@@ -590,7 +626,7 @@ async function startRelay(excludedPorts: Set<number>): Promise<number> {

    try {
      await awaitRelayReady(relayProcess, relayPort, state, buffer);
-      return relayPort;
+      return { relayPort, inspectorPort };
    } catch (error) {
      lastRelayStartupError = error;
      await stopProcess(relayProcess);
@@ -767,12 +803,19 @@ export default async function globalSetup() {
  await logSpeechHarnessConfig();

  try {
-    const relayPort = await startRelay(new Set([port, metroPort]));
    metroProcess = startMetro({
      metroPort,
      daemonPort: port,
      buffer: metroLineBuffer,
    });
+    await waitForMetro(metroPort, {
+      label: "Metro web server",
+      timeoutMs: 120000,
+      childProcess: metroProcess,
+      getRecentOutput: metroLineBuffer.dump,
+    });
+
+    const { relayPort, inspectorPort } = await startRelay(new Set([port, metroPort]));
    daemonProcess = startDaemon({
      port,
      relayPort,
@@ -783,19 +826,11 @@ export default async function globalSetup() {
      buffer: daemonLineBuffer,
    });

-    await Promise.all([
-      waitForServer(port, {
-        label: "Paseo daemon",
-        childProcess: daemonProcess,
-        getRecentOutput: daemonLineBuffer.dump,
-      }),
-      waitForServer(metroPort, {
-        label: "Metro web server",
-        timeoutMs: 120000,
-        childProcess: metroProcess,
-        getRecentOutput: metroLineBuffer.dump,
-      }),
-    ]);
+    await waitForServer(port, {
+      label: "Paseo daemon",
+      childProcess: daemonProcess,
+      getRecentOutput: daemonLineBuffer.dump,
+    });

    const offer = await waitForPairingOfferFromDaemon({
      port,
@@ -809,7 +844,7 @@ export default async function globalSetup() {
    process.env.E2E_PASEO_HOME = paseoHome;
    process.env.E2E_EDITOR_RECORD_PATH = editorRecordPath;
    console.log(
-      `[e2e] Test daemon started on port ${port}, Metro on port ${metroPort}, home: ${paseoHome}`,
+      `[e2e] Test daemon started on port ${port}, Metro on port ${metroPort}, relay on port ${relayPort}, relay inspector on port ${inspectorPort}, home: ${paseoHome}`,
    );

    return async () => {
@@ -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(),
@@ -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}`,
-  });
-}
@@ -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 });
    },
@@ -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,
  });
 }

@@ -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,
  });
 }

@@ -208,7 +208,7 @@ test.describe("Projects settings", () => {
    page,
    gitlabRemoteProject,
  }) => {
-    expect(gitlabRemoteProject.name).toBe("acme/app");
+    expect(gitlabRemoteProject.name).toBe(path.basename(gitlabRemoteProject.path));
    await openProjects(page);
    await openProjectSettings(page, gitlabRemoteProject.name);
    await editWorktreeSetup(page, updatedSetup);
@@ -46,24 +46,25 @@ async function waitForSidebarWorkspace(page: import("@playwright/test").Page, wo
 }

 test.describe("Sidebar workspace list", () => {
-  test("project with GitHub remote shows owner/repo name in sidebar", async ({ page }) => {
+  test("project with GitHub remote shows its selected folder name in sidebar", async ({ page }) => {
    const workspace = await seedWorkspace({
      repoPrefix: "sidebar-remote-",
      repo: { withRemote: true, originUrl: GITHUB_REMOTE_URL },
    });

    try {
+      const projectName = path.basename(workspace.repoPath);
      await gotoAppShell(page);
-      await waitForSidebarProject(page, "test-owner/test-repo");
+      await waitForSidebarProject(page, projectName);
      await waitForSidebarWorkspace(page, workspace.workspaceId);

      const projectRow = page
        .locator('[data-testid^="sidebar-project-row-"]')
-        .filter({ hasText: "test-owner/test-repo" })
+        .filter({ hasText: projectName })
        .first();

      await expect(projectRow).toBeVisible({ timeout: 30_000 });
-      await expect(projectRow).not.toContainText(path.basename(workspace.repoPath));
+      await expect(projectRow).not.toContainText("test-owner/test-repo");
    } finally {
      await workspace.cleanup();
    }
@@ -96,21 +97,24 @@ test.describe("Sidebar workspace list", () => {
    }
  });

-  test("workspace header shows correct title and subtitle", async ({ page }) => {
+  test("workspace header uses the selected folder name instead of its GitHub remote", async ({
+    page,
+  }) => {
    const workspace = await seedWorkspace({
      repoPrefix: "sidebar-header-",
      repo: { withRemote: true, originUrl: GITHUB_REMOTE_URL },
    });

    try {
+      const projectName = path.basename(workspace.repoPath);
      await gotoAppShell(page);
-      await waitForSidebarProject(page, "test-owner/test-repo");
+      await waitForSidebarProject(page, projectName);
      await waitForSidebarWorkspace(page, workspace.workspaceId);
      await openWorkspaceFromSidebar(page, workspace.workspaceId);

      await expectWorkspaceHeader(page, {
        title: workspace.workspaceName,
-        subtitle: "test-owner/test-repo",
+        subtitle: projectName,
      });
    } finally {
      await workspace.cleanup();
@@ -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);
@@ -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);