lyra-core 0.1.2 → 0.1.11

package/src/claude-plugins/discovery.test.ts

@@ -1,71 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { discoverClaudeExtras } from './discovery'
-
-let scratch: string
-
-beforeEach(async () => {
-  scratch = await mkdtemp(join(tmpdir(), 'lyra-claude-extras-'))
-})
-
-afterEach(async () => {
-  await rm(scratch, { recursive: true, force: true })
-})
-
-describe('discoverClaudeExtras', () => {
-  it('discovers commands + agents from plugin cache layout', async () => {
-    const versionDir = join(scratch, 'cache', 'mp', 'plug', '0.1.0')
-    await mkdir(join(versionDir, 'commands'), { recursive: true })
-    await mkdir(join(versionDir, 'agents'), { recursive: true })
-    await writeFile(
-      join(versionDir, 'commands', 'setup.md'),
-      '---\nname: setup\ndescription: Build pragma\n---\n\n# Setup body\n',
-    )
-    await writeFile(
-      join(versionDir, 'agents', 'thymos.md'),
-      '---\nname: thymos\ndescription: scalper\nmodel: sonnet\n---\n\n# Agent body\n',
-    )
-    const out = await discoverClaudeExtras({
-      claudePluginsCacheRoot: join(scratch, 'cache'),
-      importsClaudeCode: true,
-    })
-    expect(out.commands).toHaveLength(1)
-    expect(out.commands[0]!).toMatchObject({
-      id: 'plug:setup',
-      name: 'setup',
-      description: 'Build pragma',
-      source: { marketplace: 'mp', plugin: 'plug', version: '0.1.0' },
-    })
-    expect(out.commands[0]!.body).toContain('Setup body')
-    expect(out.agents).toHaveLength(1)
-    expect(out.agents[0]!).toMatchObject({
-      id: 'plug:thymos',
-      name: 'thymos',
-      model: 'sonnet',
-    })
-    expect(out.agents[0]!.body).toContain('Agent body')
-  })
-
-  it('returns empty when imports.claudeCode is false', async () => {
-    const out = await discoverClaudeExtras({
-      claudePluginsCacheRoot: join(scratch, 'cache'),
-      importsClaudeCode: false,
-    })
-    expect(out).toEqual({ commands: [], agents: [] })
-  })
-
-  it('skips files without frontmatter (still parses but with empty meta)', async () => {
-    const versionDir = join(scratch, 'cache', 'mp', 'plug', '0.1.0')
-    await mkdir(join(versionDir, 'commands'), { recursive: true })
-    await writeFile(join(versionDir, 'commands', 'foo.md'), 'no frontmatter just body')
-    const out = await discoverClaudeExtras({
-      claudePluginsCacheRoot: join(scratch, 'cache'),
-      importsClaudeCode: true,
-    })
-    expect(out.commands).toHaveLength(1)
-    expect(out.commands[0]!.name).toBe('foo')
-    expect(out.commands[0]!.body).toBe('no frontmatter just body')
-  })
-})

package/src/commands/registry.test.ts

@@ -1,186 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import {
-  COMMAND_REGISTRY,
-  commandsForSurface,
-  findCommand,
-  parseSlash,
-  suggestForPrefix,
-} from './registry'
-
-describe('COMMAND_REGISTRY', () => {
-  it('has no duplicate names', () => {
-    const names = COMMAND_REGISTRY.map(c => c.name)
-    const set = new Set(names)
-    expect(set.size).toBe(names.length)
-  })
-
-  it('every entry has at least one surface', () => {
-    for (const c of COMMAND_REGISTRY) {
-      expect(c.surfaces.length).toBeGreaterThan(0)
-    }
-  })
-
-  it('every entry has a non-empty description', () => {
-    for (const c of COMMAND_REGISTRY) {
-      expect(c.description.length).toBeGreaterThan(0)
-    }
-  })
-
-  it('all names are lowercase, no leading slash', () => {
-    for (const c of COMMAND_REGISTRY) {
-      expect(c.name).toBe(c.name.toLowerCase())
-      expect(c.name.startsWith('/')).toBe(false)
-    }
-  })
-
-  it('contains the cross-surface bypass commands required for v0.20.0', () => {
-    expect(findCommand('yolo')).toBeDefined()
-    expect(findCommand('perms')).toBeDefined()
-    expect(findCommand('reset')).toBeDefined()
-    expect(findCommand('yolo')?.surfaces).toEqual(['tui', 'tg'])
-    expect(findCommand('perms')?.surfaces).toEqual(['tui', 'tg'])
-    expect(findCommand('reset')?.surfaces).toEqual(['tui', 'tg'])
-  })
-})
-
-describe('commandsForSurface', () => {
-  it('returns only TUI commands when surface=tui', () => {
-    const tui = commandsForSurface('tui')
-    expect(tui.length).toBeGreaterThan(0)
-    for (const c of tui) expect(c.surfaces).toContain('tui')
-  })
-
-  it('returns only TG commands when surface=tg', () => {
-    const tg = commandsForSurface('tg')
-    expect(tg.length).toBeGreaterThan(0)
-    for (const c of tg) expect(c.surfaces).toContain('tg')
-  })
-
-  it('cross-surface commands appear in both lists', () => {
-    const tui = commandsForSurface('tui').map(c => c.name)
-    const tg = commandsForSurface('tg').map(c => c.name)
-    expect(tui).toContain('yolo')
-    expect(tg).toContain('yolo')
-    expect(tui).toContain('perms')
-    expect(tg).toContain('perms')
-    expect(tui).toContain('reset')
-    expect(tg).toContain('reset')
-  })
-
-  it('TUI-only commands do not appear in TG', () => {
-    const tg = commandsForSurface('tg').map(c => c.name)
-    expect(tg).not.toContain('sync')
-    expect(tg).not.toContain('model')
-    expect(tg).not.toContain('jobs')
-    expect(tg).not.toContain('help')
-  })
-
-  it('TG-only commands do not appear in TUI', () => {
-    const tui = commandsForSurface('tui').map(c => c.name)
-    expect(tui).not.toContain('stop')
-    expect(tui).not.toContain('new')
-    expect(tui).not.toContain('status')
-    expect(tui).not.toContain('approve')
-  })
-})
-
-describe('findCommand', () => {
-  it('resolves bare names', () => {
-    expect(findCommand('yolo')?.name).toBe('yolo')
-  })
-
-  it('strips leading slashes', () => {
-    expect(findCommand('/yolo')?.name).toBe('yolo')
-    expect(findCommand('//yolo')?.name).toBe('yolo')
-  })
-
-  it('is case-insensitive', () => {
-    expect(findCommand('YOLO')?.name).toBe('yolo')
-    expect(findCommand('Yolo')?.name).toBe('yolo')
-  })
-
-  it('returns undefined for unknown names', () => {
-    expect(findCommand('definitely-not-a-command')).toBeUndefined()
-  })
-})
-
-describe('parseSlash', () => {
-  it('returns null for non-slash input', () => {
-    expect(parseSlash('hello')).toBeNull()
-    expect(parseSlash('  hi /yolo')).toBeNull()
-  })
-
-  it('returns null for empty slash', () => {
-    expect(parseSlash('/')).toBeNull()
-    expect(parseSlash('   /   ')).toBeNull()
-  })
-
-  it('parses bare command name', () => {
-    const r = parseSlash('/yolo')
-    expect(r?.name).toBe('yolo')
-    expect(r?.args).toEqual([])
-    expect(r?.command?.name).toBe('yolo')
-  })
-
-  it('parses command with args', () => {
-    const r = parseSlash('/perms strict')
-    expect(r?.name).toBe('perms')
-    expect(r?.args).toEqual(['strict'])
-    expect(r?.command?.name).toBe('perms')
-  })
-
-  it('lowercases the command name', () => {
-    const r = parseSlash('/YOLO')
-    expect(r?.name).toBe('yolo')
-  })
-
-  it('preserves arg case', () => {
-    const r = parseSlash('/perms STRICT')
-    expect(r?.args).toEqual(['STRICT'])
-  })
-
-  it('returns parsed shape with undefined command for unknown names', () => {
-    const r = parseSlash('/wat is this')
-    expect(r?.name).toBe('wat')
-    expect(r?.args).toEqual(['is', 'this'])
-    expect(r?.command).toBeUndefined()
-  })
-
-  it('tolerates leading whitespace', () => {
-    const r = parseSlash('   /yolo on')
-    expect(r?.name).toBe('yolo')
-    expect(r?.args).toEqual(['on'])
-  })
-})
-
-describe('suggestForPrefix', () => {
-  it('returns all surface commands for empty query', () => {
-    const all = commandsForSurface('tui')
-    expect(suggestForPrefix('tui', '')).toEqual(all)
-    expect(suggestForPrefix('tui', '/')).toEqual(all)
-  })
-
-  it('filters by prefix', () => {
-    const out = suggestForPrefix('tui', 'y')
-    const names = out.map(c => c.name)
-    expect(names).toContain('yolo')
-    expect(names).not.toContain('perms')
-  })
-
-  it('strips leading slash from query', () => {
-    expect(suggestForPrefix('tui', '/y').map(c => c.name)).toContain('yolo')
-  })
-
-  it('is case-insensitive on query', () => {
-    expect(suggestForPrefix('tui', 'YO').map(c => c.name)).toContain('yolo')
-  })
-
-  it('returns empty when nothing matches', () => {
-    expect(suggestForPrefix('tui', 'xyz-no-match')).toEqual([])
-  })
-
-  it('respects surface filter', () => {
-    const tg = suggestForPrefix('tg', 'sy').map(c => c.name)
-    expect(tg).not.toContain('sync')
-  })
-})

package/src/events/queue.test.ts

@@ -1,43 +0,0 @@
-import { expect, test } from 'bun:test'
-import { EventQueue, newEventId } from './queue'
-
-test('FIFO ordering', async () => {
-  const q = new EventQueue()
-  for (let i = 0; i < 3; i++) {
-    q.enqueue({
-      id: newEventId(),
-      source: 'stdin',
-      payload: { label: `e${i}`, data: i },
-      ts: Date.now(),
-    })
-  }
-  const a = await q.dequeue()
-  const b = await q.dequeue()
-  const c = await q.dequeue()
-  expect(a.payload.label).toBe('e0')
-  expect(b.payload.label).toBe('e1')
-  expect(c.payload.label).toBe('e2')
-})
-
-test('dequeue awaits when empty', async () => {
-  const q = new EventQueue()
-  const pending = q.dequeue()
-  setTimeout(() => {
-    q.enqueue({
-      id: 'late',
-      source: 'stdin',
-      payload: { label: 'late', data: null },
-      ts: Date.now(),
-    })
-  }, 10)
-  const ev = await pending
-  expect(ev.payload.label).toBe('late')
-})
-
-test('closed queue throws on enqueue', () => {
-  const q = new EventQueue()
-  q.close()
-  expect(() =>
-    q.enqueue({ id: 'x', source: 'stdin', payload: { label: 'x', data: null }, ts: 0 }),
-  ).toThrow()
-})

package/src/index.test.ts

@@ -1,6 +0,0 @@
-import { expect, test } from 'bun:test'
-import { VERSION } from './index'
-
-test('core package loads and exposes VERSION', () => {
-  expect(VERSION).toBe('0.0.0')
-})

package/src/locks.test.ts

@@ -1,259 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import {
-  DEFAULT_LOCK_TTL_SECONDS,
-  acquireScopedLock,
-  clearStaleScopedLock,
-  isZombieLinux,
-} from './locks'
-
-let testDir: string
-
-beforeEach(() => {
-  testDir = mkdtempSync(join(tmpdir(), 'lyra-locks-test-'))
-})
-
-afterEach(() => {
-  rmSync(testDir, { recursive: true, force: true })
-})
-
-describe('acquireScopedLock', () => {
-  it('acquires when no prior holder exists', () => {
-    const r = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    expect(r.acquired).toBe(true)
-    expect(r.handle).toBeDefined()
-    r.handle?.releaseFn()
-  })
-
-  it('rejects when another live process holds it', () => {
-    const r1 = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    expect(r1.acquired).toBe(true)
-
-    const r2 = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    expect(r2.acquired).toBe(false)
-    expect(r2.existing?.pid).toBe(process.pid)
-
-    r1.handle?.releaseFn()
-  })
-
-  it('different identities do not collide on same scope', () => {
-    const a = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    const b = acquireScopedLock({ scope: 'test', identity: 'token-b', rootDir: testDir })
-    expect(a.acquired).toBe(true)
-    expect(b.acquired).toBe(true)
-    a.handle?.releaseFn()
-    b.handle?.releaseFn()
-  })
-
-  it('release allows re-acquire', () => {
-    const r1 = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    expect(r1.acquired).toBe(true)
-    r1.handle?.releaseFn()
-
-    const r2 = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    expect(r2.acquired).toBe(true)
-    r2.handle?.releaseFn()
-  })
-
-  it('release is idempotent', () => {
-    const r1 = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    r1.handle?.releaseFn()
-    r1.handle?.releaseFn()
-    const r2 = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    expect(r2.acquired).toBe(true)
-    r2.handle?.releaseFn()
-  })
-
-  it('reclaims a stale lock from a dead PID', () => {
-    // Manually plant a lock file with a fake PID that won't exist
-    const fakePid = 999999
-    const lockFile = findLockFile(testDir, 'test', 'token-a')
-    writeFileSync(
-      lockFile,
-      JSON.stringify({
-        pid: fakePid,
-        scope: 'test',
-        identityHash: 'fake',
-        startedAt: 0,
-        updatedAt: 0,
-        ttl: DEFAULT_LOCK_TTL_SECONDS,
-      }),
-    )
-
-    const r = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    expect(r.acquired).toBe(true)
-    r.handle?.releaseFn()
-  })
-
-  it('reclaims a TTL-expired lock from a live process', () => {
-    // Plant a lock file with a real PID but ancient updatedAt
-    const lockFile = findLockFile(testDir, 'test', 'token-a')
-    const veryOld = Math.floor(Date.now() / 1000) - 99999
-    writeFileSync(
-      lockFile,
-      JSON.stringify({
-        pid: process.pid,
-        scope: 'test',
-        identityHash: 'fake',
-        startedAt: veryOld,
-        updatedAt: veryOld,
-        ttl: 60,
-      }),
-    )
-
-    const r = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    expect(r.acquired).toBe(true)
-    r.handle?.releaseFn()
-  })
-
-  it('refreshFn returns true while owner holds the lock', () => {
-    const r = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    expect(r.handle?.refreshFn()).toBe(true)
-    r.handle?.releaseFn()
-  })
-
-  it('refreshFn returns false after release', () => {
-    const r = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    r.handle?.releaseFn()
-    expect(r.handle?.refreshFn()).toBe(false)
-  })
-
-  it('hashes the identity into the lock filename', () => {
-    const a = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    const b = acquireScopedLock({ scope: 'test', identity: 'token-different', rootDir: testDir })
-    expect(a.acquired).toBe(true)
-    expect(b.acquired).toBe(true)
-    a.handle?.releaseFn()
-    b.handle?.releaseFn()
-  })
-
-  it('records stable shape: pid + startedAt + updatedAt + ttl', () => {
-    const r = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir, ttl: 600 })
-    expect(r.acquired).toBe(true)
-    r.handle?.releaseFn()
-  })
-
-  it('respects custom rootDir', () => {
-    const r = acquireScopedLock({ scope: 'test', identity: 'token-a', rootDir: testDir })
-    expect(r.acquired).toBe(true)
-    r.handle?.releaseFn()
-  })
-})
-
-describe('isZombieLinux', () => {
-  it('returns false on non-linux platforms', () => {
-    if (process.platform === 'linux') return // platform-specific guard
-    expect(isZombieLinux(process.pid)).toBe(false)
-  })
-
-  it('returns false for the live current process on linux', () => {
-    if (process.platform !== 'linux') return
-    expect(isZombieLinux(process.pid)).toBe(false)
-  })
-
-  it('returns false when /proc/<pid>/status is unreadable', () => {
-    // pid 999999 vanishingly unlikely to exist; readFile will throw.
-    expect(isZombieLinux(999_999)).toBe(false)
-  })
-})
-
-describe('acquireScopedLock evicts dead-pid lock', () => {
-  it('reclaims when the lockfile records a pid that no longer exists', () => {
-    // Take the lock, write a tampered record claiming a vanishingly-unlikely
-    // pid is the holder, then re-acquire. The stale-detection path
-    // (process.kill(pid, 0) → ESRCH) should treat it as gone and reclaim.
-    const path = findLockFile(testDir, 'test', 'dead-pid')
-    writeFileSync(
-      path,
-      JSON.stringify({
-        pid: 999_998, // unlikely to exist on the test host
-        scope: 'test',
-        identityHash: 'whatever',
-        startedAt: Math.floor(Date.now() / 1000),
-        updatedAt: Math.floor(Date.now() / 1000),
-        ttl: 300,
-      }),
-    )
-    const r = acquireScopedLock({ scope: 'test', identity: 'dead-pid', rootDir: testDir })
-    expect(r.acquired).toBe(true)
-    r.handle?.releaseFn()
-  })
-})
-
-describe('clearStaleScopedLock', () => {
-  it('returns no-lock when nothing exists', () => {
-    const r = clearStaleScopedLock({ scope: 'test', identity: 'fresh', rootDir: testDir })
-    expect(r.cleared).toBe(false)
-    expect(r.reason).toBe('no-lock')
-  })
-
-  it('returns alive-pid when a live PID holds the lock', () => {
-    const a = acquireScopedLock({ scope: 'test', identity: 'live', rootDir: testDir })
-    expect(a.acquired).toBe(true)
-    const r = clearStaleScopedLock({ scope: 'test', identity: 'live', rootDir: testDir })
-    expect(r.cleared).toBe(false)
-    expect(r.reason).toBe('alive-pid')
-    a.handle?.releaseFn()
-  })
-
-  it('clears a dead-PID lock and reports cleared-stale', () => {
-    const path = findLockFile(testDir, 'test', 'dead')
-    writeFileSync(
-      path,
-      JSON.stringify({
-        pid: 999_997,
-        scope: 'test',
-        identityHash: 'x',
-        startedAt: Math.floor(Date.now() / 1000),
-        updatedAt: Math.floor(Date.now() / 1000),
-        ttl: 600,
-      }),
-    )
-    const r = clearStaleScopedLock({ scope: 'test', identity: 'dead', rootDir: testDir })
-    expect(r.cleared).toBe(true)
-    expect(r.reason).toBe('cleared-stale')
-    // Re-clear should now return no-lock.
-    const r2 = clearStaleScopedLock({ scope: 'test', identity: 'dead', rootDir: testDir })
-    expect(r2.cleared).toBe(false)
-    expect(r2.reason).toBe('no-lock')
-  })
-
-  it('clears a TTL-expired lock and reports cleared-ttl', () => {
-    const path = findLockFile(testDir, 'test', 'expired')
-    const ancient = Math.floor(Date.now() / 1000) - 9999
-    writeFileSync(
-      path,
-      JSON.stringify({
-        pid: process.pid,
-        scope: 'test',
-        identityHash: 'x',
-        startedAt: ancient,
-        updatedAt: ancient,
-        ttl: 60,
-      }),
-    )
-    const r = clearStaleScopedLock({ scope: 'test', identity: 'expired', rootDir: testDir })
-    expect(r.cleared).toBe(true)
-    expect(r.reason).toBe('cleared-ttl')
-  })
-
-  it('does not delete a lock owned by current process within TTL', () => {
-    const a = acquireScopedLock({ scope: 'test', identity: 'mine', rootDir: testDir })
-    expect(a.acquired).toBe(true)
-    const r = clearStaleScopedLock({ scope: 'test', identity: 'mine', rootDir: testDir })
-    expect(r.cleared).toBe(false)
-    expect(r.reason).toBe('alive-pid')
-    // Lock still acquireable by us via refresh:
-    expect(a.handle?.refreshFn()).toBe(true)
-    a.handle?.releaseFn()
-  })
-})
-
-function findLockFile(dir: string, scope: string, identity: string): string {
-  // Mirror the internal hash logic (sha256 first 16 hex chars)
-  const { createHash } = require('node:crypto') as typeof import('node:crypto')
-  const hash = createHash('sha256').update(identity).digest('hex').slice(0, 16)
-  return join(dir, `${scope}-${hash}.lock`)
-}

package/src/mcp/discovery.test.ts

@@ -1,97 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { discoverMcpServers } from './discovery'
-
-let scratch: string
-
-beforeEach(async () => {
-  scratch = await mkdtemp(join(tmpdir(), 'lyra-mcp-'))
-})
-
-afterEach(async () => {
-  await rm(scratch, { recursive: true, force: true })
-})
-
-describe('discoverMcpServers', () => {
-  it('reads ~/.lyra/.mcp.json + ~/.claude/.mcp.json', async () => {
-    const lyraPath = join(scratch, 'lyra.mcp.json')
-    const claudePath = join(scratch, 'claude.mcp.json')
-    await writeFile(
-      lyraPath,
-      JSON.stringify({
-        mcpServers: {
-          alpha: { command: 'bun', args: ['run', 'a.ts'] },
-        },
-      }),
-    )
-    await writeFile(
-      claudePath,
-      JSON.stringify({
-        mcpServers: {
-          beta: { type: 'http', url: 'https://example.com/mcp', headers: { 'X-Foo': '1' } },
-        },
-      }),
-    )
-    const out = await discoverMcpServers({
-      lyraMcpPath: lyraPath,
-      claudeMcpPath: claudePath,
-      claudePluginsCacheRoot: join(scratch, 'doesnotexist'),
-      importsClaudeCode: true,
-    })
-    expect(out.servers).toHaveLength(2)
-    const alpha = out.servers.find(s => s.name === 'alpha')
-    expect(alpha?.type).toBe('stdio')
-    if (alpha?.type === 'stdio') {
-      expect(alpha.command).toBe('bun')
-      expect(alpha.args).toEqual(['run', 'a.ts'])
-    }
-    const beta = out.servers.find(s => s.name === 'beta')
-    expect(beta?.type).toBe('http')
-    if (beta?.type === 'http') expect(beta.url).toBe('https://example.com/mcp')
-  })
-
-  it('substitutes ${CLAUDE_PLUGIN_ROOT} from plugin cache layout', async () => {
-    const cacheRoot = join(scratch, 'cache')
-    const versionDir = join(cacheRoot, 'mp', 'plug', '1.0.0')
-    await mkdir(versionDir, { recursive: true })
-    await writeFile(
-      join(versionDir, '.mcp.json'),
-      JSON.stringify({
-        mcpServers: {
-          plug: {
-            command: 'bun',
-            args: ['run', '--cwd', '${CLAUDE_PLUGIN_ROOT}', 'start'],
-            env: { PLUG_ROOT: '${CLAUDE_PLUGIN_ROOT}/data' },
-          },
-        },
-      }),
-    )
-    const out = await discoverMcpServers({
-      lyraMcpPath: join(scratch, 'doesnotexist'),
-      claudeMcpPath: join(scratch, 'doesnotexist'),
-      claudePluginsCacheRoot: cacheRoot,
-      importsClaudeCode: true,
-    })
-    expect(out.servers).toHaveLength(1)
-    const s = out.servers[0]!
-    expect(s.type).toBe('stdio')
-    if (s.type === 'stdio') {
-      expect(s.args).toEqual(['run', '--cwd', versionDir, 'start'])
-      expect(s.env?.PLUG_ROOT).toBe(`${versionDir}/data`)
-    }
-  })
-
-  it('honors importsClaudeCode=false (only lyra path scanned)', async () => {
-    const claudePath = join(scratch, 'claude.mcp.json')
-    await writeFile(claudePath, JSON.stringify({ mcpServers: { foo: { command: 'bun' } } }))
-    const out = await discoverMcpServers({
-      lyraMcpPath: join(scratch, 'doesnotexist'),
-      claudeMcpPath: claudePath,
-      claudePluginsCacheRoot: join(scratch, 'doesnotexist'),
-      importsClaudeCode: false,
-    })
-    expect(out.servers).toEqual([])
-  })
-})