@danieltmn/tamnora 0.11.3 → 0.13.0

package/harness/packages/core/src/tools/index.js

@@ -18,8 +18,8 @@ export function createTools({ mcp, ...registryOptions } = {}) {
   const registry = createToolRegistry(registryOptions);
   const definitions = [...registry.definitions, ...(mcp?.definitions ?? [])];
 
-  async function execute(name, args) {
-    if (registry.handles(name)) return registry.execute(name, args);
+  async function execute(name, args, context) {
+    if (registry.handles(name)) return registry.execute(name, args, context);
     if (mcp?.handles?.(name)) return mcp.call(name, args);
     return `Error: herramienta desconocida "${name}".`;
   }

package/harness/packages/core/src/tools/registry.js

@@ -11,8 +11,9 @@ import { evaluatePermission } from './permissions.js';
  * @param {object} [opts.permissions] - policy per tool ('allow'|'ask'|'deny' or pattern map)
  * @param {(name:string, args:object)=>Promise<boolean>} [opts.onAsk] - interactive approval
  * @param {boolean} [opts.yes] - auto-approve 'ask' (non-interactive)
+ * @param {AbortSignal} [opts.signal] - cancela las tools de larga duracion (bash, git)
  */
-export function createToolRegistry({ root, enabled, permissions = {}, onAsk, yes = false } = {}) {
+export function createToolRegistry({ root, enabled, permissions = {}, onAsk, yes = false, signal } = {}) {
   const names = new Set(enabled?.length ? enabled : TOOL_NAMES);
   const definitions = TOOL_DEFINITIONS.filter((d) => names.has(d.function.name));
 
@@ -31,7 +32,7 @@ export function createToolRegistry({ root, enabled, permissions = {}, onAsk, yes
       return `Permiso denegado para "${name}"${detail ? ` (${detail})` : ''}.`;
     }
 
-    return EXECUTORS[name](root, args);
+    return EXECUTORS[name](root, args, { signal });
   }
 
   return {

package/harness/packages/core/test/agent.test.js

@@ -357,3 +357,41 @@ test('tool_result propaga el meta del executor sin ensuciar el contenido', async
   assert.equal(result.result, 'captura');
   assert.deepEqual(result.meta, { screenshot: { name: 'a.png' } });
 });
+
+test('runAgent propaga maxOutputTokens al proveedor', async () => {
+  const seen = [];
+  const provider = {
+    async streamChat(_config, params) {
+      seen.push(params.maxOutputTokens);
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    maxOutputTokens: 1234,
+  });
+  assert.deepEqual(seen, [1234]);
+});
+
+test('runAgent emite el ciclo de vida (run.start/end, tool.before/after)', async () => {
+  const life = [];
+  const provider = {
+    async streamChat(_config, { messages }) {
+      if (messages.some((m) => m.role === 'tool')) return { content: 'listo', reasoning: '', toolCalls: [] };
+      return { content: '', reasoning: '', toolCalls: [{ id: 'c1', function: { name: 'step', arguments: '{}' } }] };
+    },
+  };
+  await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    tools: [{ type: 'function', function: { name: 'step', parameters: {} } }],
+    execute: async () => 'ok',
+    onLifecycle: (event) => life.push(event.type),
+  });
+  assert.deepEqual(life, ['run.start', 'tool.before', 'tool.after', 'run.end']);
+});

package/harness/packages/core/test/compact.test.js

@@ -0,0 +1,33 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { liveHistory, planCompaction } from '../src/agent/compact.js';
+
+test('liveHistory saca al asesor y recorta hasta el cursor', () => {
+  const history = [
+    { id: 'a', role: 'user', content: '1' },
+    { id: 'b', role: 'assistant', name: 'advisor', content: 'charla' },
+    { id: 'c', role: 'assistant', content: '2' },
+    { id: 'd', role: 'user', content: '3' },
+  ];
+  assert.deepEqual(liveHistory(history).map((m) => m.id), ['a', 'c', 'd']);
+  assert.deepEqual(liveHistory(history, 'a').map((m) => m.id), ['c', 'd']);
+  // Cursor inexistente: no perdemos contexto, devolvemos todo (sin asesor).
+  assert.deepEqual(liveHistory(history, 'zzz').map((m) => m.id), ['a', 'c', 'd']);
+});
+
+test('planCompaction decide por umbral, tamano y contexto', () => {
+  const mk = (n, size = 4000) => Array.from({ length: n }, (_, i) => ({ id: `m${i}`, role: 'user', content: 'x'.repeat(size) }));
+  // Sin contexto conocido no compacta.
+  assert.equal(planCompaction(mk(20), { contextTokens: 0 }), null);
+  // Debajo del umbral no compacta.
+  assert.equal(planCompaction(mk(3), { contextTokens: 100000, threshold: 0.75, keepLast: 2 }), null);
+  // Muy pocos mensajes: no compacta aunque el contexto sea chico.
+  assert.equal(planCompaction(mk(4), { contextTokens: 100, threshold: 0.75, keepLast: 4 }), null);
+
+  const live = mk(12);
+  const plan = planCompaction(live, { contextTokens: 1000, threshold: 0.75, keepLast: 8 });
+  assert.ok(plan);
+  assert.equal(plan.toSummarize.length, 4);
+  assert.equal(plan.keep.length, 8);
+  assert.equal(plan.cursor, 'm3');
+});

package/harness/packages/core/test/context.test.js

@@ -42,3 +42,17 @@ test('trimContext drops oldest groups but keeps the system and the tail', () =>
   assert.ok(result.messages.length <= messages.length);
   assert.ok(result.messages.length > 4);
 });
+
+test('trimContext protege los system iniciales (objetivo y resumen)', () => {
+  const messages = [
+    { role: 'system', content: 'base' },
+    { role: 'system', content: 'Objetivo: X' },
+    { role: 'system', content: 'Resumen de la conversación anterior:\nviejo' },
+    { role: 'user', content: 'u '.repeat(3000) },
+    { role: 'assistant', content: 'a '.repeat(3000) },
+  ];
+  const result = trimContext(messages, { maxTokens: 200, keepLast: 1 });
+  assert.equal(result.messages[0].content, 'base');
+  assert.equal(result.messages[1].content, 'Objetivo: X');
+  assert.match(result.messages[2].content, /Resumen de la conversación anterior/);
+});

package/harness/packages/core/test/memory.test.js

@@ -0,0 +1,96 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import {
+  memoryRoot,
+  memorySlug,
+  isMemoryTopic,
+  readMemoryIndex,
+  listMemoryTopics,
+  readMemoryTopic,
+  writeMemory,
+  writeIndex as writeMemoryIndex,
+  deleteMemory,
+  searchMemory,
+  memoryPrompt,
+} from '../src/memory/index.js';
+
+async function workspace() {
+  return mkdtemp(path.join(tmpdir(), 'tamnora-memory-'));
+}
+
+test('memorySlug / isMemoryTopic normalize names', () => {
+  assert.equal(memorySlug('Revisión de PR!'), 'revisi-n-de-pr');
+  assert.equal(isMemoryTopic('build.md'), true);
+  assert.equal(isMemoryTopic('MEMORY.md'), false);
+  assert.equal(isMemoryTopic('../evil.md'), false);
+  assert.equal(isMemoryTopic('note.txt'), false);
+});
+
+test('writeMemory creates a topic file and an index line', async () => {
+  const cwd = await workspace();
+  const saved = await writeMemory(cwd, { topic: 'arquitectura', title: 'Arquitectura', content: 'Usa SQLite.' });
+  assert.equal(saved.name, 'arquitectura.md');
+
+  const file = await readFile(path.join(memoryRoot(cwd), 'arquitectura.md'), 'utf8');
+  assert.match(file, /# Arquitectura/);
+  assert.match(file, /Usa SQLite\./);
+
+  const index = readMemoryIndex(cwd);
+  assert.match(index, /arquitectura\.md/);
+  assert.match(index, /Arquitectura/);
+
+  const topics = listMemoryTopics(cwd);
+  assert.deepEqual(topics.map((t) => t.name), ['arquitectura.md']);
+  assert.equal(topics[0].title, 'Arquitectura');
+});
+
+test('upsert keeps a single index line per topic', async () => {
+  const cwd = await workspace();
+  await writeMemory(cwd, { topic: 'deploy', content: 'primero' });
+  await writeMemory(cwd, { topic: 'deploy', content: 'segundo' });
+  const lines = readMemoryIndex(cwd)
+    .split(/\r?\n/)
+    .filter((l) => l.includes('deploy.md'));
+  assert.equal(lines.length, 1);
+});
+
+test('readMemoryTopic returns null for invalid names', async () => {
+  const cwd = await workspace();
+  assert.equal(readMemoryTopic(cwd, '../x.md'), null);
+  assert.equal(readMemoryTopic(cwd, 'missing.md'), null);
+});
+
+test('deleteMemory removes the file and its index line', async () => {
+  const cwd = await workspace();
+  await writeMemory(cwd, { topic: 'temp', content: 'algo' });
+  assert.equal(await deleteMemory(cwd, 'temp.md'), true);
+  assert.equal(readMemoryTopic(cwd, 'temp.md'), null);
+  assert.doesNotMatch(readMemoryIndex(cwd), /temp\.md/);
+});
+
+test('writeMemoryIndex replaces the whole index (capped)', async () => {
+  const cwd = await workspace();
+  await writeMemoryIndex(cwd, '# Memoria\n\n- a\n- b');
+  assert.match(readMemoryIndex(cwd), /- a/);
+});
+
+test('searchMemory finds matches in index and topics', async () => {
+  const cwd = await workspace();
+  await writeMemory(cwd, { topic: 'api', content: 'El endpoint es /v1/lento.' });
+  const hits = searchMemory(cwd, 'lento');
+  assert.ok(hits.some((h) => h.name === 'api.md'));
+  assert.ok(hits.every((h) => /lento/.test(h.snippet)));
+  assert.deepEqual(searchMemory(cwd, 'inexistente'), []);
+});
+
+test('memoryPrompt is empty without memory and includes the index otherwise', async () => {
+  const cwd = await workspace();
+  assert.equal(memoryPrompt(cwd), '');
+  await writeMemory(cwd, { topic: 'notas', title: 'Notas', content: 'Recordar X.' });
+  const prompt = memoryPrompt(cwd);
+  assert.match(prompt, /Memoria del proyecto/);
+  assert.match(prompt, /notas\.md/);
+});

package/harness/packages/core/test/providers.test.js

@@ -4,6 +4,8 @@ import { Store } from '../src/storage/sqlite.js';
 import { composeProviderSettings } from '../src/config/providers.js';
 import { toOllamaMessages } from '../src/providers/ollama.js';
 import { providerFetch, normalizeModel } from '../src/providers/utils.js';
+import { openaiCompatibleProvider } from '../src/providers/openaiCompatible.js';
+import { applyPromptCache } from '../src/providers/cache.js';
 import { isRetryableError } from '../src/providers/resilience.js';
 
 test('normalizeModel reads the context window across provider shapes', () => {
@@ -105,3 +107,67 @@ test('providerFetch turns network failures into a readable, retryable error', as
     globalThis.fetch = original;
   }
 });
+
+test('openaiCompatible manda max_tokens y respeta maxTokensField', async () => {
+  const bodies = [];
+  const original = globalThis.fetch;
+  const sse = 'data: {"choices":[{"delta":{"content":"hi"}}]}\n\ndata: [DONE]\n\n';
+  globalThis.fetch = async (_url, init) => {
+    bodies.push(JSON.parse(init.body));
+    return new Response(sse, { status: 200, headers: { 'content-type': 'text/event-stream' } });
+  };
+  const cfg = { baseUrl: 'https://x/v1', apiKey: 'k' };
+  const user = [{ role: 'user', content: 'u' }];
+  try {
+    await openaiCompatibleProvider.streamChat(cfg, { model: 'm', messages: user, maxOutputTokens: 100 });
+    const openai = { ...openaiCompatibleProvider, maxTokensField: 'max_completion_tokens' };
+    await openai.streamChat(cfg, { model: 'm', messages: user, maxOutputTokens: 200 });
+    await openaiCompatibleProvider.streamChat(cfg, { model: 'm', messages: user });
+  } finally {
+    globalThis.fetch = original;
+  }
+  assert.equal(bodies[0].max_tokens, 100);
+  assert.equal(bodies[0].max_completion_tokens, undefined);
+  assert.equal(bodies[1].max_completion_tokens, 200);
+  assert.equal(bodies[2].max_tokens, undefined);
+});
+
+test('applyPromptCache: anthropic marca el system, openai agrega la clave', () => {
+  const anthropic = { messages: [{ role: 'system', content: 'sys' }, { role: 'user', content: 'u' }] };
+  applyPromptCache(anthropic, { mode: 'anthropic' });
+  assert.deepEqual(anthropic.messages[0].content, [
+    { type: 'text', text: 'sys', cache_control: { type: 'ephemeral' } },
+  ]);
+  assert.equal(anthropic.messages[1].content, 'u');
+
+  const openai = { messages: [{ role: 'system', content: 'sys' }], tools: [] };
+  applyPromptCache(openai, { mode: 'openai' });
+  assert.equal(typeof openai.prompt_cache_key, 'string');
+  assert.equal(openai.prompt_cache_key.length, 32);
+
+  const none = { messages: [{ role: 'system', content: 'sys' }] };
+  applyPromptCache(none, { mode: 'none' });
+  assert.equal(none.messages[0].content, 'sys');
+  assert.equal(none.prompt_cache_key, undefined);
+});
+
+test('openaiCompatible aplica prompt caching solo si está activado', async () => {
+  const bodies = [];
+  const original = globalThis.fetch;
+  const sse = 'data: {"choices":[{"delta":{"content":"hi"}}]}\n\ndata: [DONE]\n\n';
+  globalThis.fetch = async (_url, init) => {
+    bodies.push(JSON.parse(init.body));
+    return new Response(sse, { status: 200, headers: { 'content-type': 'text/event-stream' } });
+  };
+  const cfg = { baseUrl: 'https://x/v1', apiKey: 'k' };
+  const user = [{ role: 'user', content: 'u' }];
+  const openai = { ...openaiCompatibleProvider, caching: 'openai' };
+  try {
+    await openai.streamChat(cfg, { model: 'm', messages: user, promptCaching: true });
+    await openai.streamChat(cfg, { model: 'm', messages: user, promptCaching: false });
+  } finally {
+    globalThis.fetch = original;
+  }
+  assert.equal(typeof bodies[0].prompt_cache_key, 'string');
+  assert.equal(bodies[1].prompt_cache_key, undefined);
+});

package/harness/packages/core/test/rules.test.js

@@ -0,0 +1,64 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import {
+  parseRuleMarkdown,
+  loadRules,
+  staticRules,
+  pathRules,
+  ruleMatchesPath,
+  rulesForPath,
+  buildStaticRulesBlock,
+  buildPathRulesBlock,
+} from '../src/rules/index.js';
+
+test('parseRuleMarkdown reads paths and body', () => {
+  const rule = parseRuleMarkdown('---\nname: Estilo\npaths: ["src/**/*.js", "lib/*.ts"]\n---\nUsá comillas simples.', 'x');
+  assert.equal(rule.name, 'Estilo');
+  assert.deepEqual(rule.paths, ['src/**/*.js', 'lib/*.ts']);
+  assert.match(rule.body, /comillas simples/);
+
+  const plain = parseRuleMarkdown('Sin frontmatter.', 'y');
+  assert.deepEqual(plain.paths, []);
+  assert.equal(plain.body, 'Sin frontmatter.');
+});
+
+test('ruleMatchesPath uses glob semantics', () => {
+  const rule = { paths: ['src/**/*.js', 'docs/*.md'] };
+  assert.equal(ruleMatchesPath(rule, 'src/a/b.js'), true);
+  assert.equal(ruleMatchesPath(rule, 'src/a/b.ts'), false);
+  assert.equal(ruleMatchesPath(rule, 'docs/guia.md'), true);
+  assert.equal(ruleMatchesPath(rule, 'docs/sub/guia.md'), false);
+});
+
+test('loadRules scans glob patterns and splits static/path rules', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-rules-'));
+  await mkdir(path.join(cwd, '.tamnora', 'rules'), { recursive: true });
+  await writeFile(
+    path.join(cwd, '.tamnora', 'rules', 'estilo.md'),
+    '---\npaths: src/**\n---\n# Estilo\nUsá punto y coma.'
+  );
+  await writeFile(path.join(cwd, '.tamnora', 'rules', 'general.md'), '# General\nSé conciso.');
+
+  const rules = await loadRules(cwd, ['.tamnora/rules/*.md']);
+  assert.equal(rules.length, 2);
+  assert.equal(staticRules(rules).length, 1);
+  assert.equal(pathRules(rules).length, 1);
+
+  const matched = rulesForPath(rules, 'src/index.js');
+  assert.equal(matched.length, 1);
+  assert.match(matched[0].body, /punto y coma/);
+});
+
+test('buildStaticRulesBlock and buildPathRulesBlock render bodies', () => {
+  const rules = [
+    { id: 'a', paths: [], body: 'Sé conciso.' },
+    { id: 'b', paths: ['src/**'], body: 'Usá 2 espacios.' },
+  ];
+  assert.equal(buildStaticRulesBlock([]), '');
+  assert.match(buildStaticRulesBlock(rules), /Sé conciso\./);
+  assert.doesNotMatch(buildStaticRulesBlock(rules), /2 espacios/);
+  assert.match(buildPathRulesBlock([rules[1]], 'src/x.js'), /2 espacios/);
+});

package/harness/packages/core/test/skills.test.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { parseSkillMarkdown, loadSkills, mergeSkills, buildSkillsPrompt } from '../src/skills/index.js';
+import { parseSkillMarkdown, loadSkills, mergeSkills, buildSkillsPrompt, buildSkillsIndex } from '../src/skills/index.js';
 import { parseSkillRef } from '../src/skills/remote.js';
 
 test('parseSkillMarkdown reads frontmatter and body', () => {
@@ -67,3 +67,12 @@ test('buildSkillsPrompt lists enabled skills and is empty without skills', () =>
   assert.match(text, /Demo/);
   assert.match(text, /Hacé X\./);
 });
+
+test('buildSkillsIndex lists id + when without the body (progressive disclosure)', () => {
+  assert.equal(buildSkillsIndex([]), '');
+  const text = buildSkillsIndex([{ id: 'demo', name: 'Demo', when: 'usar en PRs', body: 'SECRETO_BODY' }]);
+  assert.match(text, /demo/);
+  assert.match(text, /usar en PRs/);
+  assert.match(text, /skill\(\{ name \}\)/);
+  assert.doesNotMatch(text, /SECRETO_BODY/);
+});

package/harness/packages/core/test/stream.test.js

@@ -89,3 +89,23 @@ test('usage is null when the provider does not report it', async () => {
   const res = await readOpenAISSE(new Response(sse));
   assert.equal(res.usage, null);
 });
+
+test('readOpenAISSE corta el stream cuando la señal aborta', async () => {
+  const encoder = new TextEncoder();
+  // Un body que emite un frame y nunca cierra: el unico corte posible es abort.
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode('data: {"choices":[{"delta":{"content":"hola"}}]}\n\n'));
+    },
+  });
+  const ac = new AbortController();
+  const promise = readOpenAISSE(new Response(stream), { signal: ac.signal });
+  setTimeout(() => ac.abort(), 10);
+  await assert.rejects(promise, (error) => error.name === 'AbortError');
+});
+
+test('readOpenAISSE con la señal ya abortada no lee nada', async () => {
+  const ac = new AbortController();
+  ac.abort();
+  await assert.rejects(readOpenAISSE(new Response('data: [DONE]\n'), { signal: ac.signal }), (error) => error.name === 'AbortError');
+});

package/harness/packages/core/test/tools.test.js

@@ -158,6 +158,24 @@ test('bash runs inside the workspace root', async () => {
   assert.match(out, /\[exit 0\]/);
 });
 
+test('bash se cancela cuando aborta la señal del run', async () => {
+  const root = await makeWorkspace();
+  const ac = new AbortController();
+  const reg = createToolRegistry({ root, permissions: { bash: 'allow' }, signal: ac.signal });
+  const promise = reg.execute('bash', { command: 'node -e "setTimeout(() => {}, 5000)"', timeout: 30 });
+  setTimeout(() => ac.abort(), 150);
+  const out = await promise;
+  assert.match(out, /cancelado/);
+});
+
+test('bash con la señal ya abortada no arranca el proceso', async () => {
+  const root = await makeWorkspace();
+  const ac = new AbortController();
+  ac.abort();
+  const reg = createToolRegistry({ root, permissions: { bash: 'allow' }, signal: ac.signal });
+  assert.match(await reg.execute('bash', { command: 'echo hola' }), /cancelado/);
+});
+
 test('la tool speak valida el texto y la recorta', async () => {
   const root = await makeWorkspace();
   const reg = createToolRegistry({ root });

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

@@ -195,7 +195,7 @@ function activateTab(name) {
   hideMoreMenu();
   if (name === 'runs') refreshRuns();
   if (name === 'providers') refreshProviders();
-  if (name === 'ajustes') { refreshMcp(); refreshSkills(); refreshChannels(); refreshLimits(); refreshVoz(); refreshAsesor(); refreshTranscribe(); refreshProfile(); }
+  if (name === 'ajustes') { refreshMcp(); refreshSkills(); refreshMemory(); refreshChannels(); refreshLimits(); refreshVoz(); refreshAsesor(); refreshTranscribe(); refreshProfile(); }
 }
 
 document.querySelectorAll('.tab[data-tab]').forEach((t) =>
@@ -431,6 +431,7 @@ const providerSelect = $('#provider');
 const modelSelect = $('#model');
 const modeSelect = $('#mode');
 const yesInput = $('#yes');
+const strictInput = $('#strict-scope');
 
 async function loadModes() {
   const data = await api('/api/modes').catch(() => ({ modes: [] }));
@@ -445,6 +446,7 @@ async function loadModes() {
   const settings = await api('/api/settings').catch(() => null);
   const active = settings?.settings?.mode || 'agent';
   if ([...modeSelect.options].some((o) => o.value === active)) modeSelect.value = active;
+  if (strictInput) strictInput.checked = settings?.settings?.strictScope === true;
   defaultCwdCache = settings?.settings?.defaultCwd || '';
   if (!defaultCwdCache) {
     // Migración: la carpeta predeterminada vivía en localStorage; la subimos al
@@ -549,6 +551,9 @@ document.addEventListener('keydown', (event) => {
 });
 modelPill?.addEventListener('click', () => openSettingsModal());
 yesInput?.addEventListener('change', renderModePill);
+strictInput?.addEventListener('change', () =>
+  api('/api/settings', { method: 'PUT', body: { strictScope: strictInput.checked } }).catch(() => null)
+);
 
 function updateStatus(extra = {}) {
   renderModePill();
@@ -1056,6 +1061,7 @@ const ACTIVITY = {
   thinking: { cls: 'loader-thinking', label: 'pensando…' },
   working: { cls: 'loader-working', label: 'trabajando…' },
   reconnecting: { cls: 'loader-working', label: 'reconectando…' },
+  stopping: { cls: 'loader-working', label: 'deteniendo…' },
 };
 
 const footerActivityEl = $('#sb-activity');
@@ -2526,11 +2532,21 @@ async function sendMessage() {
 }
 
 if (stopBtn) {
-  stopBtn.addEventListener('click', () => {
+  stopBtn.addEventListener('click', async () => {
     const id = state.sessionId;
-    if (id) api(`/api/sessions/${id}/stop`, { method: 'POST' }).catch(() => {});
-    const controller = controllers.get(id);
-    if (controller) controller.abort();
+    if (!id || stopBtn.disabled) return;
+    stopBtn.disabled = true;
+    renderFooterActivity('stopping');
+    // Abortamos el stream local (corta el seguimiento ya) y pedimos al server que
+    // aborte el run: sin esto el run es durable y seguiria generando.
+    controllers.get(id)?.abort();
+    try {
+      await api(`/api/sessions/${id}/stop`, { method: 'POST' });
+    } catch (error) {
+      toast(`No se pudo detener el run: ${error.message}`);
+    } finally {
+      stopBtn.disabled = false;
+    }
   });
 }
 
@@ -3685,6 +3701,10 @@ const mcpForm = $('#mcp-form');
 const skillListEl = $('#skill-list');
 const skillModal = $('#skill-modal');
 const skillForm = $('#skill-form');
+const memoryListEl = $('#memory-list');
+const memoryIndexEl = $('#memory-index');
+const memoryModal = $('#memory-modal');
+const memoryForm = $('#memory-form');
 const tgTokenEl = $('#tg-token');
 const tgChatsEl = $('#tg-chats');
 const tgTranscribeEl = $('#tg-transcribe');
@@ -3973,6 +3993,88 @@ async function submitSkill(event) {
   refreshSkills();
 }
 
+/* --- ajustes: Memoria ---------------------------------------------------- */
+
+async function refreshMemory() {
+  if (!memoryListEl) return;
+  const data = await api('/api/memory').catch(() => null);
+  if (!data) return;
+  if (memoryIndexEl && document.activeElement !== memoryIndexEl) memoryIndexEl.value = data.index ?? '';
+  clear(memoryListEl);
+  if (!data.topics?.length) {
+    memoryListEl.appendChild(el('li', 'muted', 'sin memoria todavía'));
+    return;
+  }
+  for (const t of data.topics) {
+    const li = el('li', 'active');
+    const main = el('div', 'grow');
+    main.append(
+      el('div', '', t.title || t.name),
+      el('div', 'pmeta', `${t.name}${t.bytes ? ` · ${Math.max(1, Math.round(t.bytes / 1024))} KB` : ''}`)
+    );
+    li.appendChild(main);
+    const actions = el('div', 'pactions');
+    actions.appendChild(button('editar', (event) => { event.stopPropagation(); openMemoryForm(t.name); }));
+    actions.appendChild(button('borrar', (event) => { event.stopPropagation(); removeMemory(t.name); }, 'btn danger'));
+    li.appendChild(actions);
+    li.addEventListener('click', () => openMemoryForm(t.name));
+    memoryListEl.appendChild(li);
+  }
+}
+
+async function openMemoryForm(name = null) {
+  $('#memory-title').textContent = name ? `editar ${name}` : 'nuevo tema';
+  $('#mem-name').value = name ? name.replace(/\.md$/i, '') : '';
+  $('#mem-name').readOnly = Boolean(name);
+  $('#mem-title').value = '';
+  $('#mem-body').value = '';
+  setStatus('#mem-status', '');
+  if (name) {
+    const data = await api(`/api/memory/${encodeURIComponent(name)}`).catch(() => null);
+    if (data?.topic) {
+      $('#mem-title').value = data.topic.title ?? '';
+      $('#mem-body').value = data.topic.body ?? '';
+    }
+  }
+  memoryModal.showModal();
+  if (!name) $('#mem-name').focus();
+}
+
+function closeMemoryForm() {
+  if (memoryModal.open) memoryModal.close();
+}
+
+async function removeMemory(name) {
+  await deleteEntity(`/api/memory/${encodeURIComponent(name)}`, {
+    confirmText: `¿Borrar la memoria "${name}"?`,
+    refresh: refreshMemory,
+  });
+}
+
+async function submitMemory(event) {
+  event.preventDefault();
+  const name = $('#mem-name').value.trim();
+  if (!name) return setStatus('#mem-status', 'Falta el tema.', 'err');
+  const body = { title: $('#mem-title').value.trim(), body: $('#mem-body').value };
+  try {
+    await api(`/api/memory/${encodeURIComponent(name)}`, { method: 'PUT', body });
+  } catch (error) {
+    return setStatus('#mem-status', error.message, 'err');
+  }
+  closeMemoryForm();
+  refreshMemory();
+}
+
+async function saveMemoryIndex() {
+  try {
+    await api('/api/memory', { method: 'PUT', body: { index: memoryIndexEl.value } });
+  } catch (error) {
+    return setStatus('#memory-status', error.message, 'err');
+  }
+  setStatus('#memory-status', 'guardado', 'ok');
+  refreshMemory();
+}
+
 async function refreshChannels() {
   if (!tgStatusEl) return;
   const data = await api('/api/channels').catch(() => null);
@@ -4649,6 +4751,15 @@ $('#asesor-test')?.addEventListener('click', testAsesor);
   skillModal.addEventListener('click', (event) => {
     if (event.target === skillModal) closeSkillForm();
   });
+
+  $('#memory-new')?.addEventListener('click', () => openMemoryForm());
+  $('#memory-close')?.addEventListener('click', closeMemoryForm);
+  $('#mem-cancel')?.addEventListener('click', closeMemoryForm);
+  memoryForm?.addEventListener('submit', submitMemory);
+  $('#memory-save-index')?.addEventListener('click', saveMemoryIndex);
+  memoryModal?.addEventListener('click', (event) => {
+    if (event.target === memoryModal) closeMemoryForm();
+  });
 }
 
 /* --- eval ---------------------------------------------------------------- */