infra-kit 0.1.111 → 0.1.114

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'

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

@@ -0,0 +1,229 @@
+import { z } from 'zod'
+
+import {
+  buildCmuxWorkspaceTitle,
+  canonicalizeCmuxTitle,
+  closeCmuxWorkspaceByTitle,
+  listCmuxWorkspaceTitles,
+  openCmuxWorkspaceWithLayout,
+} from 'src/integrations/cmux'
+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 { logger } from 'src/lib/logger'
+import { defineMcpTool, textContent } from 'src/types'
+
+interface WorktreesReloadResult {
+  closedCmux: string[]
+  openedCmux: string[]
+  ideProviders: IdeProvider[]
+  ideFoldersAdded: number
+  ideFoldersRemoved: number
+}
+
+/**
+ * Reload command: closes every open cmux workspace for the release worktrees on
+ * disk, then reopens the full set — cmux workspaces are recreated fresh and the
+ * configured editor workspace is reconciled and relaunched. Unlike the additive
+ * `worktrees-open`, this is disruptive: it tears down live cmux windows first.
+ *
+ * The editor has no per-window close primitive, so its "reload" is a reconcile +
+ * relaunch of the configured workspace. Safe to run from any branch
+ * (non-destructive to git — only cmux/editor view state is touched).
+ */
+export const worktreesReload = async () => {
+  commandEcho.start('worktrees-reload')
+
+  try {
+    const projectRoot = await getProjectRoot()
+    const worktreeDir = `${projectRoot}${WORKTREES_DIR_SUFFIX}`
+    const currentBranches = await getCurrentWorktrees('release')
+    const repoName = await getRepoName()
+
+    // Phase 1 — close (cmux only; Cursor has no per-window close).
+    const closedCmux = await closeCmux({ currentBranches, repoName })
+
+    // Phase 2 — reopen. cmux and Cursor are independent surfaces, so reopen them
+    // concurrently to shrink the window where the just-closed cmux workspaces are gone.
+    const [ideOutcomes, { opened: openedCmux }] = await Promise.all([
+      openIdeWorkspace({ projectRoot, worktreeDir, currentBranches, skipRelaunchWhenEmpty: true }),
+      reopenCmux({ worktreeDir, currentBranches, repoName }),
+    ])
+
+    const result: WorktreesReloadResult = {
+      closedCmux,
+      openedCmux,
+      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, {
+      ideRan: ideOutcomes.some((outcome) => {
+        return outcome.ran
+      }),
+    })
+
+    commandEcho.print()
+
+    return {
+      content: textContent(JSON.stringify(result, null, 2)),
+      structuredContent: { ...result },
+    }
+  } catch (error) {
+    logger.error({ error }, '❌ Error reloading worktrees')
+    throw new OperationError(error, {
+      operation: 'reload worktrees',
+      remediation: "run 'worktrees-list' to confirm the branches exist",
+    })
+  }
+}
+
+interface CloseCmuxArgs {
+  currentBranches: string[]
+  repoName: string
+}
+
+/**
+ * Close the cmux workspace for each release worktree that is currently open.
+ * Snapshots `listCmuxWorkspaceTitles()` up front purely so the returned list
+ * reflects which workspaces were actually open (the close itself is best-effort
+ * and per-title). Returns the titles a close was attempted for.
+ */
+export const closeCmux = async (args: CloseCmuxArgs): Promise<string[]> => {
+  const { currentBranches, repoName } = args
+
+  if (currentBranches.length === 0) {
+    return []
+  }
+
+  const openBefore = await listCmuxWorkspaceTitles()
+
+  const closed: string[] = []
+
+  for (const branch of currentBranches) {
+    const title = buildCmuxWorkspaceTitle({ repoName, branch })
+
+    // openBefore holds canonical keys; match the built title the same way so a
+    // workspace stored under a drifted title (whitespace / old v-prefix) resolves.
+    if (!openBefore.has(canonicalizeCmuxTitle(title))) {
+      continue
+    }
+
+    await closeCmuxWorkspaceByTitle(title)
+    closed.push(title)
+  }
+
+  return closed
+}
+
+interface ReopenCmuxArgs {
+  worktreeDir: string
+  currentBranches: string[]
+  repoName: string
+}
+
+interface ReopenCmuxOutcome {
+  opened: string[]
+}
+
+/**
+ * Recreate a cmux workspace for every release worktree on disk. Force-opens each
+ * branch (no dedup against the live workspace list): reload has just awaited the
+ * close of these workspaces, so it favours liveness — guaranteeing every branch
+ * ends up open — over the additive dedup that `worktrees-open` relies on.
+ */
+export const reopenCmux = async (args: ReopenCmuxArgs): Promise<ReopenCmuxOutcome> => {
+  const { worktreeDir, currentBranches, repoName } = args
+
+  const opened: string[] = []
+
+  for (const branch of currentBranches) {
+    const title = buildCmuxWorkspaceTitle({ repoName, branch })
+
+    try {
+      await openCmuxWorkspaceWithLayout({ cwd: `${worktreeDir}/${branch}`, title })
+      opened.push(title)
+    } catch (error) {
+      logger.warn({ error, title }, `⚠️ Failed to reopen cmux workspace for ${branch}`)
+    }
+  }
+
+  return { opened }
+}
+
+interface LogResultsContext {
+  ideRan: boolean
+}
+
+const logResults = (result: WorktreesReloadResult, context: LogResultsContext): void => {
+  if (result.closedCmux.length > 0) {
+    logger.info(`🧹 Closed ${result.closedCmux.length} cmux workspace(s)`)
+  }
+
+  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.ideFoldersRemoved > 0) {
+      logger.info(`🧹 Removed ${result.ideFoldersRemoved} dangling folder(s) from ${ideLabels} workspace(s)`)
+    }
+  }
+
+  if (result.openedCmux.length > 0) {
+    logger.info('✅ Reopened cmux workspaces:')
+    for (const title of result.openedCmux) {
+      logger.info(title)
+    }
+  }
+
+  if (
+    !context.ideRan &&
+    result.closedCmux.length === 0 &&
+    result.openedCmux.length === 0 &&
+    result.ideFoldersAdded === 0 &&
+    result.ideFoldersRemoved === 0
+  ) {
+    logger.info('ℹ️ Nothing to reload')
+  }
+}
+
+// MCP Tool Registration
+export const worktreesReloadMcpTool = defineMcpTool({
+  name: 'worktrees-reload',
+  description:
+    'Close all open cmux workspaces for the current release worktrees, then reopen the full set. Disruptive — closes live cmux windows (unlike the additive worktrees-open). Every configured editor (Cursor and/or Zed) is reconciled + relaunched (no per-window close). Safe to run from any branch. Use to refresh stale windows after restarting cmux/the editor.',
+  inputSchema: {},
+  outputSchema: {
+    closedCmux: z.array(z.string()).describe('Titles of cmux workspaces a close was attempted for (best-effort)'),
+    openedCmux: z.array(z.string()).describe('Titles of cmux workspaces reopened during this run'),
+    ideProviders: z
+      .array(z.string())
+      .describe('Configured IDE providers that were reloaded (cursor | zed); empty if none configured'),
+    ideFoldersAdded: z.number().describe('Total worktree folders added across all configured editor workspaces'),
+    ideFoldersRemoved: z
+      .number()
+      .describe('Total dangling worktree folders removed across all configured editor workspaces'),
+  },
+  handler: worktreesReload,
+})

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

@@ -3,14 +3,13 @@ import confirm from '@inquirer/confirm'
 import process from 'node:process'
 import { z } from 'zod'
 
-import { removeFoldersFromCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
 import { getReleasePRsWithInfo } from 'src/integrations/gh'
+import { removeIdeWorktreeFolders } 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 { logger } from 'src/lib/logger'
 import { formatBranchName, parseReleaseRef } from 'src/lib/release-id'
 import { detectReleaseType, formatBranchChoices, getJiraDescriptions, releaseBranchLabels } from 'src/lib/release-utils'
@@ -119,7 +118,7 @@ export const worktreesRemove = async (options: WorktreeManagementArgs) => {
       pruneFolder: allSelected,
     })
 
-    await syncCursorWorkspaceOnRemove({ removedWorktrees, worktreeDir, projectRoot })
+    await removeIdeWorktreeFolders({ projectRoot, worktreeDir, branches: removedWorktrees })
 
     logResults(removedWorktrees)
 
@@ -143,47 +142,6 @@ export const worktreesRemove = async (options: WorktreeManagementArgs) => {
   }
 }
 
-interface SyncCursorWorkspaceOnRemoveArgs {
-  removedWorktrees: string[]
-  worktreeDir: string
-  projectRoot: string
-}
-
-/**
- * Strip removed worktrees from the configured Cursor workspace's `folders` array.
- * No-op if Cursor isn't configured, mode isn't "workspace", or no worktrees were removed.
- */
-const syncCursorWorkspaceOnRemove = async (args: SyncCursorWorkspaceOnRemoveArgs): Promise<void> => {
-  const { removedWorktrees, worktreeDir, projectRoot } = args
-
-  if (removedWorktrees.length === 0) {
-    return
-  }
-
-  const config = await getInfraKitConfig()
-  const cursorConfig = config.ide?.provider === 'cursor' ? config.ide.config : undefined
-
-  if (!cursorConfig || cursorConfig.mode !== 'workspace' || !cursorConfig.workspaceConfigPath) {
-    return
-  }
-
-  const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
-
-  const folderPaths = removedWorktrees.map((branch) => {
-    return `${worktreeDir}/${branch}`
-  })
-
-  try {
-    const { removed } = await removeFoldersFromCursorWorkspace({ workspacePath, folderPaths })
-
-    if (removed.length > 0) {
-      logger.info(`✅ Removed ${removed.length} folder(s) from ${workspacePath}`)
-    }
-  } catch (error) {
-    logger.warn({ error }, `⚠️ Failed to update Cursor workspace at ${workspacePath}`)
-  }
-}
-
 /**
  * Log the results of worktree management
  */

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

@@ -4,14 +4,13 @@ import { z } from 'zod'
 import { $ } from 'zx'
 
 import { buildCmuxWorkspaceTitle, closeCmuxWorkspaceByTitle } from 'src/integrations/cmux'
-import { removeFoldersFromCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
 import { getReleasePRs } from 'src/integrations/gh'
+import { removeIdeWorktreeFolders } 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 { logger } from 'src/lib/logger'
 import { isReleaseBranch } from 'src/lib/release-id'
 import { defineMcpTool, textContent } from 'src/types'
@@ -73,7 +72,7 @@ export const worktreesSync = async (options: WorktreeSyncArgs) => {
       repoName,
     })
 
-    await syncCursorWorkspaceOnRemove({ removedWorktrees, worktreeDir, projectRoot })
+    await removeIdeWorktreeFolders({ projectRoot, worktreeDir, branches: removedWorktrees })
 
     logResults(removedWorktrees)
 
@@ -156,47 +155,6 @@ const removeWorktrees = async (args: RemoveWorktreesArgs): Promise<string[]> =>
   return removed
 }
 
-interface SyncCursorWorkspaceOnRemoveArgs {
-  removedWorktrees: string[]
-  worktreeDir: string
-  projectRoot: string
-}
-
-/**
- * Strip removed worktrees from the configured Cursor workspace's `folders` array.
- * No-op if Cursor isn't configured, mode isn't "workspace", or no worktrees were removed.
- */
-const syncCursorWorkspaceOnRemove = async (args: SyncCursorWorkspaceOnRemoveArgs): Promise<void> => {
-  const { removedWorktrees, worktreeDir, projectRoot } = args
-
-  if (removedWorktrees.length === 0) {
-    return
-  }
-
-  const config = await getInfraKitConfig()
-  const cursorConfig = config.ide?.provider === 'cursor' ? config.ide.config : undefined
-
-  if (!cursorConfig || cursorConfig.mode !== 'workspace' || !cursorConfig.workspaceConfigPath) {
-    return
-  }
-
-  const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
-
-  const folderPaths = removedWorktrees.map((branch) => {
-    return `${worktreeDir}/${branch}`
-  })
-
-  try {
-    const { removed: removedEntries } = await removeFoldersFromCursorWorkspace({ workspacePath, folderPaths })
-
-    if (removedEntries.length > 0) {
-      logger.info(`✅ Removed ${removedEntries.length} folder(s) from ${workspacePath}`)
-    }
-  } catch (error) {
-    logger.warn({ error }, `⚠️ Failed to update Cursor workspace at ${workspacePath}`)
-  }
-}
-
 /**
  * Log the results of worktree management
  */

package/src/entry/cli.ts

@@ -18,12 +18,14 @@ import { init } from 'src/commands/init'
 import { releaseCreate } from 'src/commands/release-create'
 import { releaseDescEdit } from 'src/commands/release-desc-edit'
 import { version } from 'src/commands/version'
-import { CURSOR_MODES, worktreesAdd } from 'src/commands/worktrees-add'
-import type { CursorMode } from 'src/commands/worktrees-add'
+import { worktreesAdd } from 'src/commands/worktrees-add'
 import { worktreesList } from 'src/commands/worktrees-list'
 import { worktreesOpen } from 'src/commands/worktrees-open'
+import { worktreesReload } from 'src/commands/worktrees-reload'
 import { worktreesRemove } from 'src/commands/worktrees-remove'
 import { worktreesSync } from 'src/commands/worktrees-sync'
+import { IDE_MODES } from 'src/integrations/ide'
+import type { IdeMode } from 'src/integrations/ide'
 import { logger } from 'src/lib/logger'
 import { parseReleaseSpec } from 'src/lib/version-utils'
 import type { ReleaseInput } from 'src/lib/version-utils'
@@ -34,7 +36,7 @@ const collectReleaseSpec = (value: string, prev: string[]): string[] => {
   return [...prev, value]
 }
 
-const normalizeCursorMode = (value: unknown): CursorMode | undefined => {
+const normalizeIdeMode = (value: unknown, flagName: '--ide' | '--cursor'): IdeMode | undefined => {
   if (typeof value === 'undefined') {
     return undefined
   }
@@ -47,11 +49,11 @@ const normalizeCursorMode = (value: unknown): CursorMode | undefined => {
     return 'none'
   }
 
-  if (typeof value === 'string' && (CURSOR_MODES as readonly string[]).includes(value)) {
-    return value as CursorMode
+  if (typeof value === 'string' && (IDE_MODES as readonly string[]).includes(value)) {
+    return value as IdeMode
   }
 
-  throw new Error(`Invalid --cursor value "${String(value)}". Expected one of: ${CURSOR_MODES.join(', ')}.`)
+  throw new Error(`Invalid ${flagName} value "${String(value)}". Expected one of: ${IDE_MODES.join(', ')}.`)
 }
 
 const runProgram = async (argv?: string[]): Promise<void> => {
@@ -175,18 +177,23 @@ program
   .option('-y, --yes', 'Skip confirmation prompt')
   .option('-a, --all', 'Select all active release branches')
   .option('-v, --versions <versions>', 'Specify versions by comma, e.g. 1.2.5, 1.2.6')
-  .option('-c, --cursor [mode]', 'Cursor mode for created worktrees: workspace (default) | windows | none')
-  .option('--no-cursor', 'Skip Cursor (alias for --cursor none)')
+  .option('-i, --ide [mode]', 'Editor mode for created worktrees: workspace (default) | none')
+  .option('--no-ide', 'Skip the editor (alias for --ide none)')
+  .option('-c, --cursor [mode]', 'Deprecated alias for --ide')
+  .option('--no-cursor', 'Deprecated alias for --no-ide')
   .option('-g, --github-desktop', 'Open created worktrees in GitHub Desktop')
   .option('--no-github-desktop', 'Skip GitHub Desktop prompt')
   .option('-m, --cmux', 'Open created worktrees in cmux (3-pane layout)')
   .option('--no-cmux', 'Skip cmux prompt')
   .action(async (options) => {
+    // `--ide` wins over the deprecated `--cursor` alias when both are provided.
+    const ide = normalizeIdeMode(options.ide, '--ide') ?? normalizeIdeMode(options.cursor, '--cursor')
+
     await worktreesAdd({
       confirmedCommand: options.yes,
       all: options.all,
       versions: options.versions,
-      cursor: normalizeCursorMode(options.cursor),
+      ide,
       githubDesktop: options.githubDesktop,
       cmux: options.cmux,
     })
@@ -211,11 +218,18 @@ program
 
 program
   .command('worktrees-open')
-  .description('Open Cursor + cmux for existing release worktrees (cold-start restore)')
+  .description('Open the configured editor (Cursor/Zed) + cmux for existing release worktrees (cold-start restore)')
   .action(async () => {
     await worktreesOpen()
   })
 
+program
+  .command('worktrees-reload')
+  .description('Close all cmux/editor worktree windows, then reopen the current release worktrees')
+  .action(async () => {
+    await worktreesReload()
+  })
+
 const configCmd = program.command('config').description('Manage infra-kit configuration files')
 
 configCmd
@@ -305,7 +319,14 @@ if (process.argv.length <= 2) {
     'release-deploy-selected',
     'release-deliver',
   ]
-  const worktreeCommands = ['worktrees-add', 'worktrees-list', 'worktrees-open', 'worktrees-remove', 'worktrees-sync']
+  const worktreeCommands = [
+    'worktrees-add',
+    'worktrees-list',
+    'worktrees-open',
+    'worktrees-reload',
+    'worktrees-remove',
+    'worktrees-sync',
+  ]
   const envCommands = [
     'audit',
     'doctor',

package/src/integrations/cursor/.omc/state/agent-replay-f99d8dad-81d1-4987-8183-62edf0843d0c.jsonl

@@ -0,0 +1,2 @@
+{"t":0,"agent":"system","event":"skill_invoked","skill_name":"oh-my-claudecode:cancel"}
+{"t":0,"agent":"a56b8e3","agent_type":"unknown","event":"agent_stop","success":true,"duration_ms":0}

package/src/integrations/cursor/.omc/state/idle-notif-cooldown.json

@@ -0,0 +1,3 @@
+{
+  "lastSentAt": "2026-06-22T07:10:20.378Z"
+}

package/src/integrations/cursor/.omc/state/sessions/f99d8dad-81d1-4987-8183-62edf0843d0c/pre-tool-advisory-throttle.json

@@ -0,0 +1,18 @@
+{
+  "version": 1,
+  "entries": {
+    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
+      "last_emitted_at_ms": 1782112155382,
+      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
+    },
+    "466399dafa2d20f60587180bad0a07358eb7f2bce724df0ff682f038ad33f5ad": {
+      "last_emitted_at_ms": 1782112102061,
+      "message": "Read multiple files in parallel when possible for faster analysis."
+    },
+    "445ed27a3872b681d98190bae61ccb84954e1bc4e140df5370be958dee776b3a": {
+      "last_emitted_at_ms": 1782112093035,
+      "message": "Verify changes work after editing. Test functionality before marking complete."
+    }
+  },
+  "updated_at": "2026-06-22T07:09:15.382Z"
+}

package/src/integrations/cursor/.omc/state/sessions/f99d8dad-81d1-4987-8183-62edf0843d0c/subagent-tracking-state.json

@@ -0,0 +1,17 @@
+{
+  "agents": [
+    {
+      "agent_id": "a56b8e33689099584",
+      "agent_type": "unknown",
+      "started_at": "2026-06-22T07:13:23.151Z",
+      "parent_mode": "none",
+      "status": "completed",
+      "completed_at": "2026-06-22T07:13:23.151Z",
+      "duration_ms": 0
+    }
+  ],
+  "total_spawned": 0,
+  "total_completed": 1,
+  "total_failed": 0,
+  "last_updated": "2026-06-22T07:13:23.253Z"
+}

package/src/integrations/cursor/index.ts

@@ -1,4 +1,6 @@
 export { addFoldersToCursorWorkspace } from './add-folders-to-workspace'
+export { launchCursor } from './launch-cursor'
+export { openCursorWorkspace } from './open-cursor-workspace'
 export { reconcileCursorWorkspaceFolders } from './reconcile-workspace-folders'
 export { removeFoldersFromCursorWorkspace } from './remove-folders-from-workspace'
 export { resolveCursorWorkspacePath } from './resolve-workspace-path'

package/src/integrations/cursor/launch-cursor.ts

@@ -0,0 +1,12 @@
+import { $ } from 'zx'
+
+/**
+ * Spawns Cursor against a `.code-workspace` file (or any path). Centralised here
+ * — rather than inlined at each call site — so the editor spawn lives inside the
+ * cursor provider module and is covered by a single `vi.mock('src/integrations/cursor')`.
+ * Keeping it out of the IDE-orchestration layer is what stops tests that mock the
+ * provider (but not `zx`) from shelling out to a real editor.
+ */
+export const launchCursor = async (workspacePath: string): Promise<void> => {
+  await $`cursor ${workspacePath}`
+}