@danieltmn/tamnora 0.5.1 → 0.6.0

package/harness/packages/server/src/lib/tasks.js

@@ -0,0 +1,126 @@
+// Tool "task": el agente principal delega una subtarea a un subagente con
+// contexto propio y un toolset acotado (solo lectura por defecto). Los eventos
+// del subagente se emiten con `agentId` para que la consola los anide, y su
+// resumen final se devuelve como resultado de la tool.
+
+import { runAgent, createTools, resolveMode, summarizeToolCall, previewToolResult } from './core.js';
+
+const SUBAGENT_PROMPT = [
+  'Sos un subagente de Tamnora. Ejecutá de forma autónoma la tarea encomendada',
+  'usando las herramientas disponibles y devolvé un resumen conciso y concreto de',
+  'lo que encontraste o hiciste (archivos, hallazgos, decisiones). No pidas',
+  'confirmaciones: si algo no es posible, explicalo en el resumen.',
+].join(' ');
+
+function definition(name, description, parameters, required = []) {
+  return {
+    type: 'function',
+    function: { name, description, parameters: { type: 'object', properties: parameters, required } },
+  };
+}
+
+/**
+ * Crea la tool `task` para una sesión/run y la función `execute`.
+ * `emit(type, data, agentId)` persiste y difunde el evento (via RunManager).
+ */
+export function createSubagentTool(ctx, options) {
+  const {
+    sessionId,
+    cwd,
+    providerId,
+    model,
+    permissions = {},
+    mcp = null,
+    signal,
+    exclude = [],
+    emit,
+  } = options;
+
+  const definitions = [
+    definition(
+      'task',
+      'Delega una subtarea a un subagente con su propio contexto (solo lectura por defecto). Devolvé un prompt claro y autocontenido; el subagente responde con un resumen.',
+      {
+        description: { type: 'string', description: 'Título corto de la subtarea' },
+        prompt: { type: 'string', description: 'Instrucción completa y autocontenida para el subagente' },
+        mode: { type: 'string', enum: ['plan', 'agent'], description: 'plan (solo lectura, default) o agent' },
+        tools: { type: 'array', items: { type: 'string' }, description: 'Limitar las tools del subagente' },
+      },
+      ['prompt']
+    ),
+  ];
+
+  const handles = (name) => name === 'task';
+
+  async function execute(name, args = {}) {
+    if (!handles(name)) return `Herramienta desconocida: ${name}`;
+    const prompt = String(args.prompt ?? args.task ?? '').trim();
+    const description = String(args.description ?? prompt).slice(0, 80).trim() || 'subtarea';
+    if (!prompt) return 'La subtarea necesita "prompt".';
+
+    const agentId = ctx.store.createAgent({ sessionId, kind: 'task', title: description, model });
+    const mode = resolveMode(args.mode ?? 'plan');
+    emit('agent_start', { agentId, description, mode: mode.id, model }, agentId);
+
+    const enabled =
+      Array.isArray(args.tools) && args.tools.length
+        ? args.tools.filter((tool) => !exclude.includes(tool))
+        : mode.tools ?? undefined;
+    const local = createTools({ root: cwd, enabled, permissions, yes: false, mcp });
+    const basePrompt = await ctx.systemPromptFor(cwd);
+    const messages = [
+      { role: 'system', content: `${basePrompt}\n\n${SUBAGENT_PROMPT}\n\nTarea: ${description}` },
+      { role: 'user', content: prompt },
+    ];
+    const { provider, config } = ctx.resolveProvider({
+      ...ctx.providerSettings(providerId),
+      apiKey: ctx.apiKeyFor(providerId),
+    });
+
+    try {
+      const result = await runAgent({
+        provider,
+        config,
+        model,
+        messages,
+        tools: local.definitions,
+        execute: local.execute,
+        signal,
+        maxRounds: ctx.config.agents?.maxRounds ?? 6,
+        onEvent(event) {
+          if (event.type === 'text') emit('text', { full: event.full, agentId }, agentId);
+          else if (event.type === 'reasoning') emit('reasoning', { full: event.full, agentId }, agentId);
+          else if (event.type === 'tool_call') {
+            emit(
+              'tool_call',
+              { id: event.id, name: event.name, args: event.args, summary: summarizeToolCall(event.name, event.args), agentId },
+              agentId
+            );
+          } else if (event.type === 'tool_result') {
+            const { preview, truncated } = previewToolResult(event.name, event.result);
+            const failed = /^Error|^Permiso denegado/i.test(String(event.result));
+            emit('tool_result', { id: event.id, name: event.name, preview, truncated, failed, agentId }, agentId);
+          }
+        },
+      });
+
+      ctx.store.addMessages(
+        sessionId,
+        result.messages.slice(messages.length).map((message) => ({ ...message, agent_id: agentId }))
+      );
+      const summary = (result.content ?? '').trim() || '(sin resumen)';
+      const status = result.stopReason === 'aborted' ? 'aborted' : 'done';
+      ctx.store.finishAgent(agentId, { status, summary });
+      emit('agent_end', { agentId, status, content: summary, rounds: result.rounds, tokens: result.usage ?? null }, agentId);
+      return `Subagente "${description}" (${status}):\n\n${summary}`;
+    } catch (error) {
+      const status = error?.name === 'AbortError' ? 'aborted' : 'error';
+      const message = String(error?.message ?? error);
+      ctx.store.finishAgent(agentId, { status, summary: message });
+      emit('agent_end', { agentId, status, content: message }, agentId);
+      return `Subagente "${description}" falló (${status}): ${message}`;
+    }
+  }
+
+  return { definitions, handles, execute };
+}

package/harness/packages/server/src/routes/chat.js

@@ -1,7 +1,15 @@
 import { randomUUID } from 'node:crypto';
-import { runAgent, createTools, resolveMode, MAX_TOOL_ROUNDS } from '../lib/core.js';
+import {
+  runAgent,
+  createTools,
+  resolveMode,
+  MAX_TOOL_ROUNDS,
+  summarizeToolCall,
+  previewToolResult,
+} from '../lib/core.js';
 import { openSse, readJson, sendJson, sendError } from '../lib/http.js';
 import { workspaceForRequest, resolveExistingDir } from '../lib/workspace.js';
+import { createSubagentTool } from '../lib/tasks.js';
 
 /**
  * Emit streaming partials at most once per `ms` window, keeping only the
@@ -49,6 +57,43 @@ export function registerChat(route, ctx) {
     sendJson(res, 200, { ok: true, allow, scope });
   });
 
+  route('POST', '/api/sessions/:id/stop', ({ res, params }) => {
+    if (!ctx.runs.isActive(params.id)) return sendJson(res, 200, { ok: true, stopped: false });
+    ctx.runs.cancel(params.id);
+    sendJson(res, 200, { ok: true, stopped: true });
+  });
+
+  // Reanuda un turno en curso: reproduce los eventos guardados y sigue en vivo.
+  route('GET', '/api/sessions/:id/stream', ({ req, res, params, query }) => {
+    if (!ctx.store.getSession(params.id)) return sendError(res, 404, 'Sesión no encontrada.');
+    const from = Number(query.get('from') ?? req.headers['last-event-id'] ?? 0) || 0;
+    const sse = openSse(req, res);
+
+    const buffered = [];
+    let replaying = true;
+    const unsubscribe = ctx.runs.subscribe(params.id, (event) => {
+      if (replaying) buffered.push(event);
+      else sse.event(event.type, event.data, event.id);
+    });
+    const stored = ctx.store.getSessionEvents(params.id, { from });
+    let cursor = from;
+    for (const event of stored) {
+      sse.event(event.type, event.data, event.id);
+      cursor = event.id;
+    }
+    replaying = false;
+    for (const event of buffered) {
+      if (event.id > cursor) sse.event(event.type, event.data, event.id);
+    }
+    const active = ctx.runs.isActive(params.id);
+    sse.event('resumed', { active, cursor });
+    req.on('close', unsubscribe);
+    if (!active) {
+      sse.event('idle', {});
+      sse.close();
+    }
+  });
+
   route('POST', '/api/chat', async ({ req, res }) => {
     const body = await readJson(req);
     const input = String(body.input ?? '').trim();
@@ -87,25 +132,28 @@ export function registerChat(route, ctx) {
       });
     }
 
-    const mode = resolveMode(body.mode ?? ctx.store.getSetting('activeMode'));
+    if (ctx.runs.isActive(sessionId)) {
+      return sendError(res, 409, 'La sesión ya tiene una respuesta en curso.');
+    }
 
+    const mode = resolveMode(body.mode ?? ctx.store.getSetting('activeMode'));
     const sse = openSse(req, res);
-    const controller = new AbortController();
+    ctx.runs.start(sessionId);
+    const unsubscribe = ctx.runs.subscribe(sessionId, (event) => sse.event(event.type, event.data, event.id));
+    // Desconectar no cancela: el run sigue y los eventos quedan persistidos.
+    req.on('close', () => unsubscribe());
+
     const autoApprove = body.yes ?? ctx.yes;
     const asked = new Set();
-    req.on('close', () => {
-      controller.abort();
-      ctx.approvals.cancel(asked);
-    });
 
-    sse.event('start', { sessionId, provider: providerId, model, mode: mode.id, cwd: sessionCwd });
-    sse.event('user', { content: input });
+    ctx.runs.emit(sessionId, 'start', { sessionId, provider: providerId, model, mode: mode.id, cwd: sessionCwd });
+    ctx.runs.emit(sessionId, 'user', { content: input });
 
     let mcp = null;
     try {
       mcp = await ctx.getMcp();
     } catch (error) {
-      sse.event('warning', { message: `MCP: ${error?.message ?? error}` });
+      ctx.runs.emit(sessionId, 'warning', { message: `MCP: ${error?.message ?? error}` });
     }
 
     const enabled = Array.isArray(body.tools) && body.tools.length ? body.tools : mode.tools ?? undefined;
@@ -116,11 +164,11 @@ export function registerChat(route, ctx) {
           const askId = randomUUID();
           asked.add(askId);
           askMeta.set(askId, { sessionId });
-          sse.event('permission', { askId, sessionId, name, args });
+          ctx.runs.emit(sessionId, 'permission', { askId, sessionId, name, args });
           const allow = await ctx.approvals.ask(askId);
           asked.delete(askId);
           askMeta.delete(askId);
-          sse.event('permission_resolved', { askId, allow });
+          ctx.runs.emit(sessionId, 'permission_resolved', { askId, allow });
           return allow;
         };
     const local = createTools({
@@ -134,11 +182,29 @@ export function registerChat(route, ctx) {
     // En modo plan (solo lectura) no exponemos las tools de administración.
     const exposeAdmin = !mode.tools;
     const admin = ctx.agentTools;
-    const definitions = exposeAdmin ? [...local.definitions, ...admin.definitions] : local.definitions;
-    const execute = (name, args, context) =>
-      exposeAdmin && admin.handles(name)
-        ? admin.execute(name, args, { approve: autoApprove ? async () => true : onAsk })
-        : local.execute(name, args, context);
+    const emitAgent = (type, data, agentId = null) => ctx.runs.emit(sessionId, type, data, { agentId });
+    const tasks = createSubagentTool(ctx, {
+      sessionId,
+      cwd: sessionCwd,
+      providerId,
+      model,
+      permissions: ctx.config.permissions,
+      mcp,
+      signal: ctx.runs.signal(sessionId),
+      exclude: admin.definitions.map((d) => d.function.name),
+      emit: emitAgent,
+    });
+    const definitions = [
+      ...(exposeAdmin ? [...local.definitions, ...admin.definitions] : local.definitions),
+      ...tasks.definitions,
+    ];
+    const execute = (name, args, context) => {
+      if (tasks.handles(name)) return tasks.execute(name, args);
+      if (exposeAdmin && admin.handles(name)) {
+        return admin.execute(name, args, { approve: autoApprove ? async () => true : onAsk });
+      }
+      return local.execute(name, args, context);
+    };
 
     const { provider, config } = ctx.resolveProvider({
       ...ctx.providerSettings(providerId),
@@ -167,66 +233,84 @@ export function registerChat(route, ctx) {
       ...history,
       userMessage,
     ];
+    // Persistimos el mensaje del usuario ya: asi sobrevive a un corte y la
+    // reconexion puede reconstruir el turno desde el historial.
+    ctx.store.addMessage(sessionId, userMessage);
+    const prefixLength = messages.length;
 
-    try {
-      const partials = createPartialThrottle(300, (name, payload) => sse.event(name, payload));
-      const result = await runAgent({
-        provider,
-        config,
-        model,
-        messages,
-        tools: definitions,
-        execute,
-        signal: controller.signal,
-        maxRounds: Number(body.maxRounds) || ctx.config.maxRounds || MAX_TOOL_ROUNDS,
-        stallWarnMs: body.stallWarnMs ?? ctx.config.stallWarnMs,
-        contextTokens: Number(body.contextTokens) || ctx.config.contextTokens || 0,
-        onEvent(event) {
-          if (event.type === 'text') partials.push('text', { delta: event.delta, full: event.full });
-          else if (event.type === 'reasoning') partials.push('reasoning', { delta: event.delta, full: event.full });
-          else if (event.type === 'stall') {
-            partials.flush();
-            sse.event('stall', { seconds: event.seconds });
-          } else if (event.type === 'retry') {
-            partials.flush();
-            sse.event('retry', { attempt: event.attempt, delayMs: event.delayMs, message: event.message });
-          } else if (event.type === 'trim') {
-            partials.flush();
-            sse.event('trim', { trimmed: event.trimmed, dropped: event.dropped, tokens: event.tokens });
-          } else if (event.type === 'tool_round') {
-            partials.flush();
-            sse.event('tools', { toolCalls: event.toolCalls });
-          } else if (event.type === 'tool_call') {
-            partials.flush();
-            sse.event('tool_call', { name: event.name, args: event.args });
-          } else if (event.type === 'tool_result') {
-            partials.flush();
-            sse.event('tool_result', { name: event.name, result: String(event.result).slice(0, 8000) });
-          }
-        },
-      });
-      partials.flush();
-
-      const newMessages = result.messages
-        .slice(1 + history.length)
-        .map((message) => (message.role === 'assistant' ? { ...message, mode: mode.id } : message));
-      ctx.store.addMessages(sessionId, newMessages);
-      const current = ctx.store.getSession(sessionId);
-      const title =
-        current && (!current.title || current.title === 'Nueva sesión') ? input.slice(0, 60) : undefined;
-      ctx.store.touchSession(sessionId, { provider: providerId, model, title });
-      sse.event('done', {
-        sessionId,
-        content: result.content,
-        rounds: result.rounds,
-        stopReason: result.stopReason,
-        tokens: result.usage ?? null,
-      });
-    } catch (error) {
-      if (error?.name === 'AbortError') sse.event('aborted', {});
-      else sse.event('error', { message: error?.message ?? String(error) });
-    } finally {
-      sse.close();
-    }
+    (async () => {
+      const partials = createPartialThrottle(300, (name, payload) => ctx.runs.emit(sessionId, name, payload));
+      try {
+        const result = await runAgent({
+          provider,
+          config,
+          model,
+          messages,
+          tools: definitions,
+          execute,
+          signal: ctx.runs.signal(sessionId),
+          maxRounds: Number(body.maxRounds) || ctx.config.maxRounds || MAX_TOOL_ROUNDS,
+          stallWarnMs: body.stallWarnMs ?? ctx.config.stallWarnMs,
+          contextTokens: Number(body.contextTokens) || ctx.config.contextTokens || 0,
+          onEvent(event) {
+            if (event.type === 'text') partials.push('text', { delta: event.delta, full: event.full });
+            else if (event.type === 'reasoning') partials.push('reasoning', { delta: event.delta, full: event.full });
+            else if (event.type === 'stall') {
+              partials.flush();
+              ctx.runs.emit(sessionId, 'stall', { seconds: event.seconds });
+            } else if (event.type === 'retry') {
+              partials.flush();
+              ctx.runs.emit(sessionId, 'retry', { attempt: event.attempt, delayMs: event.delayMs, message: event.message });
+            } else if (event.type === 'trim') {
+              partials.flush();
+              ctx.runs.emit(sessionId, 'trim', { trimmed: event.trimmed, dropped: event.dropped, tokens: event.tokens });
+            } else if (event.type === 'tool_round') {
+              partials.flush();
+              ctx.runs.emit(sessionId, 'tools', { toolCalls: event.toolCalls });
+            } else if (event.type === 'tool_call') {
+              partials.flush();
+              ctx.runs.emit(sessionId, 'tool_call', {
+                id: event.id,
+                name: event.name,
+                args: event.args,
+                summary: summarizeToolCall(event.name, event.args),
+              });
+            } else if (event.type === 'tool_result') {
+              partials.flush();
+              const { preview, truncated } = previewToolResult(event.name, event.result);
+              const failed = /^Error|^Permiso denegado/i.test(String(event.result));
+              ctx.runs.emit(sessionId, 'tool_result', { id: event.id, name: event.name, preview, truncated, failed });
+            }
+          },
+        });
+        partials.flush();
+
+        const newMessages = result.messages
+          .slice(prefixLength)
+          .map((message) => (message.role === 'assistant' ? { ...message, mode: mode.id } : message));
+        ctx.store.addMessages(sessionId, newMessages);
+        const current = ctx.store.getSession(sessionId);
+        const title =
+          current && (!current.title || current.title === 'Nueva sesión') ? input.slice(0, 60) : undefined;
+        ctx.store.touchSession(sessionId, { provider: providerId, model, title });
+        if (result.stopReason === 'aborted') ctx.runs.emit(sessionId, 'aborted', {});
+        else
+          ctx.runs.emit(sessionId, 'done', {
+            sessionId,
+            content: result.content,
+            rounds: result.rounds,
+            stopReason: result.stopReason,
+            tokens: result.usage ?? null,
+          });
+      } catch (error) {
+        partials.flush();
+        if (error?.name === 'AbortError') ctx.runs.emit(sessionId, 'aborted', {});
+        else ctx.runs.emit(sessionId, 'error', { message: error?.message ?? String(error) });
+      } finally {
+        unsubscribe();
+        sse.close();
+        ctx.runs.finish(sessionId);
+      }
+    })();
   });
 }

package/harness/packages/server/src/routes/sessions.js

@@ -76,9 +76,26 @@ export function registerSessions(route, ctx) {
       session: view(session),
       tokens: ctx.store.sessionTokens(params.id),
       messages: ctx.store.getMessages(params.id),
+      running: ctx.runs?.isActive(params.id) ?? false,
     });
   });
 
+  route('GET', '/api/sessions/:id/agents', ({ res, params }) => {
+    if (!ctx.store.getSession(params.id)) return sendError(res, 404, 'Sesión no encontrada.');
+    sendJson(res, 200, { agents: ctx.store.listAgents(params.id) });
+  });
+
+  route('GET', '/api/sessions/:id/tool-result', ({ res, params, query }) => {
+    if (!ctx.store.getSession(params.id)) return sendError(res, 404, 'Sesión no encontrada.');
+    const callId = String(query.get('callId') || '');
+    if (!callId) return sendError(res, 400, 'Falta "callId".');
+    const message = ctx.store.getMessages(params.id).find((m) => m.tool_call_id === callId);
+    if (!message) return sendError(res, 404, 'Resultado no encontrado.');
+    const content =
+      typeof message.content === 'string' ? message.content : JSON.stringify(message.content, null, 2);
+    sendJson(res, 200, { callId, name: message.name ?? null, content });
+  });
+
   route('PUT', '/api/sessions/:id', async ({ req, res, params }) => {
     const session = ctx.store.getSession(params.id);
     if (!session) return sendError(res, 404, 'Sesión no encontrada.');

package/harness/packages/server/src/server.js

@@ -18,8 +18,9 @@ import { sendJson, sendError } from './lib/http.js';
 import { createPromptBuilder, DEFAULT_SYSTEM_PROMPT } from './lib/prompt.js';
 import { skillsPrompt } from './lib/skills.js';
 import { createApprovalBroker } from './lib/approvals.js';
+import { createRunManager } from './lib/runManager.js';
 import { createProcManager } from './lib/procs.js';
-import { startTelegramBot } from './lib/telegram.js';
+import { startChannels } from './lib/channels/index.js';
 import { createAgentTools } from './lib/agentTools.js';
 import { createStaticHandler } from './static.js';
 import { requireLogin, requireCsrf } from './auth.js';
@@ -71,6 +72,7 @@ export async function createTamnoraServer({
   const authEnabled = Boolean(app.user && app.user.password);
   const store = new Store(dbPath ?? databasePath(cwd));
   const approvals = createApprovalBroker({ timeoutMs: config.approvalTimeoutMs });
+  const runs = createRunManager({ store });
   const procs = createProcManager({ allow: config.processes?.allow });
   const procsEnabled = config.processes?.enabled !== false;
   const autoApproved = new Set();
@@ -142,6 +144,7 @@ export async function createTamnoraServer({
     authEnabled,
     store,
     approvals,
+    runs,
     isAutoApprove,
     setAutoApprove,
     yes,
@@ -167,20 +170,12 @@ export async function createTamnoraServer({
   ctx.systemPrompt = (await ctx.systemPromptFor(cwd)) || DEFAULT_SYSTEM_PROMPT;
   ctx.agentTools = createAgentTools(ctx);
 
-  // Bot de Telegram (long polling) si hay token: config, app.json o entorno.
-  const tgConfig = { ...(app.telegram ?? {}), ...(config.telegram ?? {}) };
-  const tgToken = tgConfig.token || process.env.TAMNORA_TELEGRAM_TOKEN || '';
-  const rawAllow = tgConfig.allowedChatIds ?? process.env.TAMNORA_TELEGRAM_CHAT_IDS ?? [];
-  const tgAllow = Array.isArray(rawAllow) ? rawAllow : String(rawAllow).split(/[,\s]+/).filter(Boolean);
-  const telegramBot =
-    telegram && tgToken
-      ? startTelegramBot(ctx, {
-          token: tgToken,
-          allowedChatIds: tgAllow,
-          log: (message) => process.stderr.write(`${message}\n`),
-        })
-      : null;
-  ctx.telegram = Boolean(telegramBot);
+  // Canales de mensajeria (Telegram via long polling) si hay token.
+  const channels = telegram
+    ? startChannels(ctx, { log: (message) => process.stderr.write(`${message}\n`) })
+    : { channels: [], enabled: false, stop() {} };
+  ctx.telegram = channels.enabled;
+  ctx.channels = channels;
 
   const routes = [];
   const route = (method, pattern, handler) =>
@@ -290,7 +285,8 @@ export async function createTamnoraServer({
 
   const close = async () => {
     approvals.cancelAll();
-    telegramBot?.stop();
+    runs.cancelAll();
+    channels.stop();
     preview.close();
     procs.close();
     try {

package/harness/packages/server/test/server.test.js

@@ -141,6 +141,89 @@ test('streams a chat turn over SSE and persists the messages', async () => {
   }
 });
 
+test('persists the run log and replays it on the stream endpoint', async () => {
+  const { instance, base } = await startServer();
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ input: 'hola', model: 'm' }),
+      })
+    ).text();
+    const list = await (await fetch(`${base}/api/sessions`)).json();
+    const id = list.sessions[0].id;
+
+    const stream = await (await fetch(`${base}/api/sessions/${id}/stream?from=0`)).text();
+    assert.match(stream, /event: start/);
+    assert.match(stream, /event: text/);
+    assert.match(stream, /event: done/);
+    assert.match(stream, /event: idle/);
+    assert.match(stream, /^id: \d+$/m);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('keeps a run alive after the client disconnects and can stop it', async () => {
+  let release;
+  const gate = new Promise((resolve) => (release = resolve));
+  const slowProvider = {
+    id: 'slow',
+    async streamChat(_config, { onEvent, signal }) {
+      onEvent?.({ type: 'text', delta: '…', full: '…' });
+      await new Promise((resolve, reject) => {
+        if (signal?.aborted) return reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+        signal?.addEventListener('abort', () =>
+          reject(Object.assign(new Error('aborted'), { name: 'AbortError' }))
+        );
+        gate.then(resolve);
+      });
+      return { content: 'fin', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider: slowProvider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ model: 'm' }),
+      })
+    ).json();
+    const id = created.session.id;
+
+    const controller = new AbortController();
+    const chat = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'hola', model: 'm', sessionId: id }),
+      signal: controller.signal,
+    }).catch(() => null);
+    await new Promise((resolve) => setTimeout(resolve, 80));
+    controller.abort();
+    await chat;
+
+    const during = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    assert.equal(during.running, true);
+
+    const stopped = await (
+      await fetch(`${base}/api/sessions/${id}/stop`, { method: 'POST', headers: json })
+    ).json();
+    assert.equal(stopped.stopped, true);
+
+    release();
+    await new Promise((resolve) => setTimeout(resolve, 80));
+    const after = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    assert.equal(after.running, false);
+  } finally {
+    release();
+    await instance.close();
+  }
+});
+
 test('manages MCP servers from the console', async () => {
   const { instance, base } = await startServer();
   const json = { 'Content-Type': 'application/json' };
@@ -898,13 +981,58 @@ test('plan mode exposes only read-only tools and adds guidance', async () => {
         body: JSON.stringify({ input: 'planificá', model: 'm', mode: 'plan' }),
       })
     ).text();
-    assert.deepEqual(captured.tools, ['fetch_url', 'git_diff', 'git_log', 'git_status', 'glob', 'grep', 'list', 'read']);
+    assert.deepEqual(captured.tools, ['fetch_url', 'git_diff', 'git_log', 'git_status', 'glob', 'grep', 'list', 'read', 'task']);
     assert.match(captured.system, /modo PLAN/);
   } finally {
     await instance.close();
   }
 });
 
+test('the agent can delegate to a subagent with the task tool', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-task-'));
+  const provider = {
+    id: 'multi',
+    async streamChat(_config, { messages, onEvent }) {
+      const isSub = messages.some((m) => m.role === 'system' && /subagente/i.test(String(m.content)));
+      if (isSub) {
+        onEvent?.({ type: 'text', delta: 'resumen', full: 'resumen subagente' });
+        return { content: 'resumen subagente', reasoning: '', toolCalls: [] };
+      }
+      const done = messages.some((m) => m.role === 'tool' && m.name === 'task');
+      if (done) return { content: 'listo', reasoning: '', toolCalls: [] };
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          { id: 't1', function: { name: 'task', arguments: JSON.stringify({ description: 'explorar', prompt: 'leé el proyecto' }) } },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const stream = await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ input: 'delegá', model: 'm' }),
+      })
+    ).text();
+    assert.match(stream, /event: agent_start/);
+    assert.match(stream, /event: agent_end/);
+
+    const list = await (await fetch(`${base}/api/sessions`)).json();
+    const id = list.sessions[0].id;
+    const agents = await (await fetch(`${base}/api/sessions/${id}/agents`)).json();
+    assert.equal(agents.agents.length, 1);
+    assert.equal(agents.agents[0].status, 'done');
+    assert.match(agents.agents[0].summary, /resumen subagente/);
+  } finally {
+    await instance.close();
+  }
+});
+
 test('aggregates the token usage of a session', async () => {
   const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tokens-'));
   const provider = {