bazilion 0.0.0 → 0.1.0

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

@@ -1,319 +0,0 @@
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { archiveAgent } from '../../src/core/agent/archive.ts'
-import { deleteAgent } from '../../src/core/agent/delete.ts'
-import { resolveAgent } from '../../src/core/agent/resolve.ts'
-import { spawnAgent } from '../../src/core/agent/spawn.ts'
-import { unarchiveAgent } from '../../src/core/agent/unarchive.ts'
-import { registerGroup } from '../../src/core/group/register.ts'
-import { createProfile } from '../../src/core/profile/create.ts'
-import * as agentRepo from '../../src/core/repos/agents.ts'
-import * as messageRepo from '../../src/core/repos/messages.ts'
-import { makeTestEnv, type TestEnv } from './helpers.ts'
-
-let env: TestEnv
-beforeEach(() => {
-  env = makeTestEnv()
-})
-afterEach(() => env.cleanup())
-
-function seedProfile() {
-  return createProfile(env.db, env.paths, {
-    id: 'base',
-    defaultModel: 'anthropic:claude-opus-4-6',
-    defaultSkills: ['skill-a'],
-  })
-}
-
-function spawn(input: Partial<Parameters<typeof spawnAgent>[2]> & { profileId?: string } = {}) {
-  return spawnAgent(env.db, env.paths, {
-    profileId: input.profileId ?? 'base',
-    groupId: input.groupId ?? env.groupId,
-    ...input,
-  })
-}
-
-test('spawnAgent creates dir, copies templates, inserts row, attaches default skills', () => {
-  seedProfile()
-  const agent = spawn({ name: 'A1' })
-
-  expect(agent.profileId).toBe('base')
-  expect(agent.status).toBe('idle')
-  expect(agent.groupId).toBe(env.groupId)
-  expect(existsSync(agent.dir)).toBe(true)
-  expect(existsSync(join(agent.dir, 'SOUL.md'))).toBe(true)
-  expect(existsSync(join(agent.dir, 'IDENTITY.md'))).toBe(true)
-  expect(existsSync(join(agent.dir, 'BOOTSTRAP.md'))).toBe(true)
-  expect(existsSync(join(agent.dir, 'agent.json'))).toBe(true)
-  // Memory now lives at the group level (`groups/<slug>/memory/`), shared
-  // by all member agents. The agent's private home only carries identity
-  // files + sessions/.
-  expect(existsSync(join(agent.dir, 'sessions'))).toBe(true)
-  expect(existsSync(join(agent.dir, 'memory'))).toBe(false)
-
-  expect(agentRepo.listAttachedSkills(env.db, agent.id)).toEqual(['skill-a'])
-})
-
-test('spawnAgent copies optional AGENTS/TOOLS/HEARTBEAT files when the profile seeded them', () => {
-  createProfile(env.db, env.paths, {
-    id: 'felix',
-    defaultModel: 'm',
-    templates: {
-      agents: '# AGENTS\n- peer: hello\n',
-      tools: '# TOOLS\n- ripgrep before grep\n',
-      heartbeat: '# HEARTBEAT\n- check calendar\n',
-    },
-  })
-  const agent = spawn({ profileId: 'felix' })
-  expect(existsSync(join(agent.dir, 'AGENTS.md'))).toBe(true)
-  expect(existsSync(join(agent.dir, 'TOOLS.md'))).toBe(true)
-  expect(existsSync(join(agent.dir, 'HEARTBEAT.md'))).toBe(true)
-})
-
-test('spawnAgent does not create optional AGENTS/TOOLS/HEARTBEAT files when the profile lacks them', () => {
-  seedProfile()
-  const agent = spawn()
-  expect(existsSync(join(agent.dir, 'AGENTS.md'))).toBe(false)
-  expect(existsSync(join(agent.dir, 'TOOLS.md'))).toBe(false)
-  expect(existsSync(join(agent.dir, 'HEARTBEAT.md'))).toBe(false)
-})
-
-test('spawning many agents from one profile produces independent instances', () => {
-  seedProfile()
-  const a = spawn()
-  const b = spawn()
-  expect(a.id).not.toBe(b.id)
-  expect(a.dir).not.toBe(b.dir)
-  expect(agentRepo.list(env.db).length).toBe(2)
-})
-
-test('spawnAgent places the agent in the requested group', () => {
-  seedProfile()
-  const g = registerGroup(env.db, { id: 'extra' }, env.paths)
-
-  const agent = spawn({ groupId: g.id })
-  expect(agent.groupId).toBe('extra')
-})
-
-test('spawnAgent rejects an unknown group', () => {
-  seedProfile()
-  expect(() => spawn({ groupId: 'no-such-group' })).toThrow(/group "no-such-group" does not exist/)
-})
-
-test('agentRepo.setGroup moves an agent to a different group', () => {
-  seedProfile()
-  const g2 = registerGroup(env.db, { id: 'g2' }, env.paths)
-  const agent = spawn()
-  expect(agent.groupId).toBe(env.groupId)
-
-  agentRepo.setGroup(env.db, agent.id, g2.id)
-  expect(agentRepo.get(env.db, agent.id)?.groupId).toBe('g2')
-})
-
-test('attaching and detaching skills on the fly', () => {
-  seedProfile()
-  const agent = spawn()
-
-  agentRepo.attachSkill(env.db, agent.id, 'extra')
-  expect(agentRepo.listAttachedSkills(env.db, agent.id).sort()).toEqual(['extra', 'skill-a'])
-
-  agentRepo.detachSkill(env.db, agent.id, 'skill-a')
-  expect(agentRepo.listAttachedSkills(env.db, agent.id)).toEqual(['extra'])
-})
-
-test('archiveAgent sets status and timestamp', () => {
-  seedProfile()
-  const agent = spawn()
-  archiveAgent(env.db, agent.id)
-  const after = agentRepo.get(env.db, agent.id)
-  expect(after?.status).toBe('archived')
-  expect(after?.archivedAt).not.toBeNull()
-})
-
-test('list excludes archived by default', () => {
-  seedProfile()
-  const a = spawn()
-  spawn()
-  archiveAgent(env.db, a.id)
-
-  expect(agentRepo.list(env.db).length).toBe(1)
-  expect(agentRepo.list(env.db, { includeArchived: true }).length).toBe(2)
-})
-
-test('unarchiveAgent flips status back to idle and clears archivedAt', () => {
-  seedProfile()
-  const agent = spawn()
-  archiveAgent(env.db, agent.id)
-  expect(agentRepo.get(env.db, agent.id)?.status).toBe('archived')
-
-  unarchiveAgent(env.db, agent.id)
-  const after = agentRepo.get(env.db, agent.id)
-  expect(after?.status).toBe('idle')
-  expect(after?.archivedAt).toBeNull()
-})
-
-test('unarchiveAgent throws on a non-archived agent', () => {
-  seedProfile()
-  const agent = spawn()
-  expect(() => unarchiveAgent(env.db, agent.id)).toThrow(/not archived/)
-})
-
-test('unarchiveAgent throws on an unknown id', () => {
-  seedProfile()
-  expect(() => unarchiveAgent(env.db, 'ghost-id')).toThrow()
-})
-
-test('deleteAgent removes the DB row and the on-disk directory', () => {
-  seedProfile()
-  const agent = spawn()
-  expect(existsSync(agent.dir)).toBe(true)
-
-  deleteAgent(env.db, agent.id)
-  expect(agentRepo.get(env.db, agent.id)).toBeNull()
-  expect(existsSync(agent.dir)).toBe(false)
-})
-
-test('deleteAgent cascades to attachments, messages, runs', () => {
-  seedProfile()
-  const a = spawn()
-  const b = spawn()
-  agentRepo.attachSkill(env.db, a.id, 'extra')
-
-  // Side table: a message tied to the agent
-  messageRepo.send(env.db, {
-    from: b.id,
-    to: a.id,
-    payload: JSON.stringify({ text: 'hi' }),
-  })
-
-  // Sanity: the rows exist before delete
-  expect(agentRepo.listAttachedSkills(env.db, a.id).length).toBeGreaterThan(0)
-  expect(messageRepo.listInbox(env.db, a.id).length).toBe(1)
-
-  deleteAgent(env.db, a.id)
-
-  expect(agentRepo.get(env.db, a.id)).toBeNull()
-  expect(agentRepo.listAttachedSkills(env.db, a.id)).toEqual([])
-  expect(messageRepo.listInbox(env.db, a.id)).toEqual([])
-
-  // Agent b is untouched
-  expect(agentRepo.get(env.db, b.id)).not.toBeNull()
-})
-
-test('deleteAgent throws on an unknown id', () => {
-  seedProfile()
-  expect(() => deleteAgent(env.db, 'ghost-id')).toThrow()
-})
-
-test('agentRepo.get resolves an unambiguous UUID prefix (≥4 chars)', () => {
-  seedProfile()
-  const agent = spawn()
-  // Full UUID still works
-  expect(agentRepo.get(env.db, agent.id)?.id).toBe(agent.id)
-  // First 8 chars (git-style) resolves
-  const prefix = agent.id.slice(0, 8)
-  expect(agentRepo.get(env.db, prefix)?.id).toBe(agent.id)
-  // <4 chars never resolves
-  expect(agentRepo.get(env.db, agent.id.slice(0, 3))).toBeNull()
-  // Non-existing prefix still null
-  expect(agentRepo.get(env.db, 'zzzzzzzz')).toBeNull()
-})
-
-test('agentRepo.get resolves by exact name when unique', () => {
-  seedProfile()
-  const a = spawn({ name: 'alpha' })
-  const b = spawn({ name: 'beta' })
-
-  expect(agentRepo.get(env.db, 'alpha')?.id).toBe(a.id)
-  expect(agentRepo.get(env.db, 'beta')?.id).toBe(b.id)
-  expect(agentRepo.get(env.db, 'nobody')).toBeNull()
-})
-
-test('agentRepo.get returns null for an ambiguous name', () => {
-  seedProfile()
-  spawn({ name: 'twin' })
-  spawn({ name: 'twin' })
-  expect(agentRepo.get(env.db, 'twin')).toBeNull()
-})
-
-test('agentRepo.get prefers exact name over prefix collision', () => {
-  seedProfile()
-  // An agent whose name is a hex string that is ALSO a valid UUID prefix of
-  // some other agent's id. The name-match should win so users can rename
-  // agents to anything and have lookup behave predictably.
-  const id = 'deadbeef-0000-0000-0000-000000000000'
-  agentRepo.insert(env.db, {
-    id,
-    profileId: 'base',
-    name: 'A-with-hex-prefix-name',
-    modelOverride: null,
-    reasoningLevel: 'medium',
-    status: 'idle',
-    dir: '/tmp/none-hex',
-    groupId: env.groupId,
-  })
-  const b = spawn({ name: 'deadbeef' })
-
-  // Lookup "deadbeef": exact name on agent b wins, even though it matches a
-  // (the id starts with deadbeef).
-  expect(agentRepo.get(env.db, 'deadbeef')?.id).toBe(b.id)
-  // But the full id for a still resolves
-  expect(agentRepo.get(env.db, id)?.id).toBe(id)
-})
-
-test('agentRepo.get returns null for ambiguous prefix', () => {
-  seedProfile()
-  // Insert two agents manually with IDs that share a 4-char prefix; spawnAgent
-  // uses random UUIDs so we bypass it.
-  agentRepo.insert(env.db, {
-    id: 'abcd1111-aaaa-bbbb-cccc-dddddddddddd',
-    profileId: 'base',
-    name: 'A',
-    modelOverride: null,
-    reasoningLevel: 'medium',
-    status: 'idle',
-    dir: '/tmp/none-a',
-    groupId: env.groupId,
-  })
-  agentRepo.insert(env.db, {
-    id: 'abcd2222-aaaa-bbbb-cccc-dddddddddddd',
-    profileId: 'base',
-    name: 'B',
-    modelOverride: null,
-    reasoningLevel: 'medium',
-    status: 'idle',
-    dir: '/tmp/none-b',
-    groupId: env.groupId,
-  })
-  expect(agentRepo.get(env.db, 'abcd')).toBeNull() // ambiguous
-  expect(agentRepo.get(env.db, 'abcd1')?.name).toBe('A') // unique
-  expect(agentRepo.get(env.db, 'abcd2')?.name).toBe('B')
-})
-
-test('resolveAgent accepts a UUID prefix', () => {
-  seedProfile()
-  const agent = spawn()
-  const resolved = resolveAgent(env.db, env.paths, agent.id.slice(0, 8))
-  expect(resolved.agent.id).toBe(agent.id)
-})
-
-test('resolveAgent assembles profile, skills, group, and model', () => {
-  seedProfile()
-  const g = registerGroup(env.db, { id: 'rg' }, env.paths)
-  const agent = spawn({ groupId: g.id, modelOverride: 'openai:gpt-5' })
-
-  const resolved = resolveAgent(env.db, env.paths, agent.id)
-  expect(resolved.model).toBe('openai:gpt-5')
-  expect(resolved.profile.id).toBe('base')
-  expect(resolved.group.id).toBe('rg')
-  expect(resolved.group.userMd).toBe('')
-  expect(resolved.skills).toEqual(['skill-a'])
-})
-
-test('resolveAgent uses profile default model when no override', () => {
-  seedProfile()
-  const agent = spawn()
-  const resolved = resolveAgent(env.db, env.paths, agent.id)
-  expect(resolved.model).toBe('anthropic:claude-opus-4-6')
-})

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

@@ -1,63 +0,0 @@
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import {
-  type BazilionDb,
-  groupAvailableModels,
-  listAvailableModels,
-  openInMemoryDb,
-  providerModelRepo,
-  providerStateRepo,
-  runMigrations,
-} from '../../src/core/index.ts'
-
-let db: BazilionDb
-
-beforeEach(() => {
-  db = openInMemoryDb()
-  runMigrations(db)
-})
-afterEach(() => {
-  db.close()
-})
-
-test('empty DB yields empty lists', () => {
-  expect(listAvailableModels(db)).toEqual([])
-  expect(groupAvailableModels(db)).toEqual([])
-})
-
-test('only enabled providers with curated models surface', () => {
-  providerStateRepo.setEnabled(db, 'anthropic', true)
-  providerStateRepo.setEnabled(db, 'openai', true)
-  providerStateRepo.setEnabled(db, 'groq', false)
-  providerStateRepo.setEnabled(db, 'lmstudio', true)
-
-  providerModelRepo.replace(db, 'anthropic', ['claude-opus-4-6', 'claude-sonnet-4-6'])
-  providerModelRepo.replace(db, 'openai', ['gpt-4o'])
-  // openai but disabled-then-enabled — still has its curated entries
-  providerModelRepo.replace(db, 'groq', ['llama-3.3-70b']) // disabled → omitted
-  // lmstudio is enabled but has no curated models → omitted from groups
-
-  const list = listAvailableModels(db)
-  expect(list.map((m) => m.value).sort()).toEqual([
-    'anthropic:claude-opus-4-6',
-    'anthropic:claude-sonnet-4-6',
-    'openai:gpt-4o',
-  ])
-
-  const groups = groupAvailableModels(db)
-  expect(groups).toEqual([
-    { provider: 'anthropic', models: ['claude-opus-4-6', 'claude-sonnet-4-6'] },
-    { provider: 'openai', models: ['gpt-4o'] },
-  ])
-})
-
-test('disabling a provider makes its curated models disappear from the list', () => {
-  providerStateRepo.setEnabled(db, 'anthropic', true)
-  providerModelRepo.replace(db, 'anthropic', ['claude-opus-4-6'])
-  expect(listAvailableModels(db)).toHaveLength(1)
-
-  providerStateRepo.setEnabled(db, 'anthropic', false)
-  expect(listAvailableModels(db)).toHaveLength(0)
-
-  providerStateRepo.setEnabled(db, 'anthropic', true)
-  expect(listAvailableModels(db)).toHaveLength(1)
-})

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

@@ -1,99 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { type BazilionDb, openInMemoryDb } from '../../src/core/db/client.ts'
-import { runMigrations } from '../../src/core/db/migrate.ts'
-import { CONFIG_KEYS, isConfigKey, openConfig } from '../../src/core/repos/config.ts'
-import { openSecrets } from '../../src/core/repos/secrets.ts'
-import { mergeSecretsIntoEnv } from '../../src/core/secrets.ts'
-
-interface Env {
-  home: string
-  db: BazilionDb
-  authToken: string
-  cleanup(): void
-}
-
-function makeEnv(): Env {
-  const home = mkdtempSync(join(tmpdir(), 'bazilion-config-'))
-  const db = openInMemoryDb()
-  runMigrations(db)
-  return {
-    home,
-    db,
-    authToken: 'test-token-abc123',
-    cleanup() {
-      db.close()
-      rmSync(home, { recursive: true, force: true })
-    },
-  }
-}
-
-let env: Env
-
-beforeEach(() => {
-  env = makeEnv()
-})
-afterEach(() => {
-  env.cleanup()
-})
-
-test('isConfigKey identifies URL-type keys and rejects secret-shaped ones', () => {
-  for (const k of CONFIG_KEYS) expect(isConfigKey(k)).toBe(true)
-  expect(isConfigKey('ANTHROPIC_API_KEY')).toBe(false)
-  expect(isConfigKey('OPENAI_API_KEY')).toBe(false)
-  expect(isConfigKey('BRAVE_API_KEY')).toBe(false)
-  expect(isConfigKey('random-junk')).toBe(false)
-})
-
-test('openConfig round-trips LMSTUDIO_URL through the config table', () => {
-  const config = openConfig(env.db)
-  config.set('LMSTUDIO_URL', 'http://192.168.1.50:1234/v1')
-  expect(config.get('LMSTUDIO_URL')).toBe('http://192.168.1.50:1234/v1')
-
-  // Re-opening (a fresh repo over the same db) yields the same value.
-  const reopened = openConfig(env.db)
-  expect(reopened.get('LMSTUDIO_URL')).toBe('http://192.168.1.50:1234/v1')
-})
-
-test('openConfig rejects unknown keys to prevent accidental secret leaks', () => {
-  const config = openConfig(env.db)
-  expect(() => config.set('ANTHROPIC_API_KEY', 'sk-abc')).toThrow(/not a known config key/)
-  expect(() => config.set('random-thing', 'x')).toThrow(/not a known config key/)
-})
-
-test('openConfig.remove clears one key without affecting siblings', () => {
-  const config = openConfig(env.db)
-  config.set('LMSTUDIO_URL', 'http://x')
-  config.set('OLLAMA_URL', 'http://y')
-  config.remove('LMSTUDIO_URL')
-  expect(config.get('LMSTUDIO_URL')).toBeUndefined()
-  expect(config.get('OLLAMA_URL')).toBe('http://y')
-})
-
-test('openSecrets round-trips an encrypted value with the bootstrap token', () => {
-  const secrets = openSecrets(env.db, env.authToken)
-  secrets.set('ANTHROPIC_API_KEY', 'sk-from-secrets')
-  expect(secrets.get('ANTHROPIC_API_KEY')).toBe('sk-from-secrets')
-
-  // A different password fails to decrypt — get returns undefined rather
-  // than throwing.
-  const wrongPass = openSecrets(env.db, 'wrong-token')
-  expect(wrongPass.get('ANTHROPIC_API_KEY')).toBeUndefined()
-})
-
-test('mergeSecretsIntoEnv layers process env over secrets over config', () => {
-  const config = openConfig(env.db)
-  config.set('LMSTUDIO_URL', 'http://from-config')
-
-  const secrets = openSecrets(env.db, env.authToken)
-  secrets.set('ANTHROPIC_API_KEY', 'sk-from-secrets')
-
-  // process env beats both.
-  const merged = mergeSecretsIntoEnv(env.db, env.authToken, {
-    ANTHROPIC_API_KEY: 'sk-from-env',
-  } as NodeJS.ProcessEnv)
-  expect(merged.LMSTUDIO_URL).toBe('http://from-config')
-  expect(merged.ANTHROPIC_API_KEY).toBe('sk-from-env')
-})

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

@@ -1,63 +0,0 @@
-import { existsSync, lstatSync, mkdtempSync, symlinkSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { registerGroup } from '../../src/core/group/register.ts'
-import * as groupRepo from '../../src/core/repos/groups.ts'
-import { makeTestEnv, type TestEnv } from './helpers.ts'
-
-let env: TestEnv
-beforeEach(() => {
-  env = makeTestEnv()
-})
-afterEach(() => env.cleanup())
-
-test('registerGroup creates a real directory under groups/<slug>/', () => {
-  const g = registerGroup(env.db, { id: 'g1' }, env.paths)
-  expect(g.id).toBe('g1')
-  expect(g.path).toBe(env.paths.groupDir('g1'))
-  expect(g.userMd).toBe('')
-  expect(existsSync(g.path)).toBe(true)
-  expect(lstatSync(g.path).isSymbolicLink()).toBe(false)
-  expect(existsSync(join(g.path, 'memory'))).toBe(true)
-  // +1 over the auto-seeded test-group from makeTestEnv.
-  expect(groupRepo.list(env.db, env.paths).length).toBe(2)
-})
-
-test('registerGroup with --link materializes the slot as a symlink', () => {
-  const target = mkdtempSync(join(tmpdir(), 'bazilion-link-'))
-  const g = registerGroup(env.db, { id: 'linked', link: target }, env.paths)
-  expect(g.path).toBe(env.paths.groupDir('linked'))
-  expect(lstatSync(g.path).isSymbolicLink()).toBe(true)
-  // memory subdir gets created via the symlink — ends up inside the target.
-  expect(existsSync(join(target, 'memory'))).toBe(true)
-})
-
-test('registerGroup --link fails when target does not exist', () => {
-  expect(() =>
-    registerGroup(env.db, { id: 'broken', link: '/tmp/no-such-bazilion-target-x9' }, env.paths),
-  ).toThrow(/does not exist/)
-})
-
-test('registerGroup refuses duplicate slug', () => {
-  registerGroup(env.db, { id: 'first' }, env.paths)
-  expect(() => registerGroup(env.db, { id: 'first' }, env.paths)).toThrow(/already registered/)
-})
-
-test('registerGroup refuses if the on-disk slot already exists', () => {
-  // Materialize the slot before the registry call — should bail out cleanly.
-  const slot = env.paths.groupDir('preexisting')
-  symlinkSync(env.home, slot, 'dir')
-  expect(() => registerGroup(env.db, { id: 'preexisting' }, env.paths)).toThrow(/slot already/)
-})
-
-test('registerGroup rejects invalid slug', () => {
-  expect(() => registerGroup(env.db, { id: 'Bad Id' }, env.paths)).toThrow(/invalid slug/)
-})
-
-test('setUserMd updates the stored value, read back via get', () => {
-  const g = registerGroup(env.db, { id: 'with-user-md' }, env.paths)
-  groupRepo.setUserMd(env.db, g.id, 'hi, call me Pat')
-  const reloaded = groupRepo.get(env.db, g.id, env.paths)
-  expect(reloaded?.userMd).toBe('hi, call me Pat')
-})

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

@@ -1,50 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { type BazilionDb, openInMemoryDb } from '../../src/core/db/client.ts'
-import { runMigrations } from '../../src/core/db/migrate.ts'
-import { registerGroup } from '../../src/core/group/register.ts'
-import { type Paths, resolvePaths } from '../../src/core/paths.ts'
-
-// `process.env.BAZILION_HOME` is consumed by `resolvePaths`. Some tests pass a
-// home explicitly; other code paths reach for the env. Either works.
-
-export interface TestEnv {
-  home: string
-  paths: Paths
-  db: BazilionDb
-  /**
-   * A group registered automatically so spawn/resolve always have a valid
-   * id to target. Named `test-group` — tests that need more can register
-   * extras.
-   */
-  groupId: string
-  cleanup: () => void
-}
-
-export function makeTestEnv(): TestEnv {
-  const home = mkdtempSync(join(tmpdir(), 'bazilion-test-'))
-  const paths = resolvePaths(home)
-  for (const d of [
-    paths.profilesDir,
-    paths.agentsDir,
-    paths.skillsDir,
-    paths.logsDir,
-    paths.groupsDir,
-  ]) {
-    mkdirSync(d, { recursive: true })
-  }
-  const db = openInMemoryDb()
-  runMigrations(db)
-  const group = registerGroup(db, { id: 'test-group', name: 'test' }, paths)
-  return {
-    home,
-    paths,
-    db,
-    groupId: group.id,
-    cleanup() {
-      db.close()
-      rmSync(home, { recursive: true, force: true })
-    },
-  }
-}

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

@@ -1,85 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import {
-  identityHasValues,
-  loadIdentityFromFile,
-  parseIdentityMarkdown,
-} from '../../src/core/profile/identity.ts'
-
-let dir: string
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), 'bazilion-identity-'))
-})
-afterEach(() => rmSync(dir, { recursive: true, force: true }))
-
-test('parseIdentityMarkdown extracts name/emoji/vibe from bullet list', () => {
-  const md = `# IDENTITY
-
-- **Name:** Felix
-- **Vibe:** cat with a clipboard
-- **Emoji:** 🐾
-- **Creature:** familiar
-`
-  const parsed = parseIdentityMarkdown(md)
-  expect(parsed).toEqual({
-    name: 'Felix',
-    vibe: 'cat with a clipboard',
-    emoji: '🐾',
-    creature: 'familiar',
-  })
-  expect(identityHasValues(parsed)).toBe(true)
-})
-
-test('parseIdentityMarkdown strips placeholder prompts', () => {
-  const md = `- Name: pick something you like
-- Emoji: 🦉
-- Theme: your signature - pick one that feels right`
-  const parsed = parseIdentityMarkdown(md)
-  expect(parsed).toEqual({ emoji: '🦉' })
-})
-
-test('parseIdentityMarkdown ignores unrelated labels and bare text', () => {
-  const md = `# Felix
-
-Random prose without a colon.
-
-- Name: Bazyl
-- Mission: this is not a known label
-- not-even-a-label
-`
-  const parsed = parseIdentityMarkdown(md)
-  expect(parsed).toEqual({ name: 'Bazyl' })
-})
-
-test('parseIdentityMarkdown strips markdown emphasis on labels', () => {
-  // Label regex drops every *_; value regex only touches edges, after the
-  // colon-adjacent space has been preserved.
-  const md = `- **Name:** Quill
-- _Vibe_: cheeky`
-  const parsed = parseIdentityMarkdown(md)
-  expect(parsed.name).toBe('Quill')
-  expect(parsed.vibe).toBe('cheeky')
-})
-
-test('identityHasValues is false for empty / placeholder-only identities', () => {
-  expect(identityHasValues(parseIdentityMarkdown('# heading\n'))).toBe(false)
-  expect(identityHasValues({})).toBe(false)
-})
-
-test('loadIdentityFromFile returns null for missing file', () => {
-  expect(loadIdentityFromFile(join(dir, 'ghost.md'))).toBeNull()
-})
-
-test('loadIdentityFromFile returns null when nothing parses', () => {
-  const path = join(dir, 'IDENTITY.md')
-  writeFileSync(path, '# Just prose, no key:value pairs\n')
-  expect(loadIdentityFromFile(path)).toBeNull()
-})
-
-test('loadIdentityFromFile returns parsed identity when the file has values', () => {
-  const path = join(dir, 'IDENTITY.md')
-  writeFileSync(path, '- Name: Ada\n- Emoji: ✨\n')
-  expect(loadIdentityFromFile(path)).toEqual({ name: 'Ada', emoji: '✨' })
-})