hive-am 1.1.0 → 1.2.1

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();

package/server/dist/errors.js

@@ -0,0 +1,11 @@
+export class DomainError extends Error {
+    kind;
+    code;
+    constructor(message, kind = 'invalid', code) {
+        super(message);
+        this.kind = kind;
+        this.code = code;
+    }
+}
+/** The HTTP status a kind maps to. */
+export const STATUS_OF_KIND = { invalid: 400, forbidden: 403, not_found: 404, conflict: 409, unavailable: 503 };

package/server/dist/git/browse.js

@@ -0,0 +1,99 @@
+import { execFile } from 'node:child_process';
+import { filesFromDiffTree, repoOf, resolveRef, run } from './ops.js';
+import { gitEnv, imageType, PathError, safePath } from './repo.js';
+const MAX_REFS = 1000;
+export async function gitRefs(cwd) {
+    const { root } = await repoOf(cwd);
+    const [heads, tags] = await Promise.all([
+        run(root, ['for-each-ref', '--sort=-committerdate', `--count=${MAX_REFS}`, '--format=%(refname)%1f%(refname:short)%1f%(objectname)%1f%(committerdate:iso-strict)%1f%(contents:subject)%1f%(HEAD)', 'refs/heads', 'refs/remotes']),
+        // For an annotated tag %(*objectname) is its commit; for a lightweight one %(objectname) already is.
+        run(root, ['for-each-ref', '--sort=-creatordate', `--count=${MAX_REFS}`, '--format=%(refname:strip=2)%1f%(*objectname)%1f%(objectname)%1f%(creatordate:iso-strict)%1f%(contents:subject)', 'refs/tags']),
+    ]);
+    const res = { current: null, branches: [], remotes: [], tags: [] };
+    for (const line of heads.out.split('\n').filter(Boolean)) {
+        const [ref, name, sha, date, subject, head] = line.split('\x1f');
+        if (ref.startsWith('refs/heads/')) {
+            res.branches.push({ name, sha, date, subject });
+            if (head === '*')
+                res.current = name;
+        }
+        else if (!ref.endsWith('/HEAD'))
+            res.remotes.push({ name, sha, date, subject });
+    }
+    for (const line of tags.out.split('\n').filter(Boolean)) {
+        const [name, peeled, direct, date, subject] = line.split('\x1f');
+        res.tags.push({ name, sha: peeled || direct, date, subject });
+    }
+    return res;
+}
+const MAX_COMPARE_FILES = 500, MAX_COMPARE_COMMITS = 100;
+/** What changed going from `base` to `head`: the files, and the commits in between. */
+export async function gitCompare(cwd, base, head) {
+    const { root } = await repoOf(cwd);
+    const [b, h] = [await resolveRef(root, base), await resolveRef(root, head)];
+    const [names, nums, ahead, behind, log] = await Promise.all([
+        run(root, ['diff-tree', '-r', '-M', '--name-status', '-z', '--no-commit-id', b, h], { raw: true }),
+        run(root, ['diff-tree', '-r', '-M', '--histogram', '--numstat', '-z', '--no-commit-id', b, h], { raw: true }),
+        run(root, ['rev-list', '--count', `${b}..${h}`]),
+        run(root, ['rev-list', '--count', `${h}..${b}`]),
+        run(root, ['log', `--max-count=${MAX_COMPARE_COMMITS + 1}`, '--format=%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1e', `${b}..${h}`]),
+    ]);
+    const files = filesFromDiffTree(names.out, nums.out);
+    const commits = log.out.split('\x1e').map((r) => r.trim()).filter(Boolean).map((r) => { const [sha, short, author, date, subject] = r.split('\x1f'); return { sha, short, author, date, subject }; });
+    return {
+        base: { ref: base, sha: b }, head: { ref: head, sha: h }, ahead: Number(ahead.out) || 0, behind: Number(behind.out) || 0,
+        commits: commits.slice(0, MAX_COMPARE_COMMITS), commitsTruncated: commits.length > MAX_COMPARE_COMMITS,
+        files: files.slice(0, MAX_COMPARE_FILES), truncated: files.length > MAX_COMPARE_FILES,
+    };
+}
+export async function gitCompareDiff(cwd, base, head, rel, oldRel) {
+    const { root } = await repoOf(cwd);
+    const [b, h] = [await resolveRef(root, base), await resolveRef(root, head)];
+    await safePath(cwd, root, rel, false);
+    if (oldRel)
+        await safePath(cwd, root, oldRel, false);
+    const { out } = await run(root, ['diff', '--histogram', '--no-color', '--no-ext-diff', '-M', '-U3', b, h, '--', ...(oldRel ? [oldRel, rel] : [rel])]);
+    const MAX = 600_000;
+    return { path: rel, diff: out.length > MAX ? out.slice(0, MAX) : out, truncated: out.length > MAX, binary: /^Binary files .* differ$/m.test(out) || /^GIT binary patch/m.test(out) };
+}
+const MAX_HITS = 300;
+/** Lines of the working files (tracked and new, never ignored ones) that contain `q`. */
+export async function gitGrep(cwd, q, caseSensitive = false) {
+    const { root, scope } = await repoOf(cwd);
+    const text = q.trim().slice(0, 200);
+    if (text.length < 2)
+        return { hits: [], truncated: false };
+    const { out } = await run(root, ['grep', '-n', '-I', '--null', '--fixed-strings', '--no-color', '--untracked', '--exclude-standard', ...(caseSensitive ? [] : ['-i']), '-e', text, '--', scope || '.'], { okCodes: [1], raw: true });
+    const hits = [];
+    let truncated = false;
+    for (const l of out.split('\n')) {
+        if (!l)
+            continue;
+        if (hits.length >= MAX_HITS) {
+            truncated = true;
+            break;
+        }
+        // With --null both the file name and the line number are followed by a NUL: `path NUL line NUL text`.
+        const [path, line, ...text] = l.split('\0');
+        if (!path || text.length === 0)
+            continue;
+        hits.push({ path, line: Number(line) || 0, text: text.join('\0').slice(0, 300) });
+    }
+    return { hits, truncated };
+}
+/* ------------------------------------------------------------------ pictures at a version */
+const MAX_IMAGE = 20 * 1024 * 1024;
+/** The bytes of a picture as it was at a commit, served only as an inert image (see the route). */
+export async function gitImageAt(cwd, ref, rel) {
+    const { root } = await repoOf(cwd);
+    const type = imageType(rel);
+    if (!type)
+        throw new PathError('Not an image');
+    const sha = await resolveRef(root, ref);
+    if (!rel || rel.includes('\0') || rel.startsWith('/') || rel.split('/').includes('..'))
+        throw new PathError('Invalid path');
+    const bytes = await new Promise((resolve, reject) => {
+        execFile('git', ['cat-file', 'blob', `${sha}:${rel}`], { cwd: root, encoding: 'buffer', maxBuffer: MAX_IMAGE, env: gitEnv(), timeout: 30_000 }, (err, stdout) => (err ? reject(new PathError('Picture not found at that version')) : resolve(stdout)));
+    });
+    return { bytes, type };
+}