infra-kit 0.1.111 → 0.1.113

package/src/integrations/zed/open-zed-workspace.ts

@@ -0,0 +1,57 @@
+import { $ } from 'zx'
+
+import { logger } from 'src/lib/logger'
+
+interface OpenZedWorkspaceArgs {
+  projectRoot: string
+  worktreeDir: string
+  currentBranches: string[]
+  /**
+   * When true, skip launching Zed if there are no release worktrees. Lets
+   * `worktrees-reload` avoid popping a bare Zed window while keeping the
+   * cold-start `worktrees-open` behaviour (launch unconditionally) intact.
+   */
+  skipRelaunchWhenEmpty: boolean
+}
+
+interface OpenZedWorkspaceOutcome {
+  ran: boolean
+  added: number
+  removed: number
+}
+
+/**
+ * Opens a single Zed workspace containing the project root plus every release
+ * worktree, via one `zed <root> <wt...>` invocation (Zed realizes a multi-folder
+ * workspace from multiple path arguments). Shared by `worktrees-open` (cold-start
+ * restore) and `worktrees-reload` (relaunch).
+ *
+ * Zed has no portable workspace file and no folder-remove CLI, so there is
+ * nothing to reconcile: `added` is the number of worktrees opened and `removed`
+ * is always 0. All failures are swallowed into a warning — opening Zed is
+ * best-effort, mirroring the Cursor integration.
+ */
+export const openZedWorkspace = async (args: OpenZedWorkspaceArgs): Promise<OpenZedWorkspaceOutcome> => {
+  const { projectRoot, worktreeDir, currentBranches, skipRelaunchWhenEmpty } = args
+
+  if (skipRelaunchWhenEmpty && currentBranches.length === 0) {
+    return { ran: false, added: 0, removed: 0 }
+  }
+
+  const paths = [
+    projectRoot,
+    ...currentBranches.map((branch) => {
+      return `${worktreeDir}/${branch}`
+    }),
+  ]
+
+  try {
+    await $`zed ${paths}`
+
+    return { ran: true, added: currentBranches.length, removed: 0 }
+  } catch (error) {
+    logger.warn({ error }, '⚠️ Failed to open Zed workspace')
+
+    return { ran: false, added: 0, removed: 0 }
+  }
+}

package/src/lib/assert-never/assert-never.ts

@@ -0,0 +1,15 @@
+/**
+ * Exhaustiveness guard for discriminated unions. Place in the `default` branch of
+ * a `switch` over a union: once every case is handled the argument narrows to
+ * `never`, so adding a new variant later turns this into a compile error.
+ *
+ * @example
+ * switch (provider) {
+ *   case 'cursor': return openCursor()
+ *   case 'zed': return openZed()
+ *   default: return assertNever(provider) // compile error if a provider is unhandled
+ * }
+ */
+export const assertNever = (value: never): never => {
+  throw new Error(`Unexpected value: ${JSON.stringify(value)}`)
+}

package/src/lib/assert-never/index.ts

@@ -0,0 +1 @@
+export { assertNever } from './assert-never'

package/src/lib/git-utils/__tests__/git-primitives.test.ts

@@ -1,6 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { getCurrentBranch, isInsideLinkedWorktree, isWorkingTreeClean } from 'src/lib/git-utils'
+import {
+  deleteLocalBranch,
+  deleteRemoteBranch,
+  getCurrentBranch,
+  isInsideLinkedWorktree,
+  isWorkingTreeClean,
+} from 'src/lib/git-utils'
 
 // Controllable per-command git output. The mocked `$` dispatches on the command
 // text so a single test can make `--absolute-git-dir` and `--git-common-dir`
@@ -12,6 +18,12 @@ const git = vi.hoisted(() => {
     status: '',
     absoluteGitDir: '/repo/.git',
     commonDir: '.git',
+    branchList: '',
+    lsRemote: '',
+    lsRemoteThrows: false,
+    localDeleteThrows: false,
+    remoteDeleteThrows: false,
+    calls: [] as string[],
   }
 })
 
@@ -19,11 +31,29 @@ vi.mock('zx', () => {
   const run = (strings: TemplateStringsArray): Promise<{ stdout: string }> => {
     const command = strings.join('')
 
+    git.calls.push(command)
+
     if (command.includes('--show-toplevel')) return Promise.resolve({ stdout: `${git.toplevel}\n` })
     if (command.includes('--abbrev-ref HEAD')) return Promise.resolve({ stdout: `${git.branch}\n` })
     if (command.includes('status --porcelain')) return Promise.resolve({ stdout: git.status })
     if (command.includes('--absolute-git-dir')) return Promise.resolve({ stdout: `${git.absoluteGitDir}\n` })
     if (command.includes('--git-common-dir')) return Promise.resolve({ stdout: `${git.commonDir}\n` })
+    if (command.includes('branch --list')) return Promise.resolve({ stdout: git.branchList })
+    if (command.includes('branch -D')) {
+      return git.localDeleteThrows
+        ? Promise.reject(new Error('branch checked out in another worktree'))
+        : Promise.resolve({ stdout: '' })
+    }
+    if (command.includes('ls-remote --heads')) {
+      return git.lsRemoteThrows
+        ? Promise.reject(new Error('could not read from remote repository'))
+        : Promise.resolve({ stdout: git.lsRemote })
+    }
+    if (command.includes('push origin --delete')) {
+      return git.remoteDeleteThrows
+        ? Promise.reject(new Error('remote ref does not exist'))
+        : Promise.resolve({ stdout: '' })
+    }
 
     return Promise.resolve({ stdout: '' })
   }
@@ -94,3 +124,94 @@ describe('isInsideLinkedWorktree', () => {
     await expect(isInsideLinkedWorktree()).resolves.toBe(true)
   })
 })
+
+const ranLocalDelete = (): boolean => {
+  return git.calls.some((c) => {
+    return c.includes('branch -D')
+  })
+}
+const ranRemoteDelete = (): boolean => {
+  return git.calls.some((c) => {
+    return c.includes('push origin --delete')
+  })
+}
+
+describe('deleteLocalBranch', () => {
+  beforeEach(() => {
+    git.branch = 'dev'
+    git.branchList = ''
+    git.localDeleteThrows = false
+    git.calls = []
+  })
+
+  it('force-deletes the branch when it exists and is not current', async () => {
+    git.branchList = '  release/v1.2.3\n'
+
+    await deleteLocalBranch('release/v1.2.3')
+
+    expect(ranLocalDelete()).toBe(true)
+  })
+
+  it('is a no-op when the branch does not exist locally', async () => {
+    git.branchList = ''
+
+    await deleteLocalBranch('release/v1.2.3')
+
+    expect(ranLocalDelete()).toBe(false)
+  })
+
+  it('is a no-op when the branch is the current checkout', async () => {
+    git.branch = 'release/v1.2.3'
+    git.branchList = '* release/v1.2.3\n'
+
+    await deleteLocalBranch('release/v1.2.3')
+
+    expect(ranLocalDelete()).toBe(false)
+  })
+
+  it('propagates when the delete itself fails (e.g. checked out in another worktree)', async () => {
+    git.branchList = '  release/v1.2.3\n'
+    git.localDeleteThrows = true
+
+    await expect(deleteLocalBranch('release/v1.2.3')).rejects.toThrow()
+  })
+})
+
+describe('deleteRemoteBranch', () => {
+  beforeEach(() => {
+    git.lsRemote = ''
+    git.lsRemoteThrows = false
+    git.remoteDeleteThrows = false
+    git.calls = []
+  })
+
+  it('deletes the remote branch when ls-remote finds it', async () => {
+    git.lsRemote = 'abc123\trefs/heads/release/v1.2.3\n'
+
+    await deleteRemoteBranch('release/v1.2.3')
+
+    expect(ranRemoteDelete()).toBe(true)
+  })
+
+  it('is a no-op when the branch does not exist on the remote', async () => {
+    git.lsRemote = ''
+
+    await deleteRemoteBranch('release/v1.2.3')
+
+    expect(ranRemoteDelete()).toBe(false)
+  })
+
+  it('propagates a network/auth failure instead of treating it as "branch absent"', async () => {
+    git.lsRemoteThrows = true
+
+    await expect(deleteRemoteBranch('release/v1.2.3')).rejects.toThrow()
+    expect(ranRemoteDelete()).toBe(false)
+  })
+
+  it('propagates when the remote delete itself fails', async () => {
+    git.lsRemote = 'abc123\trefs/heads/release/v1.2.3\n'
+    git.remoteDeleteThrows = true
+
+    await expect(deleteRemoteBranch('release/v1.2.3')).rejects.toThrow()
+  })
+})

package/src/lib/git-utils/git-utils.ts

@@ -142,3 +142,38 @@ export const getRepoName = async (): Promise<string> => {
 
   return path.basename(projectRoot)
 }
+
+/**
+ * Delete a local branch if it exists and is not the current checkout.
+ *
+ * Idempotent: a no-op when the branch is absent (`git branch --list` prints
+ * nothing). Uses force `-D` because a delivered release branch was
+ * squash-merged — its tip is unreachable from the base, so `-d` would refuse
+ * with "not fully merged". The delete itself still rejects if the branch is
+ * checked out in another worktree; callers decide how to handle that.
+ */
+export const deleteLocalBranch = async (branch: string): Promise<void> => {
+  const listed = await $`git branch --list ${branch}`
+
+  if (listed.stdout.trim().length === 0) return
+
+  if ((await getCurrentBranch()) === branch) return
+
+  await $`git branch -D ${branch}`
+}
+
+/**
+ * Delete a branch on the `origin` remote if it exists.
+ *
+ * Idempotent: a no-op when the branch is absent on the remote. Existence is
+ * probed with `git ls-remote --heads` (empty stdout = absent) rather than
+ * `--exit-code`, so a genuine network/auth failure rejects and propagates to
+ * the caller instead of being silently misread as "branch absent".
+ */
+export const deleteRemoteBranch = async (branch: string): Promise<void> => {
+  const refs = await $`git ls-remote --heads origin ${branch}`
+
+  if (refs.stdout.trim().length === 0) return
+
+  await $`git push origin --delete ${branch}`
+}

package/src/lib/git-utils/index.ts

@@ -1,4 +1,6 @@
 export {
+  deleteLocalBranch,
+  deleteRemoteBranch,
   getCurrentBranch,
   getCurrentWorktrees,
   getProjectRoot,

package/src/lib/infra-kit-config/.omc/state/sessions/8dd0ad2f-3a90-4158-b9de-ec8e19a7c983/pre-tool-advisory-throttle.json

@@ -0,0 +1,18 @@
+{
+  "version": 1,
+  "entries": {
+    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
+      "last_emitted_at_ms": 1782040911131,
+      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
+    },
+    "445ed27a3872b681d98190bae61ccb84954e1bc4e140df5370be958dee776b3a": {
+      "last_emitted_at_ms": 1782040633210,
+      "message": "Verify changes work after editing. Test functionality before marking complete."
+    },
+    "466399dafa2d20f60587180bad0a07358eb7f2bce724df0ff682f038ad33f5ad": {
+      "last_emitted_at_ms": 1782040627481,
+      "message": "Read multiple files in parallel when possible for faster analysis."
+    }
+  },
+  "updated_at": "2026-06-21T11:21:51.131Z"
+}

package/src/lib/infra-kit-config/__tests__/infra-kit-config.test.ts

@@ -6,7 +6,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 // Import AFTER the mock is declared so the module picks up the mocked dep.
 import { getProjectRoot, getRepoName } from 'src/lib/git-utils'
 
-import { getInfraKitConfig, resetInfraKitConfigCache } from '../infra-kit-config'
+import { getInfraKitConfig, resetInfraKitConfigCache, resolveConfiguredIdes } from '../infra-kit-config'
+import type { InfraKitConfig } from '../infra-kit-config'
 
 vi.mock('src/lib/git-utils', () => {
   return {
@@ -76,24 +77,143 @@ describe('getInfraKitConfig', () => {
         JSON.stringify({
           environments: ['dev'],
           envManagement: { provider: 'doppler', config: { name: 'p' } },
-          ide: { provider: 'cursor', config: { mode: 'workspace', workspaceConfigPath: './ws.code-workspace' } },
+          ide: { provider: 'cursor', config: { workspaceConfigPath: './ws.code-workspace' } },
           taskManager: { provider: 'jira', config: { baseUrl: 'https://example.atlassian.net', projectId: 123 } },
         }),
       )
 
       const cfg = await getInfraKitConfig()
 
-      expect(cfg.ide?.provider).toBe('cursor')
+      const ide = resolveConfiguredIdes(cfg)[0]
 
-      if (cfg.ide?.provider === 'cursor') {
-        expect(cfg.ide.config.mode).toBe('workspace')
-        expect(cfg.ide.config.workspaceConfigPath).toBe('./ws.code-workspace')
+      if (!ide) {
+        throw new Error('expected one configured ide')
+      }
+
+      expect(ide.provider).toBe('cursor')
+
+      if (ide.provider === 'cursor') {
+        expect(ide.config.workspaceConfigPath).toBe('./ws.code-workspace')
       }
 
       expect(cfg.taskManager?.provider).toBe('jira')
     })
   })
 
+  it('accepts a zed ide provider with no workspaceConfigPath', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: { provider: 'zed', config: {} },
+        }),
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(resolveConfiguredIdes(cfg)[0]?.provider).toBe('zed')
+    })
+  })
+
+  it('strips a legacy "mode" key (backward compat)', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: { provider: 'zed', config: { mode: 'windows' } },
+        }),
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      const ide = resolveConfiguredIdes(cfg)[0]
+
+      if (!ide) {
+        throw new Error('expected one configured ide')
+      }
+
+      expect(ide.provider).toBe('zed')
+      // The now-removed `mode` field is silently stripped, not rejected.
+      expect(ide.config).not.toHaveProperty('mode')
+    })
+  })
+
+  it('accepts an array of IDE providers (multi-editor)', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: [
+            { provider: 'cursor', config: { workspaceConfigPath: './ws.code-workspace' } },
+            { provider: 'zed', config: {} },
+          ],
+        }),
+      )
+
+      const cfg = await getInfraKitConfig()
+
+      expect(
+        resolveConfiguredIdes(cfg).map((ide) => {
+          return ide.provider
+        }),
+      ).toEqual(['cursor', 'zed'])
+    })
+  })
+
+  it('rejects an array with a duplicate provider at parse time', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: [
+            { provider: 'cursor', config: { workspaceConfigPath: './a.code-workspace' } },
+            { provider: 'cursor', config: { workspaceConfigPath: './b.code-workspace' } },
+          ],
+        }),
+      )
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/each IDE provider may appear at most once/)
+    })
+  })
+
+  it('rejects an empty IDE array', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: [],
+        }),
+      )
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/Invalid infra-kit\.json/)
+    })
+  })
+
+  it('rejects an unknown ide provider', async () => {
+    await withTmpRepo(async (tmp) => {
+      fs.writeFileSync(
+        path.join(tmp, 'infra-kit.json'),
+        JSON.stringify({
+          environments: ['dev'],
+          envManagement: { provider: 'doppler', config: { name: 'p' } },
+          ide: { provider: 'vscode', config: {} },
+        }),
+      )
+
+      await expect(getInfraKitConfig()).rejects.toThrow(/Invalid infra-kit\.json/)
+    })
+  })
+
   it('accepts a worktrees prompt-defaults block', async () => {
     await withTmpRepo(async (tmp) => {
       fs.writeFileSync(
@@ -154,18 +274,21 @@ describe('getInfraKitConfig', () => {
     })
   })
 
-  it('rejects ide.cursor mode=workspace without workspaceConfigPath', async () => {
+  it('rejects cursor without workspaceConfigPath', async () => {
     await withTmpRepo(async (tmp) => {
       fs.writeFileSync(
         path.join(tmp, 'infra-kit.json'),
         JSON.stringify({
           environments: ['dev'],
           envManagement: { provider: 'doppler', config: { name: 'p' } },
-          ide: { provider: 'cursor', config: { mode: 'workspace' } },
+          ide: { provider: 'cursor', config: {} },
         }),
       )
 
-      await expect(getInfraKitConfig()).rejects.toThrow(/workspaceConfigPath/)
+      // Cursor requires workspaceConfigPath; with the single|array union the
+      // inner message collapses to the union-level "Invalid input → at ide",
+      // but the config is still rejected (which is what matters).
+      await expect(getInfraKitConfig()).rejects.toThrow(/Invalid infra-kit\.json/)
     })
   })
 
@@ -268,3 +391,43 @@ describe('getInfraKitConfig', () => {
     })
   })
 })
+
+describe('resolveConfiguredIdes', () => {
+  const base = {
+    environments: ['dev'],
+    envManagement: { provider: 'doppler', config: { name: 'p' } },
+  } as InfraKitConfig
+
+  it('wraps a single ide object in an array', () => {
+    const cfg = {
+      ...base,
+      ide: { provider: 'cursor', config: { workspaceConfigPath: 'ws' } },
+    } as InfraKitConfig
+
+    expect(
+      resolveConfiguredIdes(cfg).map((ide) => {
+        return ide.provider
+      }),
+    ).toEqual(['cursor'])
+  })
+
+  it('returns an ide array as-is', () => {
+    const cfg = {
+      ...base,
+      ide: [
+        { provider: 'cursor', config: { workspaceConfigPath: 'ws' } },
+        { provider: 'zed', config: {} },
+      ],
+    } as InfraKitConfig
+
+    expect(
+      resolveConfiguredIdes(cfg).map((ide) => {
+        return ide.provider
+      }),
+    ).toEqual(['cursor', 'zed'])
+  })
+
+  it('returns an empty array when ide is unset', () => {
+    expect(resolveConfiguredIdes(base)).toEqual([])
+  })
+})

package/src/lib/infra-kit-config/index.ts

@@ -4,5 +4,6 @@ export {
   infraKitConfigSchema,
   infraKitOverrideConfigSchema,
   resetInfraKitConfigCache,
+  resolveConfiguredIdes,
 } from './infra-kit-config'
-export type { InfraKitConfig, InfraKitConfigPaths } from './infra-kit-config'
+export type { ConfiguredIde, InfraKitConfig, InfraKitConfigPaths } from './infra-kit-config'

package/src/lib/infra-kit-config/infra-kit-config.ts

@@ -22,27 +22,36 @@ const dopplerEnvManagementSchema = z.object({
 const envManagementSchema = z.discriminatedUnion('provider', [dopplerEnvManagementSchema])
 
 // ide
-const cursorIdeConfigSchema = z
-  .object({
-    mode: z.enum(['workspace', 'windows']).default('workspace'),
-    workspaceConfigPath: z.string().min(1).optional(),
-  })
-  .refine(
-    (v) => {
-      return v.mode !== 'workspace' || !!v.workspaceConfigPath
-    },
-    {
-      message: 'workspaceConfigPath is required when mode is "workspace"',
-      path: ['workspaceConfigPath'],
-    },
-  )
+// There is one attach style: each worktree is added to the configured editor's
+// workspace and opened (no per-window mode). Cursor needs a `.code-workspace`
+// path to reconcile its `folders` array against.
+const cursorIdeConfigSchema = z.object({
+  workspaceConfigPath: z.string().min(1),
+})
 
 const cursorIdeSchema = z.object({
   provider: z.literal('cursor'),
   config: cursorIdeConfigSchema,
 })
 
-const ideSchema = z.discriminatedUnion('provider', [cursorIdeSchema])
+// Zed has no portable workspace file (no `.code-workspace`) and no folder-remove
+// CLI: a multi-worktree workspace is realized by a single `zed <root> <wt...>`
+// invocation. So `config` carries no settings — there's no path to point at.
+const zedIdeConfigSchema = z.object({})
+
+const zedIdeSchema = z.object({
+  provider: z.literal('zed'),
+  config: zedIdeConfigSchema,
+})
+
+const ideSchema = z.discriminatedUnion('provider', [cursorIdeSchema, zedIdeSchema])
+
+// `ide` accepts a single provider (back-compat) OR an array to drive multiple
+// editors at once (e.g. Cursor + Zed). Normalized to an array everywhere via
+// `resolveConfiguredIdes`. Uniqueness-by-provider is enforced at parse time by a
+// `.superRefine` on the full config schema (see below) — not here, so the message
+// survives `z.union` error aggregation.
+const idesSchema = z.union([ideSchema, z.array(ideSchema).min(1)])
 
 // taskManager
 const jiraTaskManagerSchema = z.object({
@@ -61,18 +70,67 @@ const worktreesConfigSchema = z.object({
   openInCmux: z.boolean().optional(),
 })
 
-export const infraKitConfigSchema = z.object({
+// Base object shape, kept separate so `.partial()` (which only works on a plain
+// ZodObject, not the `.superRefine`-wrapped full schema) can derive the override
+// schema from it.
+const infraKitConfigObject = z.object({
   environments: z.array(z.string().min(1)).min(1),
   envManagement: envManagementSchema,
-  ide: ideSchema.optional(),
+  ide: idesSchema.optional(),
   taskManager: taskManagerSchema.optional(),
   worktrees: worktreesConfigSchema.optional(),
 })
 
-export const infraKitOverrideConfigSchema = infraKitConfigSchema.partial()
+// Full schema = base object + a parse-time uniqueness check on the `ide` array.
+// This runs inside the *merged* `safeParse` in getInfraKitConfig, so it's the
+// gate for the final config. (The override layers use the `.partial()` form
+// below, which drops this object-level refinement — acceptable, the merged
+// parse is authoritative.)
+export const infraKitConfigSchema = infraKitConfigObject.superRefine((cfg, ctx) => {
+  if (!Array.isArray(cfg.ide)) return
+
+  const seen = new Set<string>()
+
+  for (const entry of cfg.ide) {
+    if (seen.has(entry.provider)) {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'each IDE provider may appear at most once',
+        path: ['ide'],
+      })
+
+      return
+    }
+
+    seen.add(entry.provider)
+  }
+})
+
+export const infraKitOverrideConfigSchema = infraKitConfigObject.partial()
 
 export type InfraKitConfig = z.infer<typeof infraKitConfigSchema>
 
+/** A single resolved IDE entry (`{ provider, config }`). */
+export type ConfiguredIde = z.infer<typeof ideSchema>
+
+/**
+ * Normalize the `ide` config (single object, array, or unset) into a flat list.
+ * Validation-free: assumes already-parsed input (uniqueness is enforced by the
+ * schema). The one source of truth for "which editors are configured."
+ *
+ * @example
+ * resolveConfiguredIdes({ ide: { provider: 'cursor', config: {...} } }) // => [cursor]
+ * resolveConfiguredIdes({ ide: [cursor, zed] })                         // => [cursor, zed]
+ * resolveConfiguredIdes({})                                             // => []
+ */
+export const resolveConfiguredIdes = (config: InfraKitConfig): ConfiguredIde[] => {
+  const ide = config.ide
+
+  if (!ide) return []
+
+  return Array.isArray(ide) ? ide : [ide]
+}
+
 export interface InfraKitConfigPaths {
   /** Committed project config (required). */
   main: string
@@ -131,9 +189,9 @@ export const getInfraKitConfigPaths = async (): Promise<InfraKitConfigPaths> =>
  *
  * @example
  * // infra-kit.json:           { "environments": ["dev"], "envManagement": { "provider": "doppler", "config": { "name": "p" } } }
- * // ~/.infra-kit/config.json: { "ide": { "provider": "cursor", "config": { "mode": "windows" } } }
+ * // ~/.infra-kit/config.json: { "ide": { "provider": "cursor", "config": { "workspaceConfigPath": "./ws.code-workspace" } } }
  * const cfg = await getInfraKitConfig()
- * // => { environments: ['dev'], envManagement: {...}, ide: { provider: 'cursor', config: { mode: 'windows' } } }
+ * // => { environments: ['dev'], envManagement: {...}, ide: { provider: 'cursor', config: { workspaceConfigPath: './ws.code-workspace' } } }
  */
 export const getInfraKitConfig = async (): Promise<InfraKitConfig> => {
   const paths = await getInfraKitConfigPaths()
@@ -281,9 +339,9 @@ interface ConfigLayer {
  * // => null
  *
  * @example
- * // /home/me/.infra-kit/config.json: '{ "ide": { "provider": "cursor", "config": { "mode": "windows" } } }'
+ * // /home/me/.infra-kit/config.json: '{ "ide": { "provider": "cursor", "config": { "workspaceConfigPath": "./ws.code-workspace" } } }'
  * await loadLayer({ label: '~/.infra-kit/config.json', path: '/home/me/.infra-kit/config.json', required: false })
- * // => { ide: { provider: 'cursor', config: { mode: 'windows' } } }
+ * // => { ide: { provider: 'cursor', config: { workspaceConfigPath: './ws.code-workspace' } } }
  */
 const loadLayer = async (layer: ConfigLayer): Promise<Record<string, unknown> | null> => {
   const raw = await readIfExists(layer.path)