Run multiple independent workspaces per directory (#1539)

* feat(workspace): bind agents/terminals/status to workspaceId (Model B phase 1) Model B EX-Phase 1: the binding layer. Records gain an additive workspaceId that answers "which workspace does this belong to" without replacing the existing required cwd. - protocol: add optional workspaceId to agent/terminal records and a workspaceOwnership capability under server_info.features.* - server: resolve and persist workspaceId on agent and terminal creation; carry it through agent-manager, projections, storage, loading, sessions, and the terminal manager/worker pipeline - workspace-directory / workspace-registry-model: derive and expose workspace ownership; bind status to workspaceId - client: surface workspaceId via daemon-client - app: filter terminals and agent visibility by workspaceId, thread it through workspace screen / terminal panel / session store - tests: cover workspaceId binding across create, agent-manager, mcp-server, workspace-directory, workspace-registry-model, and agent-visibility cwd stays required on every record; workspaceId is purely additive and back-compatible (optional/defaulted), so old and new peers still parse each other's messages. Known follow-ups: none. * feat(workspace): empty projects + editable titles, fix same-cwd terminal isolation (Model B phase 2) - Address Phase 1 review fixes and add same-cwd terminal isolation e2e coverage - Isolate terminal subscriptions per workspaceId so two workspaces sharing one cwd no longer cross-wire terminals (terminal-subscription-key) - Add editable workspace title, decoupled from the backing directory/branch - Persist empty projects (no workspaces yet) across daemon restarts - Add e2e coverage: empty-project-persists (server + app), workspace-same-cwd-isolation, sidebar-workspace-rename Known follow-ups: none * feat(workspace): create multiple workspaces per directory — local or worktree (Model B phase 3) - workspace.create RPC always creates a new workspace record; no directory dedup - dropped directory dedup in open_project and createPaseoWorktree paths - non-git directories are first-class: local-checkout workspaces no longer require a repo - service-proxy collision resolved by defaulting to the owning workspace instead of failing - new creation UI: choose backing directory (local checkout or worktree) per workspace - e2e coverage for creating multiple workspaces over the same directory Known follow-ups: - COMPAT cwd->workspaceId resolver remains until client floor advances - prune any remaining workspace==directory assumptions surfaced by usage * feat(cli): paseo run workspace policy — bare run creates a workspace, --workspace/PASEO_WORKSPACE_ID target (Model B phase 4) - A workspace is now the explicit home of a `paseo run`: run.ts resolves a workspace before creating any agent, then stamps the agent with that workspaceId — no run leans on createAgent's legacy cwd->workspace fallback. - Precedence: --workspace <id> > $PASEO_WORKSPACE_ID > --worktree > bare run. --worktree mints its own workspace and overrides the ambient PASEO_WORKSPACE_ID; --worktree + --workspace is rejected upstream. - New-workspace-per-bare-run: every bare run mints a fresh local-backed workspace for its cwd rather than reattaching to an existing one in that dir. - Env support: $PASEO_WORKSPACE_ID (exported by workspace terminals) targets an existing workspace, same as --workspace. - Help text: new --workspace option documents the default (new workspace per run) and the env fallback; created runs print the workspace id plus a tip. - e2e: cli-run-workspace-precedence.e2e.test.ts covers bare, distinct-per-cwd, --workspace attach, and env attach against an isolated daemon. Known follow-ups: - createAgent's COMPAT cwd->workspace resolver stays for old clients; the CLI no longer relies on it but it is not yet removable. * feat(workspace): archive removes the workspace record, never the directory; last worktree ref offers disk delete (Model B phase 5) - Archive is now scoped to a single workspace RECORD (by workspaceId), not by cwd/worktree path. It tears down only the agents and terminals owned by the target workspaceId. - Sibling isolation: a directory can back multiple workspaces, so archiving one workspace no longer destroys a sibling workspace's agents, terminals, or directory. - Decoupled on-disk worktree deletion into an explicit, last-reference-only option (deleteWorktreeFromDisk). The directory is removed only when the archived workspace was the last active reference to a Paseo-owned worktree; local checkouts are never deleted. - Unified archive UI with a keep/delete prompt: "Keep on disk" is the default non-destructive choice, "Delete" removes the worktree directory. - Protocol: new optional, defaulted deleteWorktreeFromDisk field (COMPAT-tagged, back-compat preserved). - Tests: record-scoped archive e2e (sibling isolation, last-ref disk delete, sibling-keeps-directory) and an app e2e for the keep prompt. Known follow-ups: - Surface the keep/delete prompt's "delete" path coverage in app e2e (only the keep path is exercised today). - COMPAT(worktreeDiskDeletion): drop the optional gate when floor >= v0.1.97. * feat(workspace): uniform expandable projects + status inbox; merged worktrees cleaned, explicit-id archive (Model B phase 6) - P5 archive fixes: worktree archive now targets an explicit workspaceId, and auto-archive-on-merge cleans the worktree directory from disk when it is the last reference. - Dropped non-git project flattening: every project — git or non-git, single- or multi-workspace — renders as the same expandable parent. - Every project is expandable and every workspace is archivable; each carries its own "+ New workspace" affordance regardless of kind. - Added a status inbox grouping (Ready for review / Working / Done) where each workspace is bucketed independently by last update. - The deepest sidebar level is the workspace row: tabs, agents, and terminals never appear in the sidebar. - Added Model B sidebar e2e coverage proving the expandable-parent, no-leaf, and independent-status-bucketing invariants. Known follow-ups: the inline header FolderPlus worktree shortcut stays git-only (canCreateWorktreeForProjectKind); non-git projects create workspaces via the "+ New workspace" row. * fix(protocol): use literal :: separator in terminal subscription key The committed blob contained a NUL byte as the separator instead of the :: the comment documents, which broke text diffs and review tooling (git flagged the file as binary). Functionally the key is an in-memory Map key only, but source must stay text. * feat(workspace): shared directory right-sidebar boundary + docs; final consolidation (Model B phase 7) - Pin and document the directory-backed vs workspace-owned right-sidebar boundary: same-cwd workspaces share directory-keyed git/PR/file surfaces but never share workspace-owned drafts, attachments, or file-explorer state. New docs section in architecture.md plus data-model.md keying convention and two glossary terms. - Add e2e coverage for the boundary: same-directory-workspaces.spec.ts proves the right sidebar is shared (a directory change appears in both same-dir workspaces) while tabs/terminals stay independent per workspace. - Accumulated follow-up fixes: - MCP child agents created in a new worktree are stamped with the new worktree's workspaceId (not the parent's, not unstamped), mirroring the session path so workspaceId-scoped archive can find and tear them down. - session-store mergeWorkspaces prunes a stale empty-project descriptor when a workspace lands in that project, so it stops governing the project's metadata. - CLI run: reject --worktree alongside an ambient PASEO_WORKSPACE_ID (not just --workspace), so worktree resolution never races an existing-workspace select. New run.test.ts pins the three validation outcomes. - Full-branch reshape outcomes: - Consolidate the four placeholder server_info.features flags (workspaceOwnership, workspaceTitles, workspaceProjects, workspaceMultiplicity) into the single workspaceMultiplicity capability gate. - Remove the now-dead ensureLocalCheckoutWorkspace and its deps interface; explicit creation always mints a new same-cwd record via createLocalCheckoutWorkspace. - Resolve every Model B COMPAT marker from v0.1.X to v0.1.97. - Drop the obsolete workspaceOwnership feature assertion from the same-cwd isolation e2e; broaden a sidebar-shortcuts test to cover both project kinds. - Add workspace-create-errors.e2e.test.ts pinning each early-reject error branch. - typecheck, lint, format all green. Known follow-ups: pre-existing COMPAT(rewind) markers still carry v0.1.X placeholders (out of Model B scope, left untouched). * test(workspace): de-slop Model B tests per audit-tests (reshape mocks/assertions) Reshape Model B test changes flagged by audit-tests so they exercise real behavior and observable state instead of mock scaffolding. Categories fixed: - Mocks -> real dependencies + persisted state: create.test.ts and mcp-server.test.ts dropped hand-built AgentManager/AgentStorage mock objects and mock.calls[...] assertions, now run the real AgentManager/AgentStorage with a fake agent client and assert on the stored agent record (workspaceId, parent label). - Module-internal spying -> injected seam: acp-agent stopped spying on the tree-kill module (vi.spyOn(treeKillModule, ...)). Added a ProcessTerminator injection seam to ACPAgentClient/ACPAgentSession (production defaults to terminateWithTreeKill); tests inject a typed FakeTerminator and assert on the recorded children plus observable stream .destroyed state. - Poking internals -> public API: acp close()/killTerminal/releaseTerminal tests now create terminals through the public createTerminal API instead of mutating internals.terminalEntries. - Reimplemented production logic deleted: cli-run-workspace-precedence dropped its inline copy of resolveRunWorkspace flag precedence (a fake reimplementation it then asserted against) and now proves only the daemon behaviors the CLI builds on; flag precedence stays covered in the CLI's own run.test.ts. - Sleep -> poll: workspace-same-cwd-isolation replaced a fixed setTimeout with expect.poll on the observed snapshot state to remove the race. - Internal protocol-frame assertions removed: sidebar-workspace-rename dropped the captureWsSessionFrames workspace.title.set.request assertions, relying on the user-visible rename + reload checks already present. * fix: green CI — new-workspace status bucket regression + branch-picker flow tests + sdk emptyProjects Source regression: - packages/app/src/screens/new-workspace-screen.tsx - packages/app/src/screens/new-workspace-empty.ts When a new workspace is created with an initial agent, optimistically merge it with status "running" (statusEnteredAt now) so it lands in the "Working" bucket instead of defaulting into the wrong bucket. The empty-workspace path passes withInitialAgent: false so a bare workspace keeps its descriptor status. Test-drift (intentional P3 flow change — backing picker now required): - packages/app/e2e/new-workspace.spec.ts - packages/app/e2e/helpers/new-workspace.ts The reshaped creation flow requires choosing a backing ("New worktree") before the branch / starting-ref picker is reachable. Branch-picker specs now call selectWorkspaceBacking(page, "worktree") first, and the helper waits for the worktree control to drop aria-disabled (it stays disabled until the checkout status query confirms the project is a git repo) before clicking. Test-drift (protocol field added — sdk emptyProjects): - packages/client/src/index.test.ts fetch_workspaces response now carries emptyProjects; the toEqual expectation includes emptyProjects: []. Flake hardening: - packages/app/e2e/same-directory-workspaces.spec.ts - packages/app/e2e/helpers/seed-client.ts Out-of-band working-tree writes raced the daemon's debounced filesystem watcher, so the UI could subscribe before the new file was in the git snapshot. Force a checkout refresh (same path as the UI's manual refresh) to make the write authoritative before asserting, removing the timing dependency. * test(app): expect withInitialAgent:false in empty-workspace create call The withInitialAgent flag (fix for the new-workspace Done-bucket regression) added a field to the ensureWorkspace call; the empty-path unit test pinned the exact args. Test-drift, not behavior — update the expectation. * feat(app): stack new-workspace creation params (Project / Isolation dropdown / Base) with reserved base row + keyboard avoidance Restructure the new-workspace creation screen into a vertical stack of Project / Isolation / Base parameters instead of the previous mixed layout. - Isolation/backing is now a dropdown (Local vs New worktree) matching the app's existing dropdown/combobox primitives, replacing the inline segmented switcher. - The Base (starting ref) row now reserves its space even when the backing is Local and the picker is hidden, so switching backing no longer causes the form to shift vertically. - The form avoids the keyboard so the title input and submit stay visible while typing on native and web. - Updated the e2e new-workspace helper to drive the dropdown-based backing selector and the reserved Base row. * fix(app): simplify new-workspace form — stacked ghost rows above composer, no card/title, project-matched dropdowns - Render the three rows (formStack) at the top, under the "New workspace" heading and above the composer input, not in the composer footer. - Drop the card/surface/border chrome; rows sit on the plain background. - Stack Project, Isolation (multiplicity only), and Base; remove the title field — the title is set server-side and create works with no user title. - Each row is a Label immediately followed by its dropdown control; no columns, fixed label widths, or reserved horizontal space, with the label glyph aligned to the heading's text x. - All three triggers share the ghost badge style of the Project control (ProjectPickerTrigger / IsolationPickerTrigger / RefPickerTrigger + Combobox); keep the workspace-create-backing-* test IDs. - Omit "New worktree" from Isolation entirely when the project is non-git. - Reserve the Base row height always but render nothing on Local backing, showing the Base label + ref picker only for New worktree. - Keep keyboard avoidance on the centered content. - E2E: drive selectWorkspaceBacking via the Isolation trigger + Combobox and remove the now-gone workspace-create-title-input usage and title field. * feat(app): sidebar new-workspace entry points + non-git isolation hidden + project auto-select - Q1: hide the Isolation control on non-git projects — gate the row on canCreateWorktree (multiplicity && selectedIsGit) so a project with no git checkout never offers a worktree backing choice. - Q2: reset the stale project preselect across the reused 'new' screen — clear the manual picker choice on route project identity change so each route-driven navigation preselects its own project; align the nav verb to router.navigate. - Q3: remove the per-project "+ New workspace" sidebar row and add one global "New workspace" entry above Sessions in both mobile and desktop sidebars (testID sidebar-global-new-workspace); creation stays reachable per-project via the existing git new-worktree icon. - Q4: match the Sessions / New-workspace header button sizing to the workspace rows — SidebarHeaderRow icon md->sm, label fontSize base->sm. - e2e: new new-workspace-entry.spec covering global entry, project preselect reset across reused screen, and non-git isolation hidden; update sidebar-model-b, empty-project-persists, workspace-multiplicity, and helpers for the removed per-project row. * fix(app): group New-workspace/Sessions header (no divider, workspace-row sized) + remove banned useUnistyles - Q5: wrap the New-workspace and Sessions header entries in a single sidebarHeaderGroup that owns one bottom divider, so the two rows sit tight together with no gap and no per-row separator (both mobile and desktop sidebars). - Add a compact variant to SidebarHeaderRow: workspace-row sized (minHeight 36, surfaceSidebarHover, borderRadius.lg) with horizontal padding that aligns its icon/label with the Workspaces section title and the workspace rows below; the default header variant (settings Back-to-workspace) keeps its sidebar-height row and own separator. - Remove the banned useUnistyles() from sidebar-header-row.tsx per docs/unistyles.md: theme-reactive icon color now goes through withUnistyles(Icon) + uniProps mappings; static sizing reads ICON_SIZE. - Taste: new-workspace-screen dedupes the project-icon styles (single projectIcon/projectIconFallback/projectIconFallbackText) and replaces repeated magic numbers with BADGE_HEIGHT and a named fallback-font-size constant. * fix(app): no layout shift on git<->non-git (reserve Isolation row) + symmetric sidebar divider spacing - Q6: Isolation row reserves its height and renders an invisible spacer for non-git projects, matching the Base-row pattern, so switching between git and non-git projects keeps a constant form height with no layout shift. - Q7: sidebar header group splits paddingVertical into paddingTop/paddingBottom so the Sessions-row-to-divider gap equals the divider-to-Workspaces-header gap, centering the divider. * feat(app): rename Sessions to History (clock icon, Agent history header) - Sidebar label now reads "History" with a clock icon (was Sessions / MessagesSquare) - Sessions screen header now reads "Agent history" - Updated i18n strings across all 6 locales (en, ar, ru, zh-CN, fr, es) - Route and testIDs unchanged (sidebar-sessions, /sessions) * fix(app): symmetric sidebar header padding (top == bottom), traffic-light inset preserved The sidebarHeaderGroup wrapper (New-workspace + History rows) had paddingTop: theme.spacing[1] against paddingBottom: theme.spacing[2]. Equalize paddingTop to theme.spacing[2] so the header group's top padding matches its bottom padding. The divider stays centered since paddingBottom still matches WorkspacesSectionHeader's paddingTop. The desktop window-controls (traffic-light) spacer — paddingTopSpacerStyle plus TitlebarDragRegion — is a separate inset and is left untouched. * fix(app): hover card shows branch; sidebar copy-branch copies the real branch (not the title) - Add SidebarWorkspaceEntry.currentBranch, sourced from gitRuntime.currentBranch (normalized; detached HEAD/blank/missing -> null) - Fix copy-branch smear: handleCopyBranchName copied workspace.name (the title); now copies the real currentBranch (guarded) - Workspace hover card: add a branch row (GitBranch icon + branch name), shown only when it differs from the title - Header branch-switcher left untouched; diff-pane re-home decision still pending * feat(app): branch switcher moves into the git diff panel; header title is static (Model B coherence) - branch switcher now lives in the diff panel Changes header on desktop+mobile - workspace header title is a plain static title; branch removed from it - no new workspace-screen header row - git diff-stat unchanged, stays where it is - no duplicate git actions - unified descriptor name fallbacks via resolveWorkspaceName - rename-then-switch e2e proves header title and real branch stay independent
2026-06-15 14:23:02 +08:00
parent eb94b70848
commit 71b5c35d9b
129 changed files with 6252 additions and 1818 deletions
@@ -1,17 +1,49 @@
-import { expect, test } from "./fixtures";
+import { expect, test, type Page } from "./fixtures";
 import { gotoAppShell } from "./helpers/app";
-import { expectWorkspaceBranch, switchBranchFromHeader } from "./helpers/branch-switcher";
+import {
+  expectNoBranchSwitcherInWorkspaceHeader,
+  expectWorkspaceBranch,
+  openChangesPanel,
+  switchBranchFromChangesPanel,
+} 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";

+async function renameWorkspaceViaSidebar(
+  page: Page,
+  input: { workspaceId: string; title: string },
+): Promise<void> {
+  const serverId = getServerId();
+  const row = page.getByTestId(`sidebar-workspace-row-${serverId}:${input.workspaceId}`);
+  await expect(row).toBeVisible({ timeout: 30_000 });
+  await row.hover();
+
+  const kebab = page.getByTestId(`sidebar-workspace-kebab-${serverId}:${input.workspaceId}`);
+  await expect(kebab).toBeVisible({ timeout: 10_000 });
+  await kebab.click();
+
+  const renameItem = page.getByTestId(
+    `sidebar-workspace-menu-rename-${serverId}:${input.workspaceId}`,
+  );
+  await expect(renameItem).toBeVisible({ timeout: 10_000 });
+  await renameItem.click();
+
+  const modalPrefix = `sidebar-workspace-rename-modal-${serverId}:${input.workspaceId}`;
+  const renameInput = page.getByTestId(`${modalPrefix}-input`);
+  await expect(renameInput).toBeVisible({ timeout: 10_000 });
+  await renameInput.fill(input.title);
+  await page.getByTestId(`${modalPrefix}-submit`).click();
+  await expect(renameInput).toHaveCount(0, { timeout: 15_000 });
+}
+
 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 ({
+  test("switches the workspace branch from the git diff panel for an opaque workspace id", async ({
    page,
  }) => {
    test.setTimeout(90_000);
@@ -26,8 +58,9 @@ test.describe("Branch switcher", () => {
      await waitForSidebarHydration(page);
      await switchWorkspaceViaSidebar({ page, serverId, workspaceId: workspace.workspaceId });

+      await openChangesPanel(page);
      await expectWorkspaceBranch(page, "main");
-      await switchBranchFromHeader(page, { from: "main", to: "dev" });
+      await switchBranchFromChangesPanel(page, { from: "main", to: "dev" });
      await expectWorkspaceBranch(page, "dev");

      await expect
@@ -41,4 +74,58 @@ test.describe("Branch switcher", () => {
      await workspace.cleanup();
    }
  });
+
+  test("a custom workspace title stays in the header while the diff panel switches the real branch", async ({
+    page,
+  }) => {
+    test.setTimeout(90_000);
+    const serverId = getServerId();
+    const workspace = await seedWorkspace({
+      repoPrefix: "branch-coherence-",
+      repo: { branches: ["main", "dev"] },
+    });
+
+    try {
+      expect(workspace.workspaceName).toBe("main");
+
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await switchWorkspaceViaSidebar({ page, serverId, workspaceId: workspace.workspaceId });
+
+      const customTitle = "Payments Refactor";
+      await renameWorkspaceViaSidebar(page, {
+        workspaceId: workspace.workspaceId,
+        title: customTitle,
+      });
+
+      // The header shows the custom title verbatim (a plain static title), never a
+      // branch name, and the branch switcher does not live in the header.
+      const headerTitle = page
+        .getByTestId("workspace-header-title")
+        .filter({ visible: true })
+        .first();
+      await expect(headerTitle).toHaveText(customTitle, { timeout: 30_000 });
+      await expectNoBranchSwitcherInWorkspaceHeader(page);
+
+      // The diff panel's switcher tracks the real branch ("main"), not the title,
+      // and switching it checks out the real branch on disk.
+      await openChangesPanel(page);
+      await expectWorkspaceBranch(page, "main");
+      await switchBranchFromChangesPanel(page, { from: "main", to: "dev" });
+      await expectWorkspaceBranch(page, "dev");
+
+      // The custom title is unaffected by the branch switch.
+      await expect(headerTitle).toHaveText(customTitle, { timeout: 30_000 });
+
+      await expect
+        .poll(
+          async () =>
+            (await readWorktreeBranchInfo({ worktreePath: workspace.repoPath })).currentBranch,
+          { timeout: 30_000 },
+        )
+        .toBe("dev");
+    } finally {
+      await workspace.cleanup();
+    }
+  });
 });
@@ -0,0 +1,78 @@
+import { test, expect, type Page } from "./fixtures";
+import { gotoAppShell } from "./helpers/app";
+import { seedWorkspace } from "./helpers/seed-client";
+import { getServerId } from "./helpers/server-id";
+import { waitForSidebarHydration } from "./helpers/workspace-ui";
+
+function workspaceRowTestId(workspaceId: string): string {
+  return `sidebar-workspace-row-${getServerId()}:${workspaceId}`;
+}
+
+async function hideWorkspaceFromSidebar(page: Page, workspaceId: string): Promise<void> {
+  const serverId = getServerId();
+  const row = page.getByTestId(workspaceRowTestId(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();
+
+  // Hiding a checkout from the sidebar raises a browser confirm; accept it so the
+  // user-confirmed archive proceeds deterministically.
+  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();
+}
+
+// Model B makes the project a first-class parent: archiving its last workspace
+// must not delete the project. The per-project "+ New workspace" row is gone;
+// the empty project keeps its parent row, and creation stays reachable from the
+// project row's own new-worktree icon (git projects) and the global button.
+test.describe("Empty project persists", () => {
+  test("archiving the only workspace keeps the project row with creation still reachable", async ({
+    page,
+  }) => {
+    const workspace = await seedWorkspace({ repoPrefix: "empty-project-persists-" });
+
+    try {
+      const projectRow = page.getByTestId(`sidebar-project-row-${workspace.projectId}`);
+      const projectNewWorktreeIcon = page.getByTestId(
+        `sidebar-project-new-worktree-${workspace.projectId}`,
+      );
+      const globalNewWorkspace = page.getByTestId("sidebar-global-new-workspace");
+
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await expect(projectRow).toBeVisible({ timeout: 30_000 });
+      await expect(page.getByTestId(workspaceRowTestId(workspace.workspaceId))).toBeVisible({
+        timeout: 30_000,
+      });
+
+      await hideWorkspaceFromSidebar(page, workspace.workspaceId);
+
+      // The workspace row goes away, but its project parent stays as an empty
+      // project row. Creation is still reachable: the project row keeps its own
+      // new-worktree icon (revealed on hover) and the global button persists.
+      await expect(page.getByTestId(workspaceRowTestId(workspace.workspaceId))).toHaveCount(0, {
+        timeout: 30_000,
+      });
+      await expect(projectRow).toBeVisible({ timeout: 30_000 });
+      await expect(globalNewWorkspace).toBeVisible({ timeout: 30_000 });
+      await projectRow.hover();
+      await expect(projectNewWorktreeIcon).toBeVisible({ timeout: 30_000 });
+
+      // The empty project survives a reload — it is persisted, not a transient
+      // artifact of the just-archived workspace still lingering in memory.
+      await page.reload();
+      await waitForSidebarHydration(page);
+      await expect(projectRow).toBeVisible({ timeout: 30_000 });
+      await projectRow.hover();
+      await expect(projectNewWorktreeIcon).toBeVisible({ timeout: 30_000 });
+    } finally {
+      await workspace.cleanup();
+    }
+  });
+});
@@ -212,7 +212,7 @@ export async function openSessions(page: Page): Promise<void> {
  await expect(page).toHaveURL(new RegExp(`${buildHostSessionsRoute(getServerId())}$`), {
    timeout: 30_000,
  });
-  await expect(page.getByText("Sessions", { exact: true }).last()).toBeVisible({
+  await expect(page.getByText("Agent history", { exact: true }).last()).toBeVisible({
    timeout: 30_000,
  });
 }
@@ -1,22 +1,42 @@
 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.
+// The branch switcher lives in the git diff panel's Changes header (right-side
+// ExplorerSidebar), not in the workspace header. It 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 panel resolved a real
+// checkout directory from the opaque workspace id. Scoping to the changes header
+// keeps the matcher unambiguous even when the header is shared with diff actions.
 function branchSwitcherTrigger(page: Page, branchName: string) {
  return page
+    .getByTestId("changes-header")
    .getByRole("button", { name: new RegExp(`Current branch: ${escapeRegex(branchName)}\\b`) })
    .filter({ visible: true })
    .first();
 }

+// Opens the right-side explorer and lands on the Changes tab, where the branch
+// switcher and diff live. Git checkouts default to the Changes tab when the
+// explorer opens, so this is enough to reveal the switcher on desktop and mobile.
+export async function openChangesPanel(page: Page): Promise<void> {
+  await expect(page.getByTestId("workspace-explorer-toggle").first()).toBeVisible({
+    timeout: 30_000,
+  });
+  await page.getByTestId("workspace-explorer-toggle").first().click();
+  const changesTab = page.getByTestId("explorer-tab-changes").filter({ visible: true }).first();
+  await expect(changesTab).toBeVisible({ timeout: 30_000 });
+  await changesTab.click();
+  await expect(page.getByTestId("changes-header").filter({ visible: true }).first()).toBeVisible({
+    timeout: 30_000,
+  });
+}
+
 export async function expectWorkspaceBranch(page: Page, branchName: string): Promise<void> {
  await expect(branchSwitcherTrigger(page, branchName)).toBeVisible({ timeout: 30_000 });
 }

-export async function switchBranchFromHeader(
+export async function switchBranchFromChangesPanel(
  page: Page,
  input: { from: string; to: string },
 ): Promise<void> {
@@ -38,3 +58,10 @@ export async function switchBranchFromHeader(

  await expect(picker).not.toBeVisible({ timeout: 30_000 });
 }
+
+// The workspace header title is a plain static title in Model B; the branch
+// switcher must never appear there. Asserting on the header testID keeps this
+// honest even as the switcher continues to exist inside the Changes panel.
+export async function expectNoBranchSwitcherInWorkspaceHeader(page: Page): Promise<void> {
+  await expect(page.getByTestId("workspace-header-branch-switcher")).toHaveCount(0);
+}
@@ -13,6 +13,7 @@ type NewWorkspaceDaemonClient = Pick<
  | "connect"
  | "createPaseoWorktree"
  | "fetchWorkspaces"
+  | "getPaseoWorktreeList"
  | "openProject"
 >;

@@ -152,7 +153,7 @@ export async function openNewWorkspaceComposer(
 }

 export async function openGlobalNewWorkspaceComposer(page: Page): Promise<void> {
-  await page.getByTestId("sidebar-new-workspace").click();
+  await page.getByTestId("sidebar-global-new-workspace").click();

  await expect(page).toHaveURL(/\/h\/[^/]+\/new(?:\?.*)?$/, {
    timeout: 30_000,
@@ -190,6 +191,45 @@ export async function clickNewWorkspaceButton(
  await submitNewWorkspacePrompt(page, input.prompt);
 }

+export async function selectNewWorkspaceProject(
+  page: Page,
+  input: { projectKey: string; projectDisplayName: string },
+): Promise<void> {
+  const trigger = page.getByTestId("new-workspace-project-picker-trigger");
+  await expect(trigger).toBeVisible({ timeout: 30_000 });
+  await trigger.click();
+
+  const option = page.getByTestId(`new-workspace-project-picker-option-${input.projectKey}`);
+  await expect(option).toBeVisible({ timeout: 30_000 });
+  await option.click();
+
+  await expectNewWorkspaceProjectSelected(page, input.projectDisplayName);
+}
+
+export async function selectWorkspaceBacking(
+  page: Page,
+  backing: "local" | "worktree",
+): Promise<void> {
+  const trigger = page.getByTestId("workspace-create-backing-trigger");
+  await expect(trigger).toBeVisible({ timeout: 30_000 });
+  await trigger.click();
+
+  // "New worktree" is only listed once the checkout status query confirms the
+  // selected project is a git repo, so wait for the option to appear before
+  // clicking it.
+  const option = page.getByTestId(`workspace-create-backing-${backing}`);
+  await expect(option).toBeVisible({ timeout: 30_000 });
+  await option.click();
+}
+
+export async function submitNewWorkspaceEmpty(page: Page): Promise<void> {
+  const createButton = page
+    .getByTestId("message-input-root")
+    .getByRole("button", { name: "Create" });
+  await expect(createButton).toBeVisible({ timeout: 30_000 });
+  await createButton.click();
+}
+
 export async function openStartingRefPicker(page: Page): Promise<void> {
  const trigger = page.getByTestId("new-workspace-ref-picker-trigger");
  await expect(trigger).toBeVisible({ timeout: 30_000 });
@@ -24,6 +24,24 @@ export interface SeedDaemonClient {
    } | null;
    error: string | null;
  }>;
+  createWorkspace(input: {
+    backing: "local" | "worktree";
+    cwd?: string;
+    projectId?: string;
+    branch?: string;
+    baseBranch?: string;
+    title?: string;
+  }): Promise<{
+    workspace: { id: string; name: string } | null;
+    error: string | null;
+  }>;
+  /**
+   * Force the daemon to recompute its git snapshot and diff for a checkout,
+   * mirroring the UI's manual refresh. Tests use this to make an out-of-band
+   * working-tree write authoritative before asserting on it in the UI, instead
+   * of racing the filesystem watcher's debounce.
+   */
+  checkoutRefresh(cwd: string): Promise<{ success: boolean; error: unknown }>;
  createTerminal(
    cwd: string,
    name?: string,
@@ -34,6 +34,36 @@ export async function archiveWorktreeFromSidebar(page: Page, workspaceId: string
  const archiveItem = page.getByTestId(`sidebar-workspace-menu-archive-${serverId}:${workspaceId}`);
  await expect(archiveItem).toBeVisible({ timeout: 10_000 });
  await archiveItem.click();
+
+  // Archiving the last reference to a worktree opens the keep/delete prompt.
+  // This helper deletes the worktree from disk; callers that want to keep it use
+  // openWorktreeDeletePrompt directly.
+  const deleteButton = page.getByTestId("worktree-delete-confirm-delete");
+  await expect(deleteButton).toBeVisible({ timeout: 10_000 });
+  await deleteButton.click();
+}
+
+// Opens the archive flow for a last-reference worktree and stops at the inline
+// keep/delete prompt, which the caller resolves by clicking keep or delete.
+export async function openWorktreeDeletePrompt(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 dirty/unsynced worktree raises a browser confirm before the prompt; accept
+  // it so the prompt opens deterministically 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();
+
+  await expect(page.getByTestId("worktree-delete-confirm-keep")).toBeVisible({ timeout: 10_000 });
 }

 export async function expectWorkspaceAbsentFromSidebar(
@@ -0,0 +1,155 @@
+import { expect, test } from "./fixtures";
+import { gotoAppShell } from "./helpers/app";
+import {
+  connectNewWorkspaceDaemonClient,
+  expectNewWorkspaceProjectSelected,
+  openGlobalNewWorkspaceComposer,
+  openNewWorkspaceComposer,
+} from "./helpers/new-workspace";
+import { seedWorkspace, type SeededWorkspace } from "./helpers/seed-client";
+import { getServerId } from "./helpers/server-id";
+import { waitForSidebarHydration } from "./helpers/workspace-ui";
+
+// Model B entry points into the New Workspace screen. The per-project
+// "+ New workspace" sidebar row is gone; the surviving entries are the global
+// button (universal) and each git project's own new-worktree icon (preselects
+// that project). These specs prove the global entry opens the screen, the
+// project icon preselects the right project across the reused 'new' screen, and
+// non-git projects never offer the worktree Isolation control.
+
+function projectRow(page: import("@playwright/test").Page, projectKey: string) {
+  return page.getByTestId(`sidebar-project-row-${projectKey}`);
+}
+
+test.describe("New workspace entry points", () => {
+  let client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
+
+  test.describe.configure({ timeout: 240_000 });
+
+  test.beforeEach(async () => {
+    client = await connectNewWorkspaceDaemonClient();
+  });
+
+  test.afterEach(async () => {
+    await client?.close().catch(() => undefined);
+  });
+
+  test("the global new-workspace button opens the New Workspace screen", async ({ page }) => {
+    const seeded: SeededWorkspace = await seedWorkspace({ repoPrefix: "entry-global-button-" });
+
+    try {
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await expect(
+        page.getByTestId(`sidebar-workspace-row-${getServerId()}:${seeded.workspaceId}`),
+      ).toBeVisible({ timeout: 30_000 });
+
+      const globalButton = page.getByTestId("sidebar-global-new-workspace");
+      await expect(globalButton).toBeVisible({ timeout: 30_000 });
+
+      await openGlobalNewWorkspaceComposer(page);
+
+      // The screen is up: its project picker trigger is the canonical landmark.
+      await expect(page.getByTestId("new-workspace-project-picker-trigger")).toBeVisible({
+        timeout: 30_000,
+      });
+    } finally {
+      await seeded.cleanup();
+    }
+  });
+
+  test("each project's row icon preselects that project, and the reused screen resets a stale manual choice across projects", async ({
+    page,
+  }) => {
+    const projectA: SeededWorkspace = await seedWorkspace({ repoPrefix: "entry-preselect-a-" });
+    const projectB: SeededWorkspace = await seedWorkspace({ repoPrefix: "entry-preselect-b-" });
+    const projectC: SeededWorkspace = await seedWorkspace({ repoPrefix: "entry-preselect-c-" });
+
+    try {
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await expect(projectRow(page, projectA.projectId)).toBeVisible({ timeout: 30_000 });
+      await expect(projectRow(page, projectB.projectId)).toBeVisible({ timeout: 30_000 });
+      await expect(projectRow(page, projectC.projectId)).toBeVisible({ timeout: 30_000 });
+
+      // Project A's row icon opens New Workspace with A preselected.
+      await openNewWorkspaceComposer(page, {
+        projectKey: projectA.projectId,
+        projectDisplayName: projectA.projectDisplayName,
+      });
+      await expectNewWorkspaceProjectSelected(page, projectA.projectDisplayName);
+
+      // Manually override the selection to C from inside A's screen. This stale
+      // manualProjectKey is what the reused 'new' screen must reset when the next
+      // route-driven navigation targets a different project.
+      await page.getByTestId("new-workspace-project-picker-trigger").click();
+      const optionC = page.getByTestId(`new-workspace-project-picker-option-${projectC.projectId}`);
+      await expect(optionC).toBeVisible({ timeout: 30_000 });
+      await optionC.click();
+      await expectNewWorkspaceProjectSelected(page, projectC.projectDisplayName);
+
+      // Navigate via B's row icon. B must be preselected — the route project wins
+      // because the stale manual choice (C) was reset on the route change. If the
+      // reset were missing, the trigger would still read C.
+      await openNewWorkspaceComposer(page, {
+        projectKey: projectB.projectId,
+        projectDisplayName: projectB.projectDisplayName,
+      });
+      await expectNewWorkspaceProjectSelected(page, projectB.projectDisplayName);
+    } finally {
+      await projectA.cleanup();
+      await projectB.cleanup();
+      await projectC.cleanup();
+    }
+  });
+
+  test("the Isolation control is hidden for a non-git project and shown for a git project", async ({
+    page,
+  }) => {
+    const gitProject: SeededWorkspace = await seedWorkspace({ repoPrefix: "entry-iso-git-" });
+    const nonGitProject: SeededWorkspace = await seedWorkspace({
+      repoPrefix: "entry-iso-nongit-",
+      git: false,
+    });
+
+    try {
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await expect(projectRow(page, gitProject.projectId)).toBeVisible({ timeout: 30_000 });
+      await expect(projectRow(page, nonGitProject.projectId)).toBeVisible({ timeout: 30_000 });
+
+      // Open New Workspace for the non-git project via the global button, then
+      // select it in the picker (its row has no new-worktree icon).
+      await openGlobalNewWorkspaceComposer(page);
+      const trigger = page.getByTestId("new-workspace-project-picker-trigger");
+      await expect(trigger).toBeVisible({ timeout: 30_000 });
+      await trigger.click();
+      const nonGitOption = page.getByTestId(
+        `new-workspace-project-picker-option-${nonGitProject.projectId}`,
+      );
+      await expect(nonGitOption).toBeVisible({ timeout: 30_000 });
+      await nonGitOption.click();
+      await expectNewWorkspaceProjectSelected(page, nonGitProject.projectDisplayName);
+
+      // No git checkout means no worktree backing choice: the Isolation row is
+      // absent entirely.
+      await expect(page.getByTestId("workspace-create-backing-trigger")).toHaveCount(0);
+
+      // Switching to the git project on the same screen reveals the Isolation row.
+      await trigger.click();
+      const gitOption = page.getByTestId(
+        `new-workspace-project-picker-option-${gitProject.projectId}`,
+      );
+      await expect(gitOption).toBeVisible({ timeout: 30_000 });
+      await gitOption.click();
+      await expectNewWorkspaceProjectSelected(page, gitProject.projectDisplayName);
+
+      await expect(page.getByTestId("workspace-create-backing-trigger")).toBeVisible({
+        timeout: 30_000,
+      });
+    } finally {
+      await gitProject.cleanup();
+      await nonGitProject.cleanup();
+    }
+  });
+});
@@ -25,6 +25,7 @@ import {
  selectBranchInPicker,
  selectGitHubPrInPicker,
  selectPickerOptionByKeyboard,
+  selectWorkspaceBacking,
  submitNewWorkspacePrompt,
 } from "./helpers/new-workspace";
 import { createTempGitRepo, readWorktreeBranchInfo } from "./helpers/workspace";
@@ -632,6 +633,7 @@ test.describe("New workspace flow", () => {
        projectKey: openedProject.projectKey,
        projectDisplayName: openedProject.projectDisplayName,
      });
+      await selectWorkspaceBacking(page, "worktree");
      await openStartingRefPicker(page);
      await selectBranchInPicker(page, "dev");

@@ -677,6 +679,7 @@ test.describe("New workspace flow", () => {
        projectKey: openedProject.projectKey,
        projectDisplayName: openedProject.projectDisplayName,
      });
+      await selectWorkspaceBacking(page, "worktree");

      await openBranchPicker(page);
      await expectPickerOpen(page);
@@ -701,6 +704,7 @@ test.describe("New workspace flow", () => {
        projectKey: openedProject.projectKey,
        projectDisplayName: openedProject.projectDisplayName,
      });
+      await selectWorkspaceBacking(page, "worktree");

      await openBranchPicker(page);
      await expectPickerOpen(page);
@@ -730,6 +734,7 @@ test.describe("New workspace flow", () => {
        projectKey: openedProject.projectKey,
        projectDisplayName: openedProject.projectDisplayName,
      });
+      await selectWorkspaceBacking(page, "worktree");
      await openStartingRefPicker(page);
      await selectGitHubPrInPicker(page, pr.number);

@@ -0,0 +1,122 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { test, expect, type Page } from "./fixtures";
+import { gotoWorkspace, clickNewTerminal } from "./helpers/launcher";
+import { seedWorkspace, type SeededWorkspace } from "./helpers/seed-client";
+import { expectExplorerEntryVisible } from "./helpers/file-explorer";
+import { expectNoTerminalTabs, clickFirstTerminalTab } from "./helpers/workspace-tabs";
+
+// Model B: two workspaces can back the SAME directory. What follows from that
+// split is the contract these specs pin:
+//   - The right sidebar (file browser / git changes) reads the directory, so it
+//     is IDENTICAL across same-directory workspaces.
+//   - Tabs (agents, terminals) are owned by the workspace, so they are
+//     INDEPENDENT across same-directory workspaces.
+
+// On desktop the explorer is pinned open; on narrow layouts it must be toggled.
+// Open it either way, then select the requested tab.
+async function openExplorerTab(page: Page, tab: "files" | "changes"): Promise<void> {
+  const openButton = page.getByRole("button", { name: "Open explorer" }).first();
+  if (await openButton.isVisible().catch(() => false)) {
+    await openButton.click();
+  }
+  await page.getByTestId(`explorer-tab-${tab}`).click();
+}
+
+async function createSecondWorkspaceOnSameDir(
+  seeded: SeededWorkspace,
+  title: string,
+): Promise<string> {
+  const created = await seeded.client.createWorkspace({
+    backing: "local",
+    cwd: seeded.repoPath,
+    projectId: seeded.projectId,
+    title,
+  });
+  if (!created.workspace) {
+    throw new Error(created.error ?? `Failed to create second workspace for ${seeded.projectId}`);
+  }
+  // Both workspaces back the same on-disk checkout.
+  return created.workspace.id;
+}
+
+test.describe("Same-directory workspaces", () => {
+  test.describe.configure({ timeout: 180_000 });
+
+  test("the right sidebar is shared: a directory change shows in both same-dir workspaces", async ({
+    page,
+  }) => {
+    const seeded = await seedWorkspace({ repoPrefix: "same-dir-shared-" });
+
+    try {
+      const secondWorkspaceId = await createSecondWorkspaceOnSameDir(seeded, "Second view");
+
+      // Seed an uncommitted change directly in the shared checkout. Because the
+      // file browser and git diff read the directory, both workspaces must see
+      // it — neither owns the directory state.
+      await writeFile(
+        path.join(seeded.workspaceDirectory, "SHARED_CHANGE.md"),
+        "# shared change\n",
+      );
+
+      // Make the write authoritative on the daemon before the UI reads it. The
+      // git status/diff is otherwise refreshed by a debounced filesystem watcher,
+      // and a loaded CI host can lag that debounce past the assertion window —
+      // the source of this spec's flakiness. Forcing a refresh (the same path as
+      // the UI's manual refresh) recomputes the snapshot and diff now, so the
+      // first subscribe on mount already includes SHARED_CHANGE.md.
+      const refreshed = await seeded.client.checkoutRefresh(seeded.repoPath);
+      if (!refreshed.success) {
+        throw new Error(`Failed to refresh checkout: ${JSON.stringify(refreshed.error)}`);
+      }
+
+      // Workspace A: the new file shows in both the file browser and the git
+      // changes view.
+      await gotoWorkspace(page, seeded.workspaceId);
+      await openExplorerTab(page, "files");
+      await expectExplorerEntryVisible(page, "SHARED_CHANGE.md");
+      await openExplorerTab(page, "changes");
+      await expect(
+        page.getByTestId("git-diff-scroll").getByText("SHARED_CHANGE.md", { exact: true }).first(),
+      ).toBeVisible({ timeout: 30_000 });
+
+      // Workspace B (same directory): the SAME change is visible. The right
+      // sidebar content does not differ between the two views.
+      await gotoWorkspace(page, secondWorkspaceId);
+      await openExplorerTab(page, "files");
+      await expectExplorerEntryVisible(page, "SHARED_CHANGE.md");
+      await openExplorerTab(page, "changes");
+      await expect(
+        page.getByTestId("git-diff-scroll").getByText("SHARED_CHANGE.md", { exact: true }).first(),
+      ).toBeVisible({ timeout: 30_000 });
+    } finally {
+      await seeded.cleanup();
+    }
+  });
+
+  test("workspace state is independent: a terminal opened in A does not appear in B", async ({
+    page,
+  }) => {
+    const seeded = await seedWorkspace({ repoPrefix: "same-dir-independent-" });
+
+    try {
+      const secondWorkspaceId = await createSecondWorkspaceOnSameDir(seeded, "Independent view");
+
+      // Open workspace A and materialize a terminal tab.
+      await gotoWorkspace(page, seeded.workspaceId);
+      await clickNewTerminal(page);
+      await clickFirstTerminalTab(page);
+
+      // Workspace B shares the directory but owns its own tabs: it has no
+      // terminal tab, because the terminal belongs to A.
+      await gotoWorkspace(page, secondWorkspaceId);
+      await expectNoTerminalTabs(page);
+
+      // Back in A, the terminal is still there — B never absorbed it.
+      await gotoWorkspace(page, seeded.workspaceId);
+      await clickFirstTerminalTab(page);
+    } finally {
+      await seeded.cleanup();
+    }
+  });
+});
@@ -0,0 +1,174 @@
+import { test, expect, type Page } from "./fixtures";
+import { gotoAppShell } from "./helpers/app";
+import { gotoWorkspace, clickNewTerminal } from "./helpers/launcher";
+import { seedWorkspace, type SeededWorkspace } from "./helpers/seed-client";
+import { seedMockAgentWorkspace } from "./helpers/mock-agent";
+import { getServerId } from "./helpers/server-id";
+import { waitForSidebarHydration } from "./helpers/workspace-ui";
+import { getVisibleWorkspaceAgentTabIds } from "./helpers/workspace-tabs";
+
+// Model B sidebar shape: every project — git or non-git, single- or
+// multi-workspace — renders as the same expandable parent, the deepest sidebar
+// level is the workspace row, and tabs/agents/terminals NEVER appear in the
+// sidebar. These specs prove all three invariants end to end.
+
+function workspaceRow(page: Page, workspaceId: string) {
+  return page.getByTestId(`sidebar-workspace-row-${getServerId()}:${workspaceId}`);
+}
+
+function projectRow(page: Page, projectKey: string) {
+  return page.getByTestId(`sidebar-project-row-${projectKey}`);
+}
+
+function projectNewWorktreeIcon(page: Page, projectKey: string) {
+  return page.getByTestId(`sidebar-project-new-worktree-${projectKey}`);
+}
+
+async function seedSecondWorkspace(seeded: SeededWorkspace, title: string): Promise<string> {
+  const created = await seeded.client.createWorkspace({
+    backing: "local",
+    cwd: seeded.repoPath,
+    projectId: seeded.projectId,
+    title,
+  });
+  if (!created.workspace) {
+    throw new Error(created.error ?? `Failed to create second workspace for ${seeded.projectId}`);
+  }
+  return created.workspace.id;
+}
+
+test.describe("Model B sidebar shape", () => {
+  test.describe.configure({ timeout: 180_000 });
+
+  test("git and non-git projects both render as expandable parents; git keeps a per-row new-worktree icon, the global button covers both", async ({
+    page,
+  }) => {
+    const gitProject = await seedWorkspace({ repoPrefix: "model-b-git-" });
+    const nonGitProject = await seedWorkspace({ repoPrefix: "model-b-nongit-", git: false });
+
+    try {
+      const gitSecondId = await seedSecondWorkspace(gitProject, "Git second");
+      const nonGitSecondId = await seedSecondWorkspace(nonGitProject, "Non-git second");
+
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+
+      // Both projects are expandable parents — the non-git one is NOT flattened
+      // into a bare workspace link.
+      await expect(projectRow(page, gitProject.projectId)).toBeVisible({ timeout: 30_000 });
+      await expect(projectRow(page, nonGitProject.projectId)).toBeVisible({ timeout: 30_000 });
+
+      // Each parent shows both of its workspace rows underneath.
+      await expect(workspaceRow(page, gitProject.workspaceId)).toBeVisible({ timeout: 30_000 });
+      await expect(workspaceRow(page, gitSecondId)).toBeVisible({ timeout: 30_000 });
+      await expect(workspaceRow(page, nonGitProject.workspaceId)).toBeVisible({ timeout: 30_000 });
+      await expect(workspaceRow(page, nonGitSecondId)).toBeVisible({ timeout: 30_000 });
+
+      // The per-project "+ New workspace" row is gone. The git project keeps a
+      // per-row new-worktree icon (revealed on hover); the non-git project has
+      // none, since worktree creation needs a git checkout.
+      await projectRow(page, gitProject.projectId).hover();
+      await expect(projectNewWorktreeIcon(page, gitProject.projectId)).toBeVisible({
+        timeout: 30_000,
+      });
+      await expect(projectNewWorktreeIcon(page, nonGitProject.projectId)).toHaveCount(0);
+
+      // The global new-workspace button is the universal entry — present for both
+      // kinds regardless of their per-row affordance.
+      await expect(page.getByTestId("sidebar-global-new-workspace")).toBeVisible({
+        timeout: 30_000,
+      });
+    } finally {
+      await gitProject.cleanup();
+      await nonGitProject.cleanup();
+    }
+  });
+
+  test("no tab, agent, or terminal ever renders as a sidebar row", async ({ page }) => {
+    const mock = await seedMockAgentWorkspace({
+      repoPrefix: "model-b-leaf-",
+      title: "Leaf workspace",
+    });
+
+    try {
+      // Open the workspace and materialize both an agent tab and a terminal tab.
+      await gotoWorkspace(page, mock.workspaceId);
+      const agentTabs = await getVisibleWorkspaceAgentTabIds(page);
+      expect(agentTabs).toContain(`workspace-tab-agent_${mock.agentId}`);
+
+      await clickNewTerminal(page);
+      await expect(
+        page.locator('[data-testid^="workspace-tab-terminal_"]').filter({ visible: true }).first(),
+      ).toBeVisible({ timeout: 30_000 });
+
+      // The deepest level inside the sidebar is the workspace row: no tab,
+      // agent, or terminal element appears as a sidebar descendant.
+      const sidebar = page.getByTestId("sidebar-sessions").filter({ visible: true }).first();
+      await expect(workspaceRow(page, mock.workspaceId).first()).toBeVisible({ timeout: 30_000 });
+      await expect(sidebar.locator('[data-testid^="workspace-tab-"]')).toHaveCount(0);
+      await expect(sidebar.locator('[data-testid^="sidebar-agent-row-"]')).toHaveCount(0);
+      await expect(sidebar.locator('[data-testid^="sidebar-terminal-row-"]')).toHaveCount(0);
+    } finally {
+      await mock.cleanup();
+    }
+  });
+
+  test("status grouping shows only workspace rows and moves a single row when its status changes", async ({
+    page,
+  }) => {
+    const idleProject = await seedWorkspace({ repoPrefix: "model-b-status-idle-" });
+    const activeMock = await seedMockAgentWorkspace({
+      repoPrefix: "model-b-status-active-",
+      title: "Working workspace",
+      initialPrompt: "stay busy",
+    });
+
+    try {
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await expect(workspaceRow(page, idleProject.workspaceId)).toBeVisible({ timeout: 30_000 });
+
+      // Switch to status grouping.
+      await page.getByTestId("sidebar-grouping-selector").click();
+      await page.getByTestId("sidebar-grouping-status").click();
+
+      const sidebar = page.getByTestId("sidebar-sessions").filter({ visible: true }).first();
+
+      // The idle workspace lands in the Done bucket; the busy mock-agent workspace
+      // lands in the Working bucket. Each workspace is bucketed independently.
+      await expect(page.getByTestId("sidebar-status-group-done")).toBeVisible({ timeout: 30_000 });
+      await expect(page.getByTestId("sidebar-status-group-running")).toBeVisible({
+        timeout: 60_000,
+      });
+      await expect(workspaceRow(page, idleProject.workspaceId).first()).toBeVisible({
+        timeout: 30_000,
+      });
+      await expect(workspaceRow(page, activeMock.workspaceId).first()).toBeVisible({
+        timeout: 60_000,
+      });
+
+      // Only workspace rows are shown — no tab/agent/terminal leaves leak into
+      // the status view.
+      await expect(sidebar.locator('[data-testid^="workspace-tab-"]')).toHaveCount(0);
+
+      // The busy workspace is grouped under Working, the idle one under Done:
+      // changing one workspace's status moved only that row.
+      const workingRows = page.getByTestId("sidebar-status-group-rows-running");
+      const doneRows = page.getByTestId("sidebar-status-group-rows-done");
+      await expect(
+        workingRows.getByTestId(`sidebar-workspace-row-${getServerId()}:${activeMock.workspaceId}`),
+      ).toBeVisible({ timeout: 60_000 });
+      await expect(
+        doneRows.getByTestId(`sidebar-workspace-row-${getServerId()}:${idleProject.workspaceId}`),
+      ).toBeVisible({ timeout: 30_000 });
+      // The busy workspace is NOT also sitting in the Done bucket — only its own
+      // row moved.
+      await expect(
+        doneRows.getByTestId(`sidebar-workspace-row-${getServerId()}:${activeMock.workspaceId}`),
+      ).toHaveCount(0);
+    } finally {
+      await idleProject.cleanup();
+      await activeMock.cleanup();
+    }
+  });
+});
@@ -1,8 +1,6 @@
-import { execSync } from "node:child_process";
 import { test, expect, type Page } from "./fixtures";
 import { gotoAppShell } from "./helpers/app";
 import { seedWorkspace } from "./helpers/seed-client";
-import { captureWsSessionFrames } from "./helpers/rename";
 import { getServerId } from "./helpers/server-id";

 function workspaceRowTestId(workspaceId: string): string {
@@ -32,24 +30,16 @@ async function openRenameModal(page: Page, workspaceId: string) {
  return input;
 }

+// In Model B the workspace title is its identity: renaming sets a custom title
+// layered over the derived branch/directory name, and reconciliation never
+// touches it. The sidebar row shows the title verbatim — no branch mutation.
 test.describe("Sidebar workspace rename", () => {
-  test("renaming via kebab updates the branch name on disk and in the sidebar", async ({
-    page,
-  }) => {
+  test("renaming via kebab sets a custom title that survives reload", async ({ page }) => {
    const workspace = await seedWorkspace({ repoPrefix: "sidebar-rename-" });

    try {
      expect(workspace.workspaceName).toBe("main");

-      const renameRequests = captureWsSessionFrames(
-        page,
-        "checkout.rename_branch.request",
-        (inner) => ({
-          branch: String(inner.branch ?? ""),
-          cwd: String(inner.cwd ?? ""),
-        }),
-      );
-
      await gotoAppShell(page);
      await expect(page.getByTestId(workspaceRowTestId(workspace.workspaceId))).toBeVisible({
        timeout: 30_000,
@@ -57,56 +47,26 @@ test.describe("Sidebar workspace rename", () => {

      const input = await openRenameModal(page, workspace.workspaceId);
      await expect(input).toHaveValue("main");
-      await input.fill("Feature Rename 2");

+      const customTitle = "Payments Refactor";
+      await input.fill(customTitle);
      await page.getByTestId(workspaceRenameModalTestId(workspace.workspaceId, "submit")).click();

      await expect(input).toHaveCount(0, { timeout: 15_000 });
+      // The title is shown exactly as typed — not slugified into a branch name.
      await expect(page.getByTestId(workspaceRowTestId(workspace.workspaceId))).toContainText(
-        "feature-rename-2",
+        customTitle,
        { timeout: 15_000 },
      );

-      expect(renameRequests.length).toBeGreaterThan(0);
-      expect(renameRequests.at(-1)).toEqual({
-        branch: "feature-rename-2",
-        cwd: workspace.workspaceDirectory,
-      });
-
-      const currentBranchOnDisk = execSync("git branch --show-current", {
-        cwd: workspace.repoPath,
-        stdio: "pipe",
-      })
-        .toString()
-        .trim();
-      expect(currentBranchOnDisk).toBe("feature-rename-2");
-    } finally {
-      await workspace.cleanup();
-    }
-  });
-
-  test("rename surfaces server errors inline and keeps the modal open", async ({ page }) => {
-    const workspace = await seedWorkspace({
-      repoPrefix: "sidebar-rename-error-",
-      repo: { branches: ["taken"] },
-    });
-
-    try {
-      await gotoAppShell(page);
-      const input = await openRenameModal(page, workspace.workspaceId);
-      await expect(input).toHaveValue("main");
-
-      await input.fill("taken");
-      await page.getByTestId(workspaceRenameModalTestId(workspace.workspaceId, "submit")).click();
-
-      const errorNode = page.getByTestId(
-        workspaceRenameModalTestId(workspace.workspaceId, "error"),
-      );
-      await expect(errorNode).toBeVisible({ timeout: 15_000 });
-      await expect(errorNode).toContainText(/already exists|branch/i);
-      await expect(input).toBeVisible();
+      // The custom title is backing metadata on the workspace: a full reload
+      // re-resolves the descriptor from persistence and must not lose it. This
+      // exercises the same descriptor resolution reconciliation re-runs against,
+      // so a reconcile pass cannot overwrite the user's title either.
+      await page.reload();
      await expect(page.getByTestId(workspaceRowTestId(workspace.workspaceId))).toContainText(
-        "main",
+        customTitle,
+        { timeout: 30_000 },
      );
    } finally {
      await workspace.cleanup();
@@ -0,0 +1,226 @@
+import { test, expect, type Page } from "./fixtures";
+import { gotoAppShell } from "./helpers/app";
+import { gotoWorkspace } from "./helpers/launcher";
+import {
+  assertNewWorkspaceSidebarAndHeader,
+  connectNewWorkspaceDaemonClient,
+  openGlobalNewWorkspaceComposer,
+  selectNewWorkspaceProject,
+  selectWorkspaceBacking,
+  submitNewWorkspaceEmpty,
+} from "./helpers/new-workspace";
+import { seedWorkspace, type SeededWorkspace } from "./helpers/seed-client";
+import { expectExplorerEntryVisible } from "./helpers/file-explorer";
+import { getServerId } from "./helpers/server-id";
+import { waitForSidebarHydration } from "./helpers/workspace-ui";
+
+// Model B reshape: a workspace is the unit, its backing directory (local
+// checkout or worktree) is a CHOICE at creation, and creation NEVER dedupes by
+// directory. These specs drive the real creation UI (workspace-create-* test
+// IDs) to prove a single directory can back any number of workspaces.
+
+function workspaceRowTestId(workspaceId: string): string {
+  return `sidebar-workspace-row-${getServerId()}:${workspaceId}`;
+}
+
+// On desktop the file explorer is pinned open; on narrower layouts it must be
+// toggled first. Open it either way, then select the Files tab.
+async function openFilesTab(page: Page): Promise<void> {
+  const openButton = page.getByRole("button", { name: "Open explorer" }).first();
+  if (await openButton.isVisible().catch(() => false)) {
+    await openButton.click();
+  }
+  await page.getByTestId("explorer-tab-files").click();
+  await expect(page.getByTestId("file-explorer-tree-scroll")).toBeVisible({ timeout: 30_000 });
+}
+
+async function createWorkspaceViaUi(
+  page: Page,
+  input: {
+    project: { projectKey: string; projectDisplayName: string };
+    // null when the project has no git checkout: there is no Isolation control to
+    // touch, the backing is implicitly local.
+    backing: "local" | "worktree" | null;
+    previousWorkspaceId: string;
+    client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
+  },
+): Promise<{ workspaceId: string; workspaceName: string; workspaceDirectory: string }> {
+  await openGlobalNewWorkspaceComposer(page);
+  await selectNewWorkspaceProject(page, input.project);
+  if (input.backing !== null) {
+    await selectWorkspaceBacking(page, input.backing);
+  }
+  await submitNewWorkspaceEmpty(page);
+
+  return assertNewWorkspaceSidebarAndHeader(page, {
+    serverId: getServerId(),
+    client: input.client,
+    previousWorkspaceId: input.previousWorkspaceId,
+    projectDisplayName: input.project.projectDisplayName,
+    assertSidebarRow: false,
+    assertHeader: false,
+  });
+}
+
+test.describe("Workspace multiplicity creation flow", () => {
+  let client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
+
+  test.describe.configure({ timeout: 240_000 });
+
+  test.beforeEach(async () => {
+    client = await connectNewWorkspaceDaemonClient();
+  });
+
+  test.afterEach(async () => {
+    await client?.close().catch(() => undefined);
+  });
+
+  test("two Local workspaces share one git checkout and both are independently selectable", async ({
+    page,
+  }) => {
+    const seeded: SeededWorkspace = await seedWorkspace({
+      repoPrefix: "multiplicity-local-git-",
+    });
+
+    try {
+      const project = {
+        projectKey: seeded.projectId,
+        projectDisplayName: seeded.projectDisplayName,
+      };
+
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await expect(page.getByTestId(workspaceRowTestId(seeded.workspaceId))).toBeVisible({
+        timeout: 30_000,
+      });
+
+      const second = await createWorkspaceViaUi(page, {
+        project,
+        backing: "local",
+        previousWorkspaceId: seeded.workspaceId,
+        client,
+      });
+
+      // A second workspace was minted on the SAME checkout — creation did not
+      // dedupe the directory away.
+      expect(second.workspaceId).not.toBe(seeded.workspaceId);
+      expect(second.workspaceDirectory).toBe(seeded.workspaceDirectory);
+
+      // Both rows live under the same project and are distinct.
+      const firstRow = page.getByTestId(workspaceRowTestId(seeded.workspaceId));
+      const secondRow = page.getByTestId(workspaceRowTestId(second.workspaceId));
+      await expect(firstRow).toBeVisible({ timeout: 30_000 });
+      await expect(secondRow).toBeVisible({ timeout: 30_000 });
+      await expect(secondRow).toContainText(second.workspaceName);
+
+      // Selecting the second workspace shows the shared checkout's files.
+      await gotoWorkspace(page, second.workspaceId);
+      await openFilesTab(page);
+      await expectExplorerEntryVisible(page, "README.md");
+
+      // Selecting the first workspace shows the SAME shared directory data.
+      await gotoWorkspace(page, seeded.workspaceId);
+      await openFilesTab(page);
+      await expectExplorerEntryVisible(page, "README.md");
+    } finally {
+      await seeded.cleanup();
+    }
+  });
+
+  test("New worktree backing creates a worktree-backed workspace in a distinct directory", async ({
+    page,
+  }) => {
+    const seeded: SeededWorkspace = await seedWorkspace({
+      repoPrefix: "multiplicity-worktree-",
+    });
+
+    try {
+      const project = {
+        projectKey: seeded.projectId,
+        projectDisplayName: seeded.projectDisplayName,
+      };
+
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      await expect(page.getByTestId(workspaceRowTestId(seeded.workspaceId))).toBeVisible({
+        timeout: 30_000,
+      });
+
+      const worktree = await createWorkspaceViaUi(page, {
+        project,
+        backing: "worktree",
+        previousWorkspaceId: seeded.workspaceId,
+        client,
+      });
+
+      // The worktree row appears, pointing at a directory distinct from the
+      // backing checkout.
+      const worktreeRow = page.getByTestId(workspaceRowTestId(worktree.workspaceId));
+      await expect(worktreeRow).toBeVisible({ timeout: 30_000 });
+      expect(worktree.workspaceId).not.toBe(seeded.workspaceId);
+      expect(worktree.workspaceDirectory).not.toBe(seeded.workspaceDirectory);
+
+      // The daemon descriptor confirms the worktree kind (○ row).
+      const descriptor = (await client.fetchWorkspaces()).entries.find(
+        (entry) => entry.id === worktree.workspaceId,
+      );
+      expect(descriptor?.workspaceKind).toBe("worktree");
+
+      await client
+        .archivePaseoWorktree({ worktreePath: worktree.workspaceDirectory })
+        .catch(() => undefined);
+    } finally {
+      await seeded.cleanup();
+    }
+  });
+
+  test("two Local workspaces appear under the same non-git project", async ({ page }) => {
+    const seeded: SeededWorkspace = await seedWorkspace({
+      repoPrefix: "multiplicity-local-nongit-",
+      git: false,
+    });
+
+    try {
+      const project = {
+        projectKey: seeded.projectId,
+        projectDisplayName: seeded.projectDisplayName,
+      };
+
+      await gotoAppShell(page);
+      await waitForSidebarHydration(page);
+      // Model B: a non-git project is an expandable parent like any other, with
+      // its single workspace already rendered as its own row underneath.
+      await expect(page.getByTestId(`sidebar-project-row-${seeded.projectId}`)).toBeVisible({
+        timeout: 30_000,
+      });
+      await expect(page.getByTestId(workspaceRowTestId(seeded.workspaceId))).toBeVisible({
+        timeout: 30_000,
+      });
+
+      const second = await createWorkspaceViaUi(page, {
+        project,
+        // Non-git project: no Isolation control, backing is implicitly local.
+        backing: null,
+        previousWorkspaceId: seeded.workspaceId,
+        client,
+      });
+
+      expect(second.workspaceId).not.toBe(seeded.workspaceId);
+      expect(second.workspaceDirectory).toBe(seeded.workspaceDirectory);
+
+      // Both the original and the new workspace render as distinct rows under
+      // the same expandable parent.
+      await expect(page.getByTestId(`sidebar-project-row-${seeded.projectId}`)).toBeVisible({
+        timeout: 30_000,
+      });
+      await expect(page.getByTestId(workspaceRowTestId(seeded.workspaceId))).toBeVisible({
+        timeout: 30_000,
+      });
+      const secondRow = page.getByTestId(workspaceRowTestId(second.workspaceId));
+      await expect(secondRow).toBeVisible({ timeout: 30_000 });
+      await expect(secondRow).toContainText(second.workspaceName);
+    } finally {
+      await seeded.cleanup();
+    }
+  });
+});
@@ -0,0 +1,69 @@
+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 { expectWorkspaceAbsentFromSidebar, openWorktreeDeletePrompt } from "./helpers/sidebar";
+import { createTempGitRepo } from "./helpers/workspace";
+import { waitForSidebarHydration, waitForWorkspaceInSidebar } from "./helpers/workspace-ui";
+
+// Model B: archiving the LAST reference to a Paseo-owned worktree opens the
+// keep/delete prompt. Choosing "Keep on disk" archives the workspace record (the
+// row disappears) but leaves the worktree directory on disk, because a directory
+// can back multiple workspaces and archive removes the task, not the directory.
+test.describe("Worktree archive keep prompt", () => {
+  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-keep-");
+  });
+
+  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("keeping a last-reference worktree on disk removes the row but preserves the directory", async ({
+    page,
+  }) => {
+    const serverId = getServerId();
+    await openProjectViaDaemon(client, tempRepo.path);
+    const worktree = await createWorktreeViaDaemon(client, {
+      cwd: tempRepo.path,
+      slug: `archive-keep-${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 openWorktreeDeletePrompt(page, worktree.workspaceId);
+    await page.getByTestId("worktree-delete-confirm-keep").click();
+
+    await expectWorkspaceAbsentFromSidebar(page, worktree.workspaceId);
+
+    // The row is gone, but keeping on disk leaves the worktree directory in place
+    // and the git worktree still registered with the repo.
+    expect(existsSync(worktree.workspaceDirectory)).toBe(true);
+    const listed = await client.getPaseoWorktreeList({ cwd: tempRepo.path });
+    expect(
+      listed.worktrees.some((entry) => entry.worktreePath === worktree.workspaceDirectory),
+    ).toBe(true);
+  });
+});