infra-kit 0.1.98 → 0.1.99

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infra-kit",
   "type": "module",
-  "version": "0.1.98",
+  "version": "0.1.99",
   "description": "infra-kit",
   "main": "dist/cli.js",
   "module": "dist/cli.js",

package/src/commands/config/config.ts

@@ -105,7 +105,7 @@ export const configEdit = async (): Promise<ToolsExecutionResult> => {
   await fs.mkdir(path.dirname(paths.userProject), { recursive: true })
 
   if (!(await fileExists(paths.userProject))) {
-    const stub = `# infra-kit user override for ${paths.projectName}\n# This file is shallow-merged on top of project infra-kit.yml.\n# Top-level keys (envManagement, ide, taskManager, environments) replace wholesale.\n`
+    const stub = `# infra-kit user override for ${paths.projectName} — ~/.infra-kit/projects/${paths.projectName}/infra-kit.yml\n#\n# Layer 3 (highest precedence) of the config merge chain. Shallow-merged on\n# top of <repo>/infra-kit.yml and ~/.infra-kit/config.yml — top-level keys\n# (environments, envManagement, ide, taskManager, worktrees) replace wholesale.\n`
 
     await fs.writeFile(paths.userProject, stub, 'utf-8')
   }

package/src/commands/init/init.ts

@@ -10,20 +10,31 @@ export const MARKER_END = '# -- infra-kit:end --'
 const LEGACY_PAIRED: [start: string, end: string][] = [['# region infra-kit', '# endregion infra-kit']]
 const LEGACY_SINGLE = '# infra-kit shell functions'
 
-const USER_GLOBAL_CONFIG_STUB = `# infra-kit user-global config
+const USER_GLOBAL_CONFIG_STUB = `# infra-kit user-global config — ~/.infra-kit/config.yml
 #
-# Shared across every project on this machine. Loaded after each project's
-# infra-kit.yml and before ~/.infra-kit/projects/<repo-name>/infra-kit.yml.
+# Merge chain (later layers override earlier ones at top-level keys):
+#   1. <repo>/infra-kit.yml                            — committed project config (required)
+#   2. ~/.infra-kit/config.yml                         — this file (user-global)
+#   3. ~/.infra-kit/projects/<repo-name>/infra-kit.yml — user-scope per-project override
 #
-# Top-level keys (envManagement, ide, taskManager, environments) replace
-# wholesale when set here. Uncomment values you want to apply globally.
+# Merge is shallow: setting a top-level key here replaces that whole section
+# from layer 1. Arrays do not concatenate. Top-level keys recognized:
+# environments, envManagement, ide, taskManager, worktrees.
+#
+# Uncomment the blocks you want to apply globally across every project on this
+# machine. Per-project tweaks belong in layer 3 — run \`infra-kit config edit\`.
 
 # Per-developer IDE config
 # ide:
 #   provider: cursor
 #   config:
 #     mode: workspace
-#     workspaceConfigPath: ../Main.code-workspace
+#     workspaceConfigPath: /path/to/your.code-workspace
+
+# Worktree prompt defaults — silences the follow-up prompts in \`worktrees-add\`
+# worktrees:
+#   openInGithubDesktop: false
+#   openInCmux: true
 `
 
 /**

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

@@ -8,40 +8,23 @@ import { loadJiraConfig } from 'src/integrations/jira'
 import { commandEcho } from 'src/lib/command-echo'
 import { logger } from 'src/lib/logger'
 import { createSingleRelease, prepareGitForRelease } from 'src/lib/release-utils'
-import type { ReleaseType } from 'src/lib/release-utils'
+import type { ReleaseCreationResult, ReleaseType } from 'src/lib/release-utils'
 import {
-  NEXT_TOKEN,
   NoPriorVersionsError,
   computeNextVersion,
+  hasNextToken,
   loadExistingVersions,
-  resolveVersionTokens,
-  splitVersionInput,
+  parseVersion,
+  resolveReleaseEntries,
 } from 'src/lib/version-utils'
-import type { SemVer } from 'src/lib/version-utils'
+import type { ReleaseEntry, SemVer } from 'src/lib/version-utils'
 import type { RequiredConfirmedOptionArg, ToolsExecutionResult } from 'src/types'
 
-import { releaseCreateBatch } from '../release-create-batch/release-create-batch'
-
 interface ReleaseCreateArgs extends RequiredConfirmedOptionArg {
-  version?: string
-  description?: string
-  type?: ReleaseType
+  releases?: ReleaseEntry[]
 }
 
-const VERSION_PROMPT_HINT = '"1.2.5", "next", or "next,next,1.2.7"'
-
-const promptForType = async (): Promise<ReleaseType> => {
-  commandEcho.setInteractive()
-
-  return select<ReleaseType>({
-    message: 'Select release type:',
-    choices: [
-      { name: 'regular', value: 'regular' },
-      { name: 'hotfix', value: 'hotfix' },
-    ],
-    default: 'regular',
-  })
-}
+const VERSION_PROMPT_HINT = '"1.2.5" or "next"'
 
 const trySuggestNext = (known: SemVer[], type: ReleaseType): string | null => {
   try {
@@ -53,116 +36,111 @@ const trySuggestNext = (known: SemVer[], type: ReleaseType): string | null => {
   }
 }
 
-const exitOnNoPrior = (err: unknown): never => {
-  if (err instanceof NoPriorVersionsError) {
-    logger.error(err.message)
-    process.exit(1)
-  }
+const resolveOrExit = (entries: ReleaseEntry[], known: SemVer[]): ReleaseEntry[] => {
+  try {
+    return resolveReleaseEntries(entries, known)
+  } catch (err) {
+    if (err instanceof NoPriorVersionsError) {
+      logger.error(err.message)
+      process.exit(1)
+    }
 
-  throw err
+    throw err
+  }
 }
 
-interface ResolveTokensArgs {
-  inputVersion: string | undefined
-  type: ReleaseType
-  ensureKnown: () => Promise<SemVer[]>
-}
+const promptForReleasesInteractive = async (ensureKnown: () => Promise<SemVer[]>): Promise<ReleaseEntry[]> => {
+  commandEcho.setInteractive()
 
-const resolveRawTokens = async (args: ResolveTokensArgs): Promise<string[]> => {
-  const { inputVersion, type, ensureKnown } = args
+  const baseKnown = await ensureKnown()
+  const running: SemVer[] = [...baseKnown]
+  const entries: ReleaseEntry[] = []
+  let addAnother = true
+
+  while (addAnother) {
+    const ordinal = entries.length + 1
+    const type = await select<ReleaseType>({
+      message: `Release #${ordinal} — select type:`,
+      choices: [
+        { name: 'regular', value: 'regular' },
+        { name: 'hotfix', value: 'hotfix' },
+      ],
+      default: 'regular',
+    })
 
-  if (inputVersion && inputVersion.trim() !== '') {
-    return splitVersionInput(inputVersion)
-  }
+    const suggestion = trySuggestNext(running, type)
+    const defaultHint = suggestion ? ` [${suggestion}]` : ''
+    const versionAnswer = (await question(`  Version (e.g. ${VERSION_PROMPT_HINT})${defaultHint}: `)).trim()
+    const versionInput = versionAnswer === '' ? (suggestion ?? '') : versionAnswer
 
-  commandEcho.setInteractive()
+    if (versionInput === '') {
+      logger.error('No version provided. Exiting...')
+      process.exit(1)
+    }
 
-  const suggestion = trySuggestNext(await ensureKnown(), type)
-  const defaultHint = suggestion ? ` [${suggestion}]` : ''
-  const answer = (await question(`Enter version(s) (e.g. ${VERSION_PROMPT_HINT})${defaultHint}: `)).trim()
+    const resolved = resolveOrExit([{ version: versionInput, type }], running)[0] as ReleaseEntry
 
-  if (answer === '') return suggestion ? [suggestion] : []
+    running.push(parseVersion(`v${resolved.version}`))
 
-  return splitVersionInput(answer)
-}
+    const description = (await question('  Description (optional, press Enter to skip): ')).trim()
 
-const resolveVersionList = async (args: ResolveTokensArgs): Promise<string[]> => {
-  const rawTokens = await resolveRawTokens(args)
+    entries.push({ ...resolved, ...(description !== '' ? { description } : {}) })
 
-  if (rawTokens.length === 0) {
-    logger.error('No version provided. Exiting...')
-    process.exit(1)
+    addAnother = await confirm({ message: 'Add another release?', default: false })
   }
 
-  const needsKnown = rawTokens.some((t) => {
-    return t.toLowerCase() === NEXT_TOKEN
-  })
-
-  try {
-    return resolveVersionTokens(rawTokens, args.type, needsKnown ? await args.ensureKnown() : [])
-  } catch (err) {
-    return exitOnNoPrior(err)
-  }
+  return entries
 }
 
-const resolveDescription = async (input: string | undefined): Promise<string> => {
-  if (input !== undefined) return input
+const formatReleaseSummary = (entry: ReleaseEntry): string => {
+  const parts = [`v${entry.version}`, entry.type]
 
-  commandEcho.setInteractive()
-  const answer = await question('Enter description (optional, press Enter to skip): ')
+  if (entry.description) parts.push(entry.description)
 
-  return answer.trim()
+  return parts.join(' · ')
 }
 
-/**
- * Create a single release branch for the specified version
- * Includes Jira version creation and GitHub release branch creation
- */
-export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecutionResult> => {
-  const { version: inputVersion, description: inputDescription, type: inputType, confirmedCommand } = args
-
-  commandEcho.start('release-create')
-
-  // Load Jira config - it is now mandatory
-  const jiraConfig = await loadJiraConfig()
-
-  const type: ReleaseType = inputType ?? (await promptForType())
+const echoReleases = (entries: ReleaseEntry[]): void => {
+  for (const entry of entries) {
+    const spec = entry.description
+      ? `${entry.version}:${entry.type}:${entry.description}`
+      : `${entry.version}:${entry.type}`
 
-  commandEcho.addOption('--type', type)
-
-  let known: SemVer[] | null = null
-  const ensureKnown = async (): Promise<SemVer[]> => {
-    if (known === null) known = await loadExistingVersions()
-
-    return known
+    commandEcho.addOption('--release', spec)
   }
+}
 
-  const resolvedVersions = await resolveVersionList({ inputVersion, type, ensureKnown })
+interface FailedRelease {
+  version: string
+  error: string
+}
 
-  if (resolvedVersions.length > 1) {
-    logger.info(`Detected ${resolvedVersions.length} versions, routing to release-create-batch...`)
+const collectEntries = async (
+  inputReleases: ReleaseEntry[] | undefined,
+  ensureKnown: () => Promise<SemVer[]>,
+): Promise<ReleaseEntry[]> => {
+  if (inputReleases && inputReleases.length > 0) {
+    const known = hasNextToken(inputReleases) ? await ensureKnown() : []
+    const resolved = resolveOrExit(inputReleases, known)
 
-    return releaseCreateBatch({
-      versions: resolvedVersions.join(','),
-      type,
-      confirmedCommand,
-    })
-  }
+    echoReleases(resolved)
 
-  const trimmedVersion = resolvedVersions[0] as string
+    return resolved
+  }
 
-  commandEcho.addOption('--version', trimmedVersion)
+  const interactive = await promptForReleasesInteractive(ensureKnown)
 
-  const description = await resolveDescription(inputDescription)
+  echoReleases(interactive)
 
-  if (description) {
-    commandEcho.addOption('--description', description)
-  }
+  return interactive
+}
 
+const confirmReleases = async (entries: ReleaseEntry[], confirmedCommand: boolean): Promise<void> => {
+  const summary = entries.map(formatReleaseSummary).join('\n  - ')
   const answer = confirmedCommand
     ? true
     : await confirm({
-        message: `Are you sure you want to create release branch for version ${trimmedVersion}?`,
+        message: `Create the following ${entries.length} release(s)?\n  - ${summary}\n`,
       })
 
   if (!confirmedCommand) {
@@ -174,25 +152,105 @@ export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecu
     process.exit(0)
   }
 
-  // Track --yes flag if confirmation was interactive (user confirmed)
   commandEcho.addOption('--yes', true)
+}
+
+interface ExecuteOneArgs {
+  entry: ReleaseEntry
+  jiraConfig: Awaited<ReturnType<typeof loadJiraConfig>>
+}
+
+const executeOne = async (
+  args: ExecuteOneArgs,
+): Promise<{ result?: ReleaseCreationResult; failure?: FailedRelease }> => {
+  const { entry, jiraConfig } = args
+
+  try {
+    await prepareGitForRelease(entry.type)
+
+    const result = await createSingleRelease({
+      version: entry.version,
+      jiraConfig,
+      description: entry.description,
+      type: entry.type,
+    })
+
+    logger.info(`✅ Successfully created release: v${entry.version} (${entry.type})`)
+    logger.info(`🔗  GitHub PR: ${result.prUrl}`)
+    logger.info(`🔗  Jira Version: ${result.jiraVersionUrl}\n`)
+
+    return { result }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+
+    logger.error(`❌ Failed to create release: v${entry.version}`)
+    logger.error(`   Error: ${errorMessage}\n`)
+
+    return { failure: { version: entry.version, error: errorMessage } }
+  }
+}
+
+const logFinalSummary = (total: number, successCount: number, failureCount: number): void => {
+  if (successCount === total) {
+    logger.info(`✅ All ${total} release branch(es) were created successfully.`)
+  } else if (successCount > 0) {
+    logger.warn(`⚠️  ${successCount} of ${total} release branches were created successfully.`)
+    logger.warn(`❌  ${failureCount} release(s) failed.`)
+  } else {
+    logger.error(`❌ All ${total} release branch(es) failed to create.`)
+  }
+}
+
+/**
+ * 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.
+ */
+export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecutionResult> => {
+  const { releases: inputReleases, confirmedCommand } = args
 
-  await prepareGitForRelease(type)
+  commandEcho.start('release-create')
+
+  const jiraConfig = await loadJiraConfig()
 
-  const release = await createSingleRelease({ version: trimmedVersion, jiraConfig, description, type })
+  let known: SemVer[] | null = null
+  const ensureKnown = async (): Promise<SemVer[]> => {
+    if (known === null) known = await loadExistingVersions()
+
+    return known
+  }
+
+  const entries = await collectEntries(inputReleases, ensureKnown)
+
+  if (entries.length === 0) {
+    logger.error('No releases provided. Exiting...')
+    process.exit(1)
+  }
+
+  await confirmReleases(entries, Boolean(confirmedCommand))
+
+  const created: ReleaseCreationResult[] = []
+  const failed: FailedRelease[] = []
+
+  for (const entry of entries) {
+    const { result, failure } = await executeOne({ entry, jiraConfig })
+
+    if (result) created.push(result)
+    if (failure) failed.push(failure)
+  }
 
-  logger.info(`✅ Successfully created release: v${trimmedVersion}`)
-  logger.info(`🔗  GitHub PR: ${release.prUrl}`)
-  logger.info(`🔗  Jira Version: ${release.jiraVersionUrl}`)
+  logFinalSummary(entries.length, created.length, failed.length)
 
   commandEcho.print()
 
   const structuredContent = {
-    version: trimmedVersion,
-    type,
-    branchName: release.branchName,
-    prUrl: release.prUrl,
-    jiraVersionUrl: release.jiraVersionUrl,
+    createdBranches: created.map((r) => {
+      return r.branchName
+    }),
+    successCount: created.length,
+    failureCount: failed.length,
+    releases: created,
+    failedReleases: failed,
   }
 
   return {
@@ -210,26 +268,48 @@ export const releaseCreate = async (args: ReleaseCreateArgs): Promise<ToolsExecu
 export const releaseCreateMcpTool = {
   name: 'release-create',
   description:
-    'Create a new release: cuts the release branch off the appropriate base (dev for regular releases, main for hotfixes), opens a GitHub release PR, and creates the matching Jira fix version. Does not switch the working tree to the new branch — the caller stays on the base branch. Confirmation is auto-skipped for MCP calls, so the caller is responsible for gating. "version" is required when invoked via MCP (the interactive input prompt is unreachable without a TTY); pass "next" to auto-compute the next version (regular bumps minor + resets patch; hotfix bumps patch on the highest minor) using the union of remote release branches and Jira fix versions. "type" / "description" default to regular / empty when omitted. For multiple versions in one call, prefer release-create-batch.',
+    'Create one or more releases in a single call. Each entry in "releases" carries its own version, 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, opens a GitHub release PR, and creates the matching Jira fix version. 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. Confirmation is auto-skipped for MCP calls, so the caller is responsible for gating. Continues on per-release failure and reports successes/failures.',
   inputSchema: {
-    version: z
-      .string()
-      .describe(
-        'Version to create (e.g., "1.2.5") or the literal token "next" for auto-increment. Required for MCP calls.',
-      ),
-    description: z.string().optional().describe('Optional description for the Jira version'),
-    type: z
-      .enum(['regular', 'hotfix'])
-      .optional()
-      .default('regular')
-      .describe('Release type: "regular" or "hotfix" (default: "regular")'),
+    releases: z
+      .array(
+        z.object({
+          version: z
+            .string()
+            .describe('Version to create (e.g., "1.2.5") or the literal token "next" for auto-increment.'),
+          type: z
+            .enum(['regular', 'hotfix'])
+            .optional()
+            .default('regular')
+            .describe('Release type: "regular" (branches off dev) or "hotfix" (branches off main).'),
+          description: z.string().optional().describe('Optional description for the Jira version.'),
+        }),
+      )
+      .min(1)
+      .describe('One or more releases to create. Each entry has its own version, type, and optional description.'),
   },
   outputSchema: {
-    version: z.string().describe('Version number'),
-    type: z.enum(['regular', 'hotfix']).describe('Release type'),
-    branchName: z.string().describe('Release branch name'),
-    prUrl: z.string().describe('GitHub PR URL'),
-    jiraVersionUrl: z.string().describe('Jira version URL'),
+    createdBranches: z.array(z.string()).describe('List of created release branch names'),
+    successCount: z.number().describe('Number of releases created successfully'),
+    failureCount: z.number().describe('Number of releases that failed'),
+    releases: z
+      .array(
+        z.object({
+          version: z.string().describe('Version number'),
+          type: z.enum(['regular', 'hotfix']).describe('Release type'),
+          branchName: z.string().describe('Release branch name'),
+          prUrl: z.string().describe('GitHub PR URL'),
+          jiraVersionUrl: z.string().describe('Jira version URL'),
+        }),
+      )
+      .describe('Detailed information for each created release with URLs'),
+    failedReleases: z
+      .array(
+        z.object({
+          version: z.string().describe('Version number that failed'),
+          error: z.string().describe('Error message'),
+        }),
+      )
+      .describe('List of releases that failed with error messages'),
   },
   handler: releaseCreate,
 }

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

@@ -130,8 +130,12 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
       commandEcho.addOption('--yes', true)
     }
 
+    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',
@@ -150,16 +154,18 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
         ],
       }))
 
-    if (typeof cursor === 'undefined') {
+    if (typeof cursor === 'undefined' && !cursorConfig?.mode) {
       commandEcho.setInteractive()
     }
 
     commandEcho.addOption('--cursor', cursorMode)
 
     const openInGithubDesktop =
-      githubDesktop ?? (await confirm({ message: 'Open created worktrees in GitHub Desktop?' }))
+      githubDesktop ??
+      config.worktrees?.openInGithubDesktop ??
+      (await confirm({ message: 'Open created worktrees in GitHub Desktop?' }))
 
-    if (typeof githubDesktop === 'undefined') {
+    if (typeof githubDesktop === 'undefined' && config.worktrees?.openInGithubDesktop === undefined) {
       commandEcho.setInteractive()
     }
 
@@ -169,9 +175,10 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
       commandEcho.addOption('--no-github-desktop', true)
     }
 
-    const openInCmux = cmux ?? (await confirm({ message: 'Open created worktrees in cmux?' }))
+    const openInCmux =
+      cmux ?? config.worktrees?.openInCmux ?? (await confirm({ message: 'Open created worktrees in cmux?' }))
 
-    if (typeof cmux === 'undefined') {
+    if (typeof cmux === 'undefined' && config.worktrees?.openInCmux === undefined) {
       commandEcho.setInteractive()
     }
 
@@ -191,11 +198,8 @@ export const worktreesAdd = async (options: WorktreeManagementArgs): Promise<Too
     logResults(createdWorktrees)
 
     if (cursorMode === 'workspace') {
-      const config = await getInfraKitConfig()
-      const cursorConfig = config.ide?.provider === 'cursor' ? config.ide.config : undefined
-
       if (!cursorConfig?.workspaceConfigPath) {
-        logger.warn('⚠️ Skipping Cursor: ide.config.workspaceConfigPath is not set in infra-kit.yml')
+        logger.warn('⚠️ Skipping Cursor: ide.config.workspaceConfigPath is not set in infra-kit config')
       } else {
         const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
 
@@ -355,19 +359,19 @@ export const worktreesAddMcpTool = {
       .enum(CURSOR_MODES)
       .optional()
       .describe(
-        'Cursor open mode for created worktrees. "workspace" (default behavior when set interactively) appends each worktree as a folder to "ide.config.workspaceConfigPath" in infra-kit.yml and opens the workspace. "windows" opens each worktree in its own Cursor window. "none" skips Cursor. Defaults to "none" in MCP mode (the follow-up prompt is not shown).',
+        '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).',
       ),
     githubDesktop: z
       .boolean()
       .optional()
       .describe(
-        'Open each created worktree in GitHub Desktop. Defaults to false in MCP mode (the follow-up prompt is not shown).',
+        'Open each created worktree in GitHub Desktop. Resolution order: this flag → "worktrees.openInGithubDesktop" from infra-kit config → interactive prompt (CLI) / false (MCP, no TTY).',
       ),
     cmux: z
       .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. Defaults to false in MCP mode (the follow-up prompt is not shown).',
+        '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).',
       ),
   },
   outputSchema: {

package/src/entry/cli.ts

@@ -1,5 +1,5 @@
 import select, { Separator } from '@inquirer/select'
-import { Command, Option } from 'commander'
+import { Command } from 'commander'
 import process from 'node:process'
 
 import { configEdit, configPath } from 'src/commands/config'
@@ -15,7 +15,6 @@ import { ghReleaseDeploySelected } from 'src/commands/gh-release-deploy-selected
 import { ghReleaseList } from 'src/commands/gh-release-list'
 import { init } from 'src/commands/init'
 import { releaseCreate } from 'src/commands/release-create'
-import { releaseCreateBatch } from 'src/commands/release-create-batch'
 import { version } from 'src/commands/version'
 import { CURSOR_MODES, worktreesAdd } from 'src/commands/worktrees-add'
 import type { CursorMode } from 'src/commands/worktrees-add'
@@ -24,9 +23,14 @@ import { worktreesOpen } from 'src/commands/worktrees-open'
 import { worktreesRemove } from 'src/commands/worktrees-remove'
 import { worktreesSync } from 'src/commands/worktrees-sync'
 import { logger } from 'src/lib/logger'
+import { parseReleaseSpec } from 'src/lib/version-utils'
 
 const program = new Command()
 
+const collectReleaseSpec = (value: string, prev: string[]): string[] => {
+  return [...prev, value]
+}
+
 const normalizeCursorMode = (value: unknown): CursorMode | undefined => {
   if (typeof value === 'undefined') {
     return undefined
@@ -80,36 +84,20 @@ program
 
 program
   .command('release-create')
-  .description('Create a single release branch')
+  .description('Create one or more release branches (each entry can mix regular/hotfix and its own description)')
   .option(
-    '-v, --version <version>',
-    'Version to create, e.g. "1.2.5", "next", or "next,next,1.2.7" (multi-value routes to batch)',
+    '-r, --release <spec>',
+    'Release spec "version[:type[:description]]" (repeatable). Examples: "1.2.5", "1.2.5:hotfix", "next:regular:Holiday backend"',
+    collectReleaseSpec,
+    [],
   )
-  .option('-d, --description <description>', 'Optional description for the Jira version')
-  .addOption(new Option('-t, --type <type>', 'Release type (default: regular)').choices(['regular', 'hotfix']))
   .option('-y, --yes', 'Skip confirmation prompt')
   .action(async (options) => {
-    await releaseCreate({
-      version: options.version,
-      description: options.description,
-      type: options.type,
-      confirmedCommand: options.yes,
-    })
-  })
+    const specs = options.release as string[]
+    const releases = specs.length > 0 ? specs.map(parseReleaseSpec) : undefined
 
-program
-  .command('release-create-batch')
-  .description('Create multiple release branches (batch operation)')
-  .option(
-    '-v, --versions <versions>',
-    'Comma-separated versions, e.g. "1.2.5, 1.2.6", "next,next", or "next,next,1.2.7"',
-  )
-  .addOption(new Option('-t, --type <type>', 'Release type (default: regular)').choices(['regular', 'hotfix']))
-  .option('-y, --yes', 'Skip confirmation prompt')
-  .action(async (options) => {
-    await releaseCreateBatch({
-      versions: options.versions,
-      type: options.type,
+    await releaseCreate({
+      releases,
       confirmedCommand: options.yes,
     })
   })
@@ -275,7 +263,6 @@ if (process.argv.length <= 2) {
     'merge-dev',
     'release-list',
     'release-create',
-    'release-create-batch',
     'release-deploy-all',
     'release-deploy-selected',
     'release-deliver',