hive-am 1.10.0 → 1.11.0

package/CHANGELOG.md

@@ -6,6 +6,25 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 
 ## [Unreleased]
 
+## [1.11.0] - 2026-10-23
+
+### Added
+
+- **Cancel a delegated task.** A task sent by mistake or no longer needed can be taken back, queued or running. In **Recent delegations** (Colony and Home) each unfinished task has a **×** button: a queued one is cancelled at once and never starts, a running one asks first and is stopped. The orchestrator is told once, in the place where it delegated. Orchestrators get two new tools, `dispatch_cancel` (only for their own tasks; they get no extra message for a task they cancel) and `dispatch_list` (their tasks that have not finished). A cancelled task shows as **cancelled** with a grey dot, frees its place in the limit of 10, and what the worker already changed stays in the folder. Unfinished tasks now come first in the list and are never hidden by its limit. Stop on a worker still stops only its current turn and marks that delegation failed.
+
+### Fixed
+
+- **Lists follow the language at once.** Changing the language with the app open left some names in the old language until a reload: the **No colony** group in the chat's agent list and in **Resources**, and the colony hints in the agent form and the resource manager field. They now change right away.
+- **Collapsing the agent list clears its search.** A search typed in the chat's agent list kept filtering the collapsed list, which has no search box, so agents and groups seemed to vanish and the group headings stayed disabled. Collapsing now clears the search, and expanding shows the full list with an empty box.
+- **More of the interface follows the language.** The **Entrypoint**, **Gateway** and **Aliases** labels of a service's details, and the names screen readers hear for the method picker of a new HTTP request and for the sideways scroll bar of the diff view, were always in English; a request that failed in an HTTP file showed `error` in English too. They now come from the dictionaries. Empty cells and values show a plain hyphen instead of a long dash, and a service's empty lists (health log, variables, ports, mounts, networks) say **none**.
+
+## [1.10.1] - 2026-10-23
+
+### Fixed
+
+- **Long prompts no longer cover the editor's footer.** In **Preview** and **Split**, a long system prompt was drawn over the word count and tips line under the editor. Each pane now scrolls on its own inside the editor and the footer stays visible below it.
+- **`hive-am update` no longer cuts the install off after 2 minutes.** The install now has its own limit of 15 minutes (`HIVE_AM_INSTALL_TIMEOUT`, in seconds, `0` for none) and says beforehand that it can take a few minutes. When npm runs past the limit or is stopped by a signal, the message says so, warns the install may be incomplete and gives the command to run by hand, instead of `exit null` and a permissions hint; that hint now only shows when npm reports `EACCES` or `EPERM`.
+
 ## [1.10.0] - 2026-10-22
 
 ### Added
@@ -283,7 +302,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 - Complete documentation in English and Spanish.
 - npm package with the `hive-am` command.
 
-[Unreleased]: https://github.com/hughcbscrt/hive-am/compare/v1.10.0...HEAD
+[Unreleased]: https://github.com/hughcbscrt/hive-am/compare/v1.11.0...HEAD
+[1.11.0]: https://github.com/hughcbscrt/hive-am/compare/v1.10.1...v1.11.0
+[1.10.1]: https://github.com/hughcbscrt/hive-am/compare/v1.10.0...v1.10.1
 [1.10.0]: https://github.com/hughcbscrt/hive-am/compare/v1.9.1...v1.10.0
 [1.9.1]: https://github.com/hughcbscrt/hive-am/compare/v1.9.0...v1.9.1
 [1.9.0]: https://github.com/hughcbscrt/hive-am/compare/v1.8.0...v1.9.0

package/bin/hive-am.mjs

@@ -245,9 +245,21 @@ async function update(list) {
   if (kind === 'source') fail('This is a source checkout: update it with `git pull` and `npm install`, then rebuild.');
   if (kind !== 'global') fail(`hive-am was not installed globally with npm (${root}), so it cannot update itself. Install the new version the way you installed this one: npm install -g ${pkg.name}@${latest}`);
 
-  console.log(`Installing ${pkg.name}@${latest} ...`);
-  const r = npm(['install', '-g', `${pkg.name}@${latest}`], { stdio: 'inherit', encoding: undefined });
-  if (r.status !== 0) fail(`npm could not install ${pkg.name}@${latest} (exit ${r.status}). If it is a permissions error, see https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally`);
+  // the install gets its own limit: a slow registry or a big download easily takes longer than the 2 minutes of the quick queries
+  const raw = process.env.HIVE_AM_INSTALL_TIMEOUT;
+  const secs = raw === undefined || raw === '' ? 900 : Number(raw);
+  if (!Number.isFinite(secs) || secs < 0) fail(`HIVE_AM_INSTALL_TIMEOUT must be a number of seconds (0 for no limit), not "${raw}".`);
+  console.log(`Installing ${pkg.name}@${latest} ... this can take a few minutes (Ctrl+C stops it).`);
+  // stderr is piped so a permissions error can be told apart, and written back so npm's own text is not lost
+  const r = npm(['install', '-g', `${pkg.name}@${latest}`], { stdio: ['inherit', 'inherit', 'pipe'], timeout: secs * 1000 });
+  if (r.stderr) process.stderr.write(r.stderr);
+  const manual = `The install may be incomplete: run it yourself with npm install -g ${pkg.name}@${latest}`;
+  if (r.error?.code === 'ETIMEDOUT') fail(`npm was stopped after ${secs} seconds without finishing the install of ${pkg.name}@${latest} (raise the limit with HIVE_AM_INSTALL_TIMEOUT, in seconds, 0 for none). ${manual}`);
+  if (r.signal) fail(`npm was stopped by ${r.signal} while installing ${pkg.name}@${latest}. ${manual}`);
+  if (r.status !== 0) {
+    const perms = /\bE(ACCES|PERM)\b/.test(r.stderr ?? '') ? ' It is a permissions error: see https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally' : '';
+    fail(`npm could not install ${pkg.name}@${latest} (exit ${r.status ?? r.error?.message}).${perms}`);
+  }
   let now = latest;
   try { now = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).version; } catch { /* the folder was replaced: keep what npm installed */ }
   console.log(`hive-am updated: ${pkg.version} -> ${now}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hive-am",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "A colony of coding agents: orchestrators and subagents over Claude Code, OpenCode, Kiro and Cursor, with real session resume, a browser UI and Telegram.",
   "keywords": [
     "ai-agents",

package/server/dist/db.js

@@ -245,8 +245,9 @@ 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).
+// A delegation is `queued` until the worker's turn starts (it waits behind the worker's other turns), then `running`, then `done`, `failed`,
+// `interrupted` (the server stopped while it was queued or running) or `cancelled` (its orchestrator or the person took it back). Only a
+// row still queued or running is closed, so the first of the end of the turn and a cancel sets the one final state.
 export const dispatches = {
     start(from, to, task, mode = 'sync', origin = null) {
         const id = uid();
@@ -256,16 +257,24 @@ export const dispatches = {
     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),
+    finish: (id, status, result) => q("UPDATE dispatches SET status=?, result=?, finished_at=? WHERE id=? AND status IN ('queued','running')").run(status, result.slice(0, 20000), now(), id).changes > 0,
+    /** Cancels a task that has not finished; false if it already had. Cancelled by its orchestrator, it is never announced (the tool told it). */
+    cancel: (id, result, byOrchestrator) => {
+        const at = now();
+        return q("UPDATE dispatches SET status='cancelled', result=?, finished_at=?, notified_at=CASE WHEN ? THEN ? ELSE notified_at END WHERE id=? AND status IN ('queued','running')").run(result, at, byOrchestrator ? 1 : 0, at, id).changes > 0;
+    },
     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,
+    /** Every task of an orchestrator that has not finished, oldest first. */
+    open: (from) => q("SELECT * FROM dispatches WHERE from_id=? AND status IN ('queued','running') ORDER BY created_at, id").all(from),
     /** 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),
+    /** The newest rows, plus any older one that has not finished (so the interface can always show and cancel it). */
+    recent: (limit = 50) => q("SELECT * FROM (SELECT * FROM dispatches ORDER BY created_at DESC LIMIT ?) UNION SELECT * FROM dispatches WHERE status IN ('queued','running') ORDER BY created_at DESC").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();

package/server/dist/dispatches.js

@@ -1,6 +1,6 @@
 import { agents, dispatches } from './db.js';
 import { threads } from './connections/store.js';
-import { liveOrigin, notifyAgentsChanged, startDispatch } from './runtime.js';
+import { abortDispatch, cancelQueued, liveOrigin, notifyAgentsChanged, startDispatch } from './runtime.js';
 import { deliverTo } from './wake.js';
 import { DomainError } from './errors.js';
 /**
@@ -15,7 +15,7 @@ export const MAX_BACKGROUND = 10; // unfinished background tasks per orchestrato
 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 FINISHED = new Set(['done', 'failed', 'interrupted', 'cancelled']);
 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. */
@@ -74,6 +74,40 @@ export async function taskStatus(fromId, id, waitSeconds) {
         out.note = `wait_seconds is capped at ${MAX_WAIT_S}: waited ${MAX_WAIT_S} s at most.`;
     return out;
 }
+const CANCELLED_BY = { orchestrator: 'Cancelled by the orchestrator before it finished.', person: 'Cancelled by the person before it finished.' };
+/**
+ * Takes a delegated task back. A queued one leaves the worker's queue and never starts; a running one has its turn aborted (only that turn).
+ * One already finished is left as it is and its state is answered, so cancelling twice is harmless. The row is closed by the same conditional
+ * update as the end of the turn, so whichever comes first sets the one final state. `by` is the orchestrator that started it, or null for the
+ * person (from the web), who may cancel any task; cancelled by the person, the orchestrator is told once.
+ */
+export function cancelTask(by, id) {
+    if (!id)
+        throw new DispatchError('id is required');
+    const row = dispatches.get(id);
+    if (!row)
+        throw new DispatchError(`There is no delegated task with id "${id}".`, 'not_found');
+    if (by !== null && row.from_id !== by)
+        throw new DispatchError(`Task "${id}" was not started by you.`, 'forbidden');
+    const was = row.status;
+    const cancelled = !FINISHED.has(was) && dispatches.cancel(id, by === null ? CANCELLED_BY.person : CANCELLED_BY.orchestrator, by !== null);
+    if (cancelled) {
+        if (was === 'queued')
+            cancelQueued(row.to_id, id);
+        else
+            abortDispatch(row.to_id, id);
+        notifyAgentsChanged();
+        // At once, not when the turn ends: a queued task only settles when the worker's queue reaches it.
+        if (by === null)
+            void announce(id);
+    }
+    const now = dispatches.get(id) ?? row;
+    return { id, agent: nameOf(now.to_id), status: now.status, mode: now.mode, was, cancelled, ...(FINISHED.has(now.status) ? { result: resultText(now) } : {}) };
+}
+/** The tasks of an orchestrator that have not finished, oldest first, so it can tell which one to cancel. */
+export function openTasks(fromId) {
+    return dispatches.open(fromId).map((r) => ({ id: r.id, agent: nameOf(r.to_id), status: r.status, mode: r.mode, task: r.task.length > 200 ? `${r.task.slice(0, 200)}…` : r.task, age_s: Math.max(0, Math.round((Date.now() - r.created_at) / 1000)) }));
+}
 /** What a finished task says: its answer, its error, or why it stopped. */
 function resultText(row) {
     if (row.status === 'interrupted')
@@ -85,12 +119,26 @@ function resultText(row) {
 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();
+const delivering = new Set();
 /** 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) {
+    // A second call while the first is still delivering (a cancel, then the end of the aborted turn) or waiting to try again does nothing.
+    if (delivering.has(id) || (!tries && timers.has(id)))
+        return;
     timers.delete(id);
     const row = dispatches.get(id);
     if (!row || row.mode !== 'background' || row.notified_at || !FINISHED.has(row.status))
         return;
+    delivering.add(id);
+    try {
+        await deliver(row, tries);
+    }
+    finally {
+        delivering.delete(id);
+    }
+}
+async function deliver(row, tries) {
+    const id = row.id;
     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 = () => {

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

@@ -1,5 +1,5 @@
 import { agents, dispatches } from '../../db.js';
-import { startTask, taskStatus } from '../../dispatches.js';
+import { cancelTask, openTasks, startTask, taskStatus } from '../../dispatches.js';
 import { dispatch, liveTurn, notifyAgentsChanged } from '../../runtime.js';
 import { agentOrFail } from '../../services/agents.js';
 import { body } from '../body.js';
@@ -40,4 +40,19 @@ route('POST', '/api/dispatch/status', async ({ req }) => {
         throw bad('from is required');
     return taskStatus(text(from), text(id), wait_seconds);
 });
+// Cancelling answers the final state: `cancelled`, or the one the task already had (it is not an error).
+route('POST', '/api/dispatch/cancel', async ({ req }) => {
+    const { from, id } = await body(req);
+    if (!from)
+        throw bad('from is required');
+    return cancelTask(text(from), text(id));
+});
+route('POST', '/api/dispatch/list', async ({ req }) => {
+    const { from } = await body(req);
+    if (!from)
+        throw bad('from is required');
+    return openTasks(text(from));
+});
 route('GET', '/api/dispatches', () => dispatches.recent());
+// From the web: the person can cancel any task, as they can stop any agent.
+route('POST', '/api/dispatches/:id/cancel', ({ params }) => cancelTask(null, params[0]));

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. \`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.`);
+            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. To take back a task that is no longer needed (sent by mistake, with the wrong context, or the plan changed), call the \`dispatch_cancel\` tool (${tn('dispatch_cancel')}) with its id; the \`dispatch_list\` tool (${tn('dispatch_list')}) lists your tasks that have not finished. What a cancelled subagent already changed stays in the folder, so check it before delegating again. 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/runtime.js

@@ -13,7 +13,7 @@ const states = new Map();
 const st = (id) => {
     let s = states.get(id);
     if (!s)
-        states.set(id, (s = { chain: Promise.resolve(), controller: null, queued: 0, live: null }));
+        states.set(id, (s = { chain: Promise.resolve(), controller: null, dispatchId: null, queued: 0, live: null, cancelled: new Set() }));
     return s;
 };
 export const liveTurn = (id) => states.get(id)?.live ?? null;
@@ -47,6 +47,9 @@ export function sendTurn(agentId, prompt, source = 'user', from, dispatchId, ori
 }
 async function execute(agentId, prompt, source, from, dispatchId, origin) {
     const s = st(agentId);
+    // A delegation cancelled while it waited never reaches the provider; it already left the queue count when it was cancelled.
+    if (dispatchId && s.cancelled.delete(dispatchId))
+        return { ok: false, text: '', error: 'Cancelled' };
     s.queued--;
     let raw;
     let agent;
@@ -84,6 +87,7 @@ async function execute(agentId, prompt, source, from, dispatchId, origin) {
     const push = (event) => { s.live?.events.push(event); emit({ kind: 'event', agentId, turnId, event }); };
     try {
         s.controller = controller;
+        s.dispatchId = dispatchId ?? null;
         s.live = { turnId, prompt, events: [], source, origin };
         if (dispatchId)
             dispatches.setRunning(dispatchId);
@@ -143,6 +147,7 @@ async function execute(agentId, prompt, source, from, dispatchId, origin) {
     if (controller.signal.aborted && !error)
         push({ t: 'done', ok: false, summary: 'Stopped' });
     s.controller = null;
+    s.dispatchId = null;
     s.live = null;
     if (!error && !delegated && !controller.signal.aborted) {
         agents.setInstrHash(agentId, hash);
@@ -159,6 +164,24 @@ export function stopAgent(agentId, clearQueue = true) {
     s.controller.abort();
     return true;
 }
+/** Takes a queued delegation out of the worker's queue: its turn is skipped when the chain reaches it, and the count drops now. */
+export function cancelQueued(agentId, dispatchId) {
+    const s = states.get(agentId);
+    if (!s || s.queued <= 0 || s.cancelled.has(dispatchId))
+        return false;
+    s.cancelled.add(dispatchId);
+    s.queued--;
+    emit({ kind: 'status', agentId, status: s.live ? 'running' : s.queued ? 'queued' : agents.get(agentId)?.status === 'error' ? 'error' : 'idle', queued: s.queued });
+    return true;
+}
+/** Aborts the worker's turn only if it is serving this delegation, so cancelling one task never stops another. */
+export function abortDispatch(agentId, dispatchId) {
+    const s = states.get(agentId);
+    if (!s?.controller || s.dispatchId !== dispatchId)
+        return false;
+    s.controller.abort();
+    return true;
+}
 /**
  * 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.
@@ -174,6 +197,7 @@ export function startDispatch(fromId, workerName, task, mode = 'sync', origin =
         throw new Error(`"${worker.name}" is not assigned to ${from.name}`);
     const id = dispatches.start(from.id, worker.id, task, mode, origin);
     const done = sendTurn(worker.id, task, 'dispatch', from.id, id).then((res) => {
+        // A no-op when the task was cancelled meanwhile: the aborted or skipped turn does not turn `cancelled` into `failed`.
         dispatches.finish(id, res.ok ? 'done' : 'failed', res.text || res.error || '');
         return res;
     });

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, dispatch_status (orchestrators with a team)
+//   dispatch → list_agents, dispatch, dispatch_status, dispatch_list, dispatch_cancel (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)
@@ -39,7 +39,7 @@ const allTools = [
   {
     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.',
+    description: 'State of a task you delegated: queued, running, done, failed, interrupted or cancelled, 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: {
@@ -50,6 +50,23 @@ const allTools = [
       additionalProperties: false,
     },
   },
+  {
+    cap: 'dispatch',
+    name: 'dispatch_list',
+    description: 'List the tasks you delegated that have not finished yet (queued or running), with their id, subagent, state and age, oldest first.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    cap: 'dispatch',
+    name: 'dispatch_cancel',
+    description: 'Cancel a task you delegated that is no longer needed (sent by mistake, wrong context, or the plan changed). A queued task never starts; a running one is stopped at once, and what the subagent already changed stays in the folder, so check it before delegating again. A task that already finished is left as it is and its state is answered. You are not sent a message about a task you cancel.',
+    inputSchema: {
+      type: 'object',
+      properties: { id: { type: 'string', description: 'The task id that dispatch returned' } },
+      required: ['id'],
+      additionalProperties: false,
+    },
+  },
   {
     cap: 'channel',
     name: 'channel_reply',
@@ -333,12 +350,35 @@ async function call(name, args) {
       }
       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 (s.status === 'cancelled') throw new Error(`${j.agent} task was cancelled: ${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 === 'dispatch_list') {
+    const r = await fetch(`${API}/api/dispatch/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 ?? `dispatch_list failed (${r.status})`);
+    const age = (s) => (s < 60 ? `${s} s` : s < 3600 ? `${Math.round(s / 60)} min` : `${Math.round(s / 3600)} h`);
+    return j.length ? j.map((t) => `${t.id} · ${t.agent} · ${t.status} · ${t.mode} · ${age(t.age_s)} ago\n  ${t.task.replace(/\s+/g, ' ')}`).join('\n') : 'You have no delegated tasks that have not finished.';
+  }
+  if (name === 'dispatch_cancel') {
+    const r = await fetch(`${API}/api/dispatch/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 ?? `dispatch_cancel failed (${r.status})`);
+    if (!j.cancelled) return `Task ${j.id} for ${j.agent} had already finished (${j.status}); nothing changed.${j.result !== undefined ? ` Result:\n${j.result}` : ''}`;
+    return j.was === 'running'
+      ? `Task ${j.id} for ${j.agent} cancelled: ${j.agent} was working on it and was stopped. What it already changed stays in the folder; check it before delegating again.`
+      : `Task ${j.id} for ${j.agent} cancelled before it started.`;
+  }
   if (name === 'channel_reply') {
     const r = await fetch(`${API}/api/channel/reply`, {
       method: 'POST', headers: { 'content-type': 'application/json' },

package/web/.next/BUILD_ID

@@ -1 +1 @@
-qv9RAZqD8Of6bH1cw6RzA
+HzL5-xIKbr0VsaWuLWHNl

package/web/.next/app-build-manifest.json

@@ -13,40 +13,40 @@
       "static/chunks/89-b194fcffe5120c44.js",
       "static/chunks/main-app-27cc7ffdb888b879.js",
       "static/css/945795da867f5250.css",
-      "static/css/1afa1d0e0fdc435f.css",
+      "static/css/f9099a8765eed6f0.css",
       "static/chunks/586-4f67b823df060b46.js",
       "static/chunks/8523-82e1ee6239699d8a.js",
-      "static/chunks/9977-78b955d85f795a21.js",
+      "static/chunks/4740-0581e5cb9334010b.js",
       "static/chunks/969-07e498da015b149a.js",
       "static/chunks/3790-3d3f11a264e8ede8.js",
-      "static/chunks/app/layout-068c1695366993c1.js"
+      "static/chunks/app/layout-b327408bcfb13a70.js"
     ],
-    "/chat/page": [
+    "/colony/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
       "static/chunks/0937d497-daa99a23a4431317.js",
       "static/chunks/89-b194fcffe5120c44.js",
       "static/chunks/main-app-27cc7ffdb888b879.js",
       "static/chunks/586-4f67b823df060b46.js",
       "static/chunks/7706-bd0d2bda0e0c8d1e.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/1517-5db81b0d2ac8f7f5.js",
-      "static/chunks/app/chat/page-b1569cf72e958d8b.js"
+      "static/chunks/5642-09dd4161ddddaf94.js",
+      "static/chunks/4162-c2361cb017547c37.js",
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/1517-9b82b61ee9921bb1.js",
+      "static/chunks/969-07e498da015b149a.js",
+      "static/chunks/1606-6d25d725156f5127.js",
+      "static/chunks/5587-cdccc5cf4056b739.js",
+      "static/chunks/app/colony/page-600b663a716d08c4.js"
     ],
-    "/colony/page": [
+    "/chat/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
       "static/chunks/0937d497-daa99a23a4431317.js",
       "static/chunks/89-b194fcffe5120c44.js",
       "static/chunks/main-app-27cc7ffdb888b879.js",
       "static/chunks/586-4f67b823df060b46.js",
       "static/chunks/7706-bd0d2bda0e0c8d1e.js",
-      "static/chunks/5642-09dd4161ddddaf94.js",
-      "static/chunks/4162-c2361cb017547c37.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/1517-5db81b0d2ac8f7f5.js",
-      "static/chunks/969-07e498da015b149a.js",
-      "static/chunks/1606-2aa8ee5a6751f920.js",
-      "static/chunks/5587-7e580517c4105e63.js",
-      "static/chunks/app/colony/page-ffdc123dac47ad69.js"
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/1517-9b82b61ee9921bb1.js",
+      "static/chunks/app/chat/page-157685bdaad86c26.js"
     ],
     "/connections/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
@@ -54,8 +54,8 @@
       "static/chunks/89-b194fcffe5120c44.js",
       "static/chunks/main-app-27cc7ffdb888b879.js",
       "static/chunks/586-4f67b823df060b46.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/app/connections/page-0e4f9f272da95c83.js"
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/app/connections/page-cbfcb1547d45c833.js"
     ],
     "/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
@@ -64,10 +64,10 @@
       "static/chunks/main-app-27cc7ffdb888b879.js",
       "static/chunks/586-4f67b823df060b46.js",
       "static/chunks/7706-bd0d2bda0e0c8d1e.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/1517-5db81b0d2ac8f7f5.js",
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/1517-9b82b61ee9921bb1.js",
       "static/chunks/3790-3d3f11a264e8ede8.js",
-      "static/chunks/app/page-68ae166b2f8dbf94.js"
+      "static/chunks/app/page-78c38105a034b0b3.js"
     ],
     "/relations/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
@@ -78,10 +78,10 @@
       "static/chunks/2b9ff8ee-0851c7e556e3a39b.js",
       "static/chunks/586-4f67b823df060b46.js",
       "static/chunks/3757-45ea801718ec19e4.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/app/relations/page-a9d991b174372f37.js"
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/app/relations/page-622a4c5723c7c5cc.js"
     ],
-    "/resources/[id]/page": [
+    "/resources/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
       "static/chunks/0937d497-daa99a23a4431317.js",
       "static/chunks/89-b194fcffe5120c44.js",
@@ -91,16 +91,16 @@
       "static/chunks/5642-09dd4161ddddaf94.js",
       "static/chunks/4837-8dc05d75f258f9e1.js",
       "static/chunks/1771-4688ad65e21bb512.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/1517-5db81b0d2ac8f7f5.js",
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/1517-9b82b61ee9921bb1.js",
       "static/chunks/969-07e498da015b149a.js",
-      "static/chunks/1606-2aa8ee5a6751f920.js",
-      "static/chunks/5587-7e580517c4105e63.js",
+      "static/chunks/1606-6d25d725156f5127.js",
+      "static/chunks/5587-cdccc5cf4056b739.js",
       "static/chunks/4030-bc2e0aa4da0d9ad8.js",
-      "static/chunks/4491-49c700f509985c9e.js",
-      "static/chunks/app/resources/[id]/page-48131f750e983a07.js"
+      "static/chunks/4491-886c18aee1e9c737.js",
+      "static/chunks/app/resources/page-a2e17f0dc205a2a4.js"
     ],
-    "/resources/page": [
+    "/resources/[id]/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
       "static/chunks/0937d497-daa99a23a4431317.js",
       "static/chunks/89-b194fcffe5120c44.js",
@@ -110,14 +110,14 @@
       "static/chunks/5642-09dd4161ddddaf94.js",
       "static/chunks/4837-8dc05d75f258f9e1.js",
       "static/chunks/1771-4688ad65e21bb512.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/1517-5db81b0d2ac8f7f5.js",
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/1517-9b82b61ee9921bb1.js",
       "static/chunks/969-07e498da015b149a.js",
-      "static/chunks/1606-2aa8ee5a6751f920.js",
-      "static/chunks/5587-7e580517c4105e63.js",
+      "static/chunks/1606-6d25d725156f5127.js",
+      "static/chunks/5587-cdccc5cf4056b739.js",
       "static/chunks/4030-bc2e0aa4da0d9ad8.js",
-      "static/chunks/4491-49c700f509985c9e.js",
-      "static/chunks/app/resources/page-706d012a4c0d57ce.js"
+      "static/chunks/4491-886c18aee1e9c737.js",
+      "static/chunks/app/resources/[id]/page-b9af9eecf693b695.js"
     ],
     "/schedules/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
@@ -125,8 +125,8 @@
       "static/chunks/89-b194fcffe5120c44.js",
       "static/chunks/main-app-27cc7ffdb888b879.js",
       "static/chunks/586-4f67b823df060b46.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/app/schedules/page-5821c0d26afde69f.js"
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/app/schedules/page-d534462088c64b59.js"
     ],
     "/sessions/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
@@ -136,10 +136,10 @@
       "static/chunks/586-4f67b823df060b46.js",
       "static/chunks/7706-bd0d2bda0e0c8d1e.js",
       "static/chunks/2654-4aeef09c0d6bf56a.js",
-      "static/chunks/9977-78b955d85f795a21.js",
+      "static/chunks/4740-0581e5cb9334010b.js",
       "static/chunks/969-07e498da015b149a.js",
-      "static/chunks/2547-821b5a01cff1915f.js",
-      "static/chunks/app/sessions/page-6145eb19002dd390.js"
+      "static/chunks/2547-8b6bdae3c622a158.js",
+      "static/chunks/app/sessions/page-6fef5b73bfbf262e.js"
     ],
     "/skills/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
@@ -148,8 +148,8 @@
       "static/chunks/main-app-27cc7ffdb888b879.js",
       "static/chunks/586-4f67b823df060b46.js",
       "static/chunks/7706-bd0d2bda0e0c8d1e.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/app/skills/page-b94287c3a333870d.js"
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/app/skills/page-ab25a3a6d348a049.js"
     ],
     "/types/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
@@ -158,9 +158,9 @@
       "static/chunks/main-app-27cc7ffdb888b879.js",
       "static/chunks/586-4f67b823df060b46.js",
       "static/chunks/7706-bd0d2bda0e0c8d1e.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/1517-5db81b0d2ac8f7f5.js",
-      "static/chunks/app/types/page-a991fe9afa51bdb7.js"
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/1517-9b82b61ee9921bb1.js",
+      "static/chunks/app/types/page-7e08ca1bcbee605f.js"
     ],
     "/agents/layout": [
       "static/chunks/webpack-ba68c1813987a630.js",
@@ -170,10 +170,10 @@
       "static/chunks/586-4f67b823df060b46.js",
       "static/chunks/7706-bd0d2bda0e0c8d1e.js",
       "static/chunks/5642-09dd4161ddddaf94.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/1517-5db81b0d2ac8f7f5.js",
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/1517-9b82b61ee9921bb1.js",
       "static/chunks/969-07e498da015b149a.js",
-      "static/chunks/app/agents/layout-2536c0c15d09ddcf.js"
+      "static/chunks/app/agents/layout-db700c86124f32de.js"
     ],
     "/agents/[id]/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
@@ -185,13 +185,13 @@
       "static/chunks/5642-09dd4161ddddaf94.js",
       "static/chunks/4837-8dc05d75f258f9e1.js",
       "static/chunks/3214-c9d0c933db5b0f44.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/1517-5db81b0d2ac8f7f5.js",
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/1517-9b82b61ee9921bb1.js",
       "static/chunks/969-07e498da015b149a.js",
-      "static/chunks/1606-2aa8ee5a6751f920.js",
+      "static/chunks/1606-6d25d725156f5127.js",
       "static/chunks/4030-bc2e0aa4da0d9ad8.js",
-      "static/chunks/2547-821b5a01cff1915f.js",
-      "static/chunks/app/agents/[id]/page-da4050632f63874d.js"
+      "static/chunks/2547-8b6bdae3c622a158.js",
+      "static/chunks/app/agents/[id]/page-eeb93069b69e7f7e.js"
     ],
     "/agents/page": [
       "static/chunks/webpack-ba68c1813987a630.js",
@@ -200,9 +200,9 @@
       "static/chunks/main-app-27cc7ffdb888b879.js",
       "static/chunks/586-4f67b823df060b46.js",
       "static/chunks/7706-bd0d2bda0e0c8d1e.js",
-      "static/chunks/9977-78b955d85f795a21.js",
-      "static/chunks/1517-5db81b0d2ac8f7f5.js",
-      "static/chunks/app/agents/page-0d8769f28c624f9c.js"
+      "static/chunks/4740-0581e5cb9334010b.js",
+      "static/chunks/1517-9b82b61ee9921bb1.js",
+      "static/chunks/app/agents/page-bf40d654c5fe5c23.js"
     ]
   }
 }