Make workspace IDs opaque, independent of the filesystem path (#1503)

* Make workspace IDs opaque, independent of the filesystem path

Workspace IDs were the resolved checkout/worktree path, so code could
treat an ID as a path: prefix matching, deriving directories from it,
falling back to a path when a lookup missed. IDs are now opaque -
compared only by exact equality and never used as a path. Anything
path-shaped resolves the workspace record first and reads its cwd.

New workspaces get a generated `wks_` ID; existing path-shaped IDs are
read from disk and never regenerated, so there is no migration and no
change to the wire or persisted schemas. Groundwork for running
multiple workspaces in a single directory.

* Keep attachment scope key stable and align refetch test

The attachment scope key keeps `workspace=` instead of `wsid=` so existing
persisted drafts are not orphaned; the rename was cosmetic. The SDK refetch
test no longer asserts a filter, matching refetch fetching one page and
selecting by id client-side.

* Fix live agent updates in directories without a registered workspace

The opaque-ID work removed buildProjectPlacementForCwd's directory
fallback, so an agent running in a folder with no registered workspace
(e.g. a fresh non-git dir) produced a null placement. forwardAgentUpdate
then threw "Workspace not found", the error was swallowed by its catch,
and no agent_update was emitted — live model/thinking switches and status
updates silently stopped. Caught by the live-preferences e2e suite.

The fallback builds a directory-scoped project placement keyed by the
path. That key is a project grouping key (non-git projects group by
path), not a workspace id, so it stays within the opaque-id rule.

* Always run server worktree archive, even without a resolved workspace

Archiving bailed out entirely when the workspace was not found in the
client store, so a race or stale state could make "archive" do nothing
server-side with only a console.warn. The server archive is keyed by
worktreePath, which is always available, so it now runs regardless; only
the optimistic client-side updates (keyed by workspace id) are gated on
the workspace being resolved.

* Expect a directory-scoped placement for unregistered agent dirs

This unit test asserted the no-placement behavior reverted in the live
agent-update fix, which had broken live model/thinking switching. Update
it to expect the directory-scoped placement now emitted for an agent in a
directory with no registered workspace.

* Fix opaque workspace routing in app E2E

* Preserve workspace IDs during partial bootstrap

* Fix archive flows for opaque workspace IDs

* Stop treating opaque workspace IDs as filesystem paths

Workspace IDs are opaque (wks_<hex>), but several call sites still passed
the id where a directory was expected, which broke those flows for opaque
IDs. The branch switcher sent the id as a cwd to branch/stash/checkout git
operations, and server archive/reconcile cleanup keyed git-watch and
subscription teardown by id, leaking that state.

Git and filesystem operations now take the workspace directory; the opaque
id is used only for identity and cache keys. Archive/reconcile cleanup
routes through a single teardownArchivedWorkspace helper that keeps the key
split explicit: runtime store by id, git watch and subscription by cwd.
Path-derived grouping keys are renamed to directory keys, and the helpers
are split into workspace-identity and workspace-directory so the id-vs-path
boundary is obvious.

packages/app/e2e/archive-tab.spec.ts

@@ -68,7 +68,7 @@ test.describe("Archive tab reconciliation", () => {
         archivedAgentId: archived.id,
         survivingAgentId: surviving.id,
       });
-      await reloadWorkspace(passivePage, tempRepo.path);
+      await reloadWorkspace(passivePage, surviving.workspaceId);
       await expectWorkspaceTabHidden(passivePage, archived.id);
     } finally {
       await passivePage.close();
@@ -94,7 +94,7 @@ test.describe("Archive tab reconciliation", () => {
       await openWorkspaceWithAgents(passivePage, [archived, surviving]);
       await openSessions(page);
       await archiveAgentFromSessions(page, { agentId: archived.id, title: archived.title });
-      await reloadWorkspace(page, tempRepo.path);
+      await reloadWorkspace(page, surviving.workspaceId);
       await expectWorkspaceTabHidden(page, archived.id);
       await expectWorkspaceArchiveOutcome(passivePage, {
         archivedAgentId: archived.id,

packages/app/e2e/branch-switcher.spec.ts

@@ -0,0 +1,44 @@
+import { expect, test } from "./fixtures";
+import { gotoAppShell } from "./helpers/app";
+import { expectWorkspaceBranch, switchBranchFromHeader } from "./helpers/branch-switcher";
+import { seedWorkspace } from "./helpers/seed-client";
+import { getServerId } from "./helpers/server-id";
+import { readWorktreeBranchInfo } from "./helpers/workspace";
+import { switchWorkspaceViaSidebar, waitForSidebarHydration } from "./helpers/workspace-ui";
+
+test.describe("Branch switcher", () => {
+  // The first test after a spec-file switch can fail while the shared daemon
+  // releases stale sessions from the previous spec; one retry stabilizes it.
+  test.describe.configure({ retries: 1 });
+
+  test("switches the workspace branch from the header for an opaque workspace id", async ({
+    page,
+  }) => {
+    test.setTimeout(90_000);
+    const serverId = getServerId();
+    const workspace = await seedWorkspace({
+      repoPrefix: "branch-switch-",
+      repo: { branches: ["main", "dev"] },
+    });
+
+    try {
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await switchWorkspaceViaSidebar({ page, serverId, workspaceId: workspace.workspaceId });
+
+      await expectWorkspaceBranch(page, "main");
+      await switchBranchFromHeader(page, { from: "main", to: "dev" });
+      await expectWorkspaceBranch(page, "dev");
+
+      await expect
+        .poll(
+          async () =>
+            (await readWorktreeBranchInfo({ worktreePath: workspace.repoPath })).currentBranch,
+          { timeout: 30_000 },
+        )
+        .toBe("dev");
+    } finally {
+      await workspace.cleanup();
+    }
+  });
+});

packages/app/e2e/composer-attachments.spec.ts

@@ -244,7 +244,7 @@ test.describe("Composer attachments", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: workspace.workspaceId,
+        workspaceId: workspace.workspaceId,
       });
 
       await openNewWorkspaceComposer(page, {

packages/app/e2e/helpers/archive-tab.ts

@@ -14,6 +14,7 @@ export interface ArchiveTabAgent {
   id: string;
   title: string;
   cwd: string;
+  workspaceId: string;
 }
 
 function buildSeededStoragePayload() {
@@ -34,6 +35,10 @@ function buildSeededStoragePayload() {
  * idle agent from the same client it uses for everything else.
  */
 export interface IdleAgentSeedClient {
+  openProject(cwd: string): Promise<{
+    workspace: { id: string } | null;
+    error: string | null;
+  }>;
   createAgent(options: {
     provider: string;
     model: string;
@@ -52,6 +57,10 @@ export async function createIdleAgent(
   client: IdleAgentSeedClient,
   input: { cwd: string; title: string },
 ): Promise<ArchiveTabAgent> {
+  const opened = await client.openProject(input.cwd);
+  if (!opened.workspace) {
+    throw new Error(opened.error ?? `Failed to open project ${input.cwd}`);
+  }
   const created = await client.createAgent({
     provider: "opencode",
     model: "opencode/gpt-5-nano",
@@ -71,6 +80,7 @@ export async function createIdleAgent(
     id: created.id,
     title: input.title,
     cwd: input.cwd,
+    workspaceId: opened.workspace.id,
   };
 }
 
@@ -133,7 +143,7 @@ export async function openWorkspaceWithAgents(
 ): Promise<void> {
   const serverId = getServerId();
   for (const agent of agents) {
-    await page.goto(buildHostAgentDetailRoute(serverId, agent.id, agent.cwd));
+    await page.goto(buildHostAgentDetailRoute(serverId, agent.id, agent.workspaceId));
 
     // The workspace layout consumes `?open=agent:xxx`, returns null during the effect,
     // then replaces the URL with the clean workspace route after preparing the tab.

packages/app/e2e/helpers/branch-switcher.ts

@@ -0,0 +1,40 @@
+import { expect, type Page } from "@playwright/test";
+import { escapeRegex } from "./regex";
+
+// The header branch switcher renders as a button whose accessible name carries the
+// current branch ("Current branch: <name>. Press to switch branch."). Matching on the
+// accessible name keeps these helpers tied to what a screen reader user hears, and it
+// proves the header resolved a real checkout directory from the opaque workspace id.
+function branchSwitcherTrigger(page: Page, branchName: string) {
+  return page
+    .getByRole("button", { name: new RegExp(`Current branch: ${escapeRegex(branchName)}\\b`) })
+    .filter({ visible: true })
+    .first();
+}
+
+export async function expectWorkspaceBranch(page: Page, branchName: string): Promise<void> {
+  await expect(branchSwitcherTrigger(page, branchName)).toBeVisible({ timeout: 30_000 });
+}
+
+export async function switchBranchFromHeader(
+  page: Page,
+  input: { from: string; to: string },
+): Promise<void> {
+  await branchSwitcherTrigger(page, input.from).click();
+
+  const picker = page.getByTestId("combobox-desktop-container");
+  await expect(picker).toBeVisible({ timeout: 30_000 });
+
+  // The branch switcher combobox renders its options as plain text rows with no ARIA
+  // role, so filter by the visible branch name and click the matching row. Filtering
+  // first guarantees a single, unambiguous match.
+  const search = page.getByPlaceholder("Filter branches...");
+  await expect(search).toBeVisible({ timeout: 30_000 });
+  await search.fill(input.to);
+
+  const option = picker.getByText(input.to, { exact: true });
+  await expect(option).toBeVisible({ timeout: 30_000 });
+  await option.click();
+
+  await expect(picker).not.toBeVisible({ timeout: 30_000 });
+}

packages/app/e2e/helpers/composer.ts

@@ -166,7 +166,7 @@ export async function startRunningMockAgent(
     cwd: repo.path,
     model: opts.model,
   });
-  const agentUrl = `${buildHostWorkspaceRoute(serverId, repo.path)}?open=${encodeURIComponent(`agent:${agent.id}`)}`;
+  const agentUrl = `${buildHostWorkspaceRoute(serverId, opened.workspace.id)}?open=${encodeURIComponent(`agent:${agent.id}`)}`;
   await page.goto(agentUrl);
   await expectComposerVisible(page);
   await client.sendAgentMessage(agent.id, opts.prompt);

packages/app/e2e/helpers/launcher.ts

@@ -6,8 +6,8 @@ import { getServerId } from "./server-id";
 // ─── Navigation ────────────────────────────────────────────────────────────
 
 /** Navigate to a workspace and wait for the tab bar to appear. */
-export async function gotoWorkspace(page: Page, cwd: string): Promise<void> {
-  const route = buildHostWorkspaceRoute(getServerId(), cwd);
+export async function gotoWorkspace(page: Page, workspaceId: string): Promise<void> {
+  const route = buildHostWorkspaceRoute(getServerId(), workspaceId);
   await page.goto(route);
   await waitForTabBar(page);
 }

packages/app/e2e/helpers/mock-agent.ts

@@ -5,6 +5,7 @@ import { getServerId } from "./server-id";
 
 export interface MockAgentWorkspace {
   agentId: string;
+  workspaceId: string;
   cwd: string;
   client: SeedDaemonClient;
   cleanup(): Promise<void>;
@@ -40,6 +41,7 @@ export async function seedMockAgentWorkspace(
     });
     return {
       agentId: agent.id,
+      workspaceId: workspace.workspaceId,
       cwd: workspace.repoPath,
       client: workspace.client,
       cleanup: workspace.cleanup,
@@ -50,8 +52,8 @@ export async function seedMockAgentWorkspace(
   }
 }
 
-export function buildAgentRoute(cwd: string, agentId: string): string {
-  return `${buildHostWorkspaceRoute(getServerId(), cwd)}?open=${encodeURIComponent(
+export function buildAgentRoute(workspaceId: string, agentId: string): string {
+  return `${buildHostWorkspaceRoute(getServerId(), workspaceId)}?open=${encodeURIComponent(
     `agent:${agentId}`,
   )}`;
 }
@@ -59,9 +61,9 @@ export function buildAgentRoute(cwd: string, agentId: string): string {
 /** Boots the app directly at the agent's workspace route and waits for the open intent to settle. */
 export async function openAgentRoute(
   page: Page,
-  input: { cwd: string; agentId: string },
+  input: { workspaceId: string; agentId: string },
 ): Promise<void> {
-  await page.goto(buildAgentRoute(input.cwd, input.agentId));
+  await page.goto(buildAgentRoute(input.workspaceId, input.agentId));
   await page.waitForURL(
     (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
     { timeout: 60_000 },

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

@@ -3,7 +3,7 @@ import type { DaemonClient as InternalDaemonClient } from "@getpaseo/client/inte
 import { decodeWorkspaceIdFromPathSegment } from "@/utils/host-routes";
 import { connectDaemonClient } from "./daemon-client-loader";
 import { daemonWsRoutePattern } from "./daemon-port";
-import { expectWorkspaceHeader, workspaceLabelFromPath } from "./workspace-ui";
+import { expectWorkspaceHeader } from "./workspace-ui";
 
 type NewWorkspaceDaemonClient = Pick<
   InternalDaemonClient,
@@ -12,17 +12,20 @@ type NewWorkspaceDaemonClient = Pick<
   | "close"
   | "connect"
   | "createPaseoWorktree"
+  | "fetchWorkspaces"
   | "openProject"
 >;
 
 type OpenProjectPayload = Awaited<ReturnType<NewWorkspaceDaemonClient["openProject"]>>;
 type WorkspacePayload = Pick<OpenProjectPayload, "error" | "workspace">;
+type WorkspaceDescriptor = NonNullable<OpenProjectPayload["workspace"]>;
 
 export interface OpenedProject {
   workspaceId: string;
   projectKey: string;
   projectDisplayName: string;
   workspaceName: string;
+  workspaceDirectory: string;
 }
 
 function requireWorkspace(payload: WorkspacePayload) {
@@ -35,6 +38,39 @@ function requireWorkspace(payload: WorkspacePayload) {
   return payload.workspace;
 }
 
+function openedProjectFromWorkspace(workspace: WorkspaceDescriptor): OpenedProject {
+  return {
+    workspaceId: workspace.id,
+    projectKey: workspace.projectId,
+    projectDisplayName: workspace.projectDisplayName,
+    workspaceName: workspace.name,
+    workspaceDirectory: workspace.workspaceDirectory,
+  };
+}
+
+async function fetchWorkspaceById(
+  client: NewWorkspaceDaemonClient,
+  workspaceId: string,
+): Promise<WorkspaceDescriptor | null> {
+  const payload = await client.fetchWorkspaces();
+  return payload.entries.find((entry) => entry.id === workspaceId) ?? null;
+}
+
+async function waitForWorkspaceDescriptor(
+  client: NewWorkspaceDaemonClient,
+  workspaceId: string,
+): Promise<WorkspaceDescriptor> {
+  const deadline = Date.now() + 30_000;
+  while (Date.now() < deadline) {
+    const workspace = await fetchWorkspaceById(client, workspaceId);
+    if (workspace) {
+      return workspace;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new Error(`Workspace descriptor not found: ${workspaceId}`);
+}
+
 function parseWorkspaceIdFromPageUrl(page: Page, serverId: string): string | null {
   const pathname = new URL(page.url()).pathname;
   const match = pathname.match(
@@ -57,24 +93,19 @@ export async function openProjectViaDaemon(
   repoPath: string,
 ): Promise<OpenedProject> {
   const workspace = requireWorkspace(await client.openProject(repoPath));
-  return {
-    workspaceId: workspace.id,
-    projectKey: workspace.projectId,
-    projectDisplayName: workspace.projectDisplayName,
-    workspaceName: workspace.name,
-  };
+  return openedProjectFromWorkspace(workspace);
 }
 
 export async function archiveWorkspaceFromDaemon(
   client: NewWorkspaceDaemonClient,
-  workspaceId: string,
+  workspaceDirectory: string,
 ): Promise<void> {
-  const payload = await client.archivePaseoWorktree({ worktreePath: workspaceId });
+  const payload = await client.archivePaseoWorktree({ worktreePath: workspaceDirectory });
   if (payload.error) {
     throw new Error(payload.error.message);
   }
   if (!payload.success) {
-    throw new Error(`Failed to archive workspace: ${workspaceId}`);
+    throw new Error(`Failed to archive workspace: ${workspaceDirectory}`);
   }
 }
 
@@ -100,12 +131,7 @@ export async function createWorktreeViaDaemon(
     worktreeSlug: input.slug,
   });
   const workspace = requireWorkspace(payload);
-  return {
-    workspaceId: workspace.id,
-    projectKey: workspace.projectId,
-    projectDisplayName: workspace.projectDisplayName,
-    workspaceName: workspace.name,
-  };
+  return openedProjectFromWorkspace(workspace);
 }
 
 export async function openNewWorkspaceComposer(
@@ -241,12 +267,13 @@ export async function assertNewWorkspaceSidebarAndHeader(
   page: Page,
   input: {
     serverId: string;
+    client: NewWorkspaceDaemonClient;
     previousWorkspaceId: string;
     projectDisplayName: string;
     assertSidebarRow?: boolean;
     assertHeader?: boolean;
   },
-): Promise<{ workspaceId: string }> {
+): Promise<{ workspaceId: string; workspaceName: string; workspaceDirectory: string }> {
   // Wait for URL to redirect to the newly created workspace.
   // Uses URL as source of truth to avoid picking up sidebar rows from concurrent tests.
   let workspaceId: string | null = null;
@@ -263,21 +290,27 @@ export async function assertNewWorkspaceSidebarAndHeader(
     throw new Error(`Expected URL to redirect to a new workspace.\nCurrent URL: ${page.url()}`);
   }
 
+  const workspace = await waitForWorkspaceDescriptor(input.client, workspaceId);
+
   if (input.assertSidebarRow !== false) {
     const createdWorkspaceRow = page.getByTestId(
-      `sidebar-workspace-row-${input.serverId}:${workspaceId}`,
+      `sidebar-workspace-row-${input.serverId}:${workspace.id}`,
     );
     await expect(createdWorkspaceRow.first()).toBeVisible({ timeout: 30_000 });
   }
 
   if (input.assertHeader !== false) {
     await expectWorkspaceHeader(page, {
-      title: workspaceLabelFromPath(workspaceId),
+      title: workspace.name,
       subtitle: input.projectDisplayName,
     });
   }
 
-  return { workspaceId };
+  return {
+    workspaceId: workspace.id,
+    workspaceName: workspace.name,
+    workspaceDirectory: workspace.workspaceDirectory,
+  };
 }
 
 type WebSocketMessage = string | Buffer;

packages/app/e2e/helpers/rewind-flow.ts

@@ -14,6 +14,7 @@ export interface AgentHandle {
   page: Page;
   client: SeedDaemonClient;
   agentId: string;
+  workspaceId: string;
   cwd: string;
   provider: RewindFlowProvider;
 }
@@ -61,14 +62,17 @@ function fullAccessConfig(provider: RewindFlowProvider): ProviderLaunchConfig {
   }
 }
 
-function agentRoute(cwd: string, agentId: string): string {
-  return `${buildHostWorkspaceRoute(getServerId(), cwd)}?open=${encodeURIComponent(
+function agentRoute(workspaceId: string, agentId: string): string {
+  return `${buildHostWorkspaceRoute(getServerId(), workspaceId)}?open=${encodeURIComponent(
     `agent:${agentId}`,
   )}`;
 }
 
-async function openAgent(page: Page, input: { cwd: string; agentId: string }): Promise<void> {
-  await page.goto(agentRoute(input.cwd, input.agentId));
+async function openAgent(
+  page: Page,
+  input: { workspaceId: string; agentId: string },
+): Promise<void> {
+  await page.goto(agentRoute(input.workspaceId, input.agentId));
   await page.waitForURL(
     (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
     { timeout: 60_000 },
@@ -180,10 +184,11 @@ export async function launchAgent(input: {
     page: input.page,
     client,
     agentId: agent.id,
+    workspaceId: opened.workspace.id,
     cwd: input.cwd,
     provider: input.provider,
   };
-  await openAgent(input.page, { cwd: input.cwd, agentId: agent.id });
+  await openAgent(input.page, { workspaceId: opened.workspace.id, agentId: agent.id });
   return handle;
 }
 

packages/app/e2e/helpers/sidebar.ts

@@ -13,6 +13,38 @@ export async function expectWorkspaceListed(page: Page, name: string): Promise<v
   ).toBeVisible({ timeout: 30_000 });
 }
 
+// The workspace row kebab and its menu items carry no web ARIA role, so the sidebar
+// suite addresses them by the stable test ids the app assigns per workspace — the same
+// convention the rename flow uses. The kebab only reveals on hover.
+export async function archiveWorktreeFromSidebar(page: Page, workspaceId: string): Promise<void> {
+  const serverId = getServerId();
+  const row = page.getByTestId(`sidebar-workspace-row-${serverId}:${workspaceId}`);
+  await expect(row).toBeVisible({ timeout: 30_000 });
+  await row.hover();
+
+  const kebab = page.getByTestId(`sidebar-workspace-kebab-${serverId}:${workspaceId}`);
+  await expect(kebab).toBeVisible({ timeout: 10_000 });
+  await kebab.click();
+
+  // A clean worktree archives with no prompt; if the host reports unsynced work the app
+  // raises a browser confirm. Accept it so the user-confirmed archive stays deterministic
+  // either way.
+  page.once("dialog", (dialog) => void dialog.accept());
+
+  const archiveItem = page.getByTestId(`sidebar-workspace-menu-archive-${serverId}:${workspaceId}`);
+  await expect(archiveItem).toBeVisible({ timeout: 10_000 });
+  await archiveItem.click();
+}
+
+export async function expectWorkspaceAbsentFromSidebar(
+  page: Page,
+  workspaceId: string,
+): Promise<void> {
+  await expect(
+    page.getByTestId(`sidebar-workspace-row-${getServerId()}:${workspaceId}`),
+  ).toHaveCount(0, { timeout: 30_000 });
+}
+
 export async function openMobileAgentSidebar(page: Page): Promise<void> {
   await page.getByRole("button", { name: "Open menu" }).click();
 }

packages/app/e2e/helpers/timeline-pagination.ts

@@ -38,7 +38,7 @@ export async function seedLongMockAgentTimeline(
 }
 
 export async function openAgentTimeline(page: Page, agent: LongTimelineAgent): Promise<void> {
-  await page.goto(buildAgentRoute(agent.cwd, agent.agentId));
+  await page.goto(buildAgentRoute(agent.workspaceId, agent.agentId));
   await page.waitForURL(
     (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
     { timeout: 60_000 },

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

@@ -261,7 +261,7 @@ export async function navigateToWorkspaceViaSidebar(
   await switchWorkspaceViaSidebar({
     page,
     serverId: getServerId(),
-    targetWorkspacePath: workspaceId,
+    workspaceId,
   });
 }
 

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

@@ -18,29 +18,8 @@ export async function waitForSidebarHydration(page: Page, timeout = 60_000): Pro
     .waitFor({ state: "visible", timeout });
 }
 
-export function workspaceLabelFromPath(value: string): string {
-  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
-  const parts = normalized.split("/").filter(Boolean);
-  return parts[parts.length - 1] ?? normalized;
-}
-
-function candidateWorkspaceIds(inputPath: string): string[] {
-  const trimmed = inputPath.replace(/\/+$/, "");
-  const candidates = new Set<string>([trimmed]);
-  if (trimmed.startsWith("/var/")) {
-    candidates.add(`/private${trimmed}`);
-  }
-  if (trimmed.startsWith("/private/var/")) {
-    candidates.add(trimmed.replace(/^\/private/, ""));
-  }
-  return Array.from(candidates);
-}
-
-function workspaceRowLocator(page: Page, serverId: string, workspacePath: string) {
-  const ids = candidateWorkspaceIds(workspacePath).map(
-    (id) => `[data-testid="sidebar-workspace-row-${serverId}:${id}"]`,
-  );
-  return page.locator(ids.join(",")).first();
+function workspaceRowLocator(page: Page, serverId: string, workspaceId: string) {
+  return page.getByTestId(`sidebar-workspace-row-${serverId}:${workspaceId}`).first();
 }
 
 export async function expectSidebarWorkspaceSelected(input: {
@@ -69,13 +48,13 @@ export async function expectSidebarWorkspaceSelected(input: {
 export async function switchWorkspaceViaSidebar(input: {
   page: Page;
   serverId: string;
-  targetWorkspacePath: string;
+  workspaceId: string;
 }): Promise<void> {
-  const row = workspaceRowLocator(input.page, input.serverId, input.targetWorkspacePath);
+  const row = workspaceRowLocator(input.page, input.serverId, input.workspaceId);
   await expect(row).toBeVisible({ timeout: 30_000 });
   await row.click();
 
-  const targetWorkspaceRoute = buildHostWorkspaceRoute(input.serverId, input.targetWorkspacePath);
+  const targetWorkspaceRoute = buildHostWorkspaceRoute(input.serverId, input.workspaceId);
   await expect(input.page).toHaveURL(new RegExp(escapeRegex(targetWorkspaceRoute)), {
     timeout: 30_000,
   });
@@ -89,11 +68,10 @@ export async function waitForWorkspaceInSidebar(
   page: Page,
   input: { serverId: string; workspaceId: string },
 ): Promise<void> {
-  const candidates = candidateWorkspaceIds(input.workspaceId);
-  const selector = candidates
-    .map((id) => `[data-testid="sidebar-workspace-row-${input.serverId}:${id}"]`)
-    .join(",");
-  await page.locator(selector).first().waitFor({ state: "visible", timeout: 60_000 });
+  await workspaceRowLocator(page, input.serverId, input.workspaceId).waitFor({
+    state: "visible",
+    timeout: 60_000,
+  });
 }
 
 export async function expectWorkspaceHeader(

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

@@ -36,7 +36,6 @@ import {
   switchWorkspaceViaSidebar,
   waitForSidebarHydration,
   waitForWorkspaceInSidebar,
-  workspaceLabelFromPath,
 } from "./helpers/workspace-ui";
 
 interface WorkspaceStatusGroupEvent {
@@ -183,7 +182,7 @@ async function submitNewWorkspaceWithoutPrompt(page: import("@playwright/test").
 test.describe("New workspace flow", () => {
   let client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
   const localWorkspaceIds = new Set<string>();
-  const createdWorktreeIds = new Set<string>();
+  const createdWorktreeDirectories = new Set<string>();
 
   test.describe.configure({ timeout: 240_000 });
 
@@ -193,14 +192,14 @@ test.describe("New workspace flow", () => {
 
   test.afterEach(async () => {
     if (client) {
-      for (const workspaceId of createdWorktreeIds) {
-        await archiveWorkspaceFromDaemon(client, workspaceId).catch(() => undefined);
+      for (const workspaceDirectory of createdWorktreeDirectories) {
+        await archiveWorkspaceFromDaemon(client, workspaceDirectory).catch(() => undefined);
       }
       for (const workspaceId of localWorkspaceIds) {
         await archiveLocalWorkspaceFromDaemon(client, workspaceId).catch(() => undefined);
       }
     }
-    createdWorktreeIds.clear();
+    createdWorktreeDirectories.clear();
     localWorkspaceIds.clear();
     await client?.close().catch(() => undefined);
   });
@@ -223,7 +222,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: firstWorkspace.workspaceId,
+        workspaceId: firstWorkspace.workspaceId,
       });
       await expectWorkspaceHeader(page, {
         title: firstWorkspace.workspaceName,
@@ -233,7 +232,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: secondWorkspace.workspaceId,
+        workspaceId: secondWorkspace.workspaceId,
       });
       await waitForWorkspaceInSidebar(page, {
         serverId,
@@ -247,7 +246,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: firstWorkspace.workspaceId,
+        workspaceId: firstWorkspace.workspaceId,
       });
       await expectWorkspaceHeader(page, {
         title: firstWorkspace.workspaceName,
@@ -271,7 +270,7 @@ test.describe("New workspace flow", () => {
         slug: `nav-${Date.now()}`,
       });
       localWorkspaceIds.add(rootWorkspace.workspaceId);
-      createdWorktreeIds.add(worktreeWorkspace.workspaceId);
+      createdWorktreeDirectories.add(worktreeWorkspace.workspaceDirectory);
 
       await gotoAppShell(page);
       await waitForSidebarHydration(page);
@@ -279,7 +278,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: rootWorkspace.workspaceId,
+        workspaceId: rootWorkspace.workspaceId,
       });
       await expectWorkspaceHeader(page, {
         title: rootWorkspace.workspaceName,
@@ -294,7 +293,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: worktreeWorkspace.workspaceId,
+        workspaceId: worktreeWorkspace.workspaceId,
       });
       await expectWorkspaceHeader(page, {
         title: worktreeWorkspace.workspaceName,
@@ -315,7 +314,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: rootWorkspace.workspaceId,
+        workspaceId: rootWorkspace.workspaceId,
       });
       await expectWorkspaceHeader(page, {
         title: rootWorkspace.workspaceName,
@@ -354,7 +353,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: openedProject.workspaceId,
+        workspaceId: openedProject.workspaceId,
       });
       await expectWorkspaceHeader(page, {
         title: openedProject.workspaceName,
@@ -367,12 +366,13 @@ test.describe("New workspace flow", () => {
 
       const createdWorkspace = await assertNewWorkspaceSidebarAndHeader(page, {
         serverId,
+        client,
         previousWorkspaceId: openedProject.workspaceId,
         projectDisplayName: openedProject.projectDisplayName,
         assertSidebarRow: false,
         assertHeader: false,
       });
-      createdWorktreeIds.add(createdWorkspace.workspaceId);
+      createdWorktreeDirectories.add(createdWorkspace.workspaceDirectory);
 
       expect(createdWorkspace.workspaceId).not.toBe(openedProject.workspaceId);
       await expect(page).toHaveURL(
@@ -388,7 +388,7 @@ test.describe("New workspace flow", () => {
       await expect(createdWorkspaceRow).toBeVisible({ timeout: 30_000 });
 
       await expectWorkspaceHeader(page, {
-        title: workspaceLabelFromPath(createdWorkspace.workspaceId),
+        title: createdWorkspace.workspaceName,
         subtitle: openedProject.projectDisplayName,
       });
 
@@ -428,7 +428,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: openedProject.workspaceId,
+        workspaceId: openedProject.workspaceId,
       });
       await expectWorkspaceHeader(page, {
         title: openedProject.workspaceName,
@@ -455,12 +455,13 @@ test.describe("New workspace flow", () => {
 
       const createdWorkspace = await assertNewWorkspaceSidebarAndHeader(page, {
         serverId,
+        client,
         previousWorkspaceId: openedProject.workspaceId,
         projectDisplayName: openedProject.projectDisplayName,
         assertSidebarRow: false,
         assertHeader: false,
       });
-      createdWorktreeIds.add(createdWorkspace.workspaceId);
+      createdWorktreeDirectories.add(createdWorkspace.workspaceDirectory);
 
       await expect(page).toHaveURL(
         buildHostWorkspaceRoute(serverId, createdWorkspace.workspaceId),
@@ -507,7 +508,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: openedProject.workspaceId,
+        workspaceId: openedProject.workspaceId,
       });
       await expectWorkspaceHeader(page, {
         title: openedProject.workspaceName,
@@ -523,12 +524,13 @@ test.describe("New workspace flow", () => {
 
       const createdWorkspace = await assertNewWorkspaceSidebarAndHeader(page, {
         serverId,
+        client,
         previousWorkspaceId: openedProject.workspaceId,
         projectDisplayName: openedProject.projectDisplayName,
         assertSidebarRow: false,
         assertHeader: false,
       });
-      createdWorktreeIds.add(createdWorkspace.workspaceId);
+      createdWorktreeDirectories.add(createdWorkspace.workspaceDirectory);
 
       const rowTestId = `sidebar-workspace-row-${serverId}:${createdWorkspace.workspaceId}`;
       await expectWorkspaceStatusGroupEvents({
@@ -560,7 +562,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: openedProject.workspaceId,
+        workspaceId: openedProject.workspaceId,
       });
       await expectWorkspaceHeader(page, {
         title: openedProject.workspaceName,
@@ -576,10 +578,11 @@ test.describe("New workspace flow", () => {
 
       const createdWorkspace = await assertNewWorkspaceSidebarAndHeader(page, {
         serverId,
+        client,
         previousWorkspaceId: openedProject.workspaceId,
         projectDisplayName: openedProject.projectDisplayName,
       });
-      createdWorktreeIds.add(createdWorkspace.workspaceId);
+      createdWorktreeDirectories.add(createdWorkspace.workspaceDirectory);
 
       const rowTestId = `sidebar-workspace-row-${serverId}:${createdWorkspace.workspaceId}`;
       await expectWorkspaceStatusGroupEvents({
@@ -618,7 +621,7 @@ test.describe("New workspace flow", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: openedProject.workspaceId,
+        workspaceId: openedProject.workspaceId,
       });
       await expectWorkspaceHeader(page, {
         title: openedProject.workspaceName,
@@ -640,17 +643,18 @@ test.describe("New workspace flow", () => {
 
       const createdWorkspace = await assertNewWorkspaceSidebarAndHeader(page, {
         serverId,
+        client,
         previousWorkspaceId: openedProject.workspaceId,
         projectDisplayName: openedProject.projectDisplayName,
       });
-      createdWorktreeIds.add(createdWorkspace.workspaceId);
+      createdWorktreeDirectories.add(createdWorkspace.workspaceDirectory);
 
-      expect(existsSync(createdWorkspace.workspaceId)).toBe(true);
+      expect(existsSync(createdWorkspace.workspaceDirectory)).toBe(true);
 
       const branchInfo = await readWorktreeBranchInfo({
-        worktreePath: createdWorkspace.workspaceId,
+        worktreePath: createdWorkspace.workspaceDirectory,
       });
-      expect(branchInfo.currentBranch).toBe(path.basename(createdWorkspace.workspaceId));
+      expect(branchInfo.currentBranch).toBe(path.basename(createdWorkspace.workspaceDirectory));
       expect(branchInfo.hasAncestor(tempRepo.branchHeads.main)).toBe(true);
       expect(branchInfo.hasAncestor(tempRepo.branchHeads.dev)).toBe(true);
     } finally {

packages/app/e2e/provider-settings-refresh.spec.ts

@@ -9,7 +9,6 @@ async function openMockAgentAtMobileBreakpoint(page: Page) {
   const session = await seedMockAgentWorkspace({
     repoPrefix: "provider-sheet-stack-",
     title: "Provider sheet stack e2e",
-    initialPrompt: "Prepare provider sheet stack test agent.",
   });
   await openAgentRoute(page, session);
   await expectComposerVisible(page);
@@ -58,6 +57,12 @@ async function closeTopSheet(page: Page) {
   await page.mouse.up();
 }
 
+async function closeSheetByHeaderButton(page: Page, testId: string) {
+  const sheet = page.getByTestId(testId);
+  await sheet.getByLabel("Close", { exact: true }).click({ force: true });
+  await expect(sheet).not.toBeVisible({ timeout: 10_000 });
+}
+
 async function expectProviderSettingsVisible(page: Page) {
   await expect(page.getByTestId("provider-settings-sheet")).toBeVisible({ timeout: 10_000 });
   await expect(page.getByRole("button", { name: "Add model" })).toBeVisible();
@@ -69,14 +74,15 @@ async function exerciseProviderSettingsStack(page: Page) {
 
   await page.getByRole("button", { name: "Add model" }).click();
   await expect(page.getByTestId("add-custom-model-sheet")).toBeVisible({ timeout: 10_000 });
-  await closeTopSheet(page);
+  await closeSheetByHeaderButton(page, "add-custom-model-sheet");
+  await expect(page.getByPlaceholder("e.g. openai/gpt-5")).not.toBeVisible({ timeout: 10_000 });
   await expectProviderSettingsVisible(page);
 
   await page.getByRole("button", { name: "Diagnostic", exact: true }).click();
   await expect(page.getByTestId("provider-diagnostic-sheet")).toBeVisible({ timeout: 10_000 });
   await page.getByRole("button", { name: /Refresh diagnostic/ }).click();
   await expect(page.getByTestId("provider-diagnostic-sheet")).toBeVisible({ timeout: 10_000 });
-  await closeTopSheet(page);
+  await closeSheetByHeaderButton(page, "provider-diagnostic-sheet");
   await expectProviderSettingsVisible(page);
 
   await page.getByRole("button", { name: "Refresh", exact: true }).click();
@@ -87,18 +93,20 @@ test.describe("provider settings bottom-sheet stack", () => {
   test("provider settings and children close back through the model selector stack", async ({
     page,
   }) => {
+    test.setTimeout(180_000);
+
     const session = await openMockAgentAtMobileBreakpoint(page);
 
     try {
       await openProviderSettingsFromModelSelector(page);
       await exerciseProviderSettingsStack(page);
-      await closeTopSheet(page);
+      await closeSheetByHeaderButton(page, "provider-settings-sheet");
 
       await expectModelSelectorVisible(page);
       await page.getByRole("button", { name: /Open .* settings/ }).click();
       await expect(page.getByTestId("provider-settings-sheet")).toBeVisible({ timeout: 10_000 });
       await exerciseProviderSettingsStack(page);
-      await closeTopSheet(page);
+      await closeSheetByHeaderButton(page, "provider-settings-sheet");
 
       await expectModelSelectorVisible(page);
       await closeTopSheet(page);

packages/app/e2e/settings-toggle-tab-regression.spec.ts

@@ -74,7 +74,7 @@ test.describe("Settings toggle tab regression", () => {
       await expectSendBehavior(page, "interrupt");
 
       await pressSettingsToggleShortcut(page);
-      await expect(page).toHaveURL(buildHostWorkspaceRoute(serverId, workspace.repoPath));
+      await expect(page).toHaveURL(buildHostWorkspaceRoute(serverId, workspace.workspaceId));
       await waitForTabBar(page);
       await expectAgentTabActive(page, secondAgent.id);
 
@@ -105,13 +105,13 @@ test.describe("Settings toggle tab regression", () => {
       await openAgentRouteAndExpectFocused({
         page,
         serverId,
-        workspaceId: workspace.repoPath,
+        workspaceId: workspace.workspaceId,
         agentId: firstAgent.id,
       });
       await openAgentRouteAndExpectFocused({
         page,
         serverId,
-        workspaceId: workspace.repoPath,
+        workspaceId: workspace.workspaceId,
         agentId: secondAgent.id,
       });
 

packages/app/e2e/workspace-agent-tab-rename.spec.ts

@@ -7,8 +7,8 @@ import { buildHostAgentDetailRoute } from "@/utils/host-routes";
 import { captureWsSessionFrames, renameModalInput, renameModalSubmit } from "./helpers/rename";
 import { getServerId } from "./helpers/server-id";
 
-async function openAgentInWorkspace(page: Page, agent: { id: string; cwd: string }) {
-  await page.goto(buildHostAgentDetailRoute(getServerId(), agent.id, agent.cwd));
+async function openAgentInWorkspace(page: Page, agent: { id: string; workspaceId: string }) {
+  await page.goto(buildHostAgentDetailRoute(getServerId(), agent.id, agent.workspaceId));
   await page.waitForURL(
     (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
     { timeout: 60_000 },

packages/app/e2e/workspace-navigation-regression.spec.ts

@@ -92,7 +92,7 @@ async function openWorkspaceThroughApp(
   await switchWorkspaceViaSidebar({
     page,
     serverId: input.serverId,
-    targetWorkspacePath: input.workspace.workspaceId,
+    workspaceId: input.workspace.workspaceId,
   });
   await waitForWorkspaceTabsVisible(page);
   await expectWorkspaceLocation(page, input);
@@ -209,7 +209,7 @@ test.describe("Workspace navigation regression", () => {
 
       await gotoAppShell(page);
       await waitForSidebarHydration(page);
-      await page.goto(buildHostAgentDetailRoute(serverId, agent.id, agent.cwd));
+      await page.goto(buildHostAgentDetailRoute(serverId, agent.id, agent.workspaceId));
       await page.waitForURL(
         (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
         { timeout: 60_000 },
@@ -365,7 +365,7 @@ test.describe("Workspace navigation regression", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: firstWorkspace.workspaceId,
+        workspaceId: firstWorkspace.workspaceId,
       });
       await waitForWorkspaceTabsVisible(page);
       await expect(page).toHaveURL(buildHostWorkspaceRoute(serverId, firstWorkspace.workspaceId), {
@@ -397,7 +397,7 @@ test.describe("Workspace navigation regression", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: secondWorkspace.workspaceId,
+        workspaceId: secondWorkspace.workspaceId,
       });
       await waitForWorkspaceTabsVisible(page);
       await expect(page).toHaveURL(buildHostWorkspaceRoute(serverId, secondWorkspace.workspaceId), {
@@ -461,7 +461,7 @@ test.describe("Workspace navigation regression", () => {
       await switchWorkspaceViaSidebar({
         page,
         serverId,
-        targetWorkspacePath: firstWorkspace.workspaceId,
+        workspaceId: firstWorkspace.workspaceId,
       });
       await waitForWorkspaceTabsVisible(page);
       await expect(page).toHaveURL(buildHostWorkspaceRoute(serverId, firstWorkspace.workspaceId), {

packages/app/e2e/workspace-pane-remount.spec.ts

@@ -21,7 +21,7 @@ test.describe("Workspace pane mounting", () => {
         title: `pane-remount-${Date.now()}`,
       });
 
-      await page.goto(buildHostAgentDetailRoute(serverId, agent.id, agent.cwd));
+      await page.goto(buildHostAgentDetailRoute(serverId, agent.id, agent.workspaceId));
       await page.waitForURL(
         (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
         { timeout: 60_000 },

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

@@ -0,0 +1,59 @@
+import { existsSync } from "node:fs";
+import { expect, test } from "./fixtures";
+import { gotoAppShell } from "./helpers/app";
+import {
+  archiveWorkspaceFromDaemon,
+  connectNewWorkspaceDaemonClient,
+  createWorktreeViaDaemon,
+  openProjectViaDaemon,
+} from "./helpers/new-workspace";
+import { getServerId } from "./helpers/server-id";
+import { archiveWorktreeFromSidebar, expectWorkspaceAbsentFromSidebar } from "./helpers/sidebar";
+import { createTempGitRepo } from "./helpers/workspace";
+import { waitForSidebarHydration, waitForWorkspaceInSidebar } from "./helpers/workspace-ui";
+
+test.describe("Worktree archive", () => {
+  let client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
+  let tempRepo: { path: string; cleanup: () => Promise<void> };
+  const createdWorktreeDirectories = new Set<string>();
+
+  test.describe.configure({ retries: 1, timeout: 120_000 });
+
+  test.beforeEach(async () => {
+    client = await connectNewWorkspaceDaemonClient();
+    tempRepo = await createTempGitRepo("wt-archive-");
+  });
+
+  test.afterEach(async () => {
+    for (const directory of createdWorktreeDirectories) {
+      await archiveWorkspaceFromDaemon(client, directory).catch(() => undefined);
+    }
+    createdWorktreeDirectories.clear();
+    await client?.close().catch(() => undefined);
+    await tempRepo?.cleanup().catch(() => undefined);
+  });
+
+  test("archiving a worktree from the sidebar removes its row and worktree directory", async ({
+    page,
+  }) => {
+    const serverId = getServerId();
+    await openProjectViaDaemon(client, tempRepo.path);
+    const worktree = await createWorktreeViaDaemon(client, {
+      cwd: tempRepo.path,
+      slug: `archive-${Date.now()}`,
+    });
+    createdWorktreeDirectories.add(worktree.workspaceDirectory);
+    expect(existsSync(worktree.workspaceDirectory)).toBe(true);
+
+    await gotoAppShell(page);
+    await waitForSidebarHydration(page);
+    await waitForWorkspaceInSidebar(page, { serverId, workspaceId: worktree.workspaceId });
+
+    await archiveWorktreeFromSidebar(page, worktree.workspaceId);
+
+    await expectWorkspaceAbsentFromSidebar(page, worktree.workspaceId);
+    await expect
+      .poll(() => existsSync(worktree.workspaceDirectory), { timeout: 30_000 })
+      .toBe(false);
+  });
+});