infra-kit 0.1.113 → 0.1.115

package/src/integrations/gh/gh-release-prs/gh-release-prs.ts

@@ -1,6 +1,6 @@
-import process from 'node:process'
 import { $ } from 'zx'
 
+import { OperationError } from 'src/lib/errors/operation-error'
 import { logger } from 'src/lib/logger'
 import { compareReleaseIds, formatBranchName, formatPrTitle, parseBranchName } from 'src/lib/release-id'
 import type { ReleaseId } from 'src/lib/release-id'
@@ -84,18 +84,21 @@ export const getReleasePRs = async (): Promise<string[]> => {
     const prs = await fetchAllReleasePRs()
 
     if (prs.length === 0) {
-      logger.error('❌ No release PRs found. Check the project folder for the script. Exiting...')
-
-      process.exit(1)
+      throw new OperationError(undefined, {
+        operation: 'find open release PRs',
+        remediation: 'open a release PR first, or check you are in the right repo',
+      })
     }
 
     return sortReleasePRs(prs).map((pr) => {
       return pr.headRefName
     })
   } catch (error) {
+    if (error instanceof OperationError) throw error
+
     logger.error({ error }, '❌ Error fetching release PRs')
 
-    process.exit(1)
+    throw new OperationError(error, { operation: 'fetch release PRs' })
   }
 }
 
@@ -110,8 +113,10 @@ export const getReleasePRsWithInfo = async (): Promise<ReleasePRInfo[]> => {
     const prs = await fetchAllReleasePRs()
 
     if (prs.length === 0) {
-      logger.error('❌ No release PRs found. Check the project folder for the script. Exiting...')
-      process.exit(1)
+      throw new OperationError(undefined, {
+        operation: 'find open release PRs',
+        remediation: 'open a release PR first, or check you are in the right repo',
+      })
     }
 
     return sortReleasePRs(prs).map((pr) => {
@@ -122,8 +127,11 @@ export const getReleasePRsWithInfo = async (): Promise<ReleasePRInfo[]> => {
       }
     })
   } catch (error) {
+    if (error instanceof OperationError) throw error
+
     logger.error({ error }, '❌ Error fetching release PRs')
-    process.exit(1)
+
+    throw new OperationError(error, { operation: 'fetch release PRs' })
   }
 }
 

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

@@ -33,6 +33,7 @@ const cursor = vi.hoisted(() => {
     openCursorWorkspace: vi.fn(),
     addFoldersToCursorWorkspace: vi.fn(),
     removeFoldersFromCursorWorkspace: vi.fn(),
+    launchCursor: vi.fn(),
     resolveCursorWorkspacePath: vi.fn((value: string) => {
       return `/abs/${value}`
     }),
@@ -43,10 +44,18 @@ 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(),
   }
 })
 
@@ -65,7 +74,6 @@ const baseOpenArgs = {
   projectRoot: '/repo',
   worktreeDir: '/repo.worktrees',
   currentBranches: ['release/v1.0.0'],
-  skipRelaunchWhenEmpty: false,
 }
 
 beforeEach(() => {
@@ -183,7 +191,14 @@ describe('addIdeWorktreeFolders', () => {
 })
 
 describe('removeIdeWorktreeFolders', () => {
-  const args = { projectRoot: '/repo', worktreeDir: '/repo.worktrees', branches: ['release/v1.0.0'] }
+  // 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
@@ -204,31 +219,63 @@ describe('removeIdeWorktreeFolders', () => {
     expect(outcomes).toEqual([{ provider: 'cursor', supported: true, removed: [] }])
   })
 
-  it('reports unsupported for Zed without throwing', async () => {
+  it('does NOT relaunch Zed on the non-interactive path (allowEditorRelaunch: false)', async () => {
     config.value = zedConfig
 
-    const outcomes = await removeIdeWorktreeFolders(args)
+    const outcomes = await removeIdeWorktreeFolders({ ...args, allowEditorRelaunch: false })
 
-    expect(outcomes).toEqual([{ provider: 'zed', supported: false, removed: [] }])
+    expect(zed.reuseZedWorkspace).not.toHaveBeenCalled()
+    expect(outcomes).toEqual([{ provider: 'zed', supported: true, removed: [] }])
   })
 
-  it('removes from Cursor AND reports Zed unsupported when both are configured', async () => {
+  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)
+    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: false, removed: [] },
+      { provider: 'zed', supported: true, removed: [] },
     ])
   })
 
-  it('short-circuits to an empty array when there are no branches (no config read needed)', async () => {
+  it('short-circuits to an empty array when nothing was removed (no config read needed)', async () => {
     config.value = zedConfig
 
-    const outcomes = await removeIdeWorktreeFolders({ ...args, branches: [] })
+    const outcomes = await removeIdeWorktreeFolders({ ...args, removedWorktrees: [] })
 
+    expect(zed.reuseZedWorkspace).not.toHaveBeenCalled()
     expect(outcomes).toEqual([])
   })
 

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

@@ -1,6 +1,4 @@
-import { $ } from 'zx'
-
-import { addFoldersToCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
+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'
@@ -56,7 +54,7 @@ export const addIdeWorktreeFolders = async (
 
         logger.info(`✅ Added ${added.length} folder(s) to ${workspacePath}${skippedSuffix}`)
 
-        await $`cursor ${workspacePath}`
+        await launchCursor(workspacePath)
 
         outcomes.push({ ran: true, provider: 'cursor', added: added.length, skipped: skipped.length })
         break

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

@@ -9,15 +9,15 @@ 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
+ * 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.
  */

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

@@ -1,4 +1,5 @@
 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'
@@ -8,7 +9,17 @@ import type { RemoveIdeWorktreeFoldersOutcome } from './types'
 interface RemoveIdeWorktreeFoldersArgs {
   projectRoot: string
   worktreeDir: string
-  branches: 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
 }
 
 /**
@@ -17,57 +28,51 @@ interface RemoveIdeWorktreeFoldersArgs {
  * 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.
+ * 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, branches } = args
+  const { projectRoot, worktreeDir, currentWorktrees, removedWorktrees, allowEditorRelaunch } = args
 
-  if (branches.length === 0) {
+  if (removedWorktrees.length === 0) {
     return []
   }
 
   const config = await getInfraKitConfig()
   const ides = resolveConfiguredIdes(config)
 
-  const folderPaths = branches.map((branch) => {
+  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': {
-        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: [] })
-        }
+        outcomes.push(await removeFromCursor({ ide, projectRoot, folderPaths }))
         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: [] })
+        outcomes.push(await removeFromZed({ projectRoot, worktreeDir, remainingBranches, allowEditorRelaunch }))
         break
       }
       default: {
@@ -78,3 +83,63 @@ export const removeIdeWorktreeFolders = async (
 
   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

@@ -26,7 +26,16 @@ export interface AddIdeWorktreeFoldersOutcome {
 
 export interface RemoveIdeWorktreeFoldersOutcome {
   provider: IdeProvider
-  /** False when the configured provider has no folder-remove capability (Zed). */
+  /**
+   * 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[]
 }

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

@@ -37,7 +37,6 @@ describe('openZedWorkspace', () => {
       projectRoot: '/repo',
       worktreeDir: '/repo.worktrees',
       currentBranches: ['release/v1.0.0', 'release/v1.1.0'],
-      skipRelaunchWhenEmpty: false,
     })
 
     expect(zx.calls).toHaveLength(1)
@@ -45,25 +44,11 @@ describe('openZedWorkspace', () => {
     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 () => {
+  it('skips launching when there are no worktrees', 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)
@@ -77,7 +62,6 @@ describe('openZedWorkspace', () => {
       projectRoot: '/repo',
       worktreeDir: '/repo.worktrees',
       currentBranches: ['release/v1.0.0'],
-      skipRelaunchWhenEmpty: false,
     })
 
     expect(outcome).toEqual({ ran: false, added: 0, removed: 0 })

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

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { reuseZedWorkspace } from '../reuse-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: '' })
+    }),
+  }
+})
+
+const log = vi.hoisted(() => {
+  return { info: vi.fn(), warn: vi.fn(), error: vi.fn() }
+})
+
+vi.mock('src/lib/logger', () => {
+  return { logger: log }
+})
+
+describe('reuseZedWorkspace', () => {
+  beforeEach(() => {
+    zx.calls = []
+    zx.shouldThrow = false
+    vi.clearAllMocks()
+  })
+
+  it('runs `zed --reuse` with the project root plus the remaining worktree paths', async () => {
+    const outcome = await reuseZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      remainingBranches: ['release/v1.0.0', 'release/v1.1.0'],
+    })
+
+    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 })
+  })
+
+  it('collapses to root-only when no worktrees remain', async () => {
+    const outcome = await reuseZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      remainingBranches: [],
+    })
+
+    expect(zx.calls).toHaveLength(1)
+    expect(zx.calls[0]?.[0]).toEqual(['/repo'])
+    expect(outcome).toEqual({ ran: true })
+  })
+
+  it('emits a disclosure log line warning that other open folders are not preserved', async () => {
+    await reuseZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      remainingBranches: ['release/v1.0.0'],
+    })
+
+    expect(log.info).toHaveBeenCalledWith(
+      expect.stringContaining('other folders in the focused window are not preserved'),
+    )
+  })
+
+  it('swallows a launch failure into a best-effort warning', async () => {
+    zx.shouldThrow = true
+
+    const outcome = await reuseZedWorkspace({
+      projectRoot: '/repo',
+      worktreeDir: '/repo.worktrees',
+      remainingBranches: ['release/v1.0.0'],
+    })
+
+    expect(outcome).toEqual({ ran: false })
+    expect(log.warn).toHaveBeenCalled()
+  })
+})

package/src/integrations/zed/index.ts

@@ -1,2 +1,3 @@
 export { addFoldersToZedWorkspace } from './add-folders-to-zed-workspace'
 export { openZedWorkspace } from './open-zed-workspace'
+export { reuseZedWorkspace } from './reuse-zed-workspace'

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

@@ -6,12 +6,6 @@ interface OpenZedWorkspaceArgs {
   projectRoot: string
   worktreeDir: string
   currentBranches: string[]
-  /**
-   * When true, skip launching Zed if there are no release worktrees. Lets
-   * `worktrees-reload` avoid popping a bare Zed window while keeping the
-   * cold-start `worktrees-open` behaviour (launch unconditionally) intact.
-   */
-  skipRelaunchWhenEmpty: boolean
 }
 
 interface OpenZedWorkspaceOutcome {
@@ -23,8 +17,8 @@ interface OpenZedWorkspaceOutcome {
 /**
  * Opens a single Zed workspace containing the project root plus every release
  * worktree, via one `zed <root> <wt...>` invocation (Zed realizes a multi-folder
- * workspace from multiple path arguments). Shared by `worktrees-open` (cold-start
- * restore) and `worktrees-reload` (relaunch).
+ * workspace from multiple path arguments). Used by `worktrees-reload`; skips the
+ * launch when there are no worktrees so it never pops a bare Zed window.
  *
  * Zed has no portable workspace file and no folder-remove CLI, so there is
  * nothing to reconcile: `added` is the number of worktrees opened and `removed`
@@ -32,9 +26,9 @@ interface OpenZedWorkspaceOutcome {
  * best-effort, mirroring the Cursor integration.
  */
 export const openZedWorkspace = async (args: OpenZedWorkspaceArgs): Promise<OpenZedWorkspaceOutcome> => {
-  const { projectRoot, worktreeDir, currentBranches, skipRelaunchWhenEmpty } = args
+  const { projectRoot, worktreeDir, currentBranches } = args
 
-  if (skipRelaunchWhenEmpty && currentBranches.length === 0) {
+  if (currentBranches.length === 0) {
     return { ran: false, added: 0, removed: 0 }
   }
 

package/src/integrations/zed/reuse-zed-workspace.ts

@@ -0,0 +1,57 @@
+import { $ } from 'zx'
+
+import { logger } from 'src/lib/logger'
+
+interface ReuseZedWorkspaceArgs {
+  projectRoot: string
+  worktreeDir: string
+  remainingBranches: string[]
+}
+
+interface ReuseZedWorkspaceOutcome {
+  ran: boolean
+}
+
+/**
+ * Reflects a worktree removal in the open Zed window by running
+ * `zed --reuse <root> <remaining release worktrees...>`.
+ *
+ * IMPORTANT — this is destructive: `--reuse` REPLACES the focused window's
+ * ENTIRE folder set with exactly these paths. The remaining set is built from
+ * release worktrees only (`getCurrentWorktrees('release')`), so any other folder
+ * open in that window — feature worktrees, scratch dirs, user-added dirs — is
+ * DROPPED and is NOT recoverable by infra-kit (Zed offers no undo and we keep no
+ * record of the prior set). The caller MUST therefore only invoke this on an
+ * interactive path where a human is present and can re-add folders via
+ * `zed --add`. We emit a disclosure log line saying as much.
+ *
+ * Distinct from `openZedWorkspace`, which runs `zed <paths>` WITHOUT `--reuse`
+ * to realize a multi-folder workspace; that does not replace a focused window.
+ *
+ * Best-effort: any launch failure is swallowed into a warning, mirroring
+ * `openZedWorkspace`. Root is always included so the path list is never empty.
+ */
+export const reuseZedWorkspace = async (args: ReuseZedWorkspaceArgs): Promise<ReuseZedWorkspaceOutcome> => {
+  const { projectRoot, worktreeDir, remainingBranches } = args
+
+  const paths = [
+    projectRoot,
+    ...remainingBranches.map((branch) => {
+      return `${worktreeDir}/${branch}`
+    }),
+  ]
+
+  try {
+    await $`zed --reuse ${paths}`
+
+    logger.info(
+      `↻ Refreshed Zed workspace to root + ${remainingBranches.length} release worktree(s) (other folders in the focused window are not preserved)`,
+    )
+
+    return { ran: true }
+  } catch (error) {
+    logger.warn({ error }, '⚠️ Failed to refresh Zed workspace')
+
+    return { ran: false }
+  }
+}