infra-kit 0.1.110 → 0.1.113

package/src/commands/init/init.ts

@@ -6,7 +6,7 @@ import { logger } from 'src/lib/logger'
 import { removeManagedBlock, upsertManagedBlock } from 'src/lib/managed-block'
 
 import { writeAgentFiles } from './agent-files'
-import { migrateLegacyConfig } from './migrate-config'
+import { migrateLegacyConfig, normalizeLegacyIdeStructures } from './migrate-config'
 
 export const MARKER_START = '# -- infra-kit:begin --'
 export const MARKER_END = '# -- infra-kit:end --'
@@ -36,18 +36,27 @@ const USER_GLOBAL_CONFIG_EXAMPLE = `// infra-kit user-global config — ~/.infra
 {
   // "ide": {
   //   "provider": "cursor",
-  //   "config": { "mode": "workspace", "workspaceConfigPath": "/path/to/your.code-workspace" }
+  //   "config": { "workspaceConfigPath": "/path/to/your.code-workspace" }
   // },
+  // // Or, for Zed (no workspace file — one window with all worktrees via "zed <root> <wt...>"):
+  // "ide": { "provider": "zed", "config": {} },
+  // // Or drive BOTH editors at once with an array (at most one entry per provider):
+  // "ide": [
+  //   { "provider": "cursor", "config": { "workspaceConfigPath": "/path/to/your.code-workspace" } },
+  //   { "provider": "zed", "config": {} }
+  // ],
   // "worktrees": { "openInGithubDesktop": false, "openInCmux": true }
 }
 `
 
 /**
  * Append infra-kit shell functions to .zshrc, migrate any legacy
- * `infra-kit.yml` config layers to JSON, and seed the user-global config at
- * ~/.infra-kit/config.json on first run. Idempotent: a subsequent run replaces
- * the existing zshrc block in place, has nothing left to migrate, and leaves
- * the user-global config untouched.
+ * `infra-kit.yml` config layers to JSON, normalize existing JSON configs from
+ * the old IDE structure to the new one (strip the removed `ide.config.mode`),
+ * and seed the user-global config at ~/.infra-kit/config.json on first run.
+ * Idempotent: a subsequent run replaces the existing zshrc block in place, has
+ * nothing left to migrate or normalize, and leaves the user-global config
+ * untouched.
  *
  * @example
  * // CLI: `infra-kit init`  (or via the `pnpm dx-init` alias)
@@ -79,6 +88,10 @@ export const init = async (): Promise<void> => {
   // migrated config.json is not re-seeded as an empty stub.
   await migrateLegacyConfig()
 
+  // Migrate existing JSON configs from the old IDE structure to the new one
+  // (strip the removed `ide.config.mode` field). No-op for already-clean configs.
+  await normalizeLegacyIdeStructures()
+
   seedUserGlobalConfig()
 
   // Best-effort, non-fatal, repo-gated: keep the agent-instruction files in sync

package/src/commands/init/migrate-config.ts

@@ -144,3 +144,107 @@ export const migrateLegacyConfig = async (): Promise<void> => {
     resetInfraKitConfigCache()
   }
 }
+
+/**
+ * Surgically strip the removed `ide.config.mode` field from a parsed config
+ * object (single-provider or array form). The windows-removal made `mode` a dead
+ * key — the loader already ignores it, so this only matters for keeping the
+ * on-disk file clean. Returns `changed: false` (and the input untouched) when
+ * there is no `mode` to remove, so callers can skip rewriting clean files.
+ *
+ * Only `mode` is removed — every other key is preserved verbatim (no full-schema
+ * re-validation), so a config that is otherwise invalid or carries forward-compat
+ * keys is never altered beyond the dead field.
+ */
+const stripLegacyIdeMode = (parsed: Record<string, unknown>): { changed: boolean; result: Record<string, unknown> } => {
+  const ide = parsed.ide
+
+  if (ide === null || typeof ide !== 'object') {
+    return { changed: false, result: parsed }
+  }
+
+  let changed = false
+
+  const stripEntry = (entry: unknown): unknown => {
+    if (entry === null || typeof entry !== 'object' || !('config' in entry)) {
+      return entry
+    }
+
+    const config = (entry as { config: unknown }).config
+
+    if (config === null || typeof config !== 'object' || !('mode' in config)) {
+      return entry
+    }
+
+    changed = true
+
+    const restConfig = Object.fromEntries(
+      Object.entries(config as Record<string, unknown>).filter(([key]) => {
+        return key !== 'mode'
+      }),
+    )
+
+    return { ...(entry as Record<string, unknown>), config: restConfig }
+  }
+
+  const nextIde = Array.isArray(ide) ? ide.map(stripEntry) : stripEntry(ide)
+
+  if (!changed) {
+    return { changed: false, result: parsed }
+  }
+
+  return { changed: true, result: { ...parsed, ide: nextIde } }
+}
+
+/**
+ * Normalize any existing `infra-kit.json` config layers (project, user-global,
+ * user-project) from the old IDE structure to the new one by removing the
+ * removed `ide.config.mode` field. Run by `infra-kit init` after the YAML→JSON
+ * migration. Best-effort and non-fatal per layer; only rewrites a file when its
+ * `ide` config actually carries the dead key, so clean configs are left byte-for-
+ * byte untouched (idempotent). Resets the config cache when anything changed.
+ *
+ * @example
+ * await normalizeLegacyIdeStructures()
+ * // ✓ Normalized ide config in infra-kit.json (removed legacy "mode")
+ * // (no output when no config carries a legacy "mode")
+ */
+export const normalizeLegacyIdeStructures = async (): Promise<void> => {
+  let paths: Awaited<ReturnType<typeof getInfraKitConfigPaths>>
+
+  try {
+    paths = await getInfraKitConfigPaths()
+  } catch {
+    return
+  }
+
+  const jsonPaths = [paths.main, paths.userGlobal, paths.userProject]
+
+  let normalized = 0
+
+  for (const jsonPath of jsonPaths) {
+    if (!(await fileExists(jsonPath))) continue
+
+    try {
+      const raw = await fs.readFile(jsonPath, 'utf-8')
+
+      if (raw.trim() === '') continue
+
+      const parsed = JSON.parse(raw) as Record<string, unknown>
+      const { changed, result } = stripLegacyIdeMode(parsed)
+
+      if (!changed) continue
+
+      await fs.writeFile(jsonPath, `${JSON.stringify(result, null, 2)}\n`, 'utf-8')
+
+      logger.info(`✓ Normalized ide config in ${tildify(jsonPath)} (removed legacy "mode")`)
+      normalized++
+    } catch (err) {
+      logger.info(`⚠ Skipped normalizing ${tildify(jsonPath)} — ${(err as Error).message}`)
+    }
+  }
+
+  if (normalized > 0) {
+    resetInfraKitConfigCache()
+  }
+}

package/src/commands/release-create/release-create.ts

@@ -15,6 +15,7 @@ import type { ReleaseCreationResult, ReleaseType } from 'src/lib/release-utils'
 import {
   NoPriorVersionsError,
   computeNextVersion,
+  formatReleaseSpec,
   hasNextToken,
   loadExistingVersions,
   parseVersion,
@@ -171,20 +172,11 @@ const formatReleaseSummary = (entry: ReleaseEntry): string => {
 }
 
 const echoReleases = (entries: ReleaseEntry[]): void => {
+  // Every entry — versions, "next" (resolved to a concrete version), and named
+  // releases alike — echoes through the single --release flag. formatReleaseSpec
+  // produces a spec that parseReleaseSpec parses back into the same entry.
   for (const entry of entries) {
-    if (entry.id.kind === 'name') {
-      // Named releases echo the --name form; description is not part of the
-      // flag and is set later via release-desc-edit / interactively.
-      commandEcho.addOption('--name', entry.id.name)
-
-      continue
-    }
-
-    const spec = entry.description
-      ? `${entry.id.raw}:${entry.type}:${entry.description}`
-      : `${entry.id.raw}:${entry.type}`
-
-    commandEcho.addOption('--release', spec)
+    commandEcho.addOption('--release', formatReleaseSpec(entry))
   }
 }
 

package/src/commands/worktrees-add/index.ts

@@ -1,2 +1 @@
-export { CURSOR_MODES, worktreesAdd, worktreesAddMcpTool } from './worktrees-add'
-export type { CursorMode } from './worktrees-add'
+export { worktreesAdd, worktreesAddMcpTool } from './worktrees-add'

package/src/commands/worktrees-add/worktrees-add.ts

@@ -1,7 +1,6 @@
 /* eslint-disable sonarjs/cognitive-complexity */
 import checkbox from '@inquirer/checkbox'
 import confirm from '@inquirer/confirm'
-import select from '@inquirer/select'
 import process from 'node:process'
 import { z } from 'zod'
 import { $ } from 'zx'
@@ -12,14 +11,15 @@ import {
   listCmuxWorkspaceTitles,
   openCmuxWorkspaceWithLayout,
 } from 'src/integrations/cmux'
-import { addFoldersToCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
 import { getReleasePRsWithInfo } from 'src/integrations/gh'
+import { IDE_MODES, addIdeWorktreeFolders } from 'src/integrations/ide'
+import type { IdeMode } from 'src/integrations/ide'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { OperationError } from 'src/lib/errors/operation-error'
 import { assertManagementContext } from 'src/lib/git-guard'
 import { getCurrentWorktrees, getProjectRoot, getRepoName } from 'src/lib/git-utils'
-import { getInfraKitConfig } from 'src/lib/infra-kit-config'
+import { getInfraKitConfig, resolveConfiguredIdes } from 'src/lib/infra-kit-config'
 import { logger } from 'src/lib/logger'
 import { formatBranchName, isReleaseBranch, parseReleaseRef } from 'src/lib/release-id'
 import { detectReleaseType, formatBranchChoices, getJiraDescriptions, releaseBranchLabels } from 'src/lib/release-utils'
@@ -31,13 +31,12 @@ import type { RequiredConfirmedOptionArg } from 'src/types'
 const FEATURE_DIR = 'feature'
 const RELEASE_DIR = 'release'
 
-export const CURSOR_MODES = ['workspace', 'windows', 'none'] as const
-export type CursorMode = (typeof CURSOR_MODES)[number]
-
 interface WorktreeManagementArgs extends RequiredConfirmedOptionArg {
   all?: boolean
   versions?: string
-  cursor?: CursorMode
+  ide?: IdeMode
+  /** @deprecated Alias for `ide`, kept for back-compat. Ignored when `ide` is set. */
+  cursor?: IdeMode
   githubDesktop?: boolean
   cmux?: boolean
 }
@@ -47,7 +46,9 @@ interface WorktreeManagementArgs extends RequiredConfirmedOptionArg {
  * Creates worktrees for active release branches and removes unused ones
  */
 export const worktreesAdd = async (options: WorktreeManagementArgs) => {
-  const { confirmedCommand, all, versions, cursor, githubDesktop, cmux } = options
+  const { confirmedCommand, all, versions, githubDesktop, cmux } = options
+  // `cursor` is the deprecated alias for `ide`; `ide` wins when both are present.
+  const ide = options.ide ?? options.cursor
 
   commandEcho.start('worktrees-add')
 
@@ -136,34 +137,13 @@ export const worktreesAdd = async (options: WorktreeManagementArgs) => {
     }
 
     const config = await getInfraKitConfig()
-    const cursorConfig = config.ide?.provider === 'cursor' ? config.ide.config : undefined
-
-    const cursorMode: CursorMode =
-      cursor ??
-      cursorConfig?.mode ??
-      (await select<CursorMode>({
-        message: 'Cursor mode for created worktrees?',
-        default: 'workspace',
-        choices: [
-          {
-            name: 'Add to workspace file',
-            value: 'workspace',
-            description: 'Append each worktree as a folder in ide.config.workspaceConfigPath, then open the workspace',
-          },
-          {
-            name: 'Open separate windows',
-            value: 'windows',
-            description: 'Open each created worktree in its own Cursor window',
-          },
-          { name: 'Skip', value: 'none', description: 'Do not open Cursor' },
-        ],
-      }))
-
-    if (typeof cursor === 'undefined' && !cursorConfig?.mode) {
-      commandEcho.setInteractive()
-    }
 
-    commandEcho.addOption('--cursor', cursorMode)
+    // One attach style: every configured editor gets the worktrees added to its
+    // workspace. Per-run skip is `--ide none` / `--no-ide`; no editor configured
+    // means there's nothing to open.
+    const ideMode: IdeMode = ide ?? (resolveConfiguredIdes(config).length > 0 ? 'workspace' : 'none')
+
+    commandEcho.addOption('--ide', ideMode)
 
     const openInGithubDesktop =
       githubDesktop ??
@@ -202,28 +182,8 @@ export const worktreesAdd = async (options: WorktreeManagementArgs) => {
 
     logResults(createdWorktrees)
 
-    if (cursorMode === 'workspace') {
-      if (!cursorConfig?.workspaceConfigPath) {
-        logger.warn('⚠️ Skipping Cursor: ide.config.workspaceConfigPath is not set in infra-kit config')
-      } else {
-        const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
-
-        const folderPaths = createdWorktrees.map((branch) => {
-          return `${worktreeDir}/${branch}`
-        })
-
-        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 $`cursor ${workspacePath}`
-      }
-    } else if (cursorMode === 'windows') {
-      for (const branch of createdWorktrees) {
-        await $`cursor ${worktreeDir}/${branch}`
-      }
+    if (ideMode === 'workspace') {
+      await addIdeWorktreeFolders({ projectRoot, worktreeDir, branches: createdWorktrees })
     }
 
     if (openInGithubDesktop) {
@@ -369,12 +329,16 @@ export const worktreesAddMcpTool = defineMcpTool({
       .describe(
         'Comma-separated release versions or names to target (e.g. "1.2.5, 1.2.6" or "checkout-redesign, 1.2.5"). Either "versions" or all=true must be provided for MCP calls. Overrides "all" when set.',
       ),
-    cursor: z
-      .enum(CURSOR_MODES)
+    ide: z
+      .enum(IDE_MODES)
       .optional()
       .describe(
-        'Cursor open mode for created worktrees. "workspace" appends each worktree as a folder to "ide.config.workspaceConfigPath" in infra-kit config and opens the workspace. "windows" opens each worktree in its own Cursor window. "none" skips Cursor. Resolution order: this flag → "ide.config.mode" from infra-kit config → interactive prompt (CLI) / "none" (MCP, no TTY).',
+        'Editor open mode for created worktrees, applied to all configured editors (Cursor and/or Zed, per the "ide" config). "workspace" (the only attach style) adds each worktree to every configured editor workspace and opens it. "none" skips the editor. Resolution order: this flag → "workspace" when at least one "ide" is configured → "none" otherwise.',
       ),
+    cursor: z
+      .enum(IDE_MODES)
+      .optional()
+      .describe('Deprecated alias for "ide". Prefer "ide". Ignored when "ide" is provided.'),
     githubDesktop: z
       .boolean()
       .optional()

package/src/commands/worktrees-open/worktrees-open.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod'
-import { $ } from 'zx'
 
 import {
   buildCmuxWorkspaceTitle,
@@ -7,26 +6,27 @@ import {
   listCmuxWorkspaceTitles,
   openCmuxWorkspaceWithLayout,
 } from 'src/integrations/cmux'
-import { reconcileCursorWorkspaceFolders, resolveCursorWorkspacePath } from 'src/integrations/cursor'
+import { ideProviderLabel, openIdeWorkspace } from 'src/integrations/ide'
+import type { IdeProvider } from 'src/integrations/ide'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { OperationError } from 'src/lib/errors/operation-error'
 import { getCurrentWorktrees, getProjectRoot, getRepoName } from 'src/lib/git-utils'
-import { getInfraKitConfig } from 'src/lib/infra-kit-config'
 import { logger } from 'src/lib/logger'
 import { defineMcpTool, textContent } from 'src/types'
 
 interface WorktreesOpenResult {
   openedCmux: string[]
   skippedCmux: string[]
-  cursorFoldersAdded: number
-  cursorFoldersRemoved: number
+  ideProviders: IdeProvider[]
+  ideFoldersAdded: number
+  ideFoldersRemoved: number
 }
 
 /**
- * Cold-start restore command: reconciles `Main.code-workspace` against the set
- * of release worktrees on disk, opens Cursor against it, and ensures one cmux
- * workspace exists per worktree. Idempotent and additive — never removes
+ * Cold-start restore command: reconciles the configured editor workspace against
+ * the set of release worktrees on disk, opens the editor against it, and ensures
+ * one cmux workspace exists per worktree. Idempotent and additive — never removes
  * worktrees, never recreates running cmux workspaces.
  */
 export const worktreesOpen = async () => {
@@ -37,17 +37,38 @@ export const worktreesOpen = async () => {
     const worktreeDir = `${projectRoot}${WORKTREES_DIR_SUFFIX}`
     const currentBranches = await getCurrentWorktrees('release')
 
-    const cursorOutcome = await openCursor({ projectRoot, worktreeDir, currentBranches })
+    const ideOutcomes = await openIdeWorkspace({
+      projectRoot,
+      worktreeDir,
+      currentBranches,
+      skipRelaunchWhenEmpty: false,
+    })
     const cmuxOutcome = await openCmux({ worktreeDir, currentBranches })
 
     const result: WorktreesOpenResult = {
       openedCmux: cmuxOutcome.opened,
       skippedCmux: cmuxOutcome.skipped,
-      cursorFoldersAdded: cursorOutcome.added,
-      cursorFoldersRemoved: cursorOutcome.removed,
+      ideProviders: ideOutcomes
+        .filter((outcome) => {
+          return outcome.ran
+        })
+        .map((outcome) => {
+          return outcome.provider
+        }),
+      ideFoldersAdded: ideOutcomes.reduce((sum, outcome) => {
+        return sum + outcome.added
+      }, 0),
+      ideFoldersRemoved: ideOutcomes.reduce((sum, outcome) => {
+        return sum + outcome.removed
+      }, 0),
     }
 
-    logResults(result, { cursorRan: cursorOutcome.ran, cmuxRan: cmuxOutcome.ran })
+    logResults(result, {
+      ideRan: ideOutcomes.some((outcome) => {
+        return outcome.ran
+      }),
+      cmuxRan: cmuxOutcome.ran,
+    })
 
     commandEcho.print()
 
@@ -64,49 +85,6 @@ export const worktreesOpen = async () => {
   }
 }
 
-interface OpenCursorArgs {
-  projectRoot: string
-  worktreeDir: string
-  currentBranches: string[]
-}
-
-interface OpenCursorOutcome {
-  ran: boolean
-  added: number
-  removed: number
-}
-
-const openCursor = async (args: OpenCursorArgs): Promise<OpenCursorOutcome> => {
-  const { projectRoot, worktreeDir, currentBranches } = args
-
-  const config = await getInfraKitConfig()
-  const cursorConfig = config.ide?.provider === 'cursor' ? config.ide.config : undefined
-
-  if (!cursorConfig || cursorConfig.mode !== 'workspace' || !cursorConfig.workspaceConfigPath) {
-    logger.warn('⚠️ Skipping Cursor: ide.provider must be "cursor", mode "workspace", and workspaceConfigPath set.')
-
-    return { ran: false, added: 0, removed: 0 }
-  }
-
-  const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
-
-  try {
-    const { added, removed } = await reconcileCursorWorkspaceFolders({
-      workspacePath,
-      worktreeDir,
-      currentBranches,
-    })
-
-    await $`cursor ${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 }
-  }
-}
-
 interface OpenCmuxArgs {
   worktreeDir: string
   currentBranches: string[]
@@ -153,18 +131,24 @@ export const openCmux = async (args: OpenCmuxArgs): Promise<OpenCmuxOutcome> =>
 }
 
 interface LogResultsContext {
-  cursorRan: boolean
+  ideRan: boolean
   cmuxRan: boolean
 }
 
 const logResults = (result: WorktreesOpenResult, context: LogResultsContext): void => {
-  if (context.cursorRan) {
-    if (result.cursorFoldersAdded > 0) {
-      logger.info(`✅ Added ${result.cursorFoldersAdded} folder(s) to Cursor workspace`)
+  if (context.ideRan) {
+    const ideLabels = result.ideProviders
+      .map((provider) => {
+        return ideProviderLabel(provider)
+      })
+      .join(', ')
+
+    if (result.ideFoldersAdded > 0) {
+      logger.info(`✅ Added ${result.ideFoldersAdded} folder(s) to ${ideLabels} workspace(s)`)
     }
 
-    if (result.cursorFoldersRemoved > 0) {
-      logger.info(`🧹 Removed ${result.cursorFoldersRemoved} dangling folder(s) from Cursor workspace`)
+    if (result.ideFoldersRemoved > 0) {
+      logger.info(`🧹 Removed ${result.ideFoldersRemoved} dangling folder(s) from ${ideLabels} workspace(s)`)
     }
   }
 
@@ -180,11 +164,11 @@ const logResults = (result: WorktreesOpenResult, context: LogResultsContext): vo
   }
 
   if (
-    !context.cursorRan &&
+    !context.ideRan &&
     result.openedCmux.length === 0 &&
     result.skippedCmux.length === 0 &&
-    result.cursorFoldersAdded === 0 &&
-    result.cursorFoldersRemoved === 0
+    result.ideFoldersAdded === 0 &&
+    result.ideFoldersRemoved === 0
   ) {
     logger.info('ℹ️ Nothing to open')
   }
@@ -194,15 +178,18 @@ const logResults = (result: WorktreesOpenResult, context: LogResultsContext): vo
 export const worktreesOpenMcpTool = defineMcpTool({
   name: 'worktrees-open',
   description:
-    'Open Cursor against the configured workspace file and ensure a cmux workspace exists for each existing release worktree. Idempotent and additive — never removes worktrees, never recreates running cmux workspaces. Use after a cold start (Cursor + cmux closed). For stale-worktree cleanup, use worktrees-sync.',
+    'Open every configured editor (Cursor and/or Zed) against its workspace and ensure a cmux workspace exists for each existing release worktree. Idempotent and additive — never removes worktrees, never recreates running cmux workspaces. Use after a cold start (editor + cmux closed). For stale-worktree cleanup, use worktrees-sync.',
   inputSchema: {},
   outputSchema: {
     openedCmux: z.array(z.string()).describe('Titles of cmux workspaces opened during this run'),
     skippedCmux: z.array(z.string()).describe('Titles of cmux workspaces that were already open'),
-    cursorFoldersAdded: z.number().describe('Number of worktree folders added to the Cursor workspace file'),
-    cursorFoldersRemoved: z
+    ideProviders: z
+      .array(z.string())
+      .describe('Configured IDE providers that were opened (cursor | zed); empty if none configured'),
+    ideFoldersAdded: z.number().describe('Total worktree folders added across all configured editor workspaces'),
+    ideFoldersRemoved: z
       .number()
-      .describe('Number of dangling worktree folders removed from the Cursor workspace file'),
+      .describe('Total dangling worktree folders removed across all configured editor workspaces'),
   },
   handler: worktreesOpen,
 })

package/src/commands/worktrees-reload/__tests__/reload-cmux.test.ts

@@ -0,0 +1,119 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { closeCmuxWorkspaceByTitle, listCmuxWorkspaceTitles, openCmuxWorkspaceWithLayout } from 'src/integrations/cmux'
+import { getRepoName } from 'src/lib/git-utils'
+
+import { closeCmux, reopenCmux } from '../worktrees-reload'
+
+vi.mock('src/integrations/cmux', async (importActual) => {
+  const actual = await importActual<typeof import('src/integrations/cmux')>()
+
+  return {
+    ...actual,
+    listCmuxWorkspaceTitles: vi.fn(),
+    closeCmuxWorkspaceByTitle: vi.fn(),
+    openCmuxWorkspaceWithLayout: vi.fn(),
+  }
+})
+
+vi.mock('src/lib/git-utils', () => {
+  return {
+    getRepoName: vi.fn(),
+    getProjectRoot: vi.fn(),
+    getCurrentWorktrees: vi.fn(),
+  }
+})
+
+const REPO = 'hulyo-monorepo'
+const WORKTREE_DIR = '/repos/project-worktrees'
+const BRANCHES = ['release/v1.48.0', 'release/checkout-redesign']
+
+const titleFor = {
+  versioned: `${REPO} 1.48.0`,
+  named: `${REPO} checkout-redesign`,
+}
+
+describe('closeCmux', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(getRepoName).mockResolvedValue(REPO)
+    vi.mocked(closeCmuxWorkspaceByTitle).mockResolvedValue(undefined)
+  })
+
+  it('closes only the branches whose workspace is open in the snapshot', async () => {
+    vi.mocked(listCmuxWorkspaceTitles).mockResolvedValue(new Set([titleFor.versioned]))
+
+    const closed = await closeCmux({ currentBranches: BRANCHES, repoName: REPO })
+
+    expect(closed).toEqual([titleFor.versioned])
+    expect(closeCmuxWorkspaceByTitle).toHaveBeenCalledTimes(1)
+    expect(closeCmuxWorkspaceByTitle).toHaveBeenCalledWith(titleFor.versioned)
+  })
+
+  it('closes every open branch when all are present in the snapshot', async () => {
+    vi.mocked(listCmuxWorkspaceTitles).mockResolvedValue(new Set([titleFor.versioned, titleFor.named]))
+
+    const closed = await closeCmux({ currentBranches: BRANCHES, repoName: REPO })
+
+    expect(closed).toEqual([titleFor.versioned, titleFor.named])
+    expect(closeCmuxWorkspaceByTitle).toHaveBeenCalledTimes(2)
+  })
+
+  it('closes nothing when none are open', async () => {
+    vi.mocked(listCmuxWorkspaceTitles).mockResolvedValue(new Set())
+
+    const closed = await closeCmux({ currentBranches: BRANCHES, repoName: REPO })
+
+    expect(closed).toEqual([])
+    expect(closeCmuxWorkspaceByTitle).not.toHaveBeenCalled()
+  })
+
+  it('returns [] and skips the snapshot when there are no worktrees', async () => {
+    const closed = await closeCmux({ currentBranches: [], repoName: REPO })
+
+    expect(closed).toEqual([])
+    expect(listCmuxWorkspaceTitles).not.toHaveBeenCalled()
+    expect(closeCmuxWorkspaceByTitle).not.toHaveBeenCalled()
+  })
+})
+
+describe('reopenCmux', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(getRepoName).mockResolvedValue(REPO)
+    vi.mocked(openCmuxWorkspaceWithLayout).mockResolvedValue(undefined)
+  })
+
+  it('force-opens a workspace for every branch (no dedup)', async () => {
+    const result = await reopenCmux({ worktreeDir: WORKTREE_DIR, currentBranches: BRANCHES, repoName: REPO })
+
+    expect(result.opened).toEqual([titleFor.versioned, titleFor.named])
+    expect(openCmuxWorkspaceWithLayout).toHaveBeenCalledTimes(2)
+    expect(openCmuxWorkspaceWithLayout).toHaveBeenCalledWith({
+      cwd: `${WORKTREE_DIR}/release/v1.48.0`,
+      title: titleFor.versioned,
+    })
+    expect(openCmuxWorkspaceWithLayout).toHaveBeenCalledWith({
+      cwd: `${WORKTREE_DIR}/release/checkout-redesign`,
+      title: titleFor.named,
+    })
+  })
+
+  it('continues past a per-branch failure and reopens the rest', async () => {
+    vi.mocked(openCmuxWorkspaceWithLayout)
+      .mockRejectedValueOnce(new Error('cmux boom'))
+      .mockResolvedValueOnce(undefined)
+
+    const result = await reopenCmux({ worktreeDir: WORKTREE_DIR, currentBranches: BRANCHES, repoName: REPO })
+
+    expect(result.opened).toEqual([titleFor.named])
+    expect(openCmuxWorkspaceWithLayout).toHaveBeenCalledTimes(2)
+  })
+
+  it('opens nothing when there are no worktrees', async () => {
+    const result = await reopenCmux({ worktreeDir: WORKTREE_DIR, currentBranches: [], repoName: REPO })
+
+    expect(result.opened).toEqual([])
+    expect(openCmuxWorkspaceWithLayout).not.toHaveBeenCalled()
+  })
+})

package/src/commands/worktrees-reload/index.ts

@@ -0,0 +1 @@
+export { worktreesReload, worktreesReloadMcpTool } from './worktrees-reload'