infra-kit 0.1.114 → 0.1.117

package/src/commands/vendor-config/vendor-config.ts

@@ -0,0 +1,162 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+import { pathToFileURL } from 'node:url'
+
+import { getProjectRoot } from 'src/lib/git-utils'
+import { logger } from 'src/lib/logger'
+import { fileExists, tildify } from 'src/lib/path-display'
+import { VENDOR_CONFIG_FILE } from 'src/lib/vendor/config-schema'
+import { expandTilde, getFactoryConfigPath, loadFactoryConfig } from 'src/lib/vendor/factory-config'
+
+interface VendorConfigOptions {
+  /** Scaffold `~/.infra-kit/vendor.json` instead of printing the current one. */
+  init?: boolean
+  /** Source repo root used for legacy `targets` auto-seeding. Defaults to the git toplevel. */
+  cwd?: string
+}
+
+/** Placeholder workspace dir written by `--init`; the user edits it to their layout. */
+const PLACEHOLDER_WORKSPACE_DIR = '~/projects'
+
+/**
+ * Surface or scaffold the machine-local factory config
+ * (`~/.infra-kit/vendor.json`). CLI-only — NOT an MCP tool; returns nothing
+ * and signals problems via `process.exitCode`.
+ *
+ * Without `--init`: prints the factory file path + existence, the resolved
+ * `workspaceDir` + existence, and per-target reachability (`[✓]`/`[ ]`). Exits
+ * non-zero if the file is missing, the workspace dir is missing, or any target
+ * is unreachable, so it is usable as a doctor check.
+ *
+ * With `--init`: scaffolds the file (skipping if it already exists), seeding
+ * `targets` from a legacy source `vendor.config.ts` when one is readable.
+ */
+export const vendorConfig = async (options: VendorConfigOptions = {}): Promise<void> => {
+  if (options.init) {
+    await initFactoryConfig(options.cwd)
+
+    return
+  }
+
+  await printFactoryConfig()
+}
+
+/** Render the factory config chain with `[✓]`/`[ ]` reachability markers. */
+const printFactoryConfig = async (): Promise<void> => {
+  const factoryPath = getFactoryConfigPath()
+  const exists = await fileExists(factoryPath)
+
+  logger.info(`Factory config: ${tildify(factoryPath)}   ${exists ? '[✓]' : '[ ]'}`)
+
+  if (!exists) {
+    logger.info('\nNot found — run `infra-kit vendor-config --init` to scaffold it.')
+    process.exitCode = 1
+
+    return
+  }
+
+  const { workspaceDir, targets } = await loadFactoryConfig()
+  const resolvedWorkspace = expandTilde(workspaceDir)
+  const workspaceExists = await fileExists(resolvedWorkspace)
+
+  logger.info(
+    `workspaceDir:   ${workspaceDir}   (resolved: ${resolvedWorkspace})   ${workspaceExists ? '[✓ exists]' : '[ ] not found'}`,
+  )
+  logger.info('Targets:')
+
+  let allReachable = workspaceExists
+
+  for (const repo of targets) {
+    const targetPath = path.join(resolvedWorkspace, repo)
+    const reachable = await fileExists(targetPath)
+
+    if (!reachable) {
+      allReachable = false
+    }
+
+    const marker = reachable ? '[✓]' : '[ ]'
+    const suffix = reachable ? '' : '   (not found — clone or remove)'
+
+    logger.info(`  ${marker} ${repo}   ${tildify(targetPath)}${suffix}`)
+  }
+
+  if (!allReachable) {
+    process.exitCode = 1
+  }
+}
+
+/** Scaffold `~/.infra-kit/vendor.json`, skipping if it already exists. */
+const initFactoryConfig = async (cwd?: string): Promise<void> => {
+  const factoryPath = getFactoryConfigPath()
+
+  if (await fileExists(factoryPath)) {
+    logger.info(`Factory config already exists at ${tildify(factoryPath)} — leaving it untouched.`)
+
+    return
+  }
+
+  const sourceRoot = cwd ?? (await getProjectRoot())
+  const seededTargets = await readLegacyTargets(sourceRoot)
+
+  await fs.mkdir(path.dirname(factoryPath), { recursive: true })
+  await fs.writeFile(factoryPath, buildScaffold(seededTargets), 'utf-8')
+
+  logger.info(`✓ Created ${tildify(factoryPath)}`)
+
+  if (seededTargets.length > 0) {
+    logger.info(`  Seeded ${seededTargets.length} target(s) from the source ${VENDOR_CONFIG_FILE}.`)
+  }
+
+  logger.info(`  Edit \`workspaceDir\` (placeholder: ${PLACEHOLDER_WORKSPACE_DIR}) to point at where your repos live.`)
+
+  if (seededTargets.length === 0) {
+    logger.info('  Add at least one repo name to `targets` before running vendor sync/manifest/diff.')
+  }
+}
+
+/**
+ * Best-effort read of a legacy `targets` array from the source repo's
+ * `vendor.config.ts`. The current schema no longer accepts `targets`, so this
+ * reads the raw default export directly (bypassing validation). Returns `[]` on
+ * any failure — seeding is a convenience, never a hard requirement.
+ */
+const readLegacyTargets = async (sourceRoot: string): Promise<string[]> => {
+  try {
+    const configPath = path.join(sourceRoot, VENDOR_CONFIG_FILE)
+    const stat = await fs.stat(configPath)
+    const moduleUrl = `${pathToFileURL(configPath).href}?mtime=${Number(stat.mtimeMs)}`
+    const imported = (await import(moduleUrl)) as { default?: unknown }
+    const raw = imported.default
+    const resolved = typeof raw === 'function' ? await (raw as () => unknown)() : raw
+
+    if (resolved && typeof resolved === 'object' && 'targets' in resolved) {
+      const targets = (resolved as { targets?: unknown }).targets
+
+      if (
+        Array.isArray(targets) &&
+        targets.every((t) => {
+          return typeof t === 'string'
+        })
+      ) {
+        return targets as string[]
+      }
+    }
+  } catch {
+    // Absent or unreadable source config — fall through to an empty placeholder.
+  }
+
+  return []
+}
+
+/**
+ * Render the scaffold file body as strict JSON (`vendor.json`). The factory config
+ * is static JSON, loaded with `JSON.parse` — no comments, no executable code. When
+ * `targets` is empty the stub writes `"targets": []`, which fails the schema's
+ * `targets.min(1)` on load: this is intentional — `--init` produces an incomplete
+ * stub the user must edit before running vendor sync/manifest/diff. The annotated
+ * guidance lives in the sibling `vendor.example.jsonc` (seeded by `infra-kit init`).
+ */
+const buildScaffold = (targets: string[]): string => {
+  return `${JSON.stringify({ workspaceDir: PLACEHOLDER_WORKSPACE_DIR, targets }, null, 2)}\n`
+}

package/src/commands/vendor-diff/__tests__/vendor-diff.test.ts

@@ -0,0 +1,74 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { execMock, zxModuleMock } from 'src/lib/vendor/__tests__/zx-mock'
+
+import { vendorDiff } from '../vendor-diff'
+
+vi.mock('zx', () => {
+  return zxModuleMock()
+})
+
+let parent: string
+let home: string
+let sourceRoot: string
+let targetRoot: string
+
+const write = (root: string, rel: string, content: string): void => {
+  const full = path.join(root, rel)
+
+  fs.mkdirSync(path.dirname(full), { recursive: true })
+  fs.writeFileSync(full, content, 'utf8')
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+
+  parent = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-diff-test-'))
+  sourceRoot = path.join(parent, 'source-repo')
+  targetRoot = path.join(parent, 'target-repo')
+
+  // Machine-local factory config (workspaceDir + targets) lives under ~/.infra-kit;
+  // point os.homedir() at a fixture so the loader finds it.
+  home = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-diff-home-'))
+  vi.spyOn(os, 'homedir').mockReturnValue(home)
+  write(home, '.infra-kit/vendor.json', JSON.stringify({ workspaceDir: parent, targets: ['target-repo'] }))
+
+  write(sourceRoot, 'vendor/configs/a.js', 'aaa')
+  write(
+    sourceRoot,
+    'vendor.config.ts',
+    `export default { copy: [{ name: 'Configs', source: 'vendor/configs', target: 'vendor/configs', type: 'directory', vendored: true }] }`,
+  )
+  write(targetRoot, 'vendor/configs/a.js', 'DIFFERENT')
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  fs.rmSync(parent, { recursive: true, force: true })
+  fs.rmSync(home, { recursive: true, force: true })
+})
+
+describe('vendorDiff', () => {
+  it('reports drift when rsync dry-run returns changes', async () => {
+    execMock.mockResolvedValue({ stdout: '>f.st..... configs/a.js\n' })
+
+    const { structuredContent } = await vendorDiff({ cwd: sourceRoot })
+
+    expect(structuredContent.ok).toBe(false)
+    expect(structuredContent.drifted).toBe(1)
+    expect(structuredContent.entries[0]?.repo).toBe('target-repo')
+    expect(structuredContent.entries[0]?.changes).toContain('>f.st..... configs/a.js')
+  })
+
+  it('reports no drift when rsync dry-run is empty', async () => {
+    execMock.mockResolvedValue({ stdout: '' })
+
+    const { structuredContent } = await vendorDiff({ cwd: sourceRoot })
+
+    expect(structuredContent.ok).toBe(true)
+    expect(structuredContent.drifted).toBe(0)
+  })
+})

package/src/commands/vendor-diff/index.ts

@@ -0,0 +1 @@
+export { vendorDiff, vendorDiffMcpTool } from './vendor-diff'

package/src/commands/vendor-diff/vendor-diff.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod'
+
+import { getProjectRoot } from 'src/lib/git-utils'
+import { logger } from 'src/lib/logger'
+import { loadVendorConfig } from 'src/lib/vendor/config'
+import { loadFactoryConfig } from 'src/lib/vendor/factory-config'
+import { runDiff, selectTargets } from 'src/lib/vendor/sync-ops'
+import { defineMcpTool, textContent } from 'src/types'
+
+/** Max itemized changes to print per drifted path before truncating. */
+const MAX_REPORTED = 20
+
+interface VendorDiffOptions {
+  cwd?: string
+  repos?: string[]
+}
+
+/**
+ * Source-aware drift check: compare each target repo's `vendored:true` subtree
+ * against the source via `rsync --dry-run --delete`. Read-only (does NOT extend
+ * RequiredConfirmedOptionArg).
+ */
+export const vendorDiff = async (options: VendorDiffOptions = {}) => {
+  const sourceRoot = options.cwd ?? (await getProjectRoot())
+
+  const config = await loadVendorConfig(sourceRoot)
+  const factory = await loadFactoryConfig()
+  const targets = selectTargets(factory.targets, options.repos)
+
+  const entries = await runDiff(config, sourceRoot, factory.workspaceDir, targets)
+
+  if (entries.length === 0) {
+    logger.info('🎉 No drift detected.')
+  } else {
+    for (const entry of entries) {
+      logger.info(`❌ ${entry.repo} → ${entry.target} (${entry.changes.length} change(s)):`)
+
+      for (const change of entry.changes.slice(0, MAX_REPORTED)) {
+        logger.info(`   ${change}`)
+      }
+
+      if (entry.changes.length > MAX_REPORTED) {
+        logger.info(`   …and ${entry.changes.length - MAX_REPORTED} more`)
+      }
+    }
+  }
+
+  const structuredContent = { ok: entries.length === 0, drifted: entries.length, entries }
+
+  return { content: textContent(JSON.stringify(structuredContent, null, 2)), structuredContent }
+}
+
+const vendorDiffOutputSchema = {
+  ok: z.boolean().describe('Whether every target is in sync with the source'),
+  drifted: z.number(),
+  entries: z.array(
+    z.object({
+      repo: z.string(),
+      target: z.string(),
+      changes: z.array(z.string()),
+    }),
+  ),
+}
+
+// MCP Tool Registration (read-only; safe to expose).
+export const vendorDiffMcpTool = defineMcpTool({
+  name: 'vendor-diff',
+  description:
+    'Source-aware drift check: compare each target repo vendored subtree against the source via rsync dry-run. Read-only; run from the source repo root. ok=false when any target has drifted.',
+  inputSchema: {
+    repos: z.array(z.string()).optional().describe('Restrict to these target repo names'),
+  },
+  outputSchema: vendorDiffOutputSchema,
+  handler: (params) => {
+    return vendorDiff({ repos: params.repos })
+  },
+})

package/src/commands/vendor-manifest/index.ts

@@ -0,0 +1 @@
+export { vendorManifest, vendorManifestMcpTool } from './vendor-manifest'

package/src/commands/vendor-manifest/vendor-manifest.ts

@@ -0,0 +1,60 @@
+import path from 'node:path'
+import { z } from 'zod'
+
+import { getProjectRoot } from 'src/lib/git-utils'
+import { logger } from 'src/lib/logger'
+import { loadFactoryConfig } from 'src/lib/vendor/factory-config'
+import { getSourceCommit, runManifest, selectTargets } from 'src/lib/vendor/sync-ops'
+import { defineMcpTool, textContent } from 'src/types'
+import type { RequiredConfirmedOptionArg } from 'src/types'
+
+interface VendorManifestOptions extends RequiredConfirmedOptionArg {
+  cwd?: string
+  repos?: string[]
+}
+
+/**
+ * Regenerate each target repo's `vendor/.sync-manifest.json` + README from the
+ * CURRENT vendor content, without copying anything. Mutating (writes manifests).
+ */
+export const vendorManifest = async (options: VendorManifestOptions) => {
+  const sourceRoot = options.cwd ?? (await getProjectRoot())
+
+  const factory = await loadFactoryConfig()
+  const targets = selectTargets(factory.targets, options.repos)
+
+  const commit = await getSourceCommit(sourceRoot)
+  const source = path.basename(sourceRoot)
+
+  const repos = await runManifest(factory.workspaceDir, targets, { source, commit })
+
+  for (const repo of repos) {
+    logger.info(
+      repo.skipped ? `⚠️  ${repo.repo}: target does not exist — skipped` : `📝 ${repo.repo}: manifest written`,
+    )
+  }
+
+  const structuredContent = { source, commit, repos }
+
+  return { content: textContent(JSON.stringify(structuredContent, null, 2)), structuredContent }
+}
+
+const vendorManifestOutputSchema = {
+  source: z.string(),
+  commit: z.string(),
+  repos: z.array(z.object({ repo: z.string(), skipped: z.boolean() })),
+}
+
+// MCP Tool Registration (mutating).
+export const vendorManifestMcpTool = defineMcpTool({
+  name: 'vendor-manifest',
+  description:
+    'Regenerate each target repo vendor/.sync-manifest.json + README from current content without copying. Mutating; run from the source repo root.',
+  inputSchema: {
+    repos: z.array(z.string()).optional().describe('Restrict to these target repo names'),
+  },
+  outputSchema: vendorManifestOutputSchema,
+  handler: (params) => {
+    return vendorManifest({ repos: params.repos, confirmedCommand: params.confirmedCommand })
+  },
+})

package/src/commands/vendor-sync/__tests__/vendor-write.test.ts

@@ -0,0 +1,86 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { execMock, zxModuleMock } from 'src/lib/vendor/__tests__/zx-mock'
+
+import { vendorSync } from '../vendor-sync'
+
+// Mock zx so the write commands run without shelling out to rsync/cp/git.
+vi.mock('zx', () => {
+  return zxModuleMock()
+})
+
+let parent: string
+let home: string
+let sourceRoot: string
+let targetRoot: string
+
+const write = (root: string, rel: string, content: string): void => {
+  const full = path.join(root, rel)
+
+  fs.mkdirSync(path.dirname(full), { recursive: true })
+  fs.writeFileSync(full, content, 'utf8')
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  execMock.mockResolvedValue({ stdout: 'deadbeef\n' })
+
+  parent = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-write-test-'))
+  sourceRoot = path.join(parent, 'source-repo')
+  targetRoot = path.join(parent, 'target-repo')
+
+  // Machine-local factory config (workspaceDir + targets) lives under ~/.infra-kit;
+  // point os.homedir() at a fixture so the loader finds it.
+  home = fs.mkdtempSync(path.join(os.tmpdir(), 'vendor-write-home-'))
+  vi.spyOn(os, 'homedir').mockReturnValue(home)
+  write(home, '.infra-kit/vendor.json', JSON.stringify({ workspaceDir: parent, targets: ['target-repo'] }))
+
+  // Source repo: vendor content + config (copy[] only — targets is machine-local now).
+  write(sourceRoot, 'vendor/configs/a.js', 'aaa')
+  write(
+    sourceRoot,
+    'vendor.config.ts',
+    `export default { copy: [{ name: 'Configs', source: 'vendor/configs', target: 'vendor/configs', type: 'directory', vendored: true }] }`,
+  )
+
+  // Target repo: pre-existing vendor content (rsync is mocked, so this stays).
+  write(targetRoot, 'vendor/configs/a.js', 'aaa')
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  fs.rmSync(parent, { recursive: true, force: true })
+  fs.rmSync(home, { recursive: true, force: true })
+})
+
+describe('vendorSync', () => {
+  it('writes a manifest + README into the target vendor/ tree', async () => {
+    const { structuredContent } = await vendorSync({ cwd: sourceRoot, confirmedCommand: true })
+
+    expect(structuredContent.source).toBe('source-repo')
+    expect(structuredContent.repos).toHaveLength(1)
+    expect(structuredContent.repos[0]?.skipped).toBe(false)
+
+    const manifestPath = path.join(targetRoot, 'vendor', '.sync-manifest.json')
+    const readmePath = path.join(targetRoot, 'vendor', 'README.md')
+
+    expect(fs.existsSync(manifestPath)).toBe(true)
+    expect(fs.existsSync(readmePath)).toBe(true)
+
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+
+    expect(manifest.schemaVersion).toBe(1)
+    expect(Object.keys(manifest.files)).toContain('configs/a.js')
+  })
+
+  it('marks a non-existent target as skipped', async () => {
+    fs.rmSync(targetRoot, { recursive: true, force: true })
+
+    const { structuredContent } = await vendorSync({ cwd: sourceRoot, confirmedCommand: true })
+
+    expect(structuredContent.repos[0]?.skipped).toBe(true)
+  })
+})

package/src/commands/vendor-sync/index.ts

@@ -0,0 +1 @@
+export { vendorSync, vendorSyncMcpTool } from './vendor-sync'

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

@@ -0,0 +1,90 @@
+import confirm from '@inquirer/confirm'
+import path from 'node:path'
+import process from 'node:process'
+import { z } from 'zod'
+
+import { getProjectRoot } from 'src/lib/git-utils'
+import { logger } from 'src/lib/logger'
+import { loadVendorConfig } from 'src/lib/vendor/config'
+import { loadFactoryConfig } from 'src/lib/vendor/factory-config'
+import { getSourceCommit, runSync, selectTargets } from 'src/lib/vendor/sync-ops'
+import { defineMcpTool, textContent } from 'src/types'
+import type { RequiredConfirmedOptionArg } from 'src/types'
+
+interface VendorSyncOptions extends RequiredConfirmedOptionArg {
+  /** Source repo root. Defaults to the git toplevel. */
+  cwd?: string
+  /** Restrict the sync to these target repo names (defaults to all configured targets). */
+  repos?: string[]
+}
+
+/**
+ * Copy every item declared in the source repo's `vendor.config.ts` into each
+ * target repo, then (re)write each target's `vendor/README.md` +
+ * `.sync-manifest.json`. Mutating: extends {@link RequiredConfirmedOptionArg} and
+ * prompts for confirmation unless `confirmedCommand` is set (MCP injects it).
+ *
+ * The config loader and `zx`/rsync live in `config`/`sync-ops`. `vendor check`
+ * stays free of them because it never imports the write commands — not because
+ * of how they are imported here.
+ */
+export const vendorSync = async (options: VendorSyncOptions) => {
+  const sourceRoot = options.cwd ?? (await getProjectRoot())
+
+  const config = await loadVendorConfig(sourceRoot)
+  const factory = await loadFactoryConfig()
+  const targets = selectTargets(factory.targets, options.repos)
+
+  if (!options.confirmedCommand) {
+    const proceed = await confirm(
+      { message: `Sync vendor files from ${path.basename(sourceRoot)} into ${targets.length} repo(s)?` },
+      { output: process.stderr },
+    )
+
+    if (!proceed) {
+      process.exit(0)
+    }
+  }
+
+  const commit = await getSourceCommit(sourceRoot)
+  const source = path.basename(sourceRoot)
+
+  const structuredContent = await runSync(config, sourceRoot, factory.workspaceDir, targets, { source, commit })
+
+  for (const repo of structuredContent.repos) {
+    if (repo.skipped) {
+      logger.info(`⚠️  ${repo.repo}: target does not exist — skipped`)
+    } else {
+      logger.info(`✅ ${repo.repo}: copied ${repo.copied}/${repo.total} items + manifest`)
+    }
+  }
+
+  return { content: textContent(JSON.stringify(structuredContent, null, 2)), structuredContent }
+}
+
+const vendorSyncOutputSchema = {
+  source: z.string(),
+  commit: z.string(),
+  repos: z.array(
+    z.object({
+      repo: z.string(),
+      copied: z.number(),
+      total: z.number(),
+      skipped: z.boolean(),
+    }),
+  ),
+}
+
+// MCP Tool Registration (mutating — createToolHandler injects confirmedCommand:true).
+export const vendorSyncMcpTool = defineMcpTool({
+  name: 'vendor-sync',
+  description:
+    'Copy vendored files from the source repo (vendor.config.ts) into each target repo and regenerate their vendor/.sync-manifest.json + README. Mutating; run from the source repo root.',
+  inputSchema: {
+    repos: z.array(z.string()).optional().describe('Restrict to these target repo names'),
+  },
+  outputSchema: vendorSyncOutputSchema,
+  handler: (params) => {
+    return vendorSync({ repos: params.repos, confirmedCommand: params.confirmedCommand })
+  },
+})

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

@@ -349,7 +349,7 @@ export const worktreesAddMcpTool = defineMcpTool({
       .boolean()
       .optional()
       .describe(
-        'Open each created worktree in a new cmux workspace with a 3-pane layout (left-top, left-bottom, full-height right), all rooted at the worktree directory. Resolution order: this flag → "worktrees.openInCmux" from infra-kit config → interactive prompt (CLI) / false (MCP, no TTY).',
+        'Open each created worktree in a new cmux workspace, all rooted at the worktree directory. Pane layout follows "worktrees.cmux.layout" (default "two-columns": left | right; or "three-pane": left split top/bottom + full-height right). Resolution order: this flag → "worktrees.openInCmux" from infra-kit config → interactive prompt (CLI) / false (MCP, no TTY).',
       ),
   },
   outputSchema: {

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

@@ -27,8 +27,9 @@ interface WorktreesReloadResult {
 /**
  * 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.
+ * configured editor workspace is reconciled and relaunched. The single
+ * window-restore command: also serves the cold-start case (editor + cmux closed),
+ * at the cost of tearing down any 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
@@ -49,7 +50,7 @@ export const worktreesReload = async () => {
     // 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 }),
+      openIdeWorkspace({ projectRoot, worktreeDir, currentBranches }),
       reopenCmux({ worktreeDir, currentBranches, repoName }),
     ])
 
@@ -144,7 +145,7 @@ interface ReopenCmuxOutcome {
  * 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.
+ * ends up open.
  */
 export const reopenCmux = async (args: ReopenCmuxArgs): Promise<ReopenCmuxOutcome> => {
   const { worktreeDir, currentBranches, repoName } = args
@@ -212,7 +213,7 @@ const logResults = (result: WorktreesReloadResult, context: LogResultsContext):
 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.',
+    'Close all open cmux workspaces for the current release worktrees, then reopen the full set — the single window-restore command. Every configured editor (Cursor and/or Zed) is reconciled + relaunched (no per-window close). Disruptive: closes live cmux windows first. Safe to run from any branch. Use to refresh stale windows or to restore everything after a cold start (editor + cmux closed).',
   inputSchema: {},
   outputSchema: {
     closedCmux: z.array(z.string()).describe('Titles of cmux workspaces a close was attempted for (best-effort)'),

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

@@ -118,7 +118,16 @@ export const worktreesRemove = async (options: WorktreeManagementArgs) => {
       pruneFolder: allSelected,
     })
 
-    await removeIdeWorktreeFolders({ projectRoot, worktreeDir, branches: removedWorktrees })
+    // `!confirmedCommand` is the interactive path (a human used the picker/confirm). Only there
+    // do we let Zed's destructive `--reuse` relaunch fire; MCP/--yes runs (confirmedCommand=true)
+    // and worktrees-sync never relaunch an editor window.
+    await removeIdeWorktreeFolders({
+      projectRoot,
+      worktreeDir,
+      currentWorktrees,
+      removedWorktrees,
+      allowEditorRelaunch: !confirmedCommand,
+    })
 
     logResults(removedWorktrees)
 

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

@@ -72,7 +72,15 @@ export const worktreesSync = async (options: WorktreeSyncArgs) => {
       repoName,
     })
 
-    await removeIdeWorktreeFolders({ projectRoot, worktreeDir, branches: removedWorktrees })
+    // Hard `false`: sync is background/stale-cleanup (predominantly the MCP path) — it must never
+    // relaunch and overwrite a focused Zed window. Zed removal stays a no-op here.
+    await removeIdeWorktreeFolders({
+      projectRoot,
+      worktreeDir,
+      currentWorktrees,
+      removedWorktrees,
+      allowEditorRelaunch: false,
+    })
 
     logResults(removedWorktrees)