@danieltmn/tamnora 0.11.3 → 0.12.0

package/harness/packages/core/src/providers/stream.js

@@ -9,6 +9,47 @@
  * string or as an object (`message`, `data.message`, serialized `data`).
  * (openbridge-style tolerance: errors come in many shapes per provider.)
  */
+function abortError() {
+  return new DOMException('Aborted', 'AbortError');
+}
+
+/**
+ * `reader.read()` abortable. Aunque `fetch` deberia cancelar el body al abortar,
+ * no todos los runtimes lo hacen de forma inmediata; esto garantiza que el
+ * stream se corte apenas el usuario detiene el run.
+ */
+function readChunk(reader, signal) {
+  if (!signal) return reader.read();
+  if (signal.aborted) {
+    reader.cancel().catch(() => {});
+    return Promise.reject(abortError());
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      reader.cancel().catch(() => {});
+      reject(abortError());
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    reader.read().then(
+      (result) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener('abort', onAbort);
+        resolve(result);
+      },
+      (error) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener('abort', onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+
 export function providerErrorMessage(payload) {
   const err = typeof payload === 'string' ? payload : (payload?.error ?? payload);
   if (typeof err === 'string' && err) return err;
@@ -39,7 +80,7 @@ export function providerErrorMessage(payload) {
  * Parse an OpenAI-compatible SSE stream.
  * @returns {Promise<{content:string, reasoning:string, toolCalls:object[], usage:object|null}>}
  */
-export async function readOpenAISSE(response, { onEvent } = {}) {
+export async function readOpenAISSE(response, { onEvent, signal } = {}) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder('utf-8');
   let partial = '';
@@ -50,7 +91,7 @@ export async function readOpenAISSE(response, { onEvent } = {}) {
   let usage = null;
 
   while (true) {
-    const { done, value } = await reader.read();
+    const { done, value } = await readChunk(reader, signal);
     if (done) break;
     partial += decoder.decode(value, { stream: true });
     const lines = partial.split('\n');
@@ -108,7 +149,7 @@ export async function readOpenAISSE(response, { onEvent } = {}) {
  * Parse Ollama's native NDJSON stream (`/api/chat`).
  * @returns {Promise<{content:string, reasoning:string, toolCalls:object[], usage:object|null}>}
  */
-export async function readNDJSON(response, { onEvent } = {}) {
+export async function readNDJSON(response, { onEvent, signal } = {}) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder('utf-8');
   let partial = '';
@@ -155,7 +196,7 @@ export async function readNDJSON(response, { onEvent } = {}) {
   };
 
   while (true) {
-    const { done, value } = await reader.read();
+    const { done, value } = await readChunk(reader, signal);
     if (done) break;
     partial += decoder.decode(value, { stream: true });
     const lines = partial.split('\n');

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

@@ -77,6 +77,27 @@ export async function writeSkillFiles(dir, files = []) {
   }
 }
 
+const INDEX_WHEN_CHARS = 220;
+
+/**
+ * Índice compacto (name + when/description, sin body) para *progressive
+ * disclosure*: el modelo ve qué skills hay y carga el body on-demand con la
+ * herramienta `skill`. Mucho más barato en tokens que inyectar todos los bodies.
+ */
+export function buildSkillsIndex(skills = []) {
+  if (!skills.length) return '';
+  const lines = [
+    'Tenés skills disponibles (instrucciones especializadas). Cuando una aplique a la tarea, cargá su contenido con la herramienta `skill({ name })`:',
+  ];
+  for (const skill of skills) {
+    const title = skill.name || skill.id;
+    const when = String(skill.when || skill.description || '').replace(/\s+/g, ' ').trim();
+    const hint = when.length > INDEX_WHEN_CHARS ? `${when.slice(0, INDEX_WHEN_CHARS)}…` : when;
+    lines.push(`- ${skill.id}: ${title}${hint ? ` — ${hint}` : ''}`);
+  }
+  return lines.join('\n');
+}
+
 /** Text block appended to the system prompt with the enabled skills. */
 export function buildSkillsPrompt(skills = []) {
   if (!skills.length) return '';

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

@@ -301,12 +301,16 @@ export async function grepTool(root, { pattern, include, path: p } = {}) {
   return results.length ? results.join('\n') : 'Sin coincidencias';
 }
 
-export function bashTool(root, { command, timeout } = {}) {
+export function bashTool(root, { command, timeout } = {}, { signal } = {}) {
   return new Promise((resolve) => {
     if (!command || typeof command !== 'string') {
       resolve('Error: falta "command".');
       return;
     }
+    if (signal?.aborted) {
+      resolve('Comando cancelado por el usuario.');
+      return;
+    }
     const seconds = Math.min(Math.max(Number(timeout) || 30, 1), 300);
     let child;
     try {
@@ -318,31 +322,35 @@ export function bashTool(root, { command, timeout } = {}) {
 
     let output = '';
     let settled = false;
+    let timer = null;
     const append = (chunk) => {
       if (output.length < MAX_BASH_OUTPUT) output += chunk.toString();
     };
 
-    const timer = setTimeout(() => {
+    const finish = (text) => {
       if (settled) return;
       settled = true;
+      if (timer) clearTimeout(timer);
+      signal?.removeEventListener('abort', onAbort);
+      resolve(text);
+    };
+    const onAbort = () => {
       child.kill('SIGKILL');
-      resolve(`${output}\n[timeout tras ${seconds}s]\n[exit -1]`);
+      finish(`${output}\n[comando cancelado por el usuario]\n[exit -1]`);
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+
+    timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      finish(`${output}\n[timeout tras ${seconds}s]\n[exit -1]`);
     }, seconds * 1000);
 
     child.stdout?.on('data', append);
     child.stderr?.on('data', append);
-    child.on('error', (err) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(`Error ejecutando el comando: ${err.message}`);
-    });
+    child.on('error', (err) => finish(`Error ejecutando el comando: ${err.message}`));
     child.on('close', (code) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
       const truncated = output.length >= MAX_BASH_OUTPUT ? '\n[output truncado]' : '';
-      resolve(`${output}${truncated}\n[exit ${code}]`);
+      finish(`${output}${truncated}\n[exit ${code}]`);
     });
   });
 }

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/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/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

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

package/harness/packages/server/public/index.html

@@ -37,7 +37,7 @@
   </head>
   <body>
     <header class="topbar">
-      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span id="topbar-section" class="topbar-section">chat</span> <span class="ver">v0.11.3</span></div>
+      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span id="topbar-section" class="topbar-section">chat</span> <span class="ver">v0.12.0</span></div>
       <nav class="tabs">
         <button class="tab active" data-tab="chat">chat</button>
         <button class="tab" data-tab="providers">proveedores</button>
@@ -486,6 +486,9 @@
               <label class="check" title="aprobar automáticamente tools con permiso ask">
                 <input id="yes" type="checkbox" /> Aprobar automáticamente las tools (auto)
               </label>
+              <label class="check" title="el agente hace exactamente lo pedido, sin mejoras ni cambios fuera del pedido">
+                <input id="strict-scope" type="checkbox" /> Hacer solo lo pedido (estricto)
+              </label>
             </div>
           </div>
           <div class="row">

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

@@ -2,7 +2,7 @@
 // subagentes). La creacion de tools y el onEvent de cada canal siguen siendo
 // propios (los canales de salida son distintos); lo combinable vive aca.
 
-import { summarizeToolCall, previewToolResult } from './core.js';
+import { summarizeToolCall, previewToolResult, liveHistory } from './core.js';
 
 const FAILED_RE = /^Error|^Permiso denegado/i;
 
@@ -21,16 +21,15 @@ export function toolCallPayload(event) {
  * `approve` es el callback de aprobacion de las tools de administraación.
  */
 export function combineToolset({ local, admin = null, tasks = null, exposeAdmin = false, approve = null }) {
+  const adminAllowed = (name) => Boolean(admin?.handles(name)) && (exposeAdmin || admin.readOnly?.has(name));
   const definitions = [
     ...local.definitions,
-    ...(exposeAdmin && admin ? admin.definitions : []),
+    ...(admin ? admin.definitions.filter((d) => adminAllowed(d.function.name)) : []),
     ...(tasks ? tasks.definitions : []),
   ];
   const execute = (name, args, context) => {
     if (tasks?.handles(name)) return tasks.execute(name, args);
-    if (exposeAdmin && admin?.handles(name)) {
-      return admin.execute(name, args, approve ? { approve } : undefined);
-    }
+    if (adminAllowed(name)) return admin.execute(name, args, approve ? { approve } : undefined);
     return local.execute(name, args, context);
   };
   return { definitions, execute };
@@ -67,12 +66,13 @@ export async function composeAgentMessages({ ctx, cwd, mode, history = [], userM
   const basePrompt = await ctx.systemPromptFor(cwd);
   const goal = sessionRecord?.meta?.goal;
   const summary = sessionRecord?.meta?.summary;
+  // Historial vigente: sin el asesor y sin lo ya resumido (si hay cursor).
+  const live = liveHistory(history, sessionRecord?.meta?.summaryCursor ?? null);
   return [
     { role: 'system', content: mode.systemPrompt ? `${basePrompt}\n\n${mode.systemPrompt}` : basePrompt },
     ...(goal ? [{ role: 'system', content: `Objetivo de la sesión: ${goal}` }] : []),
     ...(summary ? [{ role: 'system', content: `Resumen de la conversación anterior:\n${summary}` }] : []),
-    // El asesor no contamina el contexto del modelo: es una capa de comentario.
-    ...history.filter((message) => message.name !== 'advisor'),
+    ...live,
     userMessage,
   ];
 }

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

@@ -13,7 +13,7 @@ import {
   normalizeMcpConfig,
   homeDir,
 } from './core.js';
-import { SKILL_ID_PATTERN, skillsView, writeSkill, setSkillEnabled } from './skills.js';
+import { SKILL_ID_PATTERN, skillsView, writeSkill, setSkillEnabled, findSkill } from './skills.js';
 
 function sanitizeId(value) {
   return String(value ?? '')
@@ -51,6 +51,12 @@ const DEFINITIONS = [
   ),
   definition('remove_mcp', 'Elimina un servidor MCP guardado desde la consola.', { id: { type: 'string' } }, ['id']),
   definition('list_skills', 'Lista las skills instaladas y si están habilitadas.', {}),
+  definition(
+    'skill',
+    'Carga el contenido completo de una skill por su id. Usala cuando una skill del índice aplique a la tarea.',
+    { name: { type: 'string', description: 'id de la skill (ver el índice de skills)' } },
+    ['name']
+  ),
   definition(
     'install_skill',
     'Crea o actualiza una skill en la casa. Pasá "content" (markdown, opcionalmente con frontmatter) o "url" para descargarla.',
@@ -88,7 +94,7 @@ function decisionFor(ctx, name) {
   const perms = ctx.config.permissions ?? {};
   const value = perms[name];
   if (value === 'allow' || value === 'ask' || value === 'deny') return value;
-  return name.startsWith('list_') ? 'allow' : 'ask';
+  return name.startsWith('list_') || name === 'skill' ? 'allow' : 'ask';
 }
 
 /**
@@ -197,6 +203,13 @@ export function createAgentTools(ctx) {
       case 'list_skills':
         return JSON.stringify(skillsView(ctx).map(({ id, name, enabled, description }) => ({ id, name, enabled, description })), null, 2);
 
+      case 'skill': {
+        const id = String(args.name ?? args.id ?? '').trim();
+        const skill = findSkill(ctx, id);
+        if (!skill) return `No existe la skill "${id}".`;
+        return `# ${skill.name || skill.id}\n\n${skill.body}`;
+      }
+
       case 'install_skill': {
         const ref = parseSkillRef(args.ref ?? args.url ?? '');
         if (ref && (args.ref || (args.url && !/\.md(\?|$)/i.test(String(args.url))))) {
@@ -240,5 +253,7 @@ export function createAgentTools(ctx) {
     }
   }
 
-  return { definitions: DEFINITIONS, handles, execute };
+  // Tools de admin que no modifican nada (lístar/leer): disponibles en todo modo.
+  const readOnly = new Set(['list_mcp', 'list_skills', 'skill']);
+  return { definitions: DEFINITIONS, handles, execute, readOnly };
 }

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

@@ -48,6 +48,13 @@ export function createApprovalBroker({ timeoutMs = 300000 } = {}) {
       for (const id of ids) settle(id, false);
     },
 
+    /** Deny every pending request of a session (used when the user stops the run). */
+    cancelForSession(sessionId) {
+      for (const [id, entry] of pending) {
+        if (entry.sessionId === sessionId) settle(id, false);
+      }
+    },
+
     /** Deny everything still pending (used on shutdown). */
     cancelAll() {
       for (const id of [...pending.keys()]) settle(id, false);