infra-kit 0.1.107 → 0.1.108

package/package.json

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

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

@@ -6,7 +6,12 @@ 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'
@@ -227,10 +232,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/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'

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

@@ -2,14 +2,19 @@ import { $ } from 'zx'
 
 import { logger } from 'src/lib/logger'
 
+import { canonicalizeCmuxTitle } from './canonicalize-cmux-title'
+
 /**
- * Returns the set of titles for all currently-open cmux workspaces.
- * Returns an empty set if cmux isn't running, the call fails, or the
- * output can't be parsed — callers should treat "empty" as "unknown,
- * proceed as if nothing is open".
+ * Returns the set of **canonical** titles for all currently-open cmux
+ * workspaces (see {@link canonicalizeCmuxTitle}). Keying on the canonical form
+ * lets callers match a workspace even when its stored title drifted from the
+ * title they rebuild (whitespace, or an older CLI's `v`-prefixed semver).
+ * Returns an empty set if cmux isn't running, the call fails, or the output
+ * can't be parsed — callers should treat "empty" as "unknown, proceed as if
+ * nothing is open".
  *
  * Each line of `cmux list-workspaces` looks like:
- *   "  workspace:8  hulyo-monorepo v1.48.0"
+ *   "  workspace:8  hulyo-monorepo 1.48.0"
  *   "* workspace:6  obsidian-workspace  [selected]"
  */
 export const listCmuxWorkspaceTitles = async (): Promise<Set<string>> => {
@@ -29,7 +34,7 @@ export const listCmuxWorkspaceTitles = async (): Promise<Set<string>> => {
       const title = match[1]?.trim()
 
       if (title) {
-        titles.add(title)
+        titles.add(canonicalizeCmuxTitle(title))
       }
     }
 

package/src/integrations/gh/gh-release-prs/.omc/state/sessions/c6ed6186-1aac-48e0-aa2a-edc6da8e0410/pre-tool-advisory-throttle.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "entries": {
+    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
+      "last_emitted_at_ms": 1781518823336,
+      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
+    }
+  },
+  "updated_at": "2026-06-15T10:20:23.336Z"
+}

package/src/integrations/gh/gh-release-prs/__tests__/gh-release-prs.test.ts

@@ -1,6 +1,8 @@
+import { execFileSync } from 'node:child_process'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { quote } from 'zx'
 
-import { getReleasePRs, getReleasePRsWithInfo } from '../gh-release-prs'
+import { createReleaseBranch, getReleasePRs, getReleasePRsWithInfo } from '../gh-release-prs'
 
 interface FakePR {
   number: number
@@ -12,17 +14,32 @@ interface FakePR {
 }
 
 const responses = vi.hoisted(() => {
-  return { release: [] as FakePR[], hotfix: [] as FakePR[] }
+  return {
+    release: [] as FakePR[],
+    hotfix: [] as FakePR[],
+    calls: [] as { strings: string[]; values: unknown[] }[],
+  }
 })
 
 // Mock zx's tagged-template `$`: the gh pr list call for `--base dev` returns
-// the "release" set, `--base main` returns the "hotfix" set. The command is
-// reconstructed from the template strings so we can branch on the base flag.
-vi.mock('zx', () => {
+// the "release" set, `--base main` returns the "hotfix" set, and `gh pr create`
+// returns a fake PR URL. Every invocation is captured (template strings +
+// interpolated values) so tests can reconstruct the exact command zx would run.
+// Spreading `...actual` keeps zx's real `quote` available for that reconstruction.
+vi.mock('zx', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('zx')>()
+
   return {
-    $: vi.fn((strings: TemplateStringsArray) => {
+    ...actual,
+    $: vi.fn((strings: TemplateStringsArray, ...values: unknown[]) => {
       const command = strings.join('')
 
+      responses.calls.push({ strings: [...strings], values })
+
+      if (command.includes('gh pr create')) {
+        return Promise.resolve({ stdout: 'https://github.com/acme/repo/pull/123' })
+      }
+
       if (command.includes('--base main')) {
         return Promise.resolve({ stdout: JSON.stringify(responses.hotfix) })
       }
@@ -113,3 +130,69 @@ describe('getReleasePRsWithInfo (discovery + sort)', () => {
     ])
   })
 })
+
+describe('createReleaseBranch (gh pr create title quoting)', () => {
+  beforeEach(() => {
+    responses.calls = []
+  })
+
+  // Rebuild the exact command zx would have run: interleave each template
+  // string with the zx-quoted form of its interpolated value. This reflects
+  // what the shell actually receives, including zx's ANSI-C `$'...'` escaping
+  // for values containing spaces.
+  const reconstruct = (call: { strings: string[]; values: unknown[] }): string => {
+    return call.strings
+      .map((part, i) => {
+        return i < call.values.length ? part + quote(String(call.values[i])) : part
+      })
+      .join('')
+  }
+
+  const findCreateCommand = (): string => {
+    const call = responses.calls.find((c) => {
+      return c.strings.join('').includes('gh pr create')
+    })
+
+    if (!call) throw new Error('gh pr create was not invoked')
+
+    return reconstruct(call)
+  }
+
+  // Run the reconstructed command through a real shell with `gh pr create`
+  // replaced by a function that prints back the value the shell parsed for
+  // `--title`. This is the behavioral proof of what gh would receive.
+  const shellTitleArg = (command: string): string => {
+    const probe = command.replace(
+      'gh pr create',
+      'f(){ while [ "$#" -gt 0 ]; do if [ "$1" = "--title" ]; then printf %s "$2"; return 0; fi; shift; done; }; f',
+    )
+
+    // Absolute path (not PATH-resolved) keeps the lint's command-injection guard happy.
+    return execFileSync('/bin/sh', ['-c', probe]).toString()
+  }
+
+  it("delivers a spaced title to gh as the literal string, with no $'...' corruption", async () => {
+    const id = { kind: 'version', semver: { major: 1, minor: 89, patch: 1 }, raw: '1.89.1' } as const
+
+    await createReleaseBranch({ id, jiraVersionUrl: 'https://jira.example/v1.89.1', type: 'hotfix' })
+
+    const command = findCreateCommand()
+
+    // Behavioral: the shell parses --title to exactly the intended title.
+    expect(shellTitleArg(command)).toBe('Hotfix v1.89.1')
+    // The pre-fix bug wrapped zx's `$'...'` token in literal double quotes, so
+    // the shell passed the literal `$'Hotfix v1.89.1'` to gh. That marker must be absent.
+    expect(command).not.toContain('"$\'')
+  })
+
+  it('delivers a named release title to gh as the literal string', async () => {
+    const id = { kind: 'name', name: 'checkout-redesign', raw: 'checkout-redesign' } as const
+
+    await createReleaseBranch({ id, jiraVersionUrl: 'https://jira.example/checkout-redesign', type: 'regular' })
+
+    const command = findCreateCommand()
+
+    expect(shellTitleArg(command)).toBe('Release checkout-redesign')
+    expect(command).not.toContain('"$\'')
+  })
+})

package/src/integrations/gh/gh-release-prs/gh-release-prs.ts

@@ -178,7 +178,7 @@ export const createReleaseBranch = async (
     await $`git push origin ${branchName}`
 
     // Create PR and capture URL
-    const prResult = await $`gh pr create --title "${prTitle}" --body ${body} --base ${baseBranch} --head ${branchName}`
+    const prResult = await $`gh pr create --title ${prTitle} --body ${body} --base ${baseBranch} --head ${branchName}`
 
     const prLink = prResult.stdout.trim()