@danieltmn/tamnora 0.25.0 → 0.25.1

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

@@ -185,6 +185,9 @@ export const skillSearchResultsEl = $('#skill-search-results');
 export const skillCatalogEl = $('#skill-catalog');
 export const skillModal = $('#skill-modal');
 export const skillForm = $('#skill-form');
+export const agentListEl = $('#agent-list');
+export const agentModal = $('#agent-modal');
+export const agentForm = $('#agent-form');
 export const memoryListEl = $('#memory-list');
 export const memoryIndexEl = $('#memory-index');
 export const memoryModal = $('#memory-modal');
@@ -556,6 +559,170 @@ export async function submitSkill(event) {
   refreshSkills();
 }
 
+/* --- ajustes: Subagentes ------------------------------------------------- */
+
+export async function refreshAgents() {
+  if (!agentListEl) return;
+  const data = await api('/api/agents').catch(() => null);
+  if (!data) return;
+  clear(agentListEl);
+  if (!data.agents.length) {
+    agentListEl.appendChild(
+      emptyState(
+        'Sin subagentes todavía',
+        'Tocá «+ nuevo» para crear uno: el agente principal va a verlo en su catálogo y podrá delegarle tareas con task.'
+      )
+    );
+    return;
+  }
+  for (const agent of data.agents) {
+    const li = el('li', agent.enabled ? 'active' : '');
+    li.appendChild(el('span', `pdot${agent.enabled ? ' on' : ''}`));
+    const main = el('div', 'grow');
+    const details = [
+      agent.provider || 'proveedor heredado',
+      agent.model || 'modelo heredado',
+      agent.mode || 'modo heredado',
+      agent.effort ? `esfuerzo ${agent.effort}` : '',
+      Array.isArray(agent.skills) ? `${agent.skills.length} skill(s)` : 'todas las skills',
+    ].filter(Boolean);
+    main.append(
+      el('div', '', `${agent.name || agent.id} · ${agent.id}`),
+      el('div', 'pmeta', agent.description || details.join(' · '))
+    );
+    li.appendChild(main);
+    const actions = el('div', 'pactions');
+    actions.appendChild(button(agent.enabled ? 'deshabilitar' : 'habilitar', (event) => { event.stopPropagation(); toggleAgent(agent.id); }));
+    actions.appendChild(button('editar', (event) => { event.stopPropagation(); openAgentForm(agent.id); }));
+    if (agent.removable) {
+      actions.appendChild(button('borrar', (event) => { event.stopPropagation(); removeAgent(agent.id); }, 'btn danger'));
+    }
+    li.appendChild(actions);
+    li.addEventListener('click', () => openAgentForm(agent.id));
+    agentListEl.appendChild(li);
+  }
+}
+
+function fillAgentProviders() {
+  const select = $('#af-provider');
+  if (!select) return;
+  const current = select.value;
+  clear(select);
+  const inherit = document.createElement('option');
+  inherit.value = '';
+  inherit.textContent = 'heredar';
+  select.appendChild(inherit);
+  for (const provider of state.providers ?? []) {
+    const option = document.createElement('option');
+    option.value = provider.id;
+    option.textContent = provider.label && provider.label !== provider.id ? `${provider.label} (${provider.id})` : provider.id;
+    select.appendChild(option);
+  }
+  select.value = current;
+}
+
+function fillAgentSkills(selected = null) {
+  const select = $('#af-skills');
+  if (!select) return;
+  clear(select);
+  for (const skill of state.skills ?? []) {
+    const option = document.createElement('option');
+    option.value = skill.id;
+    option.textContent = `${skill.name || skill.id}${skill.enabled ? '' : ' (deshabilitada)'}`;
+    option.disabled = !skill.enabled;
+    select.appendChild(option);
+  }
+  const wanted = new Set(Array.isArray(selected) ? selected : []);
+  for (const option of select.options) option.selected = wanted.has(option.value);
+}
+
+export async function openAgentForm(id = null) {
+  $('#agent-title').textContent = id ? `editar ${id}` : 'nuevo subagente';
+  $('#af-id').value = id ?? '';
+  $('#af-id').readOnly = Boolean(id);
+  $('#af-name').value = '';
+  $('#af-description').value = '';
+  $('#af-model').value = '';
+  $('#af-rounds').value = '';
+  $('#af-tools').value = '';
+  $('#af-body').value = '';
+  setStatus('#af-status', '');
+  const providers = await api('/api/providers').catch(() => null);
+  if (providers?.providers) state.providers = providers.providers;
+  const skills = await api('/api/skills').catch(() => null);
+  state.skills = skills?.skills ?? [];
+  const effort = $('#af-effort');
+  if (effort) effort.value = '';
+  fillAgentProviders();
+  $('#af-provider').value = '';
+  $('#af-mode').value = '';
+  fillAgentSkills([]);
+  if (id) {
+    const data = await api(`/api/agents/${encodeURIComponent(id)}`).catch(() => null);
+    if (data?.agent) {
+      const agent = data.agent;
+      $('#af-name').value = agent.name ?? '';
+      $('#af-description').value = agent.description ?? '';
+      $('#af-model').value = agent.model ?? '';
+      $('#af-provider').value = agent.provider ?? '';
+      $('#af-mode').value = agent.mode ?? '';
+      $('#af-effort').value = agent.effort ?? '';
+      $('#af-rounds').value = agent.maxRounds || '';
+      $('#af-tools').value = (agent.tools ?? []).join(', ');
+      fillAgentSkills(agent.skills ?? null);
+      $('#af-body').value = agent.body ?? '';
+    }
+  }
+  agentModal.showModal();
+  if (!id) $('#af-id').focus();
+}
+
+export function closeAgentForm() {
+  if (agentModal?.open) agentModal.close();
+}
+
+export async function toggleAgent(id) {
+  await toggleEntity(`/api/agents/${encodeURIComponent(id)}/toggle`, {
+    method: 'POST',
+    errorLabel: 'cambiar el subagente',
+    refresh: refreshAgents,
+  });
+}
+
+export async function removeAgent(id) {
+  await deleteEntity(`/api/agents/${encodeURIComponent(id)}`, {
+    confirmText: `¿Eliminar el subagente "${id}"?`,
+    refresh: refreshAgents,
+  });
+}
+
+export async function submitAgent(event) {
+  event.preventDefault();
+  const id = $('#af-id').value.trim();
+  if (!id) return setStatus('#af-status', 'Falta el id.', 'err');
+  const skillsSelect = $('#af-skills');
+  const selectedSkills = skillsSelect ? [...skillsSelect.selectedOptions].map((option) => option.value) : [];
+  const body = {
+    name: $('#af-name').value.trim() || id,
+    description: $('#af-description').value.trim(),
+    provider: $('#af-provider').value.trim(),
+    model: $('#af-model').value.trim(),
+    mode: $('#af-mode').value,
+    effort: $('#af-effort').value,
+    maxRounds: Number($('#af-rounds').value) || 0,
+    tools: $('#af-tools').value.split(',').map((item) => item.trim()).filter(Boolean),
+    skills: selectedSkills.length ? selectedSkills : null,
+    body: $('#af-body').value,
+  };
+  try {
+    await api(`/api/agents/${encodeURIComponent(id)}`, { method: 'PUT', body });
+  } catch (error) {
+    return setStatus('#af-status', error.message, 'err');
+  }
+  closeAgentForm();
+  refreshAgents();
+}
+
 /* --- ajustes: Memoria ---------------------------------------------------- */
 
 export async function refreshMemory() {

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

@@ -20,6 +20,7 @@ export const SETTINGS_GROUPS = [
       { id: 'perfil', label: 'Perfil', keywords: 'nombre idioma notas como llamarte usuario datos' },
       { id: 'memoria', label: 'Memoria', keywords: 'recuerdos proyecto notas durable indice' },
       { id: 'skills', label: 'Skills', keywords: 'habilidades instrucciones skill catalogo' },
+      { id: 'agentes', label: 'Subagentes', keywords: 'agentes subagentes delegar task modelo skills esfuerzo' },
       { id: 'mcp', label: 'MCP', keywords: 'servidores herramientas tools conectores catalogo playwright' },
     ],
   },

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

@@ -0,0 +1,74 @@
+import path from 'node:path';
+import { rm } from 'node:fs/promises';
+import {
+  homeDir,
+  loadAgents,
+  mergeAgents,
+  buildAgentsIndex,
+  writeAgentFile,
+} from './core.js';
+
+export const AGENT_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
+
+/** Agent roots, lowest priority first: casa agents, then the workspace's. */
+export function agentRoots(cwd) {
+  return [path.join(homeDir(), 'agents'), path.join(cwd, '.tamnora', 'agents')];
+}
+
+export function allAgents(cwd) {
+  const home = path.join(homeDir(), 'agents');
+  return mergeAgents(agentRoots(cwd).map((root) => loadAgents(root).map((a) => ({ ...a, root, home: root === home }))));
+}
+
+function disabledIds(store) {
+  const raw = store.getSetting('disabledAgents');
+  return new Set(Array.isArray(raw) ? raw.map(String) : []);
+}
+
+export function agentsView(ctx) {
+  const disabled = disabledIds(ctx.store);
+  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 = disabledIds(ctx.store);
+  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 rm(path.join(homeDir(), 'agents', String(id)), { recursive: true, force: true });
+}
+
+export function setAgentEnabled(store, id, enabled) {
+  const current = new Set(Array.isArray(store.getSetting('disabledAgents')) ? store.getSetting('disabledAgents') : []);
+  if (enabled) current.delete(id);
+  else current.add(id);
+  store.setSetting('disabledAgents', [...current]);
+}

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/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

@@ -57,6 +57,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 });

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/routes/agents.js

@@ -0,0 +1,88 @@
+import { readJson, sendJson, sendError } from '../lib/http.js';
+import { normalizeEffort, resolveMode } from '../lib/core.js';
+import {
+  AGENT_ID_PATTERN,
+  agentsView,
+  findAgent,
+  writeAgent,
+  removeAgent,
+  setAgentEnabled,
+} from '../lib/agents.js';
+
+function cleanList(value) {
+  if (value === undefined || value === null) return null;
+  if (!Array.isArray(value)) return null;
+  return value.map((item) => String(item).trim()).filter(Boolean);
+}
+
+export function registerAgents(route, ctx) {
+  route('GET', '/api/agents', ({ res }) => {
+    sendJson(res, 200, { agents: agentsView(ctx) });
+  });
+
+  route('GET', '/api/agents/:id', ({ res, params }) => {
+    const agent = findAgent(ctx, params.id);
+    if (!agent) return sendError(res, 404, 'Subagente no encontrado.');
+    sendJson(res, 200, {
+      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,
+        body: agent.body,
+        removable: Boolean(agent.home),
+      },
+    });
+  });
+
+  route('PUT', '/api/agents/:id', async ({ req, res, params }) => {
+    const id = String(params.id);
+    if (!AGENT_ID_PATTERN.test(id)) return sendError(res, 400, 'Id de subagente inválido (a-z, 0-9, - y _).');
+    const body = await readJson(req);
+    if (!String(body.body ?? '').trim() && !String(body.description ?? '').trim()) {
+      return sendError(res, 400, 'El subagente necesita un cuerpo o una descripción.');
+    }
+    const mode = body.mode ? resolveMode(String(body.mode)).id : '';
+    const maxRounds = Number(body.maxRounds);
+    try {
+      await writeAgent(id, {
+        name: String(body.name ?? id).trim() || id,
+        description: String(body.description ?? '').trim(),
+        model: String(body.model ?? '').trim(),
+        provider: String(body.provider ?? '').trim(),
+        mode,
+        effort: normalizeEffort(body.effort),
+        maxRounds: Number.isFinite(maxRounds) && maxRounds > 0 ? Math.round(maxRounds) : 0,
+        tools: cleanList(body.tools),
+        skills: cleanList(body.skills),
+        body: String(body.body ?? ''),
+      });
+    } catch (error) {
+      return sendError(res, 500, `No se pudo guardar el subagente: ${error.message}`);
+    }
+    sendJson(res, 200, { agents: agentsView(ctx) });
+  });
+
+  route('DELETE', '/api/agents/:id', async ({ res, params }) => {
+    const agent = findAgent(ctx, params.id);
+    if (!agent) return sendError(res, 404, 'Subagente no encontrado.');
+    if (!agent.home) return sendError(res, 400, 'Ese subagente vive en el workspace y no se borra desde acá.');
+    await removeAgent(agent.id);
+    setAgentEnabled(ctx.store, agent.id, true);
+    sendJson(res, 200, { agents: agentsView(ctx) });
+  });
+
+  route('POST', '/api/agents/:id/toggle', async ({ res, params }) => {
+    const agent = findAgent(ctx, params.id);
+    if (!agent) return sendError(res, 404, 'Subagente no encontrado.');
+    const enabled = !agentsView(ctx).find((item) => item.id === agent.id)?.enabled;
+    setAgentEnabled(ctx.store, agent.id, enabled);
+    sendJson(res, 200, { id: agent.id, enabled, agents: agentsView(ctx) });
+  });
+}