@danieltmn/tamnora 0.11.3 → 0.13.0

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

@@ -0,0 +1,66 @@
+// Memoria durable del proyecto (`<cwd>/.tamnora/memory`). El agente la usa con la
+// tool `memory`; la consola la lista, edita y borra desde la pestaña Memoria.
+
+import {
+  memoryRoot,
+  isMemoryTopic,
+  readMemoryIndex,
+  listMemoryTopics,
+  readMemoryTopic,
+  writeMemory,
+  deleteMemory,
+  writeMemoryIndex,
+} from '../lib/core.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+
+/** Acepta el slug o el nombre de archivo (`x` o `x.md`). */
+function topicFile(name) {
+  const raw = String(name ?? '');
+  return /\.md$/i.test(raw) ? raw : `${raw}.md`;
+}
+
+function memoryView(cwd) {
+  return {
+    root: memoryRoot(cwd),
+    index: readMemoryIndex(cwd),
+    topics: listMemoryTopics(cwd),
+  };
+}
+
+export function registerMemory(route, ctx) {
+  route('GET', '/api/memory', ({ res }) => {
+    sendJson(res, 200, memoryView(ctx.cwd));
+  });
+
+  route('PUT', '/api/memory', async ({ req, res }) => {
+    const body = await readJson(req);
+    await writeMemoryIndex(ctx.cwd, String(body.index ?? ''));
+    sendJson(res, 200, memoryView(ctx.cwd));
+  });
+
+  route('GET', '/api/memory/:name', ({ res, params }) => {
+    const topic = readMemoryTopic(ctx.cwd, topicFile(params.name));
+    if (!topic) return sendError(res, 404, 'Memoria no encontrada.');
+    sendJson(res, 200, { topic });
+  });
+
+  route('PUT', '/api/memory/:name', async ({ req, res, params }) => {
+    const file = topicFile(params.name);
+    if (!isMemoryTopic(file)) return sendError(res, 400, 'Nombre de memoria inválido.');
+    const body = await readJson(req);
+    const content = String(body.body ?? body.content ?? '').trim();
+    if (!content) return sendError(res, 400, 'La memoria necesita contenido.');
+    await writeMemory(ctx.cwd, {
+      topic: file.replace(/\.md$/i, ''),
+      title: body.title,
+      content,
+    });
+    sendJson(res, 200, memoryView(ctx.cwd));
+  });
+
+  route('DELETE', '/api/memory/:name', async ({ res, params }) => {
+    const removed = await deleteMemory(ctx.cwd, topicFile(params.name));
+    if (!removed) return sendError(res, 404, 'Memoria no encontrada.');
+    sendJson(res, 200, memoryView(ctx.cwd));
+  });
+}

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';
@@ -35,6 +36,7 @@ import { registerModels } from './routes/models.js';
 import { registerProviders } from './routes/providers.js';
 import { registerMcp } from './routes/mcp.js';
 import { registerSkills } from './routes/skills.js';
+import { registerMemory } from './routes/memory.js';
 import { registerChannels } from './routes/channels.js';
 import { registerProfile } from './routes/profile.js';
 import { registerTts } from './routes/tts.js';
@@ -160,6 +162,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 +183,8 @@ export async function createTamnoraServer({
     effectiveMaxRounds,
     effectiveMaxTokens,
     effectiveMaxDurationMs,
+    effectiveMaxOutputTokens,
+    effectiveStrictScope,
     providerSettings,
     customProviderDefs,
     apiKeyFor: (id) => resolveApiKey(providerSettings(id).apiKey, process.env),
@@ -201,7 +207,10 @@ export async function createTamnoraServer({
     cwd,
     files: config.instructions,
     profileText: () => profilePrompt(resolveProfile(ctx.app)),
-    skillsText: () => skillsPrompt(ctx),
+    skillsText: () => skillsBlock(ctx),
+    scopeText: () => scopeDirective(ctx.effectiveStrictScope()),
+    ruleFiles: config.rules ?? [],
+    memory: config.memory?.enabled !== false,
   });
   ctx.systemPrompt = (await ctx.systemPromptFor(cwd)) || DEFAULT_SYSTEM_PROMPT;
   ctx.agentTools = createAgentTools(ctx);
@@ -239,6 +248,7 @@ export async function createTamnoraServer({
   registerProviders(route, ctx);
   registerMcp(route, ctx);
   registerSkills(route, ctx);
+  registerMemory(route, ctx);
   registerChannels(route, ctx);
   registerProfile(route, ctx);
   registerTts(route, 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,280 @@ 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('manages project memory from the console', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-mem-'));
+  const { instance, base } = await startServer({ cwd });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    let res = await fetch(`${base}/api/memory/arquitectura`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ title: 'Arquitectura', body: 'Usa SQLite.' }),
+    });
+    assert.equal(res.status, 200);
+    let data = await res.json();
+    assert.equal(data.topics.length, 1);
+    assert.match(data.index, /arquitectura\.md/);
+
+    const detail = await (await fetch(`${base}/api/memory/arquitectura`)).json();
+    assert.match(detail.topic.body, /Usa SQLite/);
+
+    await fetch(`${base}/api/memory`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ index: '# Memoria\n\n- propio' }),
+    });
+    data = await (await fetch(`${base}/api/memory`)).json();
+    assert.match(data.index, /propio/);
+
+    res = await fetch(`${base}/api/memory/arquitectura`, { method: 'DELETE' });
+    assert.equal(res.status, 200);
+    data = await res.json();
+    assert.equal(data.topics.length, 0);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('project memory is injected into the system prompt', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-mem-prompt-'));
+  await mkdir(path.join(cwd, '.tamnora', 'memory'), { recursive: true });
+  await writeFile(path.join(cwd, '.tamnora', 'memory', 'MEMORY.md'), '# Memoria\n\n- [Dato](dato.md) — clave\n');
+  let captured = '';
+  const provider = {
+    id: 'capture',
+    async streamChat(_config, { messages }) {
+      captured = messages?.[0]?.content ?? '';
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm', cwd }) })
+    ).json();
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ sessionId: created.session.id, model: 'm', input: 'hola' }),
+      })
+    ).text();
+    assert.match(captured, /Memoria del proyecto/);
+    assert.match(captured, /dato\.md/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('the memory tool writes project memory', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-mem-tool-'));
+  await writeFile(path.join(cwd, 'tamnora.json'), JSON.stringify({ permissions: { memory: 'allow' } }));
+  const provider = {
+    id: 'memtool',
+    async streamChat(_config, { messages }) {
+      if (messages.some((m) => m.role === 'tool' && m.name === 'memory')) {
+        return { content: 'listo', reasoning: '', toolCalls: [] };
+      }
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          {
+            id: '1',
+            type: 'function',
+            function: { name: 'memory', arguments: JSON.stringify({ action: 'write', topic: 'nota', content: 'Hola memoria.' }) },
+          },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm', cwd }) })
+    ).json();
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ sessionId: created.session.id, model: 'm', input: 'recordá esto' }),
+      })
+    ).text();
+    const file = await readFile(path.join(cwd, '.tamnora', 'memory', 'nota.md'), 'utf8');
+    assert.match(file, /Hola memoria/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('rules by path are injected (transiently) when a tool touches a matching file', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-rules-inject-'));
+  await mkdir(path.join(cwd, '.tamnora', 'rules'), { recursive: true });
+  await writeFile(path.join(cwd, '.tamnora', 'rules', 'estilo.md'), '---\npaths: src/**\n---\nMARCADOR_ESTILO: usá 2 espacios.');
+  await mkdir(path.join(cwd, 'src'), { recursive: true });
+  await writeFile(path.join(cwd, 'src', 'index.js'), 'export const x = 1;\n');
+  let captured = null;
+  const provider = {
+    id: 'rules',
+    async streamChat(_config, { messages }) {
+      if (messages.some((m) => m.role === 'tool' && m.name === 'read')) {
+        captured = messages;
+        return { content: 'ok', reasoning: '', toolCalls: [] };
+      }
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          { id: 'r1', type: 'function', function: { name: 'read', arguments: JSON.stringify({ path: 'src/index.js' }) } },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm', cwd }) })
+    ).json();
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ sessionId: created.session.id, model: 'm', input: 'mirá src/index.js' }),
+      })
+    ).text();
+    assert.ok(captured, 'el provider no recibió una segunda ronda');
+    assert.ok(
+      captured.some((m) => m.role === 'system' && /MARCADOR_ESTILO/.test(m.content)),
+      'no se inyectó la regla por path'
+    );
+    // No se persiste: el historial guardado no incluye la regla efímera.
+    const session = await (await fetch(`${base}/api/sessions/${created.session.id}`)).json();
+    assert.ok(
+      session.messages.every((m) => !(m.role === 'system' && /MARCADOR_ESTILO/.test(String(m.content ?? '')))),
+      'la regla efímera se persistió en el historial'
+    );
+  } 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 +2031,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/harness/tamnora.example.json

@@ -5,6 +5,12 @@
   "maxRounds": 0,
   "maxTokens": 0,
   "maxDurationMs": 0,
+  "maxOutputTokens": 0,
+  "promptCaching": false,
+  "skills": { "mode": "lazy" },
+  "compact": { "enabled": true, "threshold": 0.75, "keepLast": 8 },
+  "rules": [".tamnora/rules/*.md"],
+  "memory": { "enabled": true },
   "tools": [],
   "permissions": {},
   "mcp": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.11.3",
+  "version": "0.13.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",