@danieltmn/tamnora 0.25.0 → 0.26.0

package/harness/packages/server/public/voice.js

@@ -6,11 +6,9 @@ import {
   setStatus,
   trModelEl,
   trProviderEl,
-  vozAnnAdviceEl,
   vozAnnAnswerEl,
   vozAnnEndEl,
   vozAnnStartEl,
-  vozAnnSummaryEl,
   vozAnnToolsEl,
   vozEnabledEl,
   vozFfmpegEl,
@@ -573,7 +571,7 @@ export const voz = {
     voice: 'es-AR-ElenaNeural',
     rate: '+0%',
     pitch: '+0Hz',
-    announce: { start: true, tools: true, end: true, advice: true, answer: false, summary: false },
+    announce: { start: true, tools: true, end: true, answer: false },
   },
 };
 
@@ -772,11 +770,9 @@ export function narrar(event, data, turn) {
   const { enabled, announce } = voz.settings;
   if (!enabled && !handsFreeOn) return;
   // Manos libres: conversacion, sin narracion de arranque/herramientas; lee la
-  // respuesta final (y el asesor) aunque la narracion este apagada en Ajustes.
+  // respuesta final aunque la narracion este apagada en Ajustes.
   if (handsFreeOn) {
-    if (event === 'advice') {
-      if (data?.say) hablar(data.say, { label: 'asesor', maxAgeMs: 0, force: true });
-    } else if (event === 'done') {
+    if (event === 'done') {
       const spoken = speechText(data?.content);
       if (spoken) hablar(spoken, { label: 'respuesta', maxAgeMs: 0, force: true });
       else if (data?.say) hablar(data.say, { maxAgeMs: 0, force: true });
@@ -788,15 +784,9 @@ export function narrar(event, data, turn) {
   if (!enabled) return;
   if (event === 'start' && announce.start) hablar(data?.say);
   else if (event === 'tool_call' && announce.tools) hablar(data?.say);
-  // El asesor y la respuesta final son el cierre del turno: si quedan en cola
-  // detras de un audio largo, igual hay que leerlos (sin vencimiento).
-  else if (event === 'advice') {
-    if (data?.kind === 'summary') {
-      if (announce.summary) hablar(data?.say, { label: 'resumen', maxAgeMs: 0 });
-    } else if (announce.advice) {
-      hablar(data?.say, { label: 'asesor', maxAgeMs: 0 });
-    }
-  } else if (event === 'done' && announce.answer) {
+  // La respuesta final es el cierre del turno: si queda en cola detras de un
+  // audio largo, igual hay que leerla (sin vencimiento).
+  else if (event === 'done' && announce.answer) {
     // Lee la respuesta final limpia; si era solo codigo, cae al cierre.
     const spoken = speechText(data?.content);
     if (spoken) hablar(spoken, { label: 'respuesta', maxAgeMs: 0 });
@@ -828,9 +818,7 @@ export async function aplicarVoz(data) {
       start: data.announce?.start !== false,
       tools: data.announce?.tools !== false,
       end: data.announce?.end !== false,
-      advice: data.announce?.advice !== false,
       answer: data.announce?.answer === true,
-      summary: data.announce?.summary === true,
     },
   };
   if (vozEnabledEl) vozEnabledEl.checked = voz.settings.enabled;
@@ -850,8 +838,6 @@ export async function aplicarVoz(data) {
   if (vozAnnStartEl) vozAnnStartEl.checked = voz.settings.announce.start;
   if (vozAnnToolsEl) vozAnnToolsEl.checked = voz.settings.announce.tools;
   if (vozAnnEndEl) vozAnnEndEl.checked = voz.settings.announce.end;
-  if (vozAnnAdviceEl) vozAnnAdviceEl.checked = voz.settings.announce.advice;
-  if (vozAnnSummaryEl) vozAnnSummaryEl.checked = voz.settings.announce.summary;
   if (vozAnnAnswerEl) vozAnnAnswerEl.checked = voz.settings.announce.answer;
   const estado = $('#voz-status');
   if (estado) {
@@ -877,9 +863,7 @@ export async function submitVoz() {
       start: vozAnnStartEl?.checked !== false,
       tools: vozAnnToolsEl?.checked !== false,
       end: vozAnnEndEl?.checked !== false,
-      advice: vozAnnAdviceEl?.checked !== false,
       answer: vozAnnAnswerEl?.checked === true,
-      summary: vozAnnSummaryEl?.checked === true,
     },
   };
   const data = await api('/api/tts/settings', { method: 'PUT', body }).catch((e) => ({ error: e.message }));

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

@@ -1,6 +1,5 @@
 import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
 import { sendError } from './lib/http.js';
-import { tunnelState } from './lib/core.js';
 import { isLoopback } from './lib/workspace.js';
 
 /**
@@ -38,26 +37,16 @@ export function parseCookies(header) {
   return out;
 }
 
-// Detras del tunel el server recibe desde loopback: solo ahi confiamos en
-// X-Forwarded-Proto para marcar la cookie Secure. Como el cliente del tunel
-// corre en la misma maquina, un request por el tunel es indistinguible de uno
-// local por direccion: usamos el Host (localhost/127.0.0.1 = local) y el
-// estado del bridge para no mandar la cookie sin Secure por el tunel.
-function isLocalHost(req) {
-  const host = String(req.headers.host || '').split(':')[0].toLowerCase();
-  return !host || host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '[::1]';
-}
-
+// Detras del bridge de tailscale el server recibe desde loopback: solo ahi
+// confiamos en X-Forwarded-Proto para marcar la cookie Secure. La URL del
+// tailnet es HTTPS aunque el salto interno sea http.
 function isSecure(req) {
   if (req.socket && req.socket.encrypted) return true;
   const remote = req.socket && req.socket.remoteAddress;
   const loopback = !remote || isLoopback(remote);
   if (!loopback) return false;
   const proto = String(req.headers['x-forwarded-proto'] || '').split(',')[0].trim().toLowerCase();
-  if (proto === 'https') return true;
-  // Peticion por el tunel (host publico + bridge activo): la URL publica es
-  // HTTPS, la cookie no tiene que poder viajar por la variante http.
-  return Boolean(tunnelState()) && !isLocalHost(req);
+  return proto === 'https';
 }
 
 function serializeCookie(value, req, maxAge) {

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

@@ -52,7 +52,7 @@ export async function serveCommand(argv) {
 function printHelp() {
   console.log(`Uso: tamnora serve [opciones]
 
-Levanta la consola del harness (chat + evaluación) en localhost.
+Levanta la consola del harness (chat) en localhost.
 
 Opciones:
   --port <n>       Puerto (default: 4517)

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

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import { homeDir, loadAgents, mergeAgents, buildAgentsIndex, writeAgentFile } from './core.js';
+import {
+  DEFINITION_ID_PATTERN,
+  allDefinitions,
+  disabledDefinitionIds,
+  removeDefinition,
+  setDefinitionEnabled,
+} from './definitions.js';
+
+export const AGENT_ID_PATTERN = DEFINITION_ID_PATTERN;
+
+export function allAgents(cwd) {
+  return allDefinitions(cwd, { kind: 'agents', load: loadAgents, merge: mergeAgents });
+}
+
+export function agentsView(ctx) {
+  const disabled = disabledDefinitionIds(ctx.store, 'agents');
+  return allAgents(ctx.cwd).map((agent) => ({
+    id: agent.id,
+    name: agent.name || agent.id,
+    description: agent.description || '',
+    model: agent.model || '',
+    provider: agent.provider || '',
+    mode: agent.mode || '',
+    effort: agent.effort || '',
+    maxRounds: agent.maxRounds || 0,
+    tools: agent.tools,
+    skills: agent.skills,
+    enabled: !disabled.has(agent.id),
+    removable: Boolean(agent.home),
+  }));
+}
+
+export function findAgent(ctx, id) {
+  return allAgents(ctx.cwd).find((agent) => agent.id === id) ?? null;
+}
+
+export function enabledAgents(ctx) {
+  const disabled = disabledDefinitionIds(ctx.store, 'agents');
+  return allAgents(ctx.cwd).filter((agent) => !disabled.has(agent.id));
+}
+
+export function agentsIndexPrompt(ctx) {
+  return buildAgentsIndex(enabledAgents(ctx));
+}
+
+export async function writeAgent(id, data) {
+  const dir = path.join(homeDir(), 'agents', String(id));
+  await writeAgentFile(dir, { ...data, id });
+  return dir;
+}
+
+export async function removeAgent(id) {
+  await removeDefinition('agents', id);
+}
+
+export function setAgentEnabled(store, id, enabled) {
+  setDefinitionEnabled(store, 'agents', id, enabled);
+}

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

@@ -1,27 +1,9 @@
 // Apariencia de la consola (app.json -> appearance): tema, tipografía y tamaño.
 // Los ids deben coincidir con public/appearance.js; acá solo se valida y acota.
 
-export const THEME_IDS = [
-  'paper',
-  'dark',
-  'midnight',
-  'nord',
-  'dracula',
-  'solarized',
-  'solarized-dark',
-  'bosque',
-  'vino',
-  'arena',
-  'hielo',
-  'vercel',
-  'dark-plus',
-  'github',
-  'github-dark',
-  'mocha',
-  'ebano',
-];
+export const THEME_IDS = ['paper', 'github', 'dark', 'mocha'];
 
-export const FONT_IDS = ['clasico', 'sistema', 'plex', 'inter', 'jetbrains', 'fira', 'source'];
+export const FONT_IDS = ['clasico', 'sistema'];
 
 export const DEFAULT_APPEARANCE = { theme: 'paper', font: 'clasico', chatFont: 14.5, scale: 1 };
 
@@ -31,8 +13,7 @@ const MIN_SCALE = 0.8;
 const MAX_SCALE = 1.3;
 
 export function resolveThemeId(id) {
-  const legacy = id === 'light' ? 'paper' : id;
-  return THEME_IDS.includes(legacy) ? legacy : DEFAULT_APPEARANCE.theme;
+  return THEME_IDS.includes(id) ? id : DEFAULT_APPEARANCE.theme;
 }
 
 export function resolveFontId(id) {

package/harness/packages/server/src/lib/channels/telegram/commands.js

@@ -179,7 +179,7 @@ export async function handleCommand(T, chatId, text) {
     T.controllers.get(String(chatId))?.abort();
     return send(T, chatId, 'Cancelando.');
   }
-  if (cmd === 'estricto' || cmd === 'strict') {
+  if (cmd === 'estricto') {
     const current = T.ctx.store.getSetting('strictScope') === true;
     const value = arg ? /^(on|si|sí|1|true)$/i.test(arg) : !current;
     T.ctx.store.setSetting('strictScope', value);

package/harness/packages/server/src/lib/channels/telegram/run.js

@@ -140,6 +140,7 @@ export async function run(T, chatId, input, images = []) {
       maxDurationMs: T.ctx.effectiveMaxDurationMs?.() ?? 0,
       maxOutputTokens: T.ctx.effectiveMaxOutputTokens?.() ?? T.ctx.config.maxOutputTokens ?? 0,
       promptCaching: T.ctx.effectivePromptCaching?.() ?? T.ctx.config.promptCaching === true,
+      reasoningEffort: T.ctx.effectiveEffort?.() ?? '',
       onEvent(event) {
         if (event.type === 'text') {
           full = event.full;

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

@@ -0,0 +1,40 @@
+// Registro comun de definiciones en markdown (skills y subagentes): raices
+// casa + workspace, merge con prioridad al workspace y estado on/off en un
+// setting (`disabledSkills` / `disabledAgents`).
+
+import path from 'node:path';
+import { rm } from 'node:fs/promises';
+import { homeDir } from './core.js';
+
+export const DEFINITION_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
+
+/** Raices, de menor a mayor prioridad: casa y despues workspace. */
+export function definitionRoots(cwd, kind) {
+  return [path.join(homeDir(), kind), path.join(cwd, '.tamnora', kind)];
+}
+
+/** Carga y mergea las definiciones, marcando `root` y si viven en la casa. */
+export function allDefinitions(cwd, { kind, load, merge }) {
+  const home = path.join(homeDir(), kind);
+  return merge(definitionRoots(cwd, kind).map((root) => load(root).map((item) => ({ ...item, root, home: root === home }))));
+}
+
+function disabledKey(kind) {
+  return `disabled${kind[0].toUpperCase()}${kind.slice(1)}`;
+}
+
+export function disabledDefinitionIds(store, kind) {
+  const raw = store.getSetting(disabledKey(kind));
+  return new Set(Array.isArray(raw) ? raw.map(String) : []);
+}
+
+export function setDefinitionEnabled(store, kind, id, enabled) {
+  const current = disabledDefinitionIds(store, kind);
+  if (enabled) current.delete(id);
+  else current.add(id);
+  store.setSetting(disabledKey(kind), [...current]);
+}
+
+export function removeDefinition(kind, id) {
+  return rm(path.join(homeDir(), kind, String(id)), { recursive: true, force: true });
+}

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

@@ -33,12 +33,13 @@ function workspacePreamble(cwd) {
  * @param {string[]} opts.files - instruction file names (e.g. ['AGENTS.md'])
  * @param {() => string} [opts.profileText] - user profile block, re-read on every call
  * @param {() => string} [opts.skillsText] - skills block, re-read on every call
+ * @param {() => string} [opts.agentsText] - subagent catalog block, re-read on every call
  * @param {() => string} [opts.mcpText] - MCP tool index block, re-read on every call
  * @param {() => string} [opts.scopeText] - strict-scope block, re-read on every call
  * @param {string[]} [opts.ruleFiles] - glob patterns of project rule files
  * @param {boolean} [opts.memory] - inject the project memory block
  */
-export function createPromptBuilder({ cwd, files, profileText, skillsText, mcpText, scopeText, ruleFiles = [], memory = false }) {
+export function createPromptBuilder({ cwd, files, profileText, skillsText, agentsText, mcpText, scopeText, ruleFiles = [], memory = false }) {
   const cache = new Map();
 
   async function buildFor(workspace) {
@@ -52,15 +53,22 @@ export function createPromptBuilder({ cwd, files, profileText, skillsText, mcpTe
     return text;
   }
 
-  return async function systemPromptFor(workspace = cwd) {
+  return async function systemPromptFor(workspace = cwd, overrides = {}) {
     const key = workspace || cwd;
     if (!cache.has(key)) cache.set(key, buildFor(key));
     const base = await cache.get(key);
     const parts = [base];
     const profile = typeof profileText === 'function' ? String(profileText() ?? '').trim() : '';
     if (profile) parts.push(profile);
-    const extra = typeof skillsText === 'function' ? String(skillsText() ?? '').trim() : '';
+    // Un subagente puede reemplazar (o vaciar) el bloque de skills y el catálogo
+    // de otros subagentes: las tools no se heredan automáticamente.
+    const skillsSource = overrides.skillsText !== undefined ? overrides.skillsText : skillsText;
+    const extra =
+      typeof skillsSource === 'function' ? String(skillsSource() ?? '').trim() : String(skillsSource ?? '').trim();
     if (extra) parts.push(extra);
+    const agentsSource = overrides.agentsText !== undefined ? overrides.agentsText : agentsText;
+    const agents = typeof agentsSource === 'function' ? String(agentsSource() ?? '').trim() : String(agentsSource ?? '').trim();
+    if (agents) parts.push(agents);
     const mcp = typeof mcpText === 'function' ? String(mcpText() ?? '').trim() : '';
     if (mcp) parts.push(mcp);
     if (memory) {

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

@@ -13,6 +13,7 @@ import {
 } from './agentRun.js';
 import { createSubagentTool } from './tasks.js';
 import { createRulesInjector } from './rules.js';
+import { enabledAgents } from './agents.js';
 
 function scheduleSessionId(ctx, schedule) {
   const payload = schedule.payload ?? {};
@@ -74,6 +75,8 @@ async function runAgentSchedule(ctx, schedule) {
     providerId,
     model,
     parentMode: mode,
+    effort: ctx.effectiveEffort?.() ?? '',
+    agents: enabledAgents(ctx),
     permissions: ctx.config.permissions,
     mcp,
     mcpMode: ctx.effectiveMcpMode(),
@@ -109,6 +112,7 @@ async function runAgentSchedule(ctx, schedule) {
       maxDurationMs: ctx.effectiveMaxDurationMs?.() || 0,
       maxOutputTokens: ctx.effectiveMaxOutputTokens?.() || 0,
       promptCaching: ctx.effectivePromptCaching?.() ?? ctx.config.promptCaching === true,
+      reasoningEffort: ctx.effectiveEffort?.() ?? '',
       onEvent(event) {
         if (event.type === 'text') emit('text', { full: event.full });
         else if (event.type === 'reasoning') emit('reasoning', { full: event.full });

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

@@ -12,6 +12,7 @@ export function sessionView(session) {
     provider: session.provider,
     model: session.model,
     mode: session.meta?.mode ?? null,
+    effort: session.meta?.effort ?? null,
     cwd: session.cwd,
     goal: session.meta?.goal ?? null,
     hasSummary: Boolean(session.meta?.summary),

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

@@ -1,26 +1,22 @@
 import path from 'node:path';
-import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { homeDir, loadSkills, mergeSkills, buildSkillsPrompt, buildSkillsIndex } from './core.js';
+import {
+  DEFINITION_ID_PATTERN,
+  allDefinitions,
+  disabledDefinitionIds,
+  removeDefinition,
+  setDefinitionEnabled,
+} from './definitions.js';
 
-export const SKILL_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
-
-/** Skill roots, lowest priority first: casa skills, then the workspace's. */
-export function skillRoots(cwd) {
-  return [path.join(homeDir(), 'skills'), path.join(cwd, '.tamnora', 'skills')];
-}
+export const SKILL_ID_PATTERN = DEFINITION_ID_PATTERN;
 
 export function allSkills(cwd) {
-  const home = path.join(homeDir(), 'skills');
-  return mergeSkills(skillRoots(cwd).map((root) => loadSkills(root).map((s) => ({ ...s, root, home: root === home }))));
-}
-
-function disabledIds(store) {
-  const raw = store.getSetting('disabledSkills');
-  return new Set(Array.isArray(raw) ? raw.map(String) : []);
+  return allDefinitions(cwd, { kind: 'skills', load: loadSkills, merge: mergeSkills });
 }
 
 export function skillsView(ctx) {
-  const disabled = disabledIds(ctx.store);
+  const disabled = disabledDefinitionIds(ctx.store, 'skills');
   return allSkills(ctx.cwd).map((s) => ({
     id: s.id,
     name: s.name || s.id,
@@ -36,7 +32,7 @@ export function findSkill(ctx, id) {
 }
 
 export function enabledSkills(ctx) {
-  const disabled = disabledIds(ctx.store);
+  const disabled = disabledDefinitionIds(ctx.store, 'skills');
   return allSkills(ctx.cwd)
     .filter((s) => !disabled.has(s.id))
     .map((s) => ({ id: s.id, name: s.name || s.id, description: s.description, when: s.when, body: s.body }));
@@ -57,6 +53,19 @@ export function skillsBlock(ctx) {
   return eager ? skillsPrompt(ctx) : skillsIndexPrompt(ctx);
 }
 
+/**
+ * Bloque de skills acotado a las que declara un subagente. `ids === null`
+ * significa "sin restricción" (todas las habilitadas); un array vacío no
+ * inyecta skills.
+ */
+export function skillsBlockFor(ctx, ids = null) {
+  if (!Array.isArray(ids)) return skillsBlock(ctx);
+  const wanted = new Set(ids.map(String));
+  const selected = enabledSkills(ctx).filter((skill) => wanted.has(skill.id));
+  if (!selected.length) return '';
+  return ctx.config?.skills?.mode === 'eager' ? buildSkillsPrompt(selected) : buildSkillsIndex(selected);
+}
+
 export async function writeSkill(id, { name, description, when, body }) {
   const dir = path.join(homeDir(), 'skills', id);
   await mkdir(dir, { recursive: true });
@@ -69,12 +78,9 @@ export async function writeSkill(id, { name, description, when, body }) {
 }
 
 export async function removeSkill(id) {
-  await rm(path.join(homeDir(), 'skills', id), { recursive: true, force: true });
+  await removeDefinition('skills', id);
 }
 
 export function setSkillEnabled(store, id, enabled) {
-  const current = new Set(Array.isArray(store.getSetting('disabledSkills')) ? store.getSetting('disabledSkills') : []);
-  if (enabled) current.delete(id);
-  else current.add(id);
-  store.setSetting('disabledSkills', [...current]);
+  setDefinitionEnabled(store, 'skills', id, enabled);
 }

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

@@ -2,16 +2,13 @@
 // 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.
+//
+// Un subagente puede venir de una definicion del proyecto (`agents/*.md`): en
+// ese caso aporta su propio modelo/proveedor, modo, tools, skills y esfuerzo.
 
-import { runAgent, createTools, resolveMode } from './core.js';
+import { runAgent, createTools, resolveMode, normalizeEffort, buildSubagentPrompt } from './core.js';
 import { toolCallPayload, toolResultPayload } from './agentRun.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(' ');
+import { skillsBlockFor } from './skills.js';
 
 function definition(name, description, parameters, required = []) {
   return {
@@ -34,9 +31,16 @@ function clampMode(requested, parentMode) {
   return { id: requested.id, tools, writeExtensions };
 }
 
+function intersect(list, allowed) {
+  if (!Array.isArray(list) || !list.length) return null;
+  const set = new Set(allowed);
+  return list.filter((item) => set.has(item));
+}
+
 /**
  * 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).
+ * `agents` es el catálogo de subagentes habilitados del workspace.
  */
 export function createSubagentTool(ctx, options) {
   const {
@@ -44,6 +48,7 @@ export function createSubagentTool(ctx, options) {
     cwd,
     providerId,
     model,
+    effort = '',
     permissions = {},
     mcp = null,
     mcpMode = 'auto',
@@ -52,15 +57,26 @@ export function createSubagentTool(ctx, options) {
     exclude = [],
     emit,
     parentMode = null,
+    agents = [],
   } = options;
 
+  const available = new Map(agents.map((agent) => [agent.id, agent]));
+  const agentParam = {
+    type: 'string',
+    description: available.size
+      ? `Id del subagente (ver el catálogo del system prompt): ${[...available.keys()].join(', ')}`
+      : 'Id del subagente (no hay subagentes definidos)',
+  };
+  if (available.size) agentParam.enum = [...available.keys()];
+
   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.',
+      'Delega una subtarea a un subagente con su propio contexto. Si hay subagentes definidos, elegí uno con "agent"; si no, se crea uno ad-hoc de solo lectura. 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' },
+        agent: agentParam,
         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' },
       },
@@ -76,15 +92,31 @@ export function createSubagentTool(ctx, options) {
     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 = clampMode(resolveMode(args.mode ?? 'plan'), parentMode);
-    emit('agent_start', { agentId, description, mode: mode.id, model }, agentId);
+    const wanted = String(args.agent ?? '').trim();
+    const spec = wanted ? available.get(wanted) : null;
+    if (wanted && !spec) {
+      const ids = [...available.keys()].join(', ');
+      return ids ? `No existe el subagente "${wanted}". Disponibles: ${ids}.` : 'No hay subagentes definidos.';
+    }
+
+    const subProviderId = spec?.provider || providerId;
+    const subModel = spec?.model || model;
+    const subEffort = normalizeEffort(spec?.effort) || normalizeEffort(effort);
+    const rawMode = resolveMode(spec?.mode || args.mode || 'plan');
+    const mode = clampMode(rawMode, parentMode);
+
+    // Precedencia: tools de la definicion > tools pedidas > tools del modo.
+    const declared = Array.isArray(spec?.tools) && spec.tools.length ? spec.tools : null;
+    const requested = declared ?? (Array.isArray(args.tools) && args.tools.length ? args.tools : (mode.tools ?? undefined));
+    let enabled = requested ? requested.filter((tool) => !exclude.includes(tool)) : undefined;
+    if (enabled && mode.tools) enabled = intersect(enabled, mode.tools) ?? [];
+    else if (!enabled && mode.tools) enabled = [...mode.tools];
+    if (!enabled) enabled = undefined;
+
+    const title = spec ? spec.name || spec.id : description;
+    const agentId = ctx.store.createAgent({ sessionId, kind: 'task', title, model: subModel });
+    emit('agent_start', { agentId, description, mode: mode.id, model: subModel, agent: spec?.id ?? null }, agentId);
 
-    const requested =
-      Array.isArray(args.tools) && args.tools.length
-        ? args.tools.filter((tool) => !exclude.includes(tool))
-        : (mode.tools ?? undefined);
-    const enabled = mode.tools ? requested.filter((tool) => mode.tools.includes(tool)) : requested;
     const local = createTools({
       root: cwd,
       enabled,
@@ -96,29 +128,45 @@ export function createSubagentTool(ctx, options) {
       mcpPinned,
       signal,
     });
-    const basePrompt = await ctx.systemPromptFor(cwd);
+    // Un subagente con skills declaradas ve solo esas skills (arbol de contexto
+    // acotado); sin declaracion hereda el bloque general.
+    const skillsText = spec ? skillsBlockFor(ctx, spec.skills) : undefined;
+    const basePrompt = await ctx.systemPromptFor(cwd, {
+      skillsText: spec ? skillsText : undefined,
+      agentsText: '',
+    });
+    const systemPrompt = buildSubagentPrompt(
+      {
+        id: spec?.id ?? 'task',
+        name: spec?.name ?? description,
+        description: spec?.description ?? '',
+        body: spec?.body ?? '',
+      },
+      { basePrompt }
+    );
     const messages = [
-      { role: 'system', content: `${basePrompt}\n\n${SUBAGENT_PROMPT}\n\nTarea: ${description}` },
+      { role: 'system', content: `${systemPrompt}\n\nTarea: ${description}` },
       { role: 'user', content: prompt },
     ];
     const { provider, config } = ctx.resolveProvider({
-      ...ctx.providerSettings(providerId),
-      apiKey: ctx.apiKeyFor(providerId),
+      ...ctx.providerSettings(subProviderId),
+      apiKey: ctx.apiKeyFor(subProviderId),
     });
 
     try {
       const result = await runAgent({
         provider,
         config,
-        model,
+        model: subModel,
         messages,
         tools: local.definitions,
         execute: local.execute,
         redactExtra: ctx.secretExtra?.() ?? [],
         signal,
-        maxRounds: ctx.config.agents?.maxRounds ?? 6,
+        maxRounds: spec?.maxRounds || ctx.config.agents?.maxRounds || 6,
         maxOutputTokens: ctx.config.agents?.maxOutputTokens ?? ctx.config.maxOutputTokens ?? 0,
         promptCaching: ctx.effectivePromptCaching?.() ?? ctx.config.promptCaching === true,
+        reasoningEffort: subEffort,
         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);

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

@@ -9,14 +9,14 @@ export const DEFAULT_TTS = {
   voice: VOZ_POR_DEFECTO,
   rate: '+0%',
   pitch: '+0Hz',
-  announce: { start: true, tools: true, end: true, advice: true, answer: false, summary: false },
+  announce: { start: true, tools: true, end: true, answer: false },
 };
 
 /** Merge de defaults + lo guardado (con `announce` aplanado a booleans). */
 export function resolveTts(app) {
   const saved = app?.tts && typeof app.tts === 'object' ? app.tts : {};
   const announce = { ...DEFAULT_TTS.announce, ...(saved.announce ?? {}) };
-  for (const key of ['start', 'tools', 'end', 'advice', 'answer', 'summary']) announce[key] = announce[key] === true;
+  for (const key of ['start', 'tools', 'end', 'answer']) announce[key] = announce[key] === true;
   return {
     ...DEFAULT_TTS,
     ...saved,