hive-am 1.0.0 → 1.2.0

package/server/dist/providers/opencode.js

@@ -1,10 +1,11 @@
 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';
+import { opencodeServer, stopOpencodeServer } from './opencode-server.js';
 /**
  * What OpenCode may do for each permission level. It has no such modes, so they are written as its own rules (a `deny` holds even with `--auto`):
  * read-only changes nothing; editing changes files of the project (including .env, never .git or keys), runs no commands and stays in the agent's folder
@@ -29,60 +30,82 @@ export function opencodePermissions(level) {
 export async function* runOpencode(o) {
     const { agent } = o;
     const args = ['run', '--format', 'json', '--thinking', '--auto'];
-    // `opencode run` normally talks to OpenCode's background service, which ignores the config we pass through the
-    // environment. A private (standalone) server reads it, which we need for the `dispatch` MCP and to deny `question`.
-    args.splice(1, 0, '--standalone');
     // Sessions created while the folder was wrong (older hive-am builds) would keep running there; start fresh instead.
     const recorded = agent.session_id ? opencodeSessionDir(agent.session_id) : null;
     const resume = agent.session_id && (!recorded || recorded === agent.cwd) ? agent.session_id : null;
     if (resume)
         args.push('-s', resume);
+    // The reasoning level goes as the model's `#variant` (low / medium / high).
     if (agent.model)
-        args.push('-m', agent.model);
+        args.push('-m', o.effort && !agent.model.includes('#') ? `${agent.model}#${o.effort}` : agent.model);
     const prompt = withInstructions(o.prompt, o.instructions, !!resume, o.refreshInstructions);
-    args.push(prompt);
     // Turns are non-interactive: OpenCode's `question` tool would be dismissed and end the turn with exit code 1, so
     // deny it and the agent asks in plain text instead.
     const config = { permission: { question: 'deny', ...opencodePermissions(agent.permission) }, ...(o.mcpCaps.length ? dispatchMcpConfigOpencode(agent.id, o.mcpCaps) : {}) };
     const env = { OPENCODE_CONFIG_CONTENT: JSON.stringify(config) };
+    // `opencode run` normally talks to OpenCode's shared background service, which ignores the config we pass through the environment.
+    // We need that config (the `hive` MCP, `question` denied, the permission rules), so the turn goes to a server of this agent that
+    // started with it and keeps hive connected between turns. If that server cannot start, a private one-off server is used instead.
+    let access = null;
+    // Only agents answering an external chat gain enough from it (somebody is waiting for a reply and the first `channel_reply` would fail); every other agent keeps the one-off server and costs nothing between turns.
+    if (o.mcpCaps.includes('channel') && !process.env.HIVE_AM_OPENCODE_STANDALONE) {
+        try {
+            access = await opencodeServer(agent.id, agent.cwd, config, o.signal);
+        }
+        catch (e) {
+            console.warn(`[opencode] no persistent server for ${agent.name}, using a private one: ${e instanceof Error ? e.message : e}`);
+        }
+    }
+    if (access) {
+        args.splice(1, 0, '--server', access.url);
+        env.OPENCODE_SERVER_PASSWORD = access.password;
+    }
+    else
+        args.splice(1, 0, '--standalone');
+    args.push(prompt);
+    // Stopping a turn must really stop the model: a client that is killed would leave the server working on, so the server goes down with it.
+    if (access)
+        o.signal.addEventListener('abort', () => stopOpencodeServer(agent.id), { once: true });
     const seen = new Map();
     const toolStarted = new Set();
     let sawSession = false;
-    for await (const line of spawnLines({ cmd: 'opencode', args, cwd: agent.cwd, env, signal: o.signal })) {
-        const ev = safeJson(line);
-        if (!ev)
-            continue;
-        if (ev.sessionID && !sawSession) {
-            sawSession = true;
-            yield { t: 'session', sessionId: ev.sessionID };
-        }
-        const p = ev.part;
-        if (!p)
-            continue;
-        if (p.type === 'text' || p.type === 'reasoning') {
-            const text = p.text ?? '';
-            const prev = seen.get(p.id) ?? 0;
-            if (text.length > prev) {
-                seen.set(p.id, text.length);
-                yield { t: p.type === 'text' ? 'text' : 'thinking', delta: text.slice(prev) };
+    try {
+        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 };
             }
-        }
-        else if (p.type === 'step-finish') {
-            const tk = p.tokens;
-            if (tk)
-                yield { t: 'usage', cost: p.cost || undefined, usage: { input: tk.input, output: tk.output, reasoning: tk.reasoning, cacheRead: tk.cache?.read, cacheWrite: tk.cache?.write } };
-        }
-        else if (p.type === 'tool') {
-            const st = p.state ?? {};
-            if (!toolStarted.has(p.callID ?? p.id)) {
-                toolStarted.add(p.callID ?? p.id);
-                yield { t: 'tool', id: p.callID ?? p.id, name: p.tool ?? p.name ?? 'tool', input: st.input };
+            const p = ev.part;
+            if (!p)
+                continue;
+            if (p.type === 'text' || p.type === 'reasoning') {
+                const text = p.text ?? '';
+                const prev = seen.get(p.id) ?? 0;
+                if (text.length > prev) {
+                    seen.set(p.id, text.length);
+                    yield { t: p.type === 'text' ? 'text' : 'thinking', delta: text.slice(prev) };
+                }
             }
-            if (st.status === 'completed' || st.status === 'error') {
-                const out = typeof st.output === 'string' ? st.output : Array.isArray(st.content) ? st.content.map((c) => c.text ?? '').join('\n') : '';
-                yield { t: 'tool_result', id: p.callID ?? p.id, output: out, error: st.status === 'error' };
+            else if (p.type === 'step-finish') {
+                const tk = p.tokens;
+                if (tk)
+                    yield { t: 'usage', cost: p.cost || undefined, usage: { input: tk.input, output: tk.output, reasoning: tk.reasoning, cacheRead: tk.cache?.read, cacheWrite: tk.cache?.write } };
+            }
+            else if (p.type === 'tool') {
+                const st = p.state ?? {};
+                if (!toolStarted.has(p.callID ?? p.id)) {
+                    toolStarted.add(p.callID ?? p.id);
+                    yield { t: 'tool', id: p.callID ?? p.id, name: p.tool ?? p.name ?? 'tool', input: st.input };
+                }
+                if (st.status === 'completed' || st.status === 'error') {
+                    const out = typeof st.output === 'string' ? st.output : Array.isArray(st.content) ? st.content.map((c) => c.text ?? '').join('\n') : '';
+                    yield { t: 'tool_result', id: p.callID ?? p.id, output: out, error: st.status === 'error' };
+                }
             }
         }
     }
+    finally {
+        access?.release();
+    }
     yield { t: 'done', ok: true };
 }

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

@@ -19,6 +19,7 @@ export const liveTurn = (id) => states.get(id)?.live ?? null;
 export const queueDepth = (id) => states.get(id)?.queued ?? 0;
 /** The channel message the agent is answering right now, if the running turn came from one. */
 export const liveOrigin = (id) => states.get(id)?.live?.origin;
+export const liveSource = (id) => states.get(id)?.live?.source;
 /** Whether the turn running now is the agent's own conversation (not work delegated to it by an orchestrator). */
 export const liveIsDirect = (id) => states.get(id)?.live?.source === 'user';
 /** Queue a prompt for an agent. Turns for one agent run strictly one at a time. */
@@ -57,21 +58,23 @@ 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,
-            mcpCaps: mcpCaps(agent),
+            mcpCaps: mcpCaps(agent), effort: origin?.effort,
         });
         for await (const ev of stream) {
             if (ev.t === 'session') {

package/server/dist/schedules.js

@@ -0,0 +1,222 @@
+import { randomUUID } from 'node:crypto';
+import { agents, db } from './db.js';
+import { CronError, minGapMinutes, nextCron, nextRuns, parseCron, serverTimezone, validTimezone } from './cron.js';
+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 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;
+export const MAX_PER_AGENT = 10;
+const MISSED_GRACE_MS = 5 * 60_000; // a run later than this (the server was down) is skipped
+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;
+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; },
+    all: () => db.prepare('SELECT * FROM agent_schedules ORDER BY created_at').all().map(fromRow),
+    forAgent: (agentId) => db.prepare('SELECT * FROM agent_schedules WHERE agent_id=? ORDER BY created_at').all(agentId).map(fromRow),
+    remove: (id) => db.prepare('DELETE FROM agent_schedules WHERE id=?').run(id).changes > 0,
+    setNext: (id, next) => db.prepare('UPDATE agent_schedules SET next_due=? WHERE id=?').run(next, id),
+    setEnabled: (id, on, next) => db.prepare('UPDATE agent_schedules SET enabled=?, next_due=? WHERE id=?').run(on ? 1 : 0, next, id),
+    record(id, status, detail, durationMs, firedAt) {
+        db.prepare('INSERT INTO schedule_runs (schedule_id,fired_at,status,detail,duration_ms) VALUES (?,?,?,?,?)').run(id, firedAt, status, detail, durationMs);
+        db.prepare(`DELETE FROM schedule_runs WHERE schedule_id=? AND id NOT IN (SELECT id FROM schedule_runs WHERE schedule_id=? ORDER BY id DESC LIMIT ${KEEP_RUNS})`).run(id, id);
+        db.prepare('UPDATE agent_schedules SET last_status=?, last_detail=?, last_fired_at=?, fire_count=fire_count+? WHERE id=?').run(status, detail, firedAt, status === 'delivered' ? 1 : 0, id);
+    },
+    runs: (id, limit = KEEP_RUNS) => db.prepare('SELECT id,fired_at,status,detail,duration_ms FROM schedule_runs WHERE schedule_id=? ORDER BY id DESC LIMIT ?').all(id, limit),
+};
+const hhmm = (t, tz) => new Date(t).toLocaleString('en-GB', { timeZone: tz, weekday: 'short', day: '2-digit', month: 'short', hour: '2-digit', minute: '2-digit' });
+export const describe = (s) => s.kind === 'every' ? `every ${s.expr} min` : `${s.expr} (${s.tz})`;
+/** Next run after `after`. "every N" keeps its rhythm from the previous due time instead of drifting by the run time. */
+function computeNext(s, after, from) {
+    if (s.kind === 'cron')
+        return nextCron(s.expr, s.tz, after);
+    const step = Number(s.expr) * MS_PER_MINUTE;
+    let t = (from ?? after) + step;
+    if (t <= after)
+        t += Math.ceil((after - t + 1) / step) * step;
+    return t;
+}
+// ---- timers ----
+const timers = new Map();
+function arm(s) {
+    const old = timers.get(s.id);
+    if (old)
+        clearTimeout(old);
+    timers.delete(s.id);
+    if (!s.enabled || s.next_due === null)
+        return;
+    const delay = Math.max(0, Math.min(s.next_due - Date.now(), MAX_TIMER_MS));
+    const t = setTimeout(() => { if (s.next_due !== null && s.next_due - Date.now() > 1000)
+        arm(store.get(s.id) ?? s);
+    else
+        void fire(s.id); }, delay);
+    t.unref?.();
+    timers.set(s.id, t);
+}
+const disarm = (id) => { const t = timers.get(id); if (t)
+    clearTimeout(t); timers.delete(id); };
+function text(s, web) {
+    const tool = web ? '' : ' with channel_reply';
+    return `${web ? '🔔 ' : ''}Scheduled task (${describe(s)}${s.req_name ? `, asked by ${s.req_name}` : ''}). Your note: ${s.note}\n\n${s.req_name ? `hive-am mentions ${s.req_name} at the start of your first reply, so do not mention them yourself. ` : ''}Do what the note says now and tell the person the result${tool}. If there is nothing worth reporting, say so in one line. You can see or stop your schedules with schedule_list / schedule_cancel.`;
+}
+async function fire(id) {
+    timers.delete(id);
+    const s = store.get(id);
+    if (!s || !s.enabled)
+        return;
+    const now = Date.now(), due = s.next_due ?? now;
+    const next = computeNext(s, now, s.kind === 'every' ? due : null);
+    store.setNext(id, next); // the next run is fixed before anything else can fail
+    arm({ ...s, next_due: next });
+    const skip = (status, detail) => store.record(id, status, detail, null, now);
+    const agent = agents.get(s.agent_id);
+    if (!agent) {
+        store.remove(id);
+        return;
+    }
+    if (now - due > MISSED_GRACE_MS)
+        return skip('skipped_missed', `due ${hhmm(due, s.tz)}, ${Math.round((now - due) / 60000)} min late (the server was down)`);
+    if (queueDepth(agent.id) >= BUSY_QUEUE)
+        return skip('skipped_busy', 'the agent already had messages waiting');
+    const started = Date.now();
+    try {
+        if (s.thread_id) {
+            const conn = connections.get(s.connection_id ?? ''), thread = threads.get(s.thread_id);
+            if (!conn || !thread) {
+                store.remove(id);
+                disarm(id);
+                return;
+            }
+            if (!conn.enabled)
+                return skip('skipped_disabled', 'the connection is disabled');
+            if (conn.agent_id !== s.agent_id) {
+                store.setEnabled(id, false, null);
+                disarm(id);
+                return skip('skipped_reassigned', 'the connection now belongs to another agent; the schedule was paused');
+            }
+            if (thread.muted)
+                return skip('skipped_muted', 'the thread is muted');
+            const adapter = adapterFor(conn.id);
+            if (!adapter)
+                return skip('skipped_disabled', 'the connection was not running');
+            store.record(id, 'delivered', null, null, started);
+            await deliverScheduled(conn, adapter, thread, text(s, false), s.req_id ? { id: s.req_id, name: s.req_name || 'you' } : undefined);
+        }
+        else {
+            store.record(id, 'delivered', null, null, started);
+            await sendTurn(agent.id, text(s, true), 'user');
+        }
+        db.prepare('UPDATE schedule_runs SET duration_ms=? WHERE schedule_id=? AND fired_at=? AND status=?').run(Date.now() - started, id, started, 'delivered');
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        db.prepare('UPDATE schedule_runs SET status=?, detail=? WHERE schedule_id=? AND fired_at=? AND status=?').run('failed', msg, id, started, 'delivered');
+        db.prepare('UPDATE agent_schedules SET last_status=?, last_detail=?, fire_count=MAX(0,fire_count-1) WHERE id=?').run('failed', msg, id);
+        console.warn(`[schedules] run of "${s.note.slice(0, 40)}" failed: ${msg}`);
+    }
+}
+/** Arms every saved schedule (called once at startup). A run missed while the server was down is skipped, not replayed. */
+export function armSchedules() {
+    for (const s of store.all()) {
+        if (!s.enabled)
+            continue;
+        if (s.next_due !== null && s.next_due < Date.now())
+            void fire(s.id);
+        else
+            arm(s);
+    }
+}
+export function createSchedule(agentId, input) {
+    if (!agents.get(agentId))
+        throw new ScheduleError('Unknown agent');
+    if (liveSource(agentId) === 'dispatch')
+        throw new ScheduleError('Schedules are not available while you work on a task delegated by an orchestrator.');
+    const note = String(input.note ?? '').trim();
+    if (!note)
+        throw new ScheduleError('Say in the note what to do at each run.');
+    if (note.length > 400)
+        throw new ScheduleError('The note is too long (400 characters at most).');
+    const tz = input.timezone === undefined || input.timezone === '' ? serverTimezone() : String(input.timezone);
+    if (!validTimezone(tz))
+        throw new ScheduleError(`Unknown time zone "${tz}". Use an IANA name such as America/Mexico_City.`);
+    const hasCron = input.cron !== undefined && String(input.cron).trim() !== '', hasEvery = input.every_minutes !== undefined && input.every_minutes !== null;
+    if (hasCron === hasEvery)
+        throw new ScheduleError('Give either "cron" (for example "0 9 * * MON-FRI") or "every_minutes", not both and not neither.');
+    let kind, expr, first;
+    const now = Date.now();
+    if (hasCron) {
+        kind = 'cron';
+        expr = String(input.cron).trim();
+        try {
+            parseCron(expr);
+        }
+        catch (e) {
+            throw new ScheduleError(e instanceof CronError ? e.message : String(e));
+        }
+        const gap = minGapMinutes(expr, tz, now);
+        if (gap < MIN_INTERVAL_MINUTES)
+            throw new ScheduleError(`Runs would be only ${gap} min apart; the minimum is ${MIN_INTERVAL_MINUTES} min. Choose a less frequent schedule.`);
+        first = nextCron(expr, tz, now);
+    }
+    else {
+        kind = 'every';
+        const m = Number(input.every_minutes);
+        if (!Number.isFinite(m) || m < MIN_INTERVAL_MINUTES || m > 60 * 24 * 31)
+            throw new ScheduleError(`every_minutes must be between ${MIN_INTERVAL_MINUTES} and ${60 * 24 * 31}.`);
+        expr = String(Math.round(m));
+        first = now + Math.round(m) * MS_PER_MINUTE;
+    }
+    if (first === null)
+        throw new ScheduleError('That schedule never runs.');
+    const origin = liveOrigin(agentId), thread = origin ? threads.get(origin.threadId) : undefined;
+    if (origin && !thread)
+        throw new ScheduleError('The thread no longer exists.');
+    const mine = store.forAgent(agentId);
+    if (mine.length >= MAX_PER_AGENT)
+        throw new ScheduleError(`You already have ${MAX_PER_AGENT} schedules. Cancel one with schedule_cancel first.`);
+    const dup = mine.find((x) => x.kind === kind && x.expr === expr && x.tz === tz && x.note.toLowerCase() === note.toLowerCase() && x.thread_id === (thread?.id ?? null));
+    if (dup)
+        return { schedule: dup, next: kind === 'cron' ? nextRuns(expr, tz, now, 3).map((t) => hhmm(t, tz)) : [hhmm(dup.next_due ?? first, tz)], where: thread ? 'thread' : 'chat' };
+    const id = randomUUID();
+    db.prepare('INSERT INTO agent_schedules (id,agent_id,connection_id,thread_id,kind,expr,tz,note,enabled,next_due,created_at,req_id,req_name) VALUES (?,?,?,?,?,?,?,?,1,?,?,?,?)')
+        .run(id, agentId, origin?.connectionId ?? null, thread?.id ?? null, kind, expr, tz, note, first, now, origin?.group && origin.userId ? origin.userId : null, origin?.group && origin.userId ? origin.userName : null);
+    const schedule = store.get(id);
+    arm(schedule);
+    return { schedule, next: kind === 'cron' ? nextRuns(expr, tz, now, 3).map((t) => hhmm(t, tz)) : [hhmm(first, tz)], where: thread ? 'thread' : 'chat' };
+}
+export function listFor(agentId) {
+    return store.forAgent(agentId).map((s) => ({ id: s.id, schedule: describe(s), note: s.note, enabled: s.enabled, next: s.next_due ? hhmm(s.next_due, s.tz) : null, last: s.last_status }));
+}
+export function cancelFor(agentId, id) {
+    const s = store.get(id);
+    if (!s || s.agent_id !== agentId)
+        throw new ScheduleError('You have no schedule with that id. Use schedule_list to see yours.');
+    disarm(id);
+    return store.remove(id);
+}
+export function listAll() {
+    return store.all().map((s) => ({ ...s, agent_name: agents.get(s.agent_id)?.name ?? '?', place: s.thread_id ? (threads.get(s.thread_id)?.title || 'chat') : '', description: describe(s) }));
+}
+export const runsOf = (id) => store.runs(id);
+export function setEnabled(id, on) {
+    const s = store.get(id);
+    if (!s)
+        return undefined;
+    const next = on ? computeNext(s, Date.now(), null) : null;
+    store.setEnabled(id, on, next);
+    const u = store.get(id);
+    arm(u);
+    return u;
+}
+export function removeSchedule(id) { disarm(id); return store.remove(id); }

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);
+    }
+}

package/server/dist/services/agents.js

@@ -0,0 +1,90 @@
+import { agents, db, resolved } from '../db.js';
+import { channelPermissionError } from '../connections/rules.js';
+import { liveTurn, notifyAgentsChanged, stopAgent } from '../runtime.js';
+import { findRepo } from '../git/repo.js';
+import { bad, notFound } from '../http/errors.js';
+import { trimmed } from '../http/validate.js';
+const NO_FOLDER = 'Choose a working folder, or put the agent in a colony that provides one.';
+export const agentOrFail = (id) => agents.get(id) ?? (() => { throw notFound('Agent not found'); })();
+/** The folder the agent really works in (its own, or its colony's when it inherits). */
+export const agentCwd = (id) => resolved(agentOrFail(id)).cwd;
+const uniqueName = (name, exceptId) => { const o = agents.byName(name); if (o && o.id !== exceptId)
+    throw bad(`An agent named "${name}" already exists`); };
+/** Creates an agent. With no folder of its own and none inherited it could never run, so it is removed again. */
+function create(p) {
+    const a = agents.create(p);
+    if (!a.effective.cwd) {
+        agents.remove(a.id);
+        throw bad(NO_FOLDER);
+    }
+    notifyAgentsChanged();
+    return a;
+}
+export function createAgent(p) {
+    const name = trimmed(p.name);
+    uniqueName(name);
+    return create({ ...p, name, cwd: p.cwd ?? '' });
+}
+/** A new agent that starts from a type: the type lends everything but name, description, folder and colony. */
+export function spawnFromType(t, p) {
+    const name = trimmed(p.name);
+    uniqueName(name);
+    return create({
+        name, description: p.description ?? t.description, role: t.role, type_id: t.id, provider: t.provider, model: t.model,
+        system_prompt: t.system_prompt, permission: t.permission, cwd: p.cwd ?? '', skill_ids: t.skill_ids, skill_loads: t.skill_loads, colony_id: p.colony_id ?? null,
+    });
+}
+export function updateAgent(id, p) {
+    const cur = agentOrFail(id);
+    if (p.name && p.name.toLowerCase() !== cur.name.toLowerCase())
+        uniqueName(p.name, id);
+    // Changing provider invalidates the native session pointer. (A changed folder is detected when the next turn starts.)
+    // All-or-nothing: a change that would leave a linked agent in Plan mode is rolled back.
+    const a = db.transaction(() => {
+        const u = agents.update(id, p);
+        const why = channelPermissionError(u.id);
+        if (why)
+            throw bad(why);
+        return u;
+    })();
+    if (p.provider && p.provider !== cur.provider)
+        agents.setSession(a, null);
+    if (!agents.get(a.id).effective.cwd)
+        throw bad('Choose a working folder, or keep inheriting the colony’s folder.');
+    notifyAgentsChanged();
+    return agents.get(id);
+}
+export function removeAgent(id) {
+    stopAgent(id);
+    if (!agents.remove(id))
+        throw notFound('Agent not found');
+    notifyAgentsChanged();
+}
+/** The session to read: the requested one must belong to the agent (its own or a delegated one). */
+export function sessionToRead(a, requested) {
+    const sid = requested ?? a.session_id;
+    if (sid && sid !== a.session_id && !agents.sessions(a.id).some((s) => s.session_id === sid))
+        throw bad('That session does not belong to this agent');
+    return sid;
+}
+/** Only the agent's own conversations can be made current; delegated ones are read-only. */
+export function resumeSession(a, sessionId) {
+    if (!agents.sessions(a.id).some((s) => s.session_id === sessionId && s.kind !== 'delegation'))
+        throw bad('Only the agent’s own conversations can be made current. Delegated sessions are read-only.');
+    agents.setSession(a, sessionId);
+    notifyAgentsChanged();
+}
+/** Which other agents are working in the same repository right now (a branch switch moves their files too). */
+export async function othersInRepo(agentId, cwd) {
+    const others = [];
+    const here = await findRepo(cwd);
+    if (here.ok)
+        for (const a of agents.list()) {
+            if (a.id === agentId || !(a.status === 'running' || liveTurn(a.id)))
+                continue;
+            const there = await findRepo(resolved(a).cwd);
+            if (there.ok && there.repo.root === here.repo.root)
+                others.push({ id: a.id, name: a.name });
+        }
+    return others;
+}

package/server/dist/services/colonies.js

@@ -0,0 +1,38 @@
+import { colonies, db } from '../db.js';
+import { channelPermissionError } from '../connections/rules.js';
+import { notifyAgentsChanged } from '../runtime.js';
+import { bad, notFound } from '../http/errors.js';
+import { trimmed } from '../http/validate.js';
+const sameName = (name, exceptId) => colonies.list().some((c) => c.id !== exceptId && c.name.toLowerCase() === name.toLowerCase());
+export function createColony(p) {
+    const name = trimmed(p.name);
+    if (sameName(name))
+        throw bad(`A colony named "${p.name}" already exists`);
+    const c = colonies.create({ ...p, name });
+    notifyAgentsChanged();
+    return c;
+}
+export function updateColony(id, p) {
+    const cur = colonies.get(id);
+    if (!cur)
+        throw notFound('Colony not found');
+    if (p.name && p.name.toLowerCase() !== cur.name.toLowerCase() && sameName(trimmed(p.name)))
+        throw bad(`A colony named "${p.name}" already exists`);
+    // A colony can lend Plan mode to an agent that has a channel: all-or-nothing.
+    const c = db.transaction(() => {
+        const u = colonies.update(id, p.name ? { ...p, name: trimmed(p.name) } : p);
+        for (const aid of u.agent_ids) {
+            const why = channelPermissionError(aid);
+            if (why)
+                throw bad(why);
+        }
+        return u;
+    })();
+    notifyAgentsChanged();
+    return c;
+}
+export function removeColony(id) {
+    if (!colonies.remove(id))
+        throw notFound('Colony not found');
+    notifyAgentsChanged();
+}