bazilion 0.0.0 → 0.1.0

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

@@ -1,74 +0,0 @@
-import type { Group, Profile } from '@bazilion/api-types'
-import { isSetupComplete, listAvailableModels } from '../availableModels.ts'
-import type { BazilionDb } from '../db/client.ts'
-import { registerGroup } from '../group/register.ts'
-import type { Paths } from '../paths.ts'
-import * as groupRepo from '../repos/groups.ts'
-import * as profileRepo from '../repos/profiles.ts'
-import { createProfile } from './create.ts'
-
-export const DEFAULT_PROFILE_ID = 'default'
-export const DEFAULT_GROUP_ID = 'default'
-
-export interface SeedDefaultsInput {
-  /** `provider:model` used as the profile's defaultModel. */
-  model: string
-}
-
-export interface SeedResult {
-  profile: Profile
-  group: Group
-  /** true if the helper created the profile this call (vs. returned an existing one). */
-  profileCreated: boolean
-  /** true if the helper created the group this call. */
-  groupCreated: boolean
-}
-
-/**
- * Seed the on-disk + DB defaults users land on after finishing first-run setup:
- * a `default` group at `~/.bazilion/groups/default/` and a `default` profile
- * wired to the just-enabled model. Fresh agents spawned from the default
- * profile land in the default group unless another is specified.
- *
- * Idempotent: re-seeding reuses whichever pieces already exist, so it's safe
- * to call whenever the setup state changes.
- */
-export function seedDefaults(db: BazilionDb, paths: Paths, input: SeedDefaultsInput): SeedResult {
-  let group = groupRepo.get(db, DEFAULT_GROUP_ID, paths)
-  let groupCreated = false
-  if (!group) {
-    group = registerGroup(db, { id: DEFAULT_GROUP_ID, name: 'Default' }, paths)
-    groupCreated = true
-  }
-
-  let profile = profileRepo.get(db, DEFAULT_PROFILE_ID)
-  let profileCreated = false
-  if (!profile) {
-    // skillsMode='all' so freshly-spawned default agents inherit every
-    // installed skill — the friendlier first-run posture. Custom profiles
-    // still default to 'selected' (createProfile's own default).
-    profile = createProfile(db, paths, {
-      id: DEFAULT_PROFILE_ID,
-      name: 'Default',
-      defaultModel: input.model,
-      skillsMode: 'all',
-    })
-    profileCreated = true
-  }
-
-  return { profile, group, profileCreated, groupCreated }
-}
-
-/**
- * Safe to call from any endpoint that can change setup state (toggling a
- * provider, editing model lists). No-op when either setup isn't complete
- * (nothing to seed against yet) or the default profile already exists.
- * Returns the seed result only on the cold-start transition.
- */
-export function ensureSetupSeeded(db: BazilionDb, paths: Paths): SeedResult | null {
-  if (!isSetupComplete(db)) return null
-  if (profileRepo.get(db, DEFAULT_PROFILE_ID)) return null
-  const first = listAvailableModels(db)[0]
-  if (!first) return null
-  return seedDefaults(db, paths, { model: first.value })
-}

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

@@ -1,60 +0,0 @@
-export const DEFAULT_SOUL = `# SOUL.md — Who You Are
-
-This is your personality and operating principles. Edit it freely to make this agent yours.
-
-## Core
-- Be genuinely helpful, not performatively helpful.
-- Have opinions. Push back when you disagree.
-- Be resourceful before asking — read the file, check context, then ask if stuck.
-
-## Boundaries
-- Private things stay private.
-- Confirm before destructive or external actions.
-- You're a guest in someone's environment. Treat it with respect.
-`
-
-export const DEFAULT_IDENTITY = `# IDENTITY.md — Who Am I?
-
-Fill this in during your first conversation. Make it yours.
-
-- **Name:**
-- **Vibe:**
-- **Emoji:**
-`
-
-export const DEFAULT_BOOTSTRAP = `# BOOTSTRAP.md — First Run
-
-You just woke up. There is no memory yet — that's normal.
-
-## What to do
-1. Ask your human who they are and what they want to call you.
-2. Call the \`home_write\` tool with \`file: "IDENTITY.md"\` and new content that captures your name, vibe, and emoji. Do NOT use the generic \`edit\` / \`write\` tools for this — those land in your workspace, not your private home, and would collide with other agents.
-3. Call \`bootstrap_done\` when finished — it removes this file so it does not appear in future sessions.
-`
-
-export const DEFAULT_AGENTS = `# AGENTS.md — Peers & Routing
-
-Document the other agents you can reach and when to involve them. If you're
-the only agent in this workspace, leave this short or delete it.
-
-## Peers
-- (name): what they're good at, when to hand off
-`
-
-export const DEFAULT_TOOLS = `# TOOLS.md — Tool Playbook
-
-Notes on tool usage patterns that are specific to this agent. Keep generic
-tool docs out — those live in SOUL.md or come from the tool descriptions.
-
-## Patterns
-- (pattern): when to use, what to avoid
-`
-
-export const DEFAULT_HEARTBEAT = `# HEARTBEAT.md — Scheduled Wake-Ups
-
-Tasks the agent should check on every heartbeat. Leave empty (or commented)
-to opt out — an empty file means "nothing to do right now".
-
-## Tasks
-- (task): cadence, exit criteria
-`

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

@@ -1,57 +0,0 @@
-import { 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'
-
-export interface UpdateProfileInput {
-  name?: string
-  defaultModel?: string
-  skillsMode?: SkillsMode
-  defaultSkills?: string[]
-}
-
-/**
- * Update the mutable settings in profile.json + the DB row in lockstep.
- * Profile files (SOUL/IDENTITY/BOOTSTRAP) and the memory backend are NOT
- * touched — those have their own paths.
- */
-export function updateProfile(
-  db: BazilionDb,
-  paths: Paths,
-  id: string,
-  input: UpdateProfileInput,
-): Profile {
-  const existing = profileRepo.get(db, id)
-  if (!existing) throw new Error(`profile not found: ${id}`)
-
-  const nextSkillsMode: SkillsMode = input.skillsMode ?? existing.skillsMode
-
-  const next = {
-    name: input.name ?? existing.name,
-    defaultModel: input.defaultModel ?? existing.defaultModel,
-    skillsMode: nextSkillsMode,
-  }
-  profileRepo.update(db, id, next)
-
-  if (input.defaultSkills !== undefined) {
-    profileRepo.setDefaultSkills(db, id, input.defaultSkills)
-  }
-
-  const skills = profileRepo.getDefaultSkills(db, id)
-  const profileJson = {
-    name: next.name,
-    defaultModel: next.defaultModel,
-    skillsMode: next.skillsMode,
-    defaultSkills: skills,
-  }
-  writeFileSync(
-    join(paths.profileDir(id), 'profile.json'),
-    `${JSON.stringify(profileJson, null, 2)}\n`,
-  )
-
-  const updated = profileRepo.get(db, id)
-  if (!updated) throw new Error(`profile vanished after update: ${id}`)
-  return updated
-}

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

@@ -1,9 +0,0 @@
-const SLUG = /^[a-z0-9][a-z0-9-]*$/
-
-export function validateSlug(s: string): void {
-  if (!SLUG.test(s)) {
-    throw new Error(
-      `invalid slug "${s}": must match /^[a-z0-9][a-z0-9-]*$/ (lowercase letters, digits, hyphens; must start with letter or digit)`,
-    )
-  }
-}

package/apps/daemon/src/core/repos/agents.ts

@@ -1,202 +0,0 @@
-import type { Agent, AgentSkillAttachment, AgentStatus, ReasoningLevel } from '@bazilion/api-types'
-import type { BazilionDb } from '../db/client.ts'
-
-interface RawAgent {
-  id: string
-  profile_id: string
-  name: string
-  model_override: string | null
-  reasoning_level: string
-  status: string
-  dir: string
-  group_id: string
-  created_at: number
-  archived_at: number | null
-}
-
-function toAgent(r: RawAgent): Agent {
-  return {
-    id: r.id,
-    profileId: r.profile_id,
-    name: r.name,
-    modelOverride: r.model_override,
-    reasoningLevel: r.reasoning_level as ReasoningLevel,
-    status: r.status as AgentStatus,
-    dir: r.dir,
-    groupId: r.group_id,
-    createdAt: r.created_at,
-    archivedAt: r.archived_at,
-  }
-}
-
-export function insert(db: BazilionDb, a: Omit<Agent, 'createdAt' | 'archivedAt'>): Agent {
-  const now = Date.now()
-  db.raw.run(
-    `INSERT INTO agents (id, profile_id, name, model_override, reasoning_level, status, dir, group_id, created_at, archived_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)`,
-    [a.id, a.profileId, a.name, a.modelOverride, a.reasoningLevel, a.status, a.dir, a.groupId, now],
-  )
-  return { ...a, createdAt: now, archivedAt: null }
-}
-
-export function setReasoningLevel(db: BazilionDb, id: string, level: ReasoningLevel): void {
-  db.raw.run('UPDATE agents SET reasoning_level = ? WHERE id = ?', [level, id])
-}
-
-export function setModelOverride(db: BazilionDb, id: string, model: string | null): void {
-  db.raw.run('UPDATE agents SET model_override = ? WHERE id = ?', [model, id])
-}
-
-export function setName(db: BazilionDb, id: string, name: string): void {
-  db.raw.run('UPDATE agents SET name = ? WHERE id = ?', [name, id])
-}
-
-/** Move the agent to a different group. The new group must exist. */
-export function setGroup(db: BazilionDb, id: string, groupId: string): void {
-  db.raw.run('UPDATE agents SET group_id = ? WHERE id = ?', [groupId, id])
-}
-
-/**
- * Lookup by full UUID, exact name, or unambiguous UUID prefix (git-style
- * shorthand). Resolution order: (1) exact id, (2) exact name — only if
- * unique — (3) ≥4-char id prefix — only if unique. Ambiguous name or prefix
- * returns null so the caller's "not found" branch fires. Internal callers
- * always pass full UUIDs, so this only exercises on the new path (URL params,
- * CLI arguments).
- *
- * Name comes before prefix so that a hex-looking name like "abcd1234" resolves
- * to the named agent rather than accidentally matching a UUID prefix.
- */
-export function get(db: BazilionDb, idOrName: string): Agent | null {
-  if (!idOrName) return null
-  const exactId = db.raw
-    .query<RawAgent, [string]>('SELECT * FROM agents WHERE id = ?')
-    .get(idOrName)
-  if (exactId) return toAgent(exactId)
-  const byName = db.raw
-    .query<RawAgent, [string]>('SELECT * FROM agents WHERE name = ? LIMIT 2')
-    .all(idOrName)
-  if (byName.length === 1 && byName[0]) return toAgent(byName[0])
-  if (byName.length > 1) return null
-  if (idOrName.length < 4) return null
-  const byPrefix = db.raw
-    .query<RawAgent, [string]>('SELECT * FROM agents WHERE id LIKE ? LIMIT 2')
-    .all(`${idOrName}%`)
-  return byPrefix.length === 1 && byPrefix[0] ? toAgent(byPrefix[0]) : null
-}
-
-/**
- * Resolve `idOrPrefix` to a full agent ID, or null if not found / ambiguous.
- * Thin wrapper around `get` for callers that want the canonical ID without
- * the rest of the row (e.g. URL param normalization).
- */
-export function resolveId(db: BazilionDb, idOrPrefix: string): string | null {
-  return get(db, idOrPrefix)?.id ?? null
-}
-
-export function list(db: BazilionDb, opts?: { includeArchived?: boolean }): Agent[] {
-  const sql = opts?.includeArchived
-    ? 'SELECT * FROM agents ORDER BY created_at ASC'
-    : "SELECT * FROM agents WHERE status != 'archived' ORDER BY created_at ASC"
-  return db.raw.query<RawAgent, []>(sql).all().map(toAgent)
-}
-
-export function countByProfile(db: BazilionDb, profileId: string): number {
-  return (
-    db.raw
-      .query<{ c: number }, [string]>('SELECT COUNT(*) as c FROM agents WHERE profile_id = ?')
-      .get(profileId)?.c ?? 0
-  )
-}
-
-/**
- * Count agents whose group_id matches. Blocks group deletion when > 0 (the
- * `agents.group_id` FK is `ON DELETE RESTRICT` — members must be moved or
- * archived before a group can go away).
- */
-export function countByGroup(db: BazilionDb, groupId: string): number {
-  return (
-    db.raw
-      .query<{ c: number }, [string]>('SELECT COUNT(*) as c FROM agents WHERE group_id = ?')
-      .get(groupId)?.c ?? 0
-  )
-}
-
-export function setStatus(db: BazilionDb, id: string, status: AgentStatus): void {
-  db.raw.run('UPDATE agents SET status = ? WHERE id = ?', [status, id])
-}
-
-export function archive(db: BazilionDb, id: string): void {
-  db.raw.run("UPDATE agents SET status = 'archived', archived_at = ? WHERE id = ?", [
-    Date.now(),
-    id,
-  ])
-}
-
-export function unarchive(db: BazilionDb, id: string): void {
-  db.raw.run("UPDATE agents SET status = 'idle', archived_at = NULL WHERE id = ?", [id])
-}
-
-export function remove(db: BazilionDb, id: string): void {
-  db.raw.run('DELETE FROM agents WHERE id = ?', [id])
-}
-
-// --- skill attachments ---
-
-interface RawSkill {
-  agent_id: string
-  skill_name: string
-  attached_at: number
-}
-
-function toSkillAttachment(r: RawSkill): AgentSkillAttachment {
-  return {
-    agentId: r.agent_id,
-    skillName: r.skill_name,
-    attachedAt: r.attached_at,
-  }
-}
-
-export function attachSkill(
-  db: BazilionDb,
-  agentId: string,
-  skillName: string,
-): AgentSkillAttachment {
-  const now = Date.now()
-  db.raw.run(
-    `INSERT INTO agent_skills (agent_id, skill_name, attached_at)
-     VALUES (?, ?, ?)
-     ON CONFLICT (agent_id, skill_name) DO NOTHING`,
-    [agentId, skillName, now],
-  )
-  return { agentId, skillName, attachedAt: now }
-}
-
-export function detachSkill(db: BazilionDb, agentId: string, skillName: string): void {
-  db.raw.run('DELETE FROM agent_skills WHERE agent_id = ? AND skill_name = ?', [agentId, skillName])
-}
-
-export function listAttachedSkills(db: BazilionDb, agentId: string): string[] {
-  return db.raw
-    .query<{ skill_name: string }, [string]>(
-      'SELECT skill_name FROM agent_skills WHERE agent_id = ? ORDER BY attached_at ASC',
-    )
-    .all(agentId)
-    .map((r) => r.skill_name)
-}
-
-export function listSkillAttachments(db: BazilionDb, agentId: string): AgentSkillAttachment[] {
-  return db.raw
-    .query<RawSkill, [string]>(
-      'SELECT * FROM agent_skills WHERE agent_id = ? ORDER BY attached_at ASC',
-    )
-    .all(agentId)
-    .map(toSkillAttachment)
-}
-
-// --- chat history snapshot ---
-//
-// Conversation transcript storage lives in pi-coding-agent's SessionManager
-// (JSONL under `~/.bazilion/agents/<id>/sessions/<sessionId>.jsonl`).
-// Clear/truncate/rotate operations go through the runtime's
-// `apps/daemon/src/runtime/pi/session.ts` helpers, not repo-level accessors.

package/apps/daemon/src/core/repos/config.ts

@@ -1,78 +0,0 @@
-// Plaintext config store, backed by the `config` table.
-//
-// Companion to `secrets.ts` — same key-shaped values, but for the ones that
-// don't need confidentiality (server URLs, region slugs, project IDs). Kept
-// separate so the /config UI can show plaintext values directly without
-// extra masking logic.
-//
-// The CONFIG_KEYS allowlist (derived from the services registry) is enforced
-// here on writes — a typo or accidental misclassification can't put an API
-// key in this table.
-
-import type { BazilionDb } from '../db/client.ts'
-import { SERVICES } from '../services.ts'
-
-/**
- * Env var names that live in the plaintext config store. Derived from the
- * services registry — any field marked `kind: 'config'` ends up here.
- */
-export const CONFIG_KEYS: readonly string[] = SERVICES.flatMap((s) =>
-  s.fields.filter((f) => f.kind === 'config').map((f) => f.envVar),
-)
-
-const CONFIG_KEY_SET = new Set<string>(CONFIG_KEYS)
-
-export function isConfigKey(key: string): boolean {
-  return CONFIG_KEY_SET.has(key)
-}
-
-interface RawRow {
-  key: string
-  value: string
-  updated_at: number
-}
-
-export interface ConfigStore {
-  get(key: string): string | undefined
-  set(key: string, value: string): void
-  remove(key: string): void
-  list(): { key: string; value: string }[]
-  getAll(): Record<string, string>
-}
-
-export function openConfig(db: BazilionDb): ConfigStore {
-  return {
-    get(key) {
-      const row = db.raw.query<RawRow, [string]>('SELECT * FROM config WHERE key = ?').get(key)
-      return row?.value
-    },
-    set(key, value) {
-      if (!isConfigKey(key)) {
-        throw new Error(
-          `config.set: "${key}" is not a known config key (${CONFIG_KEYS.join(', ')})`,
-        )
-      }
-      db.raw.run(
-        `INSERT INTO config (key, value, updated_at) VALUES (?, ?, ?)
-         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`,
-        [key, value, Date.now()],
-      )
-    },
-    remove(key) {
-      db.raw.run('DELETE FROM config WHERE key = ?', [key])
-    },
-    list() {
-      return db.raw
-        .query<RawRow, []>('SELECT * FROM config ORDER BY key ASC')
-        .all()
-        .map((r) => ({ key: r.key, value: r.value }))
-    },
-    getAll() {
-      const out: Record<string, string> = {}
-      for (const r of db.raw.query<RawRow, []>('SELECT * FROM config').all()) {
-        out[r.key] = r.value
-      }
-      return out
-    },
-  }
-}

package/apps/daemon/src/core/repos/groups.ts

@@ -1,55 +0,0 @@
-// Groups repo. The group `id` is the slug AND the directory name under
-// `~/.bazilion/groups/<slug>/`. There is no `path` column — callers
-// derive `paths.groupDir(id)` at read time. That makes the on-disk path
-// canonical: a real directory or a symlink, but always at the same slot.
-
-import type { Group } from '@bazilion/api-types'
-import type { BazilionDb } from '../db/client.ts'
-import type { Paths } from '../paths.ts'
-
-interface RawGroup {
-  id: string
-  name: string
-  user_md: string
-  created_at: number
-}
-
-function toGroup(r: RawGroup, paths: Paths): Group {
-  return {
-    id: r.id,
-    name: r.name,
-    path: paths.groupDir(r.id),
-    userMd: r.user_md,
-    createdAt: r.created_at,
-  }
-}
-
-export function insert(db: BazilionDb, g: { id: string; name: string }, paths: Paths): Group {
-  const now = Date.now()
-  db.raw.run("INSERT INTO groups (id, name, user_md, created_at) VALUES (?, ?, '', ?)", [
-    g.id,
-    g.name,
-    now,
-  ])
-  return { id: g.id, name: g.name, path: paths.groupDir(g.id), userMd: '', createdAt: now }
-}
-
-export function get(db: BazilionDb, id: string, paths: Paths): Group | null {
-  const row = db.raw.query<RawGroup, [string]>('SELECT * FROM groups WHERE id = ?').get(id)
-  return row ? toGroup(row, paths) : null
-}
-
-export function list(db: BazilionDb, paths: Paths): Group[] {
-  return db.raw
-    .query<RawGroup, []>('SELECT * FROM groups ORDER BY created_at ASC')
-    .all()
-    .map((r) => toGroup(r, paths))
-}
-
-export function remove(db: BazilionDb, id: string): void {
-  db.raw.run('DELETE FROM groups WHERE id = ?', [id])
-}
-
-export function setUserMd(db: BazilionDb, id: string, userMd: string): void {
-  db.raw.run('UPDATE groups SET user_md = ? WHERE id = ?', [userMd, id])
-}

package/apps/daemon/src/core/repos/messages.ts

@@ -1,127 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import type { Message } from '@bazilion/api-types'
-import type { BazilionDb } from '../db/client.ts'
-
-interface RawMessage {
-  id: string
-  from_agent_id: string
-  to_agent_id: string
-  reply_to: string | null
-  payload: string
-  created_at: number
-  read_at: number | null
-}
-
-function toMessage(r: RawMessage): Message {
-  return {
-    id: r.id,
-    fromAgentId: r.from_agent_id,
-    toAgentId: r.to_agent_id,
-    replyTo: r.reply_to,
-    payload: r.payload,
-    createdAt: r.created_at,
-    readAt: r.read_at,
-  }
-}
-
-export function send(
-  db: BazilionDb,
-  input: { from: string; to: string; payload: string; replyTo?: string | null },
-): Message {
-  const id = randomUUID()
-  const now = Date.now()
-  db.raw.run(
-    `INSERT INTO messages (id, from_agent_id, to_agent_id, reply_to, payload, created_at, read_at)
-     VALUES (?, ?, ?, ?, ?, ?, NULL)`,
-    [id, input.from, input.to, input.replyTo ?? null, input.payload, now],
-  )
-  return {
-    id,
-    fromAgentId: input.from,
-    toAgentId: input.to,
-    replyTo: input.replyTo ?? null,
-    payload: input.payload,
-    createdAt: now,
-    readAt: null,
-  }
-}
-
-export function get(db: BazilionDb, id: string): Message | null {
-  const row = db.raw.query<RawMessage, [string]>('SELECT * FROM messages WHERE id = ?').get(id)
-  return row ? toMessage(row) : null
-}
-
-export function listInbox(
-  db: BazilionDb,
-  agentId: string,
-  opts?: { unreadOnly?: boolean },
-): Message[] {
-  const sql = opts?.unreadOnly
-    ? 'SELECT * FROM messages WHERE to_agent_id = ? AND read_at IS NULL ORDER BY created_at ASC'
-    : 'SELECT * FROM messages WHERE to_agent_id = ? ORDER BY created_at ASC'
-  return db.raw.query<RawMessage, [string]>(sql).all(agentId).map(toMessage)
-}
-
-export function markRead(db: BazilionDb, id: string): void {
-  db.raw.run('UPDATE messages SET read_at = ? WHERE id = ? AND read_at IS NULL', [Date.now(), id])
-}
-
-/**
- * Find messages that are replies to a given message id, addressed to a specific agent.
- * Used by `wait_for_reply` to poll for incoming responses.
- */
-export function findReplies(db: BazilionDb, toAgentId: string, inReplyTo: string): Message[] {
-  return db.raw
-    .query<RawMessage, [string, string]>(
-      `SELECT * FROM messages
-       WHERE to_agent_id = ? AND reply_to = ?
-       ORDER BY created_at ASC`,
-    )
-    .all(toAgentId, inReplyTo)
-    .map(toMessage)
-}
-
-/**
- * Return the distinct `to_agent_id`s that currently have at least one unread
- * message, filtered to agents not in a terminal state (idle or starting).
- * Used by the scheduler's message-wake loop so a tick can fan-out auto-
- * delivery turns without walking every agent in the DB.
- */
-export function listRecipientsWithUnread(db: BazilionDb): string[] {
-  const rows = db.raw
-    .query<{ to_agent_id: string }, []>(
-      `SELECT DISTINCT m.to_agent_id FROM messages m
-       JOIN agents a ON a.id = m.to_agent_id
-       WHERE m.read_at IS NULL AND a.status = 'idle'
-       ORDER BY m.to_agent_id`,
-    )
-    .all()
-  return rows.map((r) => r.to_agent_id)
-}
-
-/**
- * Atomically fetch + mark-read all unread messages addressed to `agentId`.
- * Runs inside a transaction so two concurrent schedulers / manual deliveries
- * can't double-dispatch the same message. Returns the fetched messages in
- * ascending `created_at` order — callers format them into the recipient's
- * wake-up prompt.
- */
-export function drainUnreadForAgent(db: BazilionDb, agentId: string): Message[] {
-  return db.raw.transaction(() => {
-    const rows = db.raw
-      .query<RawMessage, [string]>(
-        `SELECT * FROM messages
-         WHERE to_agent_id = ? AND read_at IS NULL
-         ORDER BY created_at ASC`,
-      )
-      .all(agentId)
-    if (rows.length === 0) return []
-    const now = Date.now()
-    db.raw.run(
-      `UPDATE messages SET read_at = ?
-       WHERE to_agent_id = ? AND read_at IS NULL`,
-      [now, agentId],
-    )
-    return rows.map((r) => toMessage({ ...r, read_at: now }))
-  })()
-}