@danieltmn/tamnora 0.14.0 → 0.16.0

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

@@ -2,6 +2,7 @@
 // el agente hizo (pedido, respuesta, herramientas y diffs), lo interpreta con
 // una llamada corta al modelo y decide si vale la pena decir algo. NO lee la
 // respuesta del agente: solo agrega alertas de codigo, explicaciones o consejos.
+// Opcionalmente (options.summary) devuelve tambien un resumen breve de lo hecho.
 //
 // La salida es JSON estricto para poder decidir el silencio: si el modelo no
 // tiene nada que aportar, no habla ni deja tarjeta.
@@ -13,8 +14,11 @@ export const DEFAULT_ADVISOR = {
   code: true,
   explain: true,
   advice: true,
+  summary: false,
   notes: '',
   maxWords: 40,
+  provider: '',
+  model: '',
 };
 
 const KINDS = new Set(['code', 'explain', 'advice']);
@@ -30,10 +34,13 @@ export function resolveAdvisor(app) {
     code: saved.code !== false,
     explain: saved.explain !== false,
     advice: saved.advice !== false,
+    summary: saved.summary === true,
     notes: typeof saved.notes === 'string' ? saved.notes.slice(0, 2000) : '',
     maxWords: Number.isFinite(maxWords)
       ? Math.min(Math.max(Math.round(maxWords), 10), 120)
       : DEFAULT_ADVISOR.maxWords,
+    provider: typeof saved.provider === 'string' ? saved.provider.trim().slice(0, 60) : '',
+    model: typeof saved.model === 'string' ? saved.model.trim().slice(0, 120) : '',
   };
 }
 
@@ -104,18 +111,30 @@ function focusLines(options) {
 /** System + user para la consulta al asesor (expuestos para test). */
 export function buildAdvisorPrompt({ userInput = '', answer = '', toolSummary = [], changedFiles = [], options = {} } = {}) {
   const maxWords = options.maxWords ?? DEFAULT_ADVISOR.maxWords;
+  const wantsAdvice = Boolean(options.code || options.explain || options.advice);
+  const wantsSummary = options.summary === true;
   const system =
     'Sos el asesor personal del usuario dentro de Tamnora, al estilo de Jarvis.\n' +
     'Recibis lo que el agente hizo en el ultimo turno: el pedido del usuario, su respuesta\n' +
     'final, las herramientas que uso y los diffs de los archivos que toco.\n\n' +
-    'Tu trabajo NO es resumir ni repetir la respuesta del agente: el usuario ya la esta\n' +
-    'viendo. Solo aportas algo que el agente no dijo. Enfocate en:\n' +
-    `${focusLines(options)}\n\n` +
+    (wantsAdvice
+      ? 'Tu trabajo NO es resumir ni repetir la respuesta del agente: el usuario ya la esta\n' +
+        'viendo. Solo aportas algo que el agente no dijo. Enfocate en:\n' +
+        `${focusLines(options)}\n` +
+        'Si no hay nada que valga la pena decir, pon "speak" en false.\n\n'
+      : '') +
+    (wantsSummary
+      ? 'Ademas el usuario quiere un resumen breve de lo que hizo el agente: en una o dos\n' +
+        'frases, que se pidio y que se hizo, sin copiar la respuesta palabra por palabra.\n' +
+        'Inclui siempre el campo "summary", aunque no tengas un consejo ("speak" puede ser false).\n\n'
+      : '') +
     'Hablale al usuario en segunda persona, breve (' +
     `${maxWords} palabras como maximo), en espanol, sin markdown ni listas. Si no hay nada\n` +
     'que valga la pena decir, no hables.\n' +
     (options.notes ? `\nInstrucciones del usuario: ${options.notes}\n` : '') +
-    '\nResponde SOLO con JSON: {"speak": true|false, "kind": "code|explain|advice", "text": "..."}';
+    '\nResponde SOLO con JSON: {"speak": true|false, "kind": "code|explain|advice", "text": "..."' +
+    (wantsSummary ? ', "summary": "..."' : '') +
+    '}';
 
   const parts = [`PEDIDO DEL USUARIO:\n${userInput || '(sin texto)'}`];
   parts.push(`RESPUESTA FINAL DEL AGENTE:\n${answer || '(sin respuesta)'}`);
@@ -169,8 +188,9 @@ export async function consultAdvisor({
     if (error || !value || typeof value !== 'object') return null;
     const kind = KINDS.has(value.kind) ? value.kind : 'advice';
     const text = truncateWords(value.text, maxWords);
-    if (value.speak !== true || !text) return { speak: false, kind, text: '' };
-    return { speak: true, kind, text };
+    const summary = options.summary === true ? truncateWords(value.summary, maxWords) : '';
+    if (value.speak !== true || !text) return { speak: false, kind, text: '', summary };
+    return { speak: true, kind, text, summary };
   } catch {
     return null;
   }

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

@@ -20,16 +20,18 @@ export function toolCallPayload(event) {
  * Combina tools locales + admin + subagentes en un toolset unificado.
  * `approve` es el callback de aprobacion de las tools de administraación.
  */
-export function combineToolset({ local, admin = null, tasks = null, exposeAdmin = false, approve = null }) {
+export function combineToolset({ local, admin = null, tasks = null, plugins = null, exposeAdmin = false, approve = null }) {
   const adminAllowed = (name) => Boolean(admin?.handles(name)) && (exposeAdmin || admin.readOnly?.has(name));
   const definitions = [
     ...local.definitions,
     ...(admin ? admin.definitions.filter((d) => adminAllowed(d.function.name)) : []),
     ...(tasks ? tasks.definitions : []),
+    ...(plugins ? plugins.definitions : []),
   ];
   const execute = (name, args, context = {}) => {
     if (tasks?.handles(name)) return tasks.execute(name, args);
     if (adminAllowed(name)) return admin.execute(name, args, { approve, ...context });
+    if (plugins?.handles(name)) return plugins.execute(name, args, { approve, ...context });
     return local.execute(name, args, context);
   };
   return { definitions, execute };

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

@@ -477,7 +477,13 @@ export function startTelegramChannel(
     });
     const exposeAdmin = !mode.tools;
     const admin = ctx.agentTools;
-    const { definitions, execute } = combineToolset({ local, admin, exposeAdmin, approve: onAsk });
+    const { definitions, execute } = combineToolset({
+      local,
+      admin,
+      plugins: exposeAdmin ? ctx.plugins : null,
+      exposeAdmin,
+      approve: onAsk,
+    });
     const { provider, config } = resolveProviderFor(ctx, providerId);
     const userMessage = buildUserMessage(input, images);
     const messages = await composeAgentMessages({ ctx, cwd, mode, history, userMessage });

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

@@ -52,8 +52,10 @@ export async function summarizeSession(ctx, session, instruction) {
   if (!messages.length) return { error: 'La sesión no tiene mensajes para resumir.', status: 400 };
   const resolved = providerFor(ctx, session);
   if (resolved.error) return resolved;
+  ctx.hooks?.dispatch({ type: 'session.compacting', sessionId: session.id, messages: messages.length });
   const summary = await summarize(ctx, session, messages, instruction);
   if (!summary) return { error: 'El modelo no devolvió un resumen.', status: 502 };
+  ctx.hooks?.dispatch({ type: 'session.compacted', sessionId: session.id, summary });
   return { summary };
 }
 
@@ -70,8 +72,10 @@ export async function maybeAutoCompact(ctx, session, history, { contextTokens }
   const live = liveHistory(history, session.meta?.summaryCursor ?? null);
   const plan = planCompaction(live, { contextTokens, threshold, keepLast });
   if (!plan) return null;
+  ctx.hooks?.dispatch({ type: 'session.compacting', sessionId: session.id, auto: true, messages: plan.toSummarize.length });
   const summary = await summarize(ctx, session, plan.toSummarize, COMPACT_INSTRUCTION, session.meta?.summary);
   if (!summary) return null;
   ctx.store.touchSession(session.id, { meta: { summary, summaryCursor: plan.cursor } });
+  ctx.hooks?.dispatch({ type: 'session.compacted', sessionId: session.id, auto: true, summary });
   return { summary, cursor: plan.cursor, summarized: plan.toSummarize.length };
 }

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

@@ -0,0 +1,45 @@
+// Runner de hooks: carga los modulos (`core/src/hooks`) y despacha eventos a
+// sus handlers de forma aislada (un hook que tira no rompe el run) y con los
+// datos redactados. Es opt-in: sin archivos de hooks, no se ejecuta codigo.
+
+import { loadHooks, redactDeep } from './core.js';
+
+/**
+ * Crea el runner. `dispatch(event)` llama a los handlers suscritos a
+ * `event.type` (y a los wildcard `*`); no devuelve valor (observadores).
+ */
+export async function createHookRunner(ctx, patterns = []) {
+  let hooks = [];
+  try {
+    hooks = await loadHooks(ctx.cwd, patterns);
+  } catch {
+    hooks = [];
+  }
+  const handlers = new Map();
+  for (const hook of hooks) {
+    for (const [event, fn] of Object.entries(hook.events)) {
+      if (typeof fn !== 'function') continue;
+      const list = handlers.get(event) ?? [];
+      list.push(fn);
+      handlers.set(event, list);
+    }
+  }
+
+  function dispatch(event) {
+    const list = [...(handlers.get(event.type) ?? []), ...(handlers.get('*') ?? [])];
+    if (!list.length) return;
+    const safe = redactDeep(event);
+    for (const fn of list) {
+      Promise.resolve()
+        .then(() => fn(safe, ctx))
+        .catch(() => {
+          // un hook caido no debe frenar el run
+        });
+    }
+  }
+
+  const view = () =>
+    hooks.map((hook) => ({ id: hook.id, path: hook.path, events: Object.keys(hook.events).filter((e) => e !== '*') }));
+
+  return { dispatch, count: hooks.length, list: view };
+}

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

@@ -0,0 +1,76 @@
+// Plugins: agregan herramientas propias al agente (`.tamnora/plugins/*.mjs` o
+// las rutas de `config.plugins`). Corren codigo del usuario, asi que pasan por
+// permisos (default `ask`).
+
+import { loadPlugins } from './core.js';
+
+function normalizeName(value) {
+  return String(value ?? '')
+    .replace(/[^a-z0-9_-]+/gi, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, 64);
+}
+
+/** Crea el toolset de plugins. `execute(name, args, { approve })`. */
+export async function createPlugins(ctx, patterns = []) {
+  let plugins = [];
+  try {
+    plugins = await loadPlugins(ctx.cwd, patterns);
+  } catch {
+    plugins = [];
+  }
+
+  const tools = [];
+  const used = new Set();
+  for (const plugin of plugins) {
+    for (const tool of plugin.tools) {
+      const name = `plugin__${normalizeName(plugin.id)}__${normalizeName(tool.name)}`;
+      if (!name || used.has(name)) continue;
+      used.add(name);
+      tools.push({
+        name,
+        source: tool.name,
+        plugin: plugin.id,
+        description: String(tool.description || tool.name),
+        parameters: tool.parameters && typeof tool.parameters === 'object' ? tool.parameters : {},
+        required: Array.isArray(tool.required) ? tool.required : [],
+        handler: tool.handler,
+      });
+    }
+  }
+
+  const byName = new Map(tools.map((tool) => [tool.name, tool]));
+  const definitions = tools.map((tool) => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: { type: 'object', properties: tool.parameters, required: tool.required },
+    },
+  }));
+
+  async function execute(name, args = {}, { approve } = {}) {
+    const tool = byName.get(name);
+    if (!tool) return `Herramienta desconocida: ${name}`;
+    const decision = (ctx.config.permissions ?? {})[tool.name] ?? 'ask';
+    if (decision === 'deny') return `Permiso denegado para "${name}".`;
+    if (decision === 'ask') {
+      const ok = approve ? await approve(name, args) : false;
+      if (!ok) return `Permiso denegado para "${name}".`;
+    }
+    try {
+      const out = await tool.handler(args, ctx);
+      return typeof out === 'string' ? out : JSON.stringify(out ?? null, null, 2);
+    } catch (error) {
+      return `Error en ${name}: ${error?.message ?? error}`;
+    }
+  }
+
+  return {
+    definitions,
+    handles: (name) => byName.has(name),
+    execute,
+    count: tools.length,
+    list: () => tools.map(({ name, source, plugin, description }) => ({ name, source, plugin, description })),
+  };
+}

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

@@ -68,7 +68,14 @@ async function runAgentSchedule(ctx, schedule) {
     exclude: admin.definitions.map((d) => d.function.name),
     emit,
   });
-  const { definitions, execute } = combineToolset({ local, admin, tasks, exposeAdmin, approve: async () => true });
+  const { definitions, execute } = combineToolset({
+    local,
+    admin,
+    tasks,
+    plugins: exposeAdmin ? ctx.plugins : null,
+    exposeAdmin,
+    approve: async () => true,
+  });
   const { provider, config } = resolveProviderFor(ctx, providerId);
 
   try {

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

@@ -8,14 +8,14 @@ export const DEFAULT_TTS = {
   enabled: false,
   voice: VOZ_POR_DEFECTO,
   rate: '+0%',
-  announce: { start: true, tools: true, end: true, advice: true, answer: false },
+  announce: { start: true, tools: true, end: true, advice: true, answer: false, summary: 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']) announce[key] = announce[key] === true;
+  for (const key of ['start', 'tools', 'end', 'advice', 'answer', 'summary']) announce[key] = announce[key] === true;
   return {
     ...DEFAULT_TTS,
     ...saved,

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

@@ -19,7 +19,10 @@ export function registerAdvisor(route, ctx) {
     if ('code' in body) next.code = body.code !== false;
     if ('explain' in body) next.explain = body.explain !== false;
     if ('advice' in body) next.advice = body.advice !== false;
+    if ('summary' in body) next.summary = body.summary === true;
     if ('notes' in body) next.notes = String(body.notes ?? '').slice(0, 2000);
+    if ('provider' in body) next.provider = String(body.provider ?? '').trim().slice(0, 60);
+    if ('model' in body) next.model = String(body.model ?? '').trim().slice(0, 120);
     if ('maxWords' in body) {
       const value = Number(body.maxWords);
       next.maxWords = Number.isFinite(value)
@@ -34,8 +37,8 @@ export function registerAdvisor(route, ctx) {
 
   route('POST', '/api/advisor/test', async ({ res }) => {
     const options = resolveAdvisor(ctx.app);
-    const providerId = ctx.effectiveProviderId();
-    const model = ctx.effectiveModel();
+    const providerId = options.provider || ctx.effectiveProviderId();
+    const model = options.model || ctx.effectiveModel();
     if (!model) return sendError(res, 400, 'Elegí un proveedor y un modelo primero.');
     const { provider, config } = ctx.resolveProvider({
       ...ctx.providerSettings(providerId),

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

@@ -221,11 +221,18 @@ export function registerChat(route, ctx) {
       permissions: ctx.config.permissions,
       mcp,
       signal: ctx.runs.signal(sessionId),
-      exclude: admin.definitions.map((d) => d.function.name),
+      exclude: [...admin.definitions.map((d) => d.function.name), ...(ctx.plugins?.list?.().map((t) => t.name) ?? [])],
       emit: emitAgent,
     });
     const approve = autoApprove ? async () => true : (name, args) => onAsk(name, args);
-    const { definitions, execute } = combineToolset({ local, admin, tasks, exposeAdmin, approve });
+    const { definitions, execute } = combineToolset({
+      local,
+      admin,
+      tasks,
+      plugins: exposeAdmin ? ctx.plugins : null,
+      exposeAdmin,
+      approve,
+    });
 
     const { provider, config } = resolveProviderFor(ctx, providerId, {
       baseUrl: body.baseUrl || ctx.providerSettings(providerId).baseUrl,
@@ -261,6 +268,7 @@ export function registerChat(route, ctx) {
     const onLifecycle = combineLifecycle([
       createRulesInjector({ cwd: sessionCwd, patterns: ctx.config.rules ?? [] }),
       createCheckpointer(ctx, { sessionId, cwd: sessionCwd, turnId: userMessageId }),
+      ctx.hooks ? (event) => ctx.hooks.dispatch(event) : null,
     ]);
 
     (async () => {
@@ -356,10 +364,20 @@ export function registerChat(route, ctx) {
           advisorOptions.enabled &&
           advisorShouldRun({ toolCalls, answer: result.content })
         ) {
+          // El asesor puede tener proveedor/modelo propios; si no, usa los activos.
+          let advisorProvider = provider;
+          let advisorConfig = config;
+          let advisorModel = model;
+          if (advisorOptions.provider || advisorOptions.model) {
+            const resolved = resolveProviderFor(ctx, advisorOptions.provider || providerId);
+            advisorProvider = resolved.provider;
+            advisorConfig = resolved.config;
+            advisorModel = advisorOptions.model || model;
+          }
           const advice = await consultAdvisor({
-            provider,
-            config,
-            model,
+            provider: advisorProvider,
+            config: advisorConfig,
+            model: advisorModel,
             signal: ctx.runs.signal(sessionId),
             userInput: input,
             answer: result.content,
@@ -374,6 +392,23 @@ export function registerChat(route, ctx) {
               mode: advice.kind,
             });
             ctx.runs.emit(sessionId, 'advice', { text: advice.text, kind: advice.kind, say: advice.text });
+            ctx.hooks?.dispatch({ type: 'advice', sessionId, text: advice.text, kind: advice.kind });
+          }
+          // El resumen de "que hizo" va como una tarjeta/aviso aparte, para que
+          // la voz pueda leerlo siempre (independiente del consejo).
+          if (advice?.summary) {
+            ctx.store.addMessage(sessionId, {
+              role: 'assistant',
+              name: 'advisor',
+              content: advice.summary,
+              mode: 'summary',
+            });
+            ctx.runs.emit(sessionId, 'advice', {
+              text: advice.summary,
+              kind: 'summary',
+              say: advice.summary,
+            });
+            ctx.hooks?.dispatch({ type: 'advice', sessionId, text: advice.summary, kind: 'summary' });
           }
         }
       } catch (error) {

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

@@ -39,7 +39,7 @@ export function registerTts(route, ctx) {
     if ('rate' in body) next.rate = sanearRate(body.rate, actual.rate);
     if (body.announce && typeof body.announce === 'object') {
       const announce = { ...actual.announce };
-      for (const key of ['start', 'tools', 'end', 'advice', 'answer']) {
+      for (const key of ['start', 'tools', 'end', 'advice', 'answer', 'summary']) {
         if (key in body.announce) announce[key] = body.announce[key] === true;
       }
       next.announce = announce;

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

@@ -53,6 +53,8 @@ import { registerPresence } from './routes/presence.js';
 import { registerEval } from './routes/eval.js';
 import { registerSchedules } from './routes/schedules.js';
 import { createScheduler } from './lib/scheduler.js';
+import { createHookRunner } from './lib/hooks.js';
+import { createPlugins } from './lib/plugins.js';
 
 const VERSION = readPackageVersion();
 
@@ -217,6 +219,12 @@ export async function createTamnoraServer({
   ctx.systemPrompt = (await ctx.systemPromptFor(cwd)) || DEFAULT_SYSTEM_PROMPT;
   ctx.agentTools = createAgentTools(ctx);
 
+  // Hooks locales (opt-in: solo si hay archivos). Observan el ciclo de vida.
+  ctx.hooks = await createHookRunner(ctx, config.hooks ?? []);
+
+  // Plugins locales: tools propias del usuario (`.tamnora/plugins/*.mjs`).
+  ctx.plugins = await createPlugins(ctx, config.plugins ?? []);
+
   // Canales de mensajeria (Telegram via long polling) si hay token.
   const channels = createChannelsManager(ctx, {
     enabled: telegram,
@@ -270,6 +278,14 @@ export async function createTamnoraServer({
   registerEval(route, ctx);
   registerSchedules(route, ctx);
 
+  route('GET', '/api/hooks', ({ res }) => {
+    sendJson(res, 200, { hooks: ctx.hooks?.list?.() ?? [] });
+  });
+
+  route('GET', '/api/plugins', ({ res }) => {
+    sendJson(res, 200, { plugins: ctx.plugins?.list?.() ?? [] });
+  });
+
   function matchRoute(method, pathname) {
     const parts = pathname.split('/').filter(Boolean);
     for (const r of routes) {

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

@@ -25,15 +25,17 @@ const editMessages = () => [
   { role: 'tool', tool_call_id: 'c1', name: 'edit', content: '- const token = "secreto"\n+ const token = process.env.TOKEN' },
 ];
 
-test('resolveAdvisor mezcla defaults y sanitiza', () => {
-  assert.equal(resolveAdvisor({}).enabled, false);
-  const saved = resolveAdvisor({ advisor: { enabled: true, notes: 'x', maxWords: 999 } });
-  assert.equal(saved.enabled, true);
-  assert.equal(saved.code, true);
-  assert.equal(saved.maxWords, 120);
-  const off = resolveAdvisor({ advisor: { code: false, explain: false, advice: false, maxWords: 5 } });
-  assert.equal(off.maxWords, 10);
-  assert.equal(off.code, false);
+test('resolveAdvisor mezcla defaults y sanitiza', () => {
+  assert.equal(resolveAdvisor({}).enabled, false);
+  assert.equal(resolveAdvisor({}).summary, false);
+  const saved = resolveAdvisor({ advisor: { enabled: true, notes: 'x', maxWords: 999, summary: true } });
+  assert.equal(saved.enabled, true);
+  assert.equal(saved.code, true);
+  assert.equal(saved.summary, true);
+  assert.equal(saved.maxWords, 120);
+  const off = resolveAdvisor({ advisor: { code: false, explain: false, advice: false, maxWords: 5 } });
+  assert.equal(off.maxWords, 10);
+  assert.equal(off.code, false);
 });
 
 test('advisorShouldRun exige tools o respuesta larga', () => {
@@ -55,19 +57,30 @@ test('collectToolSummary lista las tools del turno', () => {
   assert.match(summary[0], /^edit:/);
 });
 
-test('buildAdvisorPrompt respeta los toggles y las notas', () => {
-  const { system, user } = buildAdvisorPrompt({
-    userInput: 'hola',
-    answer: 'listo',
-    toolSummary: ['edit: src/a.js'],
-    changedFiles: [{ path: 'src/a.js', diff: '- x\n+ y' }],
-    options: { code: false, explain: true, advice: true, notes: 'avisame de secretos', maxWords: 20 },
-  });
-  assert.doesNotMatch(system, /problema real en el codigo/);
-  assert.match(system, /explicar un proceso/);
-  assert.match(system, /avisame de secretos/);
-  assert.match(user, /PEDIDO DEL USUARIO/);
-  assert.match(user, /src\/a\.js/);
+test('buildAdvisorPrompt respeta los toggles y las notas', () => {
+  const { system, user } = buildAdvisorPrompt({
+    userInput: 'hola',
+    answer: 'listo',
+    toolSummary: ['edit: src/a.js'],
+    changedFiles: [{ path: 'src/a.js', diff: '- x\n+ y' }],
+    options: { code: false, explain: true, advice: true, notes: 'avisame de secretos', maxWords: 20 },
+  });
+  assert.doesNotMatch(system, /problema real en el codigo/);
+  assert.match(system, /explicar un proceso/);
+  assert.match(system, /avisame de secretos/);
+  assert.match(user, /PEDIDO DEL USUARIO/);
+  assert.match(user, /src\/a\.js/);
+});
+
+test('buildAdvisorPrompt pide el resumen cuando options.summary', () => {
+  const { system } = buildAdvisorPrompt({
+    userInput: 'hola',
+    answer: 'listo',
+    options: { summary: true, code: false, explain: false, advice: false, maxWords: 20 },
+  });
+  assert.match(system, /resumen breve/);
+  assert.match(system, /"summary"/);
+  assert.doesNotMatch(system, /Tu trabajo NO es resumir/);
 });
 
 const fakeProvider = (content) => ({ streamChat: async () => ({ content }) });
@@ -80,9 +93,29 @@ test('consultAdvisor interpreta speak:true', async () => {
     messages: editMessages(),
     options: { code: true, explain: true, advice: true, maxWords: 40 },
   });
-  assert.equal(advice.speak, true);
-  assert.equal(advice.kind, 'code');
-  assert.match(advice.text, /token/);
+  assert.equal(advice.speak, true);
+  assert.equal(advice.kind, 'code');
+  assert.match(advice.text, /token/);
+});
+
+test('consultAdvisor devuelve el resumen aunque no hable', async () => {
+  const advice = await consultAdvisor({
+    provider: fakeProvider('{"speak":false,"text":"","summary":"Revisaste el token y lo pasaste a env."}'),
+    config: {},
+    model: 'x',
+    messages: editMessages(),
+    options: { summary: true, code: false, explain: false, advice: false, maxWords: 40 },
+  });
+  assert.equal(advice.speak, false);
+  assert.match(advice.summary, /Revisaste el token/);
+  const ignored = await consultAdvisor({
+    provider: fakeProvider('{"speak":false,"text":"","summary":"algo"}'),
+    config: {},
+    model: 'x',
+    messages: [],
+    options: { summary: false, code: true, explain: true, advice: true },
+  });
+  assert.equal(ignored.summary, '');
 });
 
 test('consultAdvisor respeta speak:false, JSON invalido y errores', async () => {
@@ -138,14 +171,15 @@ test('GET/PUT /api/advisor/settings y POST /api/advisor/test con proveedor inyec
     const initial = await (await fetch(`${base}/api/advisor/settings`)).json();
     assert.equal(initial.enabled, false);
 
-    const put = await fetch(`${base}/api/advisor/settings`, {
-      method: 'PUT',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ enabled: true, code: false, maxWords: 500 }),
-    });
-    const saved = await put.json();
-    assert.equal(saved.enabled, true);
-    assert.equal(saved.code, false);
+    const put = await fetch(`${base}/api/advisor/settings`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ enabled: true, code: false, summary: true, maxWords: 500 }),
+    });
+    const saved = await put.json();
+    assert.equal(saved.enabled, true);
+    assert.equal(saved.code, false);
+    assert.equal(saved.summary, true);
     assert.equal(saved.maxWords, 120);
 
     const on = await (await fetch(`${base}/api/advisor/test`, { method: 'POST' })).json();
@@ -173,33 +207,39 @@ test('el asesor emite el evento advice al cerrar el turno', async () => {
         onEvent?.({ type: 'text', delta: text, full: text });
         return { content: text, reasoning: '', toolCalls: [] };
       }
-      return { content: '{"speak":true,"kind":"code","text":"Cuidado con el token."}', reasoning: '', toolCalls: [] };
-    },
-  };
-  const instance = await createTamnoraServer({
-    cwd,
-    dbPath: path.join(cwd, 'tamnora.db'),
-    loadMcp: false,
-    resolveProvider: () => ({ provider, config: {} }),
-  });
-  instance.ctx.app = {
-    ...instance.ctx.app,
-    advisor: { enabled: true, code: true, explain: true, advice: true, notes: '', maxWords: 40 },
-  };
-  instance.ctx.store.setSetting('activeProvider', 'fake');
-  instance.ctx.store.setSetting('activeModel', 'test-model');
-  const info = await instance.listen({ port: 0 });
-  try {
-    const res = await fetch(`${info.url}/api/chat`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ input: 'quién soy', model: 'test-model', provider: 'fake' }),
-    });
-    const body = await res.text();
-    assert.equal(calls, 2);
-    assert.match(body, /event: advice/);
-    assert.match(body, /Cuidado con el token/);
-  } finally {
-    await instance.close();
-  }
-});
+      return {
+        content: '{"speak":true,"kind":"code","text":"Cuidado con el token.","summary":"Revisaste la sesión."}',
+        reasoning: '',
+        toolCalls: [],
+      };
+    },
+  };
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider, config: {} }),
+  });
+  instance.ctx.app = {
+    ...instance.ctx.app,
+    advisor: { enabled: true, code: true, explain: true, advice: true, summary: true, notes: '', maxWords: 40 },
+  };
+  instance.ctx.store.setSetting('activeProvider', 'fake');
+  instance.ctx.store.setSetting('activeModel', 'test-model');
+  const info = await instance.listen({ port: 0 });
+  try {
+    const res = await fetch(`${info.url}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'quién soy', model: 'test-model', provider: 'fake' }),
+    });
+    const body = await res.text();
+    assert.equal(calls, 2);
+    assert.match(body, /event: advice/);
+    assert.match(body, /Cuidado con el token/);
+    assert.match(body, /"kind":"summary"/);
+    assert.match(body, /Revisaste la sesión/);
+  } finally {
+    await instance.close();
+  }
+});