hive-am 1.0.0 → 1.2.0

package/server/dist/wake.js

@@ -0,0 +1,149 @@
+import { randomUUID } from 'node:crypto';
+import { agents, db } from './db.js';
+import { adapterFor } from './connections/manager.js';
+import { deliverScheduled } from './connections/router.js';
+import { connections, threads } from './connections/store.js';
+import { liveOrigin, liveSource, sendTurn } from './runtime.js';
+import { DomainError } from './errors.js';
+/**
+ * Wake-ups. An agent only runs while it handles a message, so "I'll tell you when it finishes" cannot be kept by an agent that just
+ * says it: it has to ask hive-am to wake it. `wake_me` stores the request; when it is due, the agent receives a message and answers.
+ * Asked from a chat (Telegram, Slack…) the wake-up comes back to that same thread; asked from the hive-am web chat it comes back as a
+ * message of the agent's own conversation.
+ */
+export class WakeError extends DomainError {
+}
+export const WAKE_MIN_MINUTES = 1, WAKE_MAX_MINUTES = 240, WAKE_MAX_PENDING = 5;
+const WAKE_MS = Number(process.env.HIVE_AM_WAKE_MS_PER_MINUTE) || 60_000; // tests shrink a "minute"
+const RETRY_MS = Number(process.env.HIVE_AM_WAKE_RETRY_MS) || 5000; // wait before trying a delivery again
+const TOO_LATE_MS = 2 * 3_600_000; // after a long outage, an old reminder is no longer useful
+const rows = {
+    get: (id) => db.prepare('SELECT * FROM agent_wakeups WHERE id=?').get(id),
+    all: () => db.prepare('SELECT * FROM agent_wakeups ORDER BY due_at').all(),
+    remove: (id) => db.prepare('DELETE FROM agent_wakeups WHERE id=?').run(id).changes > 0,
+    pending: (agentId, threadId) => (threadId
+        ? db.prepare('SELECT COUNT(*) AS n FROM agent_wakeups WHERE thread_id=?').get(threadId)
+        : db.prepare('SELECT COUNT(*) AS n FROM agent_wakeups WHERE agent_id=? AND thread_id IS NULL').get(agentId)),
+    same: (agentId, threadId, note) => (threadId
+        ? db.prepare('SELECT * FROM agent_wakeups WHERE thread_id=? AND lower(note)=lower(?)').get(threadId, note)
+        : db.prepare('SELECT * FROM agent_wakeups WHERE agent_id=? AND thread_id IS NULL AND lower(note)=lower(?)').get(agentId, note)),
+    add(w) {
+        const row = { ...w, id: randomUUID(), created_at: Date.now() };
+        db.prepare('INSERT INTO agent_wakeups (id,agent_id,connection_id,thread_id,due_at,note,created_at,req_id,req_name) VALUES (?,?,?,?,?,?,?,?,?)').run(row.id, row.agent_id, row.connection_id, row.thread_id, row.due_at, row.note, row.created_at, row.req_id, row.req_name);
+        return row;
+    },
+};
+const wakeText = (w, replyTool) => `Scheduled wake-up (you set it at ${hhmm(w.created_at)}${w.req_name ? `, asked by ${w.req_name}` : ''}). Your note: ${w.note}\n\n${w.req_name ? `hive-am mentions ${w.req_name} at the start of your first reply, so do not mention them yourself. ` : ''}Check now what you were waiting for and tell the person${replyTool ? ` with ${replyTool}` : ''}: done, still running (then schedule another wake-up with wake_me) or failed. Give the actual result, not just that you woke up.`;
+const hhmm = (t) => new Date(t).toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' });
+const timers = new Map();
+function arm(w, tries = 0) {
+    const t = setTimeout(() => { void fire(w.id, tries); }, Math.max(0, w.due_at - Date.now()));
+    t.unref?.();
+    timers.set(w.id, t);
+}
+let override = null;
+/** Tests replace the delivery to watch what would be sent without running a model. */
+export const setDeliveryForTests = (fn) => { override = fn; };
+/**
+ * Hands a message to the agent in the place where it was asked: the chat thread (where the person who asked is mentioned) or the web conversation.
+ * `retry` means the platform is not connected yet (right after a start); `dropped` that there is nobody to tell (thread gone, connection off or
+ * reassigned, muted on purpose). `beforeSend` runs once the message is certain to go, so the caller can forget the request before the turn starts.
+ */
+export const deliverTo = async (to, threadText, webText, beforeSend) => {
+    if (override)
+        return override(to, threadText, webText, beforeSend);
+    const agent = agents.get(to.agent_id);
+    if (!agent)
+        return 'dropped';
+    if (to.thread_id) {
+        const conn = connections.get(to.connection_id ?? ''), thread = threads.get(to.thread_id);
+        if (!conn || !conn.enabled || !thread)
+            return 'dropped';
+        const adapter = adapterFor(conn.id);
+        if (!adapter)
+            return 'retry';
+        beforeSend?.();
+        if (thread.muted || conn.agent_id !== to.agent_id)
+            return 'dropped';
+        await deliverScheduled(conn, adapter, thread, threadText, to.req_id ? { id: to.req_id, name: to.req_name || 'you' } : undefined);
+        return 'sent';
+    }
+    beforeSend?.();
+    await sendTurn(agent.id, webText, 'user');
+    return 'sent';
+};
+async function fire(id, tries) {
+    timers.delete(id);
+    const w = rows.get(id);
+    if (!w)
+        return;
+    try {
+        const out = await deliverTo(w, wakeText(w, 'channel_reply'), `🔔 ${wakeText(w)}`, () => { rows.remove(id); });
+        if (out === 'retry') {
+            if (tries < 12) {
+                w.due_at = Date.now() + RETRY_MS;
+                arm(w, tries + 1);
+            }
+            else
+                rows.remove(id);
+        }
+        else if (out === 'dropped')
+            rows.remove(id);
+    }
+    catch (e) {
+        console.warn(`[wake] wake-up of agent ${agents.get(w.agent_id)?.name ?? w.agent_id} failed: ${e instanceof Error ? e.message : e}`);
+        // A failure before the message was handed over (the platform erred) must not strand the row: with no timer it would count as pending until the next restart. Try again a few times, then give up.
+        if (rows.get(id)) {
+            if (tries < 12) {
+                w.due_at = Date.now() + RETRY_MS;
+                arm(w, tries + 1);
+            }
+            else
+                rows.remove(id);
+        }
+    }
+}
+/** Re-arms the wake-ups saved before a restart (called once at startup). */
+export function armWakeups() {
+    for (const w of rows.all()) {
+        if (Date.now() - w.due_at > TOO_LATE_MS)
+            rows.remove(w.id);
+        else
+            arm(w);
+    }
+}
+/** `wake_me`: the agent asks to be woken after some minutes. */
+export function scheduleWake(agentId, minutes, note) {
+    if (!agents.get(agentId))
+        throw new WakeError('Unknown agent');
+    if (liveSource(agentId) === 'dispatch')
+        throw new WakeError('Wake-ups are not available while you work on a task delegated by an orchestrator: finish it and report what is left.');
+    const mins = Number(minutes);
+    if (!(mins >= WAKE_MIN_MINUTES && mins <= WAKE_MAX_MINUTES))
+        throw new WakeError(`minutes must be between ${WAKE_MIN_MINUTES} and ${WAKE_MAX_MINUTES}.`);
+    const text = String(note ?? '').trim();
+    if (!text)
+        throw new WakeError('Say in the note what to check when you wake up.');
+    if (text.length > 400)
+        throw new WakeError('The note is too long (400 characters at most).');
+    const origin = liveOrigin(agentId);
+    const thread = origin ? threads.get(origin.threadId) : undefined;
+    if (origin && !thread)
+        throw new WakeError('The thread no longer exists.');
+    // The same request twice (a model that retried after a hiccup) is one wake-up, not two.
+    const dup = rows.same(agentId, thread?.id ?? null, text);
+    if (dup)
+        return { at: hhmm(dup.due_at), minutes: Math.max(1, Math.round((dup.due_at - Date.now()) / WAKE_MS)), where: thread ? 'thread' : 'chat' };
+    if (rows.pending(agentId, thread?.id ?? null).n >= WAKE_MAX_PENDING)
+        throw new WakeError(`There are already ${WAKE_MAX_PENDING} wake-ups pending ${thread ? 'in this thread' : 'for you'}. Wait for one to fire.`);
+    const w = rows.add({ agent_id: agentId, connection_id: origin?.connectionId ?? null, thread_id: thread?.id ?? null, due_at: Date.now() + mins * WAKE_MS, note: text, req_id: origin?.group && origin.userId ? origin.userId : null, req_name: origin?.group && origin.userId ? origin.userName : null });
+    arm(w);
+    return { at: hhmm(w.due_at), minutes: mins, where: thread ? 'thread' : 'chat' };
+}
+export const pendingWakeups = () => rows.all();
+/** For the interface: pending one-shot wake-ups, and a way to cancel them. */
+export const listWakeups = () => rows.all();
+export const removeWakeup = (id) => { const t = timers.get(id); if (t) {
+    clearTimeout(t);
+    timers.delete(id);
+} return rows.remove(id); };

package/server/dist/watch.js

@@ -0,0 +1,201 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { isAbsolute, join, resolve, sep } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { agents, db, resolved } from './db.js';
+import { liveOrigin, liveSource } from './runtime.js';
+import { adapterFor } from './connections/manager.js';
+import { connections, threadMessages, threads } from './connections/store.js';
+import { deliverTo } from './wake.js';
+import { DomainError } from './errors.js';
+/**
+ * "Tell me the moment it finishes." The agent starts a long command in the background itself (`nohup … > log 2>&1 &`) and asks hive-am to
+ * watch its process: when it ends (or a marker file appears, or the waiting time runs out) the agent is woken in the same place where it
+ * was asked, to read the result and report. hive-am only checks that a process is alive; it never runs anything. A job on another machine
+ * works too when it is started through a local `ssh`, which lives as long as the remote command does.
+ */
+export class WatchError extends DomainError {
+}
+const POLL_MS = Number(process.env.HIVE_AM_WATCH_POLL_MS) || 1500;
+const MS_PER_MINUTE = Number(process.env.HIVE_AM_WAKE_MS_PER_MINUTE) || 60_000;
+export const WATCH_DEFAULT_MINUTES = 120, WATCH_MAX_MINUTES = 240, WATCH_MAX_PENDING = 5;
+const rows = {
+    all: () => db.prepare('SELECT * FROM agent_watches ORDER BY started_at').all(),
+    forAgent: (agentId) => db.prepare('SELECT * FROM agent_watches WHERE agent_id=?').all(agentId),
+    remove: (id) => db.prepare('DELETE FROM agent_watches WHERE id=?').run(id).changes > 0,
+    add(w) {
+        const row = { ...w, id: randomUUID() };
+        db.prepare('INSERT INTO agent_watches (id,agent_id,connection_id,thread_id,pid,pid_stamp,file,log,note,started_at,deadline,req_id,req_name) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)')
+            .run(row.id, row.agent_id, row.connection_id, row.thread_id, row.pid, row.pid_stamp, row.file, row.log, row.note, row.started_at, row.deadline, row.req_id, row.req_name);
+        return row;
+    },
+};
+/** An identifier of "this very process" (its start time), so that a PID the system reuses for something else is not mistaken for the job. null = not running. */
+export function processStamp(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const rest = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+        return rest[0] === 'Z' || rest[0] === 'X' ? null : rest[19] ?? null; // a finished job nobody has collected yet (zombie) is finished
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT' || existsSync('/proc/self'))
+            return null; // Linux: no such process
+    }
+    try { // macOS and others
+        const out = execFileSync('ps', ['-o', 'stat=,lstart=', '-p', String(pid)], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        if (!out || out.startsWith('Z'))
+            return null;
+        return out.replace(/^\S+\s+/, '');
+    }
+    catch {
+        return null;
+    }
+}
+export const isAlive = (pid, stamp) => { const s = processStamp(pid); return s !== null && (stamp === null || s === stamp); };
+/** How long it took, in plain words. */
+const took = (since) => { const s = Math.max(1, Math.round((Date.now() - since) / 1000)); return s < 90 ? `${s} s` : s < 5400 ? `${Math.round(s / 60)} min` : `${(s / 3600).toFixed(1)} h`; };
+const hhmm = (t) => new Date(t).toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' });
+const inside = (child, root) => child === root || child.startsWith(root.endsWith(sep) ? root : root + sep);
+export function createWatch(agentId, input) {
+    const agent = agents.get(agentId);
+    if (!agent)
+        throw new WatchError('Unknown agent');
+    if (liveSource(agentId) === 'dispatch')
+        throw new WatchError('Waiting for a process is not available while you work on a task delegated by an orchestrator.');
+    const note = String(input.note ?? '').trim();
+    if (!note)
+        throw new WatchError('Say in the note what to check and report when it finishes.');
+    if (note.length > 400)
+        throw new WatchError('The note is too long (400 characters at most).');
+    const pid = Number(input.pid);
+    if (!Number.isInteger(pid) || pid < 2)
+        throw new WatchError('pid must be the number of the process to wait for (for example the output of `echo $!` right after starting it in the background).');
+    if (pid === process.pid || pid === process.ppid)
+        throw new WatchError('That is not the process you started.');
+    const stamp = processStamp(pid);
+    if (stamp === null)
+        throw new WatchError(`Process ${pid} is not running (it may have finished already): look at its result now instead of waiting.`);
+    let file = null;
+    if (input.file !== undefined && input.file !== null && String(input.file).trim() !== '') {
+        const cwd = resolved(agent).cwd;
+        const p = resolve(isAbsolute(String(input.file)) ? String(input.file) : join(cwd, String(input.file)));
+        if (![cwd, tmpdir(), homedir()].filter(Boolean).some((r) => inside(p, resolve(r))))
+            throw new WatchError('The marker file must be inside your working folder, your home folder or the temp folder.');
+        file = p;
+    }
+    const log = input.log === undefined || input.log === null || String(input.log).trim() === '' ? null : String(input.log).trim().slice(0, 300);
+    const minutes = input.max_minutes === undefined || input.max_minutes === null ? WATCH_DEFAULT_MINUTES : Number(input.max_minutes);
+    if (!(minutes >= 1 && minutes <= WATCH_MAX_MINUTES))
+        throw new WatchError(`max_minutes must be between 1 and ${WATCH_MAX_MINUTES}.`);
+    const origin = liveOrigin(agentId), thread = origin ? threads.get(origin.threadId) : undefined;
+    if (origin && !thread)
+        throw new WatchError('The thread no longer exists.');
+    const mine = rows.forAgent(agentId);
+    const same = mine.find((w) => w.pid === pid && w.pid_stamp === stamp);
+    if (same)
+        return { id: same.id, until: hhmm(same.deadline), where: same.thread_id ? 'thread' : 'chat', reused: true };
+    if (mine.length >= WATCH_MAX_PENDING)
+        throw new WatchError(`You are already waiting for ${WATCH_MAX_PENDING} processes. Wait for one to finish.`);
+    const now = Date.now();
+    const w = rows.add({
+        agent_id: agentId, connection_id: origin?.connectionId ?? null, thread_id: thread?.id ?? null, pid, pid_stamp: stamp, file, log, note, started_at: now, deadline: now + minutes * MS_PER_MINUTE,
+        req_id: origin?.group && origin.userId ? origin.userId : null, req_name: origin?.group && origin.userId ? origin.userName : null,
+    });
+    poll.ensure();
+    return { id: w.id, until: hhmm(w.deadline), where: thread ? 'thread' : 'chat', reused: false };
+}
+function text(w, reason, replyTool) {
+    const dur = took(w.started_at);
+    const who = w.req_name ? `hive-am mentions ${w.req_name} at the start of your first reply, so do not mention them yourself. ` : '';
+    const how = `tell the person${replyTool ? ` with ${replyTool}` : ''}`;
+    const logLine = w.log ? ` Its output is in ${w.log}.` : '';
+    if (reason === 'timeout') {
+        return `You were waiting for the process ${w.pid}${w.req_name ? ` (asked by ${w.req_name})` : ''}, and after ${dur} it is still running.${logLine} Your note: ${w.note}\n\n${who}Look at how it is going (its log) and ${how}. If it is worth waiting longer, call wake_when_done again; otherwise say what you saw.`;
+    }
+    const what = reason === 'file' ? `The marker file ${w.file} you were waiting for appeared (${dur} after you asked).` : `The process ${w.pid} you were waiting for has ended (${dur} after you asked, at ${hhmm(Date.now())}).`;
+    return `${what}${logLine}${w.req_name ? ` Asked by ${w.req_name}.` : ''} Your note: ${w.note}\n\n${who}Look at the result now (read the output or check the outcome) and ${how}: whether it succeeded or failed, with the evidence (the lines that show it). Never paste secrets or a whole log.`;
+}
+/**
+ * The instant the process ends hive-am tells the thread itself, in one line (the agent still has to read the result, which takes it several
+ * seconds): "it finished" arrives right away and the agent's report follows. Nothing is sent when the thread is muted or the platform is down.
+ */
+async function noticeNow(w, reason) {
+    if (!w.thread_id || reason === 'timeout')
+        return;
+    try {
+        const conn = connections.get(w.connection_id ?? ''), thread = threads.get(w.thread_id), adapter = conn && adapterFor(conn.id);
+        if (!conn || !conn.enabled || !thread || thread.muted || conn.agent_id !== w.agent_id || !adapter)
+            return;
+        const dur = took(w.started_at);
+        const who = w.req_id && adapter.mention ? `${adapter.mention({ id: w.req_id, name: w.req_name || 'you' })} ` : '';
+        const es = conn.config.lang !== 'en';
+        const body = reason === 'file'
+            ? (es ? `Apareció el archivo que esperabas (${dur}). Reviso el resultado…` : `The file you were waiting for appeared (${dur}). Checking the result…`)
+            : (es ? `Terminó el proceso que esperabas (PID ${w.pid}, ${dur}). Reviso el resultado…` : `The process you were waiting for (PID ${w.pid}) has finished (${dur}). Checking the result…`);
+        const msg = `🔔 ${who}${body}`;
+        const { externalId } = await adapter.send(thread.target, msg);
+        threadMessages.record(thread.id, 'out', externalId, { name: agents.get(w.agent_id)?.name }, msg);
+    }
+    catch (e) {
+        console.warn(`[watch] the immediate notice failed: ${e instanceof Error ? e.message : e}`);
+    }
+}
+const firing = new Set();
+async function fire(w, reason) {
+    if (firing.has(w.id))
+        return;
+    firing.add(w.id);
+    try {
+        await noticeNow(w, reason);
+        const out = await deliverTo(w, text(w, reason, 'channel_reply'), `🔔 ${text(w, reason)}`, () => { rows.remove(w.id); });
+        if (out === 'dropped')
+            rows.remove(w.id);
+    }
+    catch (e) {
+        console.warn(`[watch] telling agent ${agents.get(w.agent_id)?.name ?? w.agent_id} failed: ${e instanceof Error ? e.message : e}`);
+        rows.remove(w.id);
+    }
+    finally {
+        firing.delete(w.id);
+    }
+}
+const poll = {
+    timer: null,
+    ensure() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => this.tick(), POLL_MS);
+        this.timer.unref?.();
+    },
+    tick() {
+        const all = rows.all();
+        if (all.length === 0 && this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+            return;
+        }
+        const now = Date.now();
+        for (const w of all) {
+            if (firing.has(w.id))
+                continue;
+            if (w.file && existsSync(w.file))
+                void fire(w, 'file');
+            else if (!isAlive(w.pid, w.pid_stamp))
+                void fire(w, 'ended');
+            else if (now >= w.deadline)
+                void fire(w, 'timeout');
+        }
+    },
+};
+/** Starts watching what was saved before a restart (the jobs themselves keep running without hive-am). */
+export function armWatches() { if (rows.all().length)
+    poll.ensure(); }
+export const pendingWatches = () => rows.all();
+export function removeWatch(id) { return rows.remove(id); }
+export function cancelWatchFor(agentId, id) {
+    const w = rows.forAgent(agentId).find((x) => x.id === id);
+    if (!w)
+        throw new WatchError('You are not waiting for anything with that id.');
+    return rows.remove(id);
+}

package/server/mcp/dispatch.mjs

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 // Minimal MCP stdio server for hive-am agents. Tool groups come from HIVE_CAPS:
 //   dispatch → list_agents, dispatch (orchestrators with a team)
-//   channel  → channel_reply (agents linked to Telegram/Slack)
+//   channel  → channel_reply, channel_send_file, channel_react, channel_mute (agents linked to Telegram/Slack)
+//   wake     → wake_me, wake_when_done, schedule_create, schedule_list, schedule_cancel (agents with the Wake-ups skill: to be woken later in the same place)
+//   objects  → object_list, object_logs, object_action (agents with the Colony objects skill: the servers and containers of their colony)
 // It only talks to the hive-am HTTP API; all rules (assignments, queueing) live there.
 import { createInterface } from 'node:readline';
 
@@ -100,6 +102,17 @@ const allTools = [
       additionalProperties: false,
     },
   },
+  {
+    cap: 'channel',
+    name: 'channel_react',
+    description: 'React with ONE emoji to the message you are handling (a thumbs-up to say "got it", a heart to say thanks). It is lighter than a reply and counts as your answer when nothing else needs saying. Each platform allows only some emoji (on Telegram a fixed list: 👍 👎 ❤ 🔥 👏 🎉 🙏 👌 👀 💯 🤔 😁 😢 ✍ 🫡 …); an emoji that is not allowed is refused and the error lists the ones you can use. Follow the "Chat channels" skill for when to react.',
+    inputSchema: {
+      type: 'object',
+      properties: { emoji: { type: 'string', description: 'A single emoji, e.g. 👍.' } },
+      required: ['emoji'],
+      additionalProperties: false,
+    },
+  },
   {
     cap: 'channel',
     name: 'channel_mute',
@@ -111,6 +124,99 @@ const allTools = [
       additionalProperties: false,
     },
   },
+  {
+    cap: 'objects',
+    name: 'object_list',
+    description: 'List the objects of your colony (servers and Docker containers that hive-am keeps running): name, kind, state (running, starting, stopped, error, unknown) and the reason when there is one. Use the exact names in the other object tools.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    cap: 'objects',
+    name: 'object_logs',
+    description: 'Read the latest output of an object of your colony (a server or a container). Read it before restarting something that fails. Logs can contain secrets: never repeat them in a chat.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'The exact name of the object, as object_list shows it.' },
+        tail: { type: 'number', description: 'How many of the last lines to read (default 80, at most 500).' },
+      },
+      required: ['name'],
+      additionalProperties: false,
+    },
+  },
+  {
+    cap: 'objects',
+    name: 'object_action',
+    description: 'Start, stop or restart an object of your colony. Not available in read-only mode. It answers with the state it ended in: check it with object_list a moment later, since a server can take a while to come up. Starting, stopping and restarting interrupt whoever uses it: do not do it for something that runs fine unless you were asked.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'The exact name of the object.' },
+        action: { type: 'string', enum: ['start', 'stop', 'restart'] },
+      },
+      required: ['name', 'action'],
+      additionalProperties: false,
+    },
+  },
+  {
+    cap: 'wake',
+    name: 'wake_me',
+    description: 'Schedule yourself to be woken up after some minutes, in the same place where you were asked (the same chat thread, or the same web conversation). You can only write while you are handling a message, so this is the ONLY way to tell the person something later (for example when a long deploy or job should be finished). When the time comes you receive a message with your note, check what you were waiting for and answer. Never promise "I will let you know" without calling this first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        minutes: { type: 'number', description: 'Minutes from now, between 1 and 240.' },
+        note: { type: 'string', description: 'What to check when you wake up and what to tell the person (for example: check ~/job.log, report if it finished or failed). Up to 400 characters.' },
+      },
+      required: ['minutes', 'note'],
+      additionalProperties: false,
+    },
+  },
+  {
+    cap: 'wake',
+    name: 'wake_when_done',
+    description: 'Be woken up THE MOMENT a command you started in the background finishes, in the same place where you were asked (the same chat thread, or the same web conversation), to read the result and tell the person. Start the command yourself in the background with its output in a log (for example `nohup ./deploy.sh > ~/deploy.log 2>&1 & echo $!`; for a job on another machine run the ssh itself in the background: `nohup ssh host \'./job.sh\' > ~/job.log 2>&1 & echo $!`, because the local ssh lives as long as the remote command), then call this with that pid. hive-am only watches the process; it never runs anything. If the process is already gone, check the result now instead. You can also give a marker file that the job creates when it ends. If it is still running after max_minutes you are woken anyway. Never promise "I will tell you when it finishes" without calling this first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pid: { type: 'number', description: 'Process id of the background command (the output of `echo $!` right after starting it).' },
+        log: { type: 'string', description: 'Path of the file where its output goes; you will be told it when you wake up.' },
+        file: { type: 'string', description: 'Optional: a marker file that the job creates when it ends; waking up also happens when it appears (must be in your working folder, home or temp).' },
+        note: { type: 'string', description: 'What to check and report when it finishes (up to 400 characters).' },
+        max_minutes: { type: 'number', description: 'How long to wait at most, 1 to 240 (default 120).' },
+      },
+      required: ['pid', 'note'],
+      additionalProperties: false,
+    },
+  },
+  {
+    cap: 'wake',
+    name: 'schedule_create',
+    description: 'Create a RECURRING schedule: at each run you are woken up in the same place where you were asked (the same chat thread, or the same web conversation), with your note, and you do what it says and tell the person. Use "cron" (5 fields: minute hour day-of-month month day-of-week, e.g. "0 9 * * MON-FRI") or "every_minutes". The minimum gap between runs is 15 minutes. For something that happens once, use wake_me instead. The answer gives the next run times: tell them to the person.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        cron: { type: 'string', description: 'Cron expression, e.g. "30 8 * * MON-FRI" (weekdays 08:30) or "0 */6 * * *" (every 6 hours).' },
+        every_minutes: { type: 'number', description: 'Alternative to cron: a fixed interval in minutes (15 or more).' },
+        timezone: { type: 'string', description: 'IANA time zone for cron, e.g. "America/Mexico_City". Defaults to the server time zone.' },
+        note: { type: 'string', description: 'What to do at each run and what to report (up to 400 characters).' },
+      },
+      required: ['note'],
+      additionalProperties: false,
+    },
+  },
+  {
+    cap: 'wake',
+    name: 'schedule_list',
+    description: 'List your recurring schedules (id, when, note, next run, last result).',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    cap: 'wake',
+    name: 'schedule_cancel',
+    description: 'Cancel one of your recurring schedules by id (see schedule_list).',
+    inputSchema: { type: 'object', properties: { id: { type: 'string', description: 'The schedule id.' } }, required: ['id'], additionalProperties: false },
+  },
 ];
 const tools = allTools.filter((t) => CAPS.has(t.cap)).map(({ cap, ...t }) => t);
 
@@ -169,6 +275,15 @@ async function call(name, args) {
     if (!r.ok) throw new Error(j.error ?? `channel_send_file failed (${r.status})`);
     return `Sent ${j.name} (${j.kind}).`;
   }
+  if (name === 'channel_react') {
+    const r = await fetch(`${API}/api/channel/react`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ from: FROM, emoji: args.emoji }),
+    });
+    const j = await r.json();
+    if (!r.ok) throw new Error(j.error ?? `channel_react failed (${r.status})`);
+    return `Reacted with ${j.emoji}.`;
+  }
   if (name === 'channel_mute') {
     const r = await fetch(`${API}/api/channel/mute`, {
       method: 'POST', headers: { 'content-type': 'application/json' },
@@ -178,6 +293,59 @@ async function call(name, args) {
     if (!r.ok) throw new Error(j.error ?? `channel_mute failed (${r.status})`);
     return j.muted ? `Muted in this thread (${j.place}). You will only be woken when someone mentions you or replies to you.` : `Unmuted in this thread (${j.place}).`;
   }
+  if (name === 'object_list' || name === 'object_logs' || name === 'object_action') {
+    const r = await fetch(`${API}/api/agent-objects/${name.slice('object_'.length)}`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ from: FROM, ...args }),
+    });
+    const j = await r.json();
+    if (!r.ok) throw new Error(j.error ?? `${name} failed (${r.status})`);
+    if (name === 'object_list') {
+      if (!j.objects.length) return 'Your colony has no objects.';
+      return j.objects.map((o) => `${o.name} · ${o.kind} · ${o.status}${o.detail ? ` (${o.detail})` : ''}`).join('\n');
+    }
+    if (name === 'object_logs') return j.text.trim() ? `Last lines of ${j.name}:\n${j.text}` : `${j.name} has not printed anything.`;
+    return `${j.name}: ${j.status}${j.detail ? ` (${j.detail})` : ''}. Check again with object_list in a moment.`;
+  }
+  if (name === 'wake_me') {
+    const r = await fetch(`${API}/api/wake`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ from: FROM, minutes: args.minutes, note: args.note }),
+    });
+    const j = await r.json();
+    if (!r.ok) throw new Error(j.error ?? `wake_me failed (${r.status})`);
+    return `Wake-up scheduled for ${j.at} (in ${j.minutes} min), ${j.where === 'thread' ? 'in this same thread' : 'in this same conversation'}. Tell the person that exact time.`;
+  }
+  if (name === 'wake_when_done') {
+    const r = await fetch(`${API}/api/wake-when-done`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ from: FROM, pid: args.pid, log: args.log, file: args.file, note: args.note, max_minutes: args.max_minutes }),
+    });
+    const j = await r.json();
+    if (!r.ok) throw new Error(j.error ?? `wake_when_done failed (${r.status})`);
+    return `${j.reused ? 'Already watching this process. ' : ''}Watching the process: you will be woken ${j.where === 'thread' ? 'in this same thread' : 'in this same conversation'} when it finishes (or at ${j.until} at the latest). Tell the person that, and that you will report the result then.`;
+  }
+  if (name === 'schedule_create') {
+    const r = await fetch(`${API}/api/schedules/create`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ from: FROM, cron: args.cron, every_minutes: args.every_minutes, timezone: args.timezone, note: args.note }),
+    });
+    const j = await r.json();
+    if (!r.ok) throw new Error(j.error ?? `schedule_create failed (${r.status})`);
+    return `Schedule created (id ${j.id}): ${j.schedule}, ${j.where === 'thread' ? 'in this same thread' : 'in this same conversation'}. Next runs: ${j.next.join(' · ')}. Tell the person.`;
+  }
+  if (name === 'schedule_list') {
+    const r = await fetch(`${API}/api/schedules/list`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ from: FROM }) });
+    const j = await r.json();
+    if (!r.ok) throw new Error(j.error ?? `schedule_list failed (${r.status})`);
+    return j.schedules.length ? j.schedules.map((s) => `- ${s.id}: ${s.schedule}${s.enabled ? '' : ' [paused]'} · next ${s.next ?? '-'} · last ${s.last ?? 'never'} · ${s.note}`).join('\n') : 'You have no recurring schedules.';
+  }
+  if (name === 'schedule_cancel') {
+    const r = await fetch(`${API}/api/schedules/cancel`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ from: FROM, id: args.id }) });
+    const j = await r.json();
+    if (!r.ok) throw new Error(j.error ?? `schedule_cancel failed (${r.status})`);
+    return 'Schedule cancelled.';
+  }
   throw new Error(`Unknown tool ${name}`);
 }
 

package/web/.next/BUILD_ID

@@ -1 +1 @@
-84BpRSahg2BTwk3mX6AG8
+p4S3i9kvO359GW91DQiHu