infra-kit 0.1.105 → 0.1.108

package/src/commands/init/init.ts

@@ -3,7 +3,9 @@ import os from 'node:os'
 import path from 'node:path'
 
 import { logger } from 'src/lib/logger'
+import { removeManagedBlock, upsertManagedBlock } from 'src/lib/managed-block'
 
+import { writeAgentFiles } from './agent-files'
 import { migrateLegacyConfig } from './migrate-config'
 
 export const MARKER_START = '# -- infra-kit:begin --'
@@ -55,16 +57,22 @@ const USER_GLOBAL_CONFIG_EXAMPLE = `// infra-kit user-global config — ~/.infra
  */
 export const init = async (): Promise<void> => {
   const zshrcPath = path.join(os.homedir(), '.zshrc')
-  const shellBlock = buildShellBlock()
 
-  if (fs.existsSync(zshrcPath)) {
-    const content = fs.readFileSync(zshrcPath, 'utf-8')
-    const cleaned = removeExistingBlock(content)
+  // Strip any prior block (current or legacy markers) anywhere in the file, then
+  // append a fresh block at end-of-file via the shared managed-block utility —
+  // the historical `removeExistingBlock` + append behavior, now centralized.
+  const existing = fs.existsSync(zshrcPath) ? removeExistingBlock(fs.readFileSync(zshrcPath, 'utf-8')) : ''
 
-    fs.writeFileSync(zshrcPath, cleaned)
-  }
+  const updated = upsertManagedBlock({
+    content: existing,
+    body: buildShellBody(),
+    startMarker: MARKER_START,
+    endMarker: MARKER_END,
+    placement: 'append-end',
+  })
+
+  fs.writeFileSync(zshrcPath, updated)
 
-  fs.appendFileSync(zshrcPath, `\n${shellBlock}\n`)
   logger.info(`Added infra-kit shell functions to ${zshrcPath}`)
 
   // Convert any legacy infra-kit.yml config layers to JSON before seeding, so a
@@ -73,6 +81,10 @@ export const init = async (): Promise<void> => {
 
   seedUserGlobalConfig()
 
+  // Best-effort, non-fatal, repo-gated: keep the agent-instruction files in sync
+  // with the CLI surface. A no-op outside an infra-kit repo.
+  await writeAgentFiles()
+
   logger.info('Run `source ~/.zshrc` or open a new terminal to activate.')
 }
 
@@ -125,28 +137,15 @@ const isBlockLine = (line: string): boolean => {
   )
 }
 
-const removeBetween = (content: string, start: string, end: string): string | null => {
-  const startIdx = content.indexOf(start)
-  const endIdx = content.indexOf(end)
-
-  if (startIdx === -1 || endIdx === -1) return null
-
-  // eslint-disable-next-line sonarjs/slow-regex
-  const before = content.slice(0, startIdx).replace(/\n+$/, '')
-  const after = content.slice(endIdx + end.length).replace(/^\n+/, '')
-
-  return before + (after ? `\n${after}` : '')
-}
-
 const removeExistingBlock = (content: string): string => {
   // 1. Current markers
-  const result = removeBetween(content, MARKER_START, MARKER_END)
+  const result = removeManagedBlock(content, MARKER_START, MARKER_END)
 
   if (result !== null) return result
 
   // 2. Legacy paired markers (# region / # endregion)
   for (const [start, end] of LEGACY_PAIRED) {
-    const legacyResult = removeBetween(content, start, end)
+    const legacyResult = removeManagedBlock(content, start, end)
 
     if (legacyResult !== null) return legacyResult
   }
@@ -171,11 +170,14 @@ const removeExistingBlock = (content: string): string => {
   return before + (remaining ? `\n${remaining}` : '')
 }
 
-export const buildShellBlock = (): string => {
+/**
+ * The inner shell-function lines (no markers). Composed into the full marked
+ * block by {@link buildShellBlock} and fed to `upsertManagedBlock` by `init()`.
+ */
+export const buildShellBody = (): string => {
   const runCmd = 'pnpm exec infra-kit'
 
   return [
-    MARKER_START,
     'zmodload zsh/stat 2>/dev/null',
     'zmodload zsh/datetime 2>/dev/null',
     // eslint-disable-next-line no-template-curly-in-string
@@ -223,6 +225,13 @@ export const buildShellBlock = (): string => {
     'if (( _INFRA_KIT_SHELL_STARTED > 0 )); then',
     '  add-zsh-hook precmd _infra_kit_autoload',
     'fi',
-    MARKER_END,
   ].join('\n')
 }
+
+/**
+ * The full marker-delimited shell block (`MARKER_START … MARKER_END`). Kept as
+ * a single composed string so `doctor`'s exact-match freshness check stays valid.
+ */
+export const buildShellBlock = (): string => {
+  return `${MARKER_START}\n${buildShellBody()}\n${MARKER_END}`
+}

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/entry/cli.ts

@@ -286,7 +286,7 @@ program
 
 program
   .command('init')
-  .description('Inject shell integration into your profile .zshrc')
+  .description('Inject shell integration into .zshrc and sync repo agent-instruction files')
   .action(async () => {
     await init()
   })

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/cmux/open-workspace-with-layout.ts

@@ -26,7 +26,7 @@ export const openCmuxWorkspaceWithLayout = async (args: OpenCmuxWorkspaceArgs):
   await $`cmux new-split down --workspace ${workspaceRef} --surface ${leftTopRef}`
 
   if (title) {
-    await $`cmux workspace rename --workspace ${workspaceRef} ${title}`
+    await $`cmux workspace rename --workspace ${workspaceRef} --title ${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"
+}