infra-kit 0.1.128 → 0.1.129

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

@@ -1,289 +0,0 @@
-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(),
-    reuseZedWorkspace: 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'],
-}
-
-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', () => {
-  // currentWorktrees \ removedWorktrees => remaining = ['release/v1.1.0']
-  const args = {
-    projectRoot: '/repo',
-    worktreeDir: '/repo.worktrees',
-    currentWorktrees: ['release/v1.0.0', 'release/v1.1.0'],
-    removedWorktrees: ['release/v1.0.0'],
-    allowEditorRelaunch: false,
-  }
-
-  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('does NOT relaunch Zed on the non-interactive path (allowEditorRelaunch: false)', async () => {
-    config.value = zedConfig
-
-    const outcomes = await removeIdeWorktreeFolders({ ...args, allowEditorRelaunch: false })
-
-    expect(zed.reuseZedWorkspace).not.toHaveBeenCalled()
-    expect(outcomes).toEqual([{ provider: 'zed', supported: true, removed: [] }])
-  })
-
-  it('relaunches Zed with the remaining set on the interactive path (allowEditorRelaunch: true)', async () => {
-    config.value = zedConfig
-
-    const outcomes = await removeIdeWorktreeFolders({ ...args, allowEditorRelaunch: true })
-
-    expect(zed.reuseZedWorkspace).toHaveBeenCalledWith({
-      projectRoot: '/repo',
-      worktreeDir: '/repo.worktrees',
-      remainingBranches: ['release/v1.1.0'],
-    })
-    expect(outcomes).toEqual([{ provider: 'zed', supported: true, removed: [] }])
-  })
-
-  it('reports Zed removed:[] when the relaunch swallowed a failure (ran:false), never throwing', async () => {
-    config.value = zedConfig
-    // reuseZedWorkspace is best-effort: it swallows launch failures internally and resolves
-    // { ran: false } rather than rejecting, so the facade never sees a throw.
-    zed.reuseZedWorkspace.mockResolvedValue({ ran: false })
-
-    const outcomes = await removeIdeWorktreeFolders({ ...args, allowEditorRelaunch: true })
-
-    expect(outcomes).toEqual([{ provider: 'zed', supported: true, removed: [] }])
-  })
-
-  it('removes from Cursor surgically AND relaunches Zed when both are configured (interactive)', async () => {
-    config.value = bothConfig
-    cursor.removeFoldersFromCursorWorkspace.mockResolvedValue({ removed: ['x'], notFound: [] })
-
-    const outcomes = await removeIdeWorktreeFolders({ ...args, allowEditorRelaunch: true })
-
-    expect(cursor.removeFoldersFromCursorWorkspace).toHaveBeenCalled()
-    expect(zed.reuseZedWorkspace).toHaveBeenCalledWith({
-      projectRoot: '/repo',
-      worktreeDir: '/repo.worktrees',
-      remainingBranches: ['release/v1.1.0'],
-    })
-    expect(outcomes).toEqual([
-      { provider: 'cursor', supported: true, removed: ['x'] },
-      { provider: 'zed', supported: true, removed: [] },
-    ])
-  })
-
-  it('short-circuits to an empty array when nothing was removed (no config read needed)', async () => {
-    config.value = zedConfig
-
-    const outcomes = await removeIdeWorktreeFolders({ ...args, removedWorktrees: [] })
-
-    expect(zed.reuseZedWorkspace).not.toHaveBeenCalled()
-    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

@@ -1,77 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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[]
-}
-
-/**
- * Provider-agnostic entry point for the reload open: for every configured
- * editor, reconciles (or, for Zed, simply assembles) the workspace against the
- * release worktrees on disk and launches it — skipping the launch when there are
- * no worktrees, so `worktrees-reload` never pops a bare editor window. 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

@@ -1,24 +0,0 @@
-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

@@ -1,145 +0,0 @@
-import { removeFoldersFromCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
-import { reuseZedWorkspace } 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 { RemoveIdeWorktreeFoldersOutcome } from './types'
-
-interface RemoveIdeWorktreeFoldersArgs {
-  projectRoot: string
-  worktreeDir: string
-  /** All release worktrees BEFORE removal (release-only — see Zed note below). */
-  currentWorktrees: string[]
-  /** The subset of `currentWorktrees` that was just removed. */
-  removedWorktrees: string[]
-  /**
-   * Whether the caller is on an interactive path where firing Zed's destructive
-   * `zed --reuse` is acceptable (a human is present and confirming). Interactive
-   * `worktrees-remove` passes `!confirmedCommand`; `worktrees-sync` and every
-   * non-interactive/MCP run pass `false`.
-   */
-  allowEditorRelaunch: boolean
-}
-
-/**
- * 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 surgically edits the `.code-workspace` `folders` array — it removes
- * only the named paths and leaves everything else intact.
- *
- * Zed has no surgical remove. The only mutation mechanism, `zed --reuse`,
- * REPLACES the focused window's entire folder set, so it can only re-state the
- * release worktrees we know about and silently drops any other open folder
- * (`remaining` is built from release worktrees only). Because that is
- * destructive and unrecoverable, it fires ONLY when `allowEditorRelaunch` is
- * true (interactive `worktrees-remove`). On the non-interactive/MCP path it is a
- * deliberate no-op (`supported: true`, `removed: []`) with an info message — the
- * capability exists; skipping is a policy choice, not a missing capability.
- *
- * Zed's `removed` is ALWAYS `[]`: `--reuse` performs no diff, so it confirms no
- * specific removal and we never report intended-but-unverified paths.
- */
-export const removeIdeWorktreeFolders = async (
-  args: RemoveIdeWorktreeFoldersArgs,
-): Promise<RemoveIdeWorktreeFoldersOutcome[]> => {
-  const { projectRoot, worktreeDir, currentWorktrees, removedWorktrees, allowEditorRelaunch } = args
-
-  if (removedWorktrees.length === 0) {
-    return []
-  }
-
-  const config = await getInfraKitConfig()
-  const ides = resolveConfiguredIdes(config)
-
-  const folderPaths = removedWorktrees.map((branch) => {
-    return `${worktreeDir}/${branch}`
-  })
-
-  const remainingBranches = currentWorktrees.filter((branch) => {
-    return !removedWorktrees.includes(branch)
-  })
-
-  const outcomes: RemoveIdeWorktreeFoldersOutcome[] = []
-
-  for (const ide of ides) {
-    switch (ide.provider) {
-      case 'cursor': {
-        outcomes.push(await removeFromCursor({ ide, projectRoot, folderPaths }))
-        break
-      }
-      case 'zed': {
-        outcomes.push(await removeFromZed({ projectRoot, worktreeDir, remainingBranches, allowEditorRelaunch }))
-        break
-      }
-      default: {
-        assertNever(ide)
-      }
-    }
-  }
-
-  return outcomes
-}
-
-interface RemoveFromCursorArgs {
-  ide: Extract<ReturnType<typeof resolveConfiguredIdes>[number], { provider: 'cursor' }>
-  projectRoot: string
-  folderPaths: string[]
-}
-
-/** Surgically strip the removed folder paths from the Cursor `.code-workspace`. */
-const removeFromCursor = async (args: RemoveFromCursorArgs): Promise<RemoveIdeWorktreeFoldersOutcome> => {
-  const { ide, projectRoot, folderPaths } = args
-
-  if (!ide.config.workspaceConfigPath) {
-    return { provider: 'cursor', supported: true, removed: [] }
-  }
-
-  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}`)
-    }
-
-    return { provider: 'cursor', supported: true, removed }
-  } catch (error) {
-    logger.warn({ error }, `⚠️ Failed to update Cursor workspace at ${workspacePath}`)
-
-    return { provider: 'cursor', supported: true, removed: [] }
-  }
-}
-
-interface RemoveFromZedArgs {
-  projectRoot: string
-  worktreeDir: string
-  remainingBranches: string[]
-  allowEditorRelaunch: boolean
-}
-
-/**
- * Reflect the removal in Zed by relaunching the focused window onto the
- * remaining set — but ONLY on an interactive path (see the module doc for why
- * `zed --reuse` is destructive). Otherwise a deliberate no-op. `removed` is
- * always `[]` because `--reuse` performs no diff.
- */
-const removeFromZed = async (args: RemoveFromZedArgs): Promise<RemoveIdeWorktreeFoldersOutcome> => {
-  const { projectRoot, worktreeDir, remainingBranches, allowEditorRelaunch } = args
-
-  if (!allowEditorRelaunch) {
-    logger.info(
-      'ℹ️ Zed folder removal skipped (no interactive session); close removed worktree folders in Zed manually if needed.',
-    )
-
-    return { provider: 'zed', supported: true, removed: [] }
-  }
-
-  await reuseZedWorkspace({ projectRoot, worktreeDir, remainingBranches })
-
-  return { provider: 'zed', supported: true, removed: [] }
-}

package/src/integrations/ide/types.ts

@@ -1,41 +0,0 @@
-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
-  /**
-   * True when the provider can reflect a removal. Both providers now report
-   * `true`; `false` is reserved for a future provider with no remove capability.
-   */
-  supported: boolean
-  /**
-   * Folders confirmed removed. For Cursor this is the real diff of the
-   * `.code-workspace` `folders` array. For Zed it is ALWAYS `[]`: the only
-   * mechanism (`zed --reuse`) replaces the whole window without producing a
-   * diff, so it confirms no specific removal even when it refreshed the window.
-   */
-  removed: string[]
-}