hive-am 1.5.0 → 1.7.0

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/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/validate.js

@@ -42,6 +42,23 @@ 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) {
@@ -56,8 +73,11 @@ export function validateConnection(kind, config, agentId, enabled) {
         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();

package/server/dist/instructions.js

@@ -78,7 +78,7 @@ ${lazy.map((s) => `- **${s.name}**${s.description ? `: ${s.description}` : ''}`)
         const team = a.worker_ids.map((wid) => agents.get(wid)).filter(Boolean);
         if (team.length) {
             const roster = team.map((w) => `- **${w.name}**${w.description ? `: ${w.description}` : ''}`).join('\n');
-            parts.push(`## Your team\nThese are your subagents — the ONLY agents you can delegate to:\n${roster}\n\nDelegate with the \`dispatch\` tool (${tn('dispatch')}) instead of doing their work yourself, then synthesize their answers. Always use it: never play a subagent's role yourself, and never use a generic built-in subagent in its place — a subagent is a separate real agent with its own session. Each delegation starts a fresh conversation for that subagent, so put all the context it needs in the task. Your team can change at any time: when asked which agents you have or can delegate to, call the \`list_agents\` tool (${tn('list_agents')}) and report exactly what it returns, never an older list from memory. Never mention or try to use agents outside that list.`);
+            parts.push(`## Your team\nThese are your subagents — the ONLY agents you can delegate to:\n${roster}\n\nDelegate with the \`dispatch\` tool (${tn('dispatch')}) instead of doing their work yourself, then synthesize their answers. Always use it: never play a subagent's role yourself, and never use a generic built-in subagent in its place — a subagent is a separate real agent with its own session. Each delegation starts a fresh conversation for that subagent, so put all the context it needs in the task. \`dispatch\` returns at once with a task id, so you can answer the person or delegate more meanwhile, and the result reaches you as a message when the subagent finishes (you can also ask with the \`dispatch_status\` tool (${tn('dispatch_status')})). Use \`background: false\` only for a very short task whose answer you need right now: the call then waits for it. Your team can change at any time: when asked which agents you have or can delegate to, call the \`list_agents\` tool (${tn('list_agents')}) and report exactly what it returns, never an older list from memory. Never mention or try to use agents outside that list.`);
         }
         else {
             parts.push('## Your team\nYou currently have no subagents connected to you, so you cannot delegate. If asked, say so; do not claim to know other agents.');

package/server/dist/retention.js

@@ -34,8 +34,10 @@ export function retentionPass({ now = Date.now() } = {}) {
         }
         // The record of a received file goes with the file.
         out.files = db.prepare('UPDATE thread_messages SET files=NULL WHERE files IS NOT NULL AND ts<?').run(now - RETENTION_DAYS * DAY).changes;
-        // Delegations: all but the newest KEEP_DISPATCHES (one that is still running is never one of them).
-        out.dispatches = db.prepare("DELETE FROM dispatches WHERE status<>'running' AND id IN (SELECT id FROM dispatches ORDER BY created_at DESC, id DESC LIMIT -1 OFFSET ?)").run(KEEP_DISPATCHES).changes;
+        // Delegations: all but the newest KEEP_DISPATCHES. Never one that has not finished, nor a background one whose result nobody has had
+        // yet (not handed to the orchestrator, nor read with dispatch_status): that one stays until it is.
+        out.dispatches = db.prepare(`DELETE FROM dispatches WHERE status NOT IN ('queued','running') AND NOT (mode='background' AND notified_at IS NULL AND read_at IS NULL)
+      AND id IN (SELECT id FROM dispatches ORDER BY created_at DESC, id DESC LIMIT -1 OFFSET ?)`).run(KEEP_DISPATCHES).changes;
         // Delegated conversations: past the newest KEEP_DELEGATIONS of their agent and not used for SESSION_FORGET_DAYS.
         out.sessions += db.prepare(`DELETE FROM agent_sessions WHERE kind='delegation' AND last_seen<? AND (agent_id, session_id) IN (
       SELECT agent_id, session_id FROM (SELECT agent_id, session_id, ROW_NUMBER() OVER (PARTITION BY agent_id ORDER BY last_seen DESC, session_id) AS n FROM agent_sessions WHERE kind='delegation') WHERE n>?)`)

package/server/dist/runtime.js

@@ -85,6 +85,8 @@ async function execute(agentId, prompt, source, from, dispatchId, origin) {
     try {
         s.controller = controller;
         s.live = { turnId, prompt, events: [], source, origin };
+        if (dispatchId)
+            dispatches.setRunning(dispatchId);
         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 });
@@ -157,8 +159,11 @@ export function stopAgent(agentId, clearQueue = true) {
     s.controller.abort();
     return true;
 }
-/** Orchestrator → worker delegation. Enforces the explicit assignment rule. */
-export async function dispatch(fromId, workerName, task) {
+/**
+ * Orchestrator → worker delegation. Enforces the explicit assignment rule. The task is stored and queued on the worker at once; `done`
+ * settles when the worker's turn ends, after the row holds the result, so nothing depends on the caller still waiting for it.
+ */
+export function startDispatch(fromId, workerName, task, mode = 'sync', origin = null) {
     const from = agents.get(fromId);
     if (!from)
         throw new Error('Unknown orchestrator');
@@ -167,8 +172,14 @@ export async function dispatch(fromId, workerName, task) {
         throw new Error(`No agent named "${workerName}"`);
     if (!from.worker_ids.includes(worker.id))
         throw new Error(`"${worker.name}" is not assigned to ${from.name}`);
-    const id = dispatches.start(from.id, worker.id, task);
-    const res = await sendTurn(worker.id, task, 'dispatch', from.id, id);
-    dispatches.finish(id, res.ok ? 'done' : 'failed', res.text || res.error || '');
-    return res;
+    const id = dispatches.start(from.id, worker.id, task, mode, origin);
+    const done = sendTurn(worker.id, task, 'dispatch', from.id, id).then((res) => {
+        dispatches.finish(id, res.ok ? 'done' : 'failed', res.text || res.error || '');
+        return res;
+    });
+    return { id, worker, done };
+}
+/** A delegation awaited to the end (the original blocking form, kept for callers that hold the request open). */
+export async function dispatch(fromId, workerName, task) {
+    return startDispatch(fromId, workerName, task).done;
 }

package/server/dist/services/connections.js

@@ -5,13 +5,28 @@ import { connections } from '../connections/store.js';
 import { notifyAgentsChanged } from '../runtime.js';
 import { bad, notFound } from '../http/errors.js';
 import { CONNECTION_KINDS, isRecord, trimmed, validateConnection } from '../http/validate.js';
+/** Ids with an optional name: trimmed, de-duplicated, blanks dropped. */
+function cleanIds(list) {
+    const seen = new Set();
+    return list
+        .map((c) => { const r = isRecord(c) ? c : {}; return { id: trimmed(r.id), name: r.name ? String(r.name).trim() : undefined }; })
+        .filter((c) => c.id && !seen.has(c.id) && seen.add(c.id));
+}
+/** One group's mode: `everyone` (or nothing) keeps the entry as `{ id, name }`; `members` keeps its cleaned list; anything else is left for validation to refuse. */
+function cleanChat(c) {
+    const r = isRecord(c) ? c : {};
+    const [chat] = cleanIds([r]);
+    if (!chat || r.mode === undefined || r.mode === null || r.mode === 'everyone')
+        return chat;
+    if (r.mode !== 'members')
+        return { ...chat, mode: r.mode, members: r.members };
+    return { ...chat, mode: 'members', members: Array.isArray(r.members) ? cleanIds(r.members) : r.members ?? [] };
+}
 /** Group ids and alias names from the form: trimmed, de-duplicated, blanks dropped. */
 function cleanGroupConfig(config) {
     if (Array.isArray(config.chats)) {
         const seen = new Set();
-        config.chats = config.chats
-            .map((c) => { const r = isRecord(c) ? c : {}; return { id: trimmed(r.id), name: r.name ? String(r.name).trim() : undefined }; })
-            .filter((c) => c.id && !seen.has(c.id) && seen.add(c.id));
+        config.chats = config.chats.map(cleanChat).filter((c) => c && !seen.has(c.id) && seen.add(c.id));
     }
     if (Array.isArray(config.aliases))
         config.aliases = [...new Set(config.aliases.map((x) => String(x).trim()).filter(Boolean))];

package/server/dist/skills/defaults.js

@@ -8,14 +8,15 @@ export const OBJECTS_SKILL_ID = 'default-objects';
 export const DATABASES_SKILL_ID = 'default-databases';
 /**
  * How to react to messages in a chat. It is part of the "Chat channels" skill; agents that already had that skill get it added once
- * (see `migrateChannelSkill`). Telegram's list is the one in `connections/telegram.ts` (`TELEGRAM_REACTIONS`): keep them in step.
+ * (see `migrateChannelSkill`). Telegram's list is the one in `connections/telegram.ts` (`TELEGRAM_REACTIONS`), Slack's the one in `connections/slack.ts`
+ * (`SLACK_REACTION_NAMES`): keep them in step.
  */
 export const REACTIONS_SECTION = `## Reactions
-- \`channel_react\` puts ONE emoji on the message you are handling. It is lighter than a reply and counts as your answer when there is nothing to add. A new reaction replaces the previous one on that message.
+- \`channel_react\` puts ONE emoji on the message you are handling. It is lighter than a reply and counts as your answer when there is nothing to add. On Telegram a new reaction replaces the previous one on that message; on Slack they add up.
 - React instead of writing when a text would only be noise: 👍 or 🫡 for "understood, on it", 🙏 or ❤ for thanks, 🎉 when someone shares good news, 👀 for "I am looking at it", 👌 for "done" when nothing more needs saying.
 - Do not react instead of answering a question or a request that needs a result: say it with \`channel_reply\`. You can react first (👀) and answer when you finish.
 - Do not react to every message, do not react to chatter nobody aimed at you (in a group with \`Addressed: no\` stay silent), and never use an emoji that could read as mocking, sarcastic or as a judgement of a person.
-- **Each platform allows only some emoji.** On Telegram a bot can use only this list: 👍 👎 ❤ 🔥 🥰 👏 😁 🤔 🤯 😱 😢 🎉 🤩 🙏 👌 🕊 🤡 🥱 🥴 😍 🐳 ❤‍🔥 🌚 🌭 💯 🤣 ⚡ 🍌 🏆 💔 🤨 😐 🍓 🍾 💋 😈 😴 😭 🤓 👻 👨‍💻 👀 🎃 🙈 😇 😨 🤝 ✍ 🤗 🫡 🎅 🎄 ☃ 💅 🤪 🗿 🆒 💘 🙉 🦄 😘 💊 🙊 😎 👾 🤷. The ones that fit work best: 👍 🙏 ❤ 🎉 👀 🫡 👌 🔥 💯. Common ones that are NOT allowed there: ✅ ❌ ✔ 😀 😊 😂 🚀 ⭐ (use 👌 or 👍 instead of ✅, 😁 or 🤣 instead of 😂). Stick to those if you are not sure about another platform.
+- **Each platform allows only some emoji.** On Telegram a bot can use only this list: 👍 👎 ❤ 🔥 🥰 👏 😁 🤔 🤯 😱 😢 🎉 🤩 🙏 👌 🕊 🤡 🥱 🥴 😍 🐳 ❤‍🔥 🌚 🌭 💯 🤣 ⚡ 🍌 🏆 💔 🤨 😐 🍓 🍾 💋 😈 😴 😭 🤓 👻 👨‍💻 👀 🎃 🙈 😇 😨 🤝 ✍ 🤗 🫡 🎅 🎄 ☃ 💅 🤪 🗿 🆒 💘 🙉 🦄 😘 💊 🙊 😎 👾 🤷. The ones that fit work best: 👍 🙏 ❤ 🎉 👀 🫡 👌 🔥 💯. Common ones that are NOT allowed there: ✅ ❌ ✔ 😀 😊 😂 🚀 ⭐ (use 👌 or 👍 instead of ✅, 😁 or 🤣 instead of 😂). On Slack a wider set works (✅ ❌ 🚀 😂 ⭐ 😊 among them; Slack's \`:name:\` form is accepted too), and the Telegram list above works there as well. Stick to the Telegram list if you are not sure about another platform.
 - If the tool refuses the emoji (a platform, or a group that limited its reactions), it says so and lists what you can use: pick another one, or answer with text if the message needs an answer. Do not retry the same emoji.
 `;
 export const DEFAULT_SKILLS = [
@@ -60,6 +61,7 @@ Only things that will still help in a *future* conversation and that you could n
 
 ## Answering
 - **Your normal text is not delivered** to the chat. To answer, call the \`channel_reply\` tool with the text; it goes to the thread of the message you are handling. You can call it more than once (for example a short heads-up before long work, then the result).
+- On Slack a conversation is a thread: your reply goes into the thread of the message you are handling (it opens one on a message written in the channel), and people who keep talking in that thread are talking to you. A wake-up or a scheduled message is posted to the channel itself, not into a thread. A DM has no threads.
 - Once you have sent your answer and have nothing else to do, end the turn at once without writing more text: it is never delivered.
 - Keep replies short and conversational. Use plain Markdown. Never use interactive question tools: if you need something, ask in the reply.
 - The header also says the current local time (\`Now: …\`). Use it to answer what time or day it is, without running \`date\`.
@@ -73,7 +75,7 @@ Only things that will still help in a *future* conversation and that you could n
 - For a picture the block may include "What the picture shows": a text written for you by an image model, because you cannot open images yourself. That is how you see the picture, so talk about it naturally ("I can see…"). Never tell the person that you received a description or that an image model was used, and never say you cannot see the image. It can contain mistakes: if a detail is unclear or missing, say it is not clear in the picture and ask for a sharper one.
 
 ## Groups: listen to everything, speak only when it helps
-- In groups the header also says \`Addressed: yes|no\`. **\`yes\`** means somebody called you (your name, an @mention, a reply to you, a command): answer that. **\`no\`** means people are talking among themselves and nobody asked you anything: you keep reading, and **silence is the default** — do not call \`channel_reply\` and write no text. Speak without being called only when what you add is real, verified and worth interrupting for:
+- In groups the header also says \`Addressed: yes|no\`. **\`yes\`** means somebody called you (your name, an @mention, a reply to you, a message in a Slack thread you already answered, a command): answer that. **\`no\`** means people are talking among themselves and nobody asked you anything: you keep reading, and **silence is the default** — do not call \`channel_reply\` and write no text. Speak without being called only when what you add is real, verified and worth interrupting for:
   1. **A mistake**: somebody says something wrong about the project, the environment, the branch, the deploy or what you did, and you checked (files, logs, commands) that it is wrong. Correct it briefly with what is right and where you saw it.
   2. **A danger — this one you must never let pass.** Somebody suggests or is about to run something destructive or irreversible (\`rm -rf\`, deleting or overwriting data, \`DROP\`/\`TRUNCATE\`, force-push, restarting or changing a production server), uses the wrong environment (production instead of QA), or pastes a secret in the chat. Speak at once, even if the message is for somebody else and even if you were not called: say what would break, why, and the safer way, in two or three lines. Staying silent here is the worst answer.
   3. **A missing fact that changes what they do**: they are about to test something that you know is down or not deployed, or a question to the whole group that nobody answered and you answered from something you checked, in a few lines.

package/server/dist/watch.js

@@ -134,7 +134,7 @@ async function noticeNow(w, reason) {
             ? (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);
+        const { externalId } = await adapter.send(adapter.proactive?.(thread.target) ?? thread.target, msg);
         threadMessages.record(thread.id, 'out', externalId, { name: agents.get(w.agent_id)?.name }, msg);
     }
     catch (e) {

package/server/mcp/dispatch.mjs

@@ -1,6 +1,6 @@
 #!/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)
+//   dispatch → list_agents, dispatch, dispatch_status (orchestrators with a team)
 //   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)
@@ -11,6 +11,8 @@ import { createInterface } from 'node:readline';
 const API = process.env.HIVE_AM_API ?? 'http://127.0.0.1:4400';
 const FROM = process.env.HIVE_AGENT_ID;
 const CAPS = new Set((process.env.HIVE_CAPS ?? 'dispatch').split(',').filter(Boolean));
+// A synchronous dispatch waits with dispatch_status calls of this many seconds each, so no request lasts long enough to hit a client timeout.
+const POLL_S = Math.min(60, Math.max(1, Number(process.env.HIVE_AM_DISPATCH_POLL_S) || 25));
 
 const allTools = [
   {
@@ -22,17 +24,32 @@ const allTools = [
   {
     cap: 'dispatch',
     name: 'dispatch',
-    description: 'Send a self-contained task to one of your subagents and wait for its final answer. Every delegation starts a fresh conversation for the subagent, so include all the context it needs.',
+    description: 'Send a self-contained task to one of your subagents. By default the call returns at once with a task id and the answer arrives later as a message to you (you can also ask with dispatch_status), so you can answer the person or delegate more meanwhile. Set background: false only for a very short task whose answer you need right now: the call then waits for the final answer. Every delegation starts a fresh conversation for the subagent, so include all the context it needs.',
     inputSchema: {
       type: 'object',
       properties: {
         agent: { type: 'string', description: 'Exact subagent name from list_agents' },
         task: { type: 'string', description: 'Full instructions for the subagent; include all context it needs.' },
+        background: { type: 'boolean', description: 'Return at once with a task id (default true). The result is sent to you as a message when the subagent finishes. Set false to wait for the final answer in this call.' },
       },
       required: ['agent', 'task'],
       additionalProperties: false,
     },
   },
+  {
+    cap: 'dispatch',
+    name: 'dispatch_status',
+    description: 'State of a task you delegated: queued, running, done, failed or interrupted, with the result once it has finished. With wait_seconds it waits up to that long for the end before answering.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'The task id that dispatch returned' },
+        wait_seconds: { type: 'number', minimum: 0, maximum: 60, description: 'Wait up to this many seconds (0 to 60, default 0) for the task to finish.' },
+      },
+      required: ['id'],
+      additionalProperties: false,
+    },
+  },
   {
     cap: 'channel',
     name: 'channel_reply',
@@ -106,7 +123,7 @@ const allTools = [
   {
     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.',
+    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: 👍 👎 ❤ 🔥 👏 🎉 🙏 👌 👀 💯 🤔 😁 😢 ✍ 🫡 …; on Slack a wider set, by emoji or as :name:); 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. 👍.' } },
@@ -281,6 +298,16 @@ const dbAnswer = (op, j) => {
   }
 };
 
+async function taskStatus(id, waitSeconds) {
+  const r = await fetch(`${API}/api/dispatch/status`, {
+    method: 'POST', headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ from: FROM, id, wait_seconds: waitSeconds }),
+  });
+  const j = await r.json();
+  if (!r.ok) throw Object.assign(new Error(j.error ?? `dispatch_status failed (${r.status})`), { status: r.status });
+  return j;
+}
+
 async function call(name, args) {
   if (!tools.some((t) => t.name === name)) throw new Error(`Unknown tool ${name}`);
   if (name === 'list_agents') {
@@ -288,13 +315,29 @@ async function call(name, args) {
     return JSON.stringify(await r.json(), null, 2);
   }
   if (name === 'dispatch') {
+    const background = args.background !== false;
     const r = await fetch(`${API}/api/dispatch`, {
       method: 'POST', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ from: FROM, agent: args.agent, task: args.task }),
+      body: JSON.stringify({ from: FROM, agent: args.agent, task: args.task, background, poll: !background }),
     });
     const j = await r.json();
     if (!r.ok) throw new Error(j.error ?? `dispatch failed (${r.status})`);
-    return j.text || '(the subagent finished without a text answer)';
+    if (background) return `Task ${j.id} sent to ${j.agent} (${j.status}). You will be woken with the result when it finishes; you can also ask with dispatch_status.`;
+    // Wait for the end with short calls: the answer is read from the server's record, never from one long request.
+    for (let errors = 0; ;) {
+      let s;
+      try { s = await taskStatus(j.id, POLL_S); errors = 0; } catch (e) {
+        if (e.status || ++errors > 5) throw new Error(`${e.message}. The task ${j.id} goes on: ask for its result with dispatch_status.`);
+        await new Promise((ok) => setTimeout(ok, 2000));
+        continue;
+      }
+      if (s.status === 'done') return s.result;
+      if (s.status === 'failed' || s.status === 'interrupted') throw new Error(`${j.agent} did not finish the task (${s.status}): ${s.result}`);
+    }
+  }
+  if (name === 'dispatch_status') {
+    const s = await taskStatus(args.id, args.wait_seconds);
+    return `Task ${s.id} for ${s.agent}: ${s.status}.${s.note ? ` ${s.note}` : ''}${s.result !== undefined ? ` Result:\n${s.result}` : ' Not finished yet.'}`;
   }
   if (name === 'channel_reply') {
     const r = await fetch(`${API}/api/channel/reply`, {

package/web/.next/BUILD_ID

@@ -1 +1 @@
-UDA414PFPu9ZROltNmjbX
+gqk-RaeJBRWW1cWGRixT2