bazilion 0.0.0 → 0.1.0

package/apps/daemon/test/core/migrations.test.ts

@@ -1,83 +0,0 @@
-import { afterAll, beforeAll, expect, test } from 'vitest'
-import { runMigrations } from '../../src/core/db/migrate.ts'
-import { makeTestEnv, type TestEnv } from './helpers.ts'
-
-let env: TestEnv
-beforeAll(() => {
-  env = makeTestEnv()
-})
-afterAll(() => env.cleanup())
-
-test('migrations create all expected tables', () => {
-  const tables = env.db.raw
-    .query<{ name: string }, []>(
-      "SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name",
-    )
-    .all()
-    .map((r) => r.name)
-
-  for (const t of [
-    'agent_skills',
-    'agents',
-    'groups',
-    'messages',
-    'profile_default_skills',
-    'profiles',
-    'schema_migrations',
-  ]) {
-    expect(tables).toContain(t)
-  }
-  // Junction tables dropped in 0005; runs + events dropped in 0003.
-  expect(tables).not.toContain('agent_workspaces')
-  expect(tables).not.toContain('profile_workspaces')
-  expect(tables).not.toContain('workspaces')
-  expect(tables).not.toContain('runs')
-  expect(tables).not.toContain('events')
-})
-
-test('profiles table has skills_mode and no default_workspace_id', () => {
-  const cols = env.db.raw
-    .query<{ name: string }, []>("SELECT name FROM pragma_table_info('profiles')")
-    .all()
-    .map((r) => r.name)
-  expect(cols).toContain('skills_mode')
-  expect(cols).not.toContain('default_workspace_id')
-})
-
-test('agents table has group_id; groups table has user_md', () => {
-  const agentCols = env.db.raw
-    .query<{ name: string }, []>("SELECT name FROM pragma_table_info('agents')")
-    .all()
-    .map((r) => r.name)
-  expect(agentCols).toContain('group_id')
-
-  const groupCols = env.db.raw
-    .query<{ name: string }, []>("SELECT name FROM pragma_table_info('groups')")
-    .all()
-    .map((r) => r.name)
-  expect(groupCols).toContain('user_md')
-})
-
-test('migrations are idempotent', () => {
-  const before = env.db.raw
-    .query<{ version: string }, []>('SELECT version FROM schema_migrations ORDER BY version')
-    .all()
-  runMigrations(env.db)
-  runMigrations(env.db)
-  const after = env.db.raw
-    .query<{ version: string }, []>('SELECT version FROM schema_migrations ORDER BY version')
-    .all()
-  expect(after).toEqual(before)
-  expect(after.length).toBeGreaterThan(0)
-  expect(after[0]?.version).toBe('0001_init')
-})
-
-test('foreign keys are enforced', () => {
-  expect(() =>
-    env.db.raw.run(
-      `INSERT INTO agents (id, profile_id, name, status, dir, group_id, created_at)
-       VALUES ('a1', 'nope', 'x', 'idle', '/tmp/x', 'test-group', ?)`,
-      [Date.now()],
-    ),
-  ).toThrow()
-})

package/apps/daemon/test/core/profiles.test.ts

@@ -1,182 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { createProfile } from '../../src/core/profile/create.ts'
-import { loadProfile } from '../../src/core/profile/load.ts'
-import { updateProfile } from '../../src/core/profile/update.ts'
-import * as profileRepo from '../../src/core/repos/profiles.ts'
-import { makeTestEnv, type TestEnv } from './helpers.ts'
-
-let env: TestEnv
-beforeEach(() => {
-  env = makeTestEnv()
-})
-afterEach(() => env.cleanup())
-
-test('createProfile scaffolds dir, files, and DB row', () => {
-  const profile = createProfile(env.db, env.paths, {
-    id: 'researcher',
-    name: 'Researcher',
-    defaultModel: 'anthropic:claude-opus-4-6',
-    defaultSkills: ['web-search', 'note-taking'],
-  })
-
-  expect(profile.id).toBe('researcher')
-  expect(profile.name).toBe('Researcher')
-  expect(profile.dir).toBe(env.paths.profileDir('researcher'))
-  expect(existsSync(join(profile.dir, 'SOUL.md'))).toBe(true)
-  expect(existsSync(join(profile.dir, 'IDENTITY.md'))).toBe(true)
-  expect(existsSync(join(profile.dir, 'BOOTSTRAP.md'))).toBe(true)
-  expect(existsSync(join(profile.dir, 'profile.json'))).toBe(true)
-
-  const fromDb = profileRepo.get(env.db, 'researcher')
-  expect(fromDb?.defaultModel).toBe('anthropic:claude-opus-4-6')
-  expect(fromDb?.skillsMode).toBe('selected')
-
-  const skills = profileRepo.getDefaultSkills(env.db, 'researcher')
-  expect(skills).toEqual(['note-taking', 'web-search'])
-})
-
-test('createProfile rejects invalid slug', () => {
-  expect(() =>
-    createProfile(env.db, env.paths, {
-      id: 'NotASlug!',
-      defaultModel: 'x',
-    }),
-  ).toThrow(/invalid slug/)
-})
-
-test('loadProfile returns profile, default skills, and file contents', () => {
-  createProfile(env.db, env.paths, {
-    id: 'p1',
-    defaultModel: 'm',
-    defaultSkills: ['a', 'b'],
-  })
-  const loaded = loadProfile(env.db, 'p1')
-  expect(loaded.profile.id).toBe('p1')
-  expect(loaded.defaultSkills).toEqual(['a', 'b'])
-  expect(loaded.files.soul).toContain('SOUL.md')
-  expect(loaded.files.identity).toContain('IDENTITY.md')
-  expect(loaded.files.bootstrap).toContain('BOOTSTRAP.md')
-  // Optional files default to absent — profiles opt in via templates.
-  expect(loaded.files.agents).toBeNull()
-  expect(loaded.files.tools).toBeNull()
-  expect(loaded.files.heartbeat).toBeNull()
-  expect(loaded.identity).toBeNull()
-})
-
-test('createProfile seeds AGENTS.md / TOOLS.md / HEARTBEAT.md when provided', () => {
-  const profile = createProfile(env.db, env.paths, {
-    id: 'felix',
-    defaultModel: 'm',
-    templates: {
-      identity: '# IDENTITY\n- Name: Felix\n- Emoji: 🐾\n',
-      agents: '# AGENTS\n- peer-a: does stuff\n',
-      tools: '# TOOLS\n- run_skill before shell\n',
-      heartbeat: '# HEARTBEAT\n- check inbox\n',
-    },
-  })
-  expect(existsSync(join(profile.dir, 'AGENTS.md'))).toBe(true)
-  expect(existsSync(join(profile.dir, 'TOOLS.md'))).toBe(true)
-  expect(existsSync(join(profile.dir, 'HEARTBEAT.md'))).toBe(true)
-  const loaded = loadProfile(env.db, 'felix')
-  expect(loaded.files.agents).toContain('peer-a')
-  expect(loaded.files.tools).toContain('run_skill')
-  expect(loaded.files.heartbeat).toContain('check inbox')
-  expect(loaded.identity).toEqual({ name: 'Felix', emoji: '🐾' })
-})
-
-test('createProfile skips AGENTS/TOOLS/HEARTBEAT when omitted', () => {
-  const profile = createProfile(env.db, env.paths, {
-    id: 'bare',
-    defaultModel: 'm',
-  })
-  expect(existsSync(join(profile.dir, 'AGENTS.md'))).toBe(false)
-  expect(existsSync(join(profile.dir, 'TOOLS.md'))).toBe(false)
-  expect(existsSync(join(profile.dir, 'HEARTBEAT.md'))).toBe(false)
-})
-
-test('loadProfile throws on missing profile', () => {
-  expect(() => loadProfile(env.db, 'ghost')).toThrow(/profile not found/)
-})
-
-test('createProfile writes custom soul/identity content when provided', () => {
-  const profile = createProfile(env.db, env.paths, {
-    id: 'custom',
-    defaultModel: 'm',
-    templates: {
-      soul: '# my soul\nbe bold',
-      identity: '# my identity\nname: bazyl',
-    },
-  })
-  const loaded = loadProfile(env.db, profile.id)
-  expect(loaded.files.soul).toBe('# my soul\nbe bold')
-  expect(loaded.files.identity).toBe('# my identity\nname: bazyl')
-  // Bootstrap unspecified → default kicks in.
-  expect(loaded.files.bootstrap).toContain('BOOTSTRAP.md')
-})
-
-test('createProfile with templates.bootstrap = null skips bootstrap file', () => {
-  const profile = createProfile(env.db, env.paths, {
-    id: 'no-bootstrap',
-    defaultModel: 'm',
-    templates: { bootstrap: null },
-  })
-  expect(existsSync(join(profile.dir, 'BOOTSTRAP.md'))).toBe(false)
-  const loaded = loadProfile(env.db, 'no-bootstrap')
-  expect(loaded.files.bootstrap).toBeNull()
-})
-
-test('updateProfile changes DB, profile.json, and skills in lockstep', () => {
-  createProfile(env.db, env.paths, {
-    id: 'p',
-    defaultModel: 'old:model',
-    defaultSkills: ['a'],
-  })
-  const updated = updateProfile(env.db, env.paths, 'p', {
-    name: 'Renamed',
-    defaultModel: 'new:model',
-    defaultSkills: ['b', 'c'],
-  })
-  expect(updated.name).toBe('Renamed')
-  expect(updated.defaultModel).toBe('new:model')
-
-  const fromDb = profileRepo.get(env.db, 'p')
-  expect(fromDb?.defaultModel).toBe('new:model')
-  expect(profileRepo.getDefaultSkills(env.db, 'p')).toEqual(['b', 'c'])
-
-  const json = JSON.parse(readFileSync(join(env.paths.profileDir('p'), 'profile.json'), 'utf8'))
-  expect(json.defaultModel).toBe('new:model')
-  expect(json.name).toBe('Renamed')
-  expect(json.defaultSkills).toEqual(['b', 'c'])
-})
-
-test('updateProfile skillsMode persists', () => {
-  createProfile(env.db, env.paths, {
-    id: 'r',
-    defaultModel: 'm',
-    defaultSkills: ['x'],
-  })
-  expect(profileRepo.get(env.db, 'r')?.skillsMode).toBe('selected')
-  updateProfile(env.db, env.paths, 'r', { skillsMode: 'all' })
-  expect(profileRepo.get(env.db, 'r')?.skillsMode).toBe('all')
-})
-
-test('updateProfile throws on missing profile', () => {
-  expect(() => updateProfile(env.db, env.paths, 'ghost', { name: 'x' })).toThrow(
-    /profile not found/,
-  )
-})
-
-test('listing profiles returns insertion order', () => {
-  createProfile(env.db, env.paths, {
-    id: 'a',
-    defaultModel: 'm',
-  })
-  createProfile(env.db, env.paths, {
-    id: 'b',
-    defaultModel: 'm',
-  })
-  const ids = profileRepo.list(env.db).map((p) => p.id)
-  expect(ids).toEqual(['a', 'b'])
-})

package/apps/daemon/test/core/provider-models.test.ts

@@ -1,57 +0,0 @@
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import {
-  type BazilionDb,
-  openInMemoryDb,
-  providerModelRepo,
-  runMigrations,
-} from '../../src/core/index.ts'
-
-let db: BazilionDb
-
-beforeEach(() => {
-  db = openInMemoryDb()
-  runMigrations(db)
-})
-afterEach(() => {
-  db.close()
-})
-
-test('replace seeds, round-trips, and overwrites', () => {
-  expect(providerModelRepo.list(db, 'openai')).toEqual([])
-
-  providerModelRepo.replace(db, 'openai', ['gpt-4o', 'gpt-4o-mini', 'o1'])
-  expect(providerModelRepo.list(db, 'openai')).toEqual(['gpt-4o', 'gpt-4o-mini', 'o1'])
-
-  providerModelRepo.replace(db, 'openai', ['gpt-5'])
-  expect(providerModelRepo.list(db, 'openai')).toEqual(['gpt-5'])
-
-  providerModelRepo.replace(db, 'openai', [])
-  expect(providerModelRepo.list(db, 'openai')).toEqual([])
-})
-
-test('replace trims whitespace and drops empties + duplicates', () => {
-  providerModelRepo.replace(db, 'anthropic', [
-    '  claude-opus-4-6  ',
-    '',
-    'claude-sonnet-4-6',
-    'claude-opus-4-6',
-  ])
-  expect(providerModelRepo.list(db, 'anthropic')).toEqual(['claude-opus-4-6', 'claude-sonnet-4-6'])
-})
-
-test('listAll groups by provider and omits empties', () => {
-  providerModelRepo.replace(db, 'openai', ['gpt-4o'])
-  providerModelRepo.replace(db, 'anthropic', ['claude-opus-4-6', 'claude-sonnet-4-6'])
-  expect(providerModelRepo.listAll(db)).toEqual({
-    anthropic: ['claude-opus-4-6', 'claude-sonnet-4-6'],
-    openai: ['gpt-4o'],
-  })
-})
-
-test('remove drops a single entry', () => {
-  providerModelRepo.replace(db, 'groq', ['llama-3.3-70b', 'mixtral-8x7b'])
-  providerModelRepo.remove(db, 'groq', 'mixtral-8x7b')
-  expect(providerModelRepo.list(db, 'groq')).toEqual(['llama-3.3-70b'])
-  providerModelRepo.remove(db, 'groq', 'not-present')
-  expect(providerModelRepo.list(db, 'groq')).toEqual(['llama-3.3-70b'])
-})

package/apps/daemon/test/core/provider-state.test.ts

@@ -1,36 +0,0 @@
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import {
-  type BazilionDb,
-  openInMemoryDb,
-  providerStateRepo,
-  runMigrations,
-} from '../../src/core/index.ts'
-
-let db: BazilionDb
-
-beforeEach(() => {
-  db = openInMemoryDb()
-  runMigrations(db)
-})
-afterEach(() => {
-  db.close()
-})
-
-test('absent rows default to disabled', () => {
-  expect(providerStateRepo.isEnabled(db, 'anthropic')).toBe(false)
-  expect(providerStateRepo.listEnabled(db).size).toBe(0)
-})
-
-test('setEnabled inserts on first call, updates on subsequent', () => {
-  providerStateRepo.setEnabled(db, 'anthropic', true)
-  expect(providerStateRepo.isEnabled(db, 'anthropic')).toBe(true)
-
-  providerStateRepo.setEnabled(db, 'anthropic', false)
-  expect(providerStateRepo.isEnabled(db, 'anthropic')).toBe(false)
-
-  providerStateRepo.setEnabled(db, 'anthropic', true)
-  providerStateRepo.setEnabled(db, 'openai', true)
-  providerStateRepo.setEnabled(db, 'groq', false)
-
-  expect(providerStateRepo.listEnabled(db)).toEqual(new Set(['anthropic', 'openai']))
-})

package/apps/daemon/test/core/skill-meta.test.ts

@@ -1,45 +0,0 @@
-import { beforeEach, describe, expect, test } from 'vitest'
-import {
-  type BazilionDb,
-  openInMemoryDb,
-  runMigrations,
-  skillMetaRepo,
-} from '../../src/core/index.ts'
-
-let db: BazilionDb
-beforeEach(() => {
-  db = openInMemoryDb()
-  runMigrations(db)
-})
-
-describe('skillMetaRepo', () => {
-  test('get returns null when no row exists', () => {
-    expect(skillMetaRepo.get(db, 'missing')).toBe(null)
-  })
-
-  test('upsert creates a row with defaults', () => {
-    const m = skillMetaRepo.upsert(db, { name: 'alpha' })
-    expect(m).toEqual({ name: 'alpha', source: null, importedAt: null })
-    expect(skillMetaRepo.get(db, 'alpha')).toEqual(m)
-  })
-
-  test('upsert updates source + importedAt without clobbering the name', () => {
-    skillMetaRepo.upsert(db, { name: 'alpha' })
-    const m = skillMetaRepo.upsert(db, { name: 'alpha', source: 'openclaw', importedAt: 123 })
-    expect(m).toEqual({ name: 'alpha', source: 'openclaw', importedAt: 123 })
-  })
-
-  test('listAll returns rows sorted by name', () => {
-    skillMetaRepo.upsert(db, { name: 'zebra' })
-    skillMetaRepo.upsert(db, { name: 'alpha' })
-    skillMetaRepo.upsert(db, { name: 'mid', source: 'path' })
-    const rows = skillMetaRepo.listAll(db)
-    expect(rows.map((r) => r.name)).toEqual(['alpha', 'mid', 'zebra'])
-  })
-
-  test('remove drops the row', () => {
-    skillMetaRepo.upsert(db, { name: 'tmp' })
-    skillMetaRepo.remove(db, 'tmp')
-    expect(skillMetaRepo.get(db, 'tmp')).toBe(null)
-  })
-})

package/apps/daemon/test/core/skills.test.ts

@@ -1,271 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import AdmZip from 'adm-zip'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { spawnAgent } from '../../src/core/agent/spawn.ts'
-import { createProfile } from '../../src/core/profile/create.ts'
-import * as agentRepo from '../../src/core/repos/agents.ts'
-import { discoverSkills } from '../../src/core/skills/discover.ts'
-import { importSkills } from '../../src/core/skills/import.ts'
-import { parseSkillContent, parseSkillFile } from '../../src/core/skills/parse.ts'
-import { resolveAgentSkills } from '../../src/core/skills/resolve.ts'
-import { makeTestEnv, type TestEnv } from './helpers.ts'
-
-function skillMd(name: string, body = 'body'): string {
-  return `---
-name: ${name}
-description: A test skill called ${name}.
-allowed-tools: Bash(${name}:*)
----
-
-${body}
-`
-}
-
-let env: TestEnv
-beforeEach(() => {
-  env = makeTestEnv()
-})
-afterEach(() => env.cleanup())
-
-function writeSkill(parent: string, name: string, body = 'skill body'): string {
-  const dir = join(parent, name)
-  mkdirSync(dir, { recursive: true })
-  writeFileSync(
-    join(dir, 'SKILL.md'),
-    `---
-name: ${name}
-description: A test skill called ${name}.
-allowed-tools: Bash(${name}:*)
----
-
-${body}
-`,
-  )
-  return dir
-}
-
-// --- parse ---
-
-test('parseSkillContent reads valid frontmatter and body', () => {
-  const raw = `---
-name: foo
-description: Does foo things.
-allowed-tools: Bash(foo:*)
----
-
-# Foo
-
-body here
-`
-  const p = parseSkillContent(raw)
-  expect(p.frontmatter.name).toBe('foo')
-  expect(p.frontmatter.description).toBe('Does foo things.')
-  expect(p.frontmatter['allowed-tools']).toBe('Bash(foo:*)')
-  expect(p.body).toContain('body here')
-})
-
-test('parseSkillContent rejects missing frontmatter', () => {
-  expect(() => parseSkillContent('# no frontmatter')).toThrow(/missing YAML frontmatter/)
-})
-
-test('parseSkillContent rejects missing required fields', () => {
-  expect(() =>
-    parseSkillContent(`---
-description: no name
----
-body
-`),
-  ).toThrow(/missing required "name"/)
-
-  expect(() =>
-    parseSkillContent(`---
-name: nodesc
----
-body
-`),
-  ).toThrow(/missing required "description"/)
-})
-
-test('parseSkillContent rejects invalid YAML', () => {
-  expect(() =>
-    parseSkillContent(`---
-name: x
-  bad: indent
----
-body
-`),
-  ).toThrow(/not valid YAML|missing required/)
-})
-
-// --- discover ---
-
-test('discoverSkills returns empty when skills dir is missing', () => {
-  // env creates the dir, so list it then unlink? Easier: use a fresh tmp
-  const all = discoverSkills(env.paths)
-  expect(all).toEqual([])
-})
-
-test('discoverSkills lists every dir containing SKILL.md, sorted', () => {
-  writeSkill(env.paths.skillsDir, 'b-skill')
-  writeSkill(env.paths.skillsDir, 'a-skill')
-  // Decoy: dir without SKILL.md
-  mkdirSync(join(env.paths.skillsDir, 'not-a-skill'), { recursive: true })
-  writeFileSync(join(env.paths.skillsDir, 'not-a-skill', 'README.md'), '')
-
-  const found = discoverSkills(env.paths)
-  expect(found.map((s) => s.name)).toEqual(['a-skill', 'b-skill'])
-})
-
-// --- import ---
-
-test('importSkills imports all skills from a parent dir', () => {
-  const source = join(env.home, 'src-skills')
-  mkdirSync(source, { recursive: true })
-  writeSkill(source, 'one')
-  writeSkill(source, 'two')
-
-  const result = importSkills(env.paths, { source })
-  expect(result.imported.sort()).toEqual(['one', 'two'])
-  expect(result.skipped).toEqual([])
-
-  expect(existsSync(join(env.paths.skillsDir, 'one', 'SKILL.md'))).toBe(true)
-  expect(existsSync(join(env.paths.skillsDir, 'two', 'SKILL.md'))).toBe(true)
-})
-
-test('importSkills accepts a single-skill dir as source', () => {
-  const source = join(env.home, 'standalone-skill')
-  writeSkill(env.home, 'standalone-skill')
-
-  const result = importSkills(env.paths, { source })
-  expect(result.imported).toEqual(['standalone-skill'])
-  const installed = parseSkillFile(join(env.paths.skillsDir, 'standalone-skill', 'SKILL.md'))
-  expect(installed.frontmatter.name).toBe('standalone-skill')
-})
-
-test('importSkills skips existing without --force, overwrites with --force', () => {
-  const source = join(env.home, 'src')
-  mkdirSync(source, { recursive: true })
-  writeSkill(source, 'shared', 'first version')
-
-  importSkills(env.paths, { source })
-  // Modify source body
-  writeSkill(source, 'shared', 'second version')
-
-  let result = importSkills(env.paths, { source })
-  expect(result.imported).toEqual([])
-  expect(result.skipped[0]?.name).toBe('shared')
-  let body = readFileSync(join(env.paths.skillsDir, 'shared', 'SKILL.md'), 'utf8')
-  expect(body).toContain('first version')
-
-  result = importSkills(env.paths, { source, force: true })
-  expect(result.imported).toEqual(['shared'])
-  body = readFileSync(join(env.paths.skillsDir, 'shared', 'SKILL.md'), 'utf8')
-  expect(body).toContain('second version')
-})
-
-test('importSkills refuses to import a broken skill', () => {
-  const source = join(env.home, 'broken-src')
-  mkdirSync(join(source, 'broken'), { recursive: true })
-  writeFileSync(join(source, 'broken', 'SKILL.md'), '---\nname: broken\n---\nno description\n')
-  expect(() => importSkills(env.paths, { source })).toThrow(/missing required "description"/)
-  expect(existsSync(join(env.paths.skillsDir, 'broken'))).toBe(false)
-})
-
-test('importSkills throws when nothing matches', () => {
-  const source = join(env.home, 'empty-src')
-  mkdirSync(source, { recursive: true })
-  expect(() => importSkills(env.paths, { source })).toThrow(/no skills found/)
-})
-
-// --- import from zip ---
-
-test('importSkills imports every skill from a flat .zip archive', () => {
-  const zip = new AdmZip()
-  zip.addFile('alpha/SKILL.md', Buffer.from(skillMd('alpha')))
-  zip.addFile('alpha/script.sh', Buffer.from('echo alpha\n'))
-  zip.addFile('beta/SKILL.md', Buffer.from(skillMd('beta')))
-  const zipPath = join(env.home, 'skills.zip')
-  zip.writeZip(zipPath)
-
-  const result = importSkills(env.paths, { source: zipPath })
-  expect(result.imported.sort()).toEqual(['alpha', 'beta'])
-  expect(existsSync(join(env.paths.skillsDir, 'alpha', 'SKILL.md'))).toBe(true)
-  expect(readFileSync(join(env.paths.skillsDir, 'alpha', 'script.sh'), 'utf8')).toContain(
-    'echo alpha',
-  )
-  expect(existsSync(join(env.paths.skillsDir, 'beta', 'SKILL.md'))).toBe(true)
-})
-
-test('importSkills unwraps a single top-level folder inside the zip', () => {
-  const zip = new AdmZip()
-  zip.addFile('wrapper/skill-a/SKILL.md', Buffer.from(skillMd('skill-a')))
-  zip.addFile('wrapper/skill-b/SKILL.md', Buffer.from(skillMd('skill-b')))
-  const zipPath = join(env.home, 'wrapped.zip')
-  zip.writeZip(zipPath)
-
-  const result = importSkills(env.paths, { source: zipPath })
-  expect(result.imported.sort()).toEqual(['skill-a', 'skill-b'])
-})
-
-test('importSkills rejects a zip with a zip-slip entry', () => {
-  // AdmZip's addFile sanitizes leading `../`, so to craft a genuinely hostile
-  // archive we add a placeholder and rewrite the entryName post-hoc — this
-  // survives the serialize/reparse round-trip.
-  const zip = new AdmZip()
-  zip.addFile('placeholder', Buffer.from(skillMd('escape')))
-  const entries = zip.getEntries()
-  const first = entries[0]
-  if (!first) throw new Error('zip had no entries')
-  first.entryName = '../escape/SKILL.md'
-  const zipPath = join(env.home, 'evil.zip')
-  zip.writeZip(zipPath)
-
-  expect(() => importSkills(env.paths, { source: zipPath })).toThrow(/escapes extraction root/)
-  expect(existsSync(join(env.paths.skillsDir, 'escape'))).toBe(false)
-})
-
-test('importSkills rejects a non-zip file', () => {
-  const bogus = join(env.home, 'not-a-zip.txt')
-  writeFileSync(bogus, 'hello')
-  expect(() => importSkills(env.paths, { source: bogus })).toThrow(/must be a .zip archive/)
-})
-
-test('importSkills rejects a zip with zero skills', () => {
-  const zip = new AdmZip()
-  zip.addFile('readme.md', Buffer.from('no skills here'))
-  const zipPath = join(env.home, 'empty.zip')
-  zip.writeZip(zipPath)
-
-  expect(() => importSkills(env.paths, { source: zipPath })).toThrow(/no skills found/)
-})
-
-// --- resolve ---
-
-test('resolveAgentSkills returns parsed skills attached to an agent', () => {
-  writeSkill(env.paths.skillsDir, 'web-search')
-  writeSkill(env.paths.skillsDir, 'note-taking')
-
-  createProfile(env.db, env.paths, {
-    id: 'p',
-    defaultModel: 'm',
-    defaultSkills: ['web-search', 'note-taking'],
-  })
-  const agent = spawnAgent(env.db, env.paths, { profileId: 'p', groupId: env.groupId })
-
-  const set = resolveAgentSkills(env.db, env.paths, agent.id)
-  expect(set.resolved.map((s) => s.name).sort()).toEqual(['note-taking', 'web-search'])
-  expect(set.missing).toEqual([])
-  expect(set.resolved[0]?.parsed.frontmatter.description).toContain('test skill')
-})
-
-test('resolveAgentSkills reports skills attached but not installed', () => {
-  createProfile(env.db, env.paths, { id: 'p', defaultModel: 'm' })
-  const agent = spawnAgent(env.db, env.paths, { profileId: 'p', groupId: env.groupId })
-  agentRepo.attachSkill(env.db, agent.id, 'ghost')
-
-  const set = resolveAgentSkills(env.db, env.paths, agent.id)
-  expect(set.resolved).toEqual([])
-  expect(set.missing).toHaveLength(1)
-  expect(set.missing[0]?.name).toBe('ghost')
-})