bazilion 0.0.0 → 0.1.0

package/apps/daemon/src/core/db/migrate.ts

@@ -1,41 +0,0 @@
-import { readdirSync, readFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import type { BazilionDb } from './client.ts'
-
-const migrationsDir = join(dirname(fileURLToPath(import.meta.url)), 'migrations')
-
-export function runMigrations(db: BazilionDb): void {
-  db.raw.exec(`
-    CREATE TABLE IF NOT EXISTS schema_migrations (
-      version    TEXT PRIMARY KEY,
-      applied_at INTEGER NOT NULL
-    )
-  `)
-
-  const applied = new Set(
-    db.raw
-      .query<{ version: string }, []>('SELECT version FROM schema_migrations')
-      .all()
-      .map((r) => r.version),
-  )
-
-  const files = readdirSync(migrationsDir)
-    .filter((f) => f.endsWith('.sql'))
-    .sort()
-
-  for (const file of files) {
-    const version = file.replace(/\.sql$/, '')
-    if (applied.has(version)) continue
-
-    const sql = readFileSync(join(migrationsDir, file), 'utf8')
-    const tx = db.raw.transaction(() => {
-      db.raw.exec(sql)
-      db.raw.run('INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)', [
-        version,
-        Date.now(),
-      ])
-    })
-    tx()
-  }
-}

package/apps/daemon/src/core/db/migrations/0001_init.sql

@@ -1,179 +0,0 @@
--- Bazilion initial schema (consolidated, post-IPC + secrets-in-DB cleanup).
---
--- The daemon is the sole owner of `~/.bazilion/`. All state — entity
--- metadata, inbox, scheduler, web tokens, encrypted secrets, plaintext
--- config — lives in this single SQLite file. The only other file at the
--- bazilion home root is `auth.json`: a tiny bootstrap shared by the daemon
--- (which uses its `token` as the PBKDF2 seed for the `secrets` table) and
--- the CLI (which uses the same token as its loopback bearer).
---
--- On-disk layout owned by the daemon:
---   ~/.bazilion/bazilion.db
---   ~/.bazilion/groups/<slug>/        — group root, mounted as cwd; may be a
---                                       symlink for "agents working on my
---                                       existing project tree" use cases
---                  /memory/           — qmd index for the group (shared by
---                                       all member agents)
---   ~/.bazilion/agents/<id>/          — agent's private home (NEVER inside
---                                       the group tree, so the cwd-rooted
---                                       coding tools can't see/clobber it)
---                  /sessions/*.jsonl  — pi transcripts
---   ~/.bazilion/profiles/<id>/        — profile templates
---   ~/.bazilion/skills/<name>/        — installed skills
---   ~/.bazilion/logs/                 — daemon logs
-
--- Groups are collaboration contexts: one filesystem root, one USER.md, one
--- roster of member agents. The id IS the slug IS the directory name under
--- `~/.bazilion/groups/`. No `path` column — paths derive from id.
--- `user_md` is read-only context about the human (edited via web UI; never
--- exposed as a file the agent could clobber via `edit`/`write`).
-CREATE TABLE groups (
-  id          TEXT PRIMARY KEY,
-  name        TEXT NOT NULL,
-  user_md     TEXT NOT NULL DEFAULT '',
-  created_at  INTEGER NOT NULL
-);
-
--- Profiles are agent templates. `dir` is the on-disk directory for the
--- profile's SOUL.md / IDENTITY.md / etc. master files, derived from id.
--- `skills_mode = 'all'` attaches every installed skill at spawn;
--- `'selected'` attaches only those listed in `profile_default_skills`.
-CREATE TABLE profiles (
-  id            TEXT PRIMARY KEY,
-  name          TEXT NOT NULL,
-  dir           TEXT NOT NULL,
-  default_model TEXT NOT NULL,
-  skills_mode   TEXT NOT NULL DEFAULT 'selected' CHECK (skills_mode IN ('all','selected')),
-  created_at    INTEGER NOT NULL,
-  updated_at    INTEGER NOT NULL
-);
-
-CREATE TABLE profile_default_skills (
-  profile_id  TEXT NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
-  skill_name  TEXT NOT NULL,
-  PRIMARY KEY (profile_id, skill_name)
-);
-
--- Agents have exactly one group. `dir` is the agent's private home,
--- ~/.bazilion/agents/<id>/ — strictly outside the group tree so that
--- pi's coding tools (rooted at the group dir) can't reach into it.
--- `reasoning_level` feeds pi-ai's streamSimple `reasoning` option;
--- 'medium' is the sensible default.
-CREATE TABLE agents (
-  id              TEXT PRIMARY KEY,
-  profile_id      TEXT NOT NULL REFERENCES profiles(id),
-  name            TEXT NOT NULL,
-  model_override  TEXT,
-  status          TEXT NOT NULL CHECK (status IN ('idle','running','archived')),
-  dir             TEXT NOT NULL,
-  reasoning_level TEXT NOT NULL DEFAULT 'medium',
-  group_id        TEXT NOT NULL REFERENCES groups(id) ON DELETE RESTRICT,
-  created_at      INTEGER NOT NULL,
-  archived_at     INTEGER
-);
-
-CREATE TABLE agent_skills (
-  agent_id    TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
-  skill_name  TEXT NOT NULL,
-  attached_at INTEGER NOT NULL,
-  PRIMARY KEY (agent_id, skill_name)
-);
-
--- Periodic / scheduled wake-up triggers. The scheduler picks rows whose
--- next-fire time has elapsed and kicks off a turn with `message` as the
--- user input.
---
--- kind='interval' → interval_sec holds seconds between fires (cron_expr NULL)
--- kind='cron'     → cron_expr holds a 5-field cron expression (interval_sec NULL)
---
--- last_fired_at is bumped *before* the run kicks off so a daemon restart
--- mid-fire doesn't double-trigger.
-CREATE TABLE agent_triggers (
-  id             TEXT PRIMARY KEY,
-  agent_id       TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
-  kind           TEXT NOT NULL CHECK (kind IN ('interval','cron')),
-  interval_sec   INTEGER,
-  cron_expr      TEXT,
-  message        TEXT NOT NULL,
-  enabled        INTEGER NOT NULL DEFAULT 1,
-  last_fired_at  INTEGER,
-  created_at     INTEGER NOT NULL
-);
-CREATE INDEX agent_triggers_agent ON agent_triggers(agent_id);
-CREATE INDEX agent_triggers_enabled ON agent_triggers(enabled) WHERE enabled = 1;
-
--- Inter-agent inbox. The scheduler's auto-deliver loop polls
--- `messages_to_unread` to fan out wakeup turns; the messaging tools insert
--- here when one agent sends another a message.
-CREATE TABLE messages (
-  id            TEXT PRIMARY KEY,
-  from_agent_id TEXT NOT NULL REFERENCES agents(id),
-  to_agent_id   TEXT NOT NULL REFERENCES agents(id),
-  reply_to      TEXT REFERENCES messages(id),
-  payload       TEXT NOT NULL,
-  created_at    INTEGER NOT NULL,
-  read_at       INTEGER
-);
-CREATE INDEX messages_to_unread ON messages(to_agent_id) WHERE read_at IS NULL;
-
--- Per-skill import provenance. Skills live on disk under ~/.bazilion/skills/<name>/;
--- this table records where each was imported from and when.
-CREATE TABLE skill_meta (
-  name         TEXT PRIMARY KEY,
-  source       TEXT,
-  imported_at  INTEGER
-);
-
--- Per-client web tokens. Each row stores SHA-256(token) hex; the plaintext
--- is returned exactly once at creation time and never persisted in this
--- table. The CLI's bootstrap token is one row here — its plaintext lives
--- in `~/.bazilion/auth.json` so both the daemon (PBKDF2 seed for the
--- secrets table) and the CLI (loopback bearer) can read it.
--- `revoked_at` is a soft-delete marker to keep audit trail intact.
-CREATE TABLE web_tokens (
-  id            TEXT PRIMARY KEY,
-  label         TEXT NOT NULL,
-  token_hash    TEXT NOT NULL UNIQUE,
-  created_at    INTEGER NOT NULL,
-  last_used_at  INTEGER,
-  revoked_at    INTEGER
-);
-CREATE INDEX web_tokens_active ON web_tokens(token_hash) WHERE revoked_at IS NULL;
-
--- Curated list of models per provider. Drives the model dropdowns in
--- profile creation and agent spawn/edit forms.
-CREATE TABLE provider_models (
-  provider   TEXT    NOT NULL,
-  model      TEXT    NOT NULL,
-  added_at   INTEGER NOT NULL,
-  PRIMARY KEY (provider, model)
-);
-CREATE INDEX idx_provider_models_provider ON provider_models (provider);
-
--- Admin-toggled enabled state per provider.
-CREATE TABLE provider_state (
-  provider_id TEXT    NOT NULL PRIMARY KEY,
-  enabled     INTEGER NOT NULL DEFAULT 0,
-  updated_at  INTEGER NOT NULL
-);
-
--- Encrypted secrets. AES-256-GCM envelopes (salt+iv+tag+data hex JSON),
--- one row per env-var-shaped key (`ANTHROPIC_API_KEY`, `OPENAI_CODEX_OAUTH`, …).
--- The encryption key is derived from the bootstrap web token (PBKDF2-SHA256,
--- 100k iterations) — same crypto as the previous file-based secrets.enc,
--- now atomic with the rest of the DB.
-CREATE TABLE secrets (
-  key         TEXT PRIMARY KEY,
-  envelope    TEXT NOT NULL,
-  updated_at  INTEGER NOT NULL
-);
-
--- Plaintext config. Same env-var-shaped keys as secrets, but for values
--- that don't need confidentiality (server URLs, region slugs, project IDs).
--- The application layer enforces a CONFIG_KEYS allowlist on writes so a
--- typo can't put a secret in this table.
-CREATE TABLE config (
-  key         TEXT PRIMARY KEY,
-  value       TEXT NOT NULL,
-  updated_at  INTEGER NOT NULL
-);

package/apps/daemon/src/core/group/delete.ts

@@ -1,21 +0,0 @@
-import type { BazilionDb } from '../db/client.ts'
-import type { Paths } from '../paths.ts'
-import * as agentRepo from '../repos/agents.ts'
-import * as groupRepo from '../repos/groups.ts'
-
-export function deleteGroup(db: BazilionDb, paths: Paths, id: string): void {
-  const g = groupRepo.get(db, id, paths)
-  if (!g) throw new Error(`group not found: ${id}`)
-
-  // ON DELETE RESTRICT on agents.group_id enforces this at the SQL layer,
-  // but we surface a friendlier error listing the blocking members.
-  const members = agentRepo.list(db, { includeArchived: true }).filter((a) => a.groupId === id)
-  if (members.length > 0) {
-    const names = members.map((a) => `${a.name} (${a.id.slice(0, 8)})`).join(', ')
-    throw new Error(
-      `cannot delete group "${id}": ${members.length} agent(s) still belong to it: ${names}. Move or archive them first.`,
-    )
-  }
-
-  groupRepo.remove(db, id)
-}

package/apps/daemon/src/core/group/register.ts

@@ -1,68 +0,0 @@
-// Register a group: pick a slug, materialize `~/.bazilion/groups/<slug>/`
-// (real dir or symlink), insert the row.
-//
-// Two modes:
-//   - default: creates a real directory at `paths.groupDir(slug)`.
-//   - `--link <target>`: creates a symlink at `paths.groupDir(slug)` →
-//     `<target>`. The link target must exist and be a directory — that's
-//     the "I want my agents working on my existing project tree" path.
-//
-// Slug = the row's id. Names are humanized labels separate from the slug;
-// callers may pass `name` explicitly or let it default to the slug.
-
-import { existsSync, mkdirSync, statSync, symlinkSync } from 'node:fs'
-import { resolve } from 'node:path'
-import type { Group } from '@bazilion/api-types'
-import type { BazilionDb } from '../db/client.ts'
-import type { Paths } from '../paths.ts'
-import { validateSlug } from '../profile/validate.ts'
-import * as groupRepo from '../repos/groups.ts'
-
-export interface RegisterGroupInput {
-  /** Slug. Becomes the row id AND the directory name under `groups/`. */
-  id: string
-  /** Human-readable label. Defaults to `id`. */
-  name?: string
-  /**
-   * If set, materialize `paths.groupDir(id)` as a symlink to this absolute
-   * path instead of as a real directory. Target must exist and be a dir.
-   */
-  link?: string
-}
-
-export function registerGroup(db: BazilionDb, input: RegisterGroupInput, paths: Paths): Group {
-  validateSlug(input.id)
-
-  if (groupRepo.get(db, input.id, paths)) {
-    throw new Error(`group already registered: ${input.id}`)
-  }
-
-  const slot = paths.groupDir(input.id)
-  if (existsSync(slot)) {
-    throw new Error(`group slot already on disk at ${slot} (move or remove it first)`)
-  }
-
-  // Make sure the parent `groups/` dir exists — the daemon's bootstrap creates
-  // it but tests sometimes resolve a custom $BAZILION_HOME without going
-  // through bootstrap.
-  mkdirSync(paths.groupsDir, { recursive: true })
-
-  if (input.link) {
-    const target = resolve(input.link)
-    if (!existsSync(target)) {
-      throw new Error(`--link target does not exist: ${target}`)
-    }
-    if (!statSync(target).isDirectory()) {
-      throw new Error(`--link target is not a directory: ${target}`)
-    }
-    symlinkSync(target, slot, 'dir')
-  } else {
-    mkdirSync(slot, { recursive: true })
-  }
-
-  // Memory subdir is the qmd index root for this group — created here so
-  // the first tool call doesn't have to ensure it.
-  mkdirSync(resolve(slot, 'memory'), { recursive: true })
-
-  return groupRepo.insert(db, { id: input.id, name: input.name ?? input.id }, paths)
-}

package/apps/daemon/src/core/index.ts

@@ -1,71 +0,0 @@
-export { archiveAgent } from './agent/archive.ts'
-export { deleteAgent } from './agent/delete.ts'
-export { resolveAgent } from './agent/resolve.ts'
-export type { SpawnAgentInput } from './agent/spawn.ts'
-export { spawnAgent } from './agent/spawn.ts'
-export { unarchiveAgent } from './agent/unarchive.ts'
-export type { AvailableModel } from './availableModels.ts'
-export {
-  groupAvailableModels,
-  isSetupComplete,
-  listAvailableModels,
-} from './availableModels.ts'
-export type { BazilionDb } from './db/client.ts'
-export { openDb, openInMemoryDb } from './db/client.ts'
-export { runMigrations } from './db/migrate.ts'
-export { deleteGroup } from './group/delete.ts'
-export type { RegisterGroupInput } from './group/register.ts'
-export { registerGroup } from './group/register.ts'
-export type { Paths } from './paths.ts'
-export { resolvePaths } from './paths.ts'
-export type { CreateProfileInput } from './profile/create.ts'
-export { createProfile } from './profile/create.ts'
-export { deleteProfile } from './profile/delete.ts'
-export {
-  identityHasValues,
-  loadIdentityFromFile,
-  parseIdentityMarkdown,
-} from './profile/identity.ts'
-export { loadProfile } from './profile/load.ts'
-export {
-  DEFAULT_GROUP_ID,
-  DEFAULT_PROFILE_ID,
-  ensureSetupSeeded,
-  type SeedResult,
-  seedDefaults,
-} from './profile/seed.ts'
-export {
-  DEFAULT_AGENTS,
-  DEFAULT_BOOTSTRAP,
-  DEFAULT_HEARTBEAT,
-  DEFAULT_IDENTITY,
-  DEFAULT_SOUL,
-  DEFAULT_TOOLS,
-} from './profile/templates.ts'
-export type { UpdateProfileInput } from './profile/update.ts'
-export { updateProfile } from './profile/update.ts'
-export * as agentRepo from './repos/agents.ts'
-export type { ConfigStore } from './repos/config.ts'
-export { CONFIG_KEYS, isConfigKey, openConfig } from './repos/config.ts'
-export * as groupRepo from './repos/groups.ts'
-export * as messageRepo from './repos/messages.ts'
-export * as profileRepo from './repos/profiles.ts'
-export * as providerModelRepo from './repos/providerModels.ts'
-export * as providerStateRepo from './repos/providerState.ts'
-export type { SecretsStore } from './repos/secrets.ts'
-export { openSecrets } from './repos/secrets.ts'
-export * as skillMetaRepo from './repos/skillMeta.ts'
-export * as triggerRepo from './repos/triggers.ts'
-export * as webTokenRepo from './repos/webTokens.ts'
-export type { AuthFile } from './secrets.ts'
-export { mergeSecretsIntoEnv, readAuthFile } from './secrets.ts'
-export type { FieldKind, ServiceCategory, ServiceDef, ServiceField } from './services.ts'
-export { findFieldByEnvVar, SERVICES, servicesByCategory } from './services.ts'
-export type { DiscoveredSkill } from './skills/discover.ts'
-export { discoverSkills } from './skills/discover.ts'
-export type { ImportResult, ImportSkillsInput } from './skills/import.ts'
-export { importSkills } from './skills/import.ts'
-export type { ParsedSkill, SkillFrontmatter } from './skills/parse.ts'
-export { parseSkillFile } from './skills/parse.ts'
-export type { ResolvedSkill, ResolvedSkillSet } from './skills/resolve.ts'
-export { resolveAgentSkills } from './skills/resolve.ts'

package/apps/daemon/src/core/paths.ts

@@ -1,56 +0,0 @@
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-
-export interface Paths {
-  home: string
-  db: string
-  /**
-   * Bootstrap auth file shared by the daemon and the CLI: `{token, remote?}`.
-   * - `token` is the plaintext of the bootstrap web token. The daemon reads
-   *   it once at startup to derive the encryption key for the `secrets`
-   *   table (PBKDF2 over it) and to validate that it matches a row in
-   *   `web_tokens` (so a corrupted file fails loudly). The CLI reads it as
-   *   its loopback bearer.
-   * - `remote` (set via `bazilion login`) is a CLI-only override pointing at
-   *   a remote daemon. The local daemon ignores this field.
-   *
-   * One file replaces the previous `config.json` + `secrets.enc` split:
-   * encrypted secrets and plaintext config now live as DB rows.
-   */
-  authFile: string
-  profilesDir: string
-  agentsDir: string
-  skillsDir: string
-  groupsDir: string
-  logsDir: string
-  profileDir(id: string): string
-  agentDir(id: string): string
-  skillDir(name: string): string
-  groupDir(slug: string): string
-}
-
-export function resolvePaths(home?: string): Paths {
-  const root = home ?? process.env.BAZILION_HOME ?? join(homedir(), '.bazilion')
-  return {
-    home: root,
-    db: join(root, 'bazilion.db'),
-    authFile: join(root, 'auth.json'),
-    profilesDir: join(root, 'profiles'),
-    agentsDir: join(root, 'agents'),
-    skillsDir: join(root, 'skills'),
-    groupsDir: join(root, 'groups'),
-    logsDir: join(root, 'logs'),
-    profileDir(id) {
-      return join(root, 'profiles', id)
-    },
-    agentDir(id) {
-      return join(root, 'agents', id)
-    },
-    skillDir(name) {
-      return join(root, 'skills', name)
-    },
-    groupDir(slug) {
-      return join(root, 'groups', slug)
-    },
-  }
-}

package/apps/daemon/src/core/profile/create.ts

@@ -1,78 +0,0 @@
-import { mkdirSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import type { Profile, SkillsMode } from '@bazilion/api-types'
-import type { BazilionDb } from '../db/client.ts'
-import type { Paths } from '../paths.ts'
-import * as profileRepo from '../repos/profiles.ts'
-import { DEFAULT_BOOTSTRAP, DEFAULT_IDENTITY, DEFAULT_SOUL } from './templates.ts'
-import { validateSlug } from './validate.ts'
-
-export interface CreateProfileInput {
-  id: string
-  name?: string
-  defaultModel: string
-  skillsMode?: SkillsMode
-  defaultSkills?: string[]
-  templates?: {
-    soul?: string
-    identity?: string
-    /** undefined = default bootstrap, null = skip bootstrap, string = override */
-    bootstrap?: string | null
-    /** undefined = skip, string = seed with this content */
-    agents?: string
-    /** undefined = skip, string = seed with this content */
-    tools?: string
-    /** undefined = skip, string = seed with this content */
-    heartbeat?: string
-  }
-}
-
-export function createProfile(db: BazilionDb, paths: Paths, input: CreateProfileInput): Profile {
-  validateSlug(input.id)
-
-  const dir = paths.profileDir(input.id)
-  mkdirSync(dir, { recursive: true })
-
-  const soul = input.templates?.soul ?? DEFAULT_SOUL
-  const identity = input.templates?.identity ?? DEFAULT_IDENTITY
-  const bootstrap =
-    input.templates?.bootstrap === null ? null : (input.templates?.bootstrap ?? DEFAULT_BOOTSTRAP)
-
-  writeFileSync(join(dir, 'SOUL.md'), soul)
-  writeFileSync(join(dir, 'IDENTITY.md'), identity)
-  if (bootstrap !== null) {
-    writeFileSync(join(dir, 'BOOTSTRAP.md'), bootstrap)
-  }
-  if (typeof input.templates?.agents === 'string') {
-    writeFileSync(join(dir, 'AGENTS.md'), input.templates.agents)
-  }
-  if (typeof input.templates?.tools === 'string') {
-    writeFileSync(join(dir, 'TOOLS.md'), input.templates.tools)
-  }
-  if (typeof input.templates?.heartbeat === 'string') {
-    writeFileSync(join(dir, 'HEARTBEAT.md'), input.templates.heartbeat)
-  }
-
-  const skillsMode: SkillsMode = input.skillsMode ?? 'selected'
-  const profileJson = {
-    name: input.name ?? input.id,
-    defaultModel: input.defaultModel,
-    skillsMode,
-    defaultSkills: input.defaultSkills ?? [],
-  }
-  writeFileSync(join(dir, 'profile.json'), `${JSON.stringify(profileJson, null, 2)}\n`)
-
-  const profile = profileRepo.insert(db, {
-    id: input.id,
-    name: profileJson.name,
-    dir,
-    defaultModel: input.defaultModel,
-    skillsMode,
-  })
-
-  if (skillsMode === 'selected' && input.defaultSkills && input.defaultSkills.length > 0) {
-    profileRepo.setDefaultSkills(db, input.id, input.defaultSkills)
-  }
-
-  return profile
-}

package/apps/daemon/src/core/profile/delete.ts

@@ -1,26 +0,0 @@
-import { existsSync, rmSync } from 'node:fs'
-import type { BazilionDb } from '../db/client.ts'
-import * as agentRepo from '../repos/agents.ts'
-import * as profileRepo from '../repos/profiles.ts'
-
-export function deleteProfile(db: BazilionDb, id: string): void {
-  const profile = profileRepo.get(db, id)
-  if (!profile) throw new Error(`profile not found: ${id}`)
-
-  // Check for agents still using this profile
-  const agents = agentRepo.list(db, { includeArchived: true }).filter((a) => a.profileId === id)
-  if (agents.length > 0) {
-    const names = agents.map((a) => `${a.name} (${a.id.slice(0, 8)})`).join(', ')
-    throw new Error(
-      `cannot delete profile "${id}": ${agents.length} agent(s) still reference it: ${names}. Delete or re-profile them first.`,
-    )
-  }
-
-  // Remove from DB (CASCADE deletes profile_default_skills)
-  profileRepo.remove(db, id)
-
-  // Remove the profile directory from disk
-  if (existsSync(profile.dir)) {
-    rmSync(profile.dir, { recursive: true, force: true })
-  }
-}

package/apps/daemon/src/core/profile/identity.ts

@@ -1,70 +0,0 @@
-import { readFileSync } from 'node:fs'
-import type { AgentIdentityFile } from '@bazilion/api-types'
-
-const IDENTITY_PLACEHOLDER_VALUES = new Set([
-  'pick something you like',
-  'ai? robot? familiar? ghost in the machine? something weirder?',
-  'how do you come across? sharp? warm? chaotic? calm?',
-  'your signature - pick one that feels right',
-  'workspace-relative path, http(s) url, or data uri',
-])
-
-function normalizeIdentityValue(value: string): string {
-  let normalized = value.trim()
-  normalized = normalized.replace(/^[*_]+|[*_]+$/g, '').trim()
-  if (normalized.startsWith('(') && normalized.endsWith(')')) {
-    normalized = normalized.slice(1, -1).trim()
-  }
-  normalized = normalized.replace(/[\u2013\u2014]/g, '-')
-  normalized = normalized.replace(/\s+/g, ' ').toLowerCase()
-  return normalized
-}
-
-function isIdentityPlaceholder(value: string): boolean {
-  return IDENTITY_PLACEHOLDER_VALUES.has(normalizeIdentityValue(value))
-}
-
-export function parseIdentityMarkdown(content: string): AgentIdentityFile {
-  const identity: AgentIdentityFile = {}
-  for (const line of content.split(/\r?\n/)) {
-    const cleaned = line.trim().replace(/^\s*-\s*/, '')
-    const colonIndex = cleaned.indexOf(':')
-    if (colonIndex === -1) continue
-    const label = cleaned.slice(0, colonIndex).replace(/[*_]/g, '').trim().toLowerCase()
-    const value = cleaned
-      .slice(colonIndex + 1)
-      .replace(/^[*_]+|[*_]+$/g, '')
-      .trim()
-    if (!value) continue
-    if (isIdentityPlaceholder(value)) continue
-    if (label === 'name') identity.name = value
-    else if (label === 'emoji') identity.emoji = value
-    else if (label === 'creature') identity.creature = value
-    else if (label === 'vibe') identity.vibe = value
-    else if (label === 'theme') identity.theme = value
-    else if (label === 'avatar') identity.avatar = value
-  }
-  return identity
-}
-
-export function identityHasValues(identity: AgentIdentityFile): boolean {
-  return Boolean(
-    identity.name ||
-      identity.emoji ||
-      identity.theme ||
-      identity.creature ||
-      identity.vibe ||
-      identity.avatar,
-  )
-}
-
-export function loadIdentityFromFile(path: string): AgentIdentityFile | null {
-  let content: string
-  try {
-    content = readFileSync(path, 'utf8')
-  } catch {
-    return null
-  }
-  const parsed = parseIdentityMarkdown(content)
-  return identityHasValues(parsed) ? parsed : null
-}

package/apps/daemon/src/core/profile/load.ts

@@ -1,45 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import type { LoadedProfile } from '@bazilion/api-types'
-import type { BazilionDb } from '../db/client.ts'
-import * as profileRepo from '../repos/profiles.ts'
-import { parseIdentityMarkdown } from './identity.ts'
-
-function readOptional(path: string): string | null {
-  return existsSync(path) ? readFileSync(path, 'utf8') : null
-}
-
-export function loadProfile(db: BazilionDb, id: string): LoadedProfile {
-  const profile = profileRepo.get(db, id)
-  if (!profile) throw new Error(`profile not found: ${id}`)
-
-  const soul = readFileSync(join(profile.dir, 'SOUL.md'), 'utf8')
-  const identityRaw = readFileSync(join(profile.dir, 'IDENTITY.md'), 'utf8')
-  const bootstrap = readOptional(join(profile.dir, 'BOOTSTRAP.md'))
-  const agents = readOptional(join(profile.dir, 'AGENTS.md'))
-  const tools = readOptional(join(profile.dir, 'TOOLS.md'))
-  const heartbeat = readOptional(join(profile.dir, 'HEARTBEAT.md'))
-
-  const parsedIdentity = parseIdentityMarkdown(identityRaw)
-  const anyIdentity =
-    parsedIdentity.name ||
-    parsedIdentity.emoji ||
-    parsedIdentity.theme ||
-    parsedIdentity.creature ||
-    parsedIdentity.vibe ||
-    parsedIdentity.avatar
-
-  return {
-    profile,
-    defaultSkills: profileRepo.getDefaultSkills(db, id),
-    files: {
-      soul,
-      identity: identityRaw,
-      bootstrap,
-      agents,
-      tools,
-      heartbeat,
-    },
-    identity: anyIdentity ? parsedIdentity : null,
-  }
-}