hive-am 1.0.0 → 1.2.0

package/server/dist/db/migrations.js

@@ -0,0 +1,199 @@
+const columns = (db, table) => db.prepare(`PRAGMA table_info(${table})`).all().map((c) => c.name);
+/** ALTER TABLE ... ADD COLUMN, skipped when the column is already there (`def` is the column name followed by its type). */
+export function addColumn(db, table, def) {
+    const name = def.split(/\s+/)[0];
+    if (columns(db, table).includes(name))
+        return false;
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${def}`);
+    return true;
+}
+export const MIGRATIONS = [
+    {
+        version: 1, name: 'baseline',
+        up(db) {
+            db.exec(`
+CREATE TABLE IF NOT EXISTS skills (
+  id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, description TEXT NOT NULL DEFAULT '',
+  content TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS agent_types (
+  id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, description TEXT NOT NULL DEFAULT '',
+  role TEXT NOT NULL, provider TEXT NOT NULL, model TEXT NOT NULL DEFAULT '',
+  system_prompt TEXT NOT NULL DEFAULT '', permission TEXT NOT NULL DEFAULT 'acceptEdits',
+  color TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS type_skills (
+  type_id TEXT NOT NULL REFERENCES agent_types(id) ON DELETE CASCADE,
+  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
+  PRIMARY KEY (type_id, skill_id)
+);
+CREATE TABLE IF NOT EXISTS agents (
+  id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, description TEXT NOT NULL DEFAULT '',
+  role TEXT NOT NULL, type_id TEXT REFERENCES agent_types(id) ON DELETE SET NULL,
+  provider TEXT NOT NULL, model TEXT NOT NULL DEFAULT '', system_prompt TEXT NOT NULL DEFAULT '',
+  permission TEXT NOT NULL DEFAULT 'acceptEdits', cwd TEXT NOT NULL,
+  session_id TEXT, status TEXT NOT NULL DEFAULT 'idle',
+  created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS agent_skills (
+  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
+  PRIMARY KEY (agent_id, skill_id)
+);
+CREATE TABLE IF NOT EXISTS assignments (
+  orchestrator_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  worker_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  PRIMARY KEY (orchestrator_id, worker_id)
+);
+CREATE TABLE IF NOT EXISTS colonies (
+  id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, color TEXT NOT NULL DEFAULT '', cwd TEXT NOT NULL DEFAULT '',
+  permission TEXT NOT NULL DEFAULT 'acceptEdits', system_prompt TEXT NOT NULL DEFAULT '',
+  inherit TEXT NOT NULL DEFAULT '{}', created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS colony_skills (
+  colony_id TEXT NOT NULL REFERENCES colonies(id) ON DELETE CASCADE,
+  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
+  PRIMARY KEY (colony_id, skill_id)
+);
+-- Pointer log of every native session an agent has ever used (for the Sessions view).
+CREATE TABLE IF NOT EXISTS agent_sessions (
+  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  provider TEXT NOT NULL, session_id TEXT NOT NULL, cwd TEXT NOT NULL,
+  first_seen INTEGER NOT NULL, last_seen INTEGER NOT NULL,
+  PRIMARY KEY (agent_id, session_id)
+);
+-- Dispatch log: who asked whom to do what. Results live in the worker's own session.
+CREATE TABLE IF NOT EXISTS dispatches (
+  id TEXT PRIMARY KEY, from_id TEXT NOT NULL, to_id TEXT NOT NULL, task TEXT NOT NULL,
+  status TEXT NOT NULL, result TEXT, created_at INTEGER NOT NULL, finished_at INTEGER
+);
+CREATE TABLE IF NOT EXISTS seeded_skills (slug TEXT PRIMARY KEY);
+
+-- Channels (Telegram...). Known threads: where to send a reply and when it was last active.
+CREATE TABLE IF NOT EXISTS connections (
+  id TEXT PRIMARY KEY, kind TEXT NOT NULL, name TEXT NOT NULL UNIQUE,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  config TEXT NOT NULL DEFAULT '{}', allowed TEXT NOT NULL DEFAULT '[]',
+  enabled INTEGER NOT NULL DEFAULT 1, created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS threads (
+  id TEXT PRIMARY KEY, connection_id TEXT NOT NULL REFERENCES connections(id) ON DELETE CASCADE,
+  external_key TEXT NOT NULL, title TEXT NOT NULL DEFAULT '', target TEXT NOT NULL, last_user TEXT,
+  created_at INTEGER NOT NULL, last_activity INTEGER NOT NULL,
+  UNIQUE (connection_id, external_key)
+);
+CREATE TABLE IF NOT EXISTS thread_messages (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+  direction TEXT NOT NULL, external_id TEXT NOT NULL, user_id TEXT, user_name TEXT,
+  text TEXT NOT NULL, ts INTEGER NOT NULL,
+  UNIQUE (thread_id, direction, external_id)
+);
+CREATE TABLE IF NOT EXISTS connection_cursor (
+  connection_id TEXT PRIMARY KEY REFERENCES connections(id) ON DELETE CASCADE, value TEXT NOT NULL
+);
+
+-- Wake-ups, schedules and process watches (what an agent asks hive-am to do later).
+DROP TABLE IF EXISTS wakeups;
+CREATE TABLE IF NOT EXISTS agent_wakeups (
+  id TEXT PRIMARY KEY, agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  connection_id TEXT, thread_id TEXT REFERENCES threads(id) ON DELETE CASCADE,
+  due_at INTEGER NOT NULL, note TEXT NOT NULL, created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS agent_schedules (
+  id TEXT PRIMARY KEY, agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  connection_id TEXT, thread_id TEXT REFERENCES threads(id) ON DELETE CASCADE,
+  kind TEXT NOT NULL, expr TEXT NOT NULL, tz TEXT NOT NULL, note TEXT NOT NULL,
+  enabled INTEGER NOT NULL DEFAULT 1, next_due INTEGER, created_at INTEGER NOT NULL,
+  last_fired_at INTEGER, fire_count INTEGER NOT NULL DEFAULT 0, last_status TEXT, last_detail TEXT
+);
+CREATE TABLE IF NOT EXISTS schedule_runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, schedule_id TEXT NOT NULL REFERENCES agent_schedules(id) ON DELETE CASCADE,
+  fired_at INTEGER NOT NULL, status TEXT NOT NULL, detail TEXT, duration_ms INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_schedule_runs ON schedule_runs (schedule_id, id);
+CREATE TABLE IF NOT EXISTS agent_watches (
+  id TEXT PRIMARY KEY, agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  connection_id TEXT, thread_id TEXT REFERENCES threads(id) ON DELETE CASCADE,
+  pid INTEGER NOT NULL, pid_stamp TEXT, file TEXT, log TEXT, note TEXT NOT NULL,
+  started_at INTEGER NOT NULL, deadline INTEGER NOT NULL, req_id TEXT, req_name TEXT
+);
+
+-- The agent's own notebook, and the resources of a colony.
+CREATE TABLE IF NOT EXISTS agent_notebooks (
+  agent_id TEXT PRIMARY KEY REFERENCES agents(id) ON DELETE CASCADE,
+  content TEXT NOT NULL DEFAULT '', version INTEGER NOT NULL DEFAULT 0, seen INTEGER NOT NULL DEFAULT 0,
+  updated_at INTEGER NOT NULL DEFAULT 0, updated_by TEXT NOT NULL DEFAULT ''
+);
+CREATE TABLE IF NOT EXISTS colony_objects (
+  id TEXT PRIMARY KEY, colony_id TEXT REFERENCES colonies(id) ON DELETE SET NULL,
+  kind TEXT NOT NULL, name TEXT NOT NULL UNIQUE COLLATE NOCASE, config TEXT NOT NULL,
+  created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+);
+-- The agent chosen to look after a resource (one per resource; the table keeps its first version's shape).
+CREATE TABLE IF NOT EXISTS object_agents (
+  object_id TEXT NOT NULL REFERENCES colony_objects(id) ON DELETE CASCADE,
+  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+  PRIMARY KEY (object_id, agent_id)
+);`);
+            // Columns added by later builds: databases created before them get them here.
+            addColumn(db, 'agents', 'colony_id TEXT REFERENCES colonies(id) ON DELETE SET NULL');
+            addColumn(db, 'agents', "overrides TEXT NOT NULL DEFAULT '[]'");
+            addColumn(db, 'agents', 'session_cwd TEXT');
+            addColumn(db, 'agents', 'instr_hash TEXT');
+            addColumn(db, 'agent_sessions', "kind TEXT NOT NULL DEFAULT 'direct'");
+            addColumn(db, 'agent_sessions', 'from_id TEXT');
+            addColumn(db, 'agent_sessions', 'task TEXT');
+            addColumn(db, 'dispatches', 'session_id TEXT');
+            addColumn(db, 'agent_wakeups', 'req_id TEXT');
+            addColumn(db, 'agent_wakeups', 'req_name TEXT');
+            addColumn(db, 'agent_schedules', 'req_id TEXT');
+            addColumn(db, 'agent_schedules', 'req_name TEXT');
+            addColumn(db, 'threads', 'muted INTEGER NOT NULL DEFAULT 0');
+            addColumn(db, 'threads', 'seen_id INTEGER NOT NULL DEFAULT 0');
+            addColumn(db, 'thread_messages', 'files TEXT');
+            // Skills briefly had a "default/personal" split; all skills are equal now.
+            for (const col of ['kind', 'slug']) {
+                if (columns(db, 'skills').includes(col)) {
+                    try {
+                        db.exec(`ALTER TABLE skills DROP COLUMN ${col}`);
+                    }
+                    catch { /* an old SQLite that cannot drop it: the column is harmless */ }
+                }
+            }
+            // How a skill reaches the agent: `always` puts all its text in the instructions; `on_demand` lists name + description and the agent reads the text with `skill_read`.
+            if (addColumn(db, 'skills', "load TEXT NOT NULL DEFAULT 'always'")) {
+                // The skills that came with hive-am are long, situational guides (the notebook one must always be in view).
+                db.exec("UPDATE skills SET load='on_demand' WHERE id LIKE 'default-%' AND id<>'default-notebook'");
+            }
+            // How each assignment loads the skill (Skill.load is only the suggestion offered when assigning).
+            for (const table of ['type_skills', 'colony_skills', 'agent_skills']) {
+                if (!addColumn(db, table, "load TEXT NOT NULL DEFAULT 'always'"))
+                    continue;
+                db.exec(`UPDATE ${table} SET load=COALESCE((SELECT load FROM skills WHERE skills.id=${table}.skill_id), 'always')`);
+            }
+        },
+    },
+    {
+        version: 2, name: 'renames',
+        up(db) {
+            // The first name of a cluster was `boss`.
+            db.exec("UPDATE colony_objects SET kind='cluster' WHERE kind='boss'");
+            // The section "Objects" became "Resources": the skill that came with hive-am follows, unless the person already renamed it.
+            db.exec("UPDATE skills SET name='Colony resources' WHERE id='default-objects' AND name='Colony objects' AND NOT EXISTS (SELECT 1 FROM skills WHERE lower(name)='colony resources')");
+        },
+    },
+];
+export const SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;
+/** Brings a database up to the current schema. Returns the versions it applied (empty when it was already current). */
+export function migrate(db, migrations = MIGRATIONS) {
+    const applied = [];
+    let current = db.pragma('user_version', { simple: true });
+    for (const m of migrations) {
+        if (m.version <= current)
+            continue;
+        db.transaction(() => { m.up(db); db.pragma(`user_version = ${m.version}`); })();
+        current = m.version;
+        applied.push(m.version);
+    }
+    return applied;
+}

package/server/dist/db.js

@@ -3,118 +3,28 @@ import { mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
+import { migrate } from './db/migrations.js';
+import { parseJson } from './db/json.js';
 export const DATA_DIR = process.env.HIVE_AM_HOME ?? join(homedir(), '.hive-am');
 mkdirSync(DATA_DIR, { recursive: true });
 export const db = new Database(join(DATA_DIR, 'hive-am.db'));
 db.pragma('journal_mode = WAL');
 db.pragma('foreign_keys = ON');
-db.exec(`
-CREATE TABLE IF NOT EXISTS skills (
-  id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, description TEXT NOT NULL DEFAULT '',
-  content TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
-);
-CREATE TABLE IF NOT EXISTS agent_types (
-  id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, description TEXT NOT NULL DEFAULT '',
-  role TEXT NOT NULL, provider TEXT NOT NULL, model TEXT NOT NULL DEFAULT '',
-  system_prompt TEXT NOT NULL DEFAULT '', permission TEXT NOT NULL DEFAULT 'acceptEdits',
-  color TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL
-);
-CREATE TABLE IF NOT EXISTS type_skills (
-  type_id TEXT NOT NULL REFERENCES agent_types(id) ON DELETE CASCADE,
-  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
-  PRIMARY KEY (type_id, skill_id)
-);
-CREATE TABLE IF NOT EXISTS agents (
-  id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, description TEXT NOT NULL DEFAULT '',
-  role TEXT NOT NULL, type_id TEXT REFERENCES agent_types(id) ON DELETE SET NULL,
-  provider TEXT NOT NULL, model TEXT NOT NULL DEFAULT '', system_prompt TEXT NOT NULL DEFAULT '',
-  permission TEXT NOT NULL DEFAULT 'acceptEdits', cwd TEXT NOT NULL,
-  session_id TEXT, status TEXT NOT NULL DEFAULT 'idle',
-  created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
-);
-CREATE TABLE IF NOT EXISTS agent_skills (
-  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
-  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
-  PRIMARY KEY (agent_id, skill_id)
-);
-CREATE TABLE IF NOT EXISTS assignments (
-  orchestrator_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
-  worker_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
-  PRIMARY KEY (orchestrator_id, worker_id)
-);
-CREATE TABLE IF NOT EXISTS colonies (
-  id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, color TEXT NOT NULL DEFAULT '', cwd TEXT NOT NULL DEFAULT '',
-  permission TEXT NOT NULL DEFAULT 'acceptEdits', system_prompt TEXT NOT NULL DEFAULT '',
-  inherit TEXT NOT NULL DEFAULT '{}', created_at INTEGER NOT NULL
-);
-CREATE TABLE IF NOT EXISTS colony_skills (
-  colony_id TEXT NOT NULL REFERENCES colonies(id) ON DELETE CASCADE,
-  skill_id TEXT NOT NULL REFERENCES skills(id) ON DELETE CASCADE,
-  PRIMARY KEY (colony_id, skill_id)
-);
--- Pointer log of every native session an agent has ever used (for the Sessions view).
-CREATE TABLE IF NOT EXISTS agent_sessions (
-  agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
-  provider TEXT NOT NULL, session_id TEXT NOT NULL, cwd TEXT NOT NULL,
-  first_seen INTEGER NOT NULL, last_seen INTEGER NOT NULL,
-  PRIMARY KEY (agent_id, session_id)
-);
--- Dispatch log: who asked whom to do what. Results live in the worker's own session.
-CREATE TABLE IF NOT EXISTS dispatches (
-  id TEXT PRIMARY KEY, from_id TEXT NOT NULL, to_id TEXT NOT NULL, task TEXT NOT NULL,
-  status TEXT NOT NULL, result TEXT, created_at INTEGER NOT NULL, finished_at INTEGER
-);
-`);
-// Lightweight migrations for databases created before colonies existed.
-const agentCols = db.prepare('PRAGMA table_info(agents)').all().map((c) => c.name);
-if (!agentCols.includes('colony_id'))
-    db.exec('ALTER TABLE agents ADD COLUMN colony_id TEXT REFERENCES colonies(id) ON DELETE SET NULL');
-if (!agentCols.includes('overrides'))
-    db.exec("ALTER TABLE agents ADD COLUMN overrides TEXT NOT NULL DEFAULT '[]'");
-if (!agentCols.includes('session_cwd'))
-    db.exec('ALTER TABLE agents ADD COLUMN session_cwd TEXT');
-if (!agentCols.includes('instr_hash'))
-    db.exec('ALTER TABLE agents ADD COLUMN instr_hash TEXT');
-// Skills briefly had a "default/personal" split; all skills are equal now.
-for (const col of ['kind', 'slug']) {
-    try {
-        db.exec(`ALTER TABLE skills DROP COLUMN ${col}`);
-    }
-    catch { /* already gone */ }
-}
-db.exec('CREATE TABLE IF NOT EXISTS seeded_skills (slug TEXT PRIMARY KEY)');
-// How a skill reaches the agent: `always` puts all its text in the instructions; `on_demand` lists name + description and the agent reads the text with `skill_read` when a task needs it.
-if (!db.prepare('PRAGMA table_info(skills)').all().some((c) => c.name === 'load')) {
-    db.exec("ALTER TABLE skills ADD COLUMN load TEXT NOT NULL DEFAULT 'always'");
-    // The skills that came with hive-am are long, situational guides (the notebook one must always be in view).
-    db.exec("UPDATE skills SET load='on_demand' WHERE id LIKE 'default-%' AND id<>'default-notebook'");
-}
-// How each assignment loads the skill (see Skill.load, which is only the suggestion offered when assigning).
-for (const [table] of [['type_skills'], ['colony_skills'], ['agent_skills']]) {
-    if (db.prepare(`PRAGMA table_info(${table})`).all().some((c) => c.name === 'load'))
-        continue;
-    db.exec(`ALTER TABLE ${table} ADD COLUMN load TEXT NOT NULL DEFAULT 'always'`);
-    db.exec(`UPDATE ${table} SET load=COALESCE((SELECT load FROM skills WHERE skills.id=${table}.skill_id), 'always')`);
-}
-const sessCols = db.prepare('PRAGMA table_info(agent_sessions)').all().map((c) => c.name);
-if (!sessCols.includes('kind'))
-    db.exec("ALTER TABLE agent_sessions ADD COLUMN kind TEXT NOT NULL DEFAULT 'direct'");
-if (!sessCols.includes('from_id'))
-    db.exec('ALTER TABLE agent_sessions ADD COLUMN from_id TEXT');
-if (!sessCols.includes('task'))
-    db.exec('ALTER TABLE agent_sessions ADD COLUMN task TEXT');
-const dispCols = db.prepare('PRAGMA table_info(dispatches)').all().map((c) => c.name);
-if (!dispCols.includes('session_id'))
-    db.exec('ALTER TABLE dispatches ADD COLUMN session_id TEXT');
+// Every table and column is created by the numbered migrations (db/migrations.ts); modules that own a table import `db` from here, so it is ready by then.
+migrate(db);
 const now = () => Date.now();
 const uid = () => randomUUID();
+// Statements are prepared once and reused (the SQL text is the key; the few dynamic ones only vary by table name).
+const prepared = new Map();
+const q = (sql) => { let st = prepared.get(sql); if (!st)
+    prepared.set(sql, (st = db.prepare(sql))); return st; };
 // ---- skills ----
 export const skills = {
-    list: () => db.prepare('SELECT * FROM skills ORDER BY name').all(),
-    get: (id) => db.prepare('SELECT * FROM skills WHERE id=?').get(id),
+    list: () => q('SELECT * FROM skills ORDER BY name').all(),
+    get: (id) => q('SELECT * FROM skills WHERE id=?').get(id),
     create(p) {
         const id = uid(), t = now();
-        db.prepare('INSERT INTO skills (id,name,description,content,created_at,updated_at,load) VALUES (?,?,?,?,?,?,?)').run(id, p.name, p.description ?? '', p.content ?? '', t, t, p.load ?? ((p.content ?? '').length > 2000 ? 'on_demand' : 'always'));
+        q('INSERT INTO skills (id,name,description,content,created_at,updated_at,load) VALUES (?,?,?,?,?,?,?)').run(id, p.name, p.description ?? '', p.content ?? '', t, t, p.load ?? ((p.content ?? '').length > 2000 ? 'on_demand' : 'always'));
         return skills.get(id);
     },
     update(id, p) {
@@ -122,36 +32,38 @@ export const skills = {
         if (!cur)
             return;
         const n = { ...cur, ...p };
-        db.prepare('UPDATE skills SET name=?, description=?, content=?, load=?, updated_at=? WHERE id=?').run(n.name, n.description, n.content, n.load, now(), id);
+        q('UPDATE skills SET name=?, description=?, content=?, load=?, updated_at=? WHERE id=?').run(n.name, n.description, n.content, n.load, now(), id);
         return skills.get(id);
     },
-    remove: (id) => db.prepare('DELETE FROM skills WHERE id=?').run(id).changes > 0,
+    remove: (id) => q('DELETE FROM skills WHERE id=?').run(id).changes > 0,
     /**
      * Adds the skills that come with hive-am, once each: they are ordinary skills afterwards (edit them, delete them). A
      * skill that was seeded before is never added back, and one the user already has under that name is left alone.
      */
     seedDefaults(defs) {
         const t = now();
-        for (const d of defs) {
-            const id = `default-${d.slug}`;
-            if (db.prepare('SELECT 1 FROM seeded_skills WHERE slug=?').get(d.slug))
-                continue;
-            db.prepare('INSERT OR IGNORE INTO seeded_skills (slug) VALUES (?)').run(d.slug);
-            if (db.prepare('SELECT 1 FROM skills WHERE id=?').get(id))
-                continue; // from an earlier build: keep it as it is
-            const taken = !!db.prepare('SELECT 1 FROM skills WHERE lower(name)=lower(?)').get(d.name);
-            db.prepare('INSERT INTO skills (id,name,description,content,created_at,updated_at,load) VALUES (?,?,?,?,?,?,?)').run(id, taken ? `${d.name} (hive-am)` : d.name, d.description, d.content, t, t, d.load ?? 'always');
-        }
+        db.transaction(() => {
+            for (const d of defs) {
+                const id = `default-${d.slug}`;
+                if (q('SELECT 1 FROM seeded_skills WHERE slug=?').get(d.slug))
+                    continue;
+                q('INSERT OR IGNORE INTO seeded_skills (slug) VALUES (?)').run(d.slug);
+                if (q('SELECT 1 FROM skills WHERE id=?').get(id))
+                    continue; // from an earlier build: keep it as it is
+                const taken = !!q('SELECT 1 FROM skills WHERE lower(name)=lower(?)').get(d.name);
+                q('INSERT INTO skills (id,name,description,content,created_at,updated_at,load) VALUES (?,?,?,?,?,?,?)').run(id, taken ? `${d.name} (hive-am)` : d.name, d.description, d.content, t, t, d.load ?? 'always');
+            }
+        })();
     },
     /** Agents/types using each skill, for the library view. */
     usage() {
         const out = {};
         for (const s of skills.list())
             out[s.id] = { agents: 0, types: 0 };
-        for (const r of db.prepare('SELECT skill_id, COUNT(*) c FROM agent_skills GROUP BY skill_id').all())
+        for (const r of q('SELECT skill_id, COUNT(*) c FROM agent_skills GROUP BY skill_id').all())
             if (out[r.skill_id])
                 out[r.skill_id].agents = r.c;
-        for (const r of db.prepare('SELECT skill_id, COUNT(*) c FROM type_skills GROUP BY skill_id').all())
+        for (const r of q('SELECT skill_id, COUNT(*) c FROM type_skills GROUP BY skill_id').all())
             if (out[r.skill_id])
                 out[r.skill_id].types = r.c;
         return out;
@@ -166,10 +78,11 @@ const JOINS = {
 /** How each skill assigned to this type/colony/agent is loaded. */
 function loadsOf(kind, id) {
     const j = JOINS[kind], out = {};
-    for (const r of db.prepare(`SELECT skill_id, load FROM ${j.table} WHERE ${j.owner}=?`).all(id))
+    for (const r of q(`SELECT skill_id, load FROM ${j.table} WHERE ${j.owner}=?`).all(id))
         out[r.skill_id] = r.load === 'on_demand' ? 'on_demand' : 'always';
     return out;
 }
+const skillIdsOf = (kind, id) => { const j = JOINS[kind]; return q(`SELECT skill_id FROM ${j.table} WHERE ${j.owner}=?`).all(id).map((x) => x.skill_id); };
 /**
  * Replaces the skills of a type/colony/agent. A skill keeps the way it was loaded before; a new one takes what the caller
  * says, or else the skill's own suggestion.
@@ -177,98 +90,87 @@ function loadsOf(kind, id) {
 function assignSkills(kind, id, ids, loads) {
     const j = JOINS[kind], prev = loadsOf(kind, id);
     db.transaction(() => {
-        db.prepare(`DELETE FROM ${j.table} WHERE ${j.owner}=?`).run(id);
+        q(`DELETE FROM ${j.table} WHERE ${j.owner}=?`).run(id);
         for (const s of ids) {
             const load = loads?.[s] ?? prev[s] ?? skills.get(s)?.load ?? 'always';
-            db.prepare(`INSERT OR IGNORE INTO ${j.table} (${j.owner}, skill_id, load) VALUES (?,?,?)`).run(id, s, load === 'on_demand' ? 'on_demand' : 'always');
+            q(`INSERT OR IGNORE INTO ${j.table} (${j.owner}, skill_id, load) VALUES (?,?,?)`).run(id, s, load === 'on_demand' ? 'on_demand' : 'always');
         }
     })();
 }
 // ---- agent types ----
-function typeRow(r) {
-    const skill_ids = db.prepare('SELECT skill_id FROM type_skills WHERE type_id=?').all(r.id).map((x) => x.skill_id);
-    return { ...r, skill_ids, skill_loads: loadsOf('type', r.id) };
+function typeOf(r) {
+    return { ...r, skill_ids: skillIdsOf('type', r.id), skill_loads: loadsOf('type', r.id) };
 }
 export const types = {
-    list: () => db.prepare('SELECT * FROM agent_types ORDER BY role DESC, name').all().map(typeRow),
-    get(id) { const r = db.prepare('SELECT * FROM agent_types WHERE id=?').get(id); return r ? typeRow(r) : undefined; },
-    create(p) {
+    list: () => q('SELECT * FROM agent_types ORDER BY role DESC, name').all().map(typeOf),
+    get(id) { const r = q('SELECT * FROM agent_types WHERE id=?').get(id); return r ? typeOf(r) : undefined; },
+    create: db.transaction((p) => {
         const id = uid();
-        db.prepare('INSERT INTO agent_types VALUES (?,?,?,?,?,?,?,?,?,?)').run(id, p.name, p.description ?? '', p.role, p.provider, p.model ?? '', p.system_prompt ?? '', (p.permission ?? 'acceptEdits'), p.color ?? '', now());
+        q('INSERT INTO agent_types (id,name,description,role,provider,model,system_prompt,permission,color,created_at) VALUES (?,?,?,?,?,?,?,?,?,?)').run(id, p.name, p.description ?? '', p.role, p.provider, p.model ?? '', p.system_prompt ?? '', (p.permission ?? 'acceptEdits'), p.color ?? '', now());
         types.setSkills(id, p.skill_ids ?? [], p.skill_loads);
         return types.get(id);
-    },
-    update(id, p) {
+    }),
+    update: db.transaction((id, p) => {
         const cur = types.get(id);
         if (!cur)
             return;
         const n = { ...cur, ...p };
-        db.prepare(`UPDATE agent_types SET name=?, description=?, role=?, provider=?, model=?, system_prompt=?, permission=?, color=? WHERE id=?`)
+        q('UPDATE agent_types SET name=?, description=?, role=?, provider=?, model=?, system_prompt=?, permission=?, color=? WHERE id=?')
             .run(n.name, n.description, n.role, n.provider, n.model, n.system_prompt, n.permission, n.color, id);
         if (p.skill_ids || p.skill_loads)
             types.setSkills(id, p.skill_ids ?? cur.skill_ids, p.skill_loads);
         return types.get(id);
-    },
+    }),
     setSkills: (id, ids, loads) => assignSkills('type', id, ids, loads),
-    remove: (id) => db.prepare('DELETE FROM agent_types WHERE id=?').run(id).changes > 0,
+    remove: (id) => q('DELETE FROM agent_types WHERE id=?').run(id).changes > 0,
 };
 // ---- colonies ----
 const DEFAULT_INHERIT = { cwd: true, permission: true, skills: true, prompt: true };
-function colonyRow(r) {
-    const skill_ids = db.prepare('SELECT skill_id FROM colony_skills WHERE colony_id=?').all(r.id).map((x) => x.skill_id);
-    const agent_ids = db.prepare('SELECT id FROM agents WHERE colony_id=? ORDER BY name').all(r.id).map((x) => x.id);
-    let inherit = DEFAULT_INHERIT;
-    try {
-        inherit = { ...DEFAULT_INHERIT, ...JSON.parse(r.inherit) };
-    }
-    catch { /* keep defaults */ }
-    return { ...r, inherit, skill_ids, skill_loads: loadsOf('colony', r.id), agent_ids };
+function colonyOf(r) {
+    const agent_ids = q('SELECT id FROM agents WHERE colony_id=? ORDER BY name').all(r.id).map((x) => x.id);
+    const inherit = { ...DEFAULT_INHERIT, ...parseJson(r.inherit, {}, `colony ${r.id} inherit`) };
+    return { ...r, inherit, skill_ids: skillIdsOf('colony', r.id), skill_loads: loadsOf('colony', r.id), agent_ids };
 }
 export const colonies = {
-    list: () => db.prepare('SELECT * FROM colonies ORDER BY name').all().map(colonyRow),
-    get(id) { const r = db.prepare('SELECT * FROM colonies WHERE id=?').get(id); return r ? colonyRow(r) : undefined; },
-    create(p) {
+    list: () => q('SELECT * FROM colonies ORDER BY name').all().map(colonyOf),
+    get(id) { const r = q('SELECT * FROM colonies WHERE id=?').get(id); return r ? colonyOf(r) : undefined; },
+    create: db.transaction((p) => {
         const id = uid();
-        db.prepare('INSERT INTO colonies VALUES (?,?,?,?,?,?,?,?)').run(id, p.name, p.color ?? '', p.cwd ?? '', (p.permission ?? 'acceptEdits'), p.system_prompt ?? '', JSON.stringify({ ...DEFAULT_INHERIT, ...(p.inherit ?? {}) }), now());
+        q('INSERT INTO colonies (id,name,color,cwd,permission,system_prompt,inherit,created_at) VALUES (?,?,?,?,?,?,?,?)').run(id, p.name, p.color ?? '', p.cwd ?? '', (p.permission ?? 'acceptEdits'), p.system_prompt ?? '', JSON.stringify({ ...DEFAULT_INHERIT, ...(p.inherit ?? {}) }), now());
         colonies.setSkills(id, p.skill_ids ?? [], p.skill_loads);
         if (p.agent_ids)
             colonies.setMembers(id, p.agent_ids);
         return colonies.get(id);
-    },
-    update(id, p) {
+    }),
+    update: db.transaction((id, p) => {
         const cur = colonies.get(id);
         if (!cur)
             return;
         const n = { ...cur, ...p, inherit: { ...cur.inherit, ...(p.inherit ?? {}) } };
-        db.prepare('UPDATE colonies SET name=?, color=?, cwd=?, permission=?, system_prompt=?, inherit=? WHERE id=?')
+        q('UPDATE colonies SET name=?, color=?, cwd=?, permission=?, system_prompt=?, inherit=? WHERE id=?')
             .run(n.name, n.color, n.cwd, n.permission, n.system_prompt, JSON.stringify(n.inherit), id);
         if (p.skill_ids || p.skill_loads)
             colonies.setSkills(id, p.skill_ids ?? cur.skill_ids, p.skill_loads);
         if (p.agent_ids)
             colonies.setMembers(id, p.agent_ids);
         return colonies.get(id);
-    },
+    }),
     setSkills: (id, ids, loads) => assignSkills('colony', id, ids, loads),
     /** Replaces membership; an agent belongs to at most one colony. */
-    setMembers(id, agentIds) {
-        db.transaction(() => {
-            db.prepare('UPDATE agents SET colony_id=NULL WHERE colony_id=?').run(id);
-            for (const a of agentIds)
-                db.prepare('UPDATE agents SET colony_id=? WHERE id=?').run(id, a);
-        })();
-    },
-    remove: (id) => db.prepare('DELETE FROM colonies WHERE id=?').run(id).changes > 0,
+    setMembers: db.transaction((id, agentIds) => {
+        q('UPDATE agents SET colony_id=NULL WHERE colony_id=?').run(id);
+        for (const a of agentIds)
+            q('UPDATE agents SET colony_id=? WHERE id=?').run(id, a);
+    }),
+    /** Members stay (their colony becomes none through the foreign key); the colony's own skill assignments go with it. */
+    remove: (id) => q('DELETE FROM colonies WHERE id=?').run(id).changes > 0,
 };
 // ---- agents ----
 const FIELDS = ['cwd', 'permission', 'skills', 'prompt'];
-function agentRow(r) {
-    const skill_ids = db.prepare('SELECT skill_id FROM agent_skills WHERE agent_id=?').all(r.id).map((x) => x.skill_id);
-    const worker_ids = db.prepare('SELECT worker_id FROM assignments WHERE orchestrator_id=?').all(r.id).map((x) => x.worker_id);
-    let overrides = [];
-    try {
-        overrides = JSON.parse(r.overrides ?? '[]').filter((f) => FIELDS.includes(f));
-    }
-    catch { /* none */ }
+function agentOf(r) {
+    const skill_ids = skillIdsOf('agent', r.id);
+    const worker_ids = q('SELECT worker_id FROM assignments WHERE orchestrator_id=?').all(r.id).map((x) => x.worker_id);
+    const overrides = parseJson(r.overrides, [], `agent ${r.id} overrides`).filter((f) => FIELDS.includes(f));
     const col = r.colony_id ? colonies.get(r.colony_id) : undefined;
     const follows = (f) => !!col && col.inherit[f] && !overrides.includes(f);
     const inherited = FIELDS.filter(follows);
@@ -289,69 +191,69 @@ export function resolved(a) {
     return { ...a, cwd: a.effective.cwd, permission: a.effective.permission, system_prompt: a.effective.system_prompt, skill_ids: a.effective.skill_ids, skill_loads: a.effective.skill_loads };
 }
 export const agents = {
-    list: () => db.prepare('SELECT * FROM agents ORDER BY role DESC, name').all().map(agentRow),
-    get(id) { const r = db.prepare('SELECT * FROM agents WHERE id=?').get(id); return r ? agentRow(r) : undefined; },
-    byName(name) { const r = db.prepare('SELECT * FROM agents WHERE lower(name)=lower(?)').get(name); return r ? agentRow(r) : undefined; },
-    create(p) {
+    list: () => q('SELECT * FROM agents ORDER BY role DESC, name').all().map(agentOf),
+    get(id) { const r = q('SELECT * FROM agents WHERE id=?').get(id); return r ? agentOf(r) : undefined; },
+    byName(name) { const r = q('SELECT * FROM agents WHERE lower(name)=lower(?)').get(name); return r ? agentOf(r) : undefined; },
+    /** The agent, its skills and its workers are written together: either all of it exists afterwards or none. */
+    create: db.transaction((p) => {
         const id = uid(), t = now();
-        db.prepare('INSERT INTO agents (id,name,description,role,type_id,provider,model,system_prompt,permission,cwd,session_id,status,created_at,updated_at,colony_id,overrides) VALUES (?,?,?,?,?,?,?,?,?,?,NULL,?,?,?,?,?)').run(id, p.name, p.description ?? '', p.role, p.type_id ?? null, p.provider, p.model ?? '', p.system_prompt ?? '', (p.permission ?? 'acceptEdits'), p.cwd ?? '', 'idle', t, t, p.colony_id ?? null, JSON.stringify(p.overrides ?? []));
+        q('INSERT INTO agents (id,name,description,role,type_id,provider,model,system_prompt,permission,cwd,session_id,status,created_at,updated_at,colony_id,overrides) VALUES (?,?,?,?,?,?,?,?,?,?,NULL,?,?,?,?,?)').run(id, p.name, p.description ?? '', p.role, p.type_id ?? null, p.provider, p.model ?? '', p.system_prompt ?? '', (p.permission ?? 'acceptEdits'), p.cwd ?? '', 'idle', t, t, p.colony_id ?? null, JSON.stringify(p.overrides ?? []));
         agents.setSkills(id, p.skill_ids ?? [], p.skill_loads);
         agents.setWorkers(id, p.worker_ids ?? []);
         return agents.get(id);
-    },
-    update(id, p) {
+    }),
+    update: db.transaction((id, p) => {
         const cur = agents.get(id);
         if (!cur)
             return;
         const n = { ...cur, ...p };
-        db.prepare(`UPDATE agents SET name=?, description=?, role=?, type_id=?, provider=?, model=?, system_prompt=?, permission=?, cwd=?, colony_id=?, overrides=?, updated_at=? WHERE id=?`)
+        q('UPDATE agents SET name=?, description=?, role=?, type_id=?, provider=?, model=?, system_prompt=?, permission=?, cwd=?, colony_id=?, overrides=?, updated_at=? WHERE id=?')
             .run(n.name, n.description, n.role, n.type_id, n.provider, n.model, n.system_prompt, n.permission, n.cwd, n.colony_id ?? null, JSON.stringify(n.overrides ?? []), now(), id);
         if (p.skill_ids || p.skill_loads)
             agents.setSkills(id, p.skill_ids ?? cur.skill_ids, p.skill_loads);
         if (p.worker_ids)
             agents.setWorkers(id, p.worker_ids);
         return agents.get(id);
-    },
-    setInstrHash: (id, hash) => db.prepare('UPDATE agents SET instr_hash=? WHERE id=?').run(hash, id),
-    setStatus: (id, status) => db.prepare('UPDATE agents SET status=?, updated_at=? WHERE id=?').run(status, now(), id),
-    setSession(a, sessionId) {
-        db.prepare('UPDATE agents SET session_id=?, session_cwd=?, instr_hash=NULL, updated_at=? WHERE id=?').run(sessionId, sessionId ? a.effective.cwd : null, now(), a.id);
+    }),
+    setInstrHash: (id, hash) => q('UPDATE agents SET instr_hash=? WHERE id=?').run(hash, id),
+    setStatus: (id, status) => q('UPDATE agents SET status=?, updated_at=? WHERE id=?').run(status, now(), id),
+    setSession: db.transaction((a, sessionId) => {
+        q('UPDATE agents SET session_id=?, session_cwd=?, instr_hash=NULL, updated_at=? WHERE id=?').run(sessionId, sessionId ? a.effective.cwd : null, now(), a.id);
         if (sessionId) {
-            db.prepare(`INSERT INTO agent_sessions (agent_id, provider, session_id, cwd, first_seen, last_seen) VALUES (?,?,?,?,?,?)
+            q(`INSERT INTO agent_sessions (agent_id, provider, session_id, cwd, first_seen, last_seen) VALUES (?,?,?,?,?,?)
         ON CONFLICT(agent_id, session_id) DO UPDATE SET last_seen=excluded.last_seen`)
                 .run(a.id, a.provider, sessionId, a.effective.cwd, now(), now());
         }
-    },
+    }),
     /** Logs a native session without making it the agent's current conversation (used for delegations). */
     recordSession(a, sessionId, kind, fromId, task) {
-        db.prepare(`INSERT INTO agent_sessions (agent_id, provider, session_id, cwd, first_seen, last_seen, kind, from_id, task) VALUES (?,?,?,?,?,?,?,?,?)
+        q(`INSERT INTO agent_sessions (agent_id, provider, session_id, cwd, first_seen, last_seen, kind, from_id, task) VALUES (?,?,?,?,?,?,?,?,?)
       ON CONFLICT(agent_id, session_id) DO UPDATE SET last_seen=excluded.last_seen`)
             .run(a.id, a.provider, sessionId, a.effective.cwd, now(), now(), kind, fromId ?? null, task ? task.slice(0, 500) : null);
     },
     setSkills: (id, ids, loads) => assignSkills('agent', id, ids, loads),
-    setWorkers(id, ids) {
-        db.transaction(() => {
-            db.prepare('DELETE FROM assignments WHERE orchestrator_id=?').run(id);
-            for (const w of ids)
-                if (w !== id)
-                    db.prepare('INSERT OR IGNORE INTO assignments VALUES (?,?)').run(id, w);
-        })();
-    },
-    remove: (id) => db.prepare('DELETE FROM agents WHERE id=?').run(id).changes > 0,
-    sessions: (id) => db.prepare('SELECT s.*, f.name from_name FROM agent_sessions s LEFT JOIN agents f ON f.id=s.from_id WHERE s.agent_id=? ORDER BY s.last_seen DESC').all(id),
-    allSessions: () => db.prepare(`SELECT s.*, a.name agent_name, a.role agent_role, f.name from_name FROM agent_sessions s JOIN agents a ON a.id=s.agent_id LEFT JOIN agents f ON f.id=s.from_id ORDER BY s.last_seen DESC`).all(),
+    /** Replaces the workers an orchestrator may dispatch to (never itself). */
+    setWorkers: db.transaction((id, ids) => {
+        q('DELETE FROM assignments WHERE orchestrator_id=?').run(id);
+        for (const w of ids)
+            if (w !== id)
+                q('INSERT OR IGNORE INTO assignments (orchestrator_id, worker_id) VALUES (?,?)').run(id, w);
+    }),
+    remove: (id) => q('DELETE FROM agents WHERE id=?').run(id).changes > 0,
+    sessions: (id) => q('SELECT s.*, f.name from_name FROM agent_sessions s LEFT JOIN agents f ON f.id=s.from_id WHERE s.agent_id=? ORDER BY s.last_seen DESC').all(id),
+    allSessions: () => q(`SELECT s.*, a.name agent_name, a.role agent_role, f.name from_name FROM agent_sessions s JOIN agents a ON a.id=s.agent_id LEFT JOIN agents f ON f.id=s.from_id ORDER BY s.last_seen DESC`).all(),
 };
 // ---- dispatch log ----
 export const dispatches = {
     start(from, to, task) {
         const id = uid();
-        db.prepare('INSERT INTO dispatches (id, from_id, to_id, task, status, result, created_at, finished_at) VALUES (?,?,?,?,?,NULL,?,NULL)').run(id, from, to, task, 'running', now());
+        q('INSERT INTO dispatches (id, from_id, to_id, task, status, result, created_at, finished_at) VALUES (?,?,?,?,?,NULL,?,NULL)').run(id, from, to, task, 'running', now());
         return id;
     },
-    setSession: (id, sessionId) => db.prepare('UPDATE dispatches SET session_id=? WHERE id=?').run(sessionId, id),
-    finish: (id, status, result) => db.prepare('UPDATE dispatches SET status=?, result=?, finished_at=? WHERE id=?').run(status, result.slice(0, 20000), now(), id),
-    recent: (limit = 50) => db.prepare('SELECT * FROM dispatches ORDER BY created_at DESC LIMIT ?').all(limit),
+    setSession: (id, sessionId) => q('UPDATE dispatches SET session_id=? WHERE id=?').run(sessionId, id),
+    finish: (id, status, result) => q('UPDATE dispatches SET status=?, result=?, finished_at=? WHERE id=?').run(status, result.slice(0, 20000), now(), id),
+    recent: (limit = 50) => q('SELECT * FROM dispatches ORDER BY created_at DESC LIMIT ?').all(limit),
 };
 // Agents left 'running' by a crash/blackout are simply idle again: their session is intact on disk.
-db.prepare("UPDATE agents SET status='idle' WHERE status='running'").run();
-db.prepare("UPDATE dispatches SET status='interrupted' WHERE status='running'").run();
+q("UPDATE agents SET status='idle' WHERE status='running'").run();
+q("UPDATE dispatches SET status='interrupted' WHERE status='running'").run();