hive-am 1.4.0 → 1.6.0

package/server/dist/db.js

@@ -106,7 +106,7 @@ export const types = {
     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();
-        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());
+        q('INSERT INTO agent_types (id,name,description,role,provider,model,effort,system_prompt,permission,color,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?)').run(id, p.name, p.description ?? '', p.role, p.provider, p.model ?? '', p.effort ?? '', p.system_prompt ?? '', (p.permission ?? 'acceptEdits'), p.color ?? '', now());
         types.setSkills(id, p.skill_ids ?? [], p.skill_loads);
         return types.get(id);
     }),
@@ -115,8 +115,8 @@ export const types = {
         if (!cur)
             return;
         const n = { ...cur, ...p };
-        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);
+        q('UPDATE agent_types SET name=?, description=?, role=?, provider=?, model=?, effort=?, system_prompt=?, permission=?, color=? WHERE id=?')
+            .run(n.name, n.description, n.role, n.provider, n.model, n.effort ?? '', 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);
@@ -197,7 +197,7 @@ export const agents = {
     /** 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();
-        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,browser) 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 ?? []), p.browser && p.provider === 'claude' ? 1 : 0);
+        q('INSERT INTO agents (id,name,description,role,type_id,provider,model,effort,system_prompt,permission,cwd,session_id,status,created_at,updated_at,colony_id,overrides,browser,cloned_from) VALUES (?,?,?,?,?,?,?,?,?,?,?,NULL,?,?,?,?,?,?,?)').run(id, p.name, p.description ?? '', p.role, p.type_id ?? null, p.provider, p.model ?? '', p.effort ?? '', p.system_prompt ?? '', (p.permission ?? 'acceptEdits'), p.cwd ?? '', 'idle', t, t, p.colony_id ?? null, JSON.stringify(p.overrides ?? []), p.browser && p.provider === 'claude' ? 1 : 0, p.cloned_from ?? null);
         agents.setSkills(id, p.skill_ids ?? [], p.skill_loads);
         agents.setWorkers(id, p.worker_ids ?? []);
         return agents.get(id);
@@ -207,8 +207,8 @@ export const agents = {
         if (!cur)
             return;
         const n = { ...cur, ...p };
-        q('UPDATE agents SET name=?, description=?, role=?, type_id=?, provider=?, model=?, system_prompt=?, permission=?, cwd=?, colony_id=?, overrides=?, browser=?, 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 ?? []), n.browser && n.provider === 'claude' ? 1 : 0, now(), id);
+        q('UPDATE agents SET name=?, description=?, role=?, type_id=?, provider=?, model=?, effort=?, system_prompt=?, permission=?, cwd=?, colony_id=?, overrides=?, browser=?, updated_at=? WHERE id=?')
+            .run(n.name, n.description, n.role, n.type_id, n.provider, n.model, n.effort ?? '', n.system_prompt, n.permission, n.cwd, n.colony_id ?? null, JSON.stringify(n.overrides ?? []), n.browser && n.provider === 'claude' ? 1 : 0, 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)
@@ -220,16 +220,17 @@ export const agents = {
     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) {
-            q(`INSERT INTO agent_sessions (agent_id, provider, session_id, cwd, first_seen, last_seen) VALUES (?,?,?,?,?,?)
+            // The permission is written once, when the session is first seen: it never changes on conflict, or a later change of permission would be hidden.
+            q(`INSERT INTO agent_sessions (agent_id, provider, session_id, cwd, first_seen, last_seen, permission) 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());
+                .run(a.id, a.provider, sessionId, a.effective.cwd, now(), now(), a.effective.permission);
         }
     }),
     /** Logs a native session without making it the agent's current conversation (used for delegations). */
     recordSession(a, sessionId, kind, fromId, task) {
-        q(`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, permission) 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);
+            .run(a.id, a.provider, sessionId, a.effective.cwd, now(), now(), kind, fromId ?? null, task ? task.slice(0, 500) : null, a.effective.permission);
     },
     setSkills: (id, ids, loads) => assignSkills('agent', id, ids, loads),
     /** Replaces the workers an orchestrator may dispatch to (never itself). */
@@ -244,16 +245,28 @@ export const agents = {
     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 ----
+// A delegation is `queued` until the worker's turn starts (it waits behind the worker's other turns), then `running`, then `done`, `failed`
+// or `interrupted` (the server stopped while it was queued or running).
 export const dispatches = {
-    start(from, to, task) {
+    start(from, to, task, mode = 'sync', origin = null) {
         const id = uid();
-        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());
+        q('INSERT INTO dispatches (id, from_id, to_id, task, status, result, created_at, finished_at, mode, origin) VALUES (?,?,?,?,?,NULL,?,NULL,?,?)').run(id, from, to, task, 'queued', now(), mode, origin);
         return id;
     },
+    get: (id) => q('SELECT * FROM dispatches WHERE id=?').get(id),
+    setRunning: (id) => q("UPDATE dispatches SET status='running' WHERE id=? AND status='queued'").run(id),
     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),
+    markNotified: (id) => q('UPDATE dispatches SET notified_at=? WHERE id=? AND notified_at IS NULL').run(now(), id),
+    markRead: (id) => q('UPDATE dispatches SET read_at=? WHERE id=? AND read_at IS NULL').run(now(), id),
+    /** Background tasks of an orchestrator that have not finished yet. */
+    unfinished: (from) => q("SELECT COUNT(*) AS n FROM dispatches WHERE from_id=? AND mode='background' AND status IN ('queued','running')").get(from).n,
+    /** Finished background tasks whose result was not handed to the orchestrator yet. */
+    undelivered: () => q("SELECT * FROM dispatches WHERE mode='background' AND status NOT IN ('queued','running') AND notified_at IS NULL ORDER BY created_at").all(),
+    /** At startup nothing is running any more: what was queued or running is interrupted (a task is never resumed). */
+    interruptLeftovers: () => q("UPDATE dispatches SET status='interrupted', finished_at=? WHERE status IN ('queued','running')").run(now()).changes,
     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.
 q("UPDATE agents SET status='idle' WHERE status='running'").run();
-q("UPDATE dispatches SET status='interrupted' WHERE status='running'").run();
+dispatches.interruptLeftovers();

package/server/dist/dispatches.js

@@ -0,0 +1,126 @@
+import { agents, dispatches } from './db.js';
+import { threads } from './connections/store.js';
+import { liveOrigin, notifyAgentsChanged, startDispatch } from './runtime.js';
+import { deliverTo } from './wake.js';
+import { DomainError } from './errors.js';
+/**
+ * Delegations that outlive a request. A long task held on one HTTP request broke when the client gave up waiting (Node's fetch stops at
+ * five minutes without headers), and the orchestrator lost the answer. Now a task is stored and queued at once and its result is read
+ * from the `dispatches` table: in the background the orchestrator is told when it ends, in the place where it asked (the chat thread or
+ * its web conversation); the synchronous `dispatch` tool polls `dispatch_status` with short calls until it ends.
+ */
+export class DispatchError extends DomainError {
+}
+export const MAX_BACKGROUND = 10; // unfinished background tasks per orchestrator
+export const MAX_WAIT_S = 60; // the longest one `dispatch_status` call waits
+const POLL_MS = 250;
+const RETRY_MS = Number(process.env.HIVE_AM_WAKE_RETRY_MS) || 5000; // wait before trying a delivery again (as wake-ups do)
+const FINISHED = new Set(['done', 'failed', 'interrupted']);
+const NO_TEXT = '(the subagent finished without a text answer)';
+const nameOf = (id) => agents.get(id)?.name ?? 'a removed agent';
+/** Starts a delegation without waiting for it. In the background, its end is announced to the orchestrator; a synchronous one is polled. */
+export async function startTask(fromId, workerName, task, background) {
+    if (background && dispatches.unfinished(fromId) >= MAX_BACKGROUND)
+        throw new DispatchError(`You already have ${MAX_BACKGROUND} background tasks that have not finished, the most allowed. Wait for one to finish (you are told, or ask with dispatch_status) before sending another.`);
+    let origin = null;
+    if (background) {
+        // The answer goes back where the orchestrator was asked, as a wake-up does: the chat thread it is answering now, or its web conversation.
+        const o = liveOrigin(fromId);
+        const thread = o ? threads.get(o.threadId) : undefined;
+        if (o && thread)
+            origin = JSON.stringify({ connection_id: o.connectionId, thread_id: thread.id, req_id: o.group && o.userId ? o.userId : null, req_name: o.group && o.userId ? o.userName : null });
+    }
+    let started;
+    try {
+        started = startDispatch(fromId, workerName, task, background ? 'background' : 'sync', origin);
+    }
+    catch (e) {
+        throw new DispatchError(e instanceof Error ? e.message : String(e));
+    }
+    if (background)
+        void started.done.then(() => announce(started.id), () => announce(started.id));
+    notifyAgentsChanged(); // the interface reloads the dispatch log
+    // The worker's turn starts on the next tick when it is free: answer the state it is really in (running, or queued behind other work).
+    await new Promise((r) => setImmediate(r));
+    return { id: started.id, agent: started.worker.name, status: dispatches.get(started.id)?.status ?? 'queued', mode: background ? 'background' : 'sync' };
+}
+/**
+ * The state of a task, for the orchestrator that started it. With `waitSeconds` it waits up to that long for the end (at most MAX_WAIT_S,
+ * so no single request is long) and answers the state it has then. A finished result read here counts as read.
+ */
+export async function taskStatus(fromId, id, waitSeconds) {
+    if (!id)
+        throw new DispatchError('id is required');
+    let row = dispatches.get(id);
+    if (!row)
+        throw new DispatchError(`There is no delegated task with id "${id}".`, 'not_found');
+    if (row.from_id !== fromId)
+        throw new DispatchError(`Task "${id}" was not started by you.`, 'forbidden');
+    const asked = waitSeconds === undefined || waitSeconds === null || waitSeconds === '' ? 0 : Number(waitSeconds);
+    if (!Number.isFinite(asked) || asked < 0)
+        throw new DispatchError(`wait_seconds must be a number from 0 to ${MAX_WAIT_S}.`);
+    const wait = Math.min(asked, MAX_WAIT_S);
+    const until = Date.now() + wait * 1000;
+    while (!FINISHED.has(row.status) && Date.now() < until) {
+        await new Promise((r) => setTimeout(r, Math.min(POLL_MS, until - Date.now())));
+        row = dispatches.get(id) ?? row;
+    }
+    const out = { id, agent: nameOf(row.to_id), status: row.status, mode: row.mode };
+    if (FINISHED.has(row.status)) {
+        out.result = resultText(row);
+        dispatches.markRead(id);
+    }
+    if (asked > MAX_WAIT_S)
+        out.note = `wait_seconds is capped at ${MAX_WAIT_S}: waited ${MAX_WAIT_S} s at most.`;
+    return out;
+}
+/** What a finished task says: its answer, its error, or why it stopped. */
+function resultText(row) {
+    if (row.status === 'interrupted')
+        return `hive-am restarted while ${nameOf(row.to_id)} was working on it; check the branch or the files and send the task again if needed.`;
+    if (row.status === 'failed')
+        return row.result || 'The turn failed without saying why.';
+    return row.result || NO_TEXT;
+}
+const noticeText = (row) => `Delegated task ${row.id} to ${nameOf(row.to_id)} finished (${row.status}). Result:\n${resultText(row)}`;
+const NEXT = 'Carry on with the work this task was part of and tell the person what came of it';
+const timers = new Map();
+/** Hands the result of a finished background task to the orchestrator, once. Tried again while the platform is not connected yet. */
+async function announce(id, tries = 0) {
+    timers.delete(id);
+    const row = dispatches.get(id);
+    if (!row || row.mode !== 'background' || row.notified_at || !FINISHED.has(row.status))
+        return;
+    const o = row.origin ? JSON.parse(row.origin) : null;
+    const to = { agent_id: row.from_id, connection_id: o?.connection_id ?? null, thread_id: o?.thread_id ?? null, req_id: o?.req_id ?? null, req_name: o?.req_name ?? null };
+    const again = () => {
+        if (tries >= 12) {
+            dispatches.markNotified(id);
+            return;
+        }
+        const t = setTimeout(() => { void announce(id, tries + 1); }, RETRY_MS);
+        t.unref?.();
+        timers.set(id, t);
+    };
+    try {
+        // The row is marked before the turn starts, so a restart in between cannot announce it twice.
+        const mention = to.req_name ? `hive-am mentions ${to.req_name} at the start of your first reply, so do not mention them yourself. ` : '';
+        const out = await deliverTo(to, `${noticeText(row)}\n\n${mention}${NEXT} with channel_reply.`, `🔔 ${noticeText(row)}\n\n${NEXT}.`, () => { dispatches.markNotified(id); });
+        if (out === 'retry')
+            again();
+        // Nobody to tell (the thread is gone, muted or reassigned): the result stays readable with dispatch_status.
+        else if (out === 'dropped')
+            dispatches.markNotified(id);
+    }
+    catch (e) {
+        console.warn(`[dispatch] the result of task ${id} could not be handed to ${nameOf(row.from_id)}: ${e instanceof Error ? e.message : e}`);
+        if (!dispatches.get(id)?.notified_at)
+            again();
+    }
+}
+/** At startup: tasks left queued or running are interrupted, and every finished background task not announced yet is announced now. */
+export function armDispatchNotices() {
+    dispatches.interruptLeftovers();
+    for (const row of dispatches.undelivered())
+        void announce(row.id);
+}

package/server/dist/efforts.js

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DATA_DIR } from './db.js';
+/**
+ * Reasoning effort: how hard the model thinks in a turn. Claude Code and Kiro take `--effort <level>`; OpenCode takes it as a variant of the
+ * model (`provider/model#variant`) and the variants are whatever the chosen model has, so what OpenCode and Kiro report is learned and stored
+ * on disk (`reasoning-efforts.json`), next to what is learned about context windows. An empty effort means the CLI's own default: no flag and no `#variant`.
+ */
+export const EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
+export const validEffort = (v) => typeof v === 'string' && EFFORTS.includes(v);
+/** What an OpenCode variant id can look like (`0`..`5`, `none`, `high`, `xhigh`...). */
+const VARIANT_ID = /^[\w.-]{1,24}$/;
+const FILE = join(DATA_DIR, 'reasoning-efforts.json');
+let known = null;
+const key = (provider, model) => `${provider}:${model}`;
+function load() {
+    if (known)
+        return known;
+    try {
+        known = existsSync(FILE) ? JSON.parse(readFileSync(FILE, 'utf8')) : {};
+    }
+    catch {
+        known = {};
+    }
+    return known;
+}
+/** Remembers the levels models take. Writes the file only when something changed. A model with no levels is remembered as having none. */
+export function learnEfforts(provider, models) {
+    const all = load();
+    let changed = false;
+    for (const [model, variants] of Object.entries(models)) {
+        if (!model || !Array.isArray(variants))
+            continue;
+        const clean = variants.filter((v) => v && VARIANT_ID.test(String(v.id))).map((v) => ({ id: String(v.id), ...(typeof v.level === 'string' && v.level ? { level: v.level } : {}) }));
+        const k = key(provider, model);
+        if (JSON.stringify(all[k]) !== JSON.stringify(clean)) {
+            all[k] = clean;
+            changed = true;
+        }
+    }
+    if (changed) {
+        try {
+            writeFileSync(FILE, JSON.stringify(all, null, 1));
+        }
+        catch { /* best effort: it is learned again next time */ }
+    }
+}
+/** What was learned about a model, or null when nothing was. */
+export const learnedEfforts = (provider, model) => load()[key(provider, model)] ?? null;
+/** The levels the form offers for a provider and (for OpenCode and Kiro) a model. */
+export function effortOptions(provider, model) {
+    const shared = EFFORTS.map((id) => ({ id, level: id }));
+    if (provider === 'claude')
+        return { options: shared, known: true };
+    if (provider === 'kiro') {
+        const learned = model ? learnedEfforts('kiro', model) : null;
+        return learned && learned.length ? { options: learned.map((v) => ({ id: v.id, level: v.id })), known: true } : { options: shared, known: !!learned };
+    }
+    if (model.includes('#'))
+        return { options: [], known: true }; // the model id carries its variant already: nothing is added to it
+    const learned = model ? learnedEfforts('opencode', model) : null;
+    return learned ? { options: learned, known: true } : { options: [], known: false };
+}
+/** Why an effort cannot be stored for this provider and model, or null when it can. An empty effort always can. */
+export function checkEffort(provider, model, effort) {
+    if (effort === undefined || effort === null || effort === '')
+        return null;
+    if (typeof effort !== 'string')
+        return 'effort must be text';
+    if (provider === 'opencode') {
+        if (model.includes('#'))
+            return 'This model id already names its variant: leave the effort empty.';
+        const learned = model ? learnedEfforts('opencode', model) : null;
+        if (!learned)
+            return VARIANT_ID.test(effort) ? null : `"${effort}" is not a variant name`;
+        if (!learned.length)
+            return `${model} takes no effort variant.`;
+        return learned.some((v) => v.id === effort) ? null : `${model} has no "${effort}" variant (it has ${learned.map((v) => v.id).join(', ')}).`;
+    }
+    if (!validEffort(effort))
+        return `effort must be empty or one of ${EFFORTS.join(', ')}`;
+    if (provider === 'kiro' && model) {
+        const l = learnedEfforts('kiro', model);
+        if (l && l.length && !l.some((v) => v.id === effort))
+            return `${model} takes ${l.map((v) => v.id).join(', ')}, not "${effort}".`;
+    }
+    return null;
+}
+/**
+ * What to pass to the CLI for an effort asked at turn time (the agent's, or a connection's). A level that does not apply to the model comes
+ * out empty (the CLI's default) instead of failing the turn; for OpenCode a level name is turned into the variant the model has for it.
+ */
+export function resolveEffort(provider, model, effort) {
+    if (!effort)
+        return '';
+    if (provider === 'opencode') {
+        if (model.includes('#'))
+            return '';
+        const learned = model ? learnedEfforts('opencode', model) : null;
+        if (!learned)
+            return VARIANT_ID.test(effort) ? effort : '';
+        return learned.find((v) => v.id === effort)?.id ?? learned.find((v) => v.level === effort)?.id ?? '';
+    }
+    return checkEffort(provider, model, effort) === null ? effort : '';
+}

package/server/dist/http/routes/agents.js

@@ -10,14 +10,15 @@ import { liveTurn, notifyAgentsChanged, queueDepth, sendTurn, stopAgent } from '
 import { sessionStats } from '../../stats.js';
 import { summaryOf } from '../../sessions-summary.js';
 import { emptyUsage } from '../../pricing.js';
-import { agentOrFail, createAgent, removeAgent, resumeSession, sessionToRead, updateAgent } from '../../services/agents.js';
+import { agentOrFail, cloneAgent, createAgent, permissionStale, removeAgent, resumeSession, sessionToRead, updateAgent } from '../../services/agents.js';
 import { UPLOAD_LIMIT, body } from '../body.js';
 import { HttpError, bad, notFound } from '../errors.js';
 import { route } from '../router.js';
 import { qpath, text, validateAgentInput } from '../validate.js';
-route('GET', '/api/agents', () => agents.list().map((a) => ({ ...a, queued: queueDepth(a.id), live: !!liveTurn(a.id) })));
+route('GET', '/api/agents', () => agents.list().map((a) => ({ ...a, queued: queueDepth(a.id), live: !!liveTurn(a.id), permission_stale: permissionStale(a) })));
 route('POST', '/api/agents', async ({ req }) => createAgent(validateAgentInput(await body(req))));
-route('GET', '/api/agents/:id', ({ params }) => agentOrFail(params[0]));
+route('GET', '/api/agents/:id', ({ params }) => { const a = agentOrFail(params[0]); return { ...a, permission_stale: permissionStale(a) }; });
+route('POST', '/api/agents/:id/clone', async ({ req, params }) => cloneAgent(params[0], await body(req)));
 route('PATCH', '/api/agents/:id', async ({ req, params }) => updateAgent(params[0], validateAgentInput(await body(req), true)));
 route('DELETE', '/api/agents/:id', ({ params }) => { removeAgent(params[0]); return { ok: true }; });
 route('POST', '/api/agents/:id/messages', async ({ req, params }) => {

package/server/dist/http/routes/meta.js

@@ -1,4 +1,7 @@
+import { DATA_DIR } from '../../db.js';
+import { effortOptions, learnedEfforts } from '../../efforts.js';
 import { listModels } from '../../models.js';
+import { learnOpencodeWindows } from '../../providers/opencode-server.js';
 import { isProvider, providerStatus } from '../../services/providers.js';
 import { notFound } from '../errors.js';
 import { route } from '../router.js';
@@ -9,3 +12,12 @@ route('GET', '/api/providers/:p/models', async ({ params }) => {
         throw notFound('Unknown provider');
     return listModels(params[0]);
 });
+// The reasoning levels the agent form offers for a provider and model. OpenCode's depend on the model: when they are not known yet its catalog is read first.
+route('GET', '/api/providers/:p/efforts', async ({ params, url }) => {
+    if (!isProvider(params[0]))
+        throw notFound('Unknown provider');
+    const model = url.searchParams.get('model') ?? '';
+    if (params[0] === 'opencode' && model && !learnedEfforts('opencode', model))
+        await learnOpencodeWindows(DATA_DIR, null);
+    return effortOptions(params[0], model);
+});

package/server/dist/http/routes/notebook.js

@@ -1,4 +1,4 @@
-import { liveIsDirect } from '../../runtime.js';
+import { liveIsDirect, notifyAgentsChanged } from '../../runtime.js';
 import { notebooks } from '../../skills/notebook.js';
 import { NOTEBOOK_SKILL_ID } from '../../skills/defaults.js';
 import { nbView, noteSource, notebookAgent, notebookEnabled } from '../../services/notebook.js';
@@ -23,7 +23,7 @@ route('POST', '/api/notebook/rewrite', async ({ req }) => {
 route('GET', '/api/agents/:id/notebook', ({ params }) => {
     const a = agentOrFail(params[0]);
     const n = notebooks.get(a.id);
-    return { ...nbView(n), updated_at: n.updated_at, updated_by: n.updated_by, enabled: notebookEnabled(a), skill_id: NOTEBOOK_SKILL_ID };
+    return { ...nbView(n), updated_at: n.updated_at, updated_by: n.updated_by, enabled: notebookEnabled(a), skill_id: NOTEBOOK_SKILL_ID, shared_with: notebooks.sharedWith(a.id) };
 });
 route('PUT', '/api/agents/:id/notebook', async ({ req, params }) => {
     requireLocal(req, 'The notebook can only be edited from the local app');
@@ -32,3 +32,11 @@ route('PUT', '/api/agents/:id/notebook', async ({ req, params }) => {
     const n = notebooks.edit(a.id, text(p.content), typeof p.version === 'number' ? p.version : undefined);
     return { ...nbView(n), updated_at: n.updated_at, updated_by: n.updated_by };
 });
+// Leaves the notebook it shares: the agent keeps a copy of the current text of its own and the others keep the shared one.
+route('POST', '/api/agents/:id/notebook/separate', ({ req, params }) => {
+    requireLocal(req, 'The notebook can only be changed from the local app');
+    const a = agentOrFail(params[0]);
+    const n = notebooks.separate(a.id);
+    notifyAgentsChanged();
+    return { ...nbView(n), updated_at: n.updated_at, updated_by: n.updated_by, shared_with: notebooks.sharedWith(a.id) };
+});

package/server/dist/http/routes/orchestration.js

@@ -1,10 +1,11 @@
 import { agents, dispatches } from '../../db.js';
+import { startTask, taskStatus } from '../../dispatches.js';
 import { dispatch, liveTurn, notifyAgentsChanged } from '../../runtime.js';
 import { agentOrFail } from '../../services/agents.js';
 import { body } from '../body.js';
 import { bad } from '../errors.js';
 import { route } from '../router.js';
-import { strList } from '../validate.js';
+import { strList, text } from '../validate.js';
 route('GET', '/api/orchestrators/:id/workers', ({ params }) => {
     const o = agentOrFail(params[0]);
     return o.worker_ids.map((id) => agents.get(id)).filter((w) => !!w).map((w) => ({ name: w.name, role: w.role, description: w.description, provider: w.provider, busy: !!liveTurn(w.id) }));
@@ -18,10 +19,14 @@ route('PUT', '/api/orchestrators/:id/workers', async ({ req, params }) => {
     notifyAgentsChanged();
     return agents.get(o.id);
 });
+// `background: true` returns at once and the orchestrator is told the result later; `poll: true` returns at once too, for a caller that waits
+// with /api/dispatch/status (the synchronous `dispatch` tool). With neither, the request is held until the worker answers, as it always was.
 route('POST', '/api/dispatch', async ({ req }) => {
-    const { from, agent, task } = await body(req);
+    const { from, agent, task, background, poll } = await body(req);
     if (!from || !agent || !task)
         throw bad('from, agent and task are required');
+    if (background === true || poll === true)
+        return startTask(text(from), text(agent), text(task), background === true);
     try {
         return await dispatch(from, agent, task);
     }
@@ -29,4 +34,10 @@ route('POST', '/api/dispatch', async ({ req }) => {
         throw bad(e instanceof Error ? e.message : String(e));
     }
 });
+route('POST', '/api/dispatch/status', async ({ req }) => {
+    const { from, id, wait_seconds } = await body(req);
+    if (!from)
+        throw bad('from is required');
+    return taskStatus(text(from), text(id), wait_seconds);
+});
 route('GET', '/api/dispatches', () => dispatches.recent());

package/server/dist/http/routes/resources.js

@@ -2,6 +2,7 @@ import { notifyAgentsChanged } from '../../runtime.js';
 import { DRIVER_PROPS } from '../../objects/driver-props.js';
 import { composeServices, listContainers, listImages } from '../../objects/docker-info.js';
 import { agentObjectAction, agentObjectLogs, agentObjects } from '../../objects/agent.js';
+import { agentDb } from '../../objects/agent-db.js';
 import { dbColumnsOf, dbHistory, dbHistoryClear, dbRun, dbSavedAdd, dbSavedList, dbSavedRemove, dbSavedUpdate, dbSchemaOf, dbTestConfig, createObject, statsOf, httpDescribe, httpSession, httpSessionClear, httpSessionSet, httpInspect, httpExport, httpFileRead, httpFileWrite, httpFileCreate, httpRun, httpHistory, httpDocs, httpHistoryClear, httpScan, listObjects, setObjectManager, setAgentObjects, objectAction, objectServiceAction, listTemplates, createFromTemplate, objectInspect, objectLogs, removeObject, updateObject } from '../../objects/index.js';
 import { body } from '../body.js';
 import { notFound } from '../errors.js';
@@ -20,6 +21,8 @@ const guarded = (path, fn, method = 'GET') => route(method, path, (ctx) => { loc
 route('POST', '/api/agent-objects/list', async ({ req }) => { const b = await body(req); return { objects: agentObjects(b.from) }; });
 route('POST', '/api/agent-objects/action', async ({ req }) => { const b = await body(req); return agentObjectAction(b.from, b.name, b.action); });
 route('POST', '/api/agent-objects/logs', async ({ req }) => { const b = await body(req); return agentObjectLogs(b.from, b.name, b.tail); });
+// The tools `object_db_*` of the "Database management" skill: one route, the operation in the path; scope and permission are checked in objects/agent-db.ts.
+route('POST', '/api/agent-objects/db/:op', async ({ req, params }) => agentDb(params[0], await body(req)));
 route('GET', '/api/objects', () => listObjects());
 write('POST', '/api/objects', (b) => createObject(b));
 write('PATCH', '/api/objects/:id', (b, { params }) => updateObject(params[0], b));

package/server/dist/http/routes/types.js

@@ -4,6 +4,7 @@ import { body } from '../body.js';
 import { bad, notFound } from '../errors.js';
 import { route } from '../router.js';
 import { isProvider } from '../../services/providers.js';
+import { checkEffort } from '../../efforts.js';
 import { requireName, text, validateAgentInput } from '../validate.js';
 route('GET', '/api/types', () => types.list());
 route('POST', '/api/types', async ({ req }) => {
@@ -11,6 +12,9 @@ route('POST', '/api/types', async ({ req }) => {
     const name = requireName(p.name);
     if (!isProvider(p.provider))
         throw bad('Pick a provider');
+    const why = checkEffort(p.provider, text(p.model), p.effort);
+    if (why)
+        throw bad(why);
     try {
         return types.create({ ...p, name });
     }
@@ -19,7 +23,20 @@ route('POST', '/api/types', async ({ req }) => {
     }
 });
 route('PATCH', '/api/types/:id', async ({ req, params }) => {
-    const t = types.update(params[0], await body(req));
+    const cur = types.get(params[0]);
+    if (!cur)
+        throw notFound('Type not found');
+    const p = await body(req);
+    // The effort has to apply to the provider and model the type will have; one that no longer does is cleared.
+    const provider = isProvider(p.provider) ? p.provider : cur.provider, model = p.model !== undefined ? text(p.model) : cur.model;
+    if (p.effort !== undefined) {
+        const why = checkEffort(provider, model, p.effort);
+        if (why)
+            throw bad(why);
+    }
+    else if (cur.effort && checkEffort(provider, model, cur.effort) !== null)
+        p.effort = '';
+    const t = types.update(params[0], p);
     if (!t)
         throw notFound('Type not found');
     return t;

package/server/dist/http/validate.js

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { agents, colonies } from '../db.js';
 import { validVision } from '../connections/vision.js';
 import { isProvider } from '../services/providers.js';
+import { EFFORTS, validEffort } from '../efforts.js';
 import { bad } from './errors.js';
 /** Plain value helpers: what a field is when it may be missing or of the wrong type. */
 export const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
@@ -29,6 +30,8 @@ export function validateAgentInput(p, partial = false) {
     checkFolder(p.cwd);
     if (p.browser !== undefined && typeof p.browser !== 'boolean')
         throw bad('browser must be true or false');
+    if (p.effort !== undefined && (typeof p.effort !== 'string' || p.effort.length > 24))
+        throw bad('effort must be text');
     if (p.colony_id && (typeof p.colony_id !== 'string' || !colonies.get(p.colony_id)))
         throw bad('That colony no longer exists');
     return p;
@@ -39,22 +42,42 @@ export function validateColony(p, partial = false) {
     checkFolder(p.cwd);
     return p;
 }
+const MAX_CHATS = 50;
+const MAX_CHAT_MEMBERS = 50;
+/** What a person's id looks like on each platform: Telegram user ids are positive numbers; Slack member ids are `U…` (or `W…` on Enterprise Grid). */
+const MEMBER_ID = { telegram: /^\d+$/, slack: /^[UW][A-Z0-9]{2,}$/ };
+/** One authorized group: its mode, and when it only admits some people, who they are. */
+function validateChat(kind, c) {
+    const r = isRecord(c) ? c : {};
+    if (r.mode !== undefined && r.mode !== 'everyone' && r.mode !== 'members')
+        throw bad('chat mode must be everyone or members');
+    if (r.members === undefined)
+        return;
+    if (!Array.isArray(r.members) || r.members.length > MAX_CHAT_MEMBERS)
+        throw bad(`a chat can list at most ${MAX_CHAT_MEMBERS} members`);
+    const shape = MEMBER_ID[kind];
+    if (shape && r.members.some((m) => !shape.test(trimmed(isRecord(m) ? m.id : m))))
+        throw bad('member ids must be numbers on Telegram and start with U or W on Slack');
+}
 export const CONNECTION_KINDS = ['telegram', 'slack'];
 const REQUIRED = { telegram: ['token'], slack: ['bot_token', 'app_token'] };
 export function validateConnection(kind, config, agentId, enabled) {
     const missing = (REQUIRED[kind] ?? []).filter((k) => typeof config[k] !== 'string' || !config[k].trim());
     if (missing.length)
         throw bad(`Missing: ${missing.join(', ')}`);
-    if (config.effort !== undefined && !['', 'low', 'medium', 'high'].includes(config.effort))
-        throw bad('effort must be empty, low, medium or high');
+    if (config.effort !== undefined && config.effort !== '' && !validEffort(config.effort))
+        throw bad(`effort must be empty or one of ${EFFORTS.join(', ')}`);
     if (config.on_silent !== undefined && !['notice', 'send_text', 'ignore'].includes(config.on_silent))
         throw bad('on_silent must be notice, send_text or ignore');
     if (config.group_mode !== undefined && !['mention', 'open'].includes(config.group_mode))
         throw bad('group_mode must be mention or open');
     if (config.vision !== undefined && config.vision !== null && !validVision(config.vision))
         throw bad('vision must be { provider, model } or empty');
-    if (config.chats !== undefined && (!Array.isArray(config.chats) || config.chats.length > 50))
-        throw bad('chats must be a list of at most 50 groups');
+    if (config.chats !== undefined && (!Array.isArray(config.chats) || config.chats.length > MAX_CHATS))
+        throw bad(`chats must be a list of at most ${MAX_CHATS} groups`);
+    if (Array.isArray(config.chats))
+        for (const c of config.chats)
+            validateChat(kind, c);
     if (config.aliases !== undefined && (!Array.isArray(config.aliases) || config.aliases.length > 10))
         throw bad('aliases must be a list of at most 10 names');
     if (agentId) {

package/server/dist/index.js

@@ -10,6 +10,7 @@ import './connections/index.js';
 import { startAll, stopAll } from './connections/manager.js';
 import { addReactionsToChannelSkill, migrateChannelSkill } from './connections/channel-skill.js';
 import { armWakeups } from './wake.js';
+import { armDispatchNotices } from './dispatches.js';
 import { armSchedules } from './schedules.js';
 import { armWatches } from './watch.js';
 import { armObjects } from './objects/index.js';
@@ -21,6 +22,7 @@ dropStarterSkills();
 migrateChannelSkill();
 addReactionsToChannelSkill();
 armWakeups();
+armDispatchNotices();
 armSchedules();
 armWatches();
 armObjects();
@@ -71,12 +73,15 @@ async function shutdown(why, code) {
     catch (e) {
         console.error(`[server] shutdown, ${name}:`, e);
     } };
-    await step('http', () => new Promise((done) => { server.close(() => done()); server.closeAllConnections(); }));
+    // `server.close` only ends once every connection is gone, and a WebSocket is not one `closeAllConnections` can close: stop taking requests first,
+    // drop the sockets, and only then wait for the server (waiting first made every shutdown last the full 5 s and left the database unclosed).
+    const httpClosed = new Promise((done) => { server.close(() => done()); server.closeAllConnections(); });
     await step('websockets', () => { for (const w of [wss, termWss]) {
         for (const c of w.clients)
             c.terminate();
         w.close();
     } });
+    await step('http', () => httpClosed);
     await step('terminals', closeAllTerminals);
     await step('connections', stopAll);
     await step('database', () => db.close());