@danieltmn/tamnora 0.11.3 → 0.12.0

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

@@ -46,6 +46,7 @@ const HELP = [
   '/model [id] — cambia el modelo (sin id: lista con botones)',
   '/provider [id] — cambia el proveedor (sin id: lista)',
   '/mode [plan|build] — cambia el modo (sin arg: panel)',
+  '/estricto [on|off] — el agente hace solo lo pedido (sin arg: alterna)',
   '/stop — cancela la respuesta en curso',
   '/help — esta ayuda',
   '',
@@ -508,6 +509,7 @@ export function startTelegramChannel(
         maxRounds: ctx.effectiveMaxRounds?.() ?? ctx.config.maxRounds,
         maxTokens: ctx.effectiveMaxTokens?.() ?? 0,
         maxDurationMs: ctx.effectiveMaxDurationMs?.() ?? 0,
+        maxOutputTokens: ctx.effectiveMaxOutputTokens?.() ?? ctx.config.maxOutputTokens ?? 0,
         onEvent(event) {
           if (event.type === 'text') {
             full = event.full;
@@ -659,7 +661,7 @@ export function startTelegramChannel(
       const session = sessionId ? ctx.store.getSession(sessionId) : null;
       return send(
         chatId,
-        `proyecto: ${session ? projectLabel(session) : '—'}\nproveedor: ${session?.provider || ctx.effectiveProviderId()}\nmodelo: ${session?.model || ctx.effectiveModel() || '—'}\nmodo: ${ctx.effectiveMode()}\nsesión: ${session?.title || '—'}`
+        `proyecto: ${session ? projectLabel(session) : '—'}\nproveedor: ${session?.provider || ctx.effectiveProviderId()}\nmodelo: ${session?.model || ctx.effectiveModel() || '—'}\nmodo: ${ctx.effectiveMode()}\nsolo lo pedido: ${ctx.store.getSetting('strictScope') === true ? 'sí' : 'no'}\nsesión: ${session?.title || '—'}`
       );
     }
     if (cmd === 'resumen' || cmd === 'resume') {
@@ -698,6 +700,12 @@ export function startTelegramChannel(
       controllers.get(String(chatId))?.abort();
       return send(chatId, 'Cancelando…');
     }
+    if (cmd === 'estricto' || cmd === 'strict') {
+      const current = ctx.store.getSetting('strictScope') === true;
+      const value = arg ? /^(on|si|sí|1|true)$/i.test(arg) : !current;
+      ctx.store.setSetting('strictScope', value);
+      return send(chatId, `solo lo pedido: ${value ? 'activado' : 'desactivado'}`);
+    }
     return send(chatId, `Comando desconocido: /${cmd}.\n\n${HELP}`);
   }
 

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

@@ -0,0 +1,77 @@
+// Compactación de contexto: resumen no destructivo, compactación manual
+// (/compact) y auto-compactación antes de armar el prompt de un turno.
+
+import { runAgent, liveHistory, planCompaction, COMPACT_INSTRUCTION, SUMMARY_INSTRUCTION } from './core.js';
+
+export { COMPACT_INSTRUCTION, SUMMARY_INSTRUCTION };
+
+function transcript(messages) {
+  return messages
+    .map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
+    .join('\n');
+}
+
+function providerFor(ctx, session) {
+  const providerId = session.provider || ctx.effectiveProviderId();
+  const model = session.model || ctx.effectiveModel();
+  if (!model) return { error: 'Falta el modelo para resumir.', status: 400 };
+  const { provider, config } = ctx.resolveProvider({
+    ...ctx.providerSettings(providerId),
+    apiKey: ctx.apiKeyFor(providerId),
+  });
+  return { provider, config, model };
+}
+
+/** Corre una consulta de resumen sobre `messages` (opcionalmente con el resumen previo). */
+async function summarize(ctx, session, messages, instruction, previous) {
+  const resolved = providerFor(ctx, session);
+  if (resolved.error) return null;
+  const parts = [];
+  if (previous) parts.push(`RESUMEN PREVIO:\n${previous}`);
+  parts.push(`CONVERSACIÓN:\n${transcript(messages).slice(0, 60000)}`);
+  try {
+    const result = await runAgent({
+      provider: resolved.provider,
+      config: resolved.config,
+      model: resolved.model,
+      messages: [
+        { role: 'system', content: instruction },
+        { role: 'user', content: parts.join('\n\n') },
+      ],
+      tools: [],
+    });
+    return result.content?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/** Resumen no destructivo de toda la sesión (no toca el historial). */
+export async function summarizeSession(ctx, session, instruction) {
+  const messages = ctx.store.getMessages(session.id);
+  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;
+  const summary = await summarize(ctx, session, messages, instruction);
+  if (!summary) return { error: 'El modelo no devolvió un resumen.', status: 502 };
+  return { summary };
+}
+
+/**
+ * Auto-compactación: si el historial vigente supera el umbral del contexto,
+ * resume lo viejo y lo reemplaza por `meta.summary` + `meta.summaryCursor`.
+ * Devuelve `{ summary, cursor, summarized }` o `null` si no hace falta.
+ */
+export async function maybeAutoCompact(ctx, session, history, { contextTokens } = {}) {
+  const cfg = ctx.config.compact ?? {};
+  if (cfg.enabled === false) return null;
+  const threshold = Number(cfg.threshold) > 0 && Number(cfg.threshold) < 1 ? Number(cfg.threshold) : 0.75;
+  const keepLast = Number.isFinite(Number(cfg.keepLast)) ? Number(cfg.keepLast) : 8;
+  const live = liveHistory(history, session.meta?.summaryCursor ?? null);
+  const plan = planCompaction(live, { contextTokens, threshold, keepLast });
+  if (!plan) return null;
+  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 } });
+  return { summary, cursor: plan.cursor, summarized: plan.toSummarize.length };
+}

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

@@ -33,8 +33,9 @@ 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.scopeText] - strict-scope block, re-read on every call
  */
-export function createPromptBuilder({ cwd, files, profileText, skillsText }) {
+export function createPromptBuilder({ cwd, files, profileText, skillsText, scopeText }) {
   const cache = new Map();
 
   async function buildFor(workspace) {
@@ -52,6 +53,8 @@ export function createPromptBuilder({ cwd, files, profileText, skillsText }) {
     if (profile) parts.push(profile);
     const extra = typeof skillsText === 'function' ? String(skillsText() ?? '').trim() : '';
     if (extra) parts.push(extra);
+    const scope = typeof scopeText === 'function' ? String(scopeText() ?? '').trim() : '';
+    if (scope) parts.push(scope);
     return parts.join('\n\n---\n\n');
   };
 }

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

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
-import { homeDir, loadSkills, mergeSkills, buildSkillsPrompt } from './core.js';
+import { homeDir, loadSkills, mergeSkills, buildSkillsPrompt, buildSkillsIndex } from './core.js';
 
 export const SKILL_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
 
@@ -46,6 +46,17 @@ export function skillsPrompt(ctx) {
   return buildSkillsPrompt(enabledSkills(ctx));
 }
 
+/** Índice compacto de skills (para carga on-demand con la tool `skill`). */
+export function skillsIndexPrompt(ctx) {
+  return buildSkillsIndex(enabledSkills(ctx));
+}
+
+/** Bloque de skills según `config.skills.mode`: `lazy` (default) o `eager`. */
+export function skillsBlock(ctx) {
+  const eager = ctx.config?.skills?.mode === 'eager';
+  return eager ? skillsPrompt(ctx) : skillsIndexPrompt(ctx);
+}
+
 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

@@ -67,7 +67,7 @@ export function createSubagentTool(ctx, options) {
       Array.isArray(args.tools) && args.tools.length
         ? args.tools.filter((tool) => !exclude.includes(tool))
         : mode.tools ?? undefined;
-    const local = createTools({ root: cwd, enabled, permissions, yes: false, mcp });
+    const local = createTools({ root: cwd, enabled, permissions, yes: false, mcp, signal });
     const basePrompt = await ctx.systemPromptFor(cwd);
     const messages = [
       { role: 'system', content: `${basePrompt}\n\n${SUBAGENT_PROMPT}\n\nTarea: ${description}` },
@@ -88,6 +88,7 @@ export function createSubagentTool(ctx, options) {
         execute: local.execute,
         signal,
         maxRounds: ctx.config.agents?.maxRounds ?? 6,
+        maxOutputTokens: ctx.config.agents?.maxOutputTokens ?? ctx.config.maxOutputTokens ?? 0,
         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/chat.js

@@ -18,6 +18,7 @@ import {
 } from '../lib/agentRun.js';
 import { fraseInicio, fraseFin, fraseError, createFiltroTools } from '../lib/announcer.js';
 import { resolveAdvisor, advisorShouldRun, consultAdvisor } from '../lib/advisor.js';
+import { maybeAutoCompact } from '../lib/compact.js';
 
 /**
  * Emit streaming partials at most once per `ms` window, keeping only the
@@ -75,6 +76,9 @@ export function registerChat(route, ctx) {
   route('POST', '/api/sessions/:id/stop', ({ res, params }) => {
     if (!ctx.runs.isActive(params.id)) return sendJson(res, 200, { ok: true, stopped: false });
     ctx.runs.cancel(params.id);
+    // Un run esperando una aprobacion quedaria colgado: la denegamos para que
+    // el bucle del agente pueda desenrollarse y termine.
+    ctx.approvals.cancelForSession(params.id);
     sendJson(res, 200, { ok: true, stopped: true });
   });
 
@@ -200,6 +204,7 @@ export function registerChat(route, ctx) {
       yes: autoApprove,
       onAsk,
       mcp,
+      signal: ctx.runs.signal(sessionId),
     });
     // En modo plan (solo lectura) no exponemos las tools de administración.
     const exposeAdmin = !mode.tools;
@@ -225,7 +230,19 @@ export function registerChat(route, ctx) {
 
     const userMessage = buildUserMessage(input, images);
 
-    const sessionRecord = ctx.store.getSession(sessionId);
+    let sessionRecord = ctx.store.getSession(sessionId);
+    const contextTokens = Number(body.contextTokens) || ctx.config.contextTokens || 0;
+    // Auto-compactación: si el historial vigente ya no entra en el contexto,
+    // resumimos lo viejo y seguimos con el resumen + lo reciente. No borra nada.
+    try {
+      const compacted = await maybeAutoCompact(ctx, sessionRecord, history, { contextTokens });
+      if (compacted) {
+        ctx.runs.emit(sessionId, 'compacted', { summarized: compacted.summarized, contextTokens });
+        sessionRecord = ctx.store.getSession(sessionId);
+      }
+    } catch (error) {
+      ctx.runs.emit(sessionId, 'warning', { message: `auto-compact: ${error?.message ?? error}` });
+    }
     const messages = await composeAgentMessages({
       ctx,
       cwd: sessionCwd,
@@ -255,8 +272,10 @@ export function registerChat(route, ctx) {
           maxRounds: Number(body.maxRounds) || ctx.effectiveMaxRounds?.() || MAX_TOOL_ROUNDS,
           maxTokens: Number(body.maxTokens) || ctx.effectiveMaxTokens?.() || 0,
           maxDurationMs: Number(body.maxDurationMs) || ctx.effectiveMaxDurationMs?.() || 0,
+          maxOutputTokens: Number(body.maxOutputTokens) || ctx.effectiveMaxOutputTokens?.() || 0,
+          promptCaching: ctx.config.promptCaching === true,
           stallWarnMs: body.stallWarnMs ?? ctx.config.stallWarnMs,
-          contextTokens: Number(body.contextTokens) || ctx.config.contextTokens || 0,
+          contextTokens,
           onEvent(event) {
             if (event.type === 'text') partials.push('text', { delta: event.delta, full: event.full });
             else if (event.type === 'reasoning') partials.push('reasoning', { delta: event.delta, full: event.full });

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

@@ -75,7 +75,9 @@ export function registerProviders(route, ctx) {
     maxRounds: ctx.effectiveMaxRounds(),
     maxTokens: ctx.effectiveMaxTokens(),
     maxDurationMs: ctx.effectiveMaxDurationMs(),
+    maxOutputTokens: ctx.effectiveMaxOutputTokens(),
     defaultCwd: ctx.store.getSetting('defaultCwd') || '',
+    strictScope: ctx.effectiveStrictScope(),
   });
 
   route('GET', '/api/settings', ({ res }) => {
@@ -88,7 +90,8 @@ export function registerProviders(route, ctx) {
     if (body.model !== undefined) ctx.store.setSetting('activeModel', String(body.model) || null);
     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);
-    for (const key of ['maxRounds', 'maxTokens', 'maxDurationMs']) {
+    if (body.strictScope !== undefined) ctx.store.setSetting('strictScope', Boolean(body.strictScope));
+    for (const key of ['maxRounds', 'maxTokens', 'maxDurationMs', 'maxOutputTokens']) {
       if (body[key] === undefined) continue;
       const value = Number(body[key]);
       ctx.store.setSetting(key, Number.isFinite(value) && value > 0 ? Math.round(value) : 0);

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

@@ -1,53 +1,7 @@
-import { runAgent } from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 import { workspaceForRequest } from '../lib/workspace.js';
 import { sessionView, sessionState, awaitingBySession } from '../lib/sessionView.js';
-
-const COMPACT_INSTRUCTION =
-  'Resumí la conversación en un texto conciso que preserve decisiones tomadas, archivos tocados, hallazgos y el estado actual, para poder continuar el trabajo sin el historial completo.';
-
-const SUMMARY_INSTRUCTION =
-  'Resumí la conversación para la persona: qué se pidió, qué se hizo, decisiones tomadas, archivos o comandos relevantes y el estado actual. Sé claro y conciso, en español, sin markdown pesado.';
-
-function sessionTranscript(messages) {
-  return messages
-    .map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
-    .join('\n');
-}
-
-/**
- * Corre un resumen no destructivo de la sesión (no toca el historial).
- * Devuelve `{ summary }` o `{ error, status }`.
- */
-async function summarizeSession(ctx, session, instruction) {
-  const messages = ctx.store.getMessages(session.id);
-  if (!messages.length) return { error: 'La sesión no tiene mensajes para resumir.', status: 400 };
-  const providerId = session.provider || ctx.effectiveProviderId();
-  const model = session.model || ctx.effectiveModel();
-  if (!model) return { error: 'Falta el modelo para resumir.', status: 400 };
-
-  try {
-    const { provider, config } = ctx.resolveProvider({
-      ...ctx.providerSettings(providerId),
-      apiKey: ctx.apiKeyFor(providerId),
-    });
-    const result = await runAgent({
-      provider,
-      config,
-      model,
-      messages: [
-        { role: 'system', content: instruction },
-        { role: 'user', content: sessionTranscript(messages).slice(0, 60000) },
-      ],
-      tools: [],
-    });
-    const summary = result.content?.trim();
-    if (!summary) return { error: 'El modelo no devolvió un resumen.', status: 502 };
-    return { summary };
-  } catch (error) {
-    return { error: `No se pudo resumir: ${error?.message ?? error}`, status: 502 };
-  }
-}
+import { summarizeSession, COMPACT_INSTRUCTION, SUMMARY_INSTRUCTION } from '../lib/compact.js';
 
 export function registerSessions(route, ctx) {
   route('GET', '/api/sessions', ({ res }) => {
@@ -147,7 +101,7 @@ export function registerSessions(route, ctx) {
     const session = ctx.store.getSession(params.id);
     if (!session) return sendError(res, 404, 'Sesión no encontrada.');
     ctx.store.clearMessages(params.id);
-    ctx.store.touchSession(params.id, { meta: { summary: undefined } });
+    ctx.store.touchSession(params.id, { meta: { summary: undefined, summaryCursor: undefined } });
     sendJson(res, 200, { ok: true });
   });
 
@@ -159,7 +113,7 @@ export function registerSessions(route, ctx) {
     if (!fromId) return sendError(res, 400, 'Falta "fromId".');
     const removed = ctx.store.deleteMessagesFrom(params.id, fromId);
     if (!removed) return sendError(res, 404, 'Mensaje no encontrado.');
-    ctx.store.touchSession(params.id, {});
+    ctx.store.touchSession(params.id, { meta: { summary: undefined, summaryCursor: undefined } });
     sendJson(res, 200, { ok: true, removed });
   });
 
@@ -169,7 +123,7 @@ export function registerSessions(route, ctx) {
     const out = await summarizeSession(ctx, session, COMPACT_INSTRUCTION);
     if (out.error) return sendError(res, out.status, out.error);
     ctx.store.clearMessages(params.id);
-    ctx.store.touchSession(params.id, { meta: { summary: out.summary } });
+    ctx.store.touchSession(params.id, { meta: { summary: out.summary, summaryCursor: null } });
     sendJson(res, 200, { summary: out.summary, messages: 0 });
   });
 

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

@@ -13,11 +13,12 @@ import {
   composeProviderSettings,
   buildMcpRegistry,
   readPackageVersion,
+  scopeDirective,
 } from './lib/core.js';
 import { sendJson, sendError } from './lib/http.js';
 import { createPromptBuilder, DEFAULT_SYSTEM_PROMPT } from './lib/prompt.js';
 import { profilePrompt, resolveProfile } from './lib/profile.js';
-import { skillsPrompt } from './lib/skills.js';
+import { skillsBlock } from './lib/skills.js';
 import { createApprovalBroker } from './lib/approvals.js';
 import { createPresence } from './lib/presence.js';
 import { createRunManager } from './lib/runManager.js';
@@ -160,6 +161,8 @@ export async function createTamnoraServer({
   const effectiveMaxRounds = () => settingNumber('maxRounds', config.maxRounds);
   const effectiveMaxTokens = () => settingNumber('maxTokens', config.maxTokens);
   const effectiveMaxDurationMs = () => settingNumber('maxDurationMs', config.maxDurationMs);
+  const effectiveMaxOutputTokens = () => settingNumber('maxOutputTokens', config.maxOutputTokens);
+  const effectiveStrictScope = () => store.getSetting('strictScope') === true;
 
   const ctx = {
     cwd,
@@ -179,6 +182,8 @@ export async function createTamnoraServer({
     effectiveMaxRounds,
     effectiveMaxTokens,
     effectiveMaxDurationMs,
+    effectiveMaxOutputTokens,
+    effectiveStrictScope,
     providerSettings,
     customProviderDefs,
     apiKeyFor: (id) => resolveApiKey(providerSettings(id).apiKey, process.env),
@@ -201,7 +206,8 @@ export async function createTamnoraServer({
     cwd,
     files: config.instructions,
     profileText: () => profilePrompt(resolveProfile(ctx.app)),
-    skillsText: () => skillsPrompt(ctx),
+    skillsText: () => skillsBlock(ctx),
+    scopeText: () => scopeDirective(ctx.effectiveStrictScope()),
   });
   ctx.systemPrompt = (await ctx.systemPromptFor(cwd)) || DEFAULT_SYSTEM_PROMPT;
   ctx.agentTools = createAgentTools(ctx);

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

@@ -0,0 +1,68 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome, scopeDirective, STRICT_SCOPE_PROMPT } from '../../core/src/index.js';
+
+const fakeProvider = {
+  id: 'fake',
+  async streamChat(_config, { onEvent }) {
+    onEvent?.({ type: 'text', delta: 'hola', full: 'hola' });
+    return { content: 'hola', reasoning: '', toolCalls: [] };
+  },
+};
+
+async function startServer(overrides = {}) {
+  const cwd = overrides.cwd ?? (await mkdtemp(path.join(tmpdir(), 'tamnora-scope-')));
+  setHome(cwd);
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+    ...overrides,
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url, cwd };
+}
+
+test('scopeDirective devuelve el bloque solo cuando esta activo', () => {
+  assert.equal(scopeDirective(false), '');
+  assert.equal(scopeDirective(true), STRICT_SCOPE_PROMPT);
+  assert.match(STRICT_SCOPE_PROMPT, /EXACTAMENTE/);
+});
+
+test('el toggle estricto se persiste y se inyecta en el system prompt', async () => {
+  const { instance, base, cwd } = await startServer();
+  const put = (body) =>
+    fetch(`${base}/api/settings`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+  try {
+    const initial = await (await fetch(`${base}/api/settings`)).json();
+    assert.equal(initial.settings.strictScope, false);
+
+    let prompt = await instance.ctx.systemPromptFor(cwd);
+    assert.ok(!prompt.includes(STRICT_SCOPE_PROMPT), 'sin el toggle el prompt no trae la directiva');
+
+    const saved = await put({ strictScope: true });
+    assert.equal(saved.status, 200);
+    assert.equal((await saved.json()).settings.strictScope, true);
+
+    prompt = await instance.ctx.systemPromptFor(cwd);
+    assert.ok(prompt.includes(STRICT_SCOPE_PROMPT), 'con el toggle on la directiva entra al prompt');
+
+    const reloaded = await (await fetch(`${base}/api/settings`)).json();
+    assert.equal(reloaded.settings.strictScope, true);
+
+    await put({ strictScope: false });
+    prompt = await instance.ctx.systemPromptFor(cwd);
+    assert.ok(!prompt.includes(STRICT_SCOPE_PROMPT), 'apagarlo la saca del prompt');
+  } finally {
+    await instance.close();
+  }
+});

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

@@ -1016,41 +1016,119 @@ test('manages skills from the console', async () => {
   }
 });
 
-test('injects only enabled skills into the system prompt', async () => {
-  let captured = '';
-  const captureProvider = {
-    id: 'capture',
-    async streamChat(_config, { messages }) {
-      captured = messages?.[0]?.content ?? '';
-      return { content: 'ok', reasoning: '', toolCalls: [] };
-    },
-  };
-  const { instance, base } = await startServer({ resolveProvider: () => ({ provider: captureProvider, config: {} }) });
-  const json = { 'Content-Type': 'application/json' };
-  const chat = (sessionId) =>
-    fetch(`${base}/api/chat`, { method: 'POST', headers: json, body: JSON.stringify({ sessionId, model: 'm', input: 'hola' }) });
-  const newSession = async () => {
-    const created = await (
-      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm' }) })
-    ).json();
-    return created.session.id;
-  };
-  try {
-    await fetch(`${base}/api/skills/demo`, {
-      method: 'PUT',
-      headers: json,
-      body: JSON.stringify({ name: 'Demo', body: 'Regla secreta de la skill.' }),
-    });
-
-    await (await chat(await newSession())).text();
-    assert.match(captured, /Regla secreta de la skill/);
-
-    await fetch(`${base}/api/skills/demo/toggle`, { method: 'POST' });
-    await (await chat(await newSession())).text();
-    assert.doesNotMatch(captured, /Regla secreta de la skill/);
-  } finally {
-    await instance.close();
-  }
+test('skills: indice lazy por defecto (sin body)', async () => {
+  let captured = '';
+  const captureProvider = {
+    id: 'capture',
+    async streamChat(_config, { messages }) {
+      captured = messages?.[0]?.content ?? '';
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider: captureProvider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  const chat = (sessionId) =>
+    fetch(`${base}/api/chat`, { method: 'POST', headers: json, body: JSON.stringify({ sessionId, model: 'm', input: 'hola' }) });
+  const newSession = async () => {
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm' }) })
+    ).json();
+    return created.session.id;
+  };
+  try {
+    await fetch(`${base}/api/skills/demo`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ name: 'Demo', body: 'Regla secreta de la skill.' }),
+    });
+
+    // Lazy: se inyecta el indice (id), no el cuerpo.
+    await (await chat(await newSession())).text();
+    assert.match(captured, /demo/);
+    assert.doesNotMatch(captured, /Regla secreta de la skill/);
+
+    // Deshabilitada: no aparece ni en el indice.
+    await fetch(`${base}/api/skills/demo/toggle`, { method: 'POST' });
+    await (await chat(await newSession())).text();
+    assert.doesNotMatch(captured, /demo/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('skills: modo eager inyecta el body en el system prompt', async () => {
+  let captured = '';
+  const captureProvider = {
+    id: 'capture',
+    async streamChat(_config, { messages }) {
+      captured = messages?.[0]?.content ?? '';
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-srv-'));
+  await writeFile(path.join(cwd, 'tamnora.json'), JSON.stringify({ skills: { mode: 'eager' } }));
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider: captureProvider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    await fetch(`${base}/api/skills/demo`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ name: 'Demo', body: 'Regla secreta de la skill.' }),
+    });
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm' }) })
+    ).json();
+    await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ sessionId: created.session.id, model: 'm', input: 'hola' }),
+    }).then((r) => r.text());
+    assert.match(captured, /Regla secreta de la skill/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('auto-compact resume el historial cuando el contexto se pasa', async () => {
+  let captured = '';
+  const provider = {
+    id: 'capture',
+    async streamChat(_config, { messages }) {
+      captured = (messages ?? [])
+        .map((m) => (typeof m.content === 'string' ? m.content : ''))
+        .join('\n');
+      return { content: 'RESUMEN OK', reasoning: '', toolCalls: [] };
+    },
+  };
+  const json = { 'Content-Type': 'application/json' };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ title: 't', model: 'm' }),
+      })
+    ).json();
+    const id = created.session.id;
+    const big = 'x'.repeat(4000);
+    instance.store.addMessages(
+      id,
+      Array.from({ length: 12 }, (_, i) => ({ role: i % 2 ? 'assistant' : 'user', content: `m${i} ${big}` }))
+    );
+
+    await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ sessionId: id, model: 'm', input: 'hola', contextTokens: 1000 }),
+    }).then((r) => r.text());
+
+    const meta = instance.store.getSession(id).meta;
+    assert.ok(meta.summaryCursor, 'debe guardar el cursor de compactación');
+    assert.match(captured, /Resumen de la conversación anterior/);
+  } finally {
+    await instance.close();
+  }
 });
 
 test('detects, runs and stops dev processes', async () => {
@@ -1792,20 +1870,23 @@ test('plan mode exposes only read-only tools and adds guidance', async () => {
         body: JSON.stringify({ input: 'planificá', model: 'm', mode: 'plan' }),
       })
     ).text();
-    assert.deepEqual(captured.tools, [
-      'console_errors',
-      'fetch_url',
-      'git_diff',
-      'git_log',
-      'git_status',
-      'glob',
-      'grep',
-      'list',
-      'preview_url',
-      'read',
-      'screenshot',
-      'speak',
-      'task',
+    assert.deepEqual(captured.tools, [
+      'console_errors',
+      'fetch_url',
+      'git_diff',
+      'git_log',
+      'git_status',
+      'glob',
+      'grep',
+      'list',
+      'list_mcp',
+      'list_skills',
+      'preview_url',
+      'read',
+      'screenshot',
+      'skill',
+      'speak',
+      'task',
     ]);
     assert.match(captured.system, /modo PLAN/);
   } finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",