@danieltmn/tamnora 0.22.0 → 0.23.1

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

@@ -76,7 +76,10 @@ export function createProcManager({ allow } = {}) {
         throw new Error(`Argumento no permitido con shell en Windows: "${bad}".`);
       }
     }
-    const child = spawn(bin, list, {
+    // Con `shell: true` y array de args Node concatena sin escapar (warning
+    // DEP0190): se manda un unico comando (los args ya pasaron SAFE_SHELL_ARG).
+    const [cmd, cmdArgs] = shell ? [`${bin} ${list.join(' ')}`, []] : [bin, list];
+    const child = spawn(cmd, cmdArgs, {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe'],
       windowsHide: true,

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

@@ -108,6 +108,7 @@ async function runAgentSchedule(ctx, schedule) {
       maxTokens: ctx.effectiveMaxTokens?.() || 0,
       maxDurationMs: ctx.effectiveMaxDurationMs?.() || 0,
       maxOutputTokens: ctx.effectiveMaxOutputTokens?.() || 0,
+      promptCaching: ctx.effectivePromptCaching?.() ?? ctx.config.promptCaching === true,
       onEvent(event) {
         if (event.type === 'text') emit('text', { full: event.full });
         else if (event.type === 'reasoning') emit('reasoning', { full: event.full });

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

@@ -118,6 +118,7 @@ export function createSubagentTool(ctx, options) {
         signal,
         maxRounds: ctx.config.agents?.maxRounds ?? 6,
         maxOutputTokens: ctx.config.agents?.maxOutputTokens ?? ctx.config.maxOutputTokens ?? 0,
+        promptCaching: ctx.effectivePromptCaching?.() ?? ctx.config.promptCaching === true,
         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

@@ -346,7 +346,7 @@ export function registerChat(route, ctx) {
           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,
+          promptCaching: ctx.effectivePromptCaching?.() ?? ctx.config.promptCaching === true,
           stallWarnMs: body.stallWarnMs ?? ctx.config.stallWarnMs,
           contextTokens,
           onEvent(event) {

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

@@ -80,6 +80,7 @@ export function registerProviders(route, ctx) {
     maxTokens: ctx.effectiveMaxTokens(),
     maxDurationMs: ctx.effectiveMaxDurationMs(),
     maxOutputTokens: ctx.effectiveMaxOutputTokens(),
+    promptCaching: ctx.effectivePromptCaching(),
     defaultCwd: ctx.store.getSetting('defaultCwd') || '',
     strictScope: ctx.effectiveStrictScope(),
     mcpMode: ctx.effectiveMcpMode(),
@@ -98,6 +99,7 @@ export function registerProviders(route, ctx) {
     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);
     if (body.strictScope !== undefined) ctx.store.setSetting('strictScope', Boolean(body.strictScope));
+    if (body.promptCaching !== undefined) ctx.store.setSetting('promptCaching', Boolean(body.promptCaching));
     if (body.mcpMode !== undefined) {
       const mode = String(body.mcpMode);
       ctx.store.setSetting('mcpMode', ['auto', 'eager', 'lazy'].includes(mode) ? mode : 'auto');

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

@@ -181,6 +181,11 @@ export async function createTamnoraServer({
   const effectiveMaxDurationMs = () => settingNumber('maxDurationMs', config.maxDurationMs);
   const effectiveMaxOutputTokens = () => settingNumber('maxOutputTokens', config.maxOutputTokens);
   const effectiveStrictScope = () => store.getSetting('strictScope') === true;
+  const effectivePromptCaching = () => {
+    const stored = store.getSetting('promptCaching');
+    if (stored === null || stored === undefined) return config.promptCaching === true;
+    return stored === true;
+  };
   const MCP_MODES = new Set(['auto', 'eager', 'lazy']);
   const effectiveMcpMode = () => {
     const value = String(store.getSetting('mcpMode') ?? config.mcpMode ?? 'auto');
@@ -221,6 +226,7 @@ export async function createTamnoraServer({
     effectiveMaxDurationMs,
     effectiveMaxOutputTokens,
     effectiveStrictScope,
+    effectivePromptCaching,
     effectiveMcpMode,
     effectiveMcpPinned,
     mcpText,

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

@@ -0,0 +1,119 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  ADVISOR_KINDS,
+  advisorMeta,
+  basename,
+  formatDuration,
+  isFailedToolText,
+  isReadOnlyTool,
+  parseToolArgs,
+  previewText,
+  screenshotName,
+  shortText,
+  toolSummary,
+  userImages,
+  userText,
+} from '../public/chatFormat.js';
+
+test('shortText normaliza espacios y corta con punto', () => {
+  assert.equal(shortText('  hola   mundo  '), 'hola mundo');
+  assert.equal(shortText('x'.repeat(10), 5), 'xxxx…');
+  assert.equal(shortText(null), '');
+});
+
+test('isReadOnlyTool distingue las tools de lectura, tambien las MCP', () => {
+  assert.ok(isReadOnlyTool('read'));
+  assert.ok(isReadOnlyTool('grep'));
+  assert.ok(!isReadOnlyTool('write'));
+  assert.ok(!isReadOnlyTool('bash'));
+  assert.ok(isReadOnlyTool('mcp__postgres__query'));
+  assert.ok(isReadOnlyTool('mcp__fs__list_files'));
+  assert.ok(!isReadOnlyTool('mcp__fs__write_file'));
+  assert.ok(!isReadOnlyTool(undefined));
+});
+
+test('toolSummary resume cada tool en una linea corta', () => {
+  assert.equal(toolSummary('read', { path: 'src/a.js', offset: 10, limit: 5 }), 'src/a.js:10-14');
+  assert.equal(toolSummary('read', { path: 'src/a.js', offset: 10 }), 'src/a.js:10+');
+  assert.equal(toolSummary('read', {}), '.');
+  assert.equal(toolSummary('write', { path: 'a.txt', content: 'x' }), 'a.txt');
+  assert.equal(toolSummary('bash', { command: 'npm test\notra linea' }), 'npm test');
+  assert.equal(toolSummary('grep', { pattern: 'foo', path: 'src' }), '"foo" en src');
+  assert.equal(toolSummary('git_diff', { staged: true, path: 'a.js' }), 'staged a.js');
+  assert.equal(toolSummary('git_log', { limit: 5 }), '5 commits');
+  assert.equal(toolSummary('desconocida', {}), '');
+});
+
+test('parseToolArgs acepta objeto, JSON y basura', () => {
+  assert.deepEqual(parseToolArgs({ function: { arguments: '{"a":1}' } }), { a: 1 });
+  assert.deepEqual(parseToolArgs({ arguments: { a: 2 } }), { a: 2 });
+  assert.deepEqual(parseToolArgs({ arguments: 'no es json' }), {});
+  assert.deepEqual(parseToolArgs(null), {});
+});
+
+test('isFailedToolText detecta errores y permisos denegados', () => {
+  assert.ok(isFailedToolText('Error: se rompio'));
+  assert.ok(isFailedToolText('Permiso denegado por el usuario'));
+  assert.ok(!isFailedToolText('listo, sin errores'));
+  assert.ok(!isFailedToolText(undefined));
+});
+
+test('screenshotName sale del meta o del texto del resultado', () => {
+  assert.equal(screenshotName({ meta: { screenshot: { name: 'a.png' } } }, ''), 'a.png');
+  assert.equal(screenshotName({}, 'guardado en capturas/abc-123.png'), 'abc-123.png');
+  assert.equal(screenshotName({}, 'sin captura'), null);
+});
+
+test('previewText trunca por lineas y por caracteres', () => {
+  const largo = Array.from({ length: 50 }, (_, i) => `linea ${i}`).join('\n');
+  const { preview, truncated } = previewText(largo, 5, 100);
+  assert.equal(preview.split('\n').length, 5);
+  assert.ok(truncated);
+  assert.deepEqual(previewText('hola'), { preview: 'hola', truncated: false });
+  // Un objeto se serializa con formato.
+  assert.match(previewText({ a: 1 }).preview, /"a": 1/);
+});
+
+test('userText y userImages separan las partes del mensaje multimodal', () => {
+  assert.equal(userText('plano'), 'plano');
+  assert.equal(
+    userText([
+      { type: 'text', text: 'hola' },
+      { type: 'text', text: 'mundo' },
+      { type: 'image_url', image_url: { url: 'data:x' } },
+    ]),
+    'hola\nmundo',
+  );
+  assert.equal(userText(null), '');
+  assert.deepEqual(
+    userImages([
+      { type: 'image_url', image_url: { url: 'data:x' } },
+      { type: 'text', text: 'y' },
+      { type: 'image_url', image_url: {} },
+    ]),
+    ['data:x'],
+  );
+  assert.deepEqual(userImages('plano'), []);
+});
+
+test('advisorMeta cae al default con un tipo desconocido', () => {
+  assert.equal(advisorMeta('code'), ADVISOR_KINDS.code);
+  assert.equal(advisorMeta('nope').label, 'Asesor');
+  assert.ok(ADVISOR_KINDS.summary);
+});
+
+test('basename corta el ultimo segmento y los separadores finales', () => {
+  assert.equal(basename('a/b/c'), 'c');
+  assert.equal(basename('a\\b\\c\\'), 'c');
+  // Solo separadores: no hay segmento que devolver.
+  assert.equal(basename('/'), '');
+  assert.equal(basename(null), '');
+});
+
+test('formatDuration da ms cortos y segundos con decimal', () => {
+  assert.equal(formatDuration(0), '');
+  assert.equal(formatDuration(undefined), '');
+  assert.equal(formatDuration(300), '300ms');
+  assert.equal(formatDuration(1200), '1.2s');
+});

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

@@ -0,0 +1,301 @@
+// El grafo de imports de la consola (`public/`), verificado sin navegador.
+//
+// La consola no tiene tests de DOM: si un refactor borra un export, renombra una
+// funcion o mueve una llamada a tiempo de evaluacion dentro de un ciclo, la
+// suite no lo ve y el navegador se queda con la pantalla en blanco. Esto cierra
+// ese hueco: valida que cada import resuelve a un export real y que los ciclos
+// (chrome <-> chat, app <-> explorer) siguen seguros.
+//
+// Es analisis estatico sobre el texto: no importa el modulo, asi que no hace
+// falta emular el DOM.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'public');
+
+const lee = (archivo) => readFileSync(path.join(DIR, archivo), 'utf8');
+const modulos = readdirSync(DIR).filter((f) => f.endsWith('.js'));
+
+/** Nombres exportados de un modulo: `export function X`, `export { A, B }`, `export const`. */
+function exportsDe(archivo) {
+  const src = lee(archivo);
+  const nombres = new Set();
+  for (const m of src.matchAll(/export\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g)) nombres.add(m[1]);
+  for (const m of src.matchAll(/export\s+(?:const|let|var|class)\s+([A-Za-z_$][\w$]*)/g)) nombres.add(m[1]);
+  // `export { a, b } from './x.js'` tambien expone esos nombres.
+  for (const m of src.matchAll(/export\s*\{([^}]*)\}\s*from\s*'[^']+'/g)) {
+    for (const bruto of m[1].split(',')) {
+      const nombre = bruto.trim().split(/\s+as\s+/).pop().trim();
+      if (nombre) nombres.add(nombre);
+    }
+  }
+  return nombres;
+}
+
+/** Imports relativos: `{ nombres, de }` por cada `import { ... } from './x.js'`. */
+function importsDe(archivo) {
+  const src = lee(archivo);
+  const lista = [];
+  for (const m of src.matchAll(/import\s*\{([^}]*)\}\s*from\s*'(\.[^']+)'/g)) {
+    const nombres = m[1]
+      .split(',')
+      .map((n) => n.trim().replace(/^type\s+/, '').split(/\s+as\s+/)[0].trim())
+      .filter(Boolean);
+    const de = path.basename(m[2]);
+    lista.push({ nombres, de });
+  }
+  return lista;
+}
+
+const exportsPorModulo = new Map(modulos.map((m) => [m, exportsDe(m)]));
+const importsPorModulo = new Map(modulos.map((m) => [m, importsDe(m)]));
+
+/**
+ * Statements de nivel superior de un modulo, agrupando por balance de llaves y
+ * parentesis. Asi `const x = f();` sale como un statement, y un
+ * `addEventListener(...)` con un callback multilinea tambien.
+ */
+function statementsTopLevel(src) {
+  const stmts = [];
+  let actual = '';
+  let inicio = 0;
+  let llaves = 0;
+  let corchetes = 0;
+  let parentesis = 0;
+  let enCadena = '';
+  let pos = 0;
+  for (const linea of src.split(/\r?\n/)) {
+    if (!actual) inicio = pos;
+    actual += `${actual ? '\n' : ''}${linea}`;
+    for (let i = 0; i < linea.length; i += 1) {
+      const c = linea[i];
+      const previo = linea[i - 1];
+      if (enCadena) {
+        if (c === enCadena && previo !== '\\') enCadena = '';
+        continue;
+      }
+      if (c === '"' || c === "'" || c === '`') {
+        enCadena = c;
+        continue;
+      }
+      if (c === '{') llaves += 1;
+      else if (c === '}') llaves -= 1;
+      else if (c === '[') corchetes += 1;
+      else if (c === ']') corchetes -= 1;
+      else if (c === '(') parentesis += 1;
+      else if (c === ')') parentesis -= 1;
+    }
+    pos += linea.length + 1;
+    if (llaves <= 0 && corchetes <= 0 && parentesis <= 0) {
+      if (actual.trim()) stmts.push({ texto: actual, inicio });
+      actual = '';
+      llaves = 0;
+      corchetes = 0;
+      parentesis = 0;
+    }
+  }
+  if (actual.trim()) stmts.push({ texto: actual, inicio });
+  return stmts;
+}
+
+/**
+ * Quita del statement lo que se ejecuta **despues** del arranque: cuerpos de
+ * callbacks (`=> {...}`, `=> expr`, `function () {...}`) y literales de datos
+ * (`= [...]`, `= {...}`), que a lo sumo guardan referencias. Lo que queda es lo
+ * que se evalua al cargar el modulo.
+ *
+ * Recorre con estado de cadenas: un `=>` dentro de un template no es un arrow.
+ */
+function sinDiferidos(stmt) {
+  const s = stmt.replace(/\r?\n/g, ' ');
+  let out = '';
+  let i = 0;
+  let cadena = '';
+  const cortarBloque = (desde) => {
+    // Corta hasta el cierre balanceado de `{`/`[` abierto en `desde - 1`.
+    let prof = 1;
+    let j = desde;
+    let cad = '';
+    for (; j < s.length; j += 1) {
+      const c = s[j];
+      const previo = s[j - 1];
+      if (cad) {
+        if (c === cad && previo !== '\\') cad = '';
+        continue;
+      }
+      if (c === '"' || c === "'" || c === '`') {
+        cad = c;
+        continue;
+      }
+      if (c === '{' || c === '[') prof += 1;
+      else if (c === '}' || c === ']') {
+        prof -= 1;
+        if (prof === 0) return j + 1;
+      }
+    }
+    return j;
+  };
+
+  while (i < s.length) {
+    const c = s[i];
+    const previo = s[i - 1];
+    if (cadena) {
+      out += c;
+      if (c === cadena && previo !== '\\') cadena = '';
+      i += 1;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      cadena = c;
+      out += c;
+      i += 1;
+      continue;
+    }
+    const resto = s.slice(i);
+    if (c === '=' && s[i + 1] === '>') {
+      const despues = s.slice(i + 2).match(/^\s*([[{])/);
+      if (despues) {
+        const inicio = i + 2 + despues[0].length;
+        i = cortarBloque(inicio);
+      } else {
+        i = s.length; // arrow de expression: su cuerpo corre al invocarlo
+      }
+      continue;
+    }
+    const fn = /^\bfunction\b\s*[\w$]*\s*\([^)]*\)\s*\{/.exec(resto);
+    if (fn) {
+      out += fn[0].slice(0, -1);
+      i = cortarBloque(i + fn[0].length);
+      continue;
+    }
+    if (c === '=' && /^\s*[[{]/.test(s.slice(i + 1))) {
+      const inicio = i + 1 + s.slice(i + 1).match(/^\s*[[{]/)[0].length;
+      out += '=';
+      i = cortarBloque(inicio);
+      continue;
+    }
+    out += c;
+    i += 1;
+  }
+  return out;
+}
+
+/** Profundidad de llaves antes del caracter `hasta` (para saber si es nivel 0). */
+function profundidadEn(src, hasta) {
+  let prof = 0;
+  let cadena = '';
+  for (let i = 0; i < hasta; i += 1) {
+    const c = src[i];
+    const previo = src[i - 1];
+    if (cadena) {
+      if (c === cadena && previo !== '\\') cadena = '';
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      cadena = c;
+      continue;
+    }
+    if (c === '{') prof += 1;
+    else if (c === '}') prof -= 1;
+  }
+  return prof;
+}
+
+test('cada import de la consola resuelve a un export real', () => {
+  const rotos = [];
+  for (const [modulo, imports] of importsPorModulo) {
+    for (const { nombres, de } of imports) {
+      if (!exportsPorModulo.has(de)) {
+        rotos.push(`${modulo}: importa de "${de}", que no existe`);
+        continue;
+      }
+      const expuestos = exportsPorModulo.get(de);
+      for (const nombre of nombres) {
+        if (!expuestos.has(nombre)) rotos.push(`${modulo}: "${nombre}" no existe en ${de}`);
+      }
+    }
+  }
+  assert.deepEqual(rotos, [], `imports rotos:\n  ${rotos.join('\n  ')}`);
+});
+
+test('los ciclos de la consola son seguros (nada se usa en tiempo de evaluacion)', () => {
+  // Construye el grafo dirigido y busca ciclos.
+  const grafo = new Map(modulos.map((m) => [m, [...new Set(importsPorModulo.get(m).map((i) => i.de))].filter((d) => exportsPorModulo.has(d))]));
+  const ciclos = [];
+  const camino = [];
+  const enCamino = new Set();
+  const visitado = new Set();
+
+  const dfs = (nodo) => {
+    if (enCamino.has(nodo)) {
+      const desde = camino.indexOf(nodo);
+      ciclos.push([...camino.slice(desde), nodo].join(' -> '));
+      return;
+    }
+    if (visitado.has(nodo)) return;
+    visitado.add(nodo);
+    enCamino.add(nodo);
+    camino.push(nodo);
+    for (const vecino of grafo.get(nodo) ?? []) dfs(vecino);
+    camino.pop();
+    enCamino.delete(nodo);
+  };
+  for (const nodo of grafo.keys()) dfs(nodo);
+
+  // Un ciclo es seguro mientras nadie USE un importado durante la evaluacion del
+  // modulo. Las funciones y clases estan izadas, asi que referenciarlas en un
+  // callback (`addEventListener('click', cerrar)`) es legal: corre despues. Lo
+  // que rompe el ciclo es **invocarlas** en nivel superior.
+  const enCiclo = new Set(ciclos.flatMap((c) => c.split(' -> ')));
+  // `app.js` es el entry point: lo carga el HTML, asi que su codigo de nivel
+  // superior corre cuando todo el grafo ya esta evaluado y no hay nada en la
+  // zona muerta. Ciclo con el, pero inofensivo.
+  const peligrosos = [];
+  for (const miembro of enCiclo) {
+    if (!miembro.endsWith('.js') || miembro === 'app.js') continue;
+    const propios = new Set(importsPorModulo.get(miembro).filter((i) => enCiclo.has(i.de)).flatMap((i) => i.nombres));
+    if (!propios.size) continue;
+    const src = lee(miembro);
+    for (const { texto: stmt, inicio } of statementsTopLevel(src)) {
+      // Solo nivel superior: dentro de un `switch` (los `case` de un comando) o
+      // de una funcion el codigo corre despues, no al cargar.
+      if (profundidadEn(src, inicio) !== 0) continue;
+      // Fuera de callbacks y literales: lo que se ejecuta al cargar el modulo.
+      const fuera = sinDiferidos(stmt);
+      for (const nombre of propios) {
+        if (new RegExp(`(^|[^\\w$.])${nombre}\\s*\\(`).test(fuera)) {
+          peligrosos.push(`${miembro}: ${stmt.trim().replace(/\s+/g, ' ').slice(0, 70)}`);
+        }
+      }
+    }
+  }
+  assert.deepEqual(peligrosos, [], `un ciclo invoca un importado en tiempo de evaluacion:\n  ${peligrosos.join('\n  ')}`);
+  // Estos ciclos existen a proposito; si desaparecen, cambio el grafo y
+  // conviene revisarlo a mano.
+  assert.ok(ciclos.length > 0, 'no se encontraron ciclos: cambio el grafo, revisar a mano');
+});
+
+test('los modulos de la consola no exportan nombres repetidos entre si', () => {
+  // Un `export function x` duplicado en dos modulos suele ser codigo movido dos
+  // veces al partir un archivo grande.
+  const visto = new Map();
+  const duplicados = [];
+  for (const [modulo, nombres] of exportsPorModulo) {
+    for (const nombre of nombres) {
+      if (visto.has(nombre)) duplicados.push(`${nombre}: ${visto.get(nombre)} y ${modulo}`);
+      else visto.set(nombre, modulo);
+    }
+  }
+  // `index`-style re-exports (chat.js re-exporta chatFormat.js) son esperados.
+  const reexports = new Set();
+  for (const [modulo] of importsPorModulo) {
+    const src = lee(modulo);
+    for (const m of src.matchAll(/export\s*\{([^}]*)\}\s*from/g)) {
+      for (const bruto of m[1].split(',')) reexports.add(bruto.trim().split(/\s+as\s+/).pop().trim());
+    }
+  }
+  assert.deepEqual(duplicados.filter((d) => !reexports.has(d.split(':')[0])), []);
+});

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

@@ -0,0 +1,34 @@
+// Smoke test de la consola con un navegador de verdad.
+//
+// La consola es la parte del harness que ningun test cubria: si un cambio rompe
+// un import, deja un `undefined` al cargar o dispara un error en el arranque,
+// la pantalla queda en blanco y la suite seguia en verde. Esto la abre en el
+// Chrome/Edge del sistema (el mismo navegador headless de las tools `screenshot`
+// y `console_errors`) y exige que **no haya errores de consola**.
+//
+// Se saltea si no hay navegador: es una verificacion de UI, no del engine.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { findBrowserPath, readConsole } from '../../core/src/browser/index.js';
+import { startServer } from './helpers.js';
+
+const HAY_NAVEGADOR = Boolean(findBrowserPath());
+
+test('la consola carga sin errores de consola', { skip: HAY_NAVEGADOR ? false : 'sin navegador headless' }, async () => {
+  const { instance, base } = await startServer();
+  try {
+    const { errors } = await readConsole(base, { waitMs: 2500, timeoutMs: 30000, allowPrivate: true });
+    // Solo importan los errores de la consola. El favicon y el ruido de red (la
+    // consola pide fuentes a Google) no son fallos del codigo: sin conexion el
+    // test fallaria por algo que no controlamos.
+    const ruido = /favicon|ERR_NAME_NOT_RESOLVED|ERR_INTERNET_DISCONNECTED|ERR_CONNECTION|ERR_NETWORK|Failed to load resource/i;
+    const reales = errors.filter((e) => !ruido.test(String(e?.text ?? e?.message ?? e)));
+    assert.deepEqual(
+      reales.map((e) => e?.text ?? e?.message ?? String(e)),
+      [],
+      'la consola tiro errores al cargar',
+    );
+  } finally {
+    await instance.close();
+  }
+});

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

@@ -79,6 +79,20 @@ async function readSse(url, options, until, timeoutMs = 5000) {
   return frames;
 }
 
+/**
+ * Espera una condicion (no un tiempo fijo): los procesos y los servicios tardan
+ * lo que tardan, y una espera fija solo hace flaky al test cuando la maquina
+ * esta cargada.
+ */
+async function waitFor(cond, timeoutMs = 5000, stepMs = 50) {
+  const start = Date.now();
+  for (;;) {
+    if (await cond()) return true;
+    if (Date.now() - start >= timeoutMs) return false;
+    await new Promise((resolve) => setTimeout(resolve, stepMs));
+  }
+}
+
 async function waitIdle(base, id, attempts = 60) {
   for (let i = 0; i < attempts; i += 1) {
     const detail = await (await fetch(`${base}/api/sessions/${id}`)).json();
@@ -104,4 +118,4 @@ async function readEvents(res, onFrame) {
   return buffer;
 }
 
-export { fakeProvider, startServer, HAS_GIT, gitInit, readSse, waitIdle, readEvents };
+export { fakeProvider, startServer, HAS_GIT, gitInit, readSse, waitFor, waitIdle, readEvents };

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

@@ -7,7 +7,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { createTamnoraServer } from '../src/index.js';
 import { setHome, ensureApp, readApp, writeApp, makeUser, screenshotsDir } from '../../core/src/index.js';
-import { fakeProvider, startServer, HAS_GIT, gitInit } from './helpers.js';
+import { fakeProvider, startServer, HAS_GIT, gitInit, waitFor } from './helpers.js';
 
 test('serves health, providers and the console', async () => {
   const { instance, base } = await startServer();
@@ -147,10 +147,14 @@ test('detects, runs and stops dev processes', async () => {
       })
     ).json();
     assert.ok(started.proc.id);
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    const logs = await (await fetch(`${base}/api/procs/${started.proc.id}/logs`)).json();
-    assert.match(logs.logs.map((l) => l.text).join(''), /42/);
+    // El proceso es rapido, pero arrancarlo no lo es: se espera la condicion, no
+    // un tiempo fijo (con la maquina cargada el sleep se quedaba corto y el test
+    // fallaba a veces).
+    const logs = async () => {
+      const data = await (await fetch(`${base}/api/procs/${started.proc.id}/logs`)).json();
+      return data.logs.map((l) => l.text).join('');
+    };
+    assert.ok(await waitFor(async () => /42/.test(await logs()), 10000), `no llego la salida a los logs: "${await logs()}"`);
 
     const stopped = await fetch(`${base}/api/procs/${started.proc.id}/stop`, { method: 'POST' });
     assert.equal(stopped.status, 200);

package/harness/packages/server/test/procs-manager.test.js

@@ -29,6 +29,23 @@ test('en Windows los args no admiten metacaracteres del shell', { skip: process.
   }
 });
 
+test('un comando bare con args no dispara el warning DEP0190 de Node', { skip: process.platform !== 'win32' }, async () => {
+  const cwd = await workspace();
+  const procs = createProcManager({ allow: ['node'] });
+  const warnings = [];
+  const onWarn = (warning) => warnings.push(warning);
+  process.on('warning', onWarn);
+  let proc;
+  try {
+    proc = procs.start({ cwd, command: 'node', args: ['-e', 'process.exit(0)'] });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  } finally {
+    process.removeListener('warning', onWarn);
+    if (proc) procs.stop(proc.id);
+  }
+  assert.deepEqual(warnings.filter((w) => w.code === 'DEP0190'), []);
+});
+
 test('procs arranca y detiene un proceso permitido', async () => {
   const cwd = await workspace();
   const procs = createProcManager({ allow: ['node'] });

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

@@ -199,15 +199,32 @@ test('guarda los límites del agente desde Ajustes', async () => {
     const res = await fetch(`${base}/api/settings`, {
       method: 'PUT',
       headers: json,
-      body: JSON.stringify({ maxRounds: 20, maxTokens: 50000, maxDurationMs: 600000 }),
+      body: JSON.stringify({
+        maxRounds: 20,
+        maxTokens: 50000,
+        maxDurationMs: 600000,
+        maxOutputTokens: 2048,
+        promptCaching: true,
+      }),
     });
     const data = await res.json();
     assert.equal(data.settings.maxRounds, 20);
     assert.equal(data.settings.maxTokens, 50000);
     assert.equal(data.settings.maxDurationMs, 600000);
+    assert.equal(data.settings.maxOutputTokens, 2048);
+    assert.equal(data.settings.promptCaching, true);
 
     const again = await (await fetch(`${base}/api/settings`)).json();
     assert.equal(again.settings.maxRounds, 20);
+    assert.equal(again.settings.maxOutputTokens, 2048);
+    assert.equal(again.settings.promptCaching, true);
+
+    const off = await fetch(`${base}/api/settings`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ promptCaching: false }),
+    });
+    assert.equal((await off.json()).settings.promptCaching, false);
   } finally {
     await instance.close();
   }

package/harness/scripts/canary.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// Canary de los servicios no oficiales (TTS de Edge, STT de Google): los prueba
+// contra la red real, que es lo que la suite normal no hace. Corre con
+// `pnpm canary` y lo agenda el workflow de GitHub (canary.yml).
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const test = path.join(root, 'harness', 'packages', 'core', 'test', 'servicios-vivos.test.js');
+
+console.log('Canary de servicios vivos (red real): TTS de Edge + STT de Google\n');
+const hijo = spawn(
+  process.execPath,
+  ['--disable-warning=ExperimentalWarning', '--test', test],
+  { stdio: 'inherit', env: { ...process.env, TAMNORA_LIVE: '1' } },
+);
+hijo.on('exit', (code, signal) => {
+  process.exitCode = signal ? 1 : (code ?? 1);
+  if (process.exitCode) {
+    console.error('\nEl canary fallo: un servicio externo cambio o esta caido.');
+    console.error('Si es el TTS, revisa EDGE_VERSION/TRUSTED_CLIENT_TOKEN en core/src/tts/edge.js.');
+  }
+});