Keep registered worktree projects separate

Author: friuns

src/composables/useDesktopState.test.ts

@@ -162,7 +162,7 @@ describe('filterGroupsByWorkspaceRoots', () => {
     ])
   })
 
-  it('keeps managed Codex worktrees under the main root even when a worktree root is registered', () => {
+  it('keeps unregistered managed worktrees under the main root when another managed worktree root is registered', () => {
     const groups: UiProjectGroup[] = [
       {
         projectName: 'codex-web-local',
@@ -186,28 +186,8 @@ describe('filterGroupsByWorkspaceRoots', () => {
     }
 
     expect(filterGroupsByWorkspaceRoots(groups, rootsState).map((group) => [group.projectName, group.threads.map((row) => row.id)])).toEqual([
-      ['/Users/igor/Git-projects/codex-web-local', ['main-chat', 'registered-worktree-chat', 'unregistered-worktree-chat']],
-    ])
-  })
-
-  it('keeps a managed Codex worktree root visible when no canonical root exists', () => {
-    const groups: UiProjectGroup[] = [
-      {
-        projectName: 'codex-web-local',
-        threads: [
-          thread('worktree-chat', '/Users/igor/.codex/worktrees/a77f/codex-web-local', { hasWorktree: true }),
-        ],
-      },
-    ]
-    const rootsState: WorkspaceRootsState = {
-      order: ['/Users/igor/.codex/worktrees/a77f/codex-web-local'],
-      labels: {},
-      active: ['/Users/igor/.codex/worktrees/a77f/codex-web-local'],
-      projectOrder: ['/Users/igor/.codex/worktrees/a77f/codex-web-local'],
-    }
-
-    expect(filterGroupsByWorkspaceRoots(groups, rootsState).map((group) => [group.projectName, group.threads.map((row) => row.id)])).toEqual([
-      ['codex-web-local', ['worktree-chat']],
+      ['/Users/igor/Git-projects/codex-web-local', ['main-chat', 'unregistered-worktree-chat']],
+      ['/Users/igor/.codex/worktrees/a77f/codex-web-local', ['registered-worktree-chat']],
     ])
   })
 

src/composables/useDesktopState.ts

@@ -998,35 +998,17 @@ function getWorkspaceProjectOrderPaths(rootsState: WorkspaceRootsState | null):
   return orderedRoots
 }
 
-function hasCanonicalWorkspaceRootForManagedWorktree(rootPath: string, rootsState: WorkspaceRootsState | null): boolean {
-  const normalizedRootPath = normalizePathForUi(rootPath).trim()
-  if (!isManagedCodexWorktreePath(normalizedRootPath)) return false
-  const leafName = toProjectNameFromWorkspaceRoot(normalizedRootPath)
-  return (rootsState?.order ?? []).some((candidate) => {
-    const normalizedCandidate = normalizePathForUi(candidate).trim()
-    return normalizedCandidate.length > 0
-      && !isManagedCodexWorktreePath(normalizedCandidate)
-      && toProjectNameFromWorkspaceRoot(normalizedCandidate) === leafName
-  })
-}
-
 function getWorkspaceProjectOrderNames(
   rootsState: WorkspaceRootsState | null,
   duplicateLeafNames: Set<string>,
 ): string[] {
   const remoteProjectsById = getRemoteProjectById(rootsState)
-  const names: string[] = []
-  for (const rootPath of getWorkspaceProjectOrderPaths(rootsState)) {
-    if (remoteProjectsById.has(rootPath)) {
-      names.push(rootPath)
-      continue
-    }
-    if (hasCanonicalWorkspaceRootForManagedWorktree(rootPath, rootsState)) continue
+  return getWorkspaceProjectOrderPaths(rootsState).map((rootPath) => {
+    if (remoteProjectsById.has(rootPath)) return rootPath
     const normalizedRootPath = normalizePathForUi(rootPath).trim()
     const leafName = toProjectNameFromWorkspaceRoot(normalizedRootPath)
-    names.push(duplicateLeafNames.has(leafName) ? normalizedRootPath : leafName)
-  }
-  return names
+    return duplicateLeafNames.has(leafName) ? normalizedRootPath : leafName
+  })
 }
 
 function matchesWorkspaceRootProject(rootPath: string, projectName: string): boolean {
@@ -1185,9 +1167,11 @@ function disambiguateProjectGroupsByCwd(
   const uniqueCanonicalWorkspaceRootLeafNames = new Set<string>()
   const duplicateCanonicalWorkspaceRootLeafNames = new Set<string>()
   const canonicalWorkspaceRootByLeafName = new Map<string, string>()
+  const registeredWorkspaceRoots = new Set<string>()
   for (const rootPath of rootsState?.order ?? []) {
     const normalizedRootPath = normalizePathForUi(rootPath).trim()
     if (!normalizedRootPath) continue
+    registeredWorkspaceRoots.add(normalizedRootPath)
     if (isManagedCodexWorktreePath(normalizedRootPath)) continue
     const leafName = toProjectName(normalizedRootPath)
     if (uniqueCanonicalWorkspaceRootLeafNames.has(leafName)) {
@@ -1206,7 +1190,9 @@ function disambiguateProjectGroupsByCwd(
     for (const thread of group.threads) {
       const normalizedCwd = normalizePathForUi(thread.cwd).trim()
       const leafName = toProjectName(normalizedCwd)
+      const isRegisteredRoot = registeredWorkspaceRoots.has(normalizedCwd)
       const isCanonicalWorktreeThread = isManagedCodexWorktreePath(normalizedCwd)
+        && !isRegisteredRoot
         && uniqueCanonicalWorkspaceRootLeafNames.has(leafName)
       let projectName = group.projectName
       if (isCanonicalWorktreeThread && duplicateLeafNames.has(leafName)) {
@@ -1248,7 +1234,6 @@ function addWorkspaceRootPlaceholderGroups(
     }
     const normalizedRootPath = normalizePathForUi(rootPath).trim()
     if (!normalizedRootPath) continue
-    if (hasCanonicalWorkspaceRootForManagedWorktree(normalizedRootPath, rootsState)) continue
     const leafName = toProjectNameFromWorkspaceRoot(normalizedRootPath)
     const projectName = duplicateLeafNames.has(leafName) ? normalizedRootPath : leafName
     if (existingProjectNames.has(projectName)) continue

tests.md

@@ -4149,30 +4149,27 @@ Composer runtime options and project menu worktree actions are hidden when the s
 ### Project worktree threads under canonical project
 
 #### Feature/Change Name
-Managed worktree threads remain visible under their matching canonical workspace-root project, and registered managed worktree roots do not appear as separate empty projects when the canonical root exists.
+Managed worktree threads remain visible under their matching canonical workspace-root project, and path-like project tooltips expose the full path.
 
 #### Prerequisites/Setup
 1. Dev server running (`pnpm run dev`)
 2. Codex global workspace roots include `/Users/igor/Git-projects/codex-web-local`
 3. Thread history contains at least one thread whose cwd is under `/Users/igor/.codex/worktrees/*/codex-web-local`
-4. Optional: Codex global workspace roots include a registered worktree root such as `/Users/igor/.codex/worktrees/a77f/codex-web-local`
-5. Light theme and dark theme both available from the appearance switcher
+4. Light theme and dark theme both available from the appearance switcher
 
 #### Steps
 1. In light theme, open the sidebar Projects section.
 2. Scroll to the `codex-web-local` project.
 3. Confirm the project includes the main-root thread and managed worktree threads.
 4. Confirm worktree rows still show the worktree icon.
-5. Confirm a registered managed worktree root with the same leaf folder name does not appear as a separate empty project such as `codex-web-local2 a77f`.
-6. Confirm unrelated `.git/worktrees` rows with the same leaf folder name are not grouped into this project.
-7. Hover any shortened path-like duplicate project title and confirm the tooltip shows the full project path, not only the friendly label.
-8. Switch to dark theme and repeat steps 1-7.
+5. Confirm unrelated `.git/worktrees` rows with the same leaf folder name are not grouped into this project.
+6. Hover any shortened path-like duplicate project title and confirm the tooltip shows the full project path, not only the friendly label.
+7. Switch to dark theme and repeat steps 1-6.
 
 #### Expected Results
 - Managed worktree threads with the same leaf folder name are not split into hidden path-like project groups.
 - Generic `.git/worktrees` rows are not treated as managed Codex worktrees for project-root grouping.
 - The canonical `codex-web-local` project shows both main-root and worktree threads.
-- Registered managed Codex worktree roots are suppressed as standalone empty groups when the canonical workspace root is also registered.
 - Path-like project tooltips expose the full project path.
 - Project rows and worktree icons remain readable in light and dark themes.