@danieltmn/tamnora 0.24.2 → 0.25.1

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

@@ -1,7 +1,7 @@
 import { livePermission, reloadPane, renderSessions, resolvePermissionCard, sendPresence } from './chat.js';
 import { providerSelect, setSummaryText, yesInput } from './chrome.js';
 import { toast } from './commands.js';
-import { $, api, clear, el, openStream, showConfirm, state, storage, streamPost } from './core.js';
+import { $, api, clear, el, emptyState, openStream, showConfirm, state, storage, streamPost } from './core.js';
 import { diffState, localState, pollDelayMs } from './reconcile.js';
 import { followRun } from './runStream.js';
 import { closeTab, renderTabs, showStandalonePermission } from './sessions.js';
@@ -116,7 +116,7 @@ export async function refreshRuns() {
     });
     runsList.appendChild(li);
   }
-  if (!data.runs.length) runsList.appendChild(el('li', 'muted', 'Sin runs.'));
+  if (!data.runs.length) runsList.appendChild(emptyState('Sin runs todavía', 'Las evaluaciones que corras desde la pestaña eval quedan guardadas acá.'));
 }
 
 export async function openRun(id) {

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

@@ -11,10 +11,14 @@ export const THEME_IDS = [
   'solarized-dark',
   'bosque',
   'vino',
+  'arena',
+  'hielo',
   'vercel',
   'dark-plus',
   'github',
   'github-dark',
+  'mocha',
+  'ebano',
 ];
 
 export const FONT_IDS = ['clasico', 'sistema', 'plex', 'inter', 'jetbrains', 'fira', 'source'];

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

@@ -0,0 +1,20 @@
+// Lanza el script detached que espera la muerte de este server y lo relanza con
+// el mismo comando con que arranco. Devolver rapido es el punto: el server tiene
+// que soltar el puerto antes de que el nuevo intente entrar.
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { packageRoot, homeDir } from './core.js';
+
+export function spawnRestart({ pid = process.pid, argv = process.argv.slice(1), home } = {}) {
+  const root = packageRoot();
+  if (!root) return { ok: false, error: 'no encontre el paquete del harness' };
+  const script = path.join(root, 'harness', 'scripts', 'restart.mjs');
+  const args = [script, '--pid', String(pid), '--argv', JSON.stringify(argv), '--home', home || homeDir()];
+  try {
+    const child = spawn(process.execPath, args, { detached: true, stdio: 'ignore', windowsHide: true });
+    child.unref();
+    return { ok: true, pid: child.pid };
+  } catch (error) {
+    return { ok: false, error: String(error?.message ?? error) };
+  }
+}

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

@@ -0,0 +1,53 @@
+// Cabeceras de seguridad de la consola. La consola es una SPA sin build: sus
+// scripts son modulos propios, asi que `script-src 'self'` alcanza y un XSS por
+// un hueco del renderer de markdown no puede cargar ni ejecutar codigo ajeno.
+
+const FONTS_CSS = 'https://fonts.googleapis.com';
+const FONTS_FILES = 'https://fonts.gstatic.com';
+
+export const CSP_DIRECTIVES = {
+  'default-src': ["'self'"],
+  'script-src': ["'self'"],
+  'style-src': ["'self'", "'unsafe-inline'", FONTS_CSS],
+  'font-src': ["'self'", FONTS_FILES, 'data:'],
+  'img-src': ["'self'", 'data:', 'blob:'],
+  'media-src': ["'self'", 'blob:', 'data:'],
+  'connect-src': ["'self'"],
+  // La pestaña preview embebe el dev server del usuario (local o por tunel).
+  'frame-src': ['http:', 'https:'],
+  'frame-ancestors': ["'self'"],
+  'manifest-src': ["'self'"],
+  'worker-src': ["'self'", 'blob:'],
+  'object-src': ["'none'"],
+  'base-uri': ["'self'"],
+  'form-action': ["'self'"],
+};
+
+export function buildCsp(directives = CSP_DIRECTIVES) {
+  return Object.entries(directives)
+    .map(([name, sources]) => `${name} ${sources.join(' ')}`)
+    .join('; ');
+}
+
+const CSP_VALUE = buildCsp();
+
+export const CSP_MODES = ['enforce', 'report-only', 'off'];
+
+export function cspMode(config) {
+  const mode = config?.server?.csp;
+  return CSP_MODES.includes(mode) ? mode : 'enforce';
+}
+
+/**
+ * Setea las cabeceras en `res` antes de `writeHead` (que las mezcla). La CSP solo
+ * va en lo que no es API: en un JSON o un SSE no protege nada.
+ */
+export function applySecurityHeaders(res, { api = false, csp = 'enforce' } = {}) {
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('Referrer-Policy', 'same-origin');
+  res.setHeader('X-Frame-Options', 'SAMEORIGIN');
+  res.setHeader('Permissions-Policy', 'camera=(), geolocation=(), payment=(), usb=()');
+  if (api || csp === 'off') return;
+  const name = csp === 'report-only' ? 'Content-Security-Policy-Report-Only' : 'Content-Security-Policy';
+  res.setHeader(name, CSP_VALUE);
+}

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) });
+  });
+}

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

@@ -3,11 +3,13 @@ import {
   runAgent,
   createTools,
   resolveMode,
+  normalizeEffort,
   MAX_TOOL_ROUNDS,
 } from '../lib/core.js';
 import { openSse, readJson, sendJson, sendError } from '../lib/http.js';
 import { workspaceForRequest, resolveExistingDir, localOk } from '../lib/workspace.js';
 import { createSubagentTool } from '../lib/tasks.js';
+import { enabledAgents } from '../lib/agents.js';
 import {
   combineToolset,
   combineLifecycle,
@@ -162,6 +164,8 @@ export function registerChat(route, ctx) {
     const model = body.model || session?.model || ctx.effectiveModel();
     if (!model) return sendError(res, 400, 'Falta "model" (en el cuerpo, en Ajustes o en tamnora.json).');
     const mode = resolveMode(body.mode ?? session?.meta?.mode ?? ctx.store.getSetting('activeMode'));
+    // Esfuerzo de razonamiento: cuerpo > sesión > default global/config.
+    const effort = normalizeEffort(body.effort ?? session?.meta?.effort ?? ctx.effectiveEffort?.());
 
     if (!sessionId) {
       try {
@@ -174,7 +178,7 @@ export function registerChat(route, ctx) {
         provider: providerId,
         model,
         cwd: sessionCwd,
-        meta: { mode: mode.id },
+        meta: { mode: mode.id, effort },
       });
     }
 
@@ -209,6 +213,7 @@ export function registerChat(route, ctx) {
       provider: providerId,
       model,
       mode: mode.id,
+      effort,
       cwd: sessionCwd,
       say: fraseInicio(),
     });
@@ -271,6 +276,8 @@ export function registerChat(route, ctx) {
       providerId,
       model,
       parentMode: mode,
+      effort,
+      agents: enabledAgents(ctx),
       permissions: ctx.config.permissions,
       mcp,
       mcpMode: ctx.effectiveMcpMode(),
@@ -347,6 +354,7 @@ export function registerChat(route, ctx) {
           maxDurationMs: Number(body.maxDurationMs) || ctx.effectiveMaxDurationMs?.() || 0,
           maxOutputTokens: Number(body.maxOutputTokens) || ctx.effectiveMaxOutputTokens?.() || 0,
           promptCaching: ctx.effectivePromptCaching?.() ?? ctx.config.promptCaching === true,
+          reasoningEffort: effort,
           stallWarnMs: body.stallWarnMs ?? ctx.config.stallWarnMs,
           contextTokens,
           onEvent(event) {

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

@@ -7,6 +7,7 @@ import {
   readApp,
   writeApp,
   maskSecret,
+  normalizeEffort,
 } from '../lib/core.js';
 import { resolveAppearance, sanitizeAppearance } from '../lib/appearance.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
@@ -26,6 +27,7 @@ export function providerList(ctx) {
       baseUrl: row?.baseUrl || '',
       defaultBaseUrl: meta.defaultBaseUrl,
       requiresKey: row?.requiresKey ?? meta.requiresKey,
+      reasoning: meta.reasoning ?? 'none',
       custom: false,
       builtin: true,
       stored: Boolean(row),
@@ -44,6 +46,7 @@ export function providerList(ctx) {
         baseUrl: row.baseUrl,
         defaultBaseUrl: '',
         requiresKey: row.requiresKey ?? true,
+        reasoning: 'none',
         custom: true,
         builtin: false,
         stored: true,
@@ -83,6 +86,7 @@ export function registerProviders(route, ctx) {
     maxDurationMs: ctx.effectiveMaxDurationMs(),
     maxOutputTokens: ctx.effectiveMaxOutputTokens(),
     promptCaching: ctx.effectivePromptCaching(),
+    effort: ctx.effectiveEffort(),
     defaultCwd: ctx.store.getSetting('defaultCwd') || '',
     strictScope: ctx.effectiveStrictScope(),
     mcpMode: ctx.effectiveMcpMode(),
@@ -101,6 +105,9 @@ export function registerProviders(route, ctx) {
     if (body.mode !== undefined) ctx.store.setSetting('activeMode', resolveMode(String(body.mode)).id);
     if (body.defaultCwd !== undefined) ctx.store.setSetting('defaultCwd', String(body.defaultCwd ?? '').trim() || null);
     if (body.strictScope !== undefined) ctx.store.setSetting('strictScope', Boolean(body.strictScope));
+    if (body.effort !== undefined) {
+      ctx.store.setSetting('activeEffort', normalizeEffort(body.effort) || null);
+    }
     if (body.promptCaching !== undefined) ctx.store.setSetting('promptCaching', Boolean(body.promptCaching));
     if (body.mcpMode !== undefined) {
       const mode = String(body.mcpMode);