infra-kit 0.1.111 → 0.1.114

package/src/integrations/cursor/open-cursor-workspace.ts

@@ -0,0 +1,69 @@
+import { logger } from 'src/lib/logger'
+
+import { launchCursor } from './launch-cursor'
+import { reconcileCursorWorkspaceFolders } from './reconcile-workspace-folders'
+import { resolveCursorWorkspacePath } from './resolve-workspace-path'
+
+interface OpenCursorWorkspaceArgs {
+  projectRoot: string
+  worktreeDir: string
+  currentBranches: string[]
+  /**
+   * When true, skip the `cursor <workspace>` relaunch if there are no release
+   * worktrees (folder reconcile still runs to strip dangling entries). Lets
+   * `worktrees-reload` avoid popping an empty Cursor window while keeping the
+   * cold-start `worktrees-open` behaviour (relaunch unconditionally) intact.
+   */
+  skipRelaunchWhenEmpty: boolean
+  /**
+   * The Cursor entry's config, selected by the facade from the (possibly
+   * multi-IDE) infra-kit config. Passed in rather than re-read here so this
+   * opener acts on the exact entry the caller chose — essential once `ide` can
+   * be an array of providers.
+   */
+  cursorConfig: { workspaceConfigPath: string }
+}
+
+interface OpenCursorWorkspaceOutcome {
+  ran: boolean
+  added: number
+  removed: number
+}
+
+/**
+ * Reconciles the configured Cursor `.code-workspace` `folders` array against the
+ * set of release worktrees on disk, then launches Cursor against it. Shared by
+ * `worktrees-open` (cold-start restore) and `worktrees-reload` (close + reopen).
+ *
+ * No-ops (returns `ran: false`) when the Cursor entry has no `workspaceConfigPath`.
+ * All failures are swallowed into a warning — opening Cursor is best-effort.
+ */
+export const openCursorWorkspace = async (args: OpenCursorWorkspaceArgs): Promise<OpenCursorWorkspaceOutcome> => {
+  const { projectRoot, worktreeDir, currentBranches, skipRelaunchWhenEmpty, cursorConfig } = args
+
+  if (!cursorConfig.workspaceConfigPath) {
+    logger.warn('⚠️ Skipping Cursor: workspaceConfigPath is not set.')
+
+    return { ran: false, added: 0, removed: 0 }
+  }
+
+  const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
+
+  try {
+    const { added, removed } = await reconcileCursorWorkspaceFolders({
+      workspacePath,
+      worktreeDir,
+      currentBranches,
+    })
+
+    if (!(skipRelaunchWhenEmpty && currentBranches.length === 0)) {
+      await launchCursor(workspacePath)
+    }
+
+    return { ran: true, added: added.length, removed: removed.length }
+  } catch (error) {
+    logger.warn({ error }, `⚠️ Failed to reconcile/open Cursor workspace at ${workspacePath}`)
+
+    return { ran: false, added: 0, removed: 0 }
+  }
+}

package/src/integrations/ide/__tests__/ide-facade.test.ts

@@ -0,0 +1,250 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { addIdeWorktreeFolders } from '../add-ide-worktree-folders'
+import { openIdeWorkspace } from '../open-ide-workspace'
+import { removeIdeWorktreeFolders } from '../remove-ide-worktree-folders'
+
+const config = vi.hoisted(() => {
+  return { value: {} as { ide?: unknown } }
+})
+
+vi.mock('src/lib/infra-kit-config', () => {
+  return {
+    getInfraKitConfig: vi.fn(() => {
+      return Promise.resolve(config.value)
+    }),
+    // Mirror the real normalizer (single → [ide], array → as-is, undefined → []).
+    resolveConfiguredIdes: vi.fn((cfg: { ide?: unknown }) => {
+      const ide = cfg.ide
+
+      if (!ide) return []
+
+      return Array.isArray(ide) ? ide : [ide]
+    }),
+  }
+})
+
+vi.mock('src/lib/logger', () => {
+  return { logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() } }
+})
+
+const cursor = vi.hoisted(() => {
+  return {
+    openCursorWorkspace: vi.fn(),
+    addFoldersToCursorWorkspace: vi.fn(),
+    removeFoldersFromCursorWorkspace: vi.fn(),
+    launchCursor: vi.fn(),
+    resolveCursorWorkspacePath: vi.fn((value: string) => {
+      return `/abs/${value}`
+    }),
+  }
+})
+
+vi.mock('src/integrations/cursor', () => {
+  return cursor
+})
+
+// Defense-in-depth: never let a test shell out to a real editor. Even if an
+// editor spawn leaks back into a layer this suite exercises directly, `$` is a
+// no-op here so `cursor <path>` can never open a real window during the run.
+vi.mock('zx', () => {
+  return { $: vi.fn() }
+})
+
+const zed = vi.hoisted(() => {
+  return {
+    openZedWorkspace: vi.fn(),
+    addFoldersToZedWorkspace: vi.fn(),
+  }
+})
+
+vi.mock('src/integrations/zed', () => {
+  return zed
+})
+
+const cursorEntry = { provider: 'cursor', config: { workspaceConfigPath: 'ws' } }
+const zedEntry = { provider: 'zed', config: {} }
+const cursorConfig = { ide: cursorEntry }
+const zedConfig = { ide: zedEntry }
+const bothConfig = { ide: [cursorEntry, zedEntry] }
+const unconfigured = { ide: undefined }
+
+const baseOpenArgs = {
+  projectRoot: '/repo',
+  worktreeDir: '/repo.worktrees',
+  currentBranches: ['release/v1.0.0'],
+  skipRelaunchWhenEmpty: false,
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  cursor.resolveCursorWorkspacePath.mockImplementation((value: string) => {
+    return `/abs/${value}`
+  })
+})
+
+describe('openIdeWorkspace', () => {
+  it('routes to Cursor and tags the provider (passing the cursor config down)', async () => {
+    config.value = cursorConfig
+    cursor.openCursorWorkspace.mockResolvedValue({ ran: true, added: 1, removed: 0 })
+
+    const outcomes = await openIdeWorkspace(baseOpenArgs)
+
+    expect(cursor.openCursorWorkspace).toHaveBeenCalledWith({
+      ...baseOpenArgs,
+      cursorConfig: { workspaceConfigPath: 'ws' },
+    })
+    expect(zed.openZedWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([{ ran: true, added: 1, removed: 0, provider: 'cursor' }])
+  })
+
+  it('routes to Zed and tags the provider', async () => {
+    config.value = zedConfig
+    zed.openZedWorkspace.mockResolvedValue({ ran: true, added: 2, removed: 0 })
+
+    const outcomes = await openIdeWorkspace(baseOpenArgs)
+
+    expect(zed.openZedWorkspace).toHaveBeenCalledWith(baseOpenArgs)
+    expect(cursor.openCursorWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([{ ran: true, added: 2, removed: 0, provider: 'zed' }])
+  })
+
+  it('opens BOTH editors when both are configured (one outcome per provider)', async () => {
+    config.value = bothConfig
+    cursor.openCursorWorkspace.mockResolvedValue({ ran: true, added: 1, removed: 0 })
+    zed.openZedWorkspace.mockResolvedValue({ ran: true, added: 2, removed: 0 })
+
+    const outcomes = await openIdeWorkspace(baseOpenArgs)
+
+    expect(cursor.openCursorWorkspace).toHaveBeenCalledTimes(1)
+    expect(zed.openZedWorkspace).toHaveBeenCalledTimes(1)
+    expect(outcomes).toEqual([
+      { ran: true, added: 1, removed: 0, provider: 'cursor' },
+      { ran: true, added: 2, removed: 0, provider: 'zed' },
+    ])
+  })
+
+  it('returns an empty array when no IDE is configured', async () => {
+    config.value = unconfigured
+
+    const outcomes = await openIdeWorkspace(baseOpenArgs)
+
+    expect(cursor.openCursorWorkspace).not.toHaveBeenCalled()
+    expect(zed.openZedWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([])
+  })
+})
+
+describe('addIdeWorktreeFolders', () => {
+  const args = { projectRoot: '/repo', worktreeDir: '/repo.worktrees', branches: ['release/v1.0.0'] }
+
+  it('adds to the Cursor workspace and reports skipped', async () => {
+    config.value = cursorConfig
+    cursor.addFoldersToCursorWorkspace.mockResolvedValue({ added: ['a'], skipped: ['b'] })
+
+    const outcomes = await addIdeWorktreeFolders(args)
+
+    expect(cursor.resolveCursorWorkspacePath).toHaveBeenCalledWith('ws', '/repo')
+    expect(cursor.addFoldersToCursorWorkspace).toHaveBeenCalled()
+    expect(outcomes).toEqual([{ ran: true, provider: 'cursor', added: 1, skipped: 1 }])
+  })
+
+  it('skips Cursor when workspaceConfigPath is missing', async () => {
+    config.value = { ide: { provider: 'cursor', config: {} } }
+
+    const outcomes = await addIdeWorktreeFolders(args)
+
+    expect(cursor.addFoldersToCursorWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([{ ran: false, provider: 'cursor', added: 0, skipped: 0 }])
+  })
+
+  it('adds to Zed via zed --add (skipped always 0)', async () => {
+    config.value = zedConfig
+    zed.addFoldersToZedWorkspace.mockResolvedValue({ added: ['a', 'b'] })
+
+    const outcomes = await addIdeWorktreeFolders(args)
+
+    expect(zed.addFoldersToZedWorkspace).toHaveBeenCalled()
+    expect(outcomes).toEqual([{ ran: true, provider: 'zed', added: 2, skipped: 0 }])
+  })
+
+  it('adds to BOTH editors when both are configured', async () => {
+    config.value = bothConfig
+    cursor.addFoldersToCursorWorkspace.mockResolvedValue({ added: ['a'], skipped: [] })
+    zed.addFoldersToZedWorkspace.mockResolvedValue({ added: ['a', 'b'] })
+
+    const outcomes = await addIdeWorktreeFolders(args)
+
+    expect(outcomes).toEqual([
+      { ran: true, provider: 'cursor', added: 1, skipped: 0 },
+      { ran: true, provider: 'zed', added: 2, skipped: 0 },
+    ])
+  })
+
+  it('returns an empty array when no IDE is configured', async () => {
+    config.value = unconfigured
+
+    const outcomes = await addIdeWorktreeFolders(args)
+
+    expect(outcomes).toEqual([])
+  })
+})
+
+describe('removeIdeWorktreeFolders', () => {
+  const args = { projectRoot: '/repo', worktreeDir: '/repo.worktrees', branches: ['release/v1.0.0'] }
+
+  it('removes from the Cursor workspace', async () => {
+    config.value = cursorConfig
+    cursor.removeFoldersFromCursorWorkspace.mockResolvedValue({ removed: ['x'], notFound: [] })
+
+    const outcomes = await removeIdeWorktreeFolders(args)
+
+    expect(cursor.removeFoldersFromCursorWorkspace).toHaveBeenCalled()
+    expect(outcomes).toEqual([{ provider: 'cursor', supported: true, removed: ['x'] }])
+  })
+
+  it('is a no-op for Cursor when workspaceConfigPath is missing', async () => {
+    config.value = { ide: { provider: 'cursor', config: {} } }
+
+    const outcomes = await removeIdeWorktreeFolders(args)
+
+    expect(cursor.removeFoldersFromCursorWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([{ provider: 'cursor', supported: true, removed: [] }])
+  })
+
+  it('reports unsupported for Zed without throwing', async () => {
+    config.value = zedConfig
+
+    const outcomes = await removeIdeWorktreeFolders(args)
+
+    expect(outcomes).toEqual([{ provider: 'zed', supported: false, removed: [] }])
+  })
+
+  it('removes from Cursor AND reports Zed unsupported when both are configured', async () => {
+    config.value = bothConfig
+    cursor.removeFoldersFromCursorWorkspace.mockResolvedValue({ removed: ['x'], notFound: [] })
+
+    const outcomes = await removeIdeWorktreeFolders(args)
+
+    expect(outcomes).toEqual([
+      { provider: 'cursor', supported: true, removed: ['x'] },
+      { provider: 'zed', supported: false, removed: [] },
+    ])
+  })
+
+  it('short-circuits to an empty array when there are no branches (no config read needed)', async () => {
+    config.value = zedConfig
+
+    const outcomes = await removeIdeWorktreeFolders({ ...args, branches: [] })
+
+    expect(outcomes).toEqual([])
+  })
+
+  it('returns an empty array when no IDE is configured', async () => {
+    config.value = unconfigured
+
+    const outcomes = await removeIdeWorktreeFolders(args)
+
+    expect(outcomes).toEqual([])
+  })
+})

package/src/integrations/ide/add-ide-worktree-folders.ts

@@ -0,0 +1,77 @@
+import { addFoldersToCursorWorkspace, launchCursor, resolveCursorWorkspacePath } from 'src/integrations/cursor'
+import { addFoldersToZedWorkspace } from 'src/integrations/zed'
+import { assertNever } from 'src/lib/assert-never'
+import { getInfraKitConfig, resolveConfiguredIdes } from 'src/lib/infra-kit-config'
+import { logger } from 'src/lib/logger'
+
+import type { AddIdeWorktreeFoldersOutcome } from './types'
+
+interface AddIdeWorktreeFoldersArgs {
+  projectRoot: string
+  worktreeDir: string
+  branches: string[]
+}
+
+/**
+ * Workspace-mode add (used by `worktrees-add`): append the given worktree folders
+ * to every configured editor's workspace and open it. Returns one outcome per
+ * configured provider (empty array when no IDE is configured), iterating
+ * sequentially.
+ *
+ * Cursor appends to the `.code-workspace` `folders` array (reporting `skipped`
+ * for already-present entries) then runs `cursor <workspace>`. Zed has no
+ * workspace file, so it `zed --add`s each folder (`skipped` is always 0).
+ */
+export const addIdeWorktreeFolders = async (
+  args: AddIdeWorktreeFoldersArgs,
+): Promise<AddIdeWorktreeFoldersOutcome[]> => {
+  const { projectRoot, worktreeDir, branches } = args
+
+  const config = await getInfraKitConfig()
+  const ides = resolveConfiguredIdes(config)
+
+  const folderPaths = branches.map((branch) => {
+    return `${worktreeDir}/${branch}`
+  })
+
+  const outcomes: AddIdeWorktreeFoldersOutcome[] = []
+
+  for (const ide of ides) {
+    switch (ide.provider) {
+      case 'cursor': {
+        if (!ide.config.workspaceConfigPath) {
+          logger.warn('⚠️ Skipping Cursor: ide.config.workspaceConfigPath is not set in infra-kit config')
+
+          outcomes.push({ ran: false, provider: 'cursor', added: 0, skipped: 0 })
+          break
+        }
+
+        const workspacePath = resolveCursorWorkspacePath(ide.config.workspaceConfigPath, projectRoot)
+
+        const { added, skipped } = await addFoldersToCursorWorkspace({ workspacePath, folderPaths })
+
+        const skippedSuffix = skipped.length > 0 ? ` (${skipped.length} already present)` : ''
+
+        logger.info(`✅ Added ${added.length} folder(s) to ${workspacePath}${skippedSuffix}`)
+
+        await launchCursor(workspacePath)
+
+        outcomes.push({ ran: true, provider: 'cursor', added: added.length, skipped: skipped.length })
+        break
+      }
+      case 'zed': {
+        const { added } = await addFoldersToZedWorkspace({ folderPaths })
+
+        logger.info(`✅ Added ${added.length} folder(s) to Zed workspace`)
+
+        outcomes.push({ ran: true, provider: 'zed', added: added.length, skipped: 0 })
+        break
+      }
+      default: {
+        assertNever(ide)
+      }
+    }
+  }
+
+  return outcomes
+}

package/src/integrations/ide/index.ts

@@ -0,0 +1,6 @@
+export { addIdeWorktreeFolders } from './add-ide-worktree-folders'
+export { openIdeWorkspace } from './open-ide-workspace'
+export { ideProviderLabel } from './provider-label'
+export { removeIdeWorktreeFolders } from './remove-ide-worktree-folders'
+export { IDE_MODES } from './types'
+export type { IdeMode, IdeProvider } from './types'

package/src/integrations/ide/open-ide-workspace.ts

@@ -0,0 +1,51 @@
+import { openCursorWorkspace } from 'src/integrations/cursor'
+import { openZedWorkspace } from 'src/integrations/zed'
+import { assertNever } from 'src/lib/assert-never'
+import { getInfraKitConfig, resolveConfiguredIdes } from 'src/lib/infra-kit-config'
+
+import type { OpenIdeWorkspaceOutcome } from './types'
+
+interface OpenIdeWorkspaceArgs {
+  projectRoot: string
+  worktreeDir: string
+  currentBranches: string[]
+  skipRelaunchWhenEmpty: boolean
+}
+
+/**
+ * Provider-agnostic entry point for the cold-start / reload open: for every
+ * configured editor, reconciles (or, for Zed, simply assembles) the workspace
+ * against the release worktrees on disk and launches it. Returns one outcome per
+ * configured provider (empty array when no IDE is configured). Iterates
+ * sequentially — `worktrees-reload` already wraps this call in an outer
+ * `Promise.all` with cmux, so a `Promise.all` here would compound editor-spawn
+ * concurrency. Best-effort — every provider swallows failures into a warning.
+ */
+export const openIdeWorkspace = async (args: OpenIdeWorkspaceArgs): Promise<OpenIdeWorkspaceOutcome[]> => {
+  const config = await getInfraKitConfig()
+  const ides = resolveConfiguredIdes(config)
+
+  const outcomes: OpenIdeWorkspaceOutcome[] = []
+
+  for (const ide of ides) {
+    switch (ide.provider) {
+      case 'cursor': {
+        const outcome = await openCursorWorkspace({ ...args, cursorConfig: ide.config })
+
+        outcomes.push({ ...outcome, provider: 'cursor' })
+        break
+      }
+      case 'zed': {
+        const outcome = await openZedWorkspace(args)
+
+        outcomes.push({ ...outcome, provider: 'zed' })
+        break
+      }
+      default: {
+        assertNever(ide)
+      }
+    }
+  }
+
+  return outcomes
+}

package/src/integrations/ide/provider-label.ts

@@ -0,0 +1,24 @@
+import { assertNever } from 'src/lib/assert-never'
+
+import type { IdeProvider } from './types'
+
+/**
+ * Human-facing display name for an IDE provider, used in log lines. Falls back to
+ * a generic "IDE" when no provider is configured.
+ */
+export const ideProviderLabel = (provider: IdeProvider | undefined): string => {
+  switch (provider) {
+    case 'cursor': {
+      return 'Cursor'
+    }
+    case 'zed': {
+      return 'Zed'
+    }
+    case undefined: {
+      return 'IDE'
+    }
+    default: {
+      return assertNever(provider)
+    }
+  }
+}

package/src/integrations/ide/remove-ide-worktree-folders.ts

@@ -0,0 +1,80 @@
+import { removeFoldersFromCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
+import { assertNever } from 'src/lib/assert-never'
+import { getInfraKitConfig, resolveConfiguredIdes } from 'src/lib/infra-kit-config'
+import { logger } from 'src/lib/logger'
+
+import type { RemoveIdeWorktreeFoldersOutcome } from './types'
+
+interface RemoveIdeWorktreeFoldersArgs {
+  projectRoot: string
+  worktreeDir: string
+  branches: string[]
+}
+
+/**
+ * Strip removed worktrees from every configured editor's workspace (used by
+ * `worktrees-remove` and `worktrees-sync`). Returns one outcome per configured
+ * provider (empty array when no IDE is configured or no worktrees were removed),
+ * iterating sequentially.
+ *
+ * Cursor edits the `.code-workspace` `folders` array. Zed has no folder-remove
+ * CLI, so it is a structural no-op (`supported: false`) with an info-level
+ * message — never a warning, because nothing failed.
+ */
+export const removeIdeWorktreeFolders = async (
+  args: RemoveIdeWorktreeFoldersArgs,
+): Promise<RemoveIdeWorktreeFoldersOutcome[]> => {
+  const { projectRoot, worktreeDir, branches } = args
+
+  if (branches.length === 0) {
+    return []
+  }
+
+  const config = await getInfraKitConfig()
+  const ides = resolveConfiguredIdes(config)
+
+  const folderPaths = branches.map((branch) => {
+    return `${worktreeDir}/${branch}`
+  })
+
+  const outcomes: RemoveIdeWorktreeFoldersOutcome[] = []
+
+  for (const ide of ides) {
+    switch (ide.provider) {
+      case 'cursor': {
+        if (!ide.config.workspaceConfigPath) {
+          outcomes.push({ provider: 'cursor', supported: true, removed: [] })
+          break
+        }
+
+        const workspacePath = resolveCursorWorkspacePath(ide.config.workspaceConfigPath, projectRoot)
+
+        try {
+          const { removed } = await removeFoldersFromCursorWorkspace({ workspacePath, folderPaths })
+
+          if (removed.length > 0) {
+            logger.info(`✅ Removed ${removed.length} folder(s) from ${workspacePath}`)
+          }
+
+          outcomes.push({ provider: 'cursor', supported: true, removed })
+        } catch (error) {
+          logger.warn({ error }, `⚠️ Failed to update Cursor workspace at ${workspacePath}`)
+
+          outcomes.push({ provider: 'cursor', supported: true, removed: [] })
+        }
+        break
+      }
+      case 'zed': {
+        logger.info('ℹ️ Zed has no folder-remove CLI; close removed worktree folders in Zed manually if needed.')
+
+        outcomes.push({ provider: 'zed', supported: false, removed: [] })
+        break
+      }
+      default: {
+        assertNever(ide)
+      }
+    }
+  }
+
+  return outcomes
+}

package/src/integrations/ide/types.ts

@@ -0,0 +1,32 @@
+export type IdeProvider = 'cursor' | 'zed'
+
+/**
+ * CLI-level open modes for `worktrees-add` (`--ide`). `workspace` adds each
+ * created worktree to the configured editor's workspace and opens it (the only
+ * attach style); `none` means "don't open any editor".
+ */
+export const IDE_MODES = ['workspace', 'none'] as const
+export type IdeMode = (typeof IDE_MODES)[number]
+
+// Each facade returns one outcome PER configured provider (an array), so every
+// outcome is tagged with its `provider`.
+export interface OpenIdeWorkspaceOutcome {
+  ran: boolean
+  provider: IdeProvider
+  added: number
+  removed: number
+}
+
+export interface AddIdeWorktreeFoldersOutcome {
+  ran: boolean
+  provider: IdeProvider
+  added: number
+  skipped: number
+}
+
+export interface RemoveIdeWorktreeFoldersOutcome {
+  provider: IdeProvider
+  /** False when the configured provider has no folder-remove capability (Zed). */
+  supported: boolean
+  removed: string[]
+}

package/src/integrations/zed/__tests__/open-zed-workspace.test.ts

@@ -0,0 +1,85 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { openZedWorkspace } from '../open-zed-workspace'
+
+const zx = vi.hoisted(() => {
+  return { calls: [] as unknown[][], shouldThrow: false }
+})
+
+vi.mock('zx', () => {
+  return {
+    $: vi.fn((_strings: TemplateStringsArray, ...values: unknown[]) => {
+      zx.calls.push(values)
+
+      if (zx.shouldThrow) {
+        return Promise.reject(new Error('zed failed to launch'))
+      }
+
+      return Promise.resolve({ stdout: '' })
+    }),
+  }
+})
+
+vi.mock('src/lib/logger', () => {
+  return {
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+  }
+})
+
+describe('openZedWorkspace', () => {
+  beforeEach(() => {
+    zx.calls = []
+    zx.shouldThrow = false
+  })
+
+  it('opens a single workspace with the project root plus every worktree path', async () => {
+    const outcome = await openZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      currentBranches: ['release/v1.0.0', 'release/v1.1.0'],
+      skipRelaunchWhenEmpty: false,
+    })
+
+    expect(zx.calls).toHaveLength(1)
+    expect(zx.calls[0]?.[0]).toEqual(['/repo', '/repo.worktrees/release/v1.0.0', '/repo.worktrees/release/v1.1.0'])
+    expect(outcome).toEqual({ ran: true, added: 2, removed: 0 })
+  })
+
+  it('still opens the bare project root when there are worktrees but relaunch is not skipped', async () => {
+    const outcome = await openZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      currentBranches: [],
+      skipRelaunchWhenEmpty: false,
+    })
+
+    expect(zx.calls).toHaveLength(1)
+    expect(zx.calls[0]?.[0]).toEqual(['/repo'])
+    expect(outcome).toEqual({ ran: true, added: 0, removed: 0 })
+  })
+
+  it('skips launching when skipRelaunchWhenEmpty is set and there are no worktrees', async () => {
+    const outcome = await openZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      currentBranches: [],
+      skipRelaunchWhenEmpty: true,
+    })
+
+    expect(zx.calls).toHaveLength(0)
+    expect(outcome).toEqual({ ran: false, added: 0, removed: 0 })
+  })
+
+  it('swallows a launch failure into a best-effort warning', async () => {
+    zx.shouldThrow = true
+
+    const outcome = await openZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      currentBranches: ['release/v1.0.0'],
+      skipRelaunchWhenEmpty: false,
+    })
+
+    expect(outcome).toEqual({ ran: false, added: 0, removed: 0 })
+  })
+})