hive-am 1.1.0 → 1.2.0

package/server/dist/objects/store.js

@@ -0,0 +1,115 @@
+import { randomUUID } from 'node:crypto';
+import { colonies, db } from '../db.js';
+import { parseJson } from '../db/json.js';
+import { ObjectError, kindOf, parseConfig, parseName, isKind } from './model.js';
+// The tables (colony_objects, object_agents) are created by db/migrations.ts.
+/** The secret values of an HTTP object stay on the server: what the interface receives has them empty (and `set` says there is one). */
+export function maskConfig(o) {
+    if (o.kind === 'database') {
+        const { password, ...rest } = o.config;
+        return { ...o, config: { ...rest, password: '', passwordSet: !!password } };
+    }
+    if (o.kind !== 'http')
+        return o;
+    const c = o.config;
+    if (!c.variables)
+        return o;
+    const variables = Object.fromEntries(Object.entries(c.variables).map(([env, vars]) => [env, Object.fromEntries(Object.entries(vars).map(([k, v]) => [k, v.secret ? { value: '', secret: true, set: v.value !== '' } : v]))]));
+    return { ...o, config: { ...c, variables } };
+}
+/** Saving a secret that was left empty keeps the value that was already stored. */
+function keepSecrets(old, incoming) {
+    for (const [env, vars] of Object.entries((incoming?.variables ?? {}))) {
+        for (const [k, v] of Object.entries(vars ?? {}))
+            if (v?.secret && !v.value && old?.variables?.[env]?.[k]?.secret)
+                v.value = old.variables[env][k].value;
+    }
+}
+/** A database saved with the password left empty keeps the one it had (unless the engine changed: then it was for another server). */
+function keepPassword(old, incoming) {
+    if ((incoming.password === undefined || incoming.password === '') && old.password && incoming.engine === old.engine)
+        incoming.password = old.password;
+}
+// A damaged config must not take the whole list down: it reads as empty (a cluster as one without members) until the person saves it again.
+const row = (r) => ({ ...r, config: parseJson(r.config, r.kind === 'cluster' ? { members: [] } : {}, `resource ${r.id} config`) });
+/** A cluster groups servers and containers of its own colony; nothing else, and not itself. */
+function checkMembers(kind, colony, config, selfId) {
+    if (kind !== 'cluster')
+        return;
+    for (const id of config.members) {
+        const m = objectsStore.get(id);
+        if (!m || m.id === selfId)
+            throw new ObjectError('One of the resources it groups does not exist');
+        if (m.kind !== 'server' && m.kind !== 'docker')
+            throw new ObjectError(`"${m.name}" cannot be grouped: only servers and Docker containers can`);
+        if ((m.colony_id ?? null) !== (colony ?? null))
+            throw new ObjectError(`"${m.name}" is not in the same colony as the cluster`);
+    }
+}
+export const objectsStore = {
+    list: () => db.prepare('SELECT * FROM colony_objects ORDER BY name').all().map(row),
+    get(id) { const r = db.prepare('SELECT * FROM colony_objects WHERE id=?').get(id); return r ? row(r) : undefined; },
+    byName(name) { const r = db.prepare('SELECT * FROM colony_objects WHERE name=?').get(name); return r ? row(r) : undefined; },
+    create(input) {
+        const p = { ...input, kind: kindOf(input.kind) };
+        if (!isKind(p.kind))
+            throw new ObjectError('Unknown kind of resource');
+        const name = parseName(p.name), config = parseConfig(p.kind, p.config);
+        if (objectsStore.byName(name))
+            throw new ObjectError(`There is already a resource named "${name}"`);
+        const colony = p.colony_id ? String(p.colony_id) : null;
+        if (colony && !colonies.get(colony))
+            throw new ObjectError('That colony no longer exists');
+        checkMembers(p.kind, colony, config);
+        const id = randomUUID(), now = Date.now();
+        db.prepare('INSERT INTO colony_objects (id,colony_id,kind,name,config,created_at,updated_at) VALUES (?,?,?,?,?,?,?)').run(id, colony, p.kind, name, JSON.stringify(config), now, now);
+        return objectsStore.get(id);
+    },
+    update(id, p) {
+        const cur = objectsStore.get(id);
+        if (!cur)
+            throw new ObjectError('Resource not found');
+        const name = p.name !== undefined ? parseName(p.name) : cur.name;
+        const other = objectsStore.byName(name);
+        if (other && other.id !== id)
+            throw new ObjectError(`There is already a resource named "${name}"`);
+        if (cur.kind === 'http' && p.config)
+            keepSecrets(cur.config, p.config);
+        if (cur.kind === 'database' && p.config)
+            keepPassword(cur.config, p.config);
+        const config = p.config !== undefined ? parseConfig(cur.kind, p.config) : cur.config;
+        const colony = p.colony_id === undefined ? cur.colony_id : p.colony_id ? String(p.colony_id) : null;
+        if (colony && !colonies.get(colony))
+            throw new ObjectError('That colony no longer exists');
+        checkMembers(cur.kind, colony, config, id);
+        // Moving an object to another colony takes it out of the clusters it was grouped by.
+        db.transaction(() => {
+            if (colony !== cur.colony_id)
+                objectsStore.ungroup(id);
+            db.prepare('UPDATE colony_objects SET name=?, colony_id=?, config=?, updated_at=? WHERE id=?').run(name, colony, JSON.stringify(config), Date.now(), id);
+        })();
+        return objectsStore.get(id);
+    },
+    /** The agent chosen to look after each object (object id → agent id). */
+    managers() {
+        const m = new Map();
+        for (const r of db.prepare('SELECT object_id, agent_id FROM object_agents').all())
+            if (!m.has(r.object_id))
+                m.set(r.object_id, r.agent_id);
+        return m;
+    },
+    setManager(id, agentId) {
+        db.transaction(() => {
+            db.prepare('DELETE FROM object_agents WHERE object_id=?').run(id);
+            if (agentId)
+                db.prepare('INSERT INTO object_agents (object_id, agent_id) VALUES (?,?)').run(id, agentId);
+        })();
+    },
+    /** Takes an object out of every cluster that groups it. */
+    ungroup(id) {
+        for (const b of objectsStore.list().filter((x) => x.kind === 'cluster' && x.config.members.includes(id))) {
+            db.prepare('UPDATE colony_objects SET config=?, updated_at=? WHERE id=?').run(JSON.stringify({ members: b.config.members.filter((m) => m !== id) }), Date.now(), b.id);
+        }
+    },
+    remove(id) { return db.transaction(() => { objectsStore.ungroup(id); return db.prepare('DELETE FROM colony_objects WHERE id=?').run(id).changes > 0; })(); },
+};

package/server/dist/objects/supervisor.js

@@ -0,0 +1,111 @@
+import { spawn } from 'node:child_process';
+import { connect } from 'node:net';
+import { noteServer, readSaved, rotateLog } from './runner.js';
+/**
+ * What keeps a server object in good shape without anyone looking: it restarts it when it ends by itself (never, after a failure, or
+ * always) with a longer wait each time and a limit, it asks a health check whether a running server is really working (and can restart it
+ * when it is not), and it keeps its log from growing. Stopping it yourself is never undone: a stopped server stays stopped.
+ */
+const BASE_MS = () => Number(process.env.HIVE_AM_OBJECT_BACKOFF_MS) || 1000;
+const WINDOW_MS = () => Number(process.env.HIVE_AM_OBJECT_RESTART_WINDOW_MS) || 600_000;
+const MAX_WAIT_MS = 30_000;
+const all = new Map();
+const get = (id) => { let s = all.get(id); if (!s)
+    all.set(id, s = { restarts: [], pendingExit: 0, nextAt: 0, gaveUp: false, fails: 0, lastCheck: 0, detail: '', startedAt: 0 }); return s; };
+/** A person started or stopped it: the automatic restarts begin again from nothing. */
+export const resetSupervision = (id) => { all.delete(id); };
+export const forgetSupervision = resetSupervision;
+async function check(cfg, h) {
+    const timeout = (h.timeoutSec ?? 5) * 1000;
+    try {
+        if (h.kind === 'http') {
+            const r = await fetch(h.target, { signal: AbortSignal.timeout(timeout), redirect: 'manual' });
+            return r.status >= 200 && r.status < 400 ? { ok: true, detail: '' } : { ok: false, detail: `${h.target} answered ${r.status}` };
+        }
+        if (h.kind === 'tcp') {
+            const [host, p] = h.target.includes(':') ? [h.target.split(':')[0], Number(h.target.split(':').pop())] : ['127.0.0.1', Number(h.target)];
+            const up = await new Promise((resolve) => { const s = connect({ host, port: p }, () => { s.destroy(); resolve(true); }); s.setTimeout(timeout, () => { s.destroy(); resolve(false); }); s.on('error', () => resolve(false)); });
+            return up ? { ok: true, detail: '' } : { ok: false, detail: `nothing answers on ${h.target}` };
+        }
+        return await new Promise((resolve) => {
+            const c = spawn('sh', ['-c', h.target], { cwd: cfg.cwd, env: { ...process.env, ...cfg.env }, stdio: 'ignore' });
+            const t = setTimeout(() => { try {
+                c.kill('SIGKILL');
+            }
+            catch { /* gone */ } resolve({ ok: false, detail: `the check took more than ${timeout / 1000} s` }); }, timeout);
+            c.on('exit', (code) => { clearTimeout(t); resolve(code === 0 ? { ok: true, detail: '' } : { ok: false, detail: `the check exited with ${code}` }); });
+            c.on('error', () => { clearTimeout(t); resolve({ ok: false, detail: 'the check could not run' }); });
+        });
+    }
+    catch (e) {
+        return { ok: false, detail: `${h.target}: ${e.name === 'TimeoutError' ? 'no answer in time' : e.message}` };
+    }
+}
+/** Takes the state of a server (alive or not) and returns what it really is, doing what the configuration asks. */
+export async function supervise(o, cfg, state, act) {
+    rotateLog(o.id, cfg);
+    const S = get(o.id), now = Date.now(), saved = readSaved(o.id);
+    const max = cfg.maxRestarts ?? 5;
+    S.restarts = S.restarts.filter((t) => now - t < WINDOW_MS());
+    const budget = () => S.restarts.length < max;
+    const wait = () => Math.min(MAX_WAIT_MS, BASE_MS() * 2 ** S.restarts.length);
+    // Running: is it working?
+    if ((state.status === 'running') && cfg.health) {
+        if (S.startedAt !== saved?.startedAt) {
+            S.startedAt = saved?.startedAt ?? 0;
+            S.fails = 0;
+            S.lastCheck = 0;
+        }
+        if (now - S.lastCheck >= (cfg.health.intervalSec ?? 15) * 1000) {
+            S.lastCheck = now;
+            const r = await check(cfg, cfg.health);
+            if (r.ok) {
+                S.fails = 0;
+                S.detail = '';
+            }
+            else {
+                S.fails++;
+                S.detail = r.detail;
+            }
+        }
+        if (S.fails >= (cfg.health.retries ?? 3)) {
+            if (cfg.health.restartWhenUnhealthy && budget()) {
+                S.restarts.push(now);
+                S.fails = 0;
+                S.lastCheck = now;
+                noteServer(o.id, `unhealthy (${S.detail}): restarting (${S.restarts.length}/${max})`);
+                await act.restart().catch(() => undefined);
+                return { status: 'starting', detail: `was unhealthy: restarting (${S.restarts.length}/${max})` };
+            }
+            return { status: 'error', pid: state.pid, since: state.since, detail: `unhealthy: ${S.detail}${cfg.health.restartWhenUnhealthy ? ` (gave up after ${max} restarts)` : ''}` };
+        }
+        return state;
+    }
+    if (state.status === 'running' || state.status === 'starting')
+        return state;
+    // Not running. It ended by itself, and the person did not stop it?
+    const policy = cfg.restart ?? 'no';
+    const ended = saved && !saved.stopped && saved.exit;
+    if (!ended || policy === 'no')
+        return state;
+    const failed = ended.code !== 0 || !!ended.signal;
+    if (!(policy === 'always' || failed))
+        return state;
+    if (S.gaveUp)
+        return { ...state, detail: `${state.detail ?? 'ended'} · gave up after ${max} restarts` };
+    if (S.pendingExit !== ended.at) {
+        S.pendingExit = ended.at;
+        S.nextAt = now + wait();
+    }
+    if (!budget()) {
+        S.gaveUp = true;
+        noteServer(o.id, `gave up: it ended ${max} times in ${Math.round(WINDOW_MS() / 60000)} minutes`);
+        return { ...state, detail: `${state.detail ?? 'ended'} · gave up after ${max} restarts` };
+    }
+    if (now < S.nextAt)
+        return { ...state, detail: `${state.detail ?? 'ended'} · restarting in ${Math.ceil((S.nextAt - now) / 1000)} s (${S.restarts.length + 1}/${max})` };
+    S.restarts.push(now);
+    noteServer(o.id, `ended by itself: restarting (${S.restarts.length}/${max})`);
+    await act.start().catch((e) => noteServer(o.id, `could not restart: ${e instanceof Error ? e.message : e}`));
+    return { status: 'starting', detail: `restarted (${S.restarts.length}/${max})` };
+}

package/server/dist/objects/templates.js

@@ -0,0 +1,67 @@
+import { randomBytes } from 'node:crypto';
+import { ObjectError } from './model.js';
+const q = (v) => JSON.stringify(v);
+const version = (def) => ({ key: 'version', label: 'Version (image tag)', kind: 'text', default: def });
+const port = (key, label, def) => ({ key, label, kind: 'port', default: def });
+const text = (key, label, def) => ({ key, label, kind: 'text', default: def });
+const secret = (key, label) => ({ key, label, kind: 'secret', default: '' });
+export const TEMPLATES = [
+    { id: 'redis', name: 'Redis', description: 'In-memory cache and queue', fields: [version('7-alpine'), port('port', 'Port on this machine', '6379')],
+        compose: (v) => `services:\n  redis:\n    image: redis:${v.version}\n    ports: [${q(`${v.port}:6379`)}]\n    volumes: [redis-data:/data]\n    restart: unless-stopped\nvolumes:\n  redis-data:\n` },
+    { id: 'valkey', name: 'Valkey', description: 'Open-source Redis-compatible store', fields: [version('8-alpine'), port('port', 'Port on this machine', '6379')],
+        compose: (v) => `services:\n  valkey:\n    image: valkey/valkey:${v.version}\n    ports: [${q(`${v.port}:6379`)}]\n    volumes: [valkey-data:/data]\n    restart: unless-stopped\nvolumes:\n  valkey-data:\n` },
+    { id: 'postgres', name: 'PostgreSQL', description: 'Relational database', fields: [version('16-alpine'), port('port', 'Port on this machine', '5432'), text('user', 'User', 'app'), secret('password', 'Password'), text('database', 'Database', 'app')],
+        compose: (v) => `services:\n  postgres:\n    image: postgres:${v.version}\n    environment:\n      POSTGRES_USER: ${q(v.user)}\n      POSTGRES_PASSWORD: ${q(v.password)}\n      POSTGRES_DB: ${q(v.database)}\n    ports: [${q(`${v.port}:5432`)}]\n    volumes: [pg-data:/var/lib/postgresql/data]\n    healthcheck:\n      test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER"]\n      interval: 10s\n      retries: 5\n    restart: unless-stopped\nvolumes:\n  pg-data:\n` },
+    { id: 'mariadb', name: 'MariaDB', description: 'MySQL-compatible database', fields: [version('11'), port('port', 'Port on this machine', '3306'), secret('password', 'Root password'), text('database', 'Database', 'app')],
+        compose: (v) => `services:\n  mariadb:\n    image: mariadb:${v.version}\n    environment:\n      MARIADB_ROOT_PASSWORD: ${q(v.password)}\n      MARIADB_DATABASE: ${q(v.database)}\n    ports: [${q(`${v.port}:3306`)}]\n    volumes: [maria-data:/var/lib/mysql]\n    restart: unless-stopped\nvolumes:\n  maria-data:\n` },
+    { id: 'mysql', name: 'MySQL', description: 'Relational database', fields: [version('8'), port('port', 'Port on this machine', '3306'), secret('password', 'Root password'), text('database', 'Database', 'app')],
+        compose: (v) => `services:\n  mysql:\n    image: mysql:${v.version}\n    environment:\n      MYSQL_ROOT_PASSWORD: ${q(v.password)}\n      MYSQL_DATABASE: ${q(v.database)}\n    ports: [${q(`${v.port}:3306`)}]\n    volumes: [mysql-data:/var/lib/mysql]\n    restart: unless-stopped\nvolumes:\n  mysql-data:\n` },
+    { id: 'mongodb', name: 'MongoDB', description: 'Document database', fields: [version('7'), port('port', 'Port on this machine', '27017'), text('user', 'User', 'app'), secret('password', 'Password')],
+        compose: (v) => `services:\n  mongo:\n    image: mongo:${v.version}\n    environment:\n      MONGO_INITDB_ROOT_USERNAME: ${q(v.user)}\n      MONGO_INITDB_ROOT_PASSWORD: ${q(v.password)}\n    ports: [${q(`${v.port}:27017`)}]\n    volumes: [mongo-data:/data/db]\n    restart: unless-stopped\nvolumes:\n  mongo-data:\n` },
+    { id: 'rabbitmq', name: 'RabbitMQ', description: 'Message broker with its web panel', fields: [version('3-management'), port('port', 'AMQP port', '5672'), port('webPort', 'Web panel port', '15672'), text('user', 'User', 'app'), secret('password', 'Password')],
+        compose: (v) => `services:\n  rabbitmq:\n    image: rabbitmq:${v.version}\n    environment:\n      RABBITMQ_DEFAULT_USER: ${q(v.user)}\n      RABBITMQ_DEFAULT_PASS: ${q(v.password)}\n    ports: [${q(`${v.port}:5672`)}, ${q(`${v.webPort}:15672`)}]\n    volumes: [rabbit-data:/var/lib/rabbitmq]\n    restart: unless-stopped\nvolumes:\n  rabbit-data:\n` },
+    { id: 'minio', name: 'MinIO', description: 'S3-compatible object storage', fields: [version('latest'), port('port', 'API port', '9000'), port('webPort', 'Console port', '9001'), text('user', 'User', 'minio'), secret('password', 'Password')],
+        compose: (v) => `services:\n  minio:\n    image: minio/minio:${v.version}\n    command: server /data --console-address ":9001"\n    environment:\n      MINIO_ROOT_USER: ${q(v.user)}\n      MINIO_ROOT_PASSWORD: ${q(v.password)}\n    ports: [${q(`${v.port}:9000`)}, ${q(`${v.webPort}:9001`)}]\n    volumes: [minio-data:/data]\n    restart: unless-stopped\nvolumes:\n  minio-data:\n` },
+    { id: 'nginx', name: 'Nginx', description: 'Web server', fields: [version('alpine'), port('port', 'Port on this machine', '8080')],
+        compose: (v) => `services:\n  nginx:\n    image: nginx:${v.version}\n    ports: [${q(`${v.port}:80`)}]\n    restart: unless-stopped\n` },
+    { id: 'mailpit', name: 'Mailpit', description: 'Catches the emails your app sends, with a web inbox', fields: [version('latest'), port('webPort', 'Inbox port', '8025'), port('port', 'SMTP port', '1025')],
+        compose: (v) => `services:\n  mailpit:\n    image: axllent/mailpit:${v.version}\n    ports: [${q(`${v.webPort}:8025`)}, ${q(`${v.port}:1025`)}]\n    restart: unless-stopped\n` },
+    { id: 'adminer', name: 'Adminer', description: 'Web panel for databases', fields: [version('latest'), port('port', 'Port on this machine', '8081')],
+        compose: (v) => `services:\n  adminer:\n    image: adminer:${v.version}\n    ports: [${q(`${v.port}:8080`)}]\n    restart: unless-stopped\n` },
+];
+/** The catalog for the interface; each password starts with a random value. */
+export const listTemplates = () => TEMPLATES.map(({ compose: _c, ...t }) => ({ ...t, fields: t.fields.map((f) => (f.kind === 'secret' ? { ...f, default: randomBytes(9).toString('base64url') } : f)) }));
+/** Checks the values for a template (missing ones take the default) and returns the compose file. */
+export function renderTemplate(id, given) {
+    const t = TEMPLATES.find((x) => x.id === id);
+    if (!t)
+        throw new ObjectError('Unknown template');
+    const v = {};
+    for (const f of t.fields) {
+        const raw = String(given[f.key] ?? '').trim() || f.default;
+        if (!raw)
+            throw new ObjectError(`${f.label} is required`);
+        if (f.kind === 'port') {
+            const n = Number(raw);
+            if (!Number.isInteger(n) || n < 1 || n > 65535)
+                throw new ObjectError(`${f.label} must be a port between 1 and 65535`);
+            v[f.key] = String(n);
+        }
+        else if (f.key === 'version') {
+            if (!/^[\w][\w.-]{0,60}$/.test(raw))
+                throw new ObjectError('The version is not a valid image tag');
+            v[f.key] = raw;
+        }
+        else if (f.kind === 'secret') {
+            if (!/^[\w.@%+=-]{1,64}$/.test(raw))
+                throw new ObjectError(`${f.label}: use letters, numbers and . @ % + = - _ (up to 64)`);
+            v[f.key] = raw;
+        }
+        else {
+            if (!/^[\w.@-]{1,64}$/.test(raw))
+                throw new ObjectError(`${f.label}: use letters, numbers and . @ - _ (up to 64)`);
+            v[f.key] = raw;
+        }
+    }
+    return t.compose(v);
+}

package/server/dist/providers/claude.js

@@ -1,6 +1,6 @@
 import { writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { spawnLines, safeJson } from './spawn.js';
+import { flattenText, spawnJson } from './spawn.js';
 import { DATA_DIR } from '../db.js';
 import { dispatchMcpConfig } from '../mcp-config.js';
 import { existsSync } from 'node:fs';
@@ -38,10 +38,7 @@ export async function* runClaude(o) {
     const toolNames = new Map();
     let streamedText = false;
     let sawSession = false;
-    for await (const line of spawnLines({ cmd: 'claude', args, cwd: agent.cwd, stdin: prompt, signal: o.signal })) {
-        const ev = safeJson(line);
-        if (!ev)
-            continue;
+    for await (const ev of spawnJson({ cmd: 'claude', args, cwd: agent.cwd, stdin: prompt, signal: o.signal })) {
         if (ev.session_id && !sawSession) {
             sawSession = true;
             yield { t: 'session', sessionId: ev.session_id };
@@ -73,7 +70,7 @@ export async function* runClaude(o) {
             if (Array.isArray(content))
                 for (const b of content) {
                     if (b.type === 'tool_result')
-                        yield { t: 'tool_result', id: b.tool_use_id, output: flatten(b.content), error: !!b.is_error };
+                        yield { t: 'tool_result', id: b.tool_use_id, output: flattenText(b.content), error: !!b.is_error };
                 }
         }
         else if (ev.type === 'result') {
@@ -91,10 +88,3 @@ export async function* runClaude(o) {
     }
     yield { t: 'done', ok: true };
 }
-function flatten(c) {
-    if (typeof c === 'string')
-        return c;
-    if (Array.isArray(c))
-        return c.map((x) => (typeof x === 'string' ? x : x?.text ?? '')).join('\n');
-    return c == null ? '' : JSON.stringify(c);
-}

package/server/dist/providers/index.js

@@ -1,6 +1,12 @@
 import { runClaude } from './claude.js';
 import { runOpencode } from './opencode.js';
 import { runKiro } from './kiro.js';
+export const providers = {
+    claude: { id: 'claude', run: runClaude },
+    opencode: { id: 'opencode', run: runOpencode },
+    kiro: { id: 'kiro', run: runKiro },
+};
+/** The adapters as plain functions (what `runtime.ts` and the image reader call; tests may replace one). */
 export const runners = {
-    claude: runClaude, opencode: runOpencode, kiro: runKiro,
+    claude: (o) => providers.claude.run(o), opencode: (o) => providers.opencode.run(o), kiro: (o) => providers.kiro.run(o),
 };

package/server/dist/providers/kiro.js

@@ -1,4 +1,4 @@
-import { spawnLines, safeJson } from './spawn.js';
+import { spawnJson } from './spawn.js';
 import { withInstructions } from './preamble.js';
 import { writeFileSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
@@ -40,10 +40,7 @@ export async function* runKiro(o) {
     args.push(prompt);
     let sawSession = false;
     const open = new Set();
-    for await (const line of spawnLines({ cmd: 'kiro-cli', args, cwd: agent.cwd, signal: o.signal })) {
-        const ev = safeJson(line);
-        if (!ev)
-            continue;
+    for await (const ev of spawnJson({ cmd: 'kiro-cli', args, cwd: agent.cwd, signal: o.signal })) {
         const d = ev.data ?? {};
         if (d.sessionId && !sawSession) {
             sawSession = true;

package/server/dist/providers/opencode.js

@@ -1,7 +1,7 @@
 import { DATA_DIR } from '../db.js';
 import { join } from 'node:path';
 const INBOX_ROOT = join(DATA_DIR, 'inbox');
-import { spawnLines, safeJson } from './spawn.js';
+import { spawnJson } from './spawn.js';
 import { dispatchMcpConfigOpencode } from '../mcp-config.js';
 import { opencodeSessionDir } from '../history/opencode.js';
 import { withInstructions } from './preamble.js';
@@ -70,10 +70,7 @@ export async function* runOpencode(o) {
     const toolStarted = new Set();
     let sawSession = false;
     try {
-        for await (const line of spawnLines({ cmd: 'opencode', args, cwd: agent.cwd, env, signal: o.signal })) {
-            const ev = safeJson(line);
-            if (!ev)
-                continue;
+        for await (const ev of spawnJson({ cmd: 'opencode', args, cwd: agent.cwd, env, signal: o.signal })) {
             if (ev.sessionID && !sawSession) {
                 sawSession = true;
                 yield { t: 'session', sessionId: ev.sessionID };

package/server/dist/providers/preamble.js

@@ -11,3 +11,5 @@ export function withInstructions(prompt, instructions, resumed, refresh) {
         return `<instructions update="true">\nYour configuration changed since the last message. These instructions replace any earlier ones; use them from now on.\n\n${instructions}\n</instructions>\n\n${prompt}`;
     return prompt;
 }
+/** Takes the instructions block off the front of a user message read back from a CLI's own history: it is ours, not what the person wrote. */
+export const stripInstructions = (text) => text.replace(/^<instructions[^>]*>[\s\S]*?<\/instructions>\s*/, '');

package/server/dist/providers/spawn.js

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
+const KILL_GRACE_MS = Number(process.env.HIVE_AM_KILL_GRACE_MS) || 5000;
 /** Spawns a CLI and yields its stdout lines. Throws with stderr tail if it exits non-zero and nothing aborted it. */
 export async function* spawnLines(o) {
     const child = spawn(o.cmd, o.args, {
@@ -8,8 +9,17 @@ export async function* spawnLines(o) {
         env: { ...process.env, PWD: o.cwd, ...o.env },
         stdio: ['pipe', 'pipe', 'pipe'],
     });
-    const kill = () => { if (!child.killed)
-        child.kill('SIGTERM'); };
+    // SIGTERM first; a CLI that ignores it (busy inside a tool) is cut off after a grace period so a stopped turn never leaves a process behind.
+    let hardKill;
+    const kill = () => {
+        if (child.exitCode !== null || child.signalCode !== null)
+            return;
+        if (!child.killed)
+            child.kill('SIGTERM');
+        hardKill ??= setTimeout(() => { if (child.exitCode === null && child.signalCode === null)
+            child.kill('SIGKILL'); }, KILL_GRACE_MS);
+        hardKill.unref?.();
+    };
     o.signal.addEventListener('abort', kill, { once: true });
     let stderr = '';
     child.stderr.on('data', (d) => { stderr = (stderr + d).slice(-4000); });
@@ -17,8 +27,10 @@ export async function* spawnLines(o) {
         child.on('error', (e) => { stderr += String(e); res(-1); });
         // 'exit' (not 'close'): a daemon the CLI forks (e.g. opencode's background service) can keep
         // inheriting our stdout pipe forever, so 'close' would never fire. Drain briefly, then cut the pipe.
-        child.on('exit', (c) => { setTimeout(() => child.stdout.destroy(), 250); res(c); });
+        child.on('exit', (c) => { if (hardKill)
+            clearTimeout(hardKill); setTimeout(() => child.stdout.destroy(), 250); res(c); });
     });
+    child.stdin.on('error', () => { });
     if (o.stdin !== undefined)
         child.stdin.end(o.stdin);
     else
@@ -44,3 +56,19 @@ export function safeJson(line) {
         return null;
     }
 }
+/** The JSON objects a CLI prints, one per line; lines that are not JSON (banners, warnings) are skipped. */
+export async function* spawnJson(o) {
+    for await (const line of spawnLines(o)) {
+        const ev = safeJson(line);
+        if (ev)
+            yield ev;
+    }
+}
+/** The text of a tool result, which CLIs send as a string, a list of blocks or any other JSON. */
+export function flattenText(c) {
+    if (typeof c === 'string')
+        return c;
+    if (Array.isArray(c))
+        return c.map((x) => (typeof x === 'string' ? x : x?.text ?? '')).join('\n');
+    return c == null ? '' : JSON.stringify(c);
+}

package/server/dist/runtime.js

@@ -58,17 +58,19 @@ async function execute(agentId, prompt, source, from, dispatchId, origin) {
     agents.setStatus(agentId, 'running');
     emit({ kind: 'turn_start', agentId, turnId, prompt, source, from, channel: origin && { platform: origin.platform, place: origin.place, user: origin.userName } });
     emit({ kind: 'status', agentId, status: 'running', queued: s.queued });
-    const base = composeInstructions(agent, delegated);
-    const nbVersion = notebooks.get(agentId).version;
-    const instructions = [base, notebookBlock(agent)].filter(Boolean).join('\n\n');
-    const hash = createHash('sha1').update(base).digest('hex').slice(0, 16);
-    // The conversation is re-sent the instructions when its configuration changed, or when the notes were edited behind its back (by the user, or in another conversation).
-    const refreshInstructions = !delegated && !!agent.session_id && (raw.instr_hash !== hash || notebooks.get(agentId).seen < nbVersion);
     let text = '';
     let summary;
     let error;
+    let hash = '', nbVersion = 0;
     const push = (event) => { s.live?.events.push(event); emit({ kind: 'event', agentId, turnId, event }); };
     try {
+        // Composing the instructions can fail too (a damaged skill row...): that is this turn's error, and it must not leave the agent "running" forever.
+        const base = composeInstructions(agent, delegated);
+        nbVersion = notebooks.get(agentId).version;
+        const instructions = [base, notebookBlock(agent)].filter(Boolean).join('\n\n');
+        hash = createHash('sha1').update(base).digest('hex').slice(0, 16);
+        // The conversation is re-sent the instructions when its configuration changed, or when the notes were edited behind its back (by the user, or in another conversation).
+        const refreshInstructions = !delegated && !!agent.session_id && (raw.instr_hash !== hash || notebooks.get(agentId).seen < nbVersion);
         const stream = runners[agent.provider]({
             agent, prompt, signal: controller.signal,
             instructions, refreshInstructions,

package/server/dist/schedules.js

@@ -5,12 +5,13 @@ import { adapterFor } from './connections/manager.js';
 import { deliverScheduled } from './connections/router.js';
 import { connections, threads } from './connections/store.js';
 import { liveOrigin, liveSource, queueDepth, sendTurn } from './runtime.js';
+import { DomainError } from './errors.js';
 /**
  * Recurring schedules an agent sets for itself ("every weekday at 9, check the QA logs and tell me"). Like a wake-up, a run reaches the agent
  * in the place where the schedule was made: the same chat thread, or its own web conversation. Cost is bounded: a minimum interval between runs,
  * a limit per agent, no catching up after an outage (a missed run is skipped, never replayed) and no run while the agent is already behind.
  */
-export class ScheduleError extends Error {
+export class ScheduleError extends DomainError {
 }
 const MS_PER_MINUTE = Number(process.env.HIVE_AM_WAKE_MS_PER_MINUTE) || 60_000; // tests shrink a "minute" (only for "every N minutes")
 export const MIN_INTERVAL_MINUTES = Number(process.env.HIVE_AM_SCHEDULE_MIN_MINUTES) || 15;
@@ -19,26 +20,6 @@ const MISSED_GRACE_MS = 5 * 60_000; // a run later than this (the server was dow
 const BUSY_QUEUE = 2; // skip a run when this many messages already wait for the agent
 const KEEP_RUNS = 50;
 const MAX_TIMER_MS = 2_147_483_647;
-db.exec(`
-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);`);
-// Who asked (only kept when it was in a group): each run mentions them. Older databases get the columns here.
-for (const col of ['req_id TEXT', 'req_name TEXT']) {
-    try {
-        db.exec(`ALTER TABLE agent_schedules ADD COLUMN ${col}`);
-    }
-    catch { /* already there */ }
-}
 const fromRow = (r) => ({ ...r, enabled: !!r.enabled });
 const store = {
     get: (id) => { const r = db.prepare('SELECT * FROM agent_schedules WHERE id=?').get(id); return r ? fromRow(r) : undefined; },

package/server/dist/seed.js

@@ -4,30 +4,34 @@ import { NOTEBOOK_SKILL_ID } from './skills/defaults.js';
 export function seedIfEmpty() {
     if (types.list().length || agents.list().length || skills.list().some((s) => !s.id.startsWith('default-')))
         return;
-    const s1 = skills.create({
-        name: 'concise-reports', description: 'Short, structured final answers',
-        content: 'Finish every task with a report: what you did, what you found, what is left. Use short bullet points. No filler.',
-    });
-    const s2 = skills.create({
-        name: 'careful-reviewer', description: 'Review code for bugs before style',
-        content: 'When reviewing, rank findings by severity. Report concrete failure scenarios, not preferences. Never edit files unless asked.',
-    });
     types.create({
         name: 'Queen', role: 'orchestrator', provider: 'claude', model: 'sonnet', permission: 'acceptEdits', color: '#E8A317',
         description: 'Plans the work and delegates it to workers',
         system_prompt: 'You are an orchestrator. Break the request into independent tasks, delegate each to the best subagent, then merge their answers into one clear result.',
-        skill_ids: [s1.id, NOTEBOOK_SKILL_ID],
+        skill_ids: [NOTEBOOK_SKILL_ID],
     });
     types.create({
         name: 'Builder', role: 'worker', provider: 'claude', model: 'sonnet', permission: 'acceptEdits', color: '#D97757',
         description: 'Implements features and fixes in the codebase',
         system_prompt: 'You implement changes carefully and verify them by running the project’s tests when they exist.',
-        skill_ids: [s1.id, NOTEBOOK_SKILL_ID],
+        skill_ids: [NOTEBOOK_SKILL_ID],
     });
     types.create({
         name: 'Reviewer', role: 'worker', provider: 'opencode', model: '', permission: 'plan', color: '#3E7BFA',
         description: 'Reads code and reports problems without changing it',
         system_prompt: 'You review code. You never modify files.',
-        skill_ids: [s2.id],
+        skill_ids: [],
     });
 }
+/** The two example skills older versions created on the first run are gone; where they are still as they were made, they are removed. */
+const STARTER = [
+    { name: 'concise-reports', content: 'Finish every task with a report: what you did, what you found, what is left. Use short bullet points. No filler.' },
+    { name: 'careful-reviewer', content: 'When reviewing, rank findings by severity. Report concrete failure scenarios, not preferences. Never edit files unless asked.' },
+];
+export function dropStarterSkills() {
+    for (const d of STARTER) {
+        const s = skills.list().find((x) => x.name === d.name && x.content === d.content && !x.id.startsWith('default-'));
+        if (s)
+            skills.remove(s.id);
+    }
+}