infra-kit 0.1.107 → 0.1.109

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infra-kit",
   "type": "module",
-  "version": "0.1.107",
+  "version": "0.1.109",
   "description": "infra-kit",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/src/commands/gh-merge-dev/gh-merge-dev.ts

@@ -8,6 +8,7 @@ import { $ } from 'zx'
 import { getReleasePRsWithInfo } from 'src/integrations/gh'
 import { commandEcho } from 'src/lib/command-echo'
 import { OperationError } from 'src/lib/errors/operation-error'
+import { assertManagementContext } from 'src/lib/git-guard'
 import { logger } from 'src/lib/logger'
 import { detectReleaseType, formatBranchChoices, getJiraDescriptions, releaseBranchLabels } from 'src/lib/release-utils'
 import { defineMcpTool, textContent } from 'src/types'
@@ -25,6 +26,8 @@ export const ghMergeDev = async (args: GhMergeDevArgs) => {
 
   commandEcho.start('merge-dev')
 
+  await assertManagementContext({ operation: 'merge dev into release branches', requiredBranch: 'dev' })
+
   // Only merge dev into regular releases (not hotfixes, which target main)
   const allPRs = await getReleasePRsWithInfo()
   const releasePRsList = allPRs

package/src/commands/gh-release-deliver/gh-release-deliver.ts

@@ -10,6 +10,7 @@ import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
 import { formatZxError } from 'src/lib/errors/format-zx-error'
 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 { logger } from 'src/lib/logger'
 import { displayLabel, formatJiraName, formatRcTitle, parseBranchName } from 'src/lib/release-id'
@@ -339,6 +340,10 @@ export const ghReleaseDeliver = async (args: GhReleaseDeliverArgs) => {
 
   commandEcho.start('release-deliver')
 
+  // Branch-agnostic (operates on release/RC PRs via gh and self-switches), so
+  // only the worktree + clean-tree legs apply.
+  await assertManagementContext({ operation: 'deliver release' })
+
   const { selectedReleaseBranch, releasePrTitle } = version
     ? await resolveTargetFromVersion(version)
     : await resolveTargetInteractively()

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

@@ -1,7 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import type { z } from 'zod'
 
-import { releaseCreateMcpTool } from '../release-create'
+import { OperationError } from 'src/lib/errors/operation-error'
+import type { ReleaseType } from 'src/lib/release-utils'
+import type { ReleaseEntry } from 'src/lib/version-utils'
+
+import { assertHomogeneousReleaseType, releaseCreateMcpTool } from '../release-create'
 
 /**
  * The MCP `releases[]` entry schema enforces that exactly one of `version` or
@@ -53,3 +57,36 @@ describe('release-create MCP releases[] entry schema', () => {
     }).toThrow(/exactly one of/)
   })
 })
+
+const entryOfType = (type: ReleaseType): ReleaseEntry => {
+  return {
+    id: { kind: 'version', semver: { major: 1, minor: 2, patch: 3 }, raw: '1.2.3' },
+    type,
+  } as ReleaseEntry
+}
+
+describe('assertHomogeneousReleaseType', () => {
+  it('accepts an all-regular batch', () => {
+    expect(() => {
+      return assertHomogeneousReleaseType([entryOfType('regular'), entryOfType('regular')])
+    }).not.toThrow()
+  })
+
+  it('accepts an all-hotfix batch', () => {
+    expect(() => {
+      return assertHomogeneousReleaseType([entryOfType('hotfix')])
+    }).not.toThrow()
+  })
+
+  it('rejects a mixed regular+hotfix batch with an OperationError', () => {
+    expect(() => {
+      return assertHomogeneousReleaseType([entryOfType('regular'), entryOfType('hotfix')])
+    }).toThrow(OperationError)
+  })
+
+  it('mixed-batch error mentions separate invocations', () => {
+    expect(() => {
+      return assertHomogeneousReleaseType([entryOfType('regular'), entryOfType('hotfix')])
+    }).toThrow(/separate invocations/)
+  })
+})

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

@@ -7,9 +7,10 @@ import { question } from 'zx'
 import { loadJiraConfig } from 'src/integrations/jira'
 import { commandEcho } from 'src/lib/command-echo'
 import { OperationError } from 'src/lib/errors/operation-error'
+import { assertManagementContext } from 'src/lib/git-guard'
 import { logger } from 'src/lib/logger'
 import { InvalidReleaseNameError, displayLabel, validateName } from 'src/lib/release-id'
-import { createSingleRelease, prepareGitForRelease } from 'src/lib/release-utils'
+import { createSingleRelease, getBaseBranch, prepareGitForRelease } from 'src/lib/release-utils'
 import type { ReleaseCreationResult, ReleaseType } from 'src/lib/release-utils'
 import {
   NoPriorVersionsError,
@@ -212,6 +213,28 @@ const collectEntries = async (
   return interactive
 }
 
+/**
+ * Reject a batch that mixes regular and hotfix releases. They branch off
+ * different bases (dev vs main), so the batch has no single required branch for
+ * the management guard — they must be created in separate invocations.
+ * Exported for unit testing without running the side-effecting handler.
+ */
+export const assertHomogeneousReleaseType = (entries: ReleaseEntry[]): void => {
+  const types = new Set(
+    entries.map((entry) => {
+      return entry.type
+    }),
+  )
+
+  if (types.size > 1) {
+    throw new OperationError(undefined, {
+      operation: 'create release',
+      remediation: 'create regular and hotfix releases in separate invocations',
+      stderrExcerpt: 'mixed regular and hotfix releases in one batch are not supported',
+    })
+  }
+}
+
 const confirmReleases = async (entries: ReleaseEntry[], confirmedCommand: boolean): Promise<void> => {
   const summary = entries.map(formatReleaseSummary).join('\n  - ')
   const answer = confirmedCommand
@@ -284,8 +307,10 @@ const logFinalSummary = (total: number, successCount: number, failureCount: numb
 
 /**
  * Create one or more release branches. Each release carries its own type
- * (regular/hotfix) and optional Jira description, so a single invocation
- * may mix regular and hotfix releases off their respective base branches.
+ * (regular/hotfix) and optional Jira description. All entries in a single
+ * invocation must share the same type — regular and hotfix releases branch off
+ * different bases (dev vs main), so mixed batches are rejected and must be
+ * created separately.
  */
 export const releaseCreate = async (args: ReleaseCreateArgs) => {
   const { releases: inputReleases, confirmedCommand } = args
@@ -311,6 +336,13 @@ export const releaseCreate = async (args: ReleaseCreateArgs) => {
     })
   }
 
+  assertHomogeneousReleaseType(entries)
+
+  await assertManagementContext({
+    operation: 'create release',
+    requiredBranch: getBaseBranch(entries[0]!.type),
+  })
+
   await confirmReleases(entries, Boolean(confirmedCommand))
 
   const created: ReleaseCreationResult[] = []
@@ -347,7 +379,7 @@ export const releaseCreate = async (args: ReleaseCreateArgs) => {
 export const releaseCreateMcpTool = defineMcpTool({
   name: 'release-create',
   description:
-    'Create one or more releases in a single call. Each entry in "releases" carries EITHER a "version" (semver or the literal token "next") OR a "name" (free-form kebab-case identifier) — exactly one is required and they are mutually exclusive. Each entry also has its own type (regular|hotfix, default regular) and optional description, so regular and hotfix releases can be mixed in the same invocation. For each release this tool switches to the appropriate base branch (dev for regular, main for hotfix), cuts the release branch (release/v<semver> for versions, release/n/<name> for names), opens a GitHub release PR, and creates the matching Jira fix version (v<semver> for versions, <name> for names). The literal token "next" auto-increments from the union of remote release branches and Jira fix versions (regular bumps minor + resets patch; hotfix bumps patch on the highest minor); multiple "next" tokens advance sequentially across mixed types. Named releases never auto-bump and "next" is version-only. Confirmation is auto-skipped for MCP calls, so the caller is responsible for gating. Continues on per-release failure and reports successes/failures.',
+    'Create one or more releases in a single call. Each entry in "releases" carries EITHER a "version" (semver or the literal token "next") OR a "name" (free-form kebab-case identifier) — exactly one is required and they are mutually exclusive. Each entry also has its own type (regular|hotfix, default regular) and optional description; all entries in one call must share the same type — mixed regular+hotfix batches are rejected (create them in separate invocations). For each release this tool switches to the appropriate base branch (dev for regular, main for hotfix), cuts the release branch (release/v<semver> for versions, release/n/<name> for names), opens a GitHub release PR, and creates the matching Jira fix version (v<semver> for versions, <name> for names). The literal token "next" auto-increments from the union of remote release branches and Jira fix versions (regular bumps minor + resets patch; hotfix bumps patch on the highest minor); multiple "next" tokens advance sequentially. Named releases never auto-bump and "next" is version-only. Must be run from the main repository checkout (not a linked worktree) on the matching base branch with a clean working tree. Confirmation is auto-skipped for MCP calls, so the caller is responsible for gating. Continues on per-release failure and reports successes/failures.',
   inputSchema: {
     releases: z
       .array(

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

@@ -6,12 +6,18 @@ import process from 'node:process'
 import { z } from 'zod'
 import { $ } from 'zx'
 
-import { buildCmuxWorkspaceTitle, openCmuxWorkspaceWithLayout } from 'src/integrations/cmux'
+import {
+  buildCmuxWorkspaceTitle,
+  canonicalizeCmuxTitle,
+  listCmuxWorkspaceTitles,
+  openCmuxWorkspaceWithLayout,
+} from 'src/integrations/cmux'
 import { addFoldersToCursorWorkspace, resolveCursorWorkspacePath } from 'src/integrations/cursor'
 import { getReleasePRsWithInfo } from 'src/integrations/gh'
 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'
@@ -45,6 +51,8 @@ export const worktreesAdd = async (options: WorktreeManagementArgs) => {
 
   commandEcho.start('worktrees-add')
 
+  await assertManagementContext({ operation: 'create worktrees', requiredBranch: 'dev' })
+
   try {
     const currentWorktrees = await getCurrentWorktrees('release')
     const projectRoot = await getProjectRoot()
@@ -227,10 +235,17 @@ export const worktreesAdd = async (options: WorktreeManagementArgs) => {
 
     if (openInCmux) {
       const repoName = await getRepoName()
+      const existingTitles = await listCmuxWorkspaceTitles()
 
       for (const branch of createdWorktrees) {
         const title = buildCmuxWorkspaceTitle({ repoName, branch })
 
+        // Skip branches whose cmux workspace is already open (canonical match),
+        // so re-running worktrees-add never duplicates an existing workspace.
+        if (existingTitles.has(canonicalizeCmuxTitle(title))) {
+          continue
+        }
+
         await openCmuxWorkspaceWithLayout({
           cwd: `${worktreeDir}/${branch}`,
           title,

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

@@ -0,0 +1,96 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { listCmuxWorkspaceTitles, openCmuxWorkspaceWithLayout } from 'src/integrations/cmux'
+import { getRepoName } from 'src/lib/git-utils'
+
+import { openCmux } from '../worktrees-open'
+
+vi.mock('src/integrations/cmux', async (importActual) => {
+  const actual = await importActual<typeof import('src/integrations/cmux')>()
+
+  return {
+    ...actual,
+    listCmuxWorkspaceTitles: 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/n/checkout-redesign']
+
+const titleFor = {
+  versioned: `${REPO} 1.48.0`,
+  named: `${REPO} checkout-redesign`,
+}
+
+describe('openCmux dedup', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(getRepoName).mockResolvedValue(REPO)
+    vi.mocked(openCmuxWorkspaceWithLayout).mockResolvedValue(undefined)
+  })
+
+  it('opens a workspace for every branch when none are open', async () => {
+    vi.mocked(listCmuxWorkspaceTitles).mockResolvedValue(new Set())
+
+    const result = await openCmux({ worktreeDir: WORKTREE_DIR, currentBranches: BRANCHES })
+
+    expect(result.opened).toEqual([titleFor.versioned, titleFor.named])
+    expect(result.skipped).toEqual([])
+    expect(openCmuxWorkspaceWithLayout).toHaveBeenCalledTimes(2)
+  })
+
+  it('skips every branch when all are already open (no duplicates)', async () => {
+    vi.mocked(listCmuxWorkspaceTitles).mockResolvedValue(new Set([titleFor.versioned, titleFor.named]))
+
+    const result = await openCmux({ worktreeDir: WORKTREE_DIR, currentBranches: BRANCHES })
+
+    expect(result.opened).toEqual([])
+    expect(result.skipped).toEqual([titleFor.versioned, titleFor.named])
+    expect(openCmuxWorkspaceWithLayout).not.toHaveBeenCalled()
+  })
+
+  it('opens only the missing branch in a mixed state', async () => {
+    vi.mocked(listCmuxWorkspaceTitles).mockResolvedValue(new Set([titleFor.versioned]))
+
+    const result = await openCmux({ worktreeDir: WORKTREE_DIR, currentBranches: BRANCHES })
+
+    expect(result.skipped).toEqual([titleFor.versioned])
+    expect(result.opened).toEqual([titleFor.named])
+    expect(openCmuxWorkspaceWithLayout).toHaveBeenCalledTimes(1)
+    expect(openCmuxWorkspaceWithLayout).toHaveBeenCalledWith({
+      cwd: `${WORKTREE_DIR}/release/n/checkout-redesign`,
+      title: titleFor.named,
+    })
+  })
+
+  it('skips a versioned branch whose workspace was stored under an old v-prefixed title', async () => {
+    // listCmuxWorkspaceTitles already returns canonical keys, so an old
+    // "hulyo-monorepo v1.48.0" workspace is surfaced as the canonical key below.
+    vi.mocked(listCmuxWorkspaceTitles).mockResolvedValue(new Set([titleFor.versioned]))
+
+    const result = await openCmux({ worktreeDir: WORKTREE_DIR, currentBranches: ['release/v1.48.0'] })
+
+    expect(result.opened).toEqual([])
+    expect(result.skipped).toEqual([titleFor.versioned])
+    expect(openCmuxWorkspaceWithLayout).not.toHaveBeenCalled()
+  })
+
+  it('returns empty outcome when there are no worktrees', async () => {
+    vi.mocked(listCmuxWorkspaceTitles).mockResolvedValue(new Set())
+
+    const result = await openCmux({ worktreeDir: WORKTREE_DIR, currentBranches: [] })
+
+    expect(result).toEqual({ ran: true, opened: [], skipped: [] })
+    expect(listCmuxWorkspaceTitles).not.toHaveBeenCalled()
+  })
+})

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

@@ -1,7 +1,12 @@
 import { z } from 'zod'
 import { $ } from 'zx'
 
-import { buildCmuxWorkspaceTitle, listCmuxWorkspaceTitles, openCmuxWorkspaceWithLayout } from 'src/integrations/cmux'
+import {
+  buildCmuxWorkspaceTitle,
+  canonicalizeCmuxTitle,
+  listCmuxWorkspaceTitles,
+  openCmuxWorkspaceWithLayout,
+} from 'src/integrations/cmux'
 import { reconcileCursorWorkspaceFolders, resolveCursorWorkspacePath } from 'src/integrations/cursor'
 import { commandEcho } from 'src/lib/command-echo'
 import { WORKTREES_DIR_SUFFIX } from 'src/lib/constants'
@@ -113,7 +118,7 @@ interface OpenCmuxOutcome {
   skipped: string[]
 }
 
-const openCmux = async (args: OpenCmuxArgs): Promise<OpenCmuxOutcome> => {
+export const openCmux = async (args: OpenCmuxArgs): Promise<OpenCmuxOutcome> => {
   const { worktreeDir, currentBranches } = args
 
   if (currentBranches.length === 0) {
@@ -129,7 +134,9 @@ const openCmux = async (args: OpenCmuxArgs): Promise<OpenCmuxOutcome> => {
   for (const branch of currentBranches) {
     const title = buildCmuxWorkspaceTitle({ repoName, branch })
 
-    if (existingTitles.has(title)) {
+    // existingTitles holds canonical keys; match the built title the same way so
+    // dedup survives whitespace / cross-CLI-version title drift (no duplicates).
+    if (existingTitles.has(canonicalizeCmuxTitle(title))) {
       skipped.push(title)
       continue
     }

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

@@ -8,6 +8,7 @@ import { getReleasePRsWithInfo } from 'src/integrations/gh'
 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'
@@ -33,6 +34,8 @@ export const worktreesRemove = async (options: WorktreeManagementArgs) => {
 
   commandEcho.start('worktrees-remove')
 
+  await assertManagementContext({ operation: 'remove worktrees', requiredBranch: 'dev' })
+
   try {
     const currentWorktrees = await getCurrentWorktrees('release')
 

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

@@ -9,6 +9,7 @@ import { getReleasePRs } from 'src/integrations/gh'
 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'
@@ -28,6 +29,8 @@ export const worktreesSync = async (options: WorktreeSyncArgs) => {
 
   commandEcho.start('worktrees-sync')
 
+  await assertManagementContext({ operation: 'sync worktrees', requiredBranch: 'dev' })
+
   try {
     const currentWorktrees = await getCurrentWorktrees('release')
     const projectRoot = await getProjectRoot()

package/src/integrations/cmux/__tests__/canonicalize-cmux-title.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest'
+
+import { buildCmuxWorkspaceTitle } from 'src/integrations/cmux'
+
+import { canonicalizeCmuxTitle } from '../canonicalize-cmux-title'
+
+describe('canonicalizeCmuxTitle', () => {
+  it('trims and collapses internal whitespace', () => {
+    expect(canonicalizeCmuxTitle('  hulyo-monorepo   1.48.0  ')).toBe('hulyo-monorepo 1.48.0')
+  })
+
+  it('normalizes a v-prefixed semver token to its bare form', () => {
+    expect(canonicalizeCmuxTitle('hulyo-monorepo v1.48.0')).toBe('hulyo-monorepo 1.48.0')
+  })
+
+  it('treats the v-prefixed and bare semver titles as the same key (cross-version drift)', () => {
+    expect(canonicalizeCmuxTitle('hulyo-monorepo v1.48.0')).toBe(canonicalizeCmuxTitle('hulyo-monorepo 1.48.0'))
+  })
+
+  it('does NOT strip a leading v from a named release', () => {
+    expect(canonicalizeCmuxTitle('hulyo-monorepo vega-redesign')).toBe('hulyo-monorepo vega-redesign')
+  })
+
+  it('leaves a non-release fallback title containing a slash untouched', () => {
+    expect(canonicalizeCmuxTitle('hulyo-monorepo feature/foo')).toBe('hulyo-monorepo feature/foo')
+  })
+
+  it('does not corrupt a non-semver token that merely starts with v', () => {
+    expect(canonicalizeCmuxTitle('v8-engine 1.2.3')).toBe('v8-engine 1.2.3')
+    expect(canonicalizeCmuxTitle('appv1.2.3 main')).toBe('appv1.2.3 main')
+  })
+
+  it('is idempotent', () => {
+    const once = canonicalizeCmuxTitle('hulyo-monorepo   v1.48.0 ')
+
+    expect(canonicalizeCmuxTitle(once)).toBe(once)
+  })
+
+  // The invariant that generalizes the whole fix: the title a workspace is
+  // created/renamed with must round-trip through canonicalization to the same
+  // key the dedup/close check builds — regardless of which CLI version stored it.
+  describe('round-trip invariant', () => {
+    it('built title canonicalizes to a stable key for a versioned release', () => {
+      const built = buildCmuxWorkspaceTitle({ repoName: 'hulyo-monorepo', branch: 'release/v1.48.0' })
+      const storedByOldCli = 'hulyo-monorepo v1.48.0'
+
+      expect(canonicalizeCmuxTitle(built)).toBe(canonicalizeCmuxTitle(storedByOldCli))
+    })
+
+    it('built title canonicalizes to a stable key for a named release', () => {
+      const built = buildCmuxWorkspaceTitle({ repoName: 'hulyo-monorepo', branch: 'release/n/checkout-redesign' })
+
+      expect(canonicalizeCmuxTitle(built)).toBe('hulyo-monorepo checkout-redesign')
+    })
+  })
+})

package/src/integrations/cmux/__tests__/close-workspace-by-title.test.ts

@@ -0,0 +1,63 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { $ } from 'zx'
+
+import { closeCmuxWorkspaceByTitle } from '../close-workspace-by-title'
+
+const listOutput = vi.hoisted(() => {
+  return { value: '' }
+})
+
+vi.mock('zx', () => {
+  function makeResult(stdout: string) {
+    return Object.assign(Promise.resolve({ stdout }), {
+      quiet: () => {
+        return Promise.resolve({ stdout })
+      },
+    })
+  }
+
+  return {
+    $: vi.fn((strings: TemplateStringsArray) => {
+      return strings.join('').includes('list-workspaces') ? makeResult(listOutput.value) : makeResult('')
+    }),
+  }
+})
+
+type CmuxCall = [TemplateStringsArray, ...string[]]
+
+function isCloseCall(call: CmuxCall): boolean {
+  return call[0].join('').includes('close-workspace')
+}
+
+const closeCallRef = (): string | undefined => {
+  const calls = vi.mocked($).mock.calls as unknown as CmuxCall[]
+
+  return calls.find(isCloseCall)?.[1]
+}
+
+describe('closeCmuxWorkspaceByTitle', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    listOutput.value = ''
+  })
+
+  it('closes a workspace stored under an old v-prefixed title when asked with the bare-semver title', async () => {
+    listOutput.value = [
+      '  workspace:8  hulyo-monorepo v1.48.0',
+      '* workspace:6  obsidian-workspace  [selected]',
+      '',
+    ].join('\n')
+
+    await closeCmuxWorkspaceByTitle('hulyo-monorepo 1.48.0')
+
+    expect(closeCallRef()).toBe('workspace:8')
+  })
+
+  it('does not close anything when no title matches', async () => {
+    listOutput.value = '  workspace:8  hulyo-monorepo 2.0.0\n'
+
+    await closeCmuxWorkspaceByTitle('hulyo-monorepo 1.48.0')
+
+    expect(closeCallRef()).toBeUndefined()
+  })
+})

package/src/integrations/cmux/__tests__/list-workspace-titles.test.ts

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { listCmuxWorkspaceTitles } from '../list-workspace-titles'
+
+const listOutput = vi.hoisted(() => {
+  return { value: '' }
+})
+
+vi.mock('zx', () => {
+  function makeResult() {
+    return Object.assign(Promise.resolve({ stdout: listOutput.value }), {
+      quiet: () => {
+        return Promise.resolve({ stdout: listOutput.value })
+      },
+    })
+  }
+
+  return {
+    $: vi.fn(makeResult),
+  }
+})
+
+describe('listCmuxWorkspaceTitles', () => {
+  beforeEach(() => {
+    listOutput.value = ''
+  })
+
+  it('parses titles, stripping the [selected] suffix and leading * marker', async () => {
+    listOutput.value = [
+      '  workspace:8  hulyo-monorepo 1.48.0',
+      '* workspace:6  obsidian-workspace  [selected]',
+      '',
+    ].join('\n')
+
+    const titles = await listCmuxWorkspaceTitles()
+
+    expect(titles.has('hulyo-monorepo 1.48.0')).toBe(true)
+    expect(titles.has('obsidian-workspace')).toBe(true)
+  })
+
+  it('canonicalizes a v-prefixed (old CLI) stored title to the bare-semver key', async () => {
+    listOutput.value = '  workspace:8  hulyo-monorepo v1.48.0\n'
+
+    const titles = await listCmuxWorkspaceTitles()
+
+    expect(titles.has('hulyo-monorepo 1.48.0')).toBe(true)
+    expect(titles.has('hulyo-monorepo v1.48.0')).toBe(false)
+  })
+
+  it('collapses extra internal whitespace into the canonical key', async () => {
+    listOutput.value = '  workspace:3  hulyo-monorepo    1.48.0\n'
+
+    const titles = await listCmuxWorkspaceTitles()
+
+    expect(titles.has('hulyo-monorepo 1.48.0')).toBe(true)
+  })
+
+  it('returns an empty set when cmux output is empty', async () => {
+    listOutput.value = ''
+
+    const titles = await listCmuxWorkspaceTitles()
+
+    expect(titles.size).toBe(0)
+  })
+})

package/src/integrations/cmux/canonicalize-cmux-title.ts

@@ -0,0 +1,31 @@
+/** Matches a `v`-prefixed semver token (e.g. `v1.48.0`) anchored on shape. */
+const V_SEMVER_TOKEN_RE = /\bv(\d+\.\d+\.\d+)\b/g
+
+/**
+ * Canonicalizes a cmux workspace title into a stable dedup/close key.
+ *
+ * cmux workspace titles are human display strings built by
+ * `buildCmuxWorkspaceTitle`, so the value stored when a workspace is created can
+ * drift from the value rebuilt later — across whitespace and across CLI versions
+ * (an older build titled version releases `v1.48.0`; the current build titles
+ * them `1.48.0`). Keying dedup or close on the raw title silently creates
+ * duplicate / unclosable workspaces whenever that drift occurs.
+ *
+ * Canonicalization collapses the known drift axes so both sides round-trip to an
+ * equal key:
+ *   - trims and collapses internal whitespace to single spaces;
+ *   - normalizes a `v`-prefixed semver token to its bare form
+ *     (`v1.48.0` → `1.48.0`), anchored on semver shape so named releases that
+ *     merely start with `v` (e.g. `vega-redesign`) are left untouched.
+ *
+ * Non-release fallback titles (which may contain `/`, e.g. `feature/foo`) are
+ * preserved as-is apart from whitespace normalization.
+ *
+ * @example
+ * canonicalizeCmuxTitle('hulyo-monorepo  v1.48.0')      // => 'hulyo-monorepo 1.48.0'
+ * canonicalizeCmuxTitle('hulyo-monorepo 1.48.0')        // => 'hulyo-monorepo 1.48.0'
+ * canonicalizeCmuxTitle('hulyo-monorepo vega-redesign') // => 'hulyo-monorepo vega-redesign'
+ */
+export const canonicalizeCmuxTitle = (raw: string): string => {
+  return raw.trim().replace(/\s+/g, ' ').replace(V_SEMVER_TOKEN_RE, '$1')
+}

package/src/integrations/cmux/close-workspace-by-title.ts

@@ -2,8 +2,11 @@ import { $ } from 'zx'
 
 import { logger } from 'src/lib/logger'
 
+import { canonicalizeCmuxTitle } from './canonicalize-cmux-title'
+
 /**
- * Best-effort close of the cmux workspace whose title exactly matches `title`.
+ * Best-effort close of the cmux workspace whose title matches `title` (compared
+ * via {@link canonicalizeCmuxTitle}, so a drifted stored title still resolves).
  * Silently no-ops if cmux isn't running, the workspace isn't found, or close fails.
  */
 export const closeCmuxWorkspaceByTitle = async (title: string): Promise<void> => {
@@ -24,13 +27,18 @@ export const closeCmuxWorkspaceByTitle = async (title: string): Promise<void> =>
 
 /**
  * Parses `cmux list-workspaces` output and returns the workspace ref whose
- * title exactly matches `title`, or undefined if no match.
+ * title matches `title`, or undefined if no match. Both sides are compared via
+ * {@link canonicalizeCmuxTitle} so a workspace stored under a drifted title
+ * (whitespace, or an older CLI's `v`-prefixed semver) is still found — keeping
+ * close symmetric with the dedup in `worktrees-open`.
  *
  * Each line looks like:
- *   "  workspace:8  hulyo-monorepo v1.48.0"
+ *   "  workspace:8  hulyo-monorepo 1.48.0"
  *   "* workspace:6  obsidian-workspace  [selected]"
  */
 const findWorkspaceRefByTitle = (output: string, title: string): string | undefined => {
+  const target = canonicalizeCmuxTitle(title)
+
   for (const rawLine of output.split('\n')) {
     // eslint-disable-next-line sonarjs/slow-regex, regexp/no-super-linear-backtracking
     const match = rawLine.match(/^[* ]\s*(workspace:\d+)\s+(.+?)(?:\s+\[selected\])?\s*$/)
@@ -42,7 +50,7 @@ const findWorkspaceRefByTitle = (output: string, title: string): string | undefi
     const ref = match[1]
     const lineTitle = match[2]?.trim() ?? ''
 
-    if (lineTitle === title) {
+    if (canonicalizeCmuxTitle(lineTitle) === target) {
       return ref
     }
   }

package/src/integrations/cmux/index.ts

@@ -1,3 +1,4 @@
+export { canonicalizeCmuxTitle } from './canonicalize-cmux-title'
 export { closeCmuxWorkspaceByTitle } from './close-workspace-by-title'
 export { listCmuxWorkspaceTitles } from './list-workspace-titles'
 export { openCmuxWorkspaceWithLayout } from './open-workspace-with-layout'